diff --git a/BitKeeper/etc/logging_ok b/BitKeeper/etc/logging_ok index b3533f2a834..9210c176e6e 100644 --- a/BitKeeper/etc/logging_ok +++ b/BitKeeper/etc/logging_ok @@ -76,6 +76,7 @@ konstantin@mysql.com kostja@oak.local lenz@kallisto.mysql.com lenz@mysql.com +magnus@neptunus.(none) marko@hundin.mysql.fi miguel@hegel.(none) miguel@hegel.br diff --git a/ndb/BinDist.sh b/ndb/BinDist.sh new file mode 100644 index 00000000000..ed0b294c912 --- /dev/null +++ b/ndb/BinDist.sh @@ -0,0 +1,121 @@ +# +# Invoked from scripts/make_binary_distribution as "sh BinDist.sh". +# Prints list of dirs and files to include under mysql/ndb. +# + +# release notes + +grep -v '^#' <<__END__ +#ReleaseNotes.html +mysqlclusterenv.sh +__END__ + +# subset of bins, libs, includes + +grep -v '^#' <<__END__ +bin/ +bin/ndb +bin/mgmtsrvr +bin/mgmtclient +bin/mysqlcluster +bin/mysqlcluster_install_db +bin/mysqlclusterd +bin/restore +bin/ndb_rep +bin/desc +bin/flexBench +bin/select_all +bin/select_count +bin/delete_all +bin/ndbsql +bin/drop_tab +bin/drop_index +bin/list_tables +bin/waiter +lib/ +lib/libNEWTON_API.a +lib/libNEWTON_API.so +lib/libNDB_API.a +lib/libNDB_API.so +lib/libMGM_API.a +lib/libMGM_API.so +lib/libNDB_ODBC.so +lib/libMGM_API_pic.a +lib/libNDB_API_pic.a +include/ +include/ndb_types.h +include/ndb_version.h +include/mgmapi/ +include/mgmapi/mgmapi.h +include/mgmapi/mgmapi_debug.h +include/ndbapi/ +include/ndbapi/ndbapi_limits.h +include/ndbapi/AttrType.hpp +include/ndbapi/Ndb.hpp +include/ndbapi/NdbApi.hpp +include/ndbapi/NdbConnection.hpp +include/ndbapi/NdbCursorOperation.hpp +include/ndbapi/NdbDictionary.hpp +include/ndbapi/NdbError.hpp +include/ndbapi/NdbEventOperation.hpp +include/ndbapi/NdbIndexOperation.hpp +include/ndbapi/NdbOperation.hpp +include/ndbapi/NdbPool.hpp +include/ndbapi/NdbRecAttr.hpp +include/ndbapi/NdbReceiver.hpp +include/ndbapi/NdbResultSet.hpp +include/ndbapi/NdbScanFilter.hpp +include/ndbapi/NdbScanOperation.hpp +include/ndbapi/NdbSchemaCon.hpp +include/ndbapi/NdbSchemaOp.hpp +include/newtonapi/dba.h +include/newtonapi/defs/pcn_types.h +__END__ + +#if [ -f /usr/local/lib/libstdc++.a ]; then +# cp /usr/local/lib/libstdc++.a lib/. +# echo lib/libstdc++.a +#fi +#if [ -f /usr/local/lib/libstdc++.so.5 ]; then +# cp /usr/local/lib/libstdc++.so.5 lib/. +# echo lib/libstdc++.so.5 +#fi +#if [ -f /usr/local/lib/libgcc_s.so.1 ]; then +# cp /usr/local/lib/libgcc_s.so.1 lib/. +# echo lib/libgcc_s.so.1 +#fi + +# docs + +#find docs/*.html docs/*.pdf -print | sort -t/ + +# demos + +find demos -print | grep -v /SCCS | sort -t/ + +# examples + +grep -v '^#' <<__END__ +examples/ +examples/Makefile +examples/ndbapi_example1/ +examples/ndbapi_example1/Makefile +examples/ndbapi_example1/ndbapi_example1.cpp +examples/ndbapi_example2/ +examples/ndbapi_example2/Makefile +examples/ndbapi_example2/ndbapi_example2.cpp +examples/ndbapi_example3/ +examples/ndbapi_example3/Makefile +examples/ndbapi_example3/ndbapi_example3.cpp +examples/ndbapi_example4/ +examples/ndbapi_example4/Makefile +examples/ndbapi_example4/ndbapi_example4.cpp +examples/ndbapi_example5/ +examples/ndbapi_example5/Makefile +examples/ndbapi_example5/ndbapi_example5.cpp +examples/select_all/ +examples/select_all/Makefile +examples/select_all/select_all.cpp +__END__ + +exit 0 diff --git a/ndb/Defs.mk b/ndb/Defs.mk new file mode 100644 index 00000000000..d5a21c64ca9 --- /dev/null +++ b/ndb/Defs.mk @@ -0,0 +1,84 @@ +include $(NDB_TOP)/config/config.mk +include $(NDB_TOP)/config/Defs.$(NDB_VERSION).mk +include $(NDB_TOP)/config/Defs.$(NDB_OS).$(NDB_ARCH).$(NDB_COMPILER).mk + +ifeq ($(NDB_OS), WIN32) +# Windows specific definitions +OBJEXT := obj +LIBEXT := lib +LIBPREFIX := +fixpath = `cygpath -w $1` +ar_rcs = lib -out:`cygpath -w $1` $2 +link_so = link -DLL -OUT:`cygpath -w $1` $(WIN_LIBS) $2 +#check-odbc = Y +USE_EDITLINE := N +#STRCASECMP is defined in include/portlib/PortDefs.h to _strcmpi +else +#Common definitions for almost all non-Windows environments +OBJEXT := o +LIBEXT := a +LIBPREFIX := lib +fixpath = $1 +ar_rcs = $(AR_RCS) $1 $2 +#check-odbc = $(findstring sqlext.h, $(wildcard /usr/include/sqlext.h) $(wildcard /usr/local/include/sqlext.h)) +CCFLAGS_TOP += -DHAVE_STRCASECMP + +endif + +ifeq ($(NDB_OS), WIN32) +CCFLAGS_TOP += -DHAVE_STRDUP +NDB_STRLCPY := Y +NDB_STRLCAT := Y +SHLIBEXT := dll +endif + +ifeq ($(NDB_OS), LINUX) +CCFLAGS_TOP += -DHAVE_STRDUP +NDB_STRLCAT := Y +NDB_STRLCPY := Y +SHLIBEXT := so +endif + +ifeq ($(NDB_OS), SOLARIS) +CCFLAGS_TOP += -DHAVE_STRDUP +NDB_STRLCAT := Y +NDB_STRLCPY := Y +SHLIBEXT := so +endif + +ifeq ($(NDB_OS), HPUX) +CCFLAGS_TOP += -DHAVE_STRDUP +NDB_STRLCAT := Y +NDB_STRLCPY := Y +SHLIBEXT := sl +endif + +ifeq ($(NDB_OS), MACOSX) +CCFLAGS_TOP += -DHAVE_STRLCAT +CCFLAGS_TOP += -DHAVE_STRLCAT +CCFLAGS_TOP += -DHAVE_STRLCPY +CCFLAGS_TOP += -DNDBOUT_UINTPTR +SHLIBEXT := dylib +endif + +ifeq ($(NDB_OS), OSE) +NDB_STRDUP := Y +NDB_STRLCAT := Y +NDB_STRLCPY := Y +SHLIBEXT := so +endif + +ifeq ($(NDB_OS), SOFTOSE) +NDB_STRDUP := Y +NDB_STRLCAT := Y +NDB_STRLCPY := Y +SHLIBEXT := so +endif + +ifeq ($(NDB_SCI), Y) +CCFLAGS_TOP += -DHAVE_SCI +endif + +ifneq ($(findstring OSE, $(NDB_OS)),) +USE_EDITLINE := N +endif diff --git a/ndb/Epilogue.mk b/ndb/Epilogue.mk new file mode 100644 index 00000000000..89cd4034208 --- /dev/null +++ b/ndb/Epilogue.mk @@ -0,0 +1,853 @@ +# .KEEP_STATE: +# bk test !!! + +### +# For building some intermediary targets in /tmp (only useful on solaris) +ifneq ($(NDB_BUILDROOT),) +NDB_TOPABS := $(shell cd $(NDB_TOP) && /bin/pwd) +NDB_BUILDDIR := $(subst $(NDB_TOPABS),$(NDB_BUILDROOT),$(CURDIR))/ +ifeq ($(wildcard $(NDB_BUILDDIR)),) +dummy := $(shell mkdir -p $(NDB_BUILDDIR)) +endif +endif + +### +CCFLAGS_TOP += -DNDB_$(NDB_OS) -DNDB_$(NDB_ARCH) -DNDB_$(NDB_COMPILER) + +ifdef BIN_TARGET +BIN_EXE = Y +endif + +### +# +# OS specifics +# + +# Disable shared libraries on HP-UX for the time being. +ifeq ($(NDB_OS), HPUX) + SO_LIB := N + PIC_LIB := N + PIC_ARCHIVE := N + NONPIC_ARCHIVE := Y +endif + +ifeq ($(NDB_OS), OSE) + SO_LIB := N + PIC_LIB := N + PIC_ARCHIVE := N + NONPIC_ARCHIVE := Y + +ifdef BIN_TARGET + BIN_LIB_TARGET := lib$(BIN_TARGET).a + BIN_TARGET := lib$(BIN_TARGET).a +endif +endif + +ifeq ($(NDB_OS), SOFTOSE) + SO_LIB := N + PIC_LIB := N + PIC_ARCHIVE := N + +ifdef BIN_TARGET + BIN_EXE_TARGET := $(BIN_TARGET) + BIN_LIB_TARGET := lib$(BIN_TARGET).a + EXTRA_MAIN := osemain.o +endif +endif + +ifeq ($(filter OSE, $(NDB_OS)),) + BIN_EXE_TARGET := $(BIN_TARGET) +endif + + +ifeq ($(NDB_OS), MACOSX) +.LIBPATTERNS= lib%.dylib lib%.a +endif + +### +# +# + +### +# External dependencies definition : the place we store libraries +# we get from outside the NDB development group. +EXTERNAL_DEPENDS_TOP=$(NDB_TOP)/src/external/$(NDB_OS).$(NDB_ARCH) + + +### +# +# TYPE Handling + +# +# TYPE := kernel +# +ifneq ($(filter kernel, $(TYPE)),) +CCFLAGS_LOC += \ + -I$(call fixpath,$(NDB_TOP)/src/kernel/vm) \ + -I$(call fixpath,$(NDB_TOP)/src/kernel/error) \ + -I$(call fixpath,$(NDB_TOP)/src/kernel) \ + -I$(call fixpath,$(NDB_TOP)/include/kernel) \ + -I$(call fixpath,$(NDB_TOP)/include/transporter) \ + -I$(call fixpath,$(NDB_TOP)/include/debugger) \ + -I$(call fixpath,$(NDB_TOP)/include/mgmcommon) \ + -I$(call fixpath,$(NDB_TOP)/include/ndbapi) \ + -I$(call fixpath,$(NDB_TOP)/include/util) \ + -I$(call fixpath,$(NDB_TOP)/include/portlib) \ + -I$(call fixpath,$(NDB_TOP)/include/logger) +endif + +# +# TYPE := ndbapi +# +ifneq ($(filter ndbapi, $(TYPE)),) +CCFLAGS_LOC += \ + -I$(call fixpath,$(NDB_TOP)/include/kernel) \ + -I$(call fixpath,$(NDB_TOP)/include/transporter) \ + -I$(call fixpath,$(NDB_TOP)/include/debugger) \ + -I$(call fixpath,$(NDB_TOP)/include/mgmcommon) \ + -I$(call fixpath,$(NDB_TOP)/include/ndbapi) \ + -I$(call fixpath,$(NDB_TOP)/include/util) \ + -I$(call fixpath,$(NDB_TOP)/include/portlib) \ + -I$(call fixpath,$(NDB_TOP)/include/logger) +endif + +# +# TYPE := ndbapiclient +# +ifneq ($(filter ndbapiclient, $(TYPE)),) +CCFLAGS_LOC += \ + -I$(call fixpath,$(NDB_TOP)/include/ndbapi) + +BIN_TARGET_LIBS += NDB_API +endif + +# +# TYPE := mgmapiclient +# +ifneq ($(filter mgmapiclient, $(TYPE)),) +CCFLAGS_LOC += \ + -I$(call fixpath,$(NDB_TOP)/include/mgmapi) + +BIN_TARGET_LIBS += MGM_API +endif + +# +# TYPE := ndbapitest +# +ifneq ($(filter ndbapitest, $(TYPE)),) +CCFLAGS_LOC += \ + -I$(call fixpath,$(NDB_TOP)/include/ndbapi) \ + -I$(call fixpath,$(NDB_TOP)/include/util) \ + -I$(call fixpath,$(NDB_TOP)/include/portlib) \ + -I$(call fixpath,$(NDB_TOP)/test/include) \ + -I$(call fixpath,$(NDB_TOP)/include/mgmapi) + +BIN_TARGET_LIBS += NDBT +LDFLAGS_LOC += -lNDB_API -lMGM_API -lm + +endif + +# +# TYPE := signalsender +# +ifneq ($(filter signalsender, $(TYPE)),) +CCFLAGS_LOC += \ + -I$(call fixpath,$(NDB_TOP)/include/ndbapi) \ + -I$(call fixpath,$(NDB_TOP)/src/ndbapi) \ + -I$(call fixpath,$(NDB_TOP)/src/ndbapi/signal-sender) \ + -I$(call fixpath,$(NDB_TOP)/include/util) \ + -I$(call fixpath,$(NDB_TOP)/include/portlib) \ + -I$(call fixpath,$(NDB_TOP)/include/transporter) \ + -I$(call fixpath,$(NDB_TOP)/include/mgmcommon) \ + -I$(call fixpath,$(NDB_TOP)/include/kernel) + +BIN_TARGET_LIBS += NDB_API +BIN_TARGET_ARCHIVES += editline signal-sender + +endif + + +# +# TYPE := repserver +# +ifneq ($(filter repserver, $(TYPE)),) +CCFLAGS_LOC += \ + -I$(call fixpath,$(NDB_TOP)/include/ndbapi) \ + -I$(call fixpath,$(NDB_TOP)/src) \ + -I$(call fixpath,$(NDB_TOP)/src/ndbapi) \ + -I$(call fixpath,$(NDB_TOP)/src/ndbapi/signal-sender) \ + -I$(call fixpath,$(NDB_TOP)/include/util) \ + -I$(call fixpath,$(NDB_TOP)/include/portlib) \ + -I$(call fixpath,$(NDB_TOP)/include/transporter) \ + -I$(call fixpath,$(NDB_TOP)/include/mgmcommon) \ + -I$(call fixpath,$(NDB_TOP)/include/kernel) +endif + +# +# TYPE := odbcclient +# + +ifneq ($(filter odbcclient, $(TYPE)),) +TYPE += util +LDFLAGS_LOC += -lm +#ifneq ($(call check-odbc),) +ifneq ($(NDB_ODBC),N) +ifeq ($(NDB_OS), SOLARIS) +CCFLAGS_LOC += -I/usr/local/include +BIN_TARGET_LIBS_DIRS += /usr/local/lib +BIN_TARGET_LIBS += odbc odbcinst NDBT +endif +ifeq ($(NDB_OS), LINUX) +BIN_TARGET_LIBS += odbc odbcinst NDBT +endif +ifeq ($(NDB_OS), MACOSX) +BIN_TARGET_LIBS += odbc odbcinst NDBT +endif +ifeq ($(NDB_OS), IBMAIX) +BIN_TARGET_LIBS += odbc odbcinst NDBT +endif +ifeq ($(NDB_OS), TRU64X) +BIN_TARGET_LIBS += odbc odbcinst NDBT +endif +else +BIN_EXE = N +endif +endif + +# +# TYPE := * +# +# +# TYPE := util +# +ifneq ($(filter util, $(TYPE)),) +CCFLAGS_LOC += -I$(call fixpath,$(NDB_TOP)/include/util) \ + -I$(call fixpath,$(NDB_TOP)/include/portlib) \ + -I$(call fixpath,$(NDB_TOP)/include/logger) +BIN_TARGET_LIBS += logger general portlib +endif + +CCFLAGS_LOC += -I$(call fixpath,$(NDB_TOP)/include) + +ifeq ($(NDB_SCI), Y) +BIN_TARGET_LIBS += sisci +BIN_TARGET_LIBS_DIRS += $(EXTERNAL_DEPENDS_TOP)/sci/lib + +CCFLAGS_LOC += -I$(call fixpath,$(EXTERNAL_DEPENDS_TOP)/sci/include) +endif + +# +# TYPE Handling +### + +### +# +# First rule +# +first: + $(MAKE) libs + $(MAKE) bins + +ifeq ($(findstring all,$(replace-targets)),) +all: first +endif + +### +# +# Nice to have rules +api: libs + $(MAKE) -C $(NDB_TOP)/src/ndbapi bins + +mgm: libs + $(MAKE) -C $(NDB_TOP)/src/mgmsrv bins + +ndb: libs + $(MAKE) -C $(NDB_TOP)/src/kernel/ndb-main bins + +apitest: first + $(MAKE) -C $(NDB_TOP)/test/ndbapi all + +#-lNDBT: +# $(MAKE) -C $(NDB_TOP)/test/src all +# +#-lNDB_API: libs +# $(MAKE) -C $(NDB_TOP)/src/ndbapi bins + +# +# Libs/Bins +# +ifdef PREREQ_LOC +_libs:: $(PREREQ_LOC) +_bins:: $(PREREQ_LOC) +endif + +L_DIRS := $(LIB_DIRS) $(DIRS) +B_DIRS := $(BIN_DIRS) $(DIRS) +A_DIRS := $(LIB_DIRS) $(BIN_DIRS) $(DIRS) + +_libs:: + +_bins:: + +libs: _libs $(patsubst %, _libs_%, $(L_DIRS)) +$(patsubst %, _libs_%, $(L_DIRS)) : DUMMY + $(MAKE) -C $(patsubst _libs_%,%,$@) libs + +bins: _bins $(patsubst %, _bins_%, $(B_DIRS)) +$(patsubst %, _bins_%, $(B_DIRS)) : DUMMY + $(MAKE) -C $(patsubst _bins_%,%,$@) bins + +### +# +# Links +_links: + -$(NDB_TOP)/tools/make-links.sh $(NDB_TOP)/include `pwd` + +links: _links $(patsubst %, _links_%, $(A_DIRS)) +$(patsubst %, _links_%, $(A_DIRS)) : DUMMY + $(MAKE) -C $(patsubst _links_%,%,$@) links + + +#### +# +# OSE build_spec ( +ifdef SOURCES +BS := Y +endif + +ifdef SOURCES_c +BS := Y +endif + +_build_spec: Makefile +ifdef BS + @echo "TYPE = SWU" > build.spec + @echo "include $(NDB_TOP)/Ndb.mk" >> build.spec +# @for i in $(CCFLAGS_LOC); do echo "INC += $$i" >> build.spec ; done + @for i in $(patsubst -I%, %, $(CCFLAGS_LOC)); do echo "INC += $$i" >> build.spec ; done + @echo "INC += /vobs/cello/cls/rtosi_if/include" >> build.spec + @echo "INC += /vobs/cello/cls/rtosi_if/include.@@@" >> build.spec + @echo "INC += /vobs/cello/cls/rtosi_if/include.<<<" >> build.spec +endif + +build_spec: _build_spec $(patsubst %, _build_spec_%, $(A_DIRS)) +$(patsubst %, _build_spec_%, $(A_DIRS)) : DUMMY + $(MAKE) -C $(patsubst _build_spec_%,%,$@) build_spec + +### +# +# Phony targets + +.PHONY: $(A_DIRS) + +### +# +# Dummy rule + +DUMMY: + +### +# +# Definitions of... + +PIC_DIR := $(NDB_BUILDDIR).pic +A_TMP_DIR := $(NDB_BUILDDIR).a_tmp +SO_TMP_DIR := $(NDB_BUILDDIR).so_tmp +PIC_TMP_DIR := $(NDB_BUILDDIR).pic_tmp + +$(PIC_DIR): + mkdir -p $(PIC_DIR) + +SRC_C := $(filter %.C, $(SOURCES)) +SRC_CPP := $(filter %.cpp, $(SOURCES)) +SRC_CC := $(filter %.cc, $(SOURCES)) +SRC_c := $(filter %.c, $(SOURCES)) $(filter %.c, $(SOURCES.c)) +SRC_YPP := $(filter %.ypp, $(SOURCES)) +SRC_LPP := $(filter %.lpp, $(SOURCES)) + +OBJECTS := $(SRC_C:%.C=%.$(OBJEXT)) \ + $(SRC_CPP:%.cpp=%.$(OBJEXT)) \ + $(SRC_CC:%.cc=%.$(OBJEXT)) \ + $(SRC_c:%.c=%.$(OBJEXT)) \ + $(SRC_YPP:%.ypp=%.tab.$(OBJEXT)) \ + $(SRC_LPP:%.lpp=%.yy.$(OBJEXT)) \ + $(OBJECTS_LOC) + +PIC_OBJS := $(OBJECTS:%=$(PIC_DIR)/%) + +LIB_DIR := $(NDB_TOP)/lib +BIN_DIR := $(NDB_TOP)/bin + +### +# +# ARCHIVE_TARGET +# +ifdef ARCHIVE_TARGET + +ifndef NONPIC_ARCHIVE +NONPIC_ARCHIVE := Y +endif + +ifeq ($(NONPIC_ARCHIVE), Y) +_libs:: $(LIB_DIR)/$(LIBPREFIX)$(ARCHIVE_TARGET).$(LIBEXT) +$(LIB_DIR)/$(LIBPREFIX)$(ARCHIVE_TARGET).$(LIBEXT) : $(OBJECTS) + $(call ar_rcs,$@,$(OBJECTS)) + +endif # NONPIC_ARCHIVE := Y + +ifeq ($(PIC_ARCHIVE), Y) +_libs:: $(PIC_DIR) $(LIB_DIR)/$(LIBPREFIX)$(ARCHIVE_TARGET)_pic.$(LIBEXT) +$(LIB_DIR)/$(LIBPREFIX)$(ARCHIVE_TARGET)_pic.$(LIBEXT) : $(PIC_OBJS) + cd $(PIC_DIR) && $(call ar_rcs,../$@,$(OBJECTS)) + +PIC_DEP := Y + +endif # PIC_ARCHIVE := Y + +endif # ARCHIVE_TARGET + +### +# +# LIB_TARGET +# +ifdef LIB_TARGET + +ifeq ($(A_LIB), Y) + +A_LIB_ARCHIVES := $(LIB_TARGET_ARCHIVES:%=$(LIB_DIR)/$(LIBPREFIX)%.$(LIBEXT)) + +_bins:: $(LIB_DIR)/$(LIBPREFIX)$(LIB_TARGET).$(LIBEXT) +$(LIB_DIR)/$(LIBPREFIX)$(LIB_TARGET).$(LIBEXT) : $(A_LIB_ARCHIVES) + @rm -rf $(A_TMP_DIR) && mkdir $(A_TMP_DIR) + cd $(A_TMP_DIR) && for i in $^; do ar -x ../$$i; done && $(call ar_rcs,../$@,*.$(OBJEXT)) + $(NDB_TOP)/home/bin/ndb_deploy $@ +endif # A_LIB := Y + +ifeq ($(SO_LIB), Y) +ifneq ($(NDB_OS), WIN32) +SO_LIB_ARCHIVES := $(LIB_TARGET_ARCHIVES:%=$(LIB_DIR)/$(LIBPREFIX)%_pic.$(LIBEXT)) + +_bins:: $(LIB_DIR)/$(LIBPREFIX)$(LIB_TARGET).$(SHLIBEXT) +$(LIB_DIR)/$(LIBPREFIX)$(LIB_TARGET).$(SHLIBEXT) : $(SO_LIB_ARCHIVES) + @rm -rf $(SO_TMP_DIR) && mkdir $(SO_TMP_DIR) + cd $(SO_TMP_DIR) && for i in $^; do ar -x ../$$i; done +ifneq ($(NDB_OS), MACOSX) + $(SO) $@.new $(SO_TMP_DIR)/*.$(OBJEXT) -L$(LIB_DIR) $(LIB_TARGET_LIBS) $(LDFLAGS_LAST) + rm -f $@; mv $@.new $@ +else + $(SO) $@ $(SO_TMP_DIR)/*.$(OBJEXT) -L$(LIB_DIR) $(LIB_TARGET_LIBS) $(LDFLAGS_LAST) +endif +ifeq ($(NDB_VERSION), RELEASE) +ifneq ($(NDB_OS), MACOSX) + strip $@ +endif +endif + $(NDB_TOP)/home/bin/ndb_deploy $@ +else # WIN32 +SO_LIB_ARCHIVES := $(LIB_TARGET_ARCHIVES:%=$(LIB_DIR)/$(LIBPREFIX)%_pic.$(LIBEXT)) + +_bins:: $(LIB_DIR)/$(LIBPREFIX)$(LIB_TARGET).$(SHLIBEXT) +$(LIB_DIR)/$(LIBPREFIX)$(LIB_TARGET).$(SHLIBEXT) : $(SO_LIB_ARCHIVES) + @rm -rf $(SO_TMP_DIR) && mkdir $(SO_TMP_DIR) + cd $(SO_TMP_DIR) && for i in $^; do ar -x ../$$i; done + $(call link_so,$@.new,$(SO_TMP_DIR)/*.$(OBJEXT)) + rm -f $@; mv $@.new $@ +#ifeq ($(NDB_VERSION), RELEASE) +# strip $@ +#endif + +endif +endif # SO_LIB := Y + +ifeq ($(PIC_LIB), Y) + +PIC_LIB_ARCHIVES := $(LIB_TARGET_ARCHIVES:%=$(LIB_DIR)/$(LIBPREFIX)%_pic.$(LIBEXT)) + +_bins:: $(LIB_DIR)/$(LIBPREFIX)$(LIB_TARGET)_pic.$(LIBEXT) +$(LIB_DIR)/$(LIBPREFIX)$(LIB_TARGET)_pic.$(LIBEXT) : $(PIC_LIB_ARCHIVES) + @rm -rf $(PIC_TMP_DIR) && mkdir $(PIC_TMP_DIR) + cd $(PIC_TMP_DIR) && for i in $^; do ar -x ../$$i; done && $(call ar_rcs,../$@,*.$(OBJEXT)) + +endif # PIC_LIB := Y + +endif # LIB_TARGET + +### +# +# BIN_TARGET +# +ifeq ($(BIN_EXE), Y) +ifneq ($(NDB_OS), WIN32) +BIN_LIBS := $(BIN_TARGET_ARCHIVES:%=$(LIB_DIR)/$(LIBPREFIX)%.$(LIBEXT)) +BIN_LIBS += $(BIN_TARGET_LIBS:%=-l%) + +BIN_DEPS := $(OBJECTS) $(EXTRA_MAIN) $(BIN_LIBS) +BIN_LIB_DIRS := $(BIN_TARGET_LIBS_DIRS:%=-L%) + +BIN_FLAGS := $(BIN_LIB_DIRS) $(BIN_DEPS) + +VPATH := $(LIB_DIR) $(BIN_TARGET_LIBS_DIRS) +_bins:: $(BIN_DIR)/$(BIN_TARGET) +$(BIN_DIR)/$(BIN_TARGET) : $(BIN_DEPS) + $(LINK.cc) $(LDFLAGS) $(LDLIBS) -L$(LIB_DIR) $(BIN_FLAGS) -o $@.new $(LDFLAGS_LAST) + rm -f $@; mv $@.new $@ +ifeq ($(NDB_VERSION), RELEASE) +ifneq ($(NDB_OS), MACOSX) + strip $@ +endif +endif + $(NDB_TOP)/home/bin/ndb_deploy $@ +else # WIN32 +BIN_LIBS := $(foreach lib,$(BIN_TARGET_ARCHIVES),$(call fixpath,$(LIB_DIR)/$(LIBPREFIX)$(lib).$(LIBEXT))) +BIN_LIBS += $(BIN_TARGET_LIBS:%=$(LIBPREFIX)%.$(LIBEXT)) + +BIN_DEPS := $(OBJECTS) $(BIN_TARGET_ARCHIVES:%=$(LIB_DIR)/$(LIBPREFIX)%.$(LIBEXT)) +BIN_LIB_DIRS := -libpath:$(call fixpath,$(LIB_DIR)) $(BIN_TARGET_LIBS_DIRS:%=-libpath:%) + +BIN_FLAGS := $(BIN_LIB_DIRS) + +VPATH := $(LIB_DIR) $(BIN_TARGET_LIBS_DIRS) +_bins:: $(BIN_DIR)/$(BIN_TARGET).exe +$(BIN_DIR)/$(BIN_TARGET).exe : $(BIN_DEPS) + $(LINK.cc) -out:$(call fixpath,$@.new) $(OBJECTS) $(BIN_FLAGS) $(BIN_LIBS) + rm -f $@; mv $@.new $@ +ifeq ($(NDB_VERSION), RELEASE) + strip $@ +endif + +endif +endif + +### +# +# SOURCES.sh +# +ifdef SOURCES.sh + +BIN_SRC := $(SOURCES.sh:%=$(BIN_DIR)/%) + +_bins:: $(BIN_SRC) + +$(BIN_SRC) : $(SOURCES.sh) + rm -f $(^:%=$(BIN_DIR)/%) + cp $^ $(BIN_DIR) +endif + +# +# Compile rules PIC objects +# +ifeq ($(NDB_OS), WIN32) +OUT := -Fo +else +OUT := -o +endif + +$(PIC_DIR)/%.$(OBJEXT): %.C + $(C++) $(OUT)$@ -c $(CCFLAGS) $(CFLAGS_$<) $(PIC) $< + +$(PIC_DIR)/%.$(OBJEXT): %.cpp + $(C++) $(OUT)$@ -c $(CCFLAGS) $(CFLAGS_$<) $(PIC) $< + +$(PIC_DIR)/%.$(OBJEXT): %.cc + $(C++) $(OUT)$@ -c $(CCFLAGS) $(CFLAGS_$<) $(PIC) $< + +$(PIC_DIR)/%.$(OBJEXT): %.c + $(CC) $(OUT)$@ -c $(CFLAGS) $(CFLAGS_$<) $(PIC) $< + +# +# Compile rules +# +%.$(OBJEXT) : %.cpp + $(C++) $(OUT)$@ -c $(CCFLAGS) $(CFLAGS_$<) $(NON_PIC) $< + +%.$(OBJEXT) : %.C + $(C++) $(OUT)$@ -c $(CCFLAGS) $(CFLAGS_$<) $(NON_PIC) $< + +%.$(OBJEXT) : %.cc + $(C++) $(OUT)$@ -c $(CCFLAGS) $(CFLAGS_$<) $(NON_PIC) $< + +%.$(OBJEXT) : %.c + $(CC) $(OUT)$@ -c $(CFLAGS) $(CFLAGS_$<) $(NON_PIC) $< + +%.s : %.C + $(C++) -S $(CCFLAGS) $(CFLAGS_$<) $(NON_PIC) $< + +%.s : %.cpp + $(C++) -S $(CCFLAGS) $(CFLAGS_$<) $(NON_PIC) $< + +%.s : %.cc + $(C++) -S $(CCFLAGS) $(CFLAGS_$<) $(NON_PIC) $< + +%.s : %.c + $(CC) -S $(CCFLAGS) $(CFLAGS_$<) $(NON_PIC) $< + +BISON = bison +BISONHACK = : +%.tab.cpp %.tab.hpp : %.ypp + $(BISON) $< + $(BISONHACK) $*.tab.cpp $*.tab.hpp + +FLEX = flex +FLEXHACK = : +%.yy.cpp : %.lpp + $(FLEX) -o$@ $< + $(FLEXHACK) $@ + +### +# +# Defines regarding dependencies + +DEPMK := $(NDB_BUILDDIR).depend.mk + +DEPDIR := $(NDB_BUILDDIR).depend + +DEPENDENCIES := $(SRC_C:%.C=$(DEPDIR)/%.d) \ + $(SRC_CC:%.cc=$(DEPDIR)/%.d) \ + $(SRC_CPP:%.cpp=$(DEPDIR)/%.d) \ + $(SRC_c:%.c=$(DEPDIR)/%.d) \ + $(SRC_YPP:%.ypp=$(DEPDIR)/%.tab.d) \ + $(SRC_LPP:%.lpp=$(DEPDIR)/%.yy.d) + +### +# +# Dependency rule + +_depend: $(DEPMK) + +depend: _depend $(patsubst %, _depend_%, $(A_DIRS)) + +$(patsubst %, _depend_%, $(A_DIRS)) : DUMMY + $(MAKE) -C $(patsubst _depend_%,%,$@) depend + +### +# +# Clean dependencies + +_clean_dep: + -rm -rf $(DEPMK) $(DEPDIR)/* + +clean_dep: _clean_dep $(patsubst %, _clean_dep_%, $(A_DIRS)) + +$(patsubst %, _clean_dep_%, $(A_DIRS)) : DUMMY + $(MAKE) -C $(patsubst _clean_dep_%,%,$@) clean_dep + +### +# +# Generate dependencies + +$(DEPDIR): + -@mkdir -p $(DEPDIR) + +$(DEPDIR)/%.d: %.C + @echo Generating depend for $< + @$(MAKEDEPEND) $(CCFLAGS) $(CFLAGS_$<) $< >$@ + +$(DEPDIR)/%.d: %.c + @echo Generating depend for $< + @$(MAKEDEPEND) $(CCFLAGS) $(CFLAGS_$<) $< >$@ + +$(DEPDIR)/%.d: %.cpp + @echo Generating depend for $< + @$(MAKEDEPEND) $(CCFLAGS) $(CFLAGS_$<) $< >$@ + +$(DEPDIR)/%.d: %.cc + @echo Generating depend for $< + @$(MAKEDEPEND) $(CCFLAGS) $(CFLAGS_$<) $< >$@ + +ifeq ($(NDB_OS), WIN32) +ifndef PIC_DEP +DEP_PTN := -e 's/\(.*\)\.o[ :]*/\1.$(OBJEXT) $(DEPDIR)\/\1.d : /g' +else +DEP_PTN := -e 's/\(.*\)\.o[ :]*/\1.$(OBJEXT) $(PIC_DIR)\/\1.$(OBJEXT) $(DEPDIR)\/\1.d : /g' +endif +else +ifndef PIC_DEP +DEP_PTN := -e 's!\(.*\)\.$(OBJEXT)[ :]*!\1.$(OBJEXT) $(DEPDIR)\/\1.d : !g' +else +DEP_PTN := -e 's!\(.*\)\.$(OBJEXT)[ :]*!\1.$(OBJEXT) $(PIC_DIR)\/\1.$(OBJEXT) $(DEPDIR)\/\1.d : !g' +endif +endif +#DEP_PTN += -e 's!/usr/include/[-+a-zA-Z0-9_/.]*!!g' +#DEP_PTN += -e 's!/usr/local/lib/gcc-lib/[-+a-zA-Z0-9_/.]*!!g' + +$(DEPMK): $(DEPDIR) $(SRC_YPP:%.ypp=%.tab.hpp) $(SRC_LPP:%.lpp=%.yy.cpp) $(DEPENDENCIES) $(wildcard $(NDB_TOP)/.update.d) + @echo "updating .depend.mk" + @sed $(DEP_PTN) /dev/null $(DEPENDENCIES) >$(DEPMK) + +### +# +# clean +# +_clean: + -rm -rf SunWS_cache $(PIC_DIR)/SunWS_cache +ifeq ($(NONPIC_ARCHIVE), Y) + -rm -f $(OBJECTS) $(LIB_DIR)/$(LIBPREFIX)$(ARCHIVE_TARGET).$(LIBEXT) +endif +ifeq ($(PIC_ARCHIVE), Y) + -rm -f $(PIC_OBJS) $(LIB_DIR)/$(LIBPREFIX)$(ARCHIVE_TARGET)_pic.$(LIBEXT) +endif +ifdef BIN_TARGET + -rm -f $(OBJECTS) +endif +ifdef LIB_TARGET +ifeq ($(A_LIB), Y) + -rm -f $(A_TMP_DIR)/* +endif +ifeq ($(SO_LIB), Y) + -rm -f $(SO_TMP_DIR)/* +endif +ifeq ($(PIC_LIB), Y) + -rm -f $(PIC_TMP_DIR)/* +endif +endif +ifneq ($(SRC_YPP),) + -rm -f $(SRC_YPP:%.ypp=%.tab.[hc]pp) $(SRC_YPP:%.ypp=%.output) +endif +ifneq ($(SRC_LPP),) + -rm -f $(SRC_LPP:%.lpp=%.yy.*) +endif +ifdef CLEAN_LOC + -rm -f $(CLEAN_LOC) +endif + +### +# +# clean all +# +clobber: cleanall +_cleanall: _clean clean_links + -rm -f osemain.con osemain.c +ifdef LIB_TARGET +ifeq ($(A_LIB), Y) + -rm -f $(LIB_DIR)/$(LIBPREFIX)$(LIB_TARGET).$(LIBEXT) +endif +ifeq ($(SO_LIB), Y) + -rm -f $(LIB_DIR)/$(LIBPREFIX)$(LIB_TARGET).$(SHLIBEXT) +endif +ifeq ($(PIC_LIB), Y) + -rm -f $(LIB_DIR)/$(LIBPREFIX)$(LIB_TARGET)_pic.$(LIBEXT) +endif +endif +ifdef BIN_TARGET + -rm -f $(BIN_DIR)/$(BIN_TARGET) +endif + +clean_links: + +### +# +# Dist clean +# +_distclean: _tidy + rm -rf $(DEPDIR) $(PIC_DIR) $(PIC_TMP_DIR) $(SO_TMP_DIR) $(A_TMP_DIR) Sources build.spec + +### +# +# tidy +# +_tidy: _cleanall _clean_dep + -rm -f *~ *.$(OBJEXT) *.$(LIBEXT) *.${SHLIBEXT} + +# +# clean cleanall tidy - recursion +# +ifeq ($(findstring clean,$(replace-targets)),) +clean: _clean $(patsubst %, _clean_%, $(A_DIRS)) +endif + +$(patsubst %, _clean_%, $(A_DIRS)) : DUMMY + $(MAKE) -C $(patsubst _clean_%,%,$@) clean + +cleanall: _cleanall $(patsubst %, _cleanall_%, $(A_DIRS)) + +$(patsubst %, _cleanall_%, $(A_DIRS)) : DUMMY + $(MAKE) -C $(patsubst _cleanall_%,%,$@) cleanall + +tidy: _tidy $(patsubst %, _tidy_%, $(A_DIRS)) + +$(patsubst %, _tidy_%, $(A_DIRS)) : DUMMY + $(MAKE) -C $(patsubst _tidy_%,%,$@) tidy + +distclean: _distclean $(patsubst %, _distclean_%, $(A_DIRS)) + +$(patsubst %, _distclean_%, $(A_DIRS)) : DUMMY + $(MAKE) -C $(patsubst _distclean_%,%,$@) distclean + +### +# +# Guess configuration + +$(NDB_TOP)/config/config.mk: $(NDB_TOP)/config/GuessConfig.sh + $(NDB_TOP)/config/GuessConfig.sh -D + +$(NDB_TOP)/config/Defs....mk: $(NDB_TOP)/config/config.mk +$(NDB_TOP)/config/Defs..mk: $(NDB_TOP)/config/config.mk + +### +# Soft ose envirment stuff +# +osemain.con: $(NDB_TOP)/src/env/softose/osemain_con.org + cp $< $@ + echo "PRI_PROC(init_$(BIN_TARGET), init_$(BIN_TARGET), 65535, 3, ndb, 0, NULL)" >> $@ + +osemain.c: $(OSE_LOC)/sfk-solaris2/krn-solaris2/src/osemain.c + ln -s $< $@ + +osemain.o : osemain.con + +$(DEPDIR)/osemain.d : osemain.con + +### +# +# These target dont want dependencies + +NO_DEP=clean clobber cleanall tidy clean_dep $(DEPDIR) build_spec \ + $(NDB_TOP)/config/config.mk distclean osemain.con osemain.c + +ifeq ($(filter $(NO_DEP), $(MAKECMDGOALS)),) +ifneq ($(strip $(DEPENDENCIES)),) + include $(DEPMK) +endif +endif + +### +# +# Auxiliary targets + +sources: Sources + +Sources: Makefile + @rm -f $@ + @for f in Makefile $(A_DIRS) $(SOURCES) $(SOURCES.c); do echo $$f; done >$@ + +### +# +# TAG generation for emacs and vi folks +# +# In emacs "Esc- ." or "M- ." to find a symbol location +# In vi use the :\tag command +# by convention: +# TAGS is used with emacs +# tags is used with vi +# +# Hopefully the make is being done from $(NDB_TOP)/src +# and your TAGS/tags file then is in the same directory. + +TAGS: DUMMY + rm -f TAGS + find $(NDB_TOP) -name "*.[ch]" | xargs $(ETAGS) --append + find $(NDB_TOP) -name "*.[ch]pp" | xargs $(ETAGS) --append + +tags: DUMMY + rm -f tags + find $(NDB_TOP) -name "*.[ch]" | xargs $(CTAGS) --append + find $(NDB_TOP) -name "*.[ch]pp" | xargs $(CTAGS) --append + +install: + + +ebrowse: DUMMY + cd $(NDB_TOP); rm -f EBROWSE + cd $(NDB_TOP); find . -name "*.hpp" -or -name "*.cpp" -or -name "*.h" -or -name "*.c" > tmpfile~ + cd $(NDB_TOP); ebrowse --file tmpfile~ + cd $(NDB_TOP); rm -f tmpfile~ diff --git a/ndb/Makefile b/ndb/Makefile new file mode 100644 index 00000000000..586a430bb17 --- /dev/null +++ b/ndb/Makefile @@ -0,0 +1,62 @@ +include .defs.mk + +DIRS := src test tools examples + +# hack before full autoconf +replace-targets := all clean +NDB_RELEASE := $(shell ../scripts/mysql_config --version) + +include $(NDB_TOP)/Epilogue.mk + +_libs_test : _bins_src +_libs_tools : _libs_test +_libs_examples : _bins_src +_bins_src : _libs_src +_bins_tools : _bins_src + +# always release compile except for ndbapi static lib +all: + $(MAKE) -C src/ndbapi libs + $(MAKE) libs NDB_VERSION=RELEASE + $(MAKE) bins NDB_VERSION=RELEASE +ifeq ($(NDB_OS),LINUX) + NDB_RELEASE=$(NDB_RELEASE) $(MAKE) -j1 -C docs all cd /home/bk/mysql-4.1-ndb +shell> BUILD/compile-pentium-debug -c --prefix=/usr/local/mysql-4.1-ndb +shell> make + diff --git a/ndb/bin/.empty b/ndb/bin/.empty new file mode 100644 index 00000000000..e69de29bb2d diff --git a/ndb/bin/check-regression.sh b/ndb/bin/check-regression.sh new file mode 100755 index 00000000000..93a31ccb39c --- /dev/null +++ b/ndb/bin/check-regression.sh @@ -0,0 +1,180 @@ +#!/bin/sh +# NAME +# check-regression.sh +# +# SYNOPSIS +# check-regression.sh +# +# DESCRIPTION +# +# This scrip must be run before any major cvs checkins are done. +# It will perform a number of regression tests to check that +# nothing is broken. +# +# OPTIONS +# +# EXAMPLES +# +# +# ENVIRONMENT +# NDB_PROJ_HOME Home dir for ndb +# verbose verbose printouts +# +# FILES +# $NDB_PROJ_HOME/lib/funcs.sh general shell script functions +# +# +# SEE ALSO +# +# DIAGNOSTICTS +# +# +# VERSION +# 1.0 +# +# AUTHOR +# +# + +. $NDB_PROJ_HOME/lib/funcs.sh # Load some good stuff + +synopsis="check-regression.sh" +progname=`basename $0` + +numOfTestsOK=0 +numOfTestsFailed=0 + +LOG=check-regression.`date '+%Y-%m-%d'` + +executeTest() +{ + eval "$@" | tee -a $LOG + + if [ $? -eq 0 ] + then + echo "SUCCESS: $@" + numOfTestsOK=`expr $numOfTestsOK + 1` + else + echo "FAILED: $@" + numOfTestsFailed=`expr $numOfTestsFailed + 1` + fi +} + +# +# INFO +# +trace "Starting: `date`" +trace "NDB_PROJ_HOME = $NDB_PROJ_HOME" +trace "NDB_TOP = $NDB_TOP" + +# +# THE TESTS TO EXECUTE +# + +# Testsuite: testDataBuffers +# Number of tests: 1 +executeTest 'drop_tab ' TB00 TB01 TB02 TB03 TB04 TB05 TB06 TB07 TB08 TB09 TB10 TB11 TB12 TB13 TB14 TB15 +executeTest 'testDataBuffers' +executeTest 'drop_tab ' TB00 TB01 TB02 TB03 TB04 TB05 TB06 TB07 TB08 TB09 TB10 TB11 TB12 TB13 TB14 TB15 + +TABLES="T9 T13" + +# Testsuite: testBasic +# Number of tests: 16 +executeTest 'testBasic -n PkInsert' $TABLES +executeTest 'testBasic -n PkRead' $TABLES +executeTest 'testBasic -n PkUpdate' $TABLES +executeTest 'testBasic -n PkDelete' $TABLES +#executeTest 'testBasic -n UpdateAndRead' +#executeTest 'testBasic -n PkReadAndLocker' +#executeTest 'testBasic -n PkReadAndLocker2' +#executeTest 'testBasic -n PkReadUpdateAndLocker' +#executeTest 'testBasic -n ReadWithLocksAndInserts' +#executeTest 'testBasic -n ReadConsistency' +#executeTest 'testBasic -n PkInsertTwice' +#executeTest 'testBasic -n Fill' +#executeTest 'testBasic -n FillTwice' +#executeTest 'testBasic -n NoCommitSleep' +#executeTest 'testBasic -n NoCommit626' +#executeTest 'testBasic -n NoCommitAndClose' + +# Testsuite: testBasicAsynch +# Number of tests: 4 +executeTest 'testBasicAsynch -n PkInsertAsynch' $TABLES +executeTest 'testBasicAsynch -n PkReadAsynch' $TABLES +executeTest 'testBasicAsynch -n PkUpdateAsynch' $TABLES +executeTest 'testBasicAsynch -n PkDeleteAsynch' $TABLES + +# Testsuite: testDict +# Number of tests: 6 +#executeTest 'testDict -n CreateAndDrop' +#executeTest 'testDict -n CreateAndDropWithData' +#executeTest 'testDict -n CreateAndDropDuring' +#executeTest 'testDict -n CreateInvalidTables' +#executeTest 'testDict -n CreateTableWhenDbIsFull' +#executeTest 'testDict -n CreateMaxTables' + +# Testsuite: testScan +# Number of tests: 34 +#executeTest 'testScan -n ScanRead' +#executeTest 'testScan -n ScanRead16' +executeTest 'testScan -n ScanRead240' $TABLES +executeTest 'testScan -n ScanUpdate' $TABLES +executeTest 'testScan -n ScanUpdate2' $TABLES +executeTest 'testScan -n ScanDelete' $TABLES +executeTest 'testScan -n ScanDelete2' $TABLES +#executeTest 'testScan -n ScanUpdateAndScanRead' +#executeTest 'testScan -n ScanReadAndLocker' +#executeTest 'testScan -n ScanReadAndPkRead' +#executeTest 'testScan -n ScanRead488' +#executeTest 'testScan -n ScanWithLocksAndInserts' +#executeTest 'testScan -n ScanReadAbort' +#executeTest 'testScan -n ScanReadAbort15' +#executeTest 'testScan -n ScanReadAbort16' +#executeTest 'testScan -n ScanUpdateAbort16' +#executeTest 'testScan -n ScanReadAbort240' +#executeTest 'testScan -n ScanReadRestart' +#executeTest 'testScan -n ScanReadRestart16' +#executeTest 'testScan -n ScanReadRestart32' +#executeTest 'testScan -n ScanUpdateRestart' +#executeTest 'testScan -n ScanUpdateRestart16' +#executeTest 'testScan -n CheckGetValue' +#executeTest 'testScan -n CloseWithoutStop' +#executeTest 'testScan -n NextScanWhenNoMore' +#executeTest 'testScan -n ExecuteScanWithoutOpenScan' +#executeTest 'testScan -n OnlyOpenScanOnce' +#executeTest 'testScan -n OnlyOneOpInScanTrans' +#executeTest 'testScan -n OnlyOneOpBeforeOpenScan' +#executeTest 'testScan -n OnlyOneScanPerTrans' +#executeTest 'testScan -n NoCloseTransaction' +#executeTest 'testScan -n CheckInactivityTimeOut' +#executeTest 'testScan -n CheckInactivityBeforeClose' +#executeTest 'testScan -n CheckAfterTerror' + +# Testsuite: testScanInterpreter +# Number of tests: 1 +#executeTest 'testScanInterpreter -n ScanLessThan' + +TABLES="T6 T13" + +# Testsuite: testSystemRestart +# Number of tests: 4 +executeTest 'testSystemRestart -l 1 -n SR1' $TABLES +executeTest 'testSystemRestart -l 1 -n SR2' $TABLES +#executeTest 'testSystemRestart -n SR_UNDO' +#executeTest 'testSystemRestart -n SR_FULLDB' + +# TESTS FINISHED +trace "Finished: `date`" + +# +# TEST SUMMARY +# +if [ $numOfTestsFailed -eq 0 ] +then + echo "-- REGRESSION TEST SUCCESSFUL --" +else + echo "-- REGRESSION TEST FAILED!! --" +fi +echo "Number of successful tests: $numOfTestsOK" +echo "Number of failed tests : $numOfTestsFailed" diff --git a/ndb/bin/makeTestPrograms_html.sh b/ndb/bin/makeTestPrograms_html.sh new file mode 100755 index 00000000000..ac31c8a6267 --- /dev/null +++ b/ndb/bin/makeTestPrograms_html.sh @@ -0,0 +1,22 @@ +#!/bin/sh +rm $1 +touch $1 +echo "" >> $1 +echo "" >> $1 +echo "" >> $1 +echo "" >> $1 +testBasic --print_html >> $1 +testBackup --print_html >> $1 +testBasicAsynch --print_html >> $1 +testDict --print_html >> $1 +testBank --print_html >> $1 +testIndex --print_html >> $1 +testNdbApi --print_html >> $1 +testNodeRestart --print_html >> $1 +testOperations --print_html >> $1 +testRestartGci --print_html >> $1 +testScan --print_html >> $1 +testScanInterpreter --print_html >> $1 +testSystemRestart --print_html >> $1 +echo "
Name Description
" >> $1 + diff --git a/ndb/bin/mysqlcluster b/ndb/bin/mysqlcluster new file mode 100755 index 00000000000..81fc7308942 --- /dev/null +++ b/ndb/bin/mysqlcluster @@ -0,0 +1,11 @@ +#!/bin/sh +if [ -z "$MYSQLCLUSTER_TOP" -o ! -d "$MYSQLCLUSTER_TOP" ]; then + echo "MYSQLCLUSTER_TOP not set or directory does not exist" + exit 1 +fi +if [ -z "$MYSQLCLUSTER_TOP" -o ! -d "$MYSQLCLUSTER_TOP/ndb" ]; then + echo "$MYSQLCLUSTER_TOP/ndb directory does not exist" + exit 1 +fi + +mysql --socket=$MYSQLCLUSTER_TOP/data/mysqlcluster.sock $* diff --git a/ndb/bin/mysqlcluster_install_db b/ndb/bin/mysqlcluster_install_db new file mode 100755 index 00000000000..6fe95ff105d --- /dev/null +++ b/ndb/bin/mysqlcluster_install_db @@ -0,0 +1,119 @@ +#!/bin/sh + +NDB_HOME= +export NDB_CONNECTSTRING +if [ -z "$MYSQLCLUSTER_TOP" ]; then + echo "MYSQLCLUSTER_TOP not set" + exit 1 +fi +if [ -d "$MYSQLCLUSTER_TOP" ]; then :; else + echo "$MYSQLCLUSTER_TOP directory does not exist" + exit 1 +fi +if [ -d "$MYSQLCLUSTER_TOP/ndb" ]; then :; else + echo "$MYSQLCLUSTER_TOP/ndb directory does not exist" + exit 1 +fi + +start_default_ndbcluster() { + +# configurable parameters, make sure to change in mysqlcluterd as well +MYSQLCLUSTER_FILESYSTEM=$MYSQLCLUSTER_TOP/data/mysqlclusterfs +MYSQLCLUSTER_PORT_BASE="22" # using ports MYSQLCLUSTER_PORT_BASE{"00","01", etc} +# end configurable parameters + +# do some checks + +NDB_CONNECTSTRING= + +[ -d "$MYSQLCLUSTER_FILESYSTEM" ] || mkdir "$MYSQLCLUSTER_FILESYSTEM" +if [ -d "$MYSQLCLUSTER_FILESYSTEM" ]; then :; else + echo "$MYSQLCLUSTER_FILESYSTEM filesystem directory does not exist" + exit 1 +fi + + +# set som help variables + +NDB_HOST="localhost" +NDB_PORT=$MYSQLCLUSTER_PORT_BASE"00" +NDB_CONNECTSTRING_BASE="host=$NDB_HOST:$NDB_PORT;nodeid=" + + +# Edit file system path and ports in config file + +cd $MYSQLCLUSTER_FILESYSTEM +sed \ + -e s,"WRITE_PATH_TO_FILESYSTEM_2_HERE",$MYSQLCLUSTER_FILESYSTEM,g \ + -e s,"CHOOSE_PORT_BASE",$MYSQLCLUSTER_PORT_BASE,g \ + < $MYSQLCLUSTER_TOP/ndb/demos/config-templates/config_template-install.ini \ + > config.ini + + +# Start management server as deamon + +NDB_ID="1" +NDB_CONNECTSTRING=$NDB_CONNECTSTRING_BASE$NDB_ID +#xterm -e mgmtsrvr -c $MYSQLCLUSTER_FILESYSTEM/config.ini & +if mgmtsrvr -d -c $MYSQLCLUSTER_FILESYSTEM/config.ini ; then :; else + echo "Unable to start mgmtsrvr" + exit 1 +fi + + +# Start database node + +cd $MYSQLCLUSTER_FILESYSTEM # the output from the database node gets where it starts +NDB_ID="2" +NDB_CONNECTSTRING=$NDB_CONNECTSTRING_BASE$NDB_ID +#xterm -T "NDB Cluster DB Node" -geometry 80x10 -xrm *.hold:true -e ndb -i & +ndb -d -i & + +# Start xterm for application programs + +NDB_ID="3" +NDB_CONNECTSTRING=$NDB_CONNECTSTRING_BASE$NDB_ID +#xterm -T "NDB Cluster API Node" -geometry 80x10 & +echo set before running ndbApi programs > export NDB_CONNECTSTRING=$NDB_CONNECTSTRING + +# Start management client + +#xterm -T "NDB Management Client" -geometry 80x10 -xrm *.hold:true -e mgmtclient $NDB_HOST $NDB_PORT & +echo "NDB Management Client starts with: mgmtclient $NDB_HOST $NDB_PORT" + +# test if Ndb Cluster starts properly + +NDB_ID="11" +NDB_CONNECTSTRING=$NDB_CONNECTSTRING_BASE$NDB_ID +if list_tables | grep "NDBT_ProgramExit: 0 - OK"; then :; else + echo "Ndbcluster startup failed" + exit 1 +fi +} + +start_mysql_install_db() { + # run install of regular MySQL Server + + cd $MYSQLCLUSTER_TOP + scripts/mysql_install_db --basedir=$MYSQLCLUSTER_TOP --datadir=$MYSQLCLUSTER_TOP/data --socket=$MYSQLCLUSTER_TOP/data/mysqlcluster.sock $* +} + +if test "$1" = "ndb_started" +then + shift + mgmt_host=$1 + shift + mgmt_port=$1 + shift + if [ -z "$mgmt_host" -o -z "$mgmt_port" ]; then + echo "syntax: ndb_started hostname port" + exit 1 + fi + NDB_CONNECTSTRING="host=$mgmt_host:$mgmt_port;nodeid=11" + echo using NDB_CONNECTSTRING=$NDB_CONNECTSTRING + start_mysql_install_db $* +else + start_default_ndbcluster + start_mysql_install_db +fi + diff --git a/ndb/bin/mysqlclusterd b/ndb/bin/mysqlclusterd new file mode 100755 index 00000000000..3b4deb3ed48 --- /dev/null +++ b/ndb/bin/mysqlclusterd @@ -0,0 +1,34 @@ +#!/bin/sh + +# configurable parameters +MYSQLCLUSTER_PORT_BASE="22" +# end configurable parameters + +if [ -z "$MYSQLCLUSTER_TOP" -o ! -d "$MYSQLCLUSTER_TOP" ]; then + echo "MYSQLCLUSTER_TOP not set or directory does not exist" + exit 1 +fi +if [ -z "$MYSQLCLUSTER_TOP" -o ! -d "$MYSQLCLUSTER_TOP/ndb" ]; then + echo "$MYSQLCLUSTER_TOP/ndb directory does not exist" + exit 1 +fi + +if test "$1" = "ndb_started" +then + shift + mgmt_host=$1 + shift + mgmt_port=$1 + shift + if [ -z "$mgmt_host" -o -z "$mgmt_port" ]; then + echo "syntax: ndb_started hostname port" + exit 1 + fi + NDB_CONNECTSTRING="host=$mgmt_host:$mgmt_port;nodeid=11" + echo using NDB_CONNECTSTRING=$NDB_CONNECTSTRING +else + NDB_CONNECTSTRING="host=localhost:"$MYSQLCLUSTER_PORT_BASE"00;nodeid=11" +fi +export NDB_CONNECTSTRING + +mysqld --default-table-type=ndbcluster --basedir=$MYSQLCLUSTER_TOP --datadir=$MYSQLCLUSTER_TOP/data --socket=$MYSQLCLUSTER_TOP/data/mysqlcluster.sock $* diff --git a/ndb/bin/regression.sh b/ndb/bin/regression.sh new file mode 100644 index 00000000000..5e3491af208 --- /dev/null +++ b/ndb/bin/regression.sh @@ -0,0 +1,644 @@ +#!/bin/sh +# NAME +# regression.sh +# +# SYNOPSIS +# regression.sh +# +# DESCRIPTION +# +# This script runs a number of regression tests to verify that nothing +# is broken. Currently it executes the same tests as in the autotest +# regression suite. +# +# OPTIONS +# +# EXAMPLES +# +# +# ENVIRONMENT +# verbose verbose printouts +# +# FILES +# +# +# SEE ALSO +# +# DIAGNOSTICTS +# +# +# VERSION +# 1.0 +# +# AUTHOR +# +# + + +# die prints the supplied message to stderr, +# prefixed with the program name, and exits +# with the exit code given by "-e num" or +# 1, if no -e option is present. +# +die () +{ + die_code__=1 + [ "X$1" = X-e ] && { die_code__=$2; shift 2; } + [ "X$1" = X-- ] && shift + errmsg "$@" + exit $die_code__ +} + + +# msg prints the supplied message to stderr, +# prefixed with the program name. +# +errmsg () +{ + echo "${progname:-}:" "$@" >&2 +} + +# rawdie prints the supplied message to stderr. +# It then exits with the exit code given with "-e num" +# or 1, if no -e option is present. +# +rawdie () +{ + rawdie_code__=1 + [ "X$1" = X-e ] && { rawdie_code__=$2; shift 2; } + [ "X$1" = X-- ] && shift + rawerrmsg "$@" + exit $rawdie_code__ +} + +# Syndie prints the supplied message (if present) to stderr, +# prefixed with the program name, on the first line. +# On the second line, it prints $synopsis. +# It then exits with the exit code given with "-e num" +# or 1, if no -e option is present. +# +syndie () +{ + syndie_code__=1 + [ "X$1" = X-e ] && { syndie_code__=$2; shift 2; } + [ "X$1" = X-- ] && shift + [ -n "$*" ] && msg "$*" + rawdie -e $syndie_code__ "Synopsis: $synopsis" +} + + + + +# msg prints the supplied message to stdout, +# prefixed with the program name. +# +msg () +{ + echo "${progname:-}:" "$@" +} + +rawmsg () { echo "$*"; } # print the supplied message to stdout +rawerrmsg () { echo "$*" >&2; } # print the supplied message to stderr + +# trace prints the supplied message to stdout if verbose is non-null +# +trace () +{ + [ -n "$verbose" ] && msg "$@" +} + + +# errtrace prints the supplied message to stderr if verbose is non-null +# +errtrace () +{ + [ -n "$verbose" ] && msg "$@" >&2 +} + + +synopsis="regression.sh" +progname=`basename $0` + +numOfTestsOK=0 +numOfTestsFailed=0 + +LOG=regression-$1.`date '+%Y-%m-%d'` + +executeTest() +{ + eval "$@" | tee -a $LOG + + if [ $? -eq 0 ] + then + echo "SUCCESS: $@" + numOfTestsOK=`expr $numOfTestsOK + 1` + else + echo "FAILED: $@" + numOfTestsFailed=`expr $numOfTestsFailed + 1` + fi +} + +# +# INFO +# +trace "Starting: `date`" +trace "NDB_TOP = $NDB_TOP" + +# +# THE TESTS TO EXECUTE +# + +# BASIC FUNCTIONALITY +if [ $1 = "basic" ] +then +executeTest 'testBasic -n PkRead' +executeTest 'drop_all_tabs' + +executeTest 'testBasic -n PkUpdate' +executeTest 'drop_all_tabs' + +executeTest 'testBasic -n PkDelete' +executeTest 'drop_all_tabs' + +executeTest 'testBasic -n PkInsert' +executeTest 'drop_all_tabs' + +executeTest 'testBasic -n UpdateAndRead' +executeTest 'drop_all_tabs' + +executeTest 'testBasic -n PkReadAndLocker' T6 +executeTest 'drop_tab' T6 + +executeTest 'testBasic -n PkReadAndLocker2' T6 +executeTest 'drop_tab' T6 + +executeTest 'testBasic -n PkReadUpdateAndLocker' T6 +executeTest 'drop_tab' T6 + +executeTest 'testBasic -n ReadWithLocksAndInserts' T6 +executeTest 'drop_tab' T6 + +executeTest 'testBasic -n PkInsertTwice' T1 T6 T10 +executeTest 'drop_tab' T1 T6 T10 + +executeTest 'testBasic -n PkDirtyRead' +executeTest 'drop_all_tabs' + +executeTest 'testBasic -n Fill' T6 +executeTest 'drop_tab' T6 + +executeTest 'testBasic -n Fill' T1 +executeTest 'drop_tab' T1 + +executeTest 'testBasic -n NoCommitSleep' T6 +executeTest 'drop_tab' T6 + +executeTest 'testBasic -n NoCommit626' T6 +executeTest 'drop_tab' T6 + +executeTest 'testBasic -n NoCommitAndClose' T6 +executeTest 'drop_tab' T6 + +executeTest 'testBasic -n Commit626' T6 +executeTest 'drop_tab' T6 + +executeTest 'testBasic -n CommitTry626' T6 +executeTest 'drop_tab' T6 + +executeTest 'testBasic -n CommitAsMuch626' T6 +executeTest 'drop_tab' T6 + +executeTest 'testBasic -n NoCommit626' T6 +executeTest 'drop_tab' T6 + +executeTest 'testBasic -n NoCommitRollback626' T1 T6 +executeTest 'drop_tab' T1 T6 + +executeTest 'testBasic -n Commit630' T1 T6 +executeTest 'drop_tab' T6 + +executeTest 'testBasic -n CommitTry630' T1 T6 +executeTest 'drop_tab' T1 T6 + +executeTest 'testBasic -n CommitAsMuch630' T1 T6 +executeTest 'drop_tab' T1 T6 + +executeTest 'testBasic -n NoCommit630' T1 T6 +executeTest 'drop_tab' T1 T6 + +executeTest 'testBasic -n NoCommitRollback630' T1 T6 +executeTest 'drop_tab' T1 T6 + +executeTest 'testBasic -n NoCommitAndClose' T1 T6 +executeTest 'drop_tab' T1 T6 + +executeTest 'testBasic -n RollbackUpdate' T1 T6 +executeTest 'drop_tab' T1 T6 + +executeTest 'testBasic -n RollbackDeleteMultiple' T1 T6 +executeTest 'drop_tab' T1 T6 + +executeTest 'testBasic -n ImplicitRollbackDelete' T1 T6 +executeTest 'drop_tab' T1 T6 + +executeTest 'testBasic -n CommitDelete' T1 T6 +executeTest 'drop_tab' T1 T6 + +executeTest 'testBasic -n RollbackNothing' T1 T6 +executeTest 'drop_tab' T1 T6 + +executeTest 'testBasic -n ReadConsistency' T6 +executeTest 'drop_tab' T6 + +executeTest 'testBasic -n PkRead' TPK_33 TPK_34 TPK_1003 TPK_2003 TPK_4092 +executeTest 'drop_tab' TPK_33 TPK_34 TPK_1003 TPK_2003 TPK_4092 + +executeTest 'testBasic -n PkUpdate' TPK_33 TPK_34 TPK_1003 TPK_2003 TPK_4092 +executeTest 'drop_tab' TPK_33 TPK_34 TPK_1003 TPK_2003 TPK_4092 + +executeTest 'testBasic -n PkDelete' TPK_33 TPK_34 TPK_1003 TPK_2003 TPK_4092 +executeTest 'drop_tab' TPK_33 TPK_34 TPK_1003 TPK_2003 TPK_4092 + +executeTest 'testBasic -n PkInsert' TPK_33 TPK_34 TPK_1003 TPK_2003 TPK_409 +executeTest 'drop_tab' TPK_33 TPK_34 TPK_1003 TPK_2003 TPK_4092 + +executeTest 'testBasic -n UpdateAndRead' TPK_33 TPK_34 TPK_1003 TPK_2003 TPK_4092 +#executeTest 'drop_tab' TPK_33 TPK_34 TPK_1003 TPK_2003 TPK_4092 + +executeTest 'testBasicAsynch -n PkInsertAsynch' +executeTest 'drop_all_tabs' + +executeTest 'testBasicAsynch -n PkReadAsynch' +executeTest 'drop_all_tabs' + +executeTest 'testBasicAsynch -n PkUpdateAsynch' +executeTest 'drop_all_tabs' + +executeTest 'testBasicAsynch -n PkDeleteAsynch' +executeTest 'drop_all_tabs' +fi + +# SCAN TESTS +if [ $1 = "scan" ] +then +executeTest 'testScan -n ScanRead16' +executeTest 'drop_all_tabs' + +executeTest 'testScan -n ScanRead240' +executeTest 'drop_all_tabs' + +executeTest 'testScan -n ScanUpdate' +executeTest 'drop_all_tabs' + +executeTest 'testScan -n ScanUpdate2' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n ScanDelete' +executeTest 'drop_all_tab' + +executeTest 'testScan -n ScanDelete2' T10 +executeTest 'drop_tab' T10 + +executeTest 'testScan -n ScanUpdateAndScanRead' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n ScanReadAndLocker' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n ScanReadAndPkRead' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n ScanRead488' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n ScanWithLocksAndInserts' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n ScanReadAbort' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n ScanReadAbort15' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n ScanReadAbort240' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n ScanUpdateAbort16' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n ScanReadRestart' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n ScanUpdateRestart' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n CheckGetValue' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n CloseWithoutStop' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n NextScanWhenNoMore' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n ExecuteScanWithoutOpenScan' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n OnlyOpenScanOnce' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n OnlyOneOpInScanTrans' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n OnlyOneOpBeforeOpenScan' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n OnlyOneScanPerTrans' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n NoCloseTransaction' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n CheckInactivityTimeOut' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n CheckInactivityBeforeClose' T6 +executeTest 'drop_tab' T6 + +executeTest 'testScan -n CheckAfterTerror' T6 +executeTest 'drop_tab' T6 +fi + + +# DICT TESTS +if [ $1 = "dict" ] +then +executeTest 'testDict -n CreateAndDrop' +executeTest 'drop_all_tabs' + +executeTest 'testDict -n CreateAndDropWithData' +executeTest 'drop_all_tabs' + +executeTest 'testDict -n CreateAndDropDuring' T6 +executeTest 'drop_tab' T6 + +executeTest 'testDict -n CreateInvalidTables' +executeTest 'drop_all_tabs' + +executeTest 'testDict -n CreateTableWhenDbIsFull' T6 +executeTest 'drop_tab' T6 + +executeTest 'testDict -n CreateMaxTables' T6 +executeTest 'drop_tab' T6 + +executeTest 'testDict -n FragmentTypeAll' T1 T6 T7 T8 +executeTest 'drop_tab' T1 T6 T7 T8 + +executeTest 'testDict -n FragmentTypeAllLarge' T1 T6 T7 T8 +executeTest 'drop_tab' T1 T6 T7 T8 + +executeTest 'testDict -n TemporaryTables' T1 T6 T7 T8 +executeTest 'drop_tab' T1 T6 T7 T8 +fi + +# TEST NDBAPI +if [ $1 = "api" ] +then +executeTest 'testNdbApi -n MaxNdb' T6 +executeTest 'drop_tab' T6 + +executeTest 'testNdbApi -n MaxTransactions' T1 T6 T7 T8 T13 +executeTest 'drop_tab' T1 T6 T7 T8 T13 + +executeTest 'testNdbApi -n MaxOperations' T1 T6 T7 T8 T1 +executeTest 'drop_tab' T1 T6 T7 T8 T13 + +executeTest 'testNdbApi -n MaxGetValue' T1 T6 T7 T8 T13 +executeTest 'drop_tab' T1 T6 T7 T8 T13 + +executeTest 'testNdbApi -n MaxEqual' +executeTest 'drop_all_tabs' + +executeTest 'testNdbApi -n DeleteNdb' T1 T6 +executeTest 'drop_tab' T1 T6 + +executeTest 'testNdbApi -n WaitUntilReady' T1 T6 T7 T8 T13 +executeTest 'drop_tab' T1 T6 T7 T8 T13 + +executeTest 'testNdbApi -n GetOperationNoTab' T6 +executeTest 'drop_tab' T6 + +executeTest 'testNdbApi -n NdbErrorOperation' T6 +executeTest 'drop_tab' T6 + +executeTest 'testNdbApi -n MissingOperation' T6 +executeTest 'drop_tab' T6 + +executeTest 'testNdbApi -n GetValueInUpdate' T6 +executeTest 'drop_tab' T6 + +executeTest 'testNdbApi -n UpdateWithoutKeys' T6 +executeTest 'drop_tab' T6 + +executeTest 'testNdbApi -n UpdateWithoutValues' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n ReadRead' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n ReadReadEx' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n ReadInsert' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n ReadUpdate' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n ReadDelete' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n ReadExRead' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n ReadExReadEx' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n ReadExInsert' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n ReadExUpdate' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n ReadExDelete' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n InsertRead' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n InsertReadEx' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n InsertInsert' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n InsertUpdate' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n InsertDelete' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n UpdateRead' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n UpdateReadEx' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n UpdateInsert' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n UpdateUpdate' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n UpdateDelete' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n DeleteRead' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n DeleteReadEx' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n DeleteInsert' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n DeleteUpdate' T6 +executeTest 'drop_tab' T6 + +executeTest 'testOperations -n DeleteDelete' T6 +executeTest 'drop_tab' T6 + +executeTest 'testRestartGci' T6 +executeTest 'drop_tab' T6 + +executeTest 'testIndex -n CreateAll' +executeTest 'drop_all_tabs' + +executeTest 'testIndex -n InsertDeleteGentle' T1 T6 T8 T10 +executeTest 'drop_tab' T1 T6 T8 T10 + +executeTest 'testIndex -n InsertDelete' T1 T6 T8 T10 +executeTest 'drop_tab' T1 T6 T8 T10 + +executeTest 'testIndex -n CreateLoadDropGentle' T1 T6 T8 T10 +executeTest 'drop_tab' T1 T6 T8 T10 + +executeTest 'testIndex -n CreateLoadDrop' T1 T6 T8 T10 +executeTest 'drop_tab' T1 T6 T8 T10 + +executeTest 'testBackup' -n BackupOne + +executeTest 'testBackup' -n BackupBank T6 +executeTest 'drop_tab' T6 +fi + +# TEST SYSTEM RESTARTS +if [ $1 = "sr" ] +then +executeTest 'testSystemRestart -n SR1' T1 +executeTest 'testSystemRestart -n SR1' T6 +executeTest 'testSystemRestart -n SR1' T7 +executeTest 'testSystemRestart -n SR1' T8 +executeTest 'testSystemRestart -n SR1' T10 +executeTest 'testSystemRestart -n SR2' T1 +executeTest 'testSystemRestart -n SR2' T6 +executeTest 'testSystemRestart -n SR2' T7 +executeTest 'testSystemRestart -n SR2' T10 +executeTest 'testSystemRestart -n SR2' T13 +executeTest 'testSystemRestart -n SR3' T6 +executeTest 'testSystemRestart -n SR3' T10 +executeTest 'testSystemRestart -n SR4' T6 +executeTest 'testSystemRestart -n SR_UNDO' T1 +executeTest 'testSystemRestart -n SR_UNDO' T6 +executeTest 'testSystemRestart -n SR_UNDO' T7 +executeTest 'testSystemRestart -n SR_UNDO' T8 +executeTest 'testSystemRestart -n SR_UNDO' T10 +executeTest 'drop_tab' T1 T6 T7 T8 T10 +fi + +# TEST NODE RESTARTS +if [ $1 = "nr" ] +then +executeTest 'testNodeRestart -n NoLoad' T6 T8 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n PkRead' T6 T8 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n PkReadPkUpdate' T6 T8 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n ReadUpdateScan' T6 T8 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n Terror' T6 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n FullDb' T6 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n RestartRandomNode' T6 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n RestartRandomNodeError' T6 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n RestartRandomNodeInitial' T6 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n RestartNFDuringNR' T6 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n RestartNodeDuringLCP' T6 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n RestartMasterNodeError' T6 T8 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n TwoNodeFailure' T6 T8 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n TwoMasterNodeFailure' T6 T8 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n FiftyPercentFail' T6 T8 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n RestartAllNodes' T6 T8 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n RestartAllNodesAbort' T6 T8 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n RestartAllNodesError9999' T6 T8 T13 +executeTest 'drop_tab' T6 T8 T13 + +executeTest 'testNodeRestart -n FiftyPercentStopAndWait' T6 T8 T13 +executeTest 'drop_tab' T6 T8 T13 + +fi + +# TESTS FINISHED +trace "Finished: `date`" + +# +# TEST SUMMARY +# +if [ $numOfTestsFailed -eq 0 ] +then + echo "-- REGRESSION TEST SUCCESSFUL --" +else + echo "-- REGRESSION TEST FAILED!! --" +fi +echo "Number of successful tests: $numOfTestsOK" +echo "Number of failed tests : $numOfTestsFailed" diff --git a/ndb/config/Defs.DEBUG.mk b/ndb/config/Defs.DEBUG.mk new file mode 100644 index 00000000000..309ae90a0ba --- /dev/null +++ b/ndb/config/Defs.DEBUG.mk @@ -0,0 +1,4 @@ + +VERSION_FLAGS := -DNDB_DEBUG -DUSE_EMULATED_JAM -DVM_TRACE -DERROR_INSERT -DARRAY_GUARD +#-DDEBUG_TRANSPORTER + diff --git a/ndb/config/Defs.HPUX.HPPA.GCC.mk b/ndb/config/Defs.HPUX.HPPA.GCC.mk new file mode 100644 index 00000000000..895c7672071 --- /dev/null +++ b/ndb/config/Defs.HPUX.HPPA.GCC.mk @@ -0,0 +1,50 @@ +### +# +# Defines +SHELL := /bin/sh + +C++ := g++ +CC := gcc +AR_RCS := ar rcs +SO := ld -b -o + +SHLIBEXT := sl + +MAKEDEPEND := g++ -M +PIC := -fPIC + +RPCGENFLAGS := -MA -C -N +ETAGS := etags +CTAGS := ctags + +### +# +# Flags +# +CCFLAGS_WARNINGS = -Wno-long-long -W -Wall -pedantic +# -Wno-sign-compare Use this flag if you are annoyed with all the warnings +CCFLAGS_TOP = -DHPUX -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS -DNO_COMMAND_HANDLER + +ifeq (RELEASE, $(NDB_VERSION)) +VERSION_FLAGS += -O3 +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +VERSION_FLAGS += -O3 -g +else +VERSION_FLAGS += -g +endif +endif + +CCFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) +CFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) + +LDFLAGS_TOP = -lpthread -lnsl -lrt + +LDFLAGS = $(LDFLAGS_LOC) $(LDFLAGS_TOP) + +LDLIBS = $(LDLIBS_LOC) $(LDLIBS_TOP) + +LINK.cc = $(PURE) $(C++) $(CCFLAGS) $(LDFLAGS) + +LINK.c = $(PURE) $(CC) $(CFLAGS) $(LDFLAGS) + diff --git a/ndb/config/Defs.IBMAIX.POWERPC.GCC.mk b/ndb/config/Defs.IBMAIX.POWERPC.GCC.mk new file mode 100644 index 00000000000..ae975fb2cb8 --- /dev/null +++ b/ndb/config/Defs.IBMAIX.POWERPC.GCC.mk @@ -0,0 +1,49 @@ +### +# +# Defines +SHELL := /bin/sh + +C++ := g++ +CC := gcc +AR_RCS := $(PURE) ar rcs +SO := g++ -shared -o + +MAKEDEPEND := g++ -M +PIC := -fPIC + +RPCGENFLAGS := -M -C -N + +ETAGS := etags +CTAGS := ctags + +### +# +# Flags +# +CCFLAGS_WARNINGS = -Wno-long-long -Wall #-pedantic +# Add these for more warnings -Weffc++ -W +CCFLAGS_TOP = -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS +CCFLAGS_TOP += -fno-rtti + +ifeq (RELEASE, $(NDB_VERSION)) +VERSION_FLAGS += -O3 +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +VERSION_FLAGS += -O3 -g +else +VERSION_FLAGS += -g +endif +endif + +CCFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) +CFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) + +LDFLAGS_TOP = -lpthread -lrt + +LDFLAGS = $(LDFLAGS_LOC) $(LDFLAGS_TOP) + +LDLIBS = $(LDLIBS_LOC) $(LDLIBS_TOP) + +LINK.cc = $(PURE) $(C++) $(CCFLAGS) $(LDFLAGS) + +LINK.c = $(PURE) $(CC) $(CFLAGS) $(LDFLAGS) diff --git a/ndb/config/Defs.LINUX.x86.GCC.mk b/ndb/config/Defs.LINUX.x86.GCC.mk new file mode 100644 index 00000000000..a1cc3c52a7e --- /dev/null +++ b/ndb/config/Defs.LINUX.x86.GCC.mk @@ -0,0 +1,56 @@ +### +# +# Defines +SHELL := /bin/sh + +C++ := g++$(GCC_VERSION) +CC := gcc$(GCC_VERSION) +AR_RCS := $(PURE) ar rcs +SO := gcc$(GCC_VERSION) -shared -lpthread -o + +MAKEDEPEND := g++$(GCC_VERSION) -M +PIC := -fPIC + +RPCGENFLAGS := -M -C -N + +ETAGS := etags +CTAGS := ctags + +### +# +# Flags +# +# gcc3.3 __THROW problem if -pedantic and -O2 +ifeq ($(NDB_VERSION),DEBUG) +CCFLAGS_WARNINGS = -Wno-long-long -Wall -pedantic +else +CCFLAGS_WARNINGS = -Wno-long-long -Wall +endif +# Add these for more warnings -Weffc++ -W +CCFLAGS_TOP = -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS +CCFLAGS_TOP += -fno-rtti -fno-exceptions + +ifeq (RELEASE, $(NDB_VERSION)) +VERSION_FLAGS += -O2 +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +VERSION_FLAGS += -O2 -g +else +VERSION_FLAGS += -g +endif +endif + +CCFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) +CFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) + +LDFLAGS_TOP = + +LDFLAGS = $(LDFLAGS_LOC) $(LDFLAGS_TOP) + +LDLIBS = $(LDLIBS_LOC) $(LDLIBS_TOP) + +LINK.cc = $(PURE) $(CC) $(CCFLAGS) $(LDFLAGS) + +LINK.c = $(PURE) $(CC) $(CFLAGS) $(LDFLAGS) + +LDFLAGS_LAST = -lpthread -lrt -Wl,-Bstatic -lstdc++ -Wl,-Bdynamic diff --git a/ndb/config/Defs.LINUX.x86.ICC.mk b/ndb/config/Defs.LINUX.x86.ICC.mk new file mode 100644 index 00000000000..8e8540409da --- /dev/null +++ b/ndb/config/Defs.LINUX.x86.ICC.mk @@ -0,0 +1,54 @@ +### +# +# Defines +SHELL := /bin/sh + +C++ := icc +CC := icc +AR_RCS := $(PURE) ar rcs +SO := g++$(GCC_VERSION) -shared -lpthread -o + +MAKEDEPEND := g++$(GCC_VERSION) -M +PIC := -fPIC + +RPCGENFLAGS := -M -C -N + +ETAGS := etags +CTAGS := ctags + +### +# +# Flags +# +# gcc3.3 __THROW problem if -pedantic and -O2 +ifeq ($(NDB_VERSION),DEBUG) +CCFLAGS_WARNINGS = +else +CCFLAGS_WARNINGS = +endif +# Add these for more warnings -Weffc++ -W +CCFLAGS_TOP = -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS +CCFLAGS_TOP += + +ifeq (RELEASE, $(NDB_VERSION)) +VERSION_FLAGS += -O2 +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +VERSION_FLAGS += -O2 -g +else +VERSION_FLAGS += -g +endif +endif + +CCFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) +CFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) + +LDFLAGS_TOP = -lpthread -lrt + +LDFLAGS = $(LDFLAGS_LOC) $(LDFLAGS_TOP) + +LDLIBS = $(LDLIBS_LOC) $(LDLIBS_TOP) + +LINK.cc = $(PURE) $(C++) $(CCFLAGS) $(LDFLAGS) + +LINK.c = $(PURE) $(CC) $(CFLAGS) $(LDFLAGS) diff --git a/ndb/config/Defs.LINUX.x86_64.GCC.mk b/ndb/config/Defs.LINUX.x86_64.GCC.mk new file mode 100644 index 00000000000..a238d29ef4c --- /dev/null +++ b/ndb/config/Defs.LINUX.x86_64.GCC.mk @@ -0,0 +1,54 @@ +### +# +# Defines +SHELL := /bin/sh + +C++ := g++ +CC := gcc +AR_RCS := $(PURE) ar rcs +SO := g++ -shared -lpthread -o + +MAKEDEPEND := g++ -M +PIC := -fPIC + +RPCGENFLAGS := -M -C -N + +ETAGS := etags +CTAGS := ctags + +### +# +# Flags +# +# gcc3.3 __THROW problem if -pedantic and -O2 +ifeq ($(NDB_VERSION),DEBUG) +CCFLAGS_WARNINGS = -Wno-long-long -Wall -pedantic +else +CCFLAGS_WARNINGS = -Wno-long-long -Wall +endif +# Add these for more warnings -Weffc++ -W +CCFLAGS_TOP = -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS +CCFLAGS_TOP += -fno-rtti -fno-exceptions -m64 + +ifeq (RELEASE, $(NDB_VERSION)) +VERSION_FLAGS += -O2 +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +VERSION_FLAGS += -O2 -g +else +VERSION_FLAGS += -g +endif +endif + +CCFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) +CFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) + +LDFLAGS_TOP = -lpthread -lrt + +LDFLAGS = $(LDFLAGS_LOC) $(LDFLAGS_TOP) + +LDLIBS = $(LDLIBS_LOC) $(LDLIBS_TOP) + +LINK.cc = $(PURE) $(C++) $(CCFLAGS) $(LDFLAGS) + +LINK.c = $(PURE) $(CC) $(CFLAGS) $(LDFLAGS) diff --git a/ndb/config/Defs.MACOSX.POWERPC.GCC.mk b/ndb/config/Defs.MACOSX.POWERPC.GCC.mk new file mode 100644 index 00000000000..bb73e9bcc61 --- /dev/null +++ b/ndb/config/Defs.MACOSX.POWERPC.GCC.mk @@ -0,0 +1,58 @@ +### +# +# Defines +SHELL := /bin/sh + +C++ := gcc +CC := gcc +CXX := gcc +AR_RCS := $(PURE) ar rcs +#SO := g++ -dynamiclib -Wl,-segprot,__TEXT,rwx,rwx -o +SO := gcc -dynamiclib -o + +SHLIBEXT := dylib + +MAKEDEPEND := gcc -M +PIC := -fPIC + +RPCGENFLAGS := -M -C -N + +ETAGS := etags +CTAGS := ctags + +### +# +# Flags +# +CCFLAGS_WARNINGS = -Wno-long-long -Wall -Winline #-Werror#-pedantic +# Add these for more warnings -Weffc++ -W +CCFLAGS_TOP = -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS -D_BIG_ENDIAN +CXX_FLAGS_TOP = -fno-rtti -felide-constructors -fno-exceptions -fno-omit-fram-pointer +C_FLAGS_TOP += -fno-omit-frame-pointer + +ifeq (RELEASE, $(NDB_VERSION)) +VERSION_FLAGS += -O3 +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +VERSION_FLAGS += -O3 -g +else +VERSION_FLAGS += -g +endif +endif + +CCFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(CXXFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) +CFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(C_FLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) + +LDFLAGS_TOP = + +LDFLAGS = $(LDFLAGS_LOC) $(LDFLAGS_TOP) + +LDLIBS = $(LDLIBS_LOC) $(LDLIBS_TOP) + +LINK.cc = $(PURE) $(C++) $(CCFLAGS) $(LDFLAGS) + +LINK.c = $(PURE) $(CC) $(CFLAGS) $(LDFLAGS) + +#LDFLAGS_LAST = -Wl,-Bstatic -lstdc++ -Wl,-Bdynamic +LDFLAGS_LAST = -lstdc++ + diff --git a/ndb/config/Defs.OSE.PPC750.DIAB.mk b/ndb/config/Defs.OSE.PPC750.DIAB.mk new file mode 100644 index 00000000000..8773021a152 --- /dev/null +++ b/ndb/config/Defs.OSE.PPC750.DIAB.mk @@ -0,0 +1,47 @@ +### +# +# Defines +SHELL := /bin/sh + +C++ := dplus +CC := dcc +AR_RCS := $(PURE) ar rcs +SO := dar -r + +MAKEDEPEND := g++ -M -nostdinc +PIC := + +RPCGENFLAGS := -MA -C -N + +### +# +# Flags +# +CCFLAGS_INCLUDE = -I/vobs/cello/cls/rtosi_if/include -I/vobs/cello/cls/rtosi_if/include.mp750 -I/vobs/cello/cls/rtosi_if/include.ppc +CCFLAGS_TOP = -tPPC750EH -DBIG_ENDIAN -D_BIG_ENDIAN -DPPC -DPPC750 -DOSE_DELTA -DMP -Xlint -Xforce-prototypes -DINLINE=__inline__ -Xansi -Xsmall-data=0 -Xsmall-const=0 -Xstrings-in-text + +ifeq (RELEASE, $(NDB_VERSION)) +VERSION_FLAGS += -XO +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +VERSION_FLAGS += -XO -g +else +VERSION_FLAGS += -g +endif +endif + +CCFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_INCLUDE) +CFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_INCLUDE) + +LDFLAGS_TOP = + +LDFLAGS = $(LDFLAGS_LOC) $(LDFLAGS_TOP) + +LDLIBS = $(LDLIBS_LOC) $(LDLIBS_TOP) + +LINK.cc = $(PURE) $(C++) $(CCFLAGS) $(LDFLAGS) + +LINK.c = $(PURE) $(CC) $(CFLAGS) $(LDFLAGS) + + + diff --git a/ndb/config/Defs.RELEASE.mk b/ndb/config/Defs.RELEASE.mk new file mode 100644 index 00000000000..fad72d53a43 --- /dev/null +++ b/ndb/config/Defs.RELEASE.mk @@ -0,0 +1,3 @@ + +VERSION_FLAGS := -DNDB_RELEASE -DUSE_EMULATED_JAM -DNDEBUG + diff --git a/ndb/config/Defs.RELEASE_TRACE.mk b/ndb/config/Defs.RELEASE_TRACE.mk new file mode 100644 index 00000000000..06726f282e4 --- /dev/null +++ b/ndb/config/Defs.RELEASE_TRACE.mk @@ -0,0 +1,3 @@ + +VERSION_FLAGS := -DNDB_RELEASE -DUSE_EMULATED_JAM -DNDEBUG -DVM_TRACE -DERROR_INSERT -DARRAY_GUARD + diff --git a/ndb/config/Defs.SIMCELLO.SOFTOSE.GCC.mk b/ndb/config/Defs.SIMCELLO.SOFTOSE.GCC.mk new file mode 100644 index 00000000000..8d73e7a752b --- /dev/null +++ b/ndb/config/Defs.SIMCELLO.SOFTOSE.GCC.mk @@ -0,0 +1,53 @@ +### +# +# Defines +SHELL := /bin/sh + +C++ := g++ +CC := gcc +AR_RCS := $(PURE) ar rcs +SO := g++ -shared -o + +MAKEDEPEND := g++ -M +PIC := -fPIC + +### +# +# Flags +# +NDB_STRDUP := Y +CCFLAGS_WARNINGS = -Wall -pedantic -Wno-sign-compare +CC_FLAGS_OSE = -DSPARC -DSIM -DOSE_DELTA -DMP +CCFLAGS_TOP = $(CC_FLAGS_OSE) $(CC_FLAGS_WARNINGS) -DNDB_STRDUP + +ifeq (RELEASE, $(NDB_VERSION)) +VERSION_FLAGS += -O3 +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +VERSION_FLAGS += -O3 -g +else +VERSION_FLAGS += -g +endif +endif + + +CCFLAGS_LOC_OSE= -I/vobs/cello/cls/rtosi_if/include.sparc + + +CCFLAGS = $(CCFLAGS_LOC_OSE) $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) +CFLAGS = $(CCFLAGS_LOC_OSE) $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) + +LDLIBS_LOC = -L$(NDB_TOP)/lib -L$(OSE_LOC)/sfk-solaris2/lib -L$(OSE_LOC)/sfk-solaris2/krn-solaris2/lib + +LDLIBS_TOP = + +LDFLAGS = $(LDFLAGS_LOC) $(LDFLAGS_TOP) + +LDLIBS = $(LDLIBS_LOC) $(LDLIBS_TOP) + +LINK.cc = $(PURE) $(C++) $(CCFLAGS) $(LDFLAGS) + +LINK.c = $(PURE) $(CC) $(LDFLAGS) + + + diff --git a/ndb/config/Defs.SOFTOSE.SPARC.GCC.mk b/ndb/config/Defs.SOFTOSE.SPARC.GCC.mk new file mode 100644 index 00000000000..6788fa956bf --- /dev/null +++ b/ndb/config/Defs.SOFTOSE.SPARC.GCC.mk @@ -0,0 +1,57 @@ +### +# +# Defines +SHELL := /bin/sh + +C++ := g++ +CC := gcc +AR_RCS := $(PURE) ar rcs +SO := g++ -shared -o + +MAKEDEPEND := g++ -M +PIC := -fPIC + +### +# +# Flags +# +NDB_STRDUP := Y +CCFLAGS_WARNINGS = -Wno-long-long -Wall -pedantic -Wno-sign-compare -ansi +CC_FLAGS_OSE = -DUSE_OSEDEF_H -DOSE_DELTA -DOS_DEBUG -DBIG_ENDIAN +CCFLAGS_TOP = $(CC_FLAGS_OSE) $(CC_FLAGS_WARNINGS) -DNDB_STRDUP + +ifeq (RELEASE, $(NDB_VERSION)) +VERSION_FLAGS += -O3 +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +VERSION_FLAGS += -O3 -g +else +VERSION_FLAGS += -g -DOS_DEBUG +endif +endif + +OSE_LOC = /opt/as/OSE/OSE4.3.1 + +CCFLAGS_LOC_OSESTD = -I$(OSE_LOC)/sfk-solaris2/std-include +CCFLAGS_LOC_OSE = -I$(OSE_LOC)/sfk-solaris2/include -I$(OSE_LOC)/sfk-solaris2/krn-solaris2/include -I$(NDB_TOP)/src/env/softose + + +CCFLAGS = $(CCFLAGS_LOC_OSE) $(CCFLAGS_LOC_OSESTD) $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) +CFLAGS = $(CCFLAGS_LOC_OSE) $(CCFLAGS_LOC_OSESTD) $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) + +LDLIBS_LOC = -L$(NDB_TOP)/lib -L$(OSE_LOC)/sfk-solaris2/lib -L$(OSE_LOC)/sfk-solaris2/krn-solaris2/lib + +LDLIBS_TOP = + +LDLIBS_LAST = -lsoftose_env -lsoftose_krn -llnh -lefs -lshell -lfss -ltosv -lrtc -lheap -linetutil -linetapi -lsoftose -lsoftose_env -lsoftose_krn -losepthread -lrtc -lnsl -lsocket -lpthread -lcrt -lm + +LDFLAGS = $(LDFLAGS_LOC) $(LDFLAGS_TOP) + +LDLIBS = $(LDLIBS_LOC) $(LDLIBS_TOP) + +LINK.cc = $(PURE) $(C++) $(CCFLAGS) $(LDFLAGS) + +LINK.c = $(PURE) $(CC) $(LDFLAGS) + + + diff --git a/ndb/config/Defs.SOLARIS.SPARC.FORTE6.mk b/ndb/config/Defs.SOLARIS.SPARC.FORTE6.mk new file mode 100644 index 00000000000..8a95205703d --- /dev/null +++ b/ndb/config/Defs.SOLARIS.SPARC.FORTE6.mk @@ -0,0 +1,54 @@ +### +# +# Defines +SHELL := /bin/sh + +C++ := CC +CC := /opt/as/forte6/SUNWspro/bin/cc +AR_RCS := $(PURE) CC -xar -o +SO := CC -G -z text -o + +MAKEDEPEND := CC -xM1 +PIC := -KPIC +ETAGS := etags +CTAGS := ctags + +RPCGENFLAGS := -MA -C -N + +### +# +# Flags + +CCFLAGS_TOP = -mt -DSOLARIS -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS + +ifneq ($(PURE),) + CCFLAGS_TOP += -xs + CCFLAGS_TOP += -DNDB_PURIFY +endif + +ifeq (RELEASE, $(NDB_VERSION)) +VERSION_FLAGS += -xO3 +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +VERSION_FLAGS += -xO3 -g +else +VERSION_FLAGS += -g +endif +endif + +CCFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) +CFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) + +LDFLAGS_TOP = -L/opt/as/forte6/SUNWspro/WS6/lib -lpthread -lsocket -lnsl -lrt + +LDFLAGS = $(LDFLAGS_LOC) $(LDFLAGS_TOP) + +LDLIBS = $(LDLIBS_LOC) $(LDLIBS_TOP) + +LINK.cc = $(PURE) $(C++) -xildoff $(CCFLAGS) $(LDFLAGS) + +LINK.c = $(PURE) $(CC) $(CFLAGS) $(LDFLAGS) + + + + diff --git a/ndb/config/Defs.SOLARIS.SPARC.GCC.mk b/ndb/config/Defs.SOLARIS.SPARC.GCC.mk new file mode 100644 index 00000000000..25920515278 --- /dev/null +++ b/ndb/config/Defs.SOLARIS.SPARC.GCC.mk @@ -0,0 +1,54 @@ +### +# +# Defines +SHELL := /bin/sh + +CXX := gcc +C++ := g++ +CC := gcc +AR_RCS := ar rcs +SO := gcc -G -o + +#GXX_VERSION := $(shell gcc --version | sed -e 's,.*\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\).*,\1,1' -e q) + +MAKEDEPEND := g++ -M +PIC := -fPIC + +RPCGENFLAGS := -MA -C -N +ETAGS := etags +CTAGS := ctags + +### +# +# Flags +# +CCFLAGS_WARNINGS = -Wno-long-long -W -Wall -pedantic +# -Wno-sign-compare Use this flag if you are annoyed with all the warnings +CCFLAGS_TOP = -DSOLARIS -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS -DNO_COMMAND_HANDLER +CCFLAGS_TOP += -fno-rtti + +ifeq (RELEASE, $(NDB_VERSION)) +VERSION_FLAGS += -O2 +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +VERSION_FLAGS += -O2 -g +else +VERSION_FLAGS += -g +endif +endif + +CCFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) +CFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) + +LDFLAGS_TOP = + +LDFLAGS = $(LDFLAGS_LOC) $(LDFLAGS_TOP) + +LDLIBS = $(LDLIBS_LOC) $(LDLIBS_TOP) + +LINK.cc = $(PURE) $(CXX) $(CCFLAGS) $(LDFLAGS) + +LINK.c = $(PURE) $(CC) $(CFLAGS) $(LDFLAGS) + +LDFLAGS_LAST = -lpthread -lsocket -lnsl -lrt -Wl,-Bstatic -lstdc++ -Wl,-Bdynamic + diff --git a/ndb/config/Defs.SOLARIS.SPARC_64.GCC.mk b/ndb/config/Defs.SOLARIS.SPARC_64.GCC.mk new file mode 100644 index 00000000000..2b8b9d4cc24 --- /dev/null +++ b/ndb/config/Defs.SOLARIS.SPARC_64.GCC.mk @@ -0,0 +1,53 @@ +### +# +# Note: LD_LIBRARY_PATH must be set for /usr/local/lib/sparcv9 to dynamically link +# to 64-bit libraries +# +# Defines +SHELL := /bin/sh + +C++ := g++ -m64 +CC := gcc -m64 +AR_RCS := ar rcs +SO := g++ -m64 -shared -o + +MAKEDEPEND := g++ -M +PIC := -fPIC + +RPCGENFLAGS := -MA -C -N +ETAGS := etags +CTAGS := ctags + +### +# +# Flags +# +CCFLAGS_WARNINGS = -Wno-long-long -W -Wall -pedantic +# -Wno-sign-compare Use this flag if you are annoyed with all the warnings +CCFLAGS_TOP = -DSOLARIS -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS -DNO_COMMAND_HANDLER +CCFLAGS_TOP += -fno-rtti + +ifeq (RELEASE, $(NDB_VERSION)) +VERSION_FLAGS += -O2 +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +VERSION_FLAGS += -O2 -g +else +VERSION_FLAGS += -g +endif +endif + +CCFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) +CFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) + +LDFLAGS_TOP = -lpthread -lsocket -lnsl -lrt + +LDFLAGS = $(LDFLAGS_LOC) $(LDFLAGS_TOP) + +LDLIBS = $(LDLIBS_LOC) $(LDLIBS_TOP) + +LINK.cc = $(PURE) $(C++) $(CCFLAGS) $(LDFLAGS) + +LINK.c = $(PURE) $(CC) $(CFLAGS) $(LDFLAGS) + + diff --git a/ndb/config/Defs.SOLARIS6.SPARC.GCC.mk b/ndb/config/Defs.SOLARIS6.SPARC.GCC.mk new file mode 100644 index 00000000000..f1c570ba101 --- /dev/null +++ b/ndb/config/Defs.SOLARIS6.SPARC.GCC.mk @@ -0,0 +1,53 @@ +### +# +# Defines +SHELL := /bin/sh + +C++ := g++ +CC := gcc +AR_RCS := $(PURE) ar rcs +SO := g++ -shared -o + +MAKEDEPEND := g++ -M +PIC := -fPIC + +RPCGENFLAGS := -MA -C -N + +### +# +# Flags +# +CCFLAGS_WARNINGS = -Wno-long-long -Wall -pedantic +# -Wno-sign-compare Use this flag if you are annoyed with all the warnings +CCFLAGS_TOP = -DSOLARIS -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS -DNO_COMMAND_HANDLER + +# SOLARIS 6 should use the same settings as SOLARIS7 +# if something in the SOLARIS 7 port does not work for SOLARIS 6 +# it can be ifdefed using +# if ! defined NDB_SOLRIS6 +CCFLAGS_TOP = -DNDB_SOLARIS + +ifeq (RELEASE, $(NDB_VERSION)) +VERSION_FLAGS += -O3 +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +VERSION_FLAGS += -O3 +else +VERSION_FLAGS += -g +endif +endif + +CCFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) +CFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) + +LDFLAGS_TOP = -lpthread -lsocket -lnsl -lposix4 + +LDFLAGS = $(LDFLAGS_LOC) $(LDFLAGS_TOP) + +LDLIBS = $(LDLIBS_LOC) $(LDLIBS_TOP) + +LINK.cc = $(PURE) $(C++) $(CCFLAGS) $(LDFLAGS) + +LINK.c = $(PURE) $(CC) $(CFLAGS) $(LDFLAGS) + + diff --git a/ndb/config/Defs.TRU64X.ALPHA.GCC.mk b/ndb/config/Defs.TRU64X.ALPHA.GCC.mk new file mode 100644 index 00000000000..ae975fb2cb8 --- /dev/null +++ b/ndb/config/Defs.TRU64X.ALPHA.GCC.mk @@ -0,0 +1,49 @@ +### +# +# Defines +SHELL := /bin/sh + +C++ := g++ +CC := gcc +AR_RCS := $(PURE) ar rcs +SO := g++ -shared -o + +MAKEDEPEND := g++ -M +PIC := -fPIC + +RPCGENFLAGS := -M -C -N + +ETAGS := etags +CTAGS := ctags + +### +# +# Flags +# +CCFLAGS_WARNINGS = -Wno-long-long -Wall #-pedantic +# Add these for more warnings -Weffc++ -W +CCFLAGS_TOP = -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS +CCFLAGS_TOP += -fno-rtti + +ifeq (RELEASE, $(NDB_VERSION)) +VERSION_FLAGS += -O3 +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +VERSION_FLAGS += -O3 -g +else +VERSION_FLAGS += -g +endif +endif + +CCFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) +CFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) + +LDFLAGS_TOP = -lpthread -lrt + +LDFLAGS = $(LDFLAGS_LOC) $(LDFLAGS_TOP) + +LDLIBS = $(LDLIBS_LOC) $(LDLIBS_TOP) + +LINK.cc = $(PURE) $(C++) $(CCFLAGS) $(LDFLAGS) + +LINK.c = $(PURE) $(CC) $(CFLAGS) $(LDFLAGS) diff --git a/ndb/config/Defs.WIN32.x86.VC7.mk b/ndb/config/Defs.WIN32.x86.VC7.mk new file mode 100644 index 00000000000..e66dacb78e7 --- /dev/null +++ b/ndb/config/Defs.WIN32.x86.VC7.mk @@ -0,0 +1,61 @@ +### +# +# Defines +SHELL := /bin/sh + + +DEFINES = -D_WIN32 -D_M_IX86=600 -D_MSC_EXTENSIONS=0 -U_cdecl -D_MT +# +MAKEDEPEND = g++ -M --nostdinc --nostdinc++ -I"`cygpath -u "$(MSVCDIR)\include"`" -I"`cygpath -u "$(MSVCDIR)\PlatformSDK\include"`" $(DEFINES) +PIC = -D_LIB +NON_PIC = -D_LIB + +RPCGENFLAGS := -M -C -N + +ETAGS := etags +CTAGS := ctags + +### +# +# Flags +# +CCFLAGS_WARNINGS = +CCFLAGS_TOP = +CCFLAGS_LOC = +CCFLAGS_WIN = -DWIN32 -D_WIN32_WINNT=0x0500 -DWINVER=0x0500 -D_MBCS -DNO_COMMAND_HANDLER +CCFLAGS_WIN += -W3 -EHsc +#CCFLAGS_WIN += -clr + +ifeq (RELEASE, $(NDB_VERSION)) +CCFLAGS_WIN += -MT -O2 -Ob1 -DNO_DEBUG_MESSAGES +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +CCFLAGS_WIN += -MT -O2 -Ob1 -DNO_DEBUG_MESSAGES +else +CCFLAGS_WIN += -MTd -Zi -Od -GS -D_DEBUG +endif +endif + +C++ = cl -nologo $(CCFLAGS_WIN) +CC = cl -nologo $(CCFLAGS_WIN) + +CCFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) +CFLAGS = $(CCFLAGS_LOC) $(CCFLAGS_TOP) $(USER_FLAGS) $(VERSION_FLAGS) $(CCFLAGS_WARNINGS) + +LDFLAGS_TOP = + +LDFLAGS = $(LDFLAGS_LOC) $(LDFLAGS_TOP) + +LDLIBS = $(LDLIBS_LOC) $(LDLIBS_TOP) + +WIN_LIBS := Ws2_32.lib Advapi32.lib + +ifeq (RELEASE, $(NDB_VERSION)) +LINK.cc = link -INCREMENTAL:NO -NOLOGO -LARGEADDRESSAWARE $(WIN_LIBS) +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +LINK.cc = link -INCREMENTAL:NO -NOLOGO -LARGEADDRESSAWARE $(WIN_LIBS) +else +LINK.cc = link -INCREMENTAL -NOLOGO -DEBUG -LARGEADDRESSAWARE $(WIN_LIBS) +endif +endif diff --git a/ndb/config/GuessConfig.sh b/ndb/config/GuessConfig.sh new file mode 100755 index 00000000000..a1ecdecfa93 --- /dev/null +++ b/ndb/config/GuessConfig.sh @@ -0,0 +1,113 @@ +#! /bin/sh + +if [ -z "$NDB_TOP" ] +then + echo "You have not set NDB_TOP. Exiting" 1>&2 + exit 1 +fi + +if [ -z "$NDB_SCI" ] +then + NDB_SCI=N +fi + +os=`uname -s` +case $os in +Linux) + NDB_OS=LINUX + NDB_ARCH=x86 + NDB_COMPILER=GCC + ;; +Darwin) + NDB_OS=MACOSX + NDB_ARCH=POWERPC + NDB_COMPILER=GCC + ;; +HP-UX) + NDB_OS=HPUX + NDB_ARCH=HPPA + NDB_COMPILER=GCC + ;; +CYGWIN_NT-5.0) + NDB_OS=WIN32 + NDB_ARCH=x86 + NDB_COMPILER=VC7 + ;; +*) + if [ "$os" = "SunOS" ] && [ `uname -r` = "5.6" ] + then + NDB_OS=OSE + NDB_ARCH=PPC750 + NDB_COMPILER=DIAB + else + NDB_OS=SOLARIS + NDB_ARCH=SPARC + NDB_COMPILER=GCC + fi;; +esac + +if [ -z "$NDB_ODBC" ] +then + val=N + if [ -f /usr/include/sqlext.h -o -f /usr/local/include/sqlext.h ] + then + val=Y + fi + case $NDB_OS in + LINUX) + NDB_ODBC=$val + ;; + MACOSX) + NDB_ODBC=$val + ;; + *) + NDB_ODBC=N + ;; + esac +fi + + +mch=`uname -m` +case $mch in +x86_64) + NDB_ARCH=x86_64 + ;; +*) + ;; +esac + +if [ -f $NDB_TOP/config/Makefile ] +then +TERMCAP_LIB=`grep TERMCAP_LIB $NDB_TOP/config/Makefile | sed -e s,"TERMCAP_LIB.*=.*-l","",g` +fi +if [ "$TERMCAP_LIB" = "" ] +then +TERMCAP_LIB=termcap +fi + +# Allow for selecting GCC, but must be 2nd parameter +if [ $# -gt 1 -a "$2" = "-GCC" ] +then + NDB_COMPILER=GCC +fi + +( + echo "# This file was automatically generated `date`" + echo "NDB_OS := $NDB_OS" + echo "NDB_ARCH := $NDB_ARCH" + echo "NDB_COMPILER := $NDB_COMPILER" + + if [ $# -gt 0 -a "$1" = "-R" ] + then + echo "NDB_VERSION := RELEASE" + else + echo "NDB_VERSION := DEBUG" + fi + + echo "NDB_SCI := $NDB_SCI" + echo "NDB_ODBC := $NDB_ODBC" + echo "TERMCAP_LIB := $TERMCAP_LIB" +) > $NDB_TOP/config/config.mk + +exit 0 + diff --git a/ndb/config/Makefile.am b/ndb/config/Makefile.am new file mode 100644 index 00000000000..b5fd81814a1 --- /dev/null +++ b/ndb/config/Makefile.am @@ -0,0 +1,31 @@ +# Copyright (C) 2003 MySQL AB +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +# Process this file with automake to create Makefile.in + +AUTOMAKE_OPTIONS = foreign + +# These are built from source in the Docs directory +EXTRA_DIST = +SUBDIRS = + +# Relink after clean +linked_sources = + +CLEANFILES = $(linked_sources) + +# This is just so that the linking is done early. +config.h: diff --git a/ndb/config/acinclude.m4 b/ndb/config/acinclude.m4 new file mode 100644 index 00000000000..b9edaf801ed --- /dev/null +++ b/ndb/config/acinclude.m4 @@ -0,0 +1,1513 @@ +# Local macros for automake & autoconf + +AC_DEFUN(MYSQL_CHECK_LIBEDIT_INTERFACE,[ + AC_CACHE_CHECK([libedit variant of rl_completion_entry_function], mysql_cv_libedit_interface, + AC_TRY_COMPILE( + [ + #include "stdio.h" + #include "readline/readline.h" + ], + [ + char res= *(*rl_completion_entry_function)(0,0); + completion_matches(0,0); + ], + [ + mysql_cv_libedit_interface=yes + AC_DEFINE_UNQUOTED(USE_LIBEDIT_INTERFACE) + ], + [mysql_cv_libedit_interface=no] + ) + ) +]) + +AC_DEFUN(MYSQL_CHECK_NEW_RL_INTERFACE,[ + AC_CACHE_CHECK([defined rl_compentry_func_t and rl_completion_func_t], mysql_cv_new_rl_interface, + AC_TRY_COMPILE( + [ + #include "stdio.h" + #include "readline/readline.h" + ], + [ + rl_completion_func_t *func1= (rl_completion_func_t*)0; + rl_compentry_func_t *func2= (rl_compentry_func_t*)0; + ], + [ + mysql_cv_new_rl_interface=yes + AC_DEFINE_UNQUOTED(USE_NEW_READLINE_INTERFACE) + ], + [mysql_cv_new_rl_interface=no] + ) + ) +]) + +# A local version of AC_CHECK_SIZEOF that includes sys/types.h +dnl MYSQL_CHECK_SIZEOF(TYPE [, CROSS-SIZE]) +AC_DEFUN(MYSQL_CHECK_SIZEOF, +[changequote(<<, >>)dnl +dnl The name to #define. +define(<>, translit(sizeof_$1, [a-z *], [A-Z_P]))dnl +dnl The cache variable name. +define(<>, translit(ac_cv_sizeof_$1, [ *], [_p]))dnl +changequote([, ])dnl +AC_MSG_CHECKING(size of $1) +AC_CACHE_VAL(AC_CV_NAME, +[AC_TRY_RUN([#include +#include +#if STDC_HEADERS +#include +#include +#endif +main() +{ + FILE *f=fopen("conftestval", "w"); + if (!f) exit(1); + fprintf(f, "%d\n", sizeof($1)); + exit(0); +}], AC_CV_NAME=`cat conftestval`, AC_CV_NAME=0, ifelse([$2], , , AC_CV_NAME=$2))])dnl +AC_MSG_RESULT($AC_CV_NAME) +AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME) +undefine([AC_TYPE_NAME])dnl +undefine([AC_CV_NAME])dnl +]) + +#---START: Used in for client configure +AC_DEFUN(MYSQL_TYPE_ACCEPT, +[ac_save_CXXFLAGS="$CXXFLAGS" +AC_CACHE_CHECK([base type of last arg to accept], mysql_cv_btype_last_arg_accept, +AC_LANG_SAVE +AC_LANG_CPLUSPLUS +if test "$ac_cv_prog_gxx" = "yes" +then + CXXFLAGS=`echo $CXXFLAGS -Werror | sed 's/-fbranch-probabilities//'` +fi +mysql_cv_btype_last_arg_accept=none +[AC_TRY_COMPILE([#if defined(inline) +#undef inline +#endif +#include +#include +#include +], +[int a = accept(1, (struct sockaddr *) 0, (socklen_t *) 0); return (a != 0);], +mysql_cv_btype_last_arg_accept=socklen_t)] +if test "$mysql_cv_btype_last_arg_accept" = "none"; then +[AC_TRY_COMPILE([#if defined(inline) +#undef inline +#endif +#include +#include +#include +], +[int a = accept(1, (struct sockaddr *) 0, (size_t *) 0); return (a != 0);], +mysql_cv_btype_last_arg_accept=size_t)] +fi +if test "$mysql_cv_btype_last_arg_accept" = "none"; then +mysql_cv_btype_last_arg_accept=int +fi) +AC_LANG_RESTORE +AC_DEFINE_UNQUOTED(SOCKET_SIZE_TYPE, $mysql_cv_btype_last_arg_accept) +CXXFLAGS="$ac_save_CXXFLAGS" +]) +#---END: + +dnl Find type of qsort +AC_DEFUN(MYSQL_TYPE_QSORT, +[AC_CACHE_CHECK([return type of qsort], mysql_cv_type_qsort, +[AC_TRY_COMPILE([#include +#ifdef __cplusplus +extern "C" +#endif +void qsort(void *base, size_t nel, size_t width, + int (*compar) (const void *, const void *)); +], +[int i;], mysql_cv_type_qsort=void, mysql_cv_type_qsort=int)]) +AC_DEFINE_UNQUOTED(RETQSORTTYPE, $mysql_cv_type_qsort) +if test "$mysql_cv_type_qsort" = "void" +then + AC_DEFINE_UNQUOTED(QSORT_TYPE_IS_VOID, 1) +fi +]) + +AC_DEFUN(MYSQL_TIMESPEC_TS, +[AC_CACHE_CHECK([if struct timespec has a ts_sec member], mysql_cv_timespec_ts, +[AC_TRY_COMPILE([#include +#ifdef __cplusplus +extern "C" +#endif +], +[struct timespec abstime; + +abstime.ts_sec = time(NULL)+1; +abstime.ts_nsec = 0; +], mysql_cv_timespec_ts=yes, mysql_cv_timespec_ts=no)]) +if test "$mysql_cv_timespec_ts" = "yes" +then + AC_DEFINE(HAVE_TIMESPEC_TS_SEC) +fi +]) + +AC_DEFUN(MYSQL_TZNAME, +[AC_CACHE_CHECK([if we have tzname variable], mysql_cv_tzname, +[AC_TRY_COMPILE([#include +#ifdef __cplusplus +extern "C" +#endif +], +[ tzset(); + return tzname[0] != 0; +], mysql_cv_tzname=yes, mysql_cv_tzname=no)]) +if test "$mysql_cv_tzname" = "yes" +then + AC_DEFINE(HAVE_TZNAME) +fi +]) + +AC_DEFUN(MYSQL_CHECK_ZLIB_WITH_COMPRESS, [ +save_LIBS="$LIBS" +LIBS="-l$1 $LIBS" +AC_CACHE_CHECK([if libz with compress], mysql_cv_compress, +[AC_TRY_RUN([#include +#ifdef __cplusplus +extern "C" +#endif +int main(int argv, char **argc) +{ + return 0; +} + +int link_test() +{ + return compress(0, (unsigned long*) 0, "", 0); +} +], mysql_cv_compress=yes, mysql_cv_compress=no)]) +if test "$mysql_cv_compress" = "yes" +then + AC_DEFINE(HAVE_COMPRESS) +else + LIBS="$save_LIBS" +fi +]) + +#---START: Used in for client configure +AC_DEFUN(MYSQL_CHECK_ULONG, +[AC_MSG_CHECKING(for type ulong) +AC_CACHE_VAL(ac_cv_ulong, +[AC_TRY_RUN([#include +#include +main() +{ + ulong foo; + foo++; + exit(0); +}], ac_cv_ulong=yes, ac_cv_ulong=no, ac_cv_ulong=no)]) +AC_MSG_RESULT($ac_cv_ulong) +if test "$ac_cv_ulong" = "yes" +then + AC_DEFINE(HAVE_ULONG) +fi +]) + +AC_DEFUN(MYSQL_CHECK_UCHAR, +[AC_MSG_CHECKING(for type uchar) +AC_CACHE_VAL(ac_cv_uchar, +[AC_TRY_RUN([#include +#include +main() +{ + uchar foo; + foo++; + exit(0); +}], ac_cv_uchar=yes, ac_cv_uchar=no, ac_cv_uchar=no)]) +AC_MSG_RESULT($ac_cv_uchar) +if test "$ac_cv_uchar" = "yes" +then + AC_DEFINE(HAVE_UCHAR) +fi +]) + +AC_DEFUN(MYSQL_CHECK_UINT, +[AC_MSG_CHECKING(for type uint) +AC_CACHE_VAL(ac_cv_uint, +[AC_TRY_RUN([#include +#include +main() +{ + uint foo; + foo++; + exit(0); +}], ac_cv_uint=yes, ac_cv_uint=no, ac_cv_uint=no)]) +AC_MSG_RESULT($ac_cv_uint) +if test "$ac_cv_uint" = "yes" +then + AC_DEFINE(HAVE_UINT) +fi +]) + + +AC_DEFUN(MYSQL_CHECK_IN_ADDR_T, +[AC_MSG_CHECKING(for type in_addr_t) +AC_CACHE_VAL(ac_cv_in_addr_t, +[AC_TRY_RUN([#include +#include +#include +#include +#include + +int main(int argc, char **argv) +{ + in_addr_t foo; + exit(0); +}], ac_cv_in_addr_t=yes, ac_cv_in_addr_t=no, ac_cv_in_addr_t=no)]) +AC_MSG_RESULT($ac_cv_in_addr_t) +if test "$ac_cv_in_addr_t" = "yes" +then + AC_DEFINE(HAVE_IN_ADDR_T) +fi +]) + + +AC_DEFUN(MYSQL_PTHREAD_YIELD, +[AC_CACHE_CHECK([if pthread_yield takes zero arguments], ac_cv_pthread_yield_zero_arg, +[AC_TRY_LINK([#define _GNU_SOURCE +#include +#ifdef __cplusplus +extern "C" +#endif +], +[ + pthread_yield(); +], ac_cv_pthread_yield_zero_arg=yes, ac_cv_pthread_yield_zero_arg=yeso)]) +if test "$ac_cv_pthread_yield_zero_arg" = "yes" +then + AC_DEFINE(HAVE_PTHREAD_YIELD_ZERO_ARG) +fi +] +[AC_CACHE_CHECK([if pthread_yield takes 1 argument], ac_cv_pthread_yield_one_arg, +[AC_TRY_LINK([#define _GNU_SOURCE +#include +#ifdef __cplusplus +extern "C" +#endif +], +[ + pthread_yield(0); +], ac_cv_pthread_yield_one_arg=yes, ac_cv_pthread_yield_one_arg=no)]) +if test "$ac_cv_pthread_yield_one_arg" = "yes" +then + AC_DEFINE(HAVE_PTHREAD_YIELD_ONE_ARG) +fi +] +) + + + +#---END: + +AC_DEFUN(MYSQL_CHECK_FP_EXCEPT, +[AC_MSG_CHECKING(for type fp_except) +AC_CACHE_VAL(ac_cv_fp_except, +[AC_TRY_RUN([#include +#include +#include +main() +{ + fp_except foo; + foo++; + exit(0); +}], ac_cv_fp_except=yes, ac_cv_fp_except=no, ac_cv_fp_except=no)]) +AC_MSG_RESULT($ac_cv_fp_except) +if test "$ac_cv_fp_except" = "yes" +then + AC_DEFINE(HAVE_FP_EXCEPT) +fi +]) + +# From fileutils-3.14/aclocal.m4 + +# @defmac AC_PROG_CC_STDC +# @maindex PROG_CC_STDC +# @ovindex CC +# If the C compiler in not in ANSI C mode by default, try to add an option +# to output variable @code{CC} to make it so. This macro tries various +# options that select ANSI C on some system or another. It considers the +# compiler to be in ANSI C mode if it defines @code{__STDC__} to 1 and +# handles function prototypes correctly. +# +# Patched by monty to only check if __STDC__ is defined. With the original +# check it's impossible to get things to work with the Sunpro compiler from +# Workshop 4.2 +# +# If you use this macro, you should check after calling it whether the C +# compiler has been set to accept ANSI C; if not, the shell variable +# @code{am_cv_prog_cc_stdc} is set to @samp{no}. If you wrote your source +# code in ANSI C, you can make an un-ANSIfied copy of it by using the +# program @code{ansi2knr}, which comes with Ghostscript. +# @end defmac + +AC_DEFUN(AM_PROG_CC_STDC, +[AC_REQUIRE([AC_PROG_CC]) +AC_MSG_CHECKING(for ${CC-cc} option to accept ANSI C) +AC_CACHE_VAL(am_cv_prog_cc_stdc, +[am_cv_prog_cc_stdc=no +ac_save_CC="$CC" +# Don't try gcc -ansi; that turns off useful extensions and +# breaks some systems' header files. +# AIX -qlanglvl=ansi +# Ultrix and OSF/1 -std1 +# HP-UX -Aa -D_HPUX_SOURCE +# SVR4 -Xc -D__EXTENSIONS__ +# removed "-Xc -D__EXTENSIONS__" beacause sun c++ does not like it. +for ac_arg in "" -qlanglvl=ansi -std1 "-Aa -D_HPUX_SOURCE" +do + CC="$ac_save_CC $ac_arg" + AC_TRY_COMPILE( +[#if !defined(__STDC__) +choke me +#endif +/* DYNIX/ptx V4.1.3 can't compile sys/stat.h with -Xc -D__EXTENSIONS__. */ +#ifdef _SEQUENT_ +# include +# include +#endif +], [ +int test (int i, double x); +struct s1 {int (*f) (int a);}; +struct s2 {int (*f) (double a);};], +[am_cv_prog_cc_stdc="$ac_arg"; break]) +done +CC="$ac_save_CC" +]) +AC_MSG_RESULT($am_cv_prog_cc_stdc) +case "x$am_cv_prog_cc_stdc" in + x|xno) ;; + *) CC="$CC $am_cv_prog_cc_stdc" ;; +esac +]) + +# +# Check to make sure that the build environment is sane. +# + +AC_DEFUN(AM_SANITY_CHECK, +[AC_MSG_CHECKING([whether build environment is sane]) +sleep 1 +echo timestamp > conftestfile +# Do this in a subshell so we don't clobber the current shell's +# arguments. FIXME: maybe try `-L' hack like GETLOADAVG test? +if (set X `ls -t $srcdir/configure conftestfile`; test "[$]2" = conftestfile) +then + # Ok. + : +else + AC_MSG_ERROR([newly created file is older than distributed files! +Check your system clock]) +fi +rm -f conftest* +AC_MSG_RESULT(yes)]) + +# Orginal from bash-2.0 aclocal.m4, Changed to use termcap last by monty. + +AC_DEFUN(MYSQL_CHECK_LIB_TERMCAP, +[ +AC_CACHE_VAL(mysql_cv_termcap_lib, +[AC_CHECK_LIB(ncurses, tgetent, mysql_cv_termcap_lib=libncurses, + [AC_CHECK_LIB(curses, tgetent, mysql_cv_termcap_lib=libcurses, + [AC_CHECK_LIB(termcap, tgetent, mysql_cv_termcap_lib=libtermcap, + mysql_cv_termcap_lib=NOT_FOUND)])])]) +AC_MSG_CHECKING(for termcap functions library) +if test "$mysql_cv_termcap_lib" = "NOT_FOUND"; then +AC_MSG_ERROR([No curses/termcap library found]) +elif test "$mysql_cv_termcap_lib" = "libtermcap"; then +TERMCAP_LIB=-ltermcap +elif test "$mysql_cv_termcap_lib" = "libncurses"; then +TERMCAP_LIB=-lncurses +else +TERMCAP_LIB=-lcurses +fi +AC_MSG_RESULT($TERMCAP_LIB) +]) + +dnl Check type of signal routines (posix, 4.2bsd, 4.1bsd or v7) +AC_DEFUN(MYSQL_SIGNAL_CHECK, +[AC_REQUIRE([AC_TYPE_SIGNAL]) +AC_MSG_CHECKING(for type of signal functions) +AC_CACHE_VAL(mysql_cv_signal_vintage, +[ + AC_TRY_LINK([#include ],[ + sigset_t ss; + struct sigaction sa; + sigemptyset(&ss); sigsuspend(&ss); + sigaction(SIGINT, &sa, (struct sigaction *) 0); + sigprocmask(SIG_BLOCK, &ss, (sigset_t *) 0); + ], mysql_cv_signal_vintage=posix, + [ + AC_TRY_LINK([#include ], [ + int mask = sigmask(SIGINT); + sigsetmask(mask); sigblock(mask); sigpause(mask); + ], mysql_cv_signal_vintage=4.2bsd, + [ + AC_TRY_LINK([ + #include + RETSIGTYPE foo() { }], [ + int mask = sigmask(SIGINT); + sigset(SIGINT, foo); sigrelse(SIGINT); + sighold(SIGINT); sigpause(SIGINT); + ], mysql_cv_signal_vintage=svr3, mysql_cv_signal_vintage=v7 + )] + )] +) +]) +AC_MSG_RESULT($mysql_cv_signal_vintage) +if test "$mysql_cv_signal_vintage" = posix; then +AC_DEFINE(HAVE_POSIX_SIGNALS) +elif test "$mysql_cv_signal_vintage" = "4.2bsd"; then +AC_DEFINE(HAVE_BSD_SIGNALS) +elif test "$mysql_cv_signal_vintage" = svr3; then +AC_DEFINE(HAVE_USG_SIGHOLD) +fi +]) + +AC_DEFUN(MYSQL_CHECK_GETPW_FUNCS, +[AC_MSG_CHECKING(whether programs are able to redeclare getpw functions) +AC_CACHE_VAL(mysql_cv_can_redecl_getpw, +[AC_TRY_COMPILE([#include +#include +extern struct passwd *getpwent();], [struct passwd *z; z = getpwent();], + mysql_cv_can_redecl_getpw=yes,mysql_cv_can_redecl_getpw=no)]) +AC_MSG_RESULT($mysql_cv_can_redecl_getpw) +if test "$mysql_cv_can_redecl_getpw" = "no"; then +AC_DEFINE(HAVE_GETPW_DECLS) +fi +]) + +AC_DEFUN(MYSQL_HAVE_TIOCGWINSZ, +[AC_MSG_CHECKING(for TIOCGWINSZ in sys/ioctl.h) +AC_CACHE_VAL(mysql_cv_tiocgwinsz_in_ioctl, +[AC_TRY_COMPILE([#include +#include ], [int x = TIOCGWINSZ;], + mysql_cv_tiocgwinsz_in_ioctl=yes,mysql_cv_tiocgwinsz_in_ioctl=no)]) +AC_MSG_RESULT($mysql_cv_tiocgwinsz_in_ioctl) +if test "$mysql_cv_tiocgwinsz_in_ioctl" = "yes"; then +AC_DEFINE(GWINSZ_IN_SYS_IOCTL) +fi +]) + +AC_DEFUN(MYSQL_HAVE_FIONREAD, +[AC_MSG_CHECKING(for FIONREAD in sys/ioctl.h) +AC_CACHE_VAL(mysql_cv_fionread_in_ioctl, +[AC_TRY_COMPILE([#include +#include ], [int x = FIONREAD;], + mysql_cv_fionread_in_ioctl=yes,mysql_cv_fionread_in_ioctl=no)]) +AC_MSG_RESULT($mysql_cv_fionread_in_ioctl) +if test "$mysql_cv_fionread_in_ioctl" = "yes"; then +AC_DEFINE(FIONREAD_IN_SYS_IOCTL) +fi +]) + +AC_DEFUN(MYSQL_HAVE_TIOCSTAT, +[AC_MSG_CHECKING(for TIOCSTAT in sys/ioctl.h) +AC_CACHE_VAL(mysql_cv_tiocstat_in_ioctl, +[AC_TRY_COMPILE([#include +#include ], [int x = TIOCSTAT;], + mysql_cv_tiocstat_in_ioctl=yes,mysql_cv_tiocstat_in_ioctl=no)]) +AC_MSG_RESULT($mysql_cv_tiocstat_in_ioctl) +if test "$mysql_cv_tiocstat_in_ioctl" = "yes"; then +AC_DEFINE(TIOCSTAT_IN_SYS_IOCTL) +fi +]) + +AC_DEFUN(MYSQL_STRUCT_DIRENT_D_INO, +[AC_REQUIRE([AC_HEADER_DIRENT]) +AC_MSG_CHECKING(if struct dirent has a d_ino member) +AC_CACHE_VAL(mysql_cv_dirent_has_dino, +[AC_TRY_COMPILE([ +#include +#include +#ifdef HAVE_UNISTD_H +# include +#endif /* HAVE_UNISTD_H */ +#if defined(HAVE_DIRENT_H) +# include +#else +# define dirent direct +# ifdef HAVE_SYS_NDIR_H +# include +# endif /* SYSNDIR */ +# ifdef HAVE_SYS_DIR_H +# include +# endif /* SYSDIR */ +# ifdef HAVE_NDIR_H +# include +# endif +#endif /* HAVE_DIRENT_H */ +],[ +struct dirent d; int z; z = d.d_ino; +], mysql_cv_dirent_has_dino=yes, mysql_cv_dirent_has_dino=no)]) +AC_MSG_RESULT($mysql_cv_dirent_has_dino) +if test "$mysql_cv_dirent_has_dino" = "yes"; then +AC_DEFINE(STRUCT_DIRENT_HAS_D_INO) +fi +]) + +AC_DEFUN(MYSQL_TYPE_SIGHANDLER, +[AC_MSG_CHECKING([whether signal handlers are of type void]) +AC_CACHE_VAL(mysql_cv_void_sighandler, +[AC_TRY_COMPILE([#include +#include +#ifdef signal +#undef signal +#endif +#ifdef __cplusplus +extern "C" +#endif +void (*signal ()) ();], +[int i;], mysql_cv_void_sighandler=yes, mysql_cv_void_sighandler=no)])dnl +AC_MSG_RESULT($mysql_cv_void_sighandler) +if test "$mysql_cv_void_sighandler" = "yes"; then +AC_DEFINE(VOID_SIGHANDLER) +fi +]) + +AC_DEFUN(MYSQL_CXX_BOOL, +[ +AC_REQUIRE([AC_PROG_CXX]) +AC_MSG_CHECKING(if ${CXX} supports bool types) +AC_CACHE_VAL(mysql_cv_have_bool, +[ +AC_LANG_SAVE +AC_LANG_CPLUSPLUS +AC_TRY_COMPILE(,[bool b = true;], +mysql_cv_have_bool=yes, +mysql_cv_have_bool=no) +AC_LANG_RESTORE +]) +AC_MSG_RESULT($mysql_cv_have_bool) +if test "$mysql_cv_have_bool" = yes; then +AC_DEFINE(HAVE_BOOL) +fi +])dnl + +AC_DEFUN(MYSQL_STACK_DIRECTION, + [AC_CACHE_CHECK(stack direction for C alloca, ac_cv_c_stack_direction, + [AC_TRY_RUN([#include + int find_stack_direction () + { + static char *addr = 0; + auto char dummy; + if (addr == 0) + { + addr = &dummy; + return find_stack_direction (); + } + else + return (&dummy > addr) ? 1 : -1; + } + int main () + { + exit (find_stack_direction() < 0); + }], ac_cv_c_stack_direction=1, ac_cv_c_stack_direction=-1, + ac_cv_c_stack_direction=0)]) + AC_DEFINE_UNQUOTED(STACK_DIRECTION, $ac_cv_c_stack_direction) +])dnl + +AC_DEFUN(MYSQL_FUNC_ALLOCA, +[ +# Since we have heard that alloca fails on IRIX never define it on a +# SGI machine +if test ! "$host_vendor" = "sgi" +then + AC_REQUIRE_CPP()dnl Set CPP; we run AC_EGREP_CPP conditionally. + # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works + # for constant arguments. Useless! + AC_CACHE_CHECK([for working alloca.h], ac_cv_header_alloca_h, + [AC_TRY_LINK([#include ], [char *p = alloca(2 * sizeof(int));], + ac_cv_header_alloca_h=yes, ac_cv_header_alloca_h=no)]) + if test "$ac_cv_header_alloca_h" = "yes" + then + AC_DEFINE(HAVE_ALLOCA) + fi + + AC_CACHE_CHECK([for alloca], ac_cv_func_alloca_works, + [AC_TRY_LINK([ + #ifdef __GNUC__ + # define alloca __builtin_alloca + #else + # if HAVE_ALLOCA_H + # include + # else + # ifdef _AIX + #pragma alloca + # else + # ifndef alloca /* predefined by HP cc +Olibcalls */ + char *alloca (); + # endif + # endif + # endif + #endif + ], [char *p = (char *) alloca(1);], + ac_cv_func_alloca_works=yes, ac_cv_func_alloca_works=no)]) + if test "$ac_cv_func_alloca_works" = "yes"; then + AC_DEFINE(HAVE_ALLOCA) + fi + + if test "$ac_cv_func_alloca_works" = "no"; then + # The SVR3 libPW and SVR4 libucb both contain incompatible functions + # that cause trouble. Some versions do not even contain alloca or + # contain a buggy version. If you still want to use their alloca, + # use ar to extract alloca.o from them instead of compiling alloca.c. + ALLOCA=alloca.o + AC_DEFINE(C_ALLOCA) + + AC_CACHE_CHECK(whether alloca needs Cray hooks, ac_cv_os_cray, + [AC_EGREP_CPP(webecray, + [#if defined(CRAY) && ! defined(CRAY2) + webecray + #else + wenotbecray + #endif + ], ac_cv_os_cray=yes, ac_cv_os_cray=no)]) + if test "$ac_cv_os_cray" = "yes"; then + for ac_func in _getb67 GETB67 getb67; do + AC_CHECK_FUNC($ac_func, [AC_DEFINE_UNQUOTED(CRAY_STACKSEG_END, $ac_func) + break]) + done + fi + fi + AC_SUBST(ALLOCA)dnl +else + AC_MSG_RESULT("Skipped alloca tests") +fi +]) + +AC_DEFUN(MYSQL_CHECK_LONGLONG_TO_FLOAT, +[ +AC_MSG_CHECKING(if conversion of longlong to float works) +AC_CACHE_VAL(ac_cv_conv_longlong_to_float, +[AC_TRY_RUN([#include +typedef long long longlong; +main() +{ + longlong ll=1; + float f; + FILE *file=fopen("conftestval", "w"); + f = (float) ll; + fprintf(file,"%g\n",f); + fclose(file); + exit (0); +}], ac_cv_conv_longlong_to_float=`cat conftestval`, ac_cv_conv_longlong_to_float=0, ifelse([$2], , , ac_cv_conv_longlong_to_float=$2))])dnl +if test "$ac_cv_conv_longlong_to_float" = "1" -o "$ac_cv_conv_longlong_to_float" = "yes" +then + ac_cv_conv_longlong_to_float=yes +else + ac_cv_conv_longlong_to_float=no +fi +AC_MSG_RESULT($ac_cv_conv_longlong_to_float) +]) + +AC_DEFUN(MYSQL_CHECK_CPU, +[AC_CACHE_CHECK([if compiler supports optimizations for current cpu], +mysql_cv_cpu,[ + +ac_save_CFLAGS="$CFLAGS" +if test -r /proc/cpuinfo ; then + cpuinfo="cat /proc/cpuinfo" + cpu_family=`$cpuinfo | grep 'cpu family' | cut -d ':' -f 2 | cut -d ' ' -f 2 | head -1` + cpu_vendor=`$cpuinfo | grep 'vendor_id' | cut -d ':' -f 2 | cut -d ' ' -f 2 | head -1` +fi +if test "$cpu_vendor" = "AuthenticAMD"; then + if test $cpu_family -ge 6; then + cpu_set="athlon pentiumpro k5 pentium i486 i386"; + elif test $cpu_family -eq 5; then + cpu_set="k5 pentium i486 i386"; + elif test $cpu_family -eq 4; then + cpu_set="i486 i386" + else + cpu_set="i386" + fi +elif test "$cpu_vendor" = "GenuineIntel"; then + if test $cpu_family -ge 6; then + cpu_set="pentiumpro pentium i486 i386"; + elif test $cpu_family -eq 5; then + cpu_set="pentium i486 i386"; + elif test $cpu_family -eq 4; then + cpu_set="i486 i386" + else + cpu_set="i386" + fi +fi + +for ac_arg in $cpu_set; +do + CFLAGS="$ac_save_CFLAGS -mcpu=$ac_arg -march=$ac_arg -DCPU=$ac_arg" + AC_TRY_COMPILE([],[int i],mysql_cv_cpu=$ac_arg; break;, mysql_cv_cpu="unknown") +done + +if test "$mysql_cv_cpu" = "unknown" +then + CFLAGS="$ac_save_CFLAGS" + AC_MSG_RESULT(none) +else + AC_MSG_RESULT($mysql_cv_cpu) +fi +]])) + +AC_DEFUN(MYSQL_CHECK_VIO, [ + AC_ARG_WITH([vio], + [ --with-vio Include the Virtual IO support], + [vio="$withval"], + [vio=no]) + + if test "$vio" = "yes" + then + vio_dir="vio" + vio_libs="../vio/libvio.la" + AC_DEFINE(HAVE_VIO) + else + vio_dir="" + vio_libs="" + fi + AC_SUBST([vio_dir]) + AC_SUBST([vio_libs]) +]) + +AC_DEFUN(MYSQL_FIND_OPENSSL, [ + incs="$1" + libs="$2" + case "$incs---$libs" in + ---) + for d in /usr/ssl/include /usr/local/ssl/include /usr/include \ +/usr/include/ssl /opt/ssl/include /opt/openssl/include \ +/usr/local/ssl/include /usr/local/include ; do + if test -f $d/openssl/ssl.h ; then + OPENSSL_INCLUDE=-I$d + fi + done + + for d in /usr/ssl/lib /usr/local/ssl/lib /usr/lib/openssl \ +/usr/lib /usr/lib64 /opt/ssl/lib /opt/openssl/lib /usr/local/lib/ ; do + if test -f $d/libssl.a || test -f $d/libssl.so || test -f $d/libssl.dylib ; then + OPENSSL_LIB=$d + fi + done + ;; + ---* | *---) + AC_MSG_ERROR([if either 'includes' or 'libs' is specified, both must be specified]) + ;; + * ) + if test -f $incs/openssl/ssl.h ; then + OPENSSL_INCLUDE=-I$incs + fi + if test -f $libs/libssl.a || test -f $libs/libssl.so || test -f $libs/libssl.dylib ; then + OPENSSL_LIB=$libs + fi + ;; + esac + + # On RedHat 9 we need kerberos to compile openssl + for d in /usr/kerberos/include + do + if test -f $d/krb5.h ; then + OPENSSL_KERBEROS_INCLUDE="$d" + fi + done + + + if test -z "$OPENSSL_LIB" -o -z "$OPENSSL_INCLUDE" ; then + echo "Could not find an installation of OpenSSL" + if test -n "$OPENSSL_LIB" ; then + if test "$IS_LINUX" = "true"; then + echo "Looks like you've forgotten to install OpenSSL development RPM" + fi + fi + exit 1 + fi + +]) + +AC_DEFUN(MYSQL_CHECK_OPENSSL, [ +AC_MSG_CHECKING(for OpenSSL) + AC_ARG_WITH([openssl], + [ --with-openssl Include the OpenSSL support], + [openssl="$withval"], + [openssl=no]) + + AC_ARG_WITH([openssl-includes], + [ + --with-openssl-includes=DIR + Find OpenSSL headers in DIR], + [openssl_includes="$withval"], + [openssl_includes=""]) + + AC_ARG_WITH([openssl-libs], + [ + --with-openssl-libs=DIR + Find OpenSSL libraries in DIR], + [openssl_libs="$withval"], + [openssl_libs=""]) + + if test "$openssl" = "yes" + then + MYSQL_FIND_OPENSSL([$openssl_includes], [$openssl_libs]) + #force VIO use + vio_dir="vio" + vio_libs="../vio/libvio.la" + AC_DEFINE(HAVE_VIO) + AC_MSG_RESULT(yes) + openssl_libs="-L$OPENSSL_LIB -lssl -lcrypto" + # Don't set openssl_includes to /usr/include as this gives us a lot of + # compiler warnings when using gcc 3.x + openssl_includes="" + if test "$OPENSSL_INCLUDE" != "-I/usr/include" + then + openssl_includes="$OPENSSL_INCLUDE" + fi + if test "$OPENSSL_KERBEROS_INCLUDE" + then + openssl_includes="$openssl_includes -I$OPENSSL_KERBEROS_INCLUDE" + fi + AC_DEFINE(HAVE_OPENSSL) + + # openssl-devel-0.9.6 requires dlopen() and we can't link staticly + # on many platforms (We should actually test this here, but it's quite + # hard) to do as we are doing libtool for linking. + using_static="" + case "$CLIENT_EXTRA_LDFLAGS $MYSQLD_EXTRA_LDFLAGS" in + *-all-static*) using_static="yes" ;; + esac + if test "$using_static" = "yes" + then + echo "You can't use the --all-static link option when using openssl." + exit 1 + fi + NON_THREADED_CLIENT_LIBS="$NON_THREADED_CLIENT_LIBS $openssl_libs" + else + AC_MSG_RESULT(no) + fi + AC_SUBST(openssl_libs) + AC_SUBST(openssl_includes) +]) + + +AC_DEFUN(MYSQL_CHECK_MYSQLFS, [ + AC_ARG_WITH([mysqlfs], + [ + --with-mysqlfs Include the corba-based MySQL file system], + [mysqlfs="$withval"], + [mysqlfs=no]) + +dnl Call MYSQL_CHECK_ORBIT even if mysqlfs == no, so that @orbit_*@ +dnl get substituted. + MYSQL_CHECK_ORBIT + + AC_MSG_CHECKING(if we should build MySQLFS) + fs_dirs="" + if test "$mysqlfs" = "yes" + then + if test -n "$orbit_exec_prefix" + then + fs_dirs=fs + AC_MSG_RESULT([yes]) + else + AC_MSG_RESULT(disabled because ORBIT, the CORBA ORB, was not found) + fi + else + AC_MSG_RESULT([no]) + fi + AC_SUBST([fs_dirs]) +]) + +AC_DEFUN(MYSQL_CHECK_ORBIT, [ +AC_MSG_CHECKING(for ORBit) +orbit_config_path=`which orbit-config` +if test -n "$orbit_config_path" -a $? = 0 +then + orbit_exec_prefix=`orbit-config --exec-prefix` + orbit_includes=`orbit-config --cflags server` + orbit_libs=`orbit-config --libs server` + orbit_idl="$orbit_exec_prefix/bin/orbit-idl" + AC_MSG_RESULT(found!) + AC_DEFINE(HAVE_ORBIT) +else + orbit_exec_prefix= + orbit_includes= + orbit_libs= + orbit_idl= + AC_MSG_RESULT(not found) +fi +AC_SUBST(orbit_includes) +AC_SUBST(orbit_libs) +AC_SUBST(orbit_idl) +]) + +AC_DEFUN([MYSQL_CHECK_ISAM], [ + AC_ARG_WITH([isam], [ + --with-isam Enable the ISAM table type], + [with_isam="$withval"], + [with_isam=no]) + + isam_libs= + if test X"$with_isam" = X"yes" + then + AC_DEFINE(HAVE_ISAM) + isam_libs="\$(top_builddir)/isam/libnisam.a\ + \$(top_builddir)/merge/libmerge.a" + fi + AC_SUBST(isam_libs) +]) + + +dnl --------------------------------------------------------------------------- +dnl Macro: MYSQL_CHECK_BDB +dnl Sets HAVE_BERKELEY_DB if inst library is found +dnl Makes sure db version is correct. +dnl Looks in $srcdir for Berkeley distribution if not told otherwise +dnl --------------------------------------------------------------------------- + +AC_DEFUN([MYSQL_CHECK_BDB], [ + AC_ARG_WITH([berkeley-db], + [ + --with-berkeley-db[=DIR] + Use BerkeleyDB located in DIR], + [bdb="$withval"], + [bdb=no]) + + AC_ARG_WITH([berkeley-db-includes], + [ + --with-berkeley-db-includes=DIR + Find Berkeley DB headers in DIR], + [bdb_includes="$withval"], + [bdb_includes=default]) + + AC_ARG_WITH([berkeley-db-libs], + [ + --with-berkeley-db-libs=DIR + Find Berkeley DB libraries in DIR], + [bdb_libs="$withval"], + [bdb_libs=default]) + + AC_MSG_CHECKING([for BerkeleyDB]) + +dnl SORT OUT THE SUPPLIED ARGUMENTS TO DETERMINE WHAT TO DO +dnl echo "DBG1: bdb='$bdb'; incl='$bdb_includes'; lib='$bdb_libs'" + have_berkeley_db=no + case "$bdb" in + no ) + mode=no + AC_MSG_RESULT([no]) + ;; + yes | default ) + case "$bdb_includes---$bdb_libs" in + default---default ) + mode=search-$bdb + AC_MSG_RESULT([searching...]) + ;; + default---* | *---default | yes---* | *---yes ) + AC_MSG_ERROR([if either 'includes' or 'libs' is specified, both must be specified]) + ;; + * ) + mode=supplied-two + AC_MSG_RESULT([supplied]) + ;; + esac + ;; + * ) + mode=supplied-one + AC_MSG_RESULT([supplied]) + ;; + esac + +dnl echo "DBG2: [$mode] bdb='$bdb'; incl='$bdb_includes'; lib='$bdb_libs'" + + case $mode in + no ) + bdb_includes= + bdb_libs= + bdb_libs_with_path= + ;; + supplied-two ) + MYSQL_CHECK_INSTALLED_BDB([$bdb_includes], [$bdb_libs]) + case $bdb_dir_ok in + installed ) mode=yes ;; + * ) AC_MSG_ERROR([didn't find valid BerkeleyDB: $bdb_dir_ok]) ;; + esac + ;; + supplied-one ) + MYSQL_CHECK_BDB_DIR([$bdb]) + case $bdb_dir_ok in + source ) mode=compile ;; + installed ) mode=yes ;; + * ) AC_MSG_ERROR([didn't find valid BerkeleyDB: $bdb_dir_ok]) ;; + esac + ;; + search-* ) + MYSQL_SEARCH_FOR_BDB + case $bdb_dir_ok in + source ) mode=compile ;; + installed ) mode=yes ;; + * ) + # not found + case $mode in + *-yes ) AC_MSG_ERROR([no suitable BerkeleyDB found]) ;; + * ) mode=no ;; + esac + bdb_includes= + bdb_libs= + bdb_libs_with_path= + ;; + esac + ;; + *) + AC_MSG_ERROR([impossible case condition '$mode': please report this to bugs@lists.mysql.com]) + ;; + esac + +dnl echo "DBG3: [$mode] bdb='$bdb'; incl='$bdb_includes'; lib='$bdb_libs'" + case $mode in + no ) + AC_MSG_RESULT([Not using Berkeley DB]) + ;; + yes ) + have_berkeley_db="yes" + AC_MSG_RESULT([Using Berkeley DB in '$bdb_includes']) + ;; + compile ) + have_berkeley_db="$bdb" + AC_MSG_RESULT([Compiling Berekeley DB in '$have_berkeley_db']) + ;; + * ) + AC_MSG_ERROR([impossible case condition '$mode': please report this to bugs@lists.mysql.com]) + ;; + esac + + AC_SUBST(bdb_includes) + AC_SUBST(bdb_libs) + AC_SUBST(bdb_libs_with_path) +]) + +AC_DEFUN([MYSQL_CHECK_INSTALLED_BDB], [ +dnl echo ["MYSQL_CHECK_INSTALLED_BDB ($1) ($2)"] + inc="$1" + lib="$2" + if test -f "$inc/db.h" + then + MYSQL_CHECK_BDB_VERSION([$inc/db.h], + [.*#define[ ]*], [[ ][ ]*]) + + if test X"$bdb_version_ok" = Xyes; then + save_LDFLAGS="$LDFLAGS" + LDFLAGS="-L$lib $LDFLAGS" + AC_CHECK_LIB(db,db_env_create, [ + bdb_dir_ok=installed + MYSQL_TOP_BUILDDIR([inc]) + MYSQL_TOP_BUILDDIR([lib]) + bdb_includes="-I$inc" + bdb_libs="-L$lib -ldb" + bdb_libs_with_path="$lib/libdb.a" + ]) + LDFLAGS="$save_LDFLAGS" + else + bdb_dir_ok="$bdb_version_ok" + fi + else + bdb_dir_ok="no db.h file in '$inc'" + fi +]) + +AC_DEFUN([MYSQL_CHECK_BDB_DIR], [ +dnl ([$bdb]) +dnl echo ["MYSQL_CHECK_BDB_DIR ($1)"] + dir="$1" + + MYSQL_CHECK_INSTALLED_BDB([$dir/include], [$dir/lib]) + + if test X"$bdb_dir_ok" != Xinstalled; then + # test to see if it's a source dir + rel="$dir/dist/RELEASE" + if test -f "$rel"; then + MYSQL_CHECK_BDB_VERSION([$rel], [], [=]) + if test X"$bdb_version_ok" = Xyes; then + bdb_dir_ok=source + bdb="$dir" + MYSQL_TOP_BUILDDIR([dir]) + bdb_includes="-I$dir/build_unix" + bdb_libs="-L$dir/build_unix -ldb" + bdb_libs_with_path="$dir/build_unix/libdb.a" + else + bdb_dir_ok="$bdb_version_ok" + fi + else + bdb_dir_ok="'$dir' doesn't look like a BDB directory ($bdb_dir_ok)" + fi + fi +]) + +AC_DEFUN([MYSQL_SEARCH_FOR_BDB], [ +dnl echo ["MYSQL_SEARCH_FOR_BDB"] + bdb_dir_ok="no BerkeleyDB found" + + for test_dir in $srcdir/bdb $srcdir/db-*.*.* /usr/local/BerkeleyDB*; do +dnl echo "-----------> Looking at ($test_dir; `cd $test_dir && pwd`)" + MYSQL_CHECK_BDB_DIR([$test_dir]) + if test X"$bdb_dir_ok" = Xsource || test X"$bdb_dir_ok" = Xinstalled; then +dnl echo "-----------> Found it ($bdb), ($srcdir)" +dnl This is needed so that 'make distcheck' works properly (VPATH build). +dnl VPATH build won't work if bdb is not under the source tree; but in +dnl that case, hopefully people will just make and install inside the +dnl tree, or install BDB first, and then use the installed version. + case "$bdb" in + "$srcdir/"* ) bdb=`echo "$bdb" | sed -e "s,^$srcdir/,,"` ;; + esac + break + fi + done +]) + +dnl MYSQL_CHECK_BDB_VERSION takes 3 arguments: +dnl 1) the file to look in +dnl 2) the search pattern before DB_VERSION_XXX +dnl 3) the search pattern between DB_VERSION_XXX and the number +dnl It assumes that the number is the last thing on the line +AC_DEFUN([MYSQL_CHECK_BDB_VERSION], [ + db_major=`sed -e '/^[$2]DB_VERSION_MAJOR[$3]/ !d' -e 's///' [$1]` + db_minor=`sed -e '/^[$2]DB_VERSION_MINOR[$3]/ !d' -e 's///' [$1]` + db_patch=`sed -e '/^[$2]DB_VERSION_PATCH[$3]/ !d' -e 's///' [$1]` + test -z "$db_major" && db_major=0 + test -z "$db_minor" && db_minor=0 + test -z "$db_patch" && db_patch=0 + + # This is ugly, but about as good as it can get +# mysql_bdb= +# if test $db_major -eq 3 && test $db_minor -eq 2 && test $db_patch -eq 3 +# then +# mysql_bdb=h +# elif test $db_major -eq 3 && test $db_minor -eq 2 && test $db_patch -eq 9 +# then +# want_bdb_version="3.2.9a" # hopefully this will stay up-to-date +# mysql_bdb=a +# fi + +dnl RAM: +want_bdb_version="4.1.24" +bdb_version_ok=yes + +# if test -n "$mysql_bdb" && \ +# grep "DB_VERSION_STRING.*:.*$mysql_bdb: " [$1] > /dev/null +# then +# bdb_version_ok=yes +# else +# bdb_version_ok="invalid version $db_major.$db_minor.$db_patch" +# bdb_version_ok="$bdb_version_ok (must be version 3.2.3h or $want_bdb_version)" +# fi +]) + +AC_DEFUN([MYSQL_TOP_BUILDDIR], [ + case "$[$1]" in + /* ) ;; # don't do anything with an absolute path + "$srcdir"/* ) + # If BDB is under the source directory, we need to look under the + # build directory for bdb/build_unix. + # NOTE: I'm being lazy, and assuming the user did not specify + # something like --with-berkeley-db=bdb (it would be missing "./"). + [$1]="\$(top_builddir)/"`echo "$[$1]" | sed -e "s,^$srcdir/,,"` + ;; + * ) + AC_MSG_ERROR([The BDB directory must be directly under the MySQL source directory, or be specified using the full path. ('$srcdir'; '$[$1]')]) + ;; + esac + if test X"$[$1]" != "/" + then + [$1]=`echo $[$1] | sed -e 's,/$,,'` + fi +]) + +dnl --------------------------------------------------------------------------- +dnl END OF MYSQL_CHECK_BDB SECTION +dnl --------------------------------------------------------------------------- + +dnl --------------------------------------------------------------------------- +dnl Macro: MYSQL_CHECK_INNODB +dnl Sets HAVE_INNOBASE_DB if --with-innodb is used +dnl --------------------------------------------------------------------------- + +AC_DEFUN([MYSQL_CHECK_INNODB], [ + AC_ARG_WITH([innodb], + [ + --without-innodb Do not include the InnoDB table handler], + [innodb="$withval"], + [innodb=yes]) + + AC_MSG_CHECKING([for Innodb]) + + have_innodb=no + innodb_includes= + innodb_libs= + case "$innodb" in + yes ) + AC_MSG_RESULT([Using Innodb]) + AC_DEFINE(HAVE_INNOBASE_DB) + have_innodb="yes" + innodb_includes="-I../innobase/include" + innodb_system_libs="" +dnl Some libs are listed several times, in order for gcc to sort out +dnl circular references. + innodb_libs="\ + \$(top_builddir)/innobase/usr/libusr.a\ + \$(top_builddir)/innobase/srv/libsrv.a\ + \$(top_builddir)/innobase/dict/libdict.a\ + \$(top_builddir)/innobase/que/libque.a\ + \$(top_builddir)/innobase/srv/libsrv.a\ + \$(top_builddir)/innobase/ibuf/libibuf.a\ + \$(top_builddir)/innobase/row/librow.a\ + \$(top_builddir)/innobase/pars/libpars.a\ + \$(top_builddir)/innobase/btr/libbtr.a\ + \$(top_builddir)/innobase/trx/libtrx.a\ + \$(top_builddir)/innobase/read/libread.a\ + \$(top_builddir)/innobase/usr/libusr.a\ + \$(top_builddir)/innobase/buf/libbuf.a\ + \$(top_builddir)/innobase/ibuf/libibuf.a\ + \$(top_builddir)/innobase/eval/libeval.a\ + \$(top_builddir)/innobase/log/liblog.a\ + \$(top_builddir)/innobase/fsp/libfsp.a\ + \$(top_builddir)/innobase/fut/libfut.a\ + \$(top_builddir)/innobase/fil/libfil.a\ + \$(top_builddir)/innobase/lock/liblock.a\ + \$(top_builddir)/innobase/mtr/libmtr.a\ + \$(top_builddir)/innobase/page/libpage.a\ + \$(top_builddir)/innobase/rem/librem.a\ + \$(top_builddir)/innobase/thr/libthr.a\ + \$(top_builddir)/innobase/sync/libsync.a\ + \$(top_builddir)/innobase/data/libdata.a\ + \$(top_builddir)/innobase/mach/libmach.a\ + \$(top_builddir)/innobase/ha/libha.a\ + \$(top_builddir)/innobase/dyn/libdyn.a\ + \$(top_builddir)/innobase/mem/libmem.a\ + \$(top_builddir)/innobase/sync/libsync.a\ + \$(top_builddir)/innobase/ut/libut.a\ + \$(top_builddir)/innobase/os/libos.a\ + \$(top_builddir)/innobase/ut/libut.a" + + AC_CHECK_LIB(rt, aio_read, [innodb_system_libs="-lrt"]) + ;; + * ) + AC_MSG_RESULT([Not using Innodb]) + ;; + esac + + AC_SUBST(innodb_includes) + AC_SUBST(innodb_libs) + AC_SUBST(innodb_system_libs) +]) + +dnl --------------------------------------------------------------------------- +dnl END OF MYSQL_CHECK_INNODB SECTION +dnl --------------------------------------------------------------------------- + +dnl --------------------------------------------------------------------------- +dnl Macro: MYSQL_CHECK_NDBCLUSTER +dnl Sets HAVE_NDBCLUSTER_DB if --with-ndbcluster is used +dnl --------------------------------------------------------------------------- + +AC_DEFUN([MYSQL_CHECK_NDBCLUSTER], [ + AC_ARG_WITH([ndbcluster], + [ + --without-ndbcluster Do not include the Ndb Cluster table handler], + [ndbcluster="$withval"], + [ndbcluster=yes]) + + AC_MSG_CHECKING([for Ndb Cluster]) + + have_ndbcluster=no + ndbcluster_includes= + ndbcluster_libs= + case "$ndbcluster" in + yes ) + AC_MSG_RESULT([Using Ndb Cluster]) + AC_DEFINE(HAVE_NDBCLUSTER_DB) + have_ndbcluster="yes" + ndbcluster_includes="-I../ndb/include -I../ndb/include/ndbapi" + ndbcluster_libs="\$(top_builddir)/ndb/lib/libNDB_API.a" + ndbcluster_system_libs="" + esac + + AC_SUBST(ndbcluster_includes) + AC_SUBST(ndbcluster_libs) + AC_SUBST(ndbcluster_system_libs) +]) + +dnl --------------------------------------------------------------------------- +dnl END OF MYSQL_CHECK_NDBCLUSTER SECTION +dnl --------------------------------------------------------------------------- + +dnl By default, many hosts won't let programs access large files; +dnl one must use special compiler options to get large-file access to work. +dnl For more details about this brain damage please see: +dnl http://www.sas.com/standards/large.file/x_open.20Mar96.html + +dnl Written by Paul Eggert . + +dnl Internal subroutine of AC_SYS_LARGEFILE. +dnl AC_SYS_LARGEFILE_FLAGS(FLAGSNAME) +AC_DEFUN(AC_SYS_LARGEFILE_FLAGS, + [AC_CACHE_CHECK([for $1 value to request large file support], + ac_cv_sys_largefile_$1, + [if ($GETCONF LFS_$1) >conftest.1 2>conftest.2 && test ! -s conftest.2 + then + ac_cv_sys_largefile_$1=`cat conftest.1` + else + ac_cv_sys_largefile_$1=no + ifelse($1, CFLAGS, + [case "$host_os" in + # HP-UX 10.20 requires -D__STDC_EXT__ with gcc 2.95.1. +changequote(, )dnl + hpux10.[2-9][0-9]* | hpux1[1-9]* | hpux[2-9][0-9]*) +changequote([, ])dnl + if test "$GCC" = yes; then + case `$CC --version 2>/dev/null` in + 2.95.*) ac_cv_sys_largefile_CFLAGS=-D__STDC_EXT__ ;; + esac + fi + ;; + # IRIX 6.2 and later require cc -n32. +changequote(, )dnl + irix6.[2-9]* | irix6.1[0-9]* | irix[7-9].* | irix[1-9][0-9]*) +changequote([, ])dnl + if test "$GCC" != yes; then + ac_cv_sys_largefile_CFLAGS=-n32 + fi + esac + if test "$ac_cv_sys_largefile_CFLAGS" != no; then + ac_save_CC="$CC" + CC="$CC $ac_cv_sys_largefile_CFLAGS" + AC_TRY_LINK(, , , ac_cv_sys_largefile_CFLAGS=no) + CC="$ac_save_CC" + fi]) + fi + rm -f conftest*])]) + +dnl Internal subroutine of AC_SYS_LARGEFILE. +dnl AC_SYS_LARGEFILE_SPACE_APPEND(VAR, VAL) +AC_DEFUN(AC_SYS_LARGEFILE_SPACE_APPEND, + [case $2 in + no) ;; + ?*) + case "[$]$1" in + '') $1=$2 ;; + *) $1=[$]$1' '$2 ;; + esac ;; + esac]) + +dnl Internal subroutine of AC_SYS_LARGEFILE. +dnl AC_SYS_LARGEFILE_MACRO_VALUE(C-MACRO, CACHE-VAR, COMMENT, CODE-TO-SET-DEFAULT) +AC_DEFUN(AC_SYS_LARGEFILE_MACRO_VALUE, + [AC_CACHE_CHECK([for $1], $2, + [$2=no +changequote(, )dnl + for ac_flag in $ac_cv_sys_largefile_CFLAGS no; do + case "$ac_flag" in + -D$1) + $2=1 ;; + -D$1=*) + $2=`expr " $ac_flag" : '[^=]*=\(.*\)'` ;; + esac + done + $4 +changequote([, ])dnl + ]) + if test "[$]$2" != no; then + AC_DEFINE_UNQUOTED([$1], [$]$2, [$3]) + fi]) + +AC_DEFUN(MYSQL_SYS_LARGEFILE, + [AC_REQUIRE([AC_CANONICAL_HOST]) + AC_ARG_ENABLE(largefile, + [ --disable-largefile Omit support for large files]) + if test "$enable_largefile" != no; then + AC_CHECK_TOOL(GETCONF, getconf) + AC_SYS_LARGEFILE_FLAGS(CFLAGS) + AC_SYS_LARGEFILE_FLAGS(LDFLAGS) + AC_SYS_LARGEFILE_FLAGS(LIBS) + + for ac_flag in $ac_cv_sys_largefile_CFLAGS no; do + case "$ac_flag" in + no) ;; + -D_FILE_OFFSET_BITS=*) ;; + -D_LARGEFILE_SOURCE | -D_LARGEFILE_SOURCE=*) ;; + -D_LARGE_FILES | -D_LARGE_FILES=*) ;; + -D?* | -I?*) + AC_SYS_LARGEFILE_SPACE_APPEND(CPPFLAGS, "$ac_flag") ;; + *) + AC_SYS_LARGEFILE_SPACE_APPEND(CFLAGS, "$ac_flag") ;; + esac + done + AC_SYS_LARGEFILE_SPACE_APPEND(LDFLAGS, "$ac_cv_sys_largefile_LDFLAGS") + AC_SYS_LARGEFILE_SPACE_APPEND(LIBS, "$ac_cv_sys_largefile_LIBS") + + AC_SYS_LARGEFILE_MACRO_VALUE(_FILE_OFFSET_BITS, + ac_cv_sys_file_offset_bits, + [Number of bits in a file offset, on hosts where this is settable.], + [case "$host_os" in + # HP-UX 10.20 and later + hpux10.[2-9][0-9]* | hpux1[1-9]* | hpux[2-9][0-9]*) + ac_cv_sys_file_offset_bits=64 ;; + # We can't declare _FILE_OFFSET_BITS here as this will cause + # compile errors as AC_PROG_CC adds include files in confdefs.h + # We solve this (until autoconf is fixed) by instead declaring it + # as define instead + solaris2.[8,9]) + CFLAGS="$CFLAGS -D_FILE_OFFSET_BITS=64" + CXXFLAGS="$CXXFLAGS -D_FILE_OFFSET_BITS=64" + ac_cv_sys_file_offset_bits=no ;; + esac]) + AC_SYS_LARGEFILE_MACRO_VALUE(_LARGEFILE_SOURCE, + ac_cv_sys_largefile_source, + [Define to make fseeko etc. visible, on some hosts.], + [case "$host_os" in + # HP-UX 10.20 and later + hpux10.[2-9][0-9]* | hpux1[1-9]* | hpux[2-9][0-9]*) + ac_cv_sys_largefile_source=1 ;; + esac]) + AC_SYS_LARGEFILE_MACRO_VALUE(_LARGE_FILES, + ac_cv_sys_large_files, + [Define for large files, on AIX-style hosts.], + [case "$host_os" in + # AIX 4.2 and later + aix4.[2-9]* | aix4.1[0-9]* | aix[5-9].* | aix[1-9][0-9]*) + ac_cv_sys_large_files=1 ;; + esac]) + fi + ]) + + +# Local version of _AC_PROG_CXX_EXIT_DECLARATION that does not +# include #stdlib.h as default as this breaks things on Solaris +# (Conflicts with pthreads and big file handling) + +m4_define([_AC_PROG_CXX_EXIT_DECLARATION], +[for ac_declaration in \ + ''\ + 'extern "C" void std::exit (int) throw (); using std::exit;' \ + 'extern "C" void std::exit (int); using std::exit;' \ + 'extern "C" void exit (int) throw ();' \ + 'extern "C" void exit (int);' \ + 'void exit (int);' \ + '#include ' +do + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM([@%:@include +$ac_declaration], + [exit (42);])], + [], + [continue]) + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$ac_declaration], + [exit (42);])], + [break]) +done +rm -f conftest* +if test -n "$ac_declaration"; then + echo '#ifdef __cplusplus' >>confdefs.h + echo $ac_declaration >>confdefs.h + echo '#endif' >>confdefs.h +fi +])# _AC_PROG_CXX_EXIT_DECLARATION + +dnl --------------------------------------------------------------------------- + diff --git a/ndb/config/configure.in b/ndb/config/configure.in new file mode 100644 index 00000000000..4fa5ccdb672 --- /dev/null +++ b/ndb/config/configure.in @@ -0,0 +1,2085 @@ +dnl -*- ksh -*- +dnl Process this file with autoconf to produce a configure script. + +AC_INIT(../../sql/mysqld.cc) +AC_CANONICAL_SYSTEM +# The Docs Makefile.am parses this line! +AM_INIT_AUTOMAKE(mysql, 4.1.2-3.4.3-alpha) +AM_CONFIG_HEADER(config.h) + +PROTOCOL_VERSION=10 +DOT_FRM_VERSION=6 +# See the libtool docs for information on how to do shared lib versions. +SHARED_LIB_VERSION=14:0:0 + +# Set all version vars based on $VERSION. How do we do this more elegant ? +# Remember that regexps needs to quote [ and ] since this is run through m4 +MYSQL_NO_DASH_VERSION=`echo $VERSION | sed -e "s|[[a-z]]*-.*$||"` +MYSQL_BASE_VERSION=`echo $MYSQL_NO_DASH_VERSION | sed -e "s|\.[[^.]]*$||"` +MYSQL_VERSION_ID=`echo $MYSQL_NO_DASH_VERSION. | sed -e 's/\./ /g; s/ \([[0-9]]\) / 0\\1 /g; s/ //g'` + +# The port should be constant for a LONG time +MYSQL_TCP_PORT_DEFAULT=3306 +MYSQL_UNIX_ADDR_DEFAULT="/tmp/mysql.sock" + +##### +##### + +AC_SUBST(MYSQL_NO_DASH_VERSION) +AC_SUBST(MYSQL_BASE_VERSION) +AC_SUBST(MYSQL_VERSION_ID) +AC_SUBST(PROTOCOL_VERSION) +AC_DEFINE_UNQUOTED(PROTOCOL_VERSION, $PROTOCOL_VERSION) +AC_SUBST(DOT_FRM_VERSION) +AC_DEFINE_UNQUOTED(DOT_FRM_VERSION, $DOT_FRM_VERSION) +AC_SUBST(SHARED_LIB_VERSION) + +# Canonicalize the configuration name. +SYSTEM_TYPE="$host_vendor-$host_os" +MACHINE_TYPE="$host_cpu" +AC_SUBST(SYSTEM_TYPE) +AC_DEFINE_UNQUOTED(SYSTEM_TYPE, "$SYSTEM_TYPE") +AC_SUBST(MACHINE_TYPE) +AC_DEFINE_UNQUOTED(MACHINE_TYPE, "$MACHINE_TYPE") + +# Detect intel x86 like processor +BASE_MACHINE_TYPE=$MACHINE_TYPE +case $MACHINE_TYPE in + i?86) BASE_MACHINE_TYPE=i386 ;; +esac + +# Save some variables and the command line options for mysqlbug +SAVE_ASFLAGS="$ASFLAGS" +SAVE_CFLAGS="$CFLAGS" +SAVE_CXXFLAGS="$CXXFLAGS" +SAVE_LDFLAGS="$LDFLAGS" +SAVE_CXXLDFLAGS="$CXXLDFLAGS" +CONF_COMMAND="$0 $ac_configure_args" +AC_SUBST(CONF_COMMAND) +AC_SUBST(SAVE_ASFLAGS) +AC_SUBST(SAVE_CFLAGS) +AC_SUBST(SAVE_CXXFLAGS) +AC_SUBST(SAVE_LDFLAGS) +AC_SUBST(SAVE_CXXLDFLAGS) +AC_SUBST(CXXLDFLAGS) + +AC_PREREQ(2.12)dnl Minimum Autoconf version required. + +AM_MAINTAINER_MODE +#AC_ARG_PROGRAM # Automaticly invoked by AM_INIT_AUTOMAKE +AM_SANITY_CHECK +# This is needed is SUBDIRS is set +AC_PROG_MAKE_SET + +# This is need before AC_PROG_CC +# + +if test "x${CFLAGS-}" = x ; then + cflags_is_set=no +else + cflags_is_set=yes +fi + +if test "x${CPPFLAGS-}" = x ; then + cppflags_is_set=no +else + cppflags_is_set=yes +fi + +if test "x${LDFLAGS-}" = x ; then + ldflags_is_set=no +else + ldflags_is_set=yes +fi + +# The following hack should ensure that configure doesn't add optimizing +# or debugging flags to CFLAGS or CXXFLAGS +CFLAGS="$CFLAGS " +CXXFLAGS="$CXXFLAGS " + +dnl Checks for programs. +AC_PROG_AWK +AC_PROG_CC +AC_PROG_CXX +AC_PROG_CPP + +# Print version of CC and CXX compiler (if they support --version) +case $SYSTEM_TYPE in + *netware*) +CC_VERSION=`$CC -version | grep -i version` + ;; + *) +CC_VERSION=`$CC --version | sed 1q` + ;; +esac +if test $? -eq "0" +then + AC_MSG_CHECKING("C Compiler version"); + AC_MSG_RESULT("$CC $CC_VERSION") +else +CC_VERSION="" +fi +case $SYSTEM_TYPE in + *netware*) +CXX_VERSION=`$CXX -version | grep -i version` + ;; + *) +CXX_VERSION=`$CXX --version | sed 1q` + ;; +esac +if test $? -eq "0" +then + AC_MSG_CHECKING("C++ compiler version"); + AC_MSG_RESULT("$CXX $CXX_VERSION") +else +CXX_VERSION="" +fi +AC_SUBST(CXX_VERSION) +AC_SUBST(CC_VERSION) + +# Fix for sgi gcc / sgiCC which tries to emulate gcc +if test "$CC" = "sgicc" +then + ac_cv_prog_gcc="no" +fi +if test "$CXX" = "sgi++" +then + GXX="no" +fi + +if test "$ac_cv_prog_gcc" = "yes" +then + AS="$CC -c" + AC_SUBST(AS) +else + AC_PATH_PROG(AS, as, as) +fi +# Still need ranlib for readline; local static use only so no libtool. +AC_PROG_RANLIB +# We use libtool +#AC_LIBTOOL_WIN32_DLL +AC_PROG_LIBTOOL + +# Ensure that we have --preserve-dup-deps defines, otherwise we get link +# problems of 'mysql' with CXX=g++ +LIBTOOL="$LIBTOOL --preserve-dup-deps" +AC_SUBST(LIBTOOL)dnl + +#AC_LIBTOOL_DLOPEN AC_LIBTOOL_WIN32_DLL AC_DISABLE_FAST_INSTALL AC_DISABLE_SHARED AC_DISABLE_STATIC + +# AC_PROG_INSTALL +AC_PROG_INSTALL +test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}' + +# Not critical since the generated file is distributed +AC_PROG_YACC +AC_CHECK_PROG(PDFMANUAL, pdftex, manual.pdf) +AC_CHECK_PROG(DVIS, tex, manual.dvi) + +AC_MSG_CHECKING("return type of sprintf") + +#check the return type of sprintf +case $SYSTEM_TYPE in + *netware*) + AC_DEFINE(SPRINTF_RETURNS_INT) AC_MSG_RESULT("int") + ;; + *) +AC_TRY_RUN([ + int main() + { + char* s = "hello"; + char buf[6]; + if((int)sprintf(buf, s) == strlen(s)) + return 0; + + return -1; + } + ], +AC_DEFINE(SPRINTF_RETURNS_INT) AC_MSG_RESULT("int"), + AC_TRY_RUN([ + int main() + { + char* s = "hello"; + char buf[6]; + if((char*)sprintf(buf,s) == buf + strlen(s)) + return 0; + return -1; + } +], AC_DEFINE(SPRINTF_RETURNS_PTR) AC_MSG_RESULT("ptr"), + AC_DEFINE(SPRINTF_RETURNS_GARBAGE) AC_MSG_RESULT("garbage"))) + ;; +esac + + +# option, cache_name, variable, +# code to execute if yes, code to exectute if fail +AC_DEFUN(AC_SYS_COMPILER_FLAG, +[ + AC_MSG_CHECKING($1) + OLD_CFLAGS="[$]CFLAGS" + AC_CACHE_VAL(mysql_cv_option_$2, + [ + CFLAGS="[$]OLD_CFLAGS $1" + AC_TRY_RUN([int main(){exit(0);}],mysql_cv_option_$2=yes,mysql_cv_option_$2=no,mysql_cv_option_$2=no) + ]) + + CFLAGS="[$]OLD_CFLAGS" + + if test x"[$]mysql_cv_option_$2" = "xyes" ; then + $3="[$]$3 $1" + AC_MSG_RESULT(yes) + $5 + else + AC_MSG_RESULT(no) + $4 + fi +]) + +# arch, option, cache_name, variable +AC_DEFUN(AC_SYS_CPU_COMPILER_FLAG, +[ + if test "`uname -m 2>/dev/null`" = "$1" ; then + AC_SYS_COMPILER_FLAG($2,$3,$4) + fi +]) + +# os, option, cache_name, variable +AC_DEFUN(AC_SYS_OS_COMPILER_FLAG, +[ + if test "x$mysql_cv_sys_os" = "x$1" ; then + AC_SYS_COMPILER_FLAG($2,$3,$4) + fi +]) + +# We need some special hacks when running slowaris +AC_PATH_PROG(uname_prog, uname, no) + +# We should go through this and put all the explictly system dependent +# stuff in one place +AC_MSG_CHECKING(operating system) +AC_CACHE_VAL(mysql_cv_sys_os, +[ +if test "$uname_prog" != "no"; then + mysql_cv_sys_os="`uname`" +else + mysql_cv_sys_os="Not Solaris" +fi +]) +AC_MSG_RESULT($mysql_cv_sys_os) + +# This should be rewritten to use $target_os +case "$target_os" in + sco3.2v5*) + CFLAGS="$CFLAGS -DSCO" + CXXFLAGS="$CXXFLAGS -DSCO" + LD='$(CC) $(CFLAGS)' + case "$CFLAGS" in + *-belf*) + AC_SYS_COMPILER_FLAG(-belf,sco_belf_option,CFLAGS,[],[ + case "$LDFLAGS" in + *-belf*) ;; + *) echo "Adding -belf option to ldflags." + LDFLAGS="$LDFLAGS -belf" + ;; + esac + ]) + ;; + *) + AC_SYS_COMPILER_FLAG(-belf,sco_belf_option,CFLAGS,[],[ + case "$LDFLAGS" in + *-belf*) ;; + *) + echo "Adding -belf option to ldflags." + LDFLAGS="$LDFLAGS -belf" + ;; + esac + ]) + ;; + esac + ;; + sysv5UnixWare*) + if test "$GCC" != "yes"; then + # We are using built-in inline function + CFLAGS="$CFLAGS -Kalloca" + fi + CXXFLAGS="$CXXFLAGS -DNO_CPLUSPLUS_ALLOCA" + ;; + sysv5OpenUNIX8*) + if test "$GCC" != "yes"; then + # We are using built-in inline function + CFLAGS="$CFLAGS -Kalloca" + fi + CXXFLAGS="$CXXFLAGS -DNO_CPLUSPLUS_ALLOCA" + ;; +esac +AC_SUBST(CC) +AC_SUBST(CFLAGS) +AC_SUBST(CXX) +AC_SUBST(CXXFLAGS) +AC_SUBST(LD) +AC_SUBST(INSTALL_SCRIPT) + +export CC CXX CFLAGS LD LDFLAGS AR + +if test "$GXX" = "yes" +then + # mysqld requires -fno-implicit-templates. + # Disable exceptions as they seams to create problems with gcc and threads. + # mysqld doesn't use run-time-type-checking, so we disable it. + CXXFLAGS="$CXXFLAGS -fno-implicit-templates -fno-exceptions -fno-rtti" + + # If you are using 'gcc' 3.0 (not g++) to compile C++ programs on Linux, + # we will gets some problems when linking static programs. + # The following code is used to fix this problem. + + if test "$CXX" = "gcc" -o "$CXX" = "ccache gcc" + then + if $CXX -v 2>&1 | grep 'version 3' > /dev/null 2>&1 + then + CXXFLAGS="$CXXFLAGS -DUSE_MYSYS_NEW -DDEFINE_CXA_PURE_VIRTUAL" + fi + fi +fi + +# Avoid bug in fcntl on some versions of linux +AC_MSG_CHECKING("if we should use 'skip-locking' as default for $target_os") +# Any wariation of Linux +if expr "$target_os" : "[[Ll]]inux.*" > /dev/null +then + MYSQLD_DEFAULT_SWITCHES="--skip-locking" + IS_LINUX="true" + AC_MSG_RESULT("yes"); +else + MYSQLD_DEFAULT_SWITCHES="" + IS_LINUX="false" + AC_MSG_RESULT("no"); +fi +AC_SUBST(MYSQLD_DEFAULT_SWITCHES) +AC_SUBST(IS_LINUX) + +dnl Find paths to some shell programs +AC_PATH_PROG(LN, ln, ln) +# This must be able to take a -f flag like normal unix ln. +AC_PATH_PROG(LN_CP_F, ln, ln) +if ! ( expr "$SYSTEM_TYPE" : ".*netware.*" > /dev/null ); then +# If ln -f does not exists use -s (AFS systems) +if test -n "$LN_CP_F"; then + LN_CP_F="$LN_CP_F -s" +fi +fi + +AC_PATH_PROG(MV, mv, mv) +AC_PATH_PROG(RM, rm, rm) +AC_PATH_PROG(CP, cp, cp) +AC_PATH_PROG(SED, sed, sed) +AC_PATH_PROG(CMP, cmp, cmp) +AC_PATH_PROG(CHMOD, chmod, chmod) +AC_PATH_PROG(HOSTNAME, hostname, hostname) +# 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) + +dnl We use a path for perl so the script startup works +dnl We make sure to use perl, not perl5, in hopes that the RPMs will +dnl not depend on the perl5 binary being installed (probably a bug in RPM) +AC_PATH_PROG(PERL, perl, no) +if test "$PERL" != "no" && $PERL -e 'require 5' > /dev/null 2>&1 +then + PERL5=$PERL +else + AC_PATH_PROG(PERL5, perl5, no) + if test "$PERL5" != no + then + PERL=$PERL5 + ac_cv_path_PERL=$ac_cv_path_PERL5 + fi +fi + +AC_SUBST(HOSTNAME) +AC_SUBST(PERL) +AC_SUBST(PERL5) + +# Lock for PS +AC_PATH_PROG(PS, ps, ps) +AC_MSG_CHECKING("how to check if pid exists") +PS=$ac_cv_path_PS +# Linux style +if $PS p $$ 2> /dev/null | grep $0 > /dev/null +then + FIND_PROC="$PS p \$\$PID | grep mysqld > /dev/null" +# Solaris +elif $PS -p $$ 2> /dev/null | grep $0 > /dev/null +then + FIND_PROC="$PS -p \$\$PID | grep mysqld > /dev/null" +# BSD style +elif $PS -uaxww 2> /dev/null | grep $0 > /dev/null +then + FIND_PROC="$PS -uaxww | grep mysqld | grep \" \$\$PID \" > /dev/null" +# SysV style +elif $PS -ef 2> /dev/null | grep $0 > /dev/null +then + FIND_PROC="$PS -ef | grep mysqld | grep \" \$\$PID \" > /dev/null" +# Do anybody use this? +elif $PS $$ 2> /dev/null | grep $0 > /dev/null +then + FIND_PROC="$PS \$\$PID | grep mysqld > /dev/null" +else + case $SYSTEM_TYPE in + *freebsd*) + FIND_PROC="$PS p \$\$PID | grep mysqld > /dev/null" + ;; + *darwin*) + FIND_PROC="$PS -uaxww | grep mysqld | grep \" \$\$PID \" > /dev/null" + ;; + *cygwin*) + FIND_PROC="$PS -e | grep mysqld | grep \" \$\$PID \" > /dev/null" + ;; + *netware* | *modesto*) + FIND_PROC= + ;; + *) + AC_MSG_ERROR([Could not find the right ps switches. Which OS is this ?. See the Installation chapter in the Reference Manual.]) + esac +fi +AC_SUBST(FIND_PROC) +AC_MSG_RESULT("$FIND_PROC") + +# Check if a pid is valid +AC_PATH_PROG(KILL, kill, kill) +AC_MSG_CHECKING("for kill switches") +if $ac_cv_path_KILL -0 $$ +then + CHECK_PID="$ac_cv_path_KILL -0 \$\$PID > /dev/null 2> /dev/null" +elif kill -s 0 $$ +then + CHECK_PID="$ac_cv_path_KILL -s 0 \$\$PID > /dev/null 2> /dev/null" +else + AC_MSG_WARN([kill -0 to check for pid seems to fail]) + CHECK_PID="$ac_cv_path_KILL -s SIGCONT \$\$PID > /dev/null 2> /dev/null" +fi +AC_SUBST(CHECK_PID) +AC_MSG_RESULT("$CHECK_PID") + +# We need a ANSI C compiler +AM_PROG_CC_STDC + +# We need an assembler, too +AM_PROG_AS + +if test "$am_cv_prog_cc_stdc" = "no" +then + AC_MSG_ERROR([MySQL requires a ANSI C compiler (and a C++ compiler). Try gcc. See the Installation chapter in the Reference Manual.]) +fi + +NOINST_LDFLAGS= + +static_nss="" +STATIC_NSS_FLAGS="" +OTHER_LIBC_LIB="" +AC_ARG_WITH(other-libc, + [ --with-other-libc=DIR Link against libc and other standard libraries + installed in the specified non-standard location + overriding default. Originally added to be able to + link against glibc 2.2 without making the user + upgrade the standard libc installation.], + [ + other_libc_include="$withval/include" + other_libc_lib="$withval/lib" + with_other_libc="yes" + enable_shared="no" + all_is_static="yes" + CFLAGS="$CFLAGS -I$other_libc_include" + # There seems to be a feature in gcc that treats system and libc headers + # silently when they violatate ANSI C++ standard, but it is strict otherwise + # since gcc cannot now recognize that our headers are libc, we work around + # by telling it to be permissive. Note that this option only works with + # new versions of gcc (2.95.x and above) + CXXFLAGS="$CXXFLAGS -fpermissive -I$other_libc_include" + if test -f "$other_libc_lib/libnss_files.a" + then + # libc has been compiled with --enable-static-nss + # we need special flags, but we will have to add those later + STATIC_NSS_FLAGS="-lc -lnss_files -lnss_dns -lresolv" + STATIC_NSS_FLAGS="$STATIC_NSS_FLAGS $STATIC_NSS_FLAGS" + OTHER_LIBC_LIB="-static -L$other_libc_lib" + static_nss=1 + else + # this is a dirty hack. We if we detect static nss glibc in the special + # location, we do not re-direct the linker to get libraries from there + # during check. The reason is that if we did, we would have to find a + # way to append the special static nss flags to LIBS every time we do + # any check - this is definitely feasible, but not worthwhile the risk + # of breaking other things. So for our purposes it would be sufficient + # to assume that whoever is using static NSS knows what he is doing and + # has sensible libraries in the regular location + LDFLAGS="$LDFLAGS -static -L$other_libc_lib " + fi + + # When linking against custom libc installed separately, we want to force + # all binary builds to be static, including the build done by configure + # itself to test for system features. + with_mysqld_ldflags="-all-static" + with_client_ldflags="-all-static" + NOINST_LDFLAGS="-all-static" + ], + [ + other_libc_include= + other_libc_lib= + with_other_libc="no" + ] +) +AC_SUBST(NOINST_LDFLAGS) + +# +# Check if we are using Linux and a glibc compiled with static nss +# (this is true on the MySQL build machines to avoid NSS problems) +# + +if test "$IS_LINUX" = "true" -a "$static_nss" = "" +then + tmp=`nm /usr/lib/libc.a | grep _nss_files_getaliasent_r` + if test -n "$tmp" + then + STATIC_NSS_FLAGS="-lc -lnss_files -lnss_dns -lresolv" + STATIC_NSS_FLAGS="$STATIC_NSS_FLAGS $STATIC_NSS_FLAGS" + static_nss=1 + fi +fi + + +AC_ARG_WITH(server-suffix, + [ --with-server-suffix Append value to the version string.], + [ MYSQL_SERVER_SUFFIX=`echo "$withval" | sed -e 's/^\(...................................\)..*$/\1/'` ], + [ MYSQL_SERVER_SUFFIX= ] + ) +AC_SUBST(MYSQL_SERVER_SUFFIX) + +# Set flags if we wants to have MIT threads. +AC_ARG_WITH(mit-threads, + [ --with-mit-threads Always use included thread lib.], + [ with_mit_threads=$withval ], + [ with_mit_threads=no ] + ) + +if test "$with_mit_threads" = "yes" +then + enable_largefile="no" # Will not work on Linux. +fi + +# Set flags if we want to force to use pthreads +AC_ARG_WITH(pthread, + [ --with-pthread Force use of pthread library.], + [ with_pthread=$withval ], + [ with_pthread=no ] + ) + +# Force use of thread libs LIBS +AC_ARG_WITH(named-thread-libs, + [ --with-named-thread-libs=ARG + Use specified thread libraries instead of + those automatically found by configure.], + [ with_named_thread=$withval ], + [ with_named_thread=no ] + ) + +# Force use of a curses libs +AC_ARG_WITH(named-curses-libs, + [ --with-named-curses-libs=ARG + Use specified curses libraries instead of + those automatically found by configure.], + [ with_named_curses=$withval ], + [ with_named_curses=no ] + ) + +# Force use of a zlib (compress) +AC_ARG_WITH(named-z-libs, + [ --with-named-z-libs=ARG + Use specified zlib libraries instead of + those automatically found by configure.], + [ with_named_zlib=$withval ], + [ with_named_zlib=z ] + ) + +# Make thread safe client +AC_ARG_ENABLE(thread-safe-client, + [ --enable-thread-safe-client + Compile the client with threads.], + [ THREAD_SAFE_CLIENT=$enableval ], + [ THREAD_SAFE_CLIENT=no ] + ) + +# compile with strings functions in assembler +AC_ARG_ENABLE(assembler, + [ --enable-assembler Use assembler versions of some string + functions if available.], + [ ENABLE_ASSEMBLER=$enableval ], + [ ENABLE_ASSEMBLER=no ] + ) + +AC_MSG_CHECKING(if we should use assembler functions) +# For now we only support assembler on i386 and sparc systems +AM_CONDITIONAL(ASSEMBLER_x86, test "$ENABLE_ASSEMBLER" = "yes" -a "$BASE_MACHINE_TYPE" = "i386") +AM_CONDITIONAL(ASSEMBLER_sparc32, test "$ENABLE_ASSEMBLER" = "yes" -a "$BASE_MACHINE_TYPE" = "sparc") +AM_CONDITIONAL(ASSEMBLER_sparc64, test "$ENABLE_ASSEMBLER" = "yes" -a "$BASE_MACHINE_TYPE" = "sparcv9") +AM_CONDITIONAL(ASSEMBLER, test "$ASSEMBLER_x86_TRUE" = "" -o "$ASSEMBLER_sparc32_TRUE" = "") + +if test "$ASSEMBLER_TRUE" = "" +then + AC_MSG_RESULT([yes]) +else + AC_MSG_RESULT([no]) +fi + + +AC_MSG_CHECKING(if we should use RAID) +AC_ARG_WITH(raid, + [ --with-raid Enable RAID Support], + [ USE_RAID=$withval ], + [ USE_RAID=no ] + ) +if test "$USE_RAID" = "yes" +then + AC_MSG_RESULT([yes]) + AC_DEFINE([USE_RAID]) +else + AC_MSG_RESULT([no]) +fi + +# Use this to set the place used for unix socket used to local communication. +AC_ARG_WITH(unix-socket-path, + [ --with-unix-socket-path=SOCKET + Where to put the unix-domain socket. SOCKET must be + an absolute file name.], + [ MYSQL_UNIX_ADDR=$withval ], + [ MYSQL_UNIX_ADDR=$MYSQL_UNIX_ADDR_DEFAULT ] + ) +AC_SUBST(MYSQL_UNIX_ADDR) + +AC_ARG_WITH(tcp-port, + [ --with-tcp-port=port-number + Which port to use for MySQL services (default 3306)], + [ MYSQL_TCP_PORT=$withval ], + [ MYSQL_TCP_PORT=$MYSQL_TCP_PORT_DEFAULT ] + ) +AC_SUBST(MYSQL_TCP_PORT) +# We might want to document the assigned port in the manual. +AC_SUBST(MYSQL_TCP_PORT_DEFAULT) + +# Use this to set the place used for unix socket used to local communication. +AC_ARG_WITH(mysqld-user, + [ --with-mysqld-user=username + What user the mysqld daemon shall be run as.], + [ MYSQLD_USER=$withval ], + [ MYSQLD_USER=mysql ] + ) +AC_SUBST(MYSQLD_USER) + +# If we should allow LOAD DATA LOCAL +AC_MSG_CHECKING(If we should should enable LOAD DATA LOCAL by default) +AC_ARG_ENABLE(local-infile, + [ --enable-local-infile Enable LOAD DATA LOCAL INFILE (default: disabled)], + [ ENABLED_LOCAL_INFILE=$enableval ], + [ ENABLED_LOCAL_INFILE=no ] + ) +if test "$ENABLED_LOCAL_INFILE" = "yes" +then + AC_MSG_RESULT([yes]) + AC_DEFINE([ENABLED_LOCAL_INFILE]) +else + AC_MSG_RESULT([no]) +fi + +MYSQL_SYS_LARGEFILE + +# Types that must be checked AFTER large file support is checked +AC_TYPE_SIZE_T + +#-------------------------------------------------------------------- +# Check for system header files +#-------------------------------------------------------------------- + +AC_HEADER_DIRENT +AC_HEADER_STDC +AC_HEADER_SYS_WAIT +AC_CHECK_HEADERS(fcntl.h float.h floatingpoint.h ieeefp.h limits.h \ + memory.h pwd.h select.h \ + stdlib.h stddef.h \ + strings.h string.h synch.h sys/mman.h sys/socket.h netinet/in.h arpa/inet.h \ + sys/timeb.h sys/types.h sys/un.h sys/vadvise.h sys/wait.h term.h \ + unistd.h utime.h sys/utime.h termio.h termios.h sched.h crypt.h alloca.h \ + sys/ioctl.h malloc.h sys/malloc.h linux/config.h) + +#-------------------------------------------------------------------- +# Check for system libraries. Adds the library to $LIBS +# and defines HAVE_LIBM etc +#-------------------------------------------------------------------- + +AC_CHECK_LIB(m, floor, [], AC_CHECK_LIB(m, __infinity)) + +AC_CHECK_LIB(nsl_r, gethostbyname_r, [], + AC_CHECK_LIB(nsl, gethostbyname_r)) +AC_CHECK_FUNC(gethostbyname_r) + +AC_CHECK_FUNC(setsockopt, , AC_CHECK_LIB(socket, setsockopt)) +AC_CHECK_FUNC(yp_get_default_domain, , + AC_CHECK_LIB(nsl, yp_get_default_domain)) +AC_CHECK_FUNC(p2open, , AC_CHECK_LIB(gen, p2open)) +# This may get things to compile even if bind-8 is installed +AC_CHECK_FUNC(bind, , AC_CHECK_LIB(bind, bind)) +# For crypt() on Linux +AC_CHECK_LIB(crypt, crypt) +AC_CHECK_FUNC(crypt, AC_DEFINE(HAVE_CRYPT)) + +# For sem_xxx functions on Solaris 2.6 +AC_CHECK_FUNC(sem_init, , AC_CHECK_LIB(posix4, sem_init)) + +# For compress in zlib +MYSQL_CHECK_ZLIB_WITH_COMPRESS($with_named_zlib) + +#-------------------------------------------------------------------- +# Check for TCP wrapper support +#-------------------------------------------------------------------- + +AC_ARG_WITH(libwrap, +[ --with-libwrap[=DIR] Compile in libwrap (tcp_wrappers) support],[ + case "$with_libwrap" in + no) : ;; + yes|*) + _cppflags=${CPPFLAGS} + _ldflags=${LDFLAGS} + + if test "$with_libwrap" != "yes"; then + CPPFLAGS="${CPPFLAGS} -I$with_libwrap/include" + LDFLAGS="${LDFLAGS} -L$with_libwrap/lib" + fi + + _libs=${LIBS} + AC_CHECK_HEADER(tcpd.h, + LIBS="-lwrap $LIBS" + AC_MSG_CHECKING(for TCP wrappers library -lwrap) + AC_TRY_LINK([#include +int allow_severity = 0; +int deny_severity = 0; + +struct request_info *req; +],[hosts_access (req)], + AC_MSG_RESULT(yes) + AC_DEFINE(LIBWRAP) + AC_DEFINE(HAVE_LIBWRAP) + if test "$with_libwrap" != "yes"; then + WRAPLIBS="-L${with_libwrap}/lib" + fi + WRAPLIBS="${WRAPLIBS} -lwrap", + AC_MSG_RESULT(no) + CPPFLAGS=${_cppflags} LDFLAGS=${_ldflags}), + CPPFLAGS=${_cppflags} LDFLAGS=${_ldflags}) + LDFLAGS=${_ldflags} LIBS=${_libs} + ;; + esac +]) +AC_SUBST(WRAPLIBS) + +if test "$IS_LINUX" = "true"; then + AC_MSG_CHECKING([for atomic operations]) + + atom_ops= + AC_TRY_RUN([ +#include +int main() +{ + atomic_t v; + + atomic_set(&v, 23); + atomic_add(5, &v); + return atomic_read(&v) == 28 ? 0 : -1; +} + ], AC_DEFINE(HAVE_ATOMIC_ADD) atom_ops="${atom_ops}atomic_add ", + ) + AC_TRY_RUN([ +#include +int main() +{ + atomic_t v; + + atomic_set(&v, 23); + atomic_sub(5, &v); + return atomic_read(&v) == 18 ? 0 : -1; +} + ], AC_DEFINE(HAVE_ATOMIC_SUB) atom_ops="${atom_ops}atomic_sub ", + ) + + if test -z "$atom_ops"; then atom_ops="no"; fi + AC_MSG_RESULT($atom_ops) + + AC_ARG_WITH(pstack, + [ --with-pstack Use the pstack backtrace library], + [ USE_PSTACK=$withval ], + [ USE_PSTACK=no ]) + pstack_libs= + pstack_dirs= + if test "$USE_PSTACK" = yes -a "$IS_LINUX" = "true" -a "$BASE_MACHINE_TYPE" = "i386" -a "$with_mit_threads" = "no" + then + have_libiberty= have_libbfd= + my_save_LIBS="$LIBS" +dnl I have no idea if this is a good test - can not find docs for libiberty + AC_CHECK_LIB([iberty], [fdmatch], + [have_libiberty=yes + AC_CHECK_LIB([bfd], [bfd_openr], [have_libbfd=yes], , [-liberty])]) + LIBS="$my_save_LIBS" + + if test x"$have_libiberty" = xyes -a x"$have_libbfd" = xyes + then + pstack_dirs='$(top_srcdir)'/pstack + pstack_libs="../pstack/libpstack.a -lbfd -liberty" + # We must link staticly when using pstack + with_mysqld_ldflags="-all-static" + AC_SUBST([pstack_dirs]) + AC_SUBST([pstack_libs]) + AC_DEFINE([USE_PSTACK]) +dnl This check isn't needed, but might be nice to give some feedback.... +dnl AC_CHECK_HEADER(libiberty.h, +dnl have_libiberty_h=yes, +dnl have_libiberty_h=no) + else + USE_PSTACK="no" + fi + else + USE_PSTACK="no" + fi +fi +AM_CONDITIONAL(COMPILE_PSTACK, test "$USE_PSTACK" = "yes") +AC_MSG_CHECKING([if we should use pstack]) +AC_MSG_RESULT([$USE_PSTACK]) + +# Check for gtty if termio.h doesn't exists +if test "$ac_cv_header_termio_h" = "no" -a "$ac_cv_header_termios_h" = "no" +then + AC_CHECK_FUNC(gtty, , AC_CHECK_LIB(compat, gtty)) +fi +# We make a special variable for client library's to avoid including +# thread libs in the client. +NON_THREADED_CLIENT_LIBS="$LIBS" + +AC_MSG_CHECKING([for int8]) +case $SYSTEM_TYPE in + *netware) + AC_MSG_RESULT([no]) + ;; + *) +AC_TRY_RUN([ +#ifdef HAVE_STDLIB_H +#include +#endif + +#ifdef HAVE_STDDEF_H +#include +#endif + +#ifdef HAVE_SYS_TYPES_H +#include +#endif + +int main() +{ + int8 i; + return 0; +} +], AC_DEFINE(HAVE_INT_8_16_32) AC_MSG_RESULT([yes]), AC_MSG_RESULT([no]) +) + ;; +esac + +# +# Some system specific hacks +# + +MAX_C_OPTIMIZE="-O3" +MAX_CXX_OPTIMIZE="-O3" + +case $SYSTEM_TYPE in + *solaris2.7*) + # Solaris 2.7 has a broken /usr/include/widec.h + # Make a fixed copy in ./include + echo "Fixing broken include files for $SYSTEM_TYPE" + echo " - Creating local copy of widec.h" + if test ! -d include + then + mkdir ./include + fi + builddir=`pwd` + sed -e "s|^#if[ ]*!defined(lint) && !defined(__lint)|#if !defined\(lint\) \&\& !defined\(__lint\) \&\& !defined\(getwc\)|" < /usr/include/widec.h > include/widec.h + CFLAGS="$CFLAGS -DHAVE_CURSES_H -I$builddir/include -DHAVE_RWLOCK_T" + CXXFLAGS="$CXXFLAGS -DHAVE_CURSES_H -I$builddir/include -DHAVE_RWLOCK_T" + ;; + *solaris2.8*) + # Solaris 2.8 has a broken /usr/include/widec.h + # Make a fixed copy in ./include + echo "Fixing broken include files for $SYSTEM_TYPE" + echo " - Creating local copy of widec.h" + if test ! -d include + then + mkdir ./include + fi + builddir=`pwd` + sed -e "s|^#if[ ]*!defined(__lint)|#if !defined\(__lint\) \&\& !defined\(getwc\)|" < /usr/include/widec.h > include/widec.h + CFLAGS="$CFLAGS -DHAVE_CURSES_H -I$builddir/include -DHAVE_RWLOCK_T" + CXXFLAGS="$CXXFLAGS -DHAVE_CURSES_H -I$builddir/include -DHAVE_RWLOCK_T" + ;; + *solaris2.5.1*) + echo "Enabling getpass() workaround for Solaris 2.5.1" + CFLAGS="$CFLAGS -DHAVE_BROKEN_GETPASS -DSOLARIS -DHAVE_RWLOCK_T"; + CXXFLAGS="$CXXFLAGS -DHAVE_RWLOCK_T -DSOLARIS" + ;; + *solaris*) + CFLAGS="$CFLAGS -DHAVE_RWLOCK_T" + CXXFLAGS="$CXXFLAGS -DHAVE_RWLOCK_T" + ;; + *SunOS*) + echo "Enabling getpass() workaround for SunOS" + CFLAGS="$CFLAGS -DHAVE_BROKEN_GETPASS -DSOLARIS"; + ;; + *hpux10.20*) + echo "Enabling workarounds for hpux 10.20" + CFLAGS="$CFLAGS -DHAVE_BROKEN_SNPRINTF -DSIGNALS_DONT_BREAK_READ -DDO_NOT_REMOVE_THREAD_WRAPPERS -DHPUX10 -DSIGNAL_WITH_VIO_CLOSE -DHAVE_BROKEN_PTHREAD_COND_TIMEDWAIT -DHAVE_POSIX1003_4a_MUTEX" + CXXFLAGS="$CXXFLAGS -DHAVE_BROKEN_SNPRINTF -D_INCLUDE_LONGLONG -DSIGNALS_DONT_BREAK_READ -DDO_NOT_REMOVE_THREAD_WRAPPERS -DHPUX10 -DSIGNAL_WITH_VIO_CLOSE -DHAVE_BROKEN_PTHREAD_COND_TIMEDWAIT -DHAVE_POSIX1003_4a_MUTEX" + if test "$with_named_thread" = "no" + then + echo "Using --with-named-thread=-lpthread" + with_named_thread="-lcma" + fi + ;; + *hpux11.*) + echo "Enabling workarounds for hpux 11" + CFLAGS="$CFLAGS -DHPUX11 -DHAVE_BROKEN_PREAD -DDONT_USE_FINITE -DHAVE_BROKEN_GETPASS -DNO_FCNTL_NONBLOCK -DDO_NOT_REMOVE_THREAD_WRAPPERS -DHAVE_BROKEN_PTHREAD_COND_TIMEDWAIT" + CXXFLAGS="$CXXFLAGS -DHPUX11 -DHAVE_BROKEN_PREAD -DDONT_USE_FINITE -D_INCLUDE_LONGLONG -DNO_FCNTL_NONBLOCK -DDO_NOT_REMOVE_THREAD_WRAPPERS -DHAVE_BROKEN_PTHREAD_COND_TIMEDWAIT" + if test "$with_named_thread" = "no" + then + echo "Using --with-named-thread=-lpthread" + with_named_thread="-lpthread" + fi + # Fixes for HPUX 11.0 compiler + if test "$ac_cv_prog_gcc" = "no" + then + CFLAGS="$CFLAGS -DHAVE_BROKEN_INLINE" + CXXFLAGS="$CXXFLAGS +O2" + MAX_C_OPTIMIZE="" + MAX_CXX_OPTIMIZE="" + fi + ;; + *rhapsody*) + if test "$ac_cv_prog_gcc" = "yes" + then + CPPFLAGS="$CPPFLAGS -traditional-cpp " + CFLAGS="-DHAVE_CTHREADS_WRAPPER -DDO_NOT_REMOVE_THREAD_WRAPPERS" + CXXFLAGS="-DHAVE_CTHREADS_WRAPPER" + if test $with_named_curses = "no" + then + with_named_curses="" + fi + fi + ;; + *darwin5*) + if test "$ac_cv_prog_gcc" = "yes" + then + FLAGS="-traditional-cpp -DHAVE_DARWIN_THREADS -D_P1003_1B_VISIBLE -DSIGNAL_WITH_VIO_CLOSE -DSIGNALS_DONT_BREAK_READ -DHAVE_BROKEN_REALPATH" + CFLAGS="$CFLAGS $FLAGS" + CXXFLAGS="$CXXFLAGS $FLAGS" + MAX_C_OPTIMIZE="-O" + with_named_curses="" + fi + ;; + *darwin6*) + if test "$ac_cv_prog_gcc" = "yes" + then + FLAGS="-DHAVE_DARWIN_THREADS -D_P1003_1B_VISIBLE -DSIGNAL_WITH_VIO_CLOSE -DSIGNALS_DONT_BREAK_READ -DHAVE_BROKEN_REALPATH" + CFLAGS="$CFLAGS $FLAGS" + CXXFLAGS="$CXXFLAGS $FLAGS" + MAX_C_OPTIMIZE="-O" + fi + ;; + *darwin7*) + if test "$ac_cv_prog_gcc" = "yes" + then + FLAGS="-DHAVE_DARWIN_THREADS -D_P1003_1B_VISIBLE -DSIGNAL_WITH_VIO_CLOSE -DSIGNALS_DONT_BREAK_READ" + CFLAGS="$CFLAGS $FLAGS" + CXXFLAGS="$CXXFLAGS $FLAGS" + MAX_C_OPTIMIZE="-O" + fi + ;; + *freebsd*) + echo "Adding fix for interrupted reads" + OSVERSION=`sysctl -a | grep osreldate | awk '{ print $2 }'` + if test "$OSVERSION" -gt "480100" && \ + test "$OSVERSION" -lt "500000" || \ + test "$OSVERSION" -gt "500109" + then + CXXFLAGS="$CXXFLAGS -DMYSQLD_NET_RETRY_COUNT=1000000" + else + CFLAGS="$CFLAGS -DHAVE_BROKEN_REALPATH" + CXXFLAGS="$CXXFLAGS -DMYSQLD_NET_RETRY_COUNT=1000000 -DHAVE_BROKEN_REALPATH" + fi + ;; + *netbsd*) + echo "Adding flag -Dunix" + CFLAGS="$CFLAGS -Dunix" + CXXFLAGS="$CXXFLAGS -Dunix" + OVERRIDE_MT_LD_ADD="\$(top_srcdir)/mit-pthreads/obj/libpthread.a" + ;; + *bsdi*) + echo "Adding fix for BSDI" + CFLAGS="$CFLAGS -D__BSD__ -DHAVE_BROKEN_REALPATH" + AC_DEFINE_UNQUOTED(SOCKOPT_OPTLEN_TYPE, size_t) + ;; + *sgi-irix6*) + if test "$with_named_thread" = "no" + then + echo "Using --with-named-thread=-lpthread" + with_named_thread="-lpthread" + fi + CXXFLAGS="$CXXFLAGS -D_BOOL" + ;; + *aix4.3*) + echo "Adding defines for AIX" + CFLAGS="$CFLAGS -Wa,-many -DUNDEF_HAVE_INITGROUPS -DSIGNALS_DONT_BREAK_READ" + CXXFLAGS="$CXXFLAGS -Wa,-many -DUNDEF_HAVE_INITGROUPS -DSIGNALS_DONT_BREAK_READ" + ;; +dnl Is this the right match for DEC OSF on alpha? + *dec-osf*) + if test "$ac_cv_prog_gcc" = "yes" && test "$host_cpu" = "alpha" + then + echo "Adding defines for DEC OSF on alpha" + CFLAGS="$CFLAGS -mieee" + CXXFLAGS="$CXXFLAGS -mieee" + fi + echo "Adding defines for OSF1" + # gethostbyname_r is deprecated and doesn't work ok on OSF1 + CFLAGS="$CFLAGS -DUNDEF_HAVE_GETHOSTBYNAME_R" + CXXFLAGS="$CXXFLAGS -DUNDEF_HAVE_GETHOSTBYNAME_R" + ;; + *netware*) + # No need for curses library so set it to null + with_named_curses="" + + # No thread library - in LibC + with_named_thread="" + + # + # Edit Makefile.in files. + # + echo -n "configuring Makefile.in files for NetWare... " + for file in sql/Makefile.in libmysql/Makefile.in libmysql_r/Makefile.in sql/share/Makefile.in strings/Makefile.in client/Makefile.in + do + # echo "#### $file ####" + filedir="`dirname $file`" + filebase="`basename $file`" + filesed=$filedir/$filebase.sed + # + # Backup and always use original file + # + if test -f $file.bk + then + cp -fp $file.bk $file + else + cp -fp $file $file.bk + fi + case $file in + sql/Makefile.in) + # Use gen_lex_hash.linux instead of gen_lex_hash + # Add library dependencies to mysqld_DEPENDENCIES + lib_DEPENDENCIES="\$(bdb_libs_with_path) \$(innodb_libs) \$(pstack_libs) \$(innodb_system_libs) \$(openssl_libs)" + cat > $filesed << EOF +s,\(^.*\$(MAKE) gen_lex_hash\),#\1, +s,\(\./gen_lex_hash\),\1.linux, +s%\(mysqld_DEPENDENCIES = \) %\1$lib_DEPENDENCIES % +EOF + ;; + sql/share/Makefile.in) + cat > $filesed << EOF +s,\(extra/comp_err\),\1.linux, +EOF + ;; + libmysql/Makefile.in) + cat > $filesed << EOF +s,\(\./conf_to_src\)\( \$(top_srcdir)\),\1.linux\2, +s,\(: conf_to_src\),\1.linux, +EOF + ;; + libmysql_r/Makefile.in) + cat > $filesed << EOF +s,\(\./conf_to_src\)\( \$(top_srcdir)\),\1.linux\2, +s,\(: conf_to_src\),\1.linux, +EOF + ;; + strings/Makefile.in) + cat > $filesed << EOF +s,\(\./conf_to_src\)\( \$(top_srcdir)\),\1.linux\2, +s,\(: conf_to_src\),\1.linux, +EOF + ;; + client/Makefile.in) + # + cat > $filesed << EOF +s,libmysqlclient.la,.libs/libmysqlclient.a, +EOF + ;; + esac + if `sed -f $filesed $file > $file.nw`;\ + then + mv -f $file.nw $file + rm -f $filesed + else + exit 1 + fi + # wait for file system changes to complete + sleep 1 + done + echo "done" + + # + # Make sure the following files are writable. + # + # When the files are retrieved from some source code control systems they are read-only. + # + echo -n "making sure specific build files are writable... " + for file in \ + Docs/include.texi \ + Docs/mysql.info \ + Docs/manual.txt \ + Docs/manual_toc.html \ + Docs/manual.html \ + Docs/INSTALL-BINARY \ + INSTALL-SOURCE \ + COPYING \ + COPYING.LIB \ + MIRRORS + do + if test -e $file; then + chmod +w $file + fi + done + echo "done" + + ;; +esac + + +#---START: Used in for client configure +# Check if we threads are in libc or if we should use +# -lpthread, -lpthreads or mit-pthreads +# We have to check libc last because else it fails on Solaris 2.6 + +with_posix_threads="no" +# Hack for DEC-UNIX (OSF1) +if test "$with_named_thread" = "no" -a "$with_mit_threads" = "no" +then + # Look for LinuxThreads. + AC_MSG_CHECKING("LinuxThreads") + res=`grep Linuxthreads /usr/include/pthread.h 2>/dev/null | wc -l` + if test "$res" -gt 0 + then + AC_MSG_RESULT("Found") + AC_DEFINE(HAVE_LINUXTHREADS) + # Linux 2.0 sanity check + AC_TRY_COMPILE([#include ], [int a = sched_get_priority_min(1);], , + AC_MSG_ERROR([Syntax error in sched.h. Change _P to __P in the /usr/include/sched.h file. See the Installation chapter in the Reference Manual])) + # RedHat 5.0 does not work with dynamic linking of this. -static also + # gives a speed increase in linux so it does not hurt on other systems. + with_named_thread="-lpthread" + else + AC_MSG_RESULT("Not found") + # If this is a linux machine we should barf + if test "$IS_LINUX" = "true" + then + AC_MSG_ERROR([This is a linux system and Linuxthreads was not +found. On linux Linuxthreads should be used. Please install Linuxthreads +(or a new glibc) and try again. See the Installation chapter in the +Reference Manual for more information.]) + else + AC_MSG_CHECKING("DEC threads") + if test -f /usr/shlib/libpthread.so -a -f /usr/lib/libmach.a -a -f /usr/ccs/lib/cmplrs/cc/libexc.a + then + with_named_thread="-lpthread -lmach -lexc" + CFLAGS="$CFLAGS -D_REENTRANT" + CXXFLAGS="$CXXFLAGS -D_REENTRANT" + AC_DEFINE(HAVE_DEC_THREADS) + AC_MSG_RESULT("yes") + else + AC_MSG_RESULT("no") + AC_MSG_CHECKING("DEC 3.2 threads") + if test -f /usr/shlib/libpthreads.so -a -f /usr/lib/libmach.a -a -f /usr/ccs/lib/cmplrs/cc/libexc.a + then + with_named_thread="-lpthreads -lmach -lc_r" + AC_DEFINE(HAVE_DEC_THREADS) + AC_DEFINE(HAVE_DEC_3_2_THREADS) + with_osf32_threads="yes" + MYSQLD_DEFAULT_SWITCHES="--skip-thread-priority" + AC_MSG_RESULT("yes") + else + AC_MSG_RESULT("no") + fi + fi + fi + fi +fi + + +dnl This is needed because -lsocket has to come after the thread +dnl library on SCO. +AC_DEFUN([MYSQL_REMOVE_SOCKET_FROM_LIBS_HACK], [ + LIBS=`echo " $LIBS " | sed -e 's/ -lsocket / /g'` +]) +# Hack for SCO UNIX +if test "$with_named_thread" = "no" +then + AC_MSG_CHECKING("SCO threads") + if expr "$SYSTEM_TYPE" : ".*sco.*" > /dev/null + then + if test -f /usr/lib/libgthreads.a -o -f /usr/lib/libgthreads.so + then + MYSQL_REMOVE_SOCKET_FROM_LIBS_HACK + with_named_thread="-lgthreads -lsocket -lgthreads" + # sched.h conflicts with fsu-threads + touch ./include/sched.h + + # We must have gcc + if expr "$CC" : ".*gcc.*" + then + AC_MSG_RESULT("yes") + else + AC_MSG_ERROR([On SCO UNIX MySQL must be compiled with gcc. See the Installation chapter in the Reference Manual.]); + fi + AC_MSG_RESULT("yes") + elif test -f /usr/local/lib/libpthread.a -o -f /usr/local/lib/libpthread.so + then + MYSQL_REMOVE_SOCKET_FROM_LIBS_HACK + with_named_thread="-lpthread -lsocket" + # sched.h conflicts with fsu-threads + # touch ./include/sched.h + + AC_MSG_CHECKING("for gcc") + # We must have gcc + if expr "$CC" : ".*gcc.*" + then + AC_MSG_RESULT("yes") + else + AC_MSG_ERROR([On SCO UNIX MySQL must be compiled with gcc. See the Installation chapter in the Reference Manual.]); + fi + AC_MSG_RESULT("yes") + # Hack for SCO UnixWare 7.1.x + # + elif test "$with_named_thread" = "no" + then + AC_MSG_RESULT("no") + AC_MSG_CHECKING("SCO UnixWare 7.1.x native threads") + if expr "$SYSTEM_TYPE" : ".*sco.*" > /dev/null + then + if test -f /usr/lib/libthread.so -o -f /usr/lib/libthreadT.so + then + MYSQL_REMOVE_SOCKET_FROM_LIBS_HACK + if expr "$CC" : ".*gcc.*" + then + with_named_thread="-pthread -lsocket -lnsl" + else + with_named_thread="-Kthread -lsocket -lnsl" + fi + if expr "$SYSTEM_TYPE" : ".*unixware7.0.0" > /dev/null + then + AC_DEFINE(HAVE_UNIXWARE7_THREADS) + else + AC_DEFINE(HAVE_UNIXWARE7_POSIX) + fi + AC_MSG_RESULT("yes") + # We must have cc + AC_MSG_CHECKING("for gcc") + if expr "$CC" : ".*gcc.*" + then + CC="$CC -pthread -DUNIXWARE_7 -DHAVE_BROKEN_RWLOCK"; + CXX="$CXX -pthread -DUNIXWARE_7 -DHAVE_BROKEN_RWLOCK"; + else + CC="$CC -Kthread -DUNIXWARE_7 -DHAVE_BROKEN_RWLOCK"; + CXX="$CXX -Kthread -DUNIXWARE_7 -DHAVE_BROKEN_RWLOCK"; + fi + else + { echo "configure: error: Can't find thread libs on SCO UnixWare7. See the Installation chapter in the Reference Manual." 1>&2; exit 1; }; + fi + else + AC_MSG_RESULT("no") + fi + else + AC_MSG_ERROR([On SCO UNIX MySQL requires that the FSUThreads package is installed. See the Installation chapter in the Reference Manual.]); + fi + else + AC_MSG_RESULT("no") + fi +fi +# Hack for SCO UnixWare7 +# +if test "$with_named_thread" = "no" +then + AC_MSG_CHECKING("SCO UnixWare7 native threads") + if expr "$SYSTEM_TYPE" : ".*UnixWare*" > /dev/null + then + if test -f /usr/lib/libthread.so -o -f /usr/lib/libthreadT.so + then + MYSQL_REMOVE_SOCKET_FROM_LIBS_HACK + if expr "$CC" : ".*gcc.*" + then + with_named_thread="-pthread -lsocket -lnsl" + else + with_named_thread="-Kthread -lsocket -lnsl" + fi + if expr "$SYSTEM_TYPE" : ".*unixware7.0.0" > /dev/null + then + AC_DEFINE(HAVE_UNIXWARE7_THREADS) + else + AC_DEFINE(HAVE_UNIXWARE7_POSIX) + fi + # We must have cc + AC_MSG_CHECKING("for gcc") + if expr "$CC" : ".*gcc.*" + then + CC="$CC -pthread -DUNIXWARE_7 -DHAVE_BROKEN_RWLOCK"; + CXX="$CXX -pthread -DUNIXWARE_7 -DHAVE_BROKEN_RWLOCK"; + else + CC="$CC -Kthread -DUNIXWARE_7 -DHAVE_BROKEN_RWLOCK"; + CXX="$CXX -Kthread -DUNIXWARE_7 -DHAVE_BROKEN_RWLOCK"; + fi + AC_MSG_RESULT("yes") + else + { echo "configure: error: Can't find thread libs on SCO UnixWare7. See the Installation chapter in the Reference Manual." 1>&2; exit 1; }; + fi + else + AC_MSG_RESULT("no") + fi +fi + +# Hack for Caldera OpenUNIX8 +# +if test "$with_named_thread" = "no" +then + AC_MSG_CHECKING("OpenUNIX8 native threads") + if expr "$SYSTEM_TYPE" : ".*OpenUNIX*" > /dev/null + then + if test -f /usr/lib/libthread.so -o -f /usr/lib/libthreadT.so + then + MYSQL_REMOVE_SOCKET_FROM_LIBS_HACK + if expr "$CC" : ".*gcc.*" + then + with_named_thread="-pthread -lsocket -lnsl" + else + with_named_thread="-Kthread -lsocket -lnsl" + fi + if expr "$SYSTEM_TYPE" : ".*unixware7.0.0" > /dev/null + then + AC_DEFINE(HAVE_UNIXWARE7_THREADS) + else + AC_DEFINE(HAVE_UNIXWARE7_POSIX) + fi + # We must have cc + AC_MSG_CHECKING("for gcc") + if expr "$CC" : ".*gcc.*" + then + CC="$CC -pthread -DUNIXWARE_7 -DHAVE_BROKEN_RWLOCK"; + CXX="$CXX -pthread -DUNIXWARE_7 -DHAVE_BROKEN_RWLOCK"; + else + CC="$CC -Kthread -DUNIXWARE_7 -DHAVE_BROKEN_RWLOCK"; + CXX="$CXX -Kthread -DUNIXWARE_7 -DHAVE_BROKEN_RWLOCK"; + fi + AC_MSG_RESULT("yes") + else + { echo "configure: error: Can't find thread libs on Caldera OpenUNIX 8. See the Installation chapter in the Reference Manual." 1>&2; exit 1; }; + fi + else + AC_MSG_RESULT("no") + fi +fi + +# Hack for Siemens UNIX +if test "$with_named_thread" = "no" -a "$with_mit_threads" = "no" +then + AC_MSG_CHECKING("Siemens threads") + if test -f /usr/lib/libxnet.so -a "$SYSTEM_TYPE" = "sni-sysv4" + then + LIBS="-lxnet $LIBS" + NON_THREADED_CLIENT_LIBS="$NON_THREADED_CLIENT_LIBS -lxnet" + with_named_thread="-Kthread $LDFLAGS -lxnet" + LD_FLAGS="" + CFLAGS="-Kthread $CFLAGS" + CXXFLAGS="-Kthread $CXXFLAGS" + AC_MSG_RESULT("yes") + else + AC_MSG_RESULT("no") + fi +fi + +# Use library named -lpthread +if test "$with_named_thread" = "no" -a "$with_pthread" = "yes" +then + with_named_thread="-lpthread" +fi + +#---END: + +# Hack for Solaris >= 2.5 +# We want both the new and the old interface + +if test "$with_named_thread" = "no" -a "$with_mit_threads" = "no" +then + AC_MSG_CHECKING("Solaris threads") + if test -f /usr/lib/libpthread.so -a -f /usr/lib/libthread.so + then + with_named_thread="-lpthread -lthread" + AC_MSG_RESULT("yes") + else + AC_MSG_RESULT("no") + fi +fi + +TOOLS_LIBS="$NON_THREADED_CLIENT_LIBS" + +# Should we use named pthread library ? +AC_MSG_CHECKING("named thread libs:") +if test "$with_named_thread" != "no" +then + LIBS="$with_named_thread $LIBS $with_named_thread" + TOOLS_LIBS="$with_named_thread $TOOLS_LIBS $with_named_thread" + with_posix_threads="yes" + with_mit_threads="no" + AC_MSG_RESULT("$with_named_thread") +else + AC_MSG_RESULT("no") + if test "$with_mit_threads" = "no" + then + # pthread_create is in standard libraries (As in BSDI 3.0) + AC_MSG_CHECKING("for pthread_create in -libc"); + AC_TRY_LINK( + [#include ], + [ (void) pthread_create((pthread_t*) 0,(pthread_attr_t*) 0, 0, 0); ], + with_posix_threads=yes, with_posix_threads=no) + AC_MSG_RESULT("$with_posix_threads") + if test "$with_posix_threads" = "no" + then + AC_MSG_CHECKING("for pthread_create in -lpthread"); + ac_save_LIBS="$LIBS" + ac_save_TOOLS_LIBS="$TOOLS_LIBS" + LIBS="$LIBS -lpthread" + TOOLS_LIBS="$TOOLS_LIBS -lpthread" + AC_TRY_LINK( + [#include ], + [ (void) pthread_create((pthread_t*) 0,(pthread_attr_t*) 0, 0, 0); ], + with_posix_threads=yes, with_posix_threads=no) + AC_MSG_RESULT("$with_posix_threads") + if test "$with_posix_threads" = "no" + then + LIBS=" $ac_save_LIBS -lpthreads" + TOOLS_LIBS=" $ac_save_TOOLS_LIBS -lpthreads" + AC_MSG_CHECKING("for pthread_create in -lpthreads"); + AC_TRY_LINK( + [#include ], + [ pthread_create((pthread_t*) 0,(pthread_attr_t*) 0, 0, 0); ], + with_posix_threads=yes, with_posix_threads=no) + AC_MSG_RESULT("$with_posix_threads") + if test "$with_posix_threads" = "no" + then + # This is for FreeBSD + LIBS="$ac_save_LIBS -pthread" + TOOLS_LIBS="$ac_save_TOOLS_LIBS -pthread" + AC_MSG_CHECKING("for pthread_create in -pthread"); + AC_TRY_LINK( + [#include ], + [ pthread_create((pthread_t*) 0,(pthread_attr_t*) 0, 0, 0); ], + with_posix_threads=yes, with_posix_threads=no) + AC_MSG_RESULT("$with_posix_threads") + if test "$with_posix_threads" = "no" + then + with_mit_threads="yes" + LIBS="$ac_save_LIBS" + TOOLS_LIBS="$ac_save_TOOLS_LIBS" + fi + fi + fi + fi + fi +fi + +#---START: Used in for client configure +# Must be checked after, because strtok_r may be in -lpthread +# On AIX strtok_r is in libc_r + +my_save_LIBS="$LIBS" +AC_CHECK_LIB(pthread,strtok_r) +LIBS="$my_save_LIBS" +if test "$ac_cv_lib_pthread_strtok_r" = "no" +then + AC_CHECK_LIB(c_r,strtok_r) + case "$with_osf32_threads---$target_os" in + # Don't keep -lc_r in LIBS; -pthread handles it magically + yes---* | *---freebsd* | *---hpux*) LIBS="$my_save_LIBS" ;; + + esac + AC_CHECK_FUNCS(strtok_r pthread_init) +else + AC_CHECK_FUNCS(strtok_r) +fi +#---END: + +# Check for dlopen, needed for user definable functions +# This must be checked after threads on AIX +# We only need this for mysqld, not for the clients. + +my_save_LIBS="$LIBS" +LIBS="" +AC_CHECK_LIB(dl,dlopen) +LIBDL=$LIBS +LIBS="$my_save_LIBS" +AC_SUBST(LIBDL) + +# System characteristics +case $SYSTEM_TYPE in + *netware* | *modesto*) ;; + *) +AC_SYS_RESTARTABLE_SYSCALLS + ;; +esac + +# Build optimized or debug version ? +# First check for gcc and g++ +if test "$ac_cv_prog_gcc" = "yes" +then + DEBUG_CFLAGS="-g" + DEBUG_OPTIMIZE_CC="-O" + OPTIMIZE_CFLAGS="$MAX_C_OPTIMIZE" +else + DEBUG_CFLAGS="-g" + DEBUG_OPTIMIZE_CC="" + OPTIMIZE_CFLAGS="-O" +fi +if test "$ac_cv_prog_cxx_g" = "yes" +then + DEBUG_CXXFLAGS="-g" + DEBUG_OPTIMIZE_CXX="-O" + OPTIMIZE_CXXFLAGS="$MAX_CXX_OPTIMIZE" +else + DEBUG_CXXFLAGS="-g" + DEBUG_OPTIMIZE_CXX="" + OPTIMIZE_CXXFLAGS="-O" +fi + +if expr "$SYSTEM_TYPE" : ".*netware.*" > /dev/null; then + DEBUG_CFLAGS="$DEBUG_CFLAGS -DDEBUG -sym internal,codeview4" + DEBUG_CXXFLAGS="$DEBUG_CXXFLAGS -DDEBUG -sym internal,codeview4" + OPTIMIZE_CFLAGS="$OPTIMIZE_CFLAGS -DNDEBUG" + OPTIMIZE_CXXFLAGS="$OPTIMIZE_CXXFLAGS -DNDEBUG" +fi + +AC_ARG_WITH(debug, + [ --without-debug Build a production version without debugging code], + [with_debug=$withval], + [with_debug=no]) +if test "$with_debug" = "yes" +then + # Medium debug. + CFLAGS="$DEBUG_CFLAGS $DEBUG_OPTIMIZE_CC -DDBUG_ON -DSAFE_MUTEX $CFLAGS" + CXXFLAGS="$DEBUG_CXXFLAGS $DEBUG_OPTIMIZE_CXX -DSAFE_MUTEX $CXXFLAGS" +elif test "$with_debug" = "full" +then + # Full debug. Very slow in some cases + CFLAGS="$DEBUG_CFLAGS -DDBUG_ON -DSAFE_MUTEX -DSAFEMALLOC $CFLAGS" + CXXFLAGS="$DEBUG_CXXFLAGS -DSAFE_MUTEX -DSAFEMALLOC $CXXFLAGS" +else + # Optimized version. No debug + CFLAGS="$OPTIMIZE_CFLAGS -DDBUG_OFF $CFLAGS" + CXXFLAGS="$OPTIMIZE_CXXFLAGS -DDBUG_OFF $CXXFLAGS" +fi + +# Force static compilation to avoid linking problems/get more speed +AC_ARG_WITH(mysqld-ldflags, + [ --with-mysqld-ldflags Extra linking arguments for mysqld], + [MYSQLD_EXTRA_LDFLAGS=$withval], + [MYSQLD_EXTRA_LDFLAGS=]) +AC_SUBST(MYSQLD_EXTRA_LDFLAGS) + +AC_ARG_WITH(client-ldflags, + [ --with-client-ldflags Extra linking arguments for clients], + [CLIENT_EXTRA_LDFLAGS=$withval], + [CLIENT_EXTRA_LDFLAGS=]) +AC_SUBST(CLIENT_EXTRA_LDFLAGS) + +AC_ARG_WITH(lib-ccflags, + [ --with-lib-ccflags Extra CC options for libraries], + [LIB_EXTRA_CCFLAGS=$withval], + [LIB_EXTRA_CCFLAGS=]) +AC_SUBST(LIB_EXTRA_CCFLAGS) + +# Avoid stupid bug on some OS +AC_ARG_WITH(low-memory, + [ --with-low-memory Try to use less memory to compile to avoid + memory limitations.], + [with_lowmem=$withval], + [with_lowmem=no]) +if test "$with_lowmem" = "yes" +then + if test "$ac_cv_prog_gcc" = "yes" + then + LM_CFLAGS="-fno-inline" + else + LM_CFLAGS="-O0" + fi +else + LM_CFLAGS="" +fi +AC_SUBST(LM_CFLAGS) + +AC_ARG_WITH(comment, + [ --with-comment Comment about compilation environment.], + [with_comment=$withval], + [with_comment=no]) +if test "$with_comment" != "no" +then + COMPILATION_COMMENT=$with_comment +else + COMPILATION_COMMENT="Source distribution" +fi +AC_SUBST(COMPILATION_COMMENT) + +AC_MSG_CHECKING("need of special linking flags") +if test "$IS_LINUX" = "true" -a "$ac_cv_prog_gcc" = "yes" -a "$all_is_static" != "yes" +then + LDFLAGS="$LDFLAGS -rdynamic" + AC_MSG_RESULT("-rdynamic") +else + AC_MSG_RESULT("none") +fi + +dnl Checks for typedefs, structures, and compiler characteristics. +AC_C_CONST +AC_C_INLINE +AC_TYPE_OFF_T +AC_STRUCT_ST_RDEV +AC_HEADER_TIME +AC_STRUCT_TM +# AC_CHECK_SIZEOF return 0 when it does not find the size of a +# type. We want a error instead. +AC_CHECK_SIZEOF(char, 1) +if test "$ac_cv_sizeof_char" -eq 0 +then + AC_MSG_ERROR([No size for char type. +A likely cause for this could be that there isn't any +static libraries installed. You can verify this by checking if you have libm.a +in /lib, /usr/lib or some other standard place. If this is the problem, +install the static libraries and try again. If this isn't the problem, +examine config.log for possible errors. If you want to report this, use +'scripts/mysqlbug' and include at least the last 20 rows from config.log!]) +fi +AC_CHECK_SIZEOF(char*, 4) +AC_CHECK_SIZEOF(int, 4) +if test "$ac_cv_sizeof_int" -eq 0 +then + AC_MSG_ERROR("No size for int type.") +fi +AC_CHECK_SIZEOF(long, 4) +if test "$ac_cv_sizeof_long" -eq 0 +then + AC_MSG_ERROR("No size for long type.") +fi +AC_CHECK_SIZEOF(long long, 8) +if test "$ac_cv_sizeof_long_long" -eq 0 +then + AC_MSG_ERROR("MySQL needs a long long type.") +fi +# off_t is not a builtin type +MYSQL_CHECK_SIZEOF(off_t, 4) +if test "$ac_cv_sizeof_off_t" -eq 0 +then + AC_MSG_ERROR("MySQL needs a off_t type.") +fi +# This always gives a warning. Ignore it unless you are cross compiling +AC_C_BIGENDIAN +#---START: Used in for client configure +# Check base type of last arg to accept +MYSQL_TYPE_ACCEPT + +#---END: +# Find where the stack goes +MYSQL_STACK_DIRECTION +# We want to skip alloca on irix unconditionally. It may work on some version.. +MYSQL_FUNC_ALLOCA +# Do struct timespec have members tv_sec or ts_sec +MYSQL_TIMESPEC_TS +# Do we have the tzname variable +MYSQL_TZNAME +# Do the system files define ulong +MYSQL_CHECK_ULONG +# Do the system files define uchar +MYSQL_CHECK_UCHAR +# Do the system files define uint +MYSQL_CHECK_UINT +# Check for fp_except in ieeefp.h +MYSQL_CHECK_FP_EXCEPT +# Check for IN_ADDR_T +MYSQL_CHECK_IN_ADDR_T +# Do the c++ compiler have a bool type +MYSQL_CXX_BOOL +# Check some common bugs with gcc 2.8.# on sparc +if ! ( expr "$SYSTEM_TYPE" : ".*netware.*" > /dev/null ); then +MYSQL_CHECK_LONGLONG_TO_FLOAT +if test "$ac_cv_conv_longlong_to_float" != "yes" +then + AC_MSG_ERROR([Your compiler cannot convert a longlong value to a float! +If you are using gcc 2.8.# you should upgrade to egcs 1.0.3 or newer and try +again]); +fi +fi +MYSQL_PTHREAD_YIELD + +###################################################################### +# For readline/libedit (We simply move the mimimum amount of stuff from +# the readline/libedit configure.in here) + +dnl Checks for header files. +AC_CHECK_HEADERS(malloc.h sys/cdefs.h) + +dnl Checks for library functions. +AC_FUNC_ALLOCA +AC_PROG_GCC_TRADITIONAL +AC_TYPE_SIGNAL +AC_CHECK_FUNCS(re_comp regcomp strdup) + +AC_CHECK_HEADERS(vis.h) +AC_CHECK_FUNCS(strlcat strlcpy) +AC_CHECK_FUNCS(issetugid) +AC_CHECK_FUNCS(fgetln) +AC_CHECK_FUNCS(getline flockfile) + +# from old readline settting: + +MAKE_SHELL=/bin/sh +AC_SUBST(MAKE_SHELL) + +# Already-done: stdlib.h string.h unistd.h termios.h +AC_CHECK_HEADERS(varargs.h stdarg.h dirent.h locale.h ndir.h sys/dir.h \ + sys/file.h sys/ndir.h sys/ptem.h sys/pte.h sys/select.h sys/stream.h \ + sys/mman.h curses.h termcap.h termio.h termbits.h asm/termbits.h grp.h \ +paths.h semaphore.h) + +# Already-done: strcasecmp +AC_CHECK_FUNCS(lstat putenv select setenv setlocale strcoll tcgetattr) + +AC_STAT_MACROS_BROKEN +MYSQL_SIGNAL_CHECK +MYSQL_CHECK_GETPW_FUNCS +MYSQL_HAVE_TIOCGWINSZ +MYSQL_HAVE_FIONREAD +MYSQL_HAVE_TIOCSTAT +MYSQL_STRUCT_DIRENT_D_INO +MYSQL_TYPE_SIGHANDLER +if test "$with_named_curses" = "no" +then + MYSQL_CHECK_LIB_TERMCAP +else + TERMCAP_LIB="$with_named_curses" +fi +AC_SUBST(TERMCAP_LIB) + +# End of readline/libedit stuff +######################################################################### + +dnl Checks for library functions. + +# +# The following code disables intrinsic function support while we test for +# library functions. This is to avoid configure problems with Intel ecc +# compiler + +ORG_CFLAGS="$CFLAGS" +if test "$GCC" != "yes"; then + AC_SYS_COMPILER_FLAG(-nolib_inline,nolib_inline,CFLAGS,[],[]) +fi + +AC_FUNC_MMAP +AC_TYPE_SIGNAL +MYSQL_TYPE_QSORT +AC_FUNC_UTIME_NULL +AC_FUNC_VPRINTF + +AC_CHECK_FUNCS(alarm bcmp bfill bmove bzero chsize cuserid fchmod fcntl \ + fconvert fdatasync finite fpresetsticky fpsetmask fsync ftruncate \ + getcwd gethostbyaddr_r gethostbyname_r getpass getpassphrase getpwnam \ + getpwuid getrlimit getrusage getwd gmtime_r index initgroups isnan \ + localtime_r locking longjmp lrand48 madvise mallinfo memcpy memmove \ + mkstemp mlockall perror poll pread pthread_attr_create clock_gettime \ + pthread_attr_getstacksize pthread_attr_setprio pthread_attr_setschedparam \ + pthread_attr_setstacksize pthread_condattr_create pthread_getsequence_np \ + pthread_key_delete pthread_rwlock_rdlock pthread_setprio \ + pthread_setprio_np pthread_setschedparam pthread_sigmask readlink \ + realpath rename rint rwlock_init setupterm sighold sigset sigthreadmask \ + snprintf socket stpcpy strcasecmp strerror strnlen strpbrk strstr strtol \ + strtoll strtoul strtoull tell tempnam thr_setconcurrency vidattr) + +# isinf() could be a function or a macro (HPUX) +AC_MSG_CHECKING(for isinf with ) +AC_TRY_LINK([#include ], [float f = 0.0; isinf(f)], + AC_MSG_RESULT(yes) AC_DEFINE(HAVE_ISINF,,[isinf() macro or function]), + AC_MSG_RESULT(no)) + +CFLAGS="$ORG_CFLAGS" + +# Sanity check: We chould not have any fseeko symbol unless +# large_file_support=yes +AC_CHECK_FUNC(fseeko, +[if test "$large_file_support" = no -a "$IS_LINUX" = "true"; +then + AC_MSG_ERROR("Found fseeko symbol but large_file_support is not enabled!"); +fi] +) + +my_save_LIBS="$LIBS" +LIBS="$LIBS $LIBDL" +AC_CHECK_FUNCS(dlopen dlerror) +LIBS="$my_save_LIBS" + +# Check definition of gethostbyaddr_r (glibc2 defines this with 8 arguments) +ac_save_CXXFLAGS="$CXXFLAGS" +AC_CACHE_CHECK([style of gethost* routines], mysql_cv_gethost_style, +AC_LANG_SAVE +AC_LANG_CPLUSPLUS + +# Do not treat warnings as errors if we are linking against other libc +# this is to work around gcc not being permissive on non-system includes +# with respect to ANSI C++ +# We also remove the -fbranch-probabilities option as this will give warnings +# about not profiled code, which confuses configure +if test "$ac_cv_prog_gxx" = "yes" -a "$with_other_libc" = "no" +then + CXXFLAGS=`echo "$CXXFLAGS -Werror" | sed 's/-fbranch-probabilities//'` +fi + +AC_TRY_COMPILE( +[#undef inline +#if !defined(SCO) && !defined(__osf__) && !defined(_REENTRANT) +#define _REENTRANT +#endif +#include +#include +#include +#include +#include +#include ], +[int skr; + struct hostent *foo = gethostbyaddr_r((const char *) 0, + 0, 0, (struct hostent *) 0, (char *) NULL, 0, &skr); return (foo == 0);], +mysql_cv_gethost_style=solaris, mysql_cv_gethost_style=other)) +AC_LANG_RESTORE +CXXFLAGS="$ac_save_CXXFLAGS" +if test "$mysql_cv_gethost_style" = "solaris" +then + AC_DEFINE(HAVE_SOLARIS_STYLE_GETHOST) +fi + +#---START: Used in for client configure + +# Check definition of gethostbyname_r (glibc2.0.100 is different from Solaris) +ac_save_CXXFLAGS="$CXXFLAGS" +AC_CACHE_CHECK([style of gethostname_r routines], mysql_cv_gethostname_style, +AC_LANG_SAVE +AC_LANG_CPLUSPLUS +if test "$ac_cv_prog_gxx" = "yes" -a "$with_other_libc" = "no" +then + CXXFLAGS=`echo "$CXXFLAGS -Werror" | sed 's/-fbranch-probabilities//'` +fi +AC_TRY_COMPILE( +[#undef inline +#if !defined(SCO) && !defined(__osf__) && !defined(_REENTRANT) +#define _REENTRANT +#endif +#include +#include +#include +#include +#include +#include ], +[int skr; + + skr = gethostbyname_r((const char *) 0, + (struct hostent*) 0, (char*) 0, 0, (struct hostent **) 0, &skr);], +mysql_cv_gethostname_style=glibc2, mysql_cv_gethostname_style=other)) +AC_LANG_RESTORE +CXXFLAGS="$ac_save_CXXFLAGS" +if test "$mysql_cv_gethostname_style" = "glibc2" +then + AC_DEFINE(HAVE_GETHOSTBYNAME_R_GLIBC2_STYLE) +fi + +# Check 3rd argument of getthostbyname_r +ac_save_CXXFLAGS="$CXXFLAGS" +AC_CACHE_CHECK([3 argument to gethostname_r routines], mysql_cv_gethostname_arg, +AC_LANG_SAVE +AC_LANG_CPLUSPLUS +if test "$ac_cv_prog_gxx" = "yes" -a "$with_other_libc" = "no" +then + CXXFLAGS=`echo "$CXXFLAGS -Werror" | sed 's/-fbranch-probabilities//'` +fi +AC_TRY_COMPILE( +[#undef inline +#if !defined(SCO) && !defined(__osf__) && !defined(_REENTRANT) +#define _REENTRANT +#endif +#include +#include +#include +#include +#include +#include ], +[int skr; + + skr = gethostbyname_r((const char *) 0, (struct hostent*) 0, (struct hostent_data*) 0);], +mysql_cv_gethostname_arg=hostent_data, mysql_cv_gethostname_arg=char)) +AC_LANG_RESTORE +CXXFLAGS="$ac_save_CXXFLAGS" +if test "$mysql_cv_gethostname_arg" = "hostent_data" +then + AC_DEFINE(HAVE_GETHOSTBYNAME_R_RETURN_INT) +fi + + +if test "$with_mit_threads" = "no" +then + # Check definition of pthread_getspecific + AC_CACHE_CHECK("args to pthread_getspecific", mysql_cv_getspecific_args, + AC_TRY_COMPILE( +[#if !defined(SCO) && !defined(__osf__) && !defined(_REENTRANT) +#define _REENTRANT +#endif +#define _POSIX_PTHREAD_SEMANTICS +#include ], +[ void *pthread_getspecific(pthread_key_t key); +pthread_getspecific((pthread_key_t) NULL); ], +mysql_cv_getspecific_args=POSIX, mysql_cv_getspecific_args=other)) + if test "$mysql_cv_getspecific_args" = "other" + then + AC_DEFINE(HAVE_NONPOSIX_PTHREAD_GETSPECIFIC) + fi + + # Check definition of pthread_mutex_init + AC_CACHE_CHECK("args to pthread_mutex_init", mysql_cv_mutex_init_args, + AC_TRY_COMPILE( +[#if !defined(SCO) && !defined(__osf__) +#define _REENTRANT +#endif +#define _POSIX_PTHREAD_SEMANTICS +#include ], +[ + pthread_mutexattr_t attr; + pthread_mutex_t mp; + pthread_mutex_init(&mp,&attr); ], +mysql_cv_mutex_init_args=POSIX, mysql_cv_mutex_init_args=other)) + if test "$mysql_cv_mutex_init_args" = "other" + then + AC_DEFINE(HAVE_NONPOSIX_PTHREAD_MUTEX_INIT) + fi +fi +#---END: + +#---START: Used in for client configure +# Check definition of readdir_r +AC_CACHE_CHECK("args to readdir_r", mysql_cv_readdir_r, +AC_TRY_LINK( +[#if !defined(SCO) && !defined(__osf__) +#define _REENTRANT +#endif +#define _POSIX_PTHREAD_SEMANTICS +#include +#include ], +[ int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result); +readdir_r((DIR *) NULL, (struct dirent *) NULL, (struct dirent **) NULL); ], +mysql_cv_readdir_r=POSIX, mysql_cv_readdir_r=other)) +if test "$mysql_cv_readdir_r" = "POSIX" +then + AC_DEFINE(HAVE_READDIR_R) +fi + +# Check definition of posix sigwait() +AC_CACHE_CHECK("style of sigwait", mysql_cv_sigwait, +AC_TRY_LINK( +[#if !defined(SCO) && !defined(__osf__) +#define _REENTRANT +#endif +#define _POSIX_PTHREAD_SEMANTICS +#include +#include ], +[#ifndef _AIX +sigset_t set; +int sig; +sigwait(&set,&sig); +#endif], +mysql_cv_sigwait=POSIX, mysql_cv_sigwait=other)) +if test "$mysql_cv_sigwait" = "POSIX" +then + AC_DEFINE(HAVE_SIGWAIT) +fi + +if test "$mysql_cv_sigwait" != "POSIX" +then +unset mysql_cv_sigwait +# Check definition of posix sigwait() +AC_CACHE_CHECK("style of sigwait", mysql_cv_sigwait, +AC_TRY_LINK( +[#if !defined(SCO) && !defined(__osf__) +#define _REENTRANT +#endif +#define _POSIX_PTHREAD_SEMANTICS +#include +#include ], +[sigset_t set; +int sig; +sigwait(&set);], +mysql_cv_sigwait=NONPOSIX, mysql_cv_sigwait=other)) +if test "$mysql_cv_sigwait" = "NONPOSIX" +then + AC_DEFINE(HAVE_NONPOSIX_SIGWAIT) +fi +fi +#---END: + +# Check if pthread_attr_setscope() exists +AC_CACHE_CHECK("for pthread_attr_setscope", mysql_cv_pthread_attr_setscope, +AC_TRY_LINK( +[#if !defined(SCO) && !defined(__osf__) +#define _REENTRANT +#endif +#define _POSIX_PTHREAD_SEMANTICS +#include ], +[pthread_attr_t thr_attr; +pthread_attr_setscope(&thr_attr,0);], +mysql_cv_pthread_attr_setscope=yes, mysql_cv_pthread_attr_setscope=no)) +if test "$mysql_cv_pthread_attr_setscope" = "yes" +then + AC_DEFINE(HAVE_PTHREAD_ATTR_SETSCOPE) +fi + +# Check for bad includes +AC_MSG_CHECKING("can netinet files be included") +AC_TRY_COMPILE( +[#include +#include +#include +#include +#include +#include ], +[ printf("1\n"); ], +netinet_inc=yes, netinet_inc=no) +if test "$netinet_inc" = "no" +then + AC_DEFINE(HAVE_BROKEN_NETINET_INCLUDES) +fi +AC_MSG_RESULT("$netinet_inc") + +# Some usefull subst +AC_SUBST(CC) +AC_SUBST(GXX) + +# Output results +AC_OUTPUT(Makefile dnl + , , [ + test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h + ]) diff --git a/ndb/demos/1-node/1-api-3/Ndb.cfg b/ndb/demos/1-node/1-api-3/Ndb.cfg new file mode 100644 index 00000000000..61309af029e --- /dev/null +++ b/ndb/demos/1-node/1-api-3/Ndb.cfg @@ -0,0 +1,2 @@ +OwnProcessId 3 +127.0.0.1 10000 diff --git a/ndb/demos/1-node/1-db-2/Ndb.cfg b/ndb/demos/1-node/1-db-2/Ndb.cfg new file mode 100644 index 00000000000..9315950b67a --- /dev/null +++ b/ndb/demos/1-node/1-db-2/Ndb.cfg @@ -0,0 +1,2 @@ +OwnProcessId 2 +127.0.0.1 10000 diff --git a/ndb/demos/1-node/1-mgm-1/Ndb.cfg b/ndb/demos/1-node/1-mgm-1/Ndb.cfg new file mode 100644 index 00000000000..61d4c0ecc17 --- /dev/null +++ b/ndb/demos/1-node/1-mgm-1/Ndb.cfg @@ -0,0 +1,2 @@ +OwnProcessId 1 +127.0.0.1 10000 diff --git a/ndb/demos/1-node/1-mgm-1/template_config.ini b/ndb/demos/1-node/1-mgm-1/template_config.ini new file mode 100644 index 00000000000..76bb7867e3c --- /dev/null +++ b/ndb/demos/1-node/1-mgm-1/template_config.ini @@ -0,0 +1,70 @@ +############################################################################### +# +# Initial system configuration file for MySQL Cluster v3.1.0 (Demo 1) +# +############################################################################### + +[DB DEFAULT] +NoOfReplicas: 1 +#LockPagesInMainMemory: Y +StopOnError: Y +#MaxNoOfConcurrentOperations: 1024 +#MaxNoOfConcurrentTransactions: 1024 +NoOfIndexPages: 1500 +NoOfDataPages: 5000 +#TimeBetweenLocalCheckpoints: 20 +#TimeBetweenGlobalCheckpoints: 1500 +#NoOfFragmentLogFiles: 8 +BackupMemory: 4M +BackupDataBufferSize: 2M +BackupLogBufferSize: 2M +BackupWriteSize: 32k + +[COMPUTER] +Id: 1 +ByteOrder: Little +HostName: localhost + +[MGM] +Id: 1 +ExecuteOnComputer: 1 +PortNumber: 10000 +PortNumberStats: 10001 + + +[DB] +Id: 2 +ExecuteOnComputer: 1 +FileSystemPath: WRITE_PATH_TO_FILESYSTEM_2_HERE + +[API] +Id: 3 +ExecuteOnComputer: 1 + +# Designated MySQL Server API node id +[API] +Id: 11 +ExecuteOnComputer: 1 + +[TCP DEFAULT] +SendSignalId: N +Compression: N +Checksum: N +SendBufferSize: 2000 +MaxReceiveSize: 2000 + +[TCP] +NodeId1: 1 +NodeId2: 2 +PortNumber: 10002 + +[TCP] +NodeId1: 2 +NodeId2: 3 +PortNumber: 10003 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 2 +NodeId2: 11 +PortNumber: 10011 diff --git a/ndb/demos/2-node/2-api-4/Ndb.cfg b/ndb/demos/2-node/2-api-4/Ndb.cfg new file mode 100644 index 00000000000..1713a9b5893 --- /dev/null +++ b/ndb/demos/2-node/2-api-4/Ndb.cfg @@ -0,0 +1,2 @@ +OwnProcessId 4 +127.0.0.1 10000 diff --git a/ndb/demos/2-node/2-api-5/Ndb.cfg b/ndb/demos/2-node/2-api-5/Ndb.cfg new file mode 100644 index 00000000000..faa2882eeea --- /dev/null +++ b/ndb/demos/2-node/2-api-5/Ndb.cfg @@ -0,0 +1,2 @@ +OwnProcessId 5 +127.0.0.1 10000 diff --git a/ndb/demos/2-node/2-api-6/Ndb.cfg b/ndb/demos/2-node/2-api-6/Ndb.cfg new file mode 100644 index 00000000000..bc2c4809453 --- /dev/null +++ b/ndb/demos/2-node/2-api-6/Ndb.cfg @@ -0,0 +1,2 @@ +OwnProcessId 6 +127.0.0.1 10000 diff --git a/ndb/demos/2-node/2-api-7/Ndb.cfg b/ndb/demos/2-node/2-api-7/Ndb.cfg new file mode 100644 index 00000000000..4107fdb6c5e --- /dev/null +++ b/ndb/demos/2-node/2-api-7/Ndb.cfg @@ -0,0 +1,2 @@ +OwnProcessId 7 +127.0.0.1 10000 diff --git a/ndb/demos/2-node/2-db-2/Ndb.cfg b/ndb/demos/2-node/2-db-2/Ndb.cfg new file mode 100644 index 00000000000..9315950b67a --- /dev/null +++ b/ndb/demos/2-node/2-db-2/Ndb.cfg @@ -0,0 +1,2 @@ +OwnProcessId 2 +127.0.0.1 10000 diff --git a/ndb/demos/2-node/2-db-3/Ndb.cfg b/ndb/demos/2-node/2-db-3/Ndb.cfg new file mode 100644 index 00000000000..61309af029e --- /dev/null +++ b/ndb/demos/2-node/2-db-3/Ndb.cfg @@ -0,0 +1,2 @@ +OwnProcessId 3 +127.0.0.1 10000 diff --git a/ndb/demos/2-node/2-mgm-1/Ndb.cfg b/ndb/demos/2-node/2-mgm-1/Ndb.cfg new file mode 100644 index 00000000000..61d4c0ecc17 --- /dev/null +++ b/ndb/demos/2-node/2-mgm-1/Ndb.cfg @@ -0,0 +1,2 @@ +OwnProcessId 1 +127.0.0.1 10000 diff --git a/ndb/demos/2-node/2-mgm-1/template_config.ini b/ndb/demos/2-node/2-mgm-1/template_config.ini new file mode 100644 index 00000000000..3edb909609a --- /dev/null +++ b/ndb/demos/2-node/2-mgm-1/template_config.ini @@ -0,0 +1,157 @@ +############################################################################### +# +# Initial system configuration file for MySQL Cluster v3.1.0 (Demo 2) +# +############################################################################### + +[COMPUTER] +Id: 1 +ByteOrder: Little +HostName: localhost + +[COMPUTER] +Id: 2 +ByteOrder: Little +HostName: localhost + +[MGM] +Id: 1 +ExecuteOnComputer: 1 +PortNumber: 10000 +PortNumberStats: 10001 +ArbitrationRank: 1 + +[DB DEFAULT] +NoOfReplicas: 2 +#LockPagesInMainMemory: N +StopOnError: N +#MaxNoOfConcurrentOperations: 1024 +#MaxNoOfConcurrentTransactions: 1024 +NoOfIndexPages: 200 +NoOfDataPages: 600 +#TimeBetweenLocalCheckpoints: 20 +#TimeBetweenGlobalCheckpoints: 1500 +#NoOfFragmentLogFiles: 8 +BackupMemory: 4M +BackupDataBufferSize: 2M +BackupLogBufferSize: 2M +BackupWriteSize: 32k + +[DB] +Id: 2 +ExecuteOnComputer: 1 +FileSystemPath: WRITE_PATH_TO_FILESYSTEM_2_HERE + +[DB] +Id: 3 +ExecuteOnComputer: 2 +FileSystemPath: WRITE_PATH_TO_FILESYSTEM_3_HERE + +[API DEFAULT] +ArbitrationRank: 1 + +[API] +Id: 4 +ExecuteOnComputer: 1 + +[API] +Id: 5 +ExecuteOnComputer: 1 + +[API] +Id: 6 +ExecuteOnComputer: 2 + +[API] +Id: 7 +ExecuteOnComputer: 2 + +# Designated MySQL Server API node id +[API] +Id: 11 +ExecuteOnComputer: 1 + +# Designated MySQL Server API node id +[API] +Id: 12 +ExecuteOnComputer: 2 + + +[TCP] +NodeId1: 1 +NodeId2: 2 +PortNumber: 10002 + +[TCP] +NodeId1: 1 +NodeId2: 3 +PortNumber: 10003 + +[TCP] +NodeId1: 2 +NodeId2: 3 +PortNumber: 10004 + +[TCP] +NodeId1: 2 +NodeId2: 4 +PortNumber: 10005 + +[TCP] +NodeId1: 2 +NodeId2: 5 +PortNumber: 10006 + +[TCP] +NodeId1: 2 +NodeId2: 6 +PortNumber: 10007 + +[TCP] +NodeId1: 2 +NodeId2: 7 +PortNumber: 10008 + +[TCP] +NodeId1: 3 +NodeId2: 4 +PortNumber: 10009 + +[TCP] +NodeId1: 3 +NodeId2: 5 +PortNumber: 10010 + +[TCP] +NodeId1: 3 +NodeId2: 6 +PortNumber: 10011 + +[TCP] +NodeId1: 3 +NodeId2: 7 +PortNumber: 10012 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 2 +NodeId2: 11 +PortNumber: 10013 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 3 +NodeId2: 11 +PortNumber: 10014 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 2 +NodeId2: 12 +PortNumber: 10015 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 3 +NodeId2: 12 +PortNumber: 10016 diff --git a/ndb/demos/config-templates/config_template-1-REP.ini b/ndb/demos/config-templates/config_template-1-REP.ini new file mode 100644 index 00000000000..71be3f2f53f --- /dev/null +++ b/ndb/demos/config-templates/config_template-1-REP.ini @@ -0,0 +1,87 @@ +############################################################################### +# +# Initial system configuration file for MySQL Cluster v3.1.0 (Demo 1) +# +############################################################################### + +[DB DEFAULT] +NoOfReplicas: 1 +StopOnError: Y +NoOfIndexPages: 1500 +NoOfDataPages: 5000 +BackupMemory: 4M +BackupDataBufferSize: 2M +BackupLogBufferSize: 2M +BackupWriteSize: 32k + +[COMPUTER] +Id: 1 +ByteOrder: Little +HostName: CHOOSE_HOSTNAME + +[EXTERNAL SYSTEM] +Name: External + +[MGM] +Id: 1 +ExecuteOnComputer: 1 +PortNumber: CHOOSE_PORT_BASE00 +PortNumberStats: CHOOSE_PORT_BASE01 + + +[DB] +Id: 2 +ExecuteOnComputer: 1 +FileSystemPath: WRITE_PATH_TO_FILESYSTEM_2_HERE + +[API] +Id: 3 +ExecuteOnComputer: 1 + +[REP] +Id: CHOOSE_REP_ID +ExecuteOnComputer: 1 + +[EXTERNAL REP] +Id: CHOOSE_EXTREP_ID +System: External + +# Designated MySQL Server API node id +[API] +Id: 11 +ExecuteOnComputer: 1 + +[TCP DEFAULT] +SendSignalId: N +Compression: N +Checksum: N +SendBufferSize: 2000 +MaxReceiveSize: 2000 + +[TCP] +NodeId1: 1 +NodeId2: 2 +PortNumber: CHOOSE_PORT_BASE02 + +[TCP] +NodeId1: 2 +NodeId2: 3 +PortNumber: CHOOSE_PORT_BASE03 + +[TCP] +NodeId1: 2 +NodeId2: CHOOSE_REP_ID +PortNumber: CHOOSE_PORT_BASE04 + +[TCP] +Hostname1: CHOOSE_HOSTNAME +Hostname2: CHOOSE_EXTHOSTNAME +NodeId1: CHOOSE_REP_ID +NodeId2: External.CHOOSE_EXTREP_ID +PortNumber: 10099 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 2 +NodeId2: 11 +PortNumber: CHOOSE_PORT_BASE11 diff --git a/ndb/demos/config-templates/config_template-4.ini b/ndb/demos/config-templates/config_template-4.ini new file mode 100644 index 00000000000..e47c9037344 --- /dev/null +++ b/ndb/demos/config-templates/config_template-4.ini @@ -0,0 +1,336 @@ +############################################################################### +# +# 4-node system configuration file for MySQL Cluster +# +############################################################################### + +[DB DEFAULT] +NoOfReplicas: 1 +StopOnError: N +NoOfIndexPages: 1500 +NoOfDataPages: 5000 +BackupMemory: 4M +BackupDataBufferSize: 2M +BackupLogBufferSize: 2M +BackupWriteSize: 32k + +[COMPUTER] +Id: 1 +ByteOrder: Little +HostName: CHOOSE_HOSTNAME_1 + +[COMPUTER] +Id: 2 +ByteOrder: Little +HostName: CHOOSE_HOSTNAME_2 + +[COMPUTER] +Id: 3 +ByteOrder: Little +HostName: CHOOSE_HOSTNAME_3 + +[COMPUTER] +Id: 4 +ByteOrder: Little +HostName: CHOOSE_HOSTNAME_4 + +[MGM] +Id: 1 +ExecuteOnComputer: 1 +PortNumber: CHOOSE_PORT_BASE00 +PortNumberStats: CHOOSE_PORT_BASE01 + +[DB] +Id: 2 +ExecuteOnComputer: 1 +FileSystemPath: WRITE_PATH_TO_FILESYSTEM_1_HERE + +[DB] +Id: 3 +ExecuteOnComputer: 2 +FileSystemPath: WRITE_PATH_TO_FILESYSTEM_2_HERE + +[DB] +Id: 4 +ExecuteOnComputer: 3 +FileSystemPath: WRITE_PATH_TO_FILESYSTEM_3_HERE + +[DB] +Id: 5 +ExecuteOnComputer: 4 +FileSystemPath: WRITE_PATH_TO_FILESYSTEM_4_HERE + +[API] +Id: 6 +ExecuteOnComputer: 1 + +[API] +Id: 7 +ExecuteOnComputer: 2 + +[API] +Id: 8 +ExecuteOnComputer: 3 + +[API] +Id: 9 +ExecuteOnComputer: 4 + +# Designated MySQL Server API node id +[API] +Id: 11 +ExecuteOnComputer: 1 + +# Designated MySQL Server API node id +[API] +Id: 12 +ExecuteOnComputer: 2 + +# Designated MySQL Server API node id +[API] +Id: 13 +ExecuteOnComputer: 3 + +# Designated MySQL Server API node id +[API] +Id: 14 +ExecuteOnComputer: 4 + +[TCP DEFAULT] +SendSignalId: N +Compression: N +Checksum: N +SendBufferSize: 2000 +MaxReceiveSize: 2000 + +# Management server +[TCP] +NodeId1: 1 +NodeId2: 2 +PortNumber: CHOOSE_PORT_BASE02 + +[TCP] +NodeId1: 1 +NodeId2: 3 +PortNumber: CHOOSE_PORT_BASE03 + +[TCP] +NodeId1: 1 +NodeId2: 4 +PortNumber: CHOOSE_PORT_BASE04 + +[TCP] +NodeId1: 1 +NodeId2: 5 +PortNumber: CHOOSE_PORT_BASE05 + +# Database cluster +[TCP] +NodeId1: 2 +NodeId2: 3 +PortNumber: CHOOSE_PORT_BASE06 + +[TCP] +NodeId1: 2 +NodeId2: 4 +PortNumber: CHOOSE_PORT_BASE07 + +[TCP] +NodeId1: 2 +NodeId2: 5 +PortNumber: CHOOSE_PORT_BASE08 + +[TCP] +NodeId1: 3 +NodeId2: 4 +PortNumber: CHOOSE_PORT_BASE09 + +[TCP] +NodeId1: 3 +NodeId2: 5 +PortNumber: CHOOSE_PORT_BASE10 + +[TCP] +NodeId1: 4 +NodeId2: 5 +PortNumber: CHOOSE_PORT_BASE11 + +# API node 6 +[TCP] +NodeId1: 6 +NodeId2: 2 +PortNumber: CHOOSE_PORT_BASE12 + +[TCP] +NodeId1: 6 +NodeId2: 3 +PortNumber: CHOOSE_PORT_BASE13 + +[TCP] +NodeId1: 6 +NodeId2: 4 +PortNumber: CHOOSE_PORT_BASE14 + +[TCP] +NodeId1: 6 +NodeId2: 5 +PortNumber: CHOOSE_PORT_BASE15 + +# API node 7 +[TCP] +NodeId1: 7 +NodeId2: 2 +PortNumber: CHOOSE_PORT_BASE16 + +[TCP] +NodeId1: 7 +NodeId2: 3 +PortNumber: CHOOSE_PORT_BASE17 + +[TCP] +NodeId1: 7 +NodeId2: 4 +PortNumber: CHOOSE_PORT_BASE18 + +[TCP] +NodeId1: 7 +NodeId2: 5 +PortNumber: CHOOSE_PORT_BASE19 + +# API node 8 +[TCP] +NodeId1: 8 +NodeId2: 2 +PortNumber: CHOOSE_PORT_BASE20 + +[TCP] +NodeId1: 8 +NodeId2: 3 +PortNumber: CHOOSE_PORT_BASE21 + +[TCP] +NodeId1: 8 +NodeId2: 4 +PortNumber: CHOOSE_PORT_BASE22 + +[TCP] +NodeId1: 8 +NodeId2: 5 +PortNumber: CHOOSE_PORT_BASE23 + +# API node 9 +[TCP] +NodeId1: 9 +NodeId2: 2 +PortNumber: CHOOSE_PORT_BASE24 + +[TCP] +NodeId1: 9 +NodeId2: 3 +PortNumber: CHOOSE_PORT_BASE25 + +[TCP] +NodeId1: 9 +NodeId2: 4 +PortNumber: CHOOSE_PORT_BASE26 + +[TCP] +NodeId1: 9 +NodeId2: 5 +PortNumber: CHOOSE_PORT_BASE27 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 2 +NodeId2: 11 +PortNumber: CHOOSE_PORT_BASE28 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 3 +NodeId2: 11 +PortNumber: CHOOSE_PORT_BASE29 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 4 +NodeId2: 11 +PortNumber: CHOOSE_PORT_BASE30 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 5 +NodeId2: 11 +PortNumber: CHOOSE_PORT_BASE31 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 2 +NodeId2: 12 +PortNumber: CHOOSE_PORT_BASE32 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 3 +NodeId2: 12 +PortNumber: CHOOSE_PORT_BASE33 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 4 +NodeId2: 12 +PortNumber: CHOOSE_PORT_BASE34 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 5 +NodeId2: 12 +PortNumber: CHOOSE_PORT_BASE35 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 2 +NodeId2: 13 +PortNumber: CHOOSE_PORT_BASE36 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 3 +NodeId2: 13 +PortNumber: CHOOSE_PORT_BASE37 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 4 +NodeId2: 13 +PortNumber: CHOOSE_PORT_BASE38 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 5 +NodeId2: 13 +PortNumber: CHOOSE_PORT_BASE39 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 2 +NodeId2: 14 +PortNumber: CHOOSE_PORT_BASE40 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 3 +NodeId2: 14 +PortNumber: CHOOSE_PORT_BASE41 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 4 +NodeId2: 14 +PortNumber: CHOOSE_PORT_BASE42 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 5 +NodeId2: 14 +PortNumber: CHOOSE_PORT_BASE43 diff --git a/ndb/demos/config-templates/config_template-install.ini b/ndb/demos/config-templates/config_template-install.ini new file mode 100644 index 00000000000..e31906ba609 --- /dev/null +++ b/ndb/demos/config-templates/config_template-install.ini @@ -0,0 +1,64 @@ +############################################################################### +# +# Initial system configuration file for MySQL Cluster v3.1.0 (Demo 1) +# +############################################################################### + +[DB DEFAULT] +NoOfReplicas: 1 +StopOnError: N +NoOfIndexPages: 1500 +NoOfDataPages: 5000 +BackupMemory: 4M +BackupDataBufferSize: 2M +BackupLogBufferSize: 2M +BackupWriteSize: 32k + +[COMPUTER] +Id: 1 +ByteOrder: Little +HostName: localhost + +[MGM] +Id: 1 +ExecuteOnComputer: 1 +PortNumber: CHOOSE_PORT_BASE00 +PortNumberStats: CHOOSE_PORT_BASE01 + + +[DB] +Id: 2 +ExecuteOnComputer: 1 +FileSystemPath: WRITE_PATH_TO_FILESYSTEM_2_HERE + +[API] +Id: 3 +ExecuteOnComputer: 1 + +# Designated MySQL Server API node id +[API] +Id: 11 +ExecuteOnComputer: 1 + +[TCP DEFAULT] +SendSignalId: N +Compression: N +Checksum: N +SendBufferSize: 2000 +MaxReceiveSize: 2000 + +[TCP] +NodeId1: 1 +NodeId2: 2 +PortNumber: CHOOSE_PORT_BASE02 + +[TCP] +NodeId1: 2 +NodeId2: 3 +PortNumber: CHOOSE_PORT_BASE03 + +# Designated MySQL Server API node connection +[TCP] +NodeId1: 2 +NodeId2: 11 +PortNumber: CHOOSE_PORT_BASE11 diff --git a/ndb/demos/run_demo1-PS-SS_common.sh b/ndb/demos/run_demo1-PS-SS_common.sh new file mode 100644 index 00000000000..625e9655087 --- /dev/null +++ b/ndb/demos/run_demo1-PS-SS_common.sh @@ -0,0 +1,50 @@ +echo $NDB_HOST $NDB_EXTHOST + +NDB_PORT=$NDB_PORT_BASE"00" +NDB_CONNECTSTRING_BASE="host=$NDB_HOST:$NDB_PORT;nodeid=" + +# Edit file system path + +cd $NDB_DEMO +sed -e s,"WRITE_PATH_TO_FILESYSTEM_2_HERE",$NDB_DEMO/filesystem,g \ + -e s,"CHOOSE_HOSTNAME",$NDB_HOST,g\ + -e s,"CHOOSE_EXTHOSTNAME",$NDB_EXTHOST,g\ + -e s,"CHOOSE_PORT_BASE",$NDB_PORT_BASE,g\ + -e s,"CHOOSE_REP_ID",$NDB_REP_ID,g\ + -e s,"CHOOSE_EXTREP_ID",$NDB_EXTREP_ID,g\ + < ../config-templates/config_template-1-REP.ini > config.ini + +# Start management server as deamon + +NDB_ID="1" +NDB_CONNECTSTRING=$NDB_CONNECTSTRING_BASE$NDB_ID +export NDB_CONNECTSTRING +if mgmtsrvr -d -c config.ini ; then :; else + echo "Unable to start mgmtsrvr" + exit 1 +fi + +# Start database node + +NDB_ID="2" +NDB_CONNECTSTRING=$NDB_CONNECTSTRING_BASE$NDB_ID +export NDB_CONNECTSTRING +xterm -T "$NDB_DEMO_NAME DB Node $NDB_ID" -geometry 80x10 -xrm *.hold:true -e ndb -i & + +# Start xterm for application programs + +NDB_ID="3" +NDB_CONNECTSTRING=$NDB_CONNECTSTRING_BASE$NDB_ID +export NDB_CONNECTSTRING +xterm -T "$NDB_DEMO_NAME API Node $NDB_ID" -geometry 80x10 & + +# Start xterm for rep node + +NDB_ID=$NDB_REP_ID +NDB_CONNECTSTRING=$NDB_CONNECTSTRING_BASE$NDB_ID +export NDB_CONNECTSTRING +xterm -T "$NDB_DEMO_NAME REP Node $NDB_ID" -geometry 80x10 -xrm *.hold:true -e ndb_rep & + +# Start management client + +xterm -T "$NDB_DEMO_NAME Mgmt Client" -geometry 80x10 -xrm *.hold:true -e mgmtclient $NDB_HOST $NDB_PORT & diff --git a/ndb/demos/run_demo1-PS.sh b/ndb/demos/run_demo1-PS.sh new file mode 100755 index 00000000000..82cfdd5e65b --- /dev/null +++ b/ndb/demos/run_demo1-PS.sh @@ -0,0 +1,30 @@ +#!/bin/sh +if [ -z "$MYSQLCLUSTER_TOP" ]; then + echo "MYSQLCLUSTER_TOP not set" + exit 1 +fi +if [ -d "$MYSQLCLUSTER_TOP/ndb" ]; then :; else + echo "$MYSQLCLUSTER_TOP/ndb directory does not exist" + exit 1 +fi +NDB_CONNECTSTRING= +NDB_HOME= +NDB_DEMO=$MYSQLCLUSTER_TOP/ndb/demos/1-node-PS + +NDB_PORT_BASE="102" +NDB_REP_ID="5" +NDB_EXTREP_ID="4" + +NDB_DEMO_NAME="Demo 1-PS MySQL Cluster" +NDB_HOST1=$1 +NDB_HOST2=$2 +if [ -z "$NDB_HOST1" ]; then + NDB_HOST1=localhost +fi +if [ -z "$NDB_HOST2" ]; then + NDB_HOST2=localhost +fi +NDB_HOST=$NDB_HOST1 +NDB_EXTHOST=$NDB_HOST2 + +source $MYSQLCLUSTER_TOP/ndb/demos/run_demo1-PS-SS_common.sh diff --git a/ndb/demos/run_demo1-SS.sh b/ndb/demos/run_demo1-SS.sh new file mode 100755 index 00000000000..5ede57c44c4 --- /dev/null +++ b/ndb/demos/run_demo1-SS.sh @@ -0,0 +1,30 @@ +#!/bin/sh +if [ -z "$MYSQLCLUSTER_TOP" ]; then + echo "MYSQLCLUSTER_TOP not set" + exit 1 +fi +if [ -d "$MYSQLCLUSTER_TOP/ndb" ]; then :; else + echo "$MYSQLCLUSTER_TOP/ndb directory does not exist" + exit 1 +fi +NDB_CONNECTSTRING= +NDB_HOME= +NDB_DEMO=$MYSQLCLUSTER_TOP/ndb/demos/1-node-SS + +NDB_PORT_BASE="101" +NDB_REP_ID="4" +NDB_EXTREP_ID="5" + +NDB_DEMO_NAME="Demo 1-SS MySQL Cluster" +NDB_HOST1=$1 +NDB_HOST2=$2 +if [ -z "$NDB_HOST1" ]; then + NDB_HOST1=localhost +fi +if [ -z "$NDB_HOST2" ]; then + NDB_HOST2=localhost +fi +NDB_HOST=$NDB_HOST2 +NDB_EXTHOST=$NDB_HOST1 + +source $MYSQLCLUSTER_TOP/ndb/demos/run_demo1-PS-SS_common.sh diff --git a/ndb/demos/run_demo1.sh b/ndb/demos/run_demo1.sh new file mode 100755 index 00000000000..df6e3fc799d --- /dev/null +++ b/ndb/demos/run_demo1.sh @@ -0,0 +1,41 @@ +#!/bin/sh +if [ -z "$MYSQLCLUSTER_TOP" ]; then + echo "MYSQLCLUSTER_TOP not set" + exit 1 +fi +if [ -d "$MYSQLCLUSTER_TOP/ndb" ]; then :; else + echo "$MYSQLCLUSTER_TOP/ndb directory does not exist" + exit 1 +fi +NDB_CONNECTSTRING= +NDB_HOME= +ndb_demo=$MYSQLCLUSTER_TOP/ndb/demos + +# Edit file system path + +cd $ndb_demo/1-node/1-mgm-1 +sed -e s,"WRITE_PATH_TO_FILESYSTEM_2_HERE",$ndb_demo/1-node/1-db-2/filesystem,g \ + < template_config.ini > config.ini + +# Start management server as deamon + +cd $ndb_demo/1-node/1-mgm-1 +if mgmtsrvr -d -c config.ini ; then :; else + echo "Unable to start mgmtsrvr" + exit 1 +fi + +# Start database node + +cd $ndb_demo/1-node/1-db-2 +xterm -T "Demo 1 NDB Cluster DB Node 2" -geometry 80x10 -xrm *.hold:true -e ndb -i & + +# Start xterm for application programs + +cd $ndb_demo/1-node/1-api-3 +xterm -T "Demo 1 NDB Cluster API Node 3" -geometry 80x10 & + +# Start management client + +cd $ndb_demo +xterm -T "Demo 1 NDB Management Client" -geometry 80x10 -xrm *.hold:true -e mgmtclient localhost 10000 & diff --git a/ndb/demos/run_demo2.sh b/ndb/demos/run_demo2.sh new file mode 100755 index 00000000000..9bae7517d5f --- /dev/null +++ b/ndb/demos/run_demo2.sh @@ -0,0 +1,54 @@ +#!/bin/sh +if [ -z "$MYSQLCLUSTER_TOP" ]; then + echo "MYSQLCLUSTER_TOP not set" + exit 1 +fi +if [ -d "$MYSQLCLUSTER_TOP/ndb" ]; then :; else + echo "$MYSQLCLUSTER_TOP/ndb directory does not exist" + exit 1 +fi +NDB_CONNECTSTRING= +NDB_HOME= +ndb_demo=$MYSQLCLUSTER_TOP/ndb/demos + +# Edit file system path + +cd $ndb_demo/2-node/2-mgm-1 +sed -e s,"WRITE_PATH_TO_FILESYSTEM_2_HERE",$ndb_demo/2-node/2-db-2/filesystem,g \ + -e s,"WRITE_PATH_TO_FILESYSTEM_3_HERE",$ndb_demo/2-node/2-db-3/filesystem,g \ + < template_config.ini > config.ini + +# Start management server as deamon + +cd $ndb_demo/2-node/2-mgm-1 +if mgmtsrvr -d -c config.ini ; then :; else + echo "Unable to start mgmtsrvr" + exit 1 +fi + +#xterm -T "Demo 2 NDB Management Server" -geometry 80x10 -xrm *.hold:true -e mgmtsrvr -c config.ini & + +# Start database node + +cd $ndb_demo/2-node/2-db-2 +xterm -T "Demo 2 NDB Cluster DB Node 2" -geometry 80x10 -xrm *.hold:true -e ndb -i & + +# Start database node + +cd $ndb_demo/2-node/2-db-3 +xterm -T "Demo 2 NDB Cluster DB Node 3" -geometry 80x10 -xrm *.hold:true -e ndb -i & + +# Start xterm for application programs + +cd $ndb_demo/2-node/2-api-4 +xterm -T "Demo 2 NDB Cluster API Node 4" -geometry 80x10 & + +# Start xterm for application programs + +cd $ndb_demo/2-node/2-api-5 +xterm -T "Demo 2 NDB Cluster API Node 5" -geometry 80x10 & + +# Start management client + +cd $ndb_demo +xterm -T "Demo 2 NDB Management Client" -geometry 80x10 -xrm *.hold:true -e mgmtclient localhost 10000 & diff --git a/ndb/docs/Makefile b/ndb/docs/Makefile new file mode 100644 index 00000000000..a2139b66044 --- /dev/null +++ b/ndb/docs/Makefile @@ -0,0 +1,97 @@ +include .defs.mk +# +# hack before full autoconf +replace-targets := all clean +first-docs: all + +include $(NDB_TOP)/Epilogue.mk + +all: ndbapidoc mgmapidoc + +DOXYGEN = doxygen +DOXYTOP = $(shell cd $(NDB_TOP); pwd)/docs +DOXYDIR = $(DOXYTOP)/doxygen +DOXYTMP = $(DOXYTOP)/.doxytmp +DOXYOUT = $(DOXYTOP)/.doxyout + +clean: + rm -rf ndbapi.pdf ndbapi.html mgmapi.pdf mgmapi.html + rm -rf $(DOXYTMP) $(DOXYOUT) + +### +# +# NDB API Programmer's Guide +# +ndbapidoc: ndbapi.pdf + +ndbapi.pdf: $(NDB_TOP)/include/ndb_version.h + @set -x; \ + rm -rf ndbapi.pdf ndbapi.html; \ + rm -rf $(DOXYTMP) $(DOXYOUT); \ + mkdir -p $(DOXYTMP) $(DOXYOUT); \ + (cd $(NDB_TOP)/include/ndbapi && \ + find . -type f -print | \ + grep -v /SCCS | \ + cpio -pdm $(DOXYTMP)); \ + (cd $(NDB_TOP)/examples && \ + cp -p */*.[ch]pp $(DOXYTMP)); \ + $(DOXYDIR)/predoxy.pl; \ + mv footer.html $(DOXYTMP); \ + (cd $(DOXYTMP) && \ + $(DOXYGEN) $(DOXYDIR)/Doxyfile.ndbapi); \ + $(DOXYDIR)/postdoxy.pl $(DOXYOUT)/ndbapi.latex "NDB API Programmer Guide"; \ + (cd $(DOXYOUT) && \ + find ndbapi.html -print | cpio -pdm $(DOXYTOP)); \ + (cd $(DOXYOUT)/ndbapi.latex && \ + pdflatex refman.tex && makeindex refman && pdflatex refman.tex && \ + cp -p refman.pdf $(DOXYTOP)/ndbapi.pdf); + +### +# +# MGM API Guide +# +mgmapidoc: mgmapi.pdf + +mgmapi.pdf: $(NDB_TOP)/include/ndb_version.h + @set -x; \ + rm -rf mgmapi.pdf mgmapi.html; \ + rm -rf $(DOXYTMP) $(DOXYOUT); \ + mkdir -p $(DOXYTMP) $(DOXYOUT); \ + (cd $(NDB_TOP)/include/mgmapi && \ + find . -type f -print | \ + grep -v /SCCS | \ + cpio -pdm $(DOXYTMP)); \ + $(DOXYDIR)/predoxy.pl; \ + mv footer.html $(DOXYTMP); \ + (cd $(DOXYTMP) && \ + $(DOXYGEN) $(DOXYDIR)/Doxyfile.mgmapi); \ + $(DOXYDIR)/postdoxy.pl $(OUTDIR)/mgmapi.latex "NDB Cluster MGM API Guide"; \ + (cd $(DOXYOUT) && \ + find mgmapi.html -print | cpio -pdm $(DOXYTOP)); \ + (cd $(DOXYOUT)/mgmapi.latex && \ + pdflatex refman.tex && makeindex refman && pdflatex refman.tex && \ + cp -p refman.pdf $(DOXYTOP)/mgmapi.pdf); + +### +# +# Complete Source Browser except for +# ndbapi odbc test tools win32 lib examples docs CVS config bin +# include/ndbapi +# include/newtonapi src/newtonapi +# include/mgmapi src/mgmapi +# src/client +ndbdoc: DUMMY + mkdir -p $(OUTDIR) + cd $(NDB_TOP) ; $(DOXYGEN) $(DOXYDIR)/Doxyfile.ndb + +### +# +# odbcdoc - Complete Source Browser for NDB ODBC (src/client/odbc) + +odbcdoc: DUMMY + mkdir -p $(OUTDIR) + cd $(NDB_TOP) ; $(DOXYGEN) $(DOXYDIR)/Doxyfile.odbc + +testdoc: DUMMY + mkdir -p $(OUTDIR) + cd $(NDB_TOP) ; $(DOXYGEN) $(DOXYDIR)/Doxyfile.test diff --git a/ndb/docs/README b/ndb/docs/README new file mode 100644 index 00000000000..262e9003aca --- /dev/null +++ b/ndb/docs/README @@ -0,0 +1,30 @@ +Create MySQL Cluster user documentation from source code +-------------------------------------------------------- +(All these require Doxygen.) + +* make clean + Remove all generated documentation and tmp files + +* make ndbapidoc + Makes the NDB API Programmer's Guide (in HTML) + +* make ndbapipdf + Makes the NDB API Programmer Guide (in PDF) + +* make mgmapidoc + Makes the MGM API Reference Manual (in HTML) + +* make mgmapipdf + Makes the MGM API Reference Manual (in PDF) + +* make ndbdoc + Makes source code browser for NDB Cluster (in HTML) + (Requires Graphviz.) + +Doxygen and Graphviz can be found at: + http://www.doxygen.org +or at (for Red Hat 9.0 RPMs): + http://dentrassi.de/download/doxygen/ + +-- +lars@mysql.com diff --git a/ndb/docs/doxygen/Doxyfile.mgmapi b/ndb/docs/doxygen/Doxyfile.mgmapi new file mode 100644 index 00000000000..4287b37fd97 --- /dev/null +++ b/ndb/docs/doxygen/Doxyfile.mgmapi @@ -0,0 +1,877 @@ +# Doxyfile 1.2.12 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# General configuration options +#--------------------------------------------------------------------------- +DETAILS_AT_TOP = yes +HIDE_FRIEND_COMPOUNDS = yes + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +OUTPUT_DIRECTORY = + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Brazilian, Chinese, Croatian, Czech, Danish, Dutch, Finnish, French, +# German, Hungarian, Italian, Japanese, Korean, Norwegian, Polish, +# Portuguese, Romanian, Russian, Slovak, Slovene, Spanish and Swedish. + +OUTPUT_LANGUAGE = English + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = NO + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these class will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = NO + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = YES + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = NO + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. It is allowed to use relative paths in the argument list. + +STRIP_FROM_PATH = + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower case letters. If set to YES upper case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# users are adviced to set this option to NO. + +CASE_SENSE_NAMES = YES + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter +# (but less readable) file names. This can be useful is your file systems +# doesn't support long names like on DOS, Mac, or CD-ROM. + +SHORT_NAMES = NO + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the JavaDoc +# comments will behave just like the Qt-style comments (thus requiring an +# explict @brief command for a brief description. + +JAVADOC_AUTOBRIEF = NO + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# reimplements. + +INHERIT_DOCS = YES + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 8 + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or +# disable (NO) the bug list. This list is created by putting \bug +# commands in the documentation. + +GENERATE_BUGLIST = YES + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = + +# The ENABLED_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines +# the initial value of a variable or define consist of for it to appear in +# the documentation. If the initializer consists of more lines than specified +# here it will be hidden. Use a value of 0 to hide initializers completely. +# The appearance of the initializer of individual variables and defines in the +# documentation can be controlled using \showinitializer or \hideinitializer +# command in the documentation regardless of this setting. + +MAX_INITIALIZER_LINES = 30 + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. +# For instance some of the names that are used will be different. The list +# of all members will be omitted, etc. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated +# at the bottom of the documentation of classes and structs. If set to YES the +# list will mention the files that were used to generate the documentation. + +SHOW_USED_FILES = YES + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = YES + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. + +WARN_FORMAT = + +# The WARN_LOGFILE tag can be used to specify a file to which warning +# and error messages should be written. If left blank the output is written +# to stderr. + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = . + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank file matching one of the following patterns are included: +# *.c *.cc *.cxx *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx *.hpp +# *.h++ *.idl + +FILE_PATTERNS = + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = NO + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. + +EXCLUDE_PATTERNS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = . + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude +# commands irrespective of the value of the RECURSIVE tag. +# Possible values are YES and NO. If left blank NO is used. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. + +INPUT_FILTER = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will be used to filter the input files when producing source +# files to browse. + +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = NO + +# If the REFERENCED_BY_RELATION tag is set to YES (the default) +# then for each documented function all documented +# functions referencing it will be listed. + +REFERENCED_BY_RELATION = YES + +# If the REFERENCES_RELATION tag is set to YES (the default) +# then for each documented function all documented entities +# called/used by that function will be listed. + +REFERENCES_RELATION = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = NO + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = ../.doxyout/mgmapi.html + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = footer.html + +# The HTML_STYLESHEET tag can be used to specify a user defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet + +HTML_STYLESHEET = + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag +# controls if a separate .chi index file is generated (YES) or that +# it should be included in the master .chm file (NO). + +GENERATE_CHI = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag +# controls whether a binary table of contents is generated (YES) or a +# normal table of contents (NO) in the .chm file. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members +# to the contents of the Html help documentation and to the tree view. + +TOC_EXPAND = NO + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +# This tag can be used to set the number of enum values (range [1..20]) +# that doxygen will group on one line in the generated HTML documentation. + +ENUM_VALUES_PER_LINE = 4 + +# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be +# generated containing a tree-like index structure (just like the one that +# is generated for HTML Help). For this to work a browser that supports +# JavaScript and frames is required (for instance Mozilla, Netscape 4.0+, +# or Internet explorer 4.0+). Note that for large projects the tree generation +# can take a very long time. In such cases it is better to disable this feature. +# Windows users are probably better off using the HTML help feature. + +GENERATE_TREEVIEW = NO + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be +# used to set the initial width (in pixels) of the frame in which the tree +# is shown. + +TREEVIEW_WIDTH = 250 + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = YES + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = ../.doxyout/mgmapi.latex + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = ../doxygen/header.mgmapi.tex + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = YES + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = YES + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimised for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = ../mgmapi.rtf + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using WORD or other +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assigments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an rtf document. +# Syntax is similar to doxygen's config file. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = + +# If the MAN_LINKS tag is set to YES and Doxygen generates man output, +# then it will generate one additional man file for each entity +# documented in the real man page(s). These additional files +# only source the real man page, but without them the man command +# would be unable to find the correct page. The default is NO. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. Note that this +# feature is still experimental and incomplete at the +# moment. + +GENERATE_XML = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = YES + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_PREDEFINED tags. + +EXPAND_ONLY_PREDEF = YES + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. + +PREDEFINED = DOXYGEN_SHOULD_SKIP_DEPRECATED \ + DOXYGEN_SHOULD_SKIP_INTERNAL \ + protected=private + +# If the MACRO_EXPANSION and EXPAND_PREDEF_ONLY tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then +# doxygen's preprocessor will remove all function-like macros that are alone +# on a line and do not end with a semicolon. Such function macros are typically +# used for boiler-plate code, and will confuse the parser if not removed. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration::addtions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES tag can be used to specify one or more tagfiles. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = NO + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a inheritance diagram (in Html, RTF and LaTeX) for classes with base or +# super classes. Setting the tag to NO turns the diagrams off. Note that this +# option is superceded by the HAVE_DOT option below. This is only a fallback. It is +# recommended to install and use dot, since it yield more powerful graphs. + +CLASS_DIAGRAMS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = NO + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = YES + +# If set to YES, the inheritance and collaboration graphs will hide +# inheritance and usage relations if the target is undocumented +# or is not a class. + +HIDE_UNDOC_RELATIONS = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT +# tags are set to YES then doxygen will generate a graph for each documented +# file showing the direct and indirect include dependencies of the file with +# other documented files. + +INCLUDE_GRAPH = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and +# HAVE_DOT tags are set to YES then doxygen will generate a graph for each +# documented header file showing the documented files that directly or +# indirectly include this file. + +INCLUDED_BY_GRAPH = YES + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found on the path. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the +# \dotfile command). + +DOTFILE_DIRS = + +# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_WIDTH = 1024 + +# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_HEIGHT = 1024 + +# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will +# generate a legend page explaining the meaning of the various boxes and +# arrows in the dot generated graphs. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will +# remove the intermedate dot files that are used to generate +# the various graphs. + +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +# Configuration::addtions related to the search engine +#--------------------------------------------------------------------------- + +# The SEARCHENGINE tag specifies whether or not a search engine should be +# used. If set to NO the values of all tags below this one will be ignored. + +SEARCHENGINE = NO + +# The CGI_NAME tag should be the name of the CGI script that +# starts the search engine (doxysearch) with the correct parameters. +# A script with this name will be generated by doxygen. + +CGI_NAME = + +# The CGI_URL tag should be the absolute URL to the directory where the +# cgi binaries are located. See the documentation of your http daemon for +# details. + +CGI_URL = + +# The DOC_URL tag should be the absolute URL to the directory where the +# documentation is located. If left blank the absolute path to the +# documentation, with file:// prepended to it, will be used. + +DOC_URL = + +# The DOC_ABSPATH tag should be the absolute path to the directory where the +# documentation is located. If left blank the directory on the local machine +# will be used. + +DOC_ABSPATH = + +# The BIN_ABSPATH tag must point to the directory where the doxysearch binary +# is installed. + +BIN_ABSPATH = + +# The EXT_DOC_PATHS tag can be used to specify one or more paths to +# documentation generated for other projects. This allows doxysearch to search +# the documentation for these projects as well. + +EXT_DOC_PATHS = diff --git a/ndb/docs/doxygen/Doxyfile.ndb b/ndb/docs/doxygen/Doxyfile.ndb new file mode 100644 index 00000000000..d43a66323f8 --- /dev/null +++ b/ndb/docs/doxygen/Doxyfile.ndb @@ -0,0 +1,937 @@ +# Doxyfile 1.2.14 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# General configuration options +#--------------------------------------------------------------------------- + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = "NDB Cluster" + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +OUTPUT_DIRECTORY = + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Brazilian, Chinese, Croatian, Czech, Danish, Dutch, Finnish, French, +# German, Greek, Hungarian, Italian, Japanese, Korean, Norwegian, Polish, +# Portuguese, Romanian, Russian, Slovak, Slovene, Spanish and Swedish. + +OUTPUT_LANGUAGE = English + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = YES + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = YES + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = YES + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) +# defined locally in source files will be included in the documentation. +# If set to NO only classes defined in header files are included. + +EXTRACT_LOCAL_CLASSES = YES + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these class will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = NO + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = YES + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all inherited +# members of a class in the documentation of that class as if those members were +# ordinary class members. Constructors, destructors and assignment operators of +# the base classes will not be shown. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = YES + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. It is allowed to use relative paths in the argument list. + +STRIP_FROM_PATH = . + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = YES + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower case letters. If set to YES upper case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# users are adviced to set this option to NO. + +CASE_SENSE_NAMES = YES + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter +# (but less readable) file names. This can be useful is your file systems +# doesn't support long names like on DOS, Mac, or CD-ROM. + +SHORT_NAMES = NO + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the JavaDoc +# comments will behave just like the Qt-style comments (thus requiring an +# explict @brief command for a brief description. + +JAVADOC_AUTOBRIEF = NO + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# reimplements. + +INHERIT_DOCS = YES + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 8 + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or +# disable (NO) the bug list. This list is created by putting \bug +# commands in the documentation. + +GENERATE_BUGLIST = YES + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = + +# The ENABLED_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines +# the initial value of a variable or define consist of for it to appear in +# the documentation. If the initializer consists of more lines than specified +# here it will be hidden. Use a value of 0 to hide initializers completely. +# The appearance of the initializer of individual variables and defines in the +# documentation can be controlled using \showinitializer or \hideinitializer +# command in the documentation regardless of this setting. + +MAX_INITIALIZER_LINES = 30 + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. +# For instance some of the names that are used will be different. The list +# of all members will be omitted, etc. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated +# at the bottom of the documentation of classes and structs. If set to YES the +# list will mention the files that were used to generate the documentation. + +SHOW_USED_FILES = YES + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = YES + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning +# and error messages should be written. If left blank the output is written +# to stderr. + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank the following patterns are tested: +# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx *.hpp +# *.h++ *.idl *.odl + +FILE_PATTERNS = + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = test \ + tools \ + win32 \ + lib \ + examples \ + docs \ + CVS \ + SCCS \ + config \ + bin \ + include/ndbapi \ + include/newtonapi \ + src/newtonapi \ + include/mgmapi \ + src/mgmapi \ + src/client + +# The EXCLUDE_SYMLINKS tag can be used select whether or not files or directories +# that are symbolic links (a Unix filesystem feature) are excluded from the input. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. + +EXCLUDE_PATTERNS = *CVS* \ + *SCCS* + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude +# commands irrespective of the value of the RECURSIVE tag. +# Possible values are YES and NO. If left blank NO is used. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. + +INPUT_FILTER = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will be used to filter the input files when producing source +# files to browse. + +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. + +SOURCE_BROWSER = YES + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = YES + +# If the REFERENCED_BY_RELATION tag is set to YES (the default) +# then for each documented function all documented +# functions referencing it will be listed. + +REFERENCED_BY_RELATION = YES + +# If the REFERENCES_RELATION tag is set to YES (the default) +# then for each documented function all documented entities +# called/used by that function will be listed. + +REFERENCES_RELATION = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = YES + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = ndb.html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for +# each generated HTML page (for example: .htm,.php,.asp). If it is left blank +# doxygen will generate files with .html extension. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet + +HTML_STYLESHEET = + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag +# controls if a separate .chi index file is generated (YES) or that +# it should be included in the master .chm file (NO). + +GENERATE_CHI = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag +# controls whether a binary table of contents is generated (YES) or a +# normal table of contents (NO) in the .chm file. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members +# to the contents of the Html help documentation and to the tree view. + +TOC_EXPAND = NO + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +# This tag can be used to set the number of enum values (range [1..20]) +# that doxygen will group on one line in the generated HTML documentation. + +ENUM_VALUES_PER_LINE = 4 + +# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be +# generated containing a tree-like index structure (just like the one that +# is generated for HTML Help). For this to work a browser that supports +# JavaScript and frames is required (for instance Mozilla, Netscape 4.0+, +# or Internet explorer 4.0+). Note that for large projects the tree generation +# can take a very long time. In such cases it is better to disable this feature. +# Windows users are probably better off using the HTML help feature. + +GENERATE_TREEVIEW = NO + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be +# used to set the initial width (in pixels) of the frame in which the tree +# is shown. + +TREEVIEW_WIDTH = 250 + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = NO + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = ndb.latex + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = a4wide + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = NO + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = NO + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimised for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using WORD or other +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assigments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an rtf document. +# Syntax is similar to doxygen's config file. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = .3 + +# If the MAN_LINKS tag is set to YES and Doxygen generates man output, +# then it will generate one additional man file for each entity +# documented in the real man page(s). These additional files +# only source the real man page, but without them the man command +# would be unable to find the correct page. The default is NO. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. Note that this +# feature is still experimental and incomplete at the +# moment. + +GENERATE_XML = NO + +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will +# generate an AutoGen Definitions (see autogen.sf.net) file +# that captures the structure of the code including all +# documentation. Note that this feature is still experimental +# and incomplete at the moment. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_PREDEFINED tags. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_PREDEF_ONLY tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then +# doxygen's preprocessor will remove all function-like macros that are alone +# on a line and do not end with a semicolon. Such function macros are typically +# used for boiler-plate code, and will confuse the parser if not removed. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration::addtions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES tag can be used to specify one or more tagfiles. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = NO + +# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed +# in the modules index. If set to NO, only the current project's groups will +# be listed. + +EXTERNAL_GROUPS = YES + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a inheritance diagram (in Html, RTF and LaTeX) for classes with base or +# super classes. Setting the tag to NO turns the diagrams off. Note that this +# option is superceded by the HAVE_DOT option below. This is only a fallback. It is +# recommended to install and use dot, since it yield more powerful graphs. + +CLASS_DIAGRAMS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = YES + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = YES + +# If set to YES, the inheritance and collaboration graphs will hide +# inheritance and usage relations if the target is undocumented +# or is not a class. + +HIDE_UNDOC_RELATIONS = NO + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT +# tags are set to YES then doxygen will generate a graph for each documented +# file showing the direct and indirect include dependencies of the file with +# other documented files. + +INCLUDE_GRAPH = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and +# HAVE_DOT tags are set to YES then doxygen will generate a graph for each +# documented header file showing the documented files that directly or +# indirectly include this file. + +INCLUDED_BY_GRAPH = YES + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images +# generated by dot. Possible values are gif, jpg, and png +# If left blank gif will be used. + +DOT_IMAGE_FORMAT = gif + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found on the path. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the +# \dotfile command). + +DOTFILE_DIRS = + +# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_WIDTH = 1024 + +# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_HEIGHT = 1024 + +# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will +# generate a legend page explaining the meaning of the various boxes and +# arrows in the dot generated graphs. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will +# remove the intermedate dot files that are used to generate +# the various graphs. + +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +# Configuration::addtions related to the search engine +#--------------------------------------------------------------------------- + +# The SEARCHENGINE tag specifies whether or not a search engine should be +# used. If set to NO the values of all tags below this one will be ignored. + +SEARCHENGINE = NO + +# The CGI_NAME tag should be the name of the CGI script that +# starts the search engine (doxysearch) with the correct parameters. +# A script with this name will be generated by doxygen. + +CGI_NAME = search.cgi + +# The CGI_URL tag should be the absolute URL to the directory where the +# cgi binaries are located. See the documentation of your http daemon for +# details. + +CGI_URL = + +# The DOC_URL tag should be the absolute URL to the directory where the +# documentation is located. If left blank the absolute path to the +# documentation, with file:// prepended to it, will be used. + +DOC_URL = + +# The DOC_ABSPATH tag should be the absolute path to the directory where the +# documentation is located. If left blank the directory on the local machine +# will be used. + +DOC_ABSPATH = + +# The BIN_ABSPATH tag must point to the directory where the doxysearch binary +# is installed. + +BIN_ABSPATH = /usr/local/bin + +# The EXT_DOC_PATHS tag can be used to specify one or more paths to +# documentation generated for other projects. This allows doxysearch to search +# the documentation for these projects as well. + +EXT_DOC_PATHS = diff --git a/ndb/docs/doxygen/Doxyfile.ndbapi b/ndb/docs/doxygen/Doxyfile.ndbapi new file mode 100644 index 00000000000..61d58d4fea3 --- /dev/null +++ b/ndb/docs/doxygen/Doxyfile.ndbapi @@ -0,0 +1,877 @@ +# Doxyfile 1.2.12 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# General configuration options +#--------------------------------------------------------------------------- +DETAILS_AT_TOP = yes +HIDE_FRIEND_COMPOUNDS = yes + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +OUTPUT_DIRECTORY = + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Brazilian, Chinese, Croatian, Czech, Danish, Dutch, Finnish, French, +# German, Hungarian, Italian, Japanese, Korean, Norwegian, Polish, +# Portuguese, Romanian, Russian, Slovak, Slovene, Spanish and Swedish. + +OUTPUT_LANGUAGE = English + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = NO + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these class will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = NO + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = YES + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = NO + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. It is allowed to use relative paths in the argument list. + +STRIP_FROM_PATH = + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower case letters. If set to YES upper case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# users are adviced to set this option to NO. + +CASE_SENSE_NAMES = YES + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter +# (but less readable) file names. This can be useful is your file systems +# doesn't support long names like on DOS, Mac, or CD-ROM. + +SHORT_NAMES = NO + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the JavaDoc +# comments will behave just like the Qt-style comments (thus requiring an +# explict @brief command for a brief description. + +JAVADOC_AUTOBRIEF = NO + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# reimplements. + +INHERIT_DOCS = YES + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 8 + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or +# disable (NO) the bug list. This list is created by putting \bug +# commands in the documentation. + +GENERATE_BUGLIST = YES + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = + +# The ENABLED_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines +# the initial value of a variable or define consist of for it to appear in +# the documentation. If the initializer consists of more lines than specified +# here it will be hidden. Use a value of 0 to hide initializers completely. +# The appearance of the initializer of individual variables and defines in the +# documentation can be controlled using \showinitializer or \hideinitializer +# command in the documentation regardless of this setting. + +MAX_INITIALIZER_LINES = 30 + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. +# For instance some of the names that are used will be different. The list +# of all members will be omitted, etc. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated +# at the bottom of the documentation of classes and structs. If set to YES the +# list will mention the files that were used to generate the documentation. + +SHOW_USED_FILES = YES + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = YES + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. + +WARN_FORMAT = + +# The WARN_LOGFILE tag can be used to specify a file to which warning +# and error messages should be written. If left blank the output is written +# to stderr. + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = . + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank file matching one of the following patterns are included: +# *.c *.cc *.cxx *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx *.hpp +# *.h++ *.idl + +FILE_PATTERNS = + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = NO + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. + +EXCLUDE_PATTERNS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = . + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude +# commands irrespective of the value of the RECURSIVE tag. +# Possible values are YES and NO. If left blank NO is used. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. + +INPUT_FILTER = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will be used to filter the input files when producing source +# files to browse. + +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = NO + +# If the REFERENCED_BY_RELATION tag is set to YES (the default) +# then for each documented function all documented +# functions referencing it will be listed. + +REFERENCED_BY_RELATION = YES + +# If the REFERENCES_RELATION tag is set to YES (the default) +# then for each documented function all documented entities +# called/used by that function will be listed. + +REFERENCES_RELATION = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = NO + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = ../.doxyout/ndbapi.html + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = footer.html + +# The HTML_STYLESHEET tag can be used to specify a user defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet + +HTML_STYLESHEET = + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag +# controls if a separate .chi index file is generated (YES) or that +# it should be included in the master .chm file (NO). + +GENERATE_CHI = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag +# controls whether a binary table of contents is generated (YES) or a +# normal table of contents (NO) in the .chm file. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members +# to the contents of the Html help documentation and to the tree view. + +TOC_EXPAND = NO + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +# This tag can be used to set the number of enum values (range [1..20]) +# that doxygen will group on one line in the generated HTML documentation. + +ENUM_VALUES_PER_LINE = 4 + +# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be +# generated containing a tree-like index structure (just like the one that +# is generated for HTML Help). For this to work a browser that supports +# JavaScript and frames is required (for instance Mozilla, Netscape 4.0+, +# or Internet explorer 4.0+). Note that for large projects the tree generation +# can take a very long time. In such cases it is better to disable this feature. +# Windows users are probably better off using the HTML help feature. + +GENERATE_TREEVIEW = NO + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be +# used to set the initial width (in pixels) of the frame in which the tree +# is shown. + +TREEVIEW_WIDTH = 250 + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = YES + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = ../.doxyout/ndbapi.latex + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = ../doxygen/header.ndbapi.tex + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = YES + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = YES + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimised for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = ../ndbapi.rtf + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using WORD or other +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assigments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an rtf document. +# Syntax is similar to doxygen's config file. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = + +# If the MAN_LINKS tag is set to YES and Doxygen generates man output, +# then it will generate one additional man file for each entity +# documented in the real man page(s). These additional files +# only source the real man page, but without them the man command +# would be unable to find the correct page. The default is NO. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. Note that this +# feature is still experimental and incomplete at the +# moment. + +GENERATE_XML = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = YES + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_PREDEFINED tags. + +EXPAND_ONLY_PREDEF = YES + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. + +PREDEFINED = DOXYGEN_SHOULD_SKIP_DEPRECATED \ + DOXYGEN_SHOULD_SKIP_INTERNAL \ + protected=private + +# If the MACRO_EXPANSION and EXPAND_PREDEF_ONLY tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then +# doxygen's preprocessor will remove all function-like macros that are alone +# on a line and do not end with a semicolon. Such function macros are typically +# used for boiler-plate code, and will confuse the parser if not removed. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration::addtions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES tag can be used to specify one or more tagfiles. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = NO + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a inheritance diagram (in Html, RTF and LaTeX) for classes with base or +# super classes. Setting the tag to NO turns the diagrams off. Note that this +# option is superceded by the HAVE_DOT option below. This is only a fallback. It is +# recommended to install and use dot, since it yield more powerful graphs. + +CLASS_DIAGRAMS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = NO + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = YES + +# If set to YES, the inheritance and collaboration graphs will hide +# inheritance and usage relations if the target is undocumented +# or is not a class. + +HIDE_UNDOC_RELATIONS = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT +# tags are set to YES then doxygen will generate a graph for each documented +# file showing the direct and indirect include dependencies of the file with +# other documented files. + +INCLUDE_GRAPH = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and +# HAVE_DOT tags are set to YES then doxygen will generate a graph for each +# documented header file showing the documented files that directly or +# indirectly include this file. + +INCLUDED_BY_GRAPH = YES + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found on the path. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the +# \dotfile command). + +DOTFILE_DIRS = + +# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_WIDTH = 1024 + +# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_HEIGHT = 1024 + +# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will +# generate a legend page explaining the meaning of the various boxes and +# arrows in the dot generated graphs. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will +# remove the intermedate dot files that are used to generate +# the various graphs. + +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +# Configuration::addtions related to the search engine +#--------------------------------------------------------------------------- + +# The SEARCHENGINE tag specifies whether or not a search engine should be +# used. If set to NO the values of all tags below this one will be ignored. + +SEARCHENGINE = NO + +# The CGI_NAME tag should be the name of the CGI script that +# starts the search engine (doxysearch) with the correct parameters. +# A script with this name will be generated by doxygen. + +CGI_NAME = + +# The CGI_URL tag should be the absolute URL to the directory where the +# cgi binaries are located. See the documentation of your http daemon for +# details. + +CGI_URL = + +# The DOC_URL tag should be the absolute URL to the directory where the +# documentation is located. If left blank the absolute path to the +# documentation, with file:// prepended to it, will be used. + +DOC_URL = + +# The DOC_ABSPATH tag should be the absolute path to the directory where the +# documentation is located. If left blank the directory on the local machine +# will be used. + +DOC_ABSPATH = + +# The BIN_ABSPATH tag must point to the directory where the doxysearch binary +# is installed. + +BIN_ABSPATH = + +# The EXT_DOC_PATHS tag can be used to specify one or more paths to +# documentation generated for other projects. This allows doxysearch to search +# the documentation for these projects as well. + +EXT_DOC_PATHS = diff --git a/ndb/docs/doxygen/Doxyfile.odbc b/ndb/docs/doxygen/Doxyfile.odbc new file mode 100644 index 00000000000..93e052d5b9d --- /dev/null +++ b/ndb/docs/doxygen/Doxyfile.odbc @@ -0,0 +1,921 @@ +# Doxyfile 1.2.14 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# General configuration options +#--------------------------------------------------------------------------- + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = "NDB ODBC" + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +OUTPUT_DIRECTORY = + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Brazilian, Chinese, Croatian, Czech, Danish, Dutch, Finnish, French, +# German, Greek, Hungarian, Italian, Japanese, Korean, Norwegian, Polish, +# Portuguese, Romanian, Russian, Slovak, Slovene, Spanish and Swedish. + +OUTPUT_LANGUAGE = English + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = YES + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = YES + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = YES + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) +# defined locally in source files will be included in the documentation. +# If set to NO only classes defined in header files are included. + +EXTRACT_LOCAL_CLASSES = YES + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these class will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = NO + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = YES + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all inherited +# members of a class in the documentation of that class as if those members were +# ordinary class members. Constructors, destructors and assignment operators of +# the base classes will not be shown. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = YES + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. It is allowed to use relative paths in the argument list. + +STRIP_FROM_PATH = . + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = YES + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower case letters. If set to YES upper case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# users are adviced to set this option to NO. + +CASE_SENSE_NAMES = YES + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter +# (but less readable) file names. This can be useful is your file systems +# doesn't support long names like on DOS, Mac, or CD-ROM. + +SHORT_NAMES = NO + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the JavaDoc +# comments will behave just like the Qt-style comments (thus requiring an +# explict @brief command for a brief description. + +JAVADOC_AUTOBRIEF = NO + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# reimplements. + +INHERIT_DOCS = YES + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 8 + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or +# disable (NO) the bug list. This list is created by putting \bug +# commands in the documentation. + +GENERATE_BUGLIST = YES + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = + +# The ENABLED_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines +# the initial value of a variable or define consist of for it to appear in +# the documentation. If the initializer consists of more lines than specified +# here it will be hidden. Use a value of 0 to hide initializers completely. +# The appearance of the initializer of individual variables and defines in the +# documentation can be controlled using \showinitializer or \hideinitializer +# command in the documentation regardless of this setting. + +MAX_INITIALIZER_LINES = 30 + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. +# For instance some of the names that are used will be different. The list +# of all members will be omitted, etc. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated +# at the bottom of the documentation of classes and structs. If set to YES the +# list will mention the files that were used to generate the documentation. + +SHOW_USED_FILES = YES + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = YES + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning +# and error messages should be written. If left blank the output is written +# to stderr. + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = src/client/odbc + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank the following patterns are tested: +# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx *.hpp +# *.h++ *.idl *.odl + +FILE_PATTERNS = + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used select whether or not files or directories +# that are symbolic links (a Unix filesystem feature) are excluded from the input. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. + +EXCLUDE_PATTERNS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude +# commands irrespective of the value of the RECURSIVE tag. +# Possible values are YES and NO. If left blank NO is used. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. + +INPUT_FILTER = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will be used to filter the input files when producing source +# files to browse. + +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. + +SOURCE_BROWSER = YES + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = YES + +# If the REFERENCED_BY_RELATION tag is set to YES (the default) +# then for each documented function all documented +# functions referencing it will be listed. + +REFERENCED_BY_RELATION = YES + +# If the REFERENCES_RELATION tag is set to YES (the default) +# then for each documented function all documented entities +# called/used by that function will be listed. + +REFERENCES_RELATION = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = YES + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = ../.doxyout/odbc.html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for +# each generated HTML page (for example: .htm,.php,.asp). If it is left blank +# doxygen will generate files with .html extension. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet + +HTML_STYLESHEET = + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag +# controls if a separate .chi index file is generated (YES) or that +# it should be included in the master .chm file (NO). + +GENERATE_CHI = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag +# controls whether a binary table of contents is generated (YES) or a +# normal table of contents (NO) in the .chm file. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members +# to the contents of the Html help documentation and to the tree view. + +TOC_EXPAND = NO + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +# This tag can be used to set the number of enum values (range [1..20]) +# that doxygen will group on one line in the generated HTML documentation. + +ENUM_VALUES_PER_LINE = 4 + +# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be +# generated containing a tree-like index structure (just like the one that +# is generated for HTML Help). For this to work a browser that supports +# JavaScript and frames is required (for instance Mozilla, Netscape 4.0+, +# or Internet explorer 4.0+). Note that for large projects the tree generation +# can take a very long time. In such cases it is better to disable this feature. +# Windows users are probably better off using the HTML help feature. + +GENERATE_TREEVIEW = NO + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be +# used to set the initial width (in pixels) of the frame in which the tree +# is shown. + +TREEVIEW_WIDTH = 250 + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = NO + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = ../.doxyout/odbc.latex + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = a4wide + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = NO + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = NO + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimised for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using WORD or other +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assigments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an rtf document. +# Syntax is similar to doxygen's config file. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = .3 + +# If the MAN_LINKS tag is set to YES and Doxygen generates man output, +# then it will generate one additional man file for each entity +# documented in the real man page(s). These additional files +# only source the real man page, but without them the man command +# would be unable to find the correct page. The default is NO. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. Note that this +# feature is still experimental and incomplete at the +# moment. + +GENERATE_XML = NO + +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will +# generate an AutoGen Definitions (see autogen.sf.net) file +# that captures the structure of the code including all +# documentation. Note that this feature is still experimental +# and incomplete at the moment. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_PREDEFINED tags. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_PREDEF_ONLY tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then +# doxygen's preprocessor will remove all function-like macros that are alone +# on a line and do not end with a semicolon. Such function macros are typically +# used for boiler-plate code, and will confuse the parser if not removed. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration::addtions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES tag can be used to specify one or more tagfiles. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = NO + +# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed +# in the modules index. If set to NO, only the current project's groups will +# be listed. + +EXTERNAL_GROUPS = YES + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a inheritance diagram (in Html, RTF and LaTeX) for classes with base or +# super classes. Setting the tag to NO turns the diagrams off. Note that this +# option is superceded by the HAVE_DOT option below. This is only a fallback. It is +# recommended to install and use dot, since it yield more powerful graphs. + +CLASS_DIAGRAMS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = YES + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = YES + +# If set to YES, the inheritance and collaboration graphs will hide +# inheritance and usage relations if the target is undocumented +# or is not a class. + +HIDE_UNDOC_RELATIONS = NO + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT +# tags are set to YES then doxygen will generate a graph for each documented +# file showing the direct and indirect include dependencies of the file with +# other documented files. + +INCLUDE_GRAPH = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and +# HAVE_DOT tags are set to YES then doxygen will generate a graph for each +# documented header file showing the documented files that directly or +# indirectly include this file. + +INCLUDED_BY_GRAPH = YES + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images +# generated by dot. Possible values are gif, jpg, and png +# If left blank gif will be used. + +DOT_IMAGE_FORMAT = gif + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found on the path. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the +# \dotfile command). + +DOTFILE_DIRS = + +# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_WIDTH = 1024 + +# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_HEIGHT = 1024 + +# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will +# generate a legend page explaining the meaning of the various boxes and +# arrows in the dot generated graphs. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will +# remove the intermedate dot files that are used to generate +# the various graphs. + +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +# Configuration::addtions related to the search engine +#--------------------------------------------------------------------------- + +# The SEARCHENGINE tag specifies whether or not a search engine should be +# used. If set to NO the values of all tags below this one will be ignored. + +SEARCHENGINE = YES + +# The CGI_NAME tag should be the name of the CGI script that +# starts the search engine (doxysearch) with the correct parameters. +# A script with this name will be generated by doxygen. + +CGI_NAME = search.cgi + +# The CGI_URL tag should be the absolute URL to the directory where the +# cgi binaries are located. See the documentation of your http daemon for +# details. + +CGI_URL = + +# The DOC_URL tag should be the absolute URL to the directory where the +# documentation is located. If left blank the absolute path to the +# documentation, with file:// prepended to it, will be used. + +DOC_URL = + +# The DOC_ABSPATH tag should be the absolute path to the directory where the +# documentation is located. If left blank the directory on the local machine +# will be used. + +DOC_ABSPATH = + +# The BIN_ABSPATH tag must point to the directory where the doxysearch binary +# is installed. + +BIN_ABSPATH = /usr/local/bin/ + +# The EXT_DOC_PATHS tag can be used to specify one or more paths to +# documentation generated for other projects. This allows doxysearch to search +# the documentation for these projects as well. + +EXT_DOC_PATHS = diff --git a/ndb/docs/doxygen/Doxyfile.test b/ndb/docs/doxygen/Doxyfile.test new file mode 100644 index 00000000000..34ee21873ff --- /dev/null +++ b/ndb/docs/doxygen/Doxyfile.test @@ -0,0 +1,921 @@ +# Doxyfile 1.2.14 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# General configuration options +#--------------------------------------------------------------------------- + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = "NDB Cluster Test Programs" + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +OUTPUT_DIRECTORY = + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Brazilian, Chinese, Croatian, Czech, Danish, Dutch, Finnish, French, +# German, Greek, Hungarian, Italian, Japanese, Korean, Norwegian, Polish, +# Portuguese, Romanian, Russian, Slovak, Slovene, Spanish and Swedish. + +OUTPUT_LANGUAGE = English + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = YES + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = YES + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = YES + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) +# defined locally in source files will be included in the documentation. +# If set to NO only classes defined in header files are included. + +EXTRACT_LOCAL_CLASSES = YES + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these class will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = NO + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = YES + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all inherited +# members of a class in the documentation of that class as if those members were +# ordinary class members. Constructors, destructors and assignment operators of +# the base classes will not be shown. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = YES + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. It is allowed to use relative paths in the argument list. + +STRIP_FROM_PATH = . + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = YES + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower case letters. If set to YES upper case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# users are adviced to set this option to NO. + +CASE_SENSE_NAMES = YES + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter +# (but less readable) file names. This can be useful is your file systems +# doesn't support long names like on DOS, Mac, or CD-ROM. + +SHORT_NAMES = NO + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the JavaDoc +# comments will behave just like the Qt-style comments (thus requiring an +# explict @brief command for a brief description. + +JAVADOC_AUTOBRIEF = NO + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# reimplements. + +INHERIT_DOCS = YES + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 8 + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or +# disable (NO) the bug list. This list is created by putting \bug +# commands in the documentation. + +GENERATE_BUGLIST = YES + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = + +# The ENABLED_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines +# the initial value of a variable or define consist of for it to appear in +# the documentation. If the initializer consists of more lines than specified +# here it will be hidden. Use a value of 0 to hide initializers completely. +# The appearance of the initializer of individual variables and defines in the +# documentation can be controlled using \showinitializer or \hideinitializer +# command in the documentation regardless of this setting. + +MAX_INITIALIZER_LINES = 30 + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. +# For instance some of the names that are used will be different. The list +# of all members will be omitted, etc. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated +# at the bottom of the documentation of classes and structs. If set to YES the +# list will mention the files that were used to generate the documentation. + +SHOW_USED_FILES = YES + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = YES + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning +# and error messages should be written. If left blank the output is written +# to stderr. + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = test + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank the following patterns are tested: +# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx *.hpp +# *.h++ *.idl *.odl + +FILE_PATTERNS = + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used select whether or not files or directories +# that are symbolic links (a Unix filesystem feature) are excluded from the input. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. + +EXCLUDE_PATTERNS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude +# commands irrespective of the value of the RECURSIVE tag. +# Possible values are YES and NO. If left blank NO is used. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. + +INPUT_FILTER = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will be used to filter the input files when producing source +# files to browse. + +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. + +SOURCE_BROWSER = YES + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = YES + +# If the REFERENCED_BY_RELATION tag is set to YES (the default) +# then for each documented function all documented +# functions referencing it will be listed. + +REFERENCED_BY_RELATION = YES + +# If the REFERENCES_RELATION tag is set to YES (the default) +# then for each documented function all documented entities +# called/used by that function will be listed. + +REFERENCES_RELATION = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = YES + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for +# each generated HTML page (for example: .htm,.php,.asp). If it is left blank +# doxygen will generate files with .html extension. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet + +HTML_STYLESHEET = + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag +# controls if a separate .chi index file is generated (YES) or that +# it should be included in the master .chm file (NO). + +GENERATE_CHI = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag +# controls whether a binary table of contents is generated (YES) or a +# normal table of contents (NO) in the .chm file. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members +# to the contents of the Html help documentation and to the tree view. + +TOC_EXPAND = NO + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +# This tag can be used to set the number of enum values (range [1..20]) +# that doxygen will group on one line in the generated HTML documentation. + +ENUM_VALUES_PER_LINE = 4 + +# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be +# generated containing a tree-like index structure (just like the one that +# is generated for HTML Help). For this to work a browser that supports +# JavaScript and frames is required (for instance Mozilla, Netscape 4.0+, +# or Internet explorer 4.0+). Note that for large projects the tree generation +# can take a very long time. In such cases it is better to disable this feature. +# Windows users are probably better off using the HTML help feature. + +GENERATE_TREEVIEW = NO + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be +# used to set the initial width (in pixels) of the frame in which the tree +# is shown. + +TREEVIEW_WIDTH = 250 + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = NO + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = latex + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = a4wide + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = NO + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = NO + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimised for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using WORD or other +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assigments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an rtf document. +# Syntax is similar to doxygen's config file. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = .3 + +# If the MAN_LINKS tag is set to YES and Doxygen generates man output, +# then it will generate one additional man file for each entity +# documented in the real man page(s). These additional files +# only source the real man page, but without them the man command +# would be unable to find the correct page. The default is NO. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. Note that this +# feature is still experimental and incomplete at the +# moment. + +GENERATE_XML = NO + +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will +# generate an AutoGen Definitions (see autogen.sf.net) file +# that captures the structure of the code including all +# documentation. Note that this feature is still experimental +# and incomplete at the moment. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_PREDEFINED tags. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_PREDEF_ONLY tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then +# doxygen's preprocessor will remove all function-like macros that are alone +# on a line and do not end with a semicolon. Such function macros are typically +# used for boiler-plate code, and will confuse the parser if not removed. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration::addtions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES tag can be used to specify one or more tagfiles. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = NO + +# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed +# in the modules index. If set to NO, only the current project's groups will +# be listed. + +EXTERNAL_GROUPS = YES + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a inheritance diagram (in Html, RTF and LaTeX) for classes with base or +# super classes. Setting the tag to NO turns the diagrams off. Note that this +# option is superceded by the HAVE_DOT option below. This is only a fallback. It is +# recommended to install and use dot, since it yield more powerful graphs. + +CLASS_DIAGRAMS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = YES + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = YES + +# If set to YES, the inheritance and collaboration graphs will hide +# inheritance and usage relations if the target is undocumented +# or is not a class. + +HIDE_UNDOC_RELATIONS = NO + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT +# tags are set to YES then doxygen will generate a graph for each documented +# file showing the direct and indirect include dependencies of the file with +# other documented files. + +INCLUDE_GRAPH = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and +# HAVE_DOT tags are set to YES then doxygen will generate a graph for each +# documented header file showing the documented files that directly or +# indirectly include this file. + +INCLUDED_BY_GRAPH = YES + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images +# generated by dot. Possible values are gif, jpg, and png +# If left blank gif will be used. + +DOT_IMAGE_FORMAT = gif + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found on the path. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the +# \dotfile command). + +DOTFILE_DIRS = + +# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_WIDTH = 1024 + +# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_HEIGHT = 1024 + +# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will +# generate a legend page explaining the meaning of the various boxes and +# arrows in the dot generated graphs. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will +# remove the intermedate dot files that are used to generate +# the various graphs. + +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +# Configuration::addtions related to the search engine +#--------------------------------------------------------------------------- + +# The SEARCHENGINE tag specifies whether or not a search engine should be +# used. If set to NO the values of all tags below this one will be ignored. + +SEARCHENGINE = NO + +# The CGI_NAME tag should be the name of the CGI script that +# starts the search engine (doxysearch) with the correct parameters. +# A script with this name will be generated by doxygen. + +CGI_NAME = search.cgi + +# The CGI_URL tag should be the absolute URL to the directory where the +# cgi binaries are located. See the documentation of your http daemon for +# details. + +CGI_URL = + +# The DOC_URL tag should be the absolute URL to the directory where the +# documentation is located. If left blank the absolute path to the +# documentation, with file:// prepended to it, will be used. + +DOC_URL = + +# The DOC_ABSPATH tag should be the absolute path to the directory where the +# documentation is located. If left blank the directory on the local machine +# will be used. + +DOC_ABSPATH = + +# The BIN_ABSPATH tag must point to the directory where the doxysearch binary +# is installed. + +BIN_ABSPATH = /usr/local/bin + +# The EXT_DOC_PATHS tag can be used to specify one or more paths to +# documentation generated for other projects. This allows doxysearch to search +# the documentation for these projects as well. + +EXT_DOC_PATHS = diff --git a/ndb/docs/doxygen/header.mgmapi.tex b/ndb/docs/doxygen/header.mgmapi.tex new file mode 100644 index 00000000000..1b55ceb15c7 --- /dev/null +++ b/ndb/docs/doxygen/header.mgmapi.tex @@ -0,0 +1,44 @@ +\documentclass[a4paper]{book} +\usepackage{a4wide} +\usepackage{makeidx} +\usepackage{fancyhdr} +\usepackage{graphicx} +\usepackage{multicol} +\usepackage{float} +\usepackage{textcomp} +\usepackage{alltt} +\usepackage{times} +\ifx\pdfoutput\undefined +\usepackage[ps2pdf, + pagebackref=true, + colorlinks=true, + linkcolor=blue + ]{hyperref} +\usepackage{pspicture} +\else +\usepackage[pdftex, + pagebackref=true, + colorlinks=true, + linkcolor=blue + ]{hyperref} +\fi +\usepackage{doxygen} +\makeindex +\setcounter{tocdepth}{1} +\renewcommand{\footrulewidth}{0.4pt} +\begin{document} +\begin{titlepage} +\vspace*{7cm} +\begin{center} +{\Huge NDB Cluster MGM API Guide \mbox{}\vspace{-3cm}\mbox{}\hrule\bigskip\bigskip\bigskip\bigskip\mbox{}\Huge{}}\\\vspace*{1cm} +\begin{center}\LARGE{MySQL AB}\end{center}\hfill\bigskip\bigskip\bigskip\hrule\bigskip\bigskip\bigskip\bigskip\bigskip\bigskip\bigskip\bigskip\bigskip\bigskip\bigskip\bigskip NDB Cluster Release RELEASE +\bigskip\bigskip\bigskip\bigskip\bigskip\hfill\vspace*{0.5cm} +{\small DATE}\\ +\end{center} +\end{titlepage} +\clearemptydoublepage +\pagenumbering{roman} +\tableofcontents +\clearemptydoublepage +\pagenumbering{arabic} + diff --git a/ndb/docs/doxygen/header.ndbapi.tex b/ndb/docs/doxygen/header.ndbapi.tex new file mode 100644 index 00000000000..c37ce286ed8 --- /dev/null +++ b/ndb/docs/doxygen/header.ndbapi.tex @@ -0,0 +1,44 @@ +\documentclass[a4paper]{book} +\usepackage{a4wide} +\usepackage{makeidx} +\usepackage{fancyhdr} +\usepackage{graphicx} +\usepackage{multicol} +\usepackage{float} +\usepackage{textcomp} +\usepackage{alltt} +\usepackage{times} +\ifx\pdfoutput\undefined +\usepackage[ps2pdf, + pagebackref=true, + colorlinks=true, + linkcolor=blue + ]{hyperref} +\usepackage{pspicture} +\else +\usepackage[pdftex, + pagebackref=true, + colorlinks=true, + linkcolor=blue + ]{hyperref} +\fi +\usepackage{doxygen} +\makeindex +\setcounter{tocdepth}{1} +\renewcommand{\footrulewidth}{0.4pt} +\begin{document} +\begin{titlepage} +\vspace*{7cm} +\begin{center} +{\Huge NDB API Programmer's Guide \mbox{}\vspace{-3cm}\mbox{}\hrule\bigskip\bigskip\bigskip\bigskip\mbox{}\Huge{}}\\\vspace*{1cm} +\begin{center}\LARGE{MySQL AB}\end{center}\hfill\bigskip\bigskip\bigskip\hrule\bigskip\bigskip\bigskip\bigskip\bigskip\bigskip\bigskip\bigskip\bigskip\bigskip\bigskip\bigskip NDB Cluster Release RELEASE +\bigskip\bigskip\bigskip\bigskip\bigskip\hfill\vspace*{0.5cm} +{\small DATE}\\ +\end{center} +\end{titlepage} +\clearemptydoublepage +\pagenumbering{roman} +\tableofcontents +\clearemptydoublepage +\pagenumbering{arabic} + diff --git a/ndb/docs/doxygen/postdoxy.pl b/ndb/docs/doxygen/postdoxy.pl new file mode 100755 index 00000000000..95062d1899f --- /dev/null +++ b/ndb/docs/doxygen/postdoxy.pl @@ -0,0 +1,97 @@ +#!/usr/local/bin/perl +# +# Written by Lars Thalmann, lars@mysql.com, 2003. +# + +use strict; +umask 000; + +# ----------------------------------------------------------------------------- +# Settings +# ----------------------------------------------------------------------------- + +$ENV{LD_LIBRARY_PATH} = "/usr/local/lib:/opt/as/local/lib"; +$ENV{LD_LIBRARY_PATH} = $ENV{LD_LIBRARY_PATH} . ":/opt/as/forte6/SUNWspro/lib"; +$ENV{PATH} = $ENV{PATH} . ":/usr/local/bin:/opt/as/local/bin"; +$ENV{PATH} = $ENV{PATH} . ":/opt/as/local/teTeX/bin/sparc-sun-solaris2.8"; + +my $destdir = @ARGV[0]; +my $title = ""; # $ARGV[1]; + +my $release; +if (defined $ENV{'NDB_RELEASE'}) { + $release = $ENV{'NDB_RELEASE'}; + print "----------------------------------------------------------------\n"; + print "Relase = " . $release . "\n"; + print "----------------------------------------------------------------\n"; +} else { + print "----------------------------------------------------------------\n"; + print "NDB Documentation is being modified to statndard format\n"; + print "(If you want this automatic, use env variable NDB_RELEASE.)\n"; + print "Enter release (Examples: \"1.43.0 (alpha)\" or \"2.1.0 (gamma)\"): "; + $release = ; + print "----------------------------------------------------------------\n"; +} + +# ----------------------------------------------------------------------------- +# Change a little in refman.tex +# ----------------------------------------------------------------------------- + +open (INFILE, "< ${destdir}/refman.tex") + or die "Error opening ${destdir}/refman.tex.\n"; +open (OUTFILE, "> ${destdir}/refman.tex.new") + or die "Error opening ${destdir}/refman.tex.new.\n"; + +while () +{ + if (/(.*)(RELEASE)(.*)$/) { + print OUTFILE $1 . $release . $3; + } elsif (/(.*)(DATE)(.*)$/) { + print OUTFILE $1 . localtime() . $3; + } elsif (/\\chapter\{File Index\}/) { + # Erase + } elsif (/\\input\{files\}/) { + # Erase + } elsif (/\\chapter\{Hierarchical Index\}/) { + # Erase + } elsif (/\\input\{hierarchy\}/) { + # Erase + } elsif (/\\chapter\{Page Index\}/) { + # Erase + } elsif (/\\input\{pages\}/) { + # Erase + } else { + print OUTFILE; + } +} + +close INFILE; +close OUTFILE; + +system("mv ${destdir}/refman.tex.new ${destdir}/refman.tex"); + +# ----------------------------------------------------------------------------- +# Change a little in doxygen.sty +# ----------------------------------------------------------------------------- + +open (INFILE, "< ${destdir}/doxygen.sty") + or die "Error opening INFILE.\n"; +open (OUTFILE, "> ${destdir}/doxygen.sty.new") + or die "Error opening OUTFILE.\n"; + +while () +{ + if (/\\rfoot/) { + print OUTFILE "\\rfoot[\\fancyplain{}{\\bfseries\\small \\copyright~Copyright 2003-2004 MySQL AB\\hfill support-cluster\@mysql.com}]{}\n"; + } elsif (/\\lfoot/) { + print OUTFILE "\\lfoot[]{\\fancyplain{}{\\bfseries\\small support-cluster\@mysql.com\\hfill \\copyright~Copyright 2003-2004 MySQL AB}}\n"; + } else { + print OUTFILE; + } +} + +close INFILE; +close OUTFILE; + +system("mv ${destdir}/doxygen.sty.new ${destdir}/doxygen.sty"); + diff --git a/ndb/docs/doxygen/predoxy.pl b/ndb/docs/doxygen/predoxy.pl new file mode 100755 index 00000000000..461ad02478a --- /dev/null +++ b/ndb/docs/doxygen/predoxy.pl @@ -0,0 +1,34 @@ +#!/usr/local/bin/perl +# +# Written by Lars Thalmann, lars@mysql.com, 2003. +# + +use strict; +umask 000; + +# ----------------------------------------------------------------------------- +# Fix HTML Footer +# ----------------------------------------------------------------------------- + +open (OUTFILE, "> footer.html"); + +print OUTFILE< +
+ +
+EOT +print OUTFILE "Documentation generated " . localtime() . + " from NDB Cluster source files."; +print OUTFILE< +© 2003-2004 +MySQL AB +
+
+
+ + +EOT + +print "Preformat finished\n\n"; diff --git a/ndb/env.sh b/ndb/env.sh new file mode 100644 index 00000000000..c84a61b2c6f --- /dev/null +++ b/ndb/env.sh @@ -0,0 +1,8 @@ +# + +NDB_TOP=`pwd` +export NDB_TOP + +NDB_PROJ_HOME=$NDB_TOP/home +export NDB_PROJ_HOME + diff --git a/ndb/examples/Makefile b/ndb/examples/Makefile new file mode 100644 index 00000000000..e1fb71a1817 --- /dev/null +++ b/ndb/examples/Makefile @@ -0,0 +1,26 @@ +-include .defs.mk + +#ifneq ($(C++),) +#OPTS = CC=$(CC) CXX=$(C++) +#endif + +# XXX ndbapi_example4 commented out until fixed +BIN_DIRS := ndbapi_example1 ndbapi_example2 ndbapi_example3 $(ndbapi_example4) \ + ndbapi_example5 select_all + +bins: $(patsubst %, _bins_%, $(BIN_DIRS)) + +$(patsubst %, _bins_%, $(BIN_DIRS)) : + $(MAKE) -C $(patsubst _bins_%, %, $@) $(OPTS) + +libs: + +clean: + for f in ${BIN_DIRS}; do \ + $(MAKE) -C $$f $@;\ + done + +cleanall: clean +tidy: clean +distclean: clean + diff --git a/ndb/examples/configurations/demos.tar b/ndb/examples/configurations/demos.tar new file mode 100644 index 00000000000..d8cae90ec5b Binary files /dev/null and b/ndb/examples/configurations/demos.tar differ diff --git a/ndb/examples/ndbapi_async_example/Makefile b/ndb/examples/ndbapi_async_example/Makefile new file mode 100644 index 00000000000..7910a4a1d12 --- /dev/null +++ b/ndb/examples/ndbapi_async_example/Makefile @@ -0,0 +1,34 @@ +-include ../../Defs.mk +#NDB_OS = OS_YOU_ARE_RUNNING_ON +#NDB_OS = LINUX +#You need to set the NDB_OS variable here (LINUX, SOLARIS, MACOSX) +TARGET = ndbapi_async +SRCS = ndbapi_async.cpp +OBJS = ndbapi_async.o +CC = g++ +CFLAGS = -c -Wall -fno-rtti -D$(NDB_OS) +DEBUG = +LFLAGS = -Wall +INCLUDE_DIR = ../../include +LIB_DIR = ../../lib +ifeq ($(NDB_OS), SOLARIS) +# Here is the definition of system libraries necessary for Solaris 7 +SYS_LIB = -lpthread -lsocket -lnsl -lrt +endif +ifeq ($(NDB_OS), LINUX) +# Here is the definition of system libraries necessary for Linux 2.4 +SYS_LIB = -lpthread +endif +ifeq ($(NDB_OS), MACOSX) +# Here is the definition of system libraries necessary for Mac OS X +SYS_LIB = +endif + +$(TARGET): $(OBJS) + $(CC) $(LFLAGS) -L$(LIB_DIR) -lNDB_API $(OBJS) $(SYS_LIB) -o $(TARGET) + +$(TARGET).o: $(SRCS) + $(CC) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS) + +clean: + rm -f *.o $(TARGET) diff --git a/ndb/examples/ndbapi_async_example/ndbapi_async.cpp b/ndb/examples/ndbapi_async_example/ndbapi_async.cpp new file mode 100644 index 00000000000..078ac0c5cbf --- /dev/null +++ b/ndb/examples/ndbapi_async_example/ndbapi_async.cpp @@ -0,0 +1,505 @@ + + +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +/** + * ndbapi_async.cpp: + * Illustrates how to use callbacks and error handling using the asynchronous + * part of the NDBAPI. + * + * Classes and methods in NDBAPI used in this example: + * + * Ndb + * init() + * waitUntilRead() + * getDictionary() + * startTransaction() + * closeTransaction() + * sendPollNdb() + * getNdbError() + * + * NdbConnection + * getNdbOperation() + * executeAsynchPrepare() + * getNdbError() + * + * NdbDictionary::Dictionary + * getTable() + * dropTable() + * createTable() + * getNdbError() + * + * NdbDictionary::Column + * setName() + * setPrimaryKey() + * setType() + * setLength() + * setNullable() + * + * NdbDictionary::Table + * setName() + * addColumn() + * + * NdbOperation + * insertTuple() + * equal() + * setValue() + * + */ + + +#include +#include +#include // Used for cout + +#ifdef SOLARIS +#include +#include +#endif + +#if defined LINUX || defined MACOSX +#include +#include +#endif + +/** + * Helper sleep function + */ +int +milliSleep(int milliseconds){ + int result = 0; + struct timespec sleeptime; + sleeptime.tv_sec = milliseconds / 1000; + sleeptime.tv_nsec = (milliseconds - (sleeptime.tv_sec * 1000)) * 1000000; + result = nanosleep(&sleeptime, NULL); + return result; +} + +/** + * error printout macro + */ +#define APIERROR(error) \ + { std::cout << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" \ + << error.code << ", msg: " << error.message << "." << std::endl; \ + exit(-1); } + + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL +/** + * callback struct. + * transaction : index of the transaction in transaction[] array below + * data : the data that the transaction was modifying. + * retries : counter for how many times the trans. has been retried + */ +typedef struct { + Ndb * ndb; + int transaction; + int data; + int retries; +} async_callback_t; + +/** + * Structure used in "free list" to a NdbConnection + */ +typedef struct { + NdbConnection* conn; + int used; +} transaction_t; + +/** + * Free list holding transactions + */ +transaction_t transaction[1024]; //1024 - max number of outstanding + //transaction in one Ndb object + +#endif +/** + * prototypes + */ + +/** + * Prepare and send transaction + */ +int populate(Ndb * myNdb, int data, async_callback_t * cbData); + +/** + * Error handler. + */ +bool asynchErrorHandler(NdbConnection * trans, Ndb* ndb); + +/** + * Exit function + */ +void asynchExitHandler(Ndb * m_ndb) ; + +/** + * Helper function used in callback(...) + */ +void closeTransaction(Ndb * ndb , async_callback_t * cb); + +/** + * Function to create table + */ +int create_table(Ndb * myNdb); + +/** + * stat. variables + */ +int tempErrors = 0; +int permErrors = 0; + +/** + * Helper function for callback(...) + */ +void +closeTransaction(Ndb * ndb , async_callback_t * cb) +{ + ndb->closeTransaction(transaction[cb->transaction].conn); + transaction[cb->transaction].conn = 0; + transaction[cb->transaction].used = 0; + cb->retries++; +} + +/** + * Callback executed when transaction has return from NDB + */ +static void +callback(int result, NdbConnection* trans, void* aObject) +{ + async_callback_t * cbData = (async_callback_t *)aObject; + if (result<0) + { + /** + * Error: Temporary or permanent? + */ + if (asynchErrorHandler(trans, (Ndb*)cbData->ndb)) + { + closeTransaction((Ndb*)cbData->ndb, cbData); + while(populate((Ndb*)cbData->ndb, cbData->data, cbData) < 0) + milliSleep(10); + } + else + { + std::cout << "Restore: Failed to restore data " + << "due to a unrecoverable error. Exiting..." << std::endl; + delete cbData; + asynchExitHandler((Ndb*)cbData->ndb); + } + } + else + { + /** + * OK! close transaction + */ + closeTransaction((Ndb*)cbData->ndb, cbData); + delete cbData; + } +} + + +/** + * Create table "GARAGE" + */ +int create_table(Ndb * myNdb) +{ + NdbDictionary::Table myTable; + NdbDictionary::Column myColumn; + + NdbDictionary::Dictionary* myDict = myNdb->getDictionary(); + + /********************************************************* + * Create a table named GARAGE if it does not exist * + *********************************************************/ + if (myDict->getTable("GARAGE") != NULL) + { + std::cout << "NDB already has example table: GARAGE. " + << "Dropping it..." << std::endl; + if(myDict->dropTable("GARAGE") == -1) + { + std::cout << "Failed to drop: GARAGE." << std::endl; + exit(1); + } + } + + myTable.setName("GARAGE"); + +/** + * Column REG_NO + */ + myColumn.setName("REG_NO"); + myColumn.setPrimaryKey(true); + myColumn.setType(NdbDictionary::Column::Unsigned); + myColumn.setLength(1); + myColumn.setNullable(false); + myTable.addColumn(myColumn); + +/** + * Column BRAND + */ + myColumn.setName("BRAND"); + myColumn.setPrimaryKey(false); + myColumn.setType(NdbDictionary::Column::Char); + myColumn.setLength(20); + myColumn.setNullable(false); + myTable.addColumn(myColumn); + +/** + * Column COLOR + */ + myColumn.setName("COLOR"); + myColumn.setPrimaryKey(false); + myColumn.setType(NdbDictionary::Column::Char); + myColumn.setLength(20); + myColumn.setNullable(false); + myTable.addColumn(myColumn); + + if (myDict->createTable(myTable) == -1) { + APIERROR(myDict->getNdbError()); + } + return 1; +} + +void asynchExitHandler(Ndb * m_ndb) +{ + if (m_ndb != NULL) + delete m_ndb; + exit(-1); +} + +/* returns true if is recoverable (temporary), + * false if it is an error that is permanent. + */ +bool asynchErrorHandler(NdbConnection * trans, Ndb* ndb) +{ + NdbError error = trans->getNdbError(); + switch(error.status) + { + case NdbError::Success: + return false; + break; + + case NdbError::TemporaryError: + /** + * The error code indicates a temporary error. + * The application should typically retry. + * (Includes classifications: NdbError::InsufficientSpace, + * NdbError::TemporaryResourceError, NdbError::NodeRecoveryError, + * NdbError::OverloadError, NdbError::NodeShutdown + * and NdbError::TimeoutExpired.) + * + * We should sleep for a while and retry, except for insufficient space + */ + if(error.classification == NdbError::InsufficientSpace) + return false; + milliSleep(10); + tempErrors++; + return true; + break; + case NdbError::UnknownResult: + std::cout << error.message << std::endl; + return false; + break; + default: + case NdbError::PermanentError: + switch (error.code) + { + case 499: + case 250: + milliSleep(10); + return true; // SCAN errors that can be retried. Requires restart of scan. + default: + break; + } + //ERROR + std::cout << error.message << std::endl; + return false; + break; + } + return false; +} + +static int nPreparedTransactions = 0; +static int MAX_RETRIES = 10; +static int parallelism = 100; + + +/************************************************************************ + * populate() + * 1. Prepare 'parallelism' number of insert transactions. + * 2. Send transactions to NDB and wait for callbacks to execute + */ +int populate(Ndb * myNdb, int data, async_callback_t * cbData) +{ + + NdbOperation* myNdbOperation; // For operations + + async_callback_t * cb; + int retries; + int current = 0; + for(int i=0; i<1024; i++) + { + if(transaction[i].used == 0) + { + current = i; + if (cbData == 0) + { + /** + * We already have a callback + * This is an absolutely new transaction + */ + cb = new async_callback_t; + cb->retries = 0; + } + else + { + /** + * We already have a callback + */ + cb =cbData; + retries = cbData->retries; + } + /** + * Set data used by the callback + */ + cb->ndb = myNdb; //handle to Ndb object so that we can close transaction + // in the callback (alt. make myNdb global). + + cb->data = data; //this is the data we want to insert + cb->transaction = current; //This is the number (id) of this transaction + transaction[current].used = 1 ; //Mark the transaction as used + break; + } + } + if(!current) + return -1; + + while(retries < MAX_RETRIES) + { + transaction[current].conn = myNdb->startTransaction(); + if (transaction[current].conn == NULL) { + if (asynchErrorHandler(transaction[current].conn, myNdb)) + { + /** + * no transaction to close since conn == null + */ + milliSleep(10); + retries++; + continue; + } + asynchExitHandler(myNdb); + } + // Error check. If error, then maybe table GARAGE is not in database + myNdbOperation = transaction[current].conn->getNdbOperation("GARAGE"); + if (myNdbOperation == NULL) + { + if (asynchErrorHandler(transaction[current].conn, myNdb)) + { + myNdb->closeTransaction(transaction[current].conn); + transaction[current].conn = 0; + milliSleep(10); + retries++; + continue; + } + asynchExitHandler(myNdb); + } // if + if(myNdbOperation->insertTuple() < 0 || + myNdbOperation->equal("REG_NO", data) < 0 || + myNdbOperation->setValue("BRAND", "Mercedes") <0 || + myNdbOperation->setValue("COLOR", "Blue") < 0) + { + if (asynchErrorHandler(transaction[current].conn, myNdb)) + { + myNdb->closeTransaction(transaction[current].conn); + transaction[current].conn = 0; + retries++; + milliSleep(10); + continue; + } + asynchExitHandler(myNdb); + } + + /*Prepare transaction (the transaction is NOT yet sent to NDB)*/ + transaction[current].conn->executeAsynchPrepare(Commit, + &callback, + cb); + /** + * When we have prepared parallelism number of transactions -> + * send the transaction to ndb. + * Next time we will deal with the transactions are in the + * callback. There we will see which ones that were successful + * and which ones to retry. + */ + if (nPreparedTransactions == parallelism-1) + { + // send-poll all transactions + // close transaction is done in callback + myNdb->sendPollNdb(3000, parallelism ); + nPreparedTransactions=0; + } + else + nPreparedTransactions++; + return 1; + } + std::cout << "Unable to recover from errors. Exiting..." << std::endl; + asynchExitHandler(myNdb); + return -1; +} + +int main() +{ + Ndb* myNdb = new Ndb( "TEST_DB" ); // Object representing the database + + /******************************************* + * Initialize NDB and wait until its ready * + *******************************************/ + if (myNdb->init(1024) == -1) { // Set max 1024 parallel transactions + APIERROR(myNdb->getNdbError()); + } + + if (myNdb->waitUntilReady(30) != 0) { + std::cout << "NDB was not ready within 30 secs." << std::endl; + exit(-1); + } + create_table(myNdb); + + + /** + * Initialise transaction array + */ + for(int i = 0 ; i < 1024 ; i++) + { + transaction[i].used = 0; + transaction[i].conn = 0; + + } + int i=0; + /** + * Do 20000 insert transactions. + */ + while(i < 20000) + { + while(populate(myNdb,i,0)<0) // <0, no space on free list. Sleep and try again. + milliSleep(10); + + i++; + } + std::cout << "Number of temporary errors: " << tempErrors << std::endl; + delete myNdb; +} + + diff --git a/ndb/examples/ndbapi_async_example/readme.txt b/ndb/examples/ndbapi_async_example/readme.txt new file mode 100644 index 00000000000..47cb4bf9ffa --- /dev/null +++ b/ndb/examples/ndbapi_async_example/readme.txt @@ -0,0 +1,3 @@ +1. Set NDB_OS in Makefile +2. Add path to libNDB_API.so in LD_LIBRARY_PATH +3. Set NDB_CONNECTSTRING diff --git a/ndb/examples/ndbapi_example1/Makefile b/ndb/examples/ndbapi_example1/Makefile new file mode 100644 index 00000000000..eb0142ce673 --- /dev/null +++ b/ndb/examples/ndbapi_example1/Makefile @@ -0,0 +1,33 @@ +-include .defs.mk +#NDB_OS = OS_YOU_ARE_RUNNING_ON +#You need to set the NDB_OS variable here +TARGET = ndbapi_example1 +SRCS = ndbapi_example1.cpp +OBJS = ndbapi_example1.o +CXX = g++ +CFLAGS = -c -Wall -fno-rtti -fno-exceptions +DEBUG = +LFLAGS = -Wall +INCLUDE_DIR = ../../include +LIB_DIR = ../../lib +ifeq ($(NDB_OS), SOLARIS) +# Here is the definition of system libraries necessary for Solaris 7 +SYS_LIB = +endif +ifeq ($(NDB_OS), LINUX) +# Here is the definition of system libraries necessary for Linux 2.4 +SYS_LIB = +endif +ifeq ($(NDB_OS), MACOSX) +# Here is the definition of system libraries necessary for Mac OS X +SYS_LIB = +endif + +$(TARGET): $(OBJS) + $(CXX) $(LFLAGS) -L$(LIB_DIR) $(OBJS) -lNDB_API $(SYS_LIB) -o $(TARGET) + +$(TARGET).o: $(SRCS) + $(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS) + +clean: + rm -f *.o $(TARGET) diff --git a/ndb/examples/ndbapi_example1/ndbapi_example1.cpp b/ndb/examples/ndbapi_example1/ndbapi_example1.cpp new file mode 100644 index 00000000000..879d86de824 --- /dev/null +++ b/ndb/examples/ndbapi_example1/ndbapi_example1.cpp @@ -0,0 +1,193 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +// +// ndbapi_example1.cpp: Using synchronous transactions in NDB API +// +// Correct output from this program is: +// +// ATTR1 ATTR2 +// 0 10 +// 1 1 +// 2 12 +// Detected that deleted tuple doesn't exist! +// 4 14 +// 5 5 +// 6 16 +// 7 7 +// 8 18 +// 9 9 + +#include + +// Used for cout +#include +#include + +#define APIERROR(error) \ + { std::cout << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" \ + << error.code << ", msg: " << error.message << "." << std::endl; \ + exit(-1); } + +int main() +{ + Ndb* myNdb = new Ndb( "TEST_DB_1" ); // Object representing the database + NdbDictionary::Table myTable; + NdbDictionary::Column myColumn; + + NdbConnection *myConnection; // For other transactions + NdbOperation *myOperation; // For other operations + NdbRecAttr *myRecAttr; // Result of reading attribute value + + /******************************************** + * Initialize NDB and wait until it's ready * + ********************************************/ + if (myNdb->init() == -1) { + APIERROR(myNdb->getNdbError()); + exit(-1); + } + + if (myNdb->waitUntilReady(30) != 0) { + std::cout << "NDB was not ready within 30 secs." << std::endl; + exit(-1); + } + + NdbDictionary::Dictionary* myDict = myNdb->getDictionary(); + + /********************************************************* + * Create a table named MYTABLENAME if it does not exist * + *********************************************************/ + if (myDict->getTable("MYTABLENAME") != NULL) { + std::cout << "NDB already has example table: MYTABLENAME." << std::endl; + exit(-1); + } + + myTable.setName("MYTABLENAME"); + + myColumn.setName("ATTR1"); + myColumn.setPrimaryKey(true); + myColumn.setType(NdbDictionary::Column::Unsigned); + myColumn.setLength(1); + myColumn.setNullable(false); + myTable.addColumn(myColumn); + + myColumn.setName("ATTR2"); + myColumn.setPrimaryKey(false); + myColumn.setType(NdbDictionary::Column::Unsigned); + myColumn.setLength(1); + myColumn.setNullable(false); + myTable.addColumn(myColumn); + + if (myDict->createTable(myTable) == -1) + APIERROR(myDict->getNdbError()); + + /************************************************************************** + * Using 5 transactions, insert 10 tuples in table: (0,0),(1,1),...,(9,9) * + **************************************************************************/ + for (int i = 0; i < 5; i++) { + myConnection = myNdb->startTransaction(); + if (myConnection == NULL) APIERROR(myNdb->getNdbError()); + + myOperation = myConnection->getNdbOperation("MYTABLENAME"); + if (myOperation == NULL) APIERROR(myConnection->getNdbError()); + + myOperation->insertTuple(); + myOperation->equal("ATTR1", i); + myOperation->setValue("ATTR2", i); + + myOperation = myConnection->getNdbOperation("MYTABLENAME"); + if (myOperation == NULL) APIERROR(myConnection->getNdbError()); + + myOperation->insertTuple(); + myOperation->equal("ATTR1", i+5); + myOperation->setValue("ATTR2", i+5); + + if (myConnection->execute( Commit ) == -1) + APIERROR(myConnection->getNdbError()); + + myNdb->closeTransaction(myConnection); + } + + /***************************************************************** + * Update the second attribute in half of the tuples (adding 10) * + *****************************************************************/ + for (int i = 0; i < 10; i+=2) { + myConnection = myNdb->startTransaction(); + if (myConnection == NULL) APIERROR(myNdb->getNdbError()); + + myOperation = myConnection->getNdbOperation("MYTABLENAME"); + if (myOperation == NULL) APIERROR(myConnection->getNdbError()); + + myOperation->updateTuple(); + myOperation->equal( "ATTR1", i ); + myOperation->setValue( "ATTR2", i+10); + + if( myConnection->execute( Commit ) == -1 ) + APIERROR(myConnection->getNdbError()); + + myNdb->closeTransaction(myConnection); + } + + /************************************************* + * Delete one tuple (the one with primary key 3) * + *************************************************/ + myConnection = myNdb->startTransaction(); + if (myConnection == NULL) APIERROR(myNdb->getNdbError()); + + myOperation = myConnection->getNdbOperation("MYTABLENAME"); + if (myOperation == NULL) + APIERROR(myConnection->getNdbError()); + + myOperation->deleteTuple(); + myOperation->equal( "ATTR1", 3 ); + + if (myConnection->execute(Commit) == -1) + APIERROR(myConnection->getNdbError()); + + myNdb->closeTransaction(myConnection); + + /***************************** + * Read and print all tuples * + *****************************/ + std::cout << "ATTR1 ATTR2" << std::endl; + + for (int i = 0; i < 10; i++) { + myConnection = myNdb->startTransaction(); + if (myConnection == NULL) APIERROR(myNdb->getNdbError()); + + myOperation = myConnection->getNdbOperation("MYTABLENAME"); + if (myOperation == NULL) APIERROR(myConnection->getNdbError()); + + myOperation->readTuple(); + myOperation->equal("ATTR1", i); + + myRecAttr = myOperation->getValue("ATTR2", NULL); + if (myRecAttr == NULL) APIERROR(myConnection->getNdbError()); + + if(myConnection->execute( Commit ) == -1) + if (i == 3) { + std::cout << "Detected that deleted tuple doesn't exist!" << std::endl; + } else { + APIERROR(myConnection->getNdbError()); + } + + if (i != 3) { + printf(" %2d %2d\n", i, myRecAttr->u_32_value()); + } + myNdb->closeTransaction(myConnection); + } + delete myNdb; +} diff --git a/ndb/examples/ndbapi_example2/Makefile b/ndb/examples/ndbapi_example2/Makefile new file mode 100644 index 00000000000..17b2b1528fc --- /dev/null +++ b/ndb/examples/ndbapi_example2/Makefile @@ -0,0 +1,33 @@ +-include .defs.mk +#NDB_OS = OS_YOU_ARE_RUNNING_ON +#You need to set the NDB_OS variable here +TARGET = ndbapi_example2 +SRCS = ndbapi_example2.cpp +OBJS = ndbapi_example2.o +CXX = g++ +CFLAGS = -c -Wall -fno-rtti -fno-exceptions +DEBUG = +LFLAGS = -Wall +INCLUDE_DIR = ../../include +LIB_DIR = ../../lib +ifeq ($(NDB_OS), SOLARIS) +# Here is the definition of system libraries necessary for Solaris 7 +SYS_LIB = +endif +ifeq ($(NDB_OS), LINUX) +# Here is the definition of system libraries necessary for Linux 2.4 +SYS_LIB = +endif +ifeq ($(NDB_OS), MACOSX) +# Here is the definition of system libraries necessary for Mac OS X +SYS_LIB = +endif + +$(TARGET): $(OBJS) + $(CXX) $(LFLAGS) -L$(LIB_DIR) $(OBJS) -lNDB_API $(SYS_LIB) -o $(TARGET) + +$(TARGET).o: $(SRCS) + $(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS) + +clean: + rm -f *.o $(TARGET) diff --git a/ndb/examples/ndbapi_example2/ndbapi_example2.cpp b/ndb/examples/ndbapi_example2/ndbapi_example2.cpp new file mode 100644 index 00000000000..1c61721c037 --- /dev/null +++ b/ndb/examples/ndbapi_example2/ndbapi_example2.cpp @@ -0,0 +1,110 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +// +// ndbapi_example2.cpp: Using asynchronous transactions in NDB API +// +// Execute ndbapi_example1 to create the table "MYTABLENAME" +// before executing this program. +// +// Correct output from this program is: +// +// Successful insert. +// Successful insert. + +#include + +// Used for cout +#include + +#define APIERROR(error) \ + { std::cout << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" \ + << error.code << ", msg: " << error.message << "." << std::endl; \ + exit(-1); } + +static void callback(int result, NdbConnection* NdbObject, void* aObject); + +int main() +{ + Ndb* myNdb = new Ndb( "TEST_DB_2" ); // Object representing the database + + NdbConnection* myNdbConnection[2]; // For transactions + NdbOperation* myNdbOperation; // For operations + + /******************************************* + * Initialize NDB and wait until its ready * + *******************************************/ + if (myNdb->init(2) == -1) { // Want two parallel insert transactions + APIERROR(myNdb->getNdbError()); + exit(-1); + } + + if (myNdb->waitUntilReady(30) != 0) { + std::cout << "NDB was not ready within 30 secs." << std::endl; + exit(-1); + } + + /****************************************************** + * Insert (we do two insert transactions in parallel) * + ******************************************************/ + for (int i = 0; i < 2; i++) { + myNdbConnection[i] = myNdb->startTransaction(); + if (myNdbConnection[i] == NULL) APIERROR(myNdb->getNdbError()); + + myNdbOperation = myNdbConnection[i]->getNdbOperation("MYTABLENAME"); + // Error check. If error, then maybe table MYTABLENAME is not in database + if (myNdbOperation == NULL) APIERROR(myNdbConnection[i]->getNdbError()); + + myNdbOperation->insertTuple(); + myNdbOperation->equal("ATTR1", 20 + i); + myNdbOperation->setValue("ATTR2", 20 + i); + + // Prepare transaction (the transaction is NOT yet sent to NDB) + myNdbConnection[i]->executeAsynchPrepare(Commit, &callback, NULL); + } + + // Send all transactions to NDB + myNdb->sendPreparedTransactions(0); + + // Poll all transactions + myNdb->pollNdb(3000, 2); + + // Close all transactions + for (int i = 0; i < 2; i++) + myNdb->closeTransaction(myNdbConnection[i]); + + delete myNdb; +} + +/* + * callback : This is called when the transaction is polled + * + * (This function must have three arguments: + * - The result of the transaction, + * - The NdbConnection object, and + * - A pointer to an arbitrary object.) + */ + +static void +callback(int result, NdbConnection* myTrans, void* aObject) +{ + if (result == -1) { + std::cout << "Poll error: " << std::endl; + APIERROR(myTrans->getNdbError()); + } else { + std::cout << "Successful insert." << std::endl; + } +} diff --git a/ndb/examples/ndbapi_example3/Makefile b/ndb/examples/ndbapi_example3/Makefile new file mode 100644 index 00000000000..bd6f0182aa4 --- /dev/null +++ b/ndb/examples/ndbapi_example3/Makefile @@ -0,0 +1,33 @@ +-include .defs.mk +#NDB_OS = OS_YOU_ARE_RUNNING_ON +#You need to set the NDB_OS variable here +TARGET = ndbapi_example3 +SRCS = ndbapi_example3.cpp +OBJS = ndbapi_example3.o +CXX = g++ +CFLAGS = -c -Wall -fno-rtti -fno-exceptions +DEBUG = +LFLAGS = -Wall +INCLUDE_DIR = ../../include +LIB_DIR = ../../lib +ifeq ($(NDB_OS), SOLARIS) +# Here is the definition of system libraries necessary for Solaris 7 +SYS_LIB = +endif +ifeq ($(NDB_OS), LINUX) +# Here is the definition of system libraries necessary for Linux 2.4 +SYS_LIB = +endif +ifeq ($(NDB_OS), MACOSX) +# Here is the definition of system libraries necessary for Mac OS X +SYS_LIB = +endif + +$(TARGET): $(OBJS) + $(CXX) $(LFLAGS) -L$(LIB_DIR) $(OBJS) -lNDB_API $(SYS_LIB) -o $(TARGET) + +$(TARGET).o: $(SRCS) + $(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS) + +clean: + rm -f *.o $(TARGET) diff --git a/ndb/examples/ndbapi_example3/ndbapi_example3.cpp b/ndb/examples/ndbapi_example3/ndbapi_example3.cpp new file mode 100644 index 00000000000..36d2cf1608c --- /dev/null +++ b/ndb/examples/ndbapi_example3/ndbapi_example3.cpp @@ -0,0 +1,202 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +// +// ndbapi_example3.cpp: Error handling and transaction retries +// +// Execute ndbapi_example1 to create the table "MYTABLENAME" +// before executing this program. +// +// There are many ways to program using the NDB API. In this example +// we execute two inserts in the same transaction using +// NdbConnection::Ndbexecute(NoCommit). +// +// Transaction failing is handled by re-executing the transaction +// in case of non-permanent transaction errors. +// Application errors (i.e. errors at points marked with APIERROR) +// should be handled by the application programmer. + +#include + +// Used for cout +#include + +// Used for sleep (use your own version of sleep) +#include +#define TIME_TO_SLEEP_BETWEEN_TRANSACTION_RETRIES 1 + +// +// APIERROR prints an NdbError object +// +#define APIERROR(error) \ + { std::cout << "API ERROR: " << error.code << " " << error.message \ + << std::endl \ + << " " << "Status: " << error.status \ + << ", Classification: " << error.classification << std::endl\ + << " " << "File: " << __FILE__ \ + << " (Line: " << __LINE__ << ")" << std::endl \ + ; \ + } + +// +// CONERROR prints all error info regarding an NdbConnection +// +#define CONERROR(ndbConnection) \ + { NdbError error = ndbConnection->getNdbError(); \ + std::cout << "CON ERROR: " << error.code << " " << error.message \ + << std::endl \ + << " " << "Status: " << error.status \ + << ", Classification: " << error.classification << std::endl \ + << " " << "File: " << __FILE__ \ + << " (Line: " << __LINE__ << ")" << std::endl \ + ; \ + printTransactionError(ndbConnection); \ + } + +void printTransactionError(NdbConnection *ndbConnection) { + const NdbOperation *ndbOp = NULL; + int i=0; + + /**************************************************************** + * Print NdbError object of every operations in the transaction * + ****************************************************************/ + while ((ndbOp = ndbConnection->getNextCompletedOperation(ndbOp)) != NULL) { + NdbError error = ndbOp->getNdbError(); + std::cout << " OPERATION " << i+1 << ": " + << error.code << " " << error.message << std::endl + << " Status: " << error.status + << ", Classification: " << error.classification << std::endl; + i++; + } +} + + +// +// Example insert +// @param myNdb Ndb object representing NDB Cluster +// @param myConnection NdbConnection used for transaction +// @param error NdbError object returned in case of errors +// @return -1 in case of failures, 0 otherwise +// +int insert(int transactionId, NdbConnection* myConnection) { + NdbOperation *myOperation; // For other operations + + myOperation = myConnection->getNdbOperation("MYTABLENAME"); + if (myOperation == NULL) return -1; + + if (myOperation->insertTuple() || + myOperation->equal("ATTR1", transactionId) || + myOperation->setValue("ATTR2", transactionId)) { + APIERROR(myOperation->getNdbError()); + exit(-1); + } + + return myConnection->execute(NoCommit); +} + + +// +// Execute function which re-executes (tries 10 times) the transaction +// if there are temporary errors (e.g. the NDB Cluster is overloaded). +// @return -1 failure, 1 success +// +int executeInsertTransaction(int transactionId, Ndb* myNdb) { + int result = 0; // No result yet + int noOfRetriesLeft = 10; + NdbConnection *myConnection; // For other transactions + NdbError ndberror; + + while (noOfRetriesLeft > 0 && !result) { + + /********************************* + * Start and execute transaction * + *********************************/ + myConnection = myNdb->startTransaction(); + if (myConnection == NULL) { + APIERROR(myNdb->getNdbError()); + ndberror = myNdb->getNdbError(); + result = -1; // Failure + } else if (insert(transactionId, myConnection) || + insert(10000+transactionId, myConnection) || + myConnection->execute(Commit)) { + CONERROR(myConnection); + ndberror = myConnection->getNdbError(); + result = -1; // Failure + } else { + result = 1; // Success + } + + /********************************** + * If failure, then analyze error * + **********************************/ + if (result == -1) { + switch (ndberror.status) { + case NdbError::Success: + break; + case NdbError::TemporaryError: + std::cout << "Retrying transaction..." << std::endl; + sleep(TIME_TO_SLEEP_BETWEEN_TRANSACTION_RETRIES); + --noOfRetriesLeft; + result = 0; // No completed transaction yet + break; + + case NdbError::UnknownResult: + case NdbError::PermanentError: + std::cout << "No retry of transaction..." << std::endl; + result = -1; // Permanent failure + break; + } + } + + /********************* + * Close transaction * + *********************/ + if (myConnection != NULL) { + myNdb->closeTransaction(myConnection); + } + } + + if (result != 1) exit(-1); + return result; +} + + +int main() +{ + Ndb* myNdb = new Ndb( "TEST_DB_1" ); // Object representing the database + + /******************************************* + * Initialize NDB and wait until its ready * + *******************************************/ + if (myNdb->init() == -1) { + APIERROR(myNdb->getNdbError()); + exit(-1); + } + + if (myNdb->waitUntilReady(30) != 0) { + std::cout << "NDB was not ready within 30 secs." << std::endl; + exit(-1); + } + + /************************************ + * Execute some insert transactions * + ************************************/ + for (int i = 10000; i < 20000; i++) { + executeInsertTransaction(i, myNdb); + } + + delete myNdb; +} diff --git a/ndb/examples/ndbapi_example4/Makefile b/ndb/examples/ndbapi_example4/Makefile new file mode 100644 index 00000000000..b0ce852d347 --- /dev/null +++ b/ndb/examples/ndbapi_example4/Makefile @@ -0,0 +1,33 @@ +-include .defs.mk +#NDB_OS = OS_YOU_ARE_RUNNING_ON +#You need to set the NDB_OS variable here +TARGET = ndbapi_example4 +SRCS = ndbapi_example4.cpp +OBJS = ndbapi_example4.o +CXX = g++ +CFLAGS = -c -Wall -fno-rtti -fno-exceptions +DEBUG = +LFLAGS = -Wall +INCLUDE_DIR = ../../include +LIB_DIR = ../../lib +ifeq ($(NDB_OS), SOLARIS) +# Here is the definition of system libraries necessary for Solaris 7 +SYS_LIB = +endif +ifeq ($(NDB_OS), LINUX) +# Here is the definition of system libraries necessary for Linux 2.4 +SYS_LIB = +endif +ifeq ($(NDB_OS), MACOSX) +# Here is the definition of system libraries necessary for Mac OS X +SYS_LIB = +endif + +$(TARGET): $(OBJS) + $(CXX) $(LFLAGS) -L$(LIB_DIR) $(OBJS) -lNDB_API $(SYS_LIB) -o $(TARGET) + +$(TARGET).o: $(SRCS) + $(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS) + +clean: + rm -f *.o $(TARGET) diff --git a/ndb/examples/ndbapi_example4/ndbapi_example4.cpp b/ndb/examples/ndbapi_example4/ndbapi_example4.cpp new file mode 100644 index 00000000000..520172b9b0c --- /dev/null +++ b/ndb/examples/ndbapi_example4/ndbapi_example4.cpp @@ -0,0 +1,252 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +// +// ndbapi_example4.cpp: Using secondary indexes in NDB API +// +// Correct output from this program is: +// +// ATTR1 ATTR2 +// 0 10 +// 1 1 +// 2 12 +// Detected that deleted tuple doesn't exist! +// 4 14 +// 5 5 +// 6 16 +// 7 7 +// 8 18 +// 9 9 + +#include + +// Used for cout +#include +#include + +#define APIERROR(error) \ + { std::cout << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" \ + << error.code << ", msg: " << error.message << "." << std::endl; \ + exit(-1); } + +int main() +{ + Ndb* myNdb = new Ndb( "TEST_DB_1" ); // Object representing the database + NdbDictionary::Table myTable; + NdbDictionary::Column myColumn; + NdbDictionary::Index myIndex; + + NdbConnection *myConnection; // For transactions + NdbOperation *myOperation; // For primary key operations + NdbIndexOperation *myIndexOperation; // For index operations + NdbRecAttr *myRecAttr; // Result of reading attribute value + + /******************************************** + * Initialize NDB and wait until it's ready * + ********************************************/ + if (myNdb->init() == -1) { + APIERROR(myNdb->getNdbError()); + exit(-1); + } + + if (myNdb->waitUntilReady(30) != 0) { + std::cout << "NDB was not ready within 30 secs." << std::endl; + exit(-1); + } + + /********************************************************* + * Create a table named MYTABLENAME if it does not exist * + *********************************************************/ + NdbDictionary::Dictionary* myDict = myNdb->getDictionary(); + if (myDict->getTable("MYTABLENAME") != NULL) { + std::cout << "NDB already has example table: MYTABLENAME." << std::endl; + exit(-1); + } + + myTable.setName("MYTABLENAME"); + + myColumn.setName("ATTR1"); + myColumn.setPrimaryKey(true); + myColumn.setType(NdbDictionary::Column::Unsigned); + myColumn.setLength(1); + myColumn.setNullable(false); + myTable.addColumn(myColumn); + + myColumn.setName("ATTR2"); + myColumn.setPrimaryKey(false); + myColumn.setType(NdbDictionary::Column::Unsigned); + myColumn.setLength(1); + myColumn.setNullable(false); + myTable.addColumn(myColumn); + + if (myDict->createTable(myTable) == -1) + APIERROR(myDict->getNdbError()); + + + /********************************************************** + * Create an index named MYINDEXNAME if it does not exist * + **********************************************************/ + if (myDict->getIndex("MYINDEXNAME", "MYTABLENAME") != NULL) { + std::cout << "NDB already has example index: MYINDEXNAME." << std::endl; + exit(-1); + } + + myIndex.setName("MYINDEXNAME"); + myIndex.setTable("MYTABLENAME"); + myIndex.setType(NdbDictionary::Index::UniqueHashIndex); + const char* attr_arr[] = {"ATTR2"}; + myIndex.addIndexColumns(1, attr_arr); + + if (myDict->createIndex(myIndex) == -1) + APIERROR(myDict->getNdbError()); + + + /************************************************************************** + * Using 5 transactions, insert 10 tuples in table: (0,0),(1,1),...,(9,9) * + **************************************************************************/ + for (int i = 0; i < 5; i++) { + myConnection = myNdb->startTransaction(); + if (myConnection == NULL) APIERROR(myNdb->getNdbError()); + + myOperation = myConnection->getNdbOperation("MYTABLENAME"); + if (myOperation == NULL) APIERROR(myConnection->getNdbError()); + + myOperation->insertTuple(); + myOperation->equal("ATTR1", i); + myOperation->setValue("ATTR2", i); + + myOperation = myConnection->getNdbOperation("MYTABLENAME"); + if (myOperation == NULL) APIERROR(myConnection->getNdbError()); + + myOperation->insertTuple(); + myOperation->equal("ATTR1", i+5); + myOperation->setValue("ATTR2", i+5); + + if (myConnection->execute( Commit ) == -1) + APIERROR(myConnection->getNdbError()); + + myNdb->closeTransaction(myConnection); + } + + /***************************************** + * Read and print all tuples using index * + *****************************************/ + std::cout << "ATTR1 ATTR2" << std::endl; + + for (int i = 0; i < 10; i++) { + myConnection = myNdb->startTransaction(); + if (myConnection == NULL) APIERROR(myNdb->getNdbError()); + + myIndexOperation = myConnection->getNdbIndexOperation("MYINDEXNAME", + "MYTABLENAME"); + if (myIndexOperation == NULL) APIERROR(myConnection->getNdbError()); + + myIndexOperation->readTuple(); + myIndexOperation->equal("ATTR2", i); + + myRecAttr = myIndexOperation->getValue("ATTR1", NULL); + if (myRecAttr == NULL) APIERROR(myConnection->getNdbError()); + + if(myConnection->execute( Commit ) != -1) + printf(" %2d %2d\n", myRecAttr->u_32_value(), i); + } + myNdb->closeTransaction(myConnection); + + /***************************************************************** + * Update the second attribute in half of the tuples (adding 10) * + *****************************************************************/ + for (int i = 0; i < 10; i+=2) { + myConnection = myNdb->startTransaction(); + if (myConnection == NULL) APIERROR(myNdb->getNdbError()); + + myIndexOperation = myConnection->getNdbIndexOperation("MYINDEXNAME", + "MYTABLENAME"); + if (myIndexOperation == NULL) APIERROR(myConnection->getNdbError()); + + myIndexOperation->updateTuple(); + myIndexOperation->equal( "ATTR2", i ); + myIndexOperation->setValue( "ATTR2", i+10); + + if( myConnection->execute( Commit ) == -1 ) + APIERROR(myConnection->getNdbError()); + + myNdb->closeTransaction(myConnection); + } + + /************************************************* + * Delete one tuple (the one with primary key 3) * + *************************************************/ + myConnection = myNdb->startTransaction(); + if (myConnection == NULL) APIERROR(myNdb->getNdbError()); + + myIndexOperation = myConnection->getNdbIndexOperation("MYINDEXNAME", + "MYTABLENAME"); + if (myIndexOperation == NULL) + APIERROR(myConnection->getNdbError()); + + myIndexOperation->deleteTuple(); + myIndexOperation->equal( "ATTR2", 3 ); + + if (myConnection->execute(Commit) == -1) + APIERROR(myConnection->getNdbError()); + + myNdb->closeTransaction(myConnection); + + /***************************** + * Read and print all tuples * + *****************************/ + std::cout << "ATTR1 ATTR2" << std::endl; + + for (int i = 0; i < 10; i++) { + myConnection = myNdb->startTransaction(); + if (myConnection == NULL) APIERROR(myNdb->getNdbError()); + + myOperation = myConnection->getNdbOperation("MYTABLENAME"); + if (myOperation == NULL) APIERROR(myConnection->getNdbError()); + + myOperation->readTuple(); + myOperation->equal("ATTR1", i); + + myRecAttr = myOperation->getValue("ATTR2", NULL); + if (myRecAttr == NULL) APIERROR(myConnection->getNdbError()); + + if(myConnection->execute( Commit ) == -1) + if (i == 3) { + std::cout << "Detected that deleted tuple doesn't exist!" << std::endl; + } else { + APIERROR(myConnection->getNdbError()); + } + + if (i != 3) { + printf(" %2d %2d\n", i, myRecAttr->u_32_value()); + } + myNdb->closeTransaction(myConnection); + } + + /************** + * Drop index * + **************/ + if (myDict->dropIndex("MYINDEXNAME", "MYTABLENAME") == -1) + APIERROR(myDict->getNdbError()); + + /************** + * Drop table * + **************/ + if (myDict->dropTable("MYTABLENAME") == -1) + APIERROR(myDict->getNdbError()); + + delete myNdb; +} diff --git a/ndb/examples/ndbapi_example5/Makefile b/ndb/examples/ndbapi_example5/Makefile new file mode 100644 index 00000000000..e2e3f06374a --- /dev/null +++ b/ndb/examples/ndbapi_example5/Makefile @@ -0,0 +1,33 @@ +-include .defs.mk +#NDB_OS = OS_YOU_ARE_RUNNING_ON +#You need to set the NDB_OS variable here +TARGET = ndbapi_example5 +SRCS = ndbapi_example5.cpp +OBJS = ndbapi_example5.o +CXX = g++ +CFLAGS = -c -Wall -fno-rtti -fno-exceptions +DEBUG = +LFLAGS = -Wall +INCLUDE_DIR = ../../include +LIB_DIR = ../../lib +ifeq ($(NDB_OS), SOLARIS) +# Here is the definition of system libraries necessary for Solaris 7 +SYS_LIB = +endif +ifeq ($(NDB_OS), LINUX) +# Here is the definition of system libraries necessary for Linux 2.4 +SYS_LIB = +endif +ifeq ($(NDB_OS), MACOSX) +# Here is the definition of system libraries necessary for Mac OS X +SYS_LIB = +endif + +$(TARGET): $(OBJS) + $(CXX) $(LFLAGS) -L$(LIB_DIR) $(OBJS) -lNDB_API $(SYS_LIB) -o $(TARGET) + +$(TARGET).o: $(SRCS) + $(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS) + +clean: + rm -f *.o $(TARGET) diff --git a/ndb/examples/ndbapi_example5/ndbapi_example5.cpp b/ndb/examples/ndbapi_example5/ndbapi_example5.cpp new file mode 100644 index 00000000000..a9d3099883c --- /dev/null +++ b/ndb/examples/ndbapi_example5/ndbapi_example5.cpp @@ -0,0 +1,230 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/** + * ndbapi_example5.cpp: Using API level events in NDB API + */ + +#include +#include + +// Used for cout +#include +#include +#include + + +/** + * + * Assume that there is a table TAB0 which is being updated by + * another process (e.g. flexBench -l 0 -stdtables). + * We want to monitor what happens with columns COL0, COL2, COL11 + * + * or together with the mysqlcluster client; + * + * shell> mysqlcluster -u root + * mysql> create database TEST_DB; + * mysql> use TEST_DB; + * mysql> create table TAB0 (COL0 int primary key, COL1 int, COL11 int); + * + * In another window start ndbapi_example5, wait until properly started + * + * mysql> insert into TAB0 values (1,2,3); + * mysql> insert into TAB0 values (2,2,3); + * mysql> insert into TAB0 values (3,2,9); + * mysql> + * + * you should see the data popping up in the example window + * + */ + +#define APIERROR(error) \ + { std::cout << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" \ + << error.code << ", msg: " << error.message << "." << std::endl; \ + exit(-1); } + +Ndb* myCreateNdb(); +int myCreateEvent(Ndb* myNdb, + const char *eventName, + const char *eventTableName, + const char **eventComlumnName, + const int noEventComlumnName); + +int main() +{ + Ndb* myNdb = myCreateNdb(); + NdbDictionary::Dictionary *myDict; + + const char *eventName = "CHNG_IN_TAB0"; + const char *eventTableName = "TAB0"; + const int noEventColumnName = 3; + const char *eventColumnName[noEventColumnName] = + {"COL0", + "COL1", + "COL11"}; + + myDict = myNdb->getDictionary(); + + // Create events + myCreateEvent(myNdb, + eventName, + eventTableName, + eventColumnName, + noEventColumnName); + int j = 0; + while (j < 5) { + + // Start "transaction" for handling events + NdbEventOperation* op; + printf("create EventOperation\n"); + if ((op = myNdb->createEventOperation(eventName,100)) == NULL) { + printf("Event operation creation failed\n"); + exit(-1); + } + + printf("get values\n"); + NdbRecAttr* recAttr[noEventColumnName]; + NdbRecAttr* recAttrPre[noEventColumnName]; + // primary keys should always be a part of the result + for (int i = 0; i < noEventColumnName; i++) { + recAttr[i] = op->getValue(eventColumnName[i]); + recAttrPre[i] = op->getPreValue(eventColumnName[i]); + } + + // set up the callbacks + printf("execute\n"); + if (op->execute()) { // This starts changes to "start flowing" + printf("operationd execution failed\n"); + exit(-1); + } + + int i = 0; + + while(i < 40) { + //printf("now waiting for event...\n"); + int r = myNdb->pollEvents(1000); // wait for event or 1000 ms + if (r>0) { + //printf("got data! %d\n", r); + int overrun; + while (op->next(&overrun) > 0) { + i++; + if (!op->isConsistent()) + printf("A node failiure has occured and events might be missing\n"); + switch (op->getEventType()) { + case NdbDictionary::Event::TE_INSERT: + printf("%u INSERT: ", i); + break; + case NdbDictionary::Event::TE_DELETE: + printf("%u DELETE: ", i); + break; + case NdbDictionary::Event::TE_UPDATE: + printf("%u UPDATE: ", i); + break; + } + printf("overrun %u pk %u: ", overrun, recAttr[0]->u_32_value()); + for (int i = 1; i < noEventColumnName; i++) { + if (recAttr[i]->isNULL() >= 0) { // we have a value + printf(" post[%u]=", i); + if (recAttr[i]->isNULL() == 0) // we have a non-null value + printf("%u", recAttr[i]->u_32_value()); + else // we have a null value + printf("NULL"); + } + if (recAttrPre[i]->isNULL() >= 0) { // we have a value + printf(" post[%u]=", i); + if (recAttrPre[i]->isNULL() == 0) // we have a non-null value + printf("%u", recAttrPre[i]->u_32_value()); + else // we have a null value + printf("NULL"); + } + } + printf("\n"); + } + } else + ;//printf("timed out\n"); + } + // don't want to listen to eventsanymore + myNdb->dropEventOperation(op); + + j++; + } + + myDict->dropEvent(eventName); // remove event from database + + delete myNdb; +} + +Ndb* myCreateNdb() +{ + Ndb* myNdb = new Ndb("TEST_DB"); + + /******************************************** + * Initialize NDB and wait until it's ready * + ********************************************/ + if (myNdb->init() == -1) { + APIERROR(myNdb->getNdbError()); + exit(-1); + } + + if (myNdb->waitUntilReady(30) != 0) { + std::cout << "NDB was not ready within 30 secs." << std::endl; + exit(-1); + } + + return myNdb; +} + +int myCreateEvent(Ndb* myNdb, + const char *eventName, + const char *eventTableName, + const char **eventColumnName, + const int noEventColumnName) +{ + NdbDictionary::Dictionary *myDict = myNdb->getDictionary(); + + if (!myDict) { + printf("Event Creation failedDictionary not found"); + exit(-1); + } + + NdbDictionary::Event myEvent(eventName); + myEvent.setTable(eventTableName); + myEvent.addTableEvent(NdbDictionary::Event::TE_ALL); + // myEvent.addTableEvent(NdbDictionary::Event::TE_INSERT); + // myEvent.addTableEvent(NdbDictionary::Event::TE_UPDATE); + // myEvent.addTableEvent(NdbDictionary::Event::TE_DELETE); + + for (int i = 0; i < noEventColumnName; i++) + myEvent.addEventColumn(eventColumnName[i]); + + int res = myDict->createEvent(myEvent); // Add event to database + + if (res == 0) + myEvent.print(); + else { + printf("Event creation failed\n"); + printf("trying drop Event, maybe event exists\n"); + res = myDict->dropEvent(eventName); + if (res) + exit(-1); + // try again + res = myDict->createEvent(myEvent); // Add event to database + if (res) + exit(-1); + } + + return res; +} diff --git a/ndb/examples/ndbapi_scan_example/Makefile b/ndb/examples/ndbapi_scan_example/Makefile new file mode 100644 index 00000000000..6e53317f8bf --- /dev/null +++ b/ndb/examples/ndbapi_scan_example/Makefile @@ -0,0 +1,35 @@ +-include ../../Defs.mk +#NDB_OS = OS_YOU_ARE_RUNNING_ON +#You need to set the NDB_OS variable here (LINUX, SOLARIS, MACOSX) +#NDB_OS = LINUX + +TARGET = ndbapi_scan +SRCS = ndbapi_scan.cpp +OBJS = ndbapi_scan.o +CC = g++ +CFLAGS = -c -Wall -fno-rtti +DEBUG = +LFLAGS = -Wall +INCLUDE_DIR = ../../include +LIB_DIR = ../../lib +ifeq ($(NDB_OS), SOLARIS) +# Here is the definition of system libraries necessary for Solaris 7 +SYS_LIB = -lpthread -lsocket -lnsl -lrt +endif +ifeq ($(NDB_OS), LINUX) +# Here is the definition of system libraries necessary for Linux 2.4 +SYS_LIB = -lpthread +endif +ifeq ($(NDB_OS), MACOSX) +# Here is the definition of system libraries necessary for Mac OS X +SYS_LIB = +endif + +$(TARGET): $(OBJS) + $(CC) $(LFLAGS) -L$(LIB_DIR) -lNDB_API $(OBJS) $(SYS_LIB) -o $(TARGET) + +$(TARGET).o: $(SRCS) + $(CC) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS) + +clean: + rm -f *.o $(TARGET) diff --git a/ndb/examples/ndbapi_scan_example/ndbapi_scan.cpp b/ndb/examples/ndbapi_scan_example/ndbapi_scan.cpp new file mode 100644 index 00000000000..186afdb9471 --- /dev/null +++ b/ndb/examples/ndbapi_scan_example/ndbapi_scan.cpp @@ -0,0 +1,824 @@ + +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +/* + * ndbapi_scan.cpp: + * Illustrates how to use the scan api in the NDBAPI. + * The example shows how to do scan, scan for update and scan for delete + * using NdbScanFilter and NdbScanOperation + * + * Classes and methods used in this example: + * + * Ndb + * init() + * waitUntilRead() + * getDictionary() + * startTransaction() + * closeTransaction() + * sendPreparedTransactions() + * pollNdb() + * + * NdbConnection + * getNdbOperation() + * executeAsynchPrepare() + * getNdbError() + * executeScan() + * nextScanResult() + * + * NdbDictionary::Dictionary + * getTable() + * dropTable() + * createTable() + * + * NdbDictionary::Column + * setName() + * setPrimaryKey() + * setType() + * setLength() + * setNullable() + * + * NdbDictionary::Table + * setName() + * addColumn() + * + * NdbOperation + * insertTuple() + * equal() + * setValue() + * openScanRead() + * openScanExclusive() + * + * NdbRecAttr + * aRef() + * u_32_value() + * + * NdbResultSet + * nextResult() + * deleteTuple() + * updateTuple() + * + * NdbScanOperation + * getValue() + * readTuplesExclusive() + * + * NdbScanFilter + * begin() + * eq() + * end() + * + * + */ + + +#include +#include +// Used for cout +#include + +#ifdef SOLARIS +#include +#include +#endif + +#if defined LINUX || defined MACOSX +#include +#include +#endif + +/** + * Helper sleep function + */ +int +milliSleep(int milliseconds){ + int result = 0; + struct timespec sleeptime; + sleeptime.tv_sec = milliseconds / 1000; + sleeptime.tv_nsec = (milliseconds - (sleeptime.tv_sec * 1000)) * 1000000; + result = nanosleep(&sleeptime, NULL); + return result; +} + + +/** + * Helper sleep function + */ +#define APIERROR(error) \ + { std::cout << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" \ + << error.code << ", msg: " << error.message << "." << std::endl; \ + exit(-1); } + +/* + * callback : This is called when the transaction is polled + * + * (This function must have three arguments: + * - The result of the transaction, + * - The NdbConnection object, and + * - A pointer to an arbitrary object.) + */ +static void +callback(int result, NdbConnection* myTrans, void* aObject) +{ + if (result == -1) { + std::cout << "In callback: " << std::endl; + /** + * Put error checking code here (see ndb_async_example) + */ + APIERROR(myTrans->getNdbError()); + } else { + /** + * Ok! + */ + return; + } +} + +/** + * Function to create table + */ +int create_table(Ndb * myNdb) +{ + NdbDictionary::Table myTable; + NdbDictionary::Column myColumn; + + NdbDictionary::Dictionary* myDict = myNdb->getDictionary(); + + /********************************************************* + * Create a table named GARAGE if it does not exist * + *********************************************************/ + if (myDict->getTable("GARAGE") != NULL) { + std::cout << "NDB already has example table: GARAGE. " + << "Dropping it..." << std::endl; + if(myDict->dropTable("GARAGE") == -1) + { + std::cout << "Failed to drop: GARAGE." << std::endl; + exit(1); + } + } + + myTable.setName("GARAGE"); + + myColumn.setName("REG_NO"); + myColumn.setPrimaryKey(true); + myColumn.setType(NdbDictionary::Column::Unsigned); + myColumn.setLength(1); + myColumn.setNullable(false); + myTable.addColumn(myColumn); + + myColumn.setName("BRAND"); + myColumn.setPrimaryKey(false); + myColumn.setType(NdbDictionary::Column::Char); + myColumn.setLength(20); + myColumn.setNullable(false); + myTable.addColumn(myColumn); + + + myColumn.setName("COLOR"); + myColumn.setPrimaryKey(false); + myColumn.setType(NdbDictionary::Column::Char); + myColumn.setLength(20); + myColumn.setNullable(false); + myTable.addColumn(myColumn); + + if (myDict->createTable(myTable) == -1) { + APIERROR(myDict->getNdbError()); + return -1; + } + return 1; +} + + +int populate(Ndb * myNdb) +{ + NdbConnection* myNdbConnection[15]; // For transactions + NdbOperation* myNdbOperation; // For operations + /****************************************************** + * Insert (we do 15 insert transactions in parallel) * + ******************************************************/ + /** + * Five blue mercedes + */ + for (int i = 0; i < 5; i++) + { + myNdbConnection[i] = myNdb->startTransaction(); + if (myNdbConnection[i] == NULL) + APIERROR(myNdb->getNdbError()); + myNdbOperation = myNdbConnection[i]->getNdbOperation("GARAGE"); + // Error check. If error, then maybe table GARAGE is not in database + if (myNdbOperation == NULL) + APIERROR(myNdbConnection[i]->getNdbError()); + myNdbOperation->insertTuple(); + myNdbOperation->equal("REG_NO", i); + myNdbOperation->setValue("BRAND", "Mercedes"); + myNdbOperation->setValue("COLOR", "Blue"); + // Prepare transaction (the transaction is NOT yet sent to NDB) + myNdbConnection[i]->executeAsynchPrepare(Commit, &callback, NULL); + } + + + /** + * Five black bmw + */ + for (int i = 5; i < 10; i++) + { + myNdbConnection[i] = myNdb->startTransaction(); + if (myNdbConnection[i] == NULL) + APIERROR(myNdb->getNdbError()); + myNdbOperation = myNdbConnection[i]->getNdbOperation("GARAGE"); + // Error check. If error, then maybe table MYTABLENAME is not in database + if (myNdbOperation == NULL) + APIERROR(myNdbConnection[i]->getNdbError()); + myNdbOperation->insertTuple(); + myNdbOperation->equal("REG_NO", i); + myNdbOperation->setValue("BRAND", "BMW"); + myNdbOperation->setValue("COLOR", "Black"); + // Prepare transaction (the transaction is NOT yet sent to NDB) + myNdbConnection[i]->executeAsynchPrepare(Commit, &callback, NULL); + } + + /** + * Five pink toyotas + */ + for (int i = 10; i < 15; i++) { + myNdbConnection[i] = myNdb->startTransaction(); + if (myNdbConnection[i] == NULL) APIERROR(myNdb->getNdbError()); + myNdbOperation = myNdbConnection[i]->getNdbOperation("GARAGE"); + // Error check. If error, then maybe table MYTABLENAME is not in database + if (myNdbOperation == NULL) APIERROR(myNdbConnection[i]->getNdbError()); + myNdbOperation->insertTuple(); + myNdbOperation->equal("REG_NO", i); + myNdbOperation->setValue("BRAND", "Toyota"); + myNdbOperation->setValue("COLOR", "Pink"); + // Prepare transaction (the transaction is NOT yet sent to NDB) + myNdbConnection[i]->executeAsynchPrepare(Commit, &callback, NULL); + } + + // Send all transactions to NDB + myNdb->sendPreparedTransactions(0); + // Poll all transactions + myNdb->pollNdb(3000, 0); + + // it is also possible to use sendPollNdb instead of + // myNdb->sendPreparedTransactions(0); and myNdb->pollNdb(3000, 15); above. + // myNdb->sendPollNdb(3000,0); + // Note! Neither sendPollNdb or pollNdb returs until all 15 callbacks have + // executed. + + // Close all transactions. It is also possible to close transactions + // in the callback. + for (int i = 0; i < 15; i++) + myNdb->closeTransaction(myNdbConnection[i]); + return 1; +} + +int scan_delete(Ndb* myNdb, + int parallelism, + int column, + int column_len, + const char * color) + +{ + + // Scan all records exclusive and delete + // them one by one + int retryAttempt = 0; + const int retryMax = 10; + int deletedRows = 0; + int check; + NdbError err; + NdbConnection *myTrans; + NdbScanOperation *myScanOp; + + /** + * Loop as long as : + * retryMax not reached + * failed operations due to TEMPORARY erros + * + * Exit loop; + * retyrMax reached + * Permanent error (return -1) + */ + while (true) + { + if (retryAttempt >= retryMax) + { + std::cout << "ERROR: has retried this operation " << retryAttempt + << " times, failing!" << std::endl; + return -1; + } + + myTrans = myNdb->startTransaction(); + if (myTrans == NULL) + { + const NdbError err = myNdb->getNdbError(); + + if (err.status == NdbError::TemporaryError) + { + milliSleep(50); + retryAttempt++; + continue; + } + std::cout << err.message << std::endl; + return -1; + } + + /** + * Get a scan operation. + */ + myScanOp = myTrans->getNdbScanOperation("GARAGE"); + if (myScanOp == NULL) + { + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + return -1; + } + + /** + * Define a result set for the scan. + */ + NdbResultSet * rs = myScanOp->readTuplesExclusive(parallelism); + if( rs == 0 ) { + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + return -1; + } + + /** + * Use NdbScanFilter to define a search critera + */ + NdbScanFilter filter(myScanOp) ; + if(filter.begin(NdbScanFilter::AND) < 0 || + filter.eq(column, color, column_len, false) <0|| + filter.end() <0) + { + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + return -1; + } + + /** + * Start scan (NoCommit since we are only reading at this stage); + */ + if(myTrans->execute(NoCommit) != 0){ + err = myTrans->getNdbError(); + if(err.status == NdbError::TemporaryError){ + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + milliSleep(50); + continue; + } + std::cout << err.code << std::endl; + std::cout << myTrans->getNdbError().code << std::endl; + myNdb->closeTransaction(myTrans); + return -1; + } + + + /** + * start of loop: nextResult(true) means that "parallelism" number of + * rows are fetched from NDB and cached in NDBAPI + */ + while((check = rs->nextResult(true)) == 0){ + do { + if (rs->deleteTuple() != 0){ + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + return -1; + } + deletedRows++; + + /** + * nextResult(false) means that the records + * cached in the NDBAPI are modified before + * fetching more rows from NDB. + */ + } while((check = rs->nextResult(false)) == 0); + + /** + * Commit when all cached tuple have been marked for deletion + */ + if(check != -1){ + check = myTrans->execute(Commit); + myTrans->releaseCompletedOperations(); + } + /** + * Check for errors + */ + err = myTrans->getNdbError(); + if(check == -1){ + if(err.status == NdbError::TemporaryError){ + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + milliSleep(50); + continue; + } + } + /** + * End of loop + */ + } + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + return 0; + + + } + if(myTrans!=0) { + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + } + return -1; +} + + +int scan_update(Ndb* myNdb, + int parallelism, + int column_len, + int update_column, + const char * column_name, + const char * before_color, + const char * after_color) + +{ + + // Scan all records exclusive and update + // them one by one + int retryAttempt = 0; + const int retryMax = 10; + int updatedRows = 0; + int check; + NdbError err; + NdbConnection *myTrans; + NdbScanOperation *myScanOp; + + /** + * Loop as long as : + * retryMax not reached + * failed operations due to TEMPORARY erros + * + * Exit loop; + * retyrMax reached + * Permanent error (return -1) + */ + while (true) + { + + if (retryAttempt >= retryMax) + { + std::cout << "ERROR: has retried this operation " << retryAttempt + << " times, failing!" << std::endl; + return -1; + } + + myTrans = myNdb->startTransaction(); + if (myTrans == NULL) + { + const NdbError err = myNdb->getNdbError(); + + if (err.status == NdbError::TemporaryError) + { + milliSleep(50); + retryAttempt++; + continue; + } + std::cout << err.message << std::endl; + return -1; + } + + /** + * Get a scan operation. + */ + myScanOp = myTrans->getNdbScanOperation("GARAGE"); + if (myScanOp == NULL) + { + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + return -1; + } + + /** + * Define a result set for the scan. + */ + NdbResultSet * rs = myScanOp->readTuplesExclusive(parallelism); + if( rs == 0 ) { + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + return -1; + } + + /** + * Use NdbScanFilter to define a search critera + */ + NdbScanFilter filter(myScanOp) ; + if(filter.begin(NdbScanFilter::AND) < 0 || + filter.eq(update_column, before_color, column_len, false) <0|| + filter.end() <0) + { + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + return -1; + } + + /** + * Start scan (NoCommit since we are only reading at this stage); + */ + if(myTrans->execute(NoCommit) != 0){ + err = myTrans->getNdbError(); + if(err.status == NdbError::TemporaryError){ + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + milliSleep(50); + continue; + } + std::cout << myTrans->getNdbError().code << std::endl; + myNdb->closeTransaction(myTrans); + return -1; + } + + /** + * Define an update operation + */ + NdbOperation * myUpdateOp; + /** + * start of loop: nextResult(true) means that "parallelism" number of + * rows are fetched from NDB and cached in NDBAPI + */ + while((check = rs->nextResult(true)) == 0){ + do { + /** + * Get update operation + */ + myUpdateOp = rs->updateTuple(); + if (myUpdateOp == 0){ + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + return -1; + } + updatedRows++; + /** + * do the update + */ + myUpdateOp->setValue(update_column,after_color); + /** + * nextResult(false) means that the records + * cached in the NDBAPI are modified before + * fetching more rows from NDB. + */ + } while((check = rs->nextResult(false)) == 0); + + /** + * Commit when all cached tuple have been updated + */ + if(check != -1){ + check = myTrans->execute(Commit); + myTrans->releaseCompletedOperations(); + } + /** + * Check for errors + */ + err = myTrans->getNdbError(); + if(check == -1){ + if(err.status == NdbError::TemporaryError){ + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + milliSleep(50); + continue; + } + } + /** + * End of loop + */ + } + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + return 0; + + + } + if(myTrans!=0) { + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + } + return -1; +} + + + +int scan_print(Ndb * myNdb, int parallelism, + int column_len_brand, + int column_len_color) +{ +// Scan all records exclusive and update + // them one by one + int retryAttempt = 0; + const int retryMax = 10; + int fetchedRows = 0; + int check; + NdbError err; + NdbConnection *myTrans; + NdbScanOperation *myScanOp; + /* Result of reading attribute value, three columns: + REG_NO, BRAND, and COLOR + */ + NdbRecAttr * myRecAttr[3]; + + /** + * Loop as long as : + * retryMax not reached + * failed operations due to TEMPORARY erros + * + * Exit loop; + * retyrMax reached + * Permanent error (return -1) + */ + while (true) + { + + if (retryAttempt >= retryMax) + { + std::cout << "ERROR: has retried this operation " << retryAttempt + << " times, failing!" << std::endl; + return -1; + } + + myTrans = myNdb->startTransaction(); + if (myTrans == NULL) + { + const NdbError err = myNdb->getNdbError(); + + if (err.status == NdbError::TemporaryError) + { + milliSleep(50); + retryAttempt++; + continue; + } + std::cout << err.message << std::endl; + return -1; + } + /* + * Define a scan operation. + * NDBAPI. + */ + myScanOp = myTrans->getNdbScanOperation("GARAGE"); + if (myScanOp == NULL) + { + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + return -1; + } + + /** + * Define a result set for the scan. + */ + NdbResultSet * rs = myScanOp->readTuplesExclusive(parallelism); + if( rs == 0 ) { + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + return -1; + } + + /** + * Define storage for fetched attributes. + * E.g., the resulting attributes of executing + * myOp->getValue("REG_NO") is placed in myRecAttr[0]. + * No data exists in myRecAttr until transaction has commited! + */ + myRecAttr[0] = myScanOp->getValue("REG_NO"); + myRecAttr[1] = myScanOp->getValue("BRAND"); + myRecAttr[2] = myScanOp->getValue("COLOR"); + if(myRecAttr[0] ==NULL || myRecAttr[1] == NULL || myRecAttr[2]==NULL) + { + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + return -1; + } + /** + * Start scan (NoCommit since we are only reading at this stage); + */ + if(myTrans->execute(NoCommit) != 0){ + err = myTrans->getNdbError(); + if(err.status == NdbError::TemporaryError){ + std::cout << myTrans->getNdbError().message << std::endl; + myNdb->closeTransaction(myTrans); + milliSleep(50); + continue; + } + std::cout << err.code << std::endl; + std::cout << myTrans->getNdbError().code << std::endl; + myNdb->closeTransaction(myTrans); + return -1; + } + + /** + * start of loop: nextResult(true) means that "parallelism" number of + * rows are fetched from NDB and cached in NDBAPI + */ + while((check = rs->nextResult(true)) == 0){ + do { + + fetchedRows++; + /** + * print REG_NO unsigned int + */ + std::cout << myRecAttr[0]->u_32_value() << "\t"; + char * buf_brand = new char[column_len_brand+1]; + char * buf_color = new char[column_len_color+1]; + /** + * print BRAND character string + */ + memcpy(buf_brand, myRecAttr[1]->aRef(), column_len_brand); + buf_brand[column_len_brand] = 0; + std::cout << buf_brand << "\t"; + delete [] buf_brand; + /** + * print COLOR character string + */ + memcpy(buf_color, myRecAttr[2]->aRef(), column_len_color); + buf_brand[column_len_color] = 0; + std::cout << buf_color << std::endl; + delete [] buf_color; + /** + * nextResult(false) means that the records + * cached in the NDBAPI are modified before + * fetching more rows from NDB. + */ + } while((check = rs->nextResult(false)) == 0); + + } + myNdb->closeTransaction(myTrans); + return 1; + } + return -1; + +} + + +int main() +{ + Ndb* myNdb = new Ndb( "TEST_DB" ); // Object representing the database + + + + /******************************************* + * Initialize NDB and wait until its ready * + *******************************************/ + if (myNdb->init(1024) == -1) { // Set max 1024 parallel transactions + APIERROR(myNdb->getNdbError()); + exit(-1); + } + + if (myNdb->waitUntilReady(30) != 0) { + std::cout << "NDB was not ready within 30 secs." << std::endl; + exit(-1); + } + create_table(myNdb); + + NdbDictionary::Dictionary* myDict = myNdb->getDictionary(); + int column_color = myDict->getTable("GARAGE")->getColumn("COLOR")->getColumnNo(); + int column_len_color = + myDict->getTable("GARAGE")->getColumn("COLOR")->getLength(); + int column_len_brand = + myDict->getTable("GARAGE")->getColumn("BRAND")->getLength(); + int parallelism = 16; + + + if(populate(myNdb) > 0) + std::cout << "populate: Success!" << std::endl; + + if(scan_print(myNdb, parallelism, column_len_brand, column_len_color) > 0) + std::cout << "scan_print: Success!" << std::endl << std::endl; + + std::cout << "Going to delete all pink cars!" << std::endl; + if(scan_delete(myNdb, parallelism, column_color, + column_len_color, "Pink") > 0) + std::cout << "scan_delete: Success!" << std::endl << std::endl; + + if(scan_print(myNdb, parallelism, column_len_brand, column_len_color) > 0) + std::cout << "scan_print: Success!" << std::endl << std::endl; + + std::cout << "Going to update all blue cars to black cars!" << std::endl; + if(scan_update(myNdb, parallelism, column_len_color, column_color, + "COLOR", "Blue", "Black") > 0) + { + std::cout << "scan_update: Success!" << std::endl << std::endl; + } + if(scan_print(myNdb, parallelism, column_len_brand, column_len_color) > 0) + std::cout << "scan_print: Success!" << std::endl << std::endl; + + delete myNdb; +} + diff --git a/ndb/examples/ndbapi_scan_example/readme.txt b/ndb/examples/ndbapi_scan_example/readme.txt new file mode 100644 index 00000000000..47cb4bf9ffa --- /dev/null +++ b/ndb/examples/ndbapi_scan_example/readme.txt @@ -0,0 +1,3 @@ +1. Set NDB_OS in Makefile +2. Add path to libNDB_API.so in LD_LIBRARY_PATH +3. Set NDB_CONNECTSTRING diff --git a/ndb/examples/select_all/Makefile b/ndb/examples/select_all/Makefile new file mode 100644 index 00000000000..2bec205fa99 --- /dev/null +++ b/ndb/examples/select_all/Makefile @@ -0,0 +1,33 @@ +-include .defs.mk +#NDB_OS = OS_YOU_ARE_RUNNING_ON +#You need to set the NDB_OS variable here +TARGET = select_all +SRCS = select_all.cpp +OBJS = select_all.o +CXX = g++ +CFLAGS = -c -Wall -fno-rtti -fno-exceptions +DEBUG = +LFLAGS = -Wall +INCLUDE_DIR = ../../include +LIB_DIR = ../../lib +ifeq ($(NDB_OS), SOLARIS) +# Here is the definition of system libraries necessary for Solaris 7 +SYS_LIB = +endif +ifeq ($(NDB_OS), LINUX) +# Here is the definition of system libraries necessary for Linux 2.4 +SYS_LIB = +endif +ifeq ($(NDB_OS), MACOSX) +# Here is the definition of system libraries necessary for Mac OS X +SYS_LIB = +endif + +$(TARGET): $(OBJS) + $(CXX) $(LFLAGS) -L$(LIB_DIR) $(OBJS) -lNDB_API $(SYS_LIB) -o $(TARGET) + +$(TARGET).o: $(SRCS) + $(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS) + +clean: + rm -f *.o $(TARGET) diff --git a/ndb/examples/select_all/select_all.cpp b/ndb/examples/select_all/select_all.cpp new file mode 100644 index 00000000000..3cdbdc47e62 --- /dev/null +++ b/ndb/examples/select_all/select_all.cpp @@ -0,0 +1,258 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +// +// select_all.cpp: Prints all rows of a table +// +// Usage: select_all + + +#include + +// Used for cout +#include +using namespace std; +#include +#include + +#define APIERROR(error) \ + { cout << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" \ + << error.code << ", msg: " << error.message << "." << endl; \ + exit(-1); } + +void usage(const char* prg) { + cout << "Usage: " << prg << " " << endl; + cout << "Prints all rows of table named
" << endl; + exit(0); +} + +/***************************************************************************** + *************************** Result Set Container **************************** + *****************************************************************************/ + +/* + * Container of NdbRecAttr objects. + * (NdbRecAttr objects are database rows read by a scan operation.) + */ +class ResultSetContainer { +public: + /** + * Initialize ResultSetContainer object for table named + * - Allocates memory + * - Fetches attribute names from NDB Cluster + */ + void init(NdbDictionary::Dictionary* dict, const char* tableName); + + /** + * Get no of attributes for stored NdbRecAttr objects + */ + int getNoOfAttributes() const; + + /** + * Get NdbRecAttr object no i + */ + NdbRecAttr* & getAttrStore(int i); + + /** + * Get attribute name of attribute no i + */ + const char* getAttrName(int i) const; + + /** + * Print header of rows + */ + void header() const; + +private: + int m_cols; // No of attributes for stored NdbRecAttr objects + char **m_names; // Names of attributes + NdbRecAttr **m_data; // The actual stored NdbRecAttr objects +}; + +void ResultSetContainer::init(NdbDictionary::Dictionary * dict, + const char* tableName) +{ + // Get Table object from NDB (this contains metadata about all tables) + const NdbDictionary::Table * tab = dict->getTable(tableName); + + // Get table id of the table we are interested in + if (tab == 0) APIERROR(dict->getNdbError()); // E.g. table didn't exist + + // Get no of attributes and allocate memory + m_cols = tab->getNoOfColumns(); + m_names = new char* [m_cols]; + m_data = new NdbRecAttr* [m_cols]; + + // Store all attribute names for the table + for (int i = 0; i < m_cols; i++) { + m_names[i] = new char[255]; + snprintf(m_names[i], 255, "%s", tab->getColumn(i)->getName()); + } +} + +int ResultSetContainer::getNoOfAttributes() const {return m_cols;} +NdbRecAttr*& ResultSetContainer::getAttrStore(int i) {return m_data[i];} +const char* ResultSetContainer::getAttrName(int i) const {return m_names[i];} + +/***************************************************************************** + ********************************** MAIN *********************************** + *****************************************************************************/ + +int main(int argc, const char** argv) +{ + Ndb* myNdb = new Ndb("ndbapi_example4"); // Object representing the database + NdbConnection* myNdbConnection; // For transactions + NdbOperation* myNdbOperation; // For operations + int check; + + if (argc != 2) { + usage(argv[0]); + exit(0); + } + const char* tableName = argv[1]; + + /******************************************* + * Initialize NDB and wait until its ready * + *******************************************/ + if (myNdb->init() == -1) { + APIERROR(myNdb->getNdbError()); + exit(-1); + } + + if (myNdb->waitUntilReady(30) != 0) { + cout << "NDB was not ready within 30 secs." << endl; + exit(-1); + } + + /*************************** + * Define and execute scan * + ***************************/ + cout << "Select * from " << tableName << endl; + + ResultSetContainer * container = new ResultSetContainer; + container->init(myNdb->getDictionary(), tableName); + + myNdbConnection = myNdb->startTransaction(); + if (myNdbConnection == NULL) APIERROR(myNdb->getNdbError()); + + myNdbOperation = myNdbConnection->getNdbOperation(tableName); + if (myNdbOperation == NULL) APIERROR(myNdbConnection->getNdbError()); + + // Define the operation to be an 'openScanRead' operation. + check = myNdbOperation->openScanRead(1); + if (check == -1) APIERROR(myNdbConnection->getNdbError()); + + // Set interpreted program to just be the single instruction + // 'interpret_exit_ok'. (This approves all rows of the table.) + if (myNdbOperation->interpret_exit_ok() == -1) + APIERROR(myNdbConnection->getNdbError()); + + // Get all attribute values of the row + for(int i = 0; i < container->getNoOfAttributes(); i++){ + if((container->getAttrStore(i) = + myNdbOperation->getValue(container->getAttrName(i))) == 0) + APIERROR(myNdbConnection->getNdbError()); + } + + // Execute scan operation + check = myNdbConnection->executeScan(); + if (check == -1) APIERROR(myNdbConnection->getNdbError()); + + /**************** + * Print header * + ****************/ + for (int i = 0; i < container->getNoOfAttributes(); i++) + cout << container->getAttrName(i) << "\t"; + + cout << endl; + for (int i = 0; i < container->getNoOfAttributes(); i++) { + for (int j = strlen(container->getAttrName(i)); j > 0; j--) + cout << "-"; + cout << "\t"; + } + cout << "\n"; + + /************** + * Scan table * + **************/ + int eof; + int rows = 0; + + // Print all rows of table + while ((eof = myNdbConnection->nextScanResult()) == 0) { + rows++; + + for (int i = 0; i < container->getNoOfAttributes(); i++) { + if (container->getAttrStore(i)->isNULL()) { + cout << "NULL"; + } else { + + // Element size of value (No of bits per element in attribute value) + const int size = container->getAttrStore(i)->attrSize(); + + // No of elements in an array attribute (Is 1 if non-array attribute) + const int aSize = container->getAttrStore(i)->arraySize(); + + switch(container->getAttrStore(i)->attrType()){ + case UnSigned: + switch(size) { + case 8: cout << container->getAttrStore(i)->u_64_value(); break; + case 4: cout << container->getAttrStore(i)->u_32_value(); break; + case 2: cout << container->getAttrStore(i)->u_short_value(); break; + case 1: cout << (unsigned) container->getAttrStore(i)->u_char_value(); + break; + default: cout << "Unknown size" << endl; + } + break; + + case Signed: + switch(size) { + case 8: cout << container->getAttrStore(i)->int64_value(); break; + case 4: cout << container->getAttrStore(i)->int32_value(); break; + case 2: cout << container->getAttrStore(i)->short_value(); break; + case 1: cout << (int) container->getAttrStore(i)->char_value(); break; + default: cout << "Unknown size" << endl; + } + break; + + case String: + { + char* buf = new char[aSize+1]; + memcpy(buf, container->getAttrStore(i)->aRef(), aSize); + buf[aSize] = 0; + cout << buf; + delete [] buf; + } + break; + + case Float: + cout << container->getAttrStore(i)->float_value(); + break; + + default: + cout << "Unknown"; + break; + } + } + cout << "\t"; + } + cout << endl; + } + if (eof == -1) APIERROR(myNdbConnection->getNdbError()); + + myNdb->closeTransaction(myNdbConnection); + + cout << "Selected " << rows << " rows." << endl; +} diff --git a/ndb/home/bin/Linuxmkisofs b/ndb/home/bin/Linuxmkisofs new file mode 100755 index 00000000000..a531f4cca7b Binary files /dev/null and b/ndb/home/bin/Linuxmkisofs differ diff --git a/ndb/home/bin/Solarismkisofs b/ndb/home/bin/Solarismkisofs new file mode 100755 index 00000000000..b239eaed6ad Binary files /dev/null and b/ndb/home/bin/Solarismkisofs differ diff --git a/ndb/home/bin/cvs2cl.pl b/ndb/home/bin/cvs2cl.pl new file mode 100755 index 00000000000..9e6da5acf5b --- /dev/null +++ b/ndb/home/bin/cvs2cl.pl @@ -0,0 +1,1865 @@ +#!/bin/sh +exec perl -w -x $0 ${1+"$@"} # -*- mode: perl; perl-indent-level: 2; -*- +#!perl -w + +############################################################## +### ### +### cvs2cl.pl: produce ChangeLog(s) from `cvs log` output. ### +### ### +############################################################## + +## $Revision: 2.38 $ +## $Date: 2001/02/12 19:54:35 $ +## $Author: kfogel $ +## +## (C) 1999 Karl Fogel , under the GNU GPL. +## +## (Extensively hacked on by Melissa O'Neill .) +## +## cvs2cl.pl is free software; you can redistribute it and/or modify +## it under the terms of the GNU General Public License as published by +## the Free Software Foundation; either version 2, or (at your option) +## any later version. +## +## cvs2cl.pl is distributed in the hope that it will be useful, +## but WITHOUT ANY WARRANTY; without even the implied warranty of +## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +## GNU General Public License for more details. +## +## You may have received a copy of the GNU General Public License +## along with cvs2cl.pl; see the file COPYING. If not, write to the +## Free Software Foundation, Inc., 59 Temple Place - Suite 330, +## Boston, MA 02111-1307, USA. + + + +use strict; +use Text::Wrap; +use Time::Local; +use File::Basename; + + +# The Plan: +# +# Read in the logs for multiple files, spit out a nice ChangeLog that +# mirrors the information entered during `cvs commit'. +# +# The problem presents some challenges. In an ideal world, we could +# detect files with the same author, log message, and checkin time -- +# each would be a changelog entry. +# We'd sort them; and spit them out. Unfortunately, CVS is *not atomic* +# so checkins can span a range of times. Also, the directory structure +# could be hierarchical. +# +# Another question is whether we really want to have the ChangeLog +# exactly reflect commits. An author could issue two related commits, +# with different log entries, reflecting a single logical change to the +# source. GNU style ChangeLogs group these under a single author/date. +# We try to do the same. +# +# So, we parse the output of `cvs log', storing log messages in a +# multilevel hash that stores the mapping: +# directory => author => time => message => filelist +# As we go, we notice "nearby" commit times and store them together +# (i.e., under the same timestamp), so they appear in the same log +# entry. +# +# When we've read all the logs, we twist this mapping into +# a time => author => message => filelist mapping for each directory. +# +# If we're not using the `--distributed' flag, the directory is always +# considered to be `./', even as descend into subdirectories. + + +############### Globals ################ + + +# What we run to generate it: +my $Log_Source_Command = "cvs log"; + +# In case we have to print it out: +my $VERSION = '$Revision: 2.38 $'; +$VERSION =~ s/\S+\s+(\S+)\s+\S+/$1/; + +## Vars set by options: + +# Print debugging messages? +my $Debug = 0; + +# Just show version and exit? +my $Print_Version = 0; + +# Just print usage message and exit? +my $Print_Usage = 0; + +# Single top-level ChangeLog, or one per subdirectory? +my $Distributed = 0; + +# What file should we generate (defaults to "ChangeLog")? +my $Log_File_Name = "ChangeLog"; + +# Grab most recent entry date from existing ChangeLog file, just add +# to that ChangeLog. +my $Cumulative = 0; + +# Expand usernames to email addresses based on a map file? +my $User_Map_File = ""; + +# Output to a file or to stdout? +my $Output_To_Stdout = 0; + +# Eliminate empty log messages? +my $Prune_Empty_Msgs = 0; + +# Don't call Text::Wrap on the body of the message +my $No_Wrap = 0; + +# Separates header from log message. Code assumes it is either " " or +# "\n\n", so if there's ever an option to set it to something else, +# make sure to go through all conditionals that use this var. +my $After_Header = " "; + +# Format more for programs than for humans. +my $XML_Output = 0; + +# Do some special tweaks for log data that was written in FSF +# ChangeLog style. +my $FSF_Style = 0; + +# Show times in UTC instead of local time +my $UTC_Times = 0; + +# Show day of week in output? +my $Show_Day_Of_Week = 0; + +# Show revision numbers in output? +my $Show_Revisions = 0; + +# Show tags (symbolic names) in output? +my $Show_Tags = 0; + +# Show branches by symbolic name in output? +my $Show_Branches = 0; + +# Show only revisions on these branches or their ancestors. +my @Follow_Branches; + +# Don't bother with files matching this regexp. +my @Ignore_Files; + +# How exactly we match entries. We definitely want "o", +# and user might add "i" by using --case-insensitive option. +my $Case_Insensitive = 0; + +# Maybe only show log messages matching a certain regular expression. +my $Regexp_Gate = ""; + +# Pass this global option string along to cvs, to the left of `log': +my $Global_Opts = ""; + +# Pass this option string along to the cvs log subcommand: +my $Command_Opts = ""; + +# Read log output from stdin instead of invoking cvs log? +my $Input_From_Stdin = 0; + +# Don't show filenames in output. +my $Hide_Filenames = 0; + +# Max checkin duration. CVS checkin is not atomic, so we may have checkin +# times that span a range of time. We assume that checkins will last no +# longer than $Max_Checkin_Duration seconds, and that similarly, no +# checkins will happen from the same users with the same message less +# than $Max_Checkin_Duration seconds apart. +my $Max_Checkin_Duration = 180; + +# What to put at the front of [each] ChangeLog. +my $ChangeLog_Header = ""; + +## end vars set by options. + +# In 'cvs log' output, one long unbroken line of equal signs separates +# files: +my $file_separator = "=======================================" + . "======================================"; + +# In 'cvs log' output, a shorter line of dashes separates log messages +# within a file: +my $logmsg_separator = "----------------------------"; + + +############### End globals ############ + + + + +&parse_options (); +&derive_change_log (); + + + +### Everything below is subroutine definitions. ### + +# If accumulating, grab the boundary date from pre-existing ChangeLog. +sub maybe_grab_accumulation_date () +{ + if (! $Cumulative) { + return ""; + } + + # else + + open (LOG, "$Log_File_Name") + or die ("trouble opening $Log_File_Name for reading ($!)"); + + my $boundary_date; + while () + { + if (/^(\d\d\d\d-\d\d-\d\d\s+\d\d:\d\d)/) + { + $boundary_date = "$1"; + last; + } + } + + close (LOG); + return $boundary_date; +} + + +# Fills up a ChangeLog structure in the current directory. +sub derive_change_log () +{ + # See "The Plan" above for a full explanation. + + my %grand_poobah; + + my $file_full_path; + my $time; + my $revision; + my $author; + my $msg_txt; + my $detected_file_separator; + + # Might be adding to an existing ChangeLog + my $accumulation_date = &maybe_grab_accumulation_date (); + if ($accumulation_date) { + $Log_Source_Command .= " -d\'>${accumulation_date}\'"; + } + + # We might be expanding usernames + my %usermap; + + # In general, it's probably not very maintainable to use state + # variables like this to tell the loop what it's doing at any given + # moment, but this is only the first one, and if we never have more + # than a few of these, it's okay. + my $collecting_symbolic_names = 0; + my %symbolic_names; # Where tag names get stored. + my %branch_names; # We'll grab branch names while we're at it. + my %branch_numbers; # Save some revisions for @Follow_Branches + my @branch_roots; # For showing which files are branch ancestors. + + # Bleargh. Compensate for a deficiency of custom wrapping. + if (($After_Header ne " ") and $FSF_Style) + { + $After_Header .= "\t"; + } + + if (! $Input_From_Stdin) { + open (LOG_SOURCE, "$Log_Source_Command |") + or die "unable to run \"${Log_Source_Command}\""; + } + else { + open (LOG_SOURCE, "-") or die "unable to open stdin for reading"; + } + + %usermap = &maybe_read_user_map_file (); + + while () + { + # If on a new file and don't see filename, skip until we find it, and + # when we find it, grab it. + if ((! (defined $file_full_path)) and /^Working file: (.*)/) + { + $file_full_path = $1; + if (@Ignore_Files) + { + my $base; + ($base, undef, undef) = fileparse ($file_full_path); + # Ouch, I wish trailing operators in regexps could be + # evaluated on the fly! + if ($Case_Insensitive) { + if (grep ($file_full_path =~ m|$_|i, @Ignore_Files)) { + undef $file_full_path; + } + } + elsif (grep ($file_full_path =~ m|$_|, @Ignore_Files)) { + undef $file_full_path; + } + } + next; + } + + # Just spin wheels if no file defined yet. + next if (! $file_full_path); + + # Collect tag names in case we're asked to print them in the output. + if (/^symbolic names:$/) { + $collecting_symbolic_names = 1; + next; # There's no more info on this line, so skip to next + } + if ($collecting_symbolic_names) + { + # All tag names are listed with whitespace in front in cvs log + # output; so if see non-whitespace, then we're done collecting. + if (/^\S/) { + $collecting_symbolic_names = 0; + } + else # we're looking at a tag name, so parse & store it + { + # According to the Cederqvist manual, in node "Tags", tag + # names must start with an uppercase or lowercase letter and + # can contain uppercase and lowercase letters, digits, `-', + # and `_'. However, it's not our place to enforce that, so + # we'll allow anything CVS hands us to be a tag: + /^\s+([^:]+): ([\d.]+)$/; + my $tag_name = $1; + my $tag_rev = $2; + + # A branch number either has an odd number of digit sections + # (and hence an even number of dots), or has ".0." as the + # second-to-last digit section. Test for these conditions. + my $real_branch_rev = ""; + if (($tag_rev =~ /^(\d+\.\d+\.)+\d+$/) # Even number of dots... + and (! ($tag_rev =~ /^(1\.)+1$/))) # ...but not "1.[1.]1" + { + $real_branch_rev = $tag_rev; + } + elsif ($tag_rev =~ /(\d+\.(\d+\.)+)0.(\d+)/) # Has ".0." + { + $real_branch_rev = $1 . $3; + } + # If we got a branch, record its number. + if ($real_branch_rev) + { + $branch_names{$real_branch_rev} = $tag_name; + if (@Follow_Branches) { + if (grep ($_ eq $tag_name, @Follow_Branches)) { + $branch_numbers{$tag_name} = $real_branch_rev; + } + } + } + else { + # Else it's just a regular (non-branch) tag. + push (@{$symbolic_names{$tag_rev}}, $tag_name); + } + } + } + # End of code for collecting tag names. + + # If have file name, but not revision, and see revision, then grab + # it. (We collect unconditionally, even though we may or may not + # ever use it.) + if ((! (defined $revision)) and (/^revision (\d+\.[\d.]+)/)) + { + $revision = $1; + + if (@Follow_Branches) + { + foreach my $branch (@Follow_Branches) + { + # Special case for following trunk revisions + if (($branch =~ /^trunk$/i) and ($revision =~ /^[0-9]+\.[0-9]+$/)) + { + goto dengo; + } + + my $branch_number = $branch_numbers{$branch}; + if ($branch_number) + { + # Are we on one of the follow branches or an ancestor of + # same? + # + # If this revision is a prefix of the branch number, or + # possibly is less in the minormost number, OR if this + # branch number is a prefix of the revision, then yes. + # Otherwise, no. + # + # So below, we determine if any of those conditions are + # met. + + # Trivial case: is this revision on the branch? + # (Compare this way to avoid regexps that screw up Emacs + # indentation, argh.) + if ((substr ($revision, 0, ((length ($branch_number)) + 1))) + eq ($branch_number . ".")) + { + goto dengo; + } + # Non-trivial case: check if rev is ancestral to branch + elsif ((length ($branch_number)) > (length ($revision))) + { + $revision =~ /^((?:\d+\.)+)(\d+)$/; + my $r_left = $1; # still has the trailing "." + my $r_end = $2; + + $branch_number =~ /^((?:\d+\.)+)(\d+)\.\d+$/; + my $b_left = $1; # still has trailing "." + my $b_mid = $2; # has no trailing "." + + if (($r_left eq $b_left) + && ($r_end <= $b_mid)) + { + goto dengo; + } + } + } + } + } + else # (! @Follow_Branches) + { + next; + } + + # Else we are following branches, but this revision isn't on the + # path. So skip it. + undef $revision; + dengo: + next; + } + + # If we don't have a revision right now, we couldn't possibly + # be looking at anything useful. + if (! (defined ($revision))) { + $detected_file_separator = /^$file_separator$/o; + if ($detected_file_separator) { + # No revisions for this file; can happen, e.g. "cvs log -d DATE" + goto CLEAR; + } + else { + next; + } + } + + # If have file name but not date and author, and see date or + # author, then grab them: + unless (defined $time) + { + if (/^date: .*/) + { + ($time, $author) = &parse_date_and_author ($_); + if (defined ($usermap{$author}) and $usermap{$author}) { + $author = $usermap{$author}; + } + } + else { + $detected_file_separator = /^$file_separator$/o; + if ($detected_file_separator) { + # No revisions for this file; can happen, e.g. "cvs log -d DATE" + goto CLEAR; + } + } + # If the date/time/author hasn't been found yet, we couldn't + # possibly care about anything we see. So skip: + next; + } + + # A "branches: ..." line here indicates that one or more branches + # are rooted at this revision. If we're showing branches, then we + # want to show that fact as well, so we collect all the branches + # that this is the latest ancestor of and store them in + # @branch_roots. Just for reference, the format of the line we're + # seeing at this point is: + # + # branches: 1.5.2; 1.5.4; ...; + # + # Okay, here goes: + + if (/^branches:\s+(.*);$/) + { + if ($Show_Branches) + { + my $lst = $1; + $lst =~ s/(1\.)+1;|(1\.)+1$//; # ignore the trivial branch 1.1.1 + if ($lst) { + @branch_roots = split (/;\s+/, $lst); + } + else { + undef @branch_roots; + } + next; + } + else + { + # Ugh. This really bothers me. Suppose we see a log entry + # like this: + # + # ---------------------------- + # revision 1.1 + # date: 1999/10/17 03:07:38; author: jrandom; state: Exp; + # branches: 1.1.2; + # Intended first line of log message begins here. + # ---------------------------- + # + # The question is, how we can tell the difference between that + # log message and a *two*-line log message whose first line is + # + # "branches: 1.1.2;" + # + # See the problem? The output of "cvs log" is inherently + # ambiguous. + # + # For now, we punt: we liberally assume that people don't + # write log messages like that, and just toss a "branches:" + # line if we see it but are not showing branches. I hope no + # one ever loses real log data because of this. + next; + } + } + + # If have file name, time, and author, then we're just grabbing + # log message texts: + $detected_file_separator = /^$file_separator$/o; + if ($detected_file_separator && ! (defined $revision)) { + # No revisions for this file; can happen, e.g. "cvs log -d DATE" + goto CLEAR; + } + unless ($detected_file_separator || /^$logmsg_separator$/o) + { + $msg_txt .= $_; # Normally, just accumulate the message... + next; + } + # ... until a msg separator is encountered: + # Ensure the message contains something: + if ((! $msg_txt) + || ($msg_txt =~ /^\s*\.\s*$|^\s*$/) + || ($msg_txt =~ /\*\*\* empty log message \*\*\*/)) + { + if ($Prune_Empty_Msgs) { + goto CLEAR; + } + # else + $msg_txt = "[no log message]\n"; + } + + ### Store it all in the Grand Poobah: + { + my $dir_key; # key into %grand_poobah + my %qunk; # complicated little jobbie, see below + + # Each revision of a file has a little data structure (a `qunk') + # associated with it. That data structure holds not only the + # file's name, but any additional information about the file + # that might be needed in the output, such as the revision + # number, tags, branches, etc. The reason to have these things + # arranged in a data structure, instead of just appending them + # textually to the file's name, is that we may want to do a + # little rearranging later as we write the output. For example, + # all the files on a given tag/branch will go together, followed + # by the tag in parentheses (so trunk or otherwise non-tagged + # files would go at the end of the file list for a given log + # message). This rearrangement is a lot easier to do if we + # don't have to reparse the text. + # + # A qunk looks like this: + # + # { + # filename => "hello.c", + # revision => "1.4.3.2", + # time => a timegm() return value (moment of commit) + # tags => [ "tag1", "tag2", ... ], + # branch => "branchname" # There should be only one, right? + # branchroots => [ "branchtag1", "branchtag2", ... ] + # } + + if ($Distributed) { + # Just the basename, don't include the path. + ($qunk{'filename'}, $dir_key, undef) = fileparse ($file_full_path); + } + else { + $dir_key = "./"; + $qunk{'filename'} = $file_full_path; + } + + # This may someday be used in a more sophisticated calculation + # of what other files are involved in this commit. For now, we + # don't use it, because the common-commit-detection algorithm is + # hypothesized to be "good enough" as it stands. + $qunk{'time'} = $time; + + # We might be including revision numbers and/or tags and/or + # branch names in the output. Most of the code from here to + # loop-end deals with organizing these in qunk. + + $qunk{'revision'} = $revision; + + # Grab the branch, even though we may or may not need it: + $qunk{'revision'} =~ /((?:\d+\.)+)\d+/; + my $branch_prefix = $1; + $branch_prefix =~ s/\.$//; # strip off final dot + if ($branch_names{$branch_prefix}) { + $qunk{'branch'} = $branch_names{$branch_prefix}; + } + + # If there's anything in the @branch_roots array, then this + # revision is the root of at least one branch. We'll display + # them as branch names instead of revision numbers, the + # substitution for which is done directly in the array: + if (@branch_roots) { + my @roots = map { $branch_names{$_} } @branch_roots; + $qunk{'branchroots'} = \@roots; + } + + # Save tags too. + if (defined ($symbolic_names{$revision})) { + $qunk{'tags'} = $symbolic_names{$revision}; + delete $symbolic_names{$revision}; + } + + # Add this file to the list + # (We use many spoonfuls of autovivication magic. Hashes and arrays + # will spring into existence if they aren't there already.) + + &debug ("(pushing log msg for ${dir_key}$qunk{'filename'})\n"); + + # Store with the files in this commit. Later we'll loop through + # again, making sure that revisions with the same log message + # and nearby commit times are grouped together as one commit. + push (@{$grand_poobah{$dir_key}{$author}{$time}{$msg_txt}}, \%qunk); + } + + CLEAR: + # Make way for the next message + undef $msg_txt; + undef $time; + undef $revision; + undef $author; + undef @branch_roots; + + # Maybe even make way for the next file: + if ($detected_file_separator) { + undef $file_full_path; + undef %branch_names; + undef %branch_numbers; + undef %symbolic_names; + } + } + + close (LOG_SOURCE); + + ### Process each ChangeLog + + while (my ($dir,$authorhash) = each %grand_poobah) + { + &debug ("DOING DIR: $dir\n"); + + # Here we twist our hash around, from being + # author => time => message => filelist + # in %$authorhash to + # time => author => message => filelist + # in %changelog. + # + # This is also where we merge entries. The algorithm proceeds + # through the timeline of the changelog with a sliding window of + # $Max_Checkin_Duration seconds; within that window, entries that + # have the same log message are merged. + # + # (To save space, we zap %$authorhash after we've copied + # everything out of it.) + + my %changelog; + while (my ($author,$timehash) = each %$authorhash) + { + my $lasttime; + my %stamptime; + foreach my $time (sort {$main::a <=> $main::b} (keys %$timehash)) + { + my $msghash = $timehash->{$time}; + while (my ($msg,$qunklist) = each %$msghash) + { + my $stamptime = $stamptime{$msg}; + if ((defined $stamptime) + and (($time - $stamptime) < $Max_Checkin_Duration) + and (defined $changelog{$stamptime}{$author}{$msg})) + { + push(@{$changelog{$stamptime}{$author}{$msg}}, @$qunklist); + } + else { + $changelog{$time}{$author}{$msg} = $qunklist; + $stamptime{$msg} = $time; + } + } + } + } + undef (%$authorhash); + + ### Now we can write out the ChangeLog! + + my ($logfile_here, $logfile_bak, $tmpfile); + + if (! $Output_To_Stdout) { + $logfile_here = $dir . $Log_File_Name; + $logfile_here =~ s/^\.\/\//\//; # fix any leading ".//" problem + $tmpfile = "${logfile_here}.cvs2cl$$.tmp"; + $logfile_bak = "${logfile_here}.bak"; + + open (LOG_OUT, ">$tmpfile") or die "Unable to open \"$tmpfile\""; + } + else { + open (LOG_OUT, ">-") or die "Unable to open stdout for writing"; + } + + print LOG_OUT $ChangeLog_Header; + + if ($XML_Output) { + print LOG_OUT "\n\n" + . "\n\n"; + } + + foreach my $time (sort {$main::b <=> $main::a} (keys %changelog)) + { + my $authorhash = $changelog{$time}; + while (my ($author,$mesghash) = each %$authorhash) + { + # If XML, escape in outer loop to avoid compound quoting: + if ($XML_Output) { + $author = &xml_escape ($author); + } + + while (my ($msg,$qunklist) = each %$mesghash) + { + my $files = &pretty_file_list ($qunklist); + my $header_line; # date and author + my $body; # see below + my $wholething; # $header_line + $body + + # Set up the date/author line. + # kff todo: do some more XML munging here, on the header + # part of the entry: + my ($ignore,$min,$hour,$mday,$mon,$year,$wday) + = $UTC_Times ? gmtime($time) : localtime($time); + + # XML output includes everything else, we might as well make + # it always include Day Of Week too, for consistency. + if ($Show_Day_Of_Week or $XML_Output) { + $wday = ("Sunday", "Monday", "Tuesday", "Wednesday", + "Thursday", "Friday", "Saturday")[$wday]; + $wday = ($XML_Output) ? "${wday}\n" : " $wday"; + } + else { + $wday = ""; + } + + if ($XML_Output) { + $header_line = + sprintf ("%4u-%02u-%02u\n" + . "${wday}" + . "\n" + . "%s\n", + $year+1900, $mon+1, $mday, $hour, $min, $author); + } + else { + $header_line = + sprintf ("%4u-%02u-%02u${wday} %02u:%02u %s\n\n", + $year+1900, $mon+1, $mday, $hour, $min, $author); + } + + # Reshape the body according to user preferences. + if ($XML_Output) + { + $msg = &preprocess_msg_text ($msg); + $body = $files . $msg; + } + elsif ($No_Wrap) + { + $msg = &preprocess_msg_text ($msg); + $files = wrap ("\t", " ", "$files"); + $msg =~ s/\n(.*)/\n\t$1/g; + unless ($After_Header eq " ") { + $msg =~ s/^(.*)/\t$1/g; + } + $body = $files . $After_Header . $msg; + } + else # do wrapping, either FSF-style or regular + { + if ($FSF_Style) + { + $files = wrap ("\t", " ", "$files"); + + my $files_last_line_len = 0; + if ($After_Header eq " ") + { + $files_last_line_len = &last_line_len ($files); + $files_last_line_len += 1; # for $After_Header + } + + $msg = &wrap_log_entry + ($msg, "\t", 69 - $files_last_line_len, 69); + $body = $files . $After_Header . $msg; + } + else # not FSF-style + { + $msg = &preprocess_msg_text ($msg); + $body = $files . $After_Header . $msg; + $body = wrap ("\t", " ", "$body"); + } + } + + $wholething = $header_line . $body; + + if ($XML_Output) { + $wholething = "\n${wholething}\n"; + } + + # One last check: make sure it passes the regexp test, if the + # user asked for that. We have to do it here, so that the + # test can match against information in the header as well + # as in the text of the log message. + + # How annoying to duplicate so much code just because I + # can't figure out a way to evaluate scalars on the trailing + # operator portion of a regular expression. Grrr. + if ($Case_Insensitive) { + unless ($Regexp_Gate && ($wholething !~ /$Regexp_Gate/oi)) { + print LOG_OUT "${wholething}\n"; + } + } + else { + unless ($Regexp_Gate && ($wholething !~ /$Regexp_Gate/o)) { + print LOG_OUT "${wholething}\n"; + } + } + } + } + } + + if ($XML_Output) { + print LOG_OUT "\n"; + } + + close (LOG_OUT); + + if (! $Output_To_Stdout) + { + # If accumulating, append old data to new before renaming. But + # don't append the most recent entry, since it's already in the + # new log due to CVS's idiosyncratic interpretation of "log -d". + if ($Cumulative && -f $logfile_here) + { + open (NEW_LOG, ">>$tmpfile") + or die "trouble appending to $tmpfile ($!)"; + + open (OLD_LOG, "<$logfile_here") + or die "trouble reading from $logfile_here ($!)"; + + my $started_first_entry = 0; + my $passed_first_entry = 0; + while () + { + if (! $passed_first_entry) + { + if ((! $started_first_entry) + && /^(\d\d\d\d-\d\d-\d\d\s+\d\d:\d\d)/) { + $started_first_entry = 1; + } + elsif (/^(\d\d\d\d-\d\d-\d\d\s+\d\d:\d\d)/) { + $passed_first_entry = 1; + print NEW_LOG $_; + } + } + else { + print NEW_LOG $_; + } + } + + close (NEW_LOG); + close (OLD_LOG); + } + + if (-f $logfile_here) { + rename ($logfile_here, $logfile_bak); + } + rename ($tmpfile, $logfile_here); + } + } +} + + +sub parse_date_and_author () +{ + # Parses the date/time and author out of a line like: + # + # date: 1999/02/19 23:29:05; author: apharris; state: Exp; + + my $line = shift; + + my ($year, $mon, $mday, $hours, $min, $secs, $author) = $line =~ + m#(\d+)/(\d+)/(\d+)\s+(\d+):(\d+):(\d+);\s+author:\s+([^;]+);# + or die "Couldn't parse date ``$line''"; + die "Bad date or Y2K issues" unless ($year > 1969 and $year < 2258); + # Kinda arbitrary, but useful as a sanity check + my $time = timegm($secs,$min,$hours,$mday,$mon-1,$year-1900); + + return ($time, $author); +} + + +# Here we take a bunch of qunks and convert them into printed +# summary that will include all the information the user asked for. +sub pretty_file_list () +{ + if ($Hide_Filenames and (! $XML_Output)) { + return ""; + } + + my $qunksref = shift; + my @qunkrefs = @$qunksref; + my @filenames; + my $beauty = ""; # The accumulating header string for this entry. + my %non_unanimous_tags; # Tags found in a proper subset of qunks + my %unanimous_tags; # Tags found in all qunks + my %all_branches; # Branches found in any qunk + my $common_dir = undef; # Dir prefix common to all files ("" if none) + my $fbegun = 0; # Did we begin printing filenames yet? + + # First, loop over the qunks gathering all the tag/branch names. + # We'll put them all in non_unanimous_tags, and take out the + # unanimous ones later. + foreach my $qunkref (@qunkrefs) + { + # Keep track of whether all the files in this commit were in the + # same directory, and memorize it if so. We can make the output a + # little more compact by mentioning the directory only once. + if ((scalar (@qunkrefs)) > 1) + { + if (! (defined ($common_dir))) + { + my ($base, $dir); + ($base, $dir, undef) = fileparse ($$qunkref{'filename'}); + + if ((! (defined ($dir))) # this first case is sheer paranoia + or ($dir eq "") + or ($dir eq "./") + or ($dir eq ".\\")) + { + $common_dir = ""; + } + else + { + $common_dir = $dir; + } + } + elsif ($common_dir ne "") + { + # Already have a common dir prefix, so how much of it can we preserve? + $common_dir = &common_path_prefix ($$qunkref{'filename'}, $common_dir); + } + } + else # only one file in this entry anyway, so common dir not an issue + { + $common_dir = ""; + } + + if (defined ($$qunkref{'branch'})) { + $all_branches{$$qunkref{'branch'}} = 1; + } + if (defined ($$qunkref{'tags'})) { + foreach my $tag (@{$$qunkref{'tags'}}) { + $non_unanimous_tags{$tag} = 1; + } + } + } + + # Any tag held by all qunks will be printed specially... but only if + # there are multiple qunks in the first place! + if ((scalar (@qunkrefs)) > 1) { + foreach my $tag (keys (%non_unanimous_tags)) { + my $everyone_has_this_tag = 1; + foreach my $qunkref (@qunkrefs) { + if ((! (defined ($$qunkref{'tags'}))) + or (! (grep ($_ eq $tag, @{$$qunkref{'tags'}})))) { + $everyone_has_this_tag = 0; + } + } + if ($everyone_has_this_tag) { + $unanimous_tags{$tag} = 1; + delete $non_unanimous_tags{$tag}; + } + } + } + + if ($XML_Output) + { + # If outputting XML, then our task is pretty simple, because we + # don't have to detect common dir, common tags, branch prefixing, + # etc. We just output exactly what we have, and don't worry about + # redundancy or readability. + + foreach my $qunkref (@qunkrefs) + { + my $filename = $$qunkref{'filename'}; + my $revision = $$qunkref{'revision'}; + my $tags = $$qunkref{'tags'}; + my $branch = $$qunkref{'branch'}; + my $branchroots = $$qunkref{'branchroots'}; + + $filename = &xml_escape ($filename); # probably paranoia + $revision = &xml_escape ($revision); # definitely paranoia + + $beauty .= "\n"; + $beauty .= "${filename}\n"; + $beauty .= "${revision}\n"; + if ($branch) { + $branch = &xml_escape ($branch); # more paranoia + $beauty .= "${branch}\n"; + } + foreach my $tag (@$tags) { + $tag = &xml_escape ($tag); # by now you're used to the paranoia + $beauty .= "${tag}\n"; + } + foreach my $root (@$branchroots) { + $root = &xml_escape ($root); # which is good, because it will continue + $beauty .= "${root}\n"; + } + $beauty .= "\n"; + } + + # Theoretically, we could go home now. But as long as we're here, + # let's print out the common_dir and utags, as a convenience to + # the receiver (after all, earlier code calculated that stuff + # anyway, so we might as well take advantage of it). + + if ((scalar (keys (%unanimous_tags))) > 1) { + foreach my $utag ((keys (%unanimous_tags))) { + $utag = &xml_escape ($utag); # the usual paranoia + $beauty .= "${utag}\n"; + } + } + if ($common_dir) { + $common_dir = &xml_escape ($common_dir); + $beauty .= "${common_dir}\n"; + } + + # That's enough for XML, time to go home: + return $beauty; + } + + # Else not XML output, so complexly compactify for chordate + # consumption. At this point we have enough global information + # about all the qunks to organize them non-redundantly for output. + + if ($common_dir) { + # Note that $common_dir still has its trailing slash + $beauty .= "$common_dir: "; + } + + if ($Show_Branches) + { + # For trailing revision numbers. + my @brevisions; + + foreach my $branch (keys (%all_branches)) + { + foreach my $qunkref (@qunkrefs) + { + if ((defined ($$qunkref{'branch'})) + and ($$qunkref{'branch'} eq $branch)) + { + if ($fbegun) { + # kff todo: comma-delimited in XML too? Sure. + $beauty .= ", "; + } + else { + $fbegun = 1; + } + my $fname = substr ($$qunkref{'filename'}, length ($common_dir)); + $beauty .= $fname; + $$qunkref{'printed'} = 1; # Just setting a mark bit, basically + + if ($Show_Tags && (defined @{$$qunkref{'tags'}})) { + my @tags = grep ($non_unanimous_tags{$_}, @{$$qunkref{'tags'}}); + if (@tags) { + $beauty .= " (tags: "; + $beauty .= join (', ', @tags); + $beauty .= ")"; + } + } + + if ($Show_Revisions) { + # Collect the revision numbers' last components, but don't + # print them -- they'll get printed with the branch name + # later. + $$qunkref{'revision'} =~ /.+\.([\d]+)$/; + push (@brevisions, $1); + + # todo: we're still collecting branch roots, but we're not + # showing them anywhere. If we do show them, it would be + # nifty to just call them revision "0" on a the branch. + # Yeah, that's the ticket. + } + } + } + $beauty .= " ($branch"; + if (@brevisions) { + if ((scalar (@brevisions)) > 1) { + $beauty .= ".["; + $beauty .= (join (',', @brevisions)); + $beauty .= "]"; + } + else { + $beauty .= ".$brevisions[0]"; + } + } + $beauty .= ")"; + } + } + + # Okay; any qunks that were done according to branch are taken care + # of, and marked as printed. Now print everyone else. + + foreach my $qunkref (@qunkrefs) + { + next if (defined ($$qunkref{'printed'})); # skip if already printed + + if ($fbegun) { + $beauty .= ", "; + } + else { + $fbegun = 1; + } + $beauty .= substr ($$qunkref{'filename'}, length ($common_dir)); + # todo: Shlomo's change was this: + # $beauty .= substr ($$qunkref{'filename'}, + # (($common_dir eq "./") ? "" : length ($common_dir))); + $$qunkref{'printed'} = 1; # Set a mark bit. + + if ($Show_Revisions || $Show_Tags) + { + my $started_addendum = 0; + + if ($Show_Revisions) { + $started_addendum = 1; + $beauty .= " ("; + $beauty .= "$$qunkref{'revision'}"; + } + if ($Show_Tags && (defined $$qunkref{'tags'})) { + my @tags = grep ($non_unanimous_tags{$_}, @{$$qunkref{'tags'}}); + if ((scalar (@tags)) > 0) { + if ($started_addendum) { + $beauty .= ", "; + } + else { + $beauty .= " (tags: "; + } + $beauty .= join (', ', @tags); + $started_addendum = 1; + } + } + if ($started_addendum) { + $beauty .= ")"; + } + } + } + + # Unanimous tags always come last. + if ($Show_Tags && %unanimous_tags) + { + $beauty .= " (utags: "; + $beauty .= join (', ', keys (%unanimous_tags)); + $beauty .= ")"; + } + + # todo: still have to take care of branch_roots? + + $beauty = "* $beauty:"; + + return $beauty; +} + + +sub common_path_prefix () +{ + my $path1 = shift; + my $path2 = shift; + + my ($dir1, $dir2); + (undef, $dir1, undef) = fileparse ($path1); + (undef, $dir2, undef) = fileparse ($path2); + + # Transmogrify Windows filenames to look like Unix. + # (It is far more likely that someone is running cvs2cl.pl under + # Windows than that they would genuinely have backslashes in their + # filenames.) + $dir1 =~ tr#\\#/#; + $dir2 =~ tr#\\#/#; + + my $accum1 = ""; + my $accum2 = ""; + my $last_common_prefix = ""; + + while ($accum1 eq $accum2) + { + $last_common_prefix = $accum1; + last if ($accum1 eq $dir1); + my ($tmp1) = split (/\//, (substr ($dir1, length ($accum1)))); + my ($tmp2) = split (/\//, (substr ($dir2, length ($accum2)))); + $accum1 .= "$tmp1/" if ((defined ($tmp1)) and $tmp1); + $accum2 .= "$tmp2/" if ((defined ($tmp2)) and $tmp2); + } + + return $last_common_prefix; +} + + +sub preprocess_msg_text () +{ + my $text = shift; + + # Strip out carriage returns (as they probably result from DOSsy editors). + $text =~ s/\r\n/\n/g; + + # If it *looks* like two newlines, make it *be* two newlines: + $text =~ s/\n\s*\n/\n\n/g; + + if ($XML_Output) + { + $text = &xml_escape ($text); + $text = "${text}\n"; + } + elsif (! $No_Wrap) + { + # Strip off lone newlines, but only for lines that don't begin with + # whitespace or a mail-quoting character, since we want to preserve + # that kind of formatting. Also don't strip newlines that follow a + # period; we handle those specially next. And don't strip + # newlines that precede an open paren. + 1 while ($text =~ s/(^|\n)([^>\s].*[^.\n])\n([^>\n])/$1$2 $3/g); + + # If a newline follows a period, make sure that when we bring up the + # bottom sentence, it begins with two spaces. + 1 while ($text =~ s/(^|\n)([^>\s].*)\n([^>\n])/$1$2 $3/g); + } + + return $text; +} + + +sub last_line_len () +{ + my $files_list = shift; + my @lines = split (/\n/, $files_list); + my $last_line = pop (@lines); + return length ($last_line); +} + + +# A custom wrap function, sensitive to some common constructs used in +# log entries. +sub wrap_log_entry () +{ + my $text = shift; # The text to wrap. + my $left_pad_str = shift; # String to pad with on the left. + + # These do NOT take left_pad_str into account: + my $length_remaining = shift; # Amount left on current line. + my $max_line_length = shift; # Amount left for a blank line. + + my $wrapped_text = ""; # The accumulating wrapped entry. + my $user_indent = ""; # Inherited user_indent from prev line. + + my $first_time = 1; # First iteration of the loop? + my $suppress_line_start_match = 0; # Set to disable line start checks. + + my @lines = split (/\n/, $text); + while (@lines) # Don't use `foreach' here, it won't work. + { + my $this_line = shift (@lines); + chomp $this_line; + + if ($this_line =~ /^(\s+)/) { + $user_indent = $1; + } + else { + $user_indent = ""; + } + + # If it matches any of the line-start regexps, print a newline now... + if ($suppress_line_start_match) + { + $suppress_line_start_match = 0; + } + elsif (($this_line =~ /^(\s*)\*\s+[a-zA-Z0-9]/) + || ($this_line =~ /^(\s*)\* [a-zA-Z0-9_\.\/\+-]+/) + || ($this_line =~ /^(\s*)\([a-zA-Z0-9_\.\/\+-]+(\)|,\s*)/) + || ($this_line =~ /^(\s+)(\S+)/) + || ($this_line =~ /^(\s*)- +/) + || ($this_line =~ /^()\s*$/) + || ($this_line =~ /^(\s*)\*\) +/) + || ($this_line =~ /^(\s*)[a-zA-Z0-9](\)|\.|\:) +/)) + { + # Make a line break immediately, unless header separator is set + # and this line is the first line in the entry, in which case + # we're getting the blank line for free already and shouldn't + # add an extra one. + unless (($After_Header ne " ") and ($first_time)) + { + if ($this_line =~ /^()\s*$/) { + $suppress_line_start_match = 1; + $wrapped_text .= "\n${left_pad_str}"; + } + + $wrapped_text .= "\n${left_pad_str}"; + } + + $length_remaining = $max_line_length - (length ($user_indent)); + } + + # Now that any user_indent has been preserved, strip off leading + # whitespace, so up-folding has no ugly side-effects. + $this_line =~ s/^\s*//; + + # Accumulate the line, and adjust parameters for next line. + my $this_len = length ($this_line); + if ($this_len == 0) + { + # Blank lines should cancel any user_indent level. + $user_indent = ""; + $length_remaining = $max_line_length; + } + elsif ($this_len >= $length_remaining) # Line too long, try breaking it. + { + # Walk backwards from the end. At first acceptable spot, break + # a new line. + my $idx = $length_remaining - 1; + if ($idx < 0) { $idx = 0 }; + while ($idx > 0) + { + if (substr ($this_line, $idx, 1) =~ /\s/) + { + my $line_now = substr ($this_line, 0, $idx); + my $next_line = substr ($this_line, $idx); + $this_line = $line_now; + + # Clean whitespace off the end. + chomp $this_line; + + # The current line is ready to be printed. + $this_line .= "\n${left_pad_str}"; + + # Make sure the next line is allowed full room. + $length_remaining = $max_line_length - (length ($user_indent)); + + # Strip next_line, but then preserve any user_indent. + $next_line =~ s/^\s*//; + + # Sneak a peek at the user_indent of the upcoming line, so + # $next_line (which will now precede it) can inherit that + # indent level. Otherwise, use whatever user_indent level + # we currently have, which might be none. + my $next_next_line = shift (@lines); + if ((defined ($next_next_line)) && ($next_next_line =~ /^(\s+)/)) { + $next_line = $1 . $next_line if (defined ($1)); + # $length_remaining = $max_line_length - (length ($1)); + $next_next_line =~ s/^\s*//; + } + else { + $next_line = $user_indent . $next_line; + } + if (defined ($next_next_line)) { + unshift (@lines, $next_next_line); + } + unshift (@lines, $next_line); + + # Our new next line might, coincidentally, begin with one of + # the line-start regexps, so we temporarily turn off + # sensitivity to that until we're past the line. + $suppress_line_start_match = 1; + + last; + } + else + { + $idx--; + } + } + + if ($idx == 0) + { + # We bottomed out because the line is longer than the + # available space. But that could be because the space is + # small, or because the line is longer than even the maximum + # possible space. Handle both cases below. + + if ($length_remaining == ($max_line_length - (length ($user_indent)))) + { + # The line is simply too long -- there is no hope of ever + # breaking it nicely, so just insert it verbatim, with + # appropriate padding. + $this_line = "\n${left_pad_str}${this_line}"; + } + else + { + # Can't break it here, but may be able to on the next round... + unshift (@lines, $this_line); + $length_remaining = $max_line_length - (length ($user_indent)); + $this_line = "\n${left_pad_str}"; + } + } + } + else # $this_len < $length_remaining, so tack on what we can. + { + # Leave a note for the next iteration. + $length_remaining = $length_remaining - $this_len; + + if ($this_line =~ /\.$/) + { + $this_line .= " "; + $length_remaining -= 2; + } + else # not a sentence end + { + $this_line .= " "; + $length_remaining -= 1; + } + } + + # Unconditionally indicate that loop has run at least once. + $first_time = 0; + + $wrapped_text .= "${user_indent}${this_line}"; + } + + # One last bit of padding. + $wrapped_text .= "\n"; + + return $wrapped_text; +} + + +sub xml_escape () +{ + my $txt = shift; + $txt =~ s/&/&/g; + $txt =~ s//>/g; + return $txt; +} + + +sub maybe_read_user_map_file () +{ + my %expansions; + + if ($User_Map_File) + { + open (MAPFILE, "<$User_Map_File") + or die ("Unable to open $User_Map_File ($!)"); + + while () + { + next if /^\s*#/; # Skip comment lines. + next if not /:/; # Skip lines without colons. + + # It is now safe to split on ':'. + my ($username, $expansion) = split ':'; + chomp $expansion; + $expansion =~ s/^'(.*)'$/$1/; + $expansion =~ s/^"(.*)"$/$1/; + + # If it looks like the expansion has a real name already, then + # we toss the username we got from CVS log. Otherwise, keep + # it to use in combination with the email address. + + if ($expansion =~ /^\s*<{0,1}\S+@.*/) { + # Also, add angle brackets if none present + if (! ($expansion =~ /<\S+@\S+>/)) { + $expansions{$username} = "$username <$expansion>"; + } + else { + $expansions{$username} = "$username $expansion"; + } + } + else { + $expansions{$username} = $expansion; + } + } + + close (MAPFILE); + } + + return %expansions; +} + + +sub parse_options () +{ + # Check this internally before setting the global variable. + my $output_file; + + # If this gets set, we encountered unknown options and will exit at + # the end of this subroutine. + my $exit_with_admonishment = 0; + + while (my $arg = shift (@ARGV)) + { + if ($arg =~ /^-h$|^-help$|^--help$|^--usage$|^-?$/) { + $Print_Usage = 1; + } + elsif ($arg =~ /^--debug$/) { # unadvertised option, heh + $Debug = 1; + } + elsif ($arg =~ /^--version$/) { + $Print_Version = 1; + } + elsif ($arg =~ /^-g$|^--global-opts$/) { + my $narg = shift (@ARGV) || die "$arg needs argument.\n"; + # Don't assume CVS is called "cvs" on the user's system: + $Log_Source_Command =~ s/(^\S*)/$1 $narg/; + } + elsif ($arg =~ /^-l$|^--log-opts$/) { + my $narg = shift (@ARGV) || die "$arg needs argument.\n"; + $Log_Source_Command .= " $narg"; + } + elsif ($arg =~ /^-f$|^--file$/) { + my $narg = shift (@ARGV) || die "$arg needs argument.\n"; + $output_file = $narg; + } + elsif ($arg =~ /^--accum$/) { + $Cumulative = 1; + } + elsif ($arg =~ /^--fsf$/) { + $FSF_Style = 1; + } + elsif ($arg =~ /^-U$|^--usermap$/) { + my $narg = shift (@ARGV) || die "$arg needs argument.\n"; + $User_Map_File = $narg; + } + elsif ($arg =~ /^-W$|^--window$/) { + my $narg = shift (@ARGV) || die "$arg needs argument.\n"; + $Max_Checkin_Duration = $narg; + } + elsif ($arg =~ /^-I$|^--ignore$/) { + my $narg = shift (@ARGV) || die "$arg needs argument.\n"; + push (@Ignore_Files, $narg); + } + elsif ($arg =~ /^-C$|^--case-insensitive$/) { + $Case_Insensitive = 1; + } + elsif ($arg =~ /^-R$|^--regexp$/) { + my $narg = shift (@ARGV) || die "$arg needs argument.\n"; + $Regexp_Gate = $narg; + } + elsif ($arg =~ /^--stdout$/) { + $Output_To_Stdout = 1; + } + elsif ($arg =~ /^--version$/) { + $Print_Version = 1; + } + elsif ($arg =~ /^-d$|^--distributed$/) { + $Distributed = 1; + } + elsif ($arg =~ /^-P$|^--prune$/) { + $Prune_Empty_Msgs = 1; + } + elsif ($arg =~ /^-S$|^--separate-header$/) { + $After_Header = "\n\n"; + } + elsif ($arg =~ /^--no-wrap$/) { + $No_Wrap = 1; + } + elsif ($arg =~ /^--gmt$|^--utc$/) { + $UTC_Times = 1; + } + elsif ($arg =~ /^-w$|^--day-of-week$/) { + $Show_Day_Of_Week = 1; + } + elsif ($arg =~ /^-r$|^--revisions$/) { + $Show_Revisions = 1; + } + elsif ($arg =~ /^-t$|^--tags$/) { + $Show_Tags = 1; + } + elsif ($arg =~ /^-b$|^--branches$/) { + $Show_Branches = 1; + } + elsif ($arg =~ /^-F$|^--follow$/) { + my $narg = shift (@ARGV) || die "$arg needs argument.\n"; + push (@Follow_Branches, $narg); + } + elsif ($arg =~ /^--stdin$/) { + $Input_From_Stdin = 1; + } + elsif ($arg =~ /^--header$/) { + my $narg = shift (@ARGV) || die "$arg needs argument.\n"; + $ChangeLog_Header = &slurp_file ($narg); + if (! defined ($ChangeLog_Header)) { + $ChangeLog_Header = ""; + } + } + elsif ($arg =~ /^--xml$/) { + $XML_Output = 1; + } + elsif ($arg =~ /^--hide-filenames$/) { + $Hide_Filenames = 1; + $After_Header = ""; + } + else { + # Just add a filename as argument to the log command + $Log_Source_Command .= " $arg"; + } + } + + ## Check for contradictions... + + if ($Output_To_Stdout && $Distributed) { + print STDERR "cannot pass both --stdout and --distributed\n"; + $exit_with_admonishment = 1; + } + + if ($Output_To_Stdout && $output_file) { + print STDERR "cannot pass both --stdout and --file\n"; + $exit_with_admonishment = 1; + } + + if ($XML_Output && $Cumulative) { + print STDERR "cannot pass both --xml and --accum\n"; + $exit_with_admonishment = 1; + } + + # Or if any other error message has already been printed out, we + # just leave now: + if ($exit_with_admonishment) { + &usage (); + exit (1); + } + elsif ($Print_Usage) { + &usage (); + exit (0); + } + elsif ($Print_Version) { + &version (); + exit (0); + } + + ## Else no problems, so proceed. + + if ($output_file) { + $Log_File_Name = $output_file; + } +} + + +sub slurp_file () +{ + my $filename = shift || die ("no filename passed to slurp_file()"); + my $retstr; + + open (SLURPEE, "<${filename}") or die ("unable to open $filename ($!)"); + my $saved_sep = $/; + undef $/; + $retstr = ; + $/ = $saved_sep; + close (SLURPEE); + return $retstr; +} + + +sub debug () +{ + if ($Debug) { + my $msg = shift; + print STDERR $msg; + } +} + + +sub version () +{ + print "cvs2cl.pl version ${VERSION}; distributed under the GNU GPL.\n"; +} + + +sub usage () +{ + &version (); + print <<'END_OF_INFO'; +Generate GNU-style ChangeLogs in CVS working copies. + +Notes about the output format(s): + + The default output of cvs2cl.pl is designed to be compact, formally + unambiguous, but still easy for humans to read. It is largely + self-explanatory, I hope; the one abbreviation that might not be + obvious is "utags". That stands for "universal tags" -- a + universal tag is one held by all the files in a given change entry. + + If you need output that's easy for a program to parse, use the + --xml option. Note that with XML output, just about all available + information is included with each change entry, whether you asked + for it or not, on the theory that your parser can ignore anything + it's not looking for. + +Notes about the options and arguments (the actual options are listed +last in this usage message): + + * The -I and -F options may appear multiple times. + + * To follow trunk revisions, use "-F trunk" ("-F TRUNK" also works). + This is okay because no would ever, ever be crazy enough to name a + branch "trunk", right? Right. + + * For the -U option, the UFILE should be formatted like + CVSROOT/users. That is, each line of UFILE looks like this + jrandom:jrandom@red-bean.com + or maybe even like this + jrandom:'Jesse Q. Random ' + Don't forget to quote the portion after the colon if necessary. + + * Many people want to filter by date. To do so, invoke cvs2cl.pl + like this: + cvs2cl.pl -l "-d'DATESPEC'" + where DATESPEC is any date specification valid for "cvs log -d". + (Note that CVS 1.10.7 and below requires there be no space between + -d and its argument). + +Options/Arguments: + + -h, -help, --help, or -? Show this usage and exit + --version Show version and exit + -r, --revisions Show revision numbers in output + -b, --branches Show branch names in revisions when possible + -t, --tags Show tags (symbolic names) in output + --stdin Read from stdin, don't run cvs log + --stdout Output to stdout not to ChangeLog + -d, --distributed Put ChangeLogs in subdirs + -f FILE, --file FILE Write to FILE instead of "ChangeLog" + --fsf Use this if log data is in FSF ChangeLog style + -W SECS, --window SECS Window of time within which log entries unify + -U UFILE, --usermap UFILE Expand usernames to email addresses from UFILE + -R REGEXP, --regexp REGEXP Include only entries that match REGEXP + -I REGEXP, --ignore REGEXP Ignore files whose names match REGEXP + -C, --case-insensitive Any regexp matching is done case-insensitively + -F BRANCH, --follow BRANCH Show only revisions on or ancestral to BRANCH + -S, --separate-header Blank line between each header and log message + --no-wrap Don't auto-wrap log message (recommend -S also) + --gmt, --utc Show times in GMT/UTC instead of local time + --accum Add to an existing ChangeLog (incompat w/ --xml) + -w, --day-of-week Show day of week + --header FILE Get ChangeLog header from FILE ("-" means stdin) + --xml Output XML instead of ChangeLog format + --hide-filenames Don't show filenames (ignored for XML output) + -P, --prune Don't show empty log messages + -g OPTS, --global-opts OPTS Invoke like this "cvs OPTS log ..." + -l OPTS, --log-opts OPTS Invoke like this "cvs ... log OPTS" + FILE1 [FILE2 ...] Show only log information for the named FILE(s) + +See http://www.red-bean.com/cvs2cl for maintenance and bug info. +END_OF_INFO +} + +__END__ + +=head1 NAME + +cvs2cl.pl - produces GNU-style ChangeLogs in CVS working copies, by + running "cvs log" and parsing the output. Shared log entries are + unified in an intuitive way. + +=head1 DESCRIPTION + +This script generates GNU-style ChangeLog files from CVS log +information. Basic usage: just run it inside a working copy and a +ChangeLog will appear. It requires repository access (i.e., 'cvs log' +must work). Run "cvs2cl.pl --help" to see more advanced options. + +See http://www.red-bean.com/cvs2cl for updates, and for instructions +on getting anonymous CVS access to this script. + +Maintainer: Karl Fogel +Please report bugs to . + +=head1 README + +This script generates GNU-style ChangeLog files from CVS log +information. Basic usage: just run it inside a working copy and a +ChangeLog will appear. It requires repository access (i.e., 'cvs log' +must work). Run "cvs2cl.pl --help" to see more advanced options. + +See http://www.red-bean.com/cvs2cl for updates, and for instructions +on getting anonymous CVS access to this script. + +Maintainer: Karl Fogel +Please report bugs to . + +=head1 PREREQUISITES + +This script requires C, C, and +C. +It also seems to require C or higher. + +=pod OSNAMES + +any + +=pod SCRIPT CATEGORIES + +Version_Control/CVS + +=cut + + +-*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- + +Note about a bug-slash-opportunity: +----------------------------------- + +There's a bug in Text::Wrap, which affects cvs2cl. This script +reveals it: + + #!/usr/bin/perl -w + + use Text::Wrap; + + my $test_text = + "This script demonstrates a bug in Text::Wrap. The very long line + following this paragraph will be relocated relative to the surrounding + text: + + ==================================================================== + + See? When the bug happens, we'll get the line of equal signs below + this paragraph, even though it should be above."; + + + # Print out the test text with no wrapping: + print "$test_text"; + print "\n"; + print "\n"; + + # Now print it out wrapped, and see the bug: + print wrap ("\t", " ", "$test_text"); + print "\n"; + print "\n"; + +If the line of equal signs were one shorter, then the bug doesn't +happen. Interesting. + +Anyway, rather than fix this in Text::Wrap, we might as well write a +new wrap() which has the following much-needed features: + +* initial indentation, like current Text::Wrap() +* subsequent line indentation, like current Text::Wrap() +* user chooses among: force-break long words, leave them alone, or die()? +* preserve existing indentation: chopped chunks from an indented line + are indented by same (like this line, not counting the asterisk!) +* optional list of things to preserve on line starts, default ">" + +Note that the last two are essentially the same concept, so unify in +implementation and give a good interface to controlling them. + +And how about: + +Optionally, when encounter a line pre-indented by same as previous +line, then strip the newline and refill, but indent by the same. +Yeah... diff --git a/ndb/home/bin/cvschk b/ndb/home/bin/cvschk new file mode 100755 index 00000000000..4510cc30888 --- /dev/null +++ b/ndb/home/bin/cvschk @@ -0,0 +1,569 @@ +#!/usr/bin/perl -w +# +# cvschk -- fast offline check for new files and modifications of files + +# cvschk : A perl program which checks the status of the CVS controlled +# files and gives an ASCII table sorted after the status of files. +# +# If you have used CVS, then you know that it is hard to +# get a good overview the CVS-status of the files in you +# directories. Any new files? Any files changes? +# cvschk will help the programmer get the overview in the +# situation, where we do not have access to the CVS repository. +# +# Note that the program does only local checks of the files +# If you have fast access to the CVS repositiory, then consider +# the cvsstat-program - which additionally can tell if other +# people have made newer versions of the files. +# +# The program requires Perl 5.004 (maybe previous versions also work). +# +# It is tuned to parse the output of cvs(1) version 1.9. +# Earlier and later versions may require modifications to the script. +# +# ** Note that the first line might be wrong depending ** +# ** on the location of your perl program. ** +# +# Sample output: +# The directory ./mytempdir is not under CVS control +# +# Changed files +# --------------- +# ./cvs2html +# ./cvschk +# ./cvsstat +# +# New files +# --------------- +# ./.#cvschk +# ./XX +# ./cvs2html.ok +# +# Deleted files +# --------------- +# (none) + +# Changelog: +# +# Ver Date Author Changelog +# --- ---------- -------------------- ------------------------------------- +# 1.12 2002-01-04 Michael Kohne Fixed a $foo=<> warning for +# 5.004_01 with defined($foo=<>) +# Added a --tabular|-t switch +# +# 1.11 2001-12-27 Michael Kohne Added cvsignore functionality +# Handling of 'dummy timestamp' +# Handling of 'Result of Merge' +# +# 1.10 2001-11-06 Michael Kohne Added -r and -l options +# +# 1.9 2001-08-03 Lars G. T. Jørgensen Hack to allow special entry-line +# +# 1.8 2001-06-07 Peter Toft Back to the same as 1.6 +# CVS is my friend +# +# 1.7 2001-06-04 Peter Toft Peter was very tired and +# applied a wrong patch - +# version 1.7 is crap +# +# 1.6 2000-12-17 Peter Toft Better description added +# +# 1.5 2000-11-04 Peter Toft URL of cvsstat changed +# +# 1.4 2000-09-20 Peter Toft Must show deleted files also +# as the default +# +# 1.3 2000-08-08 Ole Tange and Initial version +# Peter Toft +# ---- ---------- -------------------- ------------------------------------- +# +# ----------------------------------------------------------------------------- +# +# This program is protected by the GPL, and all modifications of +# general interest should be emailed to the maintainer (pto@sslug.dk). +# +# This program also uses code parts from cvsstat +# (same homepage as cvschk) +# +# Copyright 2000,2001 by Peter Toft and Ole Tange +# as well as +# Lars G. T. Jørgensen +# +# The URL of the home page of cvschk is shown below. + + +use Time::Local; +use strict; +use Getopt::Long; + +my $startdir = "."; + +my $debug = 0; +my (%files,%filesok,%seen,%skip); + + +# Michael Kohne 12/16/01 +# +# Simulation of .cvsignore as CVS does it... +# +# using .cvsignore handling makes cvschk take from 2 to 3 times +# longer to run over the same set of files. +# in my tests, disabling cvsignore altogether, cvschk takes .2 +# seconds on my working directory. Adding cvsignore,takes +# .4 seconds. +# Note that I do not use individual .cvsignore files - if there +# are a lot of them in your directory tree, it will add run time +# +# variables used for .cvsignore handling +my $initcvsignoreregex;# regex holding all startup cvsignore pattersn (no ()) +my $cvsignoreregex;# one regex holding all current cvsignore patterns +my $disable_cvsignore=0;# set to 1 to disable cvsignore emulation + # (available in case it's REALLY screwed up) +my $disable_ind_cvsignore=0;# set to 1 to disable finding .cvsignore files + # in each directory. +my $debug_cvsignore = 0; # For debugging .cvsignore problems + +my %mon; +@mon{qw(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec)}= + 0..11; # Perl months are 0 .. 11 + +my ($version) = ('$Revision: 1.12 $ ' =~ /^\$\w+: (.*) \$ $/); +my $URL = "http://cvs.sslug.dk/cvs2html"; +my $version_line = "cvschk version $version (see $URL)\n"; + +my $opt_all; +my $restrict; +my $local; +my $tabular; + +my $opt_restrict; + +sub show_version {print $version_line} + +sub die_version {die $version_line} + +sub die_usage { + my $bundled = ($] > 5.00399 + ? "can be bundled" + : "can't be bundled, because your Perl is too old"); + die < 5.00399) { # This requires 5.004, so silently skip it for older Perls. + eval {Getopt::Long::config("bundling")}; # avoid 5.003 compilation error + warn $@ if $@; # For Perl 5.004+ we do want to see any compilation error +} + + +GetOptions( "all|a" => \$opt_all, + "tabular|t" => \$tabular, + "restrict|r" => \$restrict, + "local|l" => \$local, + "help|h" => \&die_help, + "debug|d" => \$debug, + "version|V" => \&die_version, + ) or die_usage; + +sub cvs_changed_in_dir($); #define prototype (for recursion) + +# functions for .cvsignore handling + +# converts a given filename pattern +# (of the sort that sh(1) takes) to +# a perl regex of similar meaning. +# +# It works by doing the following: +# +# change: +# . to \. +# $ to \$ +# * to .* +# ? to . +# +sub fpat_to_regex($) +{ + my $fexp; + $fexp = shift; + $fexp =~ s/\./\\\./g;#change . to \. + $fexp =~ s/\$/\\\$/g;#change dollar sign to \dollar sign + $fexp =~ s/\*/.*/g;# change * to .* + $fexp =~ s/\?/./g; # change ? to . + return $fexp; +} + +# copy the input list to one single regex, +# items seperated by | symbols. +# return the regex string +sub do_regex_convert +{ + my $rx = ""; + my $first = 1;#true for first element only + + + # convert each element of cvsignore into a regex + # this makes the patterns usable in perl + my $cp; + foreach $cp (@_) { + if (not $first) { $rx = $rx . "|"; } + if ($first) { $first = 0; } + $rx = $rx . fpat_to_regex($cp); + } + + return $rx; +} + +# first parameter is a reference to the array +# to be loaded +# the rest of the parameters are just items +# that need to be loaded into the array. +# Note that if a ! is found, the list is +# emptied, then further items are added. +# returns true if a ! was found +sub load_list_from_list +{ + my $arref = shift;# get reference to array from front + my $item; + my $ret=0;#false means no ! found + + chomp @_;#kill newlines + foreach $item (@_) { + $item =~ s/^\s*(.*?)\s*$/$1/;#kill leading/trailing whitespace + if ($item) { # empty string is false + push @$arref,$item; + } + if ($item eq "!") { + @$arref = ();# '!' causes list to clear + $ret = 1;# ! found + } + } + + return $ret; +} + +# loads the given list with lines from the +# specified file. Note that if a '!' is found +# all prior patterns are removed from the list +# before the following patterns are loaded +# first param is the filename, +# second param is a reference to an array +# that the data is to go into +# returns true if a ! was found +sub load_list_from_file +{ + my @inlist; + my $fname = shift;#filename to read from + #if (not -e $fname) { return; } + my $arref = shift;#array to store into + open CVSIGNORE,"$fname" or return;#file might not exist, that's OK + @inlist = ; + close CVSIGNORE; + return load_list_from_list($arref,@inlist); +} + +# loads $cvsignoreregex from +# $initcvsignoreregex and the .cvsignore file +# in the local directory +sub load_cvsignore +{ + if ($disable_ind_cvsignore) {return;}#don't look for local .cvsignore files + if ($disable_cvsignore) {return;}#don't do anything + + my $dir = shift; + my @cvsignore; + + # bang will be true if a ! was found. In such cases, I need + # to not use the pre-exisitng regex list. + my $bang = load_list_from_file("$dir/.cvsignore",\@cvsignore); + + # if we get a local cvsignore list, then... + my $rx = do_regex_convert(@cvsignore); + if ($rx) { + $cvsignoreregex = "("; + if (not $bang) {$cvsignoreregex = $cvsignoreregex . $initcvsignoreregex . "|";} + $cvsignoreregex = $cvsignoreregex . $rx . ")"; + } else { + if ($bang) {$cvsignoreregex = "";} + else {$cvsignoreregex = "(" . $initcvsignoreregex . ")";} + } + + if ($debug_cvsignore) {print $dir,":",$cvsignoreregex, "\n";} +} + + +# loads all of the cvsignore patterns that +# can be loaded at script startup +sub load_initial_cvsignore() +{ + #load the default patterns + # (taken from http://www.gnu.org/manual/cvs-1.9/html_node/cvs_141.html#IDX399) + # + # this gives you the patterns that cvs normally starts with + my @initcvsignore; + push @initcvsignore,("RCS"); + push @initcvsignore,("SCCS"); + push @initcvsignore,("CVS"); + push @initcvsignore,("CVS.adm"); + push @initcvsignore,("RCSLOG"); + push @initcvsignore,("cvslog.*"); + push @initcvsignore,("tags"); + push @initcvsignore,("TAGS"); + push @initcvsignore,(".make.state"); + push @initcvsignore,(".nse_depinfo"); + push @initcvsignore,("*~"); + push @initcvsignore,("\#*"); + push @initcvsignore,(".\#*"); + push @initcvsignore,("\,*"); + push @initcvsignore,("_\$\*"); + push @initcvsignore,("*\$"); + push @initcvsignore,("*.old"); + push @initcvsignore,("*.bak"); + push @initcvsignore,("*.BAK"); + push @initcvsignore,("*.orig"); + push @initcvsignore,("*.rej"); + push @initcvsignore,(".del-*"); + push @initcvsignore,("*.a"); + push @initcvsignore,("*.olb"); + push @initcvsignore,("*.o"); + push @initcvsignore,("*.obj"); + push @initcvsignore,("*.so"); + push @initcvsignore,("*.exe"); + push @initcvsignore,("*.Z"); + push @initcvsignore,("*.elc"); + push @initcvsignore,("*.ln"); + push @initcvsignore,("core"); + + + # now, load (in proper order!) + # each of the possible cvsignore files + + # there are 4 possible .cvsignore files: + + # $CVSROOT/CVSROOT/cvsignore + # ~/.cvsignore + # $CVSIGNORE environment variable + # .cvsignore in current directory + + # The first (CVSROOT/cvsignore) would require calling cvs, so + # we won't do that one. + # The last (.cvsignore in current directory) is done + # for each directory. It's handled in the load_cvsignore routine. + + # ~/.cvsignore + my @inlist; + my $item; + my $HOME=$ENV{"HOME"}; + if (not $HOME) {$HOME = ".";} + load_list_from_file("$HOME/.cvsignore",\@initcvsignore); + + # $CVSIGNORE environment variable + my $igstr = $ENV{"CVSIGNORE"}; # get env var + if ($igstr) { + my @iglist = split(/\s+/, $igstr); #if it exists, convert to list + load_list_from_list(\@initcvsignore,@iglist); + } + + # now that @initcvsignore is setup, + # turn it into a regex string + $initcvsignoreregex = do_regex_convert(@initcvsignore); + + # now preset the cvsignore regex string to match + # @initcvsignore. That way, if we aren't using local + # cvsignore files, we do nothing. + $cvsignoreregex = "(" . $initcvsignoreregex . ")"; +} +# routine to see if the given name is in the cvsignore regex +# returns true if it is, false if it's not +sub ignore_file($) +{ + #allow user to disable the cvsignore stuff + if ($disable_cvsignore) {return 0;} + if (not $cvsignoreregex) {return 0;}# if regex is empty, nothing matches the regex + my $filename = shift; + + if ($debug_cvsignore) {print "ignore_file:",$filename,"\n";} + + if ($filename =~ $cvsignoreregex) { + if ($debug_cvsignore) {print $filename," matches\n";} + return 1; + } + + if ($debug_cvsignore) {print $filename," doesn't match\n";} + return 0; +} + +sub cvs_changed_in_dir($) { + my $dir = shift; + + my ($line,$filename,$version,$mtime,$date, + $dir_filename,$cvstime,@subdirs, + @new_in_dir,$i); + + # Examine status of files in CVS/Entries + if(not open(ENTRIES,"$dir/CVS/Entries")) { + if ($tabular) { + push @{$files{Unknown}}, $dir; + } + else { + warn "The directory $dir is not under CVS control\n"; + } + } else { + load_cvsignore($dir);#load up proper cvsignore for given directory + + while(defined ($line=)) { + # Parse CVS/Entries-line + $line=~m!^/(.*)/(.*)/(.*)/.*/! or do { + $debug and warn("Skipping entry-line $line"); + next; + }; + ($filename,$version,$date) = ($1,$2,$3); + $dir_filename=$dir."/".$filename; + + # Mark this file as seen + $seen{$dir_filename}=1; + + # if not exists: Deleted + if(not -e $dir_filename) { + push @{$files{Deleted}}, $dir_filename; next; + } + # if dir: save name for recursion + -d $dir_filename and do { + push @subdirs, $dir_filename; next; + }; + + # modification time of $dir_filename + $mtime= (stat $dir_filename)[9]; + + + if($date eq "dummy timestamp") { + # dummy timestamp means it's new to the repository. + push @{$files{Changed}}, $dir_filename; + if ($debug) { + print "$dir_filename is changed\n"; + } + } + elsif($date eq "Result of merge") { + # result of merge means it's changed, then updated. + push @{$files{Changed}}, $dir_filename; + if ($debug) { + print "$dir_filename is changed\n"; + } + } + elsif(not + $date=~/... (...)\s+(\d+)\s+(\d+):(\d+):(\d+) (\d{4})/) + { + #bogus entry in Entires + warn "Warning: $dir_filename -> '$date' ". + "not in ctime(3) format\n"; + } else { + $cvstime=timegm($5,$4,$3,$2,$mon{$1},$6); + if($cvstime != $mtime) { + push @{$files{Changed}}, $dir_filename; + if ($debug) { + print "$dir_filename is changed\n"; + } + } else { + push @{$files{Unchanged}}, $dir_filename; + if ($debug) { + print "$dir_filename is Unchanged\n"; + } + } + } + } + close ENTRIES; + + # Locate any new files/dirs + if(not opendir(D,$dir)) { + warn("Cannot open $dir"); + @new_in_dir= (); + } else { + @skip{qw(. .. CVS)}=1..3; # Filenames that that we want to ignore + #(note: these are exact filenames) + @new_in_dir= + (grep { not $seen{$_} } # files we have not already processed + map { $dir."/".$_ } # map from file to dir/file + grep { not ignore_file($_) } # ignore files in the cvsignore list + grep { not $skip{$_} } # skip files to be ignored + readdir(D)); + closedir(D); + } + + # Remember new files (actually non-directories) + push @{$files{New}}, grep { not -d $_ } @new_in_dir; + if ($debug) { print "@{$files{New}} are new in $dir\n"; } + + # Remember new subdirs + push @subdirs, grep { -d $_ } @new_in_dir; + + # Recurse all subdirs + if (not $local) { + for $i (@subdirs) { cvs_changed_in_dir($i); } + } + } +} + +sub print_status() +{ + my $k; + my %show_these_states = ("Changed" => 1); + if(not $restrict) { + $show_these_states{"New"} = 1; + $show_these_states{"Deleted"} = 1; + } + + if($opt_all) { $show_these_states{"Unchanged"} = 1; } + + if ($tabular) { + my %allfiles; # key: filesname, value: state + my ($file, $state, $statefiles); + + $show_these_states{"Unknown"} = 1; + while (($state, $statefiles) = each %files) { + for my $f (@{$statefiles}) { + $allfiles{$f} = $state; + } + } + for $file (sort keys %allfiles) { + $state = $allfiles{$file}; + printf("%-10s %s\n", $state, $file) if $show_these_states{$state}; + } + } + else { + print "\n"; + for $k (keys %show_these_states) { + if(not $files{$k} or not @{$files{$k}}) { + # no files + $files{$k}=["(none)"]; + } + print("$k files\n", + "---------------\n", + map { "$_\n" } sort @{$files{$k}}); + print "\n"; + } + } +} + +load_initial_cvsignore(); +if ($debug_cvsignore) {print "initial regex:",$cvsignoreregex,"\n";} +cvs_changed_in_dir($startdir); +print_status(); + diff --git a/ndb/home/bin/fix-cvs-root b/ndb/home/bin/fix-cvs-root new file mode 100755 index 00000000000..2c4f158f825 --- /dev/null +++ b/ndb/home/bin/fix-cvs-root @@ -0,0 +1,17 @@ +#! /bin/sh + +# change all CVS/Root to current CVSROOT + +[ "$CVSROOT" ] || { echo "no CVSROOT in environment" >&2; exit 1; } + +echo "changing all CVS/Root files under `pwd`" +sleep 1 + +find . -path '*/CVS/Root' -print | +while read file; do + echo "$file" + chmod +w $file || exit 1 + echo $CVSROOT >$file || exit 1 +done + +echo "done" diff --git a/ndb/home/bin/import-from-bk.sh b/ndb/home/bin/import-from-bk.sh new file mode 100755 index 00000000000..4e3957be6d5 --- /dev/null +++ b/ndb/home/bin/import-from-bk.sh @@ -0,0 +1,158 @@ +#! /bin/sh + +# XXX does not delete files +# XXX does not handle nested new dirs +# this script screams for perl, no time now +# look for bk2cvs on the net + +PATH=/usr/local/bin:$PATH; export PATH +LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH; export LD_LIBRARY_PATH + +batch=n +if [ "$1" = "-batch" ]; then + batch=y + shift +fi + +say() { + echo "$*" +} + +die() { + case $# in + 0) set -- "command failed" ;; + esac + say "$* -- aborted" >&2 + exit 1 +} + +usage() { + die "usage: $0 [-batch] top -- copy from mysql/ndb to another NDB_TOP" +} + +doit() { + cmd="$*" + if [ $batch = n ]; then + echo -n "$cmd [y]" + read junk + sh -c "$cmd" + return 0 + else + echo "$cmd" + sh -c "$cmd" + return $? + fi +} + +say "======================" +say "`date`" + +case $# in +1) [ -d $1/src/CVS ] || die "$1 is not an NDB_TOP" + top=$1 ;; +*) usage ;; +esac + +if ! fgrep ndb_kernel_version.h $top/include/kernel/CVS/Entries >/dev/null 2>&1; then + die "$top is not an NDB_TOP" +fi + +if find $top -path '*/CVS/Tag' -print | grep . >/dev/null; then + die "$top: contains CVS/Tag files, not accepted" +fi + +if [ ! -f include/SCCS/s.ndb_version.h ]; then + die "current dir ($PWD) is not an NDB_TOP" +fi + +doit "bk pull" || exit 1 +doit "bk -r clean" +doit "bk -r get -q" + +files=`bk -r. sfiles -g | + fgrep -v ' ' | + fgrep -v /.cvsignore` + +n=0 +files2= +for f in $files; do + if [ ! -f $f ]; then + die "$f: no such file" + fi + if [ -w $f ]; then + say "$f: is writable, accept anyway" + fi + files2="$files2 $f" + n=$((n+1)) +done +files=$files2 +say "$n files..." + +adddirs= addfiles= updfiles= +for f in $files; do + d=`dirname $f` + b=`basename $f` + if [ ! -f $top/$d/CVS/Entries ]; then + found=n + for x in $adddirs; do + if [ $x = $d ]; then found=y; break; fi + done + if [ $found = n ]; then + say "$d: to create dir" + adddirs="$adddirs $d" + fi + addfiles="$addfiles $f" + say "$f: to create" + elif ! fgrep "/$b/" $top/$d/CVS/Entries >/dev/null; then + addfiles="$addfiles $f" + say "$f: to create" + else + cmp $f $top/$f >/dev/null + case $? in + 0) continue ;; + 1) ;; + *) die "$f: unknown error" ;; + esac + updfiles="$updfiles $f" + say "$f: to update" + fi +done + +for d in $adddirs; do + doit "cd $top && mkdir -p $d" || die +done + +for f in $addfiles $updfiles; do + doit "cp -fp $f $top/$f" || die +done + +for d in $adddirs; do + # fix 1 level up + d2=`dirname $d` + if [ ! -d $top/$d2/CVS ]; then + doit "cd $top && cvs add $d2" || die + fi + doit "cd $top && cvs add $d" || die +done + +for f in $addfiles; do + kb= + if echo $f | perl -nle "print(-B $_)" | grep 1 >/dev/null; then + kb="-kb" + fi + doit "cd $top && cvs add $kb $f" || die +done + +tag=import_bk_`date +%Y_%m_%d` + +doit "cd $top && cvs commit -m $tag" || die +doit "cd $top && cvs tag -F $tag" || die + +env="NDB_TOP=$top; export NDB_TOP" +env="$env; USER_FLAGS='-DAPI_TRACE -fmessage-length=0'; export USER_FLAGS" +doit "$env; cd $top && ./configure" +doit "$env; cd $top && sh config/GuessConfig.sh" +doit "$env; cd $top && make clean nuke-deps vim-tags" +doit "$env; cd $top && make" || die + +say "imported ok" diff --git a/ndb/home/bin/ndb_deploy b/ndb/home/bin/ndb_deploy new file mode 100755 index 00000000000..773fc9b8fd7 --- /dev/null +++ b/ndb/home/bin/ndb_deploy @@ -0,0 +1,27 @@ +#!/bin/sh + +if [ $# -eq 0 ] +then + for i in $DEPLOY_DST + do + rsync -r -v --exclude '*.a' $NDB_TOP/bin $NDB_TOP/lib $i/ + done +else + while [ $# -gt 0 ] + do + arg=$1 + shift; + if [ `echo $arg | grep -c lib` -eq 0 ] + then + dst=bin/ + else + dst=lib/ + fi + + for i in $DEPLOY_DST + do + rsync -v $arg $i/$dst + done + done +fi + diff --git a/ndb/home/bin/ndbdoxy.pl b/ndb/home/bin/ndbdoxy.pl new file mode 100755 index 00000000000..89b7de8440e --- /dev/null +++ b/ndb/home/bin/ndbdoxy.pl @@ -0,0 +1,184 @@ +#!/usr/local/bin/perl +# +# ndbdoxy.pl Executes doxygen on a checked out version of NDB Cluster +# +# Written by Lars Thalmann, 2003. + +use strict; +umask 000; + +# ----------------------------------------------------------------------------- +# Settings +# ----------------------------------------------------------------------------- + +my $root = "/home/elathal/public_html/cvsdoxy"; + +$ENV{LD_LIBRARY_PATH} = "/usr/local/lib:/opt/as/local/lib"; +$ENV{LD_LIBRARY_PATH} = $ENV{LD_LIBRARY_PATH} . ":/opt/as/forte6/SUNWspro/lib"; +$ENV{PATH} = $ENV{PATH} . ":/usr/local/bin:/opt/as/local/bin"; +$ENV{PATH} = $ENV{PATH} . ":/opt/as/local/teTeX/bin/sparc-sun-solaris2.8"; + +my $DOXYGEN = "doxygen"; +my $PDFLATEX = "pdflatex"; +my $MAKEINDEX = "makeindex"; + +# ----------------------------------------------------------------------------- +# Argument handling +# ----------------------------------------------------------------------------- + +if (@ARGV != 3) { + print< <version> + + where + <module> is cvsdoxy module to doxgenify + <title> is title of report + <version> is version of NDB Cluster +END + exit; +} +my $module = $ARGV[0]; +my $title = $ARGV[1]; +my $version = $ARGV[2]; +my $destdir = "."; + +# ----------------------------------------------------------------------------- +# Execute Doxygen -g +# ----------------------------------------------------------------------------- + +if (-r "${root}/doxyfiles/${module}.doxyfile") { + system("cd ${destdir}; \ + cp ${root}/doxyfiles/${module}.doxyfile Doxyfile"); +} elsif (-r "${root}/doxyfiles/default.doxyfile") { + system("cd ${destdir}; \ + cp ${root}/doxyfiles/default.doxyfile Doxyfile"); +} else { + system("cd ${destdir}; $DOXYGEN -g"); +} + +# ----------------------------------------------------------------------------- +# HTML Footer +# ----------------------------------------------------------------------------- + +if (-r "${root}/doxyfiles/htmlfooter") { + system("cd ${destdir}; \ + cp ${root}/doxyfiles/htmlfooter footer.html"); + + open (INFILE, "< ${destdir}/footer.html") + or die "Error opening ${destdir}/footer.html.\n"; + open (OUTFILE, "> ${destdir}/footer.html.new") + or die "Error opening ${destdir}/footer.html.new.\n"; + while (<INFILE>) { + if (/(.*)DATE(.*)$/) { + print OUTFILE $1 . localtime() . $2; + } else { + print OUTFILE; + } + } + close INFILE; + close OUTFILE; + + system("mv ${destdir}/footer.html.new ${destdir}/footer.html"); +} else { + print("Warning: No ${root}/doxyfiles/${module}.htmlfooter"); +} + +# ----------------------------------------------------------------------------- +# Execute Doxygen +# ----------------------------------------------------------------------------- + +system("cd ${destdir}; $DOXYGEN"); + +# ----------------------------------------------------------------------------- +# Change a little in refman.tex +# ----------------------------------------------------------------------------- + +open (INFILE, "< ${destdir}/latex/refman.tex") + or die "Error opening ${destdir}/latex/refman.tex.\n"; +open (OUTFILE, "> ${destdir}/latex/refman.tex.new") + or die "Error opening ${destdir}/latex/refman.tex.new.\n"; + +while (<INFILE>) +{ + if (/(.*)Reference Manual(.*)$/) { + print OUTFILE $1 . + "\\mbox{}\\vspace{-3cm}\\mbox{}" . + "\\hrule\\bigskip\\bigskip\\bigskip\\bigskip" . + "\\Huge{" . $title . "}" . $2; + } elsif (/(.*)Generated by Doxygen 1.2.1[0-9](.*)$/) { + print OUTFILE $1 . + "\\begin{center}" . + "\\LARGE{MySQL AB}" . + "\\end{center}". + "\\hfill\\bigskip\\bigskip\\bigskip\\hrule" . + "\\bigskip\\bigskip\\bigskip\\bigskip\\bigskip" . + "\\bigskip\\bigskip\\bigskip\\bigskip\\bigskip" . + "\\bigskip\\bigskip NDB Cluster Release " . $version . + "\\bigskip\\bigskip\\bigskip\\bigskip\\bigskip\\hfill" . + $2; + } elsif (/\\chapter\{File Index\}/) { + print OUTFILE "\%\\chapter{File Index}\n"; + } elsif (/\\input{files}/) { + print OUTFILE "\%\\input{files}\n"; + } elsif (/\\chapter\{Page Index\}/) { + print OUTFILE "\%\\chapter{Page Index}\n"; + } elsif (/\\input{pages}/) { + print OUTFILE "\%\\input{pages}\n"; + } else { + print OUTFILE; + } +} + +close INFILE; +close OUTFILE; + +system("mv ${destdir}/latex/refman.tex.new ${destdir}/latex/refman.tex"); + +# ----------------------------------------------------------------------------- +# Change a little in doxygen.sty +# ----------------------------------------------------------------------------- + +open (INFILE, "< ${destdir}/latex/doxygen.sty") + or die "Error opening INFILE.\n"; +open (OUTFILE, "> ${destdir}/latex/doxygen.sty.new") + or die "Error opening OUTFILE.\n"; + +while (<INFILE>) +{ + if (/\\rfoot/) { + print OUTFILE "\\rfoot[\\fancyplain{}{\\bfseries\\small \\copyright~Copyright 2003 MySQL AB\\hfill support-cluster\@mysql.com}]{}\n"; + } elsif (/\\lfoot/) { + print OUTFILE "\\lfoot[]{\\fancyplain{}{\\bfseries\\small support-cluster\@mysql.com\\hfill \\copyright~Copyright 2003 MySQL AB}}\n"; + } else { + print OUTFILE; + } +} + +close INFILE; +close OUTFILE; + +system("mv ${destdir}/latex/doxygen.sty.new ${destdir}/latex/doxygen.sty"); + +# ----------------------------------------------------------------------------- +# Other +# ----------------------------------------------------------------------------- + +#system("cd ${root}/tmp/${module}; \ +# mkdir html.tar; \ +# cd html.tar; \ +# cp -r ../html ${module}; \ +# tar cf ${module}.html.tar ${module}; \ +# /usr/local/bin/gzip ${module}.html.tar; \ +# /bin/rm -rf ${root}/tmp/${module}/html.tar/${module}"); + +#system("cd ${destdir}/latex/; \ +# $PDFLATEX refman.tex \ +# $MAKEINDEX refman.idx \ +# $PDFLATEX refman.tex \ +# mv -f refman.pdf ${module}.pdf"); + +print<<END; +Execute: + latex refman; makeindex refman; latex refman +END diff --git a/ndb/home/bin/ngcalc b/ndb/home/bin/ngcalc new file mode 100755 index 00000000000..a289d384db9 --- /dev/null +++ b/ndb/home/bin/ngcalc @@ -0,0 +1,78 @@ +#! /usr/local/bin/perl + +use strict; +use Getopt::Long; + +sub usage { + print <<END; +ngcalc -- calculate node groups and table fragments +usage: ngcalc [ options ] f1 f2 ... +-g num number of node groups (default 2) +-r num number of replicas (default 2) +-n list comma-separated list of db nodes (default 1,2,...) +fX number of fragments per node group in table X (e.g. 1,2,8) + (all replicas count as same fragment) +END + exit(1); +}; + +use vars qw($cnoOfNodeGroups $cnoReplicas $nodeArray); + +$cnoOfNodeGroups = 2; +$cnoReplicas = 2; +GetOptions( + "g=i" => \$cnoOfNodeGroups, + "r=i" => \$cnoReplicas, + "n=s" => \$nodeArray, +) or &usage; + +my @tableList = @ARGV; + +$cnoOfNodeGroups > 0 or &usage; +$cnoReplicas > 0 or &usage; +if (! defined($nodeArray)) { + $nodeArray = join(',', 1..($cnoOfNodeGroups*$cnoReplicas)); +} +$nodeArray =~ /^\d+(,\d+)*$/ or &usage; +my @nodeArray = split(/,/, $nodeArray); +@nodeArray == $cnoOfNodeGroups*$cnoReplicas or &usage; + +my @nodeGroupRecord; +for (my $i = 0; $i < $cnoOfNodeGroups; $i++) { + my $rec = {}; + my $nodes = []; + for (my $j = 0; $j < $cnoReplicas; $j++) { + push(@$nodes, $nodeArray[$i * $cnoReplicas + $j]); + } + $rec->{nodesInGroup} = $nodes; + $rec->{nodeCount} = $cnoReplicas; + $rec->{nextReplicaNode} = 0; + $nodeGroupRecord[$i] = $rec; + print "NG $i: ", join(" ", @{$rec->{nodesInGroup}}), "\n"; +} + +# see Dbdih::execCREATE_FRAGMENTATION_REQ + +my $c_nextNodeGroup = 0; +for (my $t = 0; $t < @tableList; $t++) { + use integer; + my $f = $tableList[$t]; + my $ng = $c_nextNodeGroup++; + $c_nextNodeGroup = 0 if $c_nextNodeGroup == $cnoOfNodeGroups; + my $noOfFragments = $f * $cnoOfNodeGroups; + my @fragments; + for (my $fragNo = 0; $fragNo < $noOfFragments; $fragNo++) { + my $rec = $nodeGroupRecord[$ng]; + my $max = $rec->{nodeCount}; + my $ind = $rec->{nextReplicaNode}; + $rec->{nextReplicaNode} = ($ind + 1 >= $max ? 0 : $ind + 1); + for (my $replicaNo = 0; $replicaNo < $cnoReplicas; $replicaNo++) { + my $nodeId = $rec->{nodesInGroup}[$ind++]; + push(@fragments, $nodeId); + $ind = ($ind == $max ? 0 : $ind); + } + $ng++; + $ng = ($ng == $cnoOfNodeGroups ? 0 : $ng); + } + printf "%02d %s\n", $t, join(" ", @fragments); +} diff --git a/ndb/home/bin/signallog2html.lib/signallog2list.awk b/ndb/home/bin/signallog2html.lib/signallog2list.awk new file mode 100644 index 00000000000..9839f314556 --- /dev/null +++ b/ndb/home/bin/signallog2html.lib/signallog2list.awk @@ -0,0 +1,102 @@ +BEGIN{ + PRINT=0; + SIGNAL_ARRAY[0]=""; + BLOCK_ID=0; + SIGNAL_ID=-22; +} +{ + SIGNAL_ARRAY[SIGNAL_ID]=SIGNAL_ID; +} + +/^---- Send ----- Signal ----------------/ { + DIRECTION="S"; + SENDER=""; + SENDPROCESS=""; + RECEIVER=""; + RECPROCESS=""; + SIGNAL=""; + RECSIGID="?"; + SIGID="?"; + DELAY="N/A"; +} + +/^---- Send delay Signal/ { + DIRECTION="SD"; + SENDER=""; + SENDPROCESS=""; + RECEIVER=""; + RECPROCESS=""; + SIGNAL=""; + RECSIGID="?"; + SIGID="?"; + DELAY=$5; + + LEN=length(DELAY); + DELAY=substr(DELAY,2,LEN); +} + +/^---- Received - Signal ----------------/ { + DIRECTION="R"; + SENDER=""; + SENDPROCESS=""; + RECEIVER=""; + RECPROCESS=""; + SIGNAL=""; + RECSIGID="?"; + SIGID="?"; + DELAY="N/A"; +} + +/r.bn:/{ + + RECEIVER=$3; + RECPROCESS=$5; + + if(DIRECTION == "R"){ + SIGNAL=$10; + RECSIGID=$7; + } + else + SIGNAL=$8; +} + +/s.bn:/{ + + SENDER=$3; + SIGID=$7; + + if(SIGID == SIGNAL_ARRAY[SIGID]){ + PRINT=1; + if(DIRECTION == "R"){ + SIGNAL_ARRAY[RECSIGID]=RECSIGID; + }; + } + + SENDPROCESS=$5; + + LEN=length(RECEIVER); + RECEIVER=substr(RECEIVER,2,LEN-3); + + if(BLOCK_ID == "ALL" || RECEIVER==BLOCK_ID){PRINT=1; } + + LEN=length(SENDER); + SENDER=substr(SENDER,2,LEN-3); + if(BLOCK_ID == "ALL" || SENDER == BLOCK_ID){ PRINT=1;} + + LEN=length(SIGNAL); + SIGNAL=substr(SIGNAL,2,LEN-2); + + LEN=length(SENDPROCESS); + SENDPROCESS=substr(SENDPROCESS,1,LEN-1); + + LEN=length(RECPROCESS); + RECPROCESS=substr(RECPROCESS,1,LEN-1); + + if( PRINT == 1){ + print DIRECTION" "SENDPROCESS" "SENDER" "RECPROCESS" "RECEIVER" "SIGNAL" "SIGID" "RECSIGID" "DELAY; + } + + PRINT=0; +} + + diff --git a/ndb/home/bin/signallog2html.lib/uniq_blocks.awk b/ndb/home/bin/signallog2html.lib/uniq_blocks.awk new file mode 100644 index 00000000000..43f48d1cde1 --- /dev/null +++ b/ndb/home/bin/signallog2html.lib/uniq_blocks.awk @@ -0,0 +1,29 @@ +BEGIN{ + NAMES[""]=""; + ORDER[0]=""; + NUM=0; +} + +{ + if(NAMES[$2$3]!=$2$3){ + NAMES[$2$3]=$2$3; + ORDER[NUM]=$2$3; + NUM++; + } + + if(NAMES[$4$5]!=$4$5){ + NAMES[$4$5]=$4$5; + ORDER[NUM]=$4$5; + NUM++; + } + + +} +END{ + for(i=0; i<NUM; i++){ + LIST=ORDER[i]" "LIST; + + } + print LIST; +} + diff --git a/ndb/home/bin/signallog2html.sh b/ndb/home/bin/signallog2html.sh new file mode 100755 index 00000000000..5665275807c --- /dev/null +++ b/ndb/home/bin/signallog2html.sh @@ -0,0 +1,349 @@ +#!/bin/sh +# NAME +# signallog2html.sh +# +# SYNOPSIS +# signallog2html.sh [ -b <block_name | ALL> ] [ -s <signal_id> ] -f signal_log_file +# +# DESCRIPTION +# Creates a signal sequence diagram in HTML format that can be +# viewed from a web browser. The HTML file is created from a signal +# log file and it contains a big table with jpeg files in every +# table cell. Every row in the table is a signal. The block_name +# could be one of the following: CMVMI MISSRA NDBFS NDBCNTR DBACC +# DBDICT DBLQH DBDIH DBTC DBTUP QMGR ALL. The signal_id is a +# number. If no block_name or signal_id is given the default +# block_name "ALL" is used. +# +# +# +# OPTIONS +# +# EXAMPLES +# +# +# ENVIRONMENT +# NDB_PROJ_HOME Home dir for ndb +# +# FILES +# $NDB_PROJ_HOME/lib/funcs.sh General shell script functions. +# uniq_blocks.awk Creates a list of unique blocks +# in the signal_log_file. +# signallog2list.awk Creates a list file from the signal_log_file. +# empty.JPG Jpeg file, must exist in the HTML file +# directory for viewing. +# left_line.JPG +# line.JPG +# right_line.JPG +# self_line.JPG +# +# +# SEE ALSO +# +# DIAGNOSTICTS +# +# VERSION +# 1.0 +# +# DATE +# 011029 +# +# AUTHOR +# Jan Markborg +# + +progname=`basename $0` +synopsis="signallog2html.sh [ -b <block_name | ALL> ] [ -s <signal_id> ] -f signal_log_file" +block_name="" +signal_id="" +verbose=yes +signal_log_file="" + +: ${NDB_PROJ_HOME:?} # If undefined, exit with error message + +: ${NDB_LOCAL_BUILD_OPTIONS:=--} # If undef, set to --. Keeps getopts happy. + # You may have to experiment a bit + # to get quoting right (if you need it). + + +. $NDB_PROJ_HOME/lib/funcs.sh # Load some good stuff + +# defaults for options related variables +# +report_date=`date '+%Y-%m-%d'` + +# Option parsing for the the command line. +# + +while getopts f:b:s: i +do + case $i in + f) signal_log_file=$OPTARG;; + b) block_name=$OPTARG;; + s) signal_id=$OPTARG;; + \?) syndie ;; # print synopsis and exit + esac +done + +# -- Verify +trace "Verifying signal_log_file $signal_log_file" + +if [ x$signal_log_file = "x" ] +then + syndie "Invalid signal_log_file name: $signal_log_file not found" +fi + + +if [ ! -r $signal_log_file ] +then + syndie "Invalid signal_log_file name: $signal_log_file not found" +fi + + + +if [ blocknameSET = 1 ] +then + + trace "Verifying block_name" + case $block_name in + CMVMI| MISSRA| NDBFS| NDBCNTR| DBACC| DBDICT| DBLQH| DBDIH| DBTC| DBTUP| QMGR);; + ALL) trace "Signals to/from every block will be traced!";; + *) syndie "Unknown block name: $block_name";; + esac +fi + +if [ block_name="" -a signal_id="" ] +then + block_name=ALL + trace "block_name = $block_name" +fi + +trace "Arguments OK" + +### +# +# General html functions +header(){ + cat <<EOF +<html><head><title>$* + +EOF +} + +footer(){ + cat < +EOF +} + +heading(){ + h=$1; shift + cat <$* +EOF +} + +table(){ + echo "
" +} + +table_header(){ + echo "" +} + +end_table(){ + echo "
$*
" +} + +row(){ + echo "" +} + +end_row(){ + echo "" +} + +c_column(){ + cat <$* +EOF +} + +bold(){ + cat <$* +EOF +} + +column(){ + cat <$* +EOF +} + +para(){ + cat <

+EOF +} + +hr(){ + cat < +EOF +} + +img_column(){ + cat <
<$* height=100% width=100%>
+EOF +} + +# Check the direction of arrow. +# arrowDirection(){ $columnarray $sendnode$sendblock $recnode$recblock +arrowDirection(){ +if [ $2 = $3 ] +then + arrow=SELF + return; +else + for x in $1 + do + if [ $x = $2 ] + then + arrow=RIGHT + break + elif [ $x = $3 ] + then + arrow=LEFT + break + fi + done +fi +} + +drawImages(){ +for x in $columnarray +do + case $arrow in + SELF) + if [ $x = $sendnode$sendblock ] + then + img_column img SRC=\"self_line.JPG\" + else + img_column img SRC=\"empty.JPG\" + fi;; + + RIGHT) + if [ $x = $recnode$recblock ] + then + img_column img SRC=\"right_line.JPG\" + weHavePassedRec=1 + elif [ $x = $sendnode$sendblock ] + then + img_column img SRC=\"empty.JPG\" + weHavePassedSen=1 + elif [ $weHavePassedRec = 1 -o $weHavePassedSen = 0 ] + then + img_column img SRC=\"empty.JPG\" + elif [ $weHavePassedRec = 0 -a $weHavePassedSen = 1 ] + then + img_column img SRC=\"line.JPG\" + fi;; + + LEFT) + if [ $x = $recnode$recblock ] + then + img_column img SRC=\"empty.JPG\" + weHaveJustPassedRec=1 + weHavePassedRec=1 + continue + fi + if [ $x = $sendnode$sendblock -a $weHaveJustPassedRec = 1 ] + then + img_column img SRC=\"left_line.JPG\" + weHaveJustPassedRec=0 + weHavePassedSen=1 + continue + fi + if [ $x = $sendnode$sendblock ] + then + img_column img SRC=\"line.JPG\" + weHavePassedSen=1 + continue + fi + if [ $weHaveJustPassedRec = 1 ] + then + img_column img SRC=\"left_line.JPG\" + weHaveJustPassedRec=0 + continue + fi + if [ $weHavePassedSen = 1 -o $weHavePassedRec = 0 ] + then + img_column img SRC=\"empty.JPG\" + continue + fi + + if [ $weHavePassedRec = 1 -a $weHavePassedSen = 0 ] + then + img_column img SRC=\"line.JPG\" + continue + + fi + column ERROR;; + + *) + echo ERROR;; + esac +done +column $signal +} + +### Main +trace "Making HTML file" +( + header "Signal sequence diagram $report_date" + heading 1 "Signal sequence diagram $report_date" + + trace "Making list file" + #make a signal list file from the signal log file. + `awk -f /home/ndb/bin/signallog2html.lib/signallog2list.awk SIGNAL_ID=$signal_id BLOCK_ID=$block_name $signal_log_file > $signal_log_file.list` + + COLUMNS=`awk -f /home/ndb/bin/signallog2html.lib/uniq_blocks.awk $signal_log_file.list | wc -w` + + table "border=0 cellspacing=0 cellpadding=0 cols=`expr $COLUMNS + 1`" + + columnarray=`awk -f /home/ndb/bin/signallog2html.lib/uniq_blocks.awk $signal_log_file.list` + + row + column #make an empty first column! + for col in $columnarray + do + table_header $col + done + + grep "" $signal_log_file.list | \ + while read direction sendnode sendblock recnode recblock signal sigid recsigid delay + do + if [ $direction = "R" ] + then + row + weHavePassedRec=0 + weHavePassedSen=0 + weHaveJustPassedRec=0 + arrow="" + + # calculate the direction of the arrow. + arrowDirection "$columnarray" "$sendnode$sendblock" "$recnode$recblock" + + # Draw the arrow images. + drawImages + end_row + fi + done + end_table + + footer +) > $signal_log_file.html + +exit 0 diff --git a/ndb/home/bin/stripcr b/ndb/home/bin/stripcr new file mode 100755 index 00000000000..540418f88cf --- /dev/null +++ b/ndb/home/bin/stripcr @@ -0,0 +1,90 @@ +#!/bin/sh + + +# NAME +# stripcr - a program for removing carriage return chars from dos-files. +# +# SYNOPSIS +# stripcr [file...] +# +# DESCRIPTION +# stripcr deletes all CR characters from the given files. +# The files are edited in place. +# If no files are given, stdin and stdout are used instead. +# +# OPTIONS +# -s extension Make a copy of the original of each file, and +# give it the given extension (.bak, .orig, -bak, ...). +# +# EXAMPLES +# stripcr file.txt innerloop.cc +# stripcr -i.bak *.cc +# +# ENVIRONMENT +# NDB_PROJ_HOME Home dir for ndb +# +# FILES +# $NDB_PROJ_HOME/lib/funcs.sh Some userful functions for safe execution +# of commands, printing, and tracing. +# +# VERSION +# 1.0 +# +# AUTHOR +# Jonas Mölsä +# + + +progname=`basename $0` +synopsis="stripcr [-s extension] [file...]" + + +: ${NDB_PROJ_HOME:?} # If undefined, exit with error message + +: ${STRIPCR_OPTIONS:=--} # If undefined, set to --, to keep getopts happy. + # You may have to experiment, to get quoting right. + +. $NDB_PROJ_HOME/lib/funcs.sh + + +# defaults for options related variables +# +extension= +options="$STRIPCR_OPTIONS" + +# used if error when parsing the options environment variable +# +env_opterr="options environment variable: <<$options>>" + + + +# We want to be able to set options in an environment variable, +# as well as on the command line. In order not to have to repeat +# the same getopts information twice, we loop two times over the +# getopts while loop. The first time, we process options from +# the options environment variable, the second time we process +# options from the command line. +# +# The things to change are the actual options and what they do. +# +# +for optstring in "$options" "" # 1. options variable 2. cmd line +do + while getopts s: i $optstring # optstring empty => no arg => cmd line + do + case $i in + + s) extension="$OPTARG";; + \?) syndie $env_opterr;; # print synopsis and exit + + esac + done + + [ -n "$optstring" ] && OPTIND=1 # Reset for round 2, cmd line options + + env_opterr= # Round 2 should not use the value +done +shift `expr $OPTIND - 1` + + +safe perl -i$extension -lpe 'tr/\r//d' $* diff --git a/ndb/include/debugger/DebuggerNames.hpp b/ndb/include/debugger/DebuggerNames.hpp new file mode 100644 index 00000000000..cf9b1b57226 --- /dev/null +++ b/ndb/include/debugger/DebuggerNames.hpp @@ -0,0 +1,71 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DEBUGGER_NAMES +#define DEBUGGER_NAMES + +#include +#include + +/** + * getSignalName + * + * NOTES: Very quick + * + * RETURNS: Signal name or 0 if none found + */ +const char * +getSignalName(GlobalSignalNumber gsn, const char * defualtValue = "Unknown"); + +/** + * getGsn + * + * NOTES: Very slow + * + * RETURNS: Gsn or 0 if none found + */ +GlobalSignalNumber +getGsn(const char * signalName); + +/** + * getBlockName + * + * NOTES: Very quick + * + * RETURNS: Block name or + * defValue if not a valid block number + */ +const char * +getBlockName(BlockNumber blockNo, const char * defValue = 0); + +/** + * getBlockNo + * + * NOTES: Very slow + * + * RETURNS: BlockNo or 0 if none found + */ +BlockNumber +getBlockNo(const char * blockName); + +/** + * Find a print function for a signal + * + * RETURNS: 0 if none found + */ +SignalDataPrintFunction findPrintFunction(GlobalSignalNumber); + +#endif diff --git a/ndb/include/debugger/EventLogger.hpp b/ndb/include/debugger/EventLogger.hpp new file mode 100644 index 00000000000..c49bd176ee8 --- /dev/null +++ b/ndb/include/debugger/EventLogger.hpp @@ -0,0 +1,234 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef EVENTLOGGER_H +#define EVENTLOGGER_H + +#include +#include +#include +#include +#include +#include + +/** + * The EventLogger is primarily used for logging NDB events + * in the Management Server. It inherits all logging functionality of Logger. + * + * HOW TO USE + * + * 1) Create an EventLogger + * + * EventLogger myEventLogger = new EventLogger(); + * + * 2) Log NDB events and other log messages. + * + * myEventLogger->info("Changing log levels."); + * + * EventReport* report = (EventReport*)&theSignalData[0]; + * myEventLogger->log(eventReport->getEventType(), theSignalData, aNodeId); + * + * + * The following NDB event categories and log levels are enabled as default: + * + * EVENT-CATEGORY LOG-LEVEL + * + * Startup 4 + * Shutdown 1 + * Statistic 2 + * Checkpoint 5 + * NodeRestart 8 + * Connection 2 + * Error 15 + * Info 10 + * + * @see Logger + * @version #@ $Id: EventLogger.hpp,v 1.3 2003/09/01 10:15:52 innpeno Exp $ + */ +class EventLogger : public Logger +{ +public: + /** + * Default constructor. Enables default log levels and + * sets the log category to 'EventLogger'. + */ + EventLogger(); + + /** + * Destructor. + */ + ~EventLogger(); + + /** + * Open/create the eventlog, the default name is 'cluster.log'. + * + * @return true if successful. + */ + bool open(); + + /** + * Opens/creates the eventlog with the specified filename. + * + * @param aFileName the eventlog filename. + * @param maxNoFiles the maximum no of archived eventlog files. + * @param maxFileSize the maximum eventlog file size. + * @param maxLogEntries the maximum number of log entries before + * checking time to archive. + * @return true if successful. + */ + bool open(const char* logFileName, + int maxNoFiles = FileLogHandler::MAX_NO_FILES, + long int maxFileSize = FileLogHandler::MAX_FILE_SIZE, + unsigned int maxLogEntries = FileLogHandler::MAX_LOG_ENTRIES); + + /** + * Closes the eventlog. + */ + void close(); + + /** + * Logs the NDB event. + * + * @param nodeId the node id of event origin. + * @param eventType the type of event. + * @param theData the event data. + * @deprecated use log(int eventType, const Uint32* theData, NodeId nodeId) + */ + void log(NodeId nodeId, int eventType, const Uint32* theData); + + /** + * Logs the NDB event. + * + * @param eventType the type of event. + * @param theData the event data. + * @param nodeId the node id of event origin. + */ + void log(int eventType, const Uint32* theData, NodeId nodeId = 0); + + /** + * Returns the current log levels. + * Enable, disable log levels to filter the events that are sent to the + * eventlog. + * + * @return the log level. + */ + LogLevel& getLoglevel(); + + /** + * Returns the log level that is used to filter an event. The event will not + * be logged unless its event category's log level is <= levelFilter. + * + * @return the log level filter that is used for all event categories. + */ + int getFilterLevel() const; + /** + * Sets log level filter. The event will be logged if + * the event category's log level is <= 'filterLevel'. + * + * @param level the log level to filter. + */ + void setFilterLevel(int filterLevel); + + /** + * Returns the event text for the specified event report type. + * + * @param type the event type. + * @param theData the event data. + * @param nodeId a node id. + * @return the event report text. + */ + static const char* getText(int type, + const Uint32* theData, NodeId nodeId = 0); + + /** + * Find a category matching the string + * + * @param str string to match. + * @param cat the event category. + * @param exactMatch only do exact matching. + * + * @return TRUE if match is found, then cat is modified + * FALSE if match is not found + */ + static bool matchEventCategory(const char * str, + LogLevel::EventCategory * cat, + bool exactMatch = false); + + /** + * Returns category name or NULL if not found. + * + * @param cat the event category. + * @return category name. + */ + static const char * getEventCategoryName(LogLevel::EventCategory cat); + + /** + * Specifies allowed event categories/log levels. + */ + struct EventCategoryName { + LogLevel::EventCategory category; + const char * name; + }; + + static const EventCategoryName eventCategoryNames[]; + static const Uint32 noOfEventCategoryNames; + + /** + * This matrix defines which event should be printed when + * + * threshold - is in range [0-15] + * severity - DEBUG to ALERT (Type of log message) + */ + struct EventRepLogLevelMatrix { + EventReport::EventType eventType; + LogLevel::EventCategory eventCategory; + Uint32 threshold; + Logger::LoggerLevel severity; + }; + + static const EventRepLogLevelMatrix matrix[]; + + /** + * Default log levels for management nodes. + * + * threshold - is in range [0-15] + */ + struct EventLogMatrix { + LogLevel::EventCategory eventCategory; + Uint32 threshold; + }; + + static const EventLogMatrix defEventLogMatrix[]; + + + static const Uint32 matrixSize; + static const Uint32 defEventLogMatrixSize; + +private: + /** Prohibit */ + EventLogger(const EventLogger&); + EventLogger operator = (const EventLogger&); + bool operator == (const EventLogger&); + + LogLevel m_logLevel; + Uint32 m_filterLevel; + + STATIC_CONST(MAX_TEXT_LENGTH = 256); + static char m_text[MAX_TEXT_LENGTH]; +}; + + +#endif diff --git a/ndb/include/debugger/GrepError.hpp b/ndb/include/debugger/GrepError.hpp new file mode 100644 index 00000000000..ab6a7b272a5 --- /dev/null +++ b/ndb/include/debugger/GrepError.hpp @@ -0,0 +1,94 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef GREP_ERROR_H +#define GREP_ERROR_H + +#include + +/** + * + */ +class GrepError { +public: + enum Code { + NO_ERROR = 0, + SUBSCRIPTION_ID_NOMEM = 1, + SUBSCRIPTION_ID_NOT_FOUND = 2, + SUBSCRIPTION_ID_NOT_UNIQUE = 3, + SUBSCRIPTION_ID_SUMA_FAILED_CREATE = 4, + SUBSCRIPTION_ID_ALREADY_EXIST = 5, + COULD_NOT_ALLOCATE_MEM_FOR_SIGNAL = 6, + NULL_VALUE = 7, + SEQUENCE_ERROR = 8, + NOSPACE_IN_POOL= 9, + SUBSCRIPTION_NOT_FOUND = 10, + + NF_FakeErrorREF = 11, + + // Error that the user can get when issuing commands + SUBSCRIPTION_NOT_STARTED = 100, + START_OF_COMPONENT_IN_WRONG_STATE, + START_ALREADY_IN_PROGRESS, + ILLEGAL_STOP_EPOCH_ID, + WRONG_NO_OF_SECTIONS, + ILLEGAL_ACTION_WHEN_STOPPING, + ILLEGAL_USE_OF_COMMAND, + CHANNEL_NOT_STOPPABLE, + + // subscriber releated 20 - 30 + SUBSCRIBER_NOT_FOUND = 20, + + //SUMA specific 400 - 600 + SELECTED_TABLE_NOT_FOUND = 400, + SELECTED_TABLE_ALREADY_ADDED = 401, + + //REP ERRORS starts at 1000 + REP_NO_CONNECTED_NODES = 1001, + REP_DELETE_NEGATIVE_EPOCH = 1002, + REP_DELETE_NONEXISTING_EPOCH = 1003, + REP_APPLY_LOGRECORD_FAILED = 1012, + REP_APPLY_METARECORD_FAILED = 1013, + REP_APPLY_NONCOMPLETE_GCIBUFFER = 1004, + REP_APPLY_NULL_GCIBUFFER = 1005, + REP_APPLIER_START_TRANSACTION = 1006, + REP_APPLIER_NO_TABLE = 1007, + REP_APPLIER_NO_OPERATION = 1007, + REP_APPLIER_EXECUTE_TRANSACTION = 1008, + REP_APPLIER_CREATE_TABLE = 1009, + REP_APPLIER_PREPARE_TABLE = 1010, + REP_DISCONNECT = 1011, + REQUESTOR_ILLEGAL_STATE_FOR_SLOWSTOP = 1200, + REQUESTOR_ILLEGAL_STATE_FOR_FASTSTOP = 1201, + REP_NOT_PROPER_TABLE = 1202, + REP_TABLE_ALREADY_SELECTED = 1203, + REP_TABLE_NOT_FOUND = 1204, + + NOT_YET_IMPLEMENTED, + NO_OF_ERROR_CODES + }; + + struct ErrorDescription { + Code errCode; + const char * name; + }; + static const ErrorDescription errorDescriptions[]; + static const Uint32 noOfErrorDescs; + static const char * getErrorDesc(GrepError::Code err); + +}; + +#endif diff --git a/ndb/include/debugger/SignalLoggerManager.hpp b/ndb/include/debugger/SignalLoggerManager.hpp new file mode 100644 index 00000000000..cf777505399 --- /dev/null +++ b/ndb/include/debugger/SignalLoggerManager.hpp @@ -0,0 +1,169 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +//**************************************************************************** +// +// .NAME +// SignalLoggerManager - Handle signal loggers +// +//**************************************************************************** +#ifndef SignalLoggerManager_H +#define SignalLoggerManager_H + + +#include +#include +#include +#include + +class SignalLoggerManager +{ +public: + SignalLoggerManager(); + virtual ~SignalLoggerManager(); + + /** + * Sets output + * @Returns old output stream + */ + FILE * setOutputStream(FILE * output); + + /** + * Gets current output + */ + FILE * getOutputStream() const; + + void flushSignalLog(); + + /** + * For direct signals + * @See also SimulatedBlock EXECUTE_DIRECT + */ + void executeDirect(const SignalHeader&, + Uint8 prio, const Uint32 * theData, Uint32 node); + + /** + * For input signals + */ + void executeSignal(const SignalHeader&, Uint8 prio, + const Uint32 * theData, Uint32 node, + const SegmentedSectionPtr ptr[3], Uint32 secs); + + void executeSignal(const SignalHeader&, Uint8 prio, + const Uint32 * theData, Uint32 node, + const LinearSectionPtr ptr[3], Uint32 secs); + + /** + * For output signals + */ + void sendSignal(const SignalHeader&, Uint8 prio, + const Uint32 * theData, Uint32 node, + const SegmentedSectionPtr ptr[3], Uint32 secs); + + void sendSignal(const SignalHeader&, Uint8 prio, + const Uint32 * theData, Uint32 node, + const LinearSectionPtr ptr[3], Uint32 secs); + + /** + * For output signals + */ + void sendSignalWithDelay(Uint32 delayInMilliSeconds, + const SignalHeader&, + Uint8 prio, const Uint32 * data, Uint32 node, + const SegmentedSectionPtr ptr[3], Uint32 secs); + + /** + * Generic messages in the signal log + */ + void log(BlockNumber bno, const char * msg); + + /** + * LogModes + */ + enum LogMode { + LogOff = 0, + LogIn = 1, + LogOut = 2, + LogInOut = 3 + }; + + /** + * Returns no of loggers affected + */ + int log(LogMode logMode, const char * params); + int logOn(bool allBlocks, BlockNumber bno, LogMode logMode); + int logOff(bool allBlocks, BlockNumber bno, LogMode logMode); + int logToggle(bool allBlocks, BlockNumber bno, LogMode logMode); + + void setTrace(unsigned long trace); + unsigned long getTrace() const; + + /** + * Print header + */ + static void printSignalHeader(FILE * output, + const SignalHeader & sh, + Uint8 prio, + Uint32 node, + bool printReceiversSignalId); + + /** + * Function for printing the Signal Data + */ + static void printSignalData(FILE * out, + const SignalHeader & sh, const Uint32 *); + + /** + * Print linear section. + */ + static void printLinearSection(FILE * output, + const SignalHeader & sh, + const LinearSectionPtr ptr[3], + unsigned i); + + /** + * Print segmented section. + */ + static void printSegmentedSection(FILE * output, + const SignalHeader & sh, + const SegmentedSectionPtr ptr[3], + unsigned i); + + /** + * Print data word in hex. Adds line break before the word + * when pos > 0 && pos % 7 == 0. Increments pos. + */ + static void printDataWord(FILE * output, Uint32 & pos, const Uint32 data); + +private: + FILE * outputStream; + int log(int cmd, BlockNumber bno, LogMode logMode); + + Uint32 traceId; + Uint8 logModes[NO_OF_BLOCKS]; + + inline bool + logMatch(BlockNumber bno, LogMode mask) + { + // avoid addressing outside logModes + return + bno < MIN_BLOCK_NO || bno > MAX_BLOCK_NO || + (logModes[bno-MIN_BLOCK_NO] & mask); + } +}; + +#endif // SignalLoggerManager_H + diff --git a/ndb/include/editline/editline.h b/ndb/include/editline/editline.h new file mode 100644 index 00000000000..2757e385968 --- /dev/null +++ b/ndb/include/editline/editline.h @@ -0,0 +1,38 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* $Id: editline.h,v 1.1 2002/12/11 13:53:46 hin Exp $ */ + +/* + * Public include file for editline, to be included instead of readline.h + */ + +#ifndef __EDITLINE_H_INCLUDED__ +#define __EDITLINE_H_INCLUDED__ + +#ifdef __cplusplus +extern "C" { +#endif + +extern char *readline(const char *); +extern void add_history(char *); + +#ifdef __cplusplus +} +#endif + +#endif /* !__EDITLINE_H_INCLUDED__ */ + diff --git a/ndb/include/kernel/AttributeDescriptor.hpp b/ndb/include/kernel/AttributeDescriptor.hpp new file mode 100644 index 00000000000..071d45e2607 --- /dev/null +++ b/ndb/include/kernel/AttributeDescriptor.hpp @@ -0,0 +1,250 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ATTRIBUTE_DESCRIPTOR_HPP +#define ATTRIBUTE_DESCRIPTOR_HPP + +class AttributeDescriptor { + friend class Dbdict; + friend class Dbtup; + friend class Dbtux; + +private: + static void setType(Uint32 &, Uint32 type); + static void setSize(Uint32 &, Uint32 size); + static void setArray(Uint32 &, Uint32 arraySize); + static void setOriginal(Uint32 &, Uint32 original); + static void setNullable(Uint32 &, Uint32 nullable); + static void setDGroup(Uint32 &, Uint32 dgroup); + static void setDKey(Uint32 &, Uint32 dkey); + static void setPrimaryKey(Uint32 &, Uint32 dkey); + static void setStoredInTup(Uint32 &, Uint32 storedInTup); + static void setDynamic(Uint32 &, Uint32 dynamicInd); + + static Uint32 getType(const Uint32 &); + static Uint32 getSize(const Uint32 &); + static Uint32 getSizeInWords(const Uint32 &); + static Uint32 getArrayType(const Uint32 &); + static Uint32 getArraySize(const Uint32 &); + static Uint32 getOriginal(const Uint32 &); + static Uint32 getNullable(const Uint32 &); + static Uint32 getDGroup(const Uint32 &); + static Uint32 getDKey(const Uint32 &); + static Uint32 getPrimaryKey(const Uint32 &); + static Uint32 getStoredInTup(const Uint32 &); + static Uint32 getDynamic(const Uint32 &); +}; + +/** + * + * a = Array type - 2 Bits -> Max 3 (Bit 0-1) + * t = Attribute type - 2 Bits -> Max 3 (Bit 2-3) + * s = Attribute size - 3 Bits -> Max 7 (Bit 4-6) + * o = Original attribute - 1 Bit 7 + * n = Nullable - 1 Bit 8 + * ? = Stored in tup - 1 Bit 9 + * d = Disk based - 1 Bit 10 + * g = Distribution Group Ind- 1 Bit 11 + * k = Distribution Key Ind - 1 Bit 12 + * r = Distribution group sz - 1 Bit 13 + * p = Primary key attribute - 1 Bit 14 + * y = Dynamic attribute - 1 Bit 15 + * z = Array size - 16 Bits -> Max 65535 (Bit 16-31) + * + * 1111111111222222222233 + * 01234567890123456789012345678901 + * aattsss n dgkrpyzzzzzzzzzzzzzzzz + * + */ + +#define AD_ARRAY_TYPE_SHIFT (0) +#define AD_ARRAY_TYPE_MASK (3) + +#define AD_TYPE_SHIFT (2) +#define AD_TYPE_MASK (3) + +#define AD_SIZE_SHIFT (4) +#define AD_SIZE_MASK (7) + +#define AD_SIZE_IN_WORDS_OFFSET (31) +#define AD_SIZE_IN_WORDS_SHIFT (5) + +#define AD_ORIGINAL_SHIFT (8) +#define AD_NULLABLE_SHIFT (8) +#define AD_TUP_STORED_SHIFT (9) + +#define AD_DISTR_GROUP_SHIFT (11) +#define AD_DISTR_KEY_SHIFT (12) +#define AD_DISTR_GROUP_SZ (13) +#define AD_PRIMARY_KEY (14) +#define AD_DYNAMIC (15) + +#define AD_ARRAY_SIZE_SHIFT (16) +#define AD_ARRAY_SIZE_MASK (65535) + +inline +void +AttributeDescriptor::setType(Uint32 & desc, Uint32 type){ + ASSERT_MAX(type, AD_TYPE_MASK, "AttributeDescriptor::setType"); + desc |= (type << AD_TYPE_SHIFT); +} + +inline +void +AttributeDescriptor::setSize(Uint32 & desc, Uint32 size){ + ASSERT_MAX(size, AD_SIZE_MASK, "AttributeDescriptor::setSize"); + desc |= (size << AD_SIZE_SHIFT); +} + +inline +void +AttributeDescriptor::setArray(Uint32 & desc, Uint32 size){ + ASSERT_MAX(size, AD_ARRAY_SIZE_MASK, "AttributeDescriptor::setArray"); + desc |= (size << AD_ARRAY_SIZE_SHIFT); + if(size <= 1){ + desc |= (size << AD_ARRAY_TYPE_SHIFT); + } else { + desc |= (2 << AD_ARRAY_TYPE_SHIFT); + } +} + +inline +void +AttributeDescriptor::setNullable(Uint32 & desc, Uint32 nullable){ + ASSERT_BOOL(nullable, "AttributeDescriptor::setNullable"); + desc |= (nullable << AD_NULLABLE_SHIFT); +} + +inline +void +AttributeDescriptor::setOriginal(Uint32 & desc, Uint32 original){ + ASSERT_BOOL(original, "AttributeDescriptor::setOriginal"); + desc |= (original << AD_ORIGINAL_SHIFT); +} + +inline +void +AttributeDescriptor::setDGroup(Uint32 & desc, Uint32 dgroup){ + ASSERT_BOOL(dgroup, "AttributeDescriptor::setDGroup"); + desc |= (dgroup << AD_DISTR_GROUP_SHIFT); +} + +inline +void +AttributeDescriptor::setDKey(Uint32 & desc, Uint32 dkey){ + ASSERT_BOOL(dkey, "AttributeDescriptor::setDKey"); + desc |= (dkey << AD_DISTR_KEY_SHIFT); +} + +inline +void +AttributeDescriptor::setPrimaryKey(Uint32 & desc, Uint32 dkey){ + ASSERT_BOOL(dkey, "AttributeDescriptor::setPrimaryKey"); + desc |= (dkey << AD_PRIMARY_KEY); +} + +inline +void +AttributeDescriptor::setStoredInTup(Uint32 & desc, Uint32 storedInTup){ + ASSERT_BOOL(storedInTup, "AttributeDescriptor::setStoredInTup"); + desc |= (storedInTup << AD_TUP_STORED_SHIFT); +} + +inline +void +AttributeDescriptor::setDynamic(Uint32 & desc, Uint32 dynamic){ + ASSERT_BOOL(dynamic, "AttributeDescriptor::setDynamic"); + desc |= (dynamic << AD_DYNAMIC); +} + +/** + * Getters + */ +inline +Uint32 +AttributeDescriptor::getType(const Uint32 & desc){ + return (desc >> AD_TYPE_SHIFT) & AD_TYPE_MASK; +} + +inline +Uint32 +AttributeDescriptor::getSize(const Uint32 & desc){ + return (desc >> AD_SIZE_SHIFT) & AD_SIZE_MASK; +} + +inline +Uint32 +AttributeDescriptor::getSizeInWords(const Uint32 & desc){ + return ((getArraySize(desc) << getSize(desc)) + + AD_SIZE_IN_WORDS_OFFSET) + >> AD_SIZE_IN_WORDS_SHIFT; +} + +inline +Uint32 +AttributeDescriptor::getArrayType(const Uint32 & desc){ + return (desc >> AD_ARRAY_TYPE_SHIFT) & AD_ARRAY_TYPE_MASK; +} + +inline +Uint32 +AttributeDescriptor::getArraySize(const Uint32 & desc){ + return (desc >> AD_ARRAY_SIZE_SHIFT) & AD_ARRAY_SIZE_MASK; +} + +inline +Uint32 +AttributeDescriptor::getNullable(const Uint32 & desc){ + return (desc >> AD_NULLABLE_SHIFT) & 1; +} + +inline +Uint32 +AttributeDescriptor::getOriginal(const Uint32 & desc){ + return (desc >> AD_ORIGINAL_SHIFT) & 1; +} + +inline +Uint32 +AttributeDescriptor::getDGroup(const Uint32 & desc){ + return (desc >> AD_DISTR_GROUP_SHIFT) & 1; +} + +inline +Uint32 +AttributeDescriptor::getDKey(const Uint32 & desc){ + return (desc >> AD_DISTR_KEY_SHIFT) & 1; +} + +inline +Uint32 +AttributeDescriptor::getPrimaryKey(const Uint32 & desc){ + return (desc >> AD_PRIMARY_KEY) & 1; +} + +inline +Uint32 +AttributeDescriptor::getDynamic(const Uint32 & desc){ + return (desc >> AD_DYNAMIC) & 1; +} + +inline +Uint32 +AttributeDescriptor::getStoredInTup(const Uint32 & desc){ + return (desc >> AD_TUP_STORED_SHIFT) & 1; +} + +#endif diff --git a/ndb/include/kernel/AttributeHeader.hpp b/ndb/include/kernel/AttributeHeader.hpp new file mode 100644 index 00000000000..91190fdd223 --- /dev/null +++ b/ndb/include/kernel/AttributeHeader.hpp @@ -0,0 +1,204 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ATTRIBUTE_HEADER +#define ATTRIBUTE_HEADER + +#include +/** + * @class AttributeHeader + * @brief Header passed in front of every attribute value in AttrInfo signal + */ +class AttributeHeader { + friend class Dbtup; + friend class Backup; + friend class NdbOperation; + friend class DbUtil; + friend class Suma; + +public: + /** Initialize AttributeHeader at location aHeaderPtr */ + static AttributeHeader& init(void* aHeaderPtr, Uint32 anAttributeId, + Uint32 aDataSize); + + /** Returns size of AttributeHeader (usually one or two words) */ + Uint32 getHeaderSize() const; // In 32-bit words + + /** Store AttributeHeader in location given as argument */ + void insertHeader(Uint32*); + + /** Get next attribute header (if there is one) */ + AttributeHeader* getNext() const; + + /** Get location of attribute value */ + Uint32* getDataPtr() const; + + /** Getters and Setters */ + Uint32 getAttributeId() const; + void setAttributeId(Uint32); + Uint32 getDataSize() const; // In 32-bit words + void setDataSize(Uint32); + bool isNULL() const; + void setNULL(); + + /** Print **/ + //void print(NdbOut&); + void print(FILE*); + + static Uint32 getDataSize(Uint32); + +public: + AttributeHeader(Uint32 = 0); + AttributeHeader(Uint32 anAttributeId, Uint32 aDataSize); + ~AttributeHeader(); + + Uint32 m_value; +}; + +/** + * 1111111111222222222233 + * 01234567890123456789012345678901 + * ssssssssssssss eiiiiiiiiiiiiiiii + * + * i = Attribute Id + * s = Size of current "chunk" - 14 Bits -> 16384 (words) = 65k + * Including optional extra word(s). + * e - Element data/Blob, read element of array + * If == 0 next data word contains attribute value. + * If == 1 next data word contains: + * For Array of Fixed size Elements + * Start Index (16 bit), Stop Index(16 bit) + * For Blob + * Start offset (32 bit) (length is defined in previous word) + * + * An attribute value equal to "null" is represented by setting s == 0. + * + * Bit 14 is not yet used. + */ + +inline +AttributeHeader& AttributeHeader::init(void* aHeaderPtr, Uint32 anAttributeId, + Uint32 aDataSize) +{ + return * new (aHeaderPtr) AttributeHeader(anAttributeId, aDataSize); +} + +inline +AttributeHeader::AttributeHeader(Uint32 aHeader) +{ + m_value = aHeader; +} + +inline +AttributeHeader::AttributeHeader(Uint32 anAttributeId, Uint32 aDataSize) +{ + m_value = 0; + this->setAttributeId(anAttributeId); + this->setDataSize(aDataSize); +} + +inline +AttributeHeader::~AttributeHeader() +{} + +inline +Uint32 AttributeHeader::getHeaderSize() const +{ + // Should check 'e' bit here + return 1; +} + +inline +Uint32 AttributeHeader::getAttributeId() const +{ + return (m_value & 0xFFFF0000) >> 16; +} + +inline +void AttributeHeader::setAttributeId(Uint32 anAttributeId) +{ + m_value &= 0x0000FFFF; // Clear attribute id + m_value |= (anAttributeId << 16); +} + +inline +Uint32 AttributeHeader::getDataSize() const +{ + return (m_value & 0x3FFF); +} + +inline +void AttributeHeader::setDataSize(Uint32 aDataSize) +{ + m_value &= (~0x3FFF); + m_value |= aDataSize; +} + +inline +bool AttributeHeader::isNULL() const +{ + return (getDataSize() == 0); +} + +inline +void AttributeHeader::setNULL() +{ + setDataSize(0); +} + +inline +Uint32* AttributeHeader::getDataPtr() const +{ + return (Uint32*)&m_value + getHeaderSize(); +} + +inline +void AttributeHeader::insertHeader(Uint32* target) +{ + *target = m_value; +} + +inline +AttributeHeader* +AttributeHeader::getNext() const { + return (AttributeHeader*)(getDataPtr() + getDataSize()); +} + +inline +void +//AttributeHeader::print(NdbOut& output) { +AttributeHeader::print(FILE* output) { + fprintf(output, "AttributeId: H\'%.8x (D\'%d), DataSize: H\'%.8x (D\'%d), " + "isNULL: %d\n", + getAttributeId(), getAttributeId(), + getDataSize(), getDataSize(), + isNULL()); +} + +inline +Uint32 +AttributeHeader::getDataSize(Uint32 m_value){ + return (m_value & 0x3FFF); +} + +#endif + + + + + + + diff --git a/ndb/include/kernel/AttributeList.hpp b/ndb/include/kernel/AttributeList.hpp new file mode 100644 index 00000000000..7c6f71df3d2 --- /dev/null +++ b/ndb/include/kernel/AttributeList.hpp @@ -0,0 +1,32 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ATTRIBUTE_LIST_HPP +#define ATTRIBUTE_LIST_HPP + +/** + * Masks and lists used by index and trigger. Must be plain old Uint32 data. + * XXX depends on other headers XXX move to some common file + */ + +typedef Bitmask AttributeMask; + +struct AttributeList { + Uint32 sz; + Uint32 id[MAX_ATTRIBUTES_IN_INDEX]; +}; + +#endif diff --git a/ndb/include/kernel/BlockNumbers.h b/ndb/include/kernel/BlockNumbers.h new file mode 100644 index 00000000000..84c3fc656a9 --- /dev/null +++ b/ndb/include/kernel/BlockNumbers.h @@ -0,0 +1,81 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef BLOCK_NUMBERS_H +#define BLOCK_NUMBERS_H + +#include +#include + +// 240 +#define MIN_API_BLOCK_NO 0x8000 + +// 2047 +#define API_PACKED 0x07ff + +// 4002 +#define API_CLUSTERMGR 0x0FA2 + +#define BACKUP 0xF4 +#define DBTC 0xF5 +#define DBDIH 0xF6 +#define DBLQH 0xF7 +#define DBACC 0xF8 +#define DBTUP 0xF9 +#define DBDICT 0xFA +#define NDBCNTR 0xFB +#define QMGR 0xFC +#define NDBFS 0xFD +#define CMVMI 0xFE +#define TRIX 0xFF +#define DBUTIL 0x100 +#define SUMA 0x101 +#define GREP 0x102 +#define DBTUX 0x103 + +const BlockReference BACKUP_REF = numberToRef(BACKUP, 0); +const BlockReference DBTC_REF = numberToRef(DBTC, 0); +const BlockReference DBDIH_REF = numberToRef(DBDIH, 0); +const BlockReference DBLQH_REF = numberToRef(DBLQH, 0); +const BlockReference DBACC_REF = numberToRef(DBACC, 0); +const BlockReference DBTUP_REF = numberToRef(DBTUP, 0); +const BlockReference DBDICT_REF = numberToRef(DBDICT, 0); +const BlockReference NDBCNTR_REF = numberToRef(NDBCNTR, 0); +const BlockReference QMGR_REF = numberToRef(QMGR, 0); +const BlockReference NDBFS_REF = numberToRef(NDBFS, 0); +const BlockReference CMVMI_REF = numberToRef(CMVMI, 0); +const BlockReference TRIX_REF = numberToRef(TRIX, 0); +const BlockReference DBUTIL_REF = numberToRef(DBUTIL, 0); +const BlockReference SUMA_REF = numberToRef(SUMA, 0); +const BlockReference GREP_REF = numberToRef(GREP, 0); +const BlockReference DBTUX_REF = numberToRef(DBTUX, 0); + +const BlockNumber MIN_BLOCK_NO = BACKUP; +const BlockNumber MAX_BLOCK_NO = DBTUX; +const BlockNumber NO_OF_BLOCKS = (MAX_BLOCK_NO - MIN_BLOCK_NO + 1); + +/** + * Used for printing and stuff + */ +struct BlockName { + const char* name; + BlockNumber number; +}; + +extern const BlockName BlockNames[]; +extern const BlockNumber NO_OF_BLOCK_NAMES; + +#endif diff --git a/ndb/include/kernel/GlobalSignalNumbers.h b/ndb/include/kernel/GlobalSignalNumbers.h new file mode 100644 index 00000000000..87385de1f14 --- /dev/null +++ b/ndb/include/kernel/GlobalSignalNumbers.h @@ -0,0 +1,957 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef GLOBAL_SIGNAL_NUMBERS_H +#define GLOBAL_SIGNAL_NUMBERS_H + +#include +/** + * NOTE + * + * When adding a new signal, remember to update MAX_GSN and SignalNames.cpp + */ + + + +const GlobalSignalNumber MAX_GSN = 712; + + + + +struct GsnName { + GlobalSignalNumber gsn; + const char * name; +}; + +extern const GsnName SignalNames[]; +extern const GlobalSignalNumber NO_OF_SIGNAL_NAMES; + +/** + * These are used by API and kernel + */ +#define GSN_API_REGCONF 1 +#define GSN_API_REGREF 2 +#define GSN_API_REGREQ 3 + +#define GSN_ATTRINFO 4 +#define GSN_TRANSID_AI 5 +#define GSN_KEYINFO 6 +#define GSN_READCONF 7 + +#define GSN_TCKEY_FAILCONF 8 +#define GSN_TCKEY_FAILREF 9 +#define GSN_TCKEYCONF 10 +#define GSN_TCKEYREF 11 +#define GSN_TCKEYREQ 12 + +#define GSN_TCROLLBACKCONF 13 +#define GSN_TCROLLBACKREF 14 +#define GSN_TCROLLBACKREQ 15 +#define GSN_TCROLLBACKREP 16 + +#define GSN_TC_COMMITCONF 17 +#define GSN_TC_COMMITREF 18 +#define GSN_TC_COMMITREQ 19 +#define GSN_TC_HBREP 20 + +#define GSN_TRANSID_AI_R 21 +#define GSN_KEYINFO20_R 22 + +#define GSN_GET_TABINFOREF 23 +#define GSN_GET_TABINFOREQ 24 +#define GSN_GET_TABINFO_CONF 190 + +#define GSN_GET_TABLEID_REQ 683 +#define GSN_GET_TABLEID_REF 684 +#define GSN_GET_TABLEID_CONF 685 + +#define GSN_DIHNDBTAMPER 25 +#define GSN_NODE_FAILREP 26 +#define GSN_NF_COMPLETEREP 27 + +#define GSN_SCAN_NEXTREQ 28 +#define GSN_SCAN_TABCONF 29 +#define GSN_SCAN_TABINFO 30 +#define GSN_SCAN_TABREF 31 +#define GSN_SCAN_TABREQ 32 +#define GSN_KEYINFO20 33 + +#define GSN_TCRELEASECONF 34 +#define GSN_TCRELEASEREF 35 +#define GSN_TCRELEASEREQ 36 + +#define GSN_TCSEIZECONF 37 +#define GSN_TCSEIZEREF 38 +#define GSN_TCSEIZEREQ 39 + +// 40 unused +// 41 unused +// 42 unused +// 43 unused +// 44 unused +// 45 unused +// 46 unused +// 47 unused +// 48 unused +// 49 unused +// 50 unused +// 51 unused +// 52 unused +// 53 unused +// 54 unused +// 55 unused +// 56 unused +// 57 unused +// 58 unused +// 59 unused +// 60 unused +// 61 unused +// 62 unused +// 63 unused +// 64 unused +// 65 unused +// 66 unused + +/** + * These are used only by kernel + */ + +#define GSN_ACC_ABORTCONF 67 +// 68 unused +// 69 unused +// 70 unused +#define GSN_ACC_ABORTREQ 71 +#define GSN_ACC_CHECK_SCAN 72 +#define GSN_ACC_COMMITCONF 73 +#define GSN_ACC_COMMITREQ 74 +#define GSN_ACC_CONTOPCONF 75 +#define GSN_ACC_CONTOPREQ 76 +#define GSN_ACC_LCPCONF 77 +#define GSN_ACC_LCPREF 78 +#define GSN_ACC_LCPREQ 79 +#define GSN_ACC_LCPSTARTED 80 +#define GSN_ACC_OVER_REC 81 + +#define GSN_ACC_SAVE_PAGES 83 +#define GSN_ACC_SCAN_INFO 84 +#define GSN_ACC_SCAN_INFO24 85 +#define GSN_ACC_SCANCONF 86 +#define GSN_ACC_SCANREF 87 +#define GSN_ACC_SCANREQ 88 +#define GSN_ACC_SRCONF 89 +#define GSN_ACC_SRREF 90 +#define GSN_ACC_SRREQ 91 +#define GSN_ACC_TO_CONF 92 +#define GSN_ACC_TO_REF 93 +#define GSN_ACC_TO_REQ 94 +#define GSN_ACCFRAGCONF 95 +#define GSN_ACCFRAGREF 96 +#define GSN_ACCFRAGREQ 97 +#define GSN_ACCKEYCONF 98 +#define GSN_ACCKEYREF 99 +#define GSN_ACCKEYREQ 100 +#define GSN_ACCMINUPDATE 101 +#define GSN_ACCSEIZECONF 103 +#define GSN_ACCSEIZEREF 104 +#define GSN_ACCSEIZEREQ 105 +#define GSN_ACCUPDATECONF 106 +#define GSN_ACCUPDATEKEY 107 +#define GSN_ACCUPDATEREF 108 + +#define GSN_ADD_FRAGCONF 109 +#define GSN_ADD_FRAGREF 110 +#define GSN_ADD_FRAGREQ 111 + +#define GSN_API_FAILCONF 113 +#define GSN_API_FAILREQ 114 +#define GSN_APPL_CHANGEREP 115 +// 116 not unused +#define GSN_APPL_HB 117 +#define GSN_APPL_HBREQ 118 +#define GSN_APPL_REGCONF 119 +#define GSN_APPL_REGREF 120 +#define GSN_APPL_REGREQ 121 +#define GSN_APPL_RUN 122 +#define GSN_APPL_STARTCONF 123 +#define GSN_APPL_STARTREG 124 +#define GSN_CHECK_LCP_STOP 125 +#define GSN_CLOSE_COMCONF 126 +#define GSN_CLOSE_COMREQ 127 +#define GSN_CM_ACKADD 128 +#define GSN_CM_ACKALARM 129 +#define GSN_CM_ADD 130 +#define GSN_CM_APPCHG 131 +// 132 not unused +// 133 not unused +#define GSN_CM_HEARTBEAT 134 +#define GSN_CM_INFOCONF 135 +#define GSN_CM_INFOREQ 136 +#define GSN_CM_INIT 137 +#define GSN_CM_NODEINFOCONF 138 +#define GSN_CM_NODEINFOREF 139 +#define GSN_CM_NODEINFOREQ 140 +#define GSN_CM_REGCONF 141 +#define GSN_CM_REGREF 142 +#define GSN_CM_REGREQ 143 +#define GSN_CM_RUN 144 +#define GSN_CMVMI_CFGCONF 145 +#define GSN_CMVMI_CFGREQ 146 +#define GSN_CNTR_CHANGEREP 147 +#define GSN_CNTR_MASTERCONF 148 +#define GSN_CNTR_MASTERREF 149 +#define GSN_CNTR_MASTERREQ 150 +#define GSN_CNTR_WAITREP 151 +#define GSN_COMMIT 152 +#define GSN_COMMIT_FAILCONF 153 +#define GSN_COMMIT_FAILREQ 154 +#define GSN_COMMITCONF 155 +#define GSN_COMMITREQ 156 +#define GSN_COMMITTED 157 +#define GSN_COMPLETE 159 +#define GSN_COMPLETECONF 160 +#define GSN_COMPLETED 161 +#define GSN_COMPLETEREQ 162 +#define GSN_CONNECT_REP 163 +#define GSN_CONTINUEB 164 +// 165 not unused +#define GSN_COPY_ACTIVECONF 166 +#define GSN_COPY_ACTIVEREF 167 +#define GSN_COPY_ACTIVEREQ 168 +#define GSN_COPY_FRAGCONF 169 +#define GSN_COPY_FRAGREF 170 +#define GSN_COPY_FRAGREQ 171 +#define GSN_COPY_GCICONF 172 +#define GSN_COPY_GCIREQ 173 +#define GSN_COPY_STATECONF 174 +#define GSN_COPY_STATEREQ 175 +#define GSN_COPY_TABCONF 176 +#define GSN_COPY_TABREQ 177 +#define GSN_CREATE_FRAGCONF 178 +#define GSN_CREATE_FRAGREF 179 +#define GSN_CREATE_FRAGREQ 180 +#define GSN_DEBUG_SIG 181 +#define GSN_DI_FCOUNTCONF 182 +#define GSN_DI_FCOUNTREF 183 +#define GSN_DI_FCOUNTREQ 184 +#define GSN_DIADDTABCONF 185 +#define GSN_DIADDTABREF 186 +#define GSN_DIADDTABREQ 187 +// 188 not unused +// 189 not unused +// 190 not unused +#define GSN_DICTSTARTCONF 191 +#define GSN_DICTSTARTREQ 192 + +#define GSN_LIST_TABLES_REQ 193 +#define GSN_LIST_TABLES_CONF 194 + +#define GSN_ABORT 195 +#define GSN_ABORTCONF 196 +#define GSN_ABORTED 197 +#define GSN_ABORTREQ 198 + +/****************************************** + * DROP TABLE + * + */ + +/** + * This is drop table's public interface + */ +#define GSN_DROP_TABLE_REQ 82 +#define GSN_DROP_TABLE_REF 102 +#define GSN_DROP_TABLE_CONF 112 + +/** + * This is used for implementing drop table + */ +#define GSN_PREP_DROP_TAB_REQ 199 +#define GSN_PREP_DROP_TAB_REF 200 +#define GSN_PREP_DROP_TAB_CONF 201 + +#define GSN_DROP_TAB_REQ 202 +#define GSN_DROP_TAB_REF 203 +#define GSN_DROP_TAB_CONF 204 + +#define GSN_WAIT_DROP_TAB_REQ 208 +#define GSN_WAIT_DROP_TAB_REF 209 +#define GSN_WAIT_DROP_TAB_CONF 216 + +/*****************************************/ + +#define GSN_UPDATE_TOCONF 205 +#define GSN_UPDATE_TOREF 206 +#define GSN_UPDATE_TOREQ 207 + +#define GSN_DIGETNODESCONF 210 +#define GSN_DIGETNODESREF 211 +#define GSN_DIGETNODESREQ 212 +#define GSN_DIGETPRIMCONF 213 +#define GSN_DIGETPRIMREF 214 +#define GSN_DIGETPRIMREQ 215 + +#define GSN_DIH_RESTARTCONF 217 +#define GSN_DIH_RESTARTREF 218 +#define GSN_DIH_RESTARTREQ 219 + +// 220 not unused +// 221 not unused +// 222 not unused + +#define GSN_EMPTY_LCP_REQ 223 +#define GSN_EMPTY_LCP_CONF 224 + +#define GSN_SCHEMA_INFO 225 +#define GSN_SCHEMA_INFOCONF 226 + +#define GSN_MASTER_GCPCONF 227 +#define GSN_MASTER_GCPREF 228 +#define GSN_MASTER_GCPREQ 229 + +// 230 not unused +// 231 not unused + +#define GSN_DIRELEASECONF 232 +#define GSN_DIRELEASEREF 233 +#define GSN_DIRELEASEREQ 234 +#define GSN_DISCONNECT_REP 235 +#define GSN_DISEIZECONF 236 +#define GSN_DISEIZEREF 237 +#define GSN_DISEIZEREQ 238 +#define GSN_DIVERIFYCONF 239 +#define GSN_DIVERIFYREF 240 +#define GSN_DIVERIFYREQ 241 +#define GSN_ENABLE_COMORD 242 +#define GSN_END_LCPCONF 243 +#define GSN_END_LCPREQ 244 +#define GSN_END_TOCONF 245 +#define GSN_END_TOREQ 246 +#define GSN_EVENT_REP 247 +#define GSN_EXEC_FRAGCONF 248 +#define GSN_EXEC_FRAGREF 249 +#define GSN_EXEC_FRAGREQ 250 +#define GSN_EXEC_SRCONF 251 +#define GSN_EXEC_SRREQ 252 +#define GSN_EXPANDCHECK2 253 +#define GSN_FAIL_REP 254 +#define GSN_FSCLOSECONF 255 +#define GSN_FSCLOSEREF 256 +#define GSN_FSCLOSEREQ 257 +#define GSN_FSAPPENDCONF 258 +#define GSN_FSOPENCONF 259 +#define GSN_FSOPENREF 260 +#define GSN_FSOPENREQ 261 +#define GSN_FSREADCONF 262 +#define GSN_FSREADREF 263 +#define GSN_FSREADREQ 264 +#define GSN_FSSYNCCONF 265 +#define GSN_FSSYNCREF 266 +#define GSN_FSSYNCREQ 267 +#define GSN_FSAPPENDREQ 268 +#define GSN_FSAPPENDREF 269 +#define GSN_FSWRITECONF 270 +#define GSN_FSWRITEREF 271 +#define GSN_FSWRITEREQ 272 +#define GSN_GCP_ABORT 273 +#define GSN_GCP_ABORTED 274 +#define GSN_GCP_COMMIT 275 +#define GSN_GCP_NODEFINISH 276 +#define GSN_GCP_NOMORETRANS 277 +#define GSN_GCP_PREPARE 278 +#define GSN_GCP_PREPARECONF 279 +#define GSN_GCP_PREPAREREF 280 +#define GSN_GCP_SAVECONF 281 +#define GSN_GCP_SAVEREF 282 +#define GSN_GCP_SAVEREQ 283 +#define GSN_GCP_TCFINISHED 284 +#define GSN_SR_FRAGIDCONF 285 +#define GSN_SR_FRAGIDREF 286 +#define GSN_SR_FRAGIDREQ 287 +#define GSN_GETGCICONF 288 +#define GSN_GETGCIREQ 289 +#define GSN_HOT_SPAREREP 290 +#define GSN_INCL_NODECONF 291 +#define GSN_INCL_NODEREF 292 +#define GSN_INCL_NODEREQ 293 +#define GSN_LCP_FRAGIDCONF 294 +#define GSN_LCP_FRAGIDREF 295 +#define GSN_LCP_FRAGIDREQ 296 +#define GSN_LCP_HOLDOPCONF 297 +#define GSN_LCP_HOLDOPREF 298 +#define GSN_LCP_HOLDOPREQ 299 +#define GSN_SHRINKCHECK2 301 +#define GSN_GET_SCHEMA_INFOREQ 302 +// 303 not unused +// 304 not unused +#define GSN_LQH_RESTART_OP 305 +#define GSN_LQH_TRANSCONF 306 +#define GSN_LQH_TRANSREQ 307 +#define GSN_LQHADDATTCONF 308 +#define GSN_LQHADDATTREF 309 +#define GSN_LQHADDATTREQ 310 +#define GSN_LQHFRAGCONF 311 +#define GSN_LQHFRAGREF 312 +#define GSN_LQHFRAGREQ 313 +#define GSN_LQHKEYCONF 314 +#define GSN_LQHKEYREF 315 +#define GSN_LQHKEYREQ 316 + +#define GSN_MASTER_LCPCONF 318 +#define GSN_MASTER_LCPREF 319 +#define GSN_MASTER_LCPREQ 320 + +#define GSN_MEMCHECKCONF 321 +#define GSN_MEMCHECKREQ 322 +#define GSN_NDB_FAILCONF 323 +#define GSN_NDB_STARTCONF 324 +#define GSN_NDB_STARTREF 325 +#define GSN_NDB_STARTREQ 326 +#define GSN_NDB_STTOR 327 +#define GSN_NDB_STTORRY 328 +#define GSN_NDB_TAMPER 329 +#define GSN_NEXT_SCANCONF 330 +#define GSN_NEXT_SCANREF 331 +#define GSN_NEXT_SCANREQ 332 +#define GSN_NEXTOPERATION 333 +#define GSN_SIZEALT_ACK 334 +#define GSN_SIZEALT_REP 335 +#define GSN_NODE_STATESCONF 336 +#define GSN_NODE_STATESREF 337 +#define GSN_NODE_STATESREQ 338 +#define GSN_OPEN_COMCONF 339 +#define GSN_OPEN_COMREF 340 +#define GSN_OPEN_COMREQ 341 +#define GSN_PACKED_SIGNAL 342 +#define GSN_PREP_FAILCONF 343 +#define GSN_PREP_FAILREF 344 +#define GSN_PREP_FAILREQ 345 +#define GSN_PRES_TOCONF 346 +#define GSN_PRES_TOREQ 347 +#define GSN_READ_NODESCONF 348 +#define GSN_READ_NODESREF 349 +#define GSN_READ_NODESREQ 350 +#define GSN_SCAN_FRAGCONF 351 +#define GSN_SCAN_FRAGREF 352 +#define GSN_SCAN_FRAGREQ 353 +#define GSN_SCAN_HBREP 354 +#define GSN_SCAN_PROCCONF 355 +#define GSN_SCAN_PROCREQ 356 +#define GSN_SEND_PACKED 357 +#define GSN_SET_LOGLEVELORD 358 + +#define GSN_LQH_ALLOCREQ 359 +#define GSN_TUP_ALLOCREQ 360 +#define GSN_TUP_DEALLOCREQ 361 + +// 362 not unused + +#define GSN_TUP_WRITELOG_REQ 363 +#define GSN_LQH_WRITELOG_REQ 364 + +#define GSN_LCP_FRAG_REP 300 +#define GSN_LCP_FRAG_ORD 365 +#define GSN_LCP_COMPLETE_REP 158 + +#define GSN_START_LCP_REQ 317 +#define GSN_START_LCP_CONF 366 + +#define GSN_UNBLO_DICTCONF 367 +#define GSN_UNBLO_DICTREQ 368 +#define GSN_START_COPYCONF 369 +#define GSN_START_COPYREF 370 +#define GSN_START_COPYREQ 371 +#define GSN_START_EXEC_SR 372 +#define GSN_START_FRAGCONF 373 +#define GSN_START_FRAGREF 374 +#define GSN_START_FRAGREQ 375 +#define GSN_START_LCP_REF 376 +#define GSN_START_LCP_ROUND 377 +#define GSN_START_MECONF 378 +#define GSN_START_MEREF 379 +#define GSN_START_MEREQ 380 +#define GSN_START_PERMCONF 381 +#define GSN_START_PERMREF 382 +#define GSN_START_PERMREQ 383 +#define GSN_START_RECCONF 384 +#define GSN_START_RECREF 385 +#define GSN_START_RECREQ 386 +#define GSN_START_TOCONF 387 +#define GSN_START_TOREQ 388 +#define GSN_STORED_PROCCONF 389 +#define GSN_STORED_PROCREF 390 +#define GSN_STORED_PROCREQ 391 +#define GSN_STTOR 392 +#define GSN_STTORRY 393 +#define GSN_BACKUP_TRIG_REQ 394 +#define GSN_SYSTEM_ERROR 395 +#define GSN_TAB_COMMITCONF 396 +#define GSN_TAB_COMMITREF 397 +#define GSN_TAB_COMMITREQ 398 +#define GSN_TAKE_OVERTCCONF 399 +#define GSN_TAKE_OVERTCREQ 400 +#define GSN_TC_CLOPSIZECONF 401 +#define GSN_TC_CLOPSIZEREQ 402 +#define GSN_TC_SCHVERCONF 403 +#define GSN_TC_SCHVERREQ 404 +#define GSN_TCGETOPSIZECONF 405 +#define GSN_TCGETOPSIZEREQ 406 +#define GSN_TEST_ORD 407 +#define GSN_TESTSIG 408 +#define GSN_TIME_SIGNAL 409 +#define GSN_VOTE_MASTERORD 410 +// 411 unused +// 412 unused +#define GSN_TUP_ABORTREQ 414 +#define GSN_TUP_ADD_ATTCONF 415 +#define GSN_TUP_ADD_ATTRREF 416 +#define GSN_TUP_ADD_ATTRREQ 417 +#define GSN_TUP_ATTRINFO 418 +#define GSN_TUP_COMMITREQ 419 +// 420 unused +#define GSN_TUP_LCPCONF 421 +#define GSN_TUP_LCPREF 422 +#define GSN_TUP_LCPREQ 423 +#define GSN_TUP_LCPSTARTED 424 +#define GSN_TUP_PREPLCPCONF 425 +#define GSN_TUP_PREPLCPREF 426 +#define GSN_TUP_PREPLCPREQ 427 +#define GSN_TUP_SRCONF 428 +#define GSN_TUP_SRREF 429 +#define GSN_TUP_SRREQ 430 +#define GSN_TUPFRAGCONF 431 +#define GSN_TUPFRAGREF 432 +#define GSN_TUPFRAGREQ 433 +#define GSN_TUPKEYCONF 434 +#define GSN_TUPKEYREF 435 +#define GSN_TUPKEYREQ 436 +#define GSN_TUPRELEASECONF 437 +#define GSN_TUPRELEASEREF 438 +#define GSN_TUPRELEASEREQ 439 +#define GSN_TUPSEIZECONF 440 +#define GSN_TUPSEIZEREF 441 +#define GSN_TUPSEIZEREQ 442 + +#define GSN_ABORT_ALL_REQ 445 +#define GSN_ABORT_ALL_REF 446 +#define GSN_ABORT_ALL_CONF 447 + +#define GSN_STATISTICS_REQ 448 +#define GSN_STOP_ORD 449 +#define GSN_TAMPER_ORD 450 +#define GSN_SET_VAR_REQ 451 +#define GSN_SET_VAR_CONF 452 +#define GSN_SET_VAR_REF 453 +#define GSN_STATISTICS_CONF 454 + +#define GSN_START_ORD 455 +// 456 unused +// 457 unused + +#define GSN_EVENT_SUBSCRIBE_REQ 458 +#define GSN_EVENT_SUBSCRIBE_CONF 459 +#define GSN_EVENT_SUBSCRIBE_REF 460 +#define GSN_ACC_COM_BLOCK 461 +#define GSN_ACC_COM_UNBLOCK 462 +#define GSN_TUP_COM_BLOCK 463 +#define GSN_TUP_COM_UNBLOCK 464 + +#define GSN_DUMP_STATE_ORD 465 + +#define GSN_START_INFOREQ 466 +#define GSN_START_INFOREF 467 +#define GSN_START_INFOCONF 468 + +#define GSN_TC_COMMIT_ACK 469 +#define GSN_REMOVE_MARKER_ORD 470 + +#define GSN_CHECKNODEGROUPSREQ 471 +#define GSN_CHECKNODEGROUPSCONF 472 + +#define GSN_ARBIT_CFG 473 +#define GSN_ARBIT_PREPREQ 474 +#define GSN_ARBIT_PREPCONF 475 +#define GSN_ARBIT_PREPREF 476 +#define GSN_ARBIT_STARTREQ 477 +#define GSN_ARBIT_STARTCONF 478 +#define GSN_ARBIT_STARTREF 479 +#define GSN_ARBIT_CHOOSEREQ 480 +#define GSN_ARBIT_CHOOSECONF 481 +#define GSN_ARBIT_CHOOSEREF 482 +#define GSN_ARBIT_STOPORD 483 +#define GSN_ARBIT_STOPREP 484 + +#define GSN_BLOCK_COMMIT_ORD 485 +#define GSN_UNBLOCK_COMMIT_ORD 486 + +#define GSN_NODE_STATE_REP 487 +#define GSN_CHANGE_NODE_STATE_REQ 488 +#define GSN_CHANGE_NODE_STATE_CONF 489 + +#define GSN_DIH_SWITCH_REPLICA_REQ 490 +#define GSN_DIH_SWITCH_REPLICA_CONF 491 +#define GSN_DIH_SWITCH_REPLICA_REF 492 + +#define GSN_STOP_PERM_REQ 493 +#define GSN_STOP_PERM_REF 494 +#define GSN_STOP_PERM_CONF 495 + +#define GSN_STOP_ME_REQ 496 +#define GSN_STOP_ME_REF 497 +#define GSN_STOP_ME_CONF 498 + +#define GSN_WAIT_GCP_REQ 499 +#define GSN_WAIT_GCP_REF 500 +#define GSN_WAIT_GCP_CONF 501 + +// 502 not used + +/** + * Trigger and index signals + */ + +/** + * These are used by API and kernel + */ +#define GSN_TRIG_ATTRINFO 503 +#define GSN_CREATE_TRIG_REQ 504 +#define GSN_CREATE_TRIG_CONF 505 +#define GSN_CREATE_TRIG_REF 506 +#define GSN_ALTER_TRIG_REQ 507 +#define GSN_ALTER_TRIG_CONF 508 +#define GSN_ALTER_TRIG_REF 509 +#define GSN_CREATE_INDX_REQ 510 +#define GSN_CREATE_INDX_CONF 511 +#define GSN_CREATE_INDX_REF 512 +#define GSN_DROP_TRIG_REQ 513 +#define GSN_DROP_TRIG_CONF 514 +#define GSN_DROP_TRIG_REF 515 +#define GSN_DROP_INDX_REQ 516 +#define GSN_DROP_INDX_CONF 517 +#define GSN_DROP_INDX_REF 518 +#define GSN_TCINDXREQ 519 +#define GSN_TCINDXCONF 520 +#define GSN_TCINDXREF 521 +#define GSN_INDXKEYINFO 522 +#define GSN_INDXATTRINFO 523 +#define GSN_TCINDXNEXTREQ 524 +#define GSN_TCINDXNEXTCONF 525 +#define GSN_TCINDXNEXREF 526 +#define GSN_FIRE_TRIG_ORD 527 + +/** + * These are used only by kernel + */ +#define GSN_BUILDINDXREQ 528 +#define GSN_BUILDINDXCONF 529 +#define GSN_BUILDINDXREF 530 + +/** + * Backup interface + */ +#define GSN_BACKUP_REQ 531 +#define GSN_BACKUP_DATA 532 +#define GSN_BACKUP_REF 533 +#define GSN_BACKUP_CONF 534 + +#define GSN_ABORT_BACKUP_ORD 535 + +#define GSN_BACKUP_ABORT_REP 536 +#define GSN_BACKUP_COMPLETE_REP 537 +#define GSN_BACKUP_NF_COMPLETE_REP 538 + +/** + * Internal backup signals + */ +#define GSN_DEFINE_BACKUP_REQ 539 +#define GSN_DEFINE_BACKUP_REF 540 +#define GSN_DEFINE_BACKUP_CONF 541 + +#define GSN_START_BACKUP_REQ 542 +#define GSN_START_BACKUP_REF 543 +#define GSN_START_BACKUP_CONF 544 + +#define GSN_BACKUP_FRAGMENT_REQ 545 +#define GSN_BACKUP_FRAGMENT_REF 546 +#define GSN_BACKUP_FRAGMENT_CONF 547 + +#define GSN_STOP_BACKUP_REQ 548 +#define GSN_STOP_BACKUP_REF 549 +#define GSN_STOP_BACKUP_CONF 550 + +/** + * Used for master take-over / API status request + */ +#define GSN_BACKUP_STATUS_REQ 551 +#define GSN_BACKUP_STATUS_REF 116 +#define GSN_BACKUP_STATUS_CONF 165 + +/** + * Db sequence signals + */ +#define GSN_UTIL_SEQUENCE_REQ 552 +#define GSN_UTIL_SEQUENCE_REF 553 +#define GSN_UTIL_SEQUENCE_CONF 554 + +#define GSN_FSREMOVEREQ 555 +#define GSN_FSREMOVEREF 556 +#define GSN_FSREMOVECONF 557 + +#define GSN_UTIL_PREPARE_REQ 558 +#define GSN_UTIL_PREPARE_CONF 559 +#define GSN_UTIL_PREPARE_REF 560 + +#define GSN_UTIL_EXECUTE_REQ 561 +#define GSN_UTIL_EXECUTE_CONF 562 +#define GSN_UTIL_EXECUTE_REF 563 + +#define GSN_UTIL_RELEASE_REQ 564 +#define GSN_UTIL_RELEASE_CONF 565 +#define GSN_UTIL_RELEASE_REF 566 + +/** + * When dropping a long signal due to lack of memory resources + */ +#define GSN_SIGNAL_DROPPED_REP 567 +#define GSN_CONTINUE_FRAGMENTED 568 + +/** + * Suma participant interface + */ +#define GSN_SUB_REMOVE_REQ 569 +#define GSN_SUB_REMOVE_REF 570 +#define GSN_SUB_REMOVE_CONF 571 +#define GSN_SUB_STOP_REQ 572 +#define GSN_SUB_STOP_REF 573 +#define GSN_SUB_STOP_CONF 574 +// 575 unused +#define GSN_SUB_CREATE_REQ 576 +#define GSN_SUB_CREATE_REF 577 +#define GSN_SUB_CREATE_CONF 578 +#define GSN_SUB_START_REQ 579 +#define GSN_SUB_START_REF 580 +#define GSN_SUB_START_CONF 581 +#define GSN_SUB_SYNC_REQ 582 +#define GSN_SUB_SYNC_REF 583 +#define GSN_SUB_SYNC_CONF 584 +#define GSN_SUB_META_DATA 585 +#define GSN_SUB_TABLE_DATA 586 + +#define GSN_CREATE_TABLE_REQ 587 +#define GSN_CREATE_TABLE_REF 588 +#define GSN_CREATE_TABLE_CONF 589 + +#define GSN_ALTER_TABLE_REQ 624 +#define GSN_ALTER_TABLE_REF 625 +#define GSN_ALTER_TABLE_CONF 626 + +#define GSN_SUB_SYNC_CONTINUE_REQ 590 +#define GSN_SUB_SYNC_CONTINUE_REF 591 +#define GSN_SUB_SYNC_CONTINUE_CONF 592 +#define GSN_SUB_GCP_COMPLETE_REP 593 + +#define GSN_CREATE_FRAGMENTATION_REQ 594 +#define GSN_CREATE_FRAGMENTATION_REF 595 +#define GSN_CREATE_FRAGMENTATION_CONF 596 + +#define GSN_CREATE_TAB_REQ 597 +#define GSN_CREATE_TAB_REF 598 +#define GSN_CREATE_TAB_CONF 599 + +#define GSN_ALTER_TAB_REQ 600 +#define GSN_ALTER_TAB_REF 601 +#define GSN_ALTER_TAB_CONF 602 + +#define GSN_ALTER_INDX_REQ 603 +#define GSN_ALTER_INDX_REF 604 +#define GSN_ALTER_INDX_CONF 605 + +/** + * Grep signals + */ +#define GSN_GREP_SUB_CREATE_REQ 606 +#define GSN_GREP_SUB_CREATE_REF 607 +#define GSN_GREP_SUB_CREATE_CONF 608 +#define GSN_GREP_CREATE_REQ 609 +#define GSN_GREP_CREATE_REF 610 +#define GSN_GREP_CREATE_CONF 611 + +#define GSN_GREP_SUB_START_REQ 612 +#define GSN_GREP_SUB_START_REF 613 +#define GSN_GREP_SUB_START_CONF 614 +#define GSN_GREP_START_REQ 615 +#define GSN_GREP_START_REF 616 +#define GSN_GREP_START_CONF 617 + +#define GSN_GREP_SUB_SYNC_REQ 618 +#define GSN_GREP_SUB_SYNC_REF 619 +#define GSN_GREP_SUB_SYNC_CONF 620 +#define GSN_GREP_SYNC_REQ 621 +#define GSN_GREP_SYNC_REF 622 +#define GSN_GREP_SYNC_CONF 623 + +/** + * REP signals + */ +#define GSN_REP_WAITGCP_REQ 627 +#define GSN_REP_WAITGCP_REF 628 +#define GSN_REP_WAITGCP_CONF 629 +#define GSN_GREP_WAITGCP_REQ 630 +#define GSN_GREP_WAITGCP_REF 631 +#define GSN_GREP_WAITGCP_CONF 632 +#define GSN_REP_GET_GCI_REQ 633 +#define GSN_REP_GET_GCI_REF 634 +#define GSN_REP_GET_GCI_CONF 635 +#define GSN_REP_GET_GCIBUFFER_REQ 636 +#define GSN_REP_GET_GCIBUFFER_REF 637 +#define GSN_REP_GET_GCIBUFFER_CONF 638 +#define GSN_REP_INSERT_GCIBUFFER_REQ 639 +#define GSN_REP_INSERT_GCIBUFFER_REF 640 +#define GSN_REP_INSERT_GCIBUFFER_CONF 641 +#define GSN_REP_CLEAR_PS_GCIBUFFER_REQ 642 +#define GSN_REP_CLEAR_PS_GCIBUFFER_REF 643 +#define GSN_REP_CLEAR_PS_GCIBUFFER_CONF 644 +#define GSN_REP_CLEAR_SS_GCIBUFFER_REQ 645 +#define GSN_REP_CLEAR_SS_GCIBUFFER_REF 646 +#define GSN_REP_CLEAR_SS_GCIBUFFER_CONF 647 +#define GSN_REP_DATA_PAGE 648 +#define GSN_REP_GCIBUFFER_ACC_REP 649 + +#define GSN_GREP_SUB_REMOVE_REQ 650 +#define GSN_GREP_SUB_REMOVE_REF 651 +#define GSN_GREP_SUB_REMOVE_CONF 652 +#define GSN_GREP_REMOVE_REQ 653 +#define GSN_GREP_REMOVE_REF 654 +#define GSN_GREP_REMOVE_CONF 655 + +// Start Global Replication +#define GSN_GREP_REQ 656 + +/** + * Management server + */ +#define GSN_MGM_LOCK_CONFIG_REQ 657 +#define GSN_MGM_LOCK_CONFIG_REP 658 +#define GSN_MGM_UNLOCK_CONFIG_REQ 659 +#define GSN_MGM_UNLOCK_CONFIG_REP 660 + +#define GSN_UTIL_CREATE_LOCK_REQ 132 +#define GSN_UTIL_CREATE_LOCK_REF 133 +#define GSN_UTIL_CREATE_LOCK_CONF 188 + +#define GSN_UTIL_DESTROY_LOCK_REQ 189 +#define GSN_UTIL_DESTROY_LOCK_REF 220 +#define GSN_UTIL_DESTROY_LOCK_CONF 221 + +#define GSN_UTIL_LOCK_REQ 222 +#define GSN_UTIL_LOCK_REF 230 +#define GSN_UTIL_LOCK_CONF 231 + +#define GSN_UTIL_UNLOCK_REQ 303 +#define GSN_UTIL_UNLOCK_REF 304 +#define GSN_UTIL_UNLOCK_CONF 362 + +/* SUMA */ +#define GSN_CREATE_SUBID_REQ 661 +#define GSN_CREATE_SUBID_REF 662 +#define GSN_CREATE_SUBID_CONF 663 + +/* GREP */ +#define GSN_GREP_CREATE_SUBID_REQ 664 +#define GSN_GREP_CREATE_SUBID_REF 665 +#define GSN_GREP_CREATE_SUBID_CONF 666 +#define GSN_REP_DROP_TABLE_REQ 667 +#define GSN_REP_DROP_TABLE_REF 668 +#define GSN_REP_DROP_TABLE_CONF 669 + +/* + * TUX + */ +#define GSN_TUXFRAGREQ 670 +#define GSN_TUXFRAGCONF 671 +#define GSN_TUXFRAGREF 672 +#define GSN_TUX_ADD_ATTRREQ 673 +#define GSN_TUX_ADD_ATTRCONF 674 +#define GSN_TUX_ADD_ATTRREF 675 + +/* + * REP + */ +#define GSN_REP_DISCONNECT_REP 676 + +#define GSN_TUX_MAINT_REQ 677 +#define GSN_TUX_MAINT_CONF 678 +#define GSN_TUX_MAINT_REF 679 + +/* + * TUP access + */ +#define GSN_TUP_READ_ATTRS 680 +#define GSN_TUP_QUERY_TH 712 +#define GSN_TUP_STORE_TH 681 + +/** + * from mgmtsrvr to NDBCNTR + */ +#define GSN_RESUME_REQ 682 +#define GSN_STOP_REQ 443 +#define GSN_STOP_REF 444 +#define GSN_API_VERSION_REQ 697 +#define GSN_API_VERSION_CONF 698 + +// not used 686 +// not used 687 +// not used 689 +// not used 690 + +/** + * SUMA restart protocol + */ +#define GSN_SUMA_START_ME 691 +#define GSN_SUMA_HANDOVER_REQ 692 +#define GSN_SUMA_HANDOVER_CONF 693 + +// not used 694 +// not used 695 +// not used 696 + +/** + * GREP restart protocol + */ +#define GSN_GREP_START_ME 706 +#define GSN_GREP_ADD_SUB_REQ 707 +#define GSN_GREP_ADD_SUB_REF 708 +#define GSN_GREP_ADD_SUB_CONF 709 + + +/* + * EVENT Signals + */ +#define GSN_SUB_GCP_COMPLETE_ACC 699 + +#define GSN_CREATE_EVNT_REQ 700 +#define GSN_CREATE_EVNT_CONF 701 +#define GSN_CREATE_EVNT_REF 702 + +#define GSN_DROP_EVNT_REQ 703 +#define GSN_DROP_EVNT_CONF 704 +#define GSN_DROP_EVNT_REF 705 + +#define GSN_TUX_BOUND_INFO 710 + +#define GSN_ACC_LOCKREQ 711 + + +#endif diff --git a/ndb/include/kernel/GrepEvent.hpp b/ndb/include/kernel/GrepEvent.hpp new file mode 100644 index 00000000000..2073a7072c9 --- /dev/null +++ b/ndb/include/kernel/GrepEvent.hpp @@ -0,0 +1,59 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef GREP_EVENT_H +#define GREP_EVENT_H + +class GrepEvent { +public: + enum Subscription { + GrepSS_CreateSubIdConf = 1, + GrepSS_SubCreateConf = 2, + GrepSS_SubStartMetaConf = 3, + GrepSS_SubStartDataConf = 4, + GrepSS_SubSyncDataConf = 5, + GrepSS_SubSyncMetaConf = 6, + GrepSS_SubRemoveConf = 7, + + GrepPS_CreateSubIdConf = 8, + GrepPS_SubCreateConf = 9, + GrepPS_SubStartMetaConf = 10, + GrepPS_SubStartDataConf = 11, + GrepPS_SubSyncMetaConf = 12, + GrepPS_SubSyncDataConf = 13, + GrepPS_SubRemoveConf = 14, + + GrepPS_CreateSubIdRef = 15, + GrepPS_SubCreateRef = 16, + GrepPS_SubStartMetaRef = 17, + GrepPS_SubStartDataRef = 18, + GrepPS_SubSyncMetaRef = 19, + GrepPS_SubSyncDataRef = 20, + GrepPS_SubRemoveRef = 21, + + GrepSS_CreateSubIdRef = 22, + GrepSS_SubCreateRef = 23, + GrepSS_SubStartMetaRef = 24, + GrepSS_SubStartDataRef = 25, + GrepSS_SubSyncMetaRef = 26, + GrepSS_SubSyncDataRef = 27, + GrepSS_SubRemoveRef = 28, + + Rep_Disconnect = 29 + + }; +}; +#endif diff --git a/ndb/include/kernel/Interpreter.hpp b/ndb/include/kernel/Interpreter.hpp new file mode 100644 index 00000000000..2c282be361c --- /dev/null +++ b/ndb/include/kernel/Interpreter.hpp @@ -0,0 +1,284 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_INTERPRETER_HPP +#define NDB_INTERPRETER_HPP + +#include + +class Interpreter { +public: + + inline static Uint32 mod4(Uint32 len){ + return len + ((4 - (len & 3)) & 3); + } + + + /** + * General Mnemonic format + * + * i = Instruction - 5 Bits ( 0 - 5 ) max 63 + * x = Register 1 - 3 Bits ( 6 - 8 ) max 7 + * y = Register 2 - 3 Bits ( 9 -11 ) max 7 + * b = Branch offset (only branches) + * + * 1111111111222222222233 + * 01234567890123456789012345678901 + * iiiiiixxxyyy bbbbbbbbbbbbbbbb + * + * + */ + + /** + * Instructions + */ + static const Uint32 READ_ATTR_INTO_REG = 1; + static const Uint32 WRITE_ATTR_FROM_REG = 2; + static const Uint32 LOAD_CONST_NULL = 3; + static const Uint32 LOAD_CONST16 = 4; + static const Uint32 LOAD_CONST32 = 5; + static const Uint32 LOAD_CONST64 = 6; + static const Uint32 ADD_REG_REG = 7; + static const Uint32 SUB_REG_REG = 8; + static const Uint32 BRANCH = 9; + static const Uint32 BRANCH_REG_EQ_NULL = 10; + static const Uint32 BRANCH_REG_NE_NULL = 11; + static const Uint32 BRANCH_EQ_REG_REG = 12; + static const Uint32 BRANCH_NE_REG_REG = 13; + static const Uint32 BRANCH_LT_REG_REG = 14; + static const Uint32 BRANCH_LE_REG_REG = 15; + static const Uint32 BRANCH_GT_REG_REG = 16; + static const Uint32 BRANCH_GE_REG_REG = 17; + static const Uint32 EXIT_OK = 18; + static const Uint32 EXIT_REFUSE = 19; + static const Uint32 CALL = 20; + static const Uint32 RETURN = 21; + static const Uint32 EXIT_OK_LAST = 22; + static const Uint32 BRANCH_ATTR_OP_ARG = 23; + static const Uint32 BRANCH_ATTR_EQ_NULL = 24; + static const Uint32 BRANCH_ATTR_NE_NULL = 25; + + /** + * Macros for creating code + */ + static Uint32 Read(Uint32 AttrId, Uint32 Register); + static Uint32 Write(Uint32 AttrId, Uint32 Register); + + static Uint32 LoadNull(Uint32 Register); + static Uint32 LoadConst16(Uint32 Register, Uint32 Value); + static Uint32 LoadConst32(Uint32 Register); // Value in next word + static Uint32 LoadConst64(Uint32 Register); // Value in next 2 words + static Uint32 Add(Uint32 DstReg, Uint32 SrcReg1, Uint32 SrcReg2); + static Uint32 Sub(Uint32 DstReg, Uint32 SrcReg1, Uint32 SrcReg2); + static Uint32 Branch(Uint32 Inst, Uint32 R1, Uint32 R2); + static Uint32 ExitOK(); + + /** + * Branch string + * + * i = Instruction - 5 Bits ( 0 - 5 ) max 63 + * a = Attribute id + * l = Length of string + * b = Branch offset + * t = branch type + * d = Array length diff + * v = Varchar flag + * p = No-blank-padding flag for char compare + * + * 1111111111222222222233 + * 01234567890123456789012345678901 + * iiiiii ddvtttpbbbbbbbbbbbbbbbb + * aaaaaaaaaaaaaaaallllllllllllllll + * -string.... - + */ + enum UnaryCondition { + IS_NULL = 0, + IS_NOT_NULL = 1 + }; + + enum BinaryCondition { + EQ = 0, + NE = 1, + LT = 2, + LE = 3, + GT = 4, + GE = 5, + LIKE = 6, + NOT_LIKE = 7 + }; + static Uint32 BranchCol(BinaryCondition cond, + Uint32 arrayLengthDiff, Uint32 varchar, bool nopad); + static Uint32 BranchCol_2(Uint32 AttrId); + static Uint32 BranchCol_2(Uint32 AttrId, Uint32 Len); + + static Uint32 getBinaryCondition(Uint32 op1); + static Uint32 getArrayLengthDiff(Uint32 op1); + static Uint32 isVarchar(Uint32 op1); + static Uint32 isNopad(Uint32 op1); + static Uint32 getBranchCol_AttrId(Uint32 op2); + static Uint32 getBranchCol_Len(Uint32 op2); + + /** + * Macros for decoding code + */ + static Uint32 getOpCode(Uint32 op); + static Uint32 getReg1(Uint32 op); + static Uint32 getReg2(Uint32 op); + static Uint32 getReg3(Uint32 op); +}; + +inline +Uint32 +Interpreter::Read(Uint32 AttrId, Uint32 Register){ + return (AttrId << 16) + (Register << 6) + READ_ATTR_INTO_REG; +} + +inline +Uint32 +Interpreter::Write(Uint32 AttrId, Uint32 Register){ + return (AttrId << 16) + (Register << 6) + WRITE_ATTR_FROM_REG; +} + +inline +Uint32 +Interpreter::LoadConst16(Uint32 Register, Uint32 Value){ + return (Value << 16) + (Register << 6) + LOAD_CONST16; +} + +inline +Uint32 +Interpreter::LoadConst32(Uint32 Register){ + return (Register << 6) + LOAD_CONST32; +} + +inline +Uint32 +Interpreter::LoadConst64(Uint32 Register){ + return (Register << 6) + LOAD_CONST64; +} + +inline +Uint32 +Interpreter::Add(Uint32 Dcoleg, Uint32 SrcReg1, Uint32 SrcReg2){ + return (SrcReg1 << 6) + (SrcReg2 << 9) + (Dcoleg << 16) + ADD_REG_REG; +} + +inline +Uint32 +Interpreter::Sub(Uint32 Dcoleg, Uint32 SrcReg1, Uint32 SrcReg2){ + return (SrcReg1 << 6) + (SrcReg2 << 9) + (Dcoleg << 16) + SUB_REG_REG; +} + +inline +Uint32 +Interpreter::Branch(Uint32 Inst, Uint32 R1, Uint32 R2){ + return (R1 << 9) + (R2 << 6) + Inst; +} + +inline +Uint32 +Interpreter::BranchCol(BinaryCondition cond, + Uint32 arrayLengthDiff, + Uint32 varchar, bool nopad){ + //ndbout_c("BranchCol: cond=%d diff=%u varchar=%u nopad=%d", + //cond, arrayLengthDiff, varchar, nopad); + return + BRANCH_ATTR_OP_ARG + + (arrayLengthDiff << 9) + + (varchar << 11) + + (cond << 12) + + (nopad << 15); +} + +inline +Uint32 +Interpreter::BranchCol_2(Uint32 AttrId, Uint32 Len){ + return (AttrId << 16) + Len; +} + +inline +Uint32 +Interpreter::BranchCol_2(Uint32 AttrId){ + return (AttrId << 16); +} + +inline +Uint32 +Interpreter::getBinaryCondition(Uint32 op){ + return (op >> 12) & 0x7; +} + +inline +Uint32 +Interpreter::getArrayLengthDiff(Uint32 op){ + return (op >> 9) & 0x3; +} + +inline +Uint32 +Interpreter::isVarchar(Uint32 op){ + return (op >> 11) & 1; +} + +inline +Uint32 +Interpreter::isNopad(Uint32 op){ + return (op >> 15) & 1; +} + +inline +Uint32 +Interpreter::getBranchCol_AttrId(Uint32 op){ + return (op >> 16) & 0xFFFF; +} + +inline +Uint32 +Interpreter::getBranchCol_Len(Uint32 op){ + return op & 0xFFFF; +} + +inline +Uint32 +Interpreter::ExitOK(){ + return EXIT_OK; +} + +inline +Uint32 +Interpreter::getOpCode(Uint32 op){ + return op & 0x3f; +} + +inline +Uint32 +Interpreter::getReg1(Uint32 op){ + return (op >> 6) & 0x7; +} + +inline +Uint32 +Interpreter::getReg2(Uint32 op){ + return (op >> 9) & 0x7; +} + +inline +Uint32 +Interpreter::getReg3(Uint32 op){ + return (op >> 16) & 0x7; +} + +#endif diff --git a/ndb/include/kernel/LogLevel.hpp b/ndb/include/kernel/LogLevel.hpp new file mode 100644 index 00000000000..0902f3e488b --- /dev/null +++ b/ndb/include/kernel/LogLevel.hpp @@ -0,0 +1,173 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef _LOG_LEVEL_HPP +#define _LOG_LEVEL_HPP + +#include +#include + +/** + * + */ +class LogLevel { + friend class Config; +public: + /** + * Constructor + */ + LogLevel(); + + /** + * Howto add a new event category: + * 1. Add the new event category to EventCategory below + * 2. Update #define _LOGLEVEL_CATEGORIES (found below) with the number of + * items in EventCategory + * 3. Update LogLevelCategoryName in LogLevel.cpp + * 4. Add the event in EventLogger + */ + + + /** + * Copy operator + */ + LogLevel & operator= (const LogLevel &); + + enum EventCategory { + /** + * Events during all kind of startups + */ + llStartUp = 0, + + /** + * Events during shutdown + */ + llShutdown = 1, + + /** + * Transaction statistics + * Job level + * TCP/IP speed + */ + llStatistic = 2, + + /** + * Checkpoints + */ + llCheckpoint = 3, + + /** + * Events during node restart + */ + llNodeRestart = 4, + + /** + * Events related to connection / communication + */ + llConnection = 5, + + /** + * Assorted event w.r.t unexpected happenings + */ + llError = 6, + + /** + * Assorted event w.r.t information + */ + llInfo = 7, + + /** + * Events related to global replication + */ + llGrep = 8 + }; + + struct LogLevelCategoryName { + const char* name; + }; + + /** + * Log/event level category names. Remember to update the names whenever + * a new category is added. + */ + static const LogLevelCategoryName LOGLEVEL_CATEGORY_NAME[]; + + /** + * No of categories + */ +#define _LOGLEVEL_CATEGORIES 9 + static const Uint32 LOGLEVEL_CATEGORIES = _LOGLEVEL_CATEGORIES; + + void clear(); + + /** + * Note level is valid as 0-15 + */ + void setLogLevel(EventCategory ec, Uint32 level = 7); + + /** + * Get the loglevel (0-15) for a category + */ + Uint32 getLogLevel(EventCategory ec) const; + +private: + /** + * The actual data + */ + Uint32 logLevelData[LOGLEVEL_CATEGORIES]; + + LogLevel(const LogLevel &); +}; + +inline +LogLevel::LogLevel(){ + clear(); +} + +inline +LogLevel & +LogLevel::operator= (const LogLevel & org){ + for(Uint32 i = 0; i= 0 && (Uint32) ec < LOGLEVEL_CATEGORIES); + logLevelData[ec] = level; +} + +inline +Uint32 +LogLevel::getLogLevel(EventCategory ec) const{ + assert(ec >= 0 && (Uint32) ec < LOGLEVEL_CATEGORIES); + + return logLevelData[ec]; +} + + +#endif diff --git a/ndb/include/kernel/NodeBitmask.hpp b/ndb/include/kernel/NodeBitmask.hpp new file mode 100644 index 00000000000..423c01cd841 --- /dev/null +++ b/ndb/include/kernel/NodeBitmask.hpp @@ -0,0 +1,89 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NODE_BITMASK_HPP +#define NODE_BITMASK_HPP + +#include +#include +#include + +/** + * No of 32 bits words needed to store a node bitmask + * containing all the nodes in the system + * Both NDB nodes and API, MGM... nodes + * + * Note that this is used in a lot of signals + */ +#define _NODE_BITMASK_SIZE 2 + +/** + * No of 32 bits words needed to store a node bitmask + * containing all the ndb nodes in the system + * + * Note that this is used in a lot of signals + */ +#define _NDB_NODE_BITMASK_SIZE 2 + +/** + * No of 32 bits word needed to store B bits for N nodes + */ +#define NODE_ARRAY_SIZE(N, B) (((N)*(B)+31) >> 5) + +typedef Bitmask<(unsigned int)_NODE_BITMASK_SIZE> NodeBitmask; + +typedef Bitmask<(unsigned int)_NDB_NODE_BITMASK_SIZE> NdbNodeBitmask; + +#define __NBM_SZ ((MAX_NODES >> 5) + ((MAX_NODES & 31) != 0)) +#define __NNBM_SZ ((MAX_NDB_NODES >> 5) + ((MAX_NDB_NODES & 31) != 0)) + +#if ( __NBM_SZ > _NODE_BITMASK_SIZE) +#error "MAX_NODES can not fit into NODE_BITMASK_SIZE" +#endif + +#if ( __NNBM_SZ > _NDB_NODE_BITMASK_SIZE) +#error "MAX_NDB_NODES can not fit into NDB_NODE_BITMASK_SIZE" +#endif + +/** + * General B Bits operations + * + * Get(x, A[], B) + * w = x >> S1 + * s = (x & S2) << S3 + * return (A[w] >> s) & S4 + * + * Set(x, A[], v, B) + * w = x >> S1 + * s = (x & S2) << S3 + * m = ~(S4 << s) + * t = A[w] & m; + * A[w] = t | ((v & S4) << s) + * + * B(Bits) S1 S2 S3 S4 + * 1 5 31 0 1 + * 2 4 15 1 3 + * 4 3 7 2 15 + * 8 2 3 3 255 + * 16 1 1 4 65535 + * + * S1 = 5 - 2log(B) + * S2 = 2^S1 - 1 + * S3 = 2log(B) + * S4 = 2^B - 1 + */ + +#endif diff --git a/ndb/include/kernel/NodeInfo.hpp b/ndb/include/kernel/NodeInfo.hpp new file mode 100644 index 00000000000..86aca7d6883 --- /dev/null +++ b/ndb/include/kernel/NodeInfo.hpp @@ -0,0 +1,94 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NODE_INFO_HPP +#define NODE_INFO_HPP + +#include + +class NodeInfo { +public: + NodeInfo(); + + /** + * NodeType + */ + enum NodeType { + DB = 0, ///< Database node + API = 1, ///< NDB API node + MGM = 2, ///< Management node (incl. NDB API) + REP = 3, ///< Replication node (incl. NDB API) + INVALID = 255 ///< Invalid type + }; + NodeType getType() const; + + Uint32 m_version; ///< Node version + Uint32 m_signalVersion; ///< Signal version + Uint32 m_type; ///< Node type + Uint32 m_connectCount; ///< No of times connected + bool m_connected; ///< Node is connected + + friend NdbOut & operator<<(NdbOut&, const NodeInfo&); +}; + + +inline +NodeInfo::NodeInfo(){ + m_version = 0; + m_signalVersion = 0; + m_type = INVALID; + m_connectCount = 0; +} + +inline +NodeInfo::NodeType +NodeInfo::getType() const { + return (NodeType)m_type; +} + +inline +NdbOut & +operator<<(NdbOut& ndbout, const NodeInfo & info){ + ndbout << "[NodeInfo: "; + switch(info.m_type){ + case NodeInfo::DB: + ndbout << "DB"; + break; + case NodeInfo::API: + ndbout << "API"; + break; + case NodeInfo::MGM: + ndbout << "MGM"; + break; + case NodeInfo::REP: + ndbout << "REP"; + break; + case NodeInfo::INVALID: + ndbout << "INVALID"; + break; + default: + ndbout << ""; + break; + } + + ndbout << " version: " << info.m_version + << " sig. version; " << info.m_signalVersion + << " connect count: " << info.m_connectCount + << "]"; + return ndbout; +} + +#endif diff --git a/ndb/include/kernel/NodeState.hpp b/ndb/include/kernel/NodeState.hpp new file mode 100644 index 00000000000..1bc7806876d --- /dev/null +++ b/ndb/include/kernel/NodeState.hpp @@ -0,0 +1,308 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NODE_STATE_HPP +#define NODE_STATE_HPP + +#include + +class NodeState { +public: + enum StartLevel { + /** + * SL_NOTHING + * Nothing is started + */ + SL_NOTHING = 0, + + /** + * SL_CMVMI + * CMVMI is started + * Listening to management server + * Qmgr knows nothing... + */ + SL_CMVMI = 1, + + /** + * SL_STARTING + * All blocks are starting + * Initial or restart + * During this phase is startPhase valid + */ + SL_STARTING = 2, + + /** + * The database is started open for connections + */ + SL_STARTED = 3, + + SL_SINGLEUSER = 4, + + /** + * SL_STOPPING_1 - Inform API + * API is informed not to start transactions on node + * The database is about to close + * + * New TcSeize(s) are refused (TcSeizeRef) + */ + SL_STOPPING_1 = 5, + + /** + * SL_STOPPING_2 - Close TC + * New transactions(TC) are refused + */ + SL_STOPPING_2 = 6, + + + + + /** + * SL_STOPPING_3 - Wait for reads in LQH + * No transactions are running in TC + * New scans(s) and read(s) are refused in LQH + * NS: The node is not Primary for any fragment + * NS: No node is allow to start + */ + SL_STOPPING_3 = 7, + + /** + * SL_STOPPING_4 - Close LQH + * Node is out of DIGETNODES + * Insert/Update/Delete can still be running in LQH + * GCP is refused + * Node is not startable w.o Node Recovery + */ + SL_STOPPING_4 = 8 + }; + + enum StartType { + ST_INITIAL_START = 0, + ST_SYSTEM_RESTART = 1, + ST_NODE_RESTART = 2, + ST_INITIAL_NODE_RESTART = 3, + ST_ILLEGAL_TYPE = 4 + }; + + /** + * Length in 32-bit words + */ + static const Uint32 DataLength = 8; + + /** + * Constructor(s) + */ + NodeState(); + NodeState(StartLevel); + NodeState(StartLevel, bool systemShutdown); + NodeState(StartLevel, Uint32 startPhase, StartType); + + /** + * Current start level + */ + Uint32 startLevel; + + /** + * Node group + */ + Uint32 nodeGroup; // valid when startLevel == SL_STARTING + + /** + * Dynamic id + */ + union { + Uint32 dynamicId; // valid when startLevel == SL_STARTING to API + Uint32 masterNodeId; // When from cntr + }; + + /** + * + */ + union { + struct { + Uint32 startPhase; // valid when startLevel == SL_STARTING + Uint32 restartType; // valid when startLevel == SL_STARTING + } starting; + struct { + Uint32 systemShutdown; // valid when startLevel == SL_STOPPING_{X} + Uint32 timeout; + Uint32 alarmTime; + } stopping; + + + }; + Uint32 singleUserMode; + Uint32 singleUserApi; //the single user node + + void setDynamicId(Uint32 dynamic); + void setNodeGroup(Uint32 group); + void setSingleUser(Uint32 s); + void setSingleUserApi(Uint32 n); + + + /** + * Is a node restart in progress (ordinary or initial) + */ + bool getNodeRestartInProgress() const; + + /** + * Is a system restart ongoing + */ + bool getSystemRestartInProgress() const; + + /** + * Is in single user mode? + */ + bool getSingleUserMode() const; + + /** + * Is in single user mode + */ + Uint32 getSingleUserApi() const; + + friend NdbOut & operator<<(NdbOut&, const NodeState&); +}; + +inline +NodeState::NodeState(){ + startLevel = SL_CMVMI; + nodeGroup = 0xFFFFFFFF; + dynamicId = 0xFFFFFFFF; + singleUserMode = 0; + singleUserApi = 0xFFFFFFFF; +} + +inline +NodeState::NodeState(StartLevel sl){ + NodeState::NodeState(); + startLevel = sl; + singleUserMode = 0; + singleUserApi = 0xFFFFFFFF; +} + +inline +NodeState::NodeState(StartLevel sl, Uint32 sp, StartType typeOfStart){ + NodeState::NodeState(); + startLevel = sl; + starting.startPhase = sp; + starting.restartType = typeOfStart; + singleUserMode = 0; + singleUserApi = 0xFFFFFFFF; +} + +inline +NodeState::NodeState(StartLevel sl, bool sys){ + NodeState::NodeState(); + startLevel = sl; + stopping.systemShutdown = sys; + singleUserMode = 0; + singleUserApi = 0xFFFFFFFF; +} + +inline +void NodeState::setDynamicId(Uint32 dynamic){ + dynamicId = dynamic; +} + +inline +void NodeState::setNodeGroup(Uint32 group){ + nodeGroup = group; +} + +inline +void NodeState::setSingleUser(Uint32 s) { + singleUserMode = s; +} + +inline +void NodeState::setSingleUserApi(Uint32 n) { + singleUserApi = n; +} +inline +bool NodeState::getNodeRestartInProgress() const { + return startLevel == SL_STARTING && + (starting.restartType == ST_NODE_RESTART || + starting.restartType == ST_INITIAL_NODE_RESTART); +} + +inline +bool NodeState::getSingleUserMode() const { + return singleUserMode; +} + +inline +Uint32 NodeState::getSingleUserApi() const { + return singleUserApi; +} + +inline +bool NodeState::getSystemRestartInProgress() const { + return startLevel == SL_STARTING && starting.restartType == ST_SYSTEM_RESTART; +} + +inline +NdbOut & +operator<<(NdbOut& ndbout, const NodeState & state){ + ndbout << "[NodeState: startLevel: "; + switch(state.startLevel){ + case NodeState::SL_NOTHING: + ndbout << " ]"; + break; + case NodeState::SL_CMVMI: + ndbout << " ]"; + break; + case NodeState::SL_STARTING: + ndbout << " ]"; + break; + case NodeState::SL_STARTED: + ndbout << " ]"; + break; + case NodeState::SL_STOPPING_1: + ndbout << " ]"; + break; + case NodeState::SL_STOPPING_2: + ndbout << " ]"; + break; + case NodeState::SL_STOPPING_3: + ndbout << " ]"; + break; + case NodeState::SL_STOPPING_4: + ndbout << " ]"; + break; + default: + ndbout << " ]"; + } + return ndbout; +} + +#endif diff --git a/ndb/include/kernel/RefConvert.hpp b/ndb/include/kernel/RefConvert.hpp new file mode 100644 index 00000000000..7604b1cf224 --- /dev/null +++ b/ndb/include/kernel/RefConvert.hpp @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef REFCONVERT_H +#define REFCONVERT_H + +#include "kernel_types.h" + +/** + * Convert BlockReference to BlockNumber + */ +inline +BlockNumber refToBlock(BlockReference ref){ + return (BlockNumber)(ref >> 16); +} + +/** + * Convert BlockReference to NodeId + */ +inline +NodeId refToNode(BlockReference ref){ + return (NodeId)(ref & 0xFFFF); +} + +/** + * Convert NodeId and BlockNumber to BlockReference + */ +inline +BlockReference numberToRef(BlockNumber bnr, NodeId proc){ + return (((Uint32)bnr) << 16) + proc; +} + +#endif + diff --git a/ndb/include/kernel/kernel_types.h b/ndb/include/kernel/kernel_types.h new file mode 100644 index 00000000000..b176d20798c --- /dev/null +++ b/ndb/include/kernel/kernel_types.h @@ -0,0 +1,43 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_KERNEL_TYPES_H +#define NDB_KERNEL_TYPES_H + +#include + +typedef Uint16 NodeId; +typedef Uint16 BlockNumber; +typedef Uint32 BlockReference; +typedef Uint16 GlobalSignalNumber; + +enum Operation_t { + ZREAD = 0 + ,ZUPDATE = 1 + ,ZINSERT = 2 + ,ZDELETE = 3 + ,ZWRITE = 4 + ,ZREAD_EX = 5 +#if 0 + ,ZREAD_CONSISTENT = 6 +#endif +}; + +#endif + + + + diff --git a/ndb/include/kernel/ndb_limits.h b/ndb/include/kernel/ndb_limits.h new file mode 100644 index 00000000000..65f729af1f2 --- /dev/null +++ b/ndb/include/kernel/ndb_limits.h @@ -0,0 +1,94 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_LIMITS_H +#define NDB_LIMITS_H + +#define RNIL 0xffffff00 + +/** + * Note that actual value = MAX_NODES - 1, + * since NodeId = 0 can not be used + */ +#define MAX_NDB_NODES 49 +#define MAX_NODES 64 + +/** + * MAX_API_NODES = MAX_NODES - No of NDB Nodes in use + */ + +/** + * The maximum number of replicas in the system + */ +#define MAX_REPLICAS 4 + +/** + * The maximum number of local checkpoints stored at a time + */ +#define MAX_LCP_STORED 3 + +/** + * The maximum number of log execution rounds at system restart + */ +#define MAX_LOG_EXEC 4 + +/** + * The maximum number of tuples per page + **/ +#define MAX_TUPLES_PER_PAGE 8191 +#define MAX_TUPLES_BITS 13 /* 13 bits = 8191 tuples per page */ +//#define MAX_NO_OF_TUPLEKEY 16 Not currently used +#define MAX_TABLES 1600 +#define MAX_TAB_NAME_SIZE 128 +#define MAX_ATTR_NAME_SIZE 32 +#define MAX_ATTR_DEFAULT_VALUE_SIZE 128 +#define MAX_ATTRIBUTES_IN_TABLE 128 +#define MAX_ATTRIBUTES_IN_INDEX 32 +#define MAX_TUPLE_SIZE_IN_WORDS 2013 +#define MAX_FIXED_KEY_LENGTH_IN_WORDS 8 +#define MAX_KEY_SIZE_IN_WORDS 1023 +#define MAX_FRM_DATA_SIZE 6000 + +#define MIN_ATTRBUF ((MAX_ATTRIBUTES_IN_TABLE/24) + 1) +/* + * Number of Records to fetch per SCAN_NEXTREQ in a scan in LQH. The + * API can order a multiple of this number of records at a time since + * fragments can be scanned in parallel. + */ +#define MAX_PARALLEL_OP_PER_SCAN 16 +/* + * Maximum number of Parallel Scan queries on one hash index fragment + */ +#define MAX_PARALLEL_SCANS_PER_FRAG 12 +/* + * Maximum parallel ordered index scans per primary table fragment. + * Implementation limit is (256 minus 12). + */ +#define MAX_PARALLEL_INDEX_SCANS_PER_FRAG 32 + +/** + * Computed defines + */ +#define MAXNROFATTRIBUTESINWORDS (MAX_ATTRIBUTES_IN_TABLE / 32) + +/* + * Ordered index constants. Make configurable per index later. + */ +#define MAX_TTREE_NODE_SIZE 64 // total words in node +#define MAX_TTREE_PREF_SIZE 4 // words in min/max prefix each +#define MAX_TTREE_NODE_SLACK 3 // diff between max and min occupancy + +#endif diff --git a/ndb/include/kernel/signaldata/AbortAll.hpp b/ndb/include/kernel/signaldata/AbortAll.hpp new file mode 100644 index 00000000000..a3d7f483953 --- /dev/null +++ b/ndb/include/kernel/signaldata/AbortAll.hpp @@ -0,0 +1,88 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ABORT_ALL_REQ_HPP +#define ABORT_ALL_REQ_HPP + +#include "SignalData.hpp" + +class AbortAllReq { + + /** + * Reciver(s) + */ + friend class Dbtc; + + /** + * Sender + */ + friend class Ndbcntr; + +public: + STATIC_CONST( SignalLength = 2 ); + +public: + + Uint32 senderRef; + Uint32 senderData; +}; + +class AbortAllConf { + + /** + * Reciver(s) + */ + friend class Ndbcntr; + + /** + * Sender + */ + friend class Dbtc; + +public: + STATIC_CONST( SignalLength = 1 ); + +public: + Uint32 senderData; +}; + +class AbortAllRef { + + /** + * Reciver(s) + */ + friend class Ndbcntr; + + /** + * Sender + */ + friend class Dbtc; + +public: + STATIC_CONST( SignalLength = 2 ); + + enum ErrorCode { + InvalidState = 1, + AbortAlreadyInProgress = 2, + FunctionNotImplemented = 3 + }; +public: + Uint32 senderData; + Uint32 errorCode; +}; + +#endif + diff --git a/ndb/include/kernel/signaldata/AccFrag.hpp b/ndb/include/kernel/signaldata/AccFrag.hpp new file mode 100644 index 00000000000..e28ab0d1ee6 --- /dev/null +++ b/ndb/include/kernel/signaldata/AccFrag.hpp @@ -0,0 +1,89 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ACC_FRAG_HPP +#define ACC_FRAG_HPP + +#include "SignalData.hpp" + +class AccFragReq { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Receiver(s) + */ + friend class Dbacc; +public: + STATIC_CONST( SignalLength = 12 ); + +private: + Uint32 userPtr; + Uint32 userRef; + Uint32 tableId; + Uint32 reqInfo; + Uint32 fragId; + Uint32 localKeyLen; + Uint32 maxLoadFactor; + Uint32 minLoadFactor; + Uint32 kValue; + Uint32 lhFragBits; + Uint32 lhDirBits; + Uint32 keyLength; +}; + +class AccFragConf { + /** + * Sender(s) + */ + friend class Dbacc; + + /** + * Receiver(s) + */ + friend class Dblqh; +public: + STATIC_CONST( SignalLength = 7 ); + +private: + Uint32 userPtr; + Uint32 rootFragPtr; + Uint32 fragId[2]; + Uint32 fragPtr[2]; + Uint32 rootHashCheck; +}; + +class AccFragRef { + /** + * Sender(s) + */ + friend class Dbacc; + + /** + * Receiver(s) + */ + friend class Dblqh; +public: + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 userPtr; + Uint32 errorCode; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/AccLock.hpp b/ndb/include/kernel/signaldata/AccLock.hpp new file mode 100644 index 00000000000..1a41b4c9334 --- /dev/null +++ b/ndb/include/kernel/signaldata/AccLock.hpp @@ -0,0 +1,65 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ACC_LOCK_HPP +#define ACC_LOCK_HPP + +#include "SignalData.hpp" + +/* + * Lock or unlock tuple. If lock request is queued, the reply is later + * via ACCKEYCONF. + */ +class AccLockReq { + friend class Dbtux; + friend class Dbacc; + friend bool printACC_LOCKREQ(FILE *, const Uint32*, Uint32, Uint16); +public: + enum RequestType { // first byte + LockShared = 1, + LockExclusive = 2, + Unlock = 3, + Abort = 4, + AbortWithConf = 5 + }; + enum RequestFlag { // second byte + }; + enum ReturnCode { + Success = 0, + IsBlocked = 1, // was put in lock queue + WouldBlock = 2, // if we add non-blocking option + Refused = 3, + NoFreeOp = 4 + }; + STATIC_CONST( LockSignalLength = 12 ); + STATIC_CONST( UndoSignalLength = 3 ); +private: + Uint32 returnCode; + Uint32 requestInfo; + Uint32 accOpPtr; + // rest only if lock request + Uint32 userPtr; + Uint32 userRef; + Uint32 tableId; + Uint32 fragId; + Uint32 fragPtrI; + Uint32 hashValue; + Uint32 tupAddr; + Uint32 transId1; + Uint32 transId2; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/AccScan.hpp b/ndb/include/kernel/signaldata/AccScan.hpp new file mode 100644 index 00000000000..eab1c3262fc --- /dev/null +++ b/ndb/include/kernel/signaldata/AccScan.hpp @@ -0,0 +1,164 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ACC_SCAN_HPP +#define ACC_SCAN_HPP + +#include "SignalData.hpp" + +/* + * Used by ACC and TUX scan. + */ + +class AccScanReq { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Reciver(s) + */ + friend class Dbacc; + friend class Dbtux; +public: + STATIC_CONST( SignalLength = 8 ); + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 tableId; + Uint32 fragmentNo; + Uint32 requestInfo; + Uint32 transId1; + Uint32 transId2; + Uint32 savePointId; + + /** + * Previously there where also a scan type + */ + static Uint32 getLockMode(const Uint32 & requestInfo); + static Uint32 getKeyinfoFlag(const Uint32 & requestInfo); + static Uint32 getReadCommittedFlag(const Uint32 & requestInfo); + + static void setLockMode(Uint32 & requestInfo, Uint32 lockMode); + static void setKeyinfoFlag(Uint32 & requestInfo, Uint32 keyinfo); + static void setReadCommittedFlag(Uint32 & requestInfo, Uint32 readCommitted); +}; + +/** + * Request Info + * + * l = Lock Mode - 1 Bit 2 + * k = Keyinfo - 1 Bit 4 + * h = Read Committed - 1 Bit 5 + * + * 1111111111222222222233 + * 01234567890123456789012345678901 + * l kh + */ +#define AS_LOCK_MODE_SHIFT (2) +#define AS_LOCK_MODE_MASK (1) + +#define AS_KEYINFO_SHIFT (4) +#define AS_READ_COMMITTED_SHIFT (5) + +inline +Uint32 +AccScanReq::getLockMode(const Uint32 & requestInfo){ + return (requestInfo >> AS_LOCK_MODE_SHIFT) & AS_LOCK_MODE_MASK; +} + +inline +Uint32 +AccScanReq::getKeyinfoFlag(const Uint32 & requestInfo){ + return (requestInfo >> AS_KEYINFO_SHIFT) & 1; +} + +inline +Uint32 +AccScanReq::getReadCommittedFlag(const Uint32 & requestInfo){ + return (requestInfo >> AS_READ_COMMITTED_SHIFT) & 1; +} + +inline +void +AccScanReq::setLockMode(UintR & requestInfo, UintR val){ + ASSERT_MAX(val, AS_LOCK_MODE_MASK, "AccScanReq::setLockMode"); + requestInfo |= (val << AS_LOCK_MODE_SHIFT); +} + +inline +void +AccScanReq::setKeyinfoFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "AccScanReq::setKeyinfoFlag"); + requestInfo |= (val << AS_KEYINFO_SHIFT); +} + +inline +void +AccScanReq::setReadCommittedFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "AccScanReq::setReadCommittedFlag"); + requestInfo |= (val << AS_READ_COMMITTED_SHIFT); +} + +class AccScanConf { + /** + * Sender(s) + */ + friend class Dbacc; + friend class Dbtux; + + /** + * Reciver(s) + */ + friend class Dblqh; + + enum { + ZEMPTY_FRAGMENT = 0, + ZNOT_EMPTY_FRAGMENT = 1 + }; + +public: + STATIC_CONST( SignalLength = 8 ); + +private: + Uint32 scanPtr; + Uint32 accPtr; + Uint32 unused1; + Uint32 unused2; + Uint32 unused3; + Uint32 unused4; + Uint32 unused5; + Uint32 flag; +}; + +class AccCheckScan { + friend class Dbacc; + friend class Dbtux; + friend class Dblqh; + enum { + ZCHECK_LCP_STOP = 0, + ZNOT_CHECK_LCP_STOP = 1 + }; +public: + STATIC_CONST( SignalLength = 2 ); +private: + Uint32 accPtr; // scanptr.i in ACC or TUX + Uint32 checkLcpStop; // from enum +}; + +#endif diff --git a/ndb/include/kernel/signaldata/AccSizeAltReq.hpp b/ndb/include/kernel/signaldata/AccSizeAltReq.hpp new file mode 100644 index 00000000000..ac348444826 --- /dev/null +++ b/ndb/include/kernel/signaldata/AccSizeAltReq.hpp @@ -0,0 +1,53 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ACC_SIZE_ALT_REQ_H +#define ACC_SIZE_ALT_REQ_H + +#include "SignalData.hpp" + +class AccSizeAltReq { + /** + * Sender(s) + */ + friend class ClusterConfiguration; + + /** + * Reciver(s) + */ + friend class Dbacc; +private: + /** + * Indexes in theData + */ + STATIC_CONST( IND_BLOCK_REF = 0 ); + STATIC_CONST( IND_DIR_RANGE = 1 ); + STATIC_CONST( IND_DIR_ARRAY = 2 ); + STATIC_CONST( IND_FRAGMENT = 3 ); + STATIC_CONST( IND_OP_RECS = 4 ); + STATIC_CONST( IND_OVERFLOW_RECS = 5 ); + STATIC_CONST( IND_PAGE8 = 6 ); + STATIC_CONST( IND_ROOT_FRAG = 7 ); + STATIC_CONST( IND_TABLE = 8 ); + STATIC_CONST( IND_SCAN = 9 ); + + /** + * Use the index definitions to use the signal data + */ + UintR theData[10]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/AlterIndx.hpp b/ndb/include/kernel/signaldata/AlterIndx.hpp new file mode 100644 index 00000000000..1f464ded010 --- /dev/null +++ b/ndb/include/kernel/signaldata/AlterIndx.hpp @@ -0,0 +1,268 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ALTER_INDX_HPP +#define ALTER_INDX_HPP + +#include "SignalData.hpp" +#include +#include + +/** + * AlterIndxReq. + */ +class AlterIndxReq { + friend bool printALTER_INDX_REQ(FILE*, const Uint32*, Uint32, Uint16); + +public: + enum RequestType { + RT_UNDEFINED = 0, + RT_USER = 1, + RT_CREATE_INDEX = 2, + RT_DROP_INDEX = 3, + RT_SYSTEMRESTART = 4, + RT_NODERESTART = 5, + RT_DICT_PREPARE = 1 << 4, + RT_DICT_TC = 5 << 4, + RT_DICT_COMMIT = 0xC << 4, + RT_DICT_ABORT = 0xF << 4, + RT_TC = 5 << 8, + RT_TUX = 8 << 8 + }; + STATIC_CONST( SignalLength = 7 ); + +private: + Uint32 m_userRef; + Uint32 m_connectionPtr; + Uint32 m_requestInfo; + Uint32 m_tableId; + Uint32 m_indexId; // only set by DICT + Uint32 m_indexVersion; + Uint32 m_online; // new state 0-offline 1-online + // extra + Uint32 m_opKey; + +public: + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getConnectionPtr() const { + return m_connectionPtr; + } + void setConnectionPtr(Uint32 val) { + m_connectionPtr = val; + } + AlterIndxReq::RequestType getRequestType() const { + const Uint32 val = BitmaskImpl::getField(1, &m_requestInfo, 0, 16); + return (AlterIndxReq::RequestType)val; + } + void setRequestType(AlterIndxReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getRequestFlag() const { + return BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + }; + void addRequestFlag(Uint32 val) { + val |= BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + BitmaskImpl::setField(1, &m_requestInfo, 16, 16, val); + }; + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + Uint32 getIndexId() const { + return m_indexId; + } + void setIndexId(Uint32 val) { + m_indexId = val; + } + Uint32 getIndexVersion() const { + return m_indexVersion; + } + void setIndexVersion(Uint32 val) { + m_indexVersion = val; + } + Uint32 getOnline() const { + return m_online; + } + void setOnline(Uint32 val) { + m_online = val; + } + Uint32 getOpKey() const { + return m_opKey; + } + void setOpKey(Uint32 val) { + m_opKey = val; + } +}; + +/** + * AlterIndxConf. + */ +class AlterIndxConf { + friend bool printALTER_INDX_CONF(FILE*, const Uint32*, Uint32, Uint16); + +public: + STATIC_CONST( InternalLength = 3 ); + STATIC_CONST( SignalLength = 6 ); + +private: + Uint32 m_userRef; + Uint32 m_connectionPtr; + Uint32 m_requestInfo; + Uint32 m_tableId; + Uint32 m_indexId; + Uint32 m_indexVersion; + +public: + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getConnectionPtr() const { + return m_connectionPtr; + } + void setConnectionPtr(Uint32 val) { + m_connectionPtr = val; + } + AlterIndxReq::RequestType getRequestType() const { + return (AlterIndxReq::RequestType)m_requestInfo; + } + void setRequestType(AlterIndxReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + Uint32 getIndexId() const { + return m_indexId; + } + void setIndexId(Uint32 val) { + m_indexId = val; + } + Uint32 getIndexVersion() const { + return m_indexVersion; + } + void setIndexVersion(Uint32 val) { + m_indexVersion = val; + } +}; + +/** + * AlterIndxRef. + */ +class AlterIndxRef { + friend bool printALTER_INDX_REF(FILE*, const Uint32*, Uint32, Uint16); + +public: + enum ErrorCode { + NoError = 0, + Busy = 701, + IndexNotFound = 4243, + IndexExists = 4244, + BadRequestType = 4247, + NotAnIndex = 4254, + BadState = 4347, + Inconsistency = 4348 + }; + STATIC_CONST( SignalLength = AlterIndxConf::SignalLength + 3 ); + +private: + AlterIndxConf m_conf; + //Uint32 m_userRef; + //Uint32 m_connectionPtr; + //Uint32 m_requestInfo; + //Uint32 m_tableId; + //Uint32 m_indexId; + //Uint32 m_indexVersion; + Uint32 m_errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + +public: + AlterIndxConf* getConf() { + return &m_conf; + } + const AlterIndxConf* getConf() const { + return &m_conf; + } + Uint32 getUserRef() const { + return m_conf.getUserRef(); + } + void setUserRef(Uint32 val) { + m_conf.setUserRef(val); + } + Uint32 getConnectionPtr() const { + return m_conf.getConnectionPtr(); + } + void setConnectionPtr(Uint32 val) { + m_conf.setConnectionPtr(val); + } + AlterIndxReq::RequestType getRequestType() const { + return m_conf.getRequestType(); + } + void setRequestType(AlterIndxReq::RequestType val) { + m_conf.setRequestType(val); + } + Uint32 getTableId() const { + return m_conf.getTableId(); + } + void setTableId(Uint32 val) { + m_conf.setTableId(val); + } + Uint32 getIndexId() const { + return m_conf.getIndexId(); + } + void setIndexId(Uint32 val) { + m_conf.setIndexId(val); + } + Uint32 getIndexVersion() const { + return m_conf.getIndexVersion(); + } + void setIndexVersion(Uint32 val) { + m_conf.setIndexVersion(val); + } + AlterIndxRef::ErrorCode getErrorCode() const { + return (AlterIndxRef::ErrorCode)m_errorCode; + } + void setErrorCode(AlterIndxRef::ErrorCode val) { + m_errorCode = (Uint32)val; + } + Uint32 getErrorLine() const { + return m_errorLine; + } + void setErrorLine(Uint32 val) { + m_errorLine = val; + } + Uint32 getErrorNode() const { + return m_errorNode; + } + void setErrorNode(Uint32 val) { + m_errorNode = val; + } +}; + +#endif diff --git a/ndb/include/kernel/signaldata/AlterTab.hpp b/ndb/include/kernel/signaldata/AlterTab.hpp new file mode 100644 index 00000000000..02d4eb95d2e --- /dev/null +++ b/ndb/include/kernel/signaldata/AlterTab.hpp @@ -0,0 +1,125 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ALTER_TAB_HPP +#define ALTER_TAB_HPP + +#include "SignalData.hpp" +#include "GlobalSignalNumbers.h" + +/** + * AlterTab + * + * Implemenatation of AlterTable + */ +class AlterTabReq { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdict; + friend class Dbdih; + friend class Dbtc; + friend class Dblqh; + + /** + * For printing + */ + friend bool printALTER_TAB_REQ(FILE*, const Uint32*, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 9 ); + + enum RequestType { + AlterTablePrepare = 0, // Prepare alter table + AlterTableCommit = 1, // Commit alter table + AlterTableRevert = 2 // Prepare failed, revert instead + }; +private: + Uint32 senderRef; + Uint32 senderData; + Uint32 clientRef; + Uint32 clientData; + + Uint32 changeMask; + Uint32 tableId; + Uint32 tableVersion; + Uint32 gci; + Uint32 requestType; + + SECTION( DICT_TAB_INFO = 0 ); +}; + +struct AlterTabRef { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdict; + friend class Dbdih; + friend class Dbtc; + friend class Dblqh; + friend class Dbtup; + friend class SafeCounter; + + /** + * For printing + */ + friend bool printALTER_TAB_REF(FILE *, const Uint32 *, Uint32, Uint16); + + STATIC_CONST( SignalLength = 7 ); + STATIC_CONST( GSN = GSN_ALTER_TAB_REF ); + + enum ErrorCode { + NF_FakeErrorREF = 255 + }; + + Uint32 senderRef; + Uint32 senderData; + Uint32 errorCode; + Uint32 errorLine; + Uint32 errorKey; + Uint32 errorStatus; + Uint32 requestType; +}; + +class AlterTabConf { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdict; + friend class Dbdih; + friend class Dbtc; + friend class Dblqh; + friend class Dbtup; + + /** + * For printing + */ + friend bool printALTER_TAB_CONF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 7 ); + +private: + Uint32 senderRef; + Uint32 senderData; + Uint32 changeMask; + Uint32 tableId; + Uint32 tableVersion; + Uint32 gci; + Uint32 requestType; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/AlterTable.hpp b/ndb/include/kernel/signaldata/AlterTable.hpp new file mode 100644 index 00000000000..30f8727551d --- /dev/null +++ b/ndb/include/kernel/signaldata/AlterTable.hpp @@ -0,0 +1,179 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ALTER_TABLE_HPP +#define ALTER_TABLE_HPP + +#include "SignalData.hpp" + +/** + * AlterTable + * + * This signal is sent by API to DICT/TRIX + * as a request to alter a secondary index + * and then from TRIX to TRIX(n) and TRIX to TC. + */ +class AlterTableReq { + /** + * Sender(s) + */ + // API + + /** + * Sender(s) / Reciver(s) + */ + friend class NdbTableImpl; + friend class NdbDictInterface; + friend class Dbdict; + + /** + * For printing + */ + friend bool printALTER_TABLE_REQ(FILE*, const Uint32*, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 5 ); + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 changeMask; + Uint32 tableId; + Uint32 tableVersion; + + SECTION( DICT_TAB_INFO = 0 ); + +/** + * ChangeMask + */ + +/* + n = Changed name + + 1111111111222222222233 + 01234567890123456789012345678901 + n------------------------------- +*/ +#define NAME_SHIFT (0) + + /** + * Getters and setters + */ + static Uint8 getNameFlag(const UintR & changeMask); + static void setNameFlag(UintR & changeMask, Uint32 nameFlg); +}; + +inline +Uint8 +AlterTableReq::getNameFlag(const UintR & changeMask){ + return (Uint8)((changeMask >> NAME_SHIFT) & 1); +} + +inline +void +AlterTableReq::setNameFlag(UintR & changeMask, Uint32 nameFlg){ + changeMask |= (nameFlg << NAME_SHIFT); +} + + +class AlterTableRef { + /** + * Sender(s) + */ + friend class Dbdict; + + /** + * Sender(s) / Reciver(s) + */ + friend class Ndbcntr; + friend class NdbDictInterface; + + /** + * For printing + */ + friend bool printALTER_TABLE_REF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 7 ); + + enum ErrorCode { + NoError = 0, + InvalidTableVersion = 241, + DropInProgress = 283, + Busy = 701, + NotMaster = 702, + InvalidFormat = 703, + AttributeNameTooLong = 704, + TableNameTooLong = 705, + Inconsistency = 706, + NoMoreTableRecords = 707, + NoMoreAttributeRecords = 708, + NoSuchTable = 709, + AttributeNameTwice = 720, + TableAlreadyExist = 721, + ArraySizeTooBig = 737, + RecordTooBig = 738, + InvalidPrimaryKeySize = 739, + NullablePrimaryKey = 740, + UnsupportedChange = 741 + }; + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 masterNodeId; + Uint32 errorCode; + Uint32 errorLine; + Uint32 errorKey; + Uint32 status; + +public: + Uint32 getErrorCode() const { + return errorCode; + } + Uint32 getErrorLine() const { + return errorLine; + } +}; + +class AlterTableConf { + /** + * Sender(s) + */ + friend class Dbdict; + + /** + * Sender(s) / Reciver(s) + */ + friend class Ndbcntr; + friend class NdbDictInterface; + + /** + * For printing + */ + friend bool printALTER_TABLE_CONF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 tableId; + Uint32 tableVersion; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/AlterTrig.hpp b/ndb/include/kernel/signaldata/AlterTrig.hpp new file mode 100644 index 00000000000..a97c1fd0196 --- /dev/null +++ b/ndb/include/kernel/signaldata/AlterTrig.hpp @@ -0,0 +1,288 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ALTER_TRIG_HPP +#define ALTER_TRIG_HPP + +#include "SignalData.hpp" +#include +#include + +/** + * AlterTrigReq. + */ +class AlterTrigReq { + friend bool printALTER_TRIG_REQ(FILE*, const Uint32*, Uint32, Uint16); + +public: + enum RequestType { + RT_UNDEFINED = 0, + RT_USER = 1, + RT_CREATE_TRIGGER = 2, + RT_DROP_TRIGGER = 3, + RT_DICT_PREPARE = 1 << 4, + RT_DICT_TC = 5 << 4, + RT_DICT_LQH = 6 << 4, + RT_DICT_COMMIT = 0xC << 4, + RT_DICT_ABORT = 0xF << 4 + }; + STATIC_CONST( SignalLength = 8 ); + +private: + Uint32 m_userRef; + Uint32 m_connectionPtr; + Uint32 m_requestInfo; + Uint32 m_tableId; + Uint32 m_triggerId; + Uint32 m_triggerInfo; + Uint32 m_online; // new state 0-offline 1-online + Uint32 m_receiverRef; // receiver for subscription trigger + // extra + Uint32 m_opKey; + +public: + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getConnectionPtr() const { + return m_connectionPtr; + } + void setConnectionPtr(Uint32 val) { + m_connectionPtr = val; + } + AlterTrigReq::RequestType getRequestType() const { + const Uint32 val = BitmaskImpl::getField(1, &m_requestInfo, 0, 16); + return (AlterTrigReq::RequestType)val; + } + void setRequestType(AlterTrigReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getRequestFlag() const { + return BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + }; + void addRequestFlag(Uint32 val) { + val |= BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + BitmaskImpl::setField(1, &m_requestInfo, 16, 16, val); + }; + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + Uint32 getTriggerId() const { + return m_triggerId; + } + void setTriggerId(Uint32 val) { + m_triggerId = val; + } + Uint32 getTriggerInfo() const { + return m_triggerInfo; + } + void setTriggerInfo(Uint32 val) { + m_triggerInfo = val; + } + TriggerType::Value getTriggerType() const { + const Uint32 val = BitmaskImpl::getField(1, &m_triggerInfo, 0, 8); + return (TriggerType::Value)val; + } + void setTriggerType(TriggerType::Value val) { + BitmaskImpl::setField(1, &m_triggerInfo, 0, 8, (Uint32)val); + } + TriggerActionTime::Value getTriggerActionTime() const { + const Uint32 val = BitmaskImpl::getField(1, &m_triggerInfo, 8, 8); + return (TriggerActionTime::Value)val; + } + void setTriggerActionTime(TriggerActionTime::Value val) { + BitmaskImpl::setField(1, &m_triggerInfo, 8, 8, (Uint32)val); + } + TriggerEvent::Value getTriggerEvent() const { + const Uint32 val = BitmaskImpl::getField(1, &m_triggerInfo, 16, 8); + return (TriggerEvent::Value)val; + } + void setTriggerEvent(TriggerEvent::Value val) { + BitmaskImpl::setField(1, &m_triggerInfo, 16, 8, (Uint32)val); + } + bool getMonitorReplicas() const { + return BitmaskImpl::getField(1, &m_triggerInfo, 24, 1); + } + void setMonitorReplicas(bool val) { + BitmaskImpl::setField(1, &m_triggerInfo, 24, 1, val); + } + bool getMonitorAllAttributes() const { + return BitmaskImpl::getField(1, &m_triggerInfo, 25, 1); + } + void setMonitorAllAttributes(bool val) { + BitmaskImpl::setField(1, &m_triggerInfo, 25, 1, val); + } + Uint32 getOnline() const { + return m_online; + } + void setOnline(Uint32 val) { + m_online = val; + } + Uint32 getReceiverRef() const { + return m_receiverRef; + } + void setReceiverRef(Uint32 val) { + m_receiverRef = val; + } + Uint32 getOpKey() const { + return m_opKey; + } + void setOpKey(Uint32 val) { + m_opKey = val; + } +}; + +/** + * AlterTrigConf. + */ +class AlterTrigConf { + friend bool printALTER_TRIG_CONF(FILE*, const Uint32*, Uint32, Uint16); + +public: + STATIC_CONST( InternalLength = 3 ); + STATIC_CONST( SignalLength = 5 ); + +private: + Uint32 m_userRef; + Uint32 m_connectionPtr; + Uint32 m_requestInfo; + Uint32 m_tableId; + Uint32 m_triggerId; + +public: + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getConnectionPtr() const { + return m_connectionPtr; + } + void setConnectionPtr(Uint32 val) { + m_connectionPtr = val; + } + AlterTrigReq::RequestType getRequestType() const { + return (AlterTrigReq::RequestType)m_requestInfo; + } + void setRequestType(AlterTrigReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + Uint32 getTriggerId() const { + return m_triggerId; + } + void setTriggerId(Uint32 val) { + m_triggerId = val; + } +}; + +/** + * AlterTrigRef. + */ +class AlterTrigRef { + friend bool printALTER_TRIG_REF(FILE*, const Uint32*, Uint32, Uint16); + +public: + enum ErrorCode { + NoError = 0, + Busy = 701, + TriggerNotFound = 4238, + TriggerExists = 4239, + BadRequestType = 4247 + }; + STATIC_CONST( SignalLength = AlterTrigConf::SignalLength + 3 ); + +private: + AlterTrigConf m_conf; + //Uint32 m_userRef; + //Uint32 m_connectionPtr; + //Uint32 m_requestInfo; + //Uint32 m_tableId; + //Uint32 m_triggerId; + Uint32 m_errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + +public: + AlterTrigConf* getConf() { + return &m_conf; + } + const AlterTrigConf* getConf() const { + return &m_conf; + } + Uint32 getUserRef() const { + return m_conf.getUserRef(); + } + void setUserRef(Uint32 val) { + m_conf.setUserRef(val); + } + Uint32 getConnectionPtr() const { + return m_conf.getConnectionPtr(); + } + void setConnectionPtr(Uint32 val) { + m_conf.setConnectionPtr(val); + } + AlterTrigReq::RequestType getRequestType() const { + return m_conf.getRequestType(); + } + void setRequestType(AlterTrigReq::RequestType val) { + m_conf.setRequestType(val); + } + Uint32 getTableId() const { + return m_conf.getTableId(); + } + void setTableId(Uint32 val) { + m_conf.setTableId(val); + } + Uint32 getTriggerId() const { + return m_conf.getTriggerId(); + } + void setTriggerId(Uint32 val) { + m_conf.setTriggerId(val); + } + ErrorCode getErrorCode() const { + return (ErrorCode)m_errorCode; + } + void setErrorCode(ErrorCode val) { + m_errorCode = (Uint32)val; + } + Uint32 getErrorLine() const { + return m_errorLine; + } + void setErrorLine(Uint32 val) { + m_errorLine = val; + } + Uint32 getErrorNode() const { + return m_errorNode; + } + void setErrorNode(Uint32 val) { + m_errorNode = val; + } +}; + +#endif diff --git a/ndb/include/kernel/signaldata/ApiRegSignalData.hpp b/ndb/include/kernel/signaldata/ApiRegSignalData.hpp new file mode 100644 index 00000000000..84dca8fb260 --- /dev/null +++ b/ndb/include/kernel/signaldata/ApiRegSignalData.hpp @@ -0,0 +1,92 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef API_REGCONF_HPP +#define API_REGCONF_HPP + +#include + +class ApiRegReq { + /** + * Sender(s) + */ + friend class ClusterMgr; + + /** + * Reciver(s) + */ + friend class Qmgr; + +public: + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 ref; + Uint32 version; // Version of API node +}; + +/** + * + */ +class ApiRegRef { + /** + * Sender(s) + */ + friend class Qmgr; + + /** + * Reciver(s) + */ + friend class ClusterMgr; + +public: + STATIC_CONST( SignalLength = 3 ); + + enum ErrorCode { + WrongType = 1, + UnsupportedVersion = 2 + }; +private: + Uint32 ref; // Qmgr ref + Uint32 version; // Version of NDB node + Uint32 errorCode; +}; + +/** + * + */ +class ApiRegConf { + /** + * Sender(s) + */ + friend class Qmgr; + + /** + * Reciver(s) + */ + friend class ClusterMgr; + +public: + STATIC_CONST( SignalLength = 3 + NodeState::DataLength ); +private: + + Uint32 qmgrRef; + Uint32 version; // Version of NDB node + Uint32 apiHeartbeatFrequency; + NodeState nodeState; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/ApiVersion.hpp b/ndb/include/kernel/signaldata/ApiVersion.hpp new file mode 100644 index 00000000000..28281e7d186 --- /dev/null +++ b/ndb/include/kernel/signaldata/ApiVersion.hpp @@ -0,0 +1,60 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef API_VERSION_HPP +#define API_VERSION_HPP + +class ApiVersionReq { +/** + * Sender(s) + */ + friend class MgmtSrv; + + /** + * Reciver(s) + */ + friend class Qmgr; +public: + STATIC_CONST( SignalLength = 3 ); + Uint32 senderRef; + Uint32 nodeId; //api node id + Uint32 version; // Version of API node + + +}; + + + +class ApiVersionConf { +/** + * Sender(s) + */ + friend class Qmgr; + + /** + * Reciver(s) + */ + friend class MgmtSrv; +public: + STATIC_CONST( SignalLength = 3 ); + Uint32 senderRef; + Uint32 nodeId; //api node id + Uint32 version; // Version of API node + + +}; + +#endif diff --git a/ndb/include/kernel/signaldata/ArbitSignalData.hpp b/ndb/include/kernel/signaldata/ArbitSignalData.hpp new file mode 100644 index 00000000000..271b9920cd0 --- /dev/null +++ b/ndb/include/kernel/signaldata/ArbitSignalData.hpp @@ -0,0 +1,154 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ARBIT_SIGNAL_DATA_H +#define ARBIT_SIGNAL_DATA_H + +#include +#include +#include +#include +#include "SignalData.hpp" +#include "SignalDataPrint.hpp" + +/** + * The ticket. + */ +class ArbitTicket { +private: + Uint32 data[2]; + +public: + STATIC_CONST( DataLength = 2 ); + STATIC_CONST( TextLength = DataLength * 8 ); // hex digits + + inline void clear() { + data[0] = 0; + data[1] = 0; + } + + inline void update() { + Uint16 cnt = data[0] & 0xFFFF; // previous count + Uint16 pid = NdbHost_GetProcessId(); + data[0] = (pid << 16) | (cnt + 1); + data[1] = NdbTick_CurrentMillisecond(); + } + + inline bool match(ArbitTicket& aTicket) const { + return + data[0] == aTicket.data[0] && + data[1] == aTicket.data[1]; + } + + inline void getText(char *buf, size_t buf_len) const { + snprintf(buf, buf_len, "%08x%08x", data[0], data[1]); + } + +/* inline char* getText() const { + static char buf[TextLength + 1]; + getText(buf, sizeof(buf)); + return buf; + } */ +}; + +/** + * Result codes. Part of signal data. Each signal uses only + * a subset but a common namespace is convenient. + */ +class ArbitCode { +public: + STATIC_CONST( ErrTextLength = 80 ); + + enum { + NoInfo = 0, + + // CFG signals + CfgRank1 = 1, // these have to be 1 and 2 + CfgRank2 = 2, + + // QMGR continueB thread state + ThreadStart = 11, // continueB thread started + + // PREP signals + PrepPart1 = 21, // zero old ticket + PrepPart2 = 22, // get new ticket + PrepAtrun = 23, // late joiner gets ticket at RUN time + + // arbitrator state + ApiStart = 31, // arbitrator thread started + ApiFail = 32, // arbitrator died + ApiExit = 33, // arbitrator reported it will exit + + // arbitration result + LoseNodes = 41, // lose on ndb node count + WinGroups = 42, // we win, no need for arbitration + LoseGroups = 43, // we lose, missing node group + Partitioning = 44, // possible network partitioning + WinChoose = 45, // positive reply + LoseChoose = 46, // negative reply + LoseNorun = 47, // arbitrator required but not running + LoseNocfg = 48, // arbitrator required but none configured + + // general error codes + ErrTicket = 91, // invalid arbitrator-ticket + ErrToomany = 92, // too many requests + ErrState = 93, // invalid state + ErrTimeout = 94, // timeout waiting for signals + ErrUnknown = 95 // unknown error + }; + + static inline void getErrText(Uint32 code, char* buf, size_t buf_len) { + switch (code) { + case ErrTicket: + snprintf(buf, buf_len, "invalid arbitrator-ticket"); + break; + case ErrToomany: + snprintf(buf, buf_len, "too many requests"); + break; + case ErrState: + snprintf(buf, buf_len, "invalid state"); + break; + case ErrTimeout: + snprintf(buf, buf_len, "timeout"); + break; + default: + snprintf(buf, buf_len, "unknown error [code=%u]", code); + break; + } + } +}; + +/** + * Common class for arbitration signal data. + */ +class ArbitSignalData { +public: + Uint32 sender; // sender's node id (must be word 0) + Uint32 code; // result code or other info + Uint32 node; // arbitrator node id + ArbitTicket ticket; // ticket + NodeBitmask mask; // set of nodes + + STATIC_CONST( SignalLength = 3 + ArbitTicket::DataLength + NodeBitmask::Size ); + + inline bool match(ArbitSignalData& aData) const { + return + node == aData.node && + ticket.match(aData.ticket); + } +}; + +#endif diff --git a/ndb/include/kernel/signaldata/AttrInfo.hpp b/ndb/include/kernel/signaldata/AttrInfo.hpp new file mode 100644 index 00000000000..18bd9b22c40 --- /dev/null +++ b/ndb/include/kernel/signaldata/AttrInfo.hpp @@ -0,0 +1,52 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ATTRINFO_HPP +#define ATTRINFO_HPP + +#include "SignalData.hpp" + +class AttrInfo { + /** + * Sender(s) + */ + friend class DbUtil; + + /** + * Receiver(s) + */ + friend class Dbtup; + + /** + * Sender(s) / Receiver(s) + */ + friend class Dbtc; + friend class Dblqh; + + friend bool printATTRINFO(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( HeaderLength = 3 ); + STATIC_CONST( DataLength = 22 ); + STATIC_CONST( MaxSignalLength = HeaderLength + DataLength ); + +private: + Uint32 connectPtr; + Uint32 transId[2]; + Uint32 attrData[DataLength]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/BackupContinueB.hpp b/ndb/include/kernel/signaldata/BackupContinueB.hpp new file mode 100644 index 00000000000..d3d3f79f310 --- /dev/null +++ b/ndb/include/kernel/signaldata/BackupContinueB.hpp @@ -0,0 +1,38 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef BACKUP_CONTINUEB_H +#define BACKUP_CONTINUEB_H + +#include "SignalData.hpp" + +class BackupContinueB { + /** + * Sender(s)/Reciver(s) + */ + friend class Backup; + friend bool printCONTINUEB_BACKUP(FILE * output, const Uint32 * theData, Uint32 len); +private: + enum { + START_FILE_THREAD = 0, + BUFFER_UNDERFLOW = 1, + BUFFER_FULL_SCAN = 2, + BUFFER_FULL_FRAG_COMPLETE = 3, + BUFFER_FULL_META = 4 + }; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/BackupImpl.hpp b/ndb/include/kernel/signaldata/BackupImpl.hpp new file mode 100644 index 00000000000..1872069daa7 --- /dev/null +++ b/ndb/include/kernel/signaldata/BackupImpl.hpp @@ -0,0 +1,366 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef BACKUP_IMPL_HPP +#define BACKUP_IMPL_HPP + +#include "SignalData.hpp" +#include + +class DefineBackupReq { + /** + * Sender(s) + */ + friend class BackupMaster; + + /** + * Reciver(s) + */ + friend class Backup; + + friend bool printDEFINE_BACKUP_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 8 + NdbNodeBitmask::Size); + +private: + /** + * i - value of backup object + */ + Uint32 backupPtr; + + Uint32 backupId; + Uint32 clientRef; + Uint32 clientData; + Uint32 senderRef; + + /** + * Which node(s) is participating in the backup + */ + NdbNodeBitmask nodes; + + /** + * Generated random number + */ + Uint32 backupKey[2]; + + /** + * Length of backup data + */ + Uint32 backupDataLen; +}; + +class DefineBackupRef { + /** + * Sender(s) + */ + friend class Backup; + + /** + * Reciver(s) + */ + friend class BackupMaster; + + friend bool printDEFINE_BACKUP_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + + enum ErrorCode { + Undefined = 200, + FailedToAllocateBuffers = 202, + FailedToSetupFsBuffers = 203, + FailedToAllocateTables = 204, + FailedInsertFileHeader = 205, + FailedInsertTableList = 206, + FailedAllocateTableMem = 207, + FailedToAllocateFileRecord = 208, + FailedToAllocateAttributeRecord = 209 + }; +private: + Uint32 backupId; + Uint32 backupPtr; + Uint32 errorCode; +}; + +class DefineBackupConf { + /** + * Sender(s) + */ + friend class Backup; + + /** + * Reciver(s) + */ + friend class BackupMaster; + + friend bool printDEFINE_BACKUP_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 backupId; + Uint32 backupPtr; +}; + +class StartBackupReq { + /** + * Sender(s) + */ + friend class BackupMaster; + + /** + * Reciver(s) + */ + friend class Backup; + + friend bool printSTART_BACKUP_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + + STATIC_CONST( MaxTableTriggers = 4 ); + STATIC_CONST( HeaderLength = 5 ); + STATIC_CONST( TableTriggerLength = 4); + +private: + Uint32 backupId; + Uint32 backupPtr; + Uint32 signalNo; + Uint32 noOfSignals; + Uint32 noOfTableTriggers; + + struct TableTriggers { + Uint32 tableId; + Uint32 triggerIds[3]; + } tableTriggers[MaxTableTriggers]; +}; + +class StartBackupRef { + /** + * Sender(s) + */ + friend class Backup; + + /** + * Reciver(s) + */ + friend class BackupMaster; + + friend bool printSTART_BACKUP_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + enum ErrorCode { + FailedToAllocateTriggerRecord = 1 + }; +private: + Uint32 backupId; + Uint32 backupPtr; + Uint32 signalNo; + Uint32 errorCode; +}; + +class StartBackupConf { + /** + * Sender(s) + */ + friend class Backup; + + /** + * Reciver(s) + */ + friend class BackupMaster; + + friend bool printSTART_BACKUP_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 backupId; + Uint32 backupPtr; + Uint32 signalNo; +}; + +class BackupFragmentReq { + /** + * Sender(s) + */ + friend class BackupMaster; + + /** + * Reciver(s) + */ + friend class Backup; + + friend bool printBACKUP_FRAGMENT_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + +private: + Uint32 backupId; + Uint32 backupPtr; + Uint32 tableId; + Uint32 fragmentNo; + Uint32 count; +}; + +class BackupFragmentRef { + /** + * Sender(s) + */ + friend class Backup; + + /** + * Reciver(s) + */ + friend class BackupMaster; + + friend bool printBACKUP_FRAGMENT_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + +private: + Uint32 backupId; + Uint32 backupPtr; + Uint32 tableId; + Uint32 fragmentNo; + Uint32 errorCode; +}; + +class BackupFragmentConf { + /** + * Sender(s) + */ + friend class Backup; + + /** + * Reciver(s) + */ + friend class BackupMaster; + + friend bool printBACKUP_FRAGMENT_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 6 ); + +private: + Uint32 backupId; + Uint32 backupPtr; + Uint32 tableId; + Uint32 fragmentNo; + Uint32 noOfRecords; + Uint32 noOfBytes; +}; + +class StopBackupReq { + /** + * Sender(s) + */ + friend class BackupMaster; + + /** + * Reciver(s) + */ + friend class Backup; + + friend bool printSTOP_BACKUP_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 backupId; + Uint32 backupPtr; + Uint32 startGCP; + Uint32 stopGCP; +}; + +class StopBackupRef { + /** + * Sender(s) + */ + friend class Backup; + + /** + * Reciver(s) + */ + friend class BackupMaster; + + friend bool printSTOP_BACKUP_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 backupId; + Uint32 backupPtr; + Uint32 errorCode; +}; + +class StopBackupConf { + /** + * Sender(s) + */ + friend class Backup; + + /** + * Reciver(s) + */ + friend class BackupMaster; + + friend bool printSTOP_BACKUP_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 backupId; + Uint32 backupPtr; + Uint32 noOfLogBytes; + Uint32 noOfLogRecords; +}; + +class BackupStatusReq { + /** + * Sender(s) + */ + friend class BackupMaster; + + /** + * Reciver(s) + */ + friend class Backup; + + friend bool printBACKUP_STATUS_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 1 ); + +private: +}; + +class BackupStatusConf { + /** + * Sender(s) + */ + friend class Backup; + + /** + * Reciver(s) + */ + friend class BackupMaster; + + friend bool printBACKUP_STATUS_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 1 ); + +private: +}; + + +#endif diff --git a/ndb/include/kernel/signaldata/BackupSignalData.hpp b/ndb/include/kernel/signaldata/BackupSignalData.hpp new file mode 100644 index 00000000000..42eb8464d53 --- /dev/null +++ b/ndb/include/kernel/signaldata/BackupSignalData.hpp @@ -0,0 +1,252 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef BACKUP_HPP +#define BACKUP_HPP + +#include "SignalData.hpp" +#include + +/** + * Request to start a backup + */ +class BackupReq { + /** + * Sender(s) + */ + friend class MgmtSrvr; + + /** + * Reciver(s) + */ + friend class Backup; + + friend bool printBACKUP_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 senderData; + Uint32 backupDataLen; +}; + +class BackupData { + /** + * Sender(s) + */ + friend class BackupMaster; + + /** + * Reciver(s) + */ + friend class Backup; + + friend bool printBACKUP_DATA(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 25 ); + + enum KeyValues { + /** + * Buffer(s) and stuff + */ + BufferSize = 1, // In MB + BlockSize = 2, // Write in chunks of this (in bytes) + MinWrite = 3, // Minimum write as multiple of blocksize + MaxWrite = 4, // Maximum write as multiple of blocksize + + // Max throughput + // Parallell files + + NoOfTables = 1000, + TableName = 1001 // char* + }; +private: + enum RequestType { + ClientToMaster = 1, + MasterToSlave = 2 + }; + Uint32 requestType; + + union { + Uint32 backupPtr; + Uint32 senderData; + }; + Uint32 backupId; + + /** + * totalLen = totalLen_offset >> 16 + * offset = totalLen_offset & 0xFFFF + */ + Uint32 totalLen_offset; + + /** + * Length in this = signal->length() - 3 + * Sender block ref = signal->senderBlockRef() + */ + Uint32 backupData[21]; +}; + +/** + * The request to start a backup was refused + */ +class BackupRef { + /** + * Sender(s) + */ + friend class Backup; + + /** + * Reciver(s) + */ + friend class MgmtSrvr; + + friend bool printBACKUP_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + +private: + enum ErrorCodes { + Undefined = 100, + IAmNotMaster = 101, + OutOfBackupRecord = 102, + OutOfResources = 103, + SequenceFailure = 104, + BackupDefinitionNotImplemented = 105 + }; + Uint32 senderData; + Uint32 errorCode; + union { + Uint32 masterRef; + }; +}; + +/** + * The backup has started + */ +class BackupConf { + /** + * Sender(s) + */ + friend class Backup; + + /** + * Reciver(s) + */ + friend class MgmtSrvr; + + friend bool printBACKUP_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 2 + NdbNodeBitmask::Size ); + +private: + Uint32 senderData; + Uint32 backupId; + NdbNodeBitmask nodes; +}; + +/** + * A backup has been aborted + */ +class BackupAbortRep { + /** + * Sender(s) + */ + friend class Backup; + + /** + * Reciver(s) + */ + friend class MgmtSrvr; + + friend bool printBACKUP_ABORT_REP(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 senderData; + Uint32 backupId; + Uint32 reason; +}; + +/** + * A backup has been completed + */ +class BackupCompleteRep { + /** + * Sender(s) + */ + friend class Backup; + + /** + * Reciver(s) + */ + friend class MgmtSrvr; + + friend bool printBACKUP_COMPLETE_REP(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 8 + NdbNodeBitmask::Size ); +private: + Uint32 senderData; + Uint32 backupId; + Uint32 startGCP; + Uint32 stopGCP; + Uint32 noOfBytes; + Uint32 noOfRecords; + Uint32 noOfLogBytes; + Uint32 noOfLogRecords; + NdbNodeBitmask nodes; +}; + +/** + * A master has finished taking-over backup responsiblility + */ +class BackupNFCompleteRep { + friend bool printBACKUP_NF_COMPLETE_REP(FILE*, const Uint32*, Uint32, Uint16); +}; + +/** + * Abort of backup + */ +class AbortBackupOrd { + /** + * Sender / Reciver + */ + friend class Backup; + friend class MgmtSrvr; + + friend bool printABORT_BACKUP_ORD(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + + enum RequestType { + ClientAbort = 1, + BackupComplete = 2, + BackupFailure = 3, // General backup failure coordinator -> slave + LogBufferFull = 4, // slave -> coordinator + FileOrScanError = 5, // slave -> coordinator + BackupFailureDueToNodeFail = 6, // slave -> slave + OkToClean = 7 // master -> slave + }; +private: + Uint32 requestType; + Uint32 backupId; + union { + Uint32 backupPtr; + Uint32 senderData; + }; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/BlockCommitOrd.hpp b/ndb/include/kernel/signaldata/BlockCommitOrd.hpp new file mode 100644 index 00000000000..3b33dceb758 --- /dev/null +++ b/ndb/include/kernel/signaldata/BlockCommitOrd.hpp @@ -0,0 +1,62 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef BLOCK_COMMIT_ORD_HPP +#define BLOCK_COMMIT_ORD_HPP + +/** + * These two signals are sent via EXECUTE_DIRECT + * to DBDIH from QMGR + * + * Block make sure that no commit is performed + * Unblock turns on commit again + */ + +class BlockCommitOrd { + /** + * Sender(s) + */ + friend class Qmgr; + + /** + * Reciver(s) + */ + friend class Dbdih; +public: + STATIC_CONST( SignalLength = 1 ); + +private: + Uint32 failNo; // As used by Qmgr +}; + +class UnblockCommitOrd { + /** + * Sender(s) + */ + friend class Qmgr; + + /** + * Reciver(s) + */ + friend class Dbdih; +public: + STATIC_CONST( SignalLength = 1 ); + +private: + Uint32 failNo; // As used by Qmgr +}; + +#endif diff --git a/ndb/include/kernel/signaldata/BuildIndx.hpp b/ndb/include/kernel/signaldata/BuildIndx.hpp new file mode 100644 index 00000000000..9cf1123cc61 --- /dev/null +++ b/ndb/include/kernel/signaldata/BuildIndx.hpp @@ -0,0 +1,308 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef BUILD_INDX_HPP +#define BUILD_INDX_HPP + +#include "SignalData.hpp" +#include +#include +#include + +/** + * BuildIndxReq + * + * This signal is sent by DICT to TRIX(n) + * as a request to build a secondary index + */ +class BuildIndxReq { + friend bool printBUILD_INDX_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + enum RequestType { + RT_UNDEFINED = 0, + RT_USER = 1, + RT_ALTER_INDEX = 2, + RT_SYSTEMRESTART = 3, + RT_DICT_PREPARE = 1 << 4, + RT_DICT_TC = 5 << 4, + RT_DICT_TRIX = 7 << 4, + RT_DICT_TUX = 8 << 4, + RT_DICT_COMMIT = 0xC << 4, + RT_DICT_ABORT = 0xF << 4, + RT_TRIX = 7 << 8 + }; + STATIC_CONST( SignalLength = 9 ); + STATIC_CONST( INDEX_COLUMNS = 0 ); + STATIC_CONST( KEY_COLUMNS = 1 ); + STATIC_CONST( NoOfSections = 2 ); + +private: + Uint32 m_userRef; // user block reference + Uint32 m_connectionPtr; // user "schema connection" + Uint32 m_requestInfo; + Uint32 m_buildId; // Suma subscription id + Uint32 m_buildKey; // Suma subscription key + Uint32 m_tableId; // table being indexed + Uint32 m_indexType; // from DictTabInfo::TableType + Uint32 m_indexId; // table storing index + Uint32 m_parallelism; // number of parallel insert transactions + // extra + Uint32 m_opKey; + // Sent data ends here + Uint32 m_slack[25 - SignalLength - 1]; + Uint32 m_sectionBuffer[MAX_ATTRIBUTES_IN_TABLE * 2]; + +public: + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getConnectionPtr() const { + return m_connectionPtr; + } + void setConnectionPtr(Uint32 val) { + m_connectionPtr = val; + } + BuildIndxReq::RequestType getRequestType() const { + const Uint32 val = BitmaskImpl::getField(1, &m_requestInfo, 0, 16); + return (BuildIndxReq::RequestType)val; + } + void setRequestType(BuildIndxReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getRequestFlag() const { + const Uint32 val = BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + return (BuildIndxReq::RequestType)val; + }; + void addRequestFlag(Uint32 val) { + val |= BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + BitmaskImpl::setField(1, &m_requestInfo, 16, 16, val); + }; + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + Uint32 getBuildId() const { + return m_buildId; + } + void setBuildId(Uint32 val) { + m_buildId = val; + } + Uint32 getBuildKey() const { + return m_buildKey; + } + void setBuildKey(Uint32 val) { + m_buildKey = val; + } + Uint32 getIndexType() const { + return m_indexType; + } + void setIndexType(Uint32 val) { + m_indexType = val; + } + Uint32 getIndexId() const { + return m_indexId; + } + void setIndexId(Uint32 val) { + m_indexId = val; + } + Uint32 getParallelism() const { + return m_parallelism; + } + void setParallelism(Uint32 val) { + m_parallelism = val; + } + Uint32 getOpKey() const { + return m_opKey; + } + void setOpKey(Uint32 val) { + m_opKey = val; + } + // Column order + void setColumnOrder(Uint32* indexBuf, Uint32 indexLen, + Uint32* keyBuf, Uint32 keyLen, + struct LinearSectionPtr orderPtr[]); +}; + +inline +void BuildIndxReq::setColumnOrder(Uint32* indexBuf, Uint32 indexLen, + Uint32* keyBuf, Uint32 keyLen, + struct LinearSectionPtr orderPtr[]) + +{ + printf("BuildIndxReq::setColumnOrder: indexLen %u, keyLen %u\n", indexLen, keyLen); + // Copy buffers + MEMCOPY_NO_WORDS(m_sectionBuffer, indexBuf, indexLen); + MEMCOPY_NO_WORDS(m_sectionBuffer + indexLen, keyBuf, keyLen); + orderPtr[INDEX_COLUMNS].p = m_sectionBuffer; + orderPtr[INDEX_COLUMNS].sz = indexLen; + orderPtr[KEY_COLUMNS].p = m_sectionBuffer + indexLen; + orderPtr[KEY_COLUMNS].sz = keyLen; +} + +/** + * BuildIndxConf + * + * This signal is sent back to DICT from TRIX + * as confirmation of succesfull index build + * (BuildIndxReq). + */ +class BuildIndxConf { + friend bool printBUILD_INDX_CONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + STATIC_CONST( InternalLength = 3 ); + STATIC_CONST( SignalLength = 6 ); + +private: + friend class BuildIndxRef; + Uint32 m_userRef; + Uint32 m_connectionPtr; + Uint32 m_requestInfo; + Uint32 m_tableId; + Uint32 m_indexType; + Uint32 m_indexId; + +public: + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getConnectionPtr() const { + return m_connectionPtr; + } + void setConnectionPtr(Uint32 val) { + m_connectionPtr = val; + } + BuildIndxReq::RequestType getRequestType() const { + return (BuildIndxReq::RequestType)m_requestInfo; + } + void setRequestType(BuildIndxReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + Uint32 getIndexType() const { + return m_indexType; + } + void setIndexType(Uint32 val) { + m_indexType = val; + } + Uint32 getIndexId() const { + return m_indexId; + } + void setIndexId(Uint32 val) { + m_indexId = val; + } +}; + +/** + * BuildIndxRef + * + * This signal is sent back to API from DICT/TRIX + * as refusal of a failed index creation + * (BuildIndxReq). It is also sent as refusal + * from TC to TRIX and TRIX to DICT. + */ +class BuildIndxRef { + friend bool printBUILD_INDX_REF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + enum ErrorCode { + NoError = 0, + Busy = 701, + BadRequestType = 4247, + InvalidPrimaryTable = 4249, + InvalidIndexType = 4250, + IndexNotUnique = 4251, + AllocationFailure = 4252, + InternalError = 4346 + }; + STATIC_CONST( SignalLength = BuildIndxConf::SignalLength + 1 ); + +private: + //Uint32 m_userRef; + //Uint32 m_connectionPtr; + //Uint32 m_requestInfo; + //Uint32 m_tableId; + //Uint32 m_indexType; + //Uint32 m_indexId; + BuildIndxConf m_conf; + Uint32 m_errorCode; + +public: + BuildIndxConf* getConf() { + return &m_conf; + } + const BuildIndxConf* getConf() const { + return &m_conf; + } + Uint32 getUserRef() const { + return m_conf.getUserRef(); + } + void setUserRef(Uint32 val) { + m_conf.setUserRef(val); + } + Uint32 getConnectionPtr() const { + return m_conf.getConnectionPtr(); + } + void setConnectionPtr(Uint32 val) { + m_conf.setConnectionPtr(val); + } + BuildIndxReq::RequestType getRequestType() const { + return m_conf.getRequestType(); + } + void setRequestType(BuildIndxReq::RequestType val) { + m_conf.setRequestType(val); + } + Uint32 getTableId() const { + return m_conf.getTableId(); + } + void setTableId(Uint32 val) { + m_conf.setTableId(val); + } + Uint32 getIndexType() const { + return m_conf.getIndexType(); + } + void setIndexType(Uint32 val) { + m_conf.setIndexType(val); + } + Uint32 getIndexId() const { + return m_conf.getIndexId(); + } + void setIndexId(Uint32 val) { + m_conf.setIndexId(val); + } + BuildIndxRef::ErrorCode getErrorCode() const { + return (BuildIndxRef::ErrorCode)m_errorCode; + } + void setErrorCode(BuildIndxRef::ErrorCode val) { + m_errorCode = (Uint32)val; + } +}; + +#endif diff --git a/ndb/include/kernel/signaldata/CheckNodeGroups.hpp b/ndb/include/kernel/signaldata/CheckNodeGroups.hpp new file mode 100644 index 00000000000..9b2f847e128 --- /dev/null +++ b/ndb/include/kernel/signaldata/CheckNodeGroups.hpp @@ -0,0 +1,63 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CHECKNODEGROUPS_H +#define CHECKNODEGROUPS_H + +#include +#include +#include "SignalData.hpp" +#include "SignalDataPrint.hpp" + +/** + * Ask DIH to check if a node set can survive i.e. if it + * has at least one node in every node group. Returns one + * of Win, Lose, Partitioning. + * + * Same class is used for REQ and CONF. The REQ can also + * be executed as a direct signal. + */ +class CheckNodeGroups { +public: + Uint32 blockRef; // sender's node id + union { + Uint32 requestType; // direct flag, output code + Uint32 output; + }; + union { + Uint32 nodeId; // nodeId input for GetNodeGroupMembers + NodeBitmask mask; /* set of NDB nodes, input for ArbitCheck, + * output for GetNodeGroupMembers + */ + }; + + enum RequestType { + Direct = 0x1, + ArbitCheck = 0x2, + GetNodeGroup = 0x4, + GetNodeGroupMembers = 0x8 + }; + + enum Output { + Lose = 1, // we cannot survive + Win = 2, // we and only we can survive + Partitioning = 3 // possible network partitioning + }; + + STATIC_CONST( SignalLength = 2 + NodeBitmask::Size ); +}; + +#endif diff --git a/ndb/include/kernel/signaldata/CloseComReqConf.hpp b/ndb/include/kernel/signaldata/CloseComReqConf.hpp new file mode 100644 index 00000000000..3d3dc54ba64 --- /dev/null +++ b/ndb/include/kernel/signaldata/CloseComReqConf.hpp @@ -0,0 +1,53 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CLOSE_COMREQCONF_HPP +#define CLOSE_COMREQCONF_HPP + +#include "SignalData.hpp" +#include + +/** + * The Req signal is sent by Qmgr to Cmvmi + * and the Conf signal is sent back + * + * NOTE that the signals are identical + */ +class CloseComReqConf { + + /** + * Sender(s) / Reciver(s) + */ + friend class Qmgr; + friend class Cmvmi; + + /** + * For printing + */ + friend bool printCLOSECOMREQCONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + STATIC_CONST( SignalLength = 3 + NodeBitmask::Size ); +private: + + Uint32 xxxBlockRef; + Uint32 failNo; + + Uint32 noOfNodes; + Uint32 theNodes[NodeBitmask::Size]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/CmInit.hpp b/ndb/include/kernel/signaldata/CmInit.hpp new file mode 100644 index 00000000000..b59547b767b --- /dev/null +++ b/ndb/include/kernel/signaldata/CmInit.hpp @@ -0,0 +1,48 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CM_INIT_HPP +#define CM_INIT_HPP + +#include + +/** + * + */ +class CmInit { + /** + * Sender(s) + */ + friend class Cmvmi; + + /** + * Reciver(s) + */ + friend class Qmgr; + +public: + STATIC_CONST( SignalLength = 4 + NodeBitmask::Size ); +private: + + Uint32 heartbeatDbDb; + Uint32 heartbeatDbApi; + Uint32 inactiveTransactionCheck; + Uint32 arbitTimeout; + + Uint32 allNdbNodes[NodeBitmask::Size]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/CmRegSignalData.hpp b/ndb/include/kernel/signaldata/CmRegSignalData.hpp new file mode 100644 index 00000000000..f33c991249f --- /dev/null +++ b/ndb/include/kernel/signaldata/CmRegSignalData.hpp @@ -0,0 +1,192 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CM_REG_HPP +#define CM_REG_HPP + +#include + +/** + * This is the first distributed signal + * (the node tries to register in the cluster) + */ +class CmRegReq { + /** + * Sender(s) & Reciver(s) + */ + friend class Qmgr; + +public: + STATIC_CONST( SignalLength = 3 ); +private: + + Uint32 blockRef; + Uint32 nodeId; + Uint32 version; // See ndb_version.h +}; + +/** + * The node receving this signal has been accepted into the cluster + */ +class CmRegConf { + /** + * Sender(s) & Reciver(s) + */ + friend class Qmgr; + +public: + STATIC_CONST( SignalLength = 4 + NdbNodeBitmask::Size ); +private: + + Uint32 presidentBlockRef; + Uint32 presidentNodeId; + Uint32 presidentVersion; + + /** + * The dynamic id that the node reciving this signal has + */ + Uint32 dynamicId; + + Uint32 allNdbNodes[NdbNodeBitmask::Size]; +}; + +/** + * + */ +class CmRegRef { + /** + * Sender(s) & Reciver(s) + */ + friend class Qmgr; + +public: + STATIC_CONST( SignalLength = 4 ); + + enum ErrorCode { + ZBUSY = 0, /* Only the president can send this */ + ZBUSY_PRESIDENT = 1,/* Only the president can send this */ + ZBUSY_TO_PRES = 2, /* Only the president can send this */ + ZNOT_IN_CFG = 3, /* Only the president can send this */ + ZELECTION = 4, /* Receiver is definitely not president, + * but we are not sure if sender ends up + * as president. */ + ZNOT_PRESIDENT = 5, /* We are not president */ + ZNOT_DEAD = 6, /* We are not dead when we are starting */ + ZINCOMPATIBLE_VERSION = 7 + }; +private: + + Uint32 blockRef; + Uint32 nodeId; + Uint32 errorCode; + Uint32 presidentCandidate; +}; + +class CmAdd { + /** + * Sender(s) & Reciver(s) + */ + friend class Qmgr; + +public: + STATIC_CONST( SignalLength = 3 ); + +private: + enum RequestType { + Prepare = 0, + AddCommit = 1, + CommitNew = 2 + }; + + Uint32 requestType; + Uint32 startingNodeId; + Uint32 startingVersion; +}; + +class CmAckAdd { + /** + * Sender(s) & Reciver(s) + */ + friend class Qmgr; + +public: + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 senderNodeId; + Uint32 requestType; // see CmAdd::RequestType + Uint32 startingNodeId; +}; + +class CmNodeInfoReq { + /** + * Sender(s) & Reciver(s) + */ + friend class Qmgr; + +public: + STATIC_CONST( SignalLength = 3 ); + +private: + /** + * This is information for sending node (starting node) + */ + Uint32 nodeId; + Uint32 dynamicId; + Uint32 version; +}; + +class CmNodeInfoRef { + /** + * Sender(s) & Reciver(s) + */ + friend class Qmgr; + +public: + STATIC_CONST( SignalLength = 3 ); + + enum ErrorCode { + NotRunning = 1 + }; + +private: + Uint32 nodeId; + Uint32 errorCode; +}; + +class CmNodeInfoConf { + /** + * Sender(s) & Reciver(s) + */ + friend class Qmgr; + +public: + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 nodeId; + Uint32 dynamicId; + Uint32 version; +}; + +#endif + + + + + + + diff --git a/ndb/include/kernel/signaldata/CmvmiCfgConf.hpp b/ndb/include/kernel/signaldata/CmvmiCfgConf.hpp new file mode 100644 index 00000000000..12b785723d9 --- /dev/null +++ b/ndb/include/kernel/signaldata/CmvmiCfgConf.hpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CMVMI_CFGCONF_H +#define CMVMI_CFGCONF_H + +#include "SignalData.hpp" + +/** + * This signal is used for transfering the + * ISP_X Data + * + * I.e. Configuration data which is sent in a specific start phase + * + */ +class CmvmiCfgConf { + /** + * Sender(s) + */ + friend class Cmvmi; + + /** + * Reciver(s) + */ + friend class Ndbcntr; + +public: + STATIC_CONST( NO_OF_WORDS = 16 ); + STATIC_CONST( LENGTH = 17 ); +private: + + Uint32 startPhase; + Uint32 theData[NO_OF_WORDS]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/CntrMasterConf.hpp b/ndb/include/kernel/signaldata/CntrMasterConf.hpp new file mode 100644 index 00000000000..e6bf363ea68 --- /dev/null +++ b/ndb/include/kernel/signaldata/CntrMasterConf.hpp @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CNTR_MASTERCONF_HPP +#define CNTR_MASTERCONF_HPP + +#include + +/** + * This signals is sent by NdbCntr-Master to NdbCntr + */ +class CntrMasterConf { + /** + * Sender(s) + */ + + /** + * Sender(s) / Reciver(s) + */ + friend class Ndbcntr; + + /** + * Reciver(s) + */ + +public: + STATIC_CONST( SignalLength = 1 + NodeBitmask::Size ); +private: + + Uint32 noStartNodes; + Uint32 theNodes[NodeBitmask::Size]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/CntrMasterReq.hpp b/ndb/include/kernel/signaldata/CntrMasterReq.hpp new file mode 100644 index 00000000000..caf9efb1243 --- /dev/null +++ b/ndb/include/kernel/signaldata/CntrMasterReq.hpp @@ -0,0 +1,50 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CNTR_MASTERREQ_HPP +#define CNTR_MASTERREQ_HPP + +#include + +/** + * This signals is sent by NdbCntr-Master to NdbCntr + */ +class CntrMasterReq { + /** + * Sender(s) + */ + + /** + * Sender(s) / Reciver(s) + */ + friend class Ndbcntr; + + /** + * Reciver(s) + */ + +public: + STATIC_CONST( SignalLength = 4 + NodeBitmask::Size ); +private: + + Uint32 userBlockRef; + Uint32 userNodeId; + Uint32 typeOfStart; + Uint32 noRestartNodes; + Uint32 theNodes[NodeBitmask::Size]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/ConfigParamId.hpp b/ndb/include/kernel/signaldata/ConfigParamId.hpp new file mode 100644 index 00000000000..9d9e04957ab --- /dev/null +++ b/ndb/include/kernel/signaldata/ConfigParamId.hpp @@ -0,0 +1,71 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ConfigParamId_H +#define ConfigParamId_H + + enum ConfigParamId { + + Id, + ExecuteOnComputer, + MaxNoOfSavedMessages, + ShmKey, + + LockPagesInMainMemory, + TimeBetweenWatchDogCheck, + StopOnError, + + MaxNoOfConcurrentOperations, + MaxNoOfConcurrentTransactions, + MemorySpaceIndexes, + MemorySpaceTuples, + MemoryDiskPages, + NoOfFreeDiskClusters, + NoOfDiskClusters, + + TimeToWaitAlive, + HeartbeatIntervalDbDb, + HeartbeatIntervalDbApi, + ArbitTimeout, + + TimeBetweenLocalCheckpoints, + TimeBetweenGlobalCheckpoints, + NoOfFragmentLogFiles, + NoOfConcurrentCheckpointsDuringRestart, + TransactionDeadlockDetectionTimeout, + TransactionInactiveTime, + NoOfConcurrentProcessesHandleTakeover, + + NoOfConcurrentCheckpointsAfterRestart, + + NoOfDiskPagesToDiskDuringRestartTUP, + NoOfDiskPagesToDiskAfterRestartTUP, + NoOfDiskPagesToDiskDuringRestartACC, + NoOfDiskPagesToDiskAfterRestartACC, + + NoOfDiskClustersPerDiskFile, + NoOfDiskFiles, + + MaxNoOfSavedEvents + }; + +#endif // ConfigParamId_H + + + + + + diff --git a/ndb/include/kernel/signaldata/ContinueFragmented.hpp b/ndb/include/kernel/signaldata/ContinueFragmented.hpp new file mode 100644 index 00000000000..3d12b9e51eb --- /dev/null +++ b/ndb/include/kernel/signaldata/ContinueFragmented.hpp @@ -0,0 +1,36 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CONTINUE_FRAGMENTED_HPP +#define CONTINUE_FRAGMENTED_HPP + +#include "SignalData.hpp" + +class ContinueFragmented { + + /** + * Sender/Reciver(s) + */ + friend class SimulatedBlock; + + friend bool printCONTINUE_FRAGMENTED(FILE *,const Uint32 *, Uint32, Uint16); +public: + +private: + Uint32 line; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/CopyActive.hpp b/ndb/include/kernel/signaldata/CopyActive.hpp new file mode 100644 index 00000000000..19b05bda072 --- /dev/null +++ b/ndb/include/kernel/signaldata/CopyActive.hpp @@ -0,0 +1,84 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef COPY_ACTIVE_HPP +#define COPY_ACTIVE_HPP + +#include "SignalData.hpp" + +class CopyActiveReq { + /** + * Sender(s) + */ + friend class Dbdih; + + /** + * Receiver(s) + */ + friend class Dblqh; +public: + STATIC_CONST( SignalLength = 5 ); + +private: + Uint32 userPtr; + Uint32 userRef; + Uint32 tableId; + Uint32 fragId; + Uint32 distributionKey; +}; + +class CopyActiveConf { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Receiver(s) + */ + friend class Dbdih; +public: + STATIC_CONST( SignalLength = 5 ); + +private: + Uint32 userPtr; + Uint32 startingNodeId; + Uint32 tableId; + Uint32 fragId; + Uint32 startGci; +}; +class CopyActiveRef { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Receiver(s) + */ + friend class Dbdih; +public: + STATIC_CONST( SignalLength = 5 ); + +private: + Uint32 userPtr; + Uint32 startingNodeId; + Uint32 tableId; + Uint32 fragId; + Uint32 errorCode; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/CopyFrag.hpp b/ndb/include/kernel/signaldata/CopyFrag.hpp new file mode 100644 index 00000000000..67b935dda64 --- /dev/null +++ b/ndb/include/kernel/signaldata/CopyFrag.hpp @@ -0,0 +1,87 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef COPY_FRAG_HPP +#define COPY_FRAG_HPP + +#include "SignalData.hpp" + +class CopyFragReq { + /** + * Sender(s) + */ + friend class Dbdih; + + /** + * Receiver(s) + */ + friend class Dblqh; +public: + STATIC_CONST( SignalLength = 7 ); + +private: + Uint32 userPtr; + Uint32 userRef; + Uint32 tableId; + Uint32 fragId; + Uint32 nodeId; + Uint32 schemaVersion; + Uint32 distributionKey; +}; + +class CopyFragConf { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Receiver(s) + */ + friend class Dbdih; +public: + STATIC_CONST( SignalLength = 5 ); + +private: + Uint32 userPtr; + Uint32 sendingNodeId; + Uint32 startingNodeId; + Uint32 tableId; + Uint32 fragId; +}; +class CopyFragRef { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Receiver(s) + */ + friend class Dbdih; +public: + STATIC_CONST( SignalLength = 6 ); + +private: + Uint32 userPtr; + Uint32 sendingNodeId; + Uint32 startingNodeId; + Uint32 tableId; + Uint32 fragId; + Uint32 errorCode; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/CopyGCIReq.hpp b/ndb/include/kernel/signaldata/CopyGCIReq.hpp new file mode 100644 index 00000000000..4b401654de3 --- /dev/null +++ b/ndb/include/kernel/signaldata/CopyGCIReq.hpp @@ -0,0 +1,63 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef COPY_GCI_REQ_HPP +#define COPY_GCI_REQ_HPP + +#include "SignalData.hpp" + +/** + * This signal is used for transfering the sysfile + * between Dih on different nodes. + * + * The master will distributes the file to the other nodes + * + * Since the Sysfile can be larger than on StartMeConf signal, + * there might be more than on of these signals sent before + * the entire sysfile is transfered + + */ +class CopyGCIReq { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + + friend bool printCOPY_GCI_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + enum CopyReason { + IDLE = 0, + LOCAL_CHECKPOINT = 1, + RESTART = 2, + GLOBAL_CHECKPOINT = 3, + INITIAL_START_COMPLETED = 4 + }; + +private: + + Uint32 anyData; + Uint32 copyReason; + Uint32 startWord; + + /** + * No of free words to carry data + */ + STATIC_CONST( DATA_SIZE = 22 ); + + Uint32 data[DATA_SIZE]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/CreateEvnt.hpp b/ndb/include/kernel/signaldata/CreateEvnt.hpp new file mode 100644 index 00000000000..7398fb6d8cc --- /dev/null +++ b/ndb/include/kernel/signaldata/CreateEvnt.hpp @@ -0,0 +1,488 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CREATE_EVNT_HPP +#define CREATE_EVNT_HPP + +#include "SignalData.hpp" +#include +#include + +/** + * DropEvntReq. + */ +class DropEvntReq { + friend bool printDROP_EVNT_REQ(FILE*, const Uint32*, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 2 ); + SECTION( EVENT_NAME_SECTION = 0 ); + + union { // user block reference + Uint32 senderRef; + Uint32 m_userRef; + }; + union { + Uint32 senderData; + Uint32 m_userData; // user + }; + + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getUserData() const { + return m_userData; + } + void setUserData(Uint32 val) { + m_userData = val; + } +}; + +/** + * DropEvntConf. + */ +class DropEvntConf { + friend bool printDROP_EVNT_CONF(FILE*, const Uint32*, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 2 ); + + union { // user block reference + Uint32 senderRef; + Uint32 m_userRef; + }; + union { + Uint32 senderData; + Uint32 m_userData; // user + }; + + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getUserData() const { + return m_userData; + } + void setUserData(Uint32 val) { + m_userData = val; + } +}; + +/** + * DropEvntRef. + */ +class DropEvntRef { + friend bool printDROP_EVNT_REF(FILE*, const Uint32*, Uint32, Uint16); + +public: + enum ErrorCode { + NoError = 0, + Undefined = 1, + UndefinedTCError = 2, + NF_FakeErrorREF = 11, + Busy = 701, + NotMaster = 702, + SeizeError = 703, + EventNotFound = 4238, + EventNameTooLong = 4241, + TooManyEvents = 4242, + BadRequestType = 4247, + InvalidName = 4248, + InvalidPrimaryTable = 4249, + InvalidEventType = 4250, + NotUnique = 4251, + AllocationError = 4252, + CreateEventTableFailed = 4253, + InvalidAttributeOrder = 4255, + Temporary = 0x1 << 16 + }; + + STATIC_CONST( SignalLength = 5 ); + + union { // user block reference + Uint32 senderRef; + Uint32 m_userRef; + }; + union { + Uint32 senderData; + Uint32 m_userData; // user + }; + union { + Uint32 errorCode; + Uint32 m_errorCode; + }; + Uint32 m_errorLine; + Uint32 m_errorNode; + + bool isTemporary() const + { return (errorCode & Temporary) > 0; } + + void setTemporary() + { errorCode |= Temporary; } + + ErrorCode setTemporary(ErrorCode ec) + { return (ErrorCode) (errorCode = ((Uint32) ec | (Uint32)Temporary)); } + + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getUserData() const { + return m_userData; + } + void setUserData(Uint32 val) { + m_userData = val; + } + DropEvntRef::ErrorCode getErrorCode() const { + return (DropEvntRef::ErrorCode)m_errorCode; + } + void setErrorCode(DropEvntRef::ErrorCode val) { + m_errorCode = (Uint32)val; + } + Uint32 getErrorLine() const { + return m_errorLine; + } + void setErrorLine(Uint32 val) { + m_errorLine = val; + } + Uint32 getErrorNode() const { + return m_errorNode; + } + void setErrorNode(Uint32 val) { + m_errorNode = val; + } +}; + +/** + * CreateEvntReq. + */ +struct CreateEvntReq { + friend bool printCREATE_EVNT_REQ(FILE*, const Uint32*, Uint32, Uint16); + + enum RequestType { + RT_UNDEFINED = 0, + RT_USER_CREATE = 1, + RT_USER_GET = 2, + + RT_DICT_AFTER_GET = 0x1 << 4 + // RT_DICT_MASTER = 0x2 << 4, + + // RT_DICT_COMMIT = 0xC << 4, + // RT_DICT_ABORT = 0xF << 4, + // RT_TC = 5 << 8 + }; + STATIC_CONST( SignalLengthGet = 3 ); + STATIC_CONST( SignalLengthCreate = 5+MAXNROFATTRIBUTESINWORDS ); + STATIC_CONST( SignalLength = 7+MAXNROFATTRIBUTESINWORDS ); + // SECTION( ATTRIBUTE_LIST_SECTION = 0 ); + SECTION( EVENT_NAME_SECTION = 0 ); + + union { + Uint32 m_userRef; // user block reference + Uint32 senderRef; // user block reference + }; + union { + Uint32 m_userData; // user + Uint32 senderData; // user + }; + Uint32 m_requestInfo; + Uint32 m_tableId; // table to event + AttributeMask::Data m_attrListBitmask; + Uint32 m_eventType; // from DictTabInfo::TableType + Uint32 m_eventId; // event table id set by DICT/SUMA + Uint32 m_eventKey; // event table key set by DICT/SUMA + + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getUserData() const { + return m_userData; + } + void setUserData(Uint32 val) { + m_userData = val; + } + CreateEvntReq::RequestType getRequestType() const { + const Uint32 val = BitmaskImpl::getField(1, &m_requestInfo, 0, 16); + return (CreateEvntReq::RequestType)val; + } + void setRequestType(CreateEvntReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getRequestFlag() const { + return BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + }; + void addRequestFlag(Uint32 val) { + val |= BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + BitmaskImpl::setField(1, &m_requestInfo, 16, 16, val); + }; + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + AttributeMask getAttrListBitmask() const { + AttributeMask tmp; + tmp.assign(m_attrListBitmask); + return tmp; + } + void setAttrListBitmask(const AttributeMask & val) { + m_attrListBitmask = val; + } + Uint32 getEventType() const { + return m_eventType; + } + void setEventType(Uint32 val) { + m_eventType = (Uint32)val; + } + Uint32 getEventId() const { + return m_eventId; + } + void setEventId(Uint32 val) { + m_eventId = val; + } + Uint32 getEventKey() const { + return m_eventKey; + } + void setEventKey(Uint32 val) { + m_eventKey = val; + } +}; + +/** + * CreateEvntConf. + */ +class CreateEvntConf { + friend bool printCREATE_EVNT_CONF(FILE*, const Uint32*, Uint32, Uint16); + +public: + // STATIC_CONST( InternalLength = 3 ); + STATIC_CONST( SignalLength = 7+MAXNROFATTRIBUTESINWORDS ); + + union { + Uint32 m_userRef; // user block reference + Uint32 senderRef; // user block reference + }; + union { + Uint32 m_userData; // user + Uint32 senderData; // user + }; + Uint32 m_requestInfo; + Uint32 m_tableId; + AttributeMask m_attrListBitmask; + Uint32 m_eventType; + Uint32 m_eventId; + Uint32 m_eventKey; + + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getUserData() const { + return m_userData; + } + void setUserData(Uint32 val) { + m_userData = val; + } + CreateEvntReq::RequestType getRequestType() const { + return (CreateEvntReq::RequestType)m_requestInfo; + } + void setRequestType(CreateEvntReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + AttributeMask getAttrListBitmask() const { + return m_attrListBitmask; + } + void setAttrListBitmask(const AttributeMask & val) { + m_attrListBitmask = val; + } + Uint32 getEventType() const { + return m_eventType; + } + void setEventType(Uint32 val) { + m_eventType = (Uint32)val; + } + Uint32 getEventId() const { + return m_eventId; + } + void setEventId(Uint32 val) { + m_eventId = val; + } + Uint32 getEventKey() const { + return m_eventKey; + } + void setEventKey(Uint32 val) { + m_eventKey = val; + } +}; + +/** + * CreateEvntRef. + */ +struct CreateEvntRef { + friend class SafeCounter; + friend bool printCREATE_EVNT_REF(FILE*, const Uint32*, Uint32, Uint16); + + STATIC_CONST( SignalLength = 10 ); + enum ErrorCode { + NoError = 0, + Undefined = 1, + UndefinedTCError = 2, + NF_FakeErrorREF = 11, + Busy = 701, + NotMaster = 702, + SeizeError = 703, + EventNotFound = 4238, + EventExists = 4239, + EventNameTooLong = 4241, + TooManyEvents = 4242, + // EventExists = 4244, + AttributeNotStored = 4245, + AttributeNullable = 4246, + BadRequestType = 4247, + InvalidName = 4248, + InvalidPrimaryTable = 4249, + InvalidEventType = 4250, + NotUnique = 4251, + AllocationError = 4252, + CreateEventTableFailed = 4253, + InvalidAttributeOrder = 4255, + Temporary = 0x1 << 16 + }; + bool isTemporary() const; + void setTemporary(); + ErrorCode setTemporary(ErrorCode ec); + static ErrorCode makeTemporary(ErrorCode ec); + + union { + Uint32 m_userRef; // user block reference + Uint32 senderRef; // user block reference + }; + union { + Uint32 m_userData; // user + Uint32 senderData; // user + }; + + Uint32 m_requestInfo; + Uint32 m_tableId; + Uint32 m_eventType; + Uint32 m_eventId; + Uint32 m_eventKey; + Uint32 errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + +#if 0 + CreateEvntConf* getConf() { + return &m_conf; + } + const CreateEvntConf* getConf() const { + return &m_conf; + } +#endif + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getUserData() const { + return m_userData; + } + void setUserData(Uint32 val) { + m_userData = val; + } + CreateEvntReq::RequestType getRequestType() const { + return (CreateEvntReq::RequestType)m_requestInfo; + } + void setRequestType(CreateEvntReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + + Uint32 getEventType() const { + return m_eventType; + } + void setEventType(Uint32 val) { + m_eventType = (Uint32)val; + } + Uint32 getEventId() const { + return m_eventId; + } + void setEventId(Uint32 val) { + m_eventId = val; + } + Uint32 getEventKey() const { + return m_eventKey; + } + void setEventKey(Uint32 val) { + m_eventKey = val; + } + + CreateEvntRef::ErrorCode getErrorCode() const { + return (CreateEvntRef::ErrorCode)errorCode; + } + void setErrorCode(CreateEvntRef::ErrorCode val) { + errorCode = (Uint32)val; + } + Uint32 getErrorLine() const { + return m_errorLine; + } + void setErrorLine(Uint32 val) { + m_errorLine = val; + } + Uint32 getErrorNode() const { + return m_errorNode; + } + void setErrorNode(Uint32 val) { + m_errorNode = val; + } +}; +inline bool CreateEvntRef::isTemporary() const +{ return (errorCode & CreateEvntRef::Temporary) > 0; }; +inline void CreateEvntRef::setTemporary() +{ errorCode |= CreateEvntRef::Temporary; }; +inline CreateEvntRef::ErrorCode CreateEvntRef::setTemporary(ErrorCode ec) +{ return (CreateEvntRef::ErrorCode) + (errorCode = ((Uint32) ec | (Uint32)CreateEvntRef::Temporary)); }; +inline CreateEvntRef::ErrorCode CreateEvntRef::makeTemporary(ErrorCode ec) +{ return (CreateEvntRef::ErrorCode) + ( (Uint32) ec | (Uint32)CreateEvntRef::Temporary ); }; + +#endif diff --git a/ndb/include/kernel/signaldata/CreateFrag.hpp b/ndb/include/kernel/signaldata/CreateFrag.hpp new file mode 100644 index 00000000000..a7b3f836353 --- /dev/null +++ b/ndb/include/kernel/signaldata/CreateFrag.hpp @@ -0,0 +1,61 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CREATE_FRAG_HPP +#define CREATE_FRAG_HPP + +class CreateFragReq { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 8 ); + + enum ReplicaType { + STORED = 7, + COMMIT_STORED = 9 + }; +private: + + Uint32 userPtr; + BlockReference userRef; + Uint32 tableId; + Uint32 fragId; + Uint32 startingNodeId; + Uint32 copyNodeId; + Uint32 startGci; + Uint32 replicaType; +}; + +class CreateFragConf { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 5 ); +private: + + Uint32 userPtr; + Uint32 tableId; + Uint32 fragId; + Uint32 sendingNodeId; + Uint32 startingNodeId; +}; +#endif diff --git a/ndb/include/kernel/signaldata/CreateFragmentation.hpp b/ndb/include/kernel/signaldata/CreateFragmentation.hpp new file mode 100644 index 00000000000..a2f45a9580d --- /dev/null +++ b/ndb/include/kernel/signaldata/CreateFragmentation.hpp @@ -0,0 +1,101 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CREATE_FRAGMENTATION_REQ_HPP +#define CREATE_FRAGMENTATION_REQ_HPP + +#include "SignalData.hpp" + +class CreateFragmentationReq { + /** + * Sender(s) + */ + friend class Dbdict; + + /** + * Receiver(s) + */ + friend class Dbdih; + + friend bool printCREATE_FRAGMENTATION_REQ(FILE *, + const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 6 ); + +private: + Uint32 senderRef; + Uint32 senderData; + Uint32 fragmentationType; + Uint32 noOfFragments; + Uint32 fragmentNode; + Uint32 primaryTableId; // use same fragmentation as this table if not RNIL +}; + +class CreateFragmentationRef { + /** + * Sender(s) + */ + friend class Dbdih; + + /** + * Receiver(s) + */ + friend class Dbdict; + + friend bool printCREATE_FRAGMENTATION_REF(FILE *, + const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + + enum ErrorCode { + OK = 0 + ,InvalidFragmentationType = 1 + ,InvalidNodeId = 2 + ,InvalidNodeType = 3 + ,InvalidPrimaryTable = 4 + }; + +private: + Uint32 senderRef; + Uint32 senderData; + Uint32 errorCode; +}; + +class CreateFragmentationConf { + /** + * Sender(s) + */ + friend class Dbdih; + + /** + * Receiver(s) + */ + friend class Dbdict; + + friend bool printCREATE_FRAGMENTATION_CONF(FILE *, + const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + SECTION( FRAGMENTS = 0 ); + +private: + Uint32 senderRef; + Uint32 senderData; + Uint32 noOfReplicas; + Uint32 noOfFragments; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/CreateIndx.hpp b/ndb/include/kernel/signaldata/CreateIndx.hpp new file mode 100644 index 00000000000..3e277b38dea --- /dev/null +++ b/ndb/include/kernel/signaldata/CreateIndx.hpp @@ -0,0 +1,295 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CREATE_INDX_HPP +#define CREATE_INDX_HPP + +#include "SignalData.hpp" +#include +#include + +/** + * CreateIndxReq. + */ +class CreateIndxReq { + friend bool printCREATE_INDX_REQ(FILE*, const Uint32*, Uint32, Uint16); + +public: + enum RequestType { + RT_UNDEFINED = 0, + RT_USER = 1, + RT_DICT_PREPARE = 1 << 4, + RT_DICT_COMMIT = 0xC << 4, + RT_DICT_ABORT = 0xF << 4, + RT_TC = 5 << 8 + }; + STATIC_CONST( SignalLength = 8 ); + SECTION( ATTRIBUTE_LIST_SECTION = 0 ); + SECTION( INDEX_NAME_SECTION = 1 ); + +private: + Uint32 m_connectionPtr; // user "schema connection" + Uint32 m_userRef; // user block reference + Uint32 m_requestInfo; + Uint32 m_tableId; // table to index + Uint32 m_indexType; // from DictTabInfo::TableType + Uint32 m_indexId; // index table id set by DICT + Uint32 m_indexVersion; // index table version set by DICT + Uint32 m_online; // alter online + // extra + Uint32 m_opKey; + +public: + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getConnectionPtr() const { + return m_connectionPtr; + } + void setConnectionPtr(Uint32 val) { + m_connectionPtr = val; + } + CreateIndxReq::RequestType getRequestType() const { + const Uint32 val = BitmaskImpl::getField(1, &m_requestInfo, 0, 16); + return (CreateIndxReq::RequestType)val; + } + void setRequestType(CreateIndxReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getRequestFlag() const { + return BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + }; + void addRequestFlag(Uint32 val) { + val |= BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + BitmaskImpl::setField(1, &m_requestInfo, 16, 16, val); + }; + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + DictTabInfo::TableType getIndexType() const { + return (DictTabInfo::TableType)m_indexType; + } + void setIndexType(DictTabInfo::TableType val) { + m_indexType = (Uint32)val; + } + Uint32 getIndexId() const { + return m_indexId; + } + void setIndexId(Uint32 val) { + m_indexId = val; + } + Uint32 getOnline() const { + return m_online; + } + void setOnline(Uint32 val) { + m_online = val; + } + Uint32 getIndexVersion() const { + return m_indexVersion; + } + void setIndexVersion(Uint32 val) { + m_indexVersion = val; + } + Uint32 getOpKey() const { + return m_opKey; + } + void setOpKey(Uint32 val) { + m_opKey = val; + } +}; + +/** + * CreateIndxConf. + */ +class CreateIndxConf { + friend bool printCREATE_INDX_CONF(FILE*, const Uint32*, Uint32, Uint16); + +public: + STATIC_CONST( InternalLength = 3 ); + STATIC_CONST( SignalLength = 7 ); + +private: + Uint32 m_connectionPtr; + Uint32 m_userRef; + Uint32 m_requestInfo; + Uint32 m_tableId; + Uint32 m_indexType; + Uint32 m_indexId; + Uint32 m_indexVersion; + +public: + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getConnectionPtr() const { + return m_connectionPtr; + } + void setConnectionPtr(Uint32 val) { + m_connectionPtr = val; + } + CreateIndxReq::RequestType getRequestType() const { + return (CreateIndxReq::RequestType)m_requestInfo; + } + void setRequestType(CreateIndxReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + DictTabInfo::TableType getIndexType() const { + return (DictTabInfo::TableType)m_indexType; + } + void setIndexType(DictTabInfo::TableType val) { + m_indexType = (Uint32)val; + } + Uint32 getIndexId() const { + return m_indexId; + } + void setIndexId(Uint32 val) { + m_indexId = val; + } + Uint32 getIndexVersion() const { + return m_indexVersion; + } + void setIndexVersion(Uint32 val) { + m_indexVersion = val; + } +}; + +/** + * CreateIndxRef. + */ +class CreateIndxRef { + friend bool printCREATE_INDX_REF(FILE*, const Uint32*, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = CreateIndxReq::SignalLength + 3 ); + enum ErrorCode { + NoError = 0, + Busy = 701, + NotMaster = 702, + TriggerNotFound = 4238, + TriggerExists = 4239, + IndexNameTooLong = 4241, + TooManyIndexes = 4242, + IndexExists = 4244, + AttributeNotStored = 4245, + AttributeNullable = 4246, + BadRequestType = 4247, + InvalidName = 4248, + InvalidPrimaryTable = 4249, + InvalidIndexType = 4250, + NotUnique = 4251, + AllocationError = 4252, + CreateIndexTableFailed = 4253, + InvalidAttributeOrder = 4255 + }; + +private: + CreateIndxConf m_conf; + //Uint32 m_userRef; + //Uint32 m_connectionPtr; + //Uint32 m_requestInfo; + //Uint32 m_tableId; + //Uint32 m_indexType; + //Uint32 m_indexId; + //Uint32 m_indexVersion; + Uint32 m_errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + +public: + CreateIndxConf* getConf() { + return &m_conf; + } + const CreateIndxConf* getConf() const { + return &m_conf; + } + Uint32 getUserRef() const { + return m_conf.getUserRef(); + } + void setUserRef(Uint32 val) { + m_conf.setUserRef(val); + } + Uint32 getConnectionPtr() const { + return m_conf.getConnectionPtr(); + } + void setConnectionPtr(Uint32 val) { + m_conf.setConnectionPtr(val); + } + CreateIndxReq::RequestType getRequestType() const { + return m_conf.getRequestType(); + } + void setRequestType(CreateIndxReq::RequestType val) { + m_conf.setRequestType(val); + } + Uint32 getTableId() const { + return m_conf.getTableId(); + } + void setTableId(Uint32 val) { + m_conf.setTableId(val); + } + DictTabInfo::TableType getIndexType() const { + return m_conf.getIndexType(); + } + void setIndexType(DictTabInfo::TableType val) { + m_conf.setIndexType(val); + } + Uint32 getIndexId() const { + return m_conf.getIndexId(); + } + void setIndexId(Uint32 val) { + m_conf.setIndexId(val); + } + Uint32 getIndexVersion() const { + return m_conf.getIndexVersion(); + } + void setIndexVersion(Uint32 val) { + m_conf.setIndexVersion(val); + } + CreateIndxRef::ErrorCode getErrorCode() const { + return (CreateIndxRef::ErrorCode)m_errorCode; + } + void setErrorCode(CreateIndxRef::ErrorCode val) { + m_errorCode = (Uint32)val; + } + Uint32 getErrorLine() const { + return m_errorLine; + } + void setErrorLine(Uint32 val) { + m_errorLine = val; + } + Uint32 getErrorNode() const { + return m_errorNode; + } + void setErrorNode(Uint32 val) { + m_errorNode = val; + } +}; + +#endif diff --git a/ndb/include/kernel/signaldata/CreateTab.hpp b/ndb/include/kernel/signaldata/CreateTab.hpp new file mode 100644 index 00000000000..b2ef52a6bf7 --- /dev/null +++ b/ndb/include/kernel/signaldata/CreateTab.hpp @@ -0,0 +1,108 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CREATE_TAB_HPP +#define CREATE_TAB_HPP + +#include "SignalData.hpp" + +/** + * CreateTab + * + * Implemenatation of CreateTable + */ +class CreateTabReq { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdict; + + /** + * For printing + */ + friend bool printCREATE_TAB_REQ(FILE*, const Uint32*, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 8 ); + + enum RequestType { + CreateTablePrepare = 0, // Prepare create table + CreateTableCommit = 1, // Commit create table + CreateTableDrop = 2 // Prepare failed, drop instead + }; +private: + Uint32 senderRef; + Uint32 senderData; + Uint32 clientRef; + Uint32 clientData; + + Uint32 tableId; + Uint32 tableVersion; + Uint32 gci; + Uint32 requestType; + + SECTION( DICT_TAB_INFO = 0 ); + SECTION( FRAGMENTATION = 1 ); +}; + +struct CreateTabRef { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdict; + friend class SafeCounter; + + /** + * For printing + */ + friend bool printCREATE_TAB_REF(FILE *, const Uint32 *, Uint32, Uint16); + + STATIC_CONST( SignalLength = 6 ); + STATIC_CONST( GSN = GSN_CREATE_TAB_REF ); + + enum ErrorCode { + NF_FakeErrorREF = 255 + }; + + + Uint32 senderRef; + Uint32 senderData; + Uint32 errorCode; + Uint32 errorLine; + Uint32 errorKey; + Uint32 errorStatus; +}; + +class CreateTabConf { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdict; + + /** + * For printing + */ + friend bool printCREATE_TAB_CONF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 senderRef; + Uint32 senderData; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/CreateTable.hpp b/ndb/include/kernel/signaldata/CreateTable.hpp new file mode 100644 index 00000000000..424367f28d5 --- /dev/null +++ b/ndb/include/kernel/signaldata/CreateTable.hpp @@ -0,0 +1,140 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CREATE_TABLE_HPP +#define CREATE_TABLE_HPP + +#include "SignalData.hpp" + +/** + * CreateTable + * + * This signal is sent by API to DICT/TRIX + * as a request to create a secondary index + * and then from TRIX to TRIX(n) and TRIX to TC. + */ +class CreateTableReq { + /** + * Sender(s) + */ + // API + + /** + * Sender(s) / Reciver(s) + */ + friend class NdbDictInterface; + friend class Dbdict; + friend class Ndbcntr; + + /** + * For printing + */ + friend bool printCREATE_TABLE_REQ(FILE*, const Uint32*, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 senderData; + Uint32 senderRef; + + SECTION( DICT_TAB_INFO = 0 ); +}; + +class CreateTableRef { + /** + * Sender(s) + */ + friend class Dbdict; + + /** + * Sender(s) / Reciver(s) + */ + friend class Ndbcntr; + friend class NdbDictInterface; + + /** + * For printing + */ + friend bool printCREATE_TABLE_REF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 7 ); + + enum ErrorCode { + NoError = 0, + Busy = 701, + NotMaster = 702, + InvalidFormat = 703, + AttributeNameTooLong = 704, + TableNameTooLong = 705, + Inconsistency = 706, + NoMoreTableRecords = 707, + NoMoreAttributeRecords = 708, + AttributeNameTwice = 720, + TableAlreadyExist = 721, + ArraySizeTooBig = 737, + RecordTooBig = 738, + InvalidPrimaryKeySize = 739, + NullablePrimaryKey = 740 + }; + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 masterNodeId; + Uint32 errorCode; + Uint32 errorLine; + Uint32 errorKey; + Uint32 status; + +public: + Uint32 getErrorCode() const { + return errorCode; + } + Uint32 getErrorLine() const { + return errorLine; + } +}; + +class CreateTableConf { + /** + * Sender(s) + */ + friend class Dbdict; + + /** + * Sender(s) / Reciver(s) + */ + friend class Ndbcntr; + friend class NdbDictInterface; + + /** + * For printing + */ + friend bool printCREATE_TABLE_REF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 tableId; + Uint32 tableVersion; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/CreateTrig.hpp b/ndb/include/kernel/signaldata/CreateTrig.hpp new file mode 100644 index 00000000000..a8de9e50dd4 --- /dev/null +++ b/ndb/include/kernel/signaldata/CreateTrig.hpp @@ -0,0 +1,414 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CREATE_TRIG_HPP +#define CREATE_TRIG_HPP + +#include "SignalData.hpp" +#include +#include +#include + +/** + * CreateTrigReq. + */ +class CreateTrigReq { + friend bool printCREATE_TRIG_REQ(FILE*, const Uint32*, Uint32, Uint16); + +public: + enum RequestType { + RT_UNDEFINED = 0, + RT_USER = 1, + RT_ALTER_INDEX = 2, + RT_BUILD_INDEX = 3, + RT_DICT_PREPARE = 1 << 4, + RT_DICT_CREATE = 2 << 4, + RT_DICT_COMMIT = 0xC << 4, + RT_DICT_ABORT = 0xF << 4, + RT_TC = 5 << 8, + RT_LQH = 6 << 8 + }; + STATIC_CONST( SignalLength = 9 + MAXNROFATTRIBUTESINWORDS); + SECTION( TRIGGER_NAME_SECTION = 0 ); + SECTION( ATTRIBUTE_MASK_SECTION = 1 ); // not yet in use + enum KeyValues { + TriggerNameKey = 0xa1 + }; + +private: + Uint32 m_userRef; + Uint32 m_connectionPtr; + Uint32 m_requestInfo; + Uint32 m_tableId; + Uint32 m_indexId; // only for index trigger + Uint32 m_triggerId; // only set by DICT + Uint32 m_triggerInfo; // flags | event | timing | type + Uint32 m_online; // alter online (not normally for subscription) + Uint32 m_receiverRef; // receiver for subscription trigger + AttributeMask m_attributeMask; + // extra + Uint32 m_opKey; + +public: + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getConnectionPtr() const { + return m_connectionPtr; + } + void setConnectionPtr(Uint32 val) { + m_connectionPtr = val; + } + CreateTrigReq::RequestType getRequestType() const { + const Uint32 val = BitmaskImpl::getField(1, &m_requestInfo, 0, 16); + return (CreateTrigReq::RequestType)val; + } + void setRequestType(CreateTrigReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getRequestFlag() const { + return BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + }; + void addRequestFlag(Uint32 val) { + val |= BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + BitmaskImpl::setField(1, &m_requestInfo, 16, 16, val); + }; + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + Uint32 getIndexId() const { + return m_indexId; + } + void setIndexId(Uint32 val) { + m_indexId = val; + } + Uint32 getTriggerId() const { + return m_triggerId; + } + void setTriggerId(Uint32 val) { + m_triggerId = val; + } + Uint32 getTriggerInfo() const { + return m_triggerInfo; + } + void setTriggerInfo(Uint32 val) { + m_triggerInfo = val; + } + TriggerType::Value getTriggerType() const { + const Uint32 val = BitmaskImpl::getField(1, &m_triggerInfo, 0, 8); + return (TriggerType::Value)val; + } + void setTriggerType(TriggerType::Value val) { + BitmaskImpl::setField(1, &m_triggerInfo, 0, 8, (Uint32)val); + } + TriggerActionTime::Value getTriggerActionTime() const { + const Uint32 val = BitmaskImpl::getField(1, &m_triggerInfo, 8, 8); + return (TriggerActionTime::Value)val; + } + void setTriggerActionTime(TriggerActionTime::Value val) { + BitmaskImpl::setField(1, &m_triggerInfo, 8, 8, (Uint32)val); + } + TriggerEvent::Value getTriggerEvent() const { + const Uint32 val = BitmaskImpl::getField(1, &m_triggerInfo, 16, 8); + return (TriggerEvent::Value)val; + } + void setTriggerEvent(TriggerEvent::Value val) { + BitmaskImpl::setField(1, &m_triggerInfo, 16, 8, (Uint32)val); + } + bool getMonitorReplicas() const { + return BitmaskImpl::getField(1, &m_triggerInfo, 24, 1); + } + void setMonitorReplicas(bool val) { + BitmaskImpl::setField(1, &m_triggerInfo, 24, 1, val); + } + bool getMonitorAllAttributes() const { + return BitmaskImpl::getField(1, &m_triggerInfo, 25, 1); + } + void setMonitorAllAttributes(bool val) { + BitmaskImpl::setField(1, &m_triggerInfo, 25, 1, val); + } + Uint32 getOnline() const { + return m_online; + } + void setOnline(Uint32 val) { + m_online = val; + } + Uint32 getReceiverRef() const { + return m_receiverRef; + } + void setReceiverRef(Uint32 val) { + m_receiverRef = val; + } + AttributeMask& getAttributeMask() { + return m_attributeMask; + } + const AttributeMask& getAttributeMask() const { + return m_attributeMask; + } + void clearAttributeMask() { + m_attributeMask.clear(); + } + void setAttributeMask(const AttributeMask& val) { + m_attributeMask = val; + } + void setAttributeMask(Uint16 val) { + m_attributeMask.set(val); + } + Uint32 getOpKey() const { + return m_opKey; + } + void setOpKey(Uint32 val) { + m_opKey = val; + } +}; + +/** + * CreateTrigConf. + */ +class CreateTrigConf { + friend bool printCREATE_TRIG_CONF(FILE*, const Uint32*, Uint32, Uint16); + +public: + STATIC_CONST( InternalLength = 3 ); + STATIC_CONST( SignalLength = 7 ); + +private: + Uint32 m_userRef; + Uint32 m_connectionPtr; + Uint32 m_requestInfo; + Uint32 m_tableId; + Uint32 m_indexId; + Uint32 m_triggerId; + Uint32 m_triggerInfo; // BACKUP wants this + +public: + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getConnectionPtr() const { + return m_connectionPtr; + } + void setConnectionPtr(Uint32 val) { + m_connectionPtr = val; + } + CreateTrigReq::RequestType getRequestType() const { + return (CreateTrigReq::RequestType)m_requestInfo; + } + void setRequestType(CreateTrigReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + Uint32 getIndexId() const { + return m_indexId; + } + void setIndexId(Uint32 val) { + m_indexId = val; + } + Uint32 getTriggerId() const { + return m_triggerId; + } + void setTriggerId(Uint32 val) { + m_triggerId = val; + } + Uint32 getTriggerInfo() const { + return m_triggerInfo; + } + void setTriggerInfo(Uint32 val) { + m_triggerInfo = val; + } + TriggerType::Value getTriggerType() const { + const Uint32 val = BitmaskImpl::getField(1, &m_triggerInfo, 0, 8); + return (TriggerType::Value)val; + } + void setTriggerType(TriggerType::Value val) { + BitmaskImpl::setField(1, &m_triggerInfo, 0, 8, (Uint32)val); + } + TriggerActionTime::Value getTriggerActionTime() const { + const Uint32 val = BitmaskImpl::getField(1, &m_triggerInfo, 8, 8); + return (TriggerActionTime::Value)val; + } + void setTriggerActionTime(TriggerActionTime::Value val) { + BitmaskImpl::setField(1, &m_triggerInfo, 8, 8, (Uint32)val); + } + TriggerEvent::Value getTriggerEvent() const { + const Uint32 val = BitmaskImpl::getField(1, &m_triggerInfo, 16, 8); + return (TriggerEvent::Value)val; + } + void setTriggerEvent(TriggerEvent::Value val) { + BitmaskImpl::setField(1, &m_triggerInfo, 16, 8, (Uint32)val); + } + bool getMonitorReplicas() const { + return BitmaskImpl::getField(1, &m_triggerInfo, 24, 1); + } + void setMonitorReplicas(bool val) { + BitmaskImpl::setField(1, &m_triggerInfo, 24, 1, val); + } + bool getMonitorAllAttributes() const { + return BitmaskImpl::getField(1, &m_triggerInfo, 25, 1); + } + void setMonitorAllAttributes(bool val) { + BitmaskImpl::setField(1, &m_triggerInfo, 25, 1, val); + } +}; + +/** + * CreateTrigRef. + */ +class CreateTrigRef { + friend bool printCREATE_TRIG_REF(FILE*, const Uint32*, Uint32, Uint16); + +public: + enum ErrorCode { + NoError = 0, + Busy = 701, + TriggerNameTooLong = 4236, + TooManyTriggers = 4237, + TriggerNotFound = 4238, + TriggerExists = 4239, + UnsupportedTriggerType = 4240, + BadRequestType = 4247, + InvalidName = 4248, + InvalidTable = 4249 + }; + STATIC_CONST( SignalLength = CreateTrigConf::SignalLength + 3 ); + +private: + CreateTrigConf m_conf; + //Uint32 m_userRef; + //Uint32 m_connectionPtr; + //Uint32 m_requestInfo; + //Uint32 m_tableId; + //Uint32 m_indexId; + //Uint32 m_triggerId; + //Uint32 m_triggerInfo; + Uint32 m_errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + +public: + CreateTrigConf* getConf() { + return &m_conf; + } + const CreateTrigConf* getConf() const { + return &m_conf; + } + Uint32 getUserRef() const { + return m_conf.getUserRef(); + } + void setUserRef(Uint32 val) { + m_conf.setUserRef(val); + } + Uint32 getConnectionPtr() const { + return m_conf.getConnectionPtr(); + } + void setConnectionPtr(Uint32 val) { + m_conf.setConnectionPtr(val); + } + CreateTrigReq::RequestType getRequestType() const { + return m_conf.getRequestType(); + } + void setRequestType(CreateTrigReq::RequestType val) { + m_conf.setRequestType(val); + } + Uint32 getTableId() const { + return m_conf.getTableId(); + } + void setTableId(Uint32 val) { + m_conf.setTableId(val); + } + Uint32 getIndexId() const { + return m_conf.getIndexId(); + } + void setIndexId(Uint32 val) { + m_conf.setIndexId(val); + } + Uint32 getTriggerId() const { + return m_conf.getTriggerId(); + } + void setTriggerId(Uint32 val) { + m_conf.setTriggerId(val); + } + Uint32 getTriggerInfo() const { + return m_conf.getTriggerInfo(); + } + void setTriggerInfo(Uint32 val) { + m_conf.setTriggerInfo(val); + } + TriggerType::Value getTriggerType() const { + return m_conf.getTriggerType(); + } + void setTriggerType(TriggerType::Value val) { + m_conf.setTriggerType(val); + } + TriggerActionTime::Value getTriggerActionTime() const { + return m_conf.getTriggerActionTime(); + } + void setTriggerActionTime(TriggerActionTime::Value val) { + m_conf.setTriggerActionTime(val); + } + TriggerEvent::Value getTriggerEvent() const { + return m_conf.getTriggerEvent(); + } + void setTriggerEvent(TriggerEvent::Value val) { + m_conf.setTriggerEvent(val); + } + bool getMonitorReplicas() const { + return m_conf.getMonitorReplicas(); + } + void setMonitorReplicas(bool val) { + m_conf.setMonitorReplicas(val); + } + bool getMonitorAllAttributes() const { + return m_conf.getMonitorAllAttributes(); + } + void setMonitorAllAttributes(bool val) { + m_conf.setMonitorAllAttributes(val); + } + CreateTrigRef::ErrorCode getErrorCode() const { + return (CreateTrigRef::ErrorCode)m_errorCode; + } + void setErrorCode(CreateTrigRef::ErrorCode val) { + m_errorCode = (Uint32)val; + } + Uint32 getErrorLine() const { + return m_errorLine; + } + void setErrorLine(Uint32 val) { + m_errorLine = val; + } + Uint32 getErrorNode() const { + return m_errorNode; + } + void setErrorNode(Uint32 val) { + m_errorNode = val; + } +}; + +#endif diff --git a/ndb/include/kernel/signaldata/DiAddTab.hpp b/ndb/include/kernel/signaldata/DiAddTab.hpp new file mode 100644 index 00000000000..6b17515eb6f --- /dev/null +++ b/ndb/include/kernel/signaldata/DiAddTab.hpp @@ -0,0 +1,90 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DIADDTABREQ_HPP +#define DIADDTABREQ_HPP + +#include "SignalData.hpp" + +class DiAddTabReq { + /** + * Sender(s) + */ + friend class Dbdict; + + /** + * Receiver(s) + */ + friend class Dbdih; +public: + STATIC_CONST( SignalLength = 9 ); + SECTION( FRAGMENTATION = 0 ); + +private: + Uint32 connectPtr; + Uint32 tableId; + Uint32 fragType; + Uint32 kValue; + Uint32 noOfReplicas; //Currently not used + Uint32 storedTable; + Uint32 tableType; + Uint32 schemaVersion; + Uint32 primaryTableId; +}; + +class DiAddTabRef { + /** + * Sender(s) + */ + friend class Dbdih; + + /** + * Receiver(s) + */ + friend class Dbdict; +public: + STATIC_CONST( SignalLength = 2 ); + +private: + union { + Uint32 connectPtr; + Uint32 senderData; + }; + Uint32 errorCode; +}; + +class DiAddTabConf { + /** + * Sender(s) + */ + friend class Dbdih; + + /** + * Receiver(s) + */ + friend class Dbdict; +public: + STATIC_CONST( SignalLength = 1 ); + +private: + union { + Uint32 connectPtr; + Uint32 senderData; + }; +}; + + +#endif diff --git a/ndb/include/kernel/signaldata/DiGetNodes.hpp b/ndb/include/kernel/signaldata/DiGetNodes.hpp new file mode 100644 index 00000000000..05ab6bfebb3 --- /dev/null +++ b/ndb/include/kernel/signaldata/DiGetNodes.hpp @@ -0,0 +1,62 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DIGETNODES_HPP +#define DIGETNODES_HPP + +#include +#include + +/** + * + */ +class DiGetNodesConf { + /** + * Receiver(s) + */ + friend class Dbtc; + /** + * Sender(s) + */ + friend class Dbdih; +public: + STATIC_CONST( SignalLength = 3 + MAX_REPLICAS ); +private: + Uint32 zero; + Uint32 fragId; + Uint32 reqinfo; + Uint32 nodes[MAX_REPLICAS]; +}; +/** + * + */ +class DiGetNodesReq { + /** + * Sender(s) + */ + friend class Dbtc; + /** + * Receiver(s) + */ + friend class Dbdih; +public: + STATIC_CONST( SignalLength = 3 ); +private: + Uint32 notUsed; + Uint32 tableId; + Uint32 hashValue; +}; +#endif diff --git a/ndb/include/kernel/signaldata/DictSchemaInfo.hpp b/ndb/include/kernel/signaldata/DictSchemaInfo.hpp new file mode 100644 index 00000000000..d7f82abc299 --- /dev/null +++ b/ndb/include/kernel/signaldata/DictSchemaInfo.hpp @@ -0,0 +1,45 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DICT_SCHEMA_INFO_HPP +#define DICT_SCHEMA_INFO_HPP + +#include "SignalData.hpp" + +class DictSchemaInfo { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdict; + +public: + static const unsigned HeaderLength = 3; + static const unsigned DataLength = 22; + +private: + Uint32 senderRef; + Uint32 offset; + Uint32 totalLen; + + /** + * Length in this = signal->length() - 3 + * Sender block ref = signal->senderBlockRef() + */ + + Uint32 schemaInfoData[22]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/DictSizeAltReq.hpp b/ndb/include/kernel/signaldata/DictSizeAltReq.hpp new file mode 100644 index 00000000000..b40f0c8c1af --- /dev/null +++ b/ndb/include/kernel/signaldata/DictSizeAltReq.hpp @@ -0,0 +1,51 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DICT_SIZE_ALT_REQ_H +#define DICT_SIZE_ALT_REQ_H + + + +#include "SignalData.hpp" + +class DictSizeAltReq { + /** + * Sender(s) + */ + friend class ClusterConfiguration; + + /** + * Reciver(s) + */ + friend class Dbdict; +private: + /** + * Indexes in theData + */ + STATIC_CONST( IND_BLOCK_REF = 0 ); + STATIC_CONST( IND_ATTRIBUTE = 1 ); + STATIC_CONST( IND_CONNECT = 2 ); + STATIC_CONST( IND_FRAG_CONNECT = 3 ); + STATIC_CONST( IND_TABLE = 4 ); + STATIC_CONST( IND_TC_CONNECT = 5 ); + + /** + * Use the index definitions to use the signal data + */ + UintR theData[6]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/DictStart.hpp b/ndb/include/kernel/signaldata/DictStart.hpp new file mode 100644 index 00000000000..59310601f48 --- /dev/null +++ b/ndb/include/kernel/signaldata/DictStart.hpp @@ -0,0 +1,54 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DICT_START_HPP +#define DICT_START_HPP + +class DictStartReq { + /** + * Sender(s) + */ + friend class Dbdih; + /** + * Receiver(s) + */ + friend class Dbdict; + +public: + STATIC_CONST( SignalLength = 2 ); +private: + + Uint32 restartGci; + Uint32 senderRef; +}; + +class DictStartConf { + /** + * Sender(s) + */ + friend class Dbdict; + /** + * Receiver(s) + */ + friend class Dbdih; + +public: +private: + + Uint32 startingNodeId; + Uint32 startWord; +}; +#endif diff --git a/ndb/include/kernel/signaldata/DictTabInfo.hpp b/ndb/include/kernel/signaldata/DictTabInfo.hpp new file mode 100644 index 00000000000..791388d5df8 --- /dev/null +++ b/ndb/include/kernel/signaldata/DictTabInfo.hpp @@ -0,0 +1,483 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DICT_TAB_INFO_HPP +#define DICT_TAB_INFO_HPP + +#include "SignalData.hpp" +#include +#include +#include +#include +#include + +#define DTIMAP(x, y, z) \ + { DictTabInfo::y, offsetof(x, z), SimpleProperties::Uint32Value, 0, (~0), 0 } + +#define DTIMAP2(x, y, z, u, v) \ + { DictTabInfo::y, offsetof(x, z), SimpleProperties::Uint32Value, u, v, 0 } + +#define DTIMAPS(x, y, z, u, v) \ + { DictTabInfo::y, offsetof(x, z), SimpleProperties::StringValue, u, v, 0 } + +#define DTIMAPB(x, y, z, u, v, l) \ + { DictTabInfo::y, offsetof(x, z), SimpleProperties::BinaryValue, u, v, \ + offsetof(x, l) } + +#define DTIBREAK(x) \ + { DictTabInfo::x, 0, SimpleProperties::InvalidValue, 0, 0 } + +class DictTabInfo { + /** + * Sender(s) / Reciver(s) + */ + // Blocks + friend class Backup; + friend class Dbdict; + friend class Ndbcntr; + friend class Trix; + friend class DbUtil; + // API + friend class Table; + friend class NdbSchemaOp; + + /** + * For printing + */ + friend bool printDICTTABINFO(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 receiverBlockNo); + +public: + enum RequestType { + CreateTableFromAPI = 1, + AddTableFromDict = 2, // Between DICT's + CopyTable = 3, // Between DICT's + ReadTableFromDiskSR = 4, // Local in DICT + GetTabInfoConf = 5, + AlterTableFromAPI = 6 + }; + + enum KeyValues { + TableName = 1, // String, Mandatory + TableId = 2, //Mandatory between DICT's otherwise not allowed + TableVersion = 3, //Mandatory between DICT's otherwise not allowed + TableLoggedFlag = 4, //Default Logged + NoOfKeyAttr = 5, //Default 1 + NoOfAttributes = 6, //Mandatory + NoOfNullable = 7, //Deafult 0 + NoOfVariable = 8, //Default 0 + TableKValue = 9, //Default 6 + MinLoadFactor = 10, //Default 70 + MaxLoadFactor = 11, //Default 80 + KeyLength = 12, //Default 1 (No of words in primary key) + FragmentTypeVal = 13, //Default AllNodesSmallTable + TableStorageVal = 14, //Default StorageType::MainMemory + ScanOptimised = 15, //Default updateOptimised + FragmentKeyTypeVal = 16, //Default PrimaryKey + SecondTableId = 17, //Mandatory between DICT's otherwise not allowed + TableTypeVal = 18, //Default TableType::UserTable + PrimaryTable = 19, //Mandatory for index otherwise RNIL + PrimaryTableId = 20, //ditto + IndexState = 21, + InsertTriggerId = 22, + UpdateTriggerId = 23, + DeleteTriggerId = 24, + CustomTriggerId = 25, + FrmLen = 26, + FrmData = 27, + TableEnd = 999, + + AttributeName = 1000, // String, Mandatory + AttributeId = 1001, //Mandatory between DICT's otherwise not allowed + AttributeType = 1002, //Default UnSignedType + AttributeSize = 1003, //Default DictTabInfo::a32Bit + AttributeArraySize = 1005, //Default 1 + AttributeKeyFlag = 1006, //Default noKey + AttributeStorage = 1007, //Default MainMemory + AttributeNullableFlag = 1008, //Default NotNullable + AttributeDGroup = 1009, //Default NotDGroup + AttributeDKey = 1010, //Default NotDKey + AttributeStoredInd = 1011, //Default NotStored + AttributeGroup = 1012, //Default 0 + AttributeExtType = 1013, //Default 0 (undefined) + AttributeExtPrecision = 1014, //Default 0 + AttributeExtScale = 1015, //Default 0 + AttributeExtLength = 1016, //Default 0 + AttributeAutoIncrement = 1017, //Default false + AttributeDefaultValue = 1018, //Default value (printable string) + AttributeEnd = 1999 // + }; + // ---------------------------------------------------------------------- + // Part of the protocol is that we only transfer parameters which do not + // have a default value. Thus the default values are part of the protocol. + // ---------------------------------------------------------------------- + + // FragmentKeyType constants + enum FragmentKeyType { + PrimaryKey = 0, + DistributionKey = 1, + DistributionGroup = 2 + }; + + // FragmentType constants + enum FragmentType { + AllNodesSmallTable = 0, + AllNodesMediumTable = 1, + AllNodesLargeTable = 2, + SingleFragment = 3 + }; + + // TableStorage AND AttributeStorage constants + enum StorageType { + MainMemory = 0, + DiskMemory = 1 + }; + + // TableType constants + objects + enum TableType { + UndefTableType = 0, + SystemTable = 1, + UserTable = 2, + UniqueHashIndex = 3, + HashIndex = 4, + UniqueOrderedIndex = 5, + OrderedIndex = 6, + // constant 10 hardcoded in Dbdict.cpp + HashIndexTrigger = 10 + TriggerType::SECONDARY_INDEX, + SubscriptionTrigger = 10 + TriggerType::SUBSCRIPTION, + ReadOnlyConstraint = 10 + TriggerType::READ_ONLY_CONSTRAINT, + IndexTrigger = 10 + TriggerType::ORDERED_INDEX + }; + static inline bool + isTable(int tableType) { + return + tableType == SystemTable || + tableType == UserTable; + } + static inline bool + isIndex(int tableType) { + return + tableType == UniqueHashIndex || + tableType == HashIndex || + tableType == UniqueOrderedIndex || + tableType == OrderedIndex; + } + static inline bool + isUniqueIndex(int tableType) { + return + tableType == UniqueHashIndex || + tableType == UniqueOrderedIndex; + } + static inline bool + isNonUniqueIndex(int tableType) { + return + tableType == HashIndex || + tableType == OrderedIndex; + } + static inline bool + isHashIndex(int tableType) { + return + tableType == UniqueHashIndex || + tableType == HashIndex; + } + static inline bool + isOrderedIndex(int tableType) { + return + tableType == UniqueOrderedIndex || + tableType == OrderedIndex; + } + + // Object state for translating from/to API + enum ObjectState { + StateUndefined = 0, + StateOffline = 1, + StateBuilding = 2, + StateDropping = 3, + StateOnline = 4, + StateBroken = 9 + }; + + // Object store for translating from/to API + enum ObjectStore { + StoreUndefined = 0, + StoreTemporary = 1, + StorePermanent = 2 + }; + + // ScanOptimised constants + static const unsigned updateOptimised = 0; + static const unsigned scanOptimised = 1; + + // AttributeType constants + static const unsigned SignedType = 0; + static const unsigned UnSignedType = 1; + static const unsigned FloatingPointType = 2; + static const unsigned StringType = 3; + + // AttributeSize constants + static const unsigned an8Bit = 3; + static const unsigned a16Bit = 4; + static const unsigned a32Bit = 5; + static const unsigned a64Bit = 6; + static const unsigned a128Bit = 7; + + // AttributeDGroup constants + static const unsigned NotDGroup = 0; + static const unsigned DGroup = 1; + + // AttributeDKey constants + static const unsigned NotDKey = 0; + static const unsigned DKey = 1; + + // AttributeStoredInd constants + static const unsigned NotStored = 0; + static const unsigned Stored = 1; + + // Table data interpretation + struct Table { + char TableName[MAX_TAB_NAME_SIZE]; + Uint32 TableId; + Uint32 SecondTableId; + char PrimaryTable[MAX_TAB_NAME_SIZE]; // Only used when "index" + Uint32 PrimaryTableId; + Uint32 TableLoggedFlag; + Uint32 NoOfKeyAttr; + Uint32 NoOfAttributes; + Uint32 NoOfNullable; + Uint32 NoOfVariable; + Uint32 TableKValue; + Uint32 MinLoadFactor; + Uint32 MaxLoadFactor; + Uint32 KeyLength; + Uint32 FragmentType; + Uint32 TableStorage; + Uint32 ScanOptimised; + Uint32 FragmentKeyType; + Uint32 TableType; + Uint32 TableVersion; + Uint32 IndexState; + Uint32 InsertTriggerId; + Uint32 UpdateTriggerId; + Uint32 DeleteTriggerId; + Uint32 CustomTriggerId; + Uint32 FrmLen; + char FrmData[MAX_FRM_DATA_SIZE]; + + void init(); + }; + + static const + SimpleProperties::SP2StructMapping TableMapping[]; + + static const Uint32 TableMappingSize; + + // AttributeExtType values + enum ExtType { + ExtUndefined = NdbSqlUtil::Type::Undefined, + ExtTinyint = NdbSqlUtil::Type::Tinyint, + ExtTinyunsigned = NdbSqlUtil::Type::Tinyunsigned, + ExtSmallint = NdbSqlUtil::Type::Smallint, + ExtSmallunsigned = NdbSqlUtil::Type::Smallunsigned, + ExtMediumint = NdbSqlUtil::Type::Mediumint, + ExtMediumunsigned = NdbSqlUtil::Type::Mediumunsigned, + ExtInt = NdbSqlUtil::Type::Int, + ExtUnsigned = NdbSqlUtil::Type::Unsigned, + ExtBigint = NdbSqlUtil::Type::Bigint, + ExtBigunsigned = NdbSqlUtil::Type::Bigunsigned, + ExtFloat = NdbSqlUtil::Type::Float, + ExtDouble = NdbSqlUtil::Type::Double, + ExtDecimal = NdbSqlUtil::Type::Decimal, + ExtChar = NdbSqlUtil::Type::Char, + ExtVarchar = NdbSqlUtil::Type::Varchar, + ExtBinary = NdbSqlUtil::Type::Binary, + ExtVarbinary = NdbSqlUtil::Type::Varbinary, + ExtDatetime = NdbSqlUtil::Type::Datetime, + ExtTimespec = NdbSqlUtil::Type::Timespec + }; + + // Attribute data interpretation + struct Attribute { + char AttributeName[MAX_TAB_NAME_SIZE]; + Uint32 AttributeId; + Uint32 AttributeType; + Uint32 AttributeSize; + Uint32 AttributeArraySize; + Uint32 AttributeKeyFlag; + Uint32 AttributeStorage; + Uint32 AttributeNullableFlag; + Uint32 AttributeDGroup; + Uint32 AttributeDKey; + Uint32 AttributeStoredInd; + Uint32 AttributeGroup; + Uint32 AttributeExtType; + Uint32 AttributeExtPrecision; + Uint32 AttributeExtScale; + Uint32 AttributeExtLength; + Uint32 AttributeAutoIncrement; + char AttributeDefaultValue[MAX_ATTR_DEFAULT_VALUE_SIZE]; + + void init(); + + inline + Uint32 sizeInWords() + { + return ((1 << AttributeSize) * AttributeArraySize + 31) >> 5; + } + + // translate to old kernel types and sizes + inline bool + translateExtType() { + switch (AttributeExtType) { + case DictTabInfo::ExtUndefined: + break; + case DictTabInfo::ExtTinyint: + AttributeType = DictTabInfo::SignedType; + AttributeSize = DictTabInfo::an8Bit; + AttributeArraySize = AttributeExtLength; + return true; + case DictTabInfo::ExtTinyunsigned: + AttributeType = DictTabInfo::UnSignedType; + AttributeSize = DictTabInfo::an8Bit; + AttributeArraySize = AttributeExtLength; + return true; + case DictTabInfo::ExtSmallint: + AttributeType = DictTabInfo::SignedType; + AttributeSize = DictTabInfo::a16Bit; + AttributeArraySize = AttributeExtLength; + return true; + case DictTabInfo::ExtSmallunsigned: + AttributeType = DictTabInfo::UnSignedType; + AttributeSize = DictTabInfo::a16Bit; + AttributeArraySize = AttributeExtLength; + return true; + case DictTabInfo::ExtMediumint: + AttributeType = DictTabInfo::SignedType; + AttributeSize = DictTabInfo::an8Bit; + AttributeArraySize = 3 * AttributeExtLength; + return true; + case DictTabInfo::ExtMediumunsigned: + AttributeType = DictTabInfo::UnSignedType; + AttributeSize = DictTabInfo::an8Bit; + AttributeArraySize = 3 * AttributeExtLength; + return true; + case DictTabInfo::ExtInt: + AttributeType = DictTabInfo::SignedType; + AttributeSize = DictTabInfo::a32Bit; + AttributeArraySize = AttributeExtLength; + return true; + case DictTabInfo::ExtUnsigned: + AttributeType = DictTabInfo::UnSignedType; + AttributeSize = DictTabInfo::a32Bit; + AttributeArraySize = AttributeExtLength; + return true; + case DictTabInfo::ExtBigint: + AttributeType = DictTabInfo::SignedType; + AttributeSize = DictTabInfo::a64Bit; + AttributeArraySize = AttributeExtLength; + return true; + case DictTabInfo::ExtBigunsigned: + AttributeType = DictTabInfo::UnSignedType; + AttributeSize = DictTabInfo::a64Bit; + AttributeArraySize = AttributeExtLength; + return true; + case DictTabInfo::ExtFloat: + AttributeType = DictTabInfo::FloatingPointType; + AttributeSize = DictTabInfo::a32Bit; + AttributeArraySize = AttributeExtLength; + return true; + case DictTabInfo::ExtDouble: + AttributeType = DictTabInfo::FloatingPointType; + AttributeSize = DictTabInfo::a64Bit; + AttributeArraySize = AttributeExtLength; + return true; + case DictTabInfo::ExtDecimal: + // not yet implemented anywhere + break; + case DictTabInfo::ExtChar: + case DictTabInfo::ExtBinary: + AttributeType = DictTabInfo::StringType; + AttributeSize = DictTabInfo::an8Bit; + AttributeArraySize = AttributeExtLength; + return true; + case DictTabInfo::ExtVarchar: + case DictTabInfo::ExtVarbinary: + AttributeType = DictTabInfo::StringType; + AttributeSize = DictTabInfo::an8Bit; + AttributeArraySize = AttributeExtLength + 2; + return true; + case DictTabInfo::ExtDatetime: + AttributeType = DictTabInfo::StringType; + AttributeSize = DictTabInfo::an8Bit; + AttributeArraySize = 8 * AttributeExtLength; + return true; + case DictTabInfo::ExtTimespec: + AttributeType = DictTabInfo::StringType; + AttributeSize = DictTabInfo::an8Bit; + AttributeArraySize = 12 * AttributeExtLength; + return true; + }; + return false; + } + + inline void print(FILE *out) { + fprintf(out, "AttributeId = %d\n", AttributeId); + fprintf(out, "AttributeType = %d\n", AttributeType); + fprintf(out, "AttributeSize = %d\n", AttributeSize); + fprintf(out, "AttributeArraySize = %d\n", AttributeArraySize); + fprintf(out, "AttributeKeyFlag = %d\n", AttributeKeyFlag); + fprintf(out, "AttributeStorage = %d\n", AttributeStorage); + fprintf(out, "AttributeNullableFlag = %d\n", AttributeNullableFlag); + fprintf(out, "AttributeDGroup = %d\n", AttributeDGroup); + fprintf(out, "AttributeDKey = %d\n", AttributeDKey); + fprintf(out, "AttributeStoredInd = %d\n", AttributeStoredInd); + fprintf(out, "AttributeGroup = %d\n", AttributeGroup); + fprintf(out, "AttributeAutoIncrement = %d\n", AttributeAutoIncrement); + fprintf(out, "AttributeExtType = %d\n", AttributeExtType); + fprintf(out, "AttributeExtPrecision = %d\n", AttributeExtPrecision); + fprintf(out, "AttributeExtScale = %d\n", AttributeExtScale); + fprintf(out, "AttributeExtLength = %d\n", AttributeExtLength); + fprintf(out, "AttributeDefaultValue = \"%s\"\n", + AttributeDefaultValue ? AttributeDefaultValue : ""); + } + }; + + static const + SimpleProperties::SP2StructMapping AttributeMapping[]; + + static const Uint32 AttributeMappingSize; + + // Signal constants + STATIC_CONST( DataLength = 20 ); + STATIC_CONST( HeaderLength = 5 ); + +private: + Uint32 senderRef; + Uint32 senderData; + Uint32 requestType; + Uint32 totalLen; + Uint32 offset; + + /** + * Length of this data = signal->length() - HeaderLength + * Sender block ref = signal->senderBlockRef() + */ + + Uint32 tabInfoData[DataLength]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/DihAddFrag.hpp b/ndb/include/kernel/signaldata/DihAddFrag.hpp new file mode 100644 index 00000000000..6e5a24ee413 --- /dev/null +++ b/ndb/include/kernel/signaldata/DihAddFrag.hpp @@ -0,0 +1,62 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DIHADDFRAG_HPP +#define DIHADDFRAG_HPP + +#include +#include + +/** + * + */ +class DihAddFragConf { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 2 ); +private: + Uint32 senderNodeId; + Uint32 tableId; +}; +/** + * + */ +class DihAddFragReq { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 10 + MAX_REPLICAS ); +private: + Uint32 masterRef; + Uint32 tableId; + Uint32 fragId; + Uint32 kValue; + Uint32 method; + Uint32 mask; + Uint32 hashPointer; + Uint32 noOfFragments; + Uint32 noOfBackups; + Uint32 storedTable; + Uint32 nodes[MAX_REPLICAS]; +}; +#endif diff --git a/ndb/include/kernel/signaldata/DihContinueB.hpp b/ndb/include/kernel/signaldata/DihContinueB.hpp new file mode 100644 index 00000000000..e683b55351c --- /dev/null +++ b/ndb/include/kernel/signaldata/DihContinueB.hpp @@ -0,0 +1,75 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DIH_CONTINUEB_H +#define DIH_CONTINUEB_H + +#include "SignalData.hpp" + +class DihContinueB { + /** + * Sender(s)/Reciver(s) + */ + friend class Dbdih; + friend bool printCONTINUEB_DBDIH(FILE * output, const Uint32 * theData, Uint32 len); +private: + enum Type { + ZPACK_TABLE_INTO_PAGES = 1, + ZPACK_FRAG_INTO_PAGES = 2, + ZREAD_PAGES_INTO_TABLE = 3, + ZREAD_PAGES_INTO_FRAG = 4, + //ZREAD_TAB_DESCRIPTION = 5, + ZCOPY_TABLE = 6, + ZCOPY_TABLE_NODE = 7, + ZSTART_FRAGMENT = 8, + ZCOMPLETE_RESTART = 9, + ZREAD_TABLE_FROM_PAGES = 10, + ZSR_PHASE2_READ_TABLE = 11, + ZCHECK_TC_COUNTER = 12, + ZCALCULATE_KEEP_GCI = 13, + ZSTORE_NEW_LCP_ID = 14, + ZTABLE_UPDATE = 15, + ZCHECK_LCP_COMPLETED = 16, + ZINIT_LCP = 17, + ZADD_TABLE_MASTER_PAGES = 19, + ZDIH_ADD_TABLE_MASTER = 20, + ZADD_TABLE_SLAVE_PAGES = 21, + ZDIH_ADD_TABLE_SLAVE = 22, + ZSTART_GCP = 23, + ZCOPY_GCI = 24, + ZEMPTY_VERIFY_QUEUE = 25, + ZCHECK_GCP_STOP = 26, + ZREMOVE_NODE_FROM_TABLE = 27, + ZCOPY_NODE = 28, + ZSTART_TAKE_OVER = 29, + ZCHECK_START_TAKE_OVER = 30, + ZTO_START_COPY_FRAG = 31, + ZINITIALISE_RECORDS = 33, + ZINVALIDATE_NODE_LCP = 34, + ZSTART_PERMREQ_AGAIN = 35, + SwitchReplica = 36, + ZSEND_START_TO = 37, + ZSEND_ADD_FRAG = 38, + ZSEND_CREATE_FRAG = 39, + ZSEND_UPDATE_TO = 40, + ZSEND_END_TO = 41, + + WAIT_DROP_TAB_WRITING_TO_FILE = 42, + CHECK_WAIT_DROP_TAB_FAILED_LQH = 43 + }; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/DihSizeAltReq.hpp b/ndb/include/kernel/signaldata/DihSizeAltReq.hpp new file mode 100644 index 00000000000..73279447859 --- /dev/null +++ b/ndb/include/kernel/signaldata/DihSizeAltReq.hpp @@ -0,0 +1,50 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DIH_SIZE_ALT_REQ_H +#define DIH_SIZE_ALT_REQ_H + +#include "SignalData.hpp" + +class DihSizeAltReq { + /** + * Sender(s) + */ + friend class ClusterConfiguration; + + /** + * Reciver(s) + */ + friend class Dbdih; +private: + /** + * Indexes in theData + */ + STATIC_CONST( IND_BLOCK_REF = 0 ); + STATIC_CONST( IND_API_CONNECT = 1 ); + STATIC_CONST( IND_CONNECT = 2 ); + STATIC_CONST( IND_FRAG_CONNECT = 3 ); + STATIC_CONST( IND_MORE_NODES = 4 ); + STATIC_CONST( IND_REPLICAS = 5 ); + STATIC_CONST( IND_TABLE = 6 ); + + /** + * Use the index definitions to use the signal data + */ + UintR theData[7]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/DihStartTab.hpp b/ndb/include/kernel/signaldata/DihStartTab.hpp new file mode 100644 index 00000000000..75443e6070e --- /dev/null +++ b/ndb/include/kernel/signaldata/DihStartTab.hpp @@ -0,0 +1,65 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DIH_STARTTAB__HPP +#define DIH_STARTTAB__HPP + +#include "SignalData.hpp" + +class DihStartTabReq { + /** + * Sender(s) + */ + friend class Dbdict; + + /** + * Receiver(s) + */ + friend class Dbdih; +public: + STATIC_CONST( HeaderLength = 3 ); + +private: + + Uint32 senderRef; + Uint32 senderData; + Uint32 noOfTables; + + struct { + Uint32 tableId; + Uint32 schemaVersion; + } tables[10]; +}; + +class DihStartTabConf { + /** + * Sender(s) + */ + friend class Dbdih; + + /** + * Receiver(s) + */ + friend class Dbdict; +public: + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 senderRef; + Uint32 senderData; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/DihSwitchReplica.hpp b/ndb/include/kernel/signaldata/DihSwitchReplica.hpp new file mode 100644 index 00000000000..d4212f510f3 --- /dev/null +++ b/ndb/include/kernel/signaldata/DihSwitchReplica.hpp @@ -0,0 +1,72 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DIH_SWITCH_REPLICA_HPP +#define DIH_SWITCH_REPLICA_HPP + +/** + * This signal is sent from master DIH to all DIH's + * switches primary / backup nodes for replica(s) + * + */ +class DihSwitchReplicaReq { + /** + * Sender/Reciver + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 4 + MAX_REPLICAS ); + +private: + /** + * Request Info + * + */ + Uint32 senderRef; + Uint32 tableId; + Uint32 fragNo; + Uint32 noOfReplicas; + Uint32 newNodeOrder[MAX_REPLICAS]; +}; + +class DihSwitchReplicaRef { + /** + * Sender/Reciver + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 senderNode; + Uint32 errorCode; // See StopPermRef::ErrorCode +}; + +class DihSwitchReplicaConf { + /** + * Sender/Reciver + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 1 ); + +private: + Uint32 senderNode; +}; +#endif diff --git a/ndb/include/kernel/signaldata/DisconnectRep.hpp b/ndb/include/kernel/signaldata/DisconnectRep.hpp new file mode 100644 index 00000000000..d7fcdc4fb35 --- /dev/null +++ b/ndb/include/kernel/signaldata/DisconnectRep.hpp @@ -0,0 +1,61 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DISCONNECT_REP_HPP +#define DISCONNECT_REP_HPP + +#include "SignalData.hpp" + +/** + * + */ +class DisconnectRep { + /** + * Receiver(s) + */ + friend class Qmgr; + friend class Cmvmi; // Cmvmi + + /** + * Senders + */ + friend class Dbtc; + friend void reportDisconnect(void * , NodeId, Uint32); // TransporterCallback + + /** + * For printing + */ + friend bool printDISCONNECT_REP(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 2 ); + + enum ErrCode { + // ErrorCodes come from different sources + // for example TransporterCallback.hpp + // or inet errno + // This one is selected not to conflict with any of them + TcReportNodeFailed = 0xFF000001 + }; + +private: + + Uint32 nodeId; + Uint32 err; +}; + + +#endif diff --git a/ndb/include/kernel/signaldata/DropIndx.hpp b/ndb/include/kernel/signaldata/DropIndx.hpp new file mode 100644 index 00000000000..0c0cf31aec8 --- /dev/null +++ b/ndb/include/kernel/signaldata/DropIndx.hpp @@ -0,0 +1,253 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DROP_INDX_HPP +#define DROP_INDX_HPP + +#include "SignalData.hpp" +#include + +/** + * DropIndxReq. + */ +class DropIndxReq { + friend bool printDROP_INDX_REQ(FILE*, const Uint32*, Uint32, Uint16); + +public: + enum RequestType { + RT_UNDEFINED = 0, + RT_USER = 1, + RT_DICT_PREPARE = 1 << 4, + RT_DICT_COMMIT = 0xC << 4, + RT_DICT_ABORT = 0xF << 4, + RT_TC = 5 << 8 + }; + STATIC_CONST( SignalLength = 6 ); + +private: + Uint32 m_connectionPtr; + Uint32 m_userRef; + Uint32 m_requestInfo; + Uint32 m_tableId; + Uint32 m_indexId; + Uint32 m_indexVersion; + // extra + Uint32 m_opKey; + +public: + Uint32 getConnectionPtr() const { + return m_connectionPtr; + } + void setConnectionPtr(Uint32 val) { + m_connectionPtr = val; + } + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + DropIndxReq::RequestType getRequestType() const { + const Uint32 val = BitmaskImpl::getField(1, &m_requestInfo, 0, 16); + return (DropIndxReq::RequestType)val; + } + void setRequestType(DropIndxReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getRequestFlag() const { + return BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + }; + void addRequestFlag(Uint32 val) { + val |= BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + BitmaskImpl::setField(1, &m_requestInfo, 16, 16, val); + }; + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + Uint32 getIndexId() const { + return m_indexId; + } + void setIndexId(Uint32 val) { + m_indexId = val; + } + Uint32 getIndexVersion() const { + return m_indexVersion; + } + void setIndexVersion(Uint32 val) { + m_indexVersion = val; + } + Uint32 getOpKey() const { + return m_opKey; + } + void setOpKey(Uint32 val) { + m_opKey = val; + } +}; + +/** + * DropIndxConf. + */ +class DropIndxConf { + friend bool printDROP_INDX_CONF(FILE*, const Uint32*, Uint32, Uint16); + +public: + STATIC_CONST( InternalLength = 3 ); + STATIC_CONST( SignalLength = 6 ); + +private: + Uint32 m_connectionPtr; + Uint32 m_userRef; + Uint32 m_requestInfo; + Uint32 m_tableId; + Uint32 m_indexId; + Uint32 m_indexVersion; + +public: + Uint32 getConnectionPtr() const { + return m_connectionPtr; + } + void setConnectionPtr(Uint32 val) { + m_connectionPtr = val; + } + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + DropIndxReq::RequestType getRequestType() const { + return (DropIndxReq::RequestType)m_requestInfo; + } + void setRequestType(DropIndxReq::RequestType val) { + m_requestInfo = val; + } + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + Uint32 getIndexId() const { + return m_indexId; + } + void setIndexId(Uint32 val) { + m_indexId = val; + } + Uint32 getIndexVersion() const { + return m_indexVersion; + } + void setIndexVersion(Uint32 val) { + m_indexVersion = val; + } +}; + +/** + * DropIndxRef. + */ +class DropIndxRef { + friend bool printDROP_INDX_REF(FILE*, const Uint32*, Uint32, Uint16); + +public: + enum ErrorCode { + NoError = 0, + InvalidIndexVersion = 241, + Busy = 701, + IndexNotFound = 4243, + BadRequestType = 4247, + InvalidName = 4248, + NotAnIndex = 4254 + }; + STATIC_CONST( SignalLength = DropIndxConf::SignalLength + 3 ); + +private: + DropIndxConf m_conf; + //Uint32 m_userRef; + //Uint32 m_connectionPtr; + //Uint32 m_requestInfo; + //Uint32 m_tableId; + //Uint32 m_indexId; + //Uint32 m_indexVersion; + Uint32 m_errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + +public: + DropIndxConf* getConf() { + return &m_conf; + } + const DropIndxConf* getConf() const { + return &m_conf; + } + Uint32 getConnectionPtr() const { + return m_conf.getConnectionPtr(); + } + void setConnectionPtr(Uint32 val) { + m_conf.setConnectionPtr(val); + } + Uint32 getUserRef() const { + return m_conf.getUserRef(); + } + void setUserRef(Uint32 val) { + m_conf.setUserRef(val); + } + DropIndxReq::RequestType getRequestType() const { + return m_conf.getRequestType(); + } + void setRequestType(DropIndxReq::RequestType val) { + m_conf.setRequestType(val); + } + Uint32 getTableId() const { + return m_conf.getTableId(); + } + void setTableId(Uint32 val) { + m_conf.setTableId(val); + } + Uint32 getIndexId() const { + return m_conf.getIndexId(); + } + void setIndexId(Uint32 val) { + m_conf.setIndexId(val); + } + Uint32 getIndexVersion() const { + return m_conf.getIndexVersion(); + } + void setIndexVersion(Uint32 val) { + m_conf.setIndexVersion(val); + } + DropIndxRef::ErrorCode getErrorCode() const { + return (DropIndxRef::ErrorCode)m_errorCode; + } + void setErrorCode(DropIndxRef::ErrorCode val) { + m_errorCode = (Uint32)val; + } + Uint32 getErrorLine() const { + return m_errorLine; + } + void setErrorLine(Uint32 val) { + m_errorLine = val; + } + Uint32 getErrorNode() const { + return m_errorNode; + } + void setErrorNode(Uint32 val) { + m_errorNode = val; + } +}; + +#endif diff --git a/ndb/include/kernel/signaldata/DropTab.hpp b/ndb/include/kernel/signaldata/DropTab.hpp new file mode 100644 index 00000000000..906f952d852 --- /dev/null +++ b/ndb/include/kernel/signaldata/DropTab.hpp @@ -0,0 +1,114 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DROP_TAB_HPP +#define DROP_TAB_HPP + +#include "SignalData.hpp" + +class DropTabReq { + /** + * Sender(s) + */ + friend class Dbdict; + + /** + * Receiver(s) + */ + friend class Dbtc; + friend class Dblqh; + friend class Dbacc; + friend class Dbtup; + friend class Dbtux; + friend class Dbdih; + + friend bool printDROP_TAB_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + enum RequestType { + OnlineDropTab = 0, + CreateTabDrop = 1, + RestartDropTab = 2 + }; +private: + Uint32 senderRef; + Uint32 senderData; + Uint32 tableId; + Uint32 requestType; +}; + +class DropTabConf { + /** + * Sender(s) + */ + friend class Dbtc; + friend class Dblqh; + friend class Dbacc; + friend class Dbtup; + friend class Dbtux; + friend class Dbdih; + + /** + * Receiver(s) + */ + friend class Dbdict; + + friend bool printDROP_TAB_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 senderRef; + Uint32 senderData; + Uint32 tableId; +}; + +class DropTabRef { + /** + * Sender(s) + */ + friend class Dbtc; + friend class Dblqh; + friend class Dbacc; + friend class Dbtup; + friend class Dbtux; + friend class Dbdih; + + /** + * Receiver(s) + */ + friend class Dbdict; + + friend bool printDROP_TAB_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + enum ErrorCode { + NoSuchTable = 1, + DropWoPrep = 2, // Calling Drop with first calling PrepDrop + PrepDropInProgress = 3, + DropInProgress = 4 + }; + +private: + Uint32 senderRef; + Uint32 senderData; + Uint32 tableId; + Uint32 errorCode; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/DropTabFile.hpp b/ndb/include/kernel/signaldata/DropTabFile.hpp new file mode 100644 index 00000000000..9ae4dae41c1 --- /dev/null +++ b/ndb/include/kernel/signaldata/DropTabFile.hpp @@ -0,0 +1,64 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DROP_TABFILE_HPP +#define DROP_TABFILE_HPP + +#include "SignalData.hpp" + +class DropTabFileReq { + /** + * Sender(s) + */ + friend class Dbdict; + + /** + * Receiver(s) + */ + friend class Dbdih; + friend class Dbacc; + friend class Dbtup; +public: + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 userPtr; + Uint32 userRef; + Uint32 primaryTableId; + Uint32 secondaryTableId; +}; +class DropTabFileConf { + /** + * Receiver(s) + */ + friend class Dbdict; + + /** + * Sender(s) + */ + friend class Dbdih; + friend class Dbacc; + friend class Dbtup; +public: + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 userPtr; + Uint32 senderRef; + Uint32 nodeId; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/DropTable.hpp b/ndb/include/kernel/signaldata/DropTable.hpp new file mode 100644 index 00000000000..7a5b96e4cd1 --- /dev/null +++ b/ndb/include/kernel/signaldata/DropTable.hpp @@ -0,0 +1,80 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DROP_TABLE_HPP +#define DROP_TABLE_HPP + +#include "SignalData.hpp" + +class DropTableReq { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdict; + +public: + STATIC_CONST( SignalLength = 4 ); +public: + Uint32 senderData; + Uint32 senderRef; + Uint32 tableId; + Uint32 tableVersion; +}; + +class DropTableRef { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdict; + +public: + STATIC_CONST( SignalLength = 6 ); + +public: + Uint32 senderData; + Uint32 senderRef; + Uint32 tableId; + Uint32 tableVersion; + Uint32 errorCode; + Uint32 masterNodeId; + + enum ErrorCode { + Busy = 701, + NotMaster = 702, + NoSuchTable = 709, + InvalidTableVersion = 241, + DropInProgress = 283, + NoDropTableRecordAvailable = 1229 + }; +}; + +class DropTableConf { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdict; + +public: + STATIC_CONST( SignalLength = 4 ); + +public: + Uint32 senderData; + Uint32 senderRef; + Uint32 tableId; + Uint32 tableVersion; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/DropTrig.hpp b/ndb/include/kernel/signaldata/DropTrig.hpp new file mode 100644 index 00000000000..7c5049f3de8 --- /dev/null +++ b/ndb/include/kernel/signaldata/DropTrig.hpp @@ -0,0 +1,300 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DROP_TRIG_HPP +#define DROP_TRIG_HPP + +#include "SignalData.hpp" +#include +#include + +/** + * DropTrigReq. + */ +class DropTrigReq { + friend bool printDROP_TRIG_REQ(FILE*, const Uint32*, Uint32, Uint16); + +public: + enum RequestType { + RT_UNDEFINED = 0, + RT_USER = 1, + RT_ALTER_INDEX = 2, + RT_BUILD_INDEX = 3, + RT_DICT_PREPARE = 1 << 4, + RT_DICT_COMMIT = 0xC << 4, + RT_DICT_ABORT = 0xF << 4, + RT_TC = 5 << 8, + RT_LQH = 6 << 8 + }; + STATIC_CONST( SignalLength = 7 ); + SECTION( TRIGGER_NAME_SECTION = 0 ); // optional + enum KeyValues { + TriggerNameKey = 0xa1 + }; + +private: + Uint32 m_userRef; + Uint32 m_connectionPtr; + Uint32 m_requestInfo; + Uint32 m_tableId; + Uint32 m_indexId; // set by DICT if index trigger + Uint32 m_triggerId; // set by DICT based on name + Uint32 m_triggerInfo; // only for TUP + // extra + Uint32 m_opKey; + +public: + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getConnectionPtr() const { + return m_connectionPtr; + } + void setConnectionPtr(Uint32 val) { + m_connectionPtr = val; + } + DropTrigReq::RequestType getRequestType() const { + const Uint32 val = BitmaskImpl::getField(1, &m_requestInfo, 0, 16); + return (DropTrigReq::RequestType)val; + } + void setRequestType(DropTrigReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getRequestFlag() const { + return BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + }; + void addRequestFlag(Uint32 val) { + val |= BitmaskImpl::getField(1, &m_requestInfo, 16, 16); + BitmaskImpl::setField(1, &m_requestInfo, 16, 16, val); + }; + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + Uint32 getIndexId() const { + return m_indexId; + } + void setIndexId(Uint32 val) { + m_indexId = val; + } + Uint32 getTriggerId() const { + return m_triggerId; + } + void setTriggerId(Uint32 val) { + m_triggerId = val; + } + Uint32 getTriggerInfo() const { + return m_triggerInfo; + } + void setTriggerInfo(Uint32 val) { + m_triggerInfo = val; + } + TriggerType::Value getTriggerType() const { + const Uint32 val = BitmaskImpl::getField(1, &m_triggerInfo, 0, 8); + return (TriggerType::Value)val; + } + void setTriggerType(TriggerType::Value val) { + BitmaskImpl::setField(1, &m_triggerInfo, 0, 8, (Uint32)val); + } + TriggerActionTime::Value getTriggerActionTime() const { + const Uint32 val = BitmaskImpl::getField(1, &m_triggerInfo, 8, 8); + return (TriggerActionTime::Value)val; + } + void setTriggerActionTime(TriggerActionTime::Value val) { + BitmaskImpl::setField(1, &m_triggerInfo, 8, 8, (Uint32)val); + } + TriggerEvent::Value getTriggerEvent() const { + const Uint32 val = BitmaskImpl::getField(1, &m_triggerInfo, 16, 8); + return (TriggerEvent::Value)val; + } + void setTriggerEvent(TriggerEvent::Value val) { + BitmaskImpl::setField(1, &m_triggerInfo, 16, 8, (Uint32)val); + } + bool getMonitorReplicas() const { + return BitmaskImpl::getField(1, &m_triggerInfo, 24, 1); + } + void setMonitorReplicas(bool val) { + BitmaskImpl::setField(1, &m_triggerInfo, 24, 1, val); + } + bool getMonitorAllAttributes() const { + return BitmaskImpl::getField(1, &m_triggerInfo, 25, 1); + } + void setMonitorAllAttributes(bool val) { + BitmaskImpl::setField(1, &m_triggerInfo, 25, 1, val); + } + Uint32 getOpKey() const { + return m_opKey; + } + void setOpKey(Uint32 val) { + m_opKey = val; + } +}; + +/** + * DropTrigConf. + */ +class DropTrigConf { + friend bool printDROP_TRIG_CONF(FILE*, const Uint32*, Uint32, Uint16); + +public: + STATIC_CONST( InternalLength = 3 ); + STATIC_CONST( SignalLength = 6 ); + +private: + Uint32 m_userRef; + Uint32 m_connectionPtr; + Uint32 m_requestInfo; + Uint32 m_tableId; + Uint32 m_indexId; + Uint32 m_triggerId; + + // Public methods +public: + Uint32 getUserRef() const { + return m_userRef; + } + void setUserRef(Uint32 val) { + m_userRef = val; + } + Uint32 getConnectionPtr() const { + return m_connectionPtr; + } + void setConnectionPtr(Uint32 val) { + m_connectionPtr = val; + } + DropTrigReq::RequestType getRequestType() const { + return (DropTrigReq::RequestType)m_requestInfo; + } + void setRequestType(DropTrigReq::RequestType val) { + m_requestInfo = (Uint32)val; + } + Uint32 getTableId() const { + return m_tableId; + } + void setTableId(Uint32 val) { + m_tableId = val; + } + Uint32 getIndexId() const { + return m_indexId; + } + void setIndexId(Uint32 val) { + m_indexId = val; + } + Uint32 getTriggerId() const { + return m_triggerId; + } + void setTriggerId(Uint32 val) { + m_triggerId = val; + } +}; + +/** + * DropTrigRef. + */ +class DropTrigRef { + friend bool printDROP_TRIG_REF(FILE*, const Uint32*, Uint32, Uint16); + +public: + enum ErrorCode { + NoError = 0, + Busy = 701, + TriggerNotFound = 4238, + BadRequestType = 4247, + InvalidName = 4248 + }; + STATIC_CONST( SignalLength = DropTrigConf::SignalLength + 3 ); + +private: + DropTrigConf m_conf; + //Uint32 m_userRef; + //Uint32 m_connectionPtr; + //Uint32 m_requestInfo; + //Uint32 m_tableId; + //Uint32 m_indexId; + //Uint32 m_triggerId; + Uint32 m_errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + +public: + DropTrigConf* getConf() { + return &m_conf; + } + const DropTrigConf* getConf() const { + return &m_conf; + } + Uint32 getUserRef() const { + return m_conf.getUserRef(); + } + void setUserRef(Uint32 val) { + m_conf.setUserRef(val); + } + Uint32 getConnectionPtr() const { + return m_conf.getConnectionPtr(); + } + void setConnectionPtr(Uint32 val) { + m_conf.setConnectionPtr(val); + } + DropTrigReq::RequestType getRequestType() const { + return m_conf.getRequestType(); + } + void setRequestType(DropTrigReq::RequestType val) { + m_conf.setRequestType(val); + } + Uint32 getTableId() const { + return m_conf.getTableId(); + } + void setTableId(Uint32 val) { + m_conf.setTableId(val); + } + Uint32 getIndexId() const { + return m_conf.getIndexId(); + } + void setIndexId(Uint32 val) { + m_conf.setIndexId(val); + } + Uint32 getTriggerId() const { + return m_conf.getTriggerId(); + } + void setTriggerId(Uint32 val) { + m_conf.setTriggerId(val); + } + DropTrigRef::ErrorCode getErrorCode() const { + return (DropTrigRef::ErrorCode)m_errorCode; + } + void setErrorCode(DropTrigRef::ErrorCode val) { + m_errorCode = (Uint32)val; + } + Uint32 getErrorLine() const { + return m_errorLine; + } + void setErrorLine(Uint32 val) { + m_errorLine = val; + } + Uint32 getErrorNode() const { + return m_errorNode; + } + void setErrorNode(Uint32 val) { + m_errorNode = val; + } +}; + +#endif diff --git a/ndb/include/kernel/signaldata/DumpStateOrd.hpp b/ndb/include/kernel/signaldata/DumpStateOrd.hpp new file mode 100644 index 00000000000..6403a52926f --- /dev/null +++ b/ndb/include/kernel/signaldata/DumpStateOrd.hpp @@ -0,0 +1,134 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DUMP_STATE_ORD_HPP +#define DUMP_STATE_ORD_HPP + +#include "SignalData.hpp" + +/** + * DumpStateOrd is sent by the mgmtsrvr to CMVMI. + * CMVMI the redirect the signal to all blocks. + * + * The implementation of the DumpStateOrd should dump state information + * (typically using the infoEvent-function) + */ +class DumpStateOrd { + /** + * Sender/Reciver + */ + friend class Cmvmi; + + /** + * Sender(s) + */ + friend class MgmtSrvr; + + /** + * Reciver(s) + */ + friend class Dbacc; + friend class Dblqh; + friend class Dbtup; + friend class Dbtc; + friend class Ndbcntr; + friend class Qmgr; + friend class Dbdih; + friend class Dbdict; + friend class Ndbfs; + +public: + enum DumpStateType { + // 1 QMGR Dump information about phase 1 variables + // 13 CMVMI Dump signal counter + // 13 NDBCNTR Dump start phase information + // 13 NDBCNTR_REF Dump start phase information + CommitAckMarkersSize = 14, // TC+LQH Dump free size in commitAckMarkerP + CommitAckMarkersDump = 15, // TC+LQH Dump info in commitAckMarkerPool + DihDumpNodeRestartInfo = 16, // 16 DIH Dump node restart info + DihDumpNodeStatusInfo = 17,// 17 DIH Dump node status info + DihPrintFragmentation = 18,// 18 DIH Print fragmentation + // 19 NDBFS Fipple with O_SYNC, O_CREATE etc. + // 20-24 BACKUP + NdbcntrTestStopOnError = 25, + // 100-105 TUP and ACC + // 200-240 UTIL + // 300-305 TRIX + NdbfsDumpFileStat = 400, + NdbfsDumpAllFiles = 401, + NdbfsDumpOpenFiles = 402, + NdbfsDumpIdleFiles = 403, + // 1222-1225 DICT + LqhDumpAllDefinedTabs = 1332, + LqhDumpNoLogPages = 1333, + LqhDumpOneScanRec = 2300, + LqhDumpAllScanRec = 2301, + LqhDumpAllActiveScanRec = 2302, + LqhDumpLcpState = 2303, + AccDumpOneScanRec = 2400, + AccDumpAllScanRec = 2401, + AccDumpAllActiveScanRec = 2402, + AccDumpOneOperationRec = 2403, + AccDumpNumOpRecs = 2404, + AccDumpFreeOpRecs = 2405, + AccDumpNotFreeOpRecs = 2406, + DumpPageMemory = 1000, // Acc & TUP + TcDumpAllScanFragRec = 2500, + TcDumpOneScanFragRec = 2501, + TcDumpAllScanRec = 2502, + TcDumpAllActiveScanRec = 2503, + TcDumpOneScanRec = 2504, + TcDumpOneApiConnectRec = 2505, + TcDumpAllApiConnectRec = 2506, + TcSetTransactionTimeout = 2507, + CmvmiDumpConnections = 2600, + CmvmiDumpLongSignalMemory = 2601, + CmvmiSetRestartOnErrorInsert = 2602, + CmvmiTestLongSigWithDelay = 2603, + // 7000 DIH + // 7001 DIH + // 7002 DIH + // 7003 DIH + // 7004 DIH + // 7005 DIH + // 7006 DIH + // 7006 DIH + // 7007 DIH + // 7008 DIH + // 7009 DIH + // 7010 DIH + // 7011 DIH + // 7012 DIH + DihDumpLCPState= 7013, + DihDumpLCPMasterTakeOver = 7014, + // 7015 DIH + DihAllAllowNodeStart = 7016, + DihMinTimeBetweenLCP = 7017, + DihMaxTimeBetweenLCP = 7018, + EnableUndoDelayDataWrite = 7080, // DIH+ACC+TUP + DihStartLcpImmediately = 7099, + // 8000 Suma + // 12000 Tux + TuxLogToFile = 12001, + TuxSetLogFlags = 12002, + TuxMetaDataJunk = 12009 + }; +public: + + Uint32 args[25]; // Generic argument +}; + +#endif diff --git a/ndb/include/kernel/signaldata/EmptyLcp.hpp b/ndb/include/kernel/signaldata/EmptyLcp.hpp new file mode 100644 index 00000000000..32ea6c13231 --- /dev/null +++ b/ndb/include/kernel/signaldata/EmptyLcp.hpp @@ -0,0 +1,77 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef EMPTY_LCPREQ_HPP +#define EMPTY_LCPREQ_HPP + +/** + * This signals is sent by Dbdih-Master to Dblqh + * as part of master take over after node crash + */ +class EmptyLcpReq { + /** + * Sender(s) + */ + friend class Dbdih; + + /** + * Sender(s) / Receiver(s) + */ + + /** + * Receiver(s) + */ + friend class Dblqh; + +public: + STATIC_CONST( SignalLength = 1 ); +private: + + Uint32 senderRef; +}; + +/** + * This signals is sent by Dblqh to Dbdih + * as part of master take over after node crash + */ +class EmptyLcpConf { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Sender(s) / Receiver(s) + */ + + /** + * Receiver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 6 ); +private: + + Uint32 senderNodeId; + Uint32 tableId; + Uint32 fragmentId; + Uint32 lcpNo; + Uint32 lcpId; + Uint32 idle; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/EndTo.hpp b/ndb/include/kernel/signaldata/EndTo.hpp new file mode 100644 index 00000000000..944cca3ca98 --- /dev/null +++ b/ndb/include/kernel/signaldata/EndTo.hpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef END_TO_HPP +#define END_TO_HPP + +class EndToReq { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 4 ); +private: + Uint32 userPtr; + BlockReference userRef; + Uint32 startingNodeId; + Uint32 nodeTakenOver; +}; + +class EndToConf { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 3 ); +private: + + Uint32 userPtr; + Uint32 sendingNodeId; + Uint32 startingNodeId; +}; +#endif diff --git a/ndb/include/kernel/signaldata/EventReport.hpp b/ndb/include/kernel/signaldata/EventReport.hpp new file mode 100644 index 00000000000..b6106bb0ca4 --- /dev/null +++ b/ndb/include/kernel/signaldata/EventReport.hpp @@ -0,0 +1,159 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SD_EVENT_REPORT_H +#define SD_EVENT_REPORT_H + +#include "SignalData.hpp" + +/** + * Send by different block to report that a event has taken place + * + * SENDER: *Block* + * RECIVER: SimBlockCMCtrBlck + */ +class EventReport { + friend class SimulatedBlock; + friend class Cmvmi; + friend class SimblockMissra; + friend class Dbacc; + friend class Dblqh; + friend class Dbtup; + friend class Dbtc; + friend class Ndbcntr; + friend class Qmgr; + friend class Dbdih; + friend class Dbdict; + friend class MgmtSrvr; + friend class Grep; +public: + /* + EventType defines what event reports to send. + + The ORDER is NOT important anymore. //ejonore 2003-07-24 15:03 + + HOW TO ADD A NEW EVENT + -------------------- + 1) Add SentHeartbeat EventType in the category where it belongs. + ... + // INFO + SentHeartbeat, + InfoEvent + ... + + 2) remeber to update # of events below. Just to keep count... + Number of event types = 53 + + 3) Add a new SentHeartBeat entry to EventLogger::matrix[]. + ... + // INFO + { EventReport::SentHeartbeat, LogLevel::llInfo, 11, INFO }, + { EventReport::InfoEvent, LogLevel::llInfo, 2, INFO } + ... + + 4) Add SentHeartbeat in EventLogger::getText() + + */ + enum EventType { + // CONNECTION + Connected = 0, + Disconnected = 1, + CommunicationClosed = 2, + CommunicationOpened = 3, + ConnectedApiVersion = 51, + // CHECKPOINT + GlobalCheckpointStarted = 4, + GlobalCheckpointCompleted = 5, + LocalCheckpointStarted = 6, + LocalCheckpointCompleted = 7, + LCPStoppedInCalcKeepGci = 8, + LCPFragmentCompleted = 9, + // STARTUP + NDBStartStarted = 10, + NDBStartCompleted = 11, + STTORRYRecieved = 12, + StartPhaseCompleted = 13, + CM_REGCONF = 14, + CM_REGREF = 15, + FIND_NEIGHBOURS = 16, + NDBStopStarted = 17, + NDBStopAborted = 18, + StartREDOLog = 19, + StartLog = 20, + UNDORecordsExecuted = 21, + + // NODERESTART + NR_CopyDict = 22, + NR_CopyDistr = 23, + NR_CopyFragsStarted = 24, + NR_CopyFragDone = 25, + NR_CopyFragsCompleted = 26, + + // NODEFAIL + NodeFailCompleted = 27, + NODE_FAILREP = 28, + ArbitState = 29, + ArbitResult = 30, + GCP_TakeoverStarted = 31, + GCP_TakeoverCompleted = 32, + LCP_TakeoverStarted = 33, + LCP_TakeoverCompleted = 34, + + // STATISTIC + TransReportCounters = 35, + OperationReportCounters = 36, + TableCreated = 37, + UndoLogBlocked = 38, + JobStatistic = 39, + SendBytesStatistic = 40, + ReceiveBytesStatistic = 41, + MemoryUsage = 50, + + // ERROR + TransporterError = 42, + TransporterWarning = 43, + MissedHeartbeat = 44, + DeadDueToHeartbeat = 45, + WarningEvent = 46, + // INFO + SentHeartbeat = 47, + CreateLogBytes = 48, + InfoEvent = 49, + + //GREP + GrepSubscriptionInfo = 52, + GrepSubscriptionAlert = 53 + }; + + void setEventType(EventType type); + EventType getEventType() const; +private: + UintR eventType; // DATA 0 +}; + +inline +void +EventReport::setEventType(EventType type){ + eventType = (UintR) type; +} + +inline +EventReport::EventType +EventReport::getEventType() const { + return (EventType)eventType; +} + +#endif diff --git a/ndb/include/kernel/signaldata/EventSubscribeReq.hpp b/ndb/include/kernel/signaldata/EventSubscribeReq.hpp new file mode 100644 index 00000000000..2ac62be19a3 --- /dev/null +++ b/ndb/include/kernel/signaldata/EventSubscribeReq.hpp @@ -0,0 +1,60 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SD_EVENT_SUB_REQ_H +#define SD_EVENT_SUB_REQ_H + +#include "SignalData.hpp" + +/** + * Requests change (new, update, delete) of event subscription, + * i.e. forwarding of events. + * + * SENDER: Mgm server + * RECIVER: SimBlockCMCtrBlck + */ + +class EventSubscribeReq { + /** + * Receiver(s) + */ + friend class Cmvmi; + + /** + * Sender(s) + */ + friend class MgmtSrvr; + +public: + STATIC_CONST( SignalLength = 14 ); +private: + /** + * Note: If you use the same blockRef as you have used earlier, + * you update your ongoing subscription + */ + Uint32 blockRef; + + /** + * If you specify 0 entries, it's the same as cancelling an + * subscription + */ + Uint32 noOfEntries; + + Uint32 theCategories[6]; + Uint32 theLevels[6]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/ExecFragReq.hpp b/ndb/include/kernel/signaldata/ExecFragReq.hpp new file mode 100644 index 00000000000..e40213d6e29 --- /dev/null +++ b/ndb/include/kernel/signaldata/ExecFragReq.hpp @@ -0,0 +1,43 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef EXEC_FRAGREQ_HPP +#define EXEC_FRAGREQ_HPP + +#include "SignalData.hpp" + +class ExecFragReq { + /** + * Sender(s) + */ + friend class Dbdih; + + /** + * Receiver(s) + */ + friend class Dblqh; +public: + STATIC_CONST( SignalLength = 6 ); + +private: + Uint32 userPtr; + Uint32 userRef; + Uint32 tableId; + Uint32 fragId; + Uint32 startGci; + Uint32 lastGci; +}; +#endif diff --git a/ndb/include/kernel/signaldata/FailRep.hpp b/ndb/include/kernel/signaldata/FailRep.hpp new file mode 100644 index 00000000000..44577f07fdc --- /dev/null +++ b/ndb/include/kernel/signaldata/FailRep.hpp @@ -0,0 +1,56 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef FAIL_REP_HPP +#define FAIL_REP_HPP + +#include "SignalData.hpp" + +/** + * + */ +class FailRep { + /** + * Sender(s) & Reciver(s) + */ + friend class Qmgr; + + /** + * For printing + */ + friend bool printFAIL_REP(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 2 ); + + enum FailCause { + ZOWN_FAILURE=0, + ZOTHER_NODE_WHEN_WE_START=1, + ZIN_PREP_FAIL_REQ=2, + ZSTART_IN_REGREQ=3, + ZHEARTBEAT_FAILURE=4, + ZLINK_FAILURE=5, + ZOTHERNODE_FAILED_DURING_START=6 + }; + +private: + + Uint32 failNodeId; + Uint32 failCause; +}; + + +#endif diff --git a/ndb/include/kernel/signaldata/FireTrigOrd.hpp b/ndb/include/kernel/signaldata/FireTrigOrd.hpp new file mode 100644 index 00000000000..20a0a863094 --- /dev/null +++ b/ndb/include/kernel/signaldata/FireTrigOrd.hpp @@ -0,0 +1,200 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef FIRE_TRIG_ORD_HPP +#define FIRE_TRIG_ORD_HPP + +#include "SignalData.hpp" +#include +#include +#include + +/** + * FireTrigOrd + * + * This signal is sent by TUP to signal + * that a trigger has fired + */ +class FireTrigOrd { + /** + * Sender(s) + */ + // API + + /** + * Sender(s) / Reciver(s) + */ + friend class Dbtup; + + /** + * Reciver(s) + */ + friend class Dbtc; + friend class Backup; + friend class SumaParticipant; + + /** + * For printing + */ + friend bool printFIRE_TRIG_ORD(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + STATIC_CONST( SignalLength = 7 ); + STATIC_CONST( SignalWithGCILength = 8 ); + STATIC_CONST( SignalWithHashValueLength = 9 ); + +private: + Uint32 m_connectionPtr; + Uint32 m_userRef; + Uint32 m_triggerId; + TriggerEvent::Value m_triggerEvent; + Uint32 m_noPrimKeyWords; + Uint32 m_noBeforeValueWords; + Uint32 m_noAfterValueWords; + Uint32 m_gci; + Uint32 m_hashValue; + // Public methods +public: + Uint32 getConnectionPtr() const; + void setConnectionPtr(Uint32); + Uint32 getUserRef() const; + void setUserRef(Uint32); + Uint32 getTriggerId() const; + void setTriggerId(Uint32 anIndxId); + TriggerEvent::Value getTriggerEvent() const; + void setTriggerEvent(TriggerEvent::Value); + Uint32 getNoOfPrimaryKeyWords() const; + void setNoOfPrimaryKeyWords(Uint32); + Uint32 getNoOfBeforeValueWords() const; + void setNoOfBeforeValueWords(Uint32); + Uint32 getNoOfAfterValueWords() const; + void setNoOfAfterValueWords(Uint32); + Uint32 getGCI() const; + void setGCI(Uint32); + Uint32 getHashValue() const; + void setHashValue(Uint32); +}; + +inline +Uint32 FireTrigOrd::getConnectionPtr() const +{ + return m_connectionPtr; +} + +inline +void FireTrigOrd::setConnectionPtr(Uint32 aConnectionPtr) +{ + m_connectionPtr = aConnectionPtr; +} + +inline +Uint32 FireTrigOrd::getUserRef() const +{ + return m_userRef; +} + +inline +void FireTrigOrd::setUserRef(Uint32 aUserRef) +{ + m_userRef = aUserRef; +} + +inline +Uint32 FireTrigOrd::getTriggerId() const +{ + return m_triggerId; +} + +inline +void FireTrigOrd::setTriggerId(Uint32 aTriggerId) +{ + m_triggerId = aTriggerId; +} + +inline +TriggerEvent::Value FireTrigOrd::getTriggerEvent() const +{ + return m_triggerEvent; +} + +inline +void FireTrigOrd::setTriggerEvent(TriggerEvent::Value aTriggerEvent) +{ + m_triggerEvent = aTriggerEvent; +} + +inline +Uint32 FireTrigOrd::getNoOfPrimaryKeyWords() const +{ + return m_noPrimKeyWords; +} + +inline +void FireTrigOrd::setNoOfPrimaryKeyWords(Uint32 noPrim) +{ + m_noPrimKeyWords = noPrim; +} + +inline +Uint32 FireTrigOrd::getNoOfBeforeValueWords() const +{ + return m_noBeforeValueWords; +} + +inline +void FireTrigOrd::setNoOfBeforeValueWords(Uint32 noBefore) +{ + m_noBeforeValueWords = noBefore; +} + +inline +Uint32 FireTrigOrd::getNoOfAfterValueWords() const +{ + return m_noAfterValueWords; +} + +inline +void FireTrigOrd::setNoOfAfterValueWords(Uint32 noAfter) +{ + m_noAfterValueWords = noAfter; +} + +inline +Uint32 FireTrigOrd::getGCI() const +{ + return m_gci; +} + +inline +void FireTrigOrd::setGCI(Uint32 aGCI) +{ + m_gci = aGCI; +} + +inline +Uint32 FireTrigOrd::getHashValue() const +{ + return m_hashValue; +} + +inline +void FireTrigOrd::setHashValue(Uint32 flag) +{ + m_hashValue = flag; +} + + +#endif diff --git a/ndb/include/kernel/signaldata/FsAppendReq.hpp b/ndb/include/kernel/signaldata/FsAppendReq.hpp new file mode 100644 index 00000000000..e2fd61f8a11 --- /dev/null +++ b/ndb/include/kernel/signaldata/FsAppendReq.hpp @@ -0,0 +1,57 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef FS_APPENDREQ_H +#define FS_APPENDREQ_H + +#include "SignalData.hpp" + +/** + * + * SENDER: + * RECIVER: Ndbfs + */ +class FsAppendReq { + /** + * Reciver(s) + */ + friend class Ndbfs; + friend class VoidFs; + + /** + * Sender(s) + */ + friend class Backup; + + friend bool printFSAPPENDREQ(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo); +public: + STATIC_CONST( SignalLength = 6 ); + +private: + + /** + * DATA VARIABLES + */ + UintR filePointer; // DATA 0 + UintR userReference; // DATA 1 + UintR userPointer; // DATA 2 + UintR varIndex; // DATA 3 + UintR offset; // DATA 4 + UintR size; // DATA 5 +}; + +#endif diff --git a/ndb/include/kernel/signaldata/FsCloseReq.hpp b/ndb/include/kernel/signaldata/FsCloseReq.hpp new file mode 100644 index 00000000000..8ff47145f87 --- /dev/null +++ b/ndb/include/kernel/signaldata/FsCloseReq.hpp @@ -0,0 +1,85 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef FS_CLOSE_REQ_H +#define FS_CLOSE_REQ_H + +#include "SignalData.hpp" + +/** + * + * SENDER: + * RECIVER: Ndbfs + */ +class FsCloseReq { + /** + * Reciver(s) + */ + friend class Ndbfs; // Reciver + friend class VoidFs; + + /** + * Sender(s) + */ + friend class Backup; + friend class Dbdict; + + /** + * For printing + */ + friend bool printFSCLOSEREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + /** + * Length of signal + */ + STATIC_CONST( SignalLength = 4 ); + +private: + + /** + * DATA VARIABLES + */ + + UintR filePointer; // DATA 0 + UintR userReference; // DATA 1 + UintR userPointer; // DATA 2 + UintR fileFlag; // DATA 3 + + static bool getRemoveFileFlag(const UintR & fileflag); + static void setRemoveFileFlag(UintR & fileflag, bool removefile); + +}; + + +inline +bool +FsCloseReq::getRemoveFileFlag(const UintR & fileflag){ + return (fileflag == 1); +} + +inline +void +FsCloseReq::setRemoveFileFlag(UintR & fileflag, bool removefile){ + ASSERT_BOOL(removefile, "FsCloseReq::setRemoveFileFlag"); + if (removefile == true) + fileflag = 1; + else + fileflag = 0; +} + + +#endif diff --git a/ndb/include/kernel/signaldata/FsConf.hpp b/ndb/include/kernel/signaldata/FsConf.hpp new file mode 100644 index 00000000000..f66d9feea49 --- /dev/null +++ b/ndb/include/kernel/signaldata/FsConf.hpp @@ -0,0 +1,77 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef FS_CONF_H +#define FS_CONF_H + +#include "SignalData.hpp" + +/** + * FsConf - Common signal class for all CONF signals sent from Ndbfs + * GSN_FSCLOSECONF, GSN_FSOPENCONF, GSN_FSWRITECONF, GSN_FSREADCONF, + * GSN_FSSYNCCONF, GSN_FSREMOVECONF + */ + +/** + * + * SENDER: Ndbfs + * RECIVER: + */ +class FsConf { + /** + * Reciver(s) + */ + friend class Backup; + friend class Dbacc; + friend class Dbtup; + friend class Dbdict; + + /** + * Sender(s) + */ + friend class Ndbfs; + friend class VoidFs; + + /** + * For printing + */ + friend bool printFSCONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + /** + * Length of signal + */ + /** + * FSOPENCONF: static const UintR SignalLength = 2; + * FSCLOSECONF, FSREADCONF, FSWRITECONF, FSSYNCCONF: static const UintR SignalLength = 2; + */ + +private: + + /** + * DATA VARIABLES + */ + UintR userPointer; // DATA 0 + + /** + * Only used if FSOPENCONF + */ + UintR filePointer; // DATA 1 +}; + + + +#endif diff --git a/ndb/include/kernel/signaldata/FsOpenReq.hpp b/ndb/include/kernel/signaldata/FsOpenReq.hpp new file mode 100644 index 00000000000..b84d78ba9dd --- /dev/null +++ b/ndb/include/kernel/signaldata/FsOpenReq.hpp @@ -0,0 +1,266 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef FS_OPEN_REQ_H +#define FS_OPEN_REQ_H + +#include "SignalData.hpp" + +/** + * + * SENDER: + * RECIVER: Ndbfs + */ +class FsOpenReq { + /** + * Reciver(s) + */ + friend class Ndbfs; // Reciver + friend class AsyncFile; // Uses FsOpenReq to decode file open flags + friend class Filename; + friend class VoidFs; + + /** + * Sender(s) + */ + friend class Backup; + friend class Dbdict; + friend class Ndbcntr; // For initial start... + + /** + * For printing + */ + friend bool printFSOPENREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + /** + * Length of signal + */ + STATIC_CONST( SignalLength = 7 ); + +private: + + /** + * DATA VARIABLES + */ + + UintR userReference; // DATA 0 + UintR userPointer; // DATA 1 + UintR fileNumber[4]; // DATA 2 - 5 + UintR fileFlags; // DATA 6 + + STATIC_CONST( OM_READONLY = 0 ); + STATIC_CONST( OM_WRITEONLY = 1 ); + STATIC_CONST( OM_READWRITE = 2 ); + + STATIC_CONST( OM_APPEND = 0x8 ); // Not Implemented on W2k + STATIC_CONST( OM_SYNC = 0x10 ); + STATIC_CONST( OM_CREATE = 0x100 ); + STATIC_CONST( OM_TRUNCATE = 0x200 ); + + enum Suffixes { + S_DATA = 0, + S_FRAGLOG = 1, + S_LOGLOG = 2, + S_FRAGLIST = 3, + S_TABLELIST = 4, + S_SCHEMALOG = 5, + S_SYSFILE = 6, + S_LOG = 7, + S_CTL = 8 + }; + + static Uint32 getVersion(const Uint32 fileNumber[]); + static Uint32 getSuffix(const Uint32 fileNumber[]); + + static void setVersion(Uint32 fileNumber[], Uint8 val); + static void setSuffix(Uint32 fileNumber[], Uint8 val); + + /** + * V1 + */ + static Uint32 v1_getDisk(const Uint32 fileNumber[]); + static Uint32 v1_getTable(const Uint32 fileNumber[]); + static Uint32 v1_getFragment(const Uint32 fileNumber[]); + static Uint32 v1_getS(const Uint32 fileNumber[]); + static Uint32 v1_getP(const Uint32 fileNumber[]); + + static void v1_setDisk(Uint32 fileNumber[], Uint8 val); + static void v1_setTable(Uint32 fileNumber[], Uint32 val); + static void v1_setFragment(Uint32 fileNumber[], Uint32 val); + static void v1_setS(Uint32 fileNumber[], Uint32 val); + static void v1_setP(Uint32 fileNumber[], Uint8 val); + + /** + * V2 - Backup + */ + static Uint32 v2_getSequence(const Uint32 fileNumber[]); + static Uint32 v2_getNodeId(const Uint32 fileNumber[]); + static Uint32 v2_getCount(const Uint32 fileNumber[]); + + static void v2_setSequence(Uint32 fileNumber[], Uint32 no); + static void v2_setNodeId(Uint32 fileNumber[], Uint32 no); + static void v2_setCount(Uint32 fileNumber[], Uint32 no); +}; + +/** + * File flags (set according to solaris standard) + * + o = Open mode - 2 Bits -> max 3 + c = create new file - 1 Bit + t = truncate existing - 1 Bit + + 1111111111222222222233 + 01234567890123456789012345678901 + oo ct +*/ + + +/** + * -- v1 -- + * File number[0] = Table + * File number[1] = Fragment + * File number[2] = S-value + * File number[3] = + * p = v1_P 0 - 7 + * d = v1_disk 8 - 15 + * s = v1_suffix 16 - 23 + * v = version 24 - 31 + * + * 1111111111222222222233 + * 01234567890123456789012345678901 + * ppppppppddddddddssssssssvvvvvvvv + * + * -- v2 -- + * File number[0] = Backup Sequence Number + * File number[1] = Node Id + * File number[3] = + * v = version 24 - 31 + * s = v1_suffix 16 - 23 + * + * 1111111111222222222233 + * 01234567890123456789012345678901 + * ppppppppddddddddssssssssvvvvvvvv + * + */ +inline +Uint32 FsOpenReq::getVersion(const Uint32 fileNumber[]){ + return (fileNumber[3] >> 24) & 0xff; +} + +inline +void FsOpenReq::setVersion(Uint32 fileNumber[], Uint8 val){ + const Uint32 t = fileNumber[3]; + fileNumber[3] = t & 0x00FFFFFF | (((Uint32)val) << 24); +} + +inline +Uint32 FsOpenReq::getSuffix(const Uint32 fileNumber[]){ + return (fileNumber[3] >> 16)& 0xff; +} + +inline +void FsOpenReq::setSuffix(Uint32 fileNumber[], Uint8 val){ + const Uint32 t = fileNumber[3]; + fileNumber[3] = t & 0xFF00FFFF | (((Uint32)val) << 16); +} + +inline +Uint32 FsOpenReq::v1_getDisk(const Uint32 fileNumber[]){ + return (fileNumber[3]>>8) & 0xff; +} + +inline +void FsOpenReq::v1_setDisk(Uint32 fileNumber[], Uint8 val){ + const Uint32 t = fileNumber[3]; + fileNumber[3] = t & 0xFFFF00FF | (((Uint32)val) << 8); +} + +inline +Uint32 FsOpenReq::v1_getTable(const Uint32 fileNumber[]){ + return fileNumber[0]; +} + +inline +void FsOpenReq::v1_setTable(Uint32 fileNumber[], Uint32 val){ + fileNumber[0] = val; +} + +inline +Uint32 FsOpenReq::v1_getFragment(const Uint32 fileNumber[]){ + return fileNumber[1]; +} + +inline +void FsOpenReq::v1_setFragment(Uint32 fileNumber[], Uint32 val){ + fileNumber[1] = val; +} + +inline +Uint32 FsOpenReq::v1_getS(const Uint32 fileNumber[]){ + return fileNumber[2]; +} + +inline +void FsOpenReq::v1_setS(Uint32 fileNumber[], Uint32 val){ + fileNumber[2] = val; +} + +inline +Uint32 FsOpenReq::v1_getP(const Uint32 fileNumber[]){ + return fileNumber[3] & 0xff; +} + +inline +void FsOpenReq::v1_setP(Uint32 fileNumber[], Uint8 val){ + const Uint32 t = fileNumber[3]; + fileNumber[3] = t & 0xFFFFFF00 | val; +} + +/****************/ +inline +Uint32 FsOpenReq::v2_getSequence(const Uint32 fileNumber[]){ + return fileNumber[0]; +} + +inline +void FsOpenReq::v2_setSequence(Uint32 fileNumber[], Uint32 val){ + fileNumber[0] = val; +} + +inline +Uint32 FsOpenReq::v2_getNodeId(const Uint32 fileNumber[]){ + return fileNumber[1]; +} + +inline +void FsOpenReq::v2_setNodeId(Uint32 fileNumber[], Uint32 val){ + fileNumber[1] = val; +} + +inline +Uint32 FsOpenReq::v2_getCount(const Uint32 fileNumber[]){ + return fileNumber[2]; +} + +inline +void FsOpenReq::v2_setCount(Uint32 fileNumber[], Uint32 val){ + fileNumber[2] = val; +} + + +#endif + diff --git a/ndb/include/kernel/signaldata/FsReadWriteReq.hpp b/ndb/include/kernel/signaldata/FsReadWriteReq.hpp new file mode 100644 index 00000000000..6e4fa4d260e --- /dev/null +++ b/ndb/include/kernel/signaldata/FsReadWriteReq.hpp @@ -0,0 +1,152 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef FS_READWRITEREQ_H +#define FS_READWRITEREQ_H + +#include "SignalData.hpp" + +/** + * FsReadWriteReq - Common signal class for FSWRITEREQ and FSREADREQ + * + */ + +/** + * + * SENDER: + * RECIVER: Ndbfs + */ +class FsReadWriteReq { + /** + * Reciver(s) + */ + friend class Ndbfs; + friend class VoidFs; + + /** + * Sender(s) + */ + friend class Dbdict; + + + /** + * For printing + */ + friend bool printFSREADWRITEREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + /** + * Enum type for errorCode + */ + enum NdbfsFormatType { + fsFormatListOfPairs=0, + fsFormatArrayOfPages=1, + fsFormatListOfMemPages=2, + fsFormatMax + }; + + /** + * Length of signal + */ + +private: + + /** + * DATA VARIABLES + */ + UintR filePointer; // DATA 0 + UintR userReference; // DATA 1 + UintR userPointer; // DATA 2 + UintR operationFlag; // DATA 3 + UintR varIndex; // DATA 4 + UintR numberOfPages; // DATA 5 + +//------------------------------------------------------------- +// Variable sized part. Those will contain +// info about memory/file pages to read/write +//------------------------------------------------------------- + union { + UintR pageData[16]; // DATA 6 - 21 + struct { + Uint32 varIndex; // In unit cluster size + Uint32 fileOffset; // In unit page size + } listOfPair[8]; + struct { + Uint32 varIndex; + Uint32 fileOffset; + } arrayOfPages; + struct { + Uint32 varIndex[1]; // Size = numberOfPages + Uint32 fileOffset; + } listOfMemPages; + } data; + + static Uint8 getSyncFlag(const UintR & opFlag); + static void setSyncFlag(UintR & opFlag, Uint8 flag); + + static NdbfsFormatType getFormatFlag(const UintR & opFlag); + static void setFormatFlag(UintR & opFlag, Uint8 flag); + +}; + +/** + * Operation flag + * + f = Format of pageData - 4 Bits -> max 15 + s = sync after write flag - 1 Bit + + 1111111111222222222233 + 01234567890123456789012345678901 + ffffs +*/ + +#define SYNC_SHIFT (4) +#define SYNC_MASK (0x01) + +#define FORMAT_MASK (0x0F) + + +inline +Uint8 +FsReadWriteReq::getSyncFlag(const UintR & opFlag){ + return (Uint8)((opFlag >> SYNC_SHIFT) & SYNC_MASK); +} + +inline +FsReadWriteReq::NdbfsFormatType +FsReadWriteReq::getFormatFlag(const UintR & opFlag){ + return (NdbfsFormatType)(opFlag & FORMAT_MASK); +} + +inline +void +FsReadWriteReq::setSyncFlag(UintR & opFlag, Uint8 flag){ + ASSERT_BOOL(flag, "FsReadWriteReq::setSyncFlag"); + opFlag |= (flag << SYNC_SHIFT); +} + +inline +void +FsReadWriteReq::setFormatFlag(UintR & opFlag, Uint8 flag){ + ASSERT_MAX(flag, fsFormatMax, "FsReadWriteReq::setSyncFlag"); + opFlag |= flag; +} + + + + + +#endif diff --git a/ndb/include/kernel/signaldata/FsRef.hpp b/ndb/include/kernel/signaldata/FsRef.hpp new file mode 100644 index 00000000000..650f6520fb5 --- /dev/null +++ b/ndb/include/kernel/signaldata/FsRef.hpp @@ -0,0 +1,116 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef FS_REF_H +#define FS_REF_H + +#include "SignalData.hpp" + +/** + * FsRef - Common signal class for all REF signals sent from Ndbfs + * GSN_FSCLOSEREF, GSN_FSOPENREF, GSN_FSWRITEREF, GSN_FSREADREF, + * GSN_FSSYNCREF + */ + + +/** + * + * SENDER: Ndbfs + * RECIVER: + */ +class FsRef { + /** + * Reciver(s) + */ + friend class Dbdict; + friend class Backup; + + /** + * Sender(s) + */ + friend class Ndbfs; + friend class VoidFs; + + /** + * For printing + */ + friend bool printFSREF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + /** + * Enum type for errorCode + */ + enum NdbfsErrorCodeType { + fsErrNone=0, + fsErrHardwareFailed=1, + fsErrUserError=2, + fsErrEnvironmentError=3, + fsErrTemporaryNotAccessible=4, + fsErrNoSpaceLeftOnDevice=5, + fsErrPermissionDenied=6, + fsErrInvalidParameters=7, + fsErrUnknown=8, + fsErrNoMoreResources=9, + fsErrFileDoesNotExist=10, + fsErrReadUnderflow = 11, + fsErrMax + }; + /** + * Length of signal + */ + STATIC_CONST( SignalLength = 4 ); + +private: + + /** + * DATA VARIABLES + */ + UintR userPointer; // DATA 0 + UintR errorCode; // DATA 1 + UintR osErrorCode; // DATA 2 + UintR senderData; + + static NdbfsErrorCodeType getErrorCode(const UintR & errorcode); + static void setErrorCode(UintR & errorcode, NdbfsErrorCodeType errorcodetype); + static void setErrorCode(UintR & errorcode, UintR errorcodetype); + +}; + + +inline +FsRef::NdbfsErrorCodeType +FsRef::getErrorCode(const UintR & errorcode){ + return (NdbfsErrorCodeType)errorcode; +} + +inline +void +FsRef::setErrorCode(UintR & errorcode, NdbfsErrorCodeType errorcodetype){ + ASSERT_MAX(errorcodetype, fsErrMax, "FsRef::setErrorCode"); + errorcode = (UintR)errorcodetype; +} + +inline +void +FsRef::setErrorCode(UintR & errorcode, UintR errorcodetype){ + ASSERT_MAX(errorcodetype, fsErrMax, "FsRef::setErrorCode"); + errorcode = errorcodetype; +} + + + + +#endif diff --git a/ndb/include/kernel/signaldata/FsRemoveReq.hpp b/ndb/include/kernel/signaldata/FsRemoveReq.hpp new file mode 100644 index 00000000000..efb566d883a --- /dev/null +++ b/ndb/include/kernel/signaldata/FsRemoveReq.hpp @@ -0,0 +1,78 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef FS_REMOVE_REQ_H +#define FS_REMOVE_REQ_H + +#include "SignalData.hpp" +#include "FsOpenReq.hpp" + +/** + * + * SENDER: + * RECIVER: Ndbfs + */ +class FsRemoveReq { + /** + * Reciver(s) + */ + friend class Ndbfs; // Reciver + friend class AsyncFile; // Uses FsOpenReq to decode file open flags + friend class Filename; + friend class VoidFs; + + /** + * Sender(s) + */ + friend class Backup; + friend class Dbdict; + friend class Dbacc; + friend class Dbtup; + friend class Ndbcntr; // For initial start... + +public: + /** + * Length of signal + */ + STATIC_CONST( SignalLength = 8 ); + +private: + + /** + * DATA VARIABLES + */ + + UintR userReference; // DATA 0 + UintR userPointer; // DATA 1 + UintR fileNumber[4]; // DATA 2 - 5 // See FsOpen for interpretation + + /** + * 0 = File -> rm file + * 1 = Directory -> rm -r path + */ + UintR directory; + + /** + * If directory = 1 + * + * 0 = remove only files/direcories in directory specified in fileNumber + * 1 = remove directory specified in fileNumber + */ + UintR ownDirectory; +}; + +#endif + diff --git a/ndb/include/kernel/signaldata/GCPSave.hpp b/ndb/include/kernel/signaldata/GCPSave.hpp new file mode 100644 index 00000000000..2b4a25e6bb2 --- /dev/null +++ b/ndb/include/kernel/signaldata/GCPSave.hpp @@ -0,0 +1,98 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef GCP_SAVE_HPP +#define GCP_SAVE_HPP + +#include "SignalData.hpp" + +/** + * GCPSaveReq / (Ref/Conf) is sent as part of GCP + */ +class GCPSaveReq { + /** + * Sender(s) + */ + friend class Dbdih; + + /** + * Reciver(s) + */ + friend class Dblqh; + + friend bool printGCPSaveReq(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo); +public: + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 dihBlockRef; + Uint32 dihPtr; + Uint32 gci; +}; + +class GCPSaveRef { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Reciver(s) + */ + friend class Dbdih; + + friend bool printGCPSaveRef(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo); +public: + STATIC_CONST( SignalLength = 4 ); + + enum ErrorCode { + NodeShutdownInProgress = 1, + FakedSignalDueToNodeFailure = 2, + NodeRestartInProgress = 3 + }; + +private: + Uint32 dihPtr; + Uint32 nodeId; + Uint32 gci; + Uint32 errorCode; +}; + +class GCPSaveConf { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Reciver(s) + */ + friend class Dbdih; + + friend bool printGCPSaveConf(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo); +public: + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 dihPtr; + Uint32 nodeId; + Uint32 gci; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/GetTabInfo.hpp b/ndb/include/kernel/signaldata/GetTabInfo.hpp new file mode 100644 index 00000000000..cb6e38872d3 --- /dev/null +++ b/ndb/include/kernel/signaldata/GetTabInfo.hpp @@ -0,0 +1,126 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef GET_INFO_TAB_HPP +#define GET_INFO_TAB_HPP + +#include "SignalData.hpp" + +/** + * GetTabInfo - Get table info from DICT + * + * Successfull return = series of DICTTABINFO-signals + */ +class GetTabInfoReq { + /** + * Sender(s) / Reciver(s) + */ + // Blocks + friend class Dbdict; + friend class Backup; + friend class Trix; + friend class DbUtil; + // API + friend class Table; + + friend bool printGET_TABINFO_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + // STATIC_CONST( MaxTableNameLengthInWords = 20 ); +public: + Uint32 senderData; + Uint32 senderRef; + + /** + * 0 = request by id, 1 = request by name + */ + Uint32 requestType; + + union { + Uint32 tableId; + Uint32 tableNameLen; + }; + Uint32 unused; // This is located here so that Req & Ref have the same format + // Uint32 tableName[MaxTableNameLengthInWords]; + + enum RequestType { + RequestById = 0, + RequestByName = 1, + LongSignalConf = 2 + }; + SECTION( TABLE_NAME = 0 ); +}; + +class GetTabInfoRef { + /** + * Sender(s) / Reciver(s) + */ + // Blocks + friend class Dbdict; + friend class Backup; + friend class Trix; + friend class DbUtil; + // API + friend class Table; + + friend bool printGET_TABINFO_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + +public: + Uint32 senderData; + Uint32 senderRef; + Uint32 requestType; // 0 = request by id, 1 = request by name + union { + Uint32 tableId; + Uint32 tableNameLen; + }; + Uint32 errorCode; + + enum ErrorCode { + InvalidTableId = 709, + TableNotDefined = 723, + TableNameTooLong = 702, + Busy = 701 + }; +}; + +class GetTabInfoConf { + /** + * Sender(s) / Reciver(s) + */ + // Blocks + friend class Dbdict; + friend class Backup; + friend class Trix; + friend class DbUtil; + friend class Suma; + // API + friend class Table; + + friend bool printGET_TABINFO_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + SECTION( DICT_TAB_INFO = 0 ); +public: + Uint32 senderData; + Uint32 tableId; + Uint32 gci; // For table + Uint32 totalLen; // In words +}; + +#endif diff --git a/ndb/include/kernel/signaldata/GetTableId.hpp b/ndb/include/kernel/signaldata/GetTableId.hpp new file mode 100644 index 00000000000..fb91c2e10d7 --- /dev/null +++ b/ndb/include/kernel/signaldata/GetTableId.hpp @@ -0,0 +1,93 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef GET_TABLEID_HPP +#define GET_TABLEID_HPP + +#include "SignalData.hpp" + +/** + * Convert tabname to table id + */ +class GetTableIdReq { + /** + * Sender(s) / Reciver(s) + */ + // Blocks + friend class Dbdict; + friend class SumaParticipant; + + friend bool printGET_TABLEID_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); +public: + Uint32 senderData; + Uint32 senderRef; + Uint32 len; + SECTION( TABLE_NAME = 0 ); +}; + + +/** + * Convert tabname to table id + */ +class GetTableIdRef { + /** + * Sender(s) / Reciver(s) + */ + // Blocks + friend class Dbdict; + friend class SumaParticipant; + friend bool printGET_TABLEID_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); +public: + Uint32 senderData; + Uint32 senderRef; + Uint32 err; + + enum ErrorCode { + InvalidTableId = 709, + TableNotDefined = 723, + TableNameTooLong = 702, + EmptyTable = 1111 + }; +}; + + +/** + * Convert tabname to table id + */ +class GetTableIdConf { + /** + * Sender(s) / Reciver(s) + */ + // Blocks + friend class Dbdict; + friend class SumaParticipant; + friend bool printGET_TABLEID_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); +public: + Uint32 senderData; + Uint32 senderRef; + Uint32 tableId; + Uint32 schemaVersion; + +}; + + +#endif diff --git a/ndb/include/kernel/signaldata/GrepImpl.hpp b/ndb/include/kernel/signaldata/GrepImpl.hpp new file mode 100644 index 00000000000..95b93df0a58 --- /dev/null +++ b/ndb/include/kernel/signaldata/GrepImpl.hpp @@ -0,0 +1,891 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef GREP_IMPL_HPP +#define GREP_IMPL_HPP + +#include "SignalData.hpp" +#include +#include + + + +/***************************************************************************** + * GREP REQ Request a Global Replication (between SS and PS) + *****************************************************************************/ +/** + * @class GrepReq + * @brief + */ +class GrepReq +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + +public: + enum Request { + START = 0, ///< Start Global Replication (all phases) + SLOWSTOP = 1, ///< Stop after finishing applying current GCI epoch + FASTSTOP = 2, ///< Stop after finishing applying all PS GCI epochs + STATUS = 3, ///< Status + REMOVE_BUFFERS = 4, ///< Remove buffers from PS and SS + + START_SUBSCR = 5, + START_METALOG = 6, ///< Start Global Replication Logging of Metadata + START_METASCAN = 7, ///< Start Global Replication Scanning of Metadata + START_DATALOG = 8, ///< Start Global Replication Logging of table data + START_DATASCAN = 9, ///< Start Global Replication Scanning of table data + START_REQUESTOR = 10, ///< Start Global Replication Requestor + START_TRANSFER = 11, ///< Start SS-PS transfer + START_APPLY = 12, ///< Start applying GCI epochs in SS + START_DELETE = 13, ///< Start deleting buffers at PS/SS REP automatic. + + STOP_SUBSCR = 14, ///< Remove subscription + STOP_METALOG = 15, ///< Stop Global Replication Logging of Metadata + STOP_METASCAN = 16, ///< Stop Global Replication Scanning of Metadata + STOP_DATALOG = 17, ///< Stop Global Replication Logging of table data + STOP_DATASCAN = 18, ///< Stop Global Replication Scanning of table data + STOP_REQUESTOR = 19, ///< Stop Global Replication Requestor + STOP_TRANSFER = 20, ///< Stop SS-PS transfer + STOP_APPLY = 21, ///< Stop applying GCI epochs in SS + STOP_DELETE = 22, ///< Stop deleting buffers at PS/SS REP automatically + CREATE_SUBSCR = 23, ///< Create subscription ID in SUMA + DROP_TABLE = 24, ///< Create subscription ID in SUMA + STOP = 25, + + NO_REQUEST = 0xffffffff + }; + + STATIC_CONST( SignalLength = 2 ); + + Uint32 senderRef; + Uint32 request; +}; + + +/***************************************************************************** + * CREATE Between SS and PS (DB and REP nodes) + *****************************************************************************/ +/** + * @class GrepSubCreateReq + * @brief + */ +class GrepSubCreateReq +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + + friend bool printGREP_SUB_CREATE_REQ(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 subscriptionType; + Uint32 senderRef; + Uint32 senderData; + SECTION( TABLE_LIST = 0 ); +}; + +/** + * @class GrepSubCreateReq + * @brief + */ +class GrepSubCreateRef +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + + friend bool printGREP_SUB_CREATE_REF(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 6 ); + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 subscriptionType; + Uint32 err; + Uint32 senderRef; + Uint32 senderData; +}; + + +/** + * @class GrepSubCreateConf + * @brief + */ +class GrepSubCreateConf +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + + friend bool printGREP_SUB_CREATE_CONF(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 6 ); + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 subscriptionType; + Uint32 senderRef; + Uint32 senderData; + Uint32 noOfNodeGroups; +}; + + + +/***************************************************************************** + * CREATE Internal between PS DB nodes + *****************************************************************************/ + +/** + * @class GrepCreateReq + * @brief + */ +class GrepCreateReq { + /** + * Sender(s)/Reciver(s) + */ + friend class GrepParticipant; + + friend bool printGREP_CREATE_REQ(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 8 ); + + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriberData; + Uint32 subscriberRef; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 subscriptionType; + SECTION( TABLE_LIST = 0 ); +}; + + +/** + * @class GrepCreateRef + * @brief + */ +class GrepCreateRef { + /** + * Sender(s)/Reciver(s) + */ + + friend class GrepParticipant; + + friend bool printGREP_CREATE_REF(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + enum ErrorCode { + NF_FakeErrorREF = GrepError::NF_FakeErrorREF + }; + STATIC_CONST( SignalLength = 6 ); + Uint32 senderRef; + Uint32 senderData; + union { + Uint32 err; + Uint32 errorCode; + }; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 subscriptionType; +}; + + +/** + * @class GrepCreateConf + * @brief + */ +class GrepCreateConf { + /** + * Sender(s)/Reciver(s) + */ + + friend class GrepParticipant; + + friend bool printGREP_CREATE_CONF(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 6 ); + Uint32 senderNodeId; + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 subscriptionType; +}; + + +/***************************************************************************** + * START Between SS and PS (DB and REP nodes) + *****************************************************************************/ + +/** + * @class GrepSubStartReq + * @brief + */ +class GrepSubStartReq { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + + friend bool printGREP_SUB_START_REQ(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 senderRef; + Uint32 senderData; + Uint32 part; +}; + +/** + * @class GrepSubStartRef + * @brief + */ +class GrepSubStartRef { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + + friend bool printGREP_SUB_START_REF(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 6 ); + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 err; + Uint32 senderRef; + Uint32 senderData; + Uint32 part; +}; + + + +/** + * @class GrepSubStartConf + * @brief + */ +class GrepSubStartConf { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + + friend bool printGREP_SUB_START_CONF(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 6 ); + + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 senderRef; + Uint32 senderData; + Uint32 part; + Uint32 firstGCI; +}; + + +/***************************************************************************** + * START Internal between PS DB nodes + *****************************************************************************/ + +/** + * @class GrepStartReq + * @brief + */ +class GrepStartReq { + /** + * Sender(s)/Reciver(s) + */ + friend class GrepParticipant; + + friend bool printGREP_START_REQ(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + Uint32 senderData; + Uint32 part; + Uint32 subscriptionId; + Uint32 subscriptionKey; +}; + + +/** + * @class GrepStartRef + * @brief + */ +class GrepStartRef { + /** + * Sender(s)/Reciver(s) + */ + + friend class GrepParticipant; + + friend bool printGREP_START_REF(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + enum ErrorCode { + NF_FakeErrorREF = GrepError::NF_FakeErrorREF + }; + STATIC_CONST( SignalLength = 6 ); + Uint32 senderRef; + Uint32 senderData; + Uint32 part; + Uint32 subscriptionId; + Uint32 subscriptionKey; + union { + Uint32 err; + Uint32 errorCode; + }; +}; + + +/** + * @class GrepStartConf + * @brief + */ +class GrepStartConf { + /** + * Sender(s)/Reciver(s) + */ + + friend class GrepParticipant; + + friend bool printGREP_START_CONF(FILE *, + const Uint32 *, + Uint32, + Uint16); + public: + STATIC_CONST( SignalLength = 7 ); + + Uint32 senderRef; + Uint32 senderData; + Uint32 part; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 firstGCI; + Uint32 senderNodeId; + }; + + +/***************************************************************************** + * SCAN (SYNC) Between SS and PS (REP and DB nodes) + *****************************************************************************/ + +/** + * @class GrepSubSyncReq + * @brief + */ +class GrepSubSyncReq { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + + friend bool printGREP_SUB_SYNC_REQ(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 senderRef; + Uint32 senderData; + Uint32 part; +}; + + +/** + * @class GrepSubSyncRef + * @brief + */ +class GrepSubSyncRef { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + + friend bool printGREP_SUB_SYNC_REF(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 6 ); + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 senderRef; + Uint32 err; + Uint32 senderData; + Uint32 part; +}; + + +/** + * @class GrepSubSyncConf + * @brief + */ +class GrepSubSyncConf { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + + friend bool printGREP_SUB_SYNC_CONF(FILE *, + const Uint32 *, + Uint32, + Uint16); + public: + STATIC_CONST( SignalLength = 7 ); + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 senderRef; + Uint32 senderData; + Uint32 part; + Uint32 firstGCI; + Uint32 lastGCI; +}; + + + +/***************************************************************************** + * SCAN (SYNC) Internal between PS DB nodes + *****************************************************************************/ + +/** + * @class GrepSyncReq + * @brief + */ +class GrepSyncReq { + /** + * Sender(s)/Reciver(s) + */ + friend class GrepParticipant; + + friend bool printGREP_SYNC_REQ(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + Uint32 senderData; + Uint32 part; + Uint32 subscriptionId; + Uint32 subscriptionKey; +}; + + +/** + * @class GrepSyncRef + * @brief + */ +class GrepSyncRef { + /** + * Sender(s)/Reciver(s) + */ + + friend class GrepParticipant; + + friend bool printGREP_SYNC_REF(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + enum ErrorCode { + NF_FakeErrorREF = GrepError::NF_FakeErrorREF + }; + STATIC_CONST( SignalLength = 6 ); + Uint32 senderRef; + Uint32 senderData; + Uint32 part; + Uint32 subscriptionId; + Uint32 subscriptionKey; + union { + Uint32 err; + Uint32 errorCode; + }; +}; + + +/** + * @class GrepSyncConf + * @brief + */ +class GrepSyncConf +{ + /** + * Sender(s)/Reciver(s) + */ + friend class GrepParticipant; + + friend bool printGREP_SYNC_CONF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 8 ); + Uint32 senderRef; + Uint32 senderData; + Uint32 part; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 senderNodeId; + Uint32 firstGCI; + Uint32 lastGCI; +}; + +/***************************************************************************** + * ABORT - remove subscription + *****************************************************************************/ + +/** + * @class GrepSubRemoveReq + * @brief Between PS and SS + */ +class GrepSubRemoveReq { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + + friend bool printGREP_SUB_REMOVE_REQ(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; +}; + + +/** + * @class GrepSubRemoveRef + * @brief Between PS and SS + */ +class GrepSubRemoveRef { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + + friend bool printGREP_SUB_REMOVE_REF(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 err; +}; + + +/** + * @class + * @brief + */ +class GrepSubRemoveConf { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + + friend bool printGREP_SUB_REMOVE_CONF(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; +}; + + +/** + * @class + * @brief + */ +class GrepRemoveReq { + /** + * Sender(s)/Reciver(s) + */ + friend class GrepParticipant; + + friend bool printGREP_REMOVE_REQ(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; +}; + + +/** + * @class + * @brief + */ +class GrepRemoveRef { + /** + * Sender(s)/Reciver(s) + */ + + friend class GrepParticipant; + + friend bool printGREP_REMOVE_REF(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + enum ErrorCode { + NF_FakeErrorREF = GrepError::NF_FakeErrorREF + }; + STATIC_CONST( SignalLength = 5 ); + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; + union { + Uint32 err; + Uint32 errorCode; + }; +}; + + +/** + * @class + * @brief + */ +class GrepRemoveConf { + /** + * Sender(s)/Reciver(s) + */ + + friend class GrepParticipant; + + friend bool printGREP_REMOVE_CONF(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 senderNodeId; +}; + + +/***************************************************************************** + * WAIT FOR CGP + *****************************************************************************/ + +/** + * @class GrepWaitGcpReq + * @brief + */ +class GrepWaitGcpReq { + /** + * Sender(s)/Reciver(s) + */ + + friend class GrepParticipant; + + friend bool printGREP_WAITGCP_REQ(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + + Uint32 senderData; + Uint32 gcp; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 senderNodeId; +}; + +/** + * @class GrepWaitGcpConf + * @brief + */ +class GrepWaitGcpConf { + /** + * Sender(s)/Reciver(s) + */ + + friend class GrepParticipant; + + friend bool printGREP_WAITGCP_CONF(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 senderNodeId; +}; + + + +class GrepCreateSubscriptionIdConf { + friend class Grep; + + friend bool printGREP_CREATE_SUBSCRIPTION_ID_CONF(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + + Uint32 subscriptionId; + Uint32 subscriptionKey; + union { // Haven't decide what to call it + Uint32 senderData; + Uint32 subscriberData; + }; +}; + + + +class GrepStartMe { + friend class Grep; + friend bool printGREP_START_ME(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 1 ); + Uint32 senderRef; +}; + + + + +/** + * @class GrepAddSubReq + * @brief + */ +class GrepAddSubReq { + /** + * Sender(s)/Reciver(s) + */ + friend class GrepParticipant; + + friend bool printGREP_ADD_SUB_REQ(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 7 ); + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriberData; + Uint32 subscriberRef; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 subscriptionType; +}; + + +/** + * @class GrepAddSubRef + * @brief + */ +class GrepAddSubRef { + /** + * Sender(s)/Reciver(s) + */ + + friend class GrepParticipant; + + friend bool printGREP_CREATE_REF(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + Uint32 senderData; + Uint32 err; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 subscriptionType; +}; + + +/** + * @class GrepAddSubConf + * @brief + */ +class GrepAddSubConf { + /** + * Sender(s)/Reciver(s) + */ + + friend class GrepParticipant; + + friend bool printGREP_CREATE_CONF(FILE *, + const Uint32 *, + Uint32, + Uint16); +public: + STATIC_CONST( SignalLength = 1 ); + Uint32 noOfSub; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/HotSpareRep.hpp b/ndb/include/kernel/signaldata/HotSpareRep.hpp new file mode 100644 index 00000000000..fb9d338be1b --- /dev/null +++ b/ndb/include/kernel/signaldata/HotSpareRep.hpp @@ -0,0 +1,48 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef HOT_SPAREREP_HPP +#define HOT_SPAREREP_HPP + +#include + +/** + * This signals is sent by Dbdih to Dbdict + */ +class HotSpareRep { + /** + * Sender(s) + */ + friend class Dbdih; + + /** + * Sender(s) / Reciver(s) + */ + + /** + * Reciver(s) + */ + friend class Dbdict; + +public: + STATIC_CONST( SignalLength = 1 + NodeBitmask::Size ); +private: + + Uint32 noHotSpareNodes; + Uint32 theHotSpareNodes[NodeBitmask::Size]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/IndxAttrInfo.hpp b/ndb/include/kernel/signaldata/IndxAttrInfo.hpp new file mode 100755 index 00000000000..ec5790d84f3 --- /dev/null +++ b/ndb/include/kernel/signaldata/IndxAttrInfo.hpp @@ -0,0 +1,56 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef INDX_ATTRINFO_HPP +#define INDX_ATTRINFO_HPP + +#include "SignalData.hpp" + +class IndxAttrInfo { + /** + * Sender(s) + */ + friend class NdbIndexOperation; + + /** + * Receiver(s) + */ + friend class Dbtc; + + friend bool printINDXATTRINFO(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( HeaderLength = 3 ); + STATIC_CONST( DataLength = 22 ); + STATIC_CONST( MaxSignalLength = HeaderLength + DataLength); + + // Public methods +public: + Uint32* getData() const; + +private: + Uint32 connectPtr; + Uint32 transId[2]; + Uint32 attrData[DataLength]; +}; + +inline +Uint32* IndxAttrInfo::getData() const +{ + return (Uint32*)&attrData[0]; +} + +#endif diff --git a/ndb/include/kernel/signaldata/IndxKeyInfo.hpp b/ndb/include/kernel/signaldata/IndxKeyInfo.hpp new file mode 100755 index 00000000000..7cd7795ec71 --- /dev/null +++ b/ndb/include/kernel/signaldata/IndxKeyInfo.hpp @@ -0,0 +1,56 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef INDX_KEY_INFO_HPP +#define INDX_KEY_INFO_HPP + +#include "SignalData.hpp" + +class IndxKeyInfo { + /** + * Sender(s) + */ + friend class NdbIndexOperation; + + /** + * Reciver(s) + */ + friend class Dbtc; + + friend bool printINDXKEYINFO(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( HeaderLength = 3 ); + STATIC_CONST( DataLength = 20 ); + STATIC_CONST( MaxSignalLength = HeaderLength + DataLength ); + + // Public methods +public: + Uint32* getData() const; + +private: + Uint32 connectPtr; + Uint32 transId[2]; + Uint32 keyData[DataLength]; +}; + +inline +Uint32* IndxKeyInfo::getData() const +{ + return (Uint32*)&keyData[0]; +} + +#endif diff --git a/ndb/include/kernel/signaldata/InvalidateNodeLCPConf.hpp b/ndb/include/kernel/signaldata/InvalidateNodeLCPConf.hpp new file mode 100644 index 00000000000..2497af354ce --- /dev/null +++ b/ndb/include/kernel/signaldata/InvalidateNodeLCPConf.hpp @@ -0,0 +1,41 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef INVALIDATE_NODE_LCP_CONF_HPP +#define INVALIDATE_NODE_LCP_CONF_HPP + +/** + * This signal is sent from the non-master DIH to master DIHs + * + */ +class InvalidateNodeLCPConf { + + /** + * Sender/Receiver + */ + friend class Dbdih; + + /** + * NodeId of sending node + * which is "done" + */ + Uint32 sendingNodeId; + +public: + STATIC_CONST( SignalLength = 1 ); +}; + +#endif diff --git a/ndb/include/kernel/signaldata/InvalidateNodeLCPReq.hpp b/ndb/include/kernel/signaldata/InvalidateNodeLCPReq.hpp new file mode 100644 index 00000000000..e55a58710b4 --- /dev/null +++ b/ndb/include/kernel/signaldata/InvalidateNodeLCPReq.hpp @@ -0,0 +1,42 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef INVALIDATE_NODE_LCP_REQ_HPP +#define INVALIDATE_NODE_LCP_REQ_HPP + +/** + * This signal is sent from the master DIH to all DIHs + * when a node is starting without filesystem. + * + * All DIHs must then "forgett" that the starting node has + * performed LCP + * + * @see StartPermReq + */ +class InvalidateNodeLCPReq { + + /** + * Sender/Receiver + */ + friend class Dbdih; + + Uint32 startingNodeId; + +public: + STATIC_CONST( SignalLength = 1 ); +}; + +#endif diff --git a/ndb/include/kernel/signaldata/KeyInfo.hpp b/ndb/include/kernel/signaldata/KeyInfo.hpp new file mode 100644 index 00000000000..b839a2c2035 --- /dev/null +++ b/ndb/include/kernel/signaldata/KeyInfo.hpp @@ -0,0 +1,45 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef KEY_INFO_HPP +#define KEY_INFO_HPP + +#include "SignalData.hpp" + +class KeyInfo { + /** + * Sender(s) + */ + friend class DbUtil; + friend class NdbOperation; + + /** + * Reciver(s) + */ + friend class Dbtc; + +public: + STATIC_CONST( HeaderLength = 3 ); + STATIC_CONST( DataLength = 20 ); + STATIC_CONST( MaxSignalLength = HeaderLength + DataLength ); + +private: + Uint32 connectPtr; + Uint32 transId[2]; + Uint32 keyData[DataLength]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/LCP.hpp b/ndb/include/kernel/signaldata/LCP.hpp new file mode 100644 index 00000000000..7d3fb71ae7e --- /dev/null +++ b/ndb/include/kernel/signaldata/LCP.hpp @@ -0,0 +1,154 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef LCP_SIGNAL_DATA_HPP +#define LCP_SIGNAL_DATA_HPP + +#include "SignalData.hpp" +#include + +class StartLcpReq { + /** + * Sender(s) + */ + friend class Dbdih; + + /** + * Sender(s) / Receiver(s) + */ + + /** + * Receiver(s) + */ + friend class Dblqh; + + friend bool printSTART_LCP_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + + STATIC_CONST( SignalLength = 2 + 2 * NdbNodeBitmask::Size ); +private: + Uint32 senderRef; + Uint32 lcpId; + + NdbNodeBitmask participatingDIH; + NdbNodeBitmask participatingLQH; +}; + +class StartLcpConf { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Sender(s) / Receiver(s) + */ + + /** + * Receiver(s) + */ + friend class Dbdih; + + friend bool printSTART_LCP_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + + STATIC_CONST( SignalLength = 2 ); +private: + Uint32 senderRef; + Uint32 lcpId; +}; + +/** + * This signals is sent by Dbdih to Dblqh + * to order checkpointing of a certain + * fragment. + */ +class LcpFragOrd { + /** + * Sender(s) + */ + friend class Dbdih; + + /** + * Sender(s) / Receiver(s) + */ + + /** + * Receiver(s) + */ + friend class Dblqh; + + friend bool printLCP_FRAG_ORD(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 6 ); +private: + + Uint32 tableId; + Uint32 fragmentId; + Uint32 lcpNo; + Uint32 lcpId; + Uint32 lastFragmentFlag; + Uint32 keepGci; +}; + + +class LcpFragRep { + /** + * Sender(s) and receiver(s) + */ + friend class Dbdih; + + /** + * Sender(s) + */ + friend class Dblqh; + + friend bool printLCP_FRAG_REP(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 7 ); + +private: + Uint32 nodeId; + Uint32 lcpId; + Uint32 lcpNo; + Uint32 tableId; + Uint32 fragId; + Uint32 maxGciCompleted; + Uint32 maxGciStarted; +}; + +class LcpCompleteRep { + /** + * Sender(s) and receiver(s) + */ + friend class Dbdih; + + /** + * Sender(s) + */ + friend class Dblqh; + + friend bool printLCP_COMPLETE_REP(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 nodeId; + Uint32 blockNo; + Uint32 lcpId; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/ListTables.hpp b/ndb/include/kernel/signaldata/ListTables.hpp new file mode 100644 index 00000000000..7fbfab1294c --- /dev/null +++ b/ndb/include/kernel/signaldata/ListTables.hpp @@ -0,0 +1,166 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef LIST_TABLES_HPP +#define LIST_TABLES_HPP + +#include +#include "SignalData.hpp" + +/** + * It is convenient to pack request/response data per table in one + * 32-bit word... + */ +class ListTablesData { +public: + static Uint32 getTableId(Uint32 data) { + return BitmaskImpl::getField(1, &data, 0, 12); + } + static void setTableId(Uint32& data, Uint32 val) { + BitmaskImpl::setField(1, &data, 0, 12, val); + } + static Uint32 getTableType(Uint32 data) { + return BitmaskImpl::getField(1, &data, 12, 8); + } + static void setTableType(Uint32& data, Uint32 val) { + BitmaskImpl::setField(1, &data, 12, 8, val); + } + static Uint32 getTableStore(Uint32 data) { + return BitmaskImpl::getField(1, &data, 20, 4); + } + static void setTableStore(Uint32& data, Uint32 val) { + BitmaskImpl::setField(1, &data, 20, 4, val); + } + static Uint32 getTableState(Uint32 data) { + return BitmaskImpl::getField(1, &data, 24, 4); + } + static void setTableState(Uint32& data, Uint32 val) { + BitmaskImpl::setField(1, &data, 24, 4, val); + } + static Uint32 getListNames(Uint32 data) { + return BitmaskImpl::getField(1, &data, 28, 1); + } + static void setListNames(Uint32& data, Uint32 val) { + BitmaskImpl::setField(1, &data, 28, 1, val); + } + static Uint32 getListIndexes(Uint32 data) { + return BitmaskImpl::getField(1, &data, 29, 1); + } + static void setListIndexes(Uint32& data, Uint32 val) { + BitmaskImpl::setField(1, &data, 29, 1, val); + } +}; + +class ListTablesReq { + /** + * Sender(s) + */ + friend class Backup; + friend class Table; + friend class Suma; + + /** + * Reciver(s) + */ + friend class Dbdict; + +public: + STATIC_CONST( SignalLength = 3 ); + +public: + Uint32 senderData; + Uint32 senderRef; + Uint32 requestData; + + Uint32 getTableId() { + return ListTablesData::getTableId(requestData); + } + void setTableId(Uint32 val) { + ListTablesData::setTableId(requestData, val); + } + Uint32 getTableType() const { + return ListTablesData::getTableType(requestData); + } + void setTableType(Uint32 val) { + ListTablesData::setTableType(requestData, val); + } + Uint32 getListNames() const { + return ListTablesData::getListNames(requestData); + } + void setListNames(Uint32 val) { + ListTablesData::setListNames(requestData, val); + } + Uint32 getListIndexes() const { + return ListTablesData::getListIndexes(requestData); + } + void setListIndexes(Uint32 val) { + ListTablesData::setListIndexes(requestData, val); + } +}; + +class ListTablesConf { + /** + * Sender(s) + */ + friend class Dbdict; + + /** + * Reciver(s) + */ + friend class Backup; + friend class Table; + friend class Suma; + +public: + /** + * Note: last signal is indicated by having length < 25 + */ + STATIC_CONST( SignalLength = 25 ); + STATIC_CONST( HeaderLength = 2 ); + STATIC_CONST( DataLength = 23 ); + +public: + Uint32 senderData; + Uint32 counter; + Uint32 tableData[DataLength]; + + static Uint32 getTableId(Uint32 data) { + return ListTablesData::getTableId(data); + } + void setTableId(unsigned pos, Uint32 val) { + ListTablesData::setTableId(tableData[pos], val); + } + static Uint32 getTableType(Uint32 data) { + return ListTablesData::getTableType(data); + } + void setTableType(unsigned pos, Uint32 val) { + ListTablesData::setTableType(tableData[pos], val); + } + static Uint32 getTableStore(Uint32 data) { + return ListTablesData::getTableStore(data); + } + void setTableStore(unsigned pos, Uint32 val) { + ListTablesData::setTableStore(tableData[pos], val); + } + static Uint32 getTableState(Uint32 data) { + return ListTablesData::getTableState(data); + } + void setTableState(unsigned pos, Uint32 val) { + ListTablesData::setTableState(tableData[pos], val); + } +}; + +#endif diff --git a/ndb/include/kernel/signaldata/LqhFrag.hpp b/ndb/include/kernel/signaldata/LqhFrag.hpp new file mode 100644 index 00000000000..116e9c01ca0 --- /dev/null +++ b/ndb/include/kernel/signaldata/LqhFrag.hpp @@ -0,0 +1,252 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef LQH_FRAG_HPP +#define LQH_FRAG_HPP + +#include "SignalData.hpp" + +class AddFragReq { + /** + * Sender(s) + */ + friend class Dbdih; + + /** + * Receiver(s) + */ + friend class Dbdict; + + friend bool printADD_FRAG_REQ(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 9 ); + + enum RequestInfo { + CreateInRunning = 0x8000000, + TemporaryTable = 0x00000010 + }; +private: + Uint32 dihPtr; + Uint32 senderData; // The same data as sent in DIADDTABREQ + Uint32 fragmentId; + Uint32 requestInfo; + Uint32 tableId; + Uint32 nextLCP; + Uint32 nodeId; + Uint32 totalFragments; + Uint32 startGci; +}; + +class AddFragRef { + /** + * Sender(s) + */ + friend class Dbdict; + + /** + * Receiver(s) + */ + friend class Dbdih; + + friend bool printADD_FRAG_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 1 ); + +private: + Uint32 dihPtr; +}; + +class AddFragConf { + /** + * Sender(s) + */ + friend class Dbdict; + + /** + * Receiver(s) + */ + friend class Dbdih; + + friend bool printADD_FRAG_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 dihPtr; + Uint32 fragId; +}; + +class LqhFragReq { + /** + * Sender(s) + */ + friend class Dbdict; + + /** + * Receiver(s) + */ + friend class Dblqh; + + friend bool printLQH_FRAG_REQ(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 25 ); + + enum RequestInfo { + CreateInRunning = 0x8000000, + TemporaryTable = 0x00000010 + }; + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 fragmentId; + Uint32 requestInfo; + Uint32 tableId; + Uint32 localKeyLength; + Uint32 maxLoadFactor; + Uint32 minLoadFactor; + Uint32 kValue; + Uint32 lh3DistrBits; + Uint32 lh3PageBits; + Uint32 noOfAttributes; + Uint32 noOfNullAttributes; + Uint32 noOfPagesToPreAllocate; + Uint32 schemaVersion; + Uint32 keyLength; + Uint32 nextLCP; + Uint32 noOfKeyAttr; + Uint32 noOfNewAttr; + Uint32 checksumIndicator; + Uint32 noOfAttributeGroups; + Uint32 GCPIndicator; + Uint32 startGci; + Uint32 tableType; // DictTabInfo::TableType + Uint32 primaryTableId; // table of index or RNIL +}; + +class LqhFragConf { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Receiver(s) + */ + friend class Dbdict; + + friend bool printLQH_FRAG_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 senderData; + Uint32 lqhFragPtr; +}; + +class LqhFragRef { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Receiver(s) + */ + friend class Dbdict; + + friend bool printLQH_FRAG_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 senderData; + Uint32 errorCode; +}; + +class LqhAddAttrReq { + /** + * Sender(s) + */ + friend class Dbdict; + + /** + * Receiver(s) + */ + friend class Dblqh; + + friend bool printLQH_ADD_ATTR_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( HeaderLength = 4 ); + STATIC_CONST( EntryLength = 3 ); + STATIC_CONST( MAX_ATTRIBUTES = 6 ); + struct Entry { + Uint32 attrId; // for index, includes primary attr id << 16 + Uint32 attrDescriptor; // 2 words type info + Uint32 extTypeInfo; + }; +private: + Uint32 lqhFragPtr; + Uint32 noOfAttributes; + Uint32 senderData; + Uint32 senderAttrPtr; + Entry attributes[MAX_ATTRIBUTES]; +}; + +class LqhAddAttrRef { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Receiver(s) + */ + friend class Dbdict; + + friend bool printLQH_ADD_ATTR_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 senderData; + Uint32 errorCode; +}; + +class LqhAddAttrConf { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Receiver(s) + */ + friend class Dbdict; + + friend bool printLQH_ADD_ATTR_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 senderData; + Uint32 senderAttrPtr; + Uint32 fragId; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/LqhKey.hpp b/ndb/include/kernel/signaldata/LqhKey.hpp new file mode 100644 index 00000000000..e937180e3f7 --- /dev/null +++ b/ndb/include/kernel/signaldata/LqhKey.hpp @@ -0,0 +1,534 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef LQH_KEY_H +#define LQH_KEY_H + +#include "SignalData.hpp" + +class LqhKeyReq { + /** + * Reciver(s) + */ + friend class Dblqh; // Reciver + + /** + * Sender(s) + */ + friend class Dbtc; + + /** + * For printing + */ + friend bool printLQHKEYREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + STATIC_CONST( FixedSignalLength = 11 ); + +private: + + /** + * DATA VARIABLES + */ +//------------------------------------------------------------- +// Unconditional part. First 10 words +//------------------------------------------------------------- + UintR clientConnectPtr; // DATA 0 + UintR attrLen; // DATA 1 + UintR hashValue; // DATA 2 + UintR requestInfo; // DATA 3 + UintR tcBlockref; // DATA 4 + UintR tableSchemaVersion; // DATA 5 + UintR fragmentData; // DATA 6 + UintR transId1; // DATA 7 + UintR transId2; // DATA 8 + UintR savePointId; // DATA 9 + union { + /** + * When sent from TC -> LQH this variable contains scanInfo + * When send from LQH -> LQH this variable contains noFiredTriggers + */ + UintR noFiredTriggers; // DATA 10 + Uint32 scanInfo; // DATA 10 + }; + +//------------------------------------------------------------- +// Variable sized key part. Those will be placed to +// pack the signal in an appropriate manner. +//------------------------------------------------------------- + UintR variableData[10]; // DATA 11 - 21 + + static UintR getAttrLen(const UintR & scanInfoAttrLen); + static UintR getScanTakeOverFlag(const UintR & scanInfoAttrLen); + static UintR getStoredProcFlag(const UintR & scanData); + static UintR getDistributionKey(const UintR & scanData); + + static UintR getTableId(const UintR & tableSchemaVersion); + static UintR getSchemaVersion(const UintR & tableSchemaVersion); + + static UintR getFragmentId(const UintR & fragmentData); + static UintR getNextReplicaNodeId(const UintR & fragmentData); + + static Uint8 getLockType(const UintR & requestInfo); + static Uint8 getDirtyFlag(const UintR & requestInfo); + static Uint8 getInterpretedFlag(const UintR & requestInfo); + static Uint8 getSimpleFlag(const UintR & requestInfo); + static Uint8 getOperation(const UintR & requestInfo); + static Uint8 getSeqNoReplica(const UintR & requestInfo); + static Uint8 getLastReplicaNo(const UintR & requestInfo); + static Uint8 getAIInLqhKeyReq(const UintR & requestInfo); + static UintR getKeyLen(const UintR & requestInfo); + static UintR getSameClientAndTcFlag(const UintR & requestInfo); + static UintR getReturnedReadLenAIFlag(const UintR & requestInfo); + static UintR getApplicationAddressFlag(const UintR & requestInfo); + static UintR getMarkerFlag(const UintR & requestInfo); + + /** + * Setters + */ + + static void setAttrLen(UintR & scanInfoAttrLen, UintR val); + static void setScanTakeOverFlag(UintR & scanInfoAttrLen, UintR val); + static void setStoredProcFlag(UintR & scanData, UintR val); + static void setDistributionKey(UintR & scanData, UintR val); + + static void setTableId(UintR & tableSchemaVersion, UintR val); + static void setSchemaVersion(UintR & tableSchemaVersion, UintR val); + + static void setFragmentId(UintR & fragmentData, UintR val); + static void setNextReplicaNodeId(UintR & fragmentData, UintR val); + + static void setLockType(UintR & requestInfo, UintR val); + static void setDirtyFlag(UintR & requestInfo, UintR val); + static void setInterpretedFlag(UintR & requestInfo, UintR val); + static void setSimpleFlag(UintR & requestInfo, UintR val); + static void setOperation(UintR & requestInfo, UintR val); + static void setSeqNoReplica(UintR & requestInfo, UintR val); + static void setLastReplicaNo(UintR & requestInfo, UintR val); + static void setAIInLqhKeyReq(UintR & requestInfo, UintR val); + static void setKeyLen(UintR & requestInfo, UintR val); + static void setSameClientAndTcFlag(UintR & requestInfo, UintR val); + static void setReturnedReadLenAIFlag(UintR & requestInfo, UintR val); + static void setApplicationAddressFlag(UintR & requestInfo, UintR val); + static void setMarkerFlag(UintR & requestInfo, UintR val); +}; + +/** + * Request Info + * + * k = Key len - 10 Bits (0-9) max 1023 + * l = Last Replica No - 2 Bits -> Max 3 (10-11) + * t = Lock type - 3 Bits -> Max 7 (12-14) + * p = Application Addr. Ind - 1 Bit (15) + * d = Dirty indicator - 1 Bit (16) + * i = Interpreted indicator - 1 Bit (17) + * s = Simple indicator - 1 Bit (18) + * o = Operation - 3 Bits (19-21) + * r = Sequence replica - 2 Bits (22-23) + * a = Attr Info in LQHKEYREQ - 3 Bits (24-26) + * c = Same client and tc - 1 Bit (27) + * u = Read Len Return Ind - 1 Bit (28) + * m = Commit ack marker - 1 Bit (29) + * - = Unused - 2 Bits (30-31) + * + * 1111111111222222222233 + * 01234567890123456789012345678901 + * kkkkkkkkkklltttpdisooorraaacum-- + */ + +#define RI_KEYLEN_SHIFT (0) +#define RI_KEYLEN_MASK (1023) +#define RI_LAST_REPL_SHIFT (10) +#define RI_LAST_REPL_MASK (3) +#define RI_LOCK_TYPE_SHIFT (12) +#define RI_LOCK_TYPE_MASK (7) +#define RI_APPL_ADDR_SHIFT (15) +#define RI_DIRTY_SHIFT (16) +#define RI_INTERPRETED_SHIFT (17) +#define RI_SIMPLE_SHIFT (18) +#define RI_OPERATION_SHIFT (19) +#define RI_OPERATION_MASK (7) +#define RI_SEQ_REPLICA_SHIFT (22) +#define RI_SEQ_REPLICA_MASK (3) +#define RI_AI_IN_THIS_SHIFT (24) +#define RI_AI_IN_THIS_MASK (7) +#define RI_SAME_CLIENT_SHIFT (27) +#define RI_RETURN_AI_SHIFT (28) +#define RI_MARKER_SHIFT (29) + +/** + * Scan Info + * + * a = Attr Len - 16 Bits -> max 65535 (0-15) + * p = Stored Procedure Ind - 1 Bit (16) + * d = Distribution key - 8 Bit -> max 255 (17-24) + * t = Scan take over indicator - 1 Bit (25) + * + * 1111111111222222222233 + * 01234567890123456789012345678901 + * aaaaaaaaaaaaaaaapddddddddt + */ + +#define SI_ATTR_LEN_MASK (65535) +#define SI_ATTR_LEN_SHIFT (0) +#define SI_STORED_PROC_SHIFT (16) +#define SI_DISTR_KEY_MASK (255) +#define SI_DISTR_KEY_SHIFT (17) +#define SI_SCAN_TO_SHIFT (25) +#define SI_SCAN_INFO_MASK (63) +#define SI_SCAN_INFO_SHIFT (26) + +inline +UintR +LqhKeyReq::getAttrLen(const UintR & scanData) +{ + return (scanData >> SI_ATTR_LEN_SHIFT) & SI_ATTR_LEN_MASK; +} + +inline +Uint32 +LqhKeyReq::getScanTakeOverFlag(const UintR & scanData) +{ + return (scanData >> SI_SCAN_TO_SHIFT) & 1; +} + +inline +UintR +LqhKeyReq::getStoredProcFlag(const UintR & scanData){ + return (scanData >> SI_STORED_PROC_SHIFT) & 1; +} + +inline +UintR +LqhKeyReq::getDistributionKey(const UintR & scanData){ + return (scanData >> SI_DISTR_KEY_SHIFT) & SI_DISTR_KEY_MASK; +} + +inline +UintR LqhKeyReq::getTableId(const UintR & tableSchemaVersion) +{ + return tableSchemaVersion & 0xFFFF; +} + +inline +UintR LqhKeyReq::getSchemaVersion(const UintR & tableSchemaVersion) +{ + return tableSchemaVersion >> 16; +} + +inline +UintR LqhKeyReq::getFragmentId(const UintR & fragmentData) +{ + return fragmentData & 0xFFFF; +} + +inline +UintR LqhKeyReq::getNextReplicaNodeId(const UintR & fragmentData) +{ + return fragmentData >> 16; +} + +inline +Uint8 LqhKeyReq::getLastReplicaNo(const UintR & requestInfo) +{ + return (requestInfo >> RI_LAST_REPL_SHIFT) & RI_LAST_REPL_MASK; +} + +inline +Uint8 LqhKeyReq::getLockType(const UintR & requestInfo) +{ + return (requestInfo >> RI_LOCK_TYPE_SHIFT) & RI_LOCK_TYPE_MASK; +} + +inline +Uint8 LqhKeyReq::getDirtyFlag(const UintR & requestInfo) +{ + return (requestInfo >> RI_DIRTY_SHIFT) & 1; +} + +inline +Uint8 LqhKeyReq::getInterpretedFlag(const UintR & requestInfo) +{ + return (requestInfo >> RI_INTERPRETED_SHIFT) & 1; +} + +inline +Uint8 LqhKeyReq::getSimpleFlag(const UintR & requestInfo) +{ + return (requestInfo >> RI_SIMPLE_SHIFT) & 1; +} + +inline +Uint8 LqhKeyReq::getOperation(const UintR & requestInfo) +{ + return (requestInfo >> RI_OPERATION_SHIFT) & RI_OPERATION_MASK; +} + +inline +Uint8 LqhKeyReq::getSeqNoReplica(const UintR & requestInfo) +{ + return (requestInfo >> RI_SEQ_REPLICA_SHIFT) & RI_SEQ_REPLICA_MASK; +} + + +inline +Uint8 LqhKeyReq::getAIInLqhKeyReq(const UintR & requestInfo) +{ + return (requestInfo >> RI_AI_IN_THIS_SHIFT) & RI_AI_IN_THIS_MASK; +} + +inline +UintR LqhKeyReq::getKeyLen(const UintR & requestInfo) +{ + return (requestInfo >> RI_KEYLEN_SHIFT) & RI_KEYLEN_MASK; +} + +inline +UintR +LqhKeyReq::getSameClientAndTcFlag(const UintR & requestInfo) +{ + return (requestInfo >> RI_SAME_CLIENT_SHIFT) & 1; +} + +inline +UintR LqhKeyReq::getReturnedReadLenAIFlag(const UintR & requestInfo) +{ + return (requestInfo >> RI_RETURN_AI_SHIFT) & 1; +} + +inline +UintR +LqhKeyReq::getApplicationAddressFlag(const UintR & requestInfo){ + return (requestInfo >> RI_APPL_ADDR_SHIFT) & 1; +} + +inline +void +LqhKeyReq::setAttrLen(UintR & scanInfoAttrLen, UintR val){ + ASSERT_MAX(val, SI_ATTR_LEN_MASK, "LqhKeyReq::setAttrLen"); + scanInfoAttrLen |= (val << SI_ATTR_LEN_SHIFT); +} + + +inline +void +LqhKeyReq::setScanTakeOverFlag(UintR & scanInfoAttrLen, UintR val){ + ASSERT_BOOL(val, "LqhKeyReq::setScanTakeOverFlag"); + scanInfoAttrLen |= (val << SI_SCAN_TO_SHIFT); +} +inline +void + +LqhKeyReq::setStoredProcFlag(UintR & scanData, UintR val){ + ASSERT_BOOL(val, "LqhKeyReq::setStoredProcFlag"); + scanData |= (val << SI_STORED_PROC_SHIFT); +} + +inline +void + +LqhKeyReq::setDistributionKey(UintR & scanData, UintR val){ + ASSERT_MAX(val, SI_DISTR_KEY_MASK, "LqhKeyReq::setDistributionKey"); + scanData |= (val << SI_DISTR_KEY_SHIFT); +} + +#if 0 +inline +void + +LqhKeyReq::setTableId(UintR & tableSchemaVersion, UintR val){ + +} +inline +void +LqhKeyReq::setSchemaVersion(UintR & tableSchemaVersion, UintR val); + +inline +void +LqhKeyReq::setFragmentId(UintR & fragmentData, UintR val); + +inline +void +LqhKeyReq::setNextReplicaNodeId(UintR & fragmentData, UintR val); +#endif + +inline +void +LqhKeyReq::setLockType(UintR & requestInfo, UintR val){ + ASSERT_MAX(val, RI_LOCK_TYPE_MASK, "LqhKeyReq::setLockType"); + requestInfo |= (val << RI_LOCK_TYPE_SHIFT); +} + +inline +void +LqhKeyReq::setDirtyFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "LqhKeyReq::setDirtyFlag"); + requestInfo |= (val << RI_DIRTY_SHIFT); +} + +inline +void +LqhKeyReq::setInterpretedFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "LqhKeyReq::setInterpretedFlag"); + requestInfo |= (val << RI_INTERPRETED_SHIFT); +} + +inline +void +LqhKeyReq::setSimpleFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "LqhKeyReq::setSimpleFlag"); + requestInfo |= (val << RI_SIMPLE_SHIFT); +} + +inline +void +LqhKeyReq::setOperation(UintR & requestInfo, UintR val){ + ASSERT_MAX(val, RI_OPERATION_MASK, "LqhKeyReq::setOperation"); + requestInfo |= (val << RI_OPERATION_SHIFT); +} + +inline +void +LqhKeyReq::setSeqNoReplica(UintR & requestInfo, UintR val){ + ASSERT_MAX(val, RI_SEQ_REPLICA_MASK, "LqhKeyReq::setSeqNoReplica"); + requestInfo |= (val << RI_SEQ_REPLICA_SHIFT); +} + +inline +void +LqhKeyReq::setLastReplicaNo(UintR & requestInfo, UintR val){ + ASSERT_MAX(val, RI_LAST_REPL_MASK, "LqhKeyReq::setLastReplicaNo"); + requestInfo |= (val << RI_LAST_REPL_SHIFT); +} + +inline +void +LqhKeyReq::setAIInLqhKeyReq(UintR & requestInfo, UintR val){ + ASSERT_MAX(val, RI_AI_IN_THIS_MASK, "LqhKeyReq::setAIInLqhKeyReq"); + requestInfo |= (val << RI_AI_IN_THIS_SHIFT); +} + +inline +void +LqhKeyReq::setKeyLen(UintR & requestInfo, UintR val){ + ASSERT_MAX(val, RI_KEYLEN_MASK, "LqhKeyReq::setKeyLen"); + requestInfo |= (val << RI_KEYLEN_SHIFT); +} + +inline +void +LqhKeyReq::setSameClientAndTcFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "LqhKeyReq::setSameClientAndTcFlag"); + requestInfo |= (val << RI_SAME_CLIENT_SHIFT); +} + +inline +void +LqhKeyReq::setReturnedReadLenAIFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "LqhKeyReq::setReturnedReadLenAIFlag"); + requestInfo |= (val << RI_RETURN_AI_SHIFT); +} + +inline +void +LqhKeyReq::setApplicationAddressFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "LqhKeyReq::setApplicationAddressFlag"); + requestInfo |= (val << RI_APPL_ADDR_SHIFT); +} + +/**** */ + +inline +void +LqhKeyReq::setMarkerFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "LqhKeyReq::setMarkerFlag"); + requestInfo |= (val << RI_MARKER_SHIFT); +} + +inline +UintR +LqhKeyReq::getMarkerFlag(const UintR & requestInfo){ + return (requestInfo >> RI_MARKER_SHIFT) & 1; +} + +class LqhKeyConf { + /** + * Reciver(s) + */ + friend class Dbtc; + + /** + * Sender(s) + */ + friend class Dblqh; + + // Sent in a packed signal + friend class PackedSignal; + /** + * For printing + */ + friend bool printPACKED_SIGNAL(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + friend bool printLQHKEYCONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + STATIC_CONST( SignalLength = 7 ); + +private: + + /** + * DATA VARIABLES + */ + Uint32 connectPtr; + Uint32 opPtr; + Uint32 userRef; + Uint32 readLen; + Uint32 transId1; + Uint32 transId2; + Uint32 noFiredTriggers; +}; + +class LqhKeyRef { + /** + * Reciver(s) + */ + friend class Dbtc; + + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * For printing + */ + friend bool printLQHKEYREF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + STATIC_CONST( SignalLength = 5 ); + +private: + + /** + * DATA VARIABLES + */ + Uint32 userRef; + Uint32 connectPtr; + Uint32 errorCode; + Uint32 transId1; + Uint32 transId2; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/LqhSizeAltReq.hpp b/ndb/include/kernel/signaldata/LqhSizeAltReq.hpp new file mode 100644 index 00000000000..e47ce39897a --- /dev/null +++ b/ndb/include/kernel/signaldata/LqhSizeAltReq.hpp @@ -0,0 +1,53 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef LQH_SIZE_ALT_REQ_H +#define LQH_SIZE_ALT_REQ_H + + + +#include "SignalData.hpp" + +class LqhSizeAltReq { + /** + * Sender(s) + */ + friend class ClusterConfiguration; + + /** + * Reciver(s) + */ + friend class Dblqh; +private: + /** + * Indexes in theData + */ + STATIC_CONST( IND_BLOCK_REF = 0); + STATIC_CONST( IND_FRAG = 1); + STATIC_CONST( IND_CONNECT = 2); + STATIC_CONST( IND_TABLE = 3); + STATIC_CONST( IND_TC_CONNECT = 4); + STATIC_CONST( IND_REPLICAS = 5); + STATIC_CONST( IND_LOG_FILES = 6); + STATIC_CONST( IND_SCAN = 7); + + /** + * Use the index definitions to use the signal data + */ + UintR theData[8]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/LqhTransConf.hpp b/ndb/include/kernel/signaldata/LqhTransConf.hpp new file mode 100644 index 00000000000..f62dfd07f51 --- /dev/null +++ b/ndb/include/kernel/signaldata/LqhTransConf.hpp @@ -0,0 +1,218 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef LQH_TRANS_CONF_H +#define LQH_TRANS_CONF_H + +#include "SignalData.hpp" + +/** + * This signal is sent as response to a LQH_TRANSREQ + * which is sent as by a take-over TC + */ +class LqhTransConf { + /** + * Reciver(s) + */ + friend class Dbtc; + + /** + * Sender(s) + */ + friend class Dblqh; + + friend bool printLQH_TRANSCONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 15 ); +private: + + /** + * This type describes the state of the operation returned in this signal + */ + enum OperationStatus { + InvalidStatus = 0, /**< This status should never be sent in a signal + it is only used for initializing variables so that + you can easily later check if they have changed */ + LastTransConf = 4, /**< This status indicates that LQH has finished the scan + of operations belonging to the died TC. + Data 0 - 2 is valid */ + + Prepared = 2, + Committed = 3, + Aborted = 1, + Marker = 5 /**< This means that the only thing left is a marker, + Data 0 - 6 is valid */ + }; + + /** + * DATA VARIABLES + */ + Uint32 tcRef; // 0 + Uint32 lqhNodeId; // 1 + Uint32 operationStatus; // 2 See enum OperationStatus + Uint32 transId1; // 3 + Uint32 transId2; // 4 + Uint32 apiRef; // 5 + Uint32 apiOpRec; // 6 + Uint32 lqhConnectPtr; + Uint32 oldTcOpRec; + Uint32 requestInfo; + Uint32 gci; + Uint32 nextNodeId1; + Uint32 nextNodeId2; + Uint32 nextNodeId3; + Uint32 tableId; + + /** + * Getters + */ + static Uint32 getReplicaNo(Uint32 & requestInfo); + static Uint32 getReplicaType(Uint32 & requestInfo); + static Uint32 getLastReplicaNo(Uint32 & requestInfo); + static Uint32 getSimpleFlag(Uint32 & requestInfo); + static Uint32 getDirtyFlag(Uint32 & requestInfo); + static Uint32 getOperation(Uint32 & requestInfo); + static Uint32 getMarkerFlag(Uint32 & requestInfo); + + static void setReplicaNo(UintR & requestInfo, UintR val); + static void setReplicaType(UintR & requestInfo, UintR val); + static void setLastReplicaNo(UintR & requestInfo, UintR val); + static void setSimpleFlag(UintR & requestInfo, UintR val); + static void setDirtyFlag(UintR & requestInfo, UintR val); + static void setOperation(UintR & requestInfo, UintR val); + static void setMarkerFlag(Uint32 & requestInfo, Uint32 val); +}; + +/** + * Request Info + * + * t = replica type - 2 Bits (0-1) + * r = Replica No - 2 Bits (2-3) + * l = Last Replica No - 2 Bits (4-5) + * s = Simple - 1 Bits (6) + * d = Dirty - 1 Bit (7) + * o = Operation - 3 Bit (8-9) + * m = Marker present - 1 Bit (10) + * + * 1111111111222222222233 + * 01234567890123456789012345678901 + * ttrrllsdooom + */ +#define LTC_REPLICA_TYPE_SHIFT (0) +#define LTC_REPLICA_TYPE_MASK (3) +#define LTC_REPLICA_NO_SHIFT (2) +#define LTC_REPLICA_NO_MASK (3) +#define LTC_LAST_REPLICA_SHIFT (4) +#define LTC_LAST_REPLICA_MASK (3) +#define LTC_SIMPLE_SHIFT (6) +#define LTC_DIRTY_SHIFT (7) +#define LTC_OPERATION_SHIFT (8) +#define LTC_OPERATION_MASK (7) +#define LTC_MARKER_SHIFT (10) + +inline +Uint32 +LqhTransConf::getReplicaType(Uint32 & requestInfo){ + return (requestInfo >> LTC_REPLICA_TYPE_SHIFT) & LTC_REPLICA_TYPE_MASK; +} + +inline +Uint32 +LqhTransConf::getReplicaNo(Uint32 & requestInfo){ + return (requestInfo >> LTC_REPLICA_NO_SHIFT) & LTC_REPLICA_NO_MASK; +} + +inline +Uint32 +LqhTransConf::getLastReplicaNo(Uint32 & requestInfo){ + return (requestInfo >> LTC_LAST_REPLICA_SHIFT) & LTC_LAST_REPLICA_MASK; +} + +inline +Uint32 +LqhTransConf::getSimpleFlag(Uint32 & requestInfo){ + return (requestInfo >> LTC_SIMPLE_SHIFT) & 1; +} + +inline +Uint32 +LqhTransConf::getDirtyFlag(Uint32 & requestInfo){ + return (requestInfo >> LTC_DIRTY_SHIFT) & 1; +} + +inline +Uint32 +LqhTransConf::getOperation(Uint32 & requestInfo){ + return (requestInfo >> LTC_OPERATION_SHIFT) & LTC_OPERATION_MASK; +} + +inline +Uint32 +LqhTransConf::getMarkerFlag(Uint32 & requestInfo){ + return (requestInfo >> LTC_MARKER_SHIFT) & 1; +} + + +inline +void +LqhTransConf::setReplicaNo(UintR & requestInfo, UintR val){ + ASSERT_MAX(val, LTC_REPLICA_NO_MASK, "LqhTransConf::setReplicaNo"); + requestInfo |= (val << LTC_REPLICA_NO_SHIFT); +} + +inline +void +LqhTransConf::setReplicaType(UintR & requestInfo, UintR val){ + ASSERT_MAX(val, LTC_REPLICA_TYPE_MASK, "LqhTransConf::setReplicaType"); + requestInfo |= (val << LTC_REPLICA_TYPE_SHIFT); +} + +inline +void +LqhTransConf::setLastReplicaNo(UintR & requestInfo, UintR val){ + ASSERT_MAX(val, LTC_LAST_REPLICA_MASK, "LqhTransConf::setLastReplicaNo"); + requestInfo |= (val << LTC_LAST_REPLICA_SHIFT); +} + +inline +void +LqhTransConf::setSimpleFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "LqhTransConf::setSimpleFlag"); + requestInfo |= (val << LTC_SIMPLE_SHIFT); +} + +inline +void +LqhTransConf::setDirtyFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "LqhTransConf::setDirtyFlag"); + requestInfo |= (val << LTC_DIRTY_SHIFT); +} + +inline +void +LqhTransConf::setOperation(UintR & requestInfo, UintR val){ + ASSERT_MAX(val, LTC_OPERATION_MASK, "LqhTransConf::setOperation"); + requestInfo |= (val << LTC_OPERATION_SHIFT); +} + +inline +void +LqhTransConf::setMarkerFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "LqhTransConf::setMarkerFlag"); + requestInfo |= (val << LTC_MARKER_SHIFT); +} + +#endif diff --git a/ndb/include/kernel/signaldata/ManagementServer.hpp b/ndb/include/kernel/signaldata/ManagementServer.hpp new file mode 100644 index 00000000000..ce14e30c81d --- /dev/null +++ b/ndb/include/kernel/signaldata/ManagementServer.hpp @@ -0,0 +1,87 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef MANAGEMENTSERVER_HPP +#define MANAGEMENTSERVER_HPP + +#include "SignalData.hpp" + +/** + * Request to lock configuration + */ +class MgmLockConfigReq { + friend class MgmtSrvr; + +public: + STATIC_CONST( SignalLength = 1 ); + +private: + Uint32 newConfigGeneration; +}; + +/** + * Confirm configuration lock + */ +class MgmLockConfigRep { + friend class MgmtSrvr; +public: + STATIC_CONST( SignalLength = 1 ); + + /* Error codes */ + enum ErrorCode { + OK, + UNKNOWN_ERROR, + GENERATION_MISMATCH, + ALREADY_LOCKED + }; + +private: + Uint32 errorCode; +}; + +/** + * Unlock configuration + */ +class MgmUnlockConfigReq { + friend class MgmtSrvr; + +public: + STATIC_CONST( SignalLength = 1 ); + +private: + Uint32 commitConfig; +}; + +/** + * Confirm config unlock + */ +class MgmUnlockConfigRep { + friend class MgmtSrvr; +public: + STATIC_CONST( SignalLength = 1 ); + + /* Error codes */ + enum ErrorCode { + OK, + UNKNOWN_ERROR, + NOT_LOCKED + }; + +private: + Uint32 errorCode; +}; + +#endif /* !MANAGEMENTSERVER_HPP */ diff --git a/ndb/include/kernel/signaldata/MasterGCP.hpp b/ndb/include/kernel/signaldata/MasterGCP.hpp new file mode 100644 index 00000000000..ebe6857a107 --- /dev/null +++ b/ndb/include/kernel/signaldata/MasterGCP.hpp @@ -0,0 +1,84 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef MASTER_GCP_HPP +#define MASTER_GCP_HPP + +#include + +/** + * + */ +class MasterGCPConf { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 8 + NdbNodeBitmask::Size ); + + enum State { + GCP_READY = 0, + GCP_PREPARE_RECEIVED = 1, + GCP_COMMIT_RECEIVED = 2, + GCP_TC_FINISHED = 3 + }; +private: + /** + * Data replied + */ + Uint32 gcpState; + Uint32 senderNodeId; + Uint32 failedNodeId; + Uint32 newGCP; + Uint32 latestLCP; + Uint32 oldestRestorableGCI; + Uint32 keepGCI; + Uint32 lcpActive[NdbNodeBitmask::Size]; +}; +/** + * + */ +class MasterGCPReq { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 2 ); +private: + Uint32 masterRef; + Uint32 failedNodeId; +}; + +/** + * + */ +class MasterGCPRef { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 2 ); +private: + Uint32 senderNodeId; + Uint32 failedNodeId; +}; +#endif diff --git a/ndb/include/kernel/signaldata/MasterLCP.hpp b/ndb/include/kernel/signaldata/MasterLCP.hpp new file mode 100644 index 00000000000..bf84ac73309 --- /dev/null +++ b/ndb/include/kernel/signaldata/MasterLCP.hpp @@ -0,0 +1,86 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef MASTER_LCP_HPP +#define MASTER_LCP_HPP + +#include +#include "SignalData.hpp" + +/** + * + */ +class MasterLCPConf { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + + friend bool printMASTER_LCP_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + + enum State { + LCP_STATUS_IDLE = 0, + LCP_STATUS_ACTIVE = 2, + LCP_TAB_COMPLETED = 8, + LCP_TAB_SAVED = 9 + }; + + friend NdbOut& operator<<(NdbOut&, const State&); + +private: + /** + * Data replied + */ + Uint32 senderNodeId; + Uint32 lcpState; + Uint32 failedNodeId; +}; +/** + * + */ +class MasterLCPReq { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + + friend bool printMASTER_LCP_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 2 ); +private: + Uint32 masterRef; + Uint32 failedNodeId; +}; + +class MasterLCPRef { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + + friend bool printMASTER_LCP_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 2 ); +private: + /** + * Data replied + */ + Uint32 senderNodeId; + Uint32 failedNodeId; +}; +#endif diff --git a/ndb/include/kernel/signaldata/NFCompleteRep.hpp b/ndb/include/kernel/signaldata/NFCompleteRep.hpp new file mode 100644 index 00000000000..c8bde705a86 --- /dev/null +++ b/ndb/include/kernel/signaldata/NFCompleteRep.hpp @@ -0,0 +1,80 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NF_COMPLETE_REP_HPP +#define NF_COMPLETE_REP_HPP + +#include "SignalData.hpp" + +/** + * NFCompleteRep - Node Fail Complete Report + * + * This signal is sent by a block(or a node) + * when it has finished cleaning up after a node failure. + * + * It's also sent from Qmgr to the clusterMgr in API + * to tell the API that it can now abort all transactions still waiting for response + * from the failed NDB node + * + */ +class NFCompleteRep { + /** + * Sender(s) + */ + friend class Dbdict; + friend class Dblqh; + friend class Dbtc; + friend class Qmgr; + + /** + * Sender/Reciver + */ + friend class Dbdih; + friend class ClusterMgr; + + friend bool printNF_COMPLETE_REP(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 5 ); + +private: + + /** + * Which block has completed... + * + * NOTE: 0 means the node has completed + */ + Uint32 blockNo; + + /** + * Which node has completed... + */ + Uint32 nodeId; + + /** + * Which node has failed + */ + Uint32 failedNodeId; + + /** + * Is this the original message or a delayed variant. + */ + Uint32 unused; // originalMessage + + Uint32 from; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/NdbSttor.hpp b/ndb/include/kernel/signaldata/NdbSttor.hpp new file mode 100644 index 00000000000..edd93ef96a8 --- /dev/null +++ b/ndb/include/kernel/signaldata/NdbSttor.hpp @@ -0,0 +1,85 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_STTOR_HPP +#define NDB_STTOR_HPP + +#include "SignalData.hpp" + +class NdbSttor { + /** + * Sender(s) + */ + friend class NdbCntr; + + /** + * Reciver(s) + */ + friend class Ndbcntr; + friend class Dbdict; + friend class Dbdih; + friend class Dblqh; + friend class Dbtc; + friend class ClusterMgr; + friend class Trix; + friend class Backup; + friend class Suma; + friend class Grep; + + friend bool printNDB_STTOR(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + STATIC_CONST( DataLength = 16 ); +private: + + Uint32 senderRef; + Uint32 nodeId; + Uint32 internalStartPhase; + Uint32 typeOfStart; + Uint32 masterNodeId; + Uint32 unused; + Uint32 config[DataLength]; +}; + +class NdbSttorry { + /** + * Receiver(s) + */ + friend class NdbCntr; + + /** + * Sender(s) + */ + friend class Ndbcntr; + friend class Dbdict; + friend class Dbdih; + friend class Dblqh; + friend class Dbtc; + friend class ClusterMgr; + friend class Trix; + friend class Backup; + friend class Suma; + friend class Grep; + + friend bool printNDB_STTORRY(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 1 ); +private: + + Uint32 senderRef; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/NdbfsContinueB.hpp b/ndb/include/kernel/signaldata/NdbfsContinueB.hpp new file mode 100644 index 00000000000..2d569be721f --- /dev/null +++ b/ndb/include/kernel/signaldata/NdbfsContinueB.hpp @@ -0,0 +1,35 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDBFS_CONTINUEB_H +#define NDBFS_CONTINUEB_H + +#include "SignalData.hpp" + +class NdbfsContinueB { + /** + * Sender(s)/Reciver(s) + */ + friend class Ndbfs; + friend bool printCONTINUEB_NDBFS(FILE * output, const Uint32 * theData, Uint32 len); +private: + enum { + ZSCAN_MEMORYCHANNEL_10MS_DELAY = 0, + ZSCAN_MEMORYCHANNEL_NO_DELAY = 1 + }; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/NextScan.hpp b/ndb/include/kernel/signaldata/NextScan.hpp new file mode 100644 index 00000000000..3a1882f94e8 --- /dev/null +++ b/ndb/include/kernel/signaldata/NextScan.hpp @@ -0,0 +1,67 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NEXT_SCAN_HPP +#define NEXT_SCAN_HPP + +#include "SignalData.hpp" + +class NextScanReq { + friend class Dblqh; + friend class Dbacc; + friend class Dbtux; +public: + // two sets of defs picked from lqh/acc + enum ScanFlag { + ZSCAN_NEXT = 1, + ZSCAN_NEXT_COMMIT = 2, + ZSCAN_COMMIT = 3, // new + ZSCAN_CLOSE = 6, + ZSCAN_NEXT_ABORT = 12 + }; + enum CopyFlag { + todo_ZCOPY_NEXT = 1, + todo_ZCOPY_NEXT_COMMIT = 2, + todo_ZCOPY_COMMIT = 3, + todo_ZCOPY_REPEAT = 4, + todo_ZCOPY_ABORT = 5, + todo_ZCOPY_CLOSE = 6 + }; + STATIC_CONST( SignalLength = 3 ); +private: + Uint32 accPtr; // scan record in ACC/TUX + Uint32 accOperationPtr; + Uint32 scanFlag; +}; + +class NextScanConf { + friend class Dbacc; + friend class Dbtux; + friend class Dblqh; +public: + // length is less if no keyinfo or no next result + STATIC_CONST( SignalLength = 11 ); +private: + Uint32 scanPtr; // scan record in LQH + Uint32 accOperationPtr; + Uint32 fragId; + Uint32 localKey[2]; + Uint32 localKeyLength; + Uint32 keyLength; + Uint32 key[4]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/NodeFailRep.hpp b/ndb/include/kernel/signaldata/NodeFailRep.hpp new file mode 100644 index 00000000000..060acd6a3e2 --- /dev/null +++ b/ndb/include/kernel/signaldata/NodeFailRep.hpp @@ -0,0 +1,68 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NODE_FAILREP_HPP +#define NODE_FAILREP_HPP + +#include "SignalData.hpp" +#include + +/** + * This signals is sent by Qmgr to NdbCntr + * and then from NdbCntr sent to: dih, dict, lqh, tc & API + */ +class NodeFailRep { + /** + * Sender(s) + */ + friend class Qmgr; + + /** + * Sender(s) / Reciver(s) + */ + friend class Ndbcntr; + friend class Dbdict; + + /** + * Reciver(s) + */ + friend class Dbdih; + friend class Dblqh; + friend class Dbtc; + friend class ClusterMgr; + friend class Trix; + friend class Backup; + friend class Suma; + friend class Grep; + friend class SafeCounterManager; + +public: + STATIC_CONST( SignalLength = 3 + NodeBitmask::Size ); +private: + + Uint32 failNo; + + /** + * Note: This field is only set when signals is sent FROM Ndbcntr + * (not when signal is sent from Qmgr) + */ + Uint32 masterNodeId; + + Uint32 noOfNodes; + Uint32 theNodes[NodeBitmask::Size]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/NodeStateSignalData.hpp b/ndb/include/kernel/signaldata/NodeStateSignalData.hpp new file mode 100644 index 00000000000..391d8f89566 --- /dev/null +++ b/ndb/include/kernel/signaldata/NodeStateSignalData.hpp @@ -0,0 +1,94 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NODE_STATE_SIGNAL_DATA_HPP +#define NODE_STATE_SIGNAL_DATA_HPP + +#include + +/** + * NodeStateRep + * + * Sent so that all blocks will update their NodeState + */ +class NodeStateRep { + /** + * Sender(s) + */ + friend class Ndbcntr; + + /** + * Reciver + */ + friend class SimulatedBlock; + +public: + STATIC_CONST( SignalLength = NodeState::DataLength ); +private: + + NodeState nodeState; +}; + +/** + * ChangeNodeStateReq + * + * Sent by NdbCntr when synchronous NodeState updates are needed + */ +class ChangeNodeStateReq { + /** + * Sender(s) + */ + friend class Ndbcntr; + + /** + * Reciver + */ + friend class SimulatedBlock; + +public: + STATIC_CONST( SignalLength = 2 + NodeState::DataLength ); +public: + + Uint32 senderRef; + Uint32 senderData; + NodeState nodeState; +}; + +/** + * ChangeNodeStateConf + * + * Sent by SimulatedBlock as a confirmation to ChangeNodeStateReq + */ +class ChangeNodeStateConf { + /** + * Sender(s) + */ + friend class SimulatedBlock; + + /** + * Reciver + */ + friend class NdbCntr; + +public: + STATIC_CONST( SignalLength = 1 ); +private: + + Uint32 senderData; +}; + + +#endif diff --git a/ndb/include/kernel/signaldata/PackedSignal.hpp b/ndb/include/kernel/signaldata/PackedSignal.hpp new file mode 100644 index 00000000000..057bb39b25a --- /dev/null +++ b/ndb/include/kernel/signaldata/PackedSignal.hpp @@ -0,0 +1,43 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef PACKED_SIGNAL_HPP +#define PACKED_SIGNAL_HPP + +#include "SignalData.hpp" + +// -------- CODES FOR COMPRESSED SIGNAL (PACKED_SIGNAL) ------- +#define ZCOMMIT 0 +#define ZCOMPLETE 1 +#define ZCOMMITTED 2 +#define ZCOMPLETED 3 +#define ZLQHKEYCONF 4 +#define ZREMOVE_MARKER 5 + +class PackedSignal { + + static Uint32 getSignalType(Uint32 data); + + /** + * For printing + */ + friend bool printPACKED_SIGNAL(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); +}; + +inline +Uint32 PackedSignal::getSignalType(Uint32 data) { return data >> 28; }; + +#endif diff --git a/ndb/include/kernel/signaldata/PrepDropTab.hpp b/ndb/include/kernel/signaldata/PrepDropTab.hpp new file mode 100644 index 00000000000..e9cc28fed0c --- /dev/null +++ b/ndb/include/kernel/signaldata/PrepDropTab.hpp @@ -0,0 +1,170 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef PREP_DROP_TAB_HPP +#define PREP_DROP_TAB_HPP + +#include "SignalData.hpp" + +class PrepDropTabReq { + /** + * Sender(s) + */ + friend class Dbdict; + + /** + * Receiver(s) + */ + friend class Dbtc; + friend class Dblqh; + friend class Dbdih; + + friend bool printPREP_DROP_TAB_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 senderRef; + Uint32 senderData; + Uint32 tableId; + Uint32 requestType; // @see DropTabReq::RequestType +}; + +class PrepDropTabConf { + /** + * Sender(s) + */ + friend class Dbtc; + friend class Dblqh; + friend class Dbdih; + + /** + * Receiver(s) + */ + friend class Dbdict; + + friend bool printPREP_DROP_TAB_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 senderRef; + Uint32 senderData; + Uint32 tableId; +}; + +class PrepDropTabRef { + /** + * Sender(s) + */ + friend class Dbtc; + friend class Dblqh; + friend class Dbdih; + + /** + * Receiver(s) + */ + friend class Dbdict; + + friend bool printPREP_DROP_TAB_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + enum ErrorCode { + OK = 0, + NoSuchTable = 1, + PrepDropInProgress = 2, + DropInProgress = 3, + InvalidTableState = 4 + }; + +private: + Uint32 senderRef; + Uint32 senderData; + Uint32 tableId; + Uint32 errorCode; +}; + +class WaitDropTabReq { + /** + * Sender + */ + friend class Dbtc; + friend class Dbdih; + + /** + * Receiver(s) + */ + friend class Dblqh; + + friend bool printWAIT_DROP_TAB_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 2 ); + + Uint32 tableId; + Uint32 senderRef; +}; + +class WaitDropTabRef { + /** + * Sender + */ + friend class Dblqh; + + /** + * Receiver(s) + */ + friend class Dbtc; + friend class Dbdih; + + friend bool printWAIT_DROP_TAB_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + enum ErrorCode { + NoSuchTable = 1, + IllegalTableState = 2, + DropInProgress = 3 + }; + + Uint32 tableId; + Uint32 senderRef; + Uint32 errorCode; + Uint32 tableStatus; +}; + + +class WaitDropTabConf { + /** + * Sender + */ + friend class Dblqh; + + /** + * Receiver(s) + */ + friend class Dbtc; + friend class Dbdih; + + friend bool printWAIT_DROP_TAB_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 2 ); + + Uint32 tableId; + Uint32 senderRef; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/PrepFailReqRef.hpp b/ndb/include/kernel/signaldata/PrepFailReqRef.hpp new file mode 100644 index 00000000000..90b568237b8 --- /dev/null +++ b/ndb/include/kernel/signaldata/PrepFailReqRef.hpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef PREP_FAILREQREF_HPP +#define PREP_FAILREQREF_HPP + +#include "SignalData.hpp" +#include + +/** + * The Req signal is sent by Qmgr to Qmgr + * and the Ref signal might be sent back + * + * NOTE that the signals are identical + */ +class PrepFailReqRef { + + /** + * Sender(s) / Reciver(s) + */ + friend class Qmgr; + + friend bool printPREPFAILREQREF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + STATIC_CONST( SignalLength = 3 + NodeBitmask::Size ); +private: + + Uint32 xxxBlockRef; + Uint32 failNo; + + Uint32 noOfNodes; + Uint32 theNodes[NodeBitmask::Size]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/ReadNodesConf.hpp b/ndb/include/kernel/signaldata/ReadNodesConf.hpp new file mode 100644 index 00000000000..f3176cbf0e8 --- /dev/null +++ b/ndb/include/kernel/signaldata/ReadNodesConf.hpp @@ -0,0 +1,109 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef READ_NODESCONF_HPP +#define READ_NODESCONF_HPP + +#include + +/** + * This signals is sent by Qmgr to NdbCntr + * and then from NdbCntr sent to: dih, dict, lqh, tc + * + * NOTE Only noOfNodes & allNodes are valid when sent from Qmgr + */ +class ReadNodesConf { + /** + * Sender(s) + */ + friend class Qmgr; + + /** + * Sender(s) / Reciver(s) + */ + friend class Ndbcntr; + + /** + * Reciver(s) + */ + friend class Dbdih; + friend class Dbdict; + friend class Dblqh; + friend class Dbtc; + friend class Trix; + friend class Backup; + friend class Suma; + friend class Grep; + +public: + STATIC_CONST( SignalLength = 2 + 6*NodeBitmask::Size ); +private: + + Uint32 noOfNodes; + + /** + * + * NOTE Not valid when send from Qmgr + */ + Uint32 masterNodeId; + + /** + * This array defines all the ndb nodes in the system + */ + Uint32 allNodes[NodeBitmask::Size]; + + /** + * This array describes wheather the nodes are currently active + * + * NOTE Not valid when send from Qmgr + */ + Uint32 inactiveNodes[NodeBitmask::Size]; + + /** + * This array describes the version id of the nodes + * The version id is a 4 bit number + * + * NOTE Not valid when send from Qmgr + */ + Uint32 theVersionIds[4*NodeBitmask::Size]; + + static void setVersionId(NodeId, Uint8 versionId, Uint32 theVersionIds[]); + static Uint8 getVersionId(NodeId, const Uint32 theVersionIds[]); +}; + +inline +void +ReadNodesConf::setVersionId(NodeId nodeId, Uint8 versionId, + Uint32 theVersionIds[]){ + const int word = nodeId >> 3; + const int shift = (nodeId & 7) << 2; + + const Uint32 mask = ~(((Uint32)15) << shift); + const Uint32 tmp = theVersionIds[word]; + + theVersionIds[word] = (tmp & mask) | ((((Uint32)versionId) & 15) << shift); +} + +inline +Uint8 +ReadNodesConf::getVersionId(NodeId nodeId, const Uint32 theVersionIds[]){ + const int word = nodeId >> 3; + const int shift = (nodeId & 7) << 2; + + return (theVersionIds[word] >> shift) & 15; +} + +#endif diff --git a/ndb/include/kernel/signaldata/RelTabMem.hpp b/ndb/include/kernel/signaldata/RelTabMem.hpp new file mode 100644 index 00000000000..9cf1787bba4 --- /dev/null +++ b/ndb/include/kernel/signaldata/RelTabMem.hpp @@ -0,0 +1,69 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef REL_TABMEM_HPP +#define REL_TABMEM_HPP + +#include "SignalData.hpp" + +class RelTabMemReq { + /** + * Sender(s) and Receiver(s) + */ + friend class Dbdict; + + /** + * Receiver(s) + */ + friend class Dbacc; + friend class Dbdih; + friend class Dblqh; + friend class Dbtc; + friend class Dbtup; +public: + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 userPtr; + Uint32 userRef; + Uint32 primaryTableId; + Uint32 secondaryTableId; +}; + +class RelTabMemConf { + /** + * Sender(s) and Receiver(s) + */ + friend class Dbdict; + + /** + * Sender(s) + */ + friend class Dbacc; + friend class Dbdih; + friend class Dblqh; + friend class Dbtc; + friend class Dbtup; +public: + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 userPtr; + Uint32 senderRef; + Uint32 nodeId; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/RepImpl.hpp b/ndb/include/kernel/signaldata/RepImpl.hpp new file mode 100644 index 00000000000..affffe46f9c --- /dev/null +++ b/ndb/include/kernel/signaldata/RepImpl.hpp @@ -0,0 +1,500 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef REP_IMPL_HPP +#define REP_IMPL_HPP + +#include "SignalData.hpp" +#include +#include +#include + +/** + * RecordType + * sz = no of elems in enum + * @todo support for meta_log must be added + */ +enum RecordType +{ + DATA_SCAN = 0, + DATA_LOG = 1, + META_SCAN = 2, + // META_LOG = 3, //removed META_LOG. not supported + RecordTypeSize = 3 // =4 if meta log is supported +}; + +/** + * Wait GCP + */ +class RepWaitGcpReq +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + friend class GrepParticipant; + friend bool printREP_WAITGCP_REQ(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 5 ); + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 gcp; + Uint32 senderNodeId; +}; + +class RepWaitGcpConf +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + friend class GrepParticipant; + + friend bool printREP_WAITGCP_CONF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 5 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 senderNodeId; +}; + +class RepWaitGcpRef +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + friend class GrepParticipant; + + friend bool printREP_WAITGCP_REF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 6 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 senderNodeId; + GrepError::Code err; +}; + +class RepGetGciReq +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + friend class Grep; + + friend bool printREP_GET_GCI_REQ(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 3 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 nodeGrp; +}; + +class RepGetGciConf +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_GET_GCI_CONF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 7 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 nodeGrp; + Uint32 firstPSGCI; + Uint32 lastPSGCI; + Uint32 firstSSGCI; + Uint32 lastSSGCI; +}; + +class RepGetGciRef +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_GET_GCI_REF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 8); + Uint32 senderData; + Uint32 senderRef; + Uint32 nodeGrp; + Uint32 firstPSGCI; + Uint32 lastPSGCI; + Uint32 firstSSGCI; + Uint32 lastSSGCI; + GrepError::Code err; +}; + +class RepGetGciBufferReq { + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_GET_GCIBUFFER_REQ(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + Uint32 senderRef; + Uint32 senderData; + Uint32 firstGCI; + Uint32 lastGCI; + Uint32 nodeGrp; +}; + + +class RepGetGciBufferConf { + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_GET_GCIBUFFER_CONF(FILE *, const Uint32 *, + Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 8 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 firstPSGCI; + Uint32 lastPSGCI; + Uint32 firstSSGCI; + Uint32 lastSSGCI; + Uint32 currentGCIBuffer; + Uint32 nodeGrp; +}; + +class RepGetGciBufferRef +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_GET_GCIBUFFER_REF(FILE *, const Uint32 *, + Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 9 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 firstPSGCI; + Uint32 lastPSGCI; + Uint32 firstSSGCI; + Uint32 lastSSGCI; + Uint32 currentGCIBuffer; + Uint32 nodeGrp; + GrepError::Code err; +}; + +class RepInsertGciBufferReq +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_INSERT_GCIBUFFER_REQ(FILE *, const Uint32 *, + Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 5 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 gci; + Uint32 nodeGrp; + Uint32 force; +}; + +class RepInsertGciBufferRef +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_INSERT_GCIBUFFER_REF(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 7 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 gci; + Uint32 nodeGrp; + Uint32 tableId; + Uint32 force; + GrepError::Code err; +}; + +class RepInsertGciBufferConf +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_INSERT_GCIBUFFER_CONF(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 gci; + Uint32 nodeGrp; + Uint32 force; +}; + + +class RepClearPSGciBufferReq +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_CLEAR_PS_GCIBUFFER_REQ(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 firstGCI; + Uint32 lastGCI; + Uint32 nodeGrp; +}; + +class RepClearPSGciBufferRef +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_CLEAR_PS_GCIBUFFER_REF(FILE *, const Uint32 *, + Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 7 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 firstGCI; + Uint32 lastGCI; + Uint32 currentGCI; + Uint32 nodeGrp; + GrepError::Code err; +}; + +class RepClearPSGciBufferConf +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_CLEAR_PS_GCIBUFFER_CONF(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 firstGCI; + Uint32 lastGCI; + Uint32 nodeGrp; +}; + +class RepClearSSGciBufferReq +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_CLEAR_SS_GCIBUFFER_REQ(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 firstGCI; + Uint32 lastGCI; + Uint32 nodeGrp; +}; + +class RepClearSSGciBufferRef +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_CLEAR_SS_GCIBUFFER_REF(FILE *, const Uint32 *, + Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 7 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 firstGCI; + Uint32 lastGCI; + Uint32 currentGCI; + Uint32 nodeGrp; + GrepError::Code err; +}; + +class RepClearSSGciBufferConf +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_CLEAR_SS_GCIBUFFER_CONF(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 firstGCI; + Uint32 lastGCI; + Uint32 nodeGrp; +}; + + +class RepDataPage +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_DATA_PAGE(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 4 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 nodeGrp; + Uint32 gci; +}; + + +class RepGciBufferAccRep +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_GCIBUFFER_ACC_REP(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 nodeGrp; + Uint32 gci; + Uint32 totalSentBytes; +}; + +class RepDropTableReq +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_DROP_TABLE_REQ(FILE *, const Uint32 *, + Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 4 ); + Uint32 tableId; + // char tableName[MAX_TAB_NAME_SIZE]; +}; + +class RepDropTableRef +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_DROP_TABLE_REF(FILE *, const Uint32 *, + Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 4 ); + Uint32 tableId; + // char tableName[MAX_TAB_NAME_SIZE]; +}; + +class RepDropTableConf +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + + friend bool printREP_DROP_TABLE_CONF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 4 ); + Uint32 tableId; + //char tableName[MAX_TAB_NAME_SIZE]; +}; + +class RepDisconnectRep +{ + /** + * Sender(s)/Reciver(s) + */ + friend class Rep; + friend class Grep; + + friend bool printREP_DISCONNECT_REP(FILE *, const Uint32 *, Uint32, Uint16); + +public: + enum NodeType { + DB = 0, + REP = 1 + }; + STATIC_CONST( SignalLength = 7 ); + Uint32 senderData; + Uint32 senderRef; + Uint32 nodeId; + Uint32 nodeType; + Uint32 subId; + Uint32 subKey; + Uint32 err; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/ResumeReq.hpp b/ndb/include/kernel/signaldata/ResumeReq.hpp new file mode 100644 index 00000000000..a4880474ca8 --- /dev/null +++ b/ndb/include/kernel/signaldata/ResumeReq.hpp @@ -0,0 +1,69 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef RESUME_REQ_HPP +#define RESUME_REQ_HPP + +#include "SignalData.hpp" + +class ResumeReq { + + /** + * Reciver(s) + */ + friend class Ndbcntr; + + /** + * Sender + */ + friend class MgmtSrvr; + +public: + STATIC_CONST( SignalLength = 2 ); + +public: + + Uint32 senderRef; + Uint32 senderData; +}; + +class ResumeRef { + + /** + * Reciver(s) + */ + friend class MgmtSrvr; + + /** + * Sender + */ + friend class Ndbcntr; + +public: + STATIC_CONST( SignalLength = 2 ); + + enum ErrorCode { + OK = 0, + NodeShutdownInProgress = 1, + SystemShutdownInProgress = 2, + NodeShutdownWouldCauseSystemCrash = 3 + }; + +public: + Uint32 senderData; + Uint32 errorCode; +}; +#endif diff --git a/ndb/include/kernel/signaldata/ScanFrag.hpp b/ndb/include/kernel/signaldata/ScanFrag.hpp new file mode 100644 index 00000000000..65ab6f7e411 --- /dev/null +++ b/ndb/include/kernel/signaldata/ScanFrag.hpp @@ -0,0 +1,325 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SCAN_FRAG_HPP +#define SCAN_FRAG_HPP + +#include "SignalData.hpp" +#include "ndb_limits.h" + +class ScanFragReq { + /** + * Sender(s) + */ + friend class Dbtc; + friend class Backup; + friend class Suma; + + /** + * Reciver(s) + */ + friend class Dblqh; +public: + STATIC_CONST( SignalLength = 25 ); + +public: + Uint32 senderData; + Uint32 resultRef; // Where to send the result + Uint32 savePointId; + Uint32 requestInfo; + Uint32 tableId; + Uint32 fragmentNo; + Uint32 schemaVersion; + Uint32 transId1; + Uint32 transId2; + Uint32 clientOpPtr[MAX_PARALLEL_OP_PER_SCAN]; + + static Uint32 getConcurrency(const Uint32 & requestInfo); + static Uint32 getLockMode(const Uint32 & requestInfo); + static Uint32 getHoldLockFlag(const Uint32 & requestInfo); + static Uint32 getKeyinfoFlag(const Uint32 & requestInfo); + static Uint32 getReadCommittedFlag(const Uint32 & requestInfo); + static Uint32 getRangeScanFlag(const Uint32 & requestInfo); + static Uint32 getAttrLen(const Uint32 & requestInfo); + + static void setConcurrency(Uint32 & requestInfo, Uint32 concurrency); + static void setLockMode(Uint32 & requestInfo, Uint32 lockMode); + static void setHoldLockFlag(Uint32 & requestInfo, Uint32 holdLock); + static void setKeyinfoFlag(Uint32 & requestInfo, Uint32 keyinfo); + static void setReadCommittedFlag(Uint32 & requestInfo, Uint32 readCommitted); + static void setRangeScanFlag(Uint32 & requestInfo, Uint32 rangeScan); + static void setAttrLen(Uint32 & requestInfo, Uint32 attrLen); +}; + +class KeyInfo20 { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Reciver(s) + */ + friend class Backup; + friend class NdbOperation; + friend class NdbScanReceiver; +public: + //STATIC_CONST( SignalLength = 21 ); + STATIC_CONST( HeaderLength = 5); + STATIC_CONST( DataLength = 20 ); + + + static Uint32 setScanInfo(Uint32 noOfOps, Uint32 scanNo); + static Uint32 getScanNo(Uint32 scanInfo); + static Uint32 getScanOp(Uint32 scanInfo); + +public: + Uint32 clientOpPtr; + Uint32 keyLen; + Uint32 scanInfo_Node; + Uint32 transId1; + Uint32 transId2; + Uint32 keyData[DataLength]; +}; + +class ScanFragConf { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Reciver(s) + */ + friend class Dbtc; + friend class Backup; + friend class Suma; +public: + STATIC_CONST( SignalLength = 21 ); + +public: + Uint32 senderData; + Uint32 completedOps; + Uint32 fragmentCompleted; + Uint32 opReturnDataLen[16]; + Uint32 transId1; + Uint32 transId2; +}; + +class ScanFragRef { + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * Reciver(s) + */ + friend class Dbtc; + friend class Backup; + friend class Suma; +public: + STATIC_CONST( SignalLength = 4 ); +public: + enum ErrorCode { + ZNO_FREE_TC_CONREC_ERROR = 484, + ZTOO_FEW_CONCURRENT_OPERATIONS = 485, + ZTOO_MANY_CONCURRENT_OPERATIONS = 486, + ZSCAN_NO_FRAGMENT_ERROR = 487, + ZTOO_MANY_ACTIVE_SCAN_ERROR = 488, + ZNO_FREE_SCANREC_ERROR = 489, + ZSTANDBY_SCAN_ERROR = 1209, + ZSCAN_BOOK_ACC_OP_ERROR = 1219, + ZUNKNOWN_TRANS_ERROR = 1227 + }; + + Uint32 senderData; + Uint32 transId1; + Uint32 transId2; + Uint32 errorCode; +}; + +/** + * This is part of Scan Fragment protocol + * + * Not to be confused with ScanNextReq in Scan Table protocol + */ +class ScanFragNextReq { + /** + * Sender(s) + */ + friend class Dbtc; + friend class Backup; + friend class Suma; + + /** + * Reciver(s) + */ + friend class Dblqh; + + friend bool printSCANFRAGNEXTREQ(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo); +public: + STATIC_CONST( SignalLength = 4 ); + +public: + Uint32 senderData; + Uint32 closeFlag; + Uint32 transId1; + Uint32 transId2; +}; + +/** + * Request Info + * + * a = Length of attrinfo - 16 Bits (16-31) + * c = Concurrency - 5 Bits (0-4) -> Max 31 + * l = Lock Mode - 1 Bit 5 + * h = Hold lock - 1 Bit 7 + * k = Keyinfo - 1 Bit 8 + * r = read committed - 1 Bit 9 + * x = range scan - 1 Bit 6 + * + * 1111111111222222222233 + * 01234567890123456789012345678901 + * ccccclxhkr aaaaaaaaaaaaaaaa + */ +#define SF_CONCURRENCY_SHIFT (0) +#define SF_CONCURRENCY_MASK (31) + +#define SF_LOCK_MODE_SHIFT (5) +#define SF_LOCK_MODE_MASK (1) + +#define SF_HOLD_LOCK_SHIFT (7) +#define SF_KEYINFO_SHIFT (8) +#define SF_READ_COMMITTED_SHIFT (9) +#define SF_RANGE_SCAN_SHIFT (6) + +#define SF_ATTR_LEN_SHIFT (16) +#define SF_ATTR_LEN_MASK (65535) + +inline +Uint32 +ScanFragReq::getConcurrency(const Uint32 & requestInfo){ + return (requestInfo >> SF_CONCURRENCY_SHIFT) & SF_CONCURRENCY_MASK; +} + +inline +Uint32 +ScanFragReq::getLockMode(const Uint32 & requestInfo){ + return (requestInfo >> SF_LOCK_MODE_SHIFT) & SF_LOCK_MODE_MASK; +} + +inline +Uint32 +ScanFragReq::getHoldLockFlag(const Uint32 & requestInfo){ + return (requestInfo >> SF_HOLD_LOCK_SHIFT) & 1; +} + +inline +Uint32 +ScanFragReq::getKeyinfoFlag(const Uint32 & requestInfo){ + return (requestInfo >> SF_KEYINFO_SHIFT) & 1; +} + +inline +Uint32 +ScanFragReq::getReadCommittedFlag(const Uint32 & requestInfo){ + return (requestInfo >> SF_READ_COMMITTED_SHIFT) & 1; +} + +inline +Uint32 +ScanFragReq::getRangeScanFlag(const Uint32 & requestInfo){ + return (requestInfo >> SF_RANGE_SCAN_SHIFT) & 1; +} + +inline +Uint32 +ScanFragReq::getAttrLen(const Uint32 & requestInfo){ + return (requestInfo >> SF_ATTR_LEN_SHIFT) & SF_ATTR_LEN_MASK; +} + +inline +void +ScanFragReq::setConcurrency(UintR & requestInfo, UintR val){ + ASSERT_MAX(val, SF_CONCURRENCY_MASK, "ScanFragReq::setConcurrency"); + requestInfo |= (val << SF_CONCURRENCY_SHIFT); +} + +inline +void +ScanFragReq::setLockMode(UintR & requestInfo, UintR val){ + ASSERT_MAX(val, SF_LOCK_MODE_MASK, "ScanFragReq::setLockMode"); + requestInfo |= (val << SF_LOCK_MODE_SHIFT); +} + +inline +void +ScanFragReq::setHoldLockFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "ScanFragReq::setHoldLockFlag"); + requestInfo |= (val << SF_HOLD_LOCK_SHIFT); +} + +inline +void +ScanFragReq::setKeyinfoFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "ScanFragReq::setKeyinfoFlag"); + requestInfo |= (val << SF_KEYINFO_SHIFT); +} + +inline +void +ScanFragReq::setReadCommittedFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "ScanFragReq::setReadCommittedFlag"); + requestInfo |= (val << SF_READ_COMMITTED_SHIFT); +} + +inline +void +ScanFragReq::setRangeScanFlag(UintR & requestInfo, UintR val){ + ASSERT_BOOL(val, "ScanFragReq::setRangeScanFlag"); + requestInfo |= (val << SF_RANGE_SCAN_SHIFT); +} + +inline +void +ScanFragReq::setAttrLen(UintR & requestInfo, UintR val){ + ASSERT_MAX(val, SF_ATTR_LEN_MASK, "ScanFragReq::setAttrLen"); + requestInfo |= (val << SF_ATTR_LEN_SHIFT); +} + +inline +Uint32 +KeyInfo20::setScanInfo(Uint32 opNo, Uint32 scanNo){ + ASSERT_MAX(opNo, 15, "KeyInfo20::setScanInfo"); + ASSERT_MAX(scanNo, 255, "KeyInfo20::setScanInfo"); + return (opNo << 8) + scanNo; +} + +inline +Uint32 +KeyInfo20::getScanNo(Uint32 scanInfo){ + return scanInfo & 0xFF; +} + +inline +Uint32 +KeyInfo20::getScanOp(Uint32 scanInfo){ + return (scanInfo >> 8) & 0xF; +} + +#endif diff --git a/ndb/include/kernel/signaldata/ScanTab.hpp b/ndb/include/kernel/signaldata/ScanTab.hpp new file mode 100644 index 00000000000..efd8a4918ab --- /dev/null +++ b/ndb/include/kernel/signaldata/ScanTab.hpp @@ -0,0 +1,453 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SCAN_TAB_H +#define SCAN_TAB_H + +#include "SignalData.hpp" + +/** + * + * SENDER: API + * RECIVER: Dbtc + */ +class ScanTabReq { + /** + * Reciver(s) + */ + friend class Dbtc; // Reciver + + /** + * Sender(s) + */ + friend class NdbOperation; + friend class NdbConnection; + + /** + * For printing + */ + friend bool printSCANTABREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + /** + * Length of signal + */ + STATIC_CONST( SignalLength = 25 ); + +private: + + // Type definitions + + /** + * DATA VARIABLES + */ + UintR apiConnectPtr; // DATA 0 + UintR attrLen; // DATA 1 + UintR requestInfo; // DATA 2 + UintR tableId; // DATA 3 + UintR tableSchemaVersion; // DATA 4 + UintR storedProcId; // DATA 5 + UintR transId1; // DATA 6 + UintR transId2; // DATA 7 + UintR buddyConPtr; // DATA 8 + UintR apiOperationPtr[16]; // DATA 9-25 + + /** + * Get:ers for requestInfo + */ + static Uint8 getParallelism(const UintR & requestInfo); + static Uint8 getLockMode(const UintR & requestInfo); + static Uint8 getHoldLockFlag(const UintR & requestInfo); + static Uint8 getReadCommittedFlag(const UintR & requestInfo); + static Uint8 getRangeScanFlag(const UintR & requestInfo); + + /** + * Set:ers for requestInfo + */ + static void clearRequestInfo(UintR & requestInfo); + static void setParallelism(UintR & requestInfo, Uint32 flag); + static void setLockMode(UintR & requestInfo, Uint32 flag); + static void setHoldLockFlag(UintR & requestInfo, Uint32 flag); + static void setReadCommittedFlag(UintR & requestInfo, Uint32 flag); + static void setRangeScanFlag(UintR & requestInfo, Uint32 flag); + +}; + +/** + * Request Info + * + p = Parallelism - 8 Bits -> Max 256 (Bit 0-7) + l = Lock mode - 1 Bit 8 + h = Hold lock mode - 1 Bit 10 + c = Read Committed - 1 Bit 11 + x = Range Scan (TUX) - 1 Bit 15 + + 1111111111222222222233 + 01234567890123456789012345678901 + ppppppppl hc x +*/ + +#define PARALLELL_SHIFT (0) +#define PARALLELL_MASK (255) + +#define LOCK_MODE_SHIFT (8) +#define LOCK_MODE_MASK (1) + +#define HOLD_LOCK_SHIFT (10) +#define HOLD_LOCK_MASK (1) + +#define READ_COMMITTED_SHIFT (11) +#define READ_COMMITTED_MASK (1) + +#define RANGE_SCAN_SHIFT (15) +#define RANGE_SCAN_MASK (1) + +inline +Uint8 +ScanTabReq::getParallelism(const UintR & requestInfo){ + return (Uint8)((requestInfo >> PARALLELL_SHIFT) & PARALLELL_MASK); +} + +inline +Uint8 +ScanTabReq::getLockMode(const UintR & requestInfo){ + return (Uint8)((requestInfo >> LOCK_MODE_SHIFT) & LOCK_MODE_MASK); +} + +inline +Uint8 +ScanTabReq::getHoldLockFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> HOLD_LOCK_SHIFT) & HOLD_LOCK_MASK); +} + +inline +Uint8 +ScanTabReq::getReadCommittedFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> READ_COMMITTED_SHIFT) & READ_COMMITTED_MASK); +} + +inline +Uint8 +ScanTabReq::getRangeScanFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> RANGE_SCAN_SHIFT) & RANGE_SCAN_MASK); +} + +inline +void +ScanTabReq::clearRequestInfo(UintR & requestInfo){ + requestInfo = 0; +} + +inline +void +ScanTabReq::setParallelism(UintR & requestInfo, Uint32 type){ + ASSERT_MAX(type, PARALLELL_MASK, "ScanTabReq::setParallellism"); + requestInfo |= (type << PARALLELL_SHIFT); +} + +inline +void +ScanTabReq::setLockMode(UintR & requestInfo, Uint32 mode){ + ASSERT_MAX(mode, LOCK_MODE_MASK, "ScanTabReq::setLockMode"); + requestInfo |= (mode << LOCK_MODE_SHIFT); +} + +inline +void +ScanTabReq::setHoldLockFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "ScanTabReq::setHoldLockFlag"); + requestInfo |= (flag << HOLD_LOCK_SHIFT); +} + +inline +void +ScanTabReq::setReadCommittedFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "ScanTabReq::setReadCommittedFlag"); + requestInfo |= (flag << READ_COMMITTED_SHIFT); +} + +inline +void +ScanTabReq::setRangeScanFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "ScanTabReq::setRangeScanFlag"); + requestInfo |= (flag << RANGE_SCAN_SHIFT); +} + + +/** + * + * SENDER: Dbtc + * RECIVER: API + */ +class ScanTabConf { + /** + * Reciver(s) + */ + friend class NdbConnection; // Reciver + + /** + * Sender(s) + */ + friend class Dbtc; + + /** + * For printing + */ + friend bool printSCANTABCONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + /** + * Length of signal + */ + STATIC_CONST( SignalLength = 4 ); + +private: + + // Type definitions + + /** + * DATA VARIABLES + */ + UintR apiConnectPtr; // DATA 0 + UintR requestInfo; // DATA 1 + UintR transId1; // DATA 2 + UintR transId2; // DATA 3 +#if 0 + UintR operLenAndIdx[16]; // DATA 4-19 + + /** + * Get:ers for operLenAndIdx + */ + static Uint32 getLen(const UintR & operLenAndIdx); + static Uint8 getIdx(const UintR & operLenAndIdx); +#endif + + /** + * Get:ers for requestInfo + */ + static Uint8 getOperations(const UintR & reqInfo); + static Uint8 getScanStatus(const UintR & reqInfo); + + /** + * Set:ers for requestInfo + */ + static void setOperations(UintR & reqInfo, Uint32 ops); + static void setScanStatus(UintR & reqInfo, Uint32 stat); + + +}; + +/** + * request info + * + o = received operations - 7 Bits -> Max 255 (Bit 0-7) + s = status of scan - 2 Bits -> Max ??? (Bit 8-?) + + 1111111111222222222233 + 01234567890123456789012345678901 + ooooooooss +*/ + +#define OPERATIONS_SHIFT (0) +#define OPERATIONS_MASK (0xFF) + +#define STATUS_SHIFT (8) +#define STATUS_MASK (0xFF) + +inline +Uint8 +ScanTabConf::getOperations(const UintR & reqInfo){ + return (Uint8)((reqInfo >> OPERATIONS_SHIFT) & OPERATIONS_MASK); +} + +inline +void +ScanTabConf::setOperations(UintR & requestInfo, Uint32 ops){ + ASSERT_MAX(ops, OPERATIONS_MASK, "ScanTabConf::setOperations"); + requestInfo |= (ops << OPERATIONS_SHIFT); +} + +inline +Uint8 +ScanTabConf::getScanStatus(const UintR & reqInfo){ + return (Uint8)((reqInfo >> STATUS_SHIFT) & STATUS_MASK); +} + +inline +void +ScanTabConf::setScanStatus(UintR & requestInfo, Uint32 stat){ + ASSERT_MAX(stat, STATUS_MASK, "ScanTabConf::setScanStatus"); + requestInfo |= (stat << STATUS_SHIFT); +} + + +/** + * + * SENDER: Dbtc, API + * RECIVER: API, Dbtc + */ +class ScanTabInfo { + /** + * Reciver(s) and Sender(s) + */ + friend class NdbConnection; + friend class Dbtc; + + /** + * For printing + */ + friend bool printSCANTABINFO(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + /** + * Length of signal + */ + STATIC_CONST( SignalLength = 17 ); + +private: + + // Type definitions + + /** + * DATA VARIABLES + */ + UintR apiConnectPtr; // DATA 0 + UintR operLenAndIdx[16]; // DATA 1-16 + + /** + * Get:ers for operLenAndIdx + */ + static Uint32 getLen(const UintR & operLenAndIdx); + static Uint8 getIdx(const UintR & operLenAndIdx); + +}; + + +/** + * Operation length and index + * + l = Length of operation - 24 Bits -> Max 16777215 (Bit 0-24) + i = Index of operation - 7 Bits -> Max 255 (Bit 25-32) + + 1111111111222222222233 + 01234567890123456789012345678901 + llllllllllllllllllllllllliiiiiii +*/ + +#define LENGTH_SHIFT (0) +#define LENGTH_MASK (0xFFFFFF) + +#define INDEX_SHIFT (24) +#define INDEX_MASK (0xFF) + +inline +Uint32 +ScanTabInfo::getLen(const UintR & operLenAndIdx){ + return (Uint32)((operLenAndIdx >> LENGTH_SHIFT) & LENGTH_MASK); +} + +inline +Uint8 +ScanTabInfo::getIdx(const UintR & operLenAndIdx){ + return (Uint8)((operLenAndIdx >> INDEX_SHIFT) & INDEX_MASK); +} + +/** + * + * SENDER: Dbtc + * RECIVER: API + */ +class ScanTabRef { + /** + * Reciver(s) + */ + friend class NdbConnection; // Reciver + + /** + * Sender(s) + */ + friend class Dbtc; + + /** + * For printing + */ + friend bool printSCANTABREF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + /** + * Length of signal + */ + STATIC_CONST( SignalLength = 4 ); + +private: + + // Type definitions + + /** + * DATA VARIABLES + */ + UintR apiConnectPtr; // DATA 0 + UintR transId1; // DATA 1 + UintR transId2; // DATA 2 + UintR errorCode; // DATA 3 + // UintR sendScanNextReqWithClose; // DATA 4 + +}; + +/** + * + * SENDER: API + * RECIVER: Dbtc + */ +class ScanNextReq { + /** + * Reciver(s) + */ + friend class Dbtc; // Reciver + + /** + * Sender(s) + */ + friend class NdbOperation; + + /** + * For printing + */ + friend bool printSCANNEXTREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + /** + * Length of signal + */ + STATIC_CONST( SignalLength = 4 ); + +private: + + // Type definitions + + /** + * DATA VARIABLES + */ + UintR apiConnectPtr; // DATA 0 + UintR stopScan; // DATA 1 + UintR transId1; // DATA 2 + UintR transId2; // DATA 3 + + // stopScan = 1, stop this scan + +}; + +#endif diff --git a/ndb/include/kernel/signaldata/SetLogLevelOrd.hpp b/ndb/include/kernel/signaldata/SetLogLevelOrd.hpp new file mode 100644 index 00000000000..680e9b25a49 --- /dev/null +++ b/ndb/include/kernel/signaldata/SetLogLevelOrd.hpp @@ -0,0 +1,70 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SET_LOGLEVEL_ORD_HPP +#define SET_LOGLEVEL_ORD_HPP + +#include + +/** + * + */ +class SetLogLevelOrd { + /** + * Sender(s) + */ + friend class MgmtSrvr; /* XXX can probably be removed */ + friend class MgmApiSession; + friend class CommandInterpreter; + + /** + * Reciver(s) + */ + friend class Cmvmi; + + friend class NodeLogLevel; + +private: + STATIC_CONST( SignalLength = 25 ); + + Uint32 noOfEntries; + Uint32 theCategories[12]; + Uint32 theLevels[12]; + + void clear(); + + /** + * Note level is valid as 0-15 + */ + void setLogLevel(LogLevel::EventCategory ec, int level = 7); +}; + +inline +void +SetLogLevelOrd::clear(){ + noOfEntries = 0; +} + +inline +void +SetLogLevelOrd::setLogLevel(LogLevel::EventCategory ec, int level){ + assert(noOfEntries < 12); + theCategories[noOfEntries] = ec; + theLevels[noOfEntries] = level; + noOfEntries++; +} + +#endif diff --git a/ndb/include/kernel/signaldata/SetVarReq.hpp b/ndb/include/kernel/signaldata/SetVarReq.hpp new file mode 100644 index 00000000000..8cb3e78be8b --- /dev/null +++ b/ndb/include/kernel/signaldata/SetVarReq.hpp @@ -0,0 +1,84 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SETVARREQ_H +#define SETVARREQ_H + +#include "SignalData.hpp" +#include "ConfigParamId.hpp" + +class SetVarReq { + +public: + + + static UintR size(); + + void mgmtSrvrBlockRef(UintR mgmtSrvrBlockRef); + UintR mgmtSrvrBlockRef(void) const; + + void variable(ConfigParamId variable); + ConfigParamId variable(void) const; + + void value(UintR value); + UintR value(void) const; + + +private: + + UintR _mgmtSrvrBlockRef; + UintR _variable; + UintR _value; +}; + + + +inline UintR SetVarReq::size(void) { + return 3; +} + + +inline void SetVarReq::mgmtSrvrBlockRef(UintR mgmtSrvrBlockRef) { + _mgmtSrvrBlockRef = mgmtSrvrBlockRef; +} + +inline UintR SetVarReq::mgmtSrvrBlockRef(void) const { + return _mgmtSrvrBlockRef; +} + + +inline void SetVarReq::variable(ConfigParamId variable) { + _variable = variable; +} + + +inline ConfigParamId SetVarReq::variable(void) const { + return static_cast(_variable); +} + + +inline void SetVarReq::value(UintR value) { + _value = value; +} + +inline UintR SetVarReq::value(void) const { + return _value; +} + + + +#endif // SETVARREQ_H + diff --git a/ndb/include/kernel/signaldata/SignalData.hpp b/ndb/include/kernel/signaldata/SignalData.hpp new file mode 100644 index 00000000000..071bd9b9104 --- /dev/null +++ b/ndb/include/kernel/signaldata/SignalData.hpp @@ -0,0 +1,65 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SIGNAL_DATA_H +#define SIGNAL_DATA_H + +#include +#include +#include +#include +#include + +#ifndef NDB_ASSERT +#ifdef VM_TRACE +#define NDB_ASSERT(test, message) { if(!(test)) { printf(message); exit(-1); }} +#else +#define NDB_ASSERT(test, message) +#endif +#endif + +// Useful ASSERT macros... +#define ASSERT_BOOL(flag, message) NDB_ASSERT( (flag<=1), (message) ) +#define ASSERT_RANGE(value, min, max, message) \ + NDB_ASSERT((value) >= (min) && (value) <= (max), (message)) +#define ASSERT_MAX(value, max, message) \ + NDB_ASSERT((value) <= (max), (message)) + +#define SECTION(x) STATIC_CONST(x) + +// defines for setter and getters on commonly used member data in signals + +#define GET_SET_SENDERDATA \ + Uint32 getSenderData() { return senderData; }; \ + void setSenderData(Uint32 _s) { senderData = _s; }; + +#define GET_SET_SENDERREF \ + Uint32 getSenderRef() { return senderRef; }; \ + void setSenderRef(Uint32 _s) { senderRef = _s; }; + +#define GET_SET_PREPAREID \ + Uint32 getPrepareId() { return prepareId; }; \ + void setPrepareId(Uint32 _s) { prepareId = _s; }; + +#define GET_SET_ERRORCODE \ + Uint32 getErrorCode() { return errorCode; }; \ + void setErrorCode(Uint32 _s) { errorCode = _s; }; + +#define GET_SET_TCERRORCODE \ + Uint32 getTCErrorCode() { return TCErrorCode; }; \ + void setTCErrorCode(Uint32 _s) { TCErrorCode = _s; }; + +#endif diff --git a/ndb/include/kernel/signaldata/SignalDataPrint.hpp b/ndb/include/kernel/signaldata/SignalDataPrint.hpp new file mode 100644 index 00000000000..588e2893214 --- /dev/null +++ b/ndb/include/kernel/signaldata/SignalDataPrint.hpp @@ -0,0 +1,36 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SIGNAL_DATA_PRINT_H +#define SIGNAL_DATA_PRINT_H + +#include +#include + +/** + * Typedef for a Signal Data Print Function + */ +typedef bool (* SignalDataPrintFunction)(FILE * output, const Uint32 * theData, Uint32 len, BlockNumber receiverBlockNo); + +struct NameFunctionPair { + GlobalSignalNumber gsn; + SignalDataPrintFunction function; +}; + +extern const NameFunctionPair SignalDataPrintFunctions[]; +extern const unsigned short NO_OF_PRINT_FUNCTIONS; + +#endif diff --git a/ndb/include/kernel/signaldata/SignalDroppedRep.hpp b/ndb/include/kernel/signaldata/SignalDroppedRep.hpp new file mode 100644 index 00000000000..20863524358 --- /dev/null +++ b/ndb/include/kernel/signaldata/SignalDroppedRep.hpp @@ -0,0 +1,44 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SIGNAL_DROPPED_HPP +#define SIGNAL_DROPPED_HPP + +#include "SignalData.hpp" + +class SignalDroppedRep { + + /** + * Reciver(s) + */ + friend class SimulatedBlock; + + /** + * Sender (TransporterCallback.cpp) + */ + friend void execute(void * , struct SignalHeader* const, Uint8, + Uint32* const, struct LinearSectionPtr ptr[3]); + + friend bool printSIGNAL_DROPPED_REP(FILE *, const Uint32 *, Uint32, Uint16); +public: +private: + Uint32 originalGsn; + Uint32 originalLength; + Uint32 originalSectionCount; + Uint32 originalData[1]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/SrFragidConf.hpp b/ndb/include/kernel/signaldata/SrFragidConf.hpp new file mode 100644 index 00000000000..9a6088ad57f --- /dev/null +++ b/ndb/include/kernel/signaldata/SrFragidConf.hpp @@ -0,0 +1,43 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SR_FRAGIDCONF_HPP +#define SR_FRAGIDCONF_HPP + +#include "SignalData.hpp" + +class SrFragidConf { + /** + * Sender(s) + */ + friend class Dbacc; + + /** + * Receiver(s) + */ + friend class Dblqh; +public: + STATIC_CONST( SignalLength = 10 ); + +private: + Uint32 lcpPtr; + Uint32 accPtr; + Uint32 noLocFrag; + Uint32 fragId[4]; + Uint32 fragPtr[2]; + Uint32 hashCheckBit; +}; +#endif diff --git a/ndb/include/kernel/signaldata/StartFragReq.hpp b/ndb/include/kernel/signaldata/StartFragReq.hpp new file mode 100644 index 00000000000..ec05c1ee366 --- /dev/null +++ b/ndb/include/kernel/signaldata/StartFragReq.hpp @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef START_FRAGREQ_HPP +#define START_FRAGREQ_HPP + +#include "SignalData.hpp" + +class StartFragReq { + /** + * Sender(s) + */ + friend class Dbdih; + + /** + * Receiver(s) + */ + friend class Dblqh; +public: + STATIC_CONST( SignalLength = 19 ); + +private: + Uint32 userPtr; + Uint32 userRef; + Uint32 lcpNo; + Uint32 lcpId; + Uint32 tableId; + Uint32 fragId; + Uint32 noOfLogNodes; + Uint32 lqhLogNode[4]; + Uint32 startGci[4]; + Uint32 lastGci[4]; +}; +#endif diff --git a/ndb/include/kernel/signaldata/StartInfo.hpp b/ndb/include/kernel/signaldata/StartInfo.hpp new file mode 100644 index 00000000000..da032adba8a --- /dev/null +++ b/ndb/include/kernel/signaldata/StartInfo.hpp @@ -0,0 +1,84 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef START_INFO_HPP +#define START_INFO_HPP + +/** + * This signal is sent from the master DIH to all DIHs + * when a node is starting. + * If the typeStart is initial node restart then the node + * has started without filesystem. + * All DIHs must then "forget" that the starting node has + * performed LCP's ever. + * + * @see StartPermReq + */ + +class StartInfoReq { + /** + * Sender/Receiver + */ + friend class Dbdih; + + Uint32 startingNodeId; + Uint32 typeStart; + Uint32 systemFailureNo; + +public: + STATIC_CONST( SignalLength = 3 ); +}; + +class StartInfoConf { + + /** + * Sender/Receiver + */ + friend class Dbdih; + + /** + * NodeId of sending node + * which is "done" + */ + Uint32 sendingNodeId; + Uint32 startingNodeId; + +public: + STATIC_CONST( SignalLength = 2 ); +}; + +class StartInfoRef { + + /** + * Sender/Receiver + */ + friend class Dbdih; + + /** + * NodeId of sending node + * The node was refused to start. This could be + * because there are still processes handling + * previous information from the starting node. + */ + Uint32 sendingNodeId; + Uint32 startingNodeId; + Uint32 errorCode; + +public: + STATIC_CONST( SignalLength = 2 ); +}; + +#endif diff --git a/ndb/include/kernel/signaldata/StartMe.hpp b/ndb/include/kernel/signaldata/StartMe.hpp new file mode 100644 index 00000000000..6593a9e9741 --- /dev/null +++ b/ndb/include/kernel/signaldata/StartMe.hpp @@ -0,0 +1,63 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef START_ME_HPP +#define START_ME_HPP + +/** + * This signal is sent... + * + * It also contains the Sysfile. + * Since the Sysfile can be larger than on StartMeConf signal, + * there might be more than on of these signals sent before + * the entire sysfile is transfered + * + */ +class StartMeReq { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 2 ); +private: + + Uint32 startingRef; + Uint32 startingVersion; +}; + +class StartMeConf { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 25 ); +private: + + Uint32 startingNodeId; + Uint32 startWord; + + /** + * No of free words to carry data + */ + STATIC_CONST( DATA_SIZE = 23 ); + + Uint32 data[DATA_SIZE]; +}; +#endif diff --git a/ndb/include/kernel/signaldata/StartOrd.hpp b/ndb/include/kernel/signaldata/StartOrd.hpp new file mode 100644 index 00000000000..43a48f70ba9 --- /dev/null +++ b/ndb/include/kernel/signaldata/StartOrd.hpp @@ -0,0 +1,48 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef START_ORD_HPP +#define START_ORD_HPP + +#include "SignalData.hpp" +#include "StopReq.hpp" + +class StartOrd { +public: + /** + * Senders + */ + friend class ThreadConfig; + friend class MgmtSrvr; + friend class Ndbcntr; + + /** + * Receivers + */ + friend class SimBlockCMCtrBlck; + + /** + * RequestInfo - See StopReq for getters/setters + */ + Uint32 restartInfo; + +public: + STATIC_CONST( SignalLength = 1 ); +}; + + +#endif + diff --git a/ndb/include/kernel/signaldata/StartPerm.hpp b/ndb/include/kernel/signaldata/StartPerm.hpp new file mode 100644 index 00000000000..38be72835a3 --- /dev/null +++ b/ndb/include/kernel/signaldata/StartPerm.hpp @@ -0,0 +1,68 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef START_PERM_REQ_HPP +#define START_PERM_REQ_HPP + +/** + * This signal is sent by starting DIH to master DIH + * + * Used when starting in an already started cluster + * + */ +class StartPermReq { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 3 ); +private: + + Uint32 blockRef; + Uint32 nodeId; + Uint32 startType; +}; + +class StartPermConf { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 2 ); +private: + + Uint32 startingNodeId; + Uint32 systemFailureNo; +}; + +class StartPermRef { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 2 ); +private: + + Uint32 startingNodeId; + Uint32 errorCode; +}; +#endif diff --git a/ndb/include/kernel/signaldata/StartRec.hpp b/ndb/include/kernel/signaldata/StartRec.hpp new file mode 100644 index 00000000000..f8a4e01a094 --- /dev/null +++ b/ndb/include/kernel/signaldata/StartRec.hpp @@ -0,0 +1,61 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef START_REC_HPP +#define START_REC_HPP + +#include "SignalData.hpp" + +class StartRecReq { + /** + * Sender(s) + */ + friend class Dbdih; + /** + * Receiver(s) + */ + friend class Dblqh; + + friend bool printSTART_REC_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); +private: + + Uint32 receivingNodeId; + Uint32 senderRef; + Uint32 keepGci; + Uint32 lastCompletedGci; + Uint32 newestGci; +}; + +class StartRecConf { + /** + * Sender(s) + */ + friend class Dblqh; + /** + * Receiver(s) + */ + friend class Dbdih; + + friend bool printSTART_REC_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 1 ); +private: + + Uint32 startingNodeId; +}; +#endif diff --git a/ndb/include/kernel/signaldata/StartTo.hpp b/ndb/include/kernel/signaldata/StartTo.hpp new file mode 100644 index 00000000000..5aecef6275d --- /dev/null +++ b/ndb/include/kernel/signaldata/StartTo.hpp @@ -0,0 +1,50 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef START_TO_HPP +#define START_TO_HPP + +class StartToReq { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 5 ); +private: + Uint32 userPtr; + BlockReference userRef; + Uint32 startingNodeId; + Uint32 nodeTakenOver; + bool nodeRestart; +}; + +class StartToConf { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 3 ); +private: + + Uint32 userPtr; + Uint32 sendingNodeId; + Uint32 startingNodeId; +}; +#endif diff --git a/ndb/include/kernel/signaldata/StopMe.hpp b/ndb/include/kernel/signaldata/StopMe.hpp new file mode 100644 index 00000000000..51d944a3b96 --- /dev/null +++ b/ndb/include/kernel/signaldata/StopMe.hpp @@ -0,0 +1,70 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef STOP_ME_HPP +#define STOP_ME_HPP + +/** + * This signal is sent by ndbcntr to local DIH + * + * If local DIH then sends it to all DIH's + * + * @see StopPermReq + * @see StartMeReq + * @see StartPermReq + */ +class StopMeReq { + + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + + /** + * Sender + */ + friend class Ndbcntr; + +public: + STATIC_CONST( SignalLength = 2 ); +private: + + Uint32 senderRef; + Uint32 senderData; +}; + +class StopMeConf { + + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + + /** + * Reciver(s) + */ + friend class Ndbcntr; + +public: + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 senderRef; + Uint32 senderData; +}; + + +#endif diff --git a/ndb/include/kernel/signaldata/StopPerm.hpp b/ndb/include/kernel/signaldata/StopPerm.hpp new file mode 100644 index 00000000000..95fb82c8cde --- /dev/null +++ b/ndb/include/kernel/signaldata/StopPerm.hpp @@ -0,0 +1,96 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef STOP_PERM_HPP +#define STOP_PERM_HPP + +/** + * This signal is sent by ndbcntr to local DIH + * + * If local DIH is not master, it forwards it to master DIH + * and start acting as a proxy + * + * @see StopMeReq + * @see StartMeReq + * @see StartPermReq + */ +class StopPermReq { + + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + + /** + * Sender + */ + friend class Ndbcntr; + +public: + STATIC_CONST( SignalLength = 2 ); +public: + + Uint32 senderRef; + Uint32 senderData; +}; + +class StopPermConf { + + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + + /** + * Reciver(s) + */ + friend class Ndbcntr; + +public: + STATIC_CONST( SignalLength = 1 ); + +private: + Uint32 senderData; +}; + +class StopPermRef { + + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + + /** + * Reciver(s) + */ + friend class Ndbcntr; + +public: + STATIC_CONST( SignalLength = 2 ); + + enum ErrorCode { + StopOK = 0, + NodeStartInProgress = 1, + NodeShutdownInProgress = 2, + NF_CausedAbortOfStopProcedure = 3 + }; + +private: + Uint32 errorCode; + Uint32 senderData; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/StopReq.hpp b/ndb/include/kernel/signaldata/StopReq.hpp new file mode 100644 index 00000000000..ea453ae115d --- /dev/null +++ b/ndb/include/kernel/signaldata/StopReq.hpp @@ -0,0 +1,202 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef STOP_REQ_HPP +#define STOP_REQ_HPP + +#include "SignalData.hpp" + +class StopReq +{ + /** + * Reciver(s) + */ + friend class Ndbcntr; + + /** + * Sender + */ + friend class MgmtSrvr; + +public: + STATIC_CONST( SignalLength = 9 ); + +public: + Uint32 senderRef; + Uint32 senderData; + + Uint32 requestInfo; + Uint32 singleuser; // Indicates whether or not to enter + // single user mode. + // Only in conjunction with system stop + Uint32 singleUserApi; // allowed api in singleuser + + Int32 apiTimeout; // Timeout before api transactions are refused + Int32 transactionTimeout; // Timeout before transactions are aborted + Int32 readOperationTimeout; // Timeout before read operations are aborted + Int32 operationTimeout; // Timeout before all operations are aborted + + static void setSystemStop(Uint32 & requestInfo, bool value); + static void setPerformRestart(Uint32 & requestInfo, bool value); + static void setNoStart(Uint32 & requestInfo, bool value); + static void setInitialStart(Uint32 & requestInfo, bool value); + static void setEscalateOnNodeFail(Uint32 & requestInfo, bool value); + /** + * Don't perform "graceful" shutdown/restart... + */ + static void setStopAbort(Uint32 & requestInfo, bool value); + + static bool getSystemStop(const Uint32 & requestInfo); + static bool getPerformRestart(const Uint32 & requestInfo); + static bool getNoStart(const Uint32 & requestInfo); + static bool getInitialStart(const Uint32 & requestInfo); + static bool getEscalateOnNodeFail(const Uint32 & requestInfo); + static bool getStopAbort(const Uint32 & requestInfo); +}; + +class StopRef +{ + /** + * Reciver(s) + */ + friend class MgmtSrvr; + + /** + * Sender + */ + friend class Ndbcntr; + +public: + STATIC_CONST( SignalLength = 2 ); + + enum ErrorCode { + OK = 0, + NodeShutdownInProgress = 1, + SystemShutdownInProgress = 2, + NodeShutdownWouldCauseSystemCrash = 3 + }; + +public: + Uint32 senderData; + Uint32 errorCode; +}; + +inline +bool +StopReq::getSystemStop(const Uint32 & requestInfo) +{ + return requestInfo & 1; +} + +inline +bool +StopReq::getPerformRestart(const Uint32 & requestInfo) +{ + return requestInfo & 2; +} + +inline +bool +StopReq::getNoStart(const Uint32 & requestInfo) +{ + return requestInfo & 4; +} + +inline +bool +StopReq::getInitialStart(const Uint32 & requestInfo) +{ + return requestInfo & 8; +} + +inline +bool +StopReq::getEscalateOnNodeFail(const Uint32 & requestInfo) +{ + return requestInfo & 16; +} + +inline +bool +StopReq::getStopAbort(const Uint32 & requestInfo) +{ + return requestInfo & 32; +} + + +inline +void +StopReq::setSystemStop(Uint32 & requestInfo, bool value) +{ + if(value) + requestInfo |= 1; + else + requestInfo &= ~1; +} + +inline +void +StopReq::setPerformRestart(Uint32 & requestInfo, bool value) +{ + if(value) + requestInfo |= 2; + else + requestInfo &= ~2; +} + +inline +void +StopReq::setNoStart(Uint32 & requestInfo, bool value) +{ + if(value) + requestInfo |= 4; + else + requestInfo &= ~4; +} + +inline +void +StopReq::setInitialStart(Uint32 & requestInfo, bool value) +{ + if(value) + requestInfo |= 8; + else + requestInfo &= ~8; +} + +inline +void +StopReq::setEscalateOnNodeFail(Uint32 & requestInfo, bool value) +{ + if(value) + requestInfo |= 16; + else + requestInfo &= ~16; +} + +inline +void +StopReq::setStopAbort(Uint32 & requestInfo, bool value) +{ + if(value) + requestInfo |= 32; + else + requestInfo &= ~32; +} + + +#endif + diff --git a/ndb/include/kernel/signaldata/SumaImpl.hpp b/ndb/include/kernel/signaldata/SumaImpl.hpp new file mode 100644 index 00000000000..089132cd9aa --- /dev/null +++ b/ndb/include/kernel/signaldata/SumaImpl.hpp @@ -0,0 +1,619 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SUMA_IMPL_HPP +#define SUMA_IMPL_HPP + +#include "SignalData.hpp" +#include + + +class SubCreateReq { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + friend class SumaParticipant; + + friend bool printSUB_CREATE_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + + enum SubscriptionType { + SingleTableScan = 1, // + DatabaseSnapshot = 2, // All tables/all data (including new ones) + TableEvent = 3, // + SelectiveTableSnapshot = 4, // User defines tables + RemoveFlags = 0xff, + GetFlags = 0xff << 16, + AddTableFlag = 0x1 << 16, + RestartFlag = 0x2 << 16 + }; + + Uint32 subscriberRef; + Uint32 subscriberData; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 subscriptionType; + union { + Uint32 tableId; // Used when doing SingelTableScan + }; + SECTION( ATTRIBUTE_LIST = 0); // Used when doing SingelTableScan + SECTION( TABLE_LIST = 1 ); + +}; + +class SubCreateRef { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + friend class SumaParticipant; + + friend bool printSUB_CREATE_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 6 ); + + Uint32 subscriberRef; + Uint32 subscriberData; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 subscriptionType; + Uint32 err; + + SECTION( ATTRIBUTE_LIST = 0); // Used when doing SingelTableScan + union { + Uint32 tableId; // Used when doing SingelTableScan + }; +}; + +class SubCreateConf { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + friend class SumaParticipant; + + friend bool printSUB_CREATE_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + + Uint32 subscriberData; + Uint32 subscriptionId; + Uint32 subscriptionKey; +}; + +class SubscriptionData { +public: + enum Part { + MetaData = 1, + TableData = 2 + }; +}; + +class SubStartReq { + /** + * Sender(s)/Reciver(s) + */ + friend class Suma; + + friend bool printSUB_START_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 6 ); + STATIC_CONST( SignalLength2 = SignalLength+1 ); + + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 part; // SubscriptionData::Part + Uint32 subscriberData; + Uint32 subscriberRef; +}; + +class SubStartRef { + /** + * Sender(s)/Reciver(s) + */ + friend class Suma; + + friend bool printSUB_START_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + enum ErrorCode { + Undefined = 0, + NF_FakeErrorREF = 11, + Busy = 701, + Temporary = 0x1 << 16 + }; + bool isTemporary() const; + void setTemporary(); + ErrorCode setTemporary(ErrorCode ec); + + STATIC_CONST( SignalLength = 7 ); + STATIC_CONST( SignalLength2 = SignalLength+1 ); + + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 part; // SubscriptionData::Part + Uint32 subscriberData; + union { // do not change the order here! + Uint32 err; + Uint32 errorCode; + }; + // with SignalLength2 + Uint32 subscriberRef; +}; +inline bool SubStartRef::isTemporary() const +{ return (errorCode & SubStartRef::Temporary) > 0; }; +inline void SubStartRef::setTemporary() +{ errorCode |= SubStartRef::Temporary; }; +inline SubStartRef::ErrorCode SubStartRef::setTemporary(ErrorCode ec) +{ return (SubStartRef::ErrorCode) + (errorCode = ((Uint32) ec | (Uint32)SubStartRef::Temporary)); }; + +class SubStartConf { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + + friend bool printSUB_START_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 7 ); + STATIC_CONST( SignalLength2 = SignalLength+1 ); + + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 firstGCI; + Uint32 part; // SubscriptionData::Part + Uint32 subscriberData; + // with SignalLength2 + Uint32 subscriberRef; +}; + +class SubStopReq { + /** + * Sender(s)/Reciver(s) + */ + friend class Suma; + + friend bool printSUB_STOP_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 7 ); + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 part; // SubscriptionData::Part + Uint32 subscriberData; + Uint32 subscriberRef; +}; + +class SubStopRef { + /** + * Sender(s)/Reciver(s) + */ + friend class Suma; + + friend bool printSUB_STOP_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + enum ErrorCode { + Undefined = 0, + NF_FakeErrorREF = 11, + Busy = 701, + Temporary = 0x1 << 16 + }; + bool isTemporary() const; + void setTemporary(); + ErrorCode setTemporary(ErrorCode ec); + + STATIC_CONST( SignalLength = 8 ); + + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 part; // SubscriptionData::Part + Uint32 subscriberData; + Uint32 subscriberRef; + union { + Uint32 err; + Uint32 errorCode; + }; +}; +inline bool SubStopRef::isTemporary() const +{ return (errorCode & SubStopRef::Temporary) > 0; }; +inline void SubStopRef::setTemporary() +{ errorCode |= SubStopRef::Temporary; }; +inline SubStopRef::ErrorCode SubStopRef::setTemporary(ErrorCode ec) +{ return (SubStopRef::ErrorCode) + (errorCode = ((Uint32) ec | (Uint32)SubStopRef::Temporary)); }; + +class SubStopConf { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + + friend bool printSUB_STOP_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 7 ); + + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 part; // SubscriptionData::Part + Uint32 subscriberData; + Uint32 subscriberRef; +}; + +class SubSyncReq { + /** + * Sender(s)/Reciver(s) + */ + friend class Suma; + friend class Grep; + + friend bool printSUB_SYNC_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + +public: + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 subscriberData; + Uint32 part; // SubscriptionData::Part +}; + +class SubSyncRef { + /** + * Sender(s)/Reciver(s) + */ + friend class Suma; + friend class Grep; + + friend bool printSUB_SYNC_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + enum ErrorCode { + Undefined = 0, + Temporary = 0x1 << 16 + }; + STATIC_CONST( SignalLength = 5 ); + + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 part; // SubscriptionData::Part + Uint32 subscriberData; + union { + Uint32 errorCode; + Uint32 err; + }; +}; + +class SubSyncConf { + + /** + * Sender(s)/Reciver(s) + */ + friend class Suma; + friend class Grep; + + friend bool printSUB_SYNC_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 part; // SubscriptionData::Part + Uint32 subscriberData; +}; + +class SubMetaData { + /** + * Sender(s)/Reciver(s) + */ + friend class SumaParticipant; + friend class Grep; + + friend bool printSUB_META_DATA(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + SECTION( DICT_TAB_INFO = 0 ); + + Uint32 gci; + union { // Haven't decide what to call it + Uint32 senderData; + Uint32 subscriberData; + }; + union { + Uint32 tableId; + }; +}; + +class SubTableData { + /** + * Sender(s)/Reciver(s) + */ + friend class SumaParticipant; + friend class Grep; + + friend bool printSUB_TABLE_DATA(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 7 ); + + enum LogType { + SCAN = 1, + LOG = 2, + REMOVE_FLAGS = 0xff, + GCINOTCONSISTENT = 0x1 << 16 + }; + + void setGCINotConsistent() { logType |= (Uint32)GCINOTCONSISTENT; }; + bool isGCIConsistent() + { return (logType & (Uint32)GCINOTCONSISTENT) == 0 ? true : false; }; + + union { // Haven't decide what to call it + Uint32 senderData; + Uint32 subscriberData; + }; + Uint32 gci; + Uint32 tableId; + Uint32 operation; + Uint32 noOfAttributes; + Uint32 dataSize; + Uint32 logType; +}; + +class SubSyncContinueReq { + /** + * Sender(s)/Reciver(s) + */ + friend class SumaParticipant; + friend class Grep; + friend class Trix; + + friend bool printSUB_SYNC_CONTINUE_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 2 ); + + union { // Haven't decide what to call it + Uint32 senderData; + Uint32 subscriberData; + }; + Uint32 noOfRowsSent; +}; + +class SubSyncContinueRef { + /** + * Sender(s)/Reciver(s) + */ + friend class SumaParticipant; + friend class Grep; + friend class Trix; + + friend bool printSUB_SYNC_CONTINUE_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 2 ); + + Uint32 subscriptionId; + Uint32 subscriptionKey; +}; + +class SubSyncContinueConf { + /** + * Sender(s)/Reciver(s) + */ + friend class SumaParticipant; + friend class Grep; + friend class Trix; + + friend bool printSUB_SYNC_CONTINUE_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 2 ); + + Uint32 subscriptionId; + Uint32 subscriptionKey; +}; + +class SubGcpCompleteRep { + + /** + * Sender(s)/Reciver(s) + */ + friend class Dbdih; + friend class SumaParticipant; + friend class Grep; + friend class Trix; + + friend bool printSUB_GCP_COMPLETE_REP(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + + Uint32 gci; + Uint32 senderRef; + union { // Haven't decide what to call it + Uint32 senderData; + Uint32 subscriberData; + }; +}; + +class SubGcpCompleteAcc { + /** + * Sender(s)/Reciver(s) + */ +public: + STATIC_CONST( SignalLength = SubGcpCompleteRep::SignalLength ); + + SubGcpCompleteRep rep; +}; + +class SubRemoveReq { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + friend class SumaParticipant; + + friend bool printSUB_REMOVE_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + Uint32 senderRef; + Uint32 senderData; + Uint32 subscriptionId; + Uint32 subscriptionKey; +}; + +class SubRemoveRef { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + friend class SumaParticipant; + + friend bool printSUB_REMOVE_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + enum ErrorCode { + Undefined = 0, + NF_FakeErrorREF = 11, + Busy = 701, + Temporary = 0x1 << 16 + }; + bool isTemporary() const; + void setTemporary(); + ErrorCode setTemporary(ErrorCode ec); + + Uint32 senderRef; + Uint32 subscriptionId; + Uint32 subscriptionKey; + union { + Uint32 err; + Uint32 errorCode; + }; + union { // Haven't decide what to call it + Uint32 senderData; + Uint32 subscriberData; + }; +}; +inline bool SubRemoveRef::isTemporary() const +{ return (err & SubRemoveRef::Temporary) > 0; }; +inline void SubRemoveRef::setTemporary() +{ err |= SubRemoveRef::Temporary; }; +inline SubRemoveRef::ErrorCode SubRemoveRef::setTemporary(ErrorCode ec) +{ return (SubRemoveRef::ErrorCode) + (errorCode = ((Uint32) ec | (Uint32)SubRemoveRef::Temporary)); }; + +class SubRemoveConf { + /** + * Sender(s)/Reciver(s) + */ + friend class Grep; + friend class SumaParticipant; + + friend bool printSUB_REMOVE_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + + Uint32 senderRef; + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 err; + union { // Haven't decide what to call it + Uint32 senderData; + Uint32 subscriberData; + }; + +}; + + +class CreateSubscriptionIdReq { + friend class Grep; + friend class SumaParticipant; + + friend bool printCREATE_SUBSCRIPTION_ID_REQ(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + + Uint32 subscriptionId; + Uint32 subscriptionKey; + union { // Haven't decide what to call it + Uint32 senderData; + Uint32 subscriberData; + }; +}; + + +class CreateSubscriptionIdConf { + friend class Grep; + friend class SumaParticipant; + + friend bool printCREATE_SUBSCRIPTION_ID_CONF(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + + Uint32 subscriptionId; + Uint32 subscriptionKey; + union { // Haven't decide what to call it + Uint32 senderData; + Uint32 subscriberData; + }; +}; + + +class CreateSubscriptionIdRef { + friend class Grep; + friend class SumaParticipant; + + friend bool printCREATE_SUBSCRIPTION_ID_REF(FILE *, const Uint32 *, + Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + Uint32 subscriptionId; + Uint32 subscriptionKey; + Uint32 err; + union { // Haven't decide what to call it + Uint32 senderData; + Uint32 subscriberData; + }; +}; + +class SumaStartMe { +public: + STATIC_CONST( SignalLength = 1 ); + Uint32 unused; +}; + +class SumaHandoverReq { +public: + STATIC_CONST( SignalLength = 1 ); + Uint32 gci; +}; + +class SumaHandoverConf { +public: + STATIC_CONST( SignalLength = 1 ); + Uint32 gci; +}; +#endif diff --git a/ndb/include/kernel/signaldata/SystemError.hpp b/ndb/include/kernel/signaldata/SystemError.hpp new file mode 100644 index 00000000000..7b4d47c5c2e --- /dev/null +++ b/ndb/include/kernel/signaldata/SystemError.hpp @@ -0,0 +1,60 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SYSTEM_ERROR_HPP +#define SYSTEM_ERROR_HPP + +#include "SignalData.hpp" + +class SystemError { + + /** + * Reciver(s) + */ + friend class Ndbcntr; + + /** + * Sender + */ + friend class Dbtc; + friend class Dbdih; + + /** + * For printing + */ + friend bool printSYSTEM_ERROR(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + STATIC_CONST( SignalLength = 4 ); + + enum ErrorCode { + ScanfragStateError = 1, + ScanfragTimeout = 2, + GCPStopDetected = 3, + StartInProgressError = 4, + CopyFragRefError = 5, + TestStopOnError = 6 + }; + +private: + Uint32 errorRef; + Uint32 errorCode; + Uint32 data1; + Uint32 data2; +}; + +#endif + diff --git a/ndb/include/kernel/signaldata/TamperOrd.hpp b/ndb/include/kernel/signaldata/TamperOrd.hpp new file mode 100644 index 00000000000..eb6cd47b093 --- /dev/null +++ b/ndb/include/kernel/signaldata/TamperOrd.hpp @@ -0,0 +1,40 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TAMPERORD_H +#define TAMPERORD_H + +#include "SignalData.hpp" + +class TamperOrd { + /** + * Sender + */ + friend class MgmtSrvr; + + /** + * Receiver + */ + friend class Cmvmi; + +private: + STATIC_CONST( SignalLength = 1 ); + + UintR errorNo; +}; + +#endif // TAMPERORD_H + diff --git a/ndb/include/kernel/signaldata/TcCommit.hpp b/ndb/include/kernel/signaldata/TcCommit.hpp new file mode 100644 index 00000000000..43eb7be1c39 --- /dev/null +++ b/ndb/include/kernel/signaldata/TcCommit.hpp @@ -0,0 +1,74 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TCCOMMITCONF_HPP +#define TCCOMMITCONF_HPP + +#include "SignalData.hpp" + +/** + * This is signal is sent from TC to API + * It means that the transaction was committed + */ +class TcCommitConf { + /** + * Sender(s) + */ + friend class Dbtc; + + /** + * Reciver(s) + */ + friend class Ndb; + +public: + STATIC_CONST( SignalLength = 3 ); +private: + + /** + * apiConnectPtr + * + * Bit 0 (lowest) is used as indicator + * if == 1 then tc expects a commit ack + */ + Uint32 apiConnectPtr; + + Uint32 transId1; + Uint32 transId2; +}; + +class TcCommitRef { + /** + * Sender(s) + */ + friend class Dbtc; + + /** + * Reciver(s) + */ + friend class NdbConnection; + +public: + STATIC_CONST( SignalLength = 4 ); +private: + + Uint32 apiConnectPtr; + Uint32 transId1; + Uint32 transId2; + Uint32 errorCode; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/TcContinueB.hpp b/ndb/include/kernel/signaldata/TcContinueB.hpp new file mode 100644 index 00000000000..7a093b457e8 --- /dev/null +++ b/ndb/include/kernel/signaldata/TcContinueB.hpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TC_CONTINUEB_H +#define TC_CONTINUEB_H + +#include "SignalData.hpp" + +class TcContinueB { + /** + * Sender(s)/Reciver(s) + */ + friend class Dbtc; +private: + enum { + ZRETURN_FROM_QUEUED_DELIVERY = 1, + ZCOMPLETE_TRANS_AT_TAKE_OVER = 2, + ZCONTINUE_TIME_OUT_CONTROL = 3, + ZNODE_TAKE_OVER_COMPLETED = 4, + ZINITIALISE_RECORDS = 5, + ZSEND_COMMIT_LOOP = 6, + ZSEND_COMPLETE_LOOP = 7, + ZHANDLE_FAILED_API_NODE = 8, + ZTRANS_EVENT_REP = 9, + ZABORT_BREAK = 10, + ZABORT_TIMEOUT_BREAK = 11, + ZCONTINUE_TIME_OUT_FRAG_CONTROL = 12, + ZHANDLE_FAILED_API_NODE_REMOVE_MARKERS = 13, + ZWAIT_ABORT_ALL = 14, + ZCHECK_SCAN_ACTIVE_FAILED_LQH = 15, + CHECK_WAIT_DROP_TAB_FAILED_LQH = 16, + TRIGGER_PENDING = 17 + }; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/TcHbRep.hpp b/ndb/include/kernel/signaldata/TcHbRep.hpp new file mode 100644 index 00000000000..58ab015917a --- /dev/null +++ b/ndb/include/kernel/signaldata/TcHbRep.hpp @@ -0,0 +1,64 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TC_HB_REP_H +#define TC_HB_REP_H + +#include "SignalData.hpp" + +/** + * @class TcHbRep + * @brief Order tc refresh(exetend) the timeout counters for this + * transaction + * + * - SENDER: API + * - RECEIVER: TC + */ +class TcHbRep { + /** + * Receiver(s) + */ + friend class Dbtc; // Receiver + + /** + * Sender(s) + */ + friend class NdbConnection; + + /** + * For printing + */ + friend bool printTC_HBREP(FILE *, const Uint32 *, Uint32, Uint16); + +public: + /** + * Length of signal + */ + STATIC_CONST( SignalLength = 3 ); + +private: + + /** + * DATA VARIABLES + */ + + Uint32 apiConnectPtr; // DATA 0 + UintR transId1; // DATA 1 + UintR transId2; // DATA 2 +}; + + +#endif diff --git a/ndb/include/kernel/signaldata/TcIndx.hpp b/ndb/include/kernel/signaldata/TcIndx.hpp new file mode 100644 index 00000000000..764d4e9fcd7 --- /dev/null +++ b/ndb/include/kernel/signaldata/TcIndx.hpp @@ -0,0 +1,528 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TC_INDX_H +#define TC_INDX_H + +#include "SignalData.hpp" + +class TcIndxReq { + /** + * Reciver(s) + */ + friend class Dbtc; // Reciver + + /** + * Sender(s) + */ + friend class NdbIndexOperation; + + /** + * For printing + */ + friend bool printTCINDXREQ(FILE *, const Uint32 *, Uint32, Uint16); + +public: + /** + * Length of signal + */ + STATIC_CONST( StaticLength = 8 ); + STATIC_CONST( SignalLength = 25 ); + STATIC_CONST( MaxKeyInfo = 8 ); + STATIC_CONST( MaxAttrInfo = 5 ); + +private: + + enum CommitType { + CommitIfFailFree = 0, + TryCommit = 1, + CommitAsMuchAsPossible = 2 + }; + + /** + * DATA VARIABLES + */ +//------------------------------------------------------------- +// Unconditional part. First 8 words +//------------------------------------------------------------- + UintR apiConnectPtr; // DATA 0 + UintR senderData; // DATA 1 + UintR attrLen; // DATA 2 (including API Version) + UintR indexId; // DATA 3 + UintR requestInfo; // DATA 4 + UintR indexSchemaVersion; // DATA 5 + UintR transId1; // DATA 6 + UintR transId2; // DATA 7 +//------------------------------------------------------------- +// Conditional part. Those four words will be sent only if their +// indicator is set. +//------------------------------------------------------------- + UintR scanInfo; // DATA 8 + UintR distrGroupHashValue; // DATA 9 + UintR distributionKeySize; // DATA 10 + UintR storedProcId; // DATA 11 + +//------------------------------------------------------------- +// Variable sized key and attrinfo part. Those will be placed to +// pack the signal in an appropriate manner. +//------------------------------------------------------------- + UintR keyInfo[MaxKeyInfo]; // DATA 12 - 19 + UintR attrInfo[MaxAttrInfo]; // DATA 20 - 24 + + static Uint8 getAPIVersion(const UintR & attrLen); + + /** + * Get:ers for requestInfo + */ + static Uint8 getCommitFlag(const UintR & requestInfo); + static Uint8 getCommitType(const UintR & requestInfo); + static Uint8 getStartFlag(const UintR & requestInfo); + static Uint8 getSimpleFlag(const UintR & requestInfo); + static Uint8 getDirtyFlag(const UintR & requestInfo); + static Uint8 getInterpretedFlag(const UintR & requestInfo); + static Uint8 getDistributionGroupFlag(const UintR & requestInfo); + static Uint8 getDistributionGroupTypeFlag(const UintR & requestInfo); + static Uint8 getDistributionKeyFlag(const UintR & requestInfo); + static Uint8 getScanIndFlag(const UintR & requestInfo); + + static Uint8 getOperationType(const UintR & requestInfo); + + static Uint16 getIndexLength(const UintR & requestInfo); + static Uint8 getAIInTcIndxReq(const UintR & requestInfo); + + /** + * Get:ers for scanInfo + */ + + static void setAPIVersion(UintR & attrLen, Uint16 apiVersion); + + /** + * Set:ers for requestInfo + */ + static void clearRequestInfo(UintR & requestInfo); + static void setCommitType(UintR & requestInfo, Uint32 type); + static void setCommitFlag(UintR & requestInfo, Uint32 flag); + static void setStartFlag(UintR & requestInfo, Uint32 flag); + static void setSimpleFlag(UintR & requestInfo, Uint32 flag); + static void setDirtyFlag(UintR & requestInfo, Uint32 flag); + static void setInterpretedFlag(UintR & requestInfo, Uint32 flag); + static void setDistributionGroupFlag(UintR & requestInfo, Uint32 flag); + static void setDistributionGroupTypeFlag(UintR & requestInfo, Uint32 flag); + static void setDistributionKeyFlag(UintR & requestInfo, Uint32 flag); + static void setScanIndFlag(UintR & requestInfo, Uint32 flag); + + static void setOperationType(UintR & requestInfo, Uint32 type); + + static void setIndexLength(UintR & requestInfo, Uint32 len); + static void setAIInTcIndxReq(UintR & requestInfo, Uint32 len); + + /** + * Set:ers for scanInfo + */ + +}; + +#define API_VER_NO_SHIFT (16) +#define API_VER_NO_MASK (65535) + +/** + * Request Info + * + a = Attr Info in TCINDXREQ - 3 Bits -> Max 7 (Bit 16-18) + b = Distribution Key Ind - 1 Bit 2 + c = Commit Indicator - 1 Bit 4 + d = Dirty Indicator - 1 Bit 0 + e = Scan Indicator - 1 Bit 14 + g = Distribution Group Ind - 1 Bit 1 + i = Interpreted Indicator - 1 Bit 15 + k = Index lengt - 12 Bits -> Max 4095 (Bit 20 - 31) + o = Operation Type - 3 Bits -> Max 7 (Bit 5-7) + p = Simple Indicator - 1 Bit 8 + s = Start Indicator - 1 Bit 11 + t = Distribution GroupType - 1 Bit 3 + y = Commit Type - 2 Bit 12-13 + x = Last Op in execute - 1 Bit 19 + + 1111111111222222222233 + 01234567890123456789012345678901 + dgbtcooop syyeiaaa-kkkkkkkkkkkk +*/ + +#define COMMIT_SHIFT (4) +#define START_SHIFT (11) +#define SIMPLE_SHIFT (8) +#define DIRTY_SHIFT (0) +#define INTERPRETED_SHIFT (15) +#define DISTR_GROUP_SHIFT (1) +#define DISTR_GROUP_TYPE_SHIFT (3) +#define DISTR_KEY_SHIFT (2) +#define SCAN_SHIFT (14) + +#define OPERATION_SHIFT (5) +#define OPERATION_MASK (7) + +#define AINFO_SHIFT (16) +#define AINFO_MASK (7) + +#define INDEX_LEN_SHIFT (20) +#define INDEX_LEN_MASK (4095) + +#define COMMIT_TYPE_SHIFT (12) +#define COMMIT_TYPE_MASK (3) + +#define LAST_OP_IN_EXEC_SHIFT (19) + +/** + * Scan Info + * + + + 1111111111222222222233 + 01234567890123456789012345678901 + +*/ + +inline +Uint8 +TcIndxReq::getCommitFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> COMMIT_SHIFT) & 1); +} + +inline +Uint8 +TcIndxReq::getCommitType(const UintR & requestInfo){ + return (Uint8)((requestInfo >> COMMIT_TYPE_SHIFT) & COMMIT_TYPE_MASK); +} + +inline +Uint8 +TcIndxReq::getStartFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> START_SHIFT) & 1); +} + +inline +Uint8 +TcIndxReq::getSimpleFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> SIMPLE_SHIFT) & 1); +} + +inline +Uint8 +TcIndxReq::getDirtyFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> DIRTY_SHIFT) & 1); +} + +inline +Uint8 +TcIndxReq::getInterpretedFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> INTERPRETED_SHIFT) & 1); +} + +inline +Uint8 +TcIndxReq::getDistributionGroupFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> DISTR_GROUP_SHIFT) & 1); +} + +inline +Uint8 +TcIndxReq::getDistributionGroupTypeFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> DISTR_GROUP_TYPE_SHIFT) & 1); +} + +inline +Uint8 +TcIndxReq::getDistributionKeyFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> DISTR_KEY_SHIFT) & 1); +} + +inline +Uint8 +TcIndxReq::getScanIndFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> SCAN_SHIFT) & 1); +} + +inline +Uint8 +TcIndxReq::getOperationType(const UintR & requestInfo){ + return (Uint8)((requestInfo >> OPERATION_SHIFT) & OPERATION_MASK); +} + +inline +Uint16 +TcIndxReq::getIndexLength(const UintR & requestInfo){ + return (Uint16)((requestInfo >> INDEX_LEN_SHIFT) & INDEX_LEN_MASK); +} + +inline +Uint8 +TcIndxReq::getAIInTcIndxReq(const UintR & requestInfo){ + return (Uint8)((requestInfo >> AINFO_SHIFT) & AINFO_MASK); +} + +inline +void +TcIndxReq::clearRequestInfo(UintR & requestInfo){ + requestInfo = 0; +} + +inline +void +TcIndxReq::setCommitType(UintR & requestInfo, Uint32 type){ + ASSERT_MAX(type, COMMIT_TYPE_MASK, "TcIndxReq::setCommitType"); + requestInfo |= (type << COMMIT_TYPE_SHIFT); +} + +inline +void +TcIndxReq::setCommitFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcIndxReq::setCommitFlag"); + requestInfo &= ~(1 << COMMIT_SHIFT); + requestInfo |= (flag << COMMIT_SHIFT); +} + +inline +void +TcIndxReq::setStartFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcIndxReq::setStartFlag"); + requestInfo &= ~(1 << START_SHIFT); + requestInfo |= (flag << START_SHIFT); +} + +inline +void +TcIndxReq::setSimpleFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcIndxReq::setSimpleFlag"); + requestInfo &= ~(1 << SIMPLE_SHIFT); + requestInfo |= (flag << SIMPLE_SHIFT); +} + +inline +void +TcIndxReq::setDirtyFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcIndxReq::setDirtyFlag"); + requestInfo &= ~(1 << DIRTY_SHIFT); + requestInfo |= (flag << DIRTY_SHIFT); +} + +inline +void +TcIndxReq::setInterpretedFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcIndxReq::setInterpretedFlag"); + requestInfo &= ~(1 << INTERPRETED_SHIFT); + requestInfo |= (flag << INTERPRETED_SHIFT); +} + +inline +void +TcIndxReq::setDistributionGroupTypeFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcIndxReq::setDistributionGroupTypeFlag"); + requestInfo &= ~(1 << DISTR_GROUP_TYPE_SHIFT); + requestInfo |= (flag << DISTR_GROUP_TYPE_SHIFT); +} + +inline +void +TcIndxReq::setDistributionGroupFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcIndxReq::setDistributionGroupFlag"); + requestInfo &= ~(1 << DISTR_GROUP_SHIFT); + requestInfo |= (flag << DISTR_GROUP_SHIFT); +} + +inline +void +TcIndxReq::setDistributionKeyFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcIndxReq::setDistributionKeyFlag"); + requestInfo &= ~(1 << DISTR_KEY_SHIFT); + requestInfo |= (flag << DISTR_KEY_SHIFT); +} + +inline +void +TcIndxReq::setScanIndFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcIndxReq::setScanIndFlag"); + requestInfo &= ~(1 << SCAN_SHIFT); + requestInfo |= (flag << SCAN_SHIFT); +} + +inline +void +TcIndxReq::setOperationType(UintR & requestInfo, Uint32 type){ + ASSERT_MAX(type, OPERATION_MASK, "TcIndxReq::setOperationType"); + requestInfo |= (type << OPERATION_SHIFT); +} + +inline +void +TcIndxReq::setIndexLength(UintR & requestInfo, Uint32 len){ + ASSERT_MAX(len, INDEX_LEN_MASK, "TcIndxReq::setKeyLength"); + requestInfo |= (len << INDEX_LEN_SHIFT); +} + +inline +void +TcIndxReq::setAIInTcIndxReq(UintR & requestInfo, Uint32 len){ + ASSERT_MAX(len, AINFO_MASK, "TcIndxReq::setAIInTcIndxReq"); + requestInfo |= (len << AINFO_SHIFT); +} + +inline +Uint8 +TcIndxReq::getAPIVersion(const UintR & anAttrLen){ + return (Uint16)((anAttrLen >> API_VER_NO_SHIFT) & API_VER_NO_MASK); +} + +inline +void +TcIndxReq::setAPIVersion(UintR & anAttrLen, Uint16 apiVersion){ +// ASSERT_MAX(apiVersion, API_VER_NO_MASK, "TcIndxReq::setAPIVersion"); + anAttrLen |= (apiVersion << API_VER_NO_SHIFT); +} + +class TcIndxConf { + + /** + * Reciver(s) + */ + friend class Ndb; + friend class NdbConnection; + + /** + * Sender(s) + */ + friend class Dbtc; + + /** + * For printing + */ + friend bool printTCINDXCONF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + /** + * Length of signal + */ + STATIC_CONST( SignalLength = 5 ); + +private: + /** + * DATA VARIABLES + */ + //------------------------------------------------------------- + // Unconditional part. First 5 words + //------------------------------------------------------------- + + Uint32 apiConnectPtr; + Uint32 gci; + Uint32 confInfo; + Uint32 transId1; + Uint32 transId2; + + struct OperationConf { + Uint32 apiOperationPtr; + Uint32 attrInfoLen; + }; + //------------------------------------------------------------- + // Operations confirmations, + // No of actually sent = getNoOfOperations(confInfo) + //------------------------------------------------------------- + OperationConf operations[10]; + + /** + * Get:ers for confInfo + */ + static Uint32 getNoOfOperations(const Uint32 & confInfo); + static Uint32 getCommitFlag(const Uint32 & confInfo); + static bool getMarkerFlag(const Uint32 & confInfo); + + /** + * Set:ers for confInfo + */ + static void setCommitFlag(Uint32 & confInfo, Uint8 flag); + static void setNoOfOperations(Uint32 & confInfo, Uint32 noOfOps); + static void setMarkerFlag(Uint32 & confInfo, Uint32 flag); +}; + +inline +Uint32 +TcIndxConf::getNoOfOperations(const Uint32 & confInfo){ + return confInfo & 65535; +} + +inline +Uint32 +TcIndxConf::getCommitFlag(const Uint32 & confInfo){ + return ((confInfo >> 16) & 1); +} + +inline +bool +TcIndxConf::getMarkerFlag(const Uint32 & confInfo){ + const Uint32 bits = 3 << 16; // Marker only valid when doing commit + return (confInfo & bits) == bits; +} + +inline +void +TcIndxConf::setNoOfOperations(Uint32 & confInfo, Uint32 noOfOps){ + ASSERT_MAX(noOfOps, 65535, "TcIndxConf::setNoOfOperations"); + confInfo |= noOfOps; +} + +inline +void +TcIndxConf::setCommitFlag(Uint32 & confInfo, Uint8 flag){ + ASSERT_BOOL(flag, "TcIndxConf::setCommitFlag"); + confInfo |= (flag << 16); +} + +inline +void +TcIndxConf::setMarkerFlag(Uint32 & confInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcIndxConf::setMarkerFlag"); + confInfo |= (flag << 17); +} + +class TcIndxRef { + + /** + * Reciver(s) + */ + friend class NdbIndexOperation; + + /** + * Sender(s) + */ + friend class Dbtc; + + /** + * For printing + */ + friend bool printTCINDXREF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + /** + * Length of signal + */ +public: + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 connectPtr; + Uint32 transId[2]; + Uint32 errorCode; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/TcKeyConf.hpp b/ndb/include/kernel/signaldata/TcKeyConf.hpp new file mode 100644 index 00000000000..bfd684b4af4 --- /dev/null +++ b/ndb/include/kernel/signaldata/TcKeyConf.hpp @@ -0,0 +1,131 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TC_KEY_CONF_H +#define TC_KEY_CONF_H + +#include "SignalData.hpp" + +/** + * + */ +class TcKeyConf { + /** + * Reciver(s) + */ + friend class Ndb; + friend class NdbConnection; + friend class Ndbcntr; + friend class DbUtil; + + /** + * Sender(s) + */ + friend class Dbtc; + + /** + * For printing + */ + friend bool printTCKEYCONF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + /** + * Length of signal + */ + STATIC_CONST( StaticLength = 5 ); + STATIC_CONST( OperationLength = 2 ); + +private: + + /** + * DATA VARIABLES + */ + //------------------------------------------------------------- + // Unconditional part. First 5 words + //------------------------------------------------------------- + + Uint32 apiConnectPtr; + Uint32 gci; + Uint32 confInfo; + Uint32 transId1; + Uint32 transId2; + + struct OperationConf { + Uint32 apiOperationPtr; + Uint32 attrInfoLen; + }; + //------------------------------------------------------------- + // Operations confirmations, + // No of actually sent = getNoOfOperations(confInfo) + //------------------------------------------------------------- + OperationConf operations[10]; + + /** + * Get:ers for confInfo + */ + static Uint32 getNoOfOperations(const Uint32 & confInfo); + static Uint32 getCommitFlag(const Uint32 & confInfo); + static bool getMarkerFlag(const Uint32 & confInfo); + + /** + * Set:ers for confInfo + */ + static void setCommitFlag(Uint32 & confInfo, Uint8 flag); + static void setNoOfOperations(Uint32 & confInfo, Uint32 noOfOps); + static void setMarkerFlag(Uint32 & confInfo, Uint32 flag); +}; + +inline +Uint32 +TcKeyConf::getNoOfOperations(const Uint32 & confInfo){ + return confInfo & 65535; +} + +inline +Uint32 +TcKeyConf::getCommitFlag(const Uint32 & confInfo){ + return ((confInfo >> 16) & 1); +} + +inline +bool +TcKeyConf::getMarkerFlag(const Uint32 & confInfo){ + const Uint32 bits = 3 << 16; // Marker only valid when doing commit + return (confInfo & bits) == bits; +} + +inline +void +TcKeyConf::setNoOfOperations(Uint32 & confInfo, Uint32 noOfOps){ + ASSERT_MAX(noOfOps, 65535, "TcKeyConf::setNoOfOperations"); + confInfo |= noOfOps; +} + +inline +void +TcKeyConf::setCommitFlag(Uint32 & confInfo, Uint8 flag){ + ASSERT_BOOL(flag, "TcKeyConf::setCommitFlag"); + confInfo |= (flag << 16); +} + +inline +void +TcKeyConf::setMarkerFlag(Uint32 & confInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcKeyConf::setMarkerFlag"); + confInfo |= (flag << 17); +} + +#endif diff --git a/ndb/include/kernel/signaldata/TcKeyFailConf.hpp b/ndb/include/kernel/signaldata/TcKeyFailConf.hpp new file mode 100644 index 00000000000..d8207b63262 --- /dev/null +++ b/ndb/include/kernel/signaldata/TcKeyFailConf.hpp @@ -0,0 +1,53 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TCKEYFAILCONF_HPP +#define TCKEYFAILCONF_HPP + +#include + +/** + * This is signal is sent from "Take-Over" TC after a node crash + * It means that the transaction was committed + */ +class TcKeyFailConf { + /** + * Sender(s) + */ + friend class Dbtc; + + /** + * Reciver(s) + */ + friend class Ndb; + friend class NdbConnection; + +public: + STATIC_CONST( SignalLength = 3 ); +private: + + /** + * apiConnectPtr + * + * Bit 0 (lowest) is used as indicator + * if == 1 then tc expects a commit ack + */ + Uint32 apiConnectPtr; + Uint32 transId1; + Uint32 transId2; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/TcKeyRef.hpp b/ndb/include/kernel/signaldata/TcKeyRef.hpp new file mode 100644 index 00000000000..c773920713a --- /dev/null +++ b/ndb/include/kernel/signaldata/TcKeyRef.hpp @@ -0,0 +1,52 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TCKEYREF_HPP +#define TCKEYREF_HPP + +#include "SignalData.hpp" + +class TcKeyRef { + + /** + * Receiver(s) + */ + friend class NdbOperation; + friend class Ndbcntr; + friend class DbUtil; + + /** + * Sender(s) / Receiver(s) + */ + friend class Dbtc; + + /** + * Sender(s) + */ + friend class Dblqh; + + friend bool printTCKEYREF(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 connectPtr; + Uint32 transId[2]; + Uint32 errorCode; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/TcKeyReq.hpp b/ndb/include/kernel/signaldata/TcKeyReq.hpp new file mode 100644 index 00000000000..df0a00da3e0 --- /dev/null +++ b/ndb/include/kernel/signaldata/TcKeyReq.hpp @@ -0,0 +1,547 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TC_KEY_REQ_H +#define TC_KEY_REQ_H + +#include "SignalData.hpp" + +/** + * @class TcKeyReq + * @brief Contains KeyInfo and AttrInfo and is commonly followed by more signals + * + * - SENDER: API, NDBCNTR + * - RECEIVER: TC + */ +class TcKeyReq { + /** + * Receiver(s) + */ + friend class Dbtc; // Receiver + + /** + * Sender(s) + */ + friend class Ndbcntr; + friend class NdbOperation; + friend class NdbIndexOperation; + friend class DbUtil; + + /** + * For printing + */ + friend bool printTCKEYREQ(FILE *, const Uint32 *, Uint32, Uint16); + friend bool printTCINDXREQ(FILE *, const Uint32 *, Uint32, Uint16); + +public: + /** + * Length of signal + */ + STATIC_CONST( StaticLength = 8 ); + STATIC_CONST( SignalLength = 25 ); + STATIC_CONST( MaxKeyInfo = 8 ); + STATIC_CONST( MaxAttrInfo = 5 ); + STATIC_CONST( MaxTotalAttrInfo = 0xFFFF ); + +private: + + enum AbortOption { + CommitIfFailFree = 0, AbortOnError = 0, + CommitAsMuchAsPossible = 2, IgnoreError = 2 + }; + + typedef AbortOption CommitType; + + /** + * DATA VARIABLES + */ + + // ---------------------------------------------------------------------- + // Unconditional part = must be present in signal. First 8 words + // ---------------------------------------------------------------------- + Uint32 apiConnectPtr; // DATA 0 + union { + Uint32 senderData; + UintR apiOperationPtr; // DATA 1 + }; + /** + * ATTRIBUTE INFO (attrinfo) LENGTH + * This is the total length of all attribute info that is sent from + * the application as part of this operation. + * It includes all attribute info sent in possible attrinfo + * signals as well as the attribute info sent in TCKEYREQ. + */ + UintR attrLen; // DATA 2 (also stores API Version) + UintR tableId; // DATA 3 + UintR requestInfo; // DATA 4 Various transaction flags + UintR tableSchemaVersion; // DATA 5 + UintR transId1; // DATA 6 + UintR transId2; // DATA 7 + + // ---------------------------------------------------------------------- + // Conditional part = can be present in signal. + // These four words will be sent only if their indicator is set. + // ---------------------------------------------------------------------- + UintR scanInfo; // DATA 8 Various flags for scans + UintR distrGroupHashValue; // DATA 9 + UintR distributionKeySize; // DATA 10 + UintR storedProcId; // DATA 11 + + // ---------------------------------------------------------------------- + // Variable sized KEY and ATTRINFO part. + // These will be placed to pack the signal in an appropriate manner. + // ---------------------------------------------------------------------- + UintR keyInfo[MaxKeyInfo]; // DATA 12 - 19 + UintR attrInfo[MaxAttrInfo]; // DATA 20 - 24 + + /** + * Get:ers for attrLen + */ + + static Uint16 getAPIVersion(const UintR & attrLen); + static Uint16 getAttrinfoLen(const UintR & attrLen); + static void setAPIVersion(UintR & attrLen, Uint16 apiVersion); + static void setAttrinfoLen(UintR & attrLen, Uint16 aiLen); + + + /** + * Get:ers for requestInfo + */ + static Uint8 getCommitFlag(const UintR & requestInfo); + static Uint8 getAbortOption(const UintR & requestInfo); + static Uint8 getStartFlag(const UintR & requestInfo); + static Uint8 getSimpleFlag(const UintR & requestInfo); + static Uint8 getDirtyFlag(const UintR & requestInfo); + static Uint8 getInterpretedFlag(const UintR & requestInfo); + static Uint8 getDistributionGroupFlag(const UintR & requestInfo); + static Uint8 getDistributionGroupTypeFlag(const UintR & requestInfo); + static Uint8 getDistributionKeyFlag(const UintR & requestInfo); + static Uint8 getScanIndFlag(const UintR & requestInfo); + static Uint8 getOperationType(const UintR & requestInfo); + static Uint8 getExecuteFlag(const UintR & requestInfo); + + static Uint16 getKeyLength(const UintR & requestInfo); + static Uint8 getAIInTcKeyReq(const UintR & requestInfo); + static Uint8 getExecutingTrigger(const UintR & requestInfo); + + /** + * Get:ers for scanInfo + */ + static Uint8 getTakeOverScanFlag(const UintR & scanInfo); + static Uint16 getTakeOverScanNode(const UintR & scanInfo); + static Uint16 getTakeOverScanInfo(const UintR & scanInfo); + + + /** + * Set:ers for requestInfo + */ + static void clearRequestInfo(UintR & requestInfo); + static void setAbortOption(UintR & requestInfo, Uint32 type); + static void setCommitFlag(UintR & requestInfo, Uint32 flag); + static void setStartFlag(UintR & requestInfo, Uint32 flag); + static void setSimpleFlag(UintR & requestInfo, Uint32 flag); + static void setDirtyFlag(UintR & requestInfo, Uint32 flag); + static void setInterpretedFlag(UintR & requestInfo, Uint32 flag); + static void setDistributionGroupFlag(UintR & requestInfo, Uint32 flag); + static void setDistributionGroupTypeFlag(UintR & requestInfo, Uint32 flag); + static void setDistributionKeyFlag(UintR & requestInfo, Uint32 flag); + static void setScanIndFlag(UintR & requestInfo, Uint32 flag); + static void setExecuteFlag(UintR & requestInfo, Uint32 flag); + static void setOperationType(UintR & requestInfo, Uint32 type); + + static void setKeyLength(UintR & requestInfo, Uint32 len); + static void setAIInTcKeyReq(UintR & requestInfo, Uint32 len); + static void setExecutingTrigger(UintR & requestInfo, Uint32 flag); + + /** + * Set:ers for scanInfo + */ + static void setTakeOverScanFlag(UintR & scanInfo, Uint8 flag); + static void setTakeOverScanNode(UintR & scanInfo, Uint16 node); + static void setTakeOverScanInfo(UintR & scanInfo, Uint16 aScanInfo); +}; + +/** + * Request Info + * + a = Attr Info in TCKEYREQ - 3 Bits -> Max 7 (Bit 16-18) + b = Distribution Key Ind - 1 Bit 2 + c = Commit Indicator - 1 Bit 4 + d = Dirty Indicator - 1 Bit 0 + e = Scan Indicator - 1 Bit 14 + f = Execute fired trigger - 1 Bit 19 + g = Distribution Group Ind- 1 Bit 1 + i = Interpreted Indicator - 1 Bit 15 + k = Key length - 12 Bits -> Max 4095 (Bit 20 - 31) + o = Operation Type - 3 Bits -> Max 7 (Bit 5-7) + l = Execute - 1 Bit 10 + p = Simple Indicator - 1 Bit 8 + s = Start Indicator - 1 Bit 11 + t = Distribution GroupType- 1 Bit 3 + y = Commit Type - 2 Bit 12-13 + + 1111111111222222222233 + 01234567890123456789012345678901 + dgbtcooop lsyyeiaaafkkkkkkkkkkkk +*/ + +#define COMMIT_SHIFT (4) +#define START_SHIFT (11) +#define SIMPLE_SHIFT (8) +#define DIRTY_SHIFT (0) +#define EXECUTE_SHIFT (10) +#define INTERPRETED_SHIFT (15) +#define DISTR_GROUP_SHIFT (1) +#define DISTR_GROUP_TYPE_SHIFT (3) +#define DISTR_KEY_SHIFT (2) +#define SCAN_SHIFT (14) + +#define OPERATION_SHIFT (5) +#define OPERATION_MASK (7) + +#define AINFO_SHIFT (16) +#define AINFO_MASK (7) + +#define KEY_LEN_SHIFT (20) +#define KEY_LEN_MASK (4095) + +#define COMMIT_TYPE_SHIFT (12) +#define COMMIT_TYPE_MASK (3) + +#define EXECUTING_TRIGGER_SHIFT (19) + +/** + * Scan Info + * + t = Scan take over indicator - 1 Bit + n = Take over node - 16 Bits -> max 65535 + p = Scan Info - 12 Bits -> max 4095 + + 1111111111222222222233 + 01234567890123456789012345678901 + tpppppppppppp nnnnnnnnnnnnnnnn +*/ + +#define TAKE_OVER_SHIFT (0) + +#define TAKE_OVER_NODE_SHIFT (16) +#define TAKE_OVER_NODE_MASK (65535) + +#define SCAN_INFO_SHIFT (1) +#define SCAN_INFO_MASK (4095) + +/** + * Attr Len + * + n = Attrinfo length(words) - 16 Bits -> max 65535 + a = API version no - 16 Bits -> max 65535 + + 1111111111222222222233 + 01234567890123456789012345678901 + aaaaaaaaaaaaaaaannnnnnnnnnnnnnnn +*/ + +#define API_VER_NO_SHIFT (16) +#define API_VER_NO_MASK (65535) + +#define ATTRLEN_SHIFT (0) +#define ATTRLEN_MASK (65535) + +inline +Uint8 +TcKeyReq::getCommitFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> COMMIT_SHIFT) & 1); +} + +inline +Uint8 +TcKeyReq::getAbortOption(const UintR & requestInfo){ + return (Uint8)((requestInfo >> COMMIT_TYPE_SHIFT) & COMMIT_TYPE_MASK); +} + +inline +Uint8 +TcKeyReq::getStartFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> START_SHIFT) & 1); +} + +inline +Uint8 +TcKeyReq::getSimpleFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> SIMPLE_SHIFT) & 1); +} + +inline +Uint8 +TcKeyReq::getExecuteFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> EXECUTE_SHIFT) & 1); +} + +inline +Uint8 +TcKeyReq::getDirtyFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> DIRTY_SHIFT) & 1); +} + +inline +Uint8 +TcKeyReq::getInterpretedFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> INTERPRETED_SHIFT) & 1); +} + +inline +Uint8 +TcKeyReq::getDistributionGroupFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> DISTR_GROUP_SHIFT) & 1); +} + +inline +Uint8 +TcKeyReq::getDistributionGroupTypeFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> DISTR_GROUP_TYPE_SHIFT) & 1); +} + +inline +Uint8 +TcKeyReq::getDistributionKeyFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> DISTR_KEY_SHIFT) & 1); +} + +inline +Uint8 +TcKeyReq::getScanIndFlag(const UintR & requestInfo){ + return (Uint8)((requestInfo >> SCAN_SHIFT) & 1); +} + +inline +Uint8 +TcKeyReq::getOperationType(const UintR & requestInfo){ + return (Uint8)((requestInfo >> OPERATION_SHIFT) & OPERATION_MASK); +} + +inline +Uint16 +TcKeyReq::getKeyLength(const UintR & requestInfo){ + return (Uint16)((requestInfo >> KEY_LEN_SHIFT) & KEY_LEN_MASK); +} + +inline +Uint8 +TcKeyReq::getAIInTcKeyReq(const UintR & requestInfo){ + return (Uint8)((requestInfo >> AINFO_SHIFT) & AINFO_MASK); +} + +inline +Uint8 +TcKeyReq::getExecutingTrigger(const UintR & requestInfo){ + return (Uint8)((requestInfo >> EXECUTING_TRIGGER_SHIFT) & 1); +} + +inline +void +TcKeyReq::clearRequestInfo(UintR & requestInfo){ + requestInfo = 0; +} + +inline +void +TcKeyReq::setAbortOption(UintR & requestInfo, Uint32 type){ + ASSERT_MAX(type, COMMIT_TYPE_MASK, "TcKeyReq::setAbortOption"); + requestInfo &= ~(COMMIT_TYPE_MASK << COMMIT_TYPE_SHIFT); + requestInfo |= (type << COMMIT_TYPE_SHIFT); +} + +inline +void +TcKeyReq::setCommitFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcKeyReq::setCommitFlag"); + requestInfo &= ~(1 << COMMIT_SHIFT); + requestInfo |= (flag << COMMIT_SHIFT); +} + +inline +void +TcKeyReq::setStartFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcKeyReq::setStartFlag"); + requestInfo &= ~(1 << START_SHIFT); + requestInfo |= (flag << START_SHIFT); +} + +inline +void +TcKeyReq::setSimpleFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcKeyReq::setSimpleFlag"); + requestInfo &= ~(1 << SIMPLE_SHIFT); + requestInfo |= (flag << SIMPLE_SHIFT); +} + +inline +void +TcKeyReq::setDirtyFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcKeyReq::setDirstFlag"); + requestInfo &= ~(1 << DIRTY_SHIFT); + requestInfo |= (flag << DIRTY_SHIFT); +} + +inline +void +TcKeyReq::setExecuteFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcKeyReq::setExecuteFlag"); + requestInfo &= ~(1 << EXECUTE_SHIFT); + requestInfo |= (flag << EXECUTE_SHIFT); +} + +inline +void +TcKeyReq::setInterpretedFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcKeyReq::setInterpretedFlag"); + requestInfo &= ~(1 << INTERPRETED_SHIFT); + requestInfo |= (flag << INTERPRETED_SHIFT); +} + +inline +void +TcKeyReq::setDistributionGroupTypeFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcKeyReq::setDistributionGroupTypeFlag"); + requestInfo &= ~(1 << DISTR_GROUP_TYPE_SHIFT); + requestInfo |= (flag << DISTR_GROUP_TYPE_SHIFT); +} + +inline +void +TcKeyReq::setDistributionGroupFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcKeyReq::setDistributionGroupFlag"); + requestInfo &= ~(1 << DISTR_GROUP_SHIFT); + requestInfo |= (flag << DISTR_GROUP_SHIFT); +} + +inline +void +TcKeyReq::setDistributionKeyFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcKeyReq::setDistributionKeyFlag"); + requestInfo &= ~(1 << DISTR_KEY_SHIFT); + requestInfo |= (flag << DISTR_KEY_SHIFT); +} + +inline +void +TcKeyReq::setScanIndFlag(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcKeyReq::setScanIndFlag"); + requestInfo &= ~(1 << SCAN_SHIFT); + requestInfo |= (flag << SCAN_SHIFT); +} + +inline +void +TcKeyReq::setOperationType(UintR & requestInfo, Uint32 type){ + ASSERT_MAX(type, OPERATION_MASK, "TcKeyReq::setOperationType"); + requestInfo &= ~(OPERATION_MASK << OPERATION_SHIFT); + requestInfo |= (type << OPERATION_SHIFT); +} + +inline +void +TcKeyReq::setKeyLength(UintR & requestInfo, Uint32 len){ + ASSERT_MAX(len, KEY_LEN_MASK, "TcKeyReq::setKeyLength"); + requestInfo &= ~(KEY_LEN_MASK << KEY_LEN_SHIFT); + requestInfo |= (len << KEY_LEN_SHIFT); +} + +inline +void +TcKeyReq::setAIInTcKeyReq(UintR & requestInfo, Uint32 len){ + ASSERT_MAX(len, AINFO_MASK, "TcKeyReq::setAIInTcKeyReq"); + requestInfo &= ~(AINFO_MASK << AINFO_SHIFT); + requestInfo |= (len << AINFO_SHIFT); +} + +inline +void +TcKeyReq::setExecutingTrigger(UintR & requestInfo, Uint32 flag){ + ASSERT_BOOL(flag, "TcKeyReq::setExecutingTrigger"); + requestInfo &= ~(1 << EXECUTING_TRIGGER_SHIFT); + requestInfo |= (flag << EXECUTING_TRIGGER_SHIFT); +} + +inline +Uint8 +TcKeyReq::getTakeOverScanFlag(const UintR & scanInfo){ + return (Uint8)((scanInfo >> TAKE_OVER_SHIFT) & 1); +} + +inline +Uint16 +TcKeyReq::getTakeOverScanNode(const UintR & scanInfo){ + return (Uint16)((scanInfo >> TAKE_OVER_NODE_SHIFT) & TAKE_OVER_NODE_MASK); +} + +inline +Uint16 +TcKeyReq::getTakeOverScanInfo(const UintR & scanInfo){ + return (Uint16)((scanInfo >> SCAN_INFO_SHIFT) & SCAN_INFO_MASK); +} + + +inline +void +TcKeyReq::setTakeOverScanFlag(UintR & scanInfo, Uint8 flag){ + ASSERT_BOOL(flag, "TcKeyReq::setTakeOverScanFlag"); + scanInfo |= (flag << TAKE_OVER_SHIFT); +} + +inline +void +TcKeyReq::setTakeOverScanNode(UintR & scanInfo, Uint16 node){ +// ASSERT_MAX(node, TAKE_OVER_NODE_MASK, "TcKeyReq::setTakeOverScanNode"); + scanInfo |= (node << TAKE_OVER_NODE_SHIFT); +} + +inline +void +TcKeyReq::setTakeOverScanInfo(UintR & scanInfo, Uint16 aScanInfo){ +// ASSERT_MAX(aScanInfo, SCAN_INFO_MASK, "TcKeyReq::setTakeOverScanInfo"); + scanInfo |= (aScanInfo << SCAN_INFO_SHIFT); +} + + +inline +Uint16 +TcKeyReq::getAPIVersion(const UintR & anAttrLen){ + return (Uint16)((anAttrLen >> API_VER_NO_SHIFT) & API_VER_NO_MASK); +} + +inline +void +TcKeyReq::setAPIVersion(UintR & anAttrLen, Uint16 apiVersion){ +// ASSERT_MAX(apiVersion, API_VER_NO_MASK, "TcKeyReq::setAPIVersion"); + anAttrLen |= (apiVersion << API_VER_NO_SHIFT); +} + +inline +Uint16 +TcKeyReq::getAttrinfoLen(const UintR & anAttrLen){ + return (Uint16)((anAttrLen) & ATTRLEN_MASK); +} + +inline +void +TcKeyReq::setAttrinfoLen(UintR & anAttrLen, Uint16 aiLen){ +// ASSERT_MAX(aiLen, ATTRLEN_MASK, "TcKeyReq::setAttrinfoLen"); + anAttrLen |= aiLen; +} + + +#endif diff --git a/ndb/include/kernel/signaldata/TcRollbackRep.hpp b/ndb/include/kernel/signaldata/TcRollbackRep.hpp new file mode 100644 index 00000000000..b00731a04a6 --- /dev/null +++ b/ndb/include/kernel/signaldata/TcRollbackRep.hpp @@ -0,0 +1,50 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TCROLLBACKREP_HPP +#define TCROLLBACKREP_HPP + +#include "SignalData.hpp" + +class TcRollbackRep { + /** + * Sender(s) + */ + friend class NdbConnection; + friend class DbUtil; + + /** + * Receiver(s) + */ + friend class Dbtup; + + /** + * Sender(s) / Receiver(s) + */ + friend class Dbtc; + + friend bool printTCROLBACKREP(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 connectPtr; + Uint32 transId[2]; + Uint32 returnCode; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/TcSizeAltReq.hpp b/ndb/include/kernel/signaldata/TcSizeAltReq.hpp new file mode 100644 index 00000000000..34eacfe5a93 --- /dev/null +++ b/ndb/include/kernel/signaldata/TcSizeAltReq.hpp @@ -0,0 +1,52 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TC_SIZE_ALT_REQ_H +#define TC_SIZE_ALT_REQ_H + + + +#include "SignalData.hpp" + +class TcSizeAltReq { + /** + * Sender(s) + */ + friend class ClusterConfiguration; + + /** + * Reciver(s) + */ + friend class Dbtc; +private: + /** + * Indexes in theData + */ + STATIC_CONST( IND_BLOCK_REF = 0 ); + STATIC_CONST( IND_API_CONNECT = 1 ); + STATIC_CONST( IND_TC_CONNECT = 2 ); + STATIC_CONST( IND_UNUSED = 3 ); + STATIC_CONST( IND_TABLE = 4 ); + STATIC_CONST( IND_TC_SCAN = 5 ); + STATIC_CONST( IND_LOCAL_SCAN = 6 ); + + /** + * Use the index definitions to use the signal data + */ + UintR theData[7]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/TestOrd.hpp b/ndb/include/kernel/signaldata/TestOrd.hpp new file mode 100644 index 00000000000..1600df08884 --- /dev/null +++ b/ndb/include/kernel/signaldata/TestOrd.hpp @@ -0,0 +1,229 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TEST_ORD_H +#define TEST_ORD_H + +#include "SignalData.hpp" + +/** + * Send by API to preform TEST ON / TEST OFF + * + * SENDER: API + * RECIVER: SimBlockCMCtrBlck + */ +class TestOrd { + friend class Ndb; + friend class Cmvmi; + friend class MgmtSrvr; +public: + + enum Command { + KeepUnchanged = 0, + On = 1, + Off = 2, + Toggle = 3, + COMMAND_MASK = 3 + }; + + enum SignalLoggerSpecification { + InputSignals = 1, + OutputSignals = 2, + InputOutputSignals = 3, + LOG_MASK = 3 + }; + + enum TraceSpecification { + TraceALL = 0, + TraceAPI = 1, + TraceGlobalCheckpoint = 2, + TraceLocalCheckpoint = 4, + TraceDisconnect = 8, + TRACE_MASK = 15 + }; + +private: + STATIC_CONST( SignalLength = 25 ); + + /** + * Clear Signal + */ + void clear(); + + /** + * Set/Get test command + */ + void setTestCommand(Command); + void getTestCommand(Command&) const; + + /** + * Set trace command + */ + void setTraceCommand(Command, TraceSpecification); + + /** + * Get trace command + */ + void getTraceCommand(Command&, TraceSpecification&) const; + + /** + * Return no of signal logger commands + * + * -1 Means apply command(0) to all blocks + * + */ + UintR getNoOfSignalLoggerCommands() const; + + /** + * Add a signal logger command to a specific block + */ + void addSignalLoggerCommand(BlockNumber, Command, SignalLoggerSpecification); + + /** + * Add a signal logger command to all blocks + * + * Note removes all previously added commands + * + */ + void addSignalLoggerCommand(Command, SignalLoggerSpecification); + + /** + * Get Signal logger command + */ + void getSignalLoggerCommand(int no, BlockNumber&, Command&, SignalLoggerSpecification&) const; + + UintR testCommand; // DATA 0 + UintR traceCommand; // DATA 1 + UintR noOfSignalLoggerCommands; // DATA 2 + UintR signalLoggerCommands[22]; // DATA 3 - 25 +}; + +#define COMMAND_SHIFT (0) +#define TRACE_SHIFT (2) +#define LOG_SHIFT (2) + +#define BLOCK_NO_SHIFT (16) +#define BLOCK_NO_MASK 65535 + +/** + * Clear Signal + */ +inline +void +TestOrd::clear(){ + setTestCommand(KeepUnchanged); + setTraceCommand(KeepUnchanged, TraceAPI); // + noOfSignalLoggerCommands = 0; +} + +/** + * Set/Get test command + */ +inline +void +TestOrd::setTestCommand(Command cmd){ + ASSERT_RANGE(cmd, 0, COMMAND_MASK, "TestOrd::setTestCommand"); + testCommand = cmd; +} + +inline +void +TestOrd::getTestCommand(Command & cmd) const{ + cmd = (Command)(testCommand >> COMMAND_SHIFT); +} + +/** + * Set trace command + */ +inline +void +TestOrd::setTraceCommand(Command cmd, TraceSpecification spec){ + ASSERT_RANGE(cmd, 0, COMMAND_MASK, "TestOrd::setTraceCommand"); + ASSERT_RANGE(spec, 0, TRACE_MASK, "TestOrd::setTraceCommand"); + traceCommand = (cmd << COMMAND_SHIFT) | (spec << TRACE_SHIFT); +} + +/** + * Get trace command + */ +inline +void +TestOrd::getTraceCommand(Command & cmd, TraceSpecification & spec) const{ + cmd = (Command)((traceCommand >> COMMAND_SHIFT) & COMMAND_MASK); + spec = (TraceSpecification)((traceCommand >> TRACE_SHIFT) & TRACE_MASK); +} + +/** + * Return no of signal logger commands + * + * -1 Means apply command(0) to all blocks + * + */ +inline +UintR +TestOrd::getNoOfSignalLoggerCommands() const{ + return noOfSignalLoggerCommands; +} + +/** + * Add a signal logger command to a specific block + */ +inline +void +TestOrd::addSignalLoggerCommand(BlockNumber bnr, + Command cmd, SignalLoggerSpecification spec){ + ASSERT_RANGE(cmd, 0, COMMAND_MASK, "TestOrd::addSignalLoggerCommand"); + ASSERT_RANGE(spec, 0, LOG_MASK, "TestOrd::addSignalLoggerCommand"); + //ASSERT_MAX(bnr, BLOCK_NO_MASK, "TestOrd::addSignalLoggerCommand"); + + signalLoggerCommands[noOfSignalLoggerCommands] = + (bnr << BLOCK_NO_SHIFT) | (cmd << COMMAND_SHIFT) | (spec << LOG_SHIFT); + noOfSignalLoggerCommands ++; +} + +/** + * Add a signal logger command to all blocks + * + * Note removes all previously added commands + * + */ +inline +void +TestOrd::addSignalLoggerCommand(Command cmd, SignalLoggerSpecification spec){ + ASSERT_RANGE(cmd, 0, COMMAND_MASK, "TestOrd::addSignalLoggerCommand"); + ASSERT_RANGE(spec, 0, LOG_MASK, "TestOrd::addSignalLoggerCommand"); + + noOfSignalLoggerCommands = ~0; + signalLoggerCommands[0] = (cmd << COMMAND_SHIFT) | (spec << LOG_SHIFT); +} + +/** + * Get Signal logger command + */ +inline +void +TestOrd::getSignalLoggerCommand(int no, BlockNumber & bnr, + Command & cmd, + SignalLoggerSpecification & spec) const{ + bnr = (BlockNumber)((signalLoggerCommands[no] >> BLOCK_NO_SHIFT) + & BLOCK_NO_MASK); + cmd = (Command)((signalLoggerCommands[no] >> COMMAND_SHIFT) + & COMMAND_MASK); + spec = (SignalLoggerSpecification)((signalLoggerCommands[no] >> LOG_SHIFT) + & LOG_MASK); +} + +#endif diff --git a/ndb/include/kernel/signaldata/TransIdAI.hpp b/ndb/include/kernel/signaldata/TransIdAI.hpp new file mode 100755 index 00000000000..4df7bf2a126 --- /dev/null +++ b/ndb/include/kernel/signaldata/TransIdAI.hpp @@ -0,0 +1,59 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TRANSID_AI_HPP +#define TRANSID_AI_HPP + +#include "SignalData.hpp" + +class TransIdAI { + /** + * Sender(s) + */ + friend class Dbtup; + + /** + * Receiver(s) + */ + friend class NdbConnection; + friend class Dbtc; + friend class Dbutil; + friend class Dblqh; + friend class Suma; + + friend bool printTRANSID_AI(FILE *, const Uint32 *, Uint32, Uint16); + +public: + STATIC_CONST( HeaderLength = 3 ); + STATIC_CONST( DataLength = 22 ); + + // Public methods +public: + Uint32* getData() const; + +public: + Uint32 connectPtr; + Uint32 transId[2]; + Uint32 attrData[DataLength]; +}; + +inline +Uint32* TransIdAI::getData() const +{ + return (Uint32*)&attrData[0]; +} + +#endif diff --git a/ndb/include/kernel/signaldata/TrigAttrInfo.hpp b/ndb/include/kernel/signaldata/TrigAttrInfo.hpp new file mode 100644 index 00000000000..e2c029b9033 --- /dev/null +++ b/ndb/include/kernel/signaldata/TrigAttrInfo.hpp @@ -0,0 +1,138 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TRIG_ATTRINFO_HPP +#define TRIG_ATTRINFO_HPP + +#include "SignalData.hpp" +#include +#include +#include + +/** + * TrigAttrInfo + * + * This signal is sent by TUP to signal + * that a trigger has fired + */ +class TrigAttrInfo { + /** + * Sender(s) + */ + // API + + /** + * Sender(s) / Reciver(s) + */ + friend class Dbtup; + + /** + * Reciver(s) + */ + friend class Dbtc; + friend class Backup; + friend class SumaParticipant; + + /** + * For printing + */ + friend bool printTRIG_ATTRINFO(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: +enum AttrInfoType { + PRIMARY_KEY = 0, + BEFORE_VALUES = 1, + AFTER_VALUES = 2 +}; + + STATIC_CONST( DataLength = 22 ); + STATIC_CONST( StaticLength = 3 ); + +private: + Uint32 m_connectionPtr; + Uint32 m_trigId; + Uint32 m_type; + Uint32 m_data[DataLength]; + + // Public methods +public: + Uint32 getConnectionPtr() const; + void setConnectionPtr(Uint32); + AttrInfoType getAttrInfoType() const; + void setAttrInfoType(AttrInfoType anAttrType); + Uint32 getTriggerId() const; + void setTriggerId(Uint32 aTriggerId); + Uint32 getTransactionId1() const; + void setTransactionId1(Uint32 aTransId); + Uint32 getTransactionId2() const; + void setTransactionId2(Uint32 aTransId); + Uint32* getData() const; + int setData(Uint32* aDataBuf, Uint32 aDataLen); +}; + +inline +Uint32 TrigAttrInfo::getConnectionPtr() const +{ + return m_connectionPtr; +} + +inline +void TrigAttrInfo::setConnectionPtr(Uint32 aConnectionPtr) +{ + m_connectionPtr = aConnectionPtr; +} + +inline +TrigAttrInfo::AttrInfoType TrigAttrInfo::getAttrInfoType() const +{ + return (TrigAttrInfo::AttrInfoType) m_type; +} + +inline +void TrigAttrInfo::setAttrInfoType(TrigAttrInfo::AttrInfoType anAttrType) +{ + m_type = (Uint32) anAttrType; +} + +inline +Uint32 TrigAttrInfo::getTriggerId() const +{ + return m_trigId; +} + +inline +void TrigAttrInfo::setTriggerId(Uint32 aTriggerId) +{ + m_trigId = aTriggerId; +} + +inline +Uint32* TrigAttrInfo::getData() const +{ + return (Uint32*)&m_data[0]; +} + +inline +int TrigAttrInfo::setData(Uint32* aDataBuf, Uint32 aDataLen) +{ + if (aDataLen > DataLength) + return -1; + memcpy(m_data, aDataBuf, aDataLen*sizeof(Uint32)); + + return 0; +} + +#endif diff --git a/ndb/include/kernel/signaldata/TupAccess.hpp b/ndb/include/kernel/signaldata/TupAccess.hpp new file mode 100644 index 00000000000..5cfb8c0d153 --- /dev/null +++ b/ndb/include/kernel/signaldata/TupAccess.hpp @@ -0,0 +1,172 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TUP_ACCESS_HPP +#define TUP_ACCESS_HPP + +#include "SignalData.hpp" + +/* + * Direct signals used by ACC and TUX to access the TUP block in the + * same thread. + * + * NOTE: Caller must set errorCode to RNIL. Signal printer uses this to + * distinguish between input and output (no better way exists). + */ + +/* + * Read attributes from any table. + */ +class TupReadAttrs { + friend class Dbtup; + friend class Dbacc; + friend class Dbtux; + friend bool printTUP_READ_ATTRS(FILE*, const Uint32*, Uint32, Uint16); +public: + enum Flag { + /* + * Read primary key attributes. No input attribute ids are + * specified. Instead TUP fills in both input and output sections. + * Tuple version is not used. + */ + ReadKeys = (1 << 0) + }; + STATIC_CONST( SignalLength = 10 ); +private: + /* + * Error code set by TUP. Zero means no error. + */ + Uint32 errorCode; + /* + * Request info contains flags (see Flags above). + */ + Uint32 requestInfo; + /* + * Table i-value. + */ + Uint32 tableId; + /* + * Fragment is given by logical id within the table or by direct + * i-value (faster). Unknown values are given as RNIL. On return TUP + * fills in both values. + */ + Uint32 fragId; + Uint32 fragPtrI; + /* + * Logical address ("local key") of "original" tuple (the latest + * version) consisting of logical fragment page id and tuple index + * within the page (shifted left by 1). + */ + Uint32 tupAddr; + /* + * Version of the tuple to read. Not used if ReadKeys. + */ + Uint32 tupVersion; + /* + * Real page id and offset of the "original" tuple. Unknown page is + * given as RNIL. On return TUP fills in these. + */ + Uint32 pageId; + Uint32 pageOffset; + /* + * Shared buffer id. Currently must be 0 which means to use rest of + * signal data. + */ + Uint32 bufferId; + /* + * Shared buffer 0 starts after signal class. Input is number of + * attributes and list of attribute ids in AttributeHeader format. + * Output is placed after the input and consists of a list of entries + * where each entry has an AttributeHeader followed by words of data. + */ +}; + +/* + * Query status of tuple version. Used by TUX to decide if a tuple + * version found in index tree is visible to the transaction. + */ +class TupQueryTh { + friend class Dbtup; + friend class Dbtux; + friend bool printTUP_QUERY_TH(FILE*, const Uint32*, Uint32, Uint16); +public: + enum Flag { + }; + STATIC_CONST( SignalLength = 7 ); +private: + /* + TUX wants to check if tuple is visible to the scan query. + Input data is tuple address (tableId, fragId, tupAddr, tupVersion), + and transaction data so that TUP knows how to deduct if tuple is + visible (transId1, transId2, savePointId). + returnCode is set in return signal to indicate whether tuple is visible. + */ + union { + Uint32 returnCode; // 1 if tuple visible + Uint32 tableId; + }; + Uint32 fragId; + Uint32 tupAddr; + Uint32 tupVersion; + Uint32 transId1; + Uint32 transId2; + Uint32 savePointId; +}; + +/* + * Operate on entire tuple. Used by TUX where the table has a single + * Uint32 array attribute representing an index tree node. + */ +class TupStoreTh { + friend class Dbtup; + friend class Dbtux; + friend bool printTUP_STORE_TH(FILE*, const Uint32*, Uint32, Uint16); +public: + enum OpCode { + OpUndefined = 0, + OpRead = 1, + OpInsert = 2, + OpUpdate = 3, + OpDelete = 4 + }; + STATIC_CONST( SignalLength = 12 ); +private: + /* + * These are as in TupReadAttrs (except opCode). Version must be + * zero. Ordered index tuple (tree node) has only current version. + */ + Uint32 errorCode; + Uint32 opCode; + Uint32 tableId; + Uint32 fragId; + Uint32 fragPtrI; + Uint32 tupAddr; + Uint32 tupVersion; + Uint32 pageId; + Uint32 pageOffset; + Uint32 bufferId; + /* + * Data offset and size in words. Applies to both the buffer and the + * tuple. Used e.g. to read only node header. + */ + Uint32 dataOffset; + Uint32 dataSize; + /* + * Shared buffer 0 starts after signal class. + */ +}; + +#endif diff --git a/ndb/include/kernel/signaldata/TupCommit.hpp b/ndb/include/kernel/signaldata/TupCommit.hpp new file mode 100644 index 00000000000..7c5a7931e6c --- /dev/null +++ b/ndb/include/kernel/signaldata/TupCommit.hpp @@ -0,0 +1,51 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TUP_COMMIT_H +#define TUP_COMMIT_H + +#include "SignalData.hpp" + +class TupCommitReq { + /** + * Reciver(s) + */ + friend class Dbtup; + + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * For printing + */ + friend bool printTUPCOMMITREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + STATIC_CONST( SignalLength = 3 ); + +private: + + /** + * DATA VARIABLES + */ + Uint32 opPtr; + Uint32 gci; + Uint32 hashValue; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/TupFrag.hpp b/ndb/include/kernel/signaldata/TupFrag.hpp new file mode 100644 index 00000000000..ffde2217893 --- /dev/null +++ b/ndb/include/kernel/signaldata/TupFrag.hpp @@ -0,0 +1,188 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TUP_FRAG_HPP +#define TUP_FRAG_HPP + +#include "SignalData.hpp" + +/* + * Add fragment and add attribute signals between LQH and TUP,TUX. + * NOTE: return signals from TUP,TUX to LQH must have same format. + */ + +// TUP: add fragment + +class TupFragReq { + friend class Dblqh; + friend class Dbtup; +public: + STATIC_CONST( SignalLength = 14 ); +private: + Uint32 userPtr; + Uint32 userRef; + Uint32 reqInfo; + Uint32 tableId; + Uint32 noOfAttr; + Uint32 fragId; + Uint32 todo[8]; +}; + +class TupFragConf { + friend class Dblqh; + friend class Dbtup; +public: + STATIC_CONST( SignalLength = 4 ); +private: + Uint32 userPtr; + Uint32 tupConnectPtr; + Uint32 fragPtr; + Uint32 fragId; +}; + +class TupFragRef { + friend class Dblqh; + friend class Dbtup; +public: + STATIC_CONST( SignalLength = 2 ); +private: + Uint32 userPtr; + Uint32 errorCode; +}; + +// TUX: add fragment + +class TuxFragReq { + friend class Dblqh; + friend class Dbtux; +public: + STATIC_CONST( SignalLength = 9 ); +private: + Uint32 userPtr; + Uint32 userRef; + Uint32 reqInfo; + Uint32 tableId; + Uint32 noOfAttr; + Uint32 fragId; + Uint32 fragOff; + Uint32 tableType; + Uint32 primaryTableId; +}; + +class TuxFragConf { + friend class Dblqh; + friend class Dbtux; +public: + STATIC_CONST( SignalLength = 4 ); +private: + Uint32 userPtr; + Uint32 tuxConnectPtr; + Uint32 fragPtr; + Uint32 fragId; +}; + +class TuxFragRef { + friend class Dblqh; + friend class Dbtux; +public: + STATIC_CONST( SignalLength = 2 ); + enum ErrorCode { + NoError = 0, + InvalidRequest = 800, + NoFreeFragmentOper = 830, + NoFreeIndexFragment = 852, + NoFreeFragment = 604, + NoFreeAttributes = 827 + }; +private: + Uint32 userPtr; + Uint32 errorCode; +}; + +// TUP: add attribute + +class TupAddAttrReq { + friend class Dblqh; + friend class Dbtux; +public: + STATIC_CONST( SignalLength = 4 ); +private: + Uint32 tupConnectPtr; + Uint32 notused1; + Uint32 attrId; + Uint32 attrDescriptor; +}; + +class TupAddAttrConf { + friend class Dblqh; + friend class Dbtup; +public: + STATIC_CONST( SignalLength = 1 ); +private: + Uint32 userPtr; +}; + +class TupAddAttrRef { + friend class Dblqh; + friend class Dbtup; +public: + STATIC_CONST( SignalLength = 2 ); +private: + Uint32 userPtr; + Uint32 errorCode; +}; + +// TUX: add attribute + +class TuxAddAttrReq { + friend class Dblqh; + friend class Dbtux; +public: + STATIC_CONST( SignalLength = 6 ); +private: + Uint32 tuxConnectPtr; + Uint32 notused1; + Uint32 attrId; + Uint32 attrDescriptor; + Uint32 extTypeInfo; + Uint32 primaryAttrId; +}; + +class TuxAddAttrConf { + friend class Dblqh; + friend class Dbtux; +public: + STATIC_CONST( SignalLength = 1 ); +private: + Uint32 userPtr; +}; + +class TuxAddAttrRef { + friend class Dblqh; + friend class Dbtux; +public: + STATIC_CONST( SignalLength = 2 ); + enum ErrorCode { + NoError = 0, + InvalidAttributeType = 831, + InvalidNodeSize = 832 + }; +private: + Uint32 userPtr; + Uint32 errorCode; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/TupKey.hpp b/ndb/include/kernel/signaldata/TupKey.hpp new file mode 100644 index 00000000000..304bebbec88 --- /dev/null +++ b/ndb/include/kernel/signaldata/TupKey.hpp @@ -0,0 +1,126 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TUP_KEY_H +#define TUP_KEY_H + +#include "SignalData.hpp" + +class TupKeyReq { + /** + * Reciver(s) + */ + friend class Dbtup; + + /** + * Sender(s) + */ + friend class Dblqh; + + /** + * For printing + */ + friend bool printTUPKEYREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + STATIC_CONST( SignalLength = 18 ); + +private: + + /** + * DATA VARIABLES + */ + Uint32 connectPtr; + Uint32 request; + Uint32 tableRef; + Uint32 fragId; + Uint32 keyRef1; + Uint32 keyRef2; + Uint32 attrBufLen; + Uint32 opRef; + Uint32 applRef; + Uint32 schemaVersion; + Uint32 storedProcedure; + Uint32 transId1; + Uint32 transId2; + Uint32 fragPtr; + Uint32 primaryReplica; + Uint32 coordinatorTC; + Uint32 tcOpIndex; + Uint32 savePointId; +}; + +class TupKeyConf { + /** + * Reciver(s) + */ + friend class Dblqh; + + /** + * Sender(s) + */ + friend class Dbtup; + + /** + * For printing + */ + friend bool printTUPKEYCONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + STATIC_CONST( SignalLength = 6 ); + +private: + + /** + * DATA VARIABLES + */ + Uint32 userPtr; + Uint32 pageId; + Uint32 pageIndex; + Uint32 readLength; + Uint32 writeLength; + Uint32 noFiredTriggers; +}; + +class TupKeyRef { + /** + * Reciver(s) + */ + friend class Dblqh; + + /** + * Sender(s) + */ + friend class Dbtup; + + /** + * For printing + */ + friend bool printTUPKEYREF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo); + +public: + STATIC_CONST( SignalLength = 2 ); + +private: + + /** + * DATA VARIABLES + */ + Uint32 userRef; + Uint32 errorCode; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/TupSizeAltReq.hpp b/ndb/include/kernel/signaldata/TupSizeAltReq.hpp new file mode 100644 index 00000000000..215493bc188 --- /dev/null +++ b/ndb/include/kernel/signaldata/TupSizeAltReq.hpp @@ -0,0 +1,58 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TUP_SIZE_ALT_REQ_H +#define TUP_SIZE_ALT_REQ_H + + + +#include "SignalData.hpp" + +class TupSizeAltReq { + /** + * Sender(s) + */ + friend class ClusterConfiguration; + + /** + * Reciver(s) + */ + friend class Dbtup; +private: + /** + * Indexes in theData + */ + STATIC_CONST( IND_BLOCK_REF = 0 ); + STATIC_CONST( IND_DISK_PAGE_ARRAY = 1 ); + STATIC_CONST( IND_DISK_PAGE_REPRESENT = 2 ); + STATIC_CONST( IND_FRAG = 3 ); + STATIC_CONST( IND_PAGE_CLUSTER = 4 ); + STATIC_CONST( IND_LOGIC_PAGE = 5 ); + STATIC_CONST( IND_OP_RECS = 6 ); + STATIC_CONST( IND_PAGE = 7 ); + STATIC_CONST( IND_PAGE_RANGE = 8 ); + STATIC_CONST( IND_TABLE = 9 ); + STATIC_CONST( IND_TABLE_DESC = 10 ); + STATIC_CONST( IND_DELETED_BLOCKS = 11 ); + STATIC_CONST( IND_STORED_PROC = 12 ); + + /** + * Use the index definitions to use the signal data + */ + UintR theData[13]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/TuxBound.hpp b/ndb/include/kernel/signaldata/TuxBound.hpp new file mode 100644 index 00000000000..1f256150573 --- /dev/null +++ b/ndb/include/kernel/signaldata/TuxBound.hpp @@ -0,0 +1,56 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TUX_BOUND_HPP +#define TUX_BOUND_HPP + +#include "SignalData.hpp" + +class TuxBoundInfo { + friend class Dblqh; + friend class Dbtux; +public: + // must match API (0-4 and no changes expected) + enum BoundType { + BoundLE = 0, // bit 1 for less/greater + BoundLT = 1, // bit 0 for strict + BoundGE = 2, + BoundGT = 3, + BoundEQ = 4 + }; + enum ErrorCode { + InvalidAttrInfo = 4110, + InvalidBounds = 4259, + OutOfBuffers = 873 + }; + STATIC_CONST( SignalLength = 3 ); +private: + /* + * Error code set by TUX. Zero means no error. + */ + Uint32 errorCode; + /* + * Pointer (i-value) to scan operation in TUX. + */ + Uint32 tuxScanPtrI; + /* + * Number of words of bound info included after fixed signal data. + * Starts with 5 unused words (word 0 is length used by LQH). + */ + Uint32 boundAiLength; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/TuxContinueB.hpp b/ndb/include/kernel/signaldata/TuxContinueB.hpp new file mode 100644 index 00000000000..385d85715e2 --- /dev/null +++ b/ndb/include/kernel/signaldata/TuxContinueB.hpp @@ -0,0 +1,30 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TUX_CONTINUEB_H +#define TUX_CONTINUEB_H + +#include "SignalData.hpp" + +class TuxContinueB { + friend class Dbtux; +private: + enum { + DropIndex = 1 + }; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/TuxMaint.hpp b/ndb/include/kernel/signaldata/TuxMaint.hpp new file mode 100644 index 00000000000..44deb33be80 --- /dev/null +++ b/ndb/include/kernel/signaldata/TuxMaint.hpp @@ -0,0 +1,66 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TUX_MAINT_HPP +#define TUX_MAINT_HPP + +#include "SignalData.hpp" + +/* + * Ordered index maintenance operation. + */ + +class TuxMaintReq { + friend class Dbtup; + friend class Dbtux; + friend bool printTUX_MAINT_REQ(FILE*, const Uint32*, Uint32, Uint16); +public: + enum OpCode { // first byte of opInfo + OpAdd = 1, + OpRemove = 2 + }; + enum OpFlag { // second byte of opInfo + }; + enum ErrorCode { + NoError = 0, // must be zero + SearchError = 895, // add + found or remove + not found + NoMemError = 827 + }; + STATIC_CONST( SignalLength = 7 ); +private: + /* + * Error code set by TUX. Zero means no error. + */ + Uint32 errorCode; + /* + * Table, index, fragment. + */ + Uint32 tableId; + Uint32 indexId; + Uint32 fragId; + /* + * Tuple version identified by logical address of "original" tuple and + * version number. + */ + Uint32 tupAddr; + Uint32 tupVersion; + /* + * Operation code and flags. + */ + Uint32 opInfo; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/TuxSizeAltReq.hpp b/ndb/include/kernel/signaldata/TuxSizeAltReq.hpp new file mode 100644 index 00000000000..5d5a0e102ba --- /dev/null +++ b/ndb/include/kernel/signaldata/TuxSizeAltReq.hpp @@ -0,0 +1,48 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TUX_SIZE_ALT_REQ_H +#define TUX_SIZE_ALT_REQ_H + +#include "SignalData.hpp" + +class TuxSizeAltReq { + /** + * Sender(s) + */ + friend class ClusterConfiguration; + + /** + * Receiver(s) + */ + friend class Dbtux; +private: + /** + * Indexes in theData + */ + STATIC_CONST( IND_BLOCK_REF = 0 ); + STATIC_CONST( IND_INDEX = 1 ); + STATIC_CONST( IND_FRAGMENT = 2 ); + STATIC_CONST( IND_ATTRIBUTE = 3 ); + STATIC_CONST( IND_SCAN = 4 ); + + /** + * Use the index definitions to use the signal data + */ + UintR theData[4]; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/UpdateTo.hpp b/ndb/include/kernel/signaldata/UpdateTo.hpp new file mode 100644 index 00000000000..0fa5f31b6b4 --- /dev/null +++ b/ndb/include/kernel/signaldata/UpdateTo.hpp @@ -0,0 +1,59 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef UPDATE_TO_HPP +#define UPDATE_TO_HPP + +class UpdateToReq { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 6 ); +private: + enum UpdateState { + TO_COPY_FRAG_COMPLETED = 0, + TO_COPY_COMPLETED = 1 + }; + Uint32 userPtr; + BlockReference userRef; + UpdateState updateState; + Uint32 startingNodeId; + + /** + * Only when TO_COPY_FRAG_COMPLETED + */ + Uint32 tableId; + Uint32 fragmentNo; +}; + +class UpdateToConf { + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + +public: + STATIC_CONST( SignalLength = 3 ); +private: + + Uint32 userPtr; + Uint32 sendingNodeId; + Uint32 startingNodeId; +}; +#endif diff --git a/ndb/include/kernel/signaldata/UtilDelete.hpp b/ndb/include/kernel/signaldata/UtilDelete.hpp new file mode 100644 index 00000000000..67c13b8c2d5 --- /dev/null +++ b/ndb/include/kernel/signaldata/UtilDelete.hpp @@ -0,0 +1,121 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef UTIL_DELETE_HPP +#define UTIL_DELETE_HPP + +#include "SignalData.hpp" +#include + +/** + * UTIL_DELETE_REQ, UTIL_DELETE_CONF, UTIL_DELETE_REF + */ + +/** + * @class UtilDeleteReq + * @brief Delete transaction in Util block + * + * Data format: + * - UTIL_DELETE_REQ + */ + +class UtilDeleteReq { + /** Sender(s) / Receiver(s) */ + friend class DbUtil; + + /** For printing */ + friend bool printUTIL_DELETE_REQ(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo); +public: + STATIC_CONST( DataLength = 22 ); + STATIC_CONST( HeaderLength = 3 ); + +private: + Uint32 senderData; + Uint32 prepareId; // Which prepared transaction to execute + Uint32 totalDataLen; // Total length of attrData (including AttributeHeaders + // and possibly spanning over multiple signals) + + /** + * Length in this = signal->length() - 3 + * Sender block ref = signal->senderBlockRef() + */ + + Uint32 attrData[DataLength]; +}; + + + +/** + * @class UtilDeleteConf + * + * Data format: + * - UTIL_PREPARE_CONF + */ + +class UtilDeleteConf { + /** + * Sender(s) / Receiver(s) + */ + friend class DbUtil; + + /** + * For printing + */ + friend bool printUTIL_DELETE_CONF(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 receiverBlockNo); + + STATIC_CONST( SignalLength = 1 ); + +private: + Uint32 senderData; ///< The client data provided by the client sending + ///< UTIL_DELETE_REQ +}; + + +/** + * @class UtilDeleteRef + * + * Data format: + * - UTIL_PREPARE_REF + */ + +class UtilDeleteRef { + /** + * Sender(s) / Receiver(s) + */ + friend class DbUtil; + + /** + * For printing + */ + friend bool printUTIL_DELETE_REF(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 receiverBlockNo); + + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 senderData; + Uint32 errorCode; ///< See UtilExecuteRef::errorCode + Uint32 TCErrorCode; +}; + + +#endif diff --git a/ndb/include/kernel/signaldata/UtilExecute.hpp b/ndb/include/kernel/signaldata/UtilExecute.hpp new file mode 100644 index 00000000000..551fb172cac --- /dev/null +++ b/ndb/include/kernel/signaldata/UtilExecute.hpp @@ -0,0 +1,136 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef UTIL_EXECUTE_HPP +#define UTIL_EXECUTE_HPP + +#include "SignalData.hpp" +#include + +/** + * UTIL_EXECUTE_REQ, UTIL_EXECUTE_CONF, UTIL_EXECUTE_REF + */ + +/** + * @class UtilExecuteReq + * @brief Execute transaction in Util block + * + * Data format: + * - UTIL_EXECUTE_REQ + */ + +class UtilExecuteReq { + /** Sender(s) / Receiver(s) */ + friend class DbUtil; + friend class Trix; + + /** For printing */ + friend bool printUTIL_EXECUTE_REQ(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo); +public: + STATIC_CONST( SignalLength = 3 ); + STATIC_CONST( HEADER_SECTION = 0 ); + STATIC_CONST( DATA_SECTION = 1 ); + STATIC_CONST( NoOfSections = 2 ); + + GET_SET_SENDERREF + GET_SET_SENDERDATA + void setPrepareId(Uint32 pId) { prepareId = pId; }; // !! unsets release flag + Uint32 getPrepareId() { return prepareId & 0xFF; }; + void setReleaseFlag() { prepareId |= 0x100; }; + bool getReleaseFlag() { return (prepareId & 0x100) != 0; }; +private: + Uint32 senderData; // MUST be no 1! + Uint32 senderRef; + Uint32 prepareId; // Which prepared transaction to execute +}; + +/** + * @class UtilExecuteConf + * + * Data format: + * - UTIL_PREPARE_CONF + */ + +class UtilExecuteConf { + /** + * Sender(s) / Receiver(s) + */ + friend class DbUtil; + friend class Trix; + + /** + * For printing + */ + friend bool printUTIL_EXECUTE_CONF(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 receiverBlockNo); +public: + STATIC_CONST( SignalLength = 1 ); + + GET_SET_SENDERDATA +private: + Uint32 senderData; // MUST be no 1! +}; + + +/** + * @class UtilExecuteRef + * + * Data format: + * - UTIL_PREPARE_REF + */ + +class UtilExecuteRef { + /** + * Sender(s) / Receiver(s) + */ + friend class DbUtil; + friend class Trix; + + /** + * For printing + */ + friend bool printUTIL_EXECUTE_REF(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 receiverBlockNo); + +public: + STATIC_CONST( SignalLength = 3 ); + + enum ErrorCode { + IllegalKeyNumber = 1, + IllegalAttrNumber = 2, + TCError = 3, + IllegalPrepareId = 4, + AllocationError = 5, + MissingDataSection = 6, + MissingData = 7 + }; + + GET_SET_SENDERDATA + GET_SET_ERRORCODE + GET_SET_TCERRORCODE +private: + Uint32 senderData; // MUST be no 1! + Uint32 errorCode; + Uint32 TCErrorCode; +}; + + +#endif diff --git a/ndb/include/kernel/signaldata/UtilLock.hpp b/ndb/include/kernel/signaldata/UtilLock.hpp new file mode 100644 index 00000000000..1cac467daa0 --- /dev/null +++ b/ndb/include/kernel/signaldata/UtilLock.hpp @@ -0,0 +1,334 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef UTIL_LOCK_HPP +#define UTIL_LOCK_HPP + +#include "SignalData.hpp" + +class UtilLockReq { + + /** + * Receiver + */ + friend class DbUtil; + + /** + * Sender + */ + friend class Dbdih; + friend class MutexManager; + + friend bool printUTIL_LOCK_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + enum RequestInfo { + TryLock = 1 + }; +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 lockId; + Uint32 requestInfo; +}; + +class UtilLockConf { + + /** + * Receiver + */ + friend class Dbdih; + friend class MutexManager; + + /** + * Sender + */ + friend class DbUtil; + + friend bool printUTIL_LOCK_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 lockId; + Uint32 lockKey; +}; + +class UtilLockRef { + + /** + * Reciver + */ + friend class Dbdih; + friend class MutexManager; + + /** + * Sender + */ + friend class DbUtil; + + friend bool printUTIL_LOCK_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + enum ErrorCode { + OK = 0, + NoSuchLock = 1, + OutOfLockRecords = 2, + DistributedLockNotSupported = 3, + LockAlreadyHeld = 4 + + }; +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 lockId; + Uint32 errorCode; +}; + +class UtilUnlockReq { + + /** + * Receiver + */ + friend class DbUtil; + + /** + * Sender + */ + friend class Dbdih; + friend class MutexManager; + + friend bool printUTIL_UNLOCK_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 lockId; + Uint32 lockKey; +}; + +class UtilUnlockConf { + + /** + * Receiver + */ + friend class Dbdih; + friend class MutexManager; + + /** + * Sender + */ + friend class DbUtil; + + friend bool printUTIL_UNLOCK_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 lockId; +}; + +class UtilUnlockRef { + + /** + * Reciver + */ + friend class Dbdih; + friend class MutexManager; + + /** + * Sender + */ + friend class DbUtil; + + friend bool printUTIL_UNLOCK_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + + enum ErrorCode { + OK = 0, + NoSuchLock = 1, + NotLockOwner = 2 + }; +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 lockId; + Uint32 errorCode; +}; + +/** + * Creating a lock + */ +class UtilCreateLockReq { + /** + * Receiver + */ + friend class DbUtil; + + /** + * Sender + */ + friend class MutexManager; + + friend bool printUTIL_CREATE_LOCK_REQ(FILE *, const Uint32*, Uint32, Uint16); +public: + enum LockType { + Mutex = 0 // Lock with only exclusive locks + }; + + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 lockId; + Uint32 lockType; +}; + +class UtilCreateLockRef { + /** + * Sender + */ + friend class DbUtil; + + /** + * Receiver + */ + friend class MutexManager; + + friend bool printUTIL_CREATE_LOCK_REF(FILE *, const Uint32*, Uint32, Uint16); +public: + enum ErrorCode { + OK = 0, + OutOfLockQueueRecords = 1, + LockIdAlreadyUsed = 2, + UnsupportedLockType = 3 + }; + + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 lockId; + Uint32 errorCode; +}; + +class UtilCreateLockConf { + /** + * Sender + */ + friend class DbUtil; + + /** + * Receiver + */ + friend class MutexManager; + + friend bool printUTIL_CREATE_LOCK_CONF(FILE*, const Uint32*, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 lockId; +}; + +/** + * Creating a lock + */ +class UtilDestroyLockReq { + /** + * Receiver + */ + friend class DbUtil; + + /** + * Sender + */ + friend class MutexManager; + + friend bool printUTIL_DESTROY_LOCK_REQ(FILE *, const Uint32*, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 lockId; + Uint32 lockKey; +}; + +class UtilDestroyLockRef { + /** + * Sender + */ + friend class DbUtil; + + /** + * Receiver + */ + friend class MutexManager; + + friend bool printUTIL_DESTROY_LOCK_REF(FILE *, const Uint32*, Uint32, Uint16); +public: + enum ErrorCode { + OK = 0, + NoSuchLock = 1, + NotLockOwner = 2 + }; + + STATIC_CONST( SignalLength = 4 ); + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 lockId; + Uint32 errorCode; +}; + +class UtilDestroyLockConf { + /** + * Sender + */ + friend class DbUtil; + + /** + * Receiver + */ + friend class MutexManager; + + friend bool printUTIL_DESTROY_LOCK_CONF(FILE*, const Uint32*, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 senderData; + Uint32 senderRef; + Uint32 lockId; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/UtilPrepare.hpp b/ndb/include/kernel/signaldata/UtilPrepare.hpp new file mode 100644 index 00000000000..8508487ce15 --- /dev/null +++ b/ndb/include/kernel/signaldata/UtilPrepare.hpp @@ -0,0 +1,161 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef UTIL_PREPARE_REQ_HPP +#define UTIL_PREPARE_REQ_HPP + +#include "SignalData.hpp" +#include + +#ifdef NDB_WIN32 +#ifdef NO_ERROR +#undef NO_ERROR +#endif +#endif + +/** + * UTIL_PREPARE_REQ, UTIL_PREPARE_CONF, UTIL_PREPARE_REF + */ + +/** + * @class UtilPrepareReq + * @brief Prepare transaction in Util block + * + * Data format: + * - UTIL_PREPARE_REQ ( +)+ + */ +class UtilPrepareReq { + /** + * Sender(s) / Receiver(s) + */ + friend class DbUtil; + friend class Trix; + + /** + * For printing + */ + friend bool printUTIL_PREPARE_REQ(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 receiverBlockNo); + +public: + enum OperationTypeValue { + Read = 0, + Update = 1, + Insert = 2, + Delete = 3, + Write = 4 + + }; + + enum KeyValue { + NoOfOperations = 1, ///< No of operations in transaction + OperationType = 2, /// + TableName = 3, ///< String + AttributeName = 4, ///< String + TableId = 5, + AttributeId = 6 + }; + + // Signal constants + STATIC_CONST( SignalLength = 2 ); + STATIC_CONST( PROPERTIES_SECTION = 0 ); + STATIC_CONST( NoOfSections = 1 ); + + GET_SET_SENDERREF + GET_SET_SENDERDATA +private: + Uint32 senderData; // MUST be no 1! + Uint32 senderRef; +}; + +/** + * @class UtilPrepareConf + * + * Data format: + * - UTIL_PREPARE_CONF + */ + +class UtilPrepareConf { + /** + * Sender(s) / Receiver(s) + */ + friend class DbUtil; + friend class Trix; + + /** + * For printing + */ + friend bool printUTIL_PREPARE_CONF(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 receiverBlockNo); + +public: + STATIC_CONST( SignalLength = 2 ); + + GET_SET_SENDERDATA + GET_SET_PREPAREID +private: + Uint32 senderData; // MUST be no 1! + Uint32 prepareId; +}; + + +/** + * @class UtilPrepareRef + * + * Data format: + * - UTIL_PREPARE_REF + */ + +class UtilPrepareRef { + /** + * Sender(s) / Receiver(s) + */ + friend class DbUtil; + friend class Trix; + + /** + * For printing + */ + friend bool printUTIL_PREPARE_REF(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 receiverBlockNo); + +public: + enum ErrorCode { + NO_ERROR = 0, + PREPARE_SEIZE_ERROR = 1, + PREPARE_PAGES_SEIZE_ERROR = 2, + PREPARED_OPERATION_SEIZE_ERROR = 3, + DICT_TAB_INFO_ERROR = 4, + MISSING_PROPERTIES_SECTION = 5 + }; + + STATIC_CONST( SignalLength = 2 ); + + GET_SET_SENDERDATA + GET_SET_ERRORCODE +private: + Uint32 senderData; // MUST be no 1! + Uint32 errorCode; +}; + + +#endif diff --git a/ndb/include/kernel/signaldata/UtilRelease.hpp b/ndb/include/kernel/signaldata/UtilRelease.hpp new file mode 100644 index 00000000000..d2864f02f47 --- /dev/null +++ b/ndb/include/kernel/signaldata/UtilRelease.hpp @@ -0,0 +1,83 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef UTIL_RELEASE_HPP +#define UTIL_PREPARE_HPP + +#include "SignalData.hpp" + +/** + * @class UtilReleaseReq + * @brief Release Prepared transaction in Util block + * + * Data format: + * - UTIL_PREPARE_RELEASE_REQ + */ +class UtilReleaseReq { + friend class DbUtil; + friend class Trix; +public: + STATIC_CONST( SignalLength = 2 ); + +private: + Uint32 senderData; // MUST be no 1! + Uint32 prepareId; +}; + + +/** + * @class UtilReleaseConf + * + * Data format: + * - UTIL_PREPARE_CONF + */ + +class UtilReleaseConf { + friend class DbUtil; + friend class Trix; + + STATIC_CONST( SignalLength = 1 ); + +private: + Uint32 senderData; // MUST be no 1! +}; + + +/** + * @class UtilReleaseRef + * + * Data format: + * - UTIL_PREPARE_RELEASE_REF + */ + +class UtilReleaseRef { + friend class DbUtil; + friend class Trix; + + enum ErrorCode { + NO_ERROR = 0, + NO_SUCH_PREPARE_SEIZED = 1 + }; + + STATIC_CONST( SignalLength = 3 ); + +private: + Uint32 senderData; // MUST be no 1! + Uint32 prepareId; + Uint32 errorCode; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/UtilSequence.hpp b/ndb/include/kernel/signaldata/UtilSequence.hpp new file mode 100644 index 00000000000..50e5d673e99 --- /dev/null +++ b/ndb/include/kernel/signaldata/UtilSequence.hpp @@ -0,0 +1,101 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef UTIL_SEQUENCE_HPP +#define UTIL_SEQUENCE_HPP + +#include "SignalData.hpp" + +class UtilSequenceReq { + + /** + * Receiver + */ + friend class DbUtil; + + /** + * Sender + */ + friend class Backup; + friend class Suma; + + friend bool printUTIL_SEQUENCE_REQ(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 3 ); + + enum RequestType { + NextVal = 1, // Return uniq value + CurrVal = 2, // Read + Create = 3 // Create a sequence + }; +private: + Uint32 senderData; + Uint32 sequenceId; // Number of sequence variable + Uint32 requestType; +}; + +class UtilSequenceConf { + + /** + * Receiver + */ + friend class Backup; + friend class Suma; + /** + * Sender + */ + friend class DbUtil; + + friend bool printUTIL_SEQUENCE_CONF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + +private: + Uint32 senderData; + Uint32 sequenceId; + Uint32 requestType; + Uint32 sequenceValue[2]; +}; + +class UtilSequenceRef { + + /** + * Reciver + */ + friend class Backup; + friend class Suma; + /** + * Sender + */ + friend class DbUtil; + + friend bool printUTIL_SEQUENCE_REF(FILE *, const Uint32 *, Uint32, Uint16); +public: + STATIC_CONST( SignalLength = 5 ); + + enum ErrorCode { + NoSuchSequence = 1, + TCError = 2 + }; +private: + Uint32 senderData; + Uint32 sequenceId; + Uint32 requestType; + Uint32 errorCode; + Uint32 TCErrorCode; +}; + +#endif diff --git a/ndb/include/kernel/signaldata/WaitGCP.hpp b/ndb/include/kernel/signaldata/WaitGCP.hpp new file mode 100644 index 00000000000..ebed28714d2 --- /dev/null +++ b/ndb/include/kernel/signaldata/WaitGCP.hpp @@ -0,0 +1,109 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef WAIT_GCP_HPP +#define WAIT_GCP_HPP + +/** + * This signal is sent by anyone to local DIH + * + * If local DIH is not master, it forwards it to master DIH + * and start acting as a proxy + * + */ +class WaitGCPReq { + + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + + /** + * Sender + */ + friend class Ndbcntr; + friend class Dbdict; + friend class Backup; + //friend class Grep::PSCoord; + +public: + STATIC_CONST( SignalLength = 3 ); +public: + enum RequestType { + Complete = 1, ///< Wait for a GCP to complete + CompleteForceStart = 2, ///< Wait for a GCP to complete start one if needed + CompleteIfRunning = 3, ///< Wait for ongoing GCP + CurrentGCI = 8 ///< Immediately return current GCI + }; + + Uint32 senderRef; + Uint32 senderData; + Uint32 requestType; +}; + +class WaitGCPConf { + + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + + /** + * Reciver(s) + */ + friend class Ndbcntr; + friend class Dbdict; + friend class Backup; + //friend class Grep::PSCoord; + +public: + STATIC_CONST( SignalLength = 2 ); + +public: + Uint32 senderData; + Uint32 gcp; +}; + +class WaitGCPRef { + + /** + * Sender(s) / Reciver(s) + */ + friend class Dbdih; + + /** + * Reciver(s) + */ + friend class Ndbcntr; + friend class Dbdict; + friend class Backup; + friend class Grep; + +public: + STATIC_CONST( SignalLength = 2 ); + + enum ErrorCode { + StopOK = 0, + NF_CausedAbortOfProcedure = 1, + NoWaitGCPRecords = 2 + }; + +private: + Uint32 errorCode; + Uint32 senderData; +}; + +#endif diff --git a/ndb/include/kernel/trigger_definitions.h b/ndb/include/kernel/trigger_definitions.h new file mode 100644 index 00000000000..a5e7fb1953c --- /dev/null +++ b/ndb/include/kernel/trigger_definitions.h @@ -0,0 +1,66 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_TRIGGER_DEFINITIONS_H +#define NDB_TRIGGER_DEFINITIONS_H + +#include "ndb_limits.h" + +#ifndef MIN +#define MIN(x,y) (((x)<(y))?(x):(y)) +#endif + +#ifndef MAX +#define MAX(x,y) (((x)>(y))?(x):(y)) +#endif + +#define ILLEGAL_TRIGGER_ID ((Uint32)(~0)) + +struct TriggerType { + enum Value { + CONSTRAINT = 0, + SECONDARY_INDEX = 1, + FOREIGN_KEY = 2, + SCHEMA_UPGRADE = 3, + API_TRIGGER = 4, + SQL_TRIGGER = 5, + SUBSCRIPTION = 6, + READ_ONLY_CONSTRAINT = 7, + ORDERED_INDEX = 8, + SUBSCRIPTION_BEFORE = 9 + }; +}; + +struct TriggerActionTime { + enum Value { + TA_BEFORE = 0, // Immediate, before operation + TA_AFTER = 1, // Immediate, after operation + TA_DEFERRED = 2, // Before commit + TA_DETACHED = 3, // After commit in a separate transaction, NYI + TA_CUSTOM = 4 // Hardcoded per TriggerType + }; +}; + +struct TriggerEvent { + enum Value { + TE_INSERT = 0, + TE_DELETE = 1, + TE_UPDATE = 2, + TE_CUSTOM = 3 // Hardcoded per TriggerType + }; +}; + +#endif diff --git a/ndb/include/logger/ConsoleLogHandler.hpp b/ndb/include/logger/ConsoleLogHandler.hpp new file mode 100644 index 00000000000..ae77b13d3b7 --- /dev/null +++ b/ndb/include/logger/ConsoleLogHandler.hpp @@ -0,0 +1,57 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CONSOLELOGHANDLER_H +#define CONSOLELOGHANDLER_H + +#include "LogHandler.hpp" + +/** + * Logs messages to the console/stdout. + * + * @see LogHandler + * @version #@ $Id: ConsoleLogHandler.hpp,v 1.2 2003/09/01 10:15:53 innpeno Exp $ + */ +class ConsoleLogHandler : public LogHandler +{ +public: + /** + * Default constructor. + */ + ConsoleLogHandler(); + /** + * Destructor. + */ + virtual ~ConsoleLogHandler(); + + virtual bool open(); + virtual bool close(); + + virtual bool setParam(const BaseString ¶m, const BaseString &value); + +protected: + virtual void writeHeader(const char* pCategory, Logger::LoggerLevel level); + virtual void writeMessage(const char* pMsg); + virtual void writeFooter(); + +private: + /** Prohibit*/ + ConsoleLogHandler(const ConsoleLogHandler&); + ConsoleLogHandler operator = (const ConsoleLogHandler&); + bool operator == (const ConsoleLogHandler&); + +}; +#endif diff --git a/ndb/include/logger/FileLogHandler.hpp b/ndb/include/logger/FileLogHandler.hpp new file mode 100644 index 00000000000..ae69a2f5418 --- /dev/null +++ b/ndb/include/logger/FileLogHandler.hpp @@ -0,0 +1,110 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef FILELOGHANDLER_H +#define FILELOGHANDLER_H + +#include "LogHandler.hpp" + +class File; + +/** + * Logs messages to a file. The log file will be archived depending on + * the file's size or after N number of log entries. + * There will be only a specified number of archived logs + * which will be "recycled". + * + * The archived log file will be named as .1..N. + * + * + * @see LogHandler + * @version #@ $Id: FileLogHandler.hpp,v 1.2 2003/09/01 10:15:53 innpeno Exp $ + */ +class FileLogHandler : public LogHandler +{ +public: + /** Max number of log files to archive. */ + static const int MAX_NO_FILES = 6; + /** Max file size of the log before archiving. */ + static const long MAX_FILE_SIZE = 1024000; + /** Max number of log entries before archiving. */ + static const unsigned int MAX_LOG_ENTRIES = 10000; + + /** + * Default constructor. + */ + FileLogHandler(); + + /** + * Creates a new file handler with the specified filename, + * max number of archived log files and max log size for each log. + * + * @param aFileName the log filename. + * @param maxNoFiles the maximum number of archived log files. + * @param maxFileSize the maximum log file size before archiving. + * @param maxLogEntries the maximum number of log entries before checking time to archive. + */ + FileLogHandler(const char* aFileName, + int maxNoFiles = MAX_NO_FILES, + long maxFileSize = MAX_FILE_SIZE, + unsigned int maxLogEntries = MAX_LOG_ENTRIES); + + /** + * Destructor. + */ + virtual ~FileLogHandler(); + + virtual bool open(); + virtual bool close(); + + virtual bool setParam(const BaseString ¶m, const BaseString &value); + virtual bool checkParams(); + +protected: + virtual void writeHeader(const char* pCategory, Logger::LoggerLevel level); + virtual void writeMessage(const char* pMsg); + virtual void writeFooter(); + +private: + /** Prohibit */ + FileLogHandler(const FileLogHandler&); + FileLogHandler operator = (const FileLogHandler&); + bool operator == (const FileLogHandler&); + + /** + * Returns true if it is time to create a new log file. + */ + bool isTimeForNewFile(); + + /** + * Archives the current log file and creates a new one. + * The archived log filename will be in the format of .N + * + * @return true if successful. + */ + bool createNewFile(); + + bool setFilename(const BaseString &filename); + bool setMaxSize(const BaseString &size); + bool setMaxFiles(const BaseString &files); + + int m_maxNoFiles; + long m_maxFileSize; + unsigned int m_maxLogEntries; + File* m_pLogFile; +}; + +#endif diff --git a/ndb/include/logger/LogHandler.hpp b/ndb/include/logger/LogHandler.hpp new file mode 100644 index 00000000000..8c5c9298f69 --- /dev/null +++ b/ndb/include/logger/LogHandler.hpp @@ -0,0 +1,198 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef LOGHANDLER_H +#define LOGHANDLER_H + +#include "Logger.hpp" + +#include // Defines NULL + +/** + * This class is the base class for all log handlers. A log handler is + * responsible for formatting and writing log messages to a specific output. + * + * A log entry consists of three parts: a header, + * 09:17:37 2002-03-13 [MgmSrv] INFO -- Local checkpoint 13344 started. + * + * + * Header format: TIME&DATE CATEGORY LEVEL -- + * TIME&DATE = ctime() format. + * CATEGORY = Any string. + * LEVEL = ALERT to DEBUG (Log levels) + * + * Footer format: \n (currently only newline) + * + * @version #@ $Id: LogHandler.hpp,v 1.7 2003/09/01 10:15:53 innpeno Exp $ + */ +class LogHandler +{ +public: + /** + * Default constructor. + */ + LogHandler(); + + /** + * Destructor. + */ + virtual ~LogHandler(); + + /** + * Opens/initializes the log handler. + * + * @return true if successful. + */ + virtual bool open() = 0; + + /** + * Closes/free any allocated resources used by the log handler. + * + * @return true if successful. + */ + virtual bool close() = 0; + + /** + * Append a log message to the output stream/file whatever. + * append() will call writeHeader(), writeMessage() and writeFooter() for + * a child class and in that order. + * + * @param pCategory the category/name to tag the log entry with. + * @param level the log level. + * @param pMsg the log message. + */ + void append(const char* pCategory, Logger::LoggerLevel level, + const char* pMsg); + + /** + * Returns a default formatted header. It currently has the + * follwing default format: '%H:%M:%S %Y-%m-%d [CATEGORY] LOGLEVEL --' + * + * @param pStr the header string to format. + * @param pCategory a category/name to tag the log entry with. + * @param level the log level. + * @return the header. + */ + const char* getDefaultHeader(char* pStr, const char* pCategory, + Logger::LoggerLevel level) const; + + /** + * Returns a default formatted footer. Currently only returns a newline. + * + * @return the footer. + */ + const char* getDefaultFooter() const; + + /** + * Returns the date and time format used by ctime(). + * + * @return the date and time format. + */ + const char* getDateTimeFormat() const; + + /** + * Sets the date and time format. It needs to have the same arguments + * a ctime(). + * + * @param pFormat the date and time format. + */ + void setDateTimeFormat(const char* pFormat); + + /** + * Returns a string date and time string. + * + * @param pStr a string. + * @return a string with date and time. + */ + char* getTimeAsString(char* pStr) const; + + /** + * Returns the error code. + */ + int getErrorCode() const; + + /** + * Sets the error code. + * + * @param code the error code. + */ + void setErrorCode(int code); + + /** + * Parse logstring parameters + * + * @param params list of parameters, formatted as "param=value", + * entries separated by "," + * @return true on success, false on failure + */ + bool parseParams(const BaseString ¶ms); + + /** + * Sets a parameters. What parameters are accepted depends on the subclass. + * + * @param param name of parameter + * @param value value of parameter + */ + virtual bool setParam(const BaseString ¶m, const BaseString &value) = 0; + + /** + * Checks that all necessary parameters have been set. + * + * @return true if all parameters are correctly set, false otherwise + */ + virtual bool checkParams(); + +protected: + /** Max length of the date and time header in the log. */ + static const int MAX_DATE_TIME_HEADER_LENGTH = 64; + /** Max length of the header the log. */ + static const int MAX_HEADER_LENGTH = 128; + /** Max lenght of footer in the log. */ + static const int MAX_FOOTER_LENGTH = 128; + + /** + * Write the header to the log. + * + * @param pCategory the category to tag the log with. + * @param level the log level. + */ + virtual void writeHeader(const char* category, Logger::LoggerLevel level) = 0; + + /** + * Write the message to the log. + * + * @param pMsg the message to log. + */ + virtual void writeMessage(const char* pMsg) = 0; + + /** + * Write the footer to the log. + * + */ + virtual void writeFooter() = 0; + +private: + /** Prohibit */ + LogHandler(const LogHandler&); + LogHandler* operator = (const LogHandler&); + bool operator == (const LogHandler&); + + const char* m_pDateTimeFormat; + int m_errorCode; +}; + +#endif diff --git a/ndb/include/logger/Logger.hpp b/ndb/include/logger/Logger.hpp new file mode 100644 index 00000000000..2d12a5b8a6e --- /dev/null +++ b/ndb/include/logger/Logger.hpp @@ -0,0 +1,294 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef Logger_H +#define Logger_H + +#include +#include + +class LogHandler; +class LogHandlerList; + +/** + * Logger should be used whenver you need to log a message like + * general information or debug messages. By creating/adding different + * log handlers, a single log message can be sent to + * different outputs (stdout, file or syslog). + * + * Each log entry is created with a log level (or severity) which is + * used to identity the type of the entry, e.g., if it is a debug + * or an error message. + * + * Example of a log entry: + * + * 09:17:39 2002-03-13 [myLogger] INFO -- Local checkpoint started. + * + * HOW TO USE + * + * 1) Create a new instance of the Logger. + * + * Logger myLogger = new Logger(); + * + * 2) Add the log handlers that you want, i.e., where the log entries + * should be written/shown. + * + * myLogger->createConsoleHandler(); // Output to console/stdout + * myLogger->addHandler(new FileLogHandler("mylog.txt")); // use mylog.txt + * + * 3) Tag each log entry with a category/name. + * + * myLogger->setCategory("myLogger"); + * + * 4) Start log messages. + * + * myLogger->alert("T-9 to lift off"); + * myLogger->info("Here comes the sun, la la"); + * myLogger->debug("Why does this not work!!!, We should not be here...") + * + * 5) Log only debug messages. + * + * myLogger->enable(Logger::LL_DEBUG); + * + * 6) Log only ALERTS and ERRORS. + * + * myLogger->enable(Logger::LL_ERROR, Logger::LL_ALERT); + * + * 7) Do not log any messages. + * + * myLogger->disable(Logger::LL_ALL); + * + * + * LOG LEVELS (Matches the severity levels of syslog) + * 
+ *
+ *  ALERT           A condition  that  should  be  corrected
+ *                  immediately,  such as a corrupted system
+ *                  database.
+ *
+ *  CRITICAL        Critical conditions, such as hard device
+ *                  errors.
+ *
+ *  ERROR           Errors.
+ *
+ *  WARNING         Warning messages.
+ *
+ *  INFO            Informational messages.
+ *
+ *  DEBUG           Messages that contain  information  nor-
+ *                  mally  of use only when debugging a pro-
+ *                  gram.
+ *
+ * + * @version #@ $Id: Logger.hpp,v 1.7 2003/09/01 10:15:53 innpeno Exp $ + */ +class Logger +{ +public: + /** The log levels. NOTE: Could not use the name LogLevel since + * it caused conflicts with another class. + */ + enum LoggerLevel {LL_OFF, LL_DEBUG, LL_INFO, LL_WARNING, LL_ERROR, + LL_CRITICAL, LL_ALERT, LL_ALL}; + + /** + * String representation of the the log levels. + */ + static const char* LoggerLevelNames[]; + + /** + * Default constructor. + */ + Logger(); + + /** + * Destructor. + */ + virtual ~Logger(); + + /** + * Set a category/name that each log entry will have. + * + * @param pCategory the category. + */ + void setCategory(const char* pCategory); + + /** + * Create a default handler that logs to the console/stdout. + * + * @return true if successful. + */ + bool createConsoleHandler(); + + /** + * Remove the default console handler. + */ + void removeConsoleHandler(); + + /** + * Create a default handler that logs to a file called logger.log. + * + * @return true if successful. + */ + bool createFileHandler(); + + /** + * Remove the default file handler. + */ + void removeFileHandler(); + + /** + * Create a default handler that logs to the syslog. + * + * On OSE a ConsoleHandler will be created since there is no syslog support. + * + * @return true if successful. + */ + bool createSyslogHandler(); + + /** + * Remove the default syslog handler. + */ + void removeSyslogHandler(); + + /** + * Add a new log handler. + * + * @param pHandler a log handler. + * @return true if successful. + */ + bool addHandler(LogHandler* pHandler); + + /** + * Add a new handler + * + * @param logstring string describing the handler to add + */ + bool addHandler(const BaseString &logstring); + + /** + * Remove a log handler. + * + * @param pHandler log handler to remove. + * @return true if successful. + */ + bool removeHandler(LogHandler* pHandler); + + /** + * Remove all log handlers. + */ + void removeAllHandlers(); + + /** + * Returns true if the specified log level is enabled. + * + * @return true if enabled. + */ + bool isEnable(LoggerLevel logLevel) const; + + /** + * Enable the specified log level. + * + * @param logLevel the loglevel to enable. + */ + void enable(LoggerLevel logLevel); + + /** + * Enable log levels. + * + * @param fromLogLevel enable from log level. + * @param toLogLevel enable to log level. + */ + void enable (LoggerLevel fromLogLevel, LoggerLevel toLogLevel); + + /** + * Disable log level. + * + * @param logLevel disable log level. + */ + void disable(LoggerLevel logLevel); + + /** + * Log an alert message. + * + * @param pMsg the message. + */ + virtual void alert(const char* pMsg, ...) const; + virtual void alert(BaseString &pMsg) const { alert(pMsg.c_str()); }; + + /** + * Log a critical message. + * + * @param pMsg the message. + */ + virtual void critical(const char* pMsg, ...) const; + virtual void critical(BaseString &pMsg) const { critical(pMsg.c_str()); }; + + /** + * Log an error message. + * + * @param pMsg the message. + */ + virtual void error(const char* pMsg, ...) const; + virtual void error(BaseString &pMsg) const { error(pMsg.c_str()); }; + + /** + * Log a warning message. + * + * @param pMsg the message. + */ + virtual void warning(const char* pMsg, ...) const; + virtual void warning(BaseString &pMsg) const { warning(pMsg.c_str()); }; + + /** + * Log an info message. + * + * @param pMsg the message. + */ + virtual void info(const char* pMsg, ...) const; + virtual void info(BaseString &pMsg) const { info(pMsg.c_str()); }; + + /** + * Log a debug message. + * + * @param pMsg the message. + */ + virtual void debug(const char* pMsg, ...) const; + virtual void debug(BaseString &pMsg) const { debug(pMsg.c_str()); }; + +protected: + + void log(LoggerLevel logLevel, const char* msg, va_list ap) const; + +private: + /** Prohibit */ + Logger(const Logger&); + Logger operator = (const Logger&); + bool operator == (const Logger&); + + static const int MAX_LOG_LEVELS = 8; + + bool m_logLevels[MAX_LOG_LEVELS]; + + LogHandlerList* m_pHandlerList; + const char* m_pCategory; + /* Default handlers */ + LogHandler* m_pConsoleHandler; + LogHandler* m_pFileHandler; + LogHandler* m_pSyslogHandler; +}; + +#endif diff --git a/ndb/include/logger/SysLogHandler.hpp b/ndb/include/logger/SysLogHandler.hpp new file mode 100644 index 00000000000..4f13308d61b --- /dev/null +++ b/ndb/include/logger/SysLogHandler.hpp @@ -0,0 +1,97 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SYSLOGHANDLER_H +#define SYSLOGHANDLER_H + +#include "LogHandler.hpp" +#include + +/** + * Logs messages to syslog. The default identity is 'NDB'. + * See 'man 3 syslog'. + * + * It logs the following severity levels. + * 
+ *
+ *  LOG_ALERT           A condition  that  should  be  corrected
+ *                      immediately,  such as a corrupted system
+ *                      database.
+ *
+ *  LOG_CRIT            Critical conditions, such as hard device
+ *                      errors.
+ *
+ *  LOG_ERR             Errors.
+ *
+ *  LOG_WARNING         Warning messages.
+ *
+ *  LOG_INFO            Informational messages.
+ *
+ *  LOG_DEBUG           Messages that contain  information  nor-
+ *                      mally  of use only when debugging a pro-
+ *                      gram.
+ *
+ * + * @see LogHandler + * @version #@ $Id: SysLogHandler.hpp,v 1.2 2003/09/01 10:15:53 innpeno Exp $ + */ +class SysLogHandler : public LogHandler +{ +public: + /** + * Default constructor. + */ + SysLogHandler(); + + /** + * Create a new syslog handler with the specified identity. + * + * @param pIdentity a syslog identity. + * @param facility syslog facility, defaults to LOG_USER + */ + SysLogHandler(const char* pIdentity, int facility = LOG_USER); + + /** + * Destructor. + */ + virtual ~SysLogHandler(); + + virtual bool open(); + virtual bool close(); + + virtual bool setParam(const BaseString ¶m, const BaseString &value); + bool setFacility(const BaseString &facility); + +protected: + virtual void writeHeader(const char* pCategory, Logger::LoggerLevel level); + virtual void writeMessage(const char* pMsg); + virtual void writeFooter(); + +private: + /** Prohibit*/ + SysLogHandler(const SysLogHandler&); + SysLogHandler operator = (const SysLogHandler&); + bool operator == (const SysLogHandler&); + + int m_severity; + const char* m_pCategory; + + /** Syslog identity for all log entries. */ + const char* m_pIdentity; + int m_facility; +}; + +#endif diff --git a/ndb/include/mgmapi/mgmapi.h b/ndb/include/mgmapi/mgmapi.h new file mode 100644 index 00000000000..c74a046b7e7 --- /dev/null +++ b/ndb/include/mgmapi/mgmapi.h @@ -0,0 +1,663 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef MGMAPI_H +#define MGMAPI_H + +/** + * @mainpage NDB Cluster Management API + * + * The NDB Cluster Management API (MGM API) is a C API + * that is used to: + * - Start/stop database nodes (DB nodes) + * - Start/stop NDB Cluster backups + * - Control the NDB Cluster log + * - Other administrative tasks + * + * @section General Concepts + * + * Each MGM API function needs a management server handle + * (of type Mgm_C_Api::NdbMgmHandle). + * This handle is initally is created by calling the + * function ndb_mgm_create_handle(). + * + * A function can return: + * -# An integer value. + * If it returns -1 then this indicates an error, and then + * -# A pointer value. If it returns NULL then check the latest error. + * If it didn't return NULL, then a "something" is returned. + * This "something" has to be free:ed by the user of the MGM API. + * + * If there are an error, then the get latest error functions + * can be used to check what the error was. + */ + +/** @addtogroup MGM_C_API + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + + /** + * Format of statistical information from the NDB Cluster. + * STATISTIC_LINE is sent on the statistical port from the Management server, + * each line is timestamped with STATISTIC_DATE. + */ +#define STATISTIC_LINE "date=%s epochsecs=%d nodeid=%u trans=%u commit=%u " \ + "read=%u insert=%u attrinfo=%u cops=%u abort=%u" + /** + * Format of statistical information from the NDB Cluster. + * STATISTIC_LINE is sent on the statistical port from the Management server, + * each line is timestamped with STATISTIC_DATE. + */ +#define STATISTIC_DATE "%d-%.2d-%.2d/%.2d:%.2d:%.2d" + /** + * Format of statistical information from the NDB Cluster. + */ +#define OP_STATISTIC_LINE "date=%s epochsecs=%d nodeid=%d operations=%u" + + /** + * The NdbMgmHandle. + */ + typedef struct ndb_mgm_handle * NdbMgmHandle; + + /** + * NDB Cluster node types + */ + enum ndb_mgm_node_type { + NDB_MGM_NODE_TYPE_UNKNOWN = -1, ///< Node type not known + NDB_MGM_NODE_TYPE_API = 0, ///< An application node (API) + NDB_MGM_NODE_TYPE_NDB = 1, ///< A database node (DB) + NDB_MGM_NODE_TYPE_MGM = 2, ///< A management server node (MGM) + + NDB_MGM_NODE_TYPE_MIN = 0, ///< Min valid value + NDB_MGM_NODE_TYPE_MAX = 2 ///< Max valid value + }; + + /** + * Database node status + */ + enum ndb_mgm_node_status { + NDB_MGM_NODE_STATUS_UNKNOWN = 0, ///< Node status not known + NDB_MGM_NODE_STATUS_NO_CONTACT = 1, ///< No contact with node + NDB_MGM_NODE_STATUS_NOT_STARTED = 2, ///< Has not run starting protocol + NDB_MGM_NODE_STATUS_STARTING = 3, ///< Is running starting protocol + NDB_MGM_NODE_STATUS_STARTED = 4, ///< Running + NDB_MGM_NODE_STATUS_SHUTTING_DOWN = 5, ///< Is shutting down + NDB_MGM_NODE_STATUS_RESTARTING = 6, ///< Is restarting + NDB_MGM_NODE_STATUS_SINGLEUSER = 7, ///< Maintenance mode + NDB_MGM_NODE_STATUS_RESUME = 8, ///< Resume mode + + NDB_MGM_NODE_STATUS_MIN = 0, ///< Min valid value + NDB_MGM_NODE_STATUS_MAX = 6 ///< Max valid value + }; + + /** + * Error codes + */ + enum ndb_mgm_error { + NDB_MGM_NO_ERROR = 0, + + /* Request for service errors */ + NDB_MGM_ILLEGAL_CONNECT_STRING = 1001, + NDB_MGM_ILLEGAL_PORT_NUMBER = 1002, + NDB_MGM_ILLEGAL_SOCKET = 1003, + NDB_MGM_ILLEGAL_IP_ADDRESS = 1004, + NDB_MGM_ILLEGAL_SERVER_HANDLE = 1005, + NDB_MGM_ILLEGAL_SERVER_REPLY = 1006, + NDB_MGM_ILLEGAL_NUMBER_OF_NODES = 1007, + NDB_MGM_ILLEGAL_NODE_STATUS = 1008, + NDB_MGM_OUT_OF_MEMORY = 1009, + NDB_MGM_SERVER_NOT_CONNECTED = 1010, + NDB_MGM_COULD_NOT_CONNECT_TO_SOCKET = 1011, + + /* Service errors - Start/Stop Node or System */ + NDB_MGM_START_FAILED = 2001, + NDB_MGM_STOP_FAILED = 2002, + NDB_MGM_RESTART_FAILED = 2003, + + /* Service errors - Backup */ + NDB_MGM_COULD_NOT_START_BACKUP = 3001, + NDB_MGM_COULD_NOT_ABORT_BACKUP = 3002, + + /* Service errors - Single User Mode */ + NDB_MGM_COULD_NOT_ENTER_SINGLE_USER_MODE = 4001, + NDB_MGM_COULD_NOT_EXIT_SINGLE_USER_MODE = 4002 + }; + + struct Ndb_Mgm_Error_Msg { + enum ndb_mgm_error code; + const char * msg; + }; + + const struct Ndb_Mgm_Error_Msg ndb_mgm_error_msgs[] = { + { NDB_MGM_NO_ERROR, "No error" }, + + { NDB_MGM_ILLEGAL_CONNECT_STRING, "Illegal connect string" }, + { NDB_MGM_ILLEGAL_PORT_NUMBER, "Illegal port number" }, + { NDB_MGM_ILLEGAL_SOCKET, "Illegal socket" }, + { NDB_MGM_ILLEGAL_IP_ADDRESS, "Illegal IP address" }, + { NDB_MGM_ILLEGAL_SERVER_HANDLE, "Illegal server handle" }, + { NDB_MGM_ILLEGAL_SERVER_REPLY, "Illegal reply from server" }, + { NDB_MGM_ILLEGAL_NUMBER_OF_NODES, "Illegal number of nodes" }, + { NDB_MGM_ILLEGAL_NODE_STATUS, "Illegal node status" }, + { NDB_MGM_OUT_OF_MEMORY, "Out of memory" }, + { NDB_MGM_SERVER_NOT_CONNECTED, "Management server not connected" }, + { NDB_MGM_COULD_NOT_CONNECT_TO_SOCKET, "Could not connect to socket" }, + + /* Service errors - Start/Stop Node or System */ + { NDB_MGM_START_FAILED, "Start failed" }, + { NDB_MGM_STOP_FAILED, "Stop failed" }, + { NDB_MGM_RESTART_FAILED, "Restart failed" }, + + /* Service errors - Backup */ + { NDB_MGM_COULD_NOT_START_BACKUP, "Could not start backup" }, + { NDB_MGM_COULD_NOT_ABORT_BACKUP, "Could not abort backup" }, + + /* Service errors - Single User Mode */ + { NDB_MGM_COULD_NOT_ENTER_SINGLE_USER_MODE, + "Could not enter single user mode" }, + { NDB_MGM_COULD_NOT_EXIT_SINGLE_USER_MODE, + "Could not exit single user mode" } + }; + + const int ndb_mgm_noOfErrorMsgs = + sizeof(ndb_mgm_error_msgs)/sizeof(struct Ndb_Mgm_Error_Msg); + + /** + * Structure returned by ndb_mgm_get_status + */ + struct ndb_mgm_node_state { + int node_id; ///< NDB Cluster node id + enum ndb_mgm_node_type node_type; ///< Type of NDB Cluster node + enum ndb_mgm_node_status node_status; ///< State of node + int start_phase; ///< Start phase. + ///< @note Start phase is only + ///< valid if + ///< node_type is + ///< NDB_MGM_NODE_TYPE_NDB and + ///< node_status is + ///< NDB_MGM_NODE_STATUS_STARTING + int dynamic_id; ///< Id for heartbeats and + ///< master take-over + ///< (only valid for DB nodes) + int node_group; ///< Node group of node + ///< (only valid for DB nodes) + int version; ///< Internal version number + }; + + /** + * Cluster status + */ + struct ndb_mgm_cluster_state { + int no_of_nodes; ///< No of entries in the + ///< node_states array + struct ndb_mgm_node_state ///< An array with node_states + node_states[1]; + }; + + /** + * Default reply from the server + */ + struct ndb_mgm_reply { + int return_code; ///< 0 if successful, + ///< otherwise error code. + char message[256]; ///< Error or reply message. + }; + + /** + * Default information types + */ + enum ndb_mgm_info { + NDB_MGM_INFO_CLUSTER, ///< ? + NDB_MGM_INFO_CLUSTERLOG ///< Cluster log + }; + + /** + * Signal log modes + * (Used only in the development of NDB Cluster.) + */ + enum ndb_mgm_signal_log_mode { + NDB_MGM_SIGNAL_LOG_MODE_IN, ///< Log receiving signals + NDB_MGM_SIGNAL_LOG_MODE_OUT, ///< Log sending signals + NDB_MGM_SIGNAL_LOG_MODE_INOUT, ///< Log both sending/receiving + NDB_MGM_SIGNAL_LOG_MODE_OFF ///< Log off + }; + + /** + * Log severities (used to filter the cluster log) + */ + enum ndb_mgm_clusterlog_level { + NDB_MGM_CLUSTERLOG_OFF = 0, ///< Cluster log off + NDB_MGM_CLUSTERLOG_DEBUG = 1, ///< Used in NDB Cluster + ///< developement + NDB_MGM_CLUSTERLOG_INFO = 2, ///< Informational messages + NDB_MGM_CLUSTERLOG_WARNING = 3, ///< Conditions that are not + ///< error condition, but + ///< might require handling + NDB_MGM_CLUSTERLOG_ERROR = 4, ///< Conditions that should be + ///< corrected + NDB_MGM_CLUSTERLOG_CRITICAL = 5, ///< Critical conditions, like + ///< device errors or out of + ///< resources + NDB_MGM_CLUSTERLOG_ALERT = 6, ///< A condition that should be + ///< corrected immediately, + ///< such as a corrupted system + NDB_MGM_CLUSTERLOG_ALL = 7 ///< All severities on + }; + + /** + * Log categories + */ + enum ndb_mgm_event_category { + NDB_MGM_EVENT_CATEGORY_STARTUP, ///< Events during all kinds + ///< of startups + NDB_MGM_EVENT_CATEGORY_SHUTDOWN, ///< Events during shutdown + NDB_MGM_EVENT_CATEGORY_STATISTIC, ///< Transaction statistics + ///< (Job level, TCP/IP speed) + NDB_MGM_EVENT_CATEGORY_CHECKPOINT, ///< Checkpoints + NDB_MGM_EVENT_CATEGORY_NODE_RESTART, ///< Events during node restart + NDB_MGM_EVENT_CATEGORY_CONNECTION, ///< Events related to connection + ///< and communication + NDB_MGM_EVENT_CATEGORY_ERROR ///< Assorted event w.r.t. + ///< unexpected happenings + }; + + /***************************************************************************/ + /** + * @name Functions: Error Handling + * @{ + */ + + /** + * Get latest error associated with a management server handle + * + * @param handle Management handle + * @return Latest error code + */ + int ndb_mgm_get_latest_error(const NdbMgmHandle handle); + + /** + * Get latest main error message associated with a handle + * + * @param handle Management handle. + * @return Latest error message + */ + const char * ndb_mgm_get_latest_error_msg(const NdbMgmHandle handle); + + /** + * Get latest error description associated with a handle + * + * The error description gives some additional information to + * the error message. + * + * @param handle Management handle. + * @return Latest error description + */ + const char * ndb_mgm_get_latest_error_desc(const NdbMgmHandle handle); + +#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED + /** + * Get latest internal source code error line associated with a handle + * + * @param handle Management handle. + * @return Latest internal source code line of latest error + * @deprecated + */ + int ndb_mgm_get_latest_error_line(const NdbMgmHandle handle); +#endif + + /** @} *********************************************************************/ + /** + * @name Functions: Create/Destroy Management Server Handles + * @{ + */ + + /** + * Create a handle to a management server + * + * @return A management handle
+ * or NULL if no management handle could be created. + */ + NdbMgmHandle ndb_mgm_create_handle(); + + /** + * Destroy a management server handle + * + * @param handle Management handle + */ + void ndb_mgm_destroy_handle(NdbMgmHandle * handle); + + /** @} *********************************************************************/ + /** + * @name Functions: Connect/Disconnect Management Server + * @{ + */ + + /** + * Connect to a management server + * + * @param handle Management handle. + * @param mgmsrv Hostname and port of the management server, + * "hostname:port". + * @return -1 on error. + */ + int ndb_mgm_connect(NdbMgmHandle handle, const char * mgmsrv); + + /** + * Disconnect from a management server + * + * @param handle Management handle. + * @return -1 on error. + */ + int ndb_mgm_disconnect(NdbMgmHandle handle); + + /** @} *********************************************************************/ + /** + * @name Functions: Convert between different data formats + * @{ + */ + + /** + * Convert a string to a ndb_mgm_node_type + * + * @param type Node type as string. + * @return NDB_MGM_NODE_TYPE_UNKNOWN if invalid string. + */ + enum ndb_mgm_node_type ndb_mgm_match_node_type(const char * type); + + /** + * Convert an ndb_mgm_node_type to a string + * + * @param type Node type. + * @return NULL if invalid id. + */ + const char * ndb_mgm_get_node_type_string(enum ndb_mgm_node_type type); + + /** + * Convert a string to a ndb_mgm_node_status + * + * @param status NDB node status string. + * @return NDB_MGM_NODE_STATUS_UNKNOWN if invalid string. + */ + enum ndb_mgm_node_status ndb_mgm_match_node_status(const char * status); + + /** + * Convert an id to a string + * + * @param status NDB node status. + * @return NULL if invalid id. + */ + const char * ndb_mgm_get_node_status_string(enum ndb_mgm_node_status status); + + /** @} *********************************************************************/ + /** + * @name Functions: State of cluster + * @{ + */ + + /** + * Get status of the nodes in an NDB Cluster + * + * Note the caller must free the pointer returned. + * + * @param handle Management handle. + * @return Cluster state (or NULL on error). + */ + struct ndb_mgm_cluster_state * ndb_mgm_get_status(NdbMgmHandle handle); + + /** @} *********************************************************************/ + /** + * @name Functions: Start/stop nodes + * @{ + */ + + /** + * Stop database nodes + * + * @param handle Management handle. + * @param no_of_nodes no of database nodes
+ * 0 - means all database nodes in cluster
+ * n - Means stop n node(s) specified in the + * array node_list + * @param node_list List of node ids of database nodes to be stopped + * @return No of nodes stopped (or -1 on error) + * + * @note The function is equivalent + * to ndb_mgm_stop2(handle, no_of_nodes, node_list, 0) + */ + int ndb_mgm_stop(NdbMgmHandle handle, int no_of_nodes, + const int * node_list); + + /** + * Stop database nodes + * + * @param handle Management handle. + * @param no_of_nodes No of database nodes
+ * 0 - means all database nodes in cluster
+ * n - Means stop n node(s) specified in + * the array node_list + * @param node_list List of node ids of database nodes to be stopped + * @param abort Don't perform gracefull stop, + * but rather stop immediatly + * @return No of nodes stopped (or -1 on error). + */ + int ndb_mgm_stop2(NdbMgmHandle handle, int no_of_nodes, + const int * node_list, int abort); + + /** + * Restart database nodes + * + * @param handle Management handle. + * @param no_of_nodes No of database nodes
+ * 0 - means all database nodes in cluster
+ * n - Means stop n node(s) specified in the + * array node_list + * @param node_list List of node ids of database nodes to be stopped + * @return No of nodes stopped (or -1 on error). + * + * @note The function is equivalent to + * ndb_mgm_restart2(handle, no_of_nodes, node_list, 0, 0, 0); + */ + int ndb_mgm_restart(NdbMgmHandle handle, int no_of_nodes, + const int * node_list); + + /** + * Restart database nodes + * + * @param handle Management handle. + * @param no_of_nodes No of database nodes
+ * 0 - means all database nodes in cluster
+ * n - Means stop n node(s) specified in the + * array node_list + * @param node_list List of node ids of database nodes to be stopped + * @param initial Remove filesystem from node(s) restarting + * @param nostart Don't actually start node(s) but leave them + * waiting for start command + * @param abort Don't perform gracefull restart, + * but rather restart immediatly + * @return No of nodes stopped (or -1 on error). + */ + int ndb_mgm_restart2(NdbMgmHandle handle, int no_of_nodes, + const int * node_list, int initial, + int nostart, int abort); + + /** + * Start database nodes + * + * @param handle Management handle. + * @param no_of_nodes No of database nodes
+ * 0 - means all database nodes in cluster
+ * n - Means start n node(s) specified in + * the array node_list + * @param node_list List of node ids of database nodes to be started + * @return No of nodes started (or -1 on error). + * + * @note The nodes to start must have been started with nostart(-n) + * argument. + * This means that the database node binary is started and + * waiting for a START management command which will + * actually start the database node functionality + */ + int ndb_mgm_start(NdbMgmHandle handle, + int no_of_nodes, + const int * node_list); + + /** @} *********************************************************************/ + /** + * @name Functions: Logging and Statistics + * @{ + */ + + /** + * Filter cluster log + * + * @param handle NDB management handle. + * @param level A cluster log level to filter. + * @param reply Reply message. + * @return -1 on error. + */ + int ndb_mgm_filter_clusterlog(NdbMgmHandle handle, + enum ndb_mgm_clusterlog_level level, + struct ndb_mgm_reply* reply); + + /** + * Get log filter + * + * @param handle NDB management handle + * @return A vector of seven elements, + * where each element contains + * 1 if a severity is enabled and 0 if not. + * A severity is stored at position + * ndb_mgm_clusterlog_level, + * for example the "error" level is stored in position + * [NDB_MGM_CLUSTERLOG_ERROR-1]. + * The first element in the vector signals + * whether the clusterlog + * is disabled or enabled. + */ + unsigned int *ndb_mgm_get_logfilter(NdbMgmHandle handle); + + /** + * Set log category and levels for the cluster log + * + * @param handle NDB management handle. + * @param nodeId Node id. + * @param category Event category. + * @param level Log level (0-15). + * @param reply Reply message. + * @return -1 on error. + */ + int ndb_mgm_set_loglevel_clusterlog(NdbMgmHandle handle, + int nodeId, + /*enum ndb_mgm_event_category category*/ + char * category, + int level, + struct ndb_mgm_reply* reply); + + /** + * Set log category and levels for the Node + * + * @param handle NDB management handle. + * @param nodeId Node id. + * @param category Event category. + * @param level Log level (0-15). + * @param reply Reply message. + * @return -1 on error. + */ + int ndb_mgm_set_loglevel_node(NdbMgmHandle handle, + int nodeId, + /*enum ndb_mgm_event_category category*/ + char * category, + int level, + struct ndb_mgm_reply* reply); + + /** + * Returns the port number where statistics information is sent + * + * @param handle NDB management handle. + * @param reply Reply message. + * @return -1 on error. + */ + int ndb_mgm_get_stat_port(NdbMgmHandle handle, + struct ndb_mgm_reply* reply); + + /** @} *********************************************************************/ + /** + * @name Functions: Backup + * @{ + */ + + /** + * Start backup + * + * @param handle NDB management handle. + * @param backup_id Backup id is returned from function. + * @param reply Reply message. + * @return -1 on error. + */ + int ndb_mgm_start_backup(NdbMgmHandle handle, unsigned int* backup_id, + struct ndb_mgm_reply* reply); + + /** + * Abort backup + * + * @param handle NDB management handle. + * @param backup_id Backup Id. + * @param reply Reply message. + * @return -1 on error. + */ + int ndb_mgm_abort_backup(NdbMgmHandle handle, unsigned int backup_id, + struct ndb_mgm_reply* reply); + + + /** @} *********************************************************************/ + /** + * @name Functions: Single User Mode + * @{ + */ + + /** + * Enter Single user mode + * + * @param handle NDB management handle. + * @param nodeId Node Id of the single user node + * @param reply Reply message. + * @return -1 on error. + */ + int ndb_mgm_enter_single_user(NdbMgmHandle handle, unsigned int nodeId, + struct ndb_mgm_reply* reply); + + /** + * Exit Single user mode + * + * @param handle NDB management handle. + * @param nodeId Node Id of the single user node + * @param reply Reply message. + * @return -1 on error. + */ + int ndb_mgm_exit_single_user(NdbMgmHandle handle, + struct ndb_mgm_reply* reply); + +#ifdef __cplusplus +} +#endif + +/** @} */ + +#endif diff --git a/ndb/include/mgmapi/mgmapi_debug.h b/ndb/include/mgmapi/mgmapi_debug.h new file mode 100644 index 00000000000..2723263e7a7 --- /dev/null +++ b/ndb/include/mgmapi/mgmapi_debug.h @@ -0,0 +1,114 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef MGMAPI_DEBUG_H +#define MGMAPI_DEBUG_H + +#ifdef __cplusplus +extern "C" { +#endif + + /** + * Start signal logging. + * + * @param handle the NDB management handle. + * @param nodeId the node Id. + * @param reply the reply message. + * @return 0 if successful. + */ + int ndb_mgm_start_signallog(NdbMgmHandle handle, + int nodeId, + struct ndb_mgm_reply* reply); + + /** + * Stop signal logging. + * + * @param handle the NDB management handle. + * @param nodeId the node Id. + * @param reply the reply message. + * @return 0 if successful. + */ + int ndb_mgm_stop_signallog(NdbMgmHandle handle, + int nodeId, + struct ndb_mgm_reply* reply); + + /** + * Set the signals to log. + * + * @param handle the NDB management handle. + * @param nodeId the node id. + * @param mode the signal log mode. + * @param blockNames the block names (space separated). + * @param reply the reply message. + * @return 0 if successful or an error code. + */ + int ndb_mgm_log_signals(NdbMgmHandle handle, + int nodeId, + enum ndb_mgm_signal_log_mode mode, + const char* blockNames, + struct ndb_mgm_reply* reply); + + /** + * Set trace. + * + * @param handle the NDB management handle. + * @param nodeId the node id. + * @param traceNumber the trace number. + * @param reply the reply message. + * @return 0 if successful or an error code. + */ + int ndb_mgm_set_trace(NdbMgmHandle handle, + int nodeId, + int traceNumber, + struct ndb_mgm_reply* reply); + + /** + * Provoke an error. + * + * @param handle the NDB management handle. + * @param nodeId the node id. + * @param errrorCode the errorCode. + * @param reply the reply message. + * @return 0 if successful or an error code. + */ + int ndb_mgm_insert_error(NdbMgmHandle handle, + int nodeId, + int errorCode, + struct ndb_mgm_reply* reply); + + /** + * Dump state + * + * @param handle the NDB management handle. + * @param nodeId the node id. + * @param args integer array + * @param number of args in int array + * @param reply the reply message. + * @return 0 if successful or an error code. + */ + int ndb_mgm_dump_state(NdbMgmHandle handle, + int nodeId, + int * args, + int num_args, + struct ndb_mgm_reply* reply); + + +#ifdef __cplusplus +} +#endif + + +#endif diff --git a/ndb/include/mgmcommon/ConfigRetriever.hpp b/ndb/include/mgmcommon/ConfigRetriever.hpp new file mode 100644 index 00000000000..ff60e730d45 --- /dev/null +++ b/ndb/include/mgmcommon/ConfigRetriever.hpp @@ -0,0 +1,116 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ConfigRetriever_H +#define ConfigRetriever_H + +#include +#include + +/** + * @class ConfigRetriever + * @brief Used by nodes (DB, MGM, API) to get their config from MGM server. + */ +class ConfigRetriever { +public: + ConfigRetriever(); + ConfigRetriever(const int id, const char* remoteHost, const int port); + ~ConfigRetriever(); + + /** + * Read local config + * @return Own node id, -1 means fail + */ + int init(bool onlyNodeId = false); + + /** + * Get configuration for current (nodeId given in local config file) node. + * + * Configuration is fetched from one MGM server configured in local config + * file. The method loops over all the configured MGM servers and tries + * to establish a connection. This is repeated until a connection is + * established, so the function hangs until a connection is established. + * + * @return Properties object if succeeded, + * NULL if erroneous local config file or configuration error. + */ + class Properties * getConfig(const char * nodeType, int versionId); + + const char * getErrorString(); + + /** + * Sets connectstring which can be used instead of local config file + */ + void setConnectString(const char * connectString); + + /** + * Sets name of local config file (usually not needed) + */ + void setLocalConfigFileName(const char * connectString); + + /** + * Sets connectstring which can be used instead of local config file + * environment variables and Ndb.cfg has precidence over this + */ + void setDefaultConnectString(const char * defaultConnectString); + + /** + * @return Node id of this node (as stated in local config or connectString) + */ + inline Uint32 getOwnNodeId() { return _ownNodeId; } + + /** + * Get configuration object + */ + class Properties * getConfig(int versionId); + + /** + * Get config using socket + */ + class Properties * getConfig(const char * mgmhost, unsigned int port, + Uint32 nodeId, int versionId); + /** + * Get config from file + */ + class Properties * getConfig(const char * filename, Uint32 nodeId, + int versionId); +private: + char * errorString; + enum ErrorType { + CR_ERROR = 0, + CR_RETRY = 1 + }; + ErrorType latestErrorType; + + void setError(ErrorType, const char * errorMsg); + + /** + * Verifies that received configuration is correct + */ + bool verifyProperties(const char* nodeType, Properties *p, + Uint32 nodeId, int versionId); + + char * _localConfigFileName; + struct LocalConfig * _localConfig; + int _ownNodeId; + + char * m_connectString; + char * m_defaultConnectString; +}; + +#endif + + diff --git a/ndb/include/mgmcommon/IPCConfig.hpp b/ndb/include/mgmcommon/IPCConfig.hpp new file mode 100644 index 00000000000..626242865cb --- /dev/null +++ b/ndb/include/mgmcommon/IPCConfig.hpp @@ -0,0 +1,79 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef IPCConfig_H +#define IPCConfig_H + +#include +#include +#include +#include + +/** + * @class IPCConfig + * @brief Config transporters in TransporterRegistry using Properties config + */ +class IPCConfig +{ +public: + IPCConfig(Properties * props); + ~IPCConfig(); + + /** @return 0 for OK */ + int init(); + + NodeId ownId() const; + + /** @return No of transporters configured */ + int configureTransporters(class TransporterRegistry * theTransporterRegistry); + + /** + * Supply a nodeId, + * and get next higher node id + * @return false if none found, true otherwise + * + * getREPHBFrequency and getNodeType uses the last Id supplied to + * getNextRemoteNodeId. + */ + bool getNextRemoteNodeId(NodeId & nodeId) const; + Uint32 getREPHBFrequency(NodeId id) const; + const char* getNodeType(NodeId id) const; + + NodeId getNoOfRemoteNodes() const { + return theNoOfRemoteNodes; + } + + void print() const { props->print(); } + +private: + NodeId the_ownId; + Properties * props; + + bool addRemoteNodeId(NodeId nodeId); + NodeId theNoOfRemoteNodes; + NodeId theRemoteNodeIds[MAX_NODES]; +}; + +inline +NodeId +IPCConfig::ownId() const +{ + return the_ownId; +} + + + +#endif // IPCConfig_H diff --git a/ndb/include/mgmcommon/MgmtErrorReporter.hpp b/ndb/include/mgmcommon/MgmtErrorReporter.hpp new file mode 100644 index 00000000000..acc44b14d8e --- /dev/null +++ b/ndb/include/mgmcommon/MgmtErrorReporter.hpp @@ -0,0 +1,74 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +//****************************************************************************** +// Description: This file contains the error reporting macros to be used +// within management server. +// +// Author: Peter Lind +//****************************************************************************** + + +#include +#include // exit + +#define REPORT_WARNING(message) \ + ndbout << "WARNING: " << message << endl + +//**************************************************************************** +// Description: Report a warning, the message is printed on ndbout. +// Parameters: +// message: A text describing the warning. +// Returns: - +//**************************************************************************** + + +#define REPORT_ERROR(message) \ + ndbout << "ERROR: " << message << endl + +//**************************************************************************** +// Description: Report an error, the message is printed on ndbout. +// Parameters: +// message: A text describing the error. +// Returns: - +//**************************************************************************** + + +#ifdef MGMT_TRACE + +#define TRACE(message) \ + ndbout << "MGMT_TRACE: " << message << endl +#else +#define TRACE(message) + +#endif + +//**************************************************************************** +// Description: Print a message on ndbout. +// Parameters: +// message: The message +// Returns: - +//**************************************************************************** + +#ifndef NDB_ASSERT +#define NDB_ASSERT(trueToContinue, message) \ + if ( !(trueToContinue) ) { \ +ndbout << "ASSERT FAILED. FILE: " << __FILE__ << ", LINE: " << __LINE__ << ", MSG: " << message << endl;exit(-1);} +#endif + +#define MGM_REQUIRE(x) \ + if (!(x)) { ndbout << __FILE__ << " " << __LINE__ \ + << ": Warning! Requirement failed" << endl; } diff --git a/ndb/include/mgmcommon/NdbConfig.h b/ndb/include/mgmcommon/NdbConfig.h new file mode 100644 index 00000000000..d9b484edcc5 --- /dev/null +++ b/ndb/include/mgmcommon/NdbConfig.h @@ -0,0 +1,34 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_CONFIG_H +#define NDB_CONFIG_H + +#ifdef __cplusplus +extern "C" { +#endif + +const char* NdbConfig_HomePath(char* buf, int buflen); + +const char* NdbConfig_NdbCfgName(char* buf, int buflen, int with_ndb_home); +const char* NdbConfig_ErrorFileName(char* buf, int buflen); +const char* NdbConfig_ClusterLogFileName(char* buf, int buflen); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/ndb/include/ndb_types.h b/ndb/include/ndb_types.h new file mode 100644 index 00000000000..40d73b0f230 --- /dev/null +++ b/ndb/include/ndb_types.h @@ -0,0 +1,51 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/** + * @file ndb_types.h + */ + +#ifndef SYS_TYPES_H +#define SYS_TYPES_H + +#include +#include + +typedef char Int8; +typedef unsigned char Uint8; +typedef short Int16; +typedef unsigned short Uint16; +typedef int Int32; +typedef unsigned int Uint32; + +typedef unsigned int UintR; + +#ifdef __SIZE_TYPE__ +typedef __SIZE_TYPE__ UintPtr; +#else +#include +typedef uintptr_t UintPtr; +#endif + +#if defined(WIN32) || defined(NDB_WIN32) +typedef unsigned __int64 Uint64; +typedef __int64 Int64; +#else +typedef unsigned long long Uint64; +typedef long long Int64; +#endif + +#endif diff --git a/ndb/include/ndb_version.h b/ndb/include/ndb_version.h new file mode 100644 index 00000000000..4fb6ec18fce --- /dev/null +++ b/ndb/include/ndb_version.h @@ -0,0 +1,53 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_VERSION_H +#define NDB_VERSION_H + +#include +#include + +#include + +#define MAKE_VERSION(A,B,C) (((A) << 16) | ((B) << 8) | ((C) << 0)) + +/** + * version of this build + */ + +#define NDB_VERSION_MAJOR 3 +#define NDB_VERSION_MINOR 4 +#define NDB_VERSION_BUILD 5 +#define NDB_VERSION_STATUS "alpha" + +#define NDB_VERSION_D MAKE_VERSION(NDB_VERSION_MAJOR, NDB_VERSION_MINOR, NDB_VERSION_BUILD) + +#define NDB_VERSION_STRING (getVersionString(NDB_VERSION, NDB_VERSION_STATUS)) + +#define NDB_VERSION_TAG_STRING "$Name: $" + +#define NDB_VERSION ndbGetOwnVersion() + +/** + * Version id + * + * Used by transporter and when communicating with + * managment server + */ +//#define NDB_VERSION_ID 0 + +#endif + diff --git a/ndb/include/ndbapi/AttrType.hpp b/ndb/include/ndbapi/AttrType.hpp new file mode 100644 index 00000000000..e6e00c77130 --- /dev/null +++ b/ndb/include/ndbapi/AttrType.hpp @@ -0,0 +1,329 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/** + * @file AttrType.hpp + */ + +#ifndef AttrType_H +#define AttrType_H + +/** + * Max number of Ndb objects in different threads. + * (Ndb objects should not be shared by different threads.) + */ +const unsigned MAX_NO_THREADS = 4711; + +/** + * Max number of attributes in a table. + */ +const unsigned MAXNROFATTRIBUTES = 128; + +/** + * Max number of tuple keys for a table in NDB Cluster. + * + * A tuple key of a table is an attribute + * which is either part of the + * primary key or the tuple id of a table. + */ +const unsigned MAXNROFTUPLEKEY = 16; + +/** + * Max number of words in a tuple key attribute. + * + * Tuple keys can not have values larger than + * 4092 bytes (i.e. 1023 words). + */ +const unsigned MAXTUPLEKEYLENOFATTERIBUTEINWORD = 1023; + +/** + * Max number of ErrorCode in NDB Cluster range 0 - 1999. + */ +const unsigned MAXNDBCLUSTERERROR = 1999; + +/** + * Max number of theErrorCode NDB API range 4000 - 4999. + */ +const unsigned MAXNROFERRORCODE = 5000; + +/** + * Missing explanation + */ +enum ReturnType { + ReturnSuccess, ///< Missing explanation + ReturnFailure ///< Missing explanation +}; + +/** + * + */ +enum SendStatusType { + NotInit, ///< Missing explanation + InitState, ///< Missing explanation + sendOperations, ///< Missing explanation + sendCompleted, ///< Missing explanation + sendCOMMITstate, ///< Missing explanation + sendABORT, ///< Missing explanation + sendABORTfail, ///< Missing explanation + sendTC_ROLLBACK, ///< Missing explanation + sendTC_COMMIT, ///< Missing explanation + sendTC_OP ///< Missing explanation +}; + +/** + * Missing explanation + */ +enum ListState { + NotInList, ///< Missing explanation + InPreparedList, ///< Missing explanation + InSendList, ///< Missing explanation + InCompletedList ///< Missing explanation +}; + +/** + * Commit status of the transaction + */ +enum CommitStatusType { + NotStarted, ///< Transaction not yet started + Started, ///< Missing explanation + Committed, ///< Transaction has been committed + Aborted, ///< Transaction has been aborted + NeedAbort ///< Missing explanation +}; + +/** + * Commit type of transaction + */ +enum AbortOption { +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL + CommitIfFailFree = 0, + CommitAsMuchAsPossible = 2, ///< Commit transaction with as many + TryCommit = 0, ///< Missing explanation +#endif + AbortOnError = 0, ///< Abort transaction on failed operation + IgnoreError = 2 ///< Transaction continues on failed operation +}; + +typedef AbortOption CommitType; + +/** + * Missing explanation + */ +enum InitType { + NotConstructed, ///< Missing explanation + NotInitialised, ///< Missing explanation + StartingInit, ///< Missing explanation + Initialised, ///< Missing explanation + InitConfigError ///< Missing explanation +}; + +/** + * Type of attribute + */ +enum AttrType { + Signed, ///< Attributes of this type can be read with: + ///< NdbRecAttr::int64_value, + ///< NdbRecAttr::int32_value, + ///< NdbRecAttr::short_value, + ///< NdbRecAttr::char_value + UnSigned, ///< Attributes of this type can be read with: + ///< NdbRecAttr::u_64_value, + ///< NdbRecAttr::u_32_value, + ///< NdbRecAttr::u_short_value, + ///< NdbRecAttr::u_char_value + Float, ///< Attributes of this type can be read with: + ///< NdbRecAttr::float_value and + ///< NdbRecAttr::double_value + String, ///< Attributes of this type can be read with: + ///< NdbRecAttr::aRef, + ///< NdbRecAttr::getAttributeObject + NoAttrTypeDef ///< Used for debugging only +}; + +/** + * Execution type of transaction + */ +enum ExecType { + NoExecTypeDef = -1, ///< Erroneous type (Used for debugging only) + Prepare, ///< Missing explanation + NoCommit, ///< Execute the transaction as far as it has + ///< been defined, but do not yet commit it + Commit, ///< Execute and try to commit the transaction + Rollback ///< Rollback transaction +}; + +/** + * Indicates whether the attribute is part of a primary key or not + */ +enum KeyType { + Undefined = -1, ///< Used for debugging only + NoKey, ///< Attribute is not part of primary key + ///< or tuple identity + TupleKey, ///< Attribute is part of primary key + TupleId ///< Attribute is part of tuple identity + ///< (This type of attribute is created + ///< internally, and should not be + ///< manually created.) +}; + +/** + * Indicate whether the attribute should be stored on disk or not + */ +enum StorageMode { + MMBased = 0, ///< Main memory + DiskBased = 1, ///< Disk (Not yet supported.) + NoStorageTypeDef ///< Used for debugging only +}; + +/** + * Where attribute is stored. + * + * This is used to indicate whether a primary key + * should only be stored in the index storage and not in the data storage + * or if it should be stored in both places. + * The first alternative makes the attribute take less space, + * but makes it impossible to scan using attribute. + * + * @note Use NormalStorageAttribute for most cases. + * (IndexStorageAttribute should only be used on primary key + * attributes and only if you do not want to scan using the attribute.) + */ +enum StorageAttributeType { + NoStorageAttributeTypeDefined = -1, ///< Missing explanation + IndexStorageAttribute, ///< Attribute is only stored in + ///< index storage (ACC) + NormalStorageAttribute ///< Attribute values are stored + ///< both in the index (ACC) and + ///< in the data storage (TUP) +}; + +/** + * Missing explanation + */ +enum OperationStatus{ + Init, ///< Missing explanation + OperationDefined, ///< Missing explanation + TupleKeyDefined, ///< Missing explanation + GetValue, ///< Missing explanation + SetValue, ///< Missing explanation + ExecInterpretedValue, ///< Missing explanation + SetValueInterpreted, ///< Missing explanation + FinalGetValue, ///< Missing explanation + SubroutineExec, ///< Missing explanation + SubroutineEnd, ///< Missing explanation + SetBound, ///< Setting bounds in range scan + WaitResponse, ///< Missing explanation + WaitCommitResponse, ///< Missing explanation + Finished, ///< Missing explanation + ReceiveFinished ///< Missing explanation +}; + +/** + * Type of operation + */ +enum OperationType { + ReadRequest = 0, ///< Read operation + UpdateRequest = 1, ///< Update Operation + InsertRequest = 2, ///< Insert Operation + DeleteRequest = 3, ///< Delete Operation + WriteRequest = 4, ///< Write Operation + ReadExclusive = 5, ///< Read exclusive + OpenScanRequest, ///< Scan Operation + OpenRangeScanRequest, ///< Range scan operation + NotDefined2, ///< Missing explanation + NotDefined ///< Missing explanation +}; + +/** + * Missing explanation + */ +enum ConStatusType { + NotConnected, ///< Missing explanation + Connecting, ///< Missing explanation + Connected, ///< Missing explanation + DisConnecting, ///< Missing explanation + ConnectFailure ///< Missing explanation +}; + +/** + * Missing explanation + */ +enum CompletionStatus { + NotCompleted, ///< Missing explanation + CompletedSuccess, ///< Missing explanation + CompletedFailure, ///< Missing explanation + DefinitionFailure ///< Missing explanation +}; + +/** + * Type of fragmentation used for a table + */ +enum FragmentType { + Default = 0, ///< (All is default!) + Single = 1, ///< Only one fragment + All = 2, ///< Default value. One fragment per node group + DistributionGroup = 3, ///< Distribution Group used for fragmentation. + ///< One fragment per node group + DistributionKey = 4, ///< Distribution Key used for fragmentation. + ///< One fragment per node group. + AllLarge = 5, ///< Sixten fragments per node group. + DGroupLarge = 6, ///< Distribution Group used for fragmentation. + ///< Sixten fragments per node group + DKeyLarge = 7 ///< Distribution Key used for fragmentation. + ///< Sixten fragments per node group +}; + +/** + * Type of table or index. + */ +enum TableType { + UndefTableType = 0, + SystemTable = 1, ///< Internal. Table cannot be updated by user + UserTable = 2, ///< Normal application table + UniqueHashIndex = 3, ///< Unique un-ordered hash index + HashIndex = 4, ///< Non-unique un-ordered hash index + UniqueOrderedIndex = 5, ///< Unique ordered index + OrderedIndex = 6 ///< Non-unique ordered index +}; + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL +/** + * Different types of tampering with the NDB Cluster. + * Only for debugging purposes only. + */ +enum TamperType { + LockGlbChp = 1, ///< Lock GCP + UnlockGlbChp, ///< Unlock GCP + CrashNode, ///< Crash an NDB node + ReadRestartGCI, ///< Request the restart GCI id from NDB Cluster + InsertError ///< Execute an error in NDB Cluster + ///< (may crash system) +}; +#endif + +#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED +/** + * @deprecated + */ +enum NullAttributeType { + NoNullTypeDefined = -1, + NotNullAttribute, + NullAttribute, + AttributeDefined +}; +#endif + +#endif diff --git a/ndb/include/ndbapi/Ndb.hpp b/ndb/include/ndbapi/Ndb.hpp new file mode 100644 index 00000000000..59bdd212919 --- /dev/null +++ b/ndb/include/ndbapi/Ndb.hpp @@ -0,0 +1,1702 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/** + @mainpage NDB API Programmers' Guide + + This guide assumes a basic familiarity with NDB Cluster concepts. + Some of the fundamental ones are described in section @ref secConcepts. + + The NDB API is an NDB Cluster application interface + that implements both synchronous and asynchronous transactions. + The NDB API consists of the following fundamental classes: + - Ndb is the main class representing the database, + - NdbConnection represents a transaction, + - NdbOperation represents a transaction operation using primary key, + - NdbIndexOperation represents a transaction operation using a secondary + index, + - NdbRecAttr represents the value of an attribute, and + - NdbDictionary represents meta information about tables and attributes. + - NdbError represents an error condition + There are also some auxiliary classes. + + The main structure of an application program is as follows: + -# Construct and initialize Ndb object(s). + -# Define and execute (synchronous or asynchronous) transactions. + -# Delete Ndb objects + + The main structure of a transaction is as follows: + -# Start transaction + -# Add and define operations (associated with the transaction) + -# Execute transaction + + The execute can be of two different types, + Commit or NoCommit. + (The execute can also be divided into three + steps: prepare, send, and poll to get asynchronous + transactions. More about this later.) + + If the execute is of type NoCommit, + then the application program executes part of a transaction, + but without committing the transaction. + After a NoCommit type of execute, the program can continue + to add and define more operations to the transaction + for later execution. + + If the execute is of type Commit, then the transaction is + committed and no further adding and defining of operations + is allowed. + + + @section secSync Synchronous Transactions + + Synchronous transactions are defined and executed in the following way. + + -# Start (create) transaction (the transaction will be + referred to by an NdbConnection object, + typically created by Ndb::startTransaction). + At this step the transaction is being defined. + It is not yet sent to the NDB kernel. + -# Add and define operations to the transaction + (using NdbConnection::getNdbOperation and + methods from class NdbOperation). + The transaction is still not sent to the NDB kernel. + -# Execute the transaction (using NdbConnection::execute). + -# Close the transaction (using Ndb::closeTransaction). + + See example program in section @ref ndbapi_example1.cpp. + + To execute several parallel synchronous transactions, one can either + use multiple Ndb objects in several threads or start multiple + applications programs. + Another way to execute several parallel transactions is to use + asynchronous transactions. + + + @section secNdbOperations Operations + + Each transaction (NdbConnection object) consist of a list of + operations (NdbOperation or NdbIndexOperation objects. + NdbIndexOperation is used for accessing tables through secondary indexes). + Operations are of two different kinds: + -# standard operations, and + -# interpreted program operations. + +

Standard Operations

+ After the operation is created using NdbConnection::getNdbOperation + (or NdbConnection::getNdbIndexOperation), + it is defined in the following three steps: + -# Defining standard operation type + (e.g. using NdbOperation::readTuple) + -# Specifying search conditions + (e.g. using NdbOperation::equal) + -# Specify attribute actions + (e.g. using NdbOperation::getValue) + + Example code (using an NdbOperation): + @code + MyOperation = MyConnection->getNdbOperation("MYTABLENAME"); // 1. Create + if (MyOperation == NULL) APIERROR(MyConnection->getNdbError()); + + MyOperation->readTuple(); // 2. Define type of operation + MyOperation->equal("ATTR1", i); // 3. Specify Search Conditions + + MyRecAttr = MyOperation->getValue("ATTR2", NULL); // 4. Attribute Actions + if (MyRecAttr == NULL) APIERROR(MyConnection->getNdbError()); + @endcode + For more examples, see @ref ndbapi_example1.cpp and @ref ndbapi_example2.cpp. + + Example code using an NdbIndexOperation: + @code + MyOperation = // 1. Create + MyConnection->getNdbIndexOperation("MYINDEX", "MYTABLENAME"); + if (MyOperation == NULL) APIERROR(MyConnection->getNdbError()); + + MyOperation->readTuple(); // 2. Define type of operation + MyOperation->equal("ATTR1", i); // 3. Specify Search Conditions + + MyRecAttr = MyOperation->getValue("ATTR2", NULL); // 4. Attribute Actions + if (MyRecAttr == NULL) APIERROR(MyConnection->getNdbError()); + @endcode + For more examples, see @ref ndbapi_example4.cpp. + + +

Step 1: Define Standard Operation Type

+ The following types of standard operations exist: + -# NdbOperation::insertTuple : + inserts a non-existing tuple + -# NdbOperation::writeTuple : + updates an existing tuple if is exists, + otherwise inserts a new tuple + -# NdbOperation::updateTuple : + updates an existing tuple + -# NdbOperation::deleteTuple : + deletes an existing tuple + -# NdbOperation::readTuple : + reads an existing tuple + -# NdbOperation::readTupleExclusive : + reads an existing tuple using an exclusive lock + -# NdbOperation::simpleRead : + reads an existing tuple (using shared read lock), + but releases lock immediately after read + -# NdbOperation::committedRead : + reads committed tuple + -# NdbOperation::dirtyUpdate : + updates an existing tuple, but releases lock immediately + after read (uses dirty lock) + -# NdbOperation::dirtyWrite : + updates or writes a tuple, but releases lock immediately + after read (uses dirty lock) + + All of these operations operate on the unique tuple key. + (When NdbIndexOperation is used then all of these operations + operate on a defined secondary index.) + + + Some comments: + - NdbOperation::simpleRead and + NdbOperation::committedRead can execute on the same transaction + as the above operations but will release its locks immediately + after reading the tuple. + NdbOperation::simpleRead will always read the latest version + of the tuple. + Thus it will wait until it can acquire a shared read lock on + the tuple. + NdbOperation::committedRead will read the latest committed + version of the tuple. +
+ Both NdbOperation::simpleRead and NdbOperation::committedRead + are examples of consistent reads which are not repeatable. + All reads read the latest version if updates were made by the same + transaction. + Errors on simple read are only reported by the NdbOperation object. + These error codes are not transferred to the NdbConnection object. + - NdbOperation::dirtyUpdate and NdbOperation::dirtyWrite + will execute in the same transaction + but will release the lock immediately after updating the + tuple. + It will wait on the lock until it can acquire an exclusive + write lock. + In a replicated version of NDB Cluster NdbOperation::dirtyUpdate + can lead to inconsistency between the replicas. + Examples of when it could be used is + to update statistical counters on tuples which are "hot-spots". + + @note If you want to define multiple operations within the same transaction, + then you need to call NdbConnection::getNdbOperation + (or NdbConnection::getNdbIndexOperation) for each + operation. + + +

Step 2: Specify Search Conditions

+ The search condition is used to select tuples. + (In the current NdbIndexOperation implementation + this means setting the value of + the secondary index attributes of the wanted tuple.) + + If a tuple identity is used, then NdbOperation::setTupleId + is used to define the search key when inserting new tuples. + Otherwise, NdbOperation::equal is used. + + For NdbOperation::insertTuple it is also allowed to define the + search key by using NdbOperation::setValue. + The NDB API will automatically detect that it is + supposed to use NdbOperation::equal instead. + For NdbOperation::insertTuple it is not necessary to use + NdbOperation::setValue on key attributes before other attributes. + + +

Step 3: Specify Attribute Actions

+ Now it is time to define which attributes should be read or updated. + Deletes can neither read nor set values, read can only read values and + updates can only set values. + Normally the attribute is defined by its name but it is + also possible to use the attribute identity to define the + attribute. + The mapping from name to identity is performed by the Table object. + + NdbIndexOperation::getValue returns an NdbRecAttr object + containing the read value. + To get the value, there is actually two methods. + The application can either + - use its own memory (passed through a pointer aValue) to + NdbIndexOperation::getValue, or + - receive the attribute value in an NdbRecAttr object allocated + by the NDB API. + + The NdbRecAttr object is released when Ndb::closeTransaction + is called. + Thus, the application can not reference this object after + Ndb::closeTransaction have been called. + The result of reading data from an NdbRecAttr object before + calling NdbConnection::execute is undefined. + + + +

Interpreted Program Operations

+ The following types of interpreted program operations exist: + -# NdbOperation::interpretedUpdateTuple : + updates a tuple using an interpreted program + -# NdbOperation::interpretedDeleteTuple : + delete a tuple using an interpreted program + -# NdbOperation::openScanRead : + scans a table with read lock on each tuple + -# NdbOperation::openScanExclusive : + scans a table with exclusive update lock on each tuple + + The operations interpretedUpdateTuple and interpretedDeleteTuple both + work using the unique tuple key. + + These interpreted programs + make it possible to perform computations + inside the NDB Cluster Kernel instead of in the application + program. + This is sometimes very effective, since no intermediate results + are sent to the application, only the final result. + + +

Interpreted Update and Delete

+ + Operations for interpreted updates and deletes must follow a + certain order when defining operations on a tuple. + As for read and write operations, + one must first define the operation type and then the search key. + -# The first step is to define the initial readings. + In this phase it is only allowed to use the + NdbOperation::getValue method. + This part might be empty. + -# The second step is to define the interpreted part. + The methods supported are the methods listed below except + NdbOperation::def_subroutine and NdbOperation::ret_sub + which can only be used in a subroutine. + NdbOperation::incValue and NdbOperation::subValue + increment and decrement attributes + (currently only unsigned integers supported). + This part can also be empty since interpreted updates + can be used for reading and updating the same tuple. +

+ Even though getValue and setValue are not really interpreted + program instructions, it is still allowed to use them as + the last instruction of the program. + (If a getValue or setValue is found when an interpret_exit_ok + could have been issued then the interpreted_exit_ok + will be inserted. + A interpret_exit_ok should be viewed as a jump to the first + instruction after the interpreted instructions.) + -# The third step is to define all updates without any + interpreted program instructions. + Here a set of NdbOperation::setValue methods are called. + There might be zero such calls. + -# The fourth step is the final readings. + The initial readings reads the initial value of attributes + and the final readings reads them after their updates. + There might be zero NdbOperation::getValue calls. + -# The fifth step is possible subroutine definitions using + NdbOperation::def_subroutine and NdbOperation::ret_sub. + + + @subsection secScan Scanning + The most common use of interpreted programs is for scanning + tables. Scanning is a search of all tuples in a table. + Tuples which satisfy conditions (a search filter) + stated in the interpreted program + are sent to the application. + + Reasons for using scan transactions include + need to use a search key different from the primary key + and any secondary index. + Or that the query needs to access so many tuples so that + it is more efficient to scan the entire table. + + Scanning can also be used to update information. + The scanning transaction itself is however + not allowed to update any tuples. + To do updates via scanning transactions, the tuples + need to be handed over to another transaction which is + executing the actual update. + + Even though a scan operation is part of a transaction, + the scan transaction is not a normal transaction. + The locks are not kept throughout the entire + scan transaction, since this would imply non-optimal performance. + + A transaction containing a scan operation can only + contain that operation. + No other operations are allowed in the same transaction. + + + The NdbOperation::openScanRead operation + only sets a temporary read lock while + reading the tuple. + The tuple lock is released already when the + result of the read reaches the application. + The NdbOperation::openScanExclusive operation sets an + exclusive lock on the tuple + and sends the result to the application. + Thus when the application reads the data it is still + locked with the exclusive lock. + + If the application desires to update the tuple it may transfer + the tuple to another transaction which updates the tuple. + The updating transaction can consist of a combination of tuples + received from the scan and normal operations. + + For transferred operations it is not necessary to provide the + primary key. It is part of the transfer. + You only need to give the operation type and the + actions to perform on the tuple. + + The scan transaction starts like a usual transaction, + but is of the following form: + -# Start transaction + -# Get NdbOperation for the table to be scanned + -# Set the operation type using NdbOperation::openScanRead or + NdbOperation::openScanExclusive + -# Search conditions are defined by an interpreted program + (setValue and write_attr are not allowed, since scan transactions + are only allowed to read information). + The instruction interpret_exit_nok does in this case + not abort the transaction, it only skips the tuple and + proceeds with the next. + The skipped tuple will not be reported to the application. + -# Call NdbConnection::executeScan to define (and start) the scan. + -# Call NdbConnection::nextScanResult to proceed with next tuple. + When calling NdbConnection::nextScanResult, the lock on any + previous tuples are released. +
+ If the tuple should be updated then it must be transferred over + to another updating transaction. + This is performed by calling + NdbOperation::takeOverForUpdate or takeOverForDelete on + the scanning transactions NdbOperation object with the updating + transactions NdbConnection object as parameter. +

+ If NdbOperation::takeOverFor* returns NULL then the + operation was not successful, otherwise it returns a reference + to the NdbOperation which the updating transaction has received + -# Use Ndb::closeTransaction as usual to close the transaction. + This can be performed even if there are more tuples to scan. + + See also example program in section @ref select_all.cpp. + + However, a new scan api is under development, using NdbScanOperation + and NdbScanFilter. NdbScanFilter makes it easier to define a search + criteria and is recommended instead of using Interpreted Programs. + + The scan transaction starts like a usual transaction, + but is of the following form: + -# Start transaction + -# Get NdbScanOperation for the table to be scanned + -# NdbScanOperation::readTuplesExclusive returns a handle to a + NdbResultSet. + -# Search conditions are defined by NdbScanFilter + -# Call NdbConnection::execute(NoCommit) to start the scan. + -# Call NdbResultSet::nextResult to proceed with next tuple. + When calling NdbResultSet::nextResult(false), the lock on any + previous tuples are released and the next tuple cached in the API + is fetched. +
+ If the tuple should be updated then define a new update operation + (NdbOperation) using NdbResultSet::updateTuple(). + The new update operation can the be used to modify the tuple. + When nextResult(false) returns != 0, then no more tuples + are cached in the API. Updated tuples is now commit using + NdbConnection::execute(Commit). + After the commit, more tuples are fetched from NDB using + nextResult(true). + -# Use Ndb::closeTransaction as usual to close the transaction. + This can be performed even if there are more tuples to scan. + + See the scan example program in @ref ndbapi_scan.cppn for example + usage of the new scan api. + + +

Interpreted Programs

+ Interpretation programs are executed in a + register-based virtual machine. + The virtual machine has eight 64 bit registers numbered 0-7. + Each register contains type information which is used both + for type conversion and for type checking. + + @note Arrays are currently not supported in the virtual machine. + Currently only unsigned integers are supported and of size + maximum 64 bits. + + All errors in the interpretation program will cause a + transaction abort, but will not affect any other transactions. + + The following are legal interpreted program instructions: + -# incValue : Add to an attribute + -# subValue : Subtract from an attribute + -# def_label : Define a label in the interpreted program + -# add_reg : Add two registers + -# sub_reg : Subtract one register from another + -# load_const_u32 : Load an unsigned 32 bit value into a register + -# load_const_u64 : Load an unsigned 64 bit value into a register + -# load_const_null : Load a NULL value into a register + -# read_attr : Read attribute value into a register + -# write_attr : Write a register value into an attribute + -# branch_ge : Compares registers and possibly jumps to specified label + -# branch_gt : Compares registers and possibly jumps to specified label + -# branch_le : Compares registers and possibly jumps to specified label + -# branch_lt : Compares registers and possibly jumps to specified label + -# branch_eq : Compares registers and possibly jumps to specified label + -# branch_ne : Compares registers and possibly jumps to specified label + -# branch_ne_null : Jumps if register does not contain NULL value + -# branch_eq_null : Jumps if register contains NULL value + -# branch_label : Unconditional jump to label + -# interpret_exit_ok : Exit interpreted program + (approving tuple if used in scan) + -# interpret_exit_nok : Exit interpreted program + (disqualifying tuple if used in scan) + + There are also three instructions for subroutines, which + are described in the next section. + + @subsection subsubSub Interpreted Programs: Subroutines + + The following are legal interpreted program instructions for + subroutines: + -# NdbOperation::def_subroutine : + Defines start of subroutine in interpreted program code + -# NdbOperation::call_sub : + Calls a subroutine + -# NdbOperation::ret_sub : + Return from subroutine + + The virtual machine executes subroutines using a stack for + its operation. + The stack allows for up to 24 subroutine calls in succession. + Deeper subroutine nesting will cause an abort of the transaction. + + All subroutines starts with the instruction + NdbOperation::def_subroutine and ends with the instruction + NdbOperation::ret_sub. + If it is necessary to return earlier in the subroutine + it has to be done using a branch_label instruction + to a label defined right before the + NdbOperation::ret_sub instruction. + + @note The subroutines are automatically numbered starting with 0. + The parameter used by NdbOperation::def_subroutine + should match the automatic numbering to make it easier to + debug the interpreted program. + + + @section secAsync Asynchronous Transactions + The asynchronous interface is used to increase the speed of + transaction executing by better utilizing the connection + between the application and the NDB Kernel. + The interface is used to send many transactions + at the same time to the NDB kernel. + This is often much more efficient than using synchronous transactions. + The main reason for using this method is to ensure that + Sending many transactions at the same time ensures that bigger + chunks of data are sent when actually sending and thus decreasing + the operating system overhead. + + The synchronous call to NdbConnection::execute + normally performs three main steps:
+ -# Prepare + Check transaction status + - if problems, abort the transaction + - if ok, proceed + -# Send + Send the defined operations since last execute + or since start of transaction. + -# Poll + Wait for response from NDB kernel. + + The asynchronous method NdbConnection::executeAsynchPrepare + only perform step 1. + (The abort part in step 1 is only prepared for. The actual + aborting of the transaction is performed in a later step.) + + Asynchronous transactions are defined and executed + in the following way. + -# Start (create) transactions (same way as for the + synchronous transactions) + -# Add and define operations (also as in the synchronous case) + -# Prepare transactions + (using NdbConnection::executeAsynchPrepare or + NdbConnection::executeAsynch) + -# Send transactions to NDB Kernel + (using Ndb::sendPreparedTransactions, + NdbConnection::executeAsynch, or Ndb::sendPollNdb) + -# Poll NDB kernel to find completed transactions + (using Ndb::pollNdb or Ndb::sendPollNdb) + -# Close transactions (same way as for the synchronous transactions) + + See example program in section @ref ndbapi_example2.cpp. + + This prepare-send-poll protocol actually exists in four variants: + - (Prepare-Send-Poll). This is the one-step variant provided + by synchronous transactions. + - (Prepare-Send)-Poll. This is the two-step variant using + NdbConnection::executeAsynch and Ndb::pollNdb. + - Prepare-(Send-Poll). This is the two-step variant using + NdbConnection::executeAsynchPrepare and Ndb::sendPollNdb. + - Prepare-Send-Poll. This is the three-step variant using + NdbConnection::executeAsynchPrepare, Ndb::sendPreparedTransactions, and + Ndb::pollNdb. + + Transactions first has to be prepared by using method + NdbConnection::executeAsynchPrepare or NdbConnection::executeAsynch. + The difference between these is that + NdbConnection::executeAsynch also sends the transaction to + the NDB kernel. + One of the arguments to these methods is a callback method. + The callback method is executed during polling (item 5 above). + + Note that NdbConnection::executeAsynchPrepare does not + send the transaction to the NDB kernel. When using + NdbConnection::executeAsynchPrepare, you either have to call + Ndb::sendPreparedTransactions or Ndb::sendPollNdb to send the + database operations. + (Ndb::sendPollNdb also polls Ndb for completed transactions.) + + The methods Ndb::pollNdb and Ndb::sendPollNdb checks if any + sent transactions are completed. The method Ndb::sendPollNdb + also send all prepared transactions before polling NDB. + Transactions still in the definition phase (i.e. items 1-3 above, + transactions which has not yet been sent to the NDB kernel) are not + affected by poll-calls. + The poll method invoked (either Ndb::pollNdb or Ndb::sendPollNdb) + will return when: + -# at least 'minNoOfEventsToWakeup' of the transactions + are finished processing, and + -# all of these transactions have executed their + callback methods. + + The poll method returns the number of transactions that + have finished processing and executed their callback methods. + + @note When an asynchronous transaction has been started and sent to + the NDB kernel, it is not allowed to execute any methods on + objects belonging to this transaction until the transaction + callback method have been executed. + (The transaction is stated and sent by either + NdbConnection::executeAsynch or through the combination of + NdbConnection::executeAsynchPrepare and either + Ndb::sendPreparedTransactions or Ndb::sendPollNdb). + + More about how transactions are send the NDB Kernel is + available in section @ref secAdapt. + + + @section secError Error Handling + + Errors can occur when + -# operations are being defined, or when the + -# transaction is being executed. + + One recommended way to handle a transaction failure + (i.e. an error is reported) is to: + -# Rollback transaction (NdbConnection::execute with a special parameter) + -# Close transaction + -# Restart transaction (if the error was temporary) + + @note Transaction are not automatically closed when an error occur. + + Several errors can occur when a transaction holds multiple + operations which are simultaneously executed. + In this case the application has to go through the operation + objects and query for their NdbError objects to find out what really + happened. + + NdbConnection::getNdbErrorOperation returns a reference to the + operation causing the latest error. + NdbConnection::getNdbErrorLine delivers the method number of the + erroneous method in the operation. + + @code + theConnection = theNdb->startTransaction(); + theOperation = theConnection->getNdbOperation("TEST_TABLE"); + if (theOperation == NULL) goto error; + theOperation->readTuple(); + theOperation->setValue("ATTR_1", at1); + theOperation->setValue("ATTR_2", at1); //Here an error occurs + theOperation->setValue("ATTR_3", at1); + theOperation->setValue("ATTR_4", at1); + + if (theConnection->execute(Commit) == -1) { + errorLine = theConnection->getNdbErrorLine(); + errorOperation = theConnection->getNdbErrorOperation(); + @endcode + + Here errorLine will be 3 as the error occurred in the third method + on the operation object. + Getting errorLine == 0 means that the error occurred when executing the + operations. + Here errorOperation will be a pointer to the theOperation object. + NdbConnection::getNdbError will return the NdbError object + including holding information about the error. + + Since errors could have occurred even when a commit was reported, + there is also a special method, NdbConnection::commitStatus, + to check the commit status of the transaction. + +*******************************************************************************/ + +/** + * @page ndbapi_example1.cpp ndbapi_example1.cpp + * @include ndbapi_example1.cpp + */ + +/** + * @page ndbapi_example2.cpp ndbapi_example2.cpp + * @include ndbapi_example2.cpp + */ + +/** + * @page ndbapi_example3.cpp ndbapi_example3.cpp + * @include ndbapi_example3.cpp + */ + +/** + * @page ndbapi_example4.cpp ndbapi_example4.cpp + * @include ndbapi_example4.cpp + */ + +/** + * @page select_all.cpp select_all.cpp + * @include select_all.cpp + */ + +/** + * @page ndbapi_async.cpp ndbapi_async.cpp + * @include ndbapi_async.cpp + */ + +/** + * @page ndbapi_scan.cpp ndbapi_scan.cpp + * @include ndbapi_scan.cpp + */ + + +/** + @page secAdapt Adaptive Send Algorithm + + At the time of "sending" the transaction + (using NdbConnection::execute, NdbConnection::executeAsynch, + Ndb::sendPreparedTransactions, or Ndb::sendPollNdb), the transactions + are in reality not immediately transfered to the NDB Kernel. + Instead, the "sent" transactions are only kept in a + special send list (buffer) in the Ndb object to which they belong. + The adaptive send algorithm decides when transactions should + be transfered to the NDB kernel. + + For each of these "sent" transactions, there are three + possible states: + -# Waiting to be transfered to NDB Kernel. + -# Has been transfered to the NDB Kernel and is currently + being processed. + -# Has been transfered to the NDB Kernel and has + finished processing. + Now it is waiting for a call to a poll method. + (When the poll method is invoked, + then the transaction callback method will be executed.) + + The poll method invoked (either Ndb::pollNdb or Ndb::sendPollNdb) + will return when: + -# at least 'minNoOfEventsToWakeup' of the transactions + in the send list have transitioned to state 3 as described above, and + -# all of these transactions have executed their callback methods. + + + Since the NDB API is designed as a multi-threaded interface, + it is desirable to transfer database operations from more than + one thread at a time. + The NDB API keeps track of which Ndb objects are active in transfering + information to the NDB kernel and the expected amount of threads to + interact with the NDB kernel. + Note that an Ndb object should be used in at most one thread. + Two different threads should not use the same Ndb object. + + There are four reasons leading to transfering of database + operations: + -# The NDB Transporter (TCP/IP, OSE, SCI or shared memory) + decides that a buffer is full and sends it off. + The buffer size is implementation dependent and + might change between NDB Cluster releases. + On TCP/IP the buffer size is usually around 64 kByte and + on OSE/Delta it is usually less than 2000 bytes. + In each Ndb object there is one buffer per DB node, + so this criteria of a full buffer is only + local to the connection to one DB node. + -# Statistical information on the transfered information + may force sending of buffers to all DB nodes. + -# Every 10 ms a special send-thread checks whether + any send activity has occurred. If not, then the thread will + force sending to all nodes. + This means that 20 ms is the maximum time database operations + are waiting before being sent off. The 10 millisecond limit + is likely to become a configuration parameter in + later releases of NDB Cluster. + However, to support faster than 10 ms checks, + there has to be support from the operating system. + -# When calling NdbConnection::execute synchronously or calling any + of the poll-methods, there is a force parameter that overrides the + adaptive algorithm and forces the send to all nodes. + + @note The times mentioned above are examples. These might + change in later releases of NDB Cluster. +*/ + +/** + @page secConcepts NDB Cluster Concepts + + The NDB Kernel is the collection of database (DB) nodes + belonging to an NDB Cluster. + The application programmer can for most purposes view the + set of all DB nodes as one entity. + Each DB node has three main components: + - TC : The transaction coordinator + - ACC : The index storage + - TUP : The data storage + + When the application program executes a transaction, + it connects to one TC on one DB node. + Usually, the programmer does not need to specify which TC to use, + but some cases when performance is important, + transactions can be hinted to use a certain TC. + (If the node with the TC is down, then another TC will + automatically take over the work.) + + Every DB node has an ACC and a TUP which stores + the index and the data part of the database. + Even though one TC is responsible for the transaction, + several ACCs and TUPs on other DB nodes might be involved in the + execution of the transaction. + + + @section secNdbKernelConnection Selecting Transaction Coordinator + The default method is round robin, + where each new set of transactions + is placed on the next DB node. + The application chooses a TC for a number of transactions + and then lets the next TC (on the next DB node) carry out + the next set of transactions. + + The application programmer can however hint the NDB API which + transaction coordinator to use + by providing a distribution key (usually the primary key). + By using the primary key as distribution key, + the transaction will be placed on the node where the primary replica + of that record resides. + Note that this is only a hint, the system can be + reconfigured and then the NDB API will choose a transaction + coordinator without using the hint. + For more information, see NdbDictionary::Column::setDistributionKey. + + + @section secRecordStruct Record Structure + NDB Cluster is a relational database with tables of records. + Table rows represent tuples of relational data stored as records. + When created, the attribute schema of the table is specified, + and thus each record of the table has the same schema. + + + @subsection secKeys Tuple Keys + Each record has from zero up to four attributes which belong + to the primary key of the table. + If no attribute belongs to the primary key, then + the NDB Cluster creates an attribute named NDB$TID + which stores a tuple identity. + The tuple key of a table is thus either + the primary key attributes or the special NDB$TID attribute. + + + @subsection secArrays Array Attributes + A table attribute in NDB Cluster can be of array type. + This means that the attribute consists of an array of + elements. The attribute size is the size + of one element of the array (expressed in bits) and the + array size is the number of elements of the array. + + + @section secTrans Transactions + + Transactions are committed to main memory, + and are committed to disk after a global checkpoint, GCP. + Since all data is (in most NDB Cluster configurations) + synchronously replicated and stored on multiple NDB nodes, + the system can still handle processor failures without loss + of data. + However, in the case of a system failure (e.g. the whole system goes down), + then all (committed or not) transactions after the latest GCP are lost. + + + @subsection secConcur Concurrency Control + NDB Cluster uses pessimistic concurrency control based on locking. + If a requested lock (implicit and depending on database operation) + cannot be attained within a specified time, + then a timeout error occurs. + + Concurrent transactions (parallel application programs, thread-based + applications, or applications with asynchronous transactions) + sometimes deadlock when they try to access the same information. + Applications need to be programmed so that timeout errors + occurring due to deadlocks are handled. This generally + means that the transaction encountering timeout + should be rolled back and restarted. +*/ + +#ifndef Ndb_H +#define Ndb_H + +#include +#include +#include "AttrType.hpp" +#include +#include "NdbDictionary.hpp" + +class NdbObjectIdMap; +class NdbOperation; +class NdbEventOperationImpl; +class NdbScanOperation; +class NdbIndexOperation; +class NdbConnection; +class NdbSchemaOp; +class NdbSchemaCon; +class NdbApiSignal; +class NdbRecAttr; +class NdbLabel; +class NdbBranch; +class NdbSubroutine; +class NdbCall; +class NdbScanReceiver; +class Table; +class BaseString; +class NdbEventOperation; + +typedef void (* NdbEventCallback)(NdbEventOperation*, Ndb*, void*); + + +#if defined NDB_OSE +/** + * Default time to wait for response after request has been sent to + * NDB Cluster (Set to 10 seconds usually, but to 100 s in + * the OSE operating system) + */ +#define WAITFOR_RESPONSE_TIMEOUT 100000 // Milliseconds +#else +#define WAITFOR_RESPONSE_TIMEOUT 120000 // Milliseconds +#endif + +#define NDB_MAX_INTERNAL_TABLE_LENGTH NDB_MAX_DATABASE_NAME_SIZE + \ + NDB_MAX_SCHEMA_NAME_SIZE + \ + NDB_MAX_TAB_NAME_SIZE*2 + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL +class NdbWaiter { +public: + NdbWaiter(); + ~NdbWaiter(); + + void wait(int waitTime); + void nodeFail(Uint32 node); + void signal(Uint32 state); + + Uint32 m_node; + Uint32 m_state; + void * m_mutex; + struct NdbCondition * m_condition; +}; +#endif + +/** + * @class Ndb + * @brief Represents the NDB kernel and is the main class of the NDB API. + * + * Always start your application program by creating an Ndb object. + * By using several Ndb objects it is possible to design + * a multi-threaded application, but note that Ndb objects + * cannot be shared by several threads. + * Different threads should use different Ndb objects. + * A thread might however use multiple Ndb objects. + * Currently there is a limit of maximum 128 Ndb objects + * per application process. + * + * @note It is not allowed to call methods in the NDB API + * on the same Ndb object in different threads + * simultaneously (without special handling of the + * Ndb object). + * + * @note The Ndb object is multi-thread safe in the following manner. + * Each Ndb object can ONLY be handled in one thread. + * If an Ndb object is handed over to another thread then the + * application must ensure that a memory barrier is used to + * ensure that the new thread see all updates performed by + * the previous thread. + * Semaphores, mutexes and so forth are easy ways of issuing memory + * barriers without having to bother about the memory barrier concept. + * + * If one Ndb object is used to handle parallel transactions through the + * asynchronous programming interface, please read the notes regarding + * asynchronous transactions (Section @ref secAsync). + * The asynchronous interface provides much higher performance + * in some situations, but is more complicated for the application designer. + * + * @note Each Ndb object should either use the methods for + * asynchronous transaction or the methods for + * synchronous transactions but not both. + */ +class Ndb +{ + friend class NdbReceiver; + friend class NdbOperation; + friend class NdbEventOperationImpl; + friend class NdbConnection; + friend class NdbSchemaOp; + friend class NdbSchemaCon; + friend class Table; + friend class NdbApiSignal; + friend class NdbScanReceiver; + friend class NdbIndexOperation; + friend class NdbDictionaryImpl; + friend class NdbDictInterface; + +public: + /** + * @name General + * @{ + */ + /** + * The starting point of your application code is to create an + * Ndb object. + * This object represents the NDB kernel and is the main + * object used in interaction with the NDB kernel. + * + * @param aCatalogName is the name of the catalog you want to use. + * @note The catalog name provides a name space for the tables and + * indexes created in any connection from the Ndb object. + * @param aSchemaName is the name of the schema you + * want to use. It is optional and defaults to the "def" schema. + * @note The schema name provides an additional name space + * for the tables and indexes created in a given catalog. + * @note The methods get/setDatabaseName and get/setDatabaseSchemaName + * are equivalent to get/setCatalogName and get/setSchemaName. + * The get/setDatabaseName and get/setDatabaseSchemaName are + * deprecated. + */ + Ndb(const char* aCatalogName = "", const char* aSchemaName = "def"); + + ~Ndb(); + + /** + * The current catalog name can be fetched by getCatalogName. + * + * @return the current catalog name + */ + const char * getCatalogName() const; + + /** + * The current catalog name can be set by setCatalogName. + * + * @param aCatalogName is the new name of the current catalog + */ + void setCatalogName(const char * aCatalogName); + + /** + * The current schema name can be fetched by getSchemaName. + * + * @return the current schema name + */ + const char * getSchemaName() const; + + /** + * The current schema name can be set by setSchemaName. + * + * @param aSchemaName is the new name of the current schema + */ + void setSchemaName(const char * aSchemaName); + + + /** + * The current database name can be fetched by getDatabaseName. + * + * @return the current database name + */ + const char * getDatabaseName() const; + + /** + * The current database name can be set by setDatabaseName. + * + * @param aDatabaseName is the new name of the current database + */ + void setDatabaseName(const char * aDatabaseName); + + /** + * The current database schema name can be fetched by getDatabaseSchemaName. + * + * @return the current database schema name + */ + const char * getDatabaseSchemaName() const; + + /** + * The current database schema name can be set by setDatabaseSchemaName. + * + * @param aDatabaseSchemaName is the new name of the current database schema + */ + void setDatabaseSchemaName(const char * aDatabaseSchemaName); + + /** + * Before anything else it is necessary to initialize (start) + * the Ndb object. + * + * @param maxNoOfTransactions + * Maximum number of parallel + * NdbConnection objects that should be handled by the Ndb object. + * A value larger than 1024 will be downgraded to 1024. + * This means that one Ndb object can handle at most 1024 parallel + * transactions. + * There is a maximum of 128 simultaneous + * Ndb object within one application process. + * @return 0 if successful, -1 otherwise. + * + * @note The internal implementation multiplies this value + * with 3. + */ + int init(int maxNoOfTransactions = 4); + + /** + * Wait for Ndb object to successfully set-up connections to + * the NDB kernel. + * Starting to use the Ndb object without using this method + * gives unspecified behavior. + * + * @param timeout The maximum time we will wait for + * the initiation process to finish. + * Timeout is expressed in seconds. + * @return 0: Ndb is ready and timeout has not occurred.
+ * -1: Timeout has expired + */ + int waitUntilReady(int timeout = 60); + + /** @} *********************************************************************/ + + /** + * @name Meta Information + * @{ + */ + + /** + * Query the database for schema information + * (without performing any transaction). + * + * @return Object containing meta information about all tables + * in NDB Cluster. + */ + class NdbDictionary::Dictionary* getDictionary() const; + + NdbEventOperation* createEventOperation(const char* eventName, + const int bufferLength); + int dropEventOperation(NdbEventOperation*); + void monitorEvent(NdbEventOperation *, NdbEventCallback, void*); + int pollEvents(int aMillisecondNumber); + + /** + * Get the application node identity. + * + * Each node (DB nodes, Applications, and Management Servers) + * has its own node identity in the NDB Cluster. + * See documentation for the management server configuration file. + * + * @return Node id of this application. + */ + int getNodeId(); + + /** @} *********************************************************************/ + + /** + * @name Starting and Closing Transactions + * @{ + */ + + /** + * This method returns an NdbConnection which caters for the transaction. + * When the transaction is completed it must be closed. + * The Ndb::closeTransaction also return the NdbConnection object + * and all other memory related to the transaction. + * Failure to close the transaction will lead to memory leakage. + * The transaction must be closed independent of its outcome, i.e. + * even if there is an error. + * + * NDB API can be hinted to select a particular transaction coordinator. + * The default method is round robin where each set of new transactions + * is placed on the next NDB kernel node. + * By providing a distribution key (usually the primary key + * of the mostly used table of the transaction) for a record + * the transaction will be placed on the node where the primary replica + * of that record resides. + * Note that this is only a hint, the system can + * be under reconfiguration and then the NDB API + * will use select the transaction coordinator without using + * this hint. + * + * Placing the transaction coordinator close + * to the actual data used in the transaction can in many cases + * improve performance significantly. This is particularly true for + * systems using TCP/IP. A system using Solaris and a 500 MHz processor + * has a cost model for TCP/IP communication which is: + * + * 30 microseconds + (100 nanoseconds * no of Bytes) + * + * This means that if we can ensure that we use "popular" links we increase + * buffering and thus drastically reduce the communication cost. + * Systems using SCI has a different cost model which is: + * + * 5 microseconds + (10 nanoseconds * no of Bytes) + * + * Thus SCI systems are much less dependent on selection of + * transaction coordinators. + * Typically TCP/IP systems spend 30-60% of the time during communication, + * whereas SCI systems typically spend 5-10% of the time during + * communication. + * Thus SCI means that less care from the NDB API programmer is + * needed and great scalability can be achieved even for applications using + * data from many parts of the database. + * + * A simple example is an application that uses many simple updates where + * a transaction needs to update one record. + * This record has a 32 bit primary key, + * which is also the distribution key. + * Then the keyData will be the address of the integer + * of the primary key and keyLen will be 4. + * + * @note Transaction priorities are not yet supported. + * + * @param prio The priority of the transaction.
+ * Priority 0 is the highest priority and is used + * for short transactions with requirements on low delay.
+ * Priority 1 is a medium priority for short transactions. + *
+ * Priority 2 is a medium priority for long transactions.
+ * Priority 3 is a low priority for long transactions.
+ * This parameter is not currently used, + * and can be set to any value + * @param keyData Pointer to distribution key + * @param keyLen Length of distribution key expressed in bytes + * + * @return NdbConnection object, or NULL if method failed. + */ + NdbConnection* startTransaction(Uint32 prio = 0, + const char * keyData = 0, + Uint32 keyLen = 0); + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL + /** + * This method is a modification of Ndb::startTransaction, + * in which we use only the first two chars of keyData to + * select transaction coordinator. + * This is referred to as a distribution group. + * There are two ways to use the method: + * - In the first, the two characters are used directly as + * the distribution key, and + * - in the second the distribution is calculated as: + * (10 * (char[0] - 0x30) + (char[1] - 0x30)). + * Thus, in the second way, the two ASCII digits '78' + * will provide the distribution key = 78. + * + * @note Transaction priorities are not yet supported. + * + * @param aPrio Priority of the transaction.
+ * Priority 0 is the highest priority and is used for short transactions + * with requirements on low delay.
+ * Priority 1 is a medium priority for short transactions.
+ * Priority 2 is a medium priority for long transactions.
+ * Priority 3 is a low priority for long transactions. + * @param keyData is a string of which the two first characters + * is used to compute which fragement the data is stored in. + * @param type is the type of distribution group.
+ * 0 means direct usage of the two characters, and
+ * 1 means the ASCII digit variant. + * @return NdbConnection, or NULL if it failed. + */ + NdbConnection* startTransactionDGroup(Uint32 aPrio, + const char * keyData, int type); +#endif + + /** + * When a transactions is completed, the transaction has to be closed. + * + * @note It is not allowed to call Ndb::closeTransaction after sending the + * transaction asynchronously with either + * Ndb::sendPreparedTransactions or + * Ndb::sendPollNdb before the callback method has been called. + * (The application should keep track of the number of + * outstanding transactions and wait until all of them + * has completed before calling Ndb::closeTransaction). + * If the transaction is not committed it will be aborted. + */ + void closeTransaction(NdbConnection* aConnection); + +#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED + /** + * To create a table it is necessary to obtain a schema transaction + * object. + * All schema transactions need to closed when they are + * completed. + * + * @return NdbSchemaCon + */ + NdbSchemaCon* startSchemaTransaction(); + + /** + * Close schema transaction when finished. + */ + void closeSchemaTransaction(NdbSchemaCon* aSchemaCon); +#endif + + /** @} *********************************************************************/ + + /** + * @name Asynchronous Transactions + * @{ + */ + + /** + * Wait for prepared transactions. + * Will return as soon as at least 'minNoOfEventsToWakeUp' + * of them have completed, or the maximum time given as timeout has passed. + * + * @param aMillisecondNumber Maximum time to wait for transactions + * to complete. + * Polling without wait is achieved by setting the + * timer to zero. + * Time is expressed in milliseconds. + * @param minNoOfEventsToWakeup Minimum number of transactions + * which has to wake up before the poll-call will return. + * If minNoOfEventsToWakeup is + * set to a value larger than 1 then this is the minimum + * number of transactions that need to complete before the + * poll will return. + * Setting it to zero means that one should wait for all + * outstanding transactions to return before waking up. + * @return Number of transactions polled. + */ + int pollNdb(int aMillisecondNumber = WAITFOR_RESPONSE_TIMEOUT, + int minNoOfEventsToWakeup = 1); + + /** + * This send method will send all prepared database operations. + * The default method is to do it non-force and instead + * use the adaptive algorithm. (See Section @ref secAdapt.) + * The second option is to force the sending and + * finally there is the third alternative which is + * also non-force but also making sure that the + * adaptive algorithm do not notice the send. + * In this case the sending will be performed on a + * cyclical 10 millisecond event. + * + * @param forceSend When operations should be sent to NDB Kernel. + * (See @ref secAdapt.) + * - 0: non-force, adaptive algorithm notices it (default); + * - 1: force send, adaptive algorithm notices it; + * - 2: non-force, adaptive algorithm do not notice the send. + */ + void sendPreparedTransactions(int forceSend = 0); + + /** + * This is a send-poll variant that first calls + * Ndb::sendPreparedTransactions and then Ndb::pollNdb. + * It is however somewhat faster than calling the methods + * separately, since some mutex-operations are avoided. + * See documentation of Ndb::pollNdb and Ndb::sendPreparedTransactions + * for more details. + * + * @param aMillisecondNumber Timeout specifier + * Polling without wait is achieved by setting the + * millisecond timer to zero. + * @param minNoOfEventsToWakeup Minimum number of transactions + * which has to wake up before the poll-call will return. + * If minNoOfEventsToWakeup is + * set to a value larger than 1 then this is the minimum + * number of transactions that need to complete before the + * poll-call will return. + * Setting it to zero means that one should wait for all + * outstanding transactions to return before waking up. + * @param forceSend When operations should be sent to NDB Kernel. + * (See @ref secAdapt.) + * - 0: non-force, adaptive algorithm notices it (default); + * - 1: force send, adaptive algorithm notices it; + * - 2: non-force, adaptive algorithm does not notice the send. + * @return Number of transactions polled. + */ + int sendPollNdb(int aMillisecondNumber = WAITFOR_RESPONSE_TIMEOUT, + int minNoOfEventsToWakeup = 1, + int forceSend = 0); + + /** @} *********************************************************************/ + + /** + * @name Error Handling + * @{ + */ + + /** + * Get the NdbError object + * + * The NdbError object is valid until you call a new NDB API method. + */ + const NdbError & getNdbError() const; + + /** + * Get a NdbError object for a specific error code + * + * The NdbError object is valid until you call a new NDB API method. + */ + const NdbError & getNdbError(int errorCode); + + + /** + * setConnectString + * @param connectString - the connectString has the following format: + * @code + * "nodeid=;host=host://:; + * host=host://:;..." + * @endcode + * or + * @code + * "nodeid=;host=:;host=:;..." + * @endcode + */ + static void setConnectString(const char * connectString); + + /** + * useFullyQualifiedNames + * Enables unique name space for different databases and schemas + * by defining table names as DATABASENAME/SCHEMANAME/TABLENAME and + * index names as DATABASENAME/SCHEMANAME/TABLENAME/INDEXNAME + * @param turnNamingOn bool true - turn naming on, false - turn naming off + */ + static void useFullyQualifiedNames(bool turnNamingOn = true); + + static bool usingFullyQualifiedNames(); + + /** @} *********************************************************************/ + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL + /** + * For testing purposes it is possible to tamper with the NDB Cluster + * (i.e. send a special signal to DBDIH, the NDB distribution handler). + * This feature should only used for debugging purposes. + * In a release versions of NDB Cluster, + * this call always return -1 and does nothing. + * + * @param aAction Action to be taken + * - 1: Lock global checkpointing + * (Can only be sent to master DIH, + * Parameter aNode ignored). + * - 2: UnLock global checkpointing + * (Can only be sent to master DIH, + * Parameter aNode ignored). + * - 3: Crash node. + * + * @param aNode Which node the action will be taken + * -1: Master DIH. + * 0-16: Nodnumber. + * @return -1 indicates error, other values have meaning dependent + * on type of tampering. + */ + int NdbTamper(TamperType aAction, int aNode); +#endif + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL + /** + * Return a unique tuple id for a table. The id sequence is + * ascending but may contain gaps. + * + * @param aTableName table name + * + * @param cacheSize number of values to cache in this Ndb object + * + * @return tuple id or 0 on error + */ + Uint64 getAutoIncrementValue(const char* aTableName, Uint32 cacheSize = 1); + bool setAutoIncrementValue(const char* aTableName, Uint64 val); + Uint64 getTupleIdFromNdb(const char* aTableName, Uint32 cacheSize = 1000 ); + Uint64 getTupleIdFromNdb(Uint32 aTableId, Uint32 cacheSize = 1000 ); + bool setTupleIdInNdb(const char* aTableName, Uint64 val); + bool setTupleIdInNdb(Uint32 aTableId, Uint64 val); + Uint64 opTupleIdOnNdb(Uint32 aTableId, Uint64 opValue, Uint32 op); +#endif + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL + /** + */ + NdbConnection* hupp( NdbConnection* ); + Uint32 getReference() const { return theMyRef;} +#endif + +/***************************************************************************** + * These are service routines used by the other classes in the NDBAPI. + ****************************************************************************/ +private: + + NdbConnection* startTransactionLocal(Uint32 aPrio, Uint32 aFragmentId); + +// Connect the connection object to the Database. + int NDB_connect(Uint32 tNode); + NdbConnection* doConnect(Uint32 nodeId); + void doDisconnect(); + + NdbScanReceiver* getNdbScanRec();// Get a NdbScanReceiver from idle list + NdbLabel* getNdbLabel(); // Get a NdbLabel from idle list + NdbBranch* getNdbBranch(); // Get a NdbBranch from idle list + NdbSubroutine* getNdbSubroutine();// Get a NdbSubroutine from idle + NdbCall* getNdbCall(); // Get a NdbCall from idle list + NdbApiSignal* getSignal(); // Get an operation from idle list + NdbRecAttr* getRecAttr(); // Get a receeive attribute object from + // idle list of the Ndb object. + NdbOperation* getOperation(); // Get an operation from idle list + NdbScanOperation* getScanOperation(); // Get a scan operation from idle + NdbIndexOperation* getIndexOperation();// Get an index operation from idle + + class NdbGlobalEventBufferHandle* getGlobalEventBufferHandle(); + + void releaseSignal(NdbApiSignal* anApiSignal); + void releaseSignalsInList(NdbApiSignal** pList); + void releaseNdbScanRec(NdbScanReceiver* aNdbScanRec); + void releaseNdbLabel(NdbLabel* anNdbLabel); + void releaseNdbBranch(NdbBranch* anNdbBranch); + void releaseNdbSubroutine(NdbSubroutine* anNdbSubroutine); + void releaseNdbCall(NdbCall* anNdbCall); + void releaseRecAttr (NdbRecAttr* aRecAttr); + void releaseOperation(NdbOperation* anOperation); + void releaseScanOperation(NdbScanOperation* aScanOperation); + + void check_send_timeout(); + void remove_sent_list(Uint32); + Uint32 insert_completed_list(NdbConnection*); + Uint32 insert_sent_list(NdbConnection*); + + // Handle a received signal. Used by both + // synchronous and asynchronous interface + void handleReceivedSignal(NdbApiSignal* anApiSignal, struct LinearSectionPtr ptr[3]); + + // Receive response signals + int receiveResponse(int waitTime = WAITFOR_RESPONSE_TIMEOUT); + + int sendRecSignal(Uint16 aNodeId, + Uint32 aWaitState, + NdbApiSignal* aSignal, + Uint32 nodeSequence); + + // Sets Restart GCI in Ndb object + void RestartGCI(int aRestartGCI); + + // Get block number of this NDBAPI object + int getBlockNumber(); + + /**************************************************************************** + * These are local service routines used by this class. + ***************************************************************************/ + + int createConIdleList(int aNrOfCon); + int createOpIdleList( int nrOfOp ); + + void freeOperation(); // Free the first idle operation. + void freeScanOperation(); // Free the first idle scan operation. + void freeIndexOperation(); // Free the first idle index operation. + void freeNdbCon(); // Free the first idle connection. + void freeSignal(); // Free the first idle signal + void freeRecAttr(); // Free the first idle receive attr obj + void freeNdbLabel(); // Free the first idle NdbLabel obj + void freeNdbBranch();// Free the first idle NdbBranch obj + void freeNdbSubroutine();// Free the first idle NdbSubroutine obj + void freeNdbCall(); // Free the first idle NdbCall obj + void freeNdbScanRec(); // Free the first idle NdbScanRec obj + + NdbConnection* getNdbCon(); // Get a connection from idle list + + /** + * Get a connected NdbConnection to nodeId + * Returns NULL if none found + */ + NdbConnection* getConnectedNdbConnection(Uint32 nodeId); + + // Release and disconnect from DBTC a connection + // and seize it to theConIdleList + void releaseConnectToNdb (NdbConnection* aConnectConnection); + + // Release a connection to idle list + void releaseNdbCon (NdbConnection* aConnection); + + int checkInitState(); // Check that we are initialized + void report_node_failure(Uint32 node_id); // Report Failed node + void report_node_failure_completed(Uint32 node_id); // Report Failed node(NF comp.) + + void checkFailedNode(); // Check for failed nodes + + int NDB_connect(); // Perform connect towards NDB Kernel + + // Release arrays of NdbConnection pointers + void releaseTransactionArrays(); + + Uint32 pollCompleted(NdbConnection** aCopyArray); + void sendPrepTrans(int forceSend); + void reportCallback(NdbConnection** aCopyArray, Uint32 aNoOfComplTrans); + void waitCompletedTransactions(int milliSecs, int noOfEventsToWaitFor); + void completedTransaction(NdbConnection* aTransaction); + void completedScanTransaction(NdbConnection* aTransaction); + + void abortTransactionsAfterNodeFailure(Uint16 aNodeId); + + static + const char * externalizeTableName(const char * internalTableName); + const char * internalizeTableName(const char * externalTableName); + + static + const char * externalizeIndexName(const char * internalIndexName); + const char * internalizeIndexName(const NdbTableImpl * table, + const char * externalIndexName); + + static + const BaseString getDatabaseFromInternalName(const char * internalName); + static + const BaseString getSchemaFromInternalName(const char * internalName); + + void* int2void (Uint32 val); + NdbReceiver* void2rec (void* val); + NdbConnection* void2con (void* val); + NdbScanReceiver* void2rec_srec(void* val); + NdbOperation* void2rec_op (void* val); + NdbIndexOperation* void2rec_iop (void* val); + +/****************************************************************************** + * These are the private variables in this class. + *****************************************************************************/ + NdbObjectIdMap* theNdbObjectIdMap; + + NdbConnection** thePreparedTransactionsArray; + NdbConnection** theSentTransactionsArray; + NdbConnection** theCompletedTransactionsArray; + + Uint32 theNoOfPreparedTransactions; + Uint32 theNoOfSentTransactions; + Uint32 theNoOfCompletedTransactions; + Uint32 theNoOfAllocatedTransactions; + Uint32 theMaxNoOfTransactions; + Uint32 theMinNoOfEventsToWakeUp; + + Uint32 theNextConnectNode; + + NdbWaiter theWaiter; + + // Ndb database name. + char theDataBase[NDB_MAX_DATABASE_NAME_SIZE]; + // Ndb database schema name. + char theDataBaseSchema[NDB_MAX_SCHEMA_NAME_SIZE]; + char prefixName[NDB_MAX_INTERNAL_TABLE_LENGTH]; + char * prefixEnd; + + //Table* theTable; // The table object + class NdbImpl * theImpl; + class NdbDictionaryImpl* theDictionary; + class NdbGlobalEventBufferHandle* theGlobalEventBufferHandle; + + NdbConnection* theConIdleList; // First connection in idle list. + + NdbOperation* theOpIdleList; // First operation in the idle list. + + NdbScanOperation* theScanOpIdleList; // First scan operation in the idle list. + NdbIndexOperation* theIndexOpIdleList; // First index operation in the idle list. + NdbSchemaCon* theSchemaConIdleList; // First schemaCon in idle list. + + NdbSchemaCon* theSchemaConToNdbList; // Connected schemaCon object. + NdbConnection* theTransactionList; + NdbConnection** theConnectionArray; + NdbRecAttr* theRecAttrIdleList; + NdbApiSignal* theSignalIdleList; // First signal in idlelist. + NdbLabel* theLabelList; // First label descriptor in list + NdbBranch* theBranchList; // First branch descriptor in list + NdbSubroutine* theSubroutineList; // First subroutine descriptor in + NdbCall* theCallList; // First call descriptor in list + NdbScanReceiver* theScanList; + + Uint32 theMyRef; // My block reference + Uint32 theNode; // The node number of our node + + Uint32 theNoOfDBnodes; // The number of DB nodes + Uint32 * theDBnodes; // The node number of the DB nodes + Uint8 *the_release_ind;// 1 indicates to release all connections to node + + Uint64 the_last_check_time; + Uint64 theFirstTransId; + + // The tupleId is retreived from DB the + // tupleId is unique for each tableid. + Uint64 theFirstTupleId[2048]; + Uint64 theLastTupleId[2048]; + + Uint32 theRestartGCI; // the Restart GCI used by DIHNDBTAMPER + + NdbError theError; + + Int32 theNdbBlockNumber; + InitType theInitState; + + // Ensure good distribution of connects + Uint32 theCurrentConnectIndex; + Uint32 theCurrentConnectCounter; + + /** + * Computes fragement id for primary key + * + * Note that keydata has to be "shaped" as it is being sent in KEYINFO + */ + Uint32 computeFragmentId(const char * keyData, Uint32 keyLen); + Uint32 getFragmentId(Uint32 hashValue); + + /** + * Make a guess to which node is the primary for the fragment + */ + Uint32 guessPrimaryNode(Uint32 fragmentId); + + /** + * Structure containing values for guessing primary node + */ + struct StartTransactionNodeSelectionData { + StartTransactionNodeSelectionData(): + fragment2PrimaryNodeMap(NULL) {}; + Uint32 kValue; + Uint32 hashValueMask; + Uint32 hashpointerValue; + Uint32 noOfFragments; + Uint32 * fragment2PrimaryNodeMap; + + void init(Uint32 noOfNodes, Uint32 nodeIds[]); + void release(); + } startTransactionNodeSelectionData; + + NdbApiSignal* theCommitAckSignal; + + int cfreeSignals; + int cnewSignals; + int cgetSignals; + int creleaseSignals; + + static void executeMessage(void*, NdbApiSignal *, + struct LinearSectionPtr ptr[3]); + static void statusMessage(void*, Uint16, bool, bool); +#ifdef VM_TRACE + void printState(const char* fmt, ...); +#endif +}; + +#endif diff --git a/ndb/include/ndbapi/NdbApi.hpp b/ndb/include/ndbapi/NdbApi.hpp new file mode 100644 index 00000000000..e5efc9756ce --- /dev/null +++ b/ndb/include/ndbapi/NdbApi.hpp @@ -0,0 +1,33 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NdbApi_H +#define NdbApi_H + +#include "Ndb.hpp" +#include "AttrType.hpp" +#include "NdbConnection.hpp" +#include "NdbOperation.hpp" +#include "NdbScanOperation.hpp" +#include "NdbIndexOperation.hpp" +#include "NdbSchemaCon.hpp" +#include "NdbSchemaOp.hpp" +#include "NdbRecAttr.hpp" +#include "NdbResultSet.hpp" +#include "NdbDictionary.hpp" +#include "NdbEventOperation.hpp" +#include "NdbPool.hpp" +#endif diff --git a/ndb/include/ndbapi/NdbConnection.hpp b/ndb/include/ndbapi/NdbConnection.hpp new file mode 100644 index 00000000000..a1532bb2f0e --- /dev/null +++ b/ndb/include/ndbapi/NdbConnection.hpp @@ -0,0 +1,885 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NdbConnection_H +#define NdbConnection_H + +#include +#include "AttrType.hpp" +#include +#include + +class NdbConnection; +class NdbOperation; +class NdbCursorOperation; +class NdbScanOperation; +class NdbIndexOperation; +class NdbApiSignal; +class Ndb; +class NdbScanReceiver; + + +/** + * NdbAsynchCallback functions are used when executing asynchronous + * transactions (using NdbConnection::executeAsynchPrepare, or + * NdbConnection::executeAsynch). + * The functions are called when the execute has finished. + * See @ref secAsync for more information. + */ +typedef void (* NdbAsynchCallback)(int, NdbConnection*, void*); + +/** + * @class NdbConnection + * @brief Represents a transaction. + * + * A transaction (represented by an NdbConnection object) + * belongs to an Ndb object and is typically created using + * Ndb::startTransaction. + * A transaction consists of a list of operations + * (represented by NdbOperation objects). + * Each operation access exactly one table. + * + * After getting the NdbConnection object, + * the first step is to get (allocate) an operation given the table name. + * Then the operation is defined. + * Several operations can be defined in parallel on the same + * NdbConnection object. + * When all operations are defined, the NdbConnection::execute + * method sends them to the NDB kernel for execution. + * + * The NdbConnection::execute method returns when the NDB kernel has + * completed execution of all operations defined before the call to + * NdbConnection::execute. + * All allocated operations should be properly defined + * before calling NdbConnection::execute. + * + * A call to NdbConnection::execute uses one out of three types of execution: + * -# ExecType::NoCommit Executes operations without committing them. + * -# ExecType::Commit Executes remaining operation and commits the + * complete transaction + * -# ExecType::Rollback Rollbacks the entire transaction. + * + * NdbConnection::execute is equipped with an extra error handling parameter + * There are two alternatives: + * -# AbortOption::AbortOnError (default). + * The transaction is aborted if there are any error during the + * execution + * -# AbortOption::IgnoreError + * Continue execution of transaction even if operation fails + * + * NdbConnection::execute can sometimes indicate an error + * (return with -1) while the error code on the NdbConnection is 0. + * This is an indication that one of the operations found a record + * problem. The transaction is still ok and can continue as usual. + * The NdbConnection::execute returns -1 together with error code + * on NdbConnection object equal to 0 always means that an + * operation was not successful but that the total transaction was OK. + * By checking error codes on the individual operations it is possible + * to find out which operation was not successful. + * + * NdbConnection::executeScan is used to setup a scan in the NDB kernel + * after it has been defined. + * NdbConnection::nextScanResult is used to iterate through the + * scanned tuples. + * After each call to NdbConnection::nextScanResult, the pointers + * of NdbRecAttr objects defined in the NdbOperation::getValue + * operations are updated with the values of the new the scanned tuple. + */ + +/* FUTURE IMPLEMENTATION: + * Later a prepare mode will be added when Ndb supports Prepare-To-Commit + * The NdbConnection can deliver the Transaction Id of the transaction. + * After committing a transaction it is also possible to retrieve the + * global transaction checkpoint which the transaction was put in. + * + * FUTURE IMPLEMENTATION: + * There are three methods for acquiring the NdbOperation. + * -# The first method is the normal where a table name is + * provided. In this case the primary key must be supplied through + * the use of the NdbOperation::equal methods on the NdbOperation object. + * -# The second method provides the tuple identity of the tuple to be + * read. The tuple identity contains a table identifier and will + * thus be possible to use to ensure the attribute names provided + * are correct. If an object-oriented layer is put on top of NDB + * Cluster it is essential that all tables derived from a base + * class has the same attributes with the same type and the same + * name. Thus the application can use the tuple identity and need + * not known the table of the tuple. As long as the table is + * derived from the known base class everything is ok. + * It is not possible to provide any primary key since it is + * already supplied with the call to NdbConnection::getNdbOperation. + * -# The third method is used when a scanned tuple is to be transferred to + * another transaction. In this case it is not possible to define the + * primary key since it came along from the scanned tuple. + * + */ +class NdbConnection +{ + friend class Ndb; + friend class NdbOperation; + friend class NdbScanOperation; + friend class NdbIndexOperation; + friend class NdbScanReceiver; + +public: + + /** + * Get an NdbOperation for a table. + * Note that the operation has to be defined before it is executed. + * + * @note All operations within the same transaction need to + * be initialized with this method. + * + * @param aTableName The table name. + * @return Pointer to an NdbOperation object if successful, otherwise NULL. + */ + NdbOperation* getNdbOperation(const char* aTableName); + + /** + * Get an NdbOperation for index scan of a table. + * Note that the operation has to be defined before it is executed. + * + * @note All operations within the same transaction need to + * be initialized with this method. + * + * @param anIndexName The index name. + * @param aTableName The table name. + * @return Pointer to an NdbOperation object if successful, otherwise NULL. + */ + NdbOperation* getNdbOperation(const char* anIndexName, + const char* aTableName); + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL + /** + * Get an operation from NdbScanOperation idlelist and + * get the NdbConnection object which + * was fetched by startTransaction pointing to this operation. + * This operation will set the theTableId + * in the NdbOperation object.synchronous. + * + * @param aTableName a table name. + * @return pointer to an NdbOperation object if successful, otherwise NULL + */ + NdbScanOperation* getNdbScanOperation(const char* aTableName); +#endif + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL + /** + * Get an operation from NdbScanOperation idlelist and + * get the NdbConnection object which + * was fetched by startTransaction pointing to this operation. + * This operation will set the theTableId + * in the NdbOperation object.synchronous. + * + * @param anIndexName The index name. + * @param aTableName a table name. + * @return pointer to an NdbOperation object if successful, otherwise NULL + */ + NdbScanOperation* getNdbScanOperation(const char* anIndexName, + const char* aTableName); +#endif + + + /** + * Get an operation from NdbIndexOperation idlelist and + * get the NdbConnection object that + * was fetched by startTransaction pointing to this operation. + * This operation will set the theTableId + * in the NdbOperation object. Synchronous. + * + * @param indexName An index name (as created by createIndex). + * @param tableName A table name. + * @return Pointer to an NdbIndexOperation object if + * successful, otherwise NULL + */ + NdbIndexOperation* getNdbIndexOperation(const char* indexName, + const char* tableName); + + /** + * @name Execute Transaction + * @{ + */ + + /** + * Executes transaction. + * + * @param execType Execution type:
+ * ExecType::NoCommit executes operations without + * committing them.
+ * ExecType::Commit executes remaining operations and + * commits the complete transaction.
+ * ExecType::Rollback rollbacks the entire transaction. + * @param abortOption Handling of error while excuting + * AbortOnError - Abort transaction if an operation fail + * IgnoreError - Accept failing operations + * @param force When operations should be sent to NDB Kernel. + * (See @ref secAdapt.) + * - 0: non-force, adaptive algorithm notices it + * (default); + * - 1: force send, adaptive algorithm notices it; + * - 2: non-force, adaptive algorithm do not notice + * the send. + * @return 0 if successful otherwise -1. + */ + int execute(ExecType execType, + AbortOption abortOption = AbortOnError, + int force = 0 ); + + /** + * Prepare an asynchronous transaction. + * + * See @ref secAsync for more information on + * how to use this method. + * + * @param execType Execution type:
+ * ExecType::NoCommit executes operations without committing them.
+ * ExecType::Commit executes remaining operations and commits the + * complete transaction.
+ * ExecType::Rollback rollbacks the entire transaction. + * @param callback A callback method. This method gets + * called when the transaction has been + * executed. See @ref ndbapi_example2.cpp + * for an example on how to specify and use + * a callback method. + * @param anyObject A void pointer. This pointer is forwarded to the + * callback method and can be used to give + * the callback method some data to work on. + * It is up to the application programmer + * to decide on the use of this pointer. + * @param abortOption see @ref execute + */ + void executeAsynchPrepare(ExecType execType, + NdbAsynchCallback callback, + void* anyObject, + AbortOption abortOption = AbortOnError); + + /** + * Prepare and send an asynchronous transaction. + * + * This method perform the same action as + * NdbConnection::executeAsynchPrepare + * but also sends the operations to the NDB kernel. + * + * See NdbConnection::executeAsynchPrepare for information + * about the parameters of this method. + * + * See @ref secAsync for more information on + * how to use this method. + */ + void executeAsynch(ExecType aTypeOfExec, + NdbAsynchCallback aCallback, + void* anyObject, + AbortOption abortOption = AbortOnError); + + /** + * Refresh + * Update timeout counter of this transaction + * in the database. If you want to keep the transaction + * active in the database longer than the + * transaction abort timeout. + * @note It's not advised to take a lock on a record and keep it + * for a extended time since this can impact other transactions. + * + */ + int refresh(); + + /** + * Close transaction + * @note It is not allowed to call NdbConnection::close after sending the + * transaction asynchronously before the callback method has + * been called. + * (The application should keep track of the number of + * outstanding transactions and wait until all of them + * has completed before calling NdbConnection::close). + * If the transaction is not committed it will be aborted. + */ + void close(); + + /** @} *********************************************************************/ + + /** + * @name Scan Transactions + * @{ + */ + + /** + * Execute a scan transaction. This will define + * and start the scan transaction in the NDB kernel. + * + * @return 0 if successful otherwise -1. + */ + int executeScan(); + + /** + * Get the next tuple in a scan transaction. + * + * After each call to NdbConnection::nextScanResult + * the buffers and NdbRecAttr objects defined in + * NdbOperation::getValue are updated with values + * from the scanned tuple. + * + * @param fetchAllowed If set to false, then fetching is disabled + * + * The NDB API will contact the NDB Kernel for more tuples + * when necessary to do so unless you set the fetchAllowed + * to false. + * This will force NDB to process any records it + * already has in it's caches. When there are no more cached + * records it will return 2. You must then call nextScanResult + * with fetchAllowed = true in order to contact NDB for more + * records. + * + * fetchAllowed = false is useful when you want to update or + * delete all the records fetched in one transaction(This will save a + * lot of round trip time and make updates or deletes of scanned + * records a lot faster). + * While nextScanResult(false) + * returns 0 take over the record to another transaction. When + * nextScanResult(false) returns 2 you must execute and commit the other + * transaction. This will cause the locks to be transferred to the + * other transaction, updates or deletes will be made and then the + * locks will be released. + * After that, call nextScanResult(true) which will fetch new records and + * cache them in the NdbApi. + * + * @note If you don't take over the records to another transaction the + * locks on those records will be released the next time NDB Kernel + * is contacted for more records. + * + * @note Please contact for examples of efficient scan + * updates and deletes. + * + * @return + * - -1: if unsuccessful,
+ * - 0: if another tuple was received, and
+ * - 1: if there are no more tuples to scan. + * - 2: if there are no more cached records in NdbApi + */ + int nextScanResult(bool fetchAllowed = true); + + /** + * Stops the scan. Used if no more tuples are wanted. + * The transaction should still be closed with + * Ndb::closeTransaction. + * + * @return 0 if successful otherwise -1. + */ + int stopScan(); + + /** + * @name Meta Information + * @{ + */ + + /** + * Get global checkpoint identity (GCI) of transaction. + * + * Each committed transaction belong to a GCI. + * The log for the committed transaction is saved on + * disk when a global checkpoint occurs. + * + * Whether or not the global checkpoint with this GCI has been + * saved on disk or not cannot be determined by this method. + * + * By comparing the GCI of a transaction with the value + * last GCI restored in a restarted NDB Cluster one can determine + * whether the transaction was restored or not. + * + * @note Global Checkpoint Identity is undefined for scan transactions + * (This is because no updates are performed in scan transactions.) + * + * @return GCI of transaction or -1 if GCI is not available. + * (Note that there has to be an NdbConnection::execute call + * with Ndb::Commit for the GCI to be available.) + */ + int getGCI(); + + /** + * Get transaction identity. + * + * @return Transaction id. + */ + Uint64 getTransactionId(); + + /** + * Returns the commit status of the transaction. + * + * @return The commit status of the transaction, i.e. one of + * { NotStarted, Started, TimeOut, Committed, Aborted, NeedAbort } + */ + CommitStatusType commitStatus(); + + /** @} *********************************************************************/ + + /** + * @name Error Handling + * @{ + */ + + /** + * Get error object with information about the latest error. + * + * @return An error object with information about the latest error. + */ + const NdbError & getNdbError() const; + + /** + * Get the latest NdbOperation which had an error. + * This method is used on the NdbConnection object to find the + * NdbOperation causing an error. + * To find more information about the + * actual error, use method NdbOperation::getNdbError + * on the returned NdbOperation object. + * + * @return The NdbOperation causing the latest error. + */ + NdbOperation* getNdbErrorOperation(); + + /** + * Get the method number where the latest error occured. + * + * @return Line number where latest error occured. + */ + int getNdbErrorLine(); + + /** + * Get completed (i.e. executed) operations of a transaction + * + * This method should only be used after a transaction + * has been executed. + * - NdbConnection::getNextCompletedOperation(NULL) returns the + * first NdbOperation object. + * - NdbConnection::getNextCompletedOperation(op) returns the + * NdbOperation object defined after the NdbOperation "op". + * + * This method is typically used to fetch all NdbOperation:s of + * a transaction to check for errors (use NdbOperation::getNdbError + * to fetch the NdbError object of an NdbOperation). + * + * @note This method should only be used after the transaction has been + * executed and before the transaction has been closed. + * + * @param op Operation, NULL means get first operation + * @return Operation "after" op + */ + const NdbOperation * getNextCompletedOperation(const NdbOperation * op)const; + + /** + * Release completed operations + */ + void releaseCompletedOperations(); + + + /** @} *********************************************************************/ + +private: + + typedef Uint64 TimeMillis_t; + /************************************************************************** + * These methods are service methods to other classes in the NDBAPI. * + **************************************************************************/ + + /************************************************************************** + * These are the create and delete methods of this class. * + **************************************************************************/ + + NdbConnection(Ndb* aNdb); + + ~NdbConnection(); + + void init(); // Initialize connection object for new transaction + + /** + * Set Connected node id + * and sequence no + */ + void setConnectedNodeId( Uint32 nodeId, Uint32 sequence); + + Uint32 getConnectedNodeId(); // Get Connected node id + void setMyBlockReference( int ); // Set my block refrerence + void setTC_ConnectPtr( Uint32 ); // Sets TC Connect pointer + int getTC_ConnectPtr(); // Gets TC Connect pointer + void setBuddyConPtr(Uint32); // Sets Buddy Con Ptr + Uint32 getBuddyConPtr(); // Gets Buddy Con Ptr + NdbConnection* next(); // Returns the next pointer + void next(NdbConnection*); // Sets the next pointer + ConStatusType Status(); // Read the status information + void Status(ConStatusType); // Set the status information + Uint32 get_send_size(); // Get size to send + void set_send_size(Uint32); // Set size to send; + + int receiveDIHNDBTAMPER(NdbApiSignal* anApiSignal); + int receiveTCSEIZECONF(NdbApiSignal* anApiSignal); + int receiveTCSEIZEREF(NdbApiSignal* anApiSignal); + int receiveTCRELEASECONF(NdbApiSignal* anApiSignal); + int receiveTCRELEASEREF(NdbApiSignal* anApiSignal); + int receiveTC_COMMITCONF(const class TcCommitConf *); + int receiveTCKEYCONF(const class TcKeyConf *, Uint32 aDataLength); + int receiveTCKEY_FAILCONF(const class TcKeyFailConf *); + int receiveTCKEY_FAILREF(NdbApiSignal* anApiSignal); + int receiveTC_COMMITREF(NdbApiSignal* anApiSignal); + int receiveTCROLLBACKCONF(NdbApiSignal* anApiSignal); // Rec TCPREPARECONF ? + int receiveTCROLLBACKREF(NdbApiSignal* anApiSignal); // Rec TCPREPAREREF ? + int receiveTCROLLBACKREP(NdbApiSignal* anApiSignal); + int receiveTCINDXCONF(const class TcIndxConf *, Uint32 aDataLength); + int receiveTCINDXREF(NdbApiSignal*); + int receiveSCAN_TABREF(NdbApiSignal*); + int receiveSCAN_TABCONF(NdbApiSignal*); + int receiveSCAN_TABINFO(NdbApiSignal*); + + int checkNextScanResultComplete(); + int sendScanStart(); + int sendScanNext(bool stopScanFlag); + int fetchNextScanResult(); + + int doSend(); // Send all operations + int sendROLLBACK(); // Send of an ROLLBACK + int sendTC_HBREP(); // Send a TCHBREP signal; + int sendCOMMIT(); // Send a TC_COMMITREQ signal; + void setGCI(int GCI); // Set the global checkpoint identity + + int OpCompleteFailure(); // Operation Completed with success + int OpCompleteSuccess(); // Operation Completed with success + + void CompletedOperations(); // Move active ops to list of completed + + void OpSent(); // Operation Sent with success + + // Free connection related resources and close transaction + void release(); + + // Release all operations in connection + void releaseOperations(); + + // Release all cursor operations in connection + void releaseOps(NdbOperation*); + void releaseCursorOperations(NdbCursorOperation*); + + // Set the transaction identity of the transaction + void setTransactionId(Uint64 aTransactionId); + + // Indicate something went wrong in the definition phase + void setErrorCode(int anErrorCode); + + // Indicate something went wrong in the definition phase + void setOperationErrorCode(int anErrorCode); + + // Indicate something went wrong in the definition phase + void setOperationErrorCodeAbort(int anErrorCode); + + int checkMagicNumber(); // Verify correct object + NdbOperation* getNdbOperation(class NdbTableImpl* aTable); + NdbScanOperation* getNdbScanOperation(class NdbTableImpl* aTable); + NdbIndexOperation* getNdbIndexOperation(class NdbIndexImpl* anIndex, + class NdbTableImpl* aTable); + + void handleExecuteCompletion(); + + /**************************************************************************** + * These are the private variables of this class. + ****************************************************************************/ + + Uint32 ptr2int(); + Uint32 theId; + + // Keeps track of what the send method should do. + SendStatusType theSendStatus; + NdbAsynchCallback theCallbackFunction; // Pointer to the callback function + void* theCallbackObject; // The callback object pointer + Uint32 theTransArrayIndex; // Current index in a transaction + // array for this object + TimeMillis_t theStartTransTime; // Start time of the transaction + + NdbError theError; // Errorcode on transaction + int theErrorLine; // Method number of last error in NdbOperation + NdbOperation* theErrorOperation; // The NdbOperation where the error occurred + + Ndb* theNdb; // Pointer to Ndb object + NdbConnection* theNext; // Next pointer. Used in idle list. + + NdbOperation* theFirstOpInList; // First operation in defining list. + NdbOperation* theLastOpInList; // Last operation in defining list. + + NdbOperation* theFirstExecOpInList; // First executing operation in list + NdbOperation* theLastExecOpInList; // Last executing operation in list. + + + NdbOperation* theCompletedFirstOp; // First operation in completed + // operation list. + + Uint32 theNoOfOpSent; // How many operations have been sent + Uint32 theNoOfOpCompleted; // How many operations have completed + Uint32 theNoOfOpFetched; // How many operations was actually fetched + Uint32 theNoOfSCANTABCONFRecv; // How many SCAN_TABCONF have been received + Uint32 theMyRef; // Our block reference + Uint32 theTCConPtr; // Transaction Co-ordinator connection pointer. + Uint64 theTransactionId; // theTransactionId of the transaction + Uint32 theGlobalCheckpointId; // The gloabl checkpoint identity of the transaction + ConStatusType theStatus; // The status of the connection + + CompletionStatus theCompletionStatus; // The Completion status of the transaction + CommitStatusType theCommitStatus; // The commit status of the transaction + Uint32 theMagicNumber; // Magic Number to verify correct object + + Uint32 thePriority; // Transaction Priority + ReturnType theReturnStatus; // Did we have any read/update/delete failing + // to find the tuple. + bool theTransactionIsStarted; + bool theInUseState; + bool theSimpleState; + Uint8 m_abortOption; // Type of commit + + ListState theListState; + + Uint32 theDBnode; // The database node we are connected to + Uint32 theNodeSequence; // The sequence no of the db node + bool theReleaseOnClose; + + // Cursor operations + bool m_waitForReply; + NdbCursorOperation* m_theFirstCursorOperation; + NdbCursorOperation* m_theLastCursorOperation; + + NdbCursorOperation* m_firstExecutedCursorOp; + // Scan operations + bool theScanFinished; + + NdbScanReceiver* theCurrentScanRec; // The current operation to + // distribute to the app. + NdbScanReceiver* thePreviousScanRec; // The previous operation read by + // nextScanResult. + NdbOperation* theScanningOp; // The operation actually performing the scan + Uint32 theBuddyConPtr; + + static void sendTC_COMMIT_ACK(NdbApiSignal *, + Uint32 transId1, Uint32 transId2, + Uint32 aBlockRef); + + void completedFail(const char * s); +#ifdef VM_TRACE + void printState(); +#endif +}; + +inline +Uint32 +NdbConnection::get_send_size() +{ + return 0; +} + +inline +void +NdbConnection::set_send_size(Uint32 send_size) +{ + return; +} + +inline +int +NdbConnection::checkMagicNumber() +{ + if (theMagicNumber == 0x37412619) + return 0; + else { +#ifdef NDB_NO_DROPPED_SIGNAL + abort(); +#endif + return -1; + } +} + +/************************************************************************************************ +void setTransactionId(Uint64 aTransactionId); + +Remark: Set the transaction identity. +************************************************************************************************/ +inline +void +NdbConnection::setTransactionId(Uint64 aTransactionId) +{ + theTransactionId = aTransactionId; +} + +inline +void +NdbConnection::setConnectedNodeId(Uint32 aNode, Uint32 aSequenceNo) +{ + theDBnode = aNode; + theNodeSequence = aSequenceNo; +} +/****************************************************************************** +int getConnectedNodeId(); + +Return Value: Return theDBnode. +Remark: Get Connected node id. +******************************************************************************/ +inline +Uint32 +NdbConnection::getConnectedNodeId() +{ + return theDBnode; +} +/****************************************************************************** +void setMyBlockReference(int aBlockRef); + +Parameters: aBlockRef: The block refrerence. +Remark: Set my block refrerence. +******************************************************************************/ +inline +void +NdbConnection::setMyBlockReference(int aBlockRef) +{ + theMyRef = aBlockRef; +} +/****************************************************************************** +void setTC_ConnectPtr(Uint32 aTCConPtr); + +Parameters: aTCConPtr: The connection pointer. +Remark: Sets TC Connect pointer. +******************************************************************************/ +inline +void +NdbConnection::setTC_ConnectPtr(Uint32 aTCConPtr) +{ + theTCConPtr = aTCConPtr; +} + +/****************************************************************************** +int getTC_ConnectPtr(); + +Return Value: Return theTCConPtr. +Remark: Gets TC Connect pointer. +******************************************************************************/ +inline +int +NdbConnection::getTC_ConnectPtr() +{ + return theTCConPtr; +} + +inline +void +NdbConnection::setBuddyConPtr(Uint32 aBuddyConPtr) +{ + theBuddyConPtr = aBuddyConPtr; +} + +inline +Uint32 NdbConnection::getBuddyConPtr() +{ + return theBuddyConPtr; +} + +/****************************************************************************** +NdbConnection* next(); + +inline +void +NdbConnection::setBuddyConPtr(Uint32 aBuddyConPtr) +{ + theBuddyConPtr = aBuddyConPtr; +} + +inline +Uint32 NdbConnection::getBuddyConPtr() +{ + return theBuddyConPtr; +} + +Return Value: Return next pointer to NdbConnection object. +Remark: Get the next pointer. +******************************************************************************/ +inline +NdbConnection* +NdbConnection::next() +{ + return theNext; +} + +/****************************************************************************** +void next(NdbConnection aConnection); + +Parameters: aConnection: The connection object. +Remark: Sets the next pointer. +******************************************************************************/ +inline +void +NdbConnection::next(NdbConnection* aConnection) +{ + theNext = aConnection; +} + +/****************************************************************************** +ConStatusType Status(); + +Return Value Return the ConStatusType. +Parameters: aStatus: The status. +Remark: Sets Connect status. +******************************************************************************/ +inline +ConStatusType +NdbConnection::Status() +{ + return theStatus; +} + +/****************************************************************************** +void Status(ConStatusType aStatus); + +Parameters: aStatus: The status. +Remark: Sets Connect status. +******************************************************************************/ +inline +void +NdbConnection::Status( ConStatusType aStatus ) +{ + theStatus = aStatus; +} + +/****************************************************************************** + void setGCI(); + +Remark: Set global checkpoint identity of the transaction +******************************************************************************/ +inline +void +NdbConnection::setGCI(int aGlobalCheckpointId) +{ + theGlobalCheckpointId = aGlobalCheckpointId; +} + +/****************************************************************************** +void OpSent(); + +Remark: An operation was sent with success that expects a response. +******************************************************************************/ +inline +void +NdbConnection::OpSent() +{ + theNoOfOpSent++; +} + +inline +Uint32 +NdbConnection::ptr2int(){ + return theId; +} + +#endif + + diff --git a/ndb/include/ndbapi/NdbCursorOperation.hpp b/ndb/include/ndbapi/NdbCursorOperation.hpp new file mode 100644 index 00000000000..cd76b045ea2 --- /dev/null +++ b/ndb/include/ndbapi/NdbCursorOperation.hpp @@ -0,0 +1,93 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NdbCursorOperation_H +#define NdbCursorOperation_H + +#include + +class NdbResultSet; + +/** + * @class NdbCursorOperation + * @brief Operation using cursors + */ +class NdbCursorOperation : public NdbOperation +{ + friend class NdbResultSet; + friend class NdbConnection; + +public: + /** + * Type of cursor + */ + enum CursorType { + NoCursor = 0, + ScanCursor = 1, + IndexCursor = 2 + }; + + /** + * Lock when performing scan + */ + enum LockMode { + LM_Read = 0, + LM_Exclusive = 1, + LM_CommittedRead = 2, +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL + LM_Dirty = 2 +#endif + }; + + virtual CursorType cursorType() = 0; + + /** + * readTuples returns a NdbResultSet where tuples are stored. + * Tuples are not stored in NdbResultSet until execute(NoCommit) + * has been executed and nextResult has been called. + * + * @param parallel Scan parallelism + * @param LockMode Scan lock handling + * @returns NdbResultSet. + */ + virtual NdbResultSet* readTuples(unsigned parallel = 0, + LockMode = LM_Read ) = 0; + + inline NdbResultSet* readTuplesExclusive(int parallell = 0){ + return readTuples(parallell, LM_Exclusive); + } + +protected: + NdbCursorOperation(Ndb* aNdb); + + ~NdbCursorOperation(); + + void cursInit(); + + virtual int executeCursor(int ProcessorId) = 0; + + NdbResultSet* getResultSet(); + NdbResultSet* m_resultSet; + +private: + + virtual int nextResult(bool fetchAllowed) = 0; + + virtual void closeScan() = 0; +}; + + +#endif diff --git a/ndb/include/ndbapi/NdbDictionary.hpp b/ndb/include/ndbapi/NdbDictionary.hpp new file mode 100644 index 00000000000..a8a3bc86786 --- /dev/null +++ b/ndb/include/ndbapi/NdbDictionary.hpp @@ -0,0 +1,1033 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/***************************************************************************** + * Name: NdbDictionary.hpp + * Include: + * Link: + * Author: Jonas Oreland + * Date: 2003-05-14 + * Version: 0.1 + * Description: Data dictionary support + * Documentation: + * Adjust: 2003-05-14 Jonas Oreland First version. + ****************************************************************************/ + +#ifndef NdbDictionary_H +#define NdbDictionary_H + +#include + +class Ndb; + +/** + * @class NdbDictionary + * @brief Data dictionary class + * + * This class supports all schema data definition and enquiry such as: + * -# Creating tables (Dictionary::createTable) and table columns + * -# Dropping tables (Dictionary::dropTable) + * -# Creating secondary indexes (Dictionary::createIndex) + * -# Dropping secondary indexes (Dictionary::dropIndex) + * -# Enquiries about tables + * (Dictionary::getTable, Table::getNoOfColumns, + * Table::getPrimaryKey, and Table::getNoOfPrimaryKeys) + * -# Enquiries about indexes + * (Dictionary::getIndex, Index::getNoOfColumns, + * and Index::getColumn) + * + * NdbDictionary has several help (inner) classes: + * -# NdbDictionary::Table for creating tables + * -# NdbDictionary::Column for creating table columns + * -# NdbDictionary::Index for creating secondary indexes + * + * See @ref ndbapi_example4.cpp for details of usage. + */ +class NdbDictionary { +public: + /** + * @class Object + * @brief Meta information about a database object (a table, index, etc) + */ + class Object { + public: + /** + * Status of object + */ + enum Status { + New, ///< The object only exist in memory and + ///< has not been created in the NDB Kernel + Changed, ///< The object has been modified in memory + ///< and has to be commited in NDB Kernel for + ///< changes to take effect + Retrieved ///< The object exist and has been read + ///< into main memory from NDB Kernel + }; + + /** + * Get status of object + */ + virtual Status getObjectStatus() const = 0; + + /** + * Get version of object + */ + virtual int getObjectVersion() const = 0; + + /** + * Object type + */ + enum Type { + TypeUndefined = 0, ///< Undefined + SystemTable = 1, ///< System table + UserTable = 2, ///< User table (may be temporary) + UniqueHashIndex = 3, ///< Unique un-ordered hash index + HashIndex = 4, ///< Non-unique un-ordered hash index + UniqueOrderedIndex = 5, ///< Unique ordered index + OrderedIndex = 6, ///< Non-unique ordered index + HashIndexTrigger = 7, ///< Index maintenance, internal + IndexTrigger = 8, ///< Index maintenance, internal + SubscriptionTrigger = 9,///< Backup or replication, internal + ReadOnlyConstraint = 10 ///< Trigger, internal + }; + + /** + * Object state + */ + enum State { + StateUndefined = 0, ///< Undefined + StateOffline = 1, ///< Offline, not usable + StateBuilding = 2, ///< Building, not yet usable + StateDropping = 3, ///< Offlining or dropping, not usable + StateOnline = 4, ///< Online, usable + StateBroken = 9 ///< Broken, should be dropped and re-created + }; + + /** + * Object store + */ + enum Store { + StoreUndefined = 0, ///< Undefined + StoreTemporary = 1, ///< Object or data deleted on system restart + StorePermanent = 2 ///< Permanent. logged to disk + }; + + /** + * Type of fragmentation. + * + * This parameter specifies how data in the table or index will + * be distributed among the db nodes in the cluster.
+ * The bigger the table the more number of fragments should be used. + * Note that all replicas count as same "fragment".
+ * For a table, default is FragAllMedium. For a unique hash index, + * default is taken from underlying table and cannot currently + * be changed. + */ + enum FragmentType { + FragUndefined = 0, ///< Fragmentation type undefined or default + FragSingle = 1, ///< Only one fragment + FragAllSmall = 2, ///< One fragment per node group + FragAllMedium = 3, ///< Default value. Two fragments per node group. + FragAllLarge = 4 ///< Eight fragments per node group. + }; + }; + + /** + * @class Column + * @brief Represents an column in an NDB Cluster table + * + * Each column has a type. The type of a column is determind by a number + * of type specifiers. + * The type specifiers are: + * - Builtin type + * - Array length or max length + * - Precision and scale + */ + class Column { + public: + /** + * The builtin column types + */ + enum Type { + Undefined=0,///< Undefined + Tinyint, ///< 8 bit. 1 byte signed integer, can be used in array + Tinyunsigned, ///< 8 bit. 1 byte unsigned integer, can be used in array + Smallint, ///< 16 bit. 2 byte signed integer, can be used in array + Smallunsigned, ///< 16 bit. 2 byte unsigned integer, can be used in array + Mediumint, ///< 24 bit. 3 byte signed integer, can be used in array + Mediumunsigned,///< 24 bit. 3 byte unsigned integer, can be used in array + Int, ///< 32 bit. 4 byte signed integer, can be used in array + Unsigned, ///< 32 bit. 4 byte unsigned integer, can be used in array + Bigint, ///< 64 bit. 8 byte signed integer, can be used in array + Bigunsigned, ///< 64 Bit. 8 byte signed integer, can be used in array + Float, ///< 32-bit float. 4 bytes float, can be used in array + Double, ///< 64-bit float. 8 byte float, can be used in array + Decimal, ///< Precision, Scale are applicable + Char, ///< Len. A fixed array of 1-byte chars + Varchar, ///< Max len + Binary, ///< Len + Varbinary, ///< Max len + Datetime, ///< Precision down to 1 sec (sizeof(Datetime) == 8 bytes ) + Timespec, ///< Precision down to 1 nsec(sizeof(Datetime) == 12 bytes ) + Blob ///< Binary large object (see NdbBlob) + }; + + /** + * @name General + * @{ + */ + /** + * Constructor + * @param name Name of column + */ + Column(const char * name = ""); + /** + * Copy constructor + * @param column Column to be copied + */ + Column(const Column& column); + ~Column(); + + /** + * Set name of column + * @param name Name of the column + */ + void setName(const char * name); + + /** + * Get name of column + * @return Name of the column + */ + const char* getName() const; + + /** + * Set whether column is nullable or not + */ + void setNullable(bool); + + /** + * Get if the column is nullable or not + */ + bool getNullable() const; + + /** + * Set that column is part of primary key + */ + void setPrimaryKey(bool); + + /** + * Check if column is part of primary key + */ + bool getPrimaryKey() const; + + /** + * Get number of column (horizontal position within table) + */ + int getColumnNo() const; + + /** + * Check if column is equal to some other column + * @param column Column to compare with + * @return true if column is equal to some other column otherwise false. + */ + bool equal(const Column& column) const; + + /** @} *******************************************************************/ + /** + * @name Type Specifiers + * @{ + */ + + /** + * Set type of column + * @param type Type of column + */ + void setType(Type type); + + /** + * Get type of column + */ + Type getType() const; + + /** + * Set precision of column. + * @note Only applicable for builtin type Decimal + */ + void setPrecision(int); + + /** + * Get precision of column. + * @note Only applicable for builtin type Decimal + */ + int getPrecision() const; + + /** + * Set scale of column. + * @note Only applicable for builtin type Decimal + */ + void setScale(int); + + /** + * Get scale of column. + * @note Only applicable for builtin type Decimal + */ + int getScale() const; + + /** + * Set length for column + * Array length for column or max length for variable length arrays. + */ + void setLength(int length); + + /** + * Get length for column + * Array length for column or max length for variable length arrays. + */ + int getLength() const; + + /** + * Set distribution key + * + * A distribution key is a set of attributes which are used + * to distribute the tuples onto the NDB nodes. + * The distribution key uses the NDB Cluster hashing function. + * + * An example where this is useful is TPC-C where it might be + * good to use the warehouse id and district id as the distribution key. + * This would place all data for a specific district and warehouse + * in the same database node. + * + * Locally in the fragments the full primary key + * will still be used with the hashing algorithm. + * + * @param enable If set to true, then the column will be part of + * the distribution key. + */ + void setDistributionKey(bool enable); + + /** + * Check if column is part of distribution key + * @see setDistributionKey + */ + bool getDistributionKey() const; + /** @} *******************************************************************/ + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL + void setTupleKey(bool); + bool getTupleKey() const; + + void setDistributionGroup(bool, int bits = 16); + bool getDistributionGroup() const; + int getDistributionGroupBits() const; + + void setIndexOnlyStorage(bool); + bool getIndexOnlyStorage() const; + + /** + * @name ODBC Specific methods + * @{ + */ + void setAutoIncrement(bool); + bool getAutoIncrement() const; + void setAutoIncrementInitialValue(Uint64 val); + void setDefaultValue(const char*); + const char* getDefaultValue() const; + /** @} *******************************************************************/ +#endif + + private: + friend class NdbColumnImpl; + class NdbColumnImpl & m_impl; + Column(NdbColumnImpl&); + Column& operator=(const Column&); + }; + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL + /** + * ??? + */ + typedef Column Attribute; +#endif + + /** + * @brief Represents a table in NDB Cluster + * + * TableSize
+ * When calculating the data storage one should add the size of all + * attributes (each attributeconsumes at least 4 bytes) and also an overhead + * of 12 byte. Variable size attributes (not supported yet) will have a + * size of 12 bytes plus the actual data storage parts where there is an + * additional overhead based on the size of the variable part.
+ * An example table with 5 attributes: + * one 64 bit attribute, one 32 bit attribute, + * two 16 bit attributes and one array of 64 8 bits. + * This table will consume + * 12 (overhead) + 8 + 4 + 2*4 (4 is minimum) + 64 = 96 bytes per record. + * Additionally an overhead of about 2 % as page headers and waste should + * be allocated. Thus, 1 million records should consume 96 MBytes + * plus the overhead 2 MByte and rounded up to 100 000 kBytes.
+ * + */ + class Table : public Object { + public: + /** + * @name General + * @{ + */ + /** + * Constructor + * @param name Name of table + */ + Table(const char * name = ""); + + /** + * Copy constructor + * @param table Table to be copied + */ + Table(const Table& table); + virtual ~Table(); + + /** + * Assignment operator, deep copy + * @param table Table to be copied + */ + Table& operator=(const Table&); + + /** + * Name of table + * @param name Name of table + */ + void setName(const char * name); + + /** + * Get table name + */ + const char * getName() const; + + /** + * Get table id + */ + int getTableId() const; + + /** + * Add a column definition to a table + * @note creates a copy + */ + void addColumn(const Column &); + + /** + * Get column definition via name. + * @return null if none existing name + */ + const Column* getColumn(const char * name) const; + + /** + * Get column definition via index in table. + * @return null if none existing name + */ + const Column* getColumn(const int attributeId) const; + + /** @} *******************************************************************/ + /** + * @name Storage + * @{ + */ + + /** + * If set to false, then the table is a temporary + * table and is not logged to disk. + * + * In case of a system restart the table will still + * be defined and exist but will be empty. + * Thus no checkpointing and no logging is performed on the table. + * + * The default value is true and indicates a normal table + * with full checkpointing and logging activated. + */ + void setLogging(bool); + + /** + * @see NdbDictionary::Table::setLogging. + */ + bool getLogging() const; + + /** + * Set fragmentation type + */ + void setFragmentType(FragmentType); + + /** + * Get fragmentation type + */ + FragmentType getFragmentType() const; + + /** + * Set KValue (Hash parameter.) + * Only allowed value is 6. + * Later implementations might add flexibility in this parameter. + */ + void setKValue(int kValue); + + /** + * Get KValue (Hash parameter.) + * Only allowed value is 6. + * Later implementations might add flexibility in this parameter. + */ + int getKValue() const; + + /** + * Set MinLoadFactor (Hash parameter.) + * This value specifies the load factor when starting to shrink + * the hash table. + * It must be smaller than MaxLoadFactor. + * Both these factors are given in percentage. + */ + void setMinLoadFactor(int); + + /** + * Get MinLoadFactor (Hash parameter.) + * This value specifies the load factor when starting to shrink + * the hash table. + * It must be smaller than MaxLoadFactor. + * Both these factors are given in percentage. + */ + int getMinLoadFactor() const; + + /** + * Set MaxLoadFactor (Hash parameter.) + * This value specifies the load factor when starting to split + * the containers in the local hash tables. + * 100 is the maximum which will optimize memory usage. + * A lower figure will store less information in each container and thus + * find the key faster but consume more memory. + */ + void setMaxLoadFactor(int); + + /** + * Get MaxLoadFactor (Hash parameter.) + * This value specifies the load factor when starting to split + * the containers in the local hash tables. + * 100 is the maximum which will optimize memory usage. + * A lower figure will store less information in each container and thus + * find the key faster but consume more memory. + */ + int getMaxLoadFactor() const; + + /** @} *******************************************************************/ + /** + * @name Other + * @{ + */ + + /** + * Get number of columns in the table + */ + int getNoOfColumns() const; + + /** + * Get number of primary keys in the table + */ + int getNoOfPrimaryKeys() const; + + /** + * Get name of primary key + */ + const char* getPrimaryKey(int no) const; + + /** + * Check if table is equal to some other table + */ + bool equal(const Table&) const; + + /** + * Get frm file stored with this table + */ + const void* getFrmData() const; + Uint32 getFrmLength() const; + + /** + * Set frm file to store with this table + */ + void setFrm(const void* data, Uint32 len); + + /** + * Set table object type + */ + void setObjectType(Object::Type type); + + /** + * Get table object type + */ + Object::Type getObjectType() const; + + /** + * Get object status + */ + virtual Object::Status getObjectStatus() const; + + /** + * Get object version + */ + virtual int getObjectVersion() const; + + /** @} *******************************************************************/ + +#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED + void setStoredTable(bool x) { setLogging(x); } + bool getStoredTable() const { return getLogging(); } + + int getRowSizeInBytes() const ; + int createTableInDb(Ndb*, bool existingEqualIsOk = true) const ; +#endif + + private: + friend class NdbTableImpl; + class NdbTableImpl & m_impl; + Table(NdbTableImpl&); + }; + + /** + * @class Index + * @brief Represents an index in an NDB Cluster + */ + class Index : public Object { + public: + /** + * Constructor + * @param name Name of index + */ + Index(const char * name = ""); + virtual ~Index(); + + /** + * Set the name of an index + */ + void setName(const char * name); + + /** + * Get the name of an index + */ + const char * getName() const; + + /** + * Define the name of the table to be indexed + */ + void setTable(const char * name); + + /** + * Get the name of the table being indexed + */ + const char * getTable() const; + + /** + * Get the number of columns in the index + */ + unsigned getNoOfColumns() const; + + /** + * Get the number of columns in the index + * Depricated, use getNoOfColumns instead. + */ + int getNoOfIndexColumns() const; + + /** + * Get a specific column in the index + */ + const NdbDictionary::Column * getColumn(unsigned no) const ; + + /** + * Get a specific column name in the index + * Depricated, use getColumn instead. + */ + const char * getIndexColumn(int no) const ; + + /** + * Add a column to the index definition + * Note that the order of columns will be in + * the order they are added (only matters for ordered indexes). + */ + void addColumn(const Column & c); + + /** + * Add a column name to the index definition + * Note that the order of indexes will be in + * the order they are added (only matters for ordered indexes). + */ + void addColumnName(const char * name); + + /** + * Add a column name to the index definition + * Note that the order of indexes will be in + * the order they are added (only matters for ordered indexes). + * Depricated, use addColumnName instead. + */ + void addIndexColumn(const char * name); + + /** + * Add several column names to the index definition + * Note that the order of indexes will be in + * the order they are added (only matters for ordered indexes). + */ + void addColumnNames(unsigned noOfNames, const char ** names); + + /** + * Add several column names to the index definition + * Note that the order of indexes will be in + * the order they are added (only matters for ordered indexes). + * Depricated, use addColumnNames instead. + */ + void addIndexColumns(int noOfNames, const char ** names); + + /** + * Represents type of index + */ + enum Type { + Undefined = 0, ///< Undefined object type (initial value) + UniqueHashIndex = 3, ///< Unique un-ordered hash index + ///< (only one currently supported) + HashIndex = 4, ///< Non-unique un-ordered hash index + UniqueOrderedIndex = 5, ///< Unique ordered index + OrderedIndex = 6 ///< Non-unique ordered index + }; + + /** + * Set index type of the index + */ + void setType(Type type); + + /** + * Get index type of the index + */ + Type getType() const; + + /** + * Enable/Disable index storage on disk + * + * @param enable If enable is set to true, then logging becomes enabled + * + * @see NdbDictionary::Table::setLogging + * + * @note Non-logged indexes are rebuilt at system restart. + * @note Ordered index does not currently support logging. + */ + void setLogging(bool enable); + + /** + * Check if index is set to be stored on disk + * + * @see NdbDictionary::Index::setLogging + */ + bool getLogging() const; + +#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED + void setStoredIndex(bool x) { setLogging(x); } + bool getStoredIndex() const { return getLogging(); } +#endif + + /** + * Get object status + */ + virtual Object::Status getObjectStatus() const; + + /** + * Get object version + */ + virtual int getObjectVersion() const; + + private: + friend class NdbIndexImpl; + + class NdbIndexImpl & m_impl; + Index(NdbIndexImpl&); + }; + + /** + * @brief Represents an Event in NDB Cluster + * + */ + class Event : public Object { + public: + enum TableEvent { TE_INSERT=1, TE_DELETE=2, TE_UPDATE=4, TE_ALL=7 }; + enum EventDurability { + ED_UNDEFINED = 0, +#if 0 // not supported + ED_SESSION = 1, + // Only this API can use it + // and it's deleted after api has disconnected or ndb has restarted + + ED_TEMPORARY = 2, + // All API's can use it, + // But's its removed when ndb is restarted +#endif + ED_PERMANENT = 3 + // All API's can use it, + // It's still defined after a restart + }; + + Event(const char *name); + virtual ~Event(); + void setName(const char *); + void setTable(const char *); + void addTableEvent(const TableEvent); + void setDurability(const EventDurability); + void addColumn(const Column &c); + void addEventColumn(unsigned attrId); + void addEventColumn(const char * columnName); + void addEventColumns(int n, const char ** columnNames); + + /** + * Get object status + */ + virtual Object::Status getObjectStatus() const; + + /** + * Get object version + */ + virtual int getObjectVersion() const; + + void print(); + + private: + friend class NdbEventImpl; + friend class NdbEventOperationImpl; + class NdbEventImpl & m_impl; + Event(NdbEventImpl&); + }; + + /** + * @class Dictionary + * @brief Dictionary for defining and retreiving meta data + */ + class Dictionary { + public: + /** + * @class List + * @brief Structure for retrieving lists of object names + */ + struct List { + /** + * @struct Element + * @brief Object to be stored in an NdbDictionary::Dictionary::List + */ + struct Element { + unsigned id; ///< Id of object + Object::Type type; ///< Type of object + Object::State state; ///< State of object + Object::Store store; ///< How object is stored + char * database; ///< In what database the object resides + char * schema; ///< What schema the object is defined in + char * name; ///< Name of object + Element() : + id(0), + type(Object::TypeUndefined), + state(Object::StateUndefined), + store(Object::StoreUndefined), + database(0), + schema(0), + name(0) { + } + }; + unsigned count; ///< Number of elements in list + Element * elements; ///< Pointer to array of elements + List() : count(0), elements(0) {} + ~List() { + if (elements != 0) { + for (unsigned i = 0; i < count; i++) { + delete[] elements[i].database; + delete[] elements[i].schema; + delete[] elements[i].name; + elements[i].name = 0; + } + delete[] elements; + count = 0; + elements = 0; + } + } + }; + + /** + * @name General + * @{ + */ + + /** + * Fetch list of all objects, optionally restricted to given type. + */ + int listObjects(List & list, Object::Type type = Object::TypeUndefined); + + /** + * Get the latest error + * + * @return Error object. + */ + const struct NdbError & getNdbError() const; + + /** @} *******************************************************************/ + /** + * @name Tables + * @{ + */ + + /** + * Create defined table given defined Table instance + * @param Table Table to create + * @return 0 if successful otherwise -1. + */ + int createTable(const Table &); + + /** + * Drop table given retrieved Table instance + * @param Table Table to drop + * @return 0 if successful otherwise -1. + */ + int dropTable(Table &); + + /** + * Drop table given table name + * @param name Name of table to drop + * @return 0 if successful otherwise -1. + */ + int dropTable(const char * name); + + /** + * Alter defined table given defined Table instance + * @param Table Table to alter + * @return -2 (incompatible version)
+ * -1 general error
+ * 0 success + */ + int alterTable(const Table &); + + /** + * Get table with given name, NULL if undefined + * @param name Name of table to get + * @return table if successful otherwise NULL. + */ + const Table * getTable(const char * name); + + /** + * Get table with given name for alteration. + * @param name Name of table to alter + * @return table if successful. NULL if undefined + */ + Table getTableForAlteration(const char * name); + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL + /** + * Invalidate cached table object + * @param name Name of table to invalidate + */ + void invalidateTable(const char * name); +#endif + + /** + * Remove table/index from local cache + */ + void removeCachedTable(const char * table); + void removeCachedIndex(const char * index, const char * table); + + + /** @} *******************************************************************/ + /** + * @name Indexes + * @{ + */ + + /** + * Create index given defined Index instance + * @param Index to create + * @return 0 if successful otherwise -1. + */ + int createIndex(const Index &); + + /** + * Drop index with given name + * @param indexName Name of index to drop. + * @param tableName Name of table that index belongs to. + * @return 0 if successful otherwise -1. + */ + int dropIndex(const char * indexName, + const char * tableName); + + /** + * Get index with given name, NULL if undefined + * @param indexName Name of index to get. + * @param tableName Name of table that index belongs to. + * @return index if successful, otherwise 0. + */ + const Index * getIndex(const char * indexName, + const char * tableName); + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL + /** + * Invalidate cached index object + */ + void invalidateIndex(const char * indexName, + const char * tableName); +#endif + + /** + * Fetch list of indexes of given table. + * @param list Reference to list where to store the listed indexes + * @param tableName Name of table that index belongs to. + * @return 0 if successful, otherwise -1 + */ + int listIndexes(List & list, const char * tableName); + + /** @} *******************************************************************/ + /** + * @name Events + * @{ + */ + + /** + * Create event given defined Event instance + * @param Event to create + * @return 0 if successful otherwise -1. + */ + int createEvent(const Event &); + + /** + * Drop event with given name + * @param eventName Name of event to drop. + * @return 0 if successful otherwise -1. + */ + int dropEvent(const char * eventName); + + /** + * Get event with given name. + * @param eventName Name of event to get. + * @return an Event if successful, otherwise NULL. + */ + const Event * getEvent(const char * eventName); + + /** @} *******************************************************************/ + + protected: + Dictionary(Ndb & ndb); + ~Dictionary(); + + private: + friend class NdbDictionaryImpl; + friend class UtilTransactions; + class NdbDictionaryImpl & m_impl; + Dictionary(NdbDictionaryImpl&); + const Table * getIndexTable(const char * indexName, + const char * tableName); + }; +}; + +#endif diff --git a/ndb/include/ndbapi/NdbError.hpp b/ndb/include/ndbapi/NdbError.hpp new file mode 100644 index 00000000000..b08dd1041b2 --- /dev/null +++ b/ndb/include/ndbapi/NdbError.hpp @@ -0,0 +1,212 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_ERROR_HPP +#define NDB_ERROR_HPP + +/** + * @struct NdbError + * @brief Contains error information + * + * A NdbError consists of five parts: + * -# Error status : Application impact + * -# Error classification : Logical error group + * -# Error code : Internal error code + * -# Error message : Context independent description of error + * -# Error details : Context dependent information + * (not always available) + * + * Error status is usually used for programming against errors. + * If more detailed error control is needed, it is possible to + * use the error classification. + * + * It is not recommended to write application programs dependent on + * specific error codes. + * + * The error messages and error details may + * change without notice. + * + * For example of use, see @ref ndbapi_example3.cpp. + */ +struct NdbError { + /** + * Status categorizes error codes into status values reflecting + * what the application should do when encountering errors + */ + enum Status { + /** + * The error code indicate success
+ * (Includes classification: NdbError::NoError) + */ + Success = 0, + + /** + * The error code indicates a temporary error. + * The application should typically retry.
+ * (Includes classifications: NdbError::InsufficientSpace, + * NdbError::TemporaryResourceError, NdbError::NodeRecoveryError, + * NdbError::OverloadError, NdbError::NodeShutdown + * and NdbError::TimeoutExpired.) + */ + TemporaryError = 1, + + /** + * The error code indicates a permanent error.
+ * (Includes classificatons: NdbError::PermanentError, + * NdbError::ApplicationError, NdbError::NoDataFound, + * NdbError::ConstraintViolation, NdbError::SchemaError, + * NdbError::UserDefinedError, NdbError::InternalError, and, + * NdbError::FunctionNotImplemented.) + */ + PermanentError = 2, + + /** + * The result/status is unknown.
+ * (Includes classifications: NdbError::UnknownResultError, and + * NdbError::UnknownErrorCode.) + */ + UnknownResult = 3 + }; + + /** + * Type of error + */ + enum Classification { + /** + * Success. No error occurred. + */ + NoError = 0, + + /** + * Error in application program. + */ + ApplicationError = 1, + + /** + * Read operation failed due to missing record. + */ + NoDataFound = 2, + + /** + * E.g. inserting a tuple with a primary key already existing + * in the table. + */ + ConstraintViolation = 3, + + /** + * Error in creating table or usage of table. + */ + SchemaError = 4, + + /** + * Error occurred in interpreted program. + */ + UserDefinedError = 5, + + /** + * E.g. insufficient memory for data or indexes. + */ + InsufficientSpace = 6, + + /** + * E.g. too many active transactions. + */ + TemporaryResourceError = 7, + + /** + * Temporary failures which are probably inflicted by a node + * recovery in progress. Examples: information sent between + * application and NDB lost, distribution change. + */ + NodeRecoveryError = 8, + + /** + * E.g. out of log file space. + */ + OverloadError = 9, + + /** + * Timeouts, often inflicted by deadlocks in NDB. + */ + TimeoutExpired = 10, + + /** + * Is is unknown whether the transaction was committed or not. + */ + UnknownResultError = 11, + + /** + * A serious error in NDB has occurred. + */ + InternalError = 12, + + /** + * A function used is not yet implemented. + */ + FunctionNotImplemented = 13, + + /** + * Error handler could not determine correct error code. + */ + UnknownErrorCode = 14, + + /** + * Node shutdown + */ + NodeShutdown = 15 + }; + + /** + * Error status. + */ + Status status; + + /** + * Error type + */ + Classification classification; + + /** + * Error code + */ + int code; + + /** + * Error message + */ + const char * message; + + /** + * The detailed description. This is extra information regarding the + * error which is not included in the error message. + * + * @note Is NULL when no details specified + */ + char * details; + + NdbError(){ + status = UnknownResult; + classification = NoError; + code = 0; + message = 0; + details = 0; + } +}; + +class NdbOut& operator <<(class NdbOut&, const NdbError &); +class NdbOut& operator <<(class NdbOut&, const NdbError::Status&); +class NdbOut& operator <<(class NdbOut&, const NdbError::Classification&); +#endif diff --git a/ndb/include/ndbapi/NdbEventOperation.hpp b/ndb/include/ndbapi/NdbEventOperation.hpp new file mode 100644 index 00000000000..911b00b02c4 --- /dev/null +++ b/ndb/include/ndbapi/NdbEventOperation.hpp @@ -0,0 +1,205 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/***************************************************************************** + * Name: NdbEventOperation.hpp + * Include: + * Link: + * Author: Tomas Ulin MySQL AB + * Date: 2003-11-21 + * Version: 0.1 + * Description: Event support + * Documentation: + * Adjust: 2003-11-21 Tomas Ulin First version. + * Adjust: 2003-12-11 Tomas Ulin Alpha Release. + ****************************************************************************/ + +#ifndef NdbEventOperation_H +#define NdbEventOperation_H + +class NdbGlobalEventBuffer; +class NdbEventOperationImpl; + +/** + * @class NdbEventOperation + * @brief Class of operations for getting change events from database. + * + * An NdbEventOperation object is instantiated by + * NdbEventOperation *Ndb::createEventOperation(const char *eventName, + * int bufferLength) + * + * Prior to that an event must have been created in the Database through + * int NdbDictionary::createEvent(NdbDictionary::Event) + * + * bufferLength indicates size of circular buffer to store event info as + * they occur. + * + * The instance is removed by Ndb::dropEventOperation(NdbEventOperation*) + * + * For more info see: + * ndbapi_example5.cpp + * Ndb.hpp + * NdbDictionary.hpp + * + * Known limitations: + * + * Maximum number of active NdbEventOperations are now set at compile time. + * Today 100. This will become a configuration parameter later. + * + * Maximum number of NdbEventOperations tied to same event are maximum 16 + * per process. + * + * Known issues: + * + * When several NdbEventOperation s are tied to the same event in the same + * process they will share the circular buffer. The BufferLength will then + * be the same for all and decided by the first NdbEventOperation + * instantiation. Just make sure to instantiate the "largest" one first. + * + * Today all events INSERT/DELETE/UPDATE and all changed attributes are + * sent to the API, even if only specific attributes have been specified. + * These are however hidden from the user and only relevant data is shown + * after next(). However false exits from pollEvents() may occur and thus + * the subsequent next() will return zero, since there was no available + * data. Just do pollEvents() again. Will be fixed in later versions. + * + * Event code does not check table schema version. Make sure to drop events + * after table is dropped. Will be fixed in later + * versions. + * + * On a replicated system one will receive each event 2 times, one for each + * replica. If a node fails events will not be received twice anymore + * for data in corresponding fragment. Will be optimized in later versions. + * + * If a nodefailiure has occured not all events will be recieved + * anymore. Drop NdbEventOperation and Create again after nodes are up + * again. Will be fixed in later versions. + * + * Test status: + * Tests have been run on 1-node and 2-node systems + * + * Known bugs: + * + * None, except if we can call some of the "isses" above bugs + * + * Useful API programs: + * + * select_all -d sys 'NDB$EVENTS_0' + * Will show contents in the system table containing created events. + * + */ +class NdbEventOperation { +public: + enum State {CREATED,EXECUTING,ERROR}; + + State getState(); + + /** + * Activates the NdbEventOperation to start receiving events. The + * changed attribute values may be retrieved after next() has returned + * a value greater than zero. The getValue() methods below must be called + * prior to execute(). + * + * @return 0 if successful otherwise -1. + */ + int execute(); + + // about the event operation + // getting data + // NdbResultSet* getResultSet(); + + /** + * Defines a retrieval operation of an attribute value. + * The NDB API allocate memory for the NdbRecAttr object that + * will hold the returned attribute value. + * + * @note Note that it is the applications responsibility + * to allocate enough memory for aValue (if non-NULL). + * The buffer aValue supplied by the application must be + * aligned appropriately. The buffer is used directly + * (avoiding a copy penalty) only if it is aligned on a + * 4-byte boundary and the attribute size in bytes + * (i.e. NdbRecAttr::attrSize times NdbRecAttr::arraySize is + * a multiple of 4). + * + * @note There are two versions, NdbOperation::getValue and + * NdbOperation::getPreValue for retrieving the current and + * previous value repectively. + * + * @note This method does not fetch the attribute value from + * the database! The NdbRecAttr object returned by this method + * is not readable/printable before the + * NdbEventConnection::execute has been made and + * NdbEventConnection::next has returned a value greater than + * zero. If a specific attribute has not changed the corresponding + * NdbRecAttr will be in state UNDEFINED. This is checked by + * NdbRecAttr::isNull which then returns -1. + * + * @param anAttrName Attribute name + * @param aValue If this is non-NULL, then the attribute value + * will be returned in this parameter.
+ * If NULL, then the attribute value will only + * be stored in the returned NdbRecAttr object. + * @return An NdbRecAttr object to hold the value of + * the attribute, or a NULL pointer + * (indicating error). + */ + NdbRecAttr *getValue(const char *anAttrName, char *aValue = NULL); + NdbRecAttr *getPreValue(const char *anAttrName, char *aValue = NULL); + + /** + * Retrieves event resultset if available, inserted into the NdbRecAttrs + * specified in getValue() and getPreValue(). To avoid polling for + * a resultset, one can use Ndb::pollEvents(int millisecond_timeout) + * which will wait on a mutex until an event occurs or the specified + * timeout occurs. + * + * @return >=0 if successful otherwise -1. Return value inicates number + * of available events. By sending pOverRun one may query for buffer + * overflow and *pOverRun will indicate the number of events that have + * overwritten. + */ + int next(int *pOverRun=NULL); + + /** + * In the current implementation a nodefailiure may cause loss of events, + * in which case isConsistent() will return false + */ + bool isConsistent(); + + /** + * Query for occured event type. + * NdbDictionary::Event::{TE_INSERT,TE_UPDATE,TE_DELETE} + * Only valid after next() has returned value >= 0 + */ + NdbDictionary::Event::TableEvent getEventType(); + + Uint32 getGCI(); + Uint32 getLatestGCI(); + void print(); + +private: + friend class NdbEventOperationImpl; + friend class Ndb; + NdbEventOperation(Ndb *theNdb, const char* eventName,int bufferLength); + ~NdbEventOperation(); + static int wait(void *p, int aMillisecondNumber); + class NdbEventOperationImpl &m_impl; + NdbEventOperation(NdbEventOperationImpl& impl); +}; + +typedef void (* NdbEventCallback)(NdbEventOperation*, Ndb*, void*); +#endif diff --git a/ndb/include/ndbapi/NdbIndexOperation.hpp b/ndb/include/ndbapi/NdbIndexOperation.hpp new file mode 100644 index 00000000000..3b8e5f7a888 --- /dev/null +++ b/ndb/include/ndbapi/NdbIndexOperation.hpp @@ -0,0 +1,192 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/***************************************************************************** + * Name: NdbIndexOperation.hpp + * Include: + * Link: + * Author: Martin Sköld + * Date: 2002-04-01 + * Version: 0.1 + * Description: Secondary index support + * Documentation: + * Adjust: 2002-04-01 Martin Sköld First version. + ****************************************************************************/ + +#ifndef NdbIndexOperation_H +#define NdbIndexOperation_H + +#include + +class Index; +class NdbResultSet; + +/** + * @class NdbIndexOperation + * @brief Class of index operations for use in transactions + */ +class NdbIndexOperation : public NdbOperation +{ + friend class Ndb; + friend class NdbConnection; + +public: + /** + * @name Define Standard Operation + * @{ + */ + + /** + * Define the NdbIndexOperation to be a standard operation of type readTuple. + * When calling NdbConnection::execute, this operation + * reads a tuple. + * + * @return 0 if successful otherwise -1. + */ + int readTuple(); + + /** + * Define the NdbIndexOperation to be a standard operation of type + * readTupleExclusive. + * When calling NdbConnection::execute, this operation + * read a tuple using an exclusive lock. + * + * @return 0 if successful otherwise -1. + */ + int readTupleExclusive(); + + /** + * Define the NdbIndexOperation to be a standard operation of type simpleRead. + * When calling NdbConnection::execute, this operation + * reads an existing tuple (using shared read lock), + * but releases lock immediately after read. + * + * @note Using this operation twice in the same transaction + * may produce different results (e.g. if there is another + * transaction which updates the value between the + * simple reads). + * + * Note that simpleRead can read the value from any database node while + * standard read always read the value on the database node which is + * primary for the record. + * + * @return 0 if successful otherwise -1. + */ + int simpleRead(); + + /** + * Define the NdbOperation to be a standard operation of type committedRead. + * When calling NdbConnection::execute, this operation + * read latest committed value of the record. + * + * This means that if another transaction is updating the + * record, then the current transaction will not wait. + * It will instead use the latest committed value of the + * record. + * + * @return 0 if successful otherwise -1. + */ + int dirtyRead(); + +#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED + int committedRead(); +#endif + + /** + * Define the NdbIndexOperation to be a standard operation of type + * updateTuple. + * + * When calling NdbConnection::execute, this operation + * updates a tuple in the table. + * + * @return 0 if successful otherwise -1. + */ + int updateTuple(); + + /** + * Define the NdbIndexOperation to be a standard operation of type + * deleteTuple. + * + * When calling NdbConnection::execute, this operation + * deletes a tuple. + * + * @return 0 if successful otherwise -1. + */ + int deleteTuple(); + + /** + * Define the NdbIndexOperation to be a standard operation of type + * dirtyUpdate. + * + * When calling NdbConnection::execute, this operation + * updates without two-phase commit. + * + * @return 0 if successful otherwise -1. + */ + int dirtyUpdate(); + + /** @} *********************************************************************/ + /** + * @name Define Interpreted Program Operation + * @{ + */ + + /** + * Update a tuple using an interpreted program. + * + * @return 0 if successful otherwise -1. + */ + int interpretedUpdateTuple(); + + /** + * Delete a tuple using an interpreted program. + * + * @return 0 if successful otherwise -1. + */ + int interpretedDeleteTuple(); + + /** @} *********************************************************************/ + +private: + NdbIndexOperation(Ndb* aNdb); + ~NdbIndexOperation(); + + void closeScan(); + + int receiveTCINDXREF(NdbApiSignal* aSignal); + + // Overloaded method from NdbOperation + void setLastFlag(NdbApiSignal* signal, Uint32 lastFlag); + + // Overloaded methods from NdbCursorOperation + int executeCursor(int ProcessorId); + + // Overloaded methods from NdbCursorOperation + int indxInit(class NdbIndexImpl* anIndex, + class NdbTableImpl* aTable, + NdbConnection* myConnection); + + int equal_impl(const class NdbColumnImpl*, const char* aValue, Uint32 len); + int prepareSend(Uint32 TC_ConnectPtr, Uint64 TransactionId); + + // Private attributes + NdbIndexImpl* m_theIndex; + Uint32 m_theIndexDefined[MAXNROFTUPLEKEY][3]; + Uint32 m_theIndexLen; // Length of the index in words + Uint32 m_theNoOfIndexDefined; // The number of index attributes +}; + +#endif diff --git a/ndb/include/ndbapi/NdbOperation.hpp b/ndb/include/ndbapi/NdbOperation.hpp new file mode 100644 index 00000000000..4f5f4597937 --- /dev/null +++ b/ndb/include/ndbapi/NdbOperation.hpp @@ -0,0 +1,1338 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NdbOperation_H +#define NdbOperation_H + +#include +#include + +#include +#include "AttrType.hpp" +#include "NdbError.hpp" +#include "NdbReceiver.hpp" +#include + +class Ndb; +class NdbApiSignal; +class NdbRecAttr; +class NdbOperation; +class NdbConnection; +class NdbColumnImpl; + +/** + * @class NdbOperation + * @brief Class of operations for use in transactions. + */ +class NdbOperation +{ + friend class Ndb; + friend class NdbConnection; + friend class NdbScanOperation; + friend class NdbScanReceiver; + friend class NdbScanFilter; + friend class NdbScanFilterImpl; + +public: + /** + * @name Define Standard Operation Type + * @{ + */ + + /** + * Define the NdbOperation to be a standard operation of type insertTuple. + * When calling NdbConnection::execute, this operation + * adds a new tuple to the table. + * + * @return 0 if successful otherwise -1. + */ + virtual int insertTuple(); + + /** + * Define the NdbOperation to be a standard operation of type updateTuple. + * When calling NdbConnection::execute, this operation + * updates a tuple in the table. + * + * @return 0 if successful otherwise -1. + */ + virtual int updateTuple(); + + /** + * Define the NdbOperation to be a standard operation of type writeTuple. + * When calling NdbConnection::execute, this operation + * writes a tuple to the table. + * If the tuple exists, it updates it, otherwise an insert takes place. + * + * @return 0 if successful otherwise -1. + */ + virtual int writeTuple(); + + /** + * Define the NdbOperation to be a standard operation of type deleteTuple. + * When calling NdbConnection::execute, this operation + * delete a tuple. + * + * @return 0 if successful otherwise -1. + */ + virtual int deleteTuple(); + + /** + * Define the NdbOperation to be a standard operation of type readTuple. + * When calling NdbConnection::execute, this operation + * reads a tuple. + * + * @return 0 if successful otherwise -1. + */ + virtual int readTuple(); + + /** + * Define the NdbOperation to be a standard operation of type + * readTupleExclusive. + * When calling NdbConnection::execute, this operation + * read a tuple using an exclusive lock. + * + * @return 0 if successful otherwise -1. + */ + virtual int readTupleExclusive(); + + /** + * Define the NdbOperation to be a standard operation of type + * simpleRead. + * When calling NdbConnection::execute, this operation + * reads an existing tuple (using shared read lock), + * but releases lock immediately after read. + * + * @note Using this operation twice in the same transaction + * may produce different results (e.g. if there is another + * transaction which updates the value between the + * simple reads). + * + * Note that simpleRead can read the value from any database node while + * standard read always read the value on the database node which is + * primary for the record. + * + * @return 0 if successful otherwise -1. + */ + virtual int simpleRead(); + +#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED + /** + * Define the NdbOperation to be a standard operation of type committedRead. + * When calling NdbConnection::execute, this operation + * read latest committed value of the record. + * + * This means that if another transaction is updating the + * record, then the current transaction will not wait. + * It will instead use the latest committed value of the + * record. + * dirtyRead is a deprecated name for committedRead + * + * @return 0 if successful otherwise -1. + * @depricated + */ + virtual int dirtyRead(); +#endif + + /** + * Define the NdbOperation to be a standard operation of type committedRead. + * When calling NdbConnection::execute, this operation + * read latest committed value of the record. + * + * This means that if another transaction is updating the + * record, then the current transaction will not wait. + * It will instead use the latest committed value of the + * record. + * + * @return 0 if successful otherwise -1. + */ + virtual int committedRead(); + + /** + * Define the NdbOperation to be a standard operation of type dirtyUpdate. + * When calling NdbConnection::execute, this operation + * updates without two-phase commit. + * + * @return 0 if successful otherwise -1. + */ + virtual int dirtyUpdate(); + + /** + * Define the NdbOperation to be a standard operation of type dirtyWrite. + * When calling NdbConnection::execute, this operation + * writes without two-phase commit. + * + * @return 0 if successful otherwise -1. + */ + virtual int dirtyWrite(); + + /** @} *********************************************************************/ + /** + * @name Define Interpreted Program Operation Type + * @{ + */ + + /** + * Update a tuple using an interpreted program. + * + * @return 0 if successful otherwise -1. + */ + virtual int interpretedUpdateTuple(); + + /** + * Delete a tuple using an interpreted program. + * + * @return 0 if successful otherwise -1. + */ + virtual int interpretedDeleteTuple(); + + /** + * Scan a table to read tuples. + * + * The operation only sets a temporary read lock while + * reading the tuple. + * The tuple lock is released when the result of the read reaches the + * application. + * + * @param Parallelism Number of parallel tuple reads are performed + * in the scan. + * Currently a maximum of 256 parallel tuple + * reads are allowed. + * The parallelism can in reality be lower + * than specified + * depending on the number of nodes + * in the cluster + * @return 0 if successful otherwise -1. + */ + int openScanRead(Uint32 Parallelism = 16 ); + + /** + * Scan a table to write or update tuples. + * + * The operation sets an exclusive lock on the tuple and sends the result + * to the application. + * Thus when the application reads the data, the tuple is + * still locked with an exclusive lock. + * + * @param parallelism Number of parallel tuple reads are performed + * in the scan. + * Currently a maximum of 256 parallel tuple + * reads are allowed. + * The parallelism can in reality be lower + * than specified depending on the number + * of nodes in the cluster + * @return 0 if successful otherwise -1. + * + */ + int openScanExclusive(Uint32 parallelism = 16); + + /** + * Scan a table to read tuples. + * + * The operation only sets a read lock while + * reading the tuple. + * Thus when the application reads the data, the tuple is + * still locked with a read lock. + * + * @param parallelism Number of parallel tuple reads are performed + * in the scan. + * Currently a maximum of 256 parallel tuple + * reads are allowed. + * The parallelism can in reality be lower + * than specified + * depending on the number of nodes + * in the cluster + * @return 0 if successful otherwise -1. + */ + int openScanReadHoldLock(Uint32 parallelism = 16); + + /** + * Scan a table to read tuples. + * + * The operation does not wait for locks held by other transactions + * but returns the latest committed tuple instead. + * + * @param parallelism Number of parallel tuple reads are performed + * in the scan. + * Currently a maximum of 256 parallel tuple + * reads are allowed. + * The parallelism can in reality be lower + * than specified + * depending on the number of nodes + * in the cluster + * @return 0 if successful otherwise -1. + */ + int openScanReadCommitted(Uint32 parallelism = 16); + + /** @} *********************************************************************/ + + /** + * @name Define Range Scan + * + * A range scan is a scan on an ordered index. The operation is on + * the index table but tuples are returned from the primary table. + * The index contains all tuples where at least one index key has not + * null value. + * + * A range scan is currently opened via a normal open scan method. + * Bounds can be defined for each index key. After setting bounds, + * usual scan methods can be used (get value, interpreter, take over). + * These operate on the primary table. + * + * @{ + */ + + /** + * Type of ordered index key bound. The values (0-4) will not change + * and can be used explicitly (e.g. they could be computed). + */ + enum BoundType { + BoundLE = 0, ///< lower bound, + BoundLT = 1, ///< lower bound, strict + BoundGE = 2, ///< upper bound + BoundGT = 3, ///< upper bound, strict + BoundEQ = 4 ///< equality + }; + + /** + * Define bound on index key in range scan. + * + * Each index key can have not null lower and/or upper bound, or can + * be set equal to not null value. The bounds can be defined in any + * order but a duplicate definition is an error. + * + * The scan is most effective when bounds are given for an initial + * sequence of non-nullable index keys, and all but the last one is an + * equality. In this case the scan returns a contiguous range from + * each ordered index fragment. + * + * @note This release implements only the case described above, + * except for the non-nullable limitation. Other sets of + * bounds return error or empty result set. + * + * @note In this release a null key value satisfies any lower + * bound and no upper bound. This may change. + * + * @param attrName Attribute name, alternatively: + * @param anAttrId Index column id (starting from 0). + * @param type Type of bound + * @param value Pointer to bound value + * @param len Value length in bytes. + * Fixed per datatype and can be omitted + * @return 0 if successful otherwise -1 + */ + int setBound(const char* anAttrName, int type, const void* aValue, Uint32 len = 0); + + /** + * Define bound on index key in range scan using index column id. + * See the other setBound() method for details. + */ + int setBound(Uint32 anAttrId, int type, const void* aValue, Uint32 len = 0); + + /** @} *********************************************************************/ + + /** + * Validate parallelism parameter by checking the number + * against number of executing Ndb nodes. + * + * @param Parallelism + * @return 0 if correct parallelism value, otherwise -1. + * + */ + int checkParallelism(Uint32 Parallelism); + + /** + * Transfer scan operation to an updating transaction. Use this function + * when a scan has found a record that you want to update. + * 1. Start a new transaction. + * 2. Call the function takeOverForUpdate using your new transaction + * as parameter, all the properties of the found record will be copied + * to the new transaction. + * 3. When you execute the new transaction, the lock held by the scan will + * be transferred to the new transaction(it's taken over). + * + * @note You must have started the scan with openScanExclusive + * to be able to update the found tuple. + * + * @param updateTrans the update transaction connection. + * @return an NdbOperation or NULL. + */ + NdbOperation* takeOverForUpdate(NdbConnection* updateTrans); + + /** + * Transfer scan operation to a deleting transaction. Use this function + * when a scan has found a record that you want to delete. + * 1. Start a new transaction. + * 2. Call the function takeOverForDelete using your new transaction + * as parameter, all the properties of the found record will be copied + * to the new transaction. + * 3. When you execute the new transaction, the lock held by the scan will + * be transferred to the new transaction(its taken over). + * + * @note You must have started the scan with openScanExclusive + * to be able to delete the found tuple. + * + * @param deleteTrans the delete transaction connection. + * @return an NdbOperation or NULL. + */ + NdbOperation* takeOverForDelete(NdbConnection* deleteTrans); + + /** + * @name Specify Search Conditions + * @{ + */ + /** + * Define a search condition with equality. + * The condition is true if the attribute has the given value. + * To set search conditions on multiple attributes, + * use several equals (then all of them must be satisfied for the + * tuple to be selected). + * + * @note There are 10 versions of NdbOperation::equal with + * slightly different parameters. + * + * @note When using NdbOperation::equal with a string (char *) as + * second argument, the string needs to be padded with + * zeros in the following sense: + * @code + * // Equal needs strings to be padded with zeros + * strncpy(buf, str, sizeof(buf)); + * NdbOperation->equal("Attr1", buf); + * @endcode + * + * @param anAttrName Attribute name + * @param aValue Attribute value. + * @param len Attribute length expressed in bytes. + * @return -1 if unsuccessful. + */ + int equal(const char* anAttrName, const char* aValue, Uint32 len = 0); + int equal(const char* anAttrName, Uint32 aValue); + int equal(const char* anAttrName, Int32 aValue); + int equal(const char* anAttrName, Int64 aValue); + int equal(const char* anAttrName, Uint64 aValue); + int equal(Uint32 anAttrId, const char* aValue, Uint32 len = 0); + int equal(Uint32 anAttrId, Int32 aValue); + int equal(Uint32 anAttrId, Uint32 aValue); + int equal(Uint32 anAttrId, Int64 aValue); + int equal(Uint32 anAttrId, Uint64 aValue); + + /** + * Generate a tuple id and set it as search argument. + * + * The Tuple id has NDB$TID as attribute name and 0 as attribute id. + * + * The generated tuple id is returned by the method. + * If zero is returned there is an error. + * + * This is mostly used for tables without any primary key + * attributes. + * + * @return Generated tuple id if successful, otherwise 0. + */ + Uint64 setTupleId(); + + /** @} *********************************************************************/ + /** + * @name Specify Attribute Actions for Operations + * @{ + */ + + /** + * Defines a retrieval operation of an attribute value. + * The NDB API allocate memory for the NdbRecAttr object that + * will hold the returned attribute value. + * + * @note Note that it is the applications responsibility + * to allocate enough memory for aValue (if non-NULL). + * The buffer aValue supplied by the application must be + * aligned appropriately. The buffer is used directly + * (avoiding a copy penalty) only if it is aligned on a + * 4-byte boundary and the attribute size in bytes + * (i.e. NdbRecAttr::attrSize times NdbRecAttr::arraySize is + * a multiple of 4). + * + * @note There are two versions of NdbOperation::getValue with + * slightly different parameters. + * + * @note This method does not fetch the attribute value from + * the database! The NdbRecAttr object returned by this method + * is not readable/printable before the + * transaction has been executed with NdbConnection::execute. + * + * @param anAttrName Attribute name + * @param aValue If this is non-NULL, then the attribute value + * will be returned in this parameter.
+ * If NULL, then the attribute value will only + * be stored in the returned NdbRecAttr object. + * @return An NdbRecAttr object to hold the value of + * the attribute, or a NULL pointer + * (indicating error). + */ + NdbRecAttr* getValue(const char* anAttrName, char* aValue = NULL); + NdbRecAttr* getValue(Uint32 anAttrId, char* aValue = NULL); + + /** + * Define an attribute to set or update in query. + * + * To set a NULL value, use the following construct: + * @code + * setValue("ATTR_NAME", (char*)NULL); + * @endcode + * + * There are a number of NdbOperation::setValue methods that + * take a certain type as input + * (pass by value rather than passing a pointer). + * As the interface is currently implemented it is the responsibility + * of the application programmer to use the correct types. + * + * The NDB API will however check that the application sends + * a correct length to the interface as given in the length parameter. + * The passing of char* as the value can contain any type or + * any type of array. + * If length is not provided or set to zero, + * then the API will assume that the pointer + * is correct and not bother with checking it. + * + * @note There are 14 versions of NdbOperation::setValue with + * slightly different parameters. + * + * @param anAttrName Name (or Id) of attribute. + * @param aValue Attribute value to set. + * @param len Attribute length expressed in bytes. + * @return -1 if unsuccessful. + */ + virtual int setValue(const char* anAttrName, const char* aValue, + Uint32 len = 0); + virtual int setValue(const char* anAttrName, Int32 aValue); + virtual int setValue(const char* anAttrName, Uint32 aValue); + virtual int setValue(const char* anAttrName, Uint64 aValue); + virtual int setValue(const char* anAttrName, Int64 aValue); + virtual int setValue(const char* anAttrName, float aValue); + virtual int setValue(const char* anAttrName, double aValue); + + virtual int setValue(Uint32 anAttrId, const char* aValue, Uint32 len = 0); + virtual int setValue(Uint32 anAttrId, Int32 aValue); + virtual int setValue(Uint32 anAttrId, Uint32 aValue); + virtual int setValue(Uint32 anAttrId, Uint64 aValue); + virtual int setValue(Uint32 anAttrId, Int64 aValue); + virtual int setValue(Uint32 anAttrId, float aValue); + virtual int setValue(Uint32 anAttrId, double aValue); + + /** @} *********************************************************************/ + /** + * @name Specify Interpreted Program Instructions + * @{ + */ + + /** + * Interpreted program instruction: Add a value to an attribute. + * + * @note Destroys the contents of registers 6 and 7. + * (The instruction uses these registers for its operation.) + * + * @note There are four versions of NdbOperation::incValue with + * slightly different parameters. + * + * @param anAttrName Attribute name. + * @param aValue Value to add. + * @return -1 if unsuccessful. + */ + int incValue(const char* anAttrName, Uint32 aValue); + int incValue(const char* anAttrName, Uint64 aValue); + int incValue(Uint32 anAttrId, Uint32 aValue); + int incValue(Uint32 anAttrId, Uint64 aValue); + + /** + * Interpreted program instruction: + * Subtract a value from an attribute in an interpreted operation. + * + * @note Destroys the contents of registers 6 and 7. + * (The instruction uses these registers for its operation.) + * + * @note There are four versions of NdbOperation::subValue with + * slightly different parameters. + * + * @param anAttrName Attribute name. + * @param aValue Value to subtract. + * @return -1 if unsuccessful. + */ + int subValue(const char* anAttrName, Uint32 aValue); + int subValue(const char* anAttrName, Uint64 aValue); + int subValue(Uint32 anAttrId, Uint32 aValue); + int subValue(Uint32 anAttrId, Uint64 aValue); + + /** + * Interpreted program instruction: + * Define a jump label in an interpreted operation. + * + * @note The labels are automatically numbered starting with 0. + * The parameter used by NdbOperation::def_label should + * match the automatic numbering to make it easier to + * debug the interpreted program. + * + * @param labelNumber Label number. + * @return -1 if unsuccessful. + */ + int def_label(int labelNumber); + + /** + * Interpreted program instruction: + * Add two registers into a third. + * + * @param RegSource1 First register. + * @param RegSource2 Second register. + * @param RegDest Destination register where the result will be stored. + * @return -1 if unsuccessful. + */ + int add_reg(Uint32 RegSource1, Uint32 RegSource2, Uint32 RegDest); + + /** + * Interpreted program instruction: + * Substract RegSource1 from RegSource2 and put the result in RegDest. + * + * @param RegSource1 First register. + * @param RegSource2 Second register. + * @param RegDest Destination register where the result will be stored. + * @return -1 if unsuccessful. + */ + int sub_reg(Uint32 RegSource1, Uint32 RegSource2, Uint32 RegDest); + + /** + * Interpreted program instruction: + * Load a constant into a register. + * + * @param RegDest Destination register. + * @param Constant Value to load. + * @return -1 if unsuccessful. + */ + int load_const_u32(Uint32 RegDest, Uint32 Constant); + int load_const_u64(Uint32 RegDest, Uint64 Constant); + + /** + * Interpreted program instruction: + * Load NULL value into a register. + * + * @param RegDest Destination register. + * @return -1 if unsuccessful. + */ + int load_const_null(Uint32 RegDest); + + /** + * Interpreted program instruction: + * Read an attribute into a register. + * + * @param anAttrName Attribute name. + * @param RegDest Destination register. + * @return -1 if unsuccessful. + */ + int read_attr(const char* anAttrName, Uint32 RegDest); + + /** + * Interpreted program instruction: + * Write an attribute from a register. + * + * @param anAttrName Attribute name. + * @param RegSource Source register. + * @return -1 if unsuccessful. + */ + int write_attr(const char* anAttrName, Uint32 RegSource); + + /** + * Interpreted program instruction: + * Read an attribute into a register. + * + * @param anAttrId the attribute id. + * @param RegDest the destination register. + * @return -1 if unsuccessful. + */ + int read_attr(Uint32 anAttrId, Uint32 RegDest); + + /** + * Interpreted program instruction: + * Write an attribute from a register. + * + * @param anAttrId the attribute id. + * @param RegSource the source register. + * @return -1 if unsuccessful. + */ + int write_attr(Uint32 anAttrId, Uint32 RegSource); + + /** + * Interpreted program instruction: + * Define a search condition. Last two letters in the function name + * describes the search condition. + * The condition compares RegR with RegL and therefore appears + * to be reversed. + * + * - ge RegR >= RegL + * - gt RegR > RegL + * - le RegR <= RegL + * - lt RegR < RegL + * - eq RegR = RegL + * - ne RegR <> RegL + * + * @param RegLvalue left value. + * @param RegRvalue right value. + * @param Label the label to jump to. + * @return -1 if unsuccessful. + */ + int branch_ge(Uint32 RegLvalue, Uint32 RegRvalue, Uint32 Label); + int branch_gt(Uint32 RegLvalue, Uint32 RegRvalue, Uint32 Label); + int branch_le(Uint32 RegLvalue, Uint32 RegRvalue, Uint32 Label); + int branch_lt(Uint32 RegLvalue, Uint32 RegRvalue, Uint32 Label); + int branch_eq(Uint32 RegLvalue, Uint32 RegRvalue, Uint32 Label); + int branch_ne(Uint32 RegLvalue, Uint32 RegRvalue, Uint32 Label); + + /** + * Interpreted program instruction: + * Jump to Label if RegLvalue is not NULL. + * + * @param RegLvalue the value to check. + * @param Label the label to jump to. + * @return -1 if unsuccessful. + */ + int branch_ne_null(Uint32 RegLvalue, Uint32 Label); + + /** + * Interpreted program instruction: + * Jump to Label if RegLvalue is equal to NULL. + * + * @param RegLvalue Value to check. + * @param Label Label to jump to. + * @return -1 if unsuccessful. + */ + int branch_eq_null(Uint32 RegLvalue, Uint32 Label); + + /** + * Interpreted program instruction: + * Jump to Label. + * + * @param Label Label to jump to. + * @return -1 if unsuccessful. + */ + int branch_label(Uint32 Label); + + /** + * Interpreted program instruction: branch after memcmp + * @param ColId Column to check + * @param Label Label to jump to + * @return -1 if unsuccessful + */ + int branch_col_eq_null(Uint32 ColId, Uint32 Label); + int branch_col_ne_null(Uint32 ColId, Uint32 Label); + + /** + * Interpreted program instruction: branch after memcmp + * @param ColId column to check + * @param val search value + * @param len length of search value + * @param nopad force non-padded comparison for a Char column + * @param Label label to jump to + * @return -1 if unsuccessful + */ + int branch_col_eq(Uint32 ColId, const char * val, Uint32 len, + bool nopad, Uint32 Label); + int branch_col_ne(Uint32 ColId, const char * val, Uint32 len, + bool nopad, Uint32 Label); + int branch_col_lt(Uint32 ColId, const char * val, Uint32 len, + bool nopad, Uint32 Label); + int branch_col_le(Uint32 ColId, const char * val, Uint32 len, + bool nopad, Uint32 Label); + int branch_col_gt(Uint32 ColId, const char * val, Uint32 len, + bool nopad, Uint32 Label); + int branch_col_ge(Uint32 ColId, const char * val, Uint32 len, + bool nopad, Uint32 Label); + int branch_col_like(Uint32 ColId, const char *, Uint32 len, + bool nopad, Uint32 Label); + int branch_col_notlike(Uint32 ColId, const char *, Uint32 len, + bool nopad, Uint32 Label); + + /** + * Interpreted program instruction: Exit with Ok + * + * For scanning transactions, + * end interpreted operation and return the row to the application. + * + * For non-scanning transactions, + * exit interpreted program. + * + * @return -1 if unsuccessful. + */ + int interpret_exit_ok(); + + /** + * Interpreted program instruction: Exit with Not Ok + * + * For scanning transactions, + * continue with the next row without returning the current row. + * + * For non-scanning transactions, + * abort the whole transaction. + * + * @note A method also exists without the error parameter. + * + * @param ErrorCode An error code given by the application programmer. + * @return -1 if unsuccessful. + */ + int interpret_exit_nok(Uint32 ErrorCode); + int interpret_exit_nok(); + + /** + * Interpreted program instruction: + * Define a subroutine in an interpreted operation. + * + * @param SubroutineNumber the subroutine number. + * @return -1 if unsuccessful. + */ + int def_subroutine(int SubroutineNumber); + + /** + * Interpreted program instruction: + * Call a subroutine. + * + * @param Subroutine the subroutine to call. + * @return -1 if unsuccessful. + */ + int call_sub(Uint32 Subroutine); + + /** + * Interpreted program instruction: + * End a subroutine. + * + * @return -1 if unsuccessful. + */ + int ret_sub(); + + /** @} *********************************************************************/ + + /** + * @name Error Handling + * @{ + */ + + /** + * Get the latest error code. + * + * @return error code. + */ + const NdbError & getNdbError() const; + + /** + * Get the method number where the error occured. + * + * @return method number where the error occured. + */ + int getNdbErrorLine(); + + /** @} *********************************************************************/ + +protected: +/****************************************************************************** + * These are the methods used to create and delete the NdbOperation objects. + *****************************************************************************/ + NdbOperation(Ndb* aNdb); + virtual ~NdbOperation(); + + bool needReply(); +/****************************************************************************** + * These methods are service routines used by the other NDB API classes. + *****************************************************************************/ +//-------------------------------------------------------------- +// Initialise after allocating operation to a transaction +//-------------------------------------------------------------- + int init(class NdbTableImpl*, NdbConnection* aCon); + + void initScan(); // Initialise after allocating operation + // to a scan transaction + virtual void releaseScan(); // Release scan parts of transaction + void releaseSignals(); + void releaseScanSignals(); + void prepareNextScanResult(); + + // Common part for Read and Exclusive + int openScan(Uint32 aParallelism, bool, bool, bool); + + void next(NdbOperation*); // Set next pointer + + NdbOperation* next(); // Get next pointer + + OperationStatus Status(); // Read the status information + + void Status(OperationStatus); // Set the status information + + OperationType RequestType(); + + void NdbCon(NdbConnection*); // Set reference to connection + // object. + + virtual void release(); // Release all operations + // connected to + // the operations object. + void setStartIndicator(); + + void setCommitIndicator(CommitType aCommitType); + +/****************************************************************************** + * The methods below is the execution part of the NdbOperation + * class. This is where the NDB signals are sent and received. The + * operation can send TC[KEY/INDX]REQ, [INDX]ATTRINFO. + * It can receive TC[KEY/INDX]CONF, TC[KEY/INDX]REF, [INDX]ATTRINFO. + * When an operation is received in its fulness or a refuse message + * was sent, then the connection object is told about this situation. + *****************************************************************************/ + + int doSend(int ProcessorId, Uint32 lastFlag); + int doSendScan(int ProcessorId); + + int prepareSendScan(Uint32 TC_ConnectPtr, + Uint64 TransactionId); + + virtual int prepareSend(Uint32 TC_ConnectPtr, + Uint64 TransactionId); + virtual void setLastFlag(NdbApiSignal* signal, Uint32 lastFlag); + + int prepareSendInterpreted(); // Help routine to prepare* + + void TCOPCONF(Uint32 anNdbColumnImplLen); // Handle TC[KEY/INDX]CONF signal + + int receiveTCKEYREF(NdbApiSignal*); + + + int receiveTRANSID_AI(const Uint32* aDataPtr, Uint32 aDataLength); + int receiveREAD_CONF(const Uint32* aDataPtr, Uint32 aDataLength); + + + int checkMagicNumber(); // Verify correct object + + int checkState_TransId(NdbApiSignal* aSignal); + +/****************************************************************************** + * These are support methods only used locally in this class. +******************************************************************************/ + + virtual int equal_impl(const NdbColumnImpl* anAttrObject, + const char* aValue, + Uint32 len); + NdbRecAttr* getValue(const NdbColumnImpl* anAttrObject, char* aValue = NULL); + int setValue(const NdbColumnImpl* anAttrObject, const char* aValue, Uint32 len); + int incValue(const NdbColumnImpl* anAttrObject, Uint32 aValue); + int incValue(const NdbColumnImpl* anAttrObject, Uint64 aValue); + int subValue(const NdbColumnImpl* anAttrObject, Uint32 aValue); + int subValue(const NdbColumnImpl* anAttrObject, Uint64 aValue); + int read_attr(const NdbColumnImpl* anAttrObject, Uint32 RegDest); + int write_attr(const NdbColumnImpl* anAttrObject, Uint32 RegSource); + int branch_reg_reg(Uint32 type, Uint32, Uint32, Uint32); + int branch_col(Uint32 type, Uint32, const char *, Uint32, bool, Uint32 Label); + int branch_col_null(Uint32 type, Uint32 col, Uint32 Label); + int setBound(const NdbColumnImpl* anAttrObject, int type, const void* aValue, Uint32 len); + + // Handle ATTRINFO signals + int receiveREAD_AI(Uint32* aDataPtr, Uint32 aLength); + + int insertATTRINFO(Uint32 aData); + int insertATTRINFOloop(const Uint32* aDataPtr, Uint32 aLength); + int getFirstATTRINFOScan(); + int saveBoundATTRINFO(); + + int insertKEYINFO(const char* aValue, + Uint32 aStartPosition, + Uint32 aKeyLenInByte, + Uint32 anAttrBitsInLastWord); + + virtual void setErrorCode(int aErrorCode); + virtual void setErrorCodeAbort(int aErrorCode); + + void handleFailedAI_ElemLen(); // When not all attribute data + // were received + + int incCheck(const NdbColumnImpl* anAttrObject); + int initial_interpreterCheck(); + int intermediate_interpreterCheck(); + int read_attrCheck(const NdbColumnImpl* anAttrObject); + int write_attrCheck(const NdbColumnImpl* anAttrObject); + int labelCheck(); + int insertCall(Uint32 aCall); + int insertBranch(Uint32 aBranch); + + Uint32 ptr2int() { return theReceiver.getId(); }; + + NdbOperation* + takeOverScanOp(OperationType opType, NdbConnection* updateTrans); + +/****************************************************************************** + * These are the private variables that are defined in the operation objects. + *****************************************************************************/ + + NdbReceiver theReceiver; + + NdbError theError; // Errorcode + int theErrorLine; // Error line + + Ndb* theNdb; // Point back to the Ndb object. + NdbConnection* theNdbCon; // Point back to the connection object. + NdbOperation* theNext; // Next pointer to operation. + NdbOperation* theNextScanOp; + NdbApiSignal* theTCREQ; // The TC[KEY/INDX]REQ signal object + NdbApiSignal* theFirstATTRINFO; // The first ATTRINFO signal object + NdbApiSignal* theCurrentATTRINFO; // The current ATTRINFO signal object + Uint32 theTotalCurrAI_Len; // The total number of attribute info + // words currently defined + Uint32 theAI_LenInCurrAI; // The number of words defined in the + // current ATTRINFO signal + NdbApiSignal* theFirstKEYINFO; // The first KEYINFO signal object + NdbApiSignal* theLastKEYINFO; // The first KEYINFO signal object + + NdbRecAttr* theFirstRecAttr; // The first receive attribute object + NdbRecAttr* theCurrentRecAttr; // The current receive attribute object + + class NdbLabel* theFirstLabel; + class NdbLabel* theLastLabel; + class NdbBranch* theFirstBranch; + class NdbBranch* theLastBranch; + class NdbCall* theFirstCall; + class NdbCall* theLastCall; + class NdbSubroutine* theFirstSubroutine; + class NdbSubroutine* theLastSubroutine; + Uint32 theNoOfLabels; + Uint32 theNoOfSubroutines; + + Uint32* theKEYINFOptr; // Pointer to where to write KEYINFO + Uint32* theATTRINFOptr; // Pointer to where to write ATTRINFO + + Uint32 theTotalRecAI_Len; // The total length received according + // to the TCKEYCONF signal + Uint32 theCurrRecAI_Len; // The currently received length + Uint32 theAI_ElementLen; // How many words long is this element + Uint32* theCurrElemPtr; // The current pointer to the element + //Uint32 theTableId; // Table id. + //Uint32 theAccessTableId; // The id of table for initial access, + // changed by NdbIndexOperation + //Uint32 theSchemaVersion; // The schema version on the table. + class NdbTableImpl* m_currentTable; // The current table + class NdbTableImpl* m_accessTable; + + // Set to TRUE when a tuple key attribute has been defined. + // A tuple key is allowed to consist of 64 attributes. + Uint32 theTupleKeyDefined[MAXNROFTUPLEKEY][3]; + + Uint32 theTotalNrOfKeyWordInSignal; // The total number of + // keyword in signal. + + Uint32 theTupKeyLen; // Length of the tuple key in words + Uint32 theNoOfTupKeyDefined; // The number of tuple key attributes + // currently defined + OperationType theOperationType; // Read Request, Update Req...... + + Uint8 theLockMode; // Can be set to WRITE if read operation + OperationStatus theStatus; // The status of the operation. + Uint32 theMagicNumber; // Magic number to verify that object + // is correct + Uint32 theScanInfo; // Scan info bits (take over flag etc) + Uint32 theDistrKeySize; // Distribution Key size if used + Uint32 theDistributionGroup; // Distribution Group if used + + Uint32 theSubroutineSize; // Size of subroutines for interpretation + Uint32 theInitialReadSize; // Size of initial reads for interpretation + Uint32 theInterpretedSize; // Size of interpretation + Uint32 theFinalUpdateSize; // Size of final updates for interpretation + Uint32 theFinalReadSize; // Size of final reads for interpretation + + Uint8 theStartIndicator; // Indicator of whether start operation + Uint8 theCommitIndicator; // Indicator of whether commit operation + Uint8 theSimpleIndicator; // Indicator of whether simple operation + Uint8 theDirtyIndicator; // Indicator of whether dirty operation + Uint8 theInterpretIndicator; // Indicator of whether interpreted operation + Uint8 theDistrGroupIndicator; // Indicates whether distribution grp is used + Uint8 theDistrGroupType; // Type of distribution group used + Uint8 theDistrKeyIndicator; // Indicates whether distr. key is used + + Uint16 m_tcReqGSN; + Uint16 m_keyInfoGSN; + Uint16 m_attrInfoGSN; + + // Scan related variables + Uint32 theParallelism; + NdbScanReceiver** theScanReceiversArray; + NdbApiSignal* theSCAN_TABREQ; + NdbApiSignal* theFirstSCAN_TABINFO_Send; + NdbApiSignal* theLastSCAN_TABINFO_Send; + NdbApiSignal* theFirstSCAN_TABINFO_Recv; + NdbApiSignal* theLastSCAN_TABINFO_Recv; + NdbApiSignal* theSCAN_TABCONF_Recv; + // saveBoundATTRINFO() moves ATTRINFO here when setBound() is ready + NdbApiSignal* theBoundATTRINFO; + Uint32 theTotalBoundAI_Len; + +}; + +inline +int +NdbOperation::checkMagicNumber() +{ + if (theMagicNumber != 0xABCDEF01){ +#ifdef NDB_NO_DROPPED_SIGNAL + abort(); +#endif + return -1; + } + return 0; +} + +inline +void +NdbOperation::setStartIndicator() +{ + theStartIndicator = 1; +} + +#if 0 +inline +void +NdbOperation::setCommitIndicator(CommitType aTypeOfCommit) +{ + theCommitIndicator = 1; + theCommitType = (Uint8)aTypeOfCommit; +} +#endif + +inline +int +NdbOperation::getNdbErrorLine() +{ + return theErrorLine; +} + +/****************************************************************************** +void next(NdbOperation* aNdbOperation); + +Parameters: aNdbOperation: Pointers to the NdbOperation object. +Remark: Set the next variable of the operation object. +******************************************************************************/ +inline +void +NdbOperation::next(NdbOperation* aNdbOperation) +{ + theNext = aNdbOperation; +} + +/****************************************************************************** +NdbOperation* next(); + +Return Value: Return next pointer to NdbOperation object. +Remark: Get the next variable of the operation object. +******************************************************************************/ +inline +NdbOperation* +NdbOperation::next() +{ + return theNext; +} + +/****************************************************************************** +OperationStatus Status(); + +Return Value Return the OperationStatus. +Parameters: aStatus: The status. +Remark: Sets Operation status. +******************************************************************************/ +inline +OperationStatus +NdbOperation::Status() +{ + return theStatus; +} + +/****************************************************************************** +void Status(OperationStatus aStatus); + +Parameters: aStatus: The status. +Remark: Sets Operation + status. +******************************************************************************/ +inline +void +NdbOperation::Status( OperationStatus aStatus ) +{ + theStatus = aStatus; +} + +/****************************************************************************** +void NdbCon(NdbConnection* aNdbCon); + +Parameters: aNdbCon: Pointers to NdbConnection object. +Remark: Set the reference to the connection in the operation object. +******************************************************************************/ +inline +void +NdbOperation::NdbCon(NdbConnection* aNdbCon) +{ + theNdbCon = aNdbCon; +} + +/****************************************************************************** +OperationType RequestType(); + +Remark: Return the request typ of the operation.. +******************************************************************************/ +inline +OperationType +NdbOperation::RequestType() +{ + return theOperationType; +} + +inline +int +NdbOperation::equal(const char* anAttrName, Int32 aPar) +{ + return equal(anAttrName, (const char*)&aPar, (Uint32)4); +} + +inline +int +NdbOperation::equal(const char* anAttrName, Uint32 aPar) +{ + return equal(anAttrName, (const char*)&aPar, (Uint32)4); +} + +inline +int +NdbOperation::equal(const char* anAttrName, Int64 aPar) +{ + return equal(anAttrName, (const char*)&aPar, (Uint32)8); +} + +inline +int +NdbOperation::equal(const char* anAttrName, Uint64 aPar) +{ + return equal(anAttrName, (const char*)&aPar, (Uint32)8); +} + +inline +int +NdbOperation::equal(Uint32 anAttrId, Int32 aPar) +{ + return equal(anAttrId, (const char*)&aPar, (Uint32)4); +} + +inline +int +NdbOperation::equal(Uint32 anAttrId, Uint32 aPar) +{ + return equal(anAttrId, (const char*)&aPar, (Uint32)4); +} + +inline +int +NdbOperation::equal(Uint32 anAttrId, Int64 aPar) +{ + return equal(anAttrId, (const char*)&aPar, (Uint32)8); +} + +inline +int +NdbOperation::equal(Uint32 anAttrId, Uint64 aPar) +{ + return equal(anAttrId, (const char*)&aPar, (Uint32)8); +} + +inline +int +NdbOperation::setValue(const char* anAttrName, Int32 aPar) +{ + return setValue(anAttrName, (const char*)&aPar, (Uint32)4); +} + +inline +int +NdbOperation::setValue(const char* anAttrName, Uint32 aPar) +{ + return setValue(anAttrName, (const char*)&aPar, (Uint32)4); +} + +inline +int +NdbOperation::setValue(const char* anAttrName, Int64 aPar) +{ + return setValue(anAttrName, (const char*)&aPar, (Uint32)8); +} + +inline +int +NdbOperation::setValue(const char* anAttrName, Uint64 aPar) +{ + return setValue(anAttrName, (const char*)&aPar, (Uint32)8); +} + +inline +int +NdbOperation::setValue(const char* anAttrName, float aPar) +{ + return setValue(anAttrName, (const char*)&aPar, (Uint32)4); +} + +inline +int +NdbOperation::setValue(const char* anAttrName, double aPar) +{ + return setValue(anAttrName, (const char*)&aPar, (Uint32)8); +} + +inline +int +NdbOperation::setValue(Uint32 anAttrId, Int32 aPar) +{ + return setValue(anAttrId, (const char*)&aPar, (Uint32)4); +} + +inline +int +NdbOperation::setValue(Uint32 anAttrId, Uint32 aPar) +{ + return setValue(anAttrId, (const char*)&aPar, (Uint32)4); +} + +inline +int +NdbOperation::setValue(Uint32 anAttrId, Int64 aPar) +{ + return setValue(anAttrId, (const char*)&aPar, (Uint32)8); +} + +inline +int +NdbOperation::setValue(Uint32 anAttrId, Uint64 aPar) +{ + return setValue(anAttrId, (const char*)&aPar, (Uint32)8); +} + +inline +int +NdbOperation::setValue(Uint32 anAttrId, float aPar) +{ + return setValue(anAttrId, (char*)&aPar, (Uint32)4); +} + +inline +int +NdbOperation::setValue(Uint32 anAttrId, double aPar) +{ + return setValue(anAttrId, (const char*)&aPar, (Uint32)8); +} + +#endif + + diff --git a/ndb/include/ndbapi/NdbPool.hpp b/ndb/include/ndbapi/NdbPool.hpp new file mode 100644 index 00000000000..64cba5a008c --- /dev/null +++ b/ndb/include/ndbapi/NdbPool.hpp @@ -0,0 +1,35 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +class Ndb; +class NdbPool; + +bool +create_instance(Uint32 max_ndb_objects, + Uint32 no_conn_obj, + Uint32 init_no_ndb_objects); + +void +drop_instance(); + +Ndb* +get_ndb_object(Uint32 &hint_id, + const char* a_catalog_name, + const char* a_schema_name); + +void +return_ndb_object(Ndb* returned_object, Uint32 id); + diff --git a/ndb/include/ndbapi/NdbRecAttr.hpp b/ndb/include/ndbapi/NdbRecAttr.hpp new file mode 100644 index 00000000000..a5595096bf6 --- /dev/null +++ b/ndb/include/ndbapi/NdbRecAttr.hpp @@ -0,0 +1,512 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NdbRecAttr_H +#define NdbRecAttr_H + +#include + +#include +#include +#include "AttrType.hpp" + +class NdbOperation; +class AttrInfo; + +/** + * @class NdbRecAttr + * @brief Contains value of an attribute. + * + * NdbRecAttr objects are used to store the attribute value + * after retrieving the value from the NDB Cluster using the method + * NdbOperation::getValue. The objects are allocated by the NDB API. + * An example application program follows: + * + * @code + * MyRecAttr = MyOperation->getValue("ATTR2", NULL); + * if (MyRecAttr == NULL) goto error; + * + * if (MyConnection->execute(Commit) == -1) goto error; + * + * ndbout << MyRecAttr->u_32_value(); + * @endcode + * For more examples, see + * @ref ndbapi_example1.cpp and + * @ref ndbapi_example2.cpp. + * + * @note The NdbRecAttr object is instantiated with its value when + * NdbConnection::execute is called. Before this, the value is + * undefined. (NdbRecAttr::isNULL can be used to check + * if the value is defined or not.) + * This means that an NdbRecAttr object only has valid information + * between the time of calling NdbConnection::execute and + * the time of Ndb::closeTransaction. + * The value of the null indicator is -1 until the + * NdbConnection::execute method have been called. + * + * For simple types, there are methods which directly getting the value + * from the NdbRecAttr object. + * + * To get a reference to the value, there are two methods: + * NdbRecAttr::aRef (memory is released by NDB API) and + * NdbRecAttr::getAttributeObject (memory must be released + * by application program). + * The two methods may return different pointers. + * + * There are also methods to check attribute type, attribute size and + * array size. + * The method NdbRecAttr::arraySize returns the number of elements in the + * array (where each element is of size given by NdbRecAttr::attrSize). + * The NdbRecAttr::arraySize method is needed when reading variable-sized + * attributes. + * + * @note Variable-sized attributes are not yet supported. + */ +class NdbRecAttr +{ + friend class NdbOperation; + friend class NdbEventOperationImpl; + friend class NdbScanReceiver; + friend class Ndb; + +public: + /** + * @name Getting meta information + * @{ + */ + const NdbDictionary::Column * getColumn() const; + + /** + * Get attribute type. + * + * @return Type of attribute: { Signed, UnSigned, Float, String } + */ + AttrType attrType() const ; + NdbDictionary::Column::Type getType() const; + + /** + * Get attribute (element) size in bytes. + * + * @note For arrays, the method only gives the size of an element. + * The total attribute size is calculated by + * multiplying this value with the value + * returned by NdbRecAttr::arraySize. + * + * @return Attribute size in 32 bit unsigned int. + */ + Uint32 attrSize() const ; + + /** + * Get array size of attribute. + * For variable-sized arrays this method returns the + * size of the attribute read. + * + * @return array size in 32 unsigned int. + */ + Uint32 arraySize() const ; + Uint32 getLength() const ; + + /** @} *********************************************************************/ + /** + * @name Getting stored value + * @{ + */ + + /** + * Check if attribute value is NULL. + * + * @return -1 = Not defined (Failure or + * NdbConnection::execute not yet called).
+ * 0 = Attribute value is defined, but not equal to NULL.
+ * 1 = Attribute value is defined and equal to NULL. + */ + int isNULL() const; + + /** + * Get value stored in NdbRecAttr object. + * + * @return 64 bit long value. + */ + Int64 int64_value() const; + + /** + * Get value stored in NdbRecAttr object. + * + * @return 32 bit int value. + */ + Int32 int32_value() const; + + /** + * Get value stored in NdbRecAttr object. + * + * @return Short value. + */ + short short_value() const; + + /** + * Get value stored in NdbRecAttr object. + * + * @return Char value. + */ + char char_value() const; + + /** + * Get value stored in NdbRecAttr object. + * + * @return 64 bit unsigned value. + */ + Uint64 u_64_value() const; + + /** + * Get value stored in NdbRecAttr object. + * + * @return 32 bit unsigned value. + */ + Uint32 u_32_value() const; + + /** + * Get value stored in NdbRecAttr object. + * + * @return Unsigned short value. + */ + Uint16 u_short_value() const; + + /** + * Get value stored in NdbRecAttr object. + * + * @return Unsigned char value. + */ + Uint8 u_char_value() const; + + /** + * Get value stored in NdbRecAttr object. + * + * @return Float value. + */ + float float_value() const; + + /** + * Get value stored in NdbRecAttr object. + * + * @return Double value. + */ + double double_value() const; + + /** @} *********************************************************************/ + /** + * @name Getting reference to stored value + * @{ + */ + + /** + * Get reference to attribute value. + * + * Returns a char*-pointer to the value. + * The pointer is aligned appropriately for the data type. + * The memory is released when Ndb::closeTransaction is executed + * for the transaction which read the value. + * + * @note The memory is released by NDB API. + * + * @note The pointer to the attribute value stored in an NdbRecAttr + * object (i.e. the pointer returned by aRef) is constant. + * This means that this method can be called anytime after + * NdbOperation::getValue has been called. + * + * @return Pointer to attribute value. + */ + char* aRef() const; + + /** @} *********************************************************************/ + + /** + * Make a copy of RecAttr object including all data. + * + * @note Copy needs to be deleted by application program. + */ + NdbRecAttr * clone() const; + + /** + * Destructor + * + * @note You should only delete RecAttr-copies, + * i.e. objects that has been cloned. + */ + ~NdbRecAttr(); +private: + NdbRecAttr(); + + Uint32 attrId() const; /* Get attribute id */ + void setNULL(); /* Set NULL indicator */ + void setNotNULL(); /* Set Not NULL indicator */ + void setUNDEFINED(); /* Set UNDEFINED indicator */ + + void release(); /* Release memory if allocated */ + void init(); /* Initialise object when allocated */ + + void next(NdbRecAttr* aRecAttr); + NdbRecAttr* next() const; + + int setup(const class NdbColumnImpl* anAttrInfo, char* aValue); + /* Set up attributes and buffers */ + bool copyoutRequired() const; /* Need to copy data to application */ + void copyout(); /* Copy from storage to application */ + + Uint64 theStorage[4]; /* The data storage here if <= 32 bytes */ + Uint64* theStorageX; /* The data storage here if > 32 bytes */ + char* theValue; /* The data storage in the application */ + void* theRef; /* Pointer to one of above */ + + NdbRecAttr* theNext; /* Next pointer */ + Uint32 theAttrId; /* The attribute id */ + + int theNULLind; + Uint32 theAttrSize; + Uint32 theArraySize; + const NdbDictionary::Column* m_column; +}; + +inline +NdbDictionary::Column::Type +NdbRecAttr::getType() const { + return m_column->getType(); +} + +inline +const NdbDictionary::Column * +NdbRecAttr::getColumn() const { + return m_column; +} + +inline +Uint32 +NdbRecAttr::attrSize() const { + + switch(getType()){ + case NdbDictionary::Column::Int: + case NdbDictionary::Column::Unsigned: + case NdbDictionary::Column::Float: + return 4; + case NdbDictionary::Column::Decimal: + case NdbDictionary::Column::Char: + case NdbDictionary::Column::Varchar: + case NdbDictionary::Column::Binary: + case NdbDictionary::Column::Varbinary: + return 1; + case NdbDictionary::Column::Bigint: + case NdbDictionary::Column::Bigunsigned: + case NdbDictionary::Column::Double: + case NdbDictionary::Column::Datetime: + return 8; + case NdbDictionary::Column::Timespec: + return 12; + case NdbDictionary::Column::Undefined: + default: + return 0; + } +} + +inline +AttrType +NdbRecAttr::attrType() const { + switch(getType()){ + case NdbDictionary::Column::Bigint: + case NdbDictionary::Column::Int: + return Signed; + case NdbDictionary::Column::Bigunsigned: + case NdbDictionary::Column::Unsigned: + return UnSigned; + case NdbDictionary::Column::Float: + case NdbDictionary::Column::Decimal: + case NdbDictionary::Column::Double: + return Float; + case NdbDictionary::Column::Char: + case NdbDictionary::Column::Varchar: + case NdbDictionary::Column::Binary: + case NdbDictionary::Column::Varbinary: + return String; + case NdbDictionary::Column::Datetime: + case NdbDictionary::Column::Timespec: + case NdbDictionary::Column::Undefined: + default: + return NoAttrTypeDef; + } +} + +inline +Uint32 +NdbRecAttr::arraySize() const +{ + return theArraySize; +} + +inline +Int64 +NdbRecAttr::int64_value() const +{ + return *(Int64*)theRef; +} + +inline +Int32 +NdbRecAttr::int32_value() const +{ + return *(Int32*)theRef; +} + +inline +short +NdbRecAttr::short_value() const +{ + return *(short*)theRef; +} + +inline +char +NdbRecAttr::char_value() const +{ + return *(char*)theRef; +} + +inline +Uint64 +NdbRecAttr::u_64_value() const +{ + return *(Uint64*)theRef; +} + +inline +Uint32 +NdbRecAttr::u_32_value() const +{ + return *(Uint32*)theRef; +} + +inline +Uint16 +NdbRecAttr::u_short_value() const +{ + return *(Uint16*)theRef; +} + +inline +Uint8 +NdbRecAttr::u_char_value() const +{ + return *(Uint8*)theRef; +} + +inline +float +NdbRecAttr::float_value() const +{ + return *(float*)theRef; +} + +inline +double +NdbRecAttr::double_value() const +{ + return *(double*)theRef; +} + +inline +void +NdbRecAttr::release() +{ + if (theStorageX != NULL) { + delete [] theStorageX; + theStorageX = NULL; + } +} + +inline +void +NdbRecAttr::init() +{ + theStorageX = NULL; + theValue = NULL; + theRef = NULL; + theNext = NULL; + theAttrId = 0xFFFF; + theNULLind = -1; +} + +inline +void +NdbRecAttr::next(NdbRecAttr* aRecAttr) +{ + theNext = aRecAttr; +} + +inline +NdbRecAttr* +NdbRecAttr::next() const +{ + return theNext; +} + +inline +char* +NdbRecAttr::aRef() const +{ + return (char*)theRef; +} + +inline +bool +NdbRecAttr::copyoutRequired() const +{ + return theRef != theValue && theValue != NULL; +} + +inline +Uint32 +NdbRecAttr::attrId() const +{ + return theAttrId; +} + +inline +void +NdbRecAttr::setNULL() +{ + theNULLind = 1; +} + +inline +void +NdbRecAttr::setNotNULL() +{ + theNULLind = 0; +} + +inline +void +NdbRecAttr::setUNDEFINED() +{ + theNULLind = -1; +} + +inline +int +NdbRecAttr::isNULL() const +{ + return theNULLind; +} + +#endif + diff --git a/ndb/include/ndbapi/NdbReceiver.hpp b/ndb/include/ndbapi/NdbReceiver.hpp new file mode 100644 index 00000000000..952803f8e70 --- /dev/null +++ b/ndb/include/ndbapi/NdbReceiver.hpp @@ -0,0 +1,72 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NdbReceiver_H +#define NdbReceiver_H +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL // Not part of public interface + +#include + +class Ndb; +class NdbReceiver +{ +public: + enum ReceiverType { NDB_UNINITIALIZED, + NDB_OPERATION = 1, + NDB_SCANRECEIVER = 2, + NDB_INDEX_OPERATION = 3 + }; + + NdbReceiver(Ndb *aNdb); + void init(ReceiverType type, void* owner); + ~NdbReceiver(); + + Uint32 getId(){ + return m_id; + } + + ReceiverType getType(){ + return m_type; + } + + void* getOwner(){ + return m_owner; + } + + bool checkMagicNumber() const; + +private: + Uint32 theMagicNumber; + Ndb* m_ndb; + Uint32 m_id; + ReceiverType m_type; + void* m_owner; +}; + +inline +bool +NdbReceiver::checkMagicNumber() const { + bool retVal = (theMagicNumber == 0x11223344); +#ifdef NDB_NO_DROPPED_SIGNAL + if(!retVal){ + abort(); + } +#endif + return retVal; +} + +#endif +#endif diff --git a/ndb/include/ndbapi/NdbResultSet.hpp b/ndb/include/ndbapi/NdbResultSet.hpp new file mode 100644 index 00000000000..d48df01214e --- /dev/null +++ b/ndb/include/ndbapi/NdbResultSet.hpp @@ -0,0 +1,114 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/***************************************************************************** + * Name: NdbResultSet.hpp + * Include: + * Link: + * Author: Martin Sköld + * Date: 2002-04-01 + * Version: 0.1 + * Description: Cursor class + * Documentation: + * Adjust: 2002-04-01 Martin Sköld First version. + ****************************************************************************/ + +#ifndef NdbResultSet_H +#define NdbResultSet_H + + +#include +#include +#include + +/** + * @class NdbResultSet + * @brief NdbResultSet contains a NdbCursorOperation. + */ +class NdbResultSet +{ + friend class NdbCursorOperation; + +public: + + /** + * Get the next tuple in a scan transaction. + * + * After each call to NdbResult::nextResult + * the buffers and NdbRecAttr objects defined in + * NdbOperation::getValue are updated with values + * from the scanned tuple. + * + * @param fetchAllowed If set to false, then fetching is disabled + * + * The NDB API will contact the NDB Kernel for more tuples + * when necessary to do so unless you set the fetchAllowed + * to false. + * This will force NDB to process any records it + * already has in it's caches. When there are no more cached + * records it will return 2. You must then call nextResult + * with fetchAllowed = true in order to contact NDB for more + * records. + * + * fetchAllowed = false is useful when you want to update or + * delete all the records fetched in one transaction(This will save a + * lot of round trip time and make updates or deletes of scanned + * records a lot faster). + * While nextResult(false) + * returns 0 take over the record to another transaction. When + * nextResult(false) returns 2 you must execute and commit the other + * transaction. This will cause the locks to be transferred to the + * other transaction, updates or deletes will be made and then the + * locks will be released. + * After that, call nextResult(true) which will fetch new records and + * cache them in the NdbApi. + * + * @note If you don't take over the records to another transaction the + * locks on those records will be released the next time NDB Kernel + * is contacted for more records. + * + * @note Please contact for examples of efficient scan + * updates and deletes. + * + * @note See ndb/examples/ndbapi_scan_example for usage. + * + * @return + * - -1: if unsuccessful,
+ * - 0: if another tuple was received, and
+ * - 1: if there are no more tuples to scan. + * - 2: if there are no more cached records in NdbApi + */ + int nextResult(bool fetchAllowed = true); + + void close(); + + NdbOperation* updateTuple(); + NdbOperation* updateTuple(NdbConnection* takeOverTransaction); + + int deleteTuple(); + int deleteTuple(NdbConnection* takeOverTransaction); + +private: + NdbResultSet(NdbCursorOperation*); + + ~NdbResultSet(); + + void init(); + + NdbCursorOperation* m_operation; +}; + +#endif diff --git a/ndb/include/ndbapi/NdbScanFilter.hpp b/ndb/include/ndbapi/NdbScanFilter.hpp new file mode 100644 index 00000000000..9f8a01b1059 --- /dev/null +++ b/ndb/include/ndbapi/NdbScanFilter.hpp @@ -0,0 +1,177 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_SCAN_FILTER_HPP +#define NDB_SCAN_FILTER_HPP + +#include + +/** + * @class NdbScanFilter + * @brief A simple way to specify filters for scan operations + * + * @note This filter interface is under development and may change in + * the future! + * + */ +class NdbScanFilter { +public: + /** + * Constructor + * @param op The NdbOperation that the filter belongs to (is applied to). + */ + NdbScanFilter(class NdbOperation * op); + ~NdbScanFilter(); + + /** + * Group operators + */ + enum Group { + AND = 1, ///< (x1 AND x2 AND x3) + OR = 2, ///< (x1 OR x2 OR X3) + NAND = 3, ///< NOT (x1 AND x2 AND x3) + NOR = 4 ///< NOT (x1 OR x2 OR x3) + }; + + /** + * @name Grouping + * @{ + */ + + /** + * Begin of compound. + * ®return 0 if successful, -1 otherwize + */ + int begin(Group group = AND); + + /** + * End of compound. + * ®return 0 if successful, -1 otherwize + */ + int end(); + + /** @} *********************************************************************/ + + /** + * Explanation missing + */ + int istrue(); + + /** + * Explanation missing + */ + int isfalse(); + + /** + * @name Integer Comparators + * @{ + */ + /** Compare column value with integer for equal + * ®return 0 if successful, -1 otherwize + */ + int eq(int ColId, Uint32 value); + /** Compare column value with integer for not equal. + * ®return 0 if successful, -1 otherwize + */ + int ne(int ColId, Uint32 value); + /** Compare column value with integer for less than. + * ®return 0 if successful, -1 otherwize + */ + int lt(int ColId, Uint32 value); + /** Compare column value with integer for less than or equal. + * ®return 0 if successful, -1 otherwize + */ + int le(int ColId, Uint32 value); + /** Compare column value with integer for greater than. + * ®return 0 if successful, -1 otherwize + */ + int gt(int ColId, Uint32 value); + /** Compare column value with integer for greater than or equal. + * ®return 0 if successful, -1 otherwize + */ + int ge(int ColId, Uint32 value); + + /** Compare column value with integer for equal. 64-bit. + * ®return 0 if successful, -1 otherwize + */ + int eq(int ColId, Uint64 value); + /** Compare column value with integer for not equal. 64-bit. + * ®return 0 if successful, -1 otherwize + */ + int ne(int ColId, Uint64 value); + /** Compare column value with integer for less than. 64-bit. + * ®return 0 if successful, -1 otherwize + */ + int lt(int ColId, Uint64 value); + /** Compare column value with integer for less than or equal. 64-bit. + * ®return 0 if successful, -1 otherwize + */ + int le(int ColId, Uint64 value); + /** Compare column value with integer for greater than. 64-bit. + * ®return 0 if successful, -1 otherwize + */ + int gt(int ColId, Uint64 value); + /** Compare column value with integer for greater than or equal. 64-bit. + * ®return 0 if successful, -1 otherwize + */ + int ge(int ColId, Uint64 value); + /** @} *********************************************************************/ + + /** Check if column value is NULL */ + int isnull(int ColId); + /** Check if column value is non-NULL */ + int isnotnull(int ColId); + + /** + * @name String Comparators + * @{ + */ + /** + * Compare string against a Char or Varchar column. + * + * By default Char comparison blank-pads both sides to common length. + * Varchar comparison does not blank-pad. + * + * The extra nopad argument can be used to + * force non-padded comparison for a Char column. + * ®return 0 if successful, -1 otherwize + */ + int eq(int ColId, const char * val, Uint32 len, bool nopad=false); + int ne(int ColId, const char * val, Uint32 len, bool nopad=false); + int lt(int ColId, const char * val, Uint32 len, bool nopad=false); + int le(int ColId, const char * val, Uint32 len, bool nopad=false); + int gt(int ColId, const char * val, Uint32 len, bool nopad=false); + int ge(int ColId, const char * val, Uint32 len, bool nopad=false); + + /** + * Like comparison operator. + * ®return 0 if successful, -1 otherwize + */ + int like(int ColId, const char * val, Uint32 len, bool nopad=false); + /** + * Notlike comparison operator. + * ®return 0 if successful, -1 otherwize + */ + int notlike(int ColId, const char * val, Uint32 len, bool nopad=false); + /** @} *********************************************************************/ + +private: + friend class NdbScanFilterImpl; + class NdbScanFilterImpl & m_impl; + NdbScanFilter& operator=(const NdbScanFilter&); ///< Defined not implemented +}; + +#endif diff --git a/ndb/include/ndbapi/NdbScanOperation.hpp b/ndb/include/ndbapi/NdbScanOperation.hpp new file mode 100644 index 00000000000..2a27d8b34a1 --- /dev/null +++ b/ndb/include/ndbapi/NdbScanOperation.hpp @@ -0,0 +1,248 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/***************************************************************************** + * Name: NdbScanOperation.hpp + * Include: + * Link: + * Author: Martin Sköld + * Date: 2002-04-01 + * Version: 0.1 + * Description: Table scan support + * Documentation: + * Adjust: 2002-04-01 Martin Sköld First version. + ****************************************************************************/ + +#ifndef NdbScanOperation_H +#define NdbScanOperation_H + + +#include +#include + +/** + * @class NdbScanOperation + * @brief Class of scan operations for use in transactions. + */ +class NdbScanOperation : public NdbCursorOperation +{ + friend class Ndb; + friend class NdbConnection; + friend class NdbResultSet; + friend class NdbOperation; + +public: + /** + * readTuples returns a NdbResultSet where tuples are stored. + * Tuples are not stored in NdbResultSet until execute(NoCommit) + * has been executed and nextResult has been called. + * + * @param parallel Scan parallelism + * @param LockMode Scan lock handling + * @returns NdbResultSet. + */ + virtual NdbResultSet* readTuples(unsigned parallel = 0, + LockMode = LM_Read ); + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL + + int updateTuples(); + int updateTuples(Uint32 parallelism); + + int deleteTuples(); + int deleteTuples(Uint32 parallelism); + + // Overload setValue for updateTuples + int setValue(const char* anAttrName, const char* aValue, Uint32 len = 0); + int setValue(const char* anAttrName, Int32 aValue); + int setValue(const char* anAttrName, Uint32 aValue); + int setValue(const char* anAttrName, Int64 aValue); + int setValue(const char* anAttrName, Uint64 aValue); + int setValue(const char* anAttrName, float aValue); + int setValue(const char* anAttrName, double aValue); + + int setValue(Uint32 anAttrId, const char* aValue, Uint32 len = 0); + int setValue(Uint32 anAttrId, Int32 aValue); + int setValue(Uint32 anAttrId, Uint32 aValue); + int setValue(Uint32 anAttrId, Int64 aValue); + int setValue(Uint32 anAttrId, Uint64 aValue); + int setValue(Uint32 anAttrId, float aValue); + int setValue(Uint32 anAttrId, double aValue); +#endif +private: + NdbScanOperation(Ndb* aNdb); + + ~NdbScanOperation(); + + NdbCursorOperation::CursorType cursorType(); + + virtual int nextResult(bool fetchAllowed = true); + virtual void release(); + + void closeScan(); + + // Overloaded methods from NdbCursorOperation + int executeCursor(int ProcessorId); + + // Overloaded private methods from NdbOperation + int init(NdbTableImpl* tab, NdbConnection* myConnection); + int prepareSend(Uint32 TC_ConnectPtr, Uint64 TransactionId); + int doSend(int ProcessorId); + + virtual void setErrorCode(int aErrorCode); + virtual void setErrorCodeAbort(int aErrorCode); + + virtual int equal_impl(const NdbColumnImpl* anAttrObject, + const char* aValue, + Uint32 len); +private: + NdbConnection *m_transConnection; + bool m_autoExecute; + bool m_updateOp; + bool m_writeOp; + bool m_deleteOp; + class SetValueRecList* m_setValueList; +}; + +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL +class AttrInfo; +class SetValueRecList; + +class SetValueRec { + friend class SetValueRecList; +public: + SetValueRec(); + ~SetValueRec(); + + enum SetValueType { + SET_STRING_ATTR1 = 0, + SET_INT32_ATTR1 = 1, + SET_UINT32_ATTR1 = 2, + SET_INT64_ATTR1 = 3, + SET_UINT64_ATTR1 = 4, + SET_FLOAT_ATTR1 = 5, + SET_DOUBLE_ATTR1 = 6, + SET_STRING_ATTR2 = 7, + SET_INT32_ATTR2 = 8, + SET_UINT32_ATTR2 = 9, + SET_INT64_ATTR2 = 10, + SET_UINT64_ATTR2 = 11, + SET_FLOAT_ATTR2 = 12, + SET_DOUBLE_ATTR2 = 13 + }; + + SetValueType stype; + union { + char* anAttrName; + Uint32 anAttrId; + }; + typedef struct String { + char* aStringValue; + Uint32 len; + }; + union { + String stringStruct; + Int32 anInt32Value; + Uint32 anUint32Value; + Int64 anInt64Value; + Uint64 anUint64Value; + float aFloatValue; + double aDoubleValue; + }; +private: + SetValueRec* next; +}; + +inline +SetValueRec::SetValueRec() : + next(0) +{ +} + +inline +SetValueRec::~SetValueRec() +{ + if ((stype == SET_STRING_ATTR1) || + (stype == SET_INT32_ATTR1) || + (stype == SET_UINT32_ATTR1) || + (stype == SET_INT64_ATTR1) || + (stype == SET_UINT64_ATTR1) || + (stype == SET_FLOAT_ATTR1) || + (stype == SET_DOUBLE_ATTR1)) + free(anAttrName); + + if ((stype == SET_STRING_ATTR1) || + (stype == SET_STRING_ATTR2)) + free(stringStruct.aStringValue); + if (next) delete next; + next = 0; +} + +class SetValueRecList { +public: + SetValueRecList(); + ~SetValueRecList(); + + void add(const char* anAttrName, const char* aValue, Uint32 len = 0); + void add(const char* anAttrName, Int32 aValue); + void add(const char* anAttrName, Uint32 aValue); + void add(const char* anAttrName, Int64 aValue); + void add(const char* anAttrName, Uint64 aValue); + void add(const char* anAttrName, float aValue); + void add(const char* anAttrName, double aValue); + void add(Uint32 anAttrId, const char* aValue, Uint32 len = 0); + void add(Uint32 anAttrId, Int32 aValue); + void add(Uint32 anAttrId, Uint32 aValue); + void add(Uint32 anAttrId, Int64 aValue); + void add(Uint32 anAttrId, Uint64 aValue); + void add(Uint32 anAttrId, float aValue); + void add(Uint32 anAttrId, double aValue); + + typedef void(* IterateFn)(SetValueRec&, NdbOperation&); + static void callSetValueFn(SetValueRec&, NdbOperation&); + void iterate(IterateFn nextfn, NdbOperation&); +private: + SetValueRec* first; + SetValueRec* last; +}; + +inline +SetValueRecList::SetValueRecList() : + first(0), + last(0) +{ +} + +inline +SetValueRecList::~SetValueRecList() { + if (first) delete first; + first = last = 0; +} + + +inline +void SetValueRecList::iterate(SetValueRecList::IterateFn nextfn, NdbOperation& oper) +{ + SetValueRec* recPtr = first; + while(recPtr) { + (*nextfn)(*recPtr, oper); + recPtr = recPtr->next; // Move to next in list - MASV + } +} + +#endif + +#endif diff --git a/ndb/include/ndbapi/NdbSchemaCon.hpp b/ndb/include/ndbapi/NdbSchemaCon.hpp new file mode 100644 index 00000000000..9d6b49df8f9 --- /dev/null +++ b/ndb/include/ndbapi/NdbSchemaCon.hpp @@ -0,0 +1,132 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NdbSchemaCon_H +#define NdbSchemaCon_H +#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED + +#include +#include "AttrType.hpp" +#include "NdbError.hpp" + +class NdbSchemaOp; +class NdbApiSignal; +class Ndb; + +/** + * @class NdbSchemaCon + * @brief Represents a schema transaction. + * + * When creating a new table, + * the first step is to get a NdbSchemaCon object to represent + * the schema transaction. + * This is done by calling Ndb::startSchemaTransaction. + * + * The next step is to get a NdbSchemaOp object by calling + * NdbSchemaCon::getNdbSchemaOp. + * The NdbSchemaOp object then has methods to define the table and + * its attributes. + * + * Finally, the NdbSchemaCon::execute method inserts the table + * into the database. + * + * @note Currently only one table can be added per transaction. + */ +class NdbSchemaCon +{ +friend class Ndb; +friend class NdbSchemaOp; + +public: + /** + * Execute a schema transaction. + * + * @return 0 if successful otherwise -1. + */ + int execute(); + + /** + * Get a schemaoperation. + * + * @note Currently, only one operation per transaction is allowed. + * + * @return Pointer to a NdbSchemaOp or NULL if unsuccessful. + */ + NdbSchemaOp* getNdbSchemaOp(); + + /** + * Get the latest error + * + * @return Error object. + */ + const NdbError & getNdbError() const; + +private: +/****************************************************************************** + * These are the create and delete methods of this class. + *****************************************************************************/ + + NdbSchemaCon(Ndb* aNdb); + ~NdbSchemaCon(); + +/****************************************************************************** + * These are the private methods of this class. + *****************************************************************************/ + void init(); // Initialise connection object for new + // transaction. + + void release(); // Release all schemaop in schemaCon + + /*************************************************************************** + * These methods are service methods to other classes in the NDBAPI. + ***************************************************************************/ + + int checkMagicNumber(); // Verify correct object + int receiveDICTTABCONF(NdbApiSignal* aSignal); + int receiveDICTTABREF(NdbApiSignal* aSignal); + + + int receiveCREATE_INDX_CONF(NdbApiSignal*); + int receiveCREATE_INDX_REF(NdbApiSignal*); + int receiveDROP_INDX_CONF(NdbApiSignal*); + int receiveDROP_INDX_REF(NdbApiSignal*); + + + +/***************************************************************************** + * These are the private variables of this class. + *****************************************************************************/ + + + NdbError theError; // Errorcode + Ndb* theNdb; // Pointer to Ndb object + + NdbSchemaOp* theFirstSchemaOpInList; // First operation in operation list. + int theMagicNumber; // Magic number +}; + +inline +int +NdbSchemaCon::checkMagicNumber() +{ + if (theMagicNumber != 0x75318642) + return -1; + return 0; +}//NdbSchemaCon::checkMagicNumber() +#endif +#endif + + diff --git a/ndb/include/ndbapi/NdbSchemaOp.hpp b/ndb/include/ndbapi/NdbSchemaOp.hpp new file mode 100644 index 00000000000..90837bbc66b --- /dev/null +++ b/ndb/include/ndbapi/NdbSchemaOp.hpp @@ -0,0 +1,458 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NdbSchemaOp_H +#define NdbSchemaOp_H +#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED + +#include +#include "AttrType.hpp" +#include "NdbSchemaCon.hpp" +#include +#include "NdbDictionary.hpp" + +class NdbApiSignal; +class Ndb; + +/** + * @class NdbSchemaOp + * @brief Represents various operations for use in schema transactions + * + * This class is used for schema operations, e.g. creating tables and + * attributes. + * + * The NdbSchemaOp object is created using NdbSchemaCon::getNdbSchemaOp. + * + * @note This class is depricated and is now replaced with the class + * NdbDictionary. + */ +class NdbSchemaOp +{ + friend class Ndb; + friend class NdbSchemaCon; + +public: + /** + * Create a new table in the database. + * + * @note The NdbSchemaCon should be closed with + * Ndb::closeSchemaTransaction, even if this method fails. + * + * @param aTableName Table name. Should not be NULL. + * @param aTableSize (Performance parameter.) + * Initial size of the data part of the table + * expressed in kByte. + * The database handles + * bad parameter setting but at a certain + * loss in performance. + * The size given here is + * the initial size allocated for the table + * storage (the data part). + * When calculating the data storage one should + * add the size of all attributes (each attribute + * consumes at least 4 bytes) and also an overhead + * of 12 byte. + * Variable size attributes (not supported yet) + * will have a size of 12 bytes plus the actual + * data storage parts where there is an + * additional overhead based on the size of the + * variable part. + *
+ * An example table with 5 attributes: + * one 64 bit attribute, one 32 bit attribute, + * two 16 bit attributes and one array of 64 8 bits. + * This table will consume + * 12 (overhead) + 8 + 4 + 2*4 (4 is minimum) + 64 = + * 96 bytes per record. + * Additionally an overhead of about 2 % as page + * headers and waste should be allocated. + * Thus, 1 million records should consume 96 MBytes + * plus the overhead 2 MByte and rounded up to + * 100 000 kBytes. + *
+ * This parameter is currently not used. + * + * @param aTupleKey Indicates if the table has a primary key or not. + *
+ * TupleKey means that a primary key + * consisting of one to four attributes + * (at most one of variable size) + * uniquely identifies each record in the created + * table. + *
+ * TupleId means that a tuple identity + * is used. The tuple identity is + * a unique key indentifying each record of the + * created table. + * The tuple identity is a (non-stored) + * 64 bit attribute named NDB$TID. + *
+ * When inserting a record (tuple), the method + * NdbOperation::setTupleId + * will generate a unique tuple identity + * and return it to the user. + *
+ * When reading, updating or deleting a record + * in a table with TupleId, + * NdbOperation::equal("NDB$TID", value_Uint64) + * can be used to identify the record. + *
+ * Legal values: TupleKey or TupleId. + * @param aNrOfPages (Performance parameter.) + * Specifies the initial size of the index storage. + * When calculating the index storage, + * each key has approximately 14 byte of + * overhead plus the size of the key. + * Each key attribute takes up at least 4 bytes + * of storage. + * Thus a mixed key consisting of a + * 64 bit attribute, a 32 bit attribute + * and a 16 bit attribute will + * consume approx. 30 bytes per key. + * Thus, the if initial size is to be 1 million rows, + * then aNrOfPages should be set to + * 30 M / 8k = 2670 pages. + *
+ * This parameter is currently not used. + * + * @param aFragmentType Type of fragmentation.
+ * All (default) means that the + * table fragments are automatically + * distributed on all nodes in the system.
+ * DistributionGroup and + * DistributionKey are + * also supported. For further details about + * these types see the documentation of + * Ndb::startTransaction. + * @param aKValue (Hash parameter.) + * Only allowed value is 6. + * Later implementations might add flexibility + * in this parameter. + * @param aMinLoadFactor (Hash parameter.) + * This value specifies the load factor when + * starting to shrink the hash table. + * It must be smaller than aMaxLoadFactor. + * Both these factors are given in percentage. + * @param aMaxLoadFactor (Hash parameter.) + * This value specifies the load factor when + * starting to split the containers in the local + * hash tables. 100 is the maximum which will + * optimize memory usage (this is the figure + * used for the above calculations). + * A lower figure will store less information in + * each container and thus + * find the key faster but consume more memory. + * @param aMemoryType Currently only 1 is allowed which specifies + * storage of table in main memory. + * Later 2 will be added where the table is stored + * completely on disk + * and 3 where the index is in main memory but + * data is on disk. + * If 1 is chosen an individual attribute can + * still be specified as a disk attribute. + * @param aStoredTable If set to false it indicates that the table is + * a temporary table and should not be logged + * to disk. + * In case of a system restart the table will still + * be defined and exist but will be empty. + * Thus no checkpointing and + * no logging is performed on the table. + * The default value is true and indicates a + * normal table with full checkpointing and + * logging activated. + * @return Returns 0 when successful and returns -1 otherwise. + */ + int createTable( const char* aTableName, + Uint32 aTableSize = 8, + KeyType aTupleKey = TupleKey, + int aNrOfPages = 2, + FragmentType aFragmentType = All, + int aKValue = 6, + int aMinLoadFactor = 78, + int aMaxLoadFactor = 80, + int aMemoryType = 1, + bool aStoredTable = true); + +#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED + /** + * This is the old function declaration, don't use. + * + * @deprecated do not use! + */ + inline int createTable( const char* aTableName, + Uint32 aTableSize, + KeyType aTupleKey, + int aNrOfPages, + FragmentType aFragmentType, + int aKValue, + int aMinLoadFactor, + int aMaxLoadFactor, + int aMemoryType, + int aStoredTable){ + return createTable(aTableName, + aTableSize, + aTupleKey, + aNrOfPages, + aFragmentType, + aKValue, + aMinLoadFactor, + aMaxLoadFactor, + aMemoryType, + (aStoredTable == 1 ? true : false)); + } +#endif + + /** + * Add a new attribute to a database table. + * + * Attributes can only be added to a table in the same transaction + * as the transaction creating the table. + * + * @note The NdbSchemaCon transaction should be closed with + * Ndb::closeSchemaTransaction, even if this method fails. + * + * Example creating an unsigned int attribute belonging to the primary key + * of the table it is created in: + * @code + * MySchemaOp->createAttribute("Attr1", // Attribute name + * TupleKey, // Belongs to primary key + * 32, // 32 bits + * 1, // Not an array attribute + * UnSigned, // Unsigned type + * ); + * @endcode + * + * Example creating a string attribute belonging to the primary key + * of the table it is created in: + * @code + * MySchemaOp->createAttribute("Attr1", // Attribute name + * TupleKey, // Belongs to primary key + * 8, // Each character is 8 bits + * 12, // Max 12 chars in string + * String, // Attribute if of type string + * ); + * @endcode + * + * A distribution key is a set of attributes which are used + * to distribute the tuples onto the NDB nodes. + * A distribution group is a part (currently 16 bits) + * of an attribute used to distribute the tuples onto the NDB nodes. + * The distribution key uses the NDB Cluster hashing function, + * while the distribution group uses a simpler function. + * + * @param aAttrName Attribute name. Should not be NULL. + * @param aTupleKey This parameter specifies whether the + * attribute is part of the primary key or not. + * Floats are not allowed in the primary key. + *
+ * Legal values: NoKey, TupleKey + * @param aAttrSize Specifies the size of the elements of the + * attribute. (An attribute can consist + * of an array of elements.) + *
+ * Legal values: 8, 16, 32, 64 and 128 bits. + * @param aArraySize Size of array. + *
+ * Legal values: + * 0 = variable-sized array, + * 1 = no array, and + * 2- = fixed size array. + *
+ * + * Variable-sized array attributes are + * not yet supported. + * + *
+ * There is no upper limit of the array size + * for a single attribute. + * @param aAttrType The attribute type. + * This is only of interest if calculations are + * made within NDB. + *
+ * Legal values: UnSigned, Signed, Float, String + * @param aStorageMode Main memory based or disk based attribute.
+ * Legal values: MMBased, DiskBased + *
+ * + * Disk-based attributes are not yet supported. + * + * @param nullable Set to true if NULL is a correct value for + * the attribute. + *
+ * Legal values: true, false + * @param aStType Stored in both index and data storage or + * only store in index data storage. + *
+ * This parameter is only of interest for tuple + * key attributes. + * All tuple key attributes values are always stored + * in the index storage part. + * If this parameter is set to + * IndexStorageAttribute, then the attribute values + * will only be stored in the index + * storage part and not in the data + * storage part. + *
+ * If there will be no scans using the primary + * key attribute and if the size of the attribute + * is large, then this might be of interest. + * A typical example is a table where + * http-addresses are used as primary key. + *
+ * Legal values: NormalStorageAttribute, + * IndexStorageAttribute + * @param aDistributionKey Sometimes it is preferable to use a subset + * of the primary key as the distribution key. + * An example is TPC-C where it might be + * good to use the warehouse id and district id + * as the distribution key. + *
+ * Locally in the fragments the full primary key + * will still be used with the hashing algorithm. + * Set to 1 if this attribute is part of the + * distribution key. + * All distribution key attributes must be + * defined before + * any other attributes are defined. + * @param aDistributionGroup In other applications it is desirable to use + * only a part of an attribute to create the + * distribution key. + * This is applicable for some telecom + * applications. + *
+ * In these situations one must provide how many + * bits of the attribute that is to + * be used as the distribution hash value. + *
+ * This provides some control to the + * application of the distribution. + * It still needs to be part of a primary key + * the attribute and must be defined as the + * first attribute. + * @param aDistributionGroupNoOfBits + * Number of bits to use of the + * distribution group attribute in the + * distribution hash value. + *
+ * Currently, only 16 bits is supported. It will + * always be the last 16 bits in the attribute + * which is used for the distribution group. + * @param aAutoIncrement Set to autoincrement attribute. + * @param aDefaultValue Set a default value of attribute. + * + * @return Returns 0 when successful and returns -1 otherwise. + ****************************************************************************/ + int createAttribute(const char* aAttrName, + KeyType aTupleKey = NoKey, + int aAttrSize = 32, + int aArraySize = 1, + AttrType aAttrType = UnSigned, + StorageMode aStorageMode = MMBased, + bool nullable = false, + StorageAttributeType aStType= NormalStorageAttribute, + int aDistributionKey = 0, + int aDistributionGroup = 0, + int aDistributionGroupNoOfBits = 16, + bool aAutoIncrement = false, + const char* aDefaultValue = 0); + +#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED + /** + * @deprecated do not use! + */ + int createAttribute(const char* aAttrName, + KeyType aTupleKey, + int aAttrSize, + int aArraySize, + AttrType aAttrType, + StorageMode aStorageMode, + NullAttributeType aNullAttr, + StorageAttributeType aStType = NormalStorageAttribute, + int aDistributionKey = 0, + int aDistributionGroup = 0, + int aDistributionGroupNoOfBits = 16){ + return createAttribute(aAttrName, + aTupleKey, + aAttrSize, + aArraySize, + aAttrType, + aStorageMode, + aNullAttr == NullAttribute, + aStType, + aDistributionKey, + aDistributionGroup, + aDistributionGroupNoOfBits); + } +#endif + + /** + * Get the last error which occurred during the transaction. + * + * If an error occured (NdbSchemaCon::execute returned -1 or + * NdbSchemaCon::getNdbSchemaOp returned NULL), then this method + * retrieves the error object containing information about + * the error. + * + * @return Error object containing information about last error. + */ + const NdbError & getNdbError() const; + +protected: + +/***************************************************************************** + * These are the methods used to create and delete the NdbOperation objects. + ****************************************************************************/ + NdbSchemaOp(Ndb* aNdb); + + ~NdbSchemaOp(); + +/****************************************************************************** + * These methods are service routines used by the other NDBAPI classes. + *****************************************************************************/ + + void release(); // Release all memory connected + // to the operations object. + +/**************************************************************************** + * The methods below is the execution part of the NdbSchemaOp class. + *****************************************************************************/ + + int sendRec(); + int sendSignals(Uint32 aNodeId, bool HaveMutex); + + int init(NdbSchemaCon* aSchemaCon); + + /************************************************************************** + * These are the private variables that are defined in the operation + * objects. + **************************************************************************/ + Ndb* theNdb; // Point back to the Ndb object. + NdbSchemaCon* theSchemaCon; // Point back to the connection object. + + class NdbDictionary::Table * m_currentTable; +}; + +inline +const NdbError & +NdbSchemaOp::getNdbError() const +{ + return theSchemaCon->getNdbError(); +} + +#endif +#endif + + diff --git a/ndb/include/ndbapi/ndbapi_limits.h b/ndb/include/ndbapi/ndbapi_limits.h new file mode 100644 index 00000000000..bcfba7d3f9d --- /dev/null +++ b/ndb/include/ndbapi/ndbapi_limits.h @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDBAPI_LIMITS_H +#define NDBAPI_LIMITS_H + +#define NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY 32 +#define NDB_MAX_TABLES 1600 +#define NDB_MAX_DATABASE_NAME_SIZE 128 +#define NDB_MAX_SCHEMA_NAME_SIZE 128 +#define NDB_MAX_TAB_NAME_SIZE 128 +#define NDB_MAX_ATTR_NAME_SIZE 32 +#define NDB_MAX_ATTR_DEFAULT_VALUE_SIZE 128 +#define NDB_MAX_ATTRIBUTES_IN_TABLE 91 +#define NDB_MAX_ATTRIBUTES_IN_INDEX NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY +#define NDB_MAX_TUPLE_SIZE_IN_WORDS 1023 +#define NDB_MAX_FIXED_KEY_LENGTH_IN_WORDS 8 +#define NDB_MAX_KEYSIZE_IN_WORDS 1023 +#define NDB_MAX_KEY_SIZE NDB_MAX_KEYSIZE_IN_WORDS*sizeof(Uint32) +#define NDB_MAX_TUPLE_SIZE 8191 +#define NDB_MAX_CONNECTIONS 127 +#define NDB_MAX_TRANSACTIONS 1024 +#define NDB_MAX_PARALLEL_SCANS 12 +#define NDB_MAX_ACTIVE_EVENTS 100 + +#ifndef MIN +#define MIN(x,y) (((x)<(y))?(x):(y)) +#endif + +#ifndef MAX +#define MAX(x,y) (((x)>(y))?(x):(y)) +#endif + +#endif diff --git a/ndb/include/newtonapi/dba.h b/ndb/include/newtonapi/dba.h new file mode 100644 index 00000000000..eb5b3f9b5c2 --- /dev/null +++ b/ndb/include/newtonapi/dba.h @@ -0,0 +1,732 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/** + * @mainpage DBA User Guide + * + * @section secIntro Introduction + * DBA is an API to access the NDB Cluster. + * + * DBA supports transactions using an asynchronous execution model. + * Everything but transactions is synchronous. + * + * DBA uses the concept of bindings to simplify database access. + * A binding is a relation between a database table and + * one or several C structs. + * A binding is created initially and then used multiple time during + * application execution. + * + * Each of the data accessing functions in DBA is implemented as a + * transaction, i.e. the call will either fully complete or + * nothing happens (the transaction fails). + * + * DBA also supports "read as much as possible" with bulk read. + * With bulk read the application can specify a set of primary keys and + * try to read all of the corresponding rows. The bulk read will not fail + * if a row does not exist but will instead inform the application using a + * RowFoundIndicator variable. + * + * A request is a transaction or a bulk read. + * + * @section secError Error Handling + * When a synchronous method in DBA fails these methods are applicable: + * -# DBA_GetLatestError() + * -# DBA_GetLatestNdbError() + * -# DBA_GetLatestErrorMsg() + * + * The DBA_GetLatestErrorMsg() will then return a description of + * what has failed. + * + * For asynchronous methods the application should: + * -# check that the RequestId returned by function is not + * @ref DBA_INVALID_REQID + * -# check Status supplied in callback (see @ref DBA_AsyncCallbackFn_t) + * + * If @ref DBA_INVALID_REQID is returned, + * the details of error can be found using + * "latest"-functions. + * + * If error is indicated in callback (using Status), when the + * "latest"-functions are NOT applicable. + * + * @section secExamples Example Programs + * + * - @ref common.hpp + * - @ref basic.cpp + * - @ref br_test.cpp + * - @ref ptr_binding_test.cpp + * + */ + +/** + * @page basic.cpp basic.cpp + * @include basic.cpp + */ + +/** + * @page common.hpp common.hpp + * @include common.hpp + */ + +/** + * @page br_test.cpp br_test.cpp + * @include br_test.cpp + */ + +/** + * @page ptr_binding_test.cpp ptr_binding_test.cpp + * @include ptr_binding_test.cpp + */ + +/** @addtogroup DBA + * @{ + */ + +/****** THIS LINE IS 80 CHARACTERS WIDE - DO *NOT* EXCEED 80 CHARACTERS! ****/ + +#ifndef DBA_H +#define DBA_H + +/* --- Include files ---- */ + +#include + +#include + + +/* --- Types and definitions --- */ + +/** + * Possible error status for DBA functions. + */ +typedef enum { + DBA_NO_ERROR = 0, /**< Success */ + + DBA_NOT_IMPLEMENTED = -1, /**< Function not implemented */ + DBA_NDB_ERROR = -2, /**< Uncategorised error from NDB */ + DBA_ERROR = -3, /**< Uncategorised error from DBA implementation */ + + DBA_APPLICATION_ERROR = 1, /**< Function called with invalid argument(s) + or other application errors */ + DBA_NO_DATA = 2, /**< No row with specified PK existed */ + DBA_CONSTRAINT_VIOLATION = 3, /**< There already exists a row with that PK*/ + + DBA_SCHEMA_ERROR = 4, /**< Table already exists */ + DBA_INSUFFICIENT_SPACE = 5, /**< The DB is full */ + DBA_TEMPORARY_ERROR = 6, /**< Some temporary problem occured */ + DBA_TIMEOUT = 7, /**< The request timed out, probably due to + dead-lock */ + DBA_OVERLOAD = 8, /**< The DB is overloaded */ + DBA_UNKNOWN_RESULT = 9 /**< It is unknown wheater transaction was + commited or aborted */ +} DBA_Error_t; + +/** + * Error code. This is the error code that is returned by NDB. + * Not to be confused by the status returned by the DBA implementation. + */ +typedef int DBA_ErrorCode_t; + +/** + * DBA column types + */ +typedef enum { + DBA_CHAR, /**< String */ + DBA_INT /**< Integer */ +} DBA_DataTypes_t; + + +/** + * Column description. + * Used for creating tables. + */ +typedef struct DBA_ColumnDesc { + + const char* Name; /**< Name of table column */ + DBA_DataTypes_t DataType; /**< Datatype of table column*/ + Size_t Size; /**< Column size in bytes */ + Boolean_t IsKey; /**< True if column is part of primary key */ + +} DBA_ColumnDesc_t; + +/** + * Used to simplify binding definitions. See @ref DBA_ColumnBinding + * for example. + * + * @param ColName Name of column in db table + * @param Type Column/field type. + * @param Struct Structure + * @param Field Field in structure + * @return Arg list for defining binding of type @ref DBA_Binding_t + */ +#define DBA_BINDING( ColName, Type, Struct, Field ) \ + { ColName, Type, PCN_SIZE_OF( Struct, Field ), \ + PCN_OFFSET_OF( Struct, Field ), 0, 0 } + +/** + * Used to simplify ptr binding definitions. See @ref DBA_ColumnBinding + * for example. + * + * @param Struct Structure + * @param Field Field in structure + * @return Arg list for defining binding of type @ref DBA_Binding_t + */ +#define DBA_BINDING_PTR(Struct, Field, ColBindings, NbCBindings) \ + { 0, DBA_CHAR, NbCBindings, PCN_OFFSET_OF( Struct, Field ), \ + 1, ColBindings } + +/** + * The @ref DBA_ColumnBinding_t is used to describe a binding between one + * column and one field of a C struct. + * + *
+ * typedef struct Address {
+ *   char StreetName[30];
+ *   int  StreetNumber;
+ * } Address_t;
+ *
+ * typdef struct Person {
+ *   char        Name[30];
+ *   Address_t * AddressPtr;
+ * } Person_t;
+ * + * + * For example, if the field Name of a Person_t data structure is + * bound to the column "NAME", the corresponding binding would be + * defined as: + * + *
+ * DBA_ColumnBinding_t NameBinding =
+ *   DBA_BINDING( "name", DBA_CHAR, Person_t, Name );
+ * + * + * There is also the @ref DBA_BINDING_PTR which is used when + * several linked structures should be put into one table. + * + * For example, if data in a Person_t data structure should be saved + * in the same table as the Address_t data structure + * (as the address belongs to the person), the corresponding binding would be + * defined as: + * + *
+ * DBA_ColumnBinding_t AddrBinding[AddrLen]; This binding describes how the 
+ *                                            fields in the Address_t 
+ *                                            structure is linked to the 
+ *                                            table PERSON_ADDRESS
+ *
+ * DBA_ColumnBinding_t AddressBinding = 
+ *   DBA_BINDING_PTR(Person_t, AddressPtr, AddrBinding, AddrLen);
+ * + * + */ +struct DBA_ColumnBinding { + const char* Name; /**< Name of table column */ + DBA_DataTypes_t DataType; /**< Type of member in structure */ + Size_t Size; /**< Size in bytes of member + or no of @ref DBA_ColumnBinding's + when doing ptr binding */ + Size_t Offset; /**< Offset of the member */ + + Boolean_t Ptr; /**< True if binding is of ptr type */ + const struct DBA_ColumnBinding * SubBinding; /**< Address of Binding Ptr + valid if Ptr is true */ +}; + +/** + * Typedef: @ref DBA_ColumnBinding + */ +typedef struct DBA_ColumnBinding DBA_ColumnBinding_t; + +/** + * A @ref DBA_Binding_t object is used to establish a binding between + * one or more columns of a table to the fields of C structs. + * + * It is used with insert, and update and read transactions to define + * on which columns of the table the operations is performed, and to + * which members of a C data structure they map. + * + * All key columns must be bound to a field of the struct. + * + * The function @ref DBA_CreateBinding is used to create this binding. + */ +typedef struct DBA_Binding DBA_Binding_t; + +/* --- Exported functions --- */ + +/** + * Set DBA configuration parameter + *
+ * Id Description                 Default Min  Max
+ * == =========================== ======= ==== ====
+ * 0  NBP Interval                   10    4   -
+ * 1  Operations/Bulkread          1000    1   5000
+ * 2  Start transaction timeout       0    0   -
+ * 3  Force send algorithm            1    0   2
+ *
+ * @return Status + */ +DBA_Error_t DBA_SetParameter(int ParameterId, int Value); + +/** + * Set DBA configuration parameter. + * See @ref DBA_SetParameter for description of parameters. + * + * @return Status + */ +DBA_Error_t DBA_GetParameter(int ParameterId, int * Value); + +/** + * Initialize DBA library and connect to NDB Cluster. + * + * @return Status + */ +DBA_Error_t DBA_Open( ); + +/** + * Close connection to NDB cluster and free allocated memory. + * + * @return Error status + */ +DBA_Error_t DBA_Close(void); + +/** + * Get latest DBA error. + * + * @note Only applicable to synchronous methods + */ +DBA_Error_t DBA_GetLatestError(); + +/** + * Get latest NDB error. + * + * @note Only applicable to synchronous methods + */ +DBA_ErrorCode_t DBA_GetLatestNdbError(); + +/** + * Get latest error string associated with DBA_GetLatestError(). + * + * @note String must not be free by caller of this method. + * @note Only applicable to synchronous methods. + */ +const char * DBA_GetLatestErrorMsg(); + +/** + * Get error msg associated with code + * + * @note String must not be free by caller of this method + */ +const char * DBA_GetErrorMsg(DBA_Error_t); + +/** + * Get error msg associated with code + * + * @note String must not be free by caller of this method + */ +const char * DBA_GetNdbErrorMsg(DBA_ErrorCode_t); + +/** + * Create a table. + * + * @param TableName Name of table to create. + * @param NbColumns numbers of columns. + * @param Columns Column descriptions. + * @return Status. + */ +DBA_Error_t +DBA_CreateTable( const char* TableName, int NbColumns, + const DBA_ColumnDesc_t Columns[] ); + +/** + * Destroy a table. + * + * @param TableName Table name. + * @return Status. + * @note Not implemented + */ +DBA_Error_t +DBA_DropTable( const char* TableName ); + + +/** + * Test for existence of a table. + * + * @param TableName Table name. + * @return Boolean value indicating if table exists or not. + */ +Boolean_t +DBA_TableExists( const char* TableName ); + +/** + * Define a binding between the columns of a table and a C structure. + * + * @param TableName table + * @param NbCol number of columns bindings + * @param ColBinding bindings + * @param StructSz Sizeof structure. + * @return Created binding, or NULL if binding could not be created. + */ +DBA_Binding_t* +DBA_CreateBinding( const char* TableName, + int NbCol, const DBA_ColumnBinding_t ColsBinding[], + Size_t StructSz ); + +/** + * Destroys a @ref DBA_Binding_t allocated with @ref + * DBA_CreateBinding. + * + * @param pBinding Pointer to binding. + * @return Status. + */ +DBA_Error_t +DBA_DestroyBinding( DBA_Binding_t* Binding ); + +/** + * Used to identify a pending db request + */ +typedef long DBA_ReqId_t; + +/** + * An asynchronous call returning this means that the function was called + * with invalid arguments. The application should check error status + * with DBA_GetLatestError() etc. + */ +#define DBA_INVALID_REQID 0 + +/** + * Callback function for transactions. + * Will be called in NBP process (Newton Batch Process). + * + * @note The implementation of the callback function is not allowed to + * make an asynchronous database call. + * + * @param ReqId Request identifier + * @param Status Status of the request + * @param ErrorCode Error code given by NDB + * @see DBA_Error_t + */ +typedef void (*DBA_AsyncCallbackFn_t)( DBA_ReqId_t ReqId, + DBA_Error_t Status, + DBA_ErrorCode_t ErrorCode ); +/** + * Insert row(s) in the table (one transaction) + * + * @param pBinding Binding between table columns and struct fields. + * @param pData Array of pointers to structures. + * @param NbRows No of rows to insert (i.e. length of pData array) + * @return Request identifier + * + * @note All the table columns must be part of the binding. + */ +DBA_ReqId_t +DBA_InsertRows( const DBA_Binding_t* pBinding, const void * const pData[], + int NbRows, + DBA_AsyncCallbackFn_t CbFunc ); + +/** + * Insert row(s) in the table (one transaction) + * + * @param pBinding Binding between table columns and struct fields. + * @param pData Array of structures. + * @param NbRows No of rows to insert (i.e. length of pData array) + * @return Request identifier + * + * @note All the table columns must be part of the binding. + */ +DBA_ReqId_t +DBA_ArrayInsertRows( const DBA_Binding_t* pBinding, const void * pData, + int NbRows, + DBA_AsyncCallbackFn_t CbFunc ); + +/** + * Update row(s) in the table (one transaction) + * + * @param pBinding Binding between table columns and struct fields. + * @param pData Array of pointers to structures. Fields that are part of the + * key are used to generate the where clause, the + * other fields are used to update the row. + * @param NbRows No of rows to update (i.e. length of pData array). + * @return Request identifier + */ +DBA_ReqId_t +DBA_UpdateRows( const DBA_Binding_t* pBinding, const void * const pData[], + int NbRows, + DBA_AsyncCallbackFn_t CbFunc ); + +/** + * Update row(s) in the table (one transaction) + * + * @param pBinding Binding between table columns and struct fields. + * @param pData Array of structures. Fields that are part of the + * key are used to generate the where clause, the + * other fields are used to update the row. + * @param NbRows No of rows to update (i.e. length of pData array). + * @return Request identifier + */ +DBA_ReqId_t +DBA_ArrayUpdateRows( const DBA_Binding_t* pBinding, const void * pData, + int NbRows, + DBA_AsyncCallbackFn_t CbFunc ); + +/** + * Delete row(s) from the table (one transaction) + * + * @param pBinding Binding between table columns and struct fields. + * @param pData Array of pointers to structures. + * Only fields part of the primary key needs to be set. + * @param NbRows No of rows to delete (i.e. length of pData array) + * @return Request identifier + */ +DBA_ReqId_t +DBA_DeleteRows( const DBA_Binding_t* pBinding, const void * const pData[], + int NbRows, + DBA_AsyncCallbackFn_t CbFunc ); + + +/** + * Delete row(s) from the table (one transaction) + * + * @param pBinding Binding between table columns and struct fields. + * @param pData Array of structures. Only fields part of the primary + * key needs to be set. + * @param NbRows No of rows to delete (i.e. length of pData array) + * @return Request identifier + */ +DBA_ReqId_t +DBA_ArrayDeleteRows( const DBA_Binding_t* pBinding, const void * pData, + int NbRows, + DBA_AsyncCallbackFn_t CbFunc ); + +/** + * Updates/Inserts row(s) in the table (one transaction) + * + * @param pBinding Binding between table columns and struct fields. + * @param pData Array of pointers to structures. + * @param NbRows No of rows to update/insert (i.e. length of pData array) + * @return Request identifier + * @note All the table columns must be part of the binding. + */ +DBA_ReqId_t +DBA_WriteRows( const DBA_Binding_t* pBinding, const void * const pData[], + int NbRows, + DBA_AsyncCallbackFn_t CbFunc ); + +/** + * Update/Insert row(s) in the table (one transaction) + * + * @param pBinding Binding between table columns and struct fields. + * @param pData Array of structures. + * @param NbRows No of rows to update/insert (i.e. length of pData array) + * @return Request identifier + * @note All the table columns must be part of the binding. + */ +DBA_ReqId_t +DBA_ArrayWriteRows( const DBA_Binding_t* pBinding, const void * pData, + int NbRows, + DBA_AsyncCallbackFn_t CbFunc ); + +/** + * Read row(s) from a table of the database (one transaction) + * + * @param pBinding Binding between table columns and struct fields. + * @param pData Array of pointers to structures. + * Only fields part of the primary key needs to be set. + * The other fields in the binding will be populated. + * @param NbRows No of rows to read (i.e. length of pData array) + * @return Request identifier + */ +DBA_ReqId_t +DBA_ReadRows( const DBA_Binding_t* pBinding, void * const pData[], + int NbRows, + DBA_AsyncCallbackFn_t CbFunc ); + +/** + * Read row(s) from a table of the database (one transaction) + * + * @param pBinding Binding between table columns and struct fields. + * @param pData Array of structures. + * Only fields part of the primary key needs to be set. + * The other fields in the binding will be populated. + * @param NbRows No of rows to read (i.e. length of pData array) + * @return Request identifier + */ +DBA_ReqId_t +DBA_ArrayReadRows( const DBA_Binding_t* pBinding, void * pData, + int NbRows, + DBA_AsyncCallbackFn_t CbFunc ); + +/****** THIS LINE IS 80 CHARACTERS WIDE - DO *NOT* EXCEED 80 CHARACTERS! ****/ + +/** + * Insert one row for each specified binding (as one transaction). + * + * @param pBindings Array of pointers to bindings. + * @param pData Array of pointers to structures. + * @param NbBindings No of bindings (tables) to insert into, + * i.e. length of arrays pBindings and pData + * @return Request identifier + * @note It is valid to specify the same binding twice + * (with corresponding data pointer) if you want to insert two + * rows in one table + */ +DBA_ReqId_t +DBA_MultiInsertRow(const DBA_Binding_t * const pBindings[], + const void * const pData[], + int NbBindings, + DBA_AsyncCallbackFn_t CbFunc ); + +/** + * Update one row for each specified binding (as one transaction). + * + * @param pBindings Array of pointers to bindings. + * @param pData Array of pointers to structures. + * @param NbBindings No of bindings (tables) to insert into + * i.e. length of arrays pBindings and pData + * @return Request identifier + * @note It is valid to specify the same binding twice + * (with corresponding data pointer) if you want to update two + * rows in one table + */ +DBA_ReqId_t +DBA_MultiUpdateRow(const DBA_Binding_t * const pBindings[], + const void * const pData[], + int NbBindings, + DBA_AsyncCallbackFn_t CbFunc ); + +/** + * Update/insert one row for each specified binding (as one transaction). + * + * @param pBindings Array of pointers to bindings. + * @param pData Array of pointers to structures. + * @param NbBindings No of bindings (tables) to insert into + * i.e. length of arrays pBindings and pData + * @return Request identifier + * @note It is valid to specify the same binding twice + * (with corresponding data pointer) if you want to update/insert two + * rows in one table + */ +DBA_ReqId_t +DBA_MultiWriteRow(const DBA_Binding_t * const pBindings[], + const void * const pData[], + int NbBindings, + DBA_AsyncCallbackFn_t CbFunc ); + +/** + * Delete one row for each specified binding (as one transaction). + * + * @param pBindings Array of pointers to bindings. + * @param pData Array of pointers to structures. + * @param NbBindings No of bindings (tables) to insert into + * i.e. length of arrays pBindings and pData + * @return Request identifier + * @note It is valid to specify the same binding twice + * (with corresponding data pointer) if you want to delete two + * rows in one table + */ +DBA_ReqId_t +DBA_MultiDeleteRow(const DBA_Binding_t * const pBindings[], + const void * const pData[], + int NbBindings, + DBA_AsyncCallbackFn_t CbFunc ); + +/** + * Read one row for each specified binding (as one transaction). + * + * @param pBindings Array of pointers to bindings. + * @param pData Array of pointers to structures. + * @param NbBindings No of bindings (tables) to insert into + * i.e. length of arrays pBindings and pData + * @return Request identifier + * @note It is valid to specify the same binding twice + * (with corresponding data pointer) if you want to read two + * rows in one table + */ +DBA_ReqId_t +DBA_MultiReadRow(const DBA_Binding_t * const pBindings[], + void * const pData[], + int NbBindings, + DBA_AsyncCallbackFn_t CbFunc ); + +/****** THIS LINE IS 80 CHARACTERS WIDE - DO *NOT* EXCEED 80 CHARACTERS! ****/ + +/** + * A structure used for bulk reads. + * The structure contains a pointer to the data and an indicator. + * After the bulk read has completed, the indicator is set to 1 if the row + * was found and to 0 if the row was not found. + * + */ +typedef struct DBA_BulkReadResultSet { + void * DataPtr; /**< Pointer to data. Only fields part of + primary key members needs + to be set before bulk read. */ + Boolean_t RowFoundIndicator; /**< This indicator has a valid value + only after bulk read has completed. + If the value is 1 then the row was found */ +} DBA_BulkReadResultSet_t; + +/** + * Read rows from a table of the database (potentially multiple transactions) + * The users should for each NbRows specify the fields part of the primary key + * + * @param pBinding Binding between table columns and struct fields. + * @param pData Array of DBA_BulkReadResultSet_t, with DataPtr pointing to + * structure. Only the fields which are part of the + * primary key need be set. + * The RowFoundIndicator will be set when the request returns. + * @param NbRows No of rows to read (i.e. length of pData array) + * @return Request identifier + * + */ +DBA_ReqId_t +DBA_BulkReadRows(const DBA_Binding_t * pBinding, + DBA_BulkReadResultSet_t pData[], + int NbRows, + DBA_AsyncCallbackFn_t CbFunc ); + +/** + * Read rows from several tables of the database in potentially multiple + * transactions. + * + *
+ * The pData array must be organized as follows:
+ *   NbRows with DataPtr pointing to structure of type pBindings[0]
+ *   NbRows with DataPtr pointing to structure of type pBindings[1]
+ *   ...
+ * Meaning that the pData array must be (NbBindings * NbRows) in length. + * + * The user should for each (NbRows * NbBindings) specify the primary key + * fields. + * + * @param pBindings Array of pointers to bindings + * @param pData Array of DBA_BulkReadResultSet_t. + * With DataPtr pointing to structure. Only the fields which + * are part of the key need be set. + * The RowFoundIndicator will be set when the operations returns. + * @param NbBindings No of bindings (i.e. length of pBindings array) + * @param NbRows No of rows per binding to read + * @return Request identifier + */ +DBA_ReqId_t +DBA_BulkMultiReadRows(const DBA_Binding_t * const pBindings[], + DBA_BulkReadResultSet_t pData[], + int NbBindings, + int NbRows, + DBA_AsyncCallbackFn_t CbFunc ); + +/** @} */ + +#endif diff --git a/ndb/include/newtonapi/defs/pcn_types.h b/ndb/include/newtonapi/defs/pcn_types.h new file mode 100644 index 00000000000..a823846d7be --- /dev/null +++ b/ndb/include/newtonapi/defs/pcn_types.h @@ -0,0 +1,41 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef PCN_TYPES_H +#define PCN_TYPES_H + +#include +#include + +#ifdef NDB_MACOSX +typedef unsigned int Size_t; +#elif defined(NDB_SPARC_64) +typedef unsigned int Size_t; +#else +typedef size_t Size_t; +#endif + +typedef int Boolean_t; + +typedef unsigned UInt32_t; + +#define PCN_TRUE true +#define PCN_FALSE false + +#define PCN_SIZE_OF(s, m ) sizeof(((s *)0)->m) +#define PCN_OFFSET_OF(s, m) offsetof(s, m) + +#endif diff --git a/ndb/include/portlib/NdbCondition.h b/ndb/include/portlib/NdbCondition.h new file mode 100644 index 00000000000..fb1f2fcd69e --- /dev/null +++ b/ndb/include/portlib/NdbCondition.h @@ -0,0 +1,94 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_CONDITION_H +#define NDB_CONDITION_H + +#include "NdbMutex.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct NdbCondition; + + +/* +// Create a condition +// +// * returnvalue: pointer to the condition structure +*/ +struct NdbCondition* NdbCondition_Create(void); + +/* +// Wait for a condition, allows a thread to wait for +// a condition and atomically releases the associated mutex. +// +// * p_cond: pointer to the condition structure +// * p_mutex: pointer to the mutex structure +// * returnvalue: 0 = succeeded, 1 = failed +*/ +int NdbCondition_Wait(struct NdbCondition* p_cond, + NdbMutex* p_mutex); + +/* + * Wait for a condition with timeout, allows a thread to + * wait for a condition and atomically releases the associated mutex. + * + * @param p_cond - pointer to the condition structure + * @param p_mutex - pointer to the mutex structure + * @param msec - Wait for msec milli seconds the most + * @return 0 = succeeded, 1 = failed + * @ + */ +int +NdbCondition_WaitTimeout(struct NdbCondition* p_cond, + NdbMutex* p_mutex, + int msec); + + +/* +// Signal a condition +// +// * p_cond: pointer to the condition structure +// * returnvalue: 0 = succeeded, 1 = failed +*/ +int NdbCondition_Signal(struct NdbCondition* p_cond); + + +/* +// Broadcast a condition +// +// * p_cond: pointer to the condition structure +// * returnvalue: 0 = succeeded, 1 = failed +*/ +int NdbCondition_Broadcast(struct NdbCondition* p_cond); + +/* +// Destroy a condition +// +// * p_cond: pointer to the condition structure +// * returnvalue: 0 = succeeded, 1 = failed +*/ +int NdbCondition_Destroy(struct NdbCondition* p_cond); + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/ndb/include/portlib/NdbConstant.hpp b/ndb/include/portlib/NdbConstant.hpp new file mode 100644 index 00000000000..bd45209d2b5 --- /dev/null +++ b/ndb/include/portlib/NdbConstant.hpp @@ -0,0 +1,28 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_CONSTANT_HPP +#define NDB_CONSTANT_HPP + +#include + +#ifdef NDB_VC98 +#define STATIC_CONST(x) enum { x } +#else +#define STATIC_CONST(x) static const Uint32 x +#endif + +#endif diff --git a/ndb/include/portlib/NdbDaemon.h b/ndb/include/portlib/NdbDaemon.h new file mode 100644 index 00000000000..74ea3f06419 --- /dev/null +++ b/ndb/include/portlib/NdbDaemon.h @@ -0,0 +1,72 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_DAEMON_H +#define NDB_DAEMON_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Become a daemon. + * lockfile the "pid file" or other resource to lock exclusively + * logfile daemon output is directed here (input is set to /dev/null) + * if NULL, output redirection is not done + * flags none currently + * returns 0 on success, on error -1 + */ +extern int +NdbDaemon_Make(const char* lockfile, const char* logfile, unsigned flags); + +/* + * Test if the daemon is running (file is locked). + * lockfile the "pid file" + * flags none currently + * return 0 no, 1 yes, -1 + */ +extern int +NdbDaemon_Test(const char* lockfile, unsigned flags); + +/* + * Kill the daemon. + * lockfile the "pid file" + * flags none currently + * return 0 killed, 1 not running, -1 other error + */ +extern int +NdbDaemon_Kill(const char* lockfile, unsigned flags); + +/* + * Pid from last call, either forked off or found in lock file. + */ +extern long NdbDaemon_DaemonPid; + +/* + * Error code from last failed call. + */ +extern int NdbDaemon_ErrorCode; + +/* + * Error text from last failed call. + */ +extern char NdbDaemon_ErrorText[]; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/ndb/include/portlib/NdbEnv.h b/ndb/include/portlib/NdbEnv.h new file mode 100644 index 00000000000..1611bf3152e --- /dev/null +++ b/ndb/include/portlib/NdbEnv.h @@ -0,0 +1,34 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_ENV_H +#define NDB_ENV_H + + +#ifdef __cplusplus +extern "C" { +#endif + + const char* NdbEnv_GetEnv(const char* name, char * buf, int buflen); + +#ifdef __cplusplus + } +#endif + +#endif + + + diff --git a/ndb/include/portlib/NdbHost.h b/ndb/include/portlib/NdbHost.h new file mode 100644 index 00000000000..90e7b781137 --- /dev/null +++ b/ndb/include/portlib/NdbHost.h @@ -0,0 +1,43 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_HOST_H +#define NDB_HOST_H + +#ifndef NDB_WIN32 +#include +#include +#endif + +#ifndef MAXHOSTNAMELEN +#define MAXHOSTNAMELEN 255 +#endif + +#ifdef __cplusplus +extern "C" { +#endif + + int NdbHost_GetHostName(char*); + int NdbHost_GetProcessId(); + +#ifdef __cplusplus + } +#endif + +#endif + + + diff --git a/ndb/include/portlib/NdbMain.h b/ndb/include/portlib/NdbMain.h new file mode 100644 index 00000000000..7cc7a877750 --- /dev/null +++ b/ndb/include/portlib/NdbMain.h @@ -0,0 +1,66 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDBMAIN_H +#define NDBMAIN_H + +#if defined NDB_SOFTOSE || defined NDB_OSE +#include +#include + +/* Define an OSE_PROCESS that can be started from osemain.con */ +#define NDB_MAIN(name) \ +int main_ ## name(int argc, const char** argv); \ +OS_PROCESS(name){ \ + main_ ## name(0, 0); \ + stop(current_process()); \ + exit(0); \ +} \ +int main_ ## name(int argc, const char** argv) + +/* Define an function that can be started from the command line */ +#define NDB_COMMAND(name, str_name, syntax, description, stacksize) \ +int main_ ## name(int argc, const char** argv); \ + \ +static int run_ ## name(int argc, char *argv[]){ \ + return main_ ## name (argc, argv); \ +} \ + \ +OS_PROCESS(init_ ## name){ \ + shell_add_cmd_attrs(str_name, syntax, description, \ + run_ ## name, OS_PRI_PROC, 25, stacksize); \ + stop(current_process()); \ + return; \ +} \ + \ +int main_ ## name(int argc, const char** argv) + + + + +#else + +#define NDB_MAIN(name) \ +int main(int argc, const char** argv) + +#define NDB_COMMAND(name, str_name, syntax, description, stacksize) \ +int main(int argc, const char** argv) + + +#endif + + +#endif diff --git a/ndb/include/portlib/NdbMem.h b/ndb/include/portlib/NdbMem.h new file mode 100644 index 00000000000..38ad3f60448 --- /dev/null +++ b/ndb/include/portlib/NdbMem.h @@ -0,0 +1,82 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_MEM_H +#define NDB_MEM_H + +#include + + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * NdbMem_Create + * Create and initalise internal data structures for Ndb + */ +void NdbMem_Create(void); + + +/** + * NdbMem_Destroy + * Destroy all memory allocated by NdbMem + */ +void NdbMem_Destroy(void); + +/** + * NdbMem_Allocate + * Allocate size of memory + * @parameter size - size in bytes of memory to allocate + * @returns - pointer to memory if succesful otherwise NULL + */ +void* NdbMem_Allocate(size_t size); + +/** + * NdbMem_AllocateAlign + * Allocate size of memory + * @parameter size - size in bytes of memory to allocate + * @paramter alignment - byte boundary to align the data at + * @returns - pointer to memory if succesful otherwise NULL + */ +void* NdbMem_AllocateAlign(size_t size, size_t alignment); + + +/** + * NdbMem_Free + * Free the memory that ptr points to + * @parameter ptr - pointer to the memory to free + */ +void NdbMem_Free(void* ptr); + +/** + * NdbMem_MemLockAll + * Locks virtual memory in main memory + */ +int NdbMem_MemLockAll(void); + +/** + * NdbMem_MemUnlockAll + * Unlocks virtual memory + */ +int NdbMem_MemUnlockAll(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/ndb/include/portlib/NdbMutex.h b/ndb/include/portlib/NdbMutex.h new file mode 100644 index 00000000000..d2cb6328b03 --- /dev/null +++ b/ndb/include/portlib/NdbMutex.h @@ -0,0 +1,114 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_MUTEX_H +#define NDB_MUTEX_H + +#ifdef NDB_WIN32 +#include +#include +#include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined NDB_OSE || defined NDB_SOFTOSE +#include +typedef SEMAPHORE NdbMutex; +#define NDB_MUTEX_INITIALIZER { 1, 0, 0 } +#elif defined NDB_WIN32 +typedef CRITICAL_SECTION NdbMutex; +#else +#include +typedef pthread_mutex_t NdbMutex; +#define NDB_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER +#endif + +/** + * Create a mutex + * + * p_mutex: pointer to the mutex structure + * returnvalue: pointer to the mutex structure + */ +NdbMutex* NdbMutex_Create(void); + +/** + * Destroy a mutex + * + * * p_mutex: pointer to the mutex structure + * * returnvalue: 0 = succeeded, -1 = failed + */ +int NdbMutex_Destroy(NdbMutex* p_mutex); + +/** + * Lock a mutex + * + * * p_mutex: pointer to the mutex structure + * * returnvalue: 0 = succeeded, -1 = failed + */ +int NdbMutex_Lock(NdbMutex* p_mutex); + +/** + * Unlock a mutex + * + * * p_mutex: pointer to the mutex structure + * * returnvalue: 0 = succeeded, -1 = failed + */ +int NdbMutex_Unlock(NdbMutex* p_mutex); + +/** + * Try to lock a mutex + * + * * p_mutex: pointer to the mutex structure + * * returnvalue: 0 = succeeded, -1 = failed + */ +int NdbMutex_Trylock(NdbMutex* p_mutex); + +#ifdef __cplusplus +} +#endif + +#ifdef __cplusplus +class NdbLockable { + friend class Guard; +public: + NdbLockable() { m_mutex = NdbMutex_Create(); } + ~NdbLockable() { NdbMutex_Destroy(m_mutex); } + + void lock() { NdbMutex_Lock(m_mutex); } + void unlock(){ NdbMutex_Unlock(m_mutex);} + bool tryLock(){ return NdbMutex_Trylock(m_mutex) == 0;} + + NdbMutex* getMutex() {return m_mutex;}; + +protected: + NdbMutex * m_mutex; +}; + +class Guard { +public: + Guard(NdbMutex *mtx) : m_mtx(mtx) { NdbMutex_Lock(m_mtx); }; + Guard(NdbLockable & l) : m_mtx(l.m_mutex) { NdbMutex_Lock(m_mtx); }; + ~Guard() { NdbMutex_Unlock(m_mtx); }; +private: + NdbMutex *m_mtx; +}; + +#endif + +#endif diff --git a/ndb/include/portlib/NdbSleep.h b/ndb/include/portlib/NdbSleep.h new file mode 100644 index 00000000000..3b26710154f --- /dev/null +++ b/ndb/include/portlib/NdbSleep.h @@ -0,0 +1,38 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDBSLEEP_H +#define NDBSLEEP_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Sleep for some time + * + * returnvalue: true = time is up, false = failed + */ +int NdbSleep_MicroSleep(int microseconds); +int NdbSleep_MilliSleep(int milliseconds); +int NdbSleep_SecSleep(int seconds); + +#ifdef __cplusplus +} +#endif + + +#endif diff --git a/ndb/include/portlib/NdbStdio.h b/ndb/include/portlib/NdbStdio.h new file mode 100644 index 00000000000..163b7eeef6f --- /dev/null +++ b/ndb/include/portlib/NdbStdio.h @@ -0,0 +1,36 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* + * NdbStdio.h - stdio.h for ndb + * + * + */ + + +#if defined NDB_OSE || defined NDB_SOFTOSE +/* On OSE Delta the snprintf is declare in outfmt.h */ +#include +#endif + +#include + +#ifdef NDB_WIN32 +#define snprintf _snprintf +#define vsnprintf _vsnprintf +#define strtok_r(s1, s2, l) strtok(s1, s2) +#endif + diff --git a/ndb/include/portlib/NdbTCP.h b/ndb/include/portlib/NdbTCP.h new file mode 100644 index 00000000000..6e2f18b61b2 --- /dev/null +++ b/ndb/include/portlib/NdbTCP.h @@ -0,0 +1,137 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_TCP_H +#define NDB_TCP_H + +#if defined NDB_OSE || defined NDB_SOFTOSE +/** + * Include files needed + */ +#include "inet.h" + +#include +#include + +#define NDB_NONBLOCK FNDELAY +#define NDB_SOCKET_TYPE int +#define NDB_INVALID_SOCKET -1 +#define NDB_CLOSE_SOCKET(x) close(x) + +/** + * socklen_t not defined in the header files of OSE + */ +typedef int socklen_t; + +#define InetErrno (* inet_errno()) + +#endif + +#if defined NDB_SOLARIS || defined NDB_HPUX || defined NDB_IBMAIX || defined NDB_TRU64X +/** + * Include files needed + */ +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#define NDB_NONBLOCK O_NONBLOCK +#define NDB_SOCKET_TYPE int +#define NDB_INVALID_SOCKET -1 +#define NDB_CLOSE_SOCKET(x) close(x) + +#define InetErrno errno + +#endif + +#if defined NDB_LINUX || defined NDB_MACOSX +/** + * Include files needed + */ +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#define NDB_NONBLOCK O_NONBLOCK +#define NDB_SOCKET_TYPE int +#define NDB_INVALID_SOCKET -1 +#define NDB_CLOSE_SOCKET(x) close(x) + +#define InetErrno errno + +#endif + + +#ifdef NDB_WIN32 +/** + * Include files needed + */ +#include +#include +#include + +#define InetErrno WSAGetLastError() +#define EWOULDBLOCK WSAEWOULDBLOCK +#define NDB_SOCKET_TYPE SOCKET +#define NDB_INVALID_SOCKET INVALID_SOCKET +#define NDB_CLOSE_SOCKET(x) closesocket(x) + +#endif + +#ifndef NDB_MACOSX +#define NDB_SOCKLEN_T socklen_t +#else +#define NDB_SOCKLEN_T int +#endif + + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Convert host name or ip address to in_addr + * + * Returns 0 on success + * -1 on failure + * + * Implemented as: + * gethostbyname + * if not success + * inet_addr + */ +int Ndb_getInAddr(struct in_addr * dst, const char *address); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/ndb/include/portlib/NdbThread.h b/ndb/include/portlib/NdbThread.h new file mode 100644 index 00000000000..516022903e3 --- /dev/null +++ b/ndb/include/portlib/NdbThread.h @@ -0,0 +1,103 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_THREAD_H +#define NDB_THREAD_H + +#include + + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum NDB_THREAD_PRIO_ENUM { + NDB_THREAD_PRIO_HIGHEST, + NDB_THREAD_PRIO_HIGH, + NDB_THREAD_PRIO_MEAN, + NDB_THREAD_PRIO_LOW, + NDB_THREAD_PRIO_LOWEST +} NDB_THREAD_PRIO; + +typedef void* (NDB_THREAD_FUNC)(void*); +typedef void* NDB_THREAD_ARG; +typedef size_t NDB_THREAD_STACKSIZE; + +struct NdbThread; + +/** + * Create a thread + * + * * p_thread_func: pointer of the function to run in the thread + * * p_thread_arg: pointer to argument to be passed to the thread + * * thread_stack_size: stack size for this thread + * * p_thread_name: pointer to name of this thread + * * returnvalue: pointer to the created thread + */ +struct NdbThread* NdbThread_Create(NDB_THREAD_FUNC *p_thread_func, + NDB_THREAD_ARG *p_thread_arg, + const NDB_THREAD_STACKSIZE thread_stack_size, + const char* p_thread_name, + NDB_THREAD_PRIO thread_prio); + +/** + * Destroy a thread + * Deallocates memory for thread + * And NULL the pointer + * + */ +void NdbThread_Destroy(struct NdbThread** p_thread); + + +/** + * Waitfor a thread, suspend the execution of the calling thread + * until the wait_thread_id completes + * + * * p_wait_thread, pointer to the thread to wait for + * * status: exit code from thread waited for + * * returnvalue: true = succeded, false = failed + */ +int NdbThread_WaitFor(struct NdbThread* p_wait_thread, void** status); + +/** + * Exit thread, terminates the calling thread + * + * * status: exit code + */ +void NdbThread_Exit(int status); + +/** + * Set thread concurrency level + * + * * + */ +int NdbThread_SetConcurrencyLevel(int level); + + +#ifdef __cplusplus +} +#endif + +#endif + + + + + + + + + diff --git a/ndb/include/portlib/NdbTick.h b/ndb/include/portlib/NdbTick.h new file mode 100644 index 00000000000..762f65331cc --- /dev/null +++ b/ndb/include/portlib/NdbTick.h @@ -0,0 +1,69 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_TICK_H +#define NDB_TICK_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined NDB_OSE || defined NDB_SOFTOSE +typedef unsigned long NDB_TICKS; +#else +typedef Uint64 NDB_TICKS; +#endif + +/** + * Returns the current millisecond since 1970 + */ +NDB_TICKS NdbTick_CurrentMillisecond(void); + +/** + * Get current micro second + * Second method is simply abstraction on top of the first + * + * Returns 0 - Success + */ +int NdbTick_CurrentMicrosecond(NDB_TICKS * secs, Uint32 * micros); + +//#define TIME_MEASUREMENT +#ifdef TIME_MEASUREMENT + +struct MicroSecondTimer { + NDB_TICKS seconds; + NDB_TICKS micro_seconds; +}; + +/** + * Get time between start and stop time in microseconds + * Abstraction to get time in struct + * + * 0 means stop happened at or before start time + */ +NDB_TICKS NdbTick_getMicrosPassed(struct MicroSecondTimer start, + struct MicroSecondTimer stop); +int NdbTick_getMicroTimer(struct MicroSecondTimer* time_now); +#endif + +#ifdef __cplusplus +} +#endif + +#endif + diff --git a/ndb/include/portlib/NdbUnistd.h b/ndb/include/portlib/NdbUnistd.h new file mode 100644 index 00000000000..42f67e2aeb3 --- /dev/null +++ b/ndb/include/portlib/NdbUnistd.h @@ -0,0 +1,39 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_UNISTD_H +#define NDB_UNISTD_H + +#ifdef NDB_WIN32 +#include +#include +#include +#include + +#define DIR_SEPARATOR "\\" +#define PATH_MAX 256 + +#pragma warning(disable: 4503 4786) + +#else +#include +#include + +#define DIR_SEPARATOR "/" + +#endif + +#endif diff --git a/ndb/include/portlib/PortDefs.h b/ndb/include/portlib/PortDefs.h new file mode 100644 index 00000000000..6cd5be0149f --- /dev/null +++ b/ndb/include/portlib/PortDefs.h @@ -0,0 +1,96 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef PORT_DEFS_H +#define PORT_DEFS_H +/* + This file contains varoius declarations/definitions needed in the port of AXEVM to NT, as well as backporting + to Solaris... + + $Id: PortDefs.h,v 1.5 2003/10/07 07:59:59 mikael Exp $ +*/ +#ifdef NDB_WIN32 +#include + + +struct tms +{ + time_t tms_utime; // user time + time_t tms_stime; // system time + time_t tms_cutime; // user time of children + time_t tms_cstime; // system time of children +}; + +struct timespec +{ + long tv_sec; // Seconds + long tv_nsec; // Nanoseconds +}; + +#define strcasecmp(a,b) _strcmpi(a,b) + + // Exports a WIN32 getopt function +extern int optind; +extern char *optarg; +int getopt(int, char **, char *opts); +#endif // NDB_WIN32 + +#ifdef NDB_ALPHA +#ifdef NDB_GCC +extern int gnuShouldNotUseRPCC(); +#define RPCC() gnuShouldNotUseRPCC(); +#else +#ifdef NDB_WIN32 +#ifdef __cplusplus +extern "C" { +#endif //__cplusplus + u_int64 __asm(char *, ...); + double __dasm(char *, ...); + float __fasm(char *, ...); + void _AcquireSpinLock(long *); + void _ReleaseSpinLock(long *); + int __ADD_ATOMIC_LONG2(void *, int); +#ifdef __cplusplus +}; +#endif //__cplusplus +#pragma intrinsic (__asm, __dasm, __fasm) +#pragma intrinsic(_ReleaseSpinLock, _AcquireSpinLock) +#pragma intrinsic(__ADD_ATOMIC_LONG2) +#endif // NDB_WIN32 + +#define RPCC() ((int)__asm(" rpcc v0;")) +#define MB() __asm(" mb;"); +#define WMB() __asm(" wmb;"); +#ifdef USE_INITIALSP +#define IS_IP() (__asm(" mov sp,v0;") < IPinitialSP) +#else // USE_INITIALSP +#define IS_IP() (((__asm(" rpcc v0;") >> 32) & 0x7) == IP_CPU) +#endif +#endif //NDB_GCC +#else // NDB_ALPHA +#if defined NDB_SPARC +#define MB() asm ("membar 0x0;"); // LoadLoad +#define WMB() asm ("membar 0x3;"); // StoreStore +#else // NDB_SPARC +#define MB() +#define WMB() +#endif // NDB_SPARC +#define IS_IP() (1==1) +extern int shouldNotUseRPCC(); +#define RPCC() shouldNotUseRPCC(); +#endif // NDB_ALPHA + +#endif diff --git a/ndb/include/portlib/prefetch.h b/ndb/include/portlib/prefetch.h new file mode 100644 index 00000000000..d663dd4c40d --- /dev/null +++ b/ndb/include/portlib/prefetch.h @@ -0,0 +1,69 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef PREFETCH_H +#define PREFETCH_H + +#ifdef NDB_FORTE6 +#include +#endif + +#ifdef USE_PREFETCH +#define PREFETCH(addr) prefetch(addr) +#else +#define PREFETCH(addr) +#endif + +#ifdef USE_PREFETCH +#define WRITEHINT(addr) writehint(addr) +#else +#define WRITEHINT(addr) +#endif + +#include "PortDefs.h" + +#ifdef NDB_FORTE6 +#pragma optimize("", off) +#endif +inline void prefetch(void* p) +{ +#ifdef NDB_ALPHA + __asm(" ldl r31,0(a0);", p); +#endif // NDB_ALPHA +#ifdef NDB_FORTE6 + sparc_prefetch_read_once(p); +#else + (void)p; +#endif +} + +inline void writehint(void* p) +{ +#ifdef NDB_ALPHA + __asm(" wh64 (a0);", p); +#endif // NDB_ALPHA +#ifdef NDB_FORTE6 + sparc_prefetch_write_once(p); +#else + (void)p; +#endif +} +#ifdef NDB_FORTE6 +#pragma optimize("", on) +#endif + +#endif + diff --git a/ndb/include/transporter/TransporterCallback.hpp b/ndb/include/transporter/TransporterCallback.hpp new file mode 100644 index 00000000000..9f910f31728 --- /dev/null +++ b/ndb/include/transporter/TransporterCallback.hpp @@ -0,0 +1,345 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +//**************************************************************************** +// +// AUTHOR +// Åsa Fransson +// +// NAME +// TransporterCallback +// +// +//***************************************************************************/ +#ifndef TRANSPORTER_CALLBACK_H +#define TRANSPORTER_CALLBACK_H + +#include +#include "TransporterDefinitions.hpp" + + +/** + * Call back functions + */ + +/** + * The execute function + */ +void +execute(void * callbackObj, + SignalHeader * const header, + Uint8 prio, + Uint32 * const signalData, + LinearSectionPtr ptr[3]); + +/** + * A function to avoid job buffer overflow in NDB kernel, empty in API + * Non-zero return means we executed signals. This is necessary information + * to the transporter to ensure that it properly uses the transporter after + * coming back again. + */ +int +checkJobBuffer(); + +/** + * Report send length + */ +void +reportSendLen(void * callbackObj, + NodeId nodeId, Uint32 count, Uint64 bytes); + +/** + * Report average receive length + */ +void +reportReceiveLen(void * callbackObj, + NodeId nodeId, Uint32 count, Uint64 bytes); + +/** + * Report connection established + */ +void +reportConnect(void * callbackObj, NodeId nodeId); + +/** + * Report connection broken + */ + +void +reportDisconnect(void * callbackObj, + NodeId nodeId, Uint32 errNo); + +enum TransporterError { + TE_NO_ERROR = 0, + /** + * TE_ERROR_CLOSING_SOCKET + * + * Error found during closing of socket + * + * Recommended behavior: Ignore + */ + TE_ERROR_CLOSING_SOCKET = 0x1, + + /** + * TE_ERROR_IN_SELECT_BEFORE_ACCEPT + * + * Error found during accept (just before) + * The transporter will retry. + * + * Recommended behavior: Ignore + * (or possible do setPerformState(PerformDisconnect) + */ + TE_ERROR_IN_SELECT_BEFORE_ACCEPT = 0x2, + + /** + * TE_INVALID_MESSAGE_LENGTH + * + * Error found in message (message length) + * + * Recommended behavior: setPerformState(PerformDisconnect) + */ + TE_INVALID_MESSAGE_LENGTH = 0x8003, + + /** + * TE_INVALID_CHECKSUM + * + * Error found in message (checksum) + * + * Recommended behavior: setPerformState(PerformDisonnect) + */ + TE_INVALID_CHECKSUM = 0x8004, + + /** + * TE_COULD_NOT_CREATE_SOCKET + * + * Error found while creating socket + * + * Recommended behavior: setPerformState(PerformDisonnect) + */ + TE_COULD_NOT_CREATE_SOCKET = 0x8005, + + /** + * TE_COULD_NOT_BIND_SOCKET + * + * Error found while binding server socket + * + * Recommended behavior: setPerformState(PerformDisonnect) + */ + TE_COULD_NOT_BIND_SOCKET = 0x8006, + + /** + * TE_LISTEN_FAILED + * + * Error found while listening to server socket + * + * Recommended behavior: setPerformState(PerformDisonnect) + */ + TE_LISTEN_FAILED = 0x8007, + + /** + * TE_ACCEPT_RETURN_ERROR + * + * Error found during accept + * The transporter will retry. + * + * Recommended behavior: Ignore + * (or possible do setPerformState(PerformDisconnect) + */ + TE_ACCEPT_RETURN_ERROR = 0x8008 + + /** + * TE_SHM_DISCONNECT + * + * The remote node has disconnected + * + * Recommended behavior: setPerformState(PerformDisonnect) + */ + ,TE_SHM_DISCONNECT = 0x800b + + /** + * TE_SHM_IPC_STAT + * + * Unable to check shm segment + * probably because remote node + * has disconnected and removed it + * + * Recommended behavior: setPerformState(PerformDisonnect) + */ + ,TE_SHM_IPC_STAT = 0x800c + + /** + * TE_SHM_UNABLE_TO_CREATE_SEGMENT + * + * Unable to create shm segment + * probably os something error + * + * Recommended behavior: setPerformState(PerformDisonnect) + */ + ,TE_SHM_UNABLE_TO_CREATE_SEGMENT = 0x800d + + /** + * TE_SHM_UNABLE_TO_ATTACH_SEGMENT + * + * Unable to attach shm segment + * probably invalid group / user + * + * Recommended behavior: setPerformState(PerformDisonnect) + */ + ,TE_SHM_UNABLE_TO_ATTACH_SEGMENT = 0x800e + + /** + * TE_SHM_UNABLE_TO_REMOVE_SEGMENT + * + * Unable to remove shm segment + * + * Recommended behavior: Ignore (not much to do) + * Print warning to logfile + */ + ,TE_SHM_UNABLE_TO_REMOVE_SEGMENT = 0x800f + + ,TE_TOO_SMALL_SIGID = 0x0010 + ,TE_TOO_LARGE_SIGID = 0x0011 + ,TE_WAIT_STACK_FULL = 0x8012 + ,TE_RECEIVE_BUFFER_FULL = 0x8013 + + /** + * TE_SIGNAL_LOST_SEND_BUFFER_FULL + * + * Send buffer is full, and trying to force send fails + * a signal is dropped!! very bad very bad + * + */ + ,TE_SIGNAL_LOST_SEND_BUFFER_FULL = 0x8014 + + /** + * TE_SIGNAL_LOST + * + * Send failed for unknown reason + * a signal is dropped!! very bad very bad + * + */ + ,TE_SIGNAL_LOST = 0x8015 + + /** + * TE_SEND_BUFFER_FULL + * + * The send buffer was full, but sleeping for a while solved it + */ + ,TE_SEND_BUFFER_FULL = 0x0016 + + /** + * TE_SCI_UNABLE_TO_CLOSE_CHANNEL + * + * Unable to close the sci channel and the resources allocated by + * the sisci api. + */ + ,TE_SCI_UNABLE_TO_CLOSE_CHANNEL = 0x8016 + + /** + * TE_SCI_LINK_ERROR + * + * There is no link from this node to the switch. + * No point in continuing. Must check the connections. + * Recommended behavior: setPerformState(PerformDisonnect) + */ + ,TE_SCI_LINK_ERROR = 0x8017 + + /** + * TE_SCI_UNABLE_TO_START_SEQUENCE + * + * Could not start a sequence, because system resources + * are exumed or no sequence has been created. + * Recommended behavior: setPerformState(PerformDisonnect) + */ + ,TE_SCI_UNABLE_TO_START_SEQUENCE = 0x8018 + + /** + * TE_SCI_UNABLE_TO_REMOVE_SEQUENCE + * + * Could not remove a sequence + */ + ,TE_SCI_UNABLE_TO_REMOVE_SEQUENCE = 0x8019 + + /** + * TE_SCI_UNABLE_TO_CREATE_SEQUENCE + * + * Could not create a sequence, because system resources are + * exempted. Must reboot. + * Recommended behavior: setPerformState(PerformDisonnect) + */ + ,TE_SCI_UNABLE_TO_CREATE_SEQUENCE = 0x801a + + /** + * TE_SCI_UNRECOVERABLE_DATA_TFX_ERROR + * + * Tried to send data on redundant link but failed. + * Recommended behavior: setPerformState(PerformDisonnect) + */ + ,TE_SCI_UNRECOVERABLE_DATA_TFX_ERROR = 0x801b + + /** + * TE_SCI_CANNOT_INIT_LOCALSEGMENT + * + * Cannot initialize local segment. A whole lot of things has + * gone wrong (no system resources). Must reboot. + * Recommended behavior: setPerformState(PerformDisonnect) + */ + ,TE_SCI_CANNOT_INIT_LOCALSEGMENT = 0x801c + + /** + * TE_SCI_CANNOT_MAP_REMOTESEGMENT + * + * Cannot map remote segment. No system resources are left. + * Must reboot system. + * Recommended behavior: setPerformState(PerformDisonnect) + */ + ,TE_SCI_CANNOT_MAP_REMOTESEGMENT = 0x801d + + /** + * TE_SCI_UNABLE_TO_UNMAP_SEGMENT + * + * Cannot free the resources used by this segment (step 1). + * Recommended behavior: setPerformState(PerformDisonnect) + */ + ,TE_SCI_UNABLE_TO_UNMAP_SEGMENT = 0x801e + + /** + * TE_SCI_UNABLE_TO_REMOVE_SEGMENT + * + * Cannot free the resources used by this segment (step 2). + * Cannot guarantee that enough resources exist for NDB + * to map more segment + * Recommended behavior: setPerformState(PerformDisonnect) + */ + ,TE_SCI_UNABLE_TO_REMOVE_SEGMENT = 0x801f + + /** + * TE_SCI_UNABLE_TO_DISCONNECT_SEGMENT + * + * Cannot disconnect from a remote segment. + * Recommended behavior: setPerformState(PerformDisonnect) + */ + ,TE_SCI_UNABLE_TO_DISCONNECT_SEGMENT = 0x8020 + +}; + +/** + * Report error + */ +void +reportError(void * callbackObj, NodeId nodeId, TransporterError errorCode); + +#endif diff --git a/ndb/include/transporter/TransporterDefinitions.hpp b/ndb/include/transporter/TransporterDefinitions.hpp new file mode 100644 index 00000000000..5bbf7c79491 --- /dev/null +++ b/ndb/include/transporter/TransporterDefinitions.hpp @@ -0,0 +1,152 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TransporterDefinitions_H +#define TransporterDefinitions_H + +#include +#include +#include + +/** + * The maximum number of transporters allowed + * A maximum is needed to be able to allocate the array of transporters + */ +const int MAX_NTRANSPORTERS = 128; + +/** + * The sendbuffer limit after which the contents of the buffer is sent + */ +const int TCP_SEND_LIMIT = 64000; + +enum SendStatus { + SEND_OK = 0, + SEND_BLOCKED = 1, + SEND_DISCONNECTED = 2, + SEND_BUFFER_FULL = 3, + SEND_MESSAGE_TOO_BIG = 4, + SEND_UNKNOWN_NODE = 5 +}; + +/** + * Protocol6 Header + + * (optional signal id) + (optional checksum) + (signal data) + */ +//const Uint32 MAX_MESSAGE_SIZE = (12+4+4+(4*25)); +const Uint32 MAX_MESSAGE_SIZE = (12+4+4+(4*25)+(3*4)+4*4096); + +/** + * TCP Transporter Configuration + */ +struct TCP_TransporterConfiguration { + Uint32 port; + const char *remoteHostName; + const char *localHostName; + NodeId remoteNodeId; + NodeId localNodeId; + Uint32 sendBufferSize; // Size of SendBuffer of priority B + Uint32 maxReceiveSize; // Maximum no of bytes to receive + Uint32 byteOrder; + bool compression; + bool checksum; + bool signalId; +}; + +/** + * SHM Transporter Configuration + */ +struct SHM_TransporterConfiguration { + NodeId remoteNodeId; + NodeId localNodeId; + bool compression; + bool checksum; + bool signalId; + int byteOrder; + + Uint32 shmKey; + Uint32 shmSize; +}; + +/** + * OSE Transporter Configuration + */ +struct OSE_TransporterConfiguration { + const char *remoteHostName; + const char *localHostName; + NodeId remoteNodeId; + NodeId localNodeId; + bool compression; + bool checksum; + bool signalId; + int byteOrder; + + Uint32 prioASignalSize; + Uint32 prioBSignalSize; + Uint32 receiveBufferSize; // In number of signals +}; + +/** + * SCI Transporter Configuration + */ +struct SCI_TransporterConfiguration { + Uint32 sendLimit; // Packet size + Uint32 bufferSize; // Buffer size + + Uint32 nLocalAdapters; // 1 or 2, the number of adapters on local host + + Uint32 nRemoteAdapters; + Uint32 remoteSciNodeId0; // SCInodeId for adapter 1 + Uint32 remoteSciNodeId1; // SCInodeId for adapter 2 + + NodeId localNodeId; // Local node Id + NodeId remoteNodeId; // Remote node Id + + Uint32 byteOrder; + bool compression; + bool checksum; + bool signalId; + +}; + +struct SignalHeader { + Uint32 theVerId_signalNumber; // 4 bit ver id - 16 bit gsn + Uint32 theReceiversBlockNumber; // Only 16 bit blocknum + Uint32 theSendersBlockRef; + Uint32 theLength; + Uint32 theSendersSignalId; + Uint32 theSignalId; + Uint16 theTrace; + Uint8 m_noOfSections; + Uint8 m_fragmentInfo; +}; /** 7x4 = 32 Bytes */ + +struct LinearSectionPtr { + Uint32 sz; + Uint32 * p; +}; + +struct SegmentedSectionPtr { + Uint32 sz; + Uint32 i; + struct SectionSegment * p; + + void setNull() { p = 0;} + bool isNull() const { return p == 0;} +}; + +class NdbOut & operator <<(class NdbOut & out, SignalHeader & sh); + +#endif // Define of TransporterDefinitions_H diff --git a/ndb/include/transporter/TransporterRegistry.hpp b/ndb/include/transporter/TransporterRegistry.hpp new file mode 100644 index 00000000000..6c979777f18 --- /dev/null +++ b/ndb/include/transporter/TransporterRegistry.hpp @@ -0,0 +1,281 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +//**************************************************************************** +// +// NAME +// TransporterRegistry +// +// DESCRIPTION +// TransporterRegistry (singelton) is the interface to the +// transporter layer. It handles transporter states and +// holds the transporter arrays. +// +//***************************************************************************/ +#ifndef TransporterRegistry_H +#define TransporterRegistry_H + +#include "TransporterDefinitions.hpp" + +#include + +// A transporter is always in a PerformState. +// PerformIO is used initially and as long as any of the events +// PerformConnect, ... +enum PerformState { + PerformNothing = 4, // Does nothing + PerformIO = 0, // Is connected + PerformConnect = 1, // Is trying to connect + PerformDisconnect = 2, // Trying to disconnect + RemoveTransporter = 3 // Will be removed +}; + +// A transporter is always in an IOState. +// NoHalt is used initially and as long as it is no restrictions on +// sending or receiving. +enum IOState { + NoHalt = 0, + HaltInput = 1, + HaltOutput = 2, + HaltIO = 3 +}; + +enum TransporterType { + tt_TCP_TRANSPORTER = 1, + tt_SCI_TRANSPORTER = 2, + tt_SHM_TRANSPORTER = 3, + tt_OSE_TRANSPORTER = 4 +}; + +class Transporter; +class TCP_Transporter; +class SCI_Transporter; +class SHM_Transporter; +class OSE_Transporter; + +/** + * @class TransporterRegistry + * @brief ... + */ +class TransporterRegistry { + friend class OSE_Receiver; +public: + /** + * Constructor + */ + TransporterRegistry(void * callback = 0 , + unsigned maxTransporters = MAX_NTRANSPORTERS, + unsigned sizeOfLongSignalMemory = 100); + + bool init(NodeId localNodeId); + + /** + * Remove all transporters + */ + void removeAll(); + + /** + * Disconnect all transporters + */ + void disconnectAll(); + + /** + * Stops the server, disconnects all the transporter + * and deletes them and remove it from the transporter arrays + */ + ~TransporterRegistry(); + + /** + * Start/Stop receiving + */ + void startReceiving(); + void stopReceiving(); + + /** + * Start/Stop sending + */ + void startSending(); + void stopSending(); + + /** + * Get and set methods for PerformState + */ + PerformState performState(NodeId nodeId); + void setPerformState(NodeId nodeId, PerformState state); + + /** + * Set perform state for all transporters + */ + void setPerformState(PerformState state); + + /** + * Get and set methods for IOState + */ + IOState ioState(NodeId nodeId); + void setIOState(NodeId nodeId, IOState state); + + /** + * createTransporter + * + * If the config object indicates that the transporter + * to be created will act as a server and no server is + * started, startServer is called. A transporter of the selected kind + * is created and it is put in the transporter arrays. + */ + bool createTransporter(struct TCP_TransporterConfiguration * config); + bool createTransporter(struct SCI_TransporterConfiguration * config); + bool createTransporter(struct SHM_TransporterConfiguration * config); + bool createTransporter(struct OSE_TransporterConfiguration * config); + + /** + * prepareSend + * + * When IOState is HaltOutput or HaltIO do not send or insert any + * signals in the SendBuffer, unless it is intended for the remote + * CMVMI block (blockno 252) + * Perform prepareSend on the transporter. + * + * NOTE signalHeader->xxxBlockRef should contain block numbers and + * not references + */ + SendStatus prepareSend(const SignalHeader * const signalHeader, Uint8 prio, + const Uint32 * const signalData, + NodeId nodeId, + const LinearSectionPtr ptr[3]); + + SendStatus prepareSend(const SignalHeader * const signalHeader, Uint8 prio, + const Uint32 * const signalData, + NodeId nodeId, + class SectionSegmentPool & pool, + const SegmentedSectionPtr ptr[3]); + + /** + * external_IO + * + * Equal to: poll(...); perform_IO() + * + */ + void external_IO(Uint32 timeOutMillis); + + Uint32 pollReceive(Uint32 timeOutMillis); + void performReceive(); + void performSend(); + + void checkConnections(); + + /** + * Force sending if more than or equal to sendLimit + * number have asked for send. Returns 0 if not sending + * and 1 if sending. + */ + int forceSendCheck(int sendLimit); + +#ifdef DEBUG_TRANSPORTER + void printState(); +#endif + +protected: + +private: + void * callbackObj; + + int sendCounter; + NodeId localNodeId; + bool nodeIdSpecified; + unsigned maxTransporters; + int nTransporters; + int nTCPTransporters; + int nSCITransporters; + int nSHMTransporters; + int nOSETransporters; + + int m_ccCount; + int m_ccIndex; + int m_ccStep; + int m_nTransportersPerformConnect; + bool m_ccReady; + /** + * Arrays holding all transporters in the order they are created + */ + TCP_Transporter** theTCPTransporters; + SCI_Transporter** theSCITransporters; + SHM_Transporter** theSHMTransporters; + OSE_Transporter** theOSETransporters; + + /** + * Array, indexed by nodeId, holding all transporters + */ + TransporterType* theTransporterTypes; + Transporter** theTransporters; + + /** + * OSE Receiver + */ + class OSE_Receiver * theOSEReceiver; + + /** + * In OSE you for some bizar reason needs to create a socket + * the first thing you do when using inet functions. + * + * Furthermore a process doing select has to "own" a socket + * + */ + int theOSEJunkSocketSend; + int theOSEJunkSocketRecv; +#if defined NDB_OSE || defined NDB_SOFTOSE + PROCESS theReceiverPid; +#endif + + /** + * State arrays, index by host id + */ + PerformState* performStates; + IOState* ioStates; + + /** + * Unpack signal data + */ + Uint32 unpack(Uint32 * readPtr, + Uint32 bufferSize, + NodeId remoteNodeId, + IOState state); + + Uint32 * unpack(Uint32 * readPtr, + Uint32 * eodPtr, + NodeId remoteNodeId, + IOState state); + + /** + * Disconnect the transporter and remove it from + * theTransporters array. Do not allow any holes + * in theTransporters. Delete the transporter + * and remove it from theIndexedTransporters array + */ + void removeTransporter(NodeId nodeId); + + /** + * Used in polling if exists TCP_Transporter + */ + int tcpReadSelectReply; + fd_set tcpReadset; + + Uint32 poll_OSE(Uint32 timeOutMillis); + Uint32 poll_TCP(Uint32 timeOutMillis); + Uint32 poll_SCI(Uint32 timeOutMillis); + Uint32 poll_SHM(Uint32 timeOutMillis); +}; + +#endif // Define of TransporterRegistry_H diff --git a/ndb/include/util/Base64.hpp b/ndb/include/util/Base64.hpp new file mode 100644 index 00000000000..a8678da946c --- /dev/null +++ b/ndb/include/util/Base64.hpp @@ -0,0 +1,26 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef __BASE64_HPP_INCLUDED__ +#define __BASE64_HPP_INCLUDED__ + +#include +#include + +int base64_encode(UtilBuffer &src, BaseString &dst); +int base64_decode(BaseString &src, UtilBuffer &dst); + +#endif /* !__BASE64_HPP_INCLUDED__ */ diff --git a/ndb/include/util/BaseString.hpp b/ndb/include/util/BaseString.hpp new file mode 100644 index 00000000000..a88bd97ffc5 --- /dev/null +++ b/ndb/include/util/BaseString.hpp @@ -0,0 +1,260 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef __UTIL_BASESTRING_HPP_INCLUDED__ +#define __UTIL_BASESTRING_HPP_INCLUDED__ + +#include +#include + +#include + +/** + * @class BaseString + * @brief Null terminated strings + */ +class BaseString { +public: + /** @brief Constructs an empty string */ + BaseString(); + + /** @brief Constructs a copy of a char * */ + BaseString(const char* s); + + /** @brief Constructs a copy of another BaseString */ + BaseString(const BaseString& str); + + /** @brief Destructor */ + ~BaseString(); + + /** @brief Returns a C-style string */ + const char* c_str() const; + + /** @brief Returns the length of the string */ + unsigned length() const; + + /** @brief Checks if the string is empty */ + bool empty() const; + + /** @brief Convert to uppercase */ + void ndb_toupper(); + + /** @brief Convert to lowercase */ + void ndb_tolower(); + + /** @brief Assigns from a char * */ + BaseString& assign(const char* s); + + /** @brief Assigns from another BaseString */ + BaseString& assign(const BaseString& str); + + /** @brief Assigns from char *s, with maximum length n */ + BaseString& assign(const char* s, size_t n); + + /** @brief Assigns from another BaseString, with maximum length n */ + BaseString& assign(const BaseString& str, size_t n); + + /** + * Assings from a Vector of BaseStrings, each Vector entry + * separated by separator. + * + * @param vector Vector of BaseStrings to append + * @param separator Separation between appended strings + */ + BaseString& assign(const Vector &vector, + const BaseString &separator = BaseString(" ")); + + /** @brief Appends a char * to the end */ + BaseString& append(const char* s); + + /** @brief Appends a char to the end */ + BaseString& append(char c); + + /** @brief Appends another BaseString to the end */ + BaseString& append(const BaseString& str); + + /** + * Appends a Vector of BaseStrings to the end, each Vector entry + * separated by separator. + * + * @param vector Vector of BaseStrings to append + * @param separator Separation between appended strings + */ + BaseString& append(const Vector &vector, + const BaseString &separator = BaseString(" ")); + + /** @brief Assigns from a format string a la printf() */ + BaseString& assfmt(const char* ftm, ...); + + /** @brief Appends a format string a la printf() to the end */ + BaseString& appfmt(const char* ftm, ...); + + /** + * Split a string into a vector of strings. Separate the string where + * any character included in separator exists. + * Maximally maxSize entries are added to the vector, if more separators + * exist in the string, the remainder of the string will be appended + * to the last entry in the vector. + * The vector will not be cleared, so any existing strings in the + * vector will remain. + * + * @param separator characters separating the entries + * @param vector where the separated strings will be stored + * @param maximum number of strings extracted + * + * @returns the number of string added to the vector + */ + int split(Vector &vector, + const BaseString &separator = BaseString(" "), + int maxSize = -1) const; + + /** + * Returns the index of the first occurance of the character c. + * + * @params c character to look for + * @returns index of character, of -1 if no character found + */ + ssize_t indexOf(char c); + + /** + * Returns the index of the last occurance of the character c. + * + * @params c character to look for + * @returns index of character, of -1 if no character found + */ + ssize_t lastIndexOf(char c); + + /** + * Returns a subset of a string + * + * @param start index of first character + * @param stop index of last character + * @return a new string + */ + BaseString substr(ssize_t start, ssize_t stop = -1); + + /** + * @brief Assignment operator + */ + BaseString& operator=(const BaseString& str); + + /** @brief Compare two strings */ + bool operator<(const BaseString& str) const; + /** @brief Are two strings equal? */ + bool operator==(const BaseString& str) const; + /** @brief Are two strings equal? */ + bool operator==(const char *str) const; + /** @brief Are two strings not equal? */ + bool operator!=(const BaseString& str) const; + /** @brief Are two strings not equal? */ + bool operator!=(const char *str) const; + + /** + * Trim string from delim + */ + BaseString& trim(const char * delim = " \t"); + + /** + * Return c-array with strings suitable for execve + * When whitespace is detected, the characters '"' and '\' are honored, + * to make it possible to give arguments containing whitespace. + * The semantics of '"' and '\' match that of most Unix shells. + */ + static char** argify(const char *argv0, const char *src); + + /** + * Trim string from delim + */ + static char* trim(char * src, const char * delim = " \t"); +private: + char* m_chr; + unsigned m_len; +}; + +inline const char* +BaseString::c_str() const +{ + return m_chr; +} + +inline unsigned +BaseString::length() const +{ + return m_len; +} + +inline bool +BaseString::empty() const +{ + return m_len == 0; +} + +inline void +BaseString::ndb_toupper() { + for(unsigned i = 0; i < length(); i++) + m_chr[i] = ::toupper(m_chr[i]); +} + +inline void +BaseString::ndb_tolower() { + for(unsigned i = 0; i < length(); i++) + m_chr[i] = ::tolower(m_chr[i]); +} + +inline bool +BaseString::operator<(const BaseString& str) const +{ + return strcmp(m_chr, str.m_chr) < 0; +} + +inline bool +BaseString::operator==(const BaseString& str) const +{ + return strcmp(m_chr, str.m_chr) == 0; +} + +inline bool +BaseString::operator==(const char *str) const +{ + return strcmp(m_chr, str) == 0; +} + +inline bool +BaseString::operator!=(const BaseString& str) const +{ + return strcmp(m_chr, str.m_chr) != 0; +} + +inline bool +BaseString::operator!=(const char *str) const +{ + return strcmp(m_chr, str) != 0; +} + +inline BaseString& +BaseString::assign(const BaseString& str) +{ + return assign(str.m_chr); +} + +inline BaseString& +BaseString::assign(const Vector &vector, + const BaseString &separator) { + assign(""); + return append(vector, separator); +} + +#endif /* !__UTIL_BASESTRING_HPP_INCLUDED__ */ diff --git a/ndb/include/util/Bitmask.hpp b/ndb/include/util/Bitmask.hpp new file mode 100644 index 00000000000..1f95d62bcb6 --- /dev/null +++ b/ndb/include/util/Bitmask.hpp @@ -0,0 +1,755 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_BITMASK_H +#define NDB_BITMASK_H + +#include +#include + +#ifndef NDB_ASSERT +#include +#include +#define NDB_ASSERT(x, s) \ + do { if (!(x)) { printf("%s\n", s); abort(); } } while (0) +#endif + +/** + * Bitmask implementation. Size is given explicitly + * (as first argument). All methods are static. + */ +class BitmaskImpl { +public: + STATIC_CONST( NotFound = (unsigned)-1 ); + + /** + * get - Check if bit n is set. + */ + static bool get(unsigned size, const Uint32 data[], unsigned n); + + /** + * set - Set bit n to given value (true/false). + */ + static void set(unsigned size, Uint32 data[], unsigned n, bool value); + + /** + * set - Set bit n. + */ + static void set(unsigned size, Uint32 data[], unsigned n); + + /** + * set - Set all bits. + */ + static void set(unsigned size, Uint32 data[]); + + /** + * assign - Set all bits in dst to corresponding in src/ + */ + static void assign(unsigned size, Uint32 dst[], const Uint32 src[]); + + /** + * clear - Clear bit n. + */ + static void clear(unsigned size, Uint32 data[], unsigned n); + + /** + * clear - Clear all bits. + */ + static void clear(unsigned size, Uint32 data[]); + + /** + * isclear - Check if all bits are clear. This is faster + * than checking count() == 0. + */ + static bool isclear(unsigned size, const Uint32 data[]); + + /** + * count - Count number of set bits. + */ + static unsigned count(unsigned size, const Uint32 data[]); + + /** + * find - Find first set bit, starting at given position. + * Returns NotFound when not found. + */ + static unsigned find(unsigned size, const Uint32 data[], unsigned n); + + /** + * equal - Bitwise equal. + */ + static bool equal(unsigned size, const Uint32 data[], const Uint32 data2[]); + + /** + * bitOR - Bitwise (x | y) into first operand. + */ + static void bitOR(unsigned size, Uint32 data[], const Uint32 data2[]); + + /** + * bitAND - Bitwise (x & y) into first operand. + */ + static void bitAND(unsigned size, Uint32 data[], const Uint32 data2[]); + + /** + * bitANDC - Bitwise (x & ~y) into first operand. + */ + static void bitANDC(unsigned size, Uint32 data[], const Uint32 data2[]); + + /** + * bitXOR - Bitwise (x ^ y) into first operand. + */ + static void bitXOR(unsigned size, Uint32 data[], const Uint32 data2[]); + + /** + * contains - Check if all bits set in data2 are set in data + */ + static bool contains(unsigned size, Uint32 data[], const Uint32 data2[]); + + /** + * overlaps - Check if any bit set in data is set in data2 + */ + static bool overlaps(unsigned size, Uint32 data[], const Uint32 data2[]); + + /** + * getField - Get bitfield at given position and length (max 32 bits) + */ + static Uint32 getField(unsigned size, const Uint32 data[], + unsigned pos, unsigned len); + + /** + * setField - Set bitfield at given position and length (max 32 bits) + */ + static void setField(unsigned size, Uint32 data[], + unsigned pos, unsigned len, Uint32 val); + + /** + * getText - Return as hex-digits (only for debug routines). + */ + static void getText(unsigned size, const Uint32 data[], char* buf); +}; + +inline bool +BitmaskImpl::get(unsigned size, const Uint32 data[], unsigned n) +{ + NDB_ASSERT(n < (size << 5), "bit get out of range"); + return (data[n >> 5] & (1 << (n & 31))) != 0; +} + +inline void +BitmaskImpl::set(unsigned size, Uint32 data[], unsigned n, bool value) +{ + value ? set(size, data, n) : clear(size, data, n); +} + +inline void +BitmaskImpl::set(unsigned size, Uint32 data[], unsigned n) +{ + NDB_ASSERT(n < (size << 5), "bit set out of range"); + data[n >> 5] |= (1 << (n & 31)); +} + +inline void +BitmaskImpl::set(unsigned size, Uint32 data[]) +{ + for (unsigned i = 0; i < size; i++) { + data[i] = ~0; + } +} + +inline void +BitmaskImpl::assign(unsigned size, Uint32 dst[], const Uint32 src[]) +{ + for (unsigned i = 0; i < size; i++) { + dst[i] = src[i]; + } +} + +inline void +BitmaskImpl::clear(unsigned size, Uint32 data[], unsigned n) +{ + NDB_ASSERT(n < (size << 5), "bit clear out of range"); + data[n >> 5] &= ~(1 << (n & 31)); +} + +inline void +BitmaskImpl::clear(unsigned size, Uint32 data[]) +{ + for (unsigned i = 0; i < size; i++) { + data[i] = 0; + } +} + +inline bool +BitmaskImpl::isclear(unsigned size, const Uint32 data[]) +{ + for (unsigned i = 0; i < size; i++) { + if (data[i] != 0) + return false; + } + return true; +} + +inline unsigned +BitmaskImpl::count(unsigned size, const Uint32 data[]) +{ + unsigned cnt = 0; + for (unsigned i = 0; i < size; i++) { + Uint32 x = data[i]; + while (x) { + x &= (x - 1); + cnt++; + } + } + return cnt; +} + +inline unsigned +BitmaskImpl::find(unsigned size, const Uint32 data[], unsigned n) +{ + while (n < (size << 5)) { // XXX make this smarter + if (get(size, data, n)) { + return n; + } + n++; + } + return NotFound; +} + +inline bool +BitmaskImpl::equal(unsigned size, const Uint32 data[], const Uint32 data2[]) +{ + for (unsigned i = 0; i < size; i++) { + if (data[i] != data2[i]) + return false; + } + return true; +} + +inline void +BitmaskImpl::bitOR(unsigned size, Uint32 data[], const Uint32 data2[]) +{ + for (unsigned i = 0; i < size; i++) { + data[i] |= data2[i]; + } +} + +inline void +BitmaskImpl::bitAND(unsigned size, Uint32 data[], const Uint32 data2[]) +{ + for (unsigned i = 0; i < size; i++) { + data[i] &= data2[i]; + } +} + +inline void +BitmaskImpl::bitANDC(unsigned size, Uint32 data[], const Uint32 data2[]) +{ + for (unsigned i = 0; i < size; i++) { + data[i] &= ~data2[i]; + } +} + +inline void +BitmaskImpl::bitXOR(unsigned size, Uint32 data[], const Uint32 data2[]) +{ + for (unsigned i = 0; i < size; i++) { + data[i] ^= data2[i]; + } +} + +inline bool +BitmaskImpl::contains(unsigned size, Uint32 data[], const Uint32 data2[]) +{ + for (unsigned int i = 0; i < size; i++) + if ((data[i] & data2[i]) != data2[i]) + return false; + return true; +} + +inline bool +BitmaskImpl::overlaps(unsigned size, Uint32 data[], const Uint32 data2[]) +{ + for (unsigned int i = 0; i < size; i++) + if ((data[i] & data2[i]) != 0) + return true; + return false; +} + +inline Uint32 +BitmaskImpl::getField(unsigned size, const Uint32 data[], + unsigned pos, unsigned len) +{ + Uint32 val = 0; + for (unsigned i = 0; i < len; i++) + val |= get(size, data, pos + i) << i; + return val; +} + +inline void +BitmaskImpl::setField(unsigned size, Uint32 data[], + unsigned pos, unsigned len, Uint32 val) +{ + for (unsigned i = 0; i < len; i++) + set(size, data, pos + i, val & (1 << i)); +} + +inline void +BitmaskImpl::getText(unsigned size, const Uint32 data[], char* buf) +{ + const char* const hex = "0123456789abcdef"; + for (int i = (size-1); i >= 0; i--) { + Uint32 x = data[i]; + for (unsigned j = 0; j < 8; j++) { + buf[7-j] = hex[x & 0xf]; + x >>= 4; + } + buf += 8; + } + *buf = 0; +} + +/** + * Bitmasks. The size is number of 32-bit words (Uint32). + * Unused bits in the last word must be zero. + * + * XXX replace size by length in bits + */ +template +class Bitmask { +public: + /** + * POD data representation + */ + struct Data { + Uint32 data[size]; + + Data & operator=(const Bitmask & src) { + src.assign(size, data); + return *this; + } + }; +private: + + Data rep; +public: + STATIC_CONST( Size = size ); + STATIC_CONST( NotFound = BitmaskImpl::NotFound ); + STATIC_CONST( TextLength = size * 8 ); + + /** + * assign - Set all bits in dst to corresponding in src/ + */ + void assign(const Bitmask::Data & src); + + /** + * assign - Set all bits in dst to corresponding in src/ + */ + static void assign(Uint32 dst[], const Uint32 src[]); + void assign(const Bitmask & src); + + /** + * assign dst of size sz to this + */ + void assign(unsigned sz, Uint32 dst[]) const; + + /** + * assign this according to src/em> + */ + void assign(unsigned sz, const Uint32 src[]); + + /** + * get - Check if bit n is set. + */ + static bool get(const Uint32 data[], unsigned n); + bool get(unsigned n) const; + + /** + * set - Set bit n to given value (true/false). + */ + static void set(Uint32 data[], unsigned n, bool value); + void set(unsigned n, bool value); + + /** + * set - Set bit n. + */ + static void set(Uint32 data[], unsigned n); + void set(unsigned n); + + /** + * set - set all bits. + */ + static void set(Uint32 data[]); + void set(); + + /** + * clear - Clear bit n. + */ + static void clear(Uint32 data[], unsigned n); + void clear(unsigned n); + + /** + * clear - Clear all bits. + */ + static void clear(Uint32 data[]); + void clear(); + + /** + * isclear - Check if all bits are clear. This is faster + * than checking count() == 0. + */ + static bool isclear(const Uint32 data[]); + bool isclear() const; + + /** + * count - Count number of set bits. + */ + static unsigned count(const Uint32 data[]); + unsigned count() const; + + /** + * find - Find first set bit, starting at given position. + * Returns NotFound when not found. + */ + static unsigned find(const Uint32 data[], unsigned n); + unsigned find(unsigned n) const; + + /** + * equal - Bitwise equal. + */ + static bool equal(const Uint32 data[], const Uint32 data2[]); + bool equal(const Bitmask& mask2) const; + + /** + * bitOR - Bitwise (x | y) into first operand. + */ + static void bitOR(Uint32 data[], const Uint32 data2[]); + Bitmask& bitOR(const Bitmask& mask2); + + /** + * bitAND - Bitwise (x & y) into first operand. + */ + static void bitAND(Uint32 data[], const Uint32 data2[]); + Bitmask& bitAND(const Bitmask& mask2); + + /** + * bitANDC - Bitwise (x & ~y) into first operand. + */ + static void bitANDC(Uint32 data[], const Uint32 data2[]); + Bitmask& bitANDC(const Bitmask& mask2); + + /** + * bitXOR - Bitwise (x ^ y) into first operand. + */ + static void bitXOR(Uint32 data[], const Uint32 data2[]); + Bitmask& bitXOR(const Bitmask& mask2); + + /** + * contains - Check if all bits set in data2 (that) are also set in data (this) + */ + static bool contains(Uint32 data[], const Uint32 data2[]); + bool contains(Bitmask that); + + /** + * overlaps - Check if any bit set in this Bitmask (data) is also set in that (data2) + */ + static bool overlaps(Uint32 data[], const Uint32 data2[]); + bool overlaps(Bitmask that); + + /** + * getText - Return as hex-digits (only for debug routines). + */ + static void getText(const Uint32 data[], char* buf); + char* getText(char* buf) const; +}; + +template +inline void +Bitmask::assign(Uint32 dst[], const Uint32 src[]) +{ + BitmaskImpl::assign(size, dst, src); +} + +template +inline void +Bitmask::assign(const Bitmask::Data & src) +{ + assign(rep.data, src.data); +} + +template +inline void +Bitmask::assign(const Bitmask & src) +{ + assign(rep.data, src); +} + +template +inline void +Bitmask::assign(unsigned sz, Uint32 dst[]) const +{ + BitmaskImpl::assign(sz, dst, rep.data); +} + +template +inline void +Bitmask::assign(unsigned sz, const Uint32 src[]) +{ + BitmaskImpl::assign(sz, rep.data, src); +} + +template +inline bool +Bitmask::get(const Uint32 data[], unsigned n) +{ + return BitmaskImpl::get(size, data, n); +} + +template +inline bool +Bitmask::get(unsigned n) const +{ + return get(rep.data, n); +} + +template +inline void +Bitmask::set(Uint32 data[], unsigned n, bool value) +{ + BitmaskImpl::set(size, data, n, value); +} + +template +inline void +Bitmask::set(unsigned n, bool value) +{ + set(rep.data, n, value); +} + +template +inline void +Bitmask::set(Uint32 data[], unsigned n) +{ + BitmaskImpl::set(size, data, n); +} + +template +inline void +Bitmask::set(unsigned n) +{ + set(rep.data, n); +} + +template +inline void +Bitmask::set(Uint32 data[]) +{ + BitmaskImpl::set(size, data); +} + +template +inline void +Bitmask::set() +{ + set(rep.data); +} + +template +inline void +Bitmask::clear(Uint32 data[], unsigned n) +{ + BitmaskImpl::clear(size, data, n); +} + +template +inline void +Bitmask::clear(unsigned n) +{ + clear(rep.data, n); +} + +template +inline void +Bitmask::clear(Uint32 data[]) +{ + BitmaskImpl::clear(size, data); +} + +template +inline void +Bitmask::clear() +{ + clear(rep.data); +} + +template +inline bool +Bitmask::isclear(const Uint32 data[]) +{ + return BitmaskImpl::isclear(size, data); +} + +template +inline bool +Bitmask::isclear() const +{ + return isclear(rep.data); +} + +template +unsigned +Bitmask::count(const Uint32 data[]) +{ + return BitmaskImpl::count(size, data); +} + +template +inline unsigned +Bitmask::count() const +{ + return count(rep.data); +} + +template +unsigned +Bitmask::find(const Uint32 data[], unsigned n) +{ + return BitmaskImpl::find(size, data, n); +} + +template +inline unsigned +Bitmask::find(unsigned n) const +{ + return find(rep.data, n); +} + +template +inline bool +Bitmask::equal(const Uint32 data[], const Uint32 data2[]) +{ + return BitmaskImpl::equal(size, data, data2); +} + +template +inline bool +Bitmask::equal(const Bitmask& mask2) const +{ + return equal(rep.data, mask2.rep.data); +} + +template +inline void +Bitmask::bitOR(Uint32 data[], const Uint32 data2[]) +{ + BitmaskImpl::bitOR(size,data, data2); +} + +template +inline Bitmask& +Bitmask::bitOR(const Bitmask& mask2) +{ + bitOR(rep.data, mask2.rep.data); + return *this; +} + +template +inline void +Bitmask::bitAND(Uint32 data[], const Uint32 data2[]) +{ + BitmaskImpl::bitAND(size,data, data2); +} + +template +inline Bitmask& +Bitmask::bitAND(const Bitmask& mask2) +{ + bitAND(rep.data, mask2.rep.data); + return *this; +} + +template +inline void +Bitmask::bitANDC(Uint32 data[], const Uint32 data2[]) +{ + BitmaskImpl::bitANDC(size,data, data2); +} + +template +inline Bitmask& +Bitmask::bitANDC(const Bitmask& mask2) +{ + bitANDC(rep.data, mask2.rep.data); + return *this; +} + +template +inline void +Bitmask::bitXOR(Uint32 data[], const Uint32 data2[]) +{ + BitmaskImpl::bitXOR(size,data, data2); +} + +template +inline Bitmask& +Bitmask::bitXOR(const Bitmask& mask2) +{ + bitXOR(rep.data, mask2.rep.data); + return *this; +} + +template +void +Bitmask::getText(const Uint32 data[], char* buf) +{ + BitmaskImpl::getText(size, data, buf); +} + +template +inline char * +Bitmask::getText(char* buf) const +{ + getText(rep.data, buf); + return buf; +} + +template +inline bool +Bitmask::contains(Uint32 data[], const Uint32 data2[]) +{ + return BitmaskImpl::contains(size, data, data2); +} + +template +inline bool +Bitmask::contains(Bitmask that) +{ + return contains(this->rep.data, that.rep.data); +} + +template +inline bool +Bitmask::overlaps(Uint32 data[], const Uint32 data2[]) +{ + return BitmaskImpl::overlaps(size, data, data2); +} + +template +inline bool +Bitmask::overlaps(Bitmask that) +{ + return overlaps(this->rep.data, that.rep.data); +} + +#endif diff --git a/ndb/include/util/File.hpp b/ndb/include/util/File.hpp new file mode 100644 index 00000000000..fe3d2642b18 --- /dev/null +++ b/ndb/include/util/File.hpp @@ -0,0 +1,206 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef FILE_H +#define FILE_H + +#include +#include + +/** + * This class provides a file abstraction . It has operations + * to create, read, write and delete a file. + * + * @version #@ $Id: File.hpp,v 1.5 2002/04/26 13:15:38 ejonore Exp $ + */ +class File +{ +public: + /** + * Returns true if the file exist. + * + * @param aFileName a filename to check. + * @return true if the file exists. + */ + static bool exists(const char* aFileName); + + /** + * Returns the size of a file. + * + * @param f a pointer to a FILE descriptor. + * @return the size of the file. + */ + static long size(FILE* f); + + /** + * Renames a file. + * + * @param currFileName the current name of the file. + * @param newFileName the new name of the file. + * @return true if successful. + */ + static bool rename(const char* currFileName, const char* newFileName); + + /** + * Removes/deletes a file. + * + * @param aFileName the file to remove. + * @return true if successful. + */ + static bool remove(const char* aFileName); + + /** + * Default constructor. + */ + File(); + + /** + * Creates a new File with the specified filename and file mode. + * The real file itself will not be created unless open() is called! + * + * To see the available file modes use 'man 3 fopen'. + * + * @param aFileName a filename. + * @param mode the mode which the file should be opened/created with, default "r". + */ + File(const char* aFileName, const char* mode = "r"); + + /** + * Destructor. + */ + ~File(); + + /** + * Opens/creates the file. If open() fails then 'errno' and perror() + * should be used to determine the exact failure cause. + * + * @return true if successful. Check errno if unsuccessful. + */ + bool open(); + + /** + * Opens/creates the file with the specified name and mode. + * If open() fails then 'errno' and perror() should be used to + * determine the exact failure cause. + * + * @param aFileName the file to open. + * @param mode the file mode to use. + * @return true if successful. Check errno if unsuccessful. + */ + bool open(const char* aFileName, const char* mode); + + /** + * Removes the file. + * + * @return true if successful. + */ + bool remove(); + + /** + * Closes the file, i.e., the FILE descriptor is closed. + */ + bool close(); + + /** + * Read from the file. See fread() for more info. + * + * @param buf the buffer to read into. + * @param itemSize the size of each item. + * @param nitems read max n number of items. + * @return 0 if successful. + */ + int read(void* buf, size_t itemSize, size_t nitems) const; + + /** + * Read char from the file. See fread() for more info. + * + * @param buf the buffer to read into. + * @param start the start index of the buf. + * @param length the length of the buffer. + * @return 0 if successful. + */ + int readChar(char* buf, long start, long length) const; + + /** + * Read chars from the file. See fread() for more info. + * + * @param buf the buffer to read into. + * @return 0 if successful. + */ + int readChar(char* buf); + + /** + * Write to file. See fwrite() for more info. + * + * @param buf the buffer to read from. + * @param itemSize the size of each item. + * @param nitems write max n number of items. + * @return 0 if successful. + */ + int write(const void* buf, size_t itemSize, size_t nitems); + + /** + * Write chars to file. See fwrite() for more info. + * + * @param buf the buffer to read from. + * @param start the start index of the buf. + * @param length the length of the buffer. + * @return 0 if successful. + */ + int writeChar(const char* buf, long start, long length); + + /** + * Write chars to file. See fwrite() for more info. + * + * @param buf the buffer to read from. + * @return 0 if successful. + */ + int writeChar(const char* buf); + + /** + * Returns the file size. + * + * @return the file size. + */ + long size() const; + + /** + * Returns the filename. + * + * @return the filename. + */ + const char* getName() const; + + /** + * Flush the buffer. + * + * @return 0 if successful. + */ + int flush() const; + +private: + STATIC_CONST( MAX_FILE_NAME_SIZE = 128 ); + + FILE* m_file; + char m_fileName[MAX_FILE_NAME_SIZE]; + const char* m_fileMode; + /* Prohibit */ + File(const File& aCopy); + File operator = (const File&); + bool operator == (const File&); +}; +#endif + diff --git a/ndb/include/util/InputStream.hpp b/ndb/include/util/InputStream.hpp new file mode 100644 index 00000000000..6b4cf262db4 --- /dev/null +++ b/ndb/include/util/InputStream.hpp @@ -0,0 +1,48 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef INPUT_STREAM_HPP +#define INPUT_STREAM_HPP + +#include +#include + +/** + * Input stream + */ +class InputStream { +public: + virtual char* gets(char * buf, int bufLen) = 0; +}; + +class FileInputStream : public InputStream { + FILE * f; +public: + FileInputStream(FILE * file = stdin); + char* gets(char * buf, int bufLen); +}; + +extern FileInputStream Stdin; + +class SocketInputStream : public InputStream { + NDB_SOCKET_TYPE m_socket; + unsigned m_timeout; +public: + SocketInputStream(NDB_SOCKET_TYPE socket, unsigned readTimeout = 1000); + char* gets(char * buf, int bufLen); +}; + +#endif diff --git a/ndb/include/util/NdbAutoPtr.hpp b/ndb/include/util/NdbAutoPtr.hpp new file mode 100644 index 00000000000..2078714d98d --- /dev/null +++ b/ndb/include/util/NdbAutoPtr.hpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef __NDB_AUTO_PTR_HPP +#define __NDB_AUTO_PTR_HPP + +#include + +template +class NdbAutoPtr { + T * m_obj; +public: + NdbAutoPtr(T * obj = 0){ m_obj = obj;} + void reset(T * obj = 0) { if (m_obj) free(m_obj); m_obj = obj; } + ~NdbAutoPtr() { if (m_obj) free(m_obj);} +}; + +template +class NdbAutoObjPtr { + T * m_obj; +public: + NdbAutoObjPtr(T * obj = 0){ m_obj = obj;} + void reset(T * obj = 0) { if (m_obj) delete m_obj; m_obj = obj; } + ~NdbAutoObjPtr() { if (m_obj) delete m_obj;} +}; + +template +class NdbAutoObjArrayPtr { + T * m_obj; +public: + NdbAutoObjArrayPtr(T * obj = 0){ m_obj = obj;} + void reset(T * obj = 0) { if (m_obj) delete[] m_obj; m_obj = obj; } + ~NdbAutoObjArrayPtr() { if (m_obj) delete[] m_obj;} +}; + +#endif diff --git a/ndb/include/util/NdbOut.hpp b/ndb/include/util/NdbOut.hpp new file mode 100644 index 00000000000..d85d5cc6305 --- /dev/null +++ b/ndb/include/util/NdbOut.hpp @@ -0,0 +1,132 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDBOUT_H +#define NDBOUT_H + +#ifdef __cplusplus + +#include +#include + +/** + * Class used for outputting logging messages to screen. + * Since the output capabilities are different on different platforms + * this middle layer class should be used for all output messages + */ + +/* + Example usage: + + #include "NdbOut.hpp" + + / * Use ndbout as you would use cout: + + ndbout << "Hello World! "<< 1 << " Hello again" + << 67 << anIntegerVar << "Hup << endl; + + + / * Use ndbout_c as you would use printf: + + ndbout_c("Hello World %d\n", 1); +*/ + +class NdbOut; +class OutputStream; +class NullOutputStream; + +/* Declare a static variable of NdbOut as ndbout */ +extern NdbOut ndbout; + +class NdbOut +{ +public: + NdbOut& operator<<(NdbOut& (* _f)(NdbOut&)); + NdbOut& operator<<(Int8); + NdbOut& operator<<(Uint8); + NdbOut& operator<<(Int16); + NdbOut& operator<<(Uint16); + NdbOut& operator<<(Int32); + NdbOut& operator<<(Uint32); + NdbOut& operator<<(Int64); + NdbOut& operator<<(Uint64); + NdbOut& operator<<(long unsigned int); + NdbOut& operator<<(const char*); + NdbOut& operator<<(const unsigned char*); + NdbOut& operator<<(BaseString &); + NdbOut& operator<<(const void*); + NdbOut& operator<<(float); + NdbOut& operator<<(double); + NdbOut& endline(void); + NdbOut& flushline(void); + NdbOut& setHexFormat(int _format); + + NdbOut(OutputStream &); + virtual ~NdbOut(); + + void print(const char * fmt, ...); + void println(const char * fmt, ...); + + OutputStream * m_out; +private: + int isHex; +}; + +inline NdbOut& NdbOut::operator<<(NdbOut& (* _f)(NdbOut&)) { + (* _f)(*this); + return * this; +} + +inline NdbOut& endl(NdbOut& _NdbOut) { + return _NdbOut.endline(); +} + +inline NdbOut& flush(NdbOut& _NdbOut) { + return _NdbOut.flushline(); +} + +inline NdbOut& hex(NdbOut& _NdbOut) { + return _NdbOut.setHexFormat(1); +} + +inline NdbOut& dec(NdbOut& _NdbOut) { + return _NdbOut.setHexFormat(0); +} +extern "C" +void ndbout_c(const char * fmt, ...); + +class FilteredNdbOut : public NdbOut { +public: + FilteredNdbOut(OutputStream &, int threshold = 0, int level = 0); + virtual ~FilteredNdbOut(); + + void setLevel(int i); + void setThreshold(int i); + + int getLevel() const; + int getThreshold() const; + +private: + int m_threshold, m_level; + OutputStream * m_org; + NullOutputStream * m_null; +}; + +#else +void ndbout_c(const char * fmt, ...); +#endif + +#endif diff --git a/ndb/include/util/NdbSqlUtil.hpp b/ndb/include/util/NdbSqlUtil.hpp new file mode 100644 index 00000000000..bb573eea17b --- /dev/null +++ b/ndb/include/util/NdbSqlUtil.hpp @@ -0,0 +1,357 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_SQL_UTIL_HPP +#define NDB_SQL_UTIL_HPP + +#include +#include + +class NdbSqlUtil { +public: + /** + * Compare strings, optionally with padded semantics. Returns + * negative (less), zero (equal), or positive (greater). + */ + static int char_compare(const char* s1, unsigned n1, + const char* s2, unsigned n2, bool padded); + + /** + * Like operator, optionally with padded semantics. Returns true or + * false. + */ + static bool char_like(const char* s1, unsigned n1, + const char* s2, unsigned n2, bool padded); + + /** + * Compare kernel attribute values. Returns -1, 0, +1 for less, + * equal, greater, respectively. Parameters are pointers to values, + * full attribute size in words, and size of available data in words. + * There are 2 special return values to check first. All values fit + * into a signed char. + */ + typedef int Cmp(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size); + + enum CmpResult { + CmpLess = -1, + CmpEqual = 0, + CmpGreater = 1, + CmpUnknown = 126, // insufficient partial data + CmpError = 127 // bad data format or unimplemented comparison + }; + + /** + * Kernel data types. Must match m_typeList in NdbSqlUtil.cpp. + */ + struct Type { + enum Enum { + Undefined = 0, // Undefined + Tinyint, // 8 bit + Tinyunsigned, // 8 bit + Smallint, // 16 bit + Smallunsigned, // 16 bit + Mediumint, // 24 bit + Mediumunsigned, // 24 bit + Int, // 32 bit + Unsigned, // 32 bit + Bigint, // 64 bit + Bigunsigned, // 64 Bit + Float, // 32-bit float + Double, // 64-bit float + Decimal, // Precision, Scale + Char, // Len + Varchar, // Max len + Binary, // Len + Varbinary, // Max len + Datetime, // Precision down to 1 sec (size 8 bytes) + Timespec // Precision down to 1 nsec (size 12 bytes) + }; + Enum m_typeId; + Cmp* m_cmp; // set to NULL if cmp not implemented + }; + + /** + * Get type by id. Can return the Undefined type. + */ + static const Type& type(Uint32 typeId); + + /** + * Inline comparison method. Most or all real methods Type::m_cmp are + * implemented via this (trusting dead code elimination). + */ + static int cmp(Uint32 typeId, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size); + +private: + /** + * List of all types. Must match Type::Enum. + */ + static const Type m_typeList[]; + /** + * Comparison methods. + */ + static Cmp cmpTinyint; + static Cmp cmpTinyunsigned; + static Cmp cmpSmallint; + static Cmp cmpSmallunsigned; + static Cmp cmpMediumint; + static Cmp cmpMediumunsigned; + static Cmp cmpInt; + static Cmp cmpUnsigned; + static Cmp cmpBigint; + static Cmp cmpBigunsigned; + static Cmp cmpFloat; + static Cmp cmpDouble; + static Cmp cmpDecimal; + static Cmp cmpChar; + static Cmp cmpVarchar; + static Cmp cmpBinary; + static Cmp cmpVarbinary; + static Cmp cmpDatetime; + static Cmp cmpTimespec; +}; + +inline int +NdbSqlUtil::cmp(Uint32 typeId, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + if (size > full) + return CmpError; + switch ((Type::Enum)typeId) { + case Type::Undefined: + break; + case Type::Tinyint: + { + if (size >= 1) { + union { Uint32 p[1]; Int8 v; } u1, u2; + u1.p[0] = p1[0]; + u2.p[0] = p2[0]; + if (u1.v < u2.v) + return -1; + if (u1.v > u2.v) + return +1; + return 0; + } + return CmpUnknown; + } + break; + case Type::Tinyunsigned: + { + if (size >= 1) { + union { Uint32 p[1]; Uint8 v; } u1, u2; + u1.p[0] = p1[0]; + u2.p[0] = p2[0]; + if (u1.v < u2.v) + return -1; + if (u1.v > u2.v) + return +1; + return 0; + } + return CmpUnknown; + } + break; + case Type::Smallint: + { + if (size >= 1) { + union { Uint32 p[1]; Int16 v; } u1, u2; + u1.p[0] = p1[0]; + u2.p[0] = p2[0]; + if (u1.v < u2.v) + return -1; + if (u1.v > u2.v) + return +1; + return 0; + } + return CmpUnknown; + } + break; + case Type::Smallunsigned: + { + if (size >= 1) { + union { Uint32 p[1]; Uint16 v; } u1, u2; + u1.p[0] = p1[0]; + u2.p[0] = p2[0]; + if (u1.v < u2.v) + return -1; + if (u1.v > u2.v) + return +1; + return 0; + } + return CmpUnknown; + } + break; + case Type::Mediumint: // XXX fix these + break; + case Type::Mediumunsigned: + break; + case Type::Int: + { + if (size >= 1) { + union { Uint32 p[1]; Int32 v; } u1, u2; + u1.p[0] = p1[0]; + u2.p[0] = p2[0]; + if (u1.v < u2.v) + return -1; + if (u1.v > u2.v) + return +1; + return 0; + } + return CmpUnknown; + } + break; + case Type::Unsigned: + { + if (size >= 1) { + union { Uint32 p[1]; Uint32 v; } u1, u2; + u1.v = p1[0]; + u2.v = p2[0]; + if (u1.v < u2.v) + return -1; + if (u1.v > u2.v) + return +1; + return 0; + } + return CmpUnknown; + } + break; + case Type::Bigint: + { + if (size >= 2) { + union { Uint32 p[2]; Int64 v; } u1, u2; + u1.p[0] = p1[0]; + u1.p[1] = p1[1]; + u2.p[0] = p2[0]; + u2.p[1] = p2[1]; + if (u1.v < u2.v) + return -1; + if (u1.v > u2.v) + return +1; + return 0; + } + return CmpUnknown; + } + break; + case Type::Bigunsigned: + { + if (size >= 2) { + union { Uint32 p[2]; Uint64 v; } u1, u2; + u1.p[0] = p1[0]; + u1.p[1] = p1[1]; + u2.p[0] = p2[0]; + u2.p[1] = p2[1]; + if (u1.v < u2.v) + return -1; + if (u1.v > u2.v) + return +1; + return 0; + } + return CmpUnknown; + } + break; + case Type::Float: + { + if (size >= 1) { + union { Uint32 p[1]; float v; } u1, u2; + u1.p[0] = p1[0]; + u2.p[0] = p2[0]; + if (u1.v < u2.v) + return -1; + if (u1.v > u2.v) + return +1; + return 0; + } + return CmpUnknown; + } + break; + case Type::Double: + { + if (size >= 2) { + union { Uint32 p[2]; double v; } u1, u2; + u1.p[0] = p1[0]; + u1.p[1] = p1[1]; + u2.p[0] = p2[0]; + u2.p[1] = p2[1]; + if (u1.v < u2.v) + return -1; + if (u1.v > u2.v) + return +1; + return 0; + } + return CmpUnknown; + } + break; + case Type::Decimal: + break; + case Type::Char: + { + /* + * Char is blank-padded to length and null-padded to word size. + * There is no terminator so we must compare the full values. + */ + union { const Uint32* p; const char* v; } u1, u2; + u1.p = p1; + u2.p = p2; + int k = memcmp(u1.v, u2.v, size << 2); + return k < 0 ? -1 : k > 0 ? +1 : full == size ? 0 : CmpUnknown; + } + break; + case Type::Varchar: + { + /* + * Varchar is not allowed to contain a null byte and the stored + * value is null-padded. Therefore comparison does not need to + * use the length. + */ + if (size >= 1) { + union { const Uint32* p; const char* v; } u1, u2; + u1.p = p1; + u2.p = p2; + // length in first 2 bytes + int k = strncmp(u1.v + 2, u2.v + 2, (size << 2) - 2); + return k < 0 ? -1 : k > 0 ? +1 : full == size ? 0 : CmpUnknown; + } + return CmpUnknown; + } + break; + case Type::Binary: // XXX fix these + break; + case Type::Varbinary: + break; + case Type::Datetime: + { + /* + * Datetime is CC YY MM DD hh mm ss \0 + */ + if (size >= 1) { + union { const Uint32* p; const char* v; } u1, u2; + u1.p = p1; + u2.p = p2; + // skip format check + int k = strncmp(u1.v, u2.v, 4); + if (k != 0) + return k; + if (size >= 2) { + return strncmp(u1.v + 4, u2.v + 4, 4); + } + } + return CmpUnknown; + } + break; + case Type::Timespec: // XXX fix this + break; + } + return CmpError; +} + +#endif diff --git a/ndb/include/util/NdbString.h b/ndb/include/util/NdbString.h new file mode 100644 index 00000000000..97646f813ac --- /dev/null +++ b/ndb/include/util/NdbString.h @@ -0,0 +1,48 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef __NDBSTRING_H_INCLUDED__ +#define __NDBSTRING_H_INCLUDED__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef HAVE_STRDUP +extern char * strdup(const char *s); +#endif + +#ifndef HAVE_STRLCPY +extern size_t strlcpy (char *dst, const char *src, size_t dst_sz); +#endif + +#ifndef HAVE_STRLCAT +extern size_t strlcat (char *dst, const char *src, size_t dst_sz); +#endif + +#ifndef HAVE_STRCASECMP +extern int strcasecmp(const char *s1, const char *s2); +extern int strncasecmp(const char *s1, const char *s2, size_t n); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* !__NDBSTRING_H_INCLUDED__ */ diff --git a/ndb/include/util/OutputStream.hpp b/ndb/include/util/OutputStream.hpp new file mode 100644 index 00000000000..9d33ead7eb9 --- /dev/null +++ b/ndb/include/util/OutputStream.hpp @@ -0,0 +1,67 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef OUTPUT_STREAM_HPP +#define OUTPUT_STREAM_HPP + +#include +#include + +/** + * Output stream + */ +class OutputStream { +public: + virtual int print(const char * fmt, ...) = 0; + virtual int println(const char * fmt, ...) = 0; + virtual void flush() {}; +}; + +class FileOutputStream : public OutputStream { + FILE * f; +public: + FileOutputStream(FILE * file = stdout); + + int print(const char * fmt, ...); + int println(const char * fmt, ...); + void flush() { fflush(f); } +}; + +class SocketOutputStream : public OutputStream { + NDB_SOCKET_TYPE m_socket; + unsigned m_timeout; +public: + SocketOutputStream(NDB_SOCKET_TYPE socket, unsigned writeTimeout = 1000); + + int print(const char * fmt, ...); + int println(const char * fmt, ...); +}; + +class SoftOseOutputStream : public OutputStream { +public: + SoftOseOutputStream(); + + int print(const char * fmt, ...); + int println(const char * fmt, ...); +}; + +class NullOutputStream : public OutputStream { +public: + int print(const char * /* unused */, ...) { return 1;} + int println(const char * /* unused */, ...) { return 1;} +}; + +#endif diff --git a/ndb/include/util/Parser.hpp b/ndb/include/util/Parser.hpp new file mode 100644 index 00000000000..9c2f02b6024 --- /dev/null +++ b/ndb/include/util/Parser.hpp @@ -0,0 +1,290 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CPCD_PARSER_HPP +#define CPCD_PARSER_HPP + +#include "Vector.hpp" +#include "Properties.hpp" +#include "InputStream.hpp" +#include "NdbOut.hpp" + +class ParserImpl; +template class ParserRow; + +//#define PARSER_DEBUG +#ifdef PARSER_DEBUG +#define DEBUG(x) \ + ndbout_c("%s:%d:%s", __FILE__, __LINE__, x); +#else +#define DEBUG(x) +#endif + +/** + * A generic parser + */ +template +class Parser { +public: + /** + * Status for parser + */ + enum ParserStatus { + Ok = 0, + Eof = 1, + NoLine = 2, + EmptyLine = 3, + UnknownCommand = 4, + UnknownArgument = 5, + TypeMismatch = 6, + InvalidArgumentFormat = 7, + UnknownArgumentType = 8, + CommandWithoutFunction = 9, + ArgumentGivenTwice = 10, + ExternalStop = 11, + MissingMandatoryArgument = 12 + }; + + /** + * Context for parse + */ + struct Context { + ParserStatus m_status; + const ParserRow * m_currentCmd; + const ParserRow * m_currentArg; + char * m_currentToken; + char m_tokenBuffer[512]; + + Vector *> m_aliasUsed; + }; + + /** + * Initialize parser + */ + Parser(const ParserRow rows[], class InputStream & in = Stdin, + bool breakOnCommand = false, + bool breakOnEmptyLine = true, + bool breakOnInvalidArg = false); + ~Parser(); + + /** + * Run parser + */ + bool run(Context &, T &, volatile bool * stop = 0) const; + + /** + * Parse only one entry and return Properties object representing + * the message + */ + const Properties *parse(Context &, T &); + + bool getBreakOnCommand() const; + void setBreakOnCommand(bool v); + + bool getBreakOnEmptyLine() const; + void setBreakOnEmptyLine(bool v); + + bool getBreakOnInvalidArg() const; + void setBreakOnInvalidArg(bool v); + +private: + ParserImpl * impl; +}; + +template +struct ParserRow { +public: + enum Type { Cmd, Arg, CmdAlias, ArgAlias }; + enum ArgType { String, Int, Properties }; + enum ArgRequired { Mandatory, Optional }; + enum ArgMinMax { CheckMinMax, IgnoreMinMax }; + + const char * name; + const char * realName; + Type type; + ArgType argType; + ArgRequired argRequired; + ArgMinMax argMinMax; + int minVal; + int maxVal; + void (T::* function)(typename Parser::Context & ctx, + const class Properties& args); + const char * description; + void *user_value; +}; + +/** + * The void* equivalent implementation + */ +class ParserImpl { + class Dummy {}; + typedef ParserRow DummyRow; + typedef Parser::Context Context; + template friend class Parser; +private: + + ParserImpl(const DummyRow rows[], class InputStream & in, + bool b_cmd, bool b_empty, bool b_iarg); + ~ParserImpl(); + + bool run(Context *ctx, const class Properties **, volatile bool *) const ; + + static const DummyRow* matchCommand(Context*, const char*, const DummyRow*); + static const DummyRow* matchArg(Context*, const char *, const DummyRow *); + static bool parseArg(Context*, char*, const DummyRow*, Properties*); + static bool checkMandatory(Context*, const Properties*); +private: + const DummyRow * const m_rows; + class ParseInputStream & input; + bool m_breakOnEmpty; + bool m_breakOnCmd; + bool m_breakOnInvalidArg; +}; + +template +inline +Parser::Parser(const ParserRow rows[], class InputStream & in, + bool b_cmd, bool b_empty, bool b_iarg){ + impl = new ParserImpl((ParserImpl::DummyRow *)rows, in, + b_cmd, b_empty, b_iarg); +} + +template +inline +Parser::~Parser(){ +} + +template +inline +bool +Parser::run(Context & ctx, T & t, volatile bool * stop) const { + const Properties * p; + DEBUG("Executing Parser::run"); + if(impl->run((ParserImpl::Context*)&ctx, &p, stop)){ + const ParserRow * cmd = ctx.m_currentCmd; // Cast to correct type + if(cmd == 0){ + /** + * Should happen if run returns true + */ + abort(); + } + + for(unsigned i = 0; i * alias = ctx.m_aliasUsed[i]; + if(alias->function != 0){ + /** + * Report alias usage with callback (if specified by user) + */ + DEBUG("Alias usage with callback"); + (t.* alias->function)(ctx, * p); + } + } + + if(cmd->function == 0){ + ctx.m_status = CommandWithoutFunction; + DEBUG("CommandWithoutFunction"); + delete p; + return false; + } + (t.* cmd->function)(ctx, * p); // Call the function + delete p; + return true; + } + DEBUG(""); + return false; +} + +template +inline +const Properties * +Parser::parse(Context &ctx, T &t) { + const Properties * p; + volatile bool stop = false; + DEBUG("Executing Parser::parse"); + + if(impl->run((ParserImpl::Context*)&ctx, &p, &stop)){ + const ParserRow * cmd = ctx.m_currentCmd; // Cast to correct type + if(cmd == 0){ + /** + * Should happen if run returns true + */ + abort(); + } + + for(unsigned i = 0; i * alias = ctx.m_aliasUsed[i]; + if(alias->function != 0){ + /** + * Report alias usage with callback (if specified by user) + */ + DEBUG("Alias usage with callback"); + (t.* alias->function)(ctx, * p); + } + } + + if(cmd->function == 0){ + DEBUG("CommandWithoutFunction"); + ctx.m_status = CommandWithoutFunction; + return p; + } + return p; + } + DEBUG(""); + return NULL; +} + +template +inline +bool +Parser::getBreakOnCommand() const{ + return impl->m_breakOnCmd; +} + +template +inline +void +Parser::setBreakOnCommand(bool v){ + impl->m_breakOnCmd = v; +} + +template +inline +bool +Parser::getBreakOnEmptyLine() const{ + return impl->m_breakOnEmpty; +} +template +inline +void +Parser::setBreakOnEmptyLine(bool v){ + impl->m_breakOnEmpty = v; +} + +template +inline +bool +Parser::getBreakOnInvalidArg() const{ + return impl->m_breakOnInvalidArg; +} + +template +inline +void +Parser::setBreakOnInvalidArg(bool v){ + impl->m_breakOnInvalidArg; +} + +#endif diff --git a/ndb/include/util/Properties.hpp b/ndb/include/util/Properties.hpp new file mode 100644 index 00000000000..dbdc5f2b480 --- /dev/null +++ b/ndb/include/util/Properties.hpp @@ -0,0 +1,246 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef PROPERTIES_HPP +#define PROPERTIES_HPP + +#include +#include +#include +#include +#include +#include + +enum PropertiesType { + PropertiesType_Uint32, + PropertiesType_char, + PropertiesType_Properties +}; + +/** + * @struct Property + * @brief Stores one (name, value)-pair + * + * Value can be of type Properties, i.e. a Property may contain + * a Properties object. + */ +struct Property { + Property(const char* name, Uint32 val); + Property(const char* name, const char * value); + Property(const char* name, const class Properties * value); + ~Property(); +private: + friend class Properties; + struct PropertyImpl * impl; +}; + +/** + * @class Properties + * @brief Stores information in (name, value)-pairs + */ +class Properties { +public: + static const char delimiter = ':'; + static const char version[]; + + Properties(); + Properties(const Properties &); + Properties(const Property *, int len); + virtual ~Properties(); + + /** + * Set/Get wheather names in the Properties should be compared + * w/o case. + * NOTE: The property is automatically applied to all propoerties put + * into this after a called to setCaseInsensitiveNames has been made + * But properties already in when calling setCaseInsensitiveNames will + * not be affected + */ + void setCaseInsensitiveNames(bool value); + bool getCaseInsensitiveNames() const; + + /** + * Insert an array of value(s) + */ + void put(const Property *, int len); + + bool put(const char * name, Uint32 value, bool replace = false); + bool put(const char * name, const char * value, bool replace = false); + bool put(const char * name, const Properties * value, bool replace = false); + + /** + * Same as put above, + * except that _%d (where %d is a number) is added to the name + * Compare get(name, no) + */ + bool put(const char *, Uint32 no, Uint32, bool replace = false); + bool put(const char *, Uint32 no, const char *, bool replace = false); + bool put(const char *, Uint32 no, const Properties *, bool replace = false); + + + bool getTypeOf(const char * name, PropertiesType * type) const; + + /** @return true if Properties object contains name */ + bool contains(const char * name) const; + + bool get(const char * name, Uint32 * value) const; + bool get(const char * name, const char ** value) const; + bool get(const char * name, BaseString & value) const; + bool get(const char * name, const Properties ** value) const; + + bool getCopy(const char * name, char ** value) const; + bool getCopy(const char * name, Properties ** value) const; + + /** + * Same as get above + * except that _%d (where %d = no) is added to the name + */ + bool getTypeOf(const char * name, Uint32 no, PropertiesType * type) const; + bool contains(const char * name, Uint32 no) const; + + bool get(const char * name, Uint32 no, Uint32 * value) const; + bool get(const char * name, Uint32 no, const char ** value) const; + bool get(const char * name, Uint32 no, const Properties ** value) const; + + bool getCopy(const char * name, Uint32 no, char ** value) const; + bool getCopy(const char * name, Uint32 no, Properties ** value) const; + + void clear(); + + void remove(const char * name); + + void print(FILE * file = stdout, const char * prefix = 0) const; + /** + * Iterator over names + */ + class Iterator { + public: + Iterator(const Properties* prop); + + const char* first(); + const char* next(); + private: + const Properties* m_prop; + Uint32 m_iterator; + }; + friend class Properties::Iterator; + + Uint32 getPackedSize() const; + bool pack(Uint32 * buf) const; + bool pack(UtilBuffer &buf) const; + bool unpack(const Uint32 * buf, Uint32 bufLen); + bool unpack(UtilBuffer &buf); + + Uint32 getPropertiesErrno() const { return propErrno; } + Uint32 getOSErrno() const { return osErrno; } +private: + Uint32 propErrno; + Uint32 osErrno; + + friend class PropertiesImpl; + class PropertiesImpl * impl; + class Properties * parent; + + void setErrno(Uint32 pErr, Uint32 osErr = 0) const ; +}; + +/** + * Error code for properties + */ + +/** + * No error + */ +extern const Uint32 E_PROPERTIES_OK; + +/** + * Invalid name in put, names can not contain Properties::delimiter + */ +extern const Uint32 E_PROPERTIES_INVALID_NAME; + +/** + * Element did not exist when using get + */ +extern const Uint32 E_PROPERTIES_NO_SUCH_ELEMENT; + +/** + * Element had wrong type when using get + */ +extern const Uint32 E_PROPERTIES_INVALID_TYPE; + +/** + * Element already existed when using put, and replace was not specified + */ +extern const Uint32 E_PROPERTIES_ELEMENT_ALREADY_EXISTS; + +/** + * Invalid version on properties file you are trying to read + */ +extern const Uint32 E_PROPERTIES_INVALID_VERSION_WHILE_UNPACKING; + +/** + * When unpacking an buffer + * found that buffer is to short + * + * Probably an invlaid buffer + */ +extern const Uint32 E_PROPERTIES_INVALID_BUFFER_TO_SHORT; + +/** + * Error when packing, can not allocate working buffer + * + * Note: OS error is set + */ +extern const Uint32 E_PROPERTIES_ERROR_MALLOC_WHILE_PACKING; + +/** + * Error when unpacking, can not allocate working buffer + * + * Note: OS error is set + */ +extern const Uint32 E_PROPERTIES_ERROR_MALLOC_WHILE_UNPACKING; + +/** + * Error when unpacking, invalid checksum + * + */ +extern const Uint32 E_PROPERTIES_INVALID_CHECKSUM; + +/** + * Error when unpacking + * No of items > 0 while size of buffer (left) <= 0 + */ +extern const Uint32 E_PROPERTIES_BUFFER_TO_SMALL_WHILE_UNPACKING; + +inline bool +Properties::unpack(UtilBuffer &buf) { + return unpack((const Uint32 *)buf.get_data(), buf.length()); +} + +inline bool +Properties::pack(UtilBuffer &buf) const { + Uint32 size = getPackedSize(); + char *tmp_buf = new char[size]; + bool ret = pack((Uint32 *)tmp_buf); + if(ret == false) + return false; + buf.append(tmp_buf, size); + return true; +} + + + +#endif diff --git a/ndb/include/util/SimpleProperties.hpp b/ndb/include/util/SimpleProperties.hpp new file mode 100644 index 00000000000..37e28ea91d8 --- /dev/null +++ b/ndb/include/util/SimpleProperties.hpp @@ -0,0 +1,290 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SIMPLE_PROPERTIES_HPP +#define SIMPLE_PROPERTIES_HPP + +#include +#include // offsetof +#include + +/** + * @class SimpleProperties + * @brief Key-value-pair container. Actully a list of named elements. + * + * SimpleProperties: + * - The keys are Uint16 + * - The values are either Uint32 or null terminated c-strings + * + * @note Keys may be repeated. + * + * Examples of things that can be stored in a SimpleProperties object: + * - Lists like: ((1, "foo"), (2, "bar"), (3, 32), (2, "baz")) + */ +class SimpleProperties { +public: + /** + * Value types + */ + enum ValueType { + Uint32Value = 0, + StringValue = 1, + BinaryValue = 2, + InvalidValue = 3 + }; + + /** + * Struct for defining mapping to be used with unpack + */ + struct SP2StructMapping { + Uint16 Key; + Uint32 Offset; + SimpleProperties::ValueType Type; + Uint32 minValue; + Uint32 maxValue; + Uint32 Length_Offset; // Offset used for looking up length of + // data if Type = BinaryValue + }; + + /** + * UnpackStatus - Value returned from unpack + */ + enum UnpackStatus { + Eof = 0, // Success, end of SimpleProperties object reached + Break = 1, // Success + TypeMismatch = 2, + ValueTooLow = 3, + ValueTooHigh = 4, + UnknownKey = 5, + OutOfMemory = 6 // Only used when packing + }; + + /** + * Unpack + */ + class Reader; + static UnpackStatus unpack(class Reader & it, + void * dst, + const SP2StructMapping[], Uint32 mapSz, + bool ignoreMinMax, + bool ignoreUnknownKeys); + + class Writer; + static UnpackStatus pack(class Writer &, + const void * src, + const SP2StructMapping[], Uint32 mapSz, + bool ignoreMinMax); + + /** + * Reader class + */ + class Reader { + public: + /** + * Move to first element + * Return true if element exist + */ + bool first(); + + /** + * Move to next element + * Return true if element exist + */ + bool next(); + + /** + * Is this valid + */ + bool valid() const; + + /** + * Get key + * Note only valid is valid() == true + */ + Uint16 getKey() const; + + /** + * Get value length in bytes - (including terminating 0 for strings) + * Note only valid is valid() == true + */ + Uint16 getValueLen() const; + + /** + * Get value type + * Note only valid is valid() == true + */ + ValueType getValueType() const; + + /** + * Get value + * Note only valid is valid() == true + */ + Uint32 getUint32() const; + char * getString(char * dst) const; + + /** + * Print the complete simple properties (for debugging) + */ + void printAll(NdbOut& ndbout); + + private: + bool readValue(); + + Uint16 m_key; + Uint16 m_itemLen; + union { + Uint32 m_ui32_value; + Uint32 m_strLen; // Including 0-byte in words + }; + ValueType m_type; + protected: + Reader(); + virtual void reset() = 0; + + virtual bool step(Uint32 len) = 0; + virtual bool getWord(Uint32 * dst) = 0; + virtual bool peekWord(Uint32 * dst) const = 0; + virtual bool peekWords(Uint32 * dst, Uint32 len) const = 0; + }; + + /** + * Writer class + */ + class Writer { + public: + bool first(); + bool add(Uint16 key, Uint32 value); + bool add(Uint16 key, const char * value); + bool add(Uint16 key, const void* value, int len); + protected: + virtual bool reset() = 0; + virtual bool putWord(Uint32 val) = 0; + virtual bool putWords(const Uint32 * src, Uint32 len) = 0; + }; +}; + +/** + * Reader for linear memory + */ +class SimplePropertiesLinearReader : public SimpleProperties::Reader { +public: + SimplePropertiesLinearReader(const Uint32 * src, Uint32 len); + + virtual void reset(); + virtual bool step(Uint32 len); + virtual bool getWord(Uint32 * dst); + virtual bool peekWord(Uint32 * dst) const ; + virtual bool peekWords(Uint32 * dst, Uint32 len) const; +private: + Uint32 m_len; + Uint32 m_pos; + const Uint32 * m_src; +}; + +/** + * Writer for linear memory + */ +class LinearWriter : public SimpleProperties::Writer { +public: + LinearWriter(Uint32 * src, Uint32 len); + + virtual bool reset(); + virtual bool putWord(Uint32 val); + virtual bool putWords(const Uint32 * src, Uint32 len); + Uint32 getWordsUsed() const; +private: + Uint32 m_len; + Uint32 m_pos; + Uint32 * m_src; +}; + +/** + * Writer for linear memory + */ +class UtilBufferWriter : public SimpleProperties::Writer { +public: + UtilBufferWriter(class UtilBuffer & buf); + + virtual bool reset(); + virtual bool putWord(Uint32 val); + virtual bool putWords(const Uint32 * src, Uint32 len); + Uint32 getWordsUsed() const; +private: + class UtilBuffer & m_buf; +}; + +/** + * Reader for long signal section memory + * + * + * Implemented in kernel/vm/SimplePropertiesSection.cpp + */ +class SimplePropertiesSectionReader : public SimpleProperties::Reader { +public: + SimplePropertiesSectionReader(class SegmentedSectionPtr &, + class SectionSegmentPool &); + + virtual void reset(); + virtual bool step(Uint32 len); + virtual bool getWord(Uint32 * dst); + virtual bool peekWord(Uint32 * dst) const ; + virtual bool peekWords(Uint32 * dst, Uint32 len) const; + Uint32 getSize() const; + bool getWords(Uint32 * dst, Uint32 len); + +private: + Uint32 m_pos; + Uint32 m_len; + class SectionSegmentPool & m_pool; + class SectionSegment * m_head; + class SectionSegment * m_currentSegment; +}; + +inline +Uint32 SimplePropertiesSectionReader::getSize() const +{ + return m_len; +} + +/** + * Writer for long signal section memory + * + * + * Implemented in kernel/vm/SimplePropertiesSection.cpp + */ +class SimplePropertiesSectionWriter : public SimpleProperties::Writer { +public: + SimplePropertiesSectionWriter(class SectionSegmentPool &); + + virtual bool reset(); + virtual bool putWord(Uint32 val); + virtual bool putWords(const Uint32 * src, Uint32 len); + + /** + * This "unlinks" the writer from the memory + */ + void getPtr(class SegmentedSectionPtr & dst); + +private: + Int32 m_pos; + Uint32 m_sz; + class SectionSegmentPool & m_pool; + class SectionSegment * m_head; + Uint32 m_prevPtrI; // Prev to m_currentSegment + class SectionSegment * m_currentSegment; +}; + +#endif diff --git a/ndb/include/util/SocketServer.hpp b/ndb/include/util/SocketServer.hpp new file mode 100644 index 00000000000..f1ce5182183 --- /dev/null +++ b/ndb/include/util/SocketServer.hpp @@ -0,0 +1,132 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SOCKET_SERVER_HPP +#define SOCKET_SERVER_HPP + +#include +#include +#include +#include + +extern "C" void* sessionThread_C(void*); +extern "C" void* socketServerThread_C(void*); + +/** + * Socket Server + */ +class SocketServer { +public: + /** + * A Session + */ + class Session { + public: + virtual ~Session() {} + virtual void runSession(){} + virtual void stopSession(){} + protected: + friend class SocketServer; + friend void* sessionThread_C(void*); + Session(NDB_SOCKET_TYPE sock): m_socket(sock){ m_stop = m_stopped = false;} + + bool m_stop; // Has the session been ordered to stop? + bool m_stopped; // Has the session stopped? + + NDB_SOCKET_TYPE m_socket; + }; + + /** + * A service i.e. a session factory + */ + class Service { + public: + virtual ~Service(){} + + /** + * Returned Session will be ran in own thread + * + * To manage threads self, just return NULL + */ + virtual Session * newSession(NDB_SOCKET_TYPE theSock) = 0; + + virtual void stopSessions() {} + }; + + /** + * Constructor / Destructor + */ + SocketServer(int maxSessions = 32); + ~SocketServer(); + + /** + * Setup socket and bind it + * then close the socket + * Returns true if succeding in binding + */ + bool tryBind(unsigned short port, const char * intface = 0) const; + + /** + * Setup socket + * bind & listen + * Returns false if no success + */ + bool setup(Service *, unsigned short port, const char * pinterface = 0); + + /** + * start/stop the server + */ + void startServer(); + void stopServer(); + + /** + * stop sessions + * + * Note: Implies stopServer + */ + void stopSessions(bool wait = false); + +private: + struct SessionInstance { + Service * m_service; + Session * m_session; + NdbThread * m_thread; + }; + struct ServiceInstance { + Service * m_service; + NDB_SOCKET_TYPE m_socket; + }; + MutexVector m_sessions; + MutexVector m_services; + unsigned m_maxSessions; + + void doAccept(); + void checkSessions(); + void startSession(SessionInstance &); + + /** + * Note, this thread is only used when running interactive + * + */ + bool m_stopThread; + struct NdbThread * m_thread; + NdbLockable m_threadLock; + void doRun(); + friend void* socketServerThread_C(void*); + friend void* sessionThread_C(void*); +}; + +#endif diff --git a/ndb/include/util/UtilBuffer.hpp b/ndb/include/util/UtilBuffer.hpp new file mode 100644 index 00000000000..97821ee3f9b --- /dev/null +++ b/ndb/include/util/UtilBuffer.hpp @@ -0,0 +1,90 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef __BUFFER_HPP_INCLUDED__ +#define __BUFFER_HPP_INCLUDED__ + +#include +#include +#include + +/* This class represents a buffer of binary data, where you can append + * data at the end, and later read the entire bunch. + * It will take care of the hairy details of realloc()ing the space + * for you + */ +class UtilBuffer { +public: + UtilBuffer() { data = NULL; len = 0; alloc_size = 0; }; + ~UtilBuffer() { if(data) free(data); data = NULL; len = 0; alloc_size = 0; }; + + + int reallocate(size_t newsize) { + if(newsize < len) { + errno = EINVAL; + return -1; + } + void *newdata; + if((newdata = realloc(data, newsize)) == NULL) { + errno = ENOMEM; + return -1; + } + alloc_size = newsize; + data = newdata; + return 0; + }; + + int grow(size_t l) { + if(l > alloc_size) + return reallocate(l); + return 0; + }; + + int append(const void *d, size_t l) { + int ret; + ret = grow(len+l); + if(ret != 0) + return ret; + + memcpy((char *)data+len, d, l); + len+=l; + + return 0; + }; + + int assign(const void * d, size_t l) { + if (data) free(data); + data = NULL; + len = 0; + alloc_size = 0; + return append(d, l); + } + + void clear() { + len = 0; + } + + int length() const { return len; }; + + void *get_data() const { return data; }; +private: + void *data; /* Pointer to data storage */ + size_t len; /* Size of the stored data */ + size_t alloc_size; /* Size of the allocated space, + * i.e. len can grow to this size */ +}; + +#endif /* !__BUFFER_HPP_INCLUDED__ */ diff --git a/ndb/include/util/Vector.hpp b/ndb/include/util/Vector.hpp new file mode 100644 index 00000000000..a717dfecd7e --- /dev/null +++ b/ndb/include/util/Vector.hpp @@ -0,0 +1,289 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_VECTOR_HPP +#define NDB_VECTOR_HPP + +#include +#include +#include + +template +struct Vector { +public: + Vector(int sz = 10); + ~Vector(); + + T& operator[](unsigned i); + const T& operator[](unsigned i) const; + unsigned size() const { return m_size; }; + + void push_back(const T &); + T& back(); + + void erase(unsigned index); + + void clear(); + + void fill(unsigned new_size, T & obj); + + Vector& operator=(const Vector&); + + T* getBase() { return m_items;} + const T* getBase() const { return m_items;} +private: + T * m_items; + unsigned m_size; + unsigned m_incSize; + unsigned m_arraySize; +}; + +template +Vector::Vector(int i){ + m_items = new T[i]; + m_size = 0; + m_arraySize = i; + m_incSize = 50; +} + +template +Vector::~Vector(){ + delete[] m_items; +} + +template +T & +Vector::operator[](unsigned i){ + if(i >= m_size) + abort(); + return m_items[i]; +} + +template +const T & +Vector::operator[](unsigned i) const { + if(i >= m_size) + abort(); + return m_items[i]; +} + +template +T & +Vector::back(){ + return (* this)[m_size - 1]; +} + +template +void +Vector::push_back(const T & t){ + if(m_size == m_arraySize){ + T * tmp = new T [m_arraySize + m_incSize]; + for (unsigned k = 0; k < m_size; k++) + tmp[k] = m_items[k]; + delete[] m_items; + m_items = tmp; + m_arraySize = m_arraySize + m_incSize; + } + m_items[m_size] = t; + m_size++; +} + +template +void +Vector::erase(unsigned i){ + if(i >= m_size) + abort(); + + for (unsigned k = i; k + 1 < m_size; k++) + m_items[k] = m_items[k + 1]; + m_size--; +} + +template +void +Vector::clear(){ + m_size = 0; +} + +template +void +Vector::fill(unsigned new_size, T & obj){ + while(m_size <= new_size) + push_back(obj); +} + +template +Vector& +Vector::operator=(const Vector& obj){ + if(this != &obj){ + clear(); + for(size_t i = 0; i +struct MutexVector : public NdbLockable { + MutexVector(int sz = 10); + ~MutexVector(); + + T& operator[](unsigned i); + const T& operator[](unsigned i) const; + unsigned size() const { return m_size; }; + + void push_back(const T &); + void push_back(const T &, bool lockMutex); + T& back(); + + void erase(unsigned index); + void erase(unsigned index, bool lockMutex); + + void clear(); + void clear(bool lockMutex); + + void fill(unsigned new_size, T & obj); +private: + T * m_items; + unsigned m_size; + unsigned m_incSize; + unsigned m_arraySize; +}; + +template +MutexVector::MutexVector(int i){ + m_items = new T[i]; + m_size = 0; + m_arraySize = i; + m_incSize = 50; +} + +template +MutexVector::~MutexVector(){ + delete[] m_items; +} + +template +T & +MutexVector::operator[](unsigned i){ + if(i >= m_size) + abort(); + return m_items[i]; +} + +template +const T & +MutexVector::operator[](unsigned i) const { + if(i >= m_size) + abort(); + return m_items[i]; +} + +template +T & +MutexVector::back(){ + return (* this)[m_size - 1]; +} + +template +void +MutexVector::push_back(const T & t){ + lock(); + if(m_size == m_arraySize){ + T * tmp = new T [m_arraySize + m_incSize]; + for (unsigned k = 0; k < m_size; k++) + tmp[k] = m_items[k]; + delete[] m_items; + m_items = tmp; + m_arraySize = m_arraySize + m_incSize; + } + m_items[m_size] = t; + m_size++; + unlock(); +} + +template +void +MutexVector::push_back(const T & t, bool lockMutex){ + if(lockMutex) + lock(); + if(m_size == m_arraySize){ + T * tmp = new T [m_arraySize + m_incSize]; + for (unsigned k = 0; k < m_size; k++) + tmp[k] = m_items[k]; + delete[] m_items; + m_items = tmp; + m_arraySize = m_arraySize + m_incSize; + } + m_items[m_size] = t; + m_size++; + if(lockMutex) + unlock(); +} + +template +void +MutexVector::erase(unsigned i){ + if(i >= m_size) + abort(); + + lock(); + for (unsigned k = i; k + 1 < m_size; k++) + m_items[k] = m_items[k + 1]; + m_size--; + unlock(); +} + +template +void +MutexVector::erase(unsigned i, bool _lock){ + if(i >= m_size) + abort(); + + if(_lock) + lock(); + for (unsigned k = i; k + 1 < m_size; k++) + m_items[k] = m_items[k + 1]; + m_size--; + if(_lock) + unlock(); +} + +template +void +MutexVector::clear(){ + lock(); + m_size = 0; + unlock(); +} + +template +void +MutexVector::clear(bool l){ + if(l) lock(); + m_size = 0; + if(l) unlock(); +} + +template +void +MutexVector::fill(unsigned new_size, T & obj){ + while(m_size <= new_size) + push_back(obj); +} + +#endif diff --git a/ndb/include/util/getarg.h b/ndb/include/util/getarg.h new file mode 100644 index 00000000000..713cf6e4b32 --- /dev/null +++ b/ndb/include/util/getarg.h @@ -0,0 +1,115 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* + * Copyright (c) 1997, 1999 Kungliga Tekniska Högskolan + * (Royal Institute of Technology, Stockholm, Sweden). + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* $KTH: getarg.h,v 1.9 2000/09/01 21:25:55 lha Exp $ */ + +#ifndef __GETARG_H__ +#define __GETARG_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + arg_integer, + arg_string, + arg_flag, + arg_negative_flag, + arg_strings, + arg_double, + arg_collect, + arg_counter +} arg_type; + +struct getargs{ + const char *long_name; + char short_name; + arg_type type; + void *value; + const char *help; + const char *arg_help; +}; + +enum { + ARG_ERR_NO_MATCH = 1, + ARG_ERR_BAD_ARG, + ARG_ERR_NO_ARG +}; + +typedef struct getarg_strings { + int num_strings; + char **strings; +} getarg_strings; + +typedef int (*getarg_collect_func)(int short_opt, + int argc, + const char **argv, + int *optind, + int *optarg, + void *data); + +typedef struct getarg_collect_info { + getarg_collect_func func; + void *data; +} getarg_collect_info; + +int getarg(struct getargs *args, size_t num_args, + int argc, const char **argv, int *optind); + +void arg_printusage (struct getargs *args, + size_t num_args, + const char *progname, + const char *extra_string); +#ifdef __cplusplus +} +#endif + +#endif /* __GETARG_H__ */ diff --git a/ndb/include/util/md5_hash.hpp b/ndb/include/util/md5_hash.hpp new file mode 100644 index 00000000000..4c3cf239881 --- /dev/null +++ b/ndb/include/util/md5_hash.hpp @@ -0,0 +1,25 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef MD5_HASH_H +#define MD5_HASH_H + +#include + +// External declaration of hash function +Uint32 md5_hash(const Uint64* keybuf, Uint32 no_of_32_words); + +#endif diff --git a/ndb/include/util/random.h b/ndb/include/util/random.h new file mode 100644 index 00000000000..1b83e5fec93 --- /dev/null +++ b/ndb/include/util/random.h @@ -0,0 +1,84 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef RANDOM_H +#define RANDOM_H + +/*************************************************************** +* I N C L U D E D F I L E S * +***************************************************************/ + +/*************************************************************** +* M A C R O S * +***************************************************************/ + +/***************************************************************/ +/* C O N S T A N T S */ +/***************************************************************/ + + +/*************************************************************** +* D A T A S T R U C T U R E S * +***************************************************************/ + +typedef struct { + unsigned int length; + unsigned int *values; + unsigned int currentIndex; +}RandomSequence; + +typedef struct { + unsigned int length; + unsigned int value; +}SequenceValues; + +/*************************************************************** +* P U B L I C F U N C T I O N S * +***************************************************************/ + +#ifdef __cplusplus +extern "C" { +#endif + + +extern double getTps(unsigned int count, double timeValue); + +/*----------------------------*/ +/* Random Sequences Functions */ +/*----------------------------*/ +extern int initSequence(RandomSequence *seq, SequenceValues *inputValues); +extern unsigned int getNextRandom(RandomSequence *seq); +extern void printSequence(RandomSequence *seq, unsigned int numPerRow); + +/*---------------------------------------------------*/ +/* Code from the glibc, to make sure the same random */ +/* number generator is used by all */ +/*---------------------------------------------------*/ +extern void myRandom48Init(long int seedval); +extern long int myRandom48(unsigned int maxValue); + +#ifdef __cplusplus +} +#endif + +/*************************************************************** +* E X T E R N A L D A T A * +***************************************************************/ + + + +#endif /* RANDOM_H */ + diff --git a/ndb/include/util/socket_io.h b/ndb/include/util/socket_io.h new file mode 100644 index 00000000000..bbd1bf115ae --- /dev/null +++ b/ndb/include/util/socket_io.h @@ -0,0 +1,40 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef _SOCKET_IO_H +#define _SOCKET_IO_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + int read_socket(NDB_SOCKET_TYPE, int timeout_ms, char *, int len); + int readln_socket(NDB_SOCKET_TYPE, int timeout_ms, char *, int len); + int write_socket(NDB_SOCKET_TYPE, int timeout_ms, const char[], int len); + + int print_socket(NDB_SOCKET_TYPE, int timeout_ms, const char *, ...); + int println_socket(NDB_SOCKET_TYPE, int timeout_ms, const char *, ...); + int vprint_socket(NDB_SOCKET_TYPE, int timeout_ms, const char *, va_list); + int vprintln_socket(NDB_SOCKET_TYPE, int timeout_ms, const char *, va_list); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/ndb/include/util/uucode.h b/ndb/include/util/uucode.h new file mode 100644 index 00000000000..138a79fa3ae --- /dev/null +++ b/ndb/include/util/uucode.h @@ -0,0 +1,36 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef UUCODE_H +#define UUCODE_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + + void uuencode(const char * data, int dataLen, FILE * out); + int uudecode(FILE * input, char * outBuf, int bufLen); + + int uuencode_mem(char * dst, const char * src, int src_len); + int uudecode_mem(char * dst, int dst_len, const char * src); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/ndb/include/util/version.h b/ndb/include/util/version.h new file mode 100644 index 00000000000..a82ae4b8b52 --- /dev/null +++ b/ndb/include/util/version.h @@ -0,0 +1,50 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#ifndef VERSION_H +#define VERSION_H +#include +#ifdef __cplusplus +extern "C" { +#endif + + Uint32 getMajor(Uint32 version); + + Uint32 getMinor(Uint32 version); + + Uint32 getBuild(Uint32 version); + + Uint32 makeVersion(Uint32 major, Uint32 minor, Uint32 build); + + char* getVersionString(Uint32 version, char * status); + + void ndbPrintVersion(); + Uint32 ndbGetOwnVersion(); + + int ndbCompatible_mgmt_ndb(Uint32 ownVersion, Uint32 otherVersion); + int ndbCompatible_ndb_mgmt(Uint32 ownVersion, Uint32 otherVersion); + int ndbCompatible_mgmt_api(Uint32 ownVersion, Uint32 otherVersion); + int ndbCompatible_api_mgmt(Uint32 ownVersion, Uint32 otherVersion); + int ndbCompatible_api_ndb(Uint32 ownVersion, Uint32 otherVersion); + int ndbCompatible_ndb_api(Uint32 ownVersion, Uint32 otherVersion); + int ndbCompatible_ndb_ndb(Uint32 ownVersion, Uint32 otherVersion); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/ndb/lib/.empty b/ndb/lib/.empty new file mode 100644 index 00000000000..e69de29bb2d diff --git a/ndb/mysqlclusterenv.sh b/ndb/mysqlclusterenv.sh new file mode 100644 index 00000000000..e151186d01e --- /dev/null +++ b/ndb/mysqlclusterenv.sh @@ -0,0 +1,51 @@ +# Sets necessary environment variables for mysqlcluster install scripts +mytop= +if [ -f bin/mysql ]; then + mytop=`/bin/pwd` +elif [ -f bin/ndb ]; then + mytop=`dirname \`/bin/pwd\`` +fi +if [ "$mytop" ]; then + MYSQLCLUSTER_TOP=$mytop + PATH=$MYSQLCLUSTER_TOP/bin:$MYSQLCLUSTER_TOP/ndb/bin:$PATH + LD_LIBRARY_PATH=$MYSQLCLUSTER_TOP/lib:$LD_LIBRARY_PATH + LD_LIBRARY_PATH=$MYSQLCLUSTER_TOP/ndb/lib:$LD_LIBRARY_PATH + export MYSQLCLUSTER_TOP PATH LD_LIBRARY_PATH +else +if [ -d SCCS ]; then +if [ -f ndb/mysqlclusterenv.sh ]; then + mytop=`/bin/pwd` +elif [ -f mysqlclusterenv.sh ]; then + mytop=`dirname \`/bin/pwd\`` +fi +fi +if [ "$mytop" ]; then +# we're in the development tree + if [ "$REAL_EMAIL" ]; then :; else +#Guessing REAL_EMAIL + REAL_EMAIL=`whoami`@mysql.com + export REAL_EMAIL + echo Setting REAL_EMAIL=$REAL_EMAIL + fi + + MYSQLCLUSTER_TOP=$mytop + + NDB_TOP=$MYSQLCLUSTER_TOP/ndb + export NDB_TOP + + NDB_PROJ_HOME=$NDB_TOP/home + export NDB_PROJ_HOME + + PATH=$MYSQLCLUSTER_TOP/ndb/bin:$MYSQLCLUSTER_TOP/ndb/home/bin:$PATH + PATH=$MYSQLCLUSTER_TOP/client:$PATH + PATH=$MYSQLCLUSTER_TOP/sql:$PATH + LD_LIBRARY_PATH=$MYSQLCLUSTER_TOP/libmysql:$LD_LIBRARY_PATH + LD_LIBRARY_PATH=$MYSQLCLUSTER_TOP/libmysqld:$LD_LIBRARY_PATH + LD_LIBRARY_PATH=$MYSQLCLUSTER_TOP/ndb/lib:$LD_LIBRARY_PATH + LD_LIBRARY_PATH=$MYSQLCLUSTER_TOP/libmysql_r/.libs:$LD_LIBRARY_PATH + export MYSQLCLUSTER_TOP PATH LD_LIBRARY_PATH +else + echo "Please source this file (mysqlclusterenv.sh) from installation top directory" +fi +fi +mytop= diff --git a/ndb/src/Makefile b/ndb/src/Makefile new file mode 100644 index 00000000000..c4a58871f3b --- /dev/null +++ b/ndb/src/Makefile @@ -0,0 +1,34 @@ +include .defs.mk + +DIRS := \ + client \ + common \ + kernel \ + ndbapi \ + env \ + mgmsrv \ + mgmapi \ + rep \ + mgmclient \ + cw \ + newtonapi \ + ndbbaseclient +ifneq ($(NDB_ODBC),N) + DIRS += ndbclient +endif +ifeq ($(findstring OSE, $(NDB_OS)),) + DIRS += scripts +endif +include $(NDB_TOP)/Epilogue.mk + +_bins_mgmsrv: _libs_ndbapi +_bins_mgmsrv: _libs_mgmapi +_bins_mgmclient: _libs_mgmapi +_bins_mgmclient: _libs_common +_bins_client: _bins_ndbapi +_bins_common: _bins_mgmapi +_bins_kernel: _bins_ndbapi +_bins_newtonapi: _bins_ndbapi +_bins_mgmapi : _libs_common +_bins_rep: _libs_common +_bins_rep: _libs_ndbapi diff --git a/ndb/src/client/Makefile b/ndb/src/client/Makefile new file mode 100644 index 00000000000..1751a98bdfe --- /dev/null +++ b/ndb/src/client/Makefile @@ -0,0 +1,9 @@ +include .defs.mk + +DIRS = + +ifneq ($(NDB_ODBC),N) +DIRS += odbc +endif + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/client/odbc/Extra.mk b/ndb/src/client/odbc/Extra.mk new file mode 100644 index 00000000000..762fb0bedd0 --- /dev/null +++ b/ndb/src/client/odbc/Extra.mk @@ -0,0 +1,59 @@ +# before Epilogue.mk + +CCFLAGS_LOC += -I.. + +CCFLAGS_LOC += \ + -I$(call fixpath,$(NDB_TOP)/include/ndbapi) \ + -I$(call fixpath,$(NDB_TOP)/include/util) \ + -I$(call fixpath,$(NDB_TOP)/include/portlib) + +ifeq ($(NDB_OS),SOLARIS) + +CCFLAGS_LOC += -I/usr/local/include + +ifeq ($(NDB_COMPILER),GCC) +LIBS_LOC += -Wl,-z,text +CCFLAGS_WARNINGS += -Wno-unused -Wformat +CCFLAGS_TOP += -D__STL_PTHREADS +endif + +ifeq ($(NDB_COMPILER),FORTE6) +LIBS_LOC += -z text +LIBS_SPEC += /usr/lib/libCrun.so.1 +endif + +LIB_TARGET_LIBS += -lthread -lrt + +endif +ifneq ($(filter $(NDB_OS), LINUX MACOSX IBMAIX TRU64X),) + +LIBS_LOC += -Wl,-z,text +CCFLAGS_WARNINGS += -Wno-unused -Wformat +GCC_VER := $(shell $(CC) --version) + +ifeq ($(GCC_VER),2.96) +CCFLAGS_TOP += -D__STL_PTHREADS +CCFLAGS_TOP += -fmessage-length=0 +endif + +CCFLAGS_TOP += -fno-rtti + +LIB_TARGET_LIBS += -lpthread + +endif + +ifeq ($(NDB_OS),WIN32) +ifeq (RELEASE, $(NDB_VERSION)) +CCFLAGS_WIN += /MT /GR /GS /Zi -D_WINDOWS -D_USRDLL -DNDBODBC_EXPORTS -DNO_COMMAND_HANDLER -D_MBCS -D_WINDLL -U_LIB +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +CCFLAGS_WIN += /MT /GR /GS /Zi -D_WINDOWS -D_USRDLL -DNDBODBC_EXPORTS -DNO_COMMAND_HANDLER -D_MBCS -D_WINDLL -U_LIB +else +CCFLAGS_WIN += /MT /GR /GS /Zi -D_WINDOWS -D_USRDLL -DNDBODBC_EXPORTS -DNO_COMMAND_HANDLER -D_MBCS -D_WINDLL -U_LIB +endif +endif +endif + +CCFLAGS_TOP += -DYYDEBUG=0 -fexceptions + +CCFLAGS_TOP += -DHAVE_LONG_LONG diff --git a/ndb/src/client/odbc/Makefile b/ndb/src/client/odbc/Makefile new file mode 100644 index 00000000000..2da683e7d86 --- /dev/null +++ b/ndb/src/client/odbc/Makefile @@ -0,0 +1,75 @@ +include .defs.mk + +TYPE = * + +A_LIB = N +PIC_LIB = Y +SO_LIB = Y + +LIB_TARGET = NDB_ODBC + +LIB_TARGET_ARCHIVES = $(LIB_DIRS:%=odbc%) NDB_API + +# Overide Defs.mk +LDFLAGS_LAST = -lstdc++ -lm + +XXX = \ + ndbapi \ + mgmsrvcommon \ + transporter \ + general \ + signaldataprint \ + portlib \ + logger \ + trace + +ifeq ($(NDB_OS),WIN32) + +LIB_DIRS = \ + handles \ + dictionary \ + codegen \ + executor \ + common + +SOURCES += NdbOdbc.cpp +CFLAGS_NdbOdbc.cpp += -I. -I$(call fixpath,driver) + +PIC_ARCHIVE := Y +NONPIC_ARCHIVE := N +ARCHIVE_TARGET := ndb_odbcwin32 +LIB_TARGET_ARCHIVES += ndb_odbcwin32 + +ifeq (RELEASE, $(NDB_VERSION)) +WIN_LIBS += /VERSION:2.0x /NODEFAULTLIB:"odbc32" /INCREMENTAL:NO /DLL /SUBSYSTEM:WINDOWS /MACHINE:IX86 /OPT:REF /OPT:ICF /DEF:NdbOdbc.def odbc32.lib odbccp32.lib user32.lib +else +ifeq (RELEASE_TRACE, $(NDB_VERSION)) +WIN_LIBS += /VERSION:2.0x /NODEFAULTLIB:"odbc32" /INCREMENTAL:NO /DLL /SUBSYSTEM:WINDOWS /MACHINE:IX86 /OPT:REF /OPT:ICF /DEF:NdbOdbc.def odbc32.lib odbccp32.lib user32.lib +else +WIN_LIBS += /VERSION:2.0x /NODEFAULTLIB:"odbc32" /INCREMENTAL /DLL /DEBUG /SUBSYSTEM:WINDOWS /MACHINE:IX86 /DEF:NdbOdbc.def odbc32.lib odbccp32.lib user32.lib +endif +endif + +else + +LIB_DIRS = \ + driver \ + handles \ + dictionary \ + codegen \ + executor \ + common + +endif + +include Extra.mk +include $(NDB_TOP)/Epilogue.mk + +# yo + +test: + $(MAKE) -j4 + $(MAKE) -C $(NDB_TOP)/tools/ndbsql + $(MAKE) -C $(NDB_TOP)/test/odbc/driver tidy + $(MAKE) -C $(NDB_TOP)/test/odbc/driver + $(MAKE) -C $(NDB_TOP)/test/ndbapi/testOIBasic diff --git a/ndb/src/client/odbc/NdbOdbc.cpp b/ndb/src/client/odbc/NdbOdbc.cpp new file mode 100755 index 00000000000..67c6b5e0004 --- /dev/null +++ b/ndb/src/client/odbc/NdbOdbc.cpp @@ -0,0 +1,78 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include + +#include "driver.cpp" + + +BOOL APIENTRY DllMain( HANDLE hModule, + DWORD ul_reason_for_call, + LPVOID lpReserved + ) +{ + switch (ul_reason_for_call) + { + case DLL_PROCESS_ATTACH: + case DLL_THREAD_ATTACH: + case DLL_THREAD_DETACH: + case DLL_PROCESS_DETACH: + break; + } + return TRUE; +} + + +BOOL INSTAPI ConfigDSN( + HWND hwndParent, + WORD fRequest, + LPCSTR lpszDriver, + LPCSTR lpszAttributes) +{ + const char* szDSN = "NDB"; + + switch(fRequest) + { + case ODBC_ADD_DSN: + SQLWriteDSNToIni(szDSN, lpszDriver); + break; + + case ODBC_CONFIG_DSN: + break; + + case ODBC_REMOVE_DSN: + SQLRemoveDSNFromIni(szDSN); + break; + } + + return TRUE; +} + + +int FAR PASCAL +DriverConnectProc(HWND hdlg, WORD wMsg, WPARAM wParam, LPARAM lParam) +{ + return FALSE; +} + +void __declspec( dllexport) FAR PASCAL LoadByOrdinal(void); +/* Entry point to cause DM to load using ordinals */ +void __declspec( dllexport) FAR PASCAL LoadByOrdinal(void) +{ +} + diff --git a/ndb/src/client/odbc/NdbOdbc.def b/ndb/src/client/odbc/NdbOdbc.def new file mode 100755 index 00000000000..85619b91915 --- /dev/null +++ b/ndb/src/client/odbc/NdbOdbc.def @@ -0,0 +1,85 @@ +LIBRARY NdbOdbc.DLL +VERSION 03.51.00 +EXPORTS +SQLAllocConnect +SQLAllocEnv +SQLAllocHandle +SQLAllocHandleStd +SQLAllocStmt +SQLBindCol +SQLBindParam +SQLBindParameter +SQLBrowseConnect +SQLBulkOperations +SQLCancel +SQLCloseCursor +SQLColAttribute +SQLColAttributes +SQLColumnPrivileges +SQLColumns +SQLConnect +SQLCopyDesc +SQLDataSources +SQLDescribeCol +SQLDescribeParam +SQLDisconnect +SQLDriverConnect +SQLDrivers +SQLEndTran +SQLError +SQLExecDirect +SQLExecute +SQLExtendedFetch +SQLFetch +SQLFetchScroll +SQLForeignKeys +SQLFreeConnect +SQLFreeEnv +SQLFreeHandle +SQLFreeStmt +SQLGetConnectAttr +SQLGetConnectOption +SQLGetCursorName +SQLGetData +SQLGetDescField +SQLGetDescRec +SQLGetDiagField +SQLGetDiagRec +SQLGetEnvAttr +SQLGetFunctions +SQLGetInfo +SQLGetStmtAttr +SQLGetStmtOption +SQLGetTypeInfo +SQLMoreResults +SQLNativeSql +SQLNumParams +SQLNumResultCols +SQLParamData +SQLParamOptions +SQLPrepare +SQLPrimaryKeys +SQLProcedureColumns +SQLProcedures +SQLPutData +SQLRowCount +SQLSetConnectAttr +SQLSetConnectOption +SQLSetCursorName +SQLSetDescField +SQLSetDescRec +SQLSetEnvAttr +SQLSetParam +SQLSetPos +SQLSetScrollOptions +SQLSetStmtAttr +SQLSetStmtOption +SQLSpecialColumns +SQLStatistics +SQLTablePrivileges +SQLTables +SQLTransact +DllMain +DriverConnectProc +ConfigDSN +LoadByOrdinal diff --git a/ndb/src/client/odbc/codegen/CodeGen.cpp b/ndb/src/client/odbc/codegen/CodeGen.cpp new file mode 100644 index 00000000000..6be78b62bd9 --- /dev/null +++ b/ndb/src/client/odbc/codegen/CodeGen.cpp @@ -0,0 +1,229 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "CodeGen.hpp" +#include "Code_root.hpp" + +#include +#include "SimpleParser.hpp" + +void +CodeGen::prepare(Ctx& ctx) +{ + parse(ctx); + if (! ctx.ok()) + return; + analyze(ctx); + if (! ctx.ok()) + return; + describe(ctx); +} + +void +CodeGen::execute(Ctx& ctx) +{ + DescArea& ipd = m_stmtArea.descArea(Desc_usage_IPD); + if (m_stmtArea.m_unbound) { + analyze(ctx); + if (! ctx.ok()) + return; + describe(ctx); + if (! ctx.ok()) + return; + if (m_stmtArea.m_unbound) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "%u input parameters have unbound SQL type", m_stmtArea.m_unbound); + return; + } + ipd.setBound(true); + } + if (! ipd.isBound()) { + ctx_log2(("IPD changed between executes - reanalyze")); + // jdbc can change parameter length at each execute + analyze(ctx); + if (! ctx.ok()) + return; + describe(ctx); + if (! ctx.ok()) + return; + freeExec(ctx); + codegen(ctx); + if (! ctx.ok()) + return; + alloc(ctx); + if (! ctx.ok()) + return; + ipd.setBound(true); + } + if (m_stmtArea.m_execTree == 0) { + codegen(ctx); + if (! ctx.ok()) + return; + alloc(ctx); + if (! ctx.ok()) + return; + } + Executor executor(m_stmtArea); + executor.execute(ctx); +} + +void +CodeGen::fetch(Ctx& ctx) +{ + // XXX parameter types are not checked any more + ctx_assert(! m_stmtArea.m_unbound); + Executor executor(m_stmtArea); + executor.fetch(ctx); +} + +void +CodeGen::parse(Ctx& ctx) +{ + Plan_root* planRoot = new Plan_root(m_stmtArea); + SimpleParser simpleParser(ctx, m_stmtArea, planRoot); + simpleParser.yyparse(); + if (! ctx.ok()) + return; + planRoot->m_paramList.resize(1 + simpleParser.paramNumber()); + ctx_log2(("CodeGen: parse done - plan tree follows")); + if (ctx.logLevel() >= 2) + planRoot->print(ctx); + m_stmtArea.m_planTree = planRoot; +} + +void +CodeGen::analyze(Ctx& ctx) +{ + Plan_root* planRoot = static_cast(m_stmtArea.m_planTree); + ctx_assert(planRoot != 0); + Plan_base::Ctl ctl(0); + planRoot->analyze(ctx, ctl); // returns itself + if (! ctx.ok()) + return; + ctx_log2(("CodeGen: analyze done - plan tree follows")); + if (ctx.logLevel() >= 2) + planRoot->print(ctx); +} + +void +CodeGen::describe(Ctx& ctx) +{ + Plan_root* planRoot = static_cast(m_stmtArea.m_planTree); + ctx_assert(planRoot != 0); + planRoot->describe(ctx); + ctx_log2(("CodeGen: describe done")); +} + +void +CodeGen::codegen(Ctx& ctx) +{ + Plan_root* planRoot = static_cast(m_stmtArea.m_planTree); + ctx_assert(planRoot != 0); + Plan_base::Ctl ctl(0); + Exec_root* execRoot = static_cast(planRoot->codegen(ctx, ctl)); + if (! ctx.ok()) + return; + ctx_assert(execRoot != 0); + ctx_log2(("CodeGen: codegen done - code tree follows")); + if (ctx.logLevel() >= 2) + execRoot->print(ctx); + m_stmtArea.m_execTree = execRoot; +} + +void +CodeGen::alloc(Ctx& ctx) +{ + Exec_root* execRoot = static_cast(m_stmtArea.m_execTree); + ctx_assert(execRoot != 0); + Exec_base::Ctl ctl(0); + execRoot->alloc(ctx, ctl); + if (! ctx.ok()) + return; + ctx_log2(("CodeGen: alloc done")); +} + +void +CodeGen::close(Ctx& ctx) +{ + Exec_root* execRoot = static_cast(m_stmtArea.m_execTree); + if (execRoot != 0) { + execRoot->close(ctx); + ctx_log2(("CodeGen: close done")); + } +} + +void +CodeGen::free(Ctx& ctx) +{ + freePlan(ctx); + freeExec(ctx); +} + +void +CodeGen::freePlan(Ctx & ctx) +{ + if (m_stmtArea.m_planTree != 0) { + Plan_root* planRoot = static_cast(m_stmtArea.m_planTree); + ctx_assert(planRoot != 0); + unsigned count = 1 + planRoot->m_nodeList.size(); + planRoot->freeNodeList(); + delete planRoot; + m_stmtArea.m_planTree = 0; + ctx_log3(("CodeGen: freed %u plan tree nodes", count)); + } +} + +void +CodeGen::freeExec(Ctx & ctx) +{ + if (m_stmtArea.m_execTree != 0) { + Exec_root* execRoot = static_cast(m_stmtArea.m_execTree); + ctx_assert(execRoot != 0); + unsigned count = 1 + execRoot->m_nodeList.size(); + execRoot->freeNodeList(); + delete execRoot; + m_stmtArea.m_execTree = 0; + ctx_log3(("CodeGen: freed %u exec tree nodes", count)); + } +} + +// odbc support + +void +CodeGen::sqlGetData(Ctx& ctx, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, SQLPOINTER targetValue, SQLINTEGER bufferLength, SQLINTEGER* strlen_or_Ind) +{ + Exec_root* execRoot = static_cast(m_stmtArea.m_execTree); + ctx_assert(execRoot != 0); + execRoot->sqlGetData(ctx, columnNumber, targetType, targetValue, bufferLength, strlen_or_Ind); +} + +void +CodeGen::sqlParamData(Ctx& ctx, SQLPOINTER* value) +{ + Exec_root* execRoot = static_cast(m_stmtArea.m_execTree); + ctx_assert(execRoot != 0); + execRoot->sqlParamData(ctx, value); +} + +void +CodeGen::sqlPutData(Ctx& ctx, SQLPOINTER data, SQLINTEGER strlen_or_Ind) +{ + Exec_root* execRoot = static_cast(m_stmtArea.m_execTree); + ctx_assert(execRoot != 0); + execRoot->sqlPutData(ctx, data, strlen_or_Ind); +} diff --git a/ndb/src/client/odbc/codegen/CodeGen.hpp b/ndb/src/client/odbc/codegen/CodeGen.hpp new file mode 100644 index 00000000000..ae61dab0c2a --- /dev/null +++ b/ndb/src/client/odbc/codegen/CodeGen.hpp @@ -0,0 +1,69 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_CodeGen_hpp +#define ODBC_CODEGEN_CodeGen_hpp + +#include + +class StmtArea; +class SqlField; +class ExtField; + +/** + * @class CodeGen + * @brief Compiles SQL text into ExecTree::Code + */ +class CodeGen { +public: + CodeGen(StmtArea& stmtArea); + ~CodeGen(); + // parse and analyze SQL statement + void prepare(Ctx& ctx); + // these are passed to Executor + void execute(Ctx& ctx); + void fetch(Ctx& ctx); + // close statement (mainly scan) + void close(Ctx& ctx); + // free data structures + void free(Ctx& ctx); + // odbc support + void sqlGetData(Ctx& ctx, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, SQLPOINTER targetValue, SQLINTEGER bufferLength, SQLINTEGER* strlen_or_Ind); + void sqlParamData(Ctx& ctx, SQLPOINTER* value); + void sqlPutData(Ctx& ctx, SQLPOINTER data, SQLINTEGER strlen_or_Ind); +private: + void parse(Ctx& ctx); + void analyze(Ctx& ctx); + void describe(Ctx& ctx); + void codegen(Ctx& ctx); + void alloc(Ctx& ctx); + void freePlan(Ctx& ctx); + void freeExec(Ctx& ctx); + StmtArea& m_stmtArea; +}; + +inline +CodeGen::CodeGen(StmtArea& stmtArea) : + m_stmtArea(stmtArea) +{ +} + +inline +CodeGen::~CodeGen() +{ +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_base.cpp b/ndb/src/client/odbc/codegen/Code_base.cpp new file mode 100644 index 00000000000..dc02e071156 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_base.cpp @@ -0,0 +1,167 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Code_base.hpp" +#include "Code_root.hpp" + +// Plan_base + +Plan_base::~Plan_base() +{ +} + +StmtArea& +Plan_base::stmtArea() const +{ + ctx_assert(m_root != 0); + return m_root->m_stmtArea; +} + +DescArea& +Plan_base::descArea(DescUsage u) const +{ + return stmtArea().descArea(u); +} + +ConnArea& +Plan_base::connArea() const +{ + return stmtArea().connArea(); +} + +DictCatalog& +Plan_base::dictCatalog() const +{ + return connArea().dictCatalog(); +} + +DictSchema& +Plan_base::dictSchema() const +{ + return connArea().dictSchema(); +} + +Ndb* +Plan_base::ndbObject() const +{ + Ndb* ndb = connArea().ndbObject(); + ctx_assert(ndb != 0); + return ndb; +} + +NdbSchemaCon* +Plan_base::ndbSchemaCon() const +{ + NdbSchemaCon* ndbSchemaCon = connArea().ndbSchemaCon(); + ctx_assert(ndbSchemaCon != 0); + return ndbSchemaCon; +} + +NdbConnection* +Plan_base::ndbConnection() const +{ + NdbConnection* ndbConnection = connArea().ndbConnection(); + ctx_assert(ndbConnection != 0); + return ndbConnection; +} + +void +Plan_base::printList(Ctx& ctx, Plan_base* a[], unsigned n) +{ + for (unsigned i = 0; i < n; i++) { + if (a[i] == 0) + ctx.print(" -"); + else + a[i]->print(ctx); + } +} + +// Exec_base + +Exec_base::Code::~Code() +{ +} + +Exec_base::Data::~Data() +{ +} + +Exec_base::~Exec_base() +{ + delete m_code; // remove when code becomes shared + m_code = 0; + delete m_data; + m_data = 0; +} + +StmtArea& +Exec_base::stmtArea() const +{ + ctx_assert(m_root != 0); + return m_root->m_stmtArea; +} + +DescArea& +Exec_base::descArea(DescUsage u) const +{ + return stmtArea().descArea(u); +} + +ConnArea& +Exec_base::connArea() const +{ + return stmtArea().connArea(); +} + +DictSchema& +Exec_base::dictSchema() const +{ + return connArea().dictSchema(); +} + +Ndb* +Exec_base::ndbObject() const +{ + Ndb* ndb = connArea().ndbObject(); + ctx_assert(ndb != 0); + return ndb; +} + +NdbSchemaCon* +Exec_base::ndbSchemaCon() const +{ + NdbSchemaCon* ndbSchemaCon = connArea().ndbSchemaCon(); + ctx_assert(ndbSchemaCon != 0); + return ndbSchemaCon; +} + +NdbConnection* +Exec_base::ndbConnection() const +{ + NdbConnection* ndbConnection = connArea().ndbConnection(); + ctx_assert(ndbConnection != 0); + return ndbConnection; +} + +void +Exec_base::printList(Ctx& ctx, Exec_base* a[], unsigned n) +{ + for (unsigned i = 0; i < n; i++) { + ctx_assert(a[i] != 0); + a[i]->print(ctx); + } +} diff --git a/ndb/src/client/odbc/codegen/Code_base.hpp b/ndb/src/client/odbc/codegen/Code_base.hpp new file mode 100644 index 00000000000..c67c0ca7adb --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_base.hpp @@ -0,0 +1,237 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_base_hpp +#define ODBC_CODEGEN_Code_base_hpp + +#include +#include +#include +#include +#include +#include + +class Ctx; +class ConnArea; +class StmtArea; +class DescArea; +class DictCatalog; +class DictSchema; +class ResultArea; +class ResultSet; +class SpecRow; +class Ndb; +class NdbSchemaCon; +class NdbConnection; +class NdbOperation; +class NdbScanFilter; + +class Plan_root; +class Plan_table; +class Plan_column; +class Plan_expr; +class Plan_expr_param; +class Plan_pred; +class Plan_dml_row; +class Plan_dml_column; +class Plan_ddl_column; +class Plan_ddl_constr; +class Plan_idx_column; +class Exec_root; +class Exec_base; +class Exec_query; +class Exec_expr; +class Exec_expr_row; +class Exec_expr_param; + +/** + * @class Plan_base + * @brief Base class for plan trees + */ +class Plan_base : public PlanTree { +public: + Plan_base(Plan_root* root); + virtual ~Plan_base() = 0; + // get references to StmtArea via Plan_root + StmtArea& stmtArea() const; + DescArea& descArea(DescUsage u) const; + ConnArea& connArea() const; + // catalogs + DictCatalog& dictCatalog() const; + DictSchema& dictSchema() const; + // ndb + Ndb* ndbObject() const; + NdbSchemaCon* ndbSchemaCon() const; + NdbConnection* ndbConnection() const; + // containers for Plan classes + typedef std::vector TableVector; + typedef std::vector ColumnVector; + typedef std::vector DmlColumnVector; + typedef std::vector DdlColumnVector; + typedef std::vector DdlConstrVector; + typedef std::vector IdxColumnVector; + typedef std::vector ExprVector; + typedef std::list ExprList; + typedef std::vector ExprListVector; + typedef std::list PredList; + typedef std::set TableSet; + typedef std::vector ParamVector; + // control area on the stack XXX needs to be designed + struct Ctl { + Ctl(Ctl* up); + Ctl* m_up; // up the stack + // analyze + TableVector m_tableList; // resolve column names + bool m_topand; // in top-level where clause + bool m_extra; // anything but single pk=expr + bool m_aggrok; // aggregate allowed + bool m_aggrin; // within aggregate args + bool m_const; // only constants in set clause + PredList m_topcomp; // top level comparisons + Plan_dml_row *m_dmlRow; // row type to convert to + Plan_table* m_topTable; // top level table for interpreted progs + bool m_having; // in having-predicate + // codegen + Exec_root* m_execRoot; // root of Exec tree + const Exec_query* m_execQuery; // pass to column + }; + // semantic analysis and optimization + virtual Plan_base* analyze(Ctx& ctx, Ctl& ctl) = 0; + // generate "executable" code + virtual Exec_base* codegen(Ctx& ctx, Ctl& ctl) = 0; + // misc + virtual void print(Ctx& ctx) = 0; +protected: + Plan_root* m_root; + void printList(Ctx& ctx, Plan_base* a[], unsigned n); +}; + +inline +Plan_base::Plan_base(Plan_root* root) : + m_root(root) +{ + ctx_assert(m_root != 0); +} + +inline +Plan_base::Ctl::Ctl(Ctl* up) : + m_up(up), + m_tableList(1), // 1-based + m_topand(false), + m_extra(false), + m_aggrok(false), + m_aggrin(false), + m_dmlRow(0), + m_topTable(0), + m_having(false), + m_execRoot(0), + m_execQuery(0) +{ +} + +/** + * @class Exec_base + * @brief Base class for exec trees + */ +class Exec_base : public ExecTree { +public: + class Code : public ExecTree::Code { + public: + virtual ~Code() = 0; + }; + class Data : public ExecTree::Data { + public: + virtual ~Data() = 0; + }; + Exec_base(Exec_root* root); + virtual ~Exec_base() = 0; + // get references to StmtArea via Exec_root + virtual StmtArea& stmtArea() const; + DescArea& descArea(DescUsage u) const; + ConnArea& connArea() const; + // catalogs + DictSchema& dictSchema() const; + // ndb + Ndb* ndbObject() const; + NdbSchemaCon* ndbSchemaCon() const; + NdbConnection* ndbConnection() const; + // containers for Exec classes + typedef std::vector ExprVector; + typedef std::vector ParamVector; + // control area on the stack + struct Ctl { + Ctl(Ctl* up); + Ctl* m_up; // up the stack + const Exec_query* m_query; // pass Data + ExprVector m_exprList; // pass Data + NdbOperation* m_scanOp; // scan operation + bool m_postEval; // for rownum + unsigned m_groupIndex; // for group by + bool m_groupInit; // first in group + Exec_expr_row* m_sortRow; // from sort to group by + NdbScanFilter* m_scanFilter; // scan filter + }; + // allocate and deallocate Data instances + virtual void alloc(Ctx& ctx, Ctl& ctl) = 0; + virtual void close(Ctx& ctx) = 0; + // set Code and Data + void setCode(const Code& code); + void setData(Data& data); + // misc + virtual void print(Ctx& ctx) = 0; +protected: + const Code* m_code; + Data* m_data; + Exec_root* m_root; + void printList(Ctx& ctx, Exec_base* a[], unsigned n); +}; + +inline +Exec_base::Exec_base(Exec_root* root) : + m_code(0), + m_data(0), + m_root(root) +{ + ctx_assert(m_root != 0); +} + +inline void +Exec_base::setCode(const Code& code) +{ + ctx_assert(m_code == 0); + m_code = &code; +} + +inline void +Exec_base::setData(Data& data) +{ + ctx_assert(m_data == 0); + m_data = &data; +} + +inline +Exec_base::Ctl::Ctl(Ctl* up) : + m_up(up), + m_scanOp(0), + m_postEval(false), + m_groupIndex(0), + m_groupInit(false), + m_sortRow(0), + m_scanFilter(0) +{ +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_column.cpp b/ndb/src/client/odbc/codegen/Code_column.cpp new file mode 100644 index 00000000000..c4c0480a5e7 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_column.cpp @@ -0,0 +1,72 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include "Code_column.hpp" +#include "Code_table_list.hpp" +#include "Code_table.hpp" + +// Plan_column + +Plan_column::~Plan_column() +{ +} + +void +Plan_column::analyzeColumn(Ctx& ctx, Plan_base::Ctl& ctl) +{ + if (m_resTable != 0) // done on previous pass + return; + if (! (ctl.m_tableList.size() > 1)) { + ctx.pushStatus(Sqlstate::_42000, Error::Gen, "column %s not allowed here", getPrintName()); + return; + } + unsigned resCount = 0; + for (unsigned i = 1; i < ctl.m_tableList.size(); i++) { + Plan_table* table = ctl.m_tableList[i]; + ctx_assert(table != 0); + int ret = table->resolveColumn(ctx, this); + if (ret < 0) + return; + if (ret) + resCount++; + } + if (resCount == 0) { + // XXX try to strip "schema name" from table name + for (unsigned i = 1; i < ctl.m_tableList.size(); i++) { + Plan_table* table = ctl.m_tableList[i]; + ctx_assert(table != 0); + int ret = table->resolveColumn(ctx, this, true); + if (ret < 0) + return; + if (ret) + resCount++; + } + } + if (resCount == 0) { + ctx.pushStatus(Sqlstate::_42S22, Error::Gen, "column %s not found", getPrintName()); + return; + } + if (resCount > 1) { + ctx.pushStatus(Error::Gen, "column %s is ambiguous", getPrintName()); + return; + } + // copy SQL type + m_sqlType = dictColumn().sqlType(); +} diff --git a/ndb/src/client/odbc/codegen/Code_column.hpp b/ndb/src/client/odbc/codegen/Code_column.hpp new file mode 100644 index 00000000000..af0dcea690d --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_column.hpp @@ -0,0 +1,122 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_column_hpp +#define ODBC_CODEGEN_Code_column_hpp + +#include +#include +#include "Code_base.hpp" + +class DictColumn; +class Plan_table; + +/** + * @class Plan_column + * @brief Abstract base class for columns + */ +class Plan_column { +public: + enum Type { + Type_expr = 1, + Type_dml = 2, + Type_ddl = 3, // new columns in create table + Type_idx = 4 // old columns in create index + }; + Plan_column(Type type, const BaseString& name); + virtual ~Plan_column() = 0; + void analyzeColumn(Ctx& ctx, Plan_base::Ctl& ctl); + // attributes + const BaseString& getName() const; + const BaseString& getCname() const; + const char* getPrintName() const; + void setCname(const BaseString& cname); + const DictColumn& dictColumn() const; + const SqlType& sqlType() const; +protected: + friend class Plan_table; + friend class Plan_comp_op; + Type m_type; + BaseString m_name; + BaseString m_cname; + BaseString m_printName; + DictColumn* m_dictColumn; + /** + * Resolve to table and operational position (for example + * column number in scan query). + */ + Plan_table* m_resTable; + unsigned m_resPos; + SqlType m_sqlType; +}; + +inline +Plan_column::Plan_column(Type type, const BaseString& name) : + m_type(type), + m_name(name), + m_printName(name), + m_dictColumn(0), + m_resTable(0), + m_resPos(0) +{ +} + +inline const BaseString& +Plan_column::getName() const +{ + return m_name; +} + +inline const BaseString& +Plan_column::getCname() const +{ + return m_cname; +} + +inline const char* +Plan_column::getPrintName() const +{ + return m_printName.c_str(); +} + +inline void +Plan_column::setCname(const BaseString& cname) +{ + m_cname.assign(cname); + if (m_cname.empty()) + m_printName.assign(m_name); + else { + m_printName.assign(m_cname); + m_printName.append("."); + m_printName.append(m_name); + } +} + +inline const DictColumn& +Plan_column::dictColumn() const +{ + ctx_assert(m_dictColumn != 0); + return *m_dictColumn; +} + +inline const SqlType& +Plan_column::sqlType() const +{ + ctx_assert(m_sqlType.type() != SqlType::Undef); + return m_sqlType; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_comp_op.cpp b/ndb/src/client/odbc/codegen/Code_comp_op.cpp new file mode 100644 index 00000000000..7782ed1ea2a --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_comp_op.cpp @@ -0,0 +1,485 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Code_pred.hpp" +#include "Code_comp_op.hpp" +#include "Code_expr_conv.hpp" +#include "Code_expr_column.hpp" +#include "Code_table.hpp" +#include "Code_root.hpp" + +// Comp_op + +const char* +Comp_op::name() const +{ + switch (m_opcode) { + case Eq: + return "="; + case Noteq: + return "!="; + case Lt: + return "<"; + case Lteq: + return "<="; + case Gt: + return ">"; + case Gteq: + return ">="; + case Like: + return "like"; + case Notlike: + return "not like"; + case Isnull: + return "is null"; + case Isnotnull: + return "is not null"; + } + ctx_assert(false); + return ""; +} + +unsigned +Comp_op::arity() const +{ + switch (m_opcode) { + case Eq: + case Noteq: + case Lt: + case Lteq: + case Gt: + case Gteq: + case Like: + case Notlike: + return 2; + case Isnull: + case Isnotnull: + return 1; + } + ctx_assert(false); + return 0; +} + +// Plan_comp_op + +Plan_comp_op::~Plan_comp_op() +{ +} + +Plan_base* +Plan_comp_op::analyze(Ctx& ctx, Ctl& ctl) +{ + m_exec = 0; + const unsigned arity = m_op.arity(); + // analyze operands + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_expr[i] != 0); + m_expr[i]->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + } + // for each operand, find type to convert to + SqlType con[1 + 2]; + if (arity == 1) { + const SqlType& t1 = m_expr[1]->sqlType(); + switch (t1.type()) { + case SqlType::Char: + case SqlType::Varchar: + case SqlType::Smallint: + case SqlType::Integer: + case SqlType::Bigint: + case SqlType::Real: + case SqlType::Double: + case SqlType::Datetime: + case SqlType::Null: + case SqlType::Unbound: + con[1] = t1; + break; + default: + break; + } + if (con[1].type() == SqlType::Undef) { + char b1[40]; + t1.print(b1, sizeof(b1)); + ctx.pushStatus(Error::Gen, "type mismatch in comparison: %s %s", b1, m_op.name()); + return 0; + } + } else if (arity == 2) { + const SqlType& t1 = m_expr[1]->sqlType(); + const SqlType& t2 = m_expr[2]->sqlType(); + switch (t1.type()) { + case SqlType::Char: + switch (t2.type()) { + case SqlType::Char: + case SqlType::Varchar: + case SqlType::Null: + con[1] = t1; + con[2] = t2; + break; + case SqlType::Unbound: + con[1] = con[2] = t2; + break; + default: + break; + } + break; + case SqlType::Varchar: + switch (t2.type()) { + case SqlType::Char: + case SqlType::Varchar: + case SqlType::Null: + con[1] = t1; + con[2] = t2; + break; + case SqlType::Unbound: + con[1] = con[2] = t2; + break; + default: + break; + } + break; + case SqlType::Smallint: + case SqlType::Integer: + case SqlType::Bigint: + switch (t2.type()) { + case SqlType::Smallint: + case SqlType::Integer: + case SqlType::Bigint: + // conversion would mask primary key optimization + con[1] = t1; + con[2] = t2; + break; + case SqlType::Real: + case SqlType::Double: + con[1].setType(ctx, SqlType::Double); + con[2] = con[1]; + break; + case SqlType::Null: + con[1] = t1; + con[2] = t2; + break; + case SqlType::Unbound: + con[1] = con[2] = t2; + break; + default: + break; + } + break; + case SqlType::Real: + case SqlType::Double: + switch (t2.type()) { + case SqlType::Smallint: + case SqlType::Integer: + case SqlType::Bigint: + case SqlType::Real: + case SqlType::Double: + con[1].setType(ctx, SqlType::Double); + con[2] = con[1]; + break; + case SqlType::Null: + con[1] = t1; + con[2] = t2; + break; + case SqlType::Unbound: + con[1] = con[2] = t2; + break; + default: + break; + } + break; + case SqlType::Datetime: + switch (t2.type()) { + case SqlType::Datetime: + con[1] = t1; + con[2] = t2; + break; + case SqlType::Unbound: + con[1] = con[2] = t2; + break; + default: + break; + } + break; + case SqlType::Null: + switch (t2.type()) { + case SqlType::Char: + case SqlType::Varchar: + case SqlType::Smallint: + case SqlType::Integer: + case SqlType::Bigint: + case SqlType::Real: + case SqlType::Double: + case SqlType::Datetime: + con[1] = t1; + con[2] = t2; + break; + case SqlType::Unbound: + con[1] = con[2] = t2; + break; + default: + break; + } + break; + case SqlType::Unbound: + con[1] = con[2] = t1; + break; + default: + break; + } + if (con[1].type() == SqlType::Undef || con[2].type() == SqlType::Undef) { + char b1[40], b2[40]; + t1.print(b1, sizeof(b1)); + t2.print(b2, sizeof(b2)); + ctx.pushStatus(Error::Gen, "type mismatch in comparison: %s %s %s", b1, m_op.name(), b2); + return 0; + } + } else { + ctx_assert(false); + return 0; + } + if (! ctx.ok()) + return 0; + // insert required conversions + for (unsigned i = 1; i <= arity; i++) { + if (con[i].type() == SqlType::Unbound) { + continue; + } + Plan_expr_conv* exprConv = new Plan_expr_conv(m_root, con[i]); + m_root->saveNode(exprConv); + exprConv->setExpr(m_expr[i]); + m_expr[i] = static_cast(exprConv->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(m_expr[i] != 0); + } + // look for column=expr + if (ctl.m_topand && m_op.m_opcode == Comp_op::Eq) { + ctx_assert(arity == 2); + for (unsigned i = 1, j = 2; i <= 2; i++, j--) { + if (m_expr[i]->type() != Plan_expr::TypeColumn) + continue; + Plan_expr_column* column = static_cast(m_expr[i]); + if (! column->resolveEq(ctx, m_expr[j])) + ctl.m_extra = true; + } + } else { + ctl.m_extra = true; + } + // save top level comparison on list + if (ctl.m_topand) { + ctl.m_topcomp.push_back(this); + } + // table dependencies are union from operands + m_tableSet.clear(); + for (unsigned i = 1; i <= arity; i++) { + const TableSet& ts = m_expr[i]->tableSet(); + m_tableSet.insert(ts.begin(), ts.end()); + } + // set of tables for which interpreter cannot be used + m_noInterp.clear(); + // convenient +#undef ustype +#define ustype(b, n) (((b) ? 1 : 0) * 100 + (n)) + if (arity == 1) { + for (unsigned i = 1; i <= 1; i++) { + const SqlType t1 = m_expr[i]->sqlType(); + switch (m_op.m_opcode) { + case Comp_op::Isnull: + case Comp_op::Isnotnull: + if (m_expr[i]->type() == Plan_expr::TypeColumn) { + switch (ustype(t1.unSigned(), t1.type())) { + // all types accepted now + default: + { + Plan_expr_column* column = static_cast(m_expr[i]); + ctx_assert(column->m_resTable != 0); + m_interpColumn[i] = column; + continue; // ok + } + break; + } + } + break; + default: + break; + } + const TableSet& ts = m_expr[i]->tableSet(); + m_noInterp.insert(ts.begin(), ts.end()); + } + } else if (arity == 2) { + for (unsigned i = 1, j = 2; i <= 2; i++, j--) { + const SqlType t1 = m_expr[i]->sqlType(); + switch (m_op.m_opcode) { + case Comp_op::Like: + case Comp_op::Notlike: + if (i == 2) // col like val but not val like col + break; + /*FALLTHRU*/ + case Comp_op::Eq: + case Comp_op::Noteq: + case Comp_op::Lt: + case Comp_op::Lteq: + case Comp_op::Gt: + case Comp_op::Gteq: + if (m_expr[i]->type() == Plan_expr::TypeColumn) { + switch (ustype(t1.unSigned(), t1.type())) { + case ustype(false, SqlType::Char): + case ustype(false, SqlType::Varchar): + case ustype(true, SqlType::Smallint): + case ustype(true, SqlType::Integer): + case ustype(true, SqlType::Bigint): + { + Plan_expr_column* column = static_cast(m_expr[i]); + ctx_assert(column->m_resTable != 0); + const TableSet& ts = m_expr[j]->tableSet(); + if (ts.find(column->m_resTable) == ts.end()) { + // candidate for column=const + m_interpColumn[i] = column; + continue; // ok + } + } + break; + default: + break; + } + } + break; + default: + break; + } + const TableSet& ts = m_expr[i]->tableSet(); + m_noInterp.insert(ts.begin(), ts.end()); + } + } else { + ctx_assert(false); + return 0; + } +#undef ustype + return this; +} + +Exec_base* +Plan_comp_op::codegen(Ctx& ctx, Ctl& ctl) +{ + if (m_exec != 0) + return m_exec; + const unsigned arity = m_op.arity(); + Exec_comp_op* exec = new Exec_comp_op(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + // create code for operands + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_expr[i] != 0); + Exec_expr* execExpr = static_cast(m_expr[i]->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execExpr != 0); + exec->setExpr(i, execExpr); + } + // create the code + Exec_comp_op::Code& code = *new Exec_comp_op::Code(m_op); + // interpreted column=const + if (! ctl.m_having) { + ctx_assert(ctl.m_topTable != 0); + for (unsigned i = 1; i <= arity; i++) { + Plan_expr_column* column = m_interpColumn[i]; + if (column == 0) + continue; + ctx_assert(column->m_resTable != 0); + if (column->m_resTable != ctl.m_topTable) + continue; + ctx_assert(code.m_interpColumn == 0); + code.m_interpColumn = i; + code.m_interpAttrId = column->dictColumn().getAttrId(); + ctx_log2(("can use interpreter on %s", column->getPrintName())); + } + } + exec->setCode(code); + m_exec = exec; + return exec; +} + +void +Plan_comp_op::print(Ctx& ctx) +{ + ctx.print(" [%s", m_op.name()); + Plan_base* a[] = { m_expr[1], m_expr[2] }; + printList(ctx, a, m_op.arity()); + ctx.print("]"); +} + +bool +Plan_comp_op::isGroupBy(const Plan_expr_row* row) const +{ + const unsigned arity = m_op.arity(); + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_expr[i] != 0); + if (! m_expr[i]->isGroupBy(row)) + return false; + } + return true; +} + +// Code_comp_op + +Exec_comp_op::Code::~Code() +{ +} + +Exec_comp_op::Data::~Data() +{ +} + +Exec_comp_op::~Exec_comp_op() +{ +} + +void +Exec_comp_op::alloc(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + // allocate subexpressions + unsigned arity = code.m_op.arity(); + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_expr[i] != 0); + m_expr[i]->alloc(ctx, ctl); + if (! ctx.ok()) + return; + } + Data& data = *new Data; + setData(data); +} + +void +Exec_comp_op::close(Ctx& ctx) +{ + const Code& code = getCode(); + unsigned arity = code.m_op.arity(); + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_expr[i] != 0); + m_expr[i]->close(ctx); + } +} + +void +Exec_comp_op::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx.print(" [%s", code.m_op.name()); + Exec_base* a[] = { m_expr[1], m_expr[2] }; + printList(ctx, a, code.m_op.arity()); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_comp_op.hpp b/ndb/src/client/odbc/codegen/Code_comp_op.hpp new file mode 100644 index 00000000000..0585ab1dabf --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_comp_op.hpp @@ -0,0 +1,172 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_comp_op_hpp +#define ODBC_CODEGEN_Code_comp_op_hpp + +#include +#include +#include "Code_pred.hpp" +#include "Code_expr.hpp" +#include "Code_expr_column.hpp" + +/** + * @class Comp_op + * @brief Comparison operations + */ +struct Comp_op { + enum Opcode { + Eq = 1, // binary + Noteq, + Lt, + Lteq, + Gt, + Gteq, + Like, + Notlike, + Isnull, // unary + Isnotnull + }; + Comp_op(Opcode opcode); + const char* name() const; + unsigned arity() const; + Opcode m_opcode; +}; + +inline +Comp_op::Comp_op(Opcode opcode) : + m_opcode(opcode) +{ +} + +/** + * @class Plan_comp_op + * @brief Comparison operator node in PlanTree + */ +class Plan_comp_op : public Plan_pred { +public: + Plan_comp_op(Plan_root* root, Comp_op op); + virtual ~Plan_comp_op(); + void setExpr(unsigned i, Plan_expr* expr); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + virtual bool isGroupBy(const Plan_expr_row* row) const; +protected: + Comp_op m_op; + Plan_expr* m_expr[1 + 2]; + Plan_expr_column* m_interpColumn[1 + 2]; // candidates +}; + +inline +Plan_comp_op::Plan_comp_op(Plan_root* root, Comp_op op) : + Plan_pred(root, TypeComp), + m_op(op) +{ + m_expr[0] = m_expr[1] = m_expr[2] = 0; + m_interpColumn[0] = m_interpColumn[1] = m_interpColumn[2] = 0; +} + +inline void +Plan_comp_op::setExpr(unsigned i, Plan_expr* expr) +{ + ctx_assert(1 <= i && i <= 2); + m_expr[i] = expr; +} + +/** + * @class Exec_comp_op + * @brief Comparison operator node in ExecTree + */ +class Exec_comp_op : public Exec_pred { +public: + class Code : public Exec_pred::Code { + public: + Code(Comp_op op); + virtual ~Code(); + protected: + friend class Plan_comp_op; + friend class Exec_comp_op; + Comp_op m_op; + unsigned m_interpColumn; // 1 or 2 if interpreted column, 0 if both constant + NdbAttrId m_interpAttrId; + }; + class Data : public Exec_pred::Data { + public: + Data(); + virtual ~Data(); + protected: + friend class Exec_comp_op; + }; + Exec_comp_op(Exec_root* root); + virtual ~Exec_comp_op(); + void alloc(Ctx& ctx, Ctl& ctl); + void execInterp(Ctx& ctx, Ctl& ctl); + void evaluate(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setExpr(unsigned i, Exec_expr* expr); +protected: + Exec_expr* m_expr[1 + 2]; +}; + +inline +Exec_comp_op::Code::Code(Comp_op op) : + m_op(op), + m_interpColumn(0), + m_interpAttrId((NdbAttrId)-1) +{ +} + +inline +Exec_comp_op::Data::Data() +{ +} + +inline +Exec_comp_op::Exec_comp_op(Exec_root* root) : + Exec_pred(root) +{ + m_expr[0] = m_expr[1] = m_expr[2] = 0; +} + +// children + +inline const Exec_comp_op::Code& +Exec_comp_op::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_comp_op::Data& +Exec_comp_op::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_comp_op::setExpr(unsigned i, Exec_expr* expr) +{ + ctx_assert(1 <= i && i <= 2 && m_expr[i] == 0); + m_expr[i] = expr; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_create_index.cpp b/ndb/src/client/odbc/codegen/Code_create_index.cpp new file mode 100644 index 00000000000..84f319338a4 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_create_index.cpp @@ -0,0 +1,124 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Code_create_index.hpp" +#include "Code_root.hpp" + +// Plan_create_index + +Plan_create_index::~Plan_create_index() +{ +} + +Plan_base* +Plan_create_index::analyze(Ctx& ctx, Ctl& ctl) +{ + stmtArea().stmtInfo().setName(Stmt_name_create_index); + // analyze the table + ctx_assert(m_table != 0); + m_table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + // analyze the columns + ctl.m_tableList.resize(1 + 1); // indexed from 1 + ctl.m_tableList[1] = m_table; + for (unsigned i = 1, n = countColumn(); i <= n; i++) { + Plan_idx_column* column = getColumn(i); + column->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + } + return this; +} + +void +Plan_create_index::describe(Ctx& ctx) +{ + stmtArea().setFunction(ctx, "CREATE INDEX", SQL_DIAG_CREATE_INDEX); +} + +Exec_base* +Plan_create_index::codegen(Ctx& ctx, Ctl& ctl) +{ + Exec_create_index* exec = new Exec_create_index(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + const unsigned count = countColumn(); + const char** attrList = new const char* [1 + count]; + attrList[0] = 0; // unused + for (unsigned i = 1; i <= count; i++) { + Plan_idx_column* column = getColumn(i); + const char* cname = column->getName().c_str(); + attrList[i] = strcpy(new char[strlen(cname) + 1], cname); + } + Exec_create_index::Code& code = *new Exec_create_index::Code(m_name, m_table->getName(), m_type, count, attrList); + exec->setCode(code); + code.m_fragmentType = m_fragmentType; + code.m_logging = m_logging; + return exec; +} + +void +Plan_create_index::print(Ctx& ctx) +{ + ctx.print(" [create_index name=%s table=%s type=%d", m_name.c_str(), m_table->getName().c_str(), (int)m_type); + ctx.print(" ["); + for (unsigned i = 1; i <= countColumn(); i++) { + Plan_idx_column* column = getColumn(i); + if (i > 1) + ctx.print(" "); + column->print(ctx); + } + ctx.print("]"); +} + +// Exec_create_index + +Exec_create_index::Code::~Code() +{ + for (unsigned i = 1; i <= m_attrCount; i++) { + delete[] m_attrList[i]; + m_attrList[i] = 0; + } + delete[] m_attrList; +} + +Exec_create_index::Data::~Data() +{ +} + +Exec_create_index::~Exec_create_index() +{ +} + +void +Exec_create_index::alloc(Ctx& ctx, Ctl& ctl) +{ + Data& data = *new Data; + setData(data); +} + +void +Exec_create_index::close(Ctx& ctx) +{ +} + +void +Exec_create_index::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx.print(" [create_index %s]", code.m_tableName.c_str()); +} diff --git a/ndb/src/client/odbc/codegen/Code_create_index.hpp b/ndb/src/client/odbc/codegen/Code_create_index.hpp new file mode 100644 index 00000000000..ebd757e1118 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_create_index.hpp @@ -0,0 +1,203 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_create_index_hpp +#define ODBC_CODEGEN_Code_create_index_hpp + +#include +#include +#include +#include "Code_ddl.hpp" +#include "Code_table.hpp" +#include "Code_idx_column.hpp" + +class DictTable; +class DictColumn; + +/** + * @class Plan_create_index + * @brief Create table in PlanTree + */ +class Plan_create_index : public Plan_ddl { +public: + Plan_create_index(Plan_root* root, const BaseString& name); + virtual ~Plan_create_index(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void describe(Ctx & ctx); + void print(Ctx& ctx); + // attributes + const BaseString& getName() const; + // children + void setType(NdbDictionary::Object::Type type); + void setTable(Plan_table* table); + unsigned countColumn() const; + void addColumn(Plan_idx_column* column); + Plan_idx_column* getColumn(unsigned i) const; + void setFragmentType(NdbDictionary::Object::FragmentType fragmentType); + void setLogging(bool logging); +protected: + BaseString m_name; + NdbDictionary::Object::Type m_type; + Plan_table* m_table; + IdxColumnVector m_columnList; + NdbDictionary::Object::FragmentType m_fragmentType; + bool m_logging; +}; + +inline +Plan_create_index::Plan_create_index(Plan_root* root, const BaseString& name) : + Plan_ddl(root), + m_name(name), + m_type(NdbDictionary::Object::TypeUndefined), + m_columnList(1), + m_fragmentType(NdbDictionary::Object::FragUndefined), + m_logging(true) +{ +} + +inline const BaseString& +Plan_create_index::getName() const +{ + return m_name; +} + +// children + +inline void +Plan_create_index::setType(NdbDictionary::Object::Type type) +{ + m_type = type; +} + +inline void +Plan_create_index::setTable(Plan_table* table) +{ + ctx_assert(table != 0); + m_table = table; +} + +inline unsigned +Plan_create_index::countColumn() const +{ + return m_columnList.size() - 1; +} + +inline void +Plan_create_index::addColumn(Plan_idx_column* column) +{ + ctx_assert(column != 0); + m_columnList.push_back(column); +} + +inline Plan_idx_column* +Plan_create_index::getColumn(unsigned i) const +{ + ctx_assert(1 <= i && i <= countColumn() && m_columnList[i] != 0); + return m_columnList[i]; +} + +inline void +Plan_create_index::setFragmentType(NdbDictionary::Object::FragmentType fragmentType) +{ + m_fragmentType = fragmentType; +} + +inline void +Plan_create_index::setLogging(bool logging) +{ + m_logging = logging; +} + +/** + * @class Exec_create_index + * @brief Create table in ExecTree + */ +class Exec_create_index : public Exec_ddl { +public: + class Code : public Exec_ddl::Code { + public: + Code(const BaseString& indexName, const BaseString& tableName, NdbDictionary::Object::Type type, unsigned attrCount, const char** attrList); + virtual ~Code(); + protected: + friend class Plan_create_index; + friend class Exec_create_index; + const BaseString m_indexName; + const BaseString m_tableName; + NdbDictionary::Object::Type m_type; + const unsigned m_attrCount; + const char** m_attrList; + NdbDictionary::Object::FragmentType m_fragmentType; + bool m_logging; + }; + class Data : public Exec_ddl::Data { + public: + Data(); + virtual ~Data(); + protected: + friend class Exec_create_index; + }; + Exec_create_index(Exec_root* root); + virtual ~Exec_create_index(); + void alloc(Ctx& ctx, Ctl& ctl); + void execute(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; +}; + +inline +Exec_create_index::Code::Code(const BaseString& indexName, const BaseString& tableName, NdbDictionary::Object::Type type, unsigned attrCount, const char** attrList) : + m_indexName(indexName), + m_tableName(tableName), + m_type(type), + m_attrCount(attrCount), + m_attrList(attrList), + m_fragmentType(NdbDictionary::Object::FragUndefined), + m_logging(true) +{ +} + +inline +Exec_create_index::Data::Data() +{ +} + +inline +Exec_create_index::Exec_create_index(Exec_root* root) : + Exec_ddl(root) +{ +} + +// children + +inline const Exec_create_index::Code& +Exec_create_index::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_create_index::Data& +Exec_create_index::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_create_row.cpp b/ndb/src/client/odbc/codegen/Code_create_row.cpp new file mode 100644 index 00000000000..5b90b658ed7 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_create_row.cpp @@ -0,0 +1,162 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_create_row.hpp" +#include "Code_root.hpp" + +Plan_create_row::~Plan_create_row() +{ +} + +Plan_base* +Plan_create_row::analyze(Ctx& ctx, Ctl& ctl) +{ + // check for duplicate column name + for (unsigned i = 1, n = countColumn(); i < n; i++) { + const BaseString& a = getColumn(i)->getName(); + for (unsigned i2 = i + 1; i2 <= n; i2++) { + const BaseString& a2 = getColumn(i2)->getName(); + if (strcmp(a.c_str(), a2.c_str()) == 0) { + ctx.pushStatus(Error::Gen, "duplicate column %s", a.c_str()); + return 0; + } + } + } + // move single-column primary key constraint to constraint list + for (unsigned i = 1, n = countColumn(); i <= n; i++) { + Plan_ddl_column* column = getColumn(i); + if (column->m_primaryKey) { + Plan_ddl_row* ddlRow = new Plan_ddl_row(m_root); + m_root->saveNode(ddlRow); + ddlRow->addColumn(column); + Plan_ddl_constr* constr = new Plan_ddl_constr(m_root); + m_root->saveNode(constr); + constr->setRow(ddlRow); + addConstr(constr); + column->m_primaryKey = false; // will be set again + } + } + // check primary key constraints + if (countConstr() < 1) { + ctx.pushStatus(Error::Gen, "table must have a primary key"); + return 0; + } + if (countConstr() > 1) { + ctx.pushStatus(Error::Gen, "table can have only one primary key"); + return 0; + } + Plan_ddl_row* ddlRow = getConstr(1)->getRow(); + for (unsigned i = 1, n = ddlRow->countColumn(); i <= n; i++) { + Plan_ddl_column* column = ddlRow->getColumn(i); + const BaseString& a = column->getName(); + bool found = false; + for (unsigned i2 = 1, n2 = countColumn(); i2 <= n2; i2++) { + Plan_ddl_column* column2 = getColumn(i2); + const BaseString& a2 = column2->getName(); + if (strcmp(a.c_str(), a2.c_str()) != 0) + continue; + if (column2->getPrimaryKey()) { + ctx.pushStatus(Error::Gen, "duplicate primary key constraint on %s", a.c_str()); + return 0; + } + column2->setPrimaryKey(); + found = true; + break; + } + if (! found) { + ctx.pushStatus(Error::Gen, "undefined primary key column %s", a.c_str()); + return 0; + } + } + // analyze column types + for (unsigned i = 1, n = countColumn(); i <= n; i++) { + getColumn(i)->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + } + // check TupleId + unsigned tupleId = 0; + for (unsigned i = 1, n = countColumn(); i <= n; i++) { + Plan_ddl_column* column = getColumn(i); + if (! column->getTupleId()) + continue; + if (i != 1) { + ctx.pushStatus(Error::Gen, "tuple id column %u is not first column", i); + return 0; + } + if (tupleId != 0) { // cannot happen now since attr name is fixed + ctx.pushStatus(Error::Gen, "duplicate tuple id column %u", i); + return 0; + } + tupleId = i; + } + if (tupleId != 0) { + for (unsigned i = 1, n = countColumn(); i <= n; i++) { + Plan_ddl_column* column = getColumn(i); + if (i == tupleId) + continue; + if (! column->getPrimaryKey()) + continue; + ctx.pushStatus(Error::Gen, "cannot have both tuple id and other primary key column %u", i); + return 0; + } + } + // check auto-increment + unsigned autoIncrement = 0; + for (unsigned i = 1, n = countColumn(); i <= n; i++) { + Plan_ddl_column* column = getColumn(i); + if (! column->getAutoIncrement()) + continue; + if (autoIncrement != 0) { + ctx.pushStatus(Error::Gen, "duplicate auto-increment column %u", i); + return 0; + } + autoIncrement = i; + } + if (autoIncrement != 0) { + for (unsigned i = 1, n = countColumn(); i <= n; i++) { + Plan_ddl_column* column = getColumn(i); + if (i == autoIncrement) + continue; + if (! column->getPrimaryKey()) + continue; + ctx.pushStatus(Error::Gen, "cannot have both auto-increment column and other primary key column %u", i); + return 0; + } + } + return this; +} + +Exec_base* +Plan_create_row::codegen(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(false); + return 0; +} + +void +Plan_create_row::print(Ctx& ctx) +{ + ctx.print(" [create_row"); + for (unsigned i = 1; i <= countColumn(); i++) { + Plan_base* a = m_columnList[i]; + printList(ctx, &a, 1); + } + for (unsigned i = 1; i <= countConstr(); i++) { + Plan_base* a = m_constrList[i]; + printList(ctx, &a, 1); + } +} diff --git a/ndb/src/client/odbc/codegen/Code_create_row.hpp b/ndb/src/client/odbc/codegen/Code_create_row.hpp new file mode 100644 index 00000000000..f03455ff28e --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_create_row.hpp @@ -0,0 +1,99 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_create_row_hpp +#define ODBC_CODEGEN_Code_create_row_hpp + +#include +#include +#include "Code_base.hpp" +#include "Code_ddl_column.hpp" +#include "Code_ddl_constr.hpp" + +/** + * @class Plan_create_row + * @brief Row of columns and constraints in create statement + */ +class Plan_create_row : public Plan_base { +public: + Plan_create_row(Plan_root* root); + virtual ~Plan_create_row(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + unsigned countColumn() const; + void addColumn(Plan_ddl_column* column); + Plan_ddl_column* getColumn(unsigned i) const; + unsigned countConstr() const; + void addConstr(Plan_ddl_constr* constr); + Plan_ddl_constr* getConstr(unsigned i) const; +protected: + DdlColumnVector m_columnList; + DdlConstrVector m_constrList; +}; + +inline +Plan_create_row::Plan_create_row(Plan_root* root) : + Plan_base(root), + m_columnList(1), + m_constrList(1) +{ +} + +// children + +inline unsigned +Plan_create_row::countColumn() const +{ + return m_columnList.size() - 1; +} + +inline void +Plan_create_row::addColumn(Plan_ddl_column* column) +{ + ctx_assert(column != 0); + m_columnList.push_back(column); +} + +inline Plan_ddl_column* +Plan_create_row::getColumn(unsigned i) const +{ + ctx_assert(1 <= i && i <= m_columnList.size() && m_columnList[i] != 0); + return m_columnList[i]; +} + +inline unsigned +Plan_create_row::countConstr() const +{ + return m_constrList.size() - 1; +} + +inline void +Plan_create_row::addConstr(Plan_ddl_constr* constr) +{ + ctx_assert(constr != 0); + m_constrList.push_back(constr); +} + +inline Plan_ddl_constr* +Plan_create_row::getConstr(unsigned i) const +{ + ctx_assert(1 <= i && i <= m_constrList.size() && m_constrList[i] != 0); + return m_constrList[i]; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_create_table.cpp b/ndb/src/client/odbc/codegen/Code_create_table.cpp new file mode 100644 index 00000000000..14e4abbd7fe --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_create_table.cpp @@ -0,0 +1,137 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Code_create_table.hpp" +#include "Code_root.hpp" + +// Plan_create_table + +Plan_create_table::~Plan_create_table() +{ +} + +Plan_base* +Plan_create_table::analyze(Ctx& ctx, Ctl& ctl) +{ + stmtArea().stmtInfo().setName(Stmt_name_create_table); + // analyze the create row + ctx_assert(m_createRow != 0); + m_createRow->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +void +Plan_create_table::describe(Ctx& ctx) +{ + stmtArea().setFunction(ctx, "CREATE TABLE", SQL_DIAG_CREATE_TABLE); +} + +Exec_base* +Plan_create_table::codegen(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_createRow != 0); + Exec_create_table* exec = new Exec_create_table(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + const unsigned count = m_createRow->countColumn(); + Exec_create_table::Code::Attr* attrList = new Exec_create_table::Code::Attr[1 + count]; + unsigned tupleId = 0; + unsigned autoIncrement = 0; + for (unsigned i = 1; i <= count; i++) { + Plan_ddl_column* column = m_createRow->getColumn(i); + Exec_create_table::Code::Attr& attr = attrList[i]; + attr.m_attrName.assign(column->getName()); + attr.m_sqlType = column->sqlType(); + attr.m_tupleKey = column->getPrimaryKey(); + attr.m_tupleId = column->getTupleId(); + attr.m_autoIncrement = column->getAutoIncrement(); + if (attr.m_tupleId) + tupleId = i; + if (attr.m_autoIncrement) + autoIncrement = i; + attr.m_defaultValue = 0; + Plan_expr* expr; + if ((expr = column->getDefaultValue()) != 0) { + Exec_expr* execExpr = static_cast(expr->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execExpr != 0); + attr.m_defaultValue = execExpr; + } + } + Exec_create_table::Code& code = *new Exec_create_table::Code(m_name, count, attrList, tupleId, autoIncrement); + exec->setCode(code); + code.m_fragmentType = m_fragmentType; + code.m_logging = m_logging; + return exec; +} + +void +Plan_create_table::print(Ctx& ctx) +{ + ctx.print(" [create_table '%s'", m_name.c_str()); + Plan_base* a[] = { m_createRow }; + printList(ctx, a, 1); + ctx.print("]"); +} + +// Exec_create_table + +Exec_create_table::Code::~Code() +{ + delete[] m_attrList; +} + +Exec_create_table::Data::~Data() +{ +} + +Exec_create_table::~Exec_create_table() +{ +} + +void +Exec_create_table::alloc(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + const Code::Attr& attr = code.m_attrList[i]; + if (attr.m_defaultValue != 0) + attr.m_defaultValue->alloc(ctx, ctl); + } + Data& data = *new Data; + setData(data); +} + +void +Exec_create_table::close(Ctx& ctx) +{ + const Code& code = getCode(); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + const Code::Attr& attr = code.m_attrList[i]; + if (attr.m_defaultValue != 0) + attr.m_defaultValue->close(ctx); + } +} + +void +Exec_create_table::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx.print(" [create_table %s]", code.m_tableName.c_str()); +} diff --git a/ndb/src/client/odbc/codegen/Code_create_table.hpp b/ndb/src/client/odbc/codegen/Code_create_table.hpp new file mode 100644 index 00000000000..cbb2189d8ce --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_create_table.hpp @@ -0,0 +1,178 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_create_table_hpp +#define ODBC_CODEGEN_Code_create_table_hpp + +#include +#include +#include "Code_ddl.hpp" +#include "Code_ddl_row.hpp" +#include "Code_create_row.hpp" + +class DictTable; +class DictColumn; + +/** + * @class Plan_create_table + * @brief Create table in PlanTree + */ +class Plan_create_table : public Plan_ddl { +public: + Plan_create_table(Plan_root* root, const BaseString& name); + virtual ~Plan_create_table(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void describe(Ctx & ctx); + void print(Ctx& ctx); + // attributes + const BaseString& getName() const; + // children + void setCreateRow(Plan_create_row* createRow); + void setFragmentType(NdbDictionary::Object::FragmentType fragmentType); + void setLogging(bool logging); +protected: + BaseString m_name; + Plan_create_row* m_createRow; + NdbDictionary::Object::FragmentType m_fragmentType; + bool m_logging; +}; + +inline +Plan_create_table::Plan_create_table(Plan_root* root, const BaseString& name) : + Plan_ddl(root), + m_name(name), + m_createRow(0), + m_fragmentType(NdbDictionary::Object::FragUndefined), + m_logging(true) +{ +} + +inline const BaseString& +Plan_create_table::getName() const +{ + return m_name; +} + +// children + +inline void +Plan_create_table::setCreateRow(Plan_create_row* createRow) +{ + ctx_assert(createRow != 0); + m_createRow = createRow; +} + +inline void +Plan_create_table::setFragmentType(NdbDictionary::Object::FragmentType fragmentType) +{ + m_fragmentType = fragmentType; +} + +inline void +Plan_create_table::setLogging(bool logging) +{ + m_logging = logging; +} + +/** + * @class Exec_create_table + * @brief Create table in ExecTree + */ +class Exec_create_table : public Exec_ddl { +public: + class Code : public Exec_ddl::Code { + public: + struct Attr { + Attr() : m_defaultValue(0) {} + BaseString m_attrName; + SqlType m_sqlType; + bool m_tupleKey; + bool m_tupleId; + bool m_autoIncrement; + Exec_expr* m_defaultValue; + }; + Code(const BaseString& tableName, unsigned attrCount, const Attr* attrList, unsigned tupleId, unsigned autoIncrement); + virtual ~Code(); + protected: + friend class Plan_create_table; + friend class Exec_create_table; + const BaseString m_tableName; + const unsigned m_attrCount; + const Attr* const m_attrList; + unsigned m_tupleId; + unsigned m_autoIncrement; + NdbDictionary::Object::FragmentType m_fragmentType; + bool m_logging; + }; + class Data : public Exec_ddl::Data { + public: + Data(); + virtual ~Data(); + protected: + friend class Exec_create_table; + }; + Exec_create_table(Exec_root* root); + virtual ~Exec_create_table(); + void alloc(Ctx& ctx, Ctl& ctl); + void execute(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; +}; + +inline +Exec_create_table::Code::Code(const BaseString& tableName, unsigned attrCount, const Attr* attrList, unsigned tupleId, unsigned autoIncrement) : + m_tableName(tableName), + m_attrCount(attrCount), + m_attrList(attrList), + m_tupleId(tupleId), + m_autoIncrement(autoIncrement), + m_fragmentType(NdbDictionary::Object::FragUndefined), + m_logging(true) +{ +} + +inline +Exec_create_table::Data::Data() +{ +} + +inline +Exec_create_table::Exec_create_table(Exec_root* root) : + Exec_ddl(root) +{ +} + +// children + +inline const Exec_create_table::Code& +Exec_create_table::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_create_table::Data& +Exec_create_table::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_data_type.cpp b/ndb/src/client/odbc/codegen/Code_data_type.cpp new file mode 100644 index 00000000000..1ff0fcebcbe --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_data_type.cpp @@ -0,0 +1,44 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include "Code_data_type.hpp" + +// Plan_data_type + +Plan_data_type::~Plan_data_type() +{ +} + +Plan_base* +Plan_data_type::analyze(Ctx& ctx, Ctl& ctl) +{ + return this; +} + +Exec_base* +Plan_data_type::codegen(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(false); + return 0; +} + +void +Plan_data_type::print(Ctx& ctx) +{ + ctx.print(" [data_type]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_data_type.hpp b/ndb/src/client/odbc/codegen/Code_data_type.hpp new file mode 100644 index 00000000000..735dc05014f --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_data_type.hpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_data_type_hpp +#define ODBC_CODEGEN_Code_data_type_hpp + +#include +#include +#include "Code_base.hpp" + +/** + * @class Plan_data_type + * @brief Data type in DDL statement + * + * This is pure plan node. + */ +class Plan_data_type : public Plan_base { +public: + Plan_data_type(Plan_root* root, const SqlType& sqlType); + virtual ~Plan_data_type(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); +private: + friend class Plan_ddl_column; + SqlType m_sqlType; +}; + +inline +Plan_data_type::Plan_data_type(Plan_root* root, const SqlType& sqlType) : + Plan_base(root), + m_sqlType(sqlType) +{ +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_ddl.cpp b/ndb/src/client/odbc/codegen/Code_ddl.cpp new file mode 100644 index 00000000000..2ba4291a0e8 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_ddl.cpp @@ -0,0 +1,37 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_ddl.hpp" + +// Plan_ddl + +Plan_ddl::~Plan_ddl() +{ +} + +// Exec_ddl + +Exec_ddl::Code::~Code() +{ +} + +Exec_ddl::Data::~Data() +{ +} + +Exec_ddl::~Exec_ddl() +{ +} diff --git a/ndb/src/client/odbc/codegen/Code_ddl.hpp b/ndb/src/client/odbc/codegen/Code_ddl.hpp new file mode 100644 index 00000000000..1ceca62d55d --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_ddl.hpp @@ -0,0 +1,63 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_ddl_hpp +#define ODBC_CODEGEN_Code_ddl_hpp + +#include +#include "Code_stmt.hpp" + +/** + * @class Plan_ddl + * @brief Base class for DDL statements in PlanTree + */ +class Plan_ddl : public Plan_stmt { +public: + Plan_ddl(Plan_root* root); + virtual ~Plan_ddl() = 0; +}; + +inline +Plan_ddl::Plan_ddl(Plan_root* root) : + Plan_stmt(root) +{ +} + +/** + * @class Exec_ddl + * @brief Base class for DDL statements in ExecTree + */ +class Exec_ddl : public Exec_stmt { +public: + class Code : public Exec_stmt::Code { + public: + virtual ~Code() = 0; + }; + class Data : public Exec_stmt::Data { + public: + virtual ~Data() = 0; + }; + Exec_ddl(Exec_root* root); + virtual ~Exec_ddl() = 0; +}; + +inline +Exec_ddl::Exec_ddl(Exec_root* root) : + Exec_stmt(root) +{ +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_ddl_column.cpp b/ndb/src/client/odbc/codegen/Code_ddl_column.cpp new file mode 100644 index 00000000000..ee037e54c1f --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_ddl_column.cpp @@ -0,0 +1,104 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include "Code_ddl_column.hpp" +#include "Code_expr_conv.hpp" +#include "Code_root.hpp" + +// Plan_ddl_column + +Plan_ddl_column::~Plan_ddl_column() +{ +} + +Plan_base* +Plan_ddl_column::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_type != 0); + if (! m_type->m_sqlType.nullable()) { + m_nullable = false; + } + m_sqlType = m_type->m_sqlType; + m_sqlType.nullable(m_nullable); + const BaseString& name = getName(); + if (m_unSigned) { + switch (m_sqlType.type()) { + case SqlType::Smallint: + case SqlType::Integer: + case SqlType::Bigint: + break; + default: + ctx.pushStatus(Error::Gen, "invalid unsigned qualifier on column %s", name.c_str()); + return 0; + } + m_sqlType.unSigned(true); + } + if (strcmp(name.c_str(), "NDB$TID") == 0) { + if (! m_primaryKey) { + ctx.pushStatus(Error::Gen, "column %s must be a primary key", name.c_str()); + return 0; + } + if (sqlType().type() != SqlType::Bigint || ! sqlType().unSigned()) { + ctx.pushStatus(Error::Gen, "tuple id %s must have type BIGINT UNSIGNED", name.c_str()); + return 0; + } + setTupleId(); + } + if (m_autoIncrement) { + if (! m_primaryKey) { + ctx.pushStatus(Error::Gen, "auto-increment column %s must be a primary key", name.c_str()); + return 0; + } + if (sqlType().type() != SqlType::Smallint && sqlType().type() != SqlType::Integer && sqlType().type() != SqlType::Bigint) { + ctx.pushStatus(Error::Gen, "auto-increment column %s must have an integral type", name.c_str()); + return 0; + } + } + if (m_defaultValue != 0) { + if (m_primaryKey) { + ctx.pushStatus(Sqlstate::_42000, Error::Gen, "default value not allowed on primary key column %s", name.c_str()); + return 0; + } + m_defaultValue->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + // insert conversion node + Plan_expr_conv* exprConv = new Plan_expr_conv(m_root, sqlType()); + m_root->saveNode(exprConv); + exprConv->setExpr(m_defaultValue); + Plan_expr* expr = static_cast(exprConv->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(expr != 0); + m_defaultValue = expr; + } + return this; +} + +Exec_base* +Plan_ddl_column::codegen(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(false); + return 0; +} + +void +Plan_ddl_column::print(Ctx& ctx) +{ + ctx.print(" [ddl_column %s key=%d id=%d]", getPrintName(), m_primaryKey, m_tupleId); +} diff --git a/ndb/src/client/odbc/codegen/Code_ddl_column.hpp b/ndb/src/client/odbc/codegen/Code_ddl_column.hpp new file mode 100644 index 00000000000..7d089d37440 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_ddl_column.hpp @@ -0,0 +1,150 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_ddl_column_hpp +#define ODBC_CODEGEN_Code_ddl_column_hpp + +#include +#include "Code_column.hpp" +#include "Code_data_type.hpp" +#include "Code_expr.hpp" + +class DictColumn; +class Plan_table; + +/** + * @class Plan_ddl_column + * @brief Column in DDL statement + */ +class Plan_ddl_column : public Plan_base, public Plan_column { +public: + Plan_ddl_column(Plan_root* root, const BaseString& name); + virtual ~Plan_ddl_column(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // attributes + void setNotNull(); + void setUnSigned(); + void setPrimaryKey(); + bool getPrimaryKey() const; + void setTupleId(); + bool getTupleId() const; + void setAutoIncrement(); + bool getAutoIncrement() const; + // children + void setType(Plan_data_type* type); + void setDefaultValue(Plan_expr* defaultValue); + Plan_expr* getDefaultValue() const; +protected: + friend class Plan_create_row; + Plan_data_type* m_type; + Plan_expr* m_defaultValue; + bool m_nullable; + bool m_unSigned; + bool m_primaryKey; + bool m_tupleId; + bool m_autoIncrement; +}; + +inline +Plan_ddl_column::Plan_ddl_column(Plan_root* root, const BaseString& name) : + Plan_base(root), + Plan_column(Type_ddl, name), + m_type(0), + m_defaultValue(0), + m_nullable(true), + m_unSigned(false), + m_primaryKey(false), + m_tupleId(false), + m_autoIncrement(false) +{ +} + +inline void +Plan_ddl_column::setNotNull() +{ + m_nullable = false; +} + +inline void +Plan_ddl_column::setUnSigned() +{ + m_unSigned = true; +} + +inline void +Plan_ddl_column::setPrimaryKey() +{ + m_nullable = false; + m_primaryKey = true; +} + +inline bool +Plan_ddl_column::getPrimaryKey() const +{ + return m_primaryKey; +} + +inline void +Plan_ddl_column::setTupleId() +{ + m_nullable = false; + m_tupleId = true; +} + +inline bool +Plan_ddl_column::getTupleId() const +{ + return m_tupleId; +} + +inline void +Plan_ddl_column::setAutoIncrement() +{ + m_nullable = false; + m_autoIncrement = true; +} + +inline bool +Plan_ddl_column::getAutoIncrement() const +{ + return m_autoIncrement; +} + +// children + +inline void +Plan_ddl_column::setType(Plan_data_type* type) +{ + ctx_assert(type != 0); + m_type = type; +} + +inline void +Plan_ddl_column::setDefaultValue(Plan_expr* defaultValue) +{ + ctx_assert(defaultValue != 0); + m_defaultValue = defaultValue; +} + +inline Plan_expr* +Plan_ddl_column::getDefaultValue() const +{ + return m_defaultValue; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_ddl_constr.cpp b/ndb/src/client/odbc/codegen/Code_ddl_constr.cpp new file mode 100644 index 00000000000..78c23e38d97 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_ddl_constr.cpp @@ -0,0 +1,51 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include "Code_ddl_constr.hpp" + +// Plan_ddl_constr + +Plan_ddl_constr::~Plan_ddl_constr() +{ +} + +Plan_base* +Plan_ddl_constr::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_ddlRow != 0); + m_ddlRow->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +Exec_base* +Plan_ddl_constr::codegen(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(false); + return 0; +} + +void +Plan_ddl_constr::print(Ctx& ctx) +{ + ctx.print(" [ddl_constr"); + Plan_base* a[] = { m_ddlRow }; + printList(ctx, a, 1); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_ddl_constr.hpp b/ndb/src/client/odbc/codegen/Code_ddl_constr.hpp new file mode 100644 index 00000000000..ea7808b37cb --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_ddl_constr.hpp @@ -0,0 +1,65 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_ddl_constr_hpp +#define ODBC_CODEGEN_Code_ddl_constr_hpp + +#include +#include "Code_ddl_row.hpp" + +/** + * @class Plan_ddl_constr + * @brief Constraint in DDL statement + * + * Only unnamed primary key constraint exists. + */ +class Plan_ddl_constr : public Plan_base { +public: + Plan_ddl_constr(Plan_root* root); + virtual ~Plan_ddl_constr(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setRow(Plan_ddl_row* ddlRow); + Plan_ddl_row* getRow() const; +protected: + Plan_ddl_row* m_ddlRow; +}; + +inline +Plan_ddl_constr::Plan_ddl_constr(Plan_root* root) : + Plan_base(root) +{ +} + +// children + +inline void +Plan_ddl_constr::setRow(Plan_ddl_row* ddlRow) +{ + ctx_assert(ddlRow != 0); + m_ddlRow = ddlRow; +} + +inline Plan_ddl_row* +Plan_ddl_constr::getRow() const +{ + ctx_assert(m_ddlRow != 0); + return m_ddlRow; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_ddl_row.cpp b/ndb/src/client/odbc/codegen/Code_ddl_row.cpp new file mode 100644 index 00000000000..87589ebbaa0 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_ddl_row.cpp @@ -0,0 +1,54 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_ddl_row.hpp" +#include "Code_ddl_column.hpp" +#include "Code_ddl_constr.hpp" + +Plan_ddl_row::~Plan_ddl_row() +{ +} + +Plan_base* +Plan_ddl_row::analyze(Ctx& ctx, Ctl& ctl) +{ + // analyze the columns + for (unsigned i = 1, n = countColumn(); i <= n; i++) { + Plan_ddl_column* column = getColumn(i); + column->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + } + // node was not replaced + return this; +} + +Exec_base* +Plan_ddl_row::codegen(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(false); + return 0; +} + +void +Plan_ddl_row::print(Ctx& ctx) +{ + ctx.print(" [ddl_row"); + for (unsigned i = 1, n = countColumn(); i <= n; i++) { + Plan_base* a = m_columnList[i]; + printList(ctx, &a, 1); + } +} diff --git a/ndb/src/client/odbc/codegen/Code_ddl_row.hpp b/ndb/src/client/odbc/codegen/Code_ddl_row.hpp new file mode 100644 index 00000000000..ac3eded1b2e --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_ddl_row.hpp @@ -0,0 +1,72 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_ddl_row_hpp +#define ODBC_CODEGEN_Code_ddl_row_hpp + +#include +#include "Code_base.hpp" +#include "Code_ddl_column.hpp" + +/** + * @class Plan_ddl_row + * @brief Row of columns in create statement + */ +class Plan_ddl_row : public Plan_base { +public: + Plan_ddl_row(Plan_root* root); + virtual ~Plan_ddl_row(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + unsigned countColumn() const; + void addColumn(Plan_ddl_column* column); + Plan_ddl_column* getColumn(unsigned i) const; +protected: + DdlColumnVector m_columnList; +}; + +inline +Plan_ddl_row::Plan_ddl_row(Plan_root* root) : + Plan_base(root), + m_columnList(1) +{ +} + +// children + +inline unsigned +Plan_ddl_row::countColumn() const +{ + return m_columnList.size() - 1; +} + +inline void +Plan_ddl_row::addColumn(Plan_ddl_column* column) +{ + ctx_assert(column != 0); + m_columnList.push_back(column); +} + +inline Plan_ddl_column* +Plan_ddl_row::getColumn(unsigned i) const +{ + ctx_assert(1 <= i && i <= countColumn() && m_columnList[i] != 0); + return m_columnList[i]; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_delete.cpp b/ndb/src/client/odbc/codegen/Code_delete.cpp new file mode 100644 index 00000000000..35b3daa1aca --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_delete.cpp @@ -0,0 +1,205 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Code_delete.hpp" +#include "Code_delete_lookup.hpp" +#include "Code_delete_index.hpp" +#include "Code_delete_scan.hpp" +#include "Code_query_filter.hpp" +#include "Code_query_lookup.hpp" +#include "Code_query_index.hpp" +#include "Code_query_scan.hpp" +#include "Code_query_range.hpp" +#include "Code_query_repeat.hpp" +#include "Code_table.hpp" +#include "Code_root.hpp" + +Plan_delete::~Plan_delete() +{ +} + +Plan_base* +Plan_delete::analyze(Ctx& ctx, Ctl& ctl) +{ + stmtArea().stmtInfo().setName(Stmt_name_delete); + // analyze the table + ctx_assert(m_table != 0); + m_table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + // set name resolution scope + ctl.m_tableList.resize(1 + 1); // indexed from 1 + ctl.m_tableList[1] = m_table; + Plan_dml* stmt = 0; + if (m_pred != 0) { + // analyze the predicate + ctl.m_topand = true; + ctl.m_extra = false; + m_pred = static_cast(m_pred->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(m_pred != 0); + // check for key match + Plan_table::Index* indexBest = 0; + for (unsigned i = 0; i <= m_table->indexCount(); i++) { + Plan_table::Index& index = m_table->m_indexList[i]; + TableSet tsDone; + m_table->resolveSet(ctx, index, tsDone); + if (! ctx.ok()) + return 0; + if (! index.m_keyFound) + continue; + // prefer smaller rank, less unused keys + int k; + (k = (indexBest == 0)) || + (k = (indexBest->m_rank - index.m_rank)) || + (k = (indexBest->m_keyCountUnused - index.m_keyCountUnused)); + if (k > 0) + indexBest = &index; + } + if (indexBest != 0) { + const bool exactKey = indexBest->m_rank <= 1 ? m_table->exactKey(ctx, indexBest) : false; + const bool direct = ! ctl.m_extra && exactKey; + ctx_log3(("delete direct=%d: extra=%d exact=%d", direct, ctl.m_extra, exactKey)); + if (indexBest->m_rank == 0) { + // primary key + Plan_delete_lookup* deleteLookup = new Plan_delete_lookup(m_root); + m_root->saveNode(deleteLookup); + deleteLookup->setTable(m_table); + if (direct) { + // key match with no extra conditions + Plan_query_repeat* queryRepeat = new Plan_query_repeat(m_root, 1); + m_root->saveNode(queryRepeat); + deleteLookup->setQuery(queryRepeat); + } else { + // key match with extra conditions + Plan_query_lookup* queryLookup = new Plan_query_lookup(m_root); + m_root->saveNode(queryLookup); + Plan_query_filter* queryFilter = new Plan_query_filter(m_root); + m_root->saveNode(queryFilter); + queryLookup->setTable(m_table); + queryFilter->setQuery(queryLookup); + queryFilter->setPred(m_pred); + queryFilter->m_topTable = m_table; + deleteLookup->setQuery(queryFilter); + } + stmt = deleteLookup; + } else if (indexBest->m_rank == 1) { + // hash index + Plan_delete_index* deleteIndex = new Plan_delete_index(m_root); + m_root->saveNode(deleteIndex); + deleteIndex->setTable(m_table, indexBest); + if (direct) { + // key match with no extra conditions + Plan_query_repeat* queryRepeat = new Plan_query_repeat(m_root, 1); + m_root->saveNode(queryRepeat); + deleteIndex->setQuery(queryRepeat); + } else { + // key match with extra conditions + Plan_query_index* queryIndex = new Plan_query_index(m_root); + m_root->saveNode(queryIndex); + Plan_query_filter* queryFilter = new Plan_query_filter(m_root); + m_root->saveNode(queryFilter); + queryIndex->setTable(m_table, indexBest); + queryFilter->setQuery(queryIndex); + queryFilter->setPred(m_pred); + queryFilter->m_topTable = m_table; + deleteIndex->setQuery(queryFilter); + } + stmt = deleteIndex; + } else if (indexBest->m_rank == 2) { + // ordered index + Plan_delete_scan* deleteScan = new Plan_delete_scan(m_root); + m_root->saveNode(deleteScan); + Plan_query_filter* queryFilter = new Plan_query_filter(m_root); + m_root->saveNode(queryFilter); + Plan_query_range* queryRange = new Plan_query_range(m_root); + m_root->saveNode(queryRange); + queryRange->setTable(m_table, indexBest); + queryRange->setExclusive(); + queryFilter->setQuery(queryRange); + queryFilter->setPred(m_pred); + queryFilter->m_topTable = m_table; + const TableSet& ts2 = m_pred->noInterp(); + ctx_assert(ts2.size() <= 1); + if (ts2.size() == 0) { + queryRange->setInterp(m_pred); + } + deleteScan->setQuery(queryFilter); + stmt = deleteScan; + } else { + ctx_assert(false); + } + } else { + // scan delete with filter + Plan_delete_scan* deleteScan = new Plan_delete_scan(m_root); + m_root->saveNode(deleteScan); + Plan_query_filter* queryFilter = new Plan_query_filter(m_root); + m_root->saveNode(queryFilter); + Plan_query_scan* queryScan = new Plan_query_scan(m_root); + m_root->saveNode(queryScan); + queryScan->setTable(m_table); + queryScan->setExclusive(); + queryFilter->setQuery(queryScan); + queryFilter->setPred(m_pred); + queryFilter->m_topTable = m_table; + // interpeter + const TableSet& ts2 = m_pred->noInterp(); + ctx_assert(ts2.size() <= 1); + if (ts2.size() == 0) { + queryScan->setInterp(m_pred); + } + deleteScan->setQuery(queryFilter); + stmt = deleteScan; + } + } else { + // scan delete without filter + Plan_delete_scan* deleteScan = new Plan_delete_scan(m_root); + m_root->saveNode(deleteScan); + Plan_query_scan* queryScan = new Plan_query_scan(m_root); + m_root->saveNode(queryScan); + queryScan->setTable(m_table); + queryScan->setExclusive(); + deleteScan->setQuery(queryScan); + stmt = deleteScan; + } + // set base for column position offsets + m_table->m_resOff = 1; + return stmt; +} + +void +Plan_delete::describe(Ctx& ctx) +{ + stmtArea().setFunction(ctx, "DELETE WHERE", SQL_DIAG_DELETE_WHERE); +} + +Exec_base* +Plan_delete::codegen(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(false); + return 0; +} + +void +Plan_delete::print(Ctx& ctx) +{ + ctx.print(" [delete"); + Plan_base* a[] = { m_table, m_pred }; + printList(ctx, a, 1); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_delete.hpp b/ndb/src/client/odbc/codegen/Code_delete.hpp new file mode 100644 index 00000000000..c7fa245497b --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_delete.hpp @@ -0,0 +1,69 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_delete_hpp +#define ODBC_CODEGEN_Code_delete_hpp + +#include +#include "Code_base.hpp" +#include "Code_dml.hpp" +#include "Code_table.hpp" +#include "Code_query.hpp" +#include "Code_pred.hpp" + +/** + * @class Plan_delete + * @brief Delete in PlanTree + */ +class Plan_delete : public Plan_dml { +public: + Plan_delete(Plan_root* root); + virtual ~Plan_delete(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + void describe(Ctx& ctx); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setTable(Plan_table* table); + void setPred(Plan_pred* pred); +protected: + Plan_table* m_table; + Plan_pred* m_pred; +}; + +inline +Plan_delete::Plan_delete(Plan_root* root) : + Plan_dml(root), + m_table(0), + m_pred(0) +{ +} + +inline void +Plan_delete::setTable(Plan_table* table) +{ + ctx_assert(table != 0); + m_table = table; +} + +inline void +Plan_delete::setPred(Plan_pred* pred) +{ + ctx_assert(pred != 0); + m_pred = pred; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_delete_index.cpp b/ndb/src/client/odbc/codegen/Code_delete_index.cpp new file mode 100644 index 00000000000..8f2c3be2848 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_delete_index.cpp @@ -0,0 +1,164 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include "Code_expr.hpp" +#include "Code_delete_index.hpp" +#include "Code_table.hpp" +#include "Code_root.hpp" + +Plan_delete_index::~Plan_delete_index() +{ +} + +Plan_base* +Plan_delete_index::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_query != 0); + m_query->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + ctx_assert(m_table != 0); + m_table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +void +Plan_delete_index::describe(Ctx& ctx) +{ + stmtArea().setFunction(ctx, "DELETE WHERE", SQL_DIAG_DELETE_WHERE); +} + +Exec_base* +Plan_delete_index::codegen(Ctx& ctx, Ctl& ctl) +{ + // create code for the query + ctx_assert(m_query != 0); + Exec_query* execQuery = static_cast(m_query->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execQuery != 0); + // set up + ctx_assert(m_table != 0 && m_index != 0); + const BaseString& tableName = m_table->getName(); + ctx_assert(m_index->m_dictIndex != 0); + const DictIndex& dictIndex = *m_index->m_dictIndex; + const BaseString& indexName = dictIndex.getName(); + const unsigned keyCount = m_index->m_keyCount; + // create the code + Exec_delete_index::Code& code = *new Exec_delete_index::Code(keyCount); + code.m_tableName = strcpy(new char[tableName.length() + 1], tableName.c_str()); + code.m_indexName = strcpy(new char[indexName.length() + 1], indexName.c_str()); + // key attributes + code.m_keyId = new NdbAttrId[1 + keyCount]; + code.m_keyId[0] = (NdbAttrId)-1; + for (unsigned k = 1; k <= keyCount; k++) { + const DictColumn* keyColumn = dictIndex.getColumn(k); + const SqlType& sqlType = keyColumn->sqlType(); + SqlSpec sqlSpec(sqlType, SqlSpec::Physical); + code.m_keySpecs.setEntry(k, sqlSpec); + code.m_keyId[k] = k - 1; // index column order + } + // matching expressions + ctx_assert(m_index->m_keyFound); + const ExprVector& keyEq = m_index->m_keyEq; + ctx_assert(keyEq.size() == 1 + keyCount); + code.m_keyMatch = new Exec_expr* [1 + keyCount]; + code.m_keyMatch[0] = 0; + for (unsigned k = 1; k <= keyCount; k++) { + Plan_expr* expr = keyEq[k]; + Exec_expr* execExpr = static_cast(expr->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execExpr != 0); + code.m_keyMatch[k] = execExpr; + } + // create the exec + Exec_delete_index* exec = new Exec_delete_index(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + exec->setCode(code); + exec->setQuery(execQuery); + return exec; +} + +void +Plan_delete_index::print(Ctx& ctx) +{ + ctx.print(" [delete_index"); + Plan_base* a[] = { m_query, m_table }; + printList(ctx, a, 2); + ctx.print("]"); +} + +// Exec_delete_index + +Exec_delete_index::Code::~Code() +{ + delete[] m_tableName; + delete[] m_keyId; + delete[] m_keyMatch; +} + +Exec_delete_index::Data::~Data() +{ +} + +Exec_delete_index::~Exec_delete_index() +{ +} + +void +Exec_delete_index::alloc(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + // allocate the subquery + ctx_assert(m_query != 0); + m_query->alloc(ctx, ctl); + if (! ctx.ok()) + return; + // allocate matching expressions + for (unsigned k = 1; k <= code.m_keyCount; k++) { + Exec_expr* expr = code.m_keyMatch[k]; + ctx_assert(expr != 0); + expr->alloc(ctx, ctl); + if (! ctx.ok()) + return; + } + // create data + Data& data = *new Data; + setData(data); +} + +void +Exec_delete_index::close(Ctx& ctx) +{ + ctx_assert(m_query != 0); + m_query->close(ctx); +} + +void +Exec_delete_index::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx.print(" [delete_index"); + Exec_base* a[] = { m_query }; + printList(ctx, a, 1); + printList(ctx, (Exec_base**)&code.m_keyMatch[1], code.m_keyCount); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_delete_index.hpp b/ndb/src/client/odbc/codegen/Code_delete_index.hpp new file mode 100644 index 00000000000..1aaaa18abcb --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_delete_index.hpp @@ -0,0 +1,156 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_delete_index_hpp +#define ODBC_CODEGEN_Code_delete_index_hpp + +#include +#include "Code_dml.hpp" +#include "Code_query.hpp" +#include "Code_table.hpp" + +/** + * @class Plan_delete_index + * @brief Delete by primary key + */ +class Plan_delete_index : public Plan_dml { +public: + Plan_delete_index(Plan_root* root); + virtual ~Plan_delete_index(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + void describe(Ctx& ctx); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setQuery(Plan_query* query); + void setTable(Plan_table* table, Plan_table::Index* index); +protected: + Plan_query* m_query; + Plan_table* m_table; + Plan_table::Index* m_index; +}; + +inline +Plan_delete_index::Plan_delete_index(Plan_root* root) : + Plan_dml(root), + m_query(0), + m_table(0) +{ +} + +inline void +Plan_delete_index::setQuery(Plan_query* query) +{ + ctx_assert(query != 0); + m_query = query; +} + +inline void +Plan_delete_index::setTable(Plan_table* table, Plan_table::Index* index) +{ + ctx_assert(table != 0 && index != 0 && index == &table->m_indexList[index->m_pos] && index->m_pos != 0); + m_table = table; + m_index = index; +} + +/** + * @class Exec_delete_index + * @brief Delete by primary key + */ +class Exec_delete_index : public Exec_dml { +public: + class Code : public Exec_dml::Code { + public: + Code(unsigned keyCount); + virtual ~Code(); + protected: + friend class Plan_delete_index; + friend class Exec_delete_index; + const char* m_tableName; + const char* m_indexName; + unsigned m_keyCount; + SqlSpecs m_keySpecs; // key types + NdbAttrId* m_keyId; + Exec_expr** m_keyMatch; // XXX pointers for now + }; + class Data : public Exec_dml::Data { + public: + Data(); + virtual ~Data(); + protected: + friend class Exec_delete_index; + }; + Exec_delete_index(Exec_root* root); + virtual ~Exec_delete_index(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setQuery(Exec_query* query); +protected: + Exec_query* m_query; +}; + +inline +Exec_delete_index::Code::Code(unsigned keyCount) : + m_tableName(0), + m_indexName(0), + m_keyCount(keyCount), + m_keySpecs(keyCount), + m_keyId(0), + m_keyMatch(0) +{ +} + +inline +Exec_delete_index::Data::Data() +{ +} + +inline +Exec_delete_index::Exec_delete_index(Exec_root* root) : + Exec_dml(root), + m_query(0) +{ +} + +// children + +inline const Exec_delete_index::Code& +Exec_delete_index::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_delete_index::Data& +Exec_delete_index::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_delete_index::setQuery(Exec_query* query) +{ + ctx_assert(query != 0 && m_query == 0); + m_query = query; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_delete_lookup.cpp b/ndb/src/client/odbc/codegen/Code_delete_lookup.cpp new file mode 100644 index 00000000000..4a6dec64654 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_delete_lookup.cpp @@ -0,0 +1,162 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include "Code_expr.hpp" +#include "Code_delete_lookup.hpp" +#include "Code_table.hpp" +#include "Code_root.hpp" + +Plan_delete_lookup::~Plan_delete_lookup() +{ +} + +Plan_base* +Plan_delete_lookup::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_query != 0); + m_query->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + ctx_assert(m_table != 0); + m_table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +void +Plan_delete_lookup::describe(Ctx& ctx) +{ + stmtArea().setFunction(ctx, "DELETE WHERE", SQL_DIAG_DELETE_WHERE); +} + +Exec_base* +Plan_delete_lookup::codegen(Ctx& ctx, Ctl& ctl) +{ + // create code for the query + ctx_assert(m_query != 0); + Exec_query* execQuery = static_cast(m_query->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execQuery != 0); + // set up + ctx_assert(m_table != 0); + const BaseString& tableName = m_table->getName(); + const DictTable& dictTable = m_table->dictTable(); + const unsigned keyCount = dictTable.keyCount(); + // create the code + Exec_delete_lookup::Code& code = *new Exec_delete_lookup::Code(keyCount); + code.m_tableName = strcpy(new char[tableName.length() + 1], tableName.c_str()); + // key attributes + code.m_keyId = new NdbAttrId[1 + keyCount]; + code.m_keyId[0] = (NdbAttrId)-1; + for (unsigned k = 1; k <= keyCount; k++) { + const DictColumn* keyColumn = dictTable.getKey(k); + const SqlType& sqlType = keyColumn->sqlType(); + SqlSpec sqlSpec(sqlType, SqlSpec::Physical); + code.m_keySpecs.setEntry(k, sqlSpec); + code.m_keyId[k] = keyColumn->getAttrId(); + } + // matching expressions + const Plan_table::Index& index = m_table->m_indexList[0]; + ctx_assert(index.m_keyFound); + const ExprVector& keyEq = index.m_keyEq; + ctx_assert(keyEq.size() == 1 + keyCount); + code.m_keyMatch = new Exec_expr* [1 + keyCount]; + code.m_keyMatch[0] = 0; + for (unsigned k = 1; k <= keyCount; k++) { + Plan_expr* expr = keyEq[k]; + Exec_expr* execExpr = static_cast(expr->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execExpr != 0); + code.m_keyMatch[k] = execExpr; + } + // create the exec + Exec_delete_lookup* exec = new Exec_delete_lookup(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + exec->setCode(code); + exec->setQuery(execQuery); + return exec; +} + +void +Plan_delete_lookup::print(Ctx& ctx) +{ + ctx.print(" [delete_lookup"); + Plan_base* a[] = { m_query, m_table }; + printList(ctx, a, 2); + ctx.print("]"); +} + +// Exec_delete_lookup + +Exec_delete_lookup::Code::~Code() +{ + delete[] m_tableName; + delete[] m_keyId; + delete[] m_keyMatch; +} + +Exec_delete_lookup::Data::~Data() +{ +} + +Exec_delete_lookup::~Exec_delete_lookup() +{ +} + +void +Exec_delete_lookup::alloc(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + // allocate the subquery + ctx_assert(m_query != 0); + m_query->alloc(ctx, ctl); + if (! ctx.ok()) + return; + // allocate matching expressions + for (unsigned k = 1; k <= code.m_keyCount; k++) { + Exec_expr* expr = code.m_keyMatch[k]; + ctx_assert(expr != 0); + expr->alloc(ctx, ctl); + if (! ctx.ok()) + return; + } + // create data + Data& data = *new Data; + setData(data); +} + +void +Exec_delete_lookup::close(Ctx& ctx) +{ + ctx_assert(m_query != 0); + m_query->close(ctx); +} + +void +Exec_delete_lookup::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx.print(" [delete_lookup"); + Exec_base* a[] = { m_query }; + printList(ctx, a, 1); + printList(ctx, (Exec_base**)&code.m_keyMatch[1], code.m_keyCount); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_delete_lookup.hpp b/ndb/src/client/odbc/codegen/Code_delete_lookup.hpp new file mode 100644 index 00000000000..4138baefa4c --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_delete_lookup.hpp @@ -0,0 +1,152 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_delete_lookup_hpp +#define ODBC_CODEGEN_Code_delete_lookup_hpp + +#include +#include "Code_dml.hpp" +#include "Code_query.hpp" +#include "Code_table.hpp" + +/** + * @class Plan_delete_lookup + * @brief Delete by primary key + */ +class Plan_delete_lookup : public Plan_dml { +public: + Plan_delete_lookup(Plan_root* root); + virtual ~Plan_delete_lookup(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + void describe(Ctx& ctx); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setQuery(Plan_query* query); + void setTable(Plan_table* table); +protected: + Plan_query* m_query; + Plan_table* m_table; +}; + +inline +Plan_delete_lookup::Plan_delete_lookup(Plan_root* root) : + Plan_dml(root), + m_query(0), + m_table(0) +{ +} + +inline void +Plan_delete_lookup::setQuery(Plan_query* query) +{ + ctx_assert(query != 0); + m_query = query; +} + +inline void +Plan_delete_lookup::setTable(Plan_table* table) +{ + ctx_assert(table != 0); + m_table = table; +} + +/** + * @class Exec_delete_lookup + * @brief Delete by primary key + */ +class Exec_delete_lookup : public Exec_dml { +public: + class Code : public Exec_dml::Code { + public: + Code(unsigned keyCount); + virtual ~Code(); + protected: + friend class Plan_delete_lookup; + friend class Exec_delete_lookup; + char* m_tableName; + unsigned m_keyCount; + SqlSpecs m_keySpecs; // key types + NdbAttrId* m_keyId; + Exec_expr** m_keyMatch; // XXX pointers for now + }; + class Data : public Exec_dml::Data { + public: + Data(); + virtual ~Data(); + protected: + friend class Exec_delete_lookup; + }; + Exec_delete_lookup(Exec_root* root); + virtual ~Exec_delete_lookup(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setQuery(Exec_query* query); +protected: + Exec_query* m_query; +}; + +inline +Exec_delete_lookup::Code::Code(unsigned keyCount) : + m_tableName(0), + m_keyCount(keyCount), + m_keySpecs(keyCount), + m_keyId(0), + m_keyMatch(0) +{ +} + +inline +Exec_delete_lookup::Data::Data() +{ +} + +inline +Exec_delete_lookup::Exec_delete_lookup(Exec_root* root) : + Exec_dml(root), + m_query(0) +{ +} + +// children + +inline const Exec_delete_lookup::Code& +Exec_delete_lookup::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_delete_lookup::Data& +Exec_delete_lookup::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_delete_lookup::setQuery(Exec_query* query) +{ + ctx_assert(query != 0 && m_query == 0); + m_query = query; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_delete_scan.cpp b/ndb/src/client/odbc/codegen/Code_delete_scan.cpp new file mode 100644 index 00000000000..fed7244a026 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_delete_scan.cpp @@ -0,0 +1,110 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Code_delete_scan.hpp" +#include "Code_root.hpp" + +Plan_delete_scan::~Plan_delete_scan() +{ +} + +Plan_base* +Plan_delete_scan::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_query != 0); + m_query->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +void +Plan_delete_scan::describe(Ctx& ctx) +{ + stmtArea().setFunction(ctx, "DELETE WHERE", SQL_DIAG_DELETE_WHERE); +} + +Exec_base* +Plan_delete_scan::codegen(Ctx& ctx, Ctl& ctl) +{ + // create code for the subquery + ctx_assert(m_query != 0); + Exec_query* execQuery = static_cast(m_query->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execQuery != 0); + // create the code + Exec_delete_scan* exec = new Exec_delete_scan(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + Exec_delete_scan::Code& code = *new Exec_delete_scan::Code; + exec->setCode(code); + exec->setQuery(execQuery); + return exec; +} + +void +Plan_delete_scan::print(Ctx& ctx) +{ + ctx.print(" [delete_scan"); + Plan_base* a[] = { m_query }; + printList(ctx, a, 1); + ctx.print("]"); +} + +// Exec_delete_scan + +Exec_delete_scan::Code::~Code() +{ +} + +Exec_delete_scan::Data::~Data() +{ +} + +Exec_delete_scan::~Exec_delete_scan() +{ +} + +void +Exec_delete_scan::alloc(Ctx& ctx, Ctl& ctl) +{ + // allocate the subquery + ctx_assert(m_query != 0); + m_query->alloc(ctx, ctl); + if (! ctx.ok()) + return; + // create data + Data& data = *new Data; + setData(data); +} + +void +Exec_delete_scan::close(Ctx& ctx) +{ + ctx_assert(m_query != 0); + m_query->close(ctx); +} + +void +Exec_delete_scan::print(Ctx& ctx) +{ + ctx.print(" [delete_scan"); + Exec_base* a[] = { m_query }; + printList(ctx, a, 1); + ctx.print("]"); +} + diff --git a/ndb/src/client/odbc/codegen/Code_delete_scan.hpp b/ndb/src/client/odbc/codegen/Code_delete_scan.hpp new file mode 100644 index 00000000000..eb013a8257e --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_delete_scan.hpp @@ -0,0 +1,130 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_delete_scan_hpp +#define ODBC_CODEGEN_Code_delete_scan_hpp + +#include +#include "Code_dml.hpp" +#include "Code_query.hpp" + +/** + * @class Plan_delete_scan + * @brief Scan delete + */ +class Plan_delete_scan : public Plan_dml { +public: + Plan_delete_scan(Plan_root* root); + virtual ~Plan_delete_scan(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + void describe(Ctx& ctx); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setQuery(Plan_query* query); +protected: + Plan_query* m_query; +}; + +inline +Plan_delete_scan::Plan_delete_scan(Plan_root* root) : + Plan_dml(root), + m_query(0) +{ +} + +inline void +Plan_delete_scan::setQuery(Plan_query* query) +{ + ctx_assert(query != 0); + m_query = query; +} + +/** + * @class Exec_delete_scan + * @brief Scan delete + */ +class Exec_delete_scan : public Exec_dml { +public: + class Code : public Exec_dml::Code { + public: + Code(); + virtual ~Code(); + protected: + friend class Exec_delete_scan; + }; + class Data : public Exec_dml::Data { + public: + Data(); + virtual ~Data(); + protected: + friend class Exec_delete_scan; + }; + Exec_delete_scan(Exec_root* root); + virtual ~Exec_delete_scan(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setQuery(Exec_query* query); +protected: + Exec_query* m_query; +}; + +inline +Exec_delete_scan::Code::Code() +{ +} + +inline +Exec_delete_scan::Data::Data() +{ +} + +inline +Exec_delete_scan::Exec_delete_scan(Exec_root* root) : + Exec_dml(root), + m_query(0) +{ +} + +// children + +inline const Exec_delete_scan::Code& +Exec_delete_scan::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_delete_scan::Data& +Exec_delete_scan::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_delete_scan::setQuery(Exec_query* query) +{ + ctx_assert(query != 0 && m_query == 0); + m_query = query; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_dml.cpp b/ndb/src/client/odbc/codegen/Code_dml.cpp new file mode 100644 index 00000000000..44fd4478646 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_dml.cpp @@ -0,0 +1,51 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Code_dml.hpp" + +// Plan_dml + +Plan_dml::~Plan_dml() +{ +} + +// Exec_dml + +Exec_dml::Code::~Code() +{ +} + +Exec_dml::Data::~Data() +{ +} + +Exec_dml::~Exec_dml() +{ +} + +void +Exec_dml::execute(Ctx& ctx, Ctl& ctl) +{ + execImpl(ctx, ctl); + if (m_topLevel) { + if (ctx.ok()) { + if (stmtArea().getRowCount() == 0) { + ctx.setCode(SQL_NO_DATA); + } + } + } +} diff --git a/ndb/src/client/odbc/codegen/Code_dml.hpp b/ndb/src/client/odbc/codegen/Code_dml.hpp new file mode 100644 index 00000000000..0618f583984 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_dml.hpp @@ -0,0 +1,67 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_dml_hpp +#define ODBC_CODEGEN_Code_dml_hpp + +#include +#include +#include "Code_stmt.hpp" + +/** + * @class Plan_dml + * @brief Base class for DML statements in PlanTree + */ +class Plan_dml : public Plan_stmt { +public: + Plan_dml(Plan_root* root); + virtual ~Plan_dml() = 0; +}; + +inline +Plan_dml::Plan_dml(Plan_root* root) : + Plan_stmt(root) +{ +} + +/** + * @class Exec_dml + * @brief Base class for DML statements in ExecTree + */ +class Exec_dml : public Exec_stmt { +public: + class Code : public Exec_stmt::Code { + public: + virtual ~Code() = 0; + }; + class Data : public Exec_stmt::Data, public ResultArea { + public: + virtual ~Data() = 0; + }; + Exec_dml(Exec_root* root); + virtual ~Exec_dml() = 0; + void execute(Ctx& ctx, Ctl& ctl); +protected: + virtual void execImpl(Ctx& ctx, Ctl& ctl) = 0; +}; + +inline +Exec_dml::Exec_dml(Exec_root* root) : + Exec_stmt(root) +{ +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_dml_column.cpp b/ndb/src/client/odbc/codegen/Code_dml_column.cpp new file mode 100644 index 00000000000..808e2ac8c4b --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_dml_column.cpp @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include "Code_dml_column.hpp" + +// Plan_dml_column + +Plan_dml_column::~Plan_dml_column() +{ +} + +Plan_base* +Plan_dml_column::analyze(Ctx& ctx, Ctl& ctl) +{ + analyzeColumn(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +Exec_base* +Plan_dml_column::codegen(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(false); + return 0; +} + +void +Plan_dml_column::print(Ctx& ctx) +{ + ctx.print(" [dml_column %s]", getPrintName()); +} diff --git a/ndb/src/client/odbc/codegen/Code_dml_column.hpp b/ndb/src/client/odbc/codegen/Code_dml_column.hpp new file mode 100644 index 00000000000..0fb33944a3a --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_dml_column.hpp @@ -0,0 +1,46 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_dml_column_hpp +#define ODBC_CODEGEN_Code_dml_column_hpp + +#include +#include "Code_column.hpp" + +class DictColumn; +class Plan_table; + +/** + * @class Plan_dml_column + * @brief Column in query expression + */ +class Plan_dml_column : public Plan_base, public Plan_column { +public: + Plan_dml_column(Plan_root* root, const BaseString& name); + virtual ~Plan_dml_column(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); +}; + +inline +Plan_dml_column::Plan_dml_column(Plan_root* root, const BaseString& name) : + Plan_base(root), + Plan_column(Type_dml, name) +{ +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_dml_row.cpp b/ndb/src/client/odbc/codegen/Code_dml_row.cpp new file mode 100644 index 00000000000..ceb63a9f7b9 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_dml_row.cpp @@ -0,0 +1,56 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_dml_row.hpp" +#include "Code_dml_column.hpp" + +Plan_dml_row::~Plan_dml_row() +{ +} + +Plan_base* +Plan_dml_row::analyze(Ctx& ctx, Ctl& ctl) +{ + unsigned size = getSize(); + // analyze the columns + for (unsigned i = 1; i <= size; i++) { + Plan_dml_column* column = getColumn(i); + column->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + } + // node was not replaced + return this; +} + +Exec_base* +Plan_dml_row::codegen(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(false); + return 0; +} + +void +Plan_dml_row::print(Ctx& ctx) +{ + unsigned size = getSize(); + ctx.print(" [dml_row"); + for (unsigned i = 1; i <= size; i++) { + Plan_base* a = m_columnList[i]; + a == 0 ? ctx.print(" -") : a->print(ctx); + } + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_dml_row.hpp b/ndb/src/client/odbc/codegen/Code_dml_row.hpp new file mode 100644 index 00000000000..6c7e46ba9af --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_dml_row.hpp @@ -0,0 +1,76 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_dml_row_hpp +#define ODBC_CODEGEN_Code_dml_row_hpp + +#include +#include +#include +#include "Code_base.hpp" +#include "Code_dml_column.hpp" + +class Plan_dml_column; + +/** + * @class Plan_dml_row + * @brief Row of lvalue columns in insert or update + */ +class Plan_dml_row : public Plan_base { +public: + Plan_dml_row(Plan_root* root); + virtual ~Plan_dml_row(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + unsigned getSize() const; + void addColumn(Plan_dml_column* column); + Plan_dml_column* getColumn(unsigned i) const; +protected: + DmlColumnVector m_columnList; +}; + +inline +Plan_dml_row::Plan_dml_row(Plan_root* root) : + Plan_base(root), + m_columnList(1) +{ +} + +// children + +inline unsigned +Plan_dml_row::getSize() const +{ + return m_columnList.size() - 1; +} + +inline void +Plan_dml_row::addColumn(Plan_dml_column* column) +{ + ctx_assert(column != 0); + m_columnList.push_back(column); +} + +inline Plan_dml_column* +Plan_dml_row::getColumn(unsigned i) const +{ + ctx_assert(1 <= i && i <= m_columnList.size() && m_columnList[i] != 0); + return m_columnList[i]; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_drop_index.cpp b/ndb/src/client/odbc/codegen/Code_drop_index.cpp new file mode 100644 index 00000000000..b6bae88e270 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_drop_index.cpp @@ -0,0 +1,87 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Code_drop_index.hpp" +#include "Code_root.hpp" + +// Plan_drop_index + +Plan_drop_index::~Plan_drop_index() +{ +} + +Plan_base* +Plan_drop_index::analyze(Ctx& ctx, Ctl& ctl) +{ + stmtArea().stmtInfo().setName(Stmt_name_drop_index); + return this; +} + +void +Plan_drop_index::describe(Ctx& ctx) +{ + stmtArea().setFunction(ctx, "DROP INDEX", SQL_DIAG_DROP_INDEX); +} + +Exec_base* +Plan_drop_index::codegen(Ctx& ctx, Ctl& ctl) +{ + Exec_drop_index* exec = new Exec_drop_index(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + Exec_drop_index::Code& code = *new Exec_drop_index::Code(m_name, m_tableName); + exec->setCode(code); + return exec; +} + +void +Plan_drop_index::print(Ctx& ctx) +{ + ctx.print(" [drop_index %s]", m_name.c_str()); +} + +// Exec_drop_index + +Exec_drop_index::Code::~Code() +{ +} + +Exec_drop_index::Data::~Data() +{ +} + +Exec_drop_index::~Exec_drop_index() +{ +} + +void +Exec_drop_index::alloc(Ctx& ctx, Ctl& ctl) +{ + Data& data = *new Data; + setData(data); +} + +void +Exec_drop_index::close(Ctx& ctx) +{ +} + +void +Exec_drop_index::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx.print(" [drop_index %s]", code.m_indexName.c_str()); +} diff --git a/ndb/src/client/odbc/codegen/Code_drop_index.hpp b/ndb/src/client/odbc/codegen/Code_drop_index.hpp new file mode 100644 index 00000000000..99891c9a52f --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_drop_index.hpp @@ -0,0 +1,136 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_drop_index_hpp +#define ODBC_CODEGEN_Code_drop_index_hpp + +#include +#include +#include +#include "Code_ddl.hpp" + +class DictTable; +class DictColumn; + +/** + * @class Plan_drop_index + * @brief Drop index in PlanTree + */ +class Plan_drop_index : public Plan_ddl { +public: + Plan_drop_index(Plan_root* root, const BaseString& name); + Plan_drop_index(Plan_root* root, const BaseString& name, const BaseString& tableName); + virtual ~Plan_drop_index(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void describe(Ctx & ctx); + void print(Ctx& ctx); + // attributes + const BaseString& getName() const; +protected: + BaseString m_name; + BaseString m_tableName; +}; + +inline +Plan_drop_index::Plan_drop_index(Plan_root* root, const BaseString& name) : + Plan_ddl(root), + m_name(name) +{ +} + +inline +Plan_drop_index::Plan_drop_index(Plan_root* root, const BaseString& name, const BaseString& tableName) : + Plan_ddl(root), + m_name(name), + m_tableName(tableName) +{ +} + +inline const BaseString& +Plan_drop_index::getName() const +{ + return m_name; +} + +/** + * @class Exec_drop_index + * @brief Drop index in ExecTree + */ +class Exec_drop_index : public Exec_ddl { +public: + class Code : public Exec_ddl::Code { + public: + Code(const BaseString& indexName, const BaseString& tableName); + virtual ~Code(); + protected: + friend class Exec_drop_index; + const BaseString m_indexName; + const BaseString m_tableName; + }; + class Data : public Exec_ddl::Data { + public: + Data(); + virtual ~Data(); + protected: + friend class Exec_drop_index; + }; + Exec_drop_index(Exec_root* root); + virtual ~Exec_drop_index(); + void alloc(Ctx& ctx, Ctl& ctl); + void execute(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; +}; + +inline +Exec_drop_index::Code::Code(const BaseString& indexName, const BaseString& tableName) : + m_indexName(indexName), + m_tableName(tableName) +{ +} + +inline +Exec_drop_index::Data::Data() +{ +} + +inline +Exec_drop_index::Exec_drop_index(Exec_root* root) : + Exec_ddl(root) +{ +} + +// children + +inline const Exec_drop_index::Code& +Exec_drop_index::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_drop_index::Data& +Exec_drop_index::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_drop_table.cpp b/ndb/src/client/odbc/codegen/Code_drop_table.cpp new file mode 100644 index 00000000000..f20bf9fdae0 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_drop_table.cpp @@ -0,0 +1,87 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Code_drop_table.hpp" +#include "Code_root.hpp" + +// Plan_drop_table + +Plan_drop_table::~Plan_drop_table() +{ +} + +Plan_base* +Plan_drop_table::analyze(Ctx& ctx, Ctl& ctl) +{ + stmtArea().stmtInfo().setName(Stmt_name_drop_table); + return this; +} + +void +Plan_drop_table::describe(Ctx& ctx) +{ + stmtArea().setFunction(ctx, "DROP TABLE", SQL_DIAG_DROP_TABLE); +} + +Exec_base* +Plan_drop_table::codegen(Ctx& ctx, Ctl& ctl) +{ + Exec_drop_table* exec = new Exec_drop_table(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + Exec_drop_table::Code& code = *new Exec_drop_table::Code(m_name); + exec->setCode(code); + return exec; +} + +void +Plan_drop_table::print(Ctx& ctx) +{ + ctx.print(" [drop_table %s]", m_name.c_str()); +} + +// Exec_drop_table + +Exec_drop_table::Code::~Code() +{ +} + +Exec_drop_table::Data::~Data() +{ +} + +Exec_drop_table::~Exec_drop_table() +{ +} + +void +Exec_drop_table::alloc(Ctx& ctx, Ctl& ctl) +{ + Data& data = *new Data; + setData(data); +} + +void +Exec_drop_table::close(Ctx& ctx) +{ +} + +void +Exec_drop_table::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx.print(" [drop_table %s]", code.m_tableName.c_str()); +} diff --git a/ndb/src/client/odbc/codegen/Code_drop_table.hpp b/ndb/src/client/odbc/codegen/Code_drop_table.hpp new file mode 100644 index 00000000000..849a472ed94 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_drop_table.hpp @@ -0,0 +1,124 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_drop_table_hpp +#define ODBC_CODEGEN_Code_drop_table_hpp + +#include +#include +#include +#include "Code_ddl.hpp" + +class DictTable; +class DictColumn; + +/** + * @class Plan_drop_table + * @brief Drop table in PlanTree + */ +class Plan_drop_table : public Plan_ddl { +public: + Plan_drop_table(Plan_root* root, const BaseString& name); + virtual ~Plan_drop_table(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void describe(Ctx & ctx); + void print(Ctx& ctx); + // attributes + const BaseString& getName() const; +protected: + BaseString m_name; +}; + +inline +Plan_drop_table::Plan_drop_table(Plan_root* root, const BaseString& name) : + Plan_ddl(root), + m_name(name) +{ +} + +inline const BaseString& +Plan_drop_table::getName() const +{ + return m_name; +} + +/** + * @class Exec_drop_table + * @brief Drop table in ExecTree + */ +class Exec_drop_table : public Exec_ddl { +public: + class Code : public Exec_ddl::Code { + public: + Code(const BaseString& tableName); + virtual ~Code(); + protected: + friend class Exec_drop_table; + const BaseString m_tableName; + }; + class Data : public Exec_ddl::Data { + public: + Data(); + virtual ~Data(); + protected: + friend class Exec_drop_table; + }; + Exec_drop_table(Exec_root* root); + virtual ~Exec_drop_table(); + void alloc(Ctx& ctx, Ctl& ctl); + void execute(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; +}; + +inline +Exec_drop_table::Code::Code(const BaseString& tableName) : + m_tableName(tableName) +{ +} + +inline +Exec_drop_table::Data::Data() +{ +} + +inline +Exec_drop_table::Exec_drop_table(Exec_root* root) : + Exec_ddl(root) +{ +} + +// children + +inline const Exec_drop_table::Code& +Exec_drop_table::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_drop_table::Data& +Exec_drop_table::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_expr.cpp b/ndb/src/client/odbc/codegen/Code_expr.cpp new file mode 100644 index 00000000000..4afa75986a0 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr.cpp @@ -0,0 +1,79 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_expr.hpp" +#include "Code_expr_row.hpp" + +// Plan_expr + +Plan_expr::~Plan_expr() +{ +} + +bool +Plan_expr::isEqual(const Plan_expr* expr) const +{ + return false; +} + +bool +Plan_expr::isAnyEqual(const Plan_expr_row* row) const +{ + ctx_assert(row != 0); + const unsigned size = row->getSize(); + for (unsigned i = 1; i <= size; i++) { + if (isEqual(row->getExpr(i))) + return true; + } + return false; +} + +bool +Plan_expr::isGroupBy(const Plan_expr_row* row) const +{ + return false; +} + +// Exec_expr + +Exec_expr::Code::~Code() +{ +} + +Exec_expr::Data::~Data() +{ +} + +Exec_expr::~Exec_expr() +{ +} + +SqlField& +Exec_expr::Data::groupField(const SqlType& sqlType, unsigned i, bool initFlag) +{ + if (m_groupField.size() == 0) { + m_groupField.resize(1); + } + if (initFlag) { + //unsigned i2 = m_groupField.size(); + //ctx_assert(i == i2); + const SqlSpec sqlSpec(sqlType, SqlSpec::Physical); + const SqlField sqlField(sqlSpec); + m_groupField.push_back(sqlField); + } + ctx_assert(i != 0 && i < m_groupField.size()); + return m_groupField[i]; +} diff --git a/ndb/src/client/odbc/codegen/Code_expr.hpp b/ndb/src/client/odbc/codegen/Code_expr.hpp new file mode 100644 index 00000000000..b6f07471b4d --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr.hpp @@ -0,0 +1,219 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_expr_hpp +#define ODBC_CODEGEN_Code_expr_hpp + +#include +#include +#include "Code_base.hpp" + +class Ctx; +class Plan_expr_row; +class Exec_expr; + +/** + * @class Plan_expr + * @brief Base class for expressions in PlanTree + */ +class Plan_expr : public Plan_base { +public: + // type is convenient since RTTI cannot be used + enum Type { + TypeUndefined = 0, + TypeColumn, + TypeConst, + TypeConv, + TypeFunc, + TypeOp, + TypeParam, + TypeValue + }; + Plan_expr(Plan_root* root, Type type); + virtual ~Plan_expr() = 0; + Type type() const; + const SqlType& sqlType() const; // data type set by analyze + const TableSet& tableSet() const; + const BaseString& getAlias() const; + bool isAggr() const; + bool isBound() const; + bool isAnyEqual(const Plan_expr_row* row) const; + virtual bool isEqual(const Plan_expr* expr) const; + virtual bool isGroupBy(const Plan_expr_row* row) const; +protected: + friend class Plan_expr_row; + friend class Plan_expr_op; + friend class Plan_expr_func; + friend class Plan_comp_op; + const Type m_type; + SqlType m_sqlType; // subclass must set + BaseString m_alias; // for row expression alias + TableSet m_tableSet; // depends on these tables + bool m_isAggr; // contains an aggregate expression + bool m_isBound; // only constants and aggregates + Exec_expr* m_exec; // XXX wrong move +}; + +inline +Plan_expr::Plan_expr(Plan_root* root, Type type) : + Plan_base(root), + m_type(type), + m_isAggr(false), + m_isBound(false), + m_exec(0) +{ +} + +inline Plan_expr::Type +Plan_expr::type() const +{ + return m_type; +} + +inline const SqlType& +Plan_expr::sqlType() const +{ + ctx_assert(m_sqlType.type() != SqlType::Undef); + return m_sqlType; +} + +inline const Plan_base::TableSet& +Plan_expr::tableSet() const +{ + return m_tableSet; +} + +inline const BaseString& +Plan_expr::getAlias() const +{ + return m_alias; +} + +inline bool +Plan_expr::isAggr() const +{ + return m_isAggr; +} + +inline bool +Plan_expr::isBound() const +{ + return m_isBound; +} + +/** + * @class Exec_expr + * @brief Base class for expressions in ExecTree + */ +class Exec_expr : public Exec_base { +public: + /** + * Exec_expr::Code includes reference to SqlSpec which + * specifies data type and access method. + */ + class Code : public Exec_base::Code { + public: + Code(const SqlSpec& sqlSpec); + virtual ~Code() = 0; + const SqlSpec& sqlSpec() const; + protected: + friend class Exec_expr; + const SqlSpec& m_sqlSpec; // subclass must contain + }; + /** + * Exec_expr::Data includes reference to SqlField which + * contains specification and data address. + */ + class Data : public Exec_base::Data { + public: + Data(const SqlField& sqlField); + virtual ~Data() = 0; + const SqlField& sqlField() const; + const SqlField& groupField(unsigned i) const; + protected: + friend class Exec_expr; + const SqlField& m_sqlField; // subclass must contain + // group-by data + typedef std::vector GroupField; + GroupField m_groupField; + SqlField& groupField(const SqlType& sqlType, unsigned i, bool initFlag); + }; + Exec_expr(Exec_root* root); + virtual ~Exec_expr() = 0; + /** + * Evaluate the expression. Must be implemented by all + * subclasses. Check ctx.ok() for errors. + */ + virtual void evaluate(Ctx& ctx, Ctl& ctl) = 0; + // children + const Code& getCode() const; + Data& getData() const; +}; + +inline +Exec_expr::Code::Code(const SqlSpec& sqlSpec) : + m_sqlSpec(sqlSpec) +{ +} + +inline const SqlSpec& +Exec_expr::Code::sqlSpec() const { + return m_sqlSpec; +} + +inline +Exec_expr::Data::Data(const SqlField& sqlField) : + m_sqlField(sqlField) +{ +} + +inline const SqlField& +Exec_expr::Data::sqlField() const +{ + return m_sqlField; +} + +inline const SqlField& +Exec_expr::Data::groupField(unsigned i) const +{ + ctx_assert(i != 0 && i < m_groupField.size()); + return m_groupField[i]; +} + +inline +Exec_expr::Exec_expr(Exec_root* root) : + Exec_base(root) +{ +} + +// children + +inline const Exec_expr::Code& +Exec_expr::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_expr::Data& +Exec_expr::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_expr_column.cpp b/ndb/src/client/odbc/codegen/Code_expr_column.cpp new file mode 100644 index 00000000000..17a9a502d4c --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr_column.cpp @@ -0,0 +1,160 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include "Code_query.hpp" +#include "Code_table.hpp" +#include "Code_expr_column.hpp" +#include "Code_root.hpp" + +// Plan_expr_column + +Plan_expr_column::~Plan_expr_column() +{ +} + +Plan_base* +Plan_expr_column::analyze(Ctx& ctx, Ctl& ctl) +{ + m_exec = 0; + analyzeColumn(ctx, ctl); + if (! ctx.ok()) + return 0; + Plan_expr::m_sqlType = Plan_column::m_sqlType; + // depends on one table + m_tableSet.insert(m_resTable); + // not constant as set-value + ctl.m_const = false; + // set alias name + m_alias = m_name; + return this; +} + +Exec_base* +Plan_expr_column::codegen(Ctx& ctx, Ctl& ctl) +{ + if (m_exec != 0) + return m_exec; + // connect column to query column + const Exec_query* execQuery = ctl.m_execQuery; + ctx_assert(execQuery != 0); + const Exec_query::Code& codeQuery = execQuery->getCode(); + const SqlSpec sqlSpec(Plan_expr::m_sqlType, SqlSpec::Reference); + // offset in final output row + ctx_assert(m_resTable != 0 && m_resTable->m_resOff != 0 && m_resPos != 0); + unsigned resOff = m_resTable->m_resOff + (m_resPos - 1); + // create the code + Exec_expr_column* exec = new Exec_expr_column(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + Exec_expr_column::Code& code = *new Exec_expr_column::Code(sqlSpec, resOff); + exec->setCode(code); + m_exec = exec; + return exec; +} + +bool +Plan_expr_column::resolveEq(Ctx& ctx, Plan_expr* expr) +{ + ctx_assert(m_resTable != 0 && expr != 0); + return m_resTable->resolveEq(ctx, this, expr); +} + +void +Plan_expr_column::print(Ctx& ctx) +{ + ctx.print(" [expr_column %s]", getPrintName()); +} + +bool +Plan_expr_column::isEqual(const Plan_expr* expr) const +{ + ctx_assert(expr != 0); + if (expr->type() != Plan_expr::TypeColumn) + return false; + const Plan_expr_column* expr2 = static_cast(expr); + ctx_assert(m_resTable != 0 && expr2->m_resTable != 0); + if (m_resTable != expr2->m_resTable) + return false; + ctx_assert(m_dictColumn != 0 && expr2->m_dictColumn != 0); + if (m_dictColumn != expr2->m_dictColumn) + return false; + return true; +} + +bool +Plan_expr_column::isGroupBy(const Plan_expr_row* row) const +{ + if (isAnyEqual(row)) + return true; + return false; +} + +// Exec_expr_column + +Exec_expr_column::Code::~Code() +{ +} + +Exec_expr_column::Data::~Data() +{ +} + +Exec_expr_column::~Exec_expr_column() +{ +} + +void +Exec_expr_column::alloc(Ctx& ctx, Ctl& ctl) +{ + if (m_data != 0) + return; + const Code& code = getCode(); + // connect column to query column + ctx_assert(ctl.m_query != 0); + const SqlRow& sqlRow = ctl.m_query->getData().sqlRow(); + SqlField& sqlField = sqlRow.getEntry(code.m_resOff); + // create the data + Data& data = *new Data(sqlField); + setData(data); +} + +void +Exec_expr_column::evaluate(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + if (ctl.m_groupIndex != 0) { + SqlField& out = data.groupField(code.sqlSpec().sqlType(), ctl.m_groupIndex, ctl.m_groupInit); + data.sqlField().copy(ctx, out); + } +} + +void +Exec_expr_column::close(Ctx& ctx) +{ + Data& data = getData(); + data.m_groupField.clear(); +} + +void +Exec_expr_column::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx.print(" [column %d]", code.m_resOff); +} diff --git a/ndb/src/client/odbc/codegen/Code_expr_column.hpp b/ndb/src/client/odbc/codegen/Code_expr_column.hpp new file mode 100644 index 00000000000..2ce7c441e45 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr_column.hpp @@ -0,0 +1,120 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_expr_column_hpp +#define ODBC_CODEGEN_Code_expr_column_hpp + +#include +#include "Code_column.hpp" +#include "Code_expr.hpp" + +class DictColumn; +class Plan_table; + +/** + * @class Plan_expr_column + * @brief Column in query expression + */ +class Plan_expr_column : public Plan_expr, public Plan_column { +public: + Plan_expr_column(Plan_root* root, const BaseString& name); + virtual ~Plan_expr_column(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + bool resolveEq(Ctx& ctx, Plan_expr* expr); + void print(Ctx& ctx); + bool isEqual(const Plan_expr* expr) const; + bool isGroupBy(const Plan_expr_row* row) const; +}; + +inline +Plan_expr_column::Plan_expr_column(Plan_root* root, const BaseString& name) : + Plan_expr(root, TypeColumn), + Plan_column(Type_expr, name) +{ +} + +/** + * @class Exec_expr_column + * @brief Column in query expression + */ +class Exec_expr_column : public Exec_expr { +public: + class Code : public Exec_expr::Code { + public: + Code(const SqlSpec& sqlSpec, unsigned resOff); + virtual ~Code(); + protected: + friend class Exec_expr_column; + SqlSpec m_sqlSpec; + unsigned m_resOff; + }; + class Data : public Exec_expr::Data { + public: + Data(SqlField& sqlField); + virtual ~Data(); + protected: + friend class Exec_expr_column; + // set reference to SqlField in query + }; + Exec_expr_column(Exec_root* root); + virtual ~Exec_expr_column(); + void alloc(Ctx& ctx, Ctl& ctl); + void evaluate(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; +}; + +inline +Exec_expr_column::Code::Code(const SqlSpec& sqlSpec, unsigned resOff) : + Exec_expr::Code(m_sqlSpec), + m_sqlSpec(sqlSpec), + m_resOff(resOff) +{ +} + +inline +Exec_expr_column::Data::Data(SqlField& sqlField) : + Exec_expr::Data(sqlField) +{ +} + +inline +Exec_expr_column::Exec_expr_column(Exec_root* root) : + Exec_expr(root) +{ +} + +// children + +inline const Exec_expr_column::Code& +Exec_expr_column::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_expr_column::Data& +Exec_expr_column::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_expr_const.cpp b/ndb/src/client/odbc/codegen/Code_expr_const.cpp new file mode 100644 index 00000000000..564d307a4f8 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr_const.cpp @@ -0,0 +1,138 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_expr_const.hpp" +#include "Code_root.hpp" + +// Plan_expr_const + +Plan_expr_const::~Plan_expr_const() +{ +} + +Plan_base* +Plan_expr_const::analyze(Ctx& ctx, Ctl& ctl) +{ + m_exec = 0; + // convert data type + m_lexType.convert(ctx, m_sqlType, m_string.length()); + if (! ctx.ok()) + return 0; + // depends on no tables + // set alias name + m_alias = m_string; + // node was not changed + return this; +} + +Exec_base* +Plan_expr_const::codegen(Ctx& ctx, Ctl& ctl) +{ + if (m_exec != 0) + return m_exec; + // convert data + SqlSpec sqlSpec(m_sqlType, SqlSpec::Physical); + SqlField sqlField(sqlSpec); + LexSpec lexSpec(m_lexType); + lexSpec.convert(ctx, m_string, sqlField); + if (! ctx.ok()) + return 0; + // create code + Exec_expr_const* exec = new Exec_expr_const(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + Exec_expr_const::Code& code = *new Exec_expr_const::Code(sqlField); + exec->setCode(code); + m_exec = exec; + return exec; +} + +void +Plan_expr_const::print(Ctx& ctx) +{ + ctx.print(" [const %s]", m_string.c_str()); +} + +bool +Plan_expr_const::isEqual(const Plan_expr* expr) const +{ + ctx_assert(expr != 0); + if (expr->type() != Plan_expr::TypeConst) + return false; + const Plan_expr_const* expr2 = static_cast(expr); + if (strcmp(m_string.c_str(), expr2->m_string.c_str()) != 0) + return false; + return true; +} + +bool +Plan_expr_const::isGroupBy(const Plan_expr_row* row) const +{ + return true; +} + +// Exec_expr_const + +Exec_expr_const::Code::~Code() +{ +} + +Exec_expr_const::Data::~Data() +{ +} + +Exec_expr_const::~Exec_expr_const() +{ +} + +void +Exec_expr_const::alloc(Ctx& ctx, Ctl& ctl) +{ + if (m_data != 0) + return; + // copy the value for const correctness reasons + SqlField sqlField(getCode().m_sqlField); + Data& data = *new Data(sqlField); + setData(data); +} + +void +Exec_expr_const::evaluate(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + if (ctl.m_groupIndex != 0) { + SqlField& out = data.groupField(code.sqlSpec().sqlType(), ctl.m_groupIndex, ctl.m_groupInit); + data.sqlField().copy(ctx, out); + } +} + +void +Exec_expr_const::close(Ctx& ctx) +{ + Data& data = getData(); + data.m_groupField.clear(); +} + +void +Exec_expr_const::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx.print(" ["); + char buf[500]; + code.m_sqlField.print(buf, sizeof(buf)); + ctx.print("%s", buf); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_expr_const.hpp b/ndb/src/client/odbc/codegen/Code_expr_const.hpp new file mode 100644 index 00000000000..2e26c637a23 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr_const.hpp @@ -0,0 +1,120 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_expr_const_hpp +#define ODBC_CODEGEN_Code_expr_const_hpp + +#include +#include +#include "Code_expr.hpp" + +/** + * @class Plan_expr_const + * @brief Constant expression value in PlanTree + */ +class Plan_expr_const : public Plan_expr { +public: + Plan_expr_const(Plan_root* root, LexType lexType, const char* value); + virtual ~Plan_expr_const(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + bool isEqual(const Plan_expr* expr) const; + bool isGroupBy(const Plan_expr_row* row) const; +protected: + // lexical type and token set by the parser + LexType m_lexType; + BaseString m_string; +}; + +inline +Plan_expr_const::Plan_expr_const(Plan_root* root, LexType lexType, const char* value) : + Plan_expr(root, TypeConst), + m_lexType(lexType), + m_string(value) +{ +} + +/** + * @class Exec_expr_const + * @brief Constant expression value in ExecTree + */ +class Exec_expr_const : public Exec_expr { +public: + class Code : public Exec_expr::Code { + public: + Code(const SqlField& sqlField); + virtual ~Code(); + protected: + friend class Exec_expr_const; + const SqlField m_sqlField; + }; + class Data : public Exec_expr::Data { + public: + Data(SqlField& sqlField); + virtual ~Data(); + protected: + friend class Exec_expr_const; + SqlField m_sqlField; + }; + Exec_expr_const(Exec_root* root); + virtual ~Exec_expr_const(); + void alloc(Ctx& ctx, Ctl& ctl); + void evaluate(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; +}; + +inline +Exec_expr_const::Code::Code(const SqlField& sqlField) : + Exec_expr::Code(m_sqlField.sqlSpec()), + m_sqlField(sqlField) +{ +} + +inline +Exec_expr_const::Data::Data(SqlField& sqlField) : + Exec_expr::Data(m_sqlField), + m_sqlField(sqlField) +{ +} + +inline +Exec_expr_const::Exec_expr_const(Exec_root* root) : + Exec_expr(root) +{ +} + +// children + +inline const Exec_expr_const::Code& +Exec_expr_const::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_expr_const::Data& +Exec_expr_const::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_expr_conv.cpp b/ndb/src/client/odbc/codegen/Code_expr_conv.cpp new file mode 100644 index 00000000000..bc89482fedc --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr_conv.cpp @@ -0,0 +1,273 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_expr.hpp" +#include "Code_expr_conv.hpp" +#include "Code_root.hpp" + +// Plan_expr_conv + +Plan_expr_conv::~Plan_expr_conv() +{ +} + +Plan_base* +Plan_expr_conv::analyze(Ctx& ctx, Ctl& ctl) +{ + m_exec = 0; + const SqlType& t1 = sqlType(); + ctx_assert(m_expr != 0); + m_expr->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + const SqlType& t2 = m_expr->sqlType(); + if (t2.type() == SqlType::Unbound) { + return m_expr; + } + if (t1.equal(t2)) { + return m_expr; + } + // XXX move to runtime or make table-driven + bool ok = false; + if (t2.type() == SqlType::Null) { + ok = true; + } else if (t1.type() == SqlType::Char) { + if (t2.type() == SqlType::Char) { + ok = true; + } else if (t2.type() == SqlType::Varchar) { + ok = true; + } else if (t2.type() == SqlType::Binary) { + ok = true; + } else if (t2.type() == SqlType::Varbinary) { + ok = true; + } + } else if (t1.type() == SqlType::Varchar) { + if (t2.type() == SqlType::Char) { + ok = true; + } else if (t2.type() == SqlType::Varchar) { + ok = true; + } else if (t2.type() == SqlType::Binary) { + ok = true; + } else if (t2.type() == SqlType::Varbinary) { + ok = true; + } + } else if (t1.type() == SqlType::Binary) { + if (t2.type() == SqlType::Char) { + ok = true; + } else if (t2.type() == SqlType::Varchar) { + ok = true; + } else if (t2.type() == SqlType::Binary) { + ok = true; + } else if (t2.type() == SqlType::Varbinary) { + ok = true; + } + } else if (t1.type() == SqlType::Varbinary) { + if (t2.type() == SqlType::Char) { + ok = true; + } else if (t2.type() == SqlType::Varchar) { + ok = true; + } else if (t2.type() == SqlType::Binary) { + ok = true; + } else if (t2.type() == SqlType::Varbinary) { + ok = true; + } + } else if (t1.type() == SqlType::Smallint) { + if (t2.type() == SqlType::Smallint) { + ok = true; + } else if (t2.type() == SqlType::Integer) { + ok = true; + } else if (t2.type() == SqlType::Bigint) { + ok = true; + } else if (t2.type() == SqlType::Real) { + ok = true; + } else if (t2.type() == SqlType::Double) { + ok = true; + } + } else if (t1.type() == SqlType::Integer) { + if (t2.type() == SqlType::Smallint) { + ok = true; + } else if (t2.type() == SqlType::Integer) { + ok = true; + } else if (t2.type() == SqlType::Bigint) { + ok = true; + } else if (t2.type() == SqlType::Real) { + ok = true; + } else if (t2.type() == SqlType::Double) { + ok = true; + } + } else if (t1.type() == SqlType::Bigint) { + if (t2.type() == SqlType::Smallint) { + ok = true; + } else if (t2.type() == SqlType::Integer) { + ok = true; + } else if (t2.type() == SqlType::Bigint) { + ok = true; + } else if (t2.type() == SqlType::Real) { + ok = true; + } else if (t2.type() == SqlType::Double) { + ok = true; + } + } else if (t1.type() == SqlType::Real) { + if (t2.type() == SqlType::Smallint) { + ok = true; + } else if (t2.type() == SqlType::Integer) { + ok = true; + } else if (t2.type() == SqlType::Bigint) { + ok = true; + } else if (t2.type() == SqlType::Real) { + ok = true; + } else if (t2.type() == SqlType::Double) { + ok = true; + } + } else if (t1.type() == SqlType::Double) { + if (t2.type() == SqlType::Smallint) { + ok = true; + } else if (t2.type() == SqlType::Integer) { + ok = true; + } else if (t2.type() == SqlType::Bigint) { + ok = true; + } else if (t2.type() == SqlType::Real) { + ok = true; + } else if (t2.type() == SqlType::Double) { + ok = true; + } + } else if (t1.type() == SqlType::Datetime) { + if (t2.type() == SqlType::Datetime) { + ok = true; + } + } + if (! ok) { + char b1[40], b2[40]; + t1.print(b1, sizeof(b1)); + t2.print(b2, sizeof(b2)); + ctx.pushStatus(Error::Gen, "cannot convert %s to %s", b2, b1); + return 0; + } + // depend on same tables + const TableSet& ts = m_expr->tableSet(); + m_tableSet.insert(ts.begin(), ts.end()); + // set alias + m_alias = m_expr->getAlias(); + return this; +} + +Exec_base* +Plan_expr_conv::codegen(Ctx& ctx, Ctl& ctl) +{ + if (m_exec != 0) + return m_exec; + Exec_expr_conv* exec = new Exec_expr_conv(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + // create code for subexpression + ctx_assert(m_expr != 0); + Exec_expr* execExpr = static_cast(m_expr->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + exec->setExpr(execExpr); + // create the code + SqlSpec sqlSpec(sqlType(), SqlSpec::Physical); + Exec_expr_conv::Code& code = *new Exec_expr_conv::Code(sqlSpec); + exec->setCode(code); + m_exec = exec; + return exec; +} + +void +Plan_expr_conv::print(Ctx& ctx) +{ + ctx.print(" [expr_conv "); + char buf[100]; + m_sqlType.print(buf, sizeof(buf)); + ctx.print("%s", buf); + Plan_base* a[] = { m_expr }; + printList(ctx, a, 1); + ctx.print("]"); +} + +bool +Plan_expr_conv::isEqual(const Plan_expr* expr) const +{ + ctx_assert(expr != 0); + if (expr->type() != Plan_expr::TypeConv) + return false; + const Plan_expr_conv* expr2 = static_cast(expr); + if (! m_sqlType.equal(expr2->m_sqlType)) + return false; + ctx_assert(m_expr != 0 && expr2->m_expr != 0); + if (! m_expr->isEqual(expr2->m_expr)) + return false; + return true; +} + +bool +Plan_expr_conv::isGroupBy(const Plan_expr_row* row) const +{ + if (isAnyEqual(row)) + return true; + ctx_assert(m_expr != 0); + if (m_expr->isGroupBy(row)) + return true; + return false; +} + +// Code_expr_conv + +Exec_expr_conv::Code::~Code() +{ +} + +Exec_expr_conv::Data::~Data() +{ +} + +Exec_expr_conv::~Exec_expr_conv() +{ +} + +void +Exec_expr_conv::alloc(Ctx& ctx, Ctl& ctl) +{ + if (m_data != 0) + return; + const Code& code = getCode(); + // allocate subexpression + ctx_assert(m_expr != 0); + m_expr->alloc(ctx, ctl); + if (! ctx.ok()) + return; + SqlField sqlField(code.m_sqlSpec); + Data& data = *new Data(sqlField); + setData(data); +} + +void +Exec_expr_conv::close(Ctx& ctx) +{ + ctx_assert(m_expr != 0); + m_expr->close(ctx); + Data& data = getData(); + data.m_groupField.clear(); +} + +void +Exec_expr_conv::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx.print(" [expr_conv"); + Exec_base* a[] = { m_expr }; + printList(ctx, a, sizeof(a)/sizeof(a[0])); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_expr_conv.hpp b/ndb/src/client/odbc/codegen/Code_expr_conv.hpp new file mode 100644 index 00000000000..3294960c7b3 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr_conv.hpp @@ -0,0 +1,141 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_expr_conv_hpp +#define ODBC_CODEGEN_Code_expr_conv_hpp + +#include +#include +#include "Code_expr.hpp" + +/** + * @class Plan_expr_conv + * @brief Data type conversion in PlanTree + * + * Inserted to convert value to another compatible type. + */ +class Plan_expr_conv : public Plan_expr { +public: + Plan_expr_conv(Plan_root* root, const SqlType& sqlType); + virtual ~Plan_expr_conv(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + bool isEqual(const Plan_expr* expr) const; + bool isGroupBy(const Plan_expr_row* row) const; + // children + void setExpr(Plan_expr* expr); +protected: + Plan_expr* m_expr; +}; + +inline +Plan_expr_conv::Plan_expr_conv(Plan_root* root, const SqlType& sqlType) : + Plan_expr(root, TypeConv), + m_expr(0) +{ + ctx_assert(sqlType.type() != SqlType::Undef); + m_sqlType = sqlType; +} + +inline void +Plan_expr_conv::setExpr(Plan_expr* expr) +{ + ctx_assert(expr != 0); + m_expr = expr; +} + +/** + * @class Exec_expr_conv + * @brief Data type conversion in ExecTree + */ +class Exec_expr_conv : public Exec_expr { +public: + class Code : public Exec_expr::Code { + public: + Code(const SqlSpec& spec); + virtual ~Code(); + protected: + friend class Exec_expr_conv; + const SqlSpec m_sqlSpec; + }; + class Data : public Exec_expr::Data { + public: + Data(const SqlField& sqlField); + virtual ~Data(); + protected: + friend class Exec_expr_conv; + SqlField m_sqlField; + }; + Exec_expr_conv(Exec_root* root); + virtual ~Exec_expr_conv(); + void alloc(Ctx& ctx, Ctl& ctl); + void evaluate(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setExpr(Exec_expr* expr); +protected: + Exec_expr* m_expr; +}; + +inline +Exec_expr_conv::Code::Code(const SqlSpec& sqlSpec) : + Exec_expr::Code(m_sqlSpec), + m_sqlSpec(sqlSpec) +{ +} + +inline +Exec_expr_conv::Data::Data(const SqlField& sqlField) : + Exec_expr::Data(m_sqlField), + m_sqlField(sqlField) +{ +} + +inline +Exec_expr_conv::Exec_expr_conv(Exec_root* root) : + Exec_expr(root), + m_expr(0) +{ +} + +// children + +inline const Exec_expr_conv::Code& +Exec_expr_conv::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_expr_conv::Data& +Exec_expr_conv::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_expr_conv::setExpr(Exec_expr* expr) +{ + ctx_assert(m_expr == 0 && expr != 0); + m_expr = expr; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_expr_func.cpp b/ndb/src/client/odbc/codegen/Code_expr_func.cpp new file mode 100644 index 00000000000..96b461a72d9 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr_func.cpp @@ -0,0 +1,401 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_expr.hpp" +#include "Code_expr_func.hpp" +#include "Code_expr_conv.hpp" +#include "Code_root.hpp" +#include "PortDefs.h" + + +// Expr_func + +static const struct { const char* alias; const char* name; } +expr_func_alias[] = { + { "SUBSTRING", "SUBSTR" }, + { 0, 0 } +}; + +static const Expr_func +expr_func[] = { + Expr_func(Expr_func::Substr, "SUBSTR", false ), + Expr_func(Expr_func::Left, "LEFT", false ), + Expr_func(Expr_func::Right, "RIGHT", false ), + Expr_func(Expr_func::Count, "COUNT", true ), + Expr_func(Expr_func::Max, "MAX", true ), + Expr_func(Expr_func::Min, "MIN", true ), + Expr_func(Expr_func::Sum, "SUM", true ), + Expr_func(Expr_func::Avg, "AVG", true ), + Expr_func(Expr_func::Rownum, "ROWNUM", false ), + Expr_func(Expr_func::Sysdate, "SYSDATE", false ), + Expr_func(Expr_func::Undef, 0, false ) +}; + +const Expr_func& +Expr_func::find(const char* name) +{ + for (unsigned i = 0; expr_func_alias[i].alias != 0; i++) { + if (strcasecmp(expr_func_alias[i].alias, name) == 0) { + name = expr_func_alias[i].name; + break; + } + } + const Expr_func* p; + for (p = expr_func; p->m_name != 0; p++) { + if (strcasecmp(p->m_name, name) == 0) + break; + } + return *p; +} + +// Plan_expr_func + +Plan_expr_func::~Plan_expr_func() +{ + delete[] m_conv; + m_conv = 0; +} + +Plan_base* +Plan_expr_func::analyze(Ctx& ctx, Ctl& ctl) +{ + m_exec = 0; + ctx_assert(m_narg == 0 || m_args != 0); + // aggregate check + if (m_func.m_aggr) { + if (! ctl.m_aggrok) { + ctx.pushStatus(Error::Gen, "%s: invalid use of aggregate function", m_func.m_name); + return 0; + } + if (ctl.m_aggrin) { + // XXX actually possible with group-by but too hard + ctx.pushStatus(Error::Gen, "%s: nested aggregate function", m_func.m_name); + return 0; + } + ctl.m_aggrin = true; + m_isAggr = true; + m_isBound = true; + } + // analyze argument expressions + if (m_func.m_code != Expr_func::Rownum) + m_isBound = true; + for (unsigned i = 1; i <= m_narg; i++) { + Plan_expr* expr = m_args->getExpr(i); + expr = static_cast(expr->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(expr != 0); + if (expr->m_isAggr) + m_isAggr = true; + if (! m_func.m_aggr && ! expr->m_isBound) + m_isBound = false; + } + if (m_func.m_aggr) + ctl.m_aggrin = false; + // find result type and conversion types + SqlType res; + const Expr_func::Code fc = m_func.m_code; + const char* const invalidArgCount = "%s: argument count %u is invalid"; + const char* const invalidArgType = "%s: argument %u has invalid type"; + if (fc == Expr_func::Substr || fc == Expr_func::Left || fc == Expr_func::Right) { + if ((m_narg != (unsigned)2) && (m_narg != (unsigned)(fc == Expr_func::Substr ? 3 : 2))) { + ctx.pushStatus(Error::Gen, invalidArgCount, m_func.m_name, m_narg); + return 0; + } + const SqlType& t1 = m_args->getExpr(1)->sqlType(); + switch (t1.type()) { + case SqlType::Char: + { + // XXX convert to varchar for now to get length right + SqlType tx(SqlType::Varchar, t1.length()); + res = m_conv[1] = tx; + } + break; + case SqlType::Varchar: + case SqlType::Unbound: + res = m_conv[1] = t1; + break; + default: + ctx.pushStatus(Error::Gen, invalidArgType, m_func.m_name, 1); + return 0; + } + for (unsigned i = 2; i <= m_narg; i++) { + const SqlType& t2 = m_args->getExpr(i)->sqlType(); + switch (t2.type()) { + case SqlType::Smallint: + case SqlType::Integer: + case SqlType::Bigint: + case SqlType::Unbound: + m_conv[i] = t2; + break; + default: + ctx.pushStatus(Error::Gen, invalidArgType, m_func.m_name, i); + return 0; + } + } + } else if (fc == Expr_func::Count) { + ctx_assert(m_args != 0); + if (m_args->getAsterisk()) { + ctx_assert(m_narg == 0); + } else { + if (m_narg != 1) { + ctx.pushStatus(Error::Gen, invalidArgCount, m_func.m_name, m_narg); + return 0; + } + m_conv[1] = m_args->getExpr(1)->sqlType(); + } + res.setType(ctx, SqlType::Bigint); + } else if (fc == Expr_func::Min || fc == Expr_func::Max) { + if (m_narg != 1) { + ctx.pushStatus(Error::Gen, invalidArgCount, m_func.m_name, m_narg); + return 0; + } + const SqlType& t1 = m_args->getExpr(1)->sqlType(); + res = m_conv[1] = t1; + } else if (fc == Expr_func::Sum) { + if (m_narg != 1) { + ctx.pushStatus(Error::Gen, invalidArgCount, m_func.m_name, m_narg); + return 0; + } + const SqlType& t1 = m_args->getExpr(1)->sqlType(); + switch (t1.type()) { + case SqlType::Smallint: + case SqlType::Integer: + case SqlType::Bigint: + res.setType(ctx, SqlType::Bigint); + m_conv[1] = res; + break; + case SqlType::Real: + case SqlType::Double: + res.setType(ctx, SqlType::Double); + m_conv[1] = res; + break; + case SqlType::Unbound: + res = m_conv[1] = t1; + break; + default: + ctx.pushStatus(Error::Gen, invalidArgType, m_func.m_name, 1); + return 0; + } + } else if (fc == Expr_func::Avg) { + if (m_narg != 1) { + ctx.pushStatus(Error::Gen, invalidArgCount, m_func.m_name, m_narg); + return 0; + } + const SqlType& t1 = m_args->getExpr(1)->sqlType(); + switch (t1.type()) { + case SqlType::Smallint: + case SqlType::Integer: + case SqlType::Bigint: + case SqlType::Real: + case SqlType::Double: + res.setType(ctx, SqlType::Double); + m_conv[1] = res; + break; + case SqlType::Unbound: + res = m_conv[1] = t1; + break; + default: + ctx.pushStatus(Error::Gen, invalidArgType, m_func.m_name, 1); + return 0; + } + } else if (fc == Expr_func::Rownum) { + ctx_assert(m_narg == 0 && m_args == 0); + res.setType(ctx, SqlType::Bigint); + } else if (fc == Expr_func::Sysdate) { + ctx_assert(m_narg == 0 && m_args == 0); + res.setType(ctx, SqlType::Datetime); + } else { + ctx_assert(false); + } + // insert required conversions + for (unsigned i = 1; i <= m_narg; i++) { + if (m_conv[i].type() == SqlType::Unbound) { + // parameter type not yet bound + continue; + } + Plan_expr_conv* exprConv = new Plan_expr_conv(m_root, m_conv[i]); + m_root->saveNode(exprConv); + exprConv->setExpr(m_args->getExpr(i)); + Plan_expr* expr = static_cast(exprConv->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + m_args->setExpr(i, expr); + } + // set result type + m_sqlType = res; + // set table dependencies + for (unsigned i = 1; i <= m_narg; i++) { + const TableSet& ts = m_args->getExpr(i)->tableSet(); + m_tableSet.insert(ts.begin(), ts.end()); + } + // set alias name + m_alias.assign(m_func.m_name); + if (m_narg == 0) { + if (fc == Expr_func::Count) + m_alias.append("(*)"); + } else { + m_alias.append("("); + for (unsigned i = 1; i <= m_narg; i++) { + if (i > 1) + m_alias.append(","); + m_alias.append(m_args->getExpr(i)->getAlias()); + } + m_alias.append(")"); + } + return this; +} + +Exec_base* +Plan_expr_func::codegen(Ctx& ctx, Ctl& ctl) +{ + if (m_exec != 0) + return m_exec; + Exec_expr_func* exec = new Exec_expr_func(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + SqlSpec sqlSpec(sqlType(), SqlSpec::Physical); + Exec_expr_func::Code& code = *new Exec_expr_func::Code(m_func, sqlSpec); + exec->setCode(code); + code.m_narg = m_narg; + code.m_args = new Exec_expr* [1 + m_narg]; + for (unsigned i = 0; i <= m_narg; i++) + code.m_args[i] = 0; + // create code for arguments + for (unsigned i = 1; i <= m_narg; i++) { + Plan_expr* expr = m_args->getExpr(i); + ctx_assert(expr != 0); + Exec_expr* execExpr = static_cast(expr->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execExpr != 0); + code.m_args[i] = execExpr; + } + m_exec = exec; + return exec; +} + +void +Plan_expr_func::print(Ctx& ctx) +{ + ctx.print(" [%s", m_func.m_name); + Plan_base* a[] = { m_args }; + printList(ctx, a, sizeof(a)/sizeof(a[1])); + ctx.print("]"); +} + +bool +Plan_expr_func::isEqual(const Plan_expr* expr) const +{ + ctx_assert(expr != 0); + if (expr->type() != Plan_expr::TypeFunc) + return false; + const Plan_expr_func* expr2 = static_cast(expr); + if (m_func.m_code != expr2->m_func.m_code) + return false; + if (m_narg != expr2->m_narg) + return false; + ctx_assert(m_args != 0 && expr2->m_args != 0); + for (unsigned i = 1; i <= m_narg; i++) { + if (! m_args->getExpr(i)->isEqual(expr2->m_args->getExpr(i))) + return false; + } + return true; +} + +bool +Plan_expr_func::isGroupBy(const Plan_expr_row* row) const +{ + if (m_func.m_aggr) + return true; + switch (m_func.m_code) { + case Expr_func::Substr: + case Expr_func::Left: + case Expr_func::Right: + ctx_assert(m_narg >= 1); + if (m_args->getExpr(1)->isGroupBy(row)) + return true; + break; + case Expr_func::Sysdate: + return true; + default: + break; + } + if (isAnyEqual(row)) + return true; + return false; +} + +// Exec_expr_func + +Exec_expr_func::Code::~Code() +{ + delete[] m_args; + m_args = 0; +} + +Exec_expr_func::Data::~Data() +{ +} + +Exec_expr_func::~Exec_expr_func() +{ +} + +void +Exec_expr_func::alloc(Ctx& ctx, Ctl& ctl) +{ + if (m_data != 0) + return; + const Code& code = getCode(); + // allocate arguments + for (unsigned i = 1; i <= code.m_narg; i++) { + ctx_assert(code.m_args != 0 && code.m_args[i] != 0); + code.m_args[i]->alloc(ctx, ctl); + if (! ctx.ok()) + return; + } + SqlField sqlField(code.m_sqlSpec); + Data& data = *new Data(sqlField); + setData(data); + ctx_assert(ctl.m_groupIndex == 0); + init(ctx, ctl); +} + +void +Exec_expr_func::close(Ctx& ctx) +{ + const Code& code = getCode(); + Data& data = getData(); + for (unsigned i = 1; i <= code.m_narg; i++) { + ctx_assert(code.m_args != 0 && code.m_args[i] != 0); + code.m_args[i]->close(ctx); + } + data.m_groupField.clear(); + Ctl ctl(0); + init(ctx, ctl); +} + +void +Exec_expr_func::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx.print(" [%s", code.m_func.m_name); + for (unsigned i = 1; i <= code.m_narg; i++) { + Exec_base* a[] = { code.m_args[i] }; + printList(ctx, a, sizeof(a)/sizeof(a[0])); + } + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_expr_func.hpp b/ndb/src/client/odbc/codegen/Code_expr_func.hpp new file mode 100644 index 00000000000..856d7529875 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr_func.hpp @@ -0,0 +1,193 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_expr_func_hpp +#define ODBC_CODEGEN_Code_expr_func_hpp + +#include +#include +#include "Code_expr.hpp" +#include "Code_expr_row.hpp" + +/** + * @class Expr_func + * @brief Specifies a function + */ +struct Expr_func { + enum Code { + Undef = 0, + Substr, + Left, + Right, + Count, + Max, + Min, + Sum, + Avg, + Rownum, + Sysdate + }; + Expr_func(Code code, const char* name, bool aggr); + Code m_code; + const char* m_name; + bool m_aggr; + static const Expr_func& find(const char* name); +}; + +inline +Expr_func::Expr_func(Code code, const char* name, bool aggr) : + m_code(code), + m_name(name), + m_aggr(aggr) +{ +} + +/** + * @class Plan_expr_func + * @brief Function node in an expression in PlanTree + */ +class Plan_expr_func : public Plan_expr { +public: + Plan_expr_func(Plan_root* root, const Expr_func& func); + virtual ~Plan_expr_func(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + bool isEqual(const Plan_expr* expr) const; + bool isGroupBy(const Plan_expr_row* row) const; + // children + void setArgs(Plan_expr_row* args); +protected: + const Expr_func& m_func; + Plan_expr_row* m_args; + unsigned m_narg; + SqlType* m_conv; // temp work area +}; + +inline +Plan_expr_func::Plan_expr_func(Plan_root* root, const Expr_func& func) : + Plan_expr(root, TypeFunc), + m_func(func), + m_args(0), + m_narg(0), + m_conv(0) +{ +} + +inline void +Plan_expr_func::setArgs(Plan_expr_row* args) +{ + if (args == 0) { + m_args = 0; + m_narg = 0; + } else { + m_args = args; + m_narg = m_args->getSize(); + delete[] m_conv; + m_conv = new SqlType[1 + m_narg]; + } +} + +/** + * @class Exec_expr_func + * @brief Function node in an expression in ExecTree + */ +class Exec_expr_func : public Exec_expr { +public: + class Code : public Exec_expr::Code { + public: + Code(const Expr_func& func, const SqlSpec& spec); + virtual ~Code(); + protected: + friend class Plan_expr_func; + friend class Exec_expr_func; + const Expr_func& m_func; + const SqlSpec m_sqlSpec; + unsigned m_narg; + Exec_expr** m_args; // XXX pointers for now + }; + class Data : public Exec_expr::Data { + public: + Data(const SqlField& sqlField); + virtual ~Data(); + protected: + friend class Exec_expr_func; + SqlField m_sqlField; + struct Acc { // accumulators etc + SqlBigint m_count; // current row count + union { + SqlBigint m_bigint; + SqlDouble m_double; + SqlDatetime m_sysdate; + }; + }; + // group-by extra accumulators (default in entry 0) + typedef std::vector GroupAcc; + GroupAcc m_groupAcc; + }; + Exec_expr_func(Exec_root* root); + virtual ~Exec_expr_func(); + void alloc(Ctx& ctx, Ctl& ctl); + void evaluate(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; +protected: + void init(Ctx &ctx, Ctl& ctl); // initialize values +}; + +inline +Exec_expr_func::Code::Code(const Expr_func& func, const SqlSpec& sqlSpec) : + Exec_expr::Code(m_sqlSpec), + m_func(func), + m_sqlSpec(sqlSpec), + m_args(0) +{ +} + +inline +Exec_expr_func::Data::Data(const SqlField& sqlField) : + Exec_expr::Data(m_sqlField), + m_sqlField(sqlField), + m_groupAcc(1) +{ +} + +inline +Exec_expr_func::Exec_expr_func(Exec_root* root) : + Exec_expr(root) +{ +} + +// children + +inline const Exec_expr_func::Code& +Exec_expr_func::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_expr_func::Data& +Exec_expr_func::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_expr_op.cpp b/ndb/src/client/odbc/codegen/Code_expr_op.cpp new file mode 100644 index 00000000000..7e8314c1741 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr_op.cpp @@ -0,0 +1,424 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_expr.hpp" +#include "Code_expr_op.hpp" +#include "Code_expr_conv.hpp" +#include "Code_root.hpp" + +// Expr_op + +const char* +Expr_op::name() const +{ + switch (m_opcode) { + case Add: + return "+"; + case Subtract: + return "-"; + case Multiply: + return "*"; + case Divide: + return "/"; + case Plus: + return "+"; + case Minus: + return "-"; + } + ctx_assert(false); + return ""; +} + +unsigned +Expr_op::arity() const +{ + switch (m_opcode) { + case Add: + case Subtract: + case Multiply: + case Divide: + return 2; + case Plus: + case Minus: + return 1; + } + ctx_assert(false); + return 0; +} + +// Plan_expr_op + +Plan_expr_op::~Plan_expr_op() +{ +} + +Plan_base* +Plan_expr_op::analyze(Ctx& ctx, Ctl& ctl) +{ + m_exec = 0; + unsigned arity = m_op.arity(); + // analyze operands + m_isAggr = false; + m_isBound = true; + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_expr[i] != 0); + m_expr[i]->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + if (m_expr[i]->m_isAggr) + m_isAggr = true; + if (! m_expr[i]->m_isBound) + m_isBound = false; + } + // find result type and conversion types (currently same) + SqlType res; + SqlType con[1 + 2]; + if (arity == 1) { + const SqlType& t1 = m_expr[1]->sqlType(); + switch (t1.type()) { + case SqlType::Char: + case SqlType::Varchar: + break; + case SqlType::Smallint: + case SqlType::Integer: + case SqlType::Bigint: + res.setType(ctx, SqlType::Bigint); + con[1] = res; + break; + case SqlType::Real: + case SqlType::Double: + res.setType(ctx, SqlType::Double); + con[1] = res; + break; + case SqlType::Null: + res.setType(ctx, SqlType::Null); + con[1] = res; + break; + case SqlType::Unbound: + res.setType(ctx, SqlType::Unbound); + con[1] = res; + default: + break; + } + if (con[1].type() == SqlType::Undef) { + char b1[40]; + t1.print(b1, sizeof(b1)); + ctx.pushStatus(Error::Gen, "type mismatch in operation: %s %s", m_op.name(), b1); + return 0; + } + } else if (arity == 2) { + const SqlType& t1 = m_expr[1]->sqlType(); + const SqlType& t2 = m_expr[2]->sqlType(); + switch (t1.type()) { + case SqlType::Char: // handle char types as in oracle + switch (t2.type()) { + case SqlType::Char: + res.setType(ctx, SqlType::Char, t1.length() + t2.length()); + con[1] = t1; + con[2] = t2; + break; + case SqlType::Varchar: + res.setType(ctx, SqlType::Varchar, t1.length() + t2.length()); + con[1] = t1; + con[2] = t2; + break; + case SqlType::Null: + res.setType(ctx, SqlType::Varchar, t1.length()); + con[1] = t1; + con[2] = t2; + break; + case SqlType::Unbound: + res.setType(ctx, SqlType::Unbound); + con[1] = con[2] = res; + break; + default: + break; + } + break; + case SqlType::Varchar: + switch (t2.type()) { + case SqlType::Char: + res.setType(ctx, SqlType::Varchar, t1.length() + t2.length()); + con[1] = t1; + con[2] = t2; + break; + case SqlType::Varchar: + res.setType(ctx, SqlType::Varchar, t1.length() + t2.length()); + con[1] = t1; + con[2] = t2; + break; + case SqlType::Null: + res.setType(ctx, SqlType::Varchar, t1.length()); + con[1] = t1; + con[2] = t2; + break; + case SqlType::Unbound: + res.setType(ctx, SqlType::Unbound); + con[1] = con[2] = res; + break; + default: + break; + } + break; + case SqlType::Smallint: + case SqlType::Integer: + case SqlType::Bigint: + switch (t2.type()) { + case SqlType::Smallint: + case SqlType::Integer: + case SqlType::Bigint: + res.setType(ctx, SqlType::Bigint); + con[1] = con[2] = res; + if (t1.unSigned() || t2.unSigned()) { + con[1].unSigned(true); + con[2].unSigned(true); + } + break; + case SqlType::Real: + case SqlType::Double: + res.setType(ctx, SqlType::Double); + con[1] = con[2] = res; + break; + case SqlType::Null: + res.setType(ctx, SqlType::Null); + con[1] = con[2] = res; + break; + case SqlType::Unbound: + res.setType(ctx, SqlType::Unbound); + con[1] = con[2] = res; + break; + default: + break; + } + break; + case SqlType::Real: + case SqlType::Double: + switch (t2.type()) { + case SqlType::Smallint: + case SqlType::Integer: + case SqlType::Bigint: + case SqlType::Real: + case SqlType::Double: + res.setType(ctx, SqlType::Double); + con[1] = con[2] = res; + break; + case SqlType::Null: + res.setType(ctx, SqlType::Null); + con[1] = con[2] = res; + break; + case SqlType::Unbound: + res.setType(ctx, SqlType::Unbound); + con[1] = con[2] = res; + break; + default: + break; + } + break; + case SqlType::Null: + switch (t2.type()) { + case SqlType::Char: + case SqlType::Varchar: + res.setType(ctx, SqlType::Varchar, t2.length()); + con[1] = con[2] = res; + break; + case SqlType::Unbound: + res.setType(ctx, SqlType::Unbound); + con[1] = con[2] = res; + break; + default: + res.setType(ctx, SqlType::Null); + con[1] = con[2] = res; + break; + } + break; + case SqlType::Unbound: + res.setType(ctx, SqlType::Unbound); + con[1] = con[2] = res; + break; + default: + break; + } + if (con[1].type() == SqlType::Undef || con[2].type() == SqlType::Undef) { + char b1[40], b2[40]; + t1.print(b1, sizeof(b1)); + t2.print(b2, sizeof(b2)); + ctx.pushStatus(Error::Gen, "type mismatch in operation: %s %s %s", b1, m_op.name(), b2); + return 0; + } + } else { + ctx_assert(false); + return 0; + } + if (! ctx.ok()) + return 0; + // insert required conversions + for (unsigned i = 1; i <= arity; i++) { + if (con[i].type() == SqlType::Undef) { + ctx.pushStatus(Error::Gen, "mismatched types in operation"); + return 0; + } + if (con[i].type() == SqlType::Unbound) { + // parameter type not yet bound + continue; + } + Plan_expr_conv* exprConv = new Plan_expr_conv(m_root, con[i]); + m_root->saveNode(exprConv); + exprConv->setExpr(m_expr[i]); + m_expr[i] = static_cast(exprConv->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(m_expr[i] != 0); + } + // set result type + m_sqlType = res; + // table dependencies are union from operands + for (unsigned i = 1; i <= arity; i++) { + const TableSet& ts = m_expr[i]->tableSet(); + m_tableSet.insert(ts.begin(), ts.end()); + } + // set alias name XXX misses operator precedence + if (arity == 1) { + m_alias.assign(m_op.name()); + m_alias.append(m_expr[1]->m_alias); + } else if (arity == 2) { + m_alias.assign(m_expr[1]->m_alias); + m_alias.append(m_op.name()); + m_alias.append(m_expr[2]->m_alias); + } + return this; +} + +Exec_base* +Plan_expr_op::codegen(Ctx& ctx, Ctl& ctl) +{ + if (m_exec != 0) + return m_exec; + unsigned arity = m_op.arity(); + Exec_expr_op* exec = new Exec_expr_op(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + // create code for operands + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_expr[i] != 0); + Exec_expr* execExpr = static_cast(m_expr[i]->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execExpr != 0); + exec->setExpr(i, execExpr); + } + // create the code + SqlSpec sqlSpec(sqlType(), SqlSpec::Physical); + Exec_expr_op::Code& code = *new Exec_expr_op::Code(m_op, sqlSpec); + exec->setCode(code); + m_exec = exec; + return exec; +} + +void +Plan_expr_op::print(Ctx& ctx) +{ + ctx.print(" [%s", m_op.name()); + Plan_base* a[] = { m_expr[1], m_expr[2] }; + printList(ctx, a, m_op.arity()); + ctx.print("]"); +} + +bool +Plan_expr_op::isEqual(const Plan_expr* expr) const +{ + ctx_assert(expr != 0); + if (expr->type() != Plan_expr::TypeOp) + return false; + const Plan_expr_op* expr2 = static_cast(expr); + if (m_op.m_opcode != expr2->m_op.m_opcode) + return false; + const unsigned arity = m_op.arity(); + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_expr[i] != 0); + if (! m_expr[i]->isEqual(expr2->m_expr[i])) + return false; + } + return true; +} + +bool +Plan_expr_op::isGroupBy(const Plan_expr_row* row) const +{ + if (isAnyEqual(row)) + return true; + const unsigned arity = m_op.arity(); + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_expr[i] != 0); + if (! m_expr[i]->isGroupBy(row)) + return false; + } + return true; +} + +// Code_expr_op + +Exec_expr_op::Code::~Code() +{ +} + +Exec_expr_op::Data::~Data() +{ +} + +Exec_expr_op::~Exec_expr_op() +{ +} + +void +Exec_expr_op::alloc(Ctx& ctx, Ctl& ctl) +{ + if (m_data != 0) + return; + const Code& code = getCode(); + // allocate subexpressions + unsigned arity = code.m_op.arity(); + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_expr[i] != 0); + m_expr[i]->alloc(ctx, ctl); + if (! ctx.ok()) + return; + } + SqlField sqlField(code.m_sqlSpec); + Data& data = *new Data(sqlField); + setData(data); +} + +void +Exec_expr_op::close(Ctx& ctx) +{ + const Code& code = getCode(); + unsigned arity = code.m_op.arity(); + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_expr[i] != 0); + m_expr[i]->close(ctx); + } + Data& data = getData(); + data.m_groupField.clear(); +} + +void +Exec_expr_op::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx.print(" [%s", code.m_op.name()); + Exec_base* a[] = { m_expr[1], m_expr[2] }; + printList(ctx, a, code.m_op.arity()); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_expr_op.hpp b/ndb/src/client/odbc/codegen/Code_expr_op.hpp new file mode 100644 index 00000000000..f9686cad151 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr_op.hpp @@ -0,0 +1,166 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_expr_op_hpp +#define ODBC_CODEGEN_Code_expr_op_hpp + +#include +#include +#include "Code_expr.hpp" + +/** + * @class Expr_op + * @brief Arithmetic and string operators + */ +struct Expr_op { + enum Opcode { + Add = 1, // binary + Subtract, + Multiply, + Divide, + Plus, // unary + Minus + }; + Expr_op(Opcode opcode); + const char* name() const; + unsigned arity() const; + Opcode m_opcode; +}; + +inline +Expr_op::Expr_op(Opcode opcode) : + m_opcode(opcode) +{ +} + +/** + * @class Plan_expr_op + * @brief Operator node in an expression in PlanTree + */ +class Plan_expr_op : public Plan_expr { +public: + Plan_expr_op(Plan_root* root, Expr_op op); + virtual ~Plan_expr_op(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + bool isEqual(const Plan_expr* expr) const; + bool isGroupBy(const Plan_expr_row* row) const; + // children + void setExpr(unsigned i, Plan_expr* expr); +protected: + Expr_op m_op; + Plan_expr* m_expr[1 + 2]; +}; + +inline +Plan_expr_op::Plan_expr_op(Plan_root* root, Expr_op op) : + Plan_expr(root, TypeOp), + m_op(op) +{ + m_expr[0] = m_expr[1] = m_expr[2] = 0; +} + +inline void +Plan_expr_op::setExpr(unsigned i, Plan_expr* expr) +{ + ctx_assert(1 <= i && i <= 2 && expr != 0); + m_expr[i] = expr; +} + +/** + * @class Exec_expr_op + * @brief Operator node in an expression in ExecTree + */ +class Exec_expr_op : public Exec_expr { +public: + class Code : public Exec_expr::Code { + public: + Code(Expr_op op, const SqlSpec& spec); + virtual ~Code(); + protected: + friend class Exec_expr_op; + Expr_op m_op; + const SqlSpec m_sqlSpec; + }; + class Data : public Exec_expr::Data { + public: + Data(const SqlField& sqlField); + virtual ~Data(); + protected: + friend class Exec_expr_op; + SqlField m_sqlField; + }; + Exec_expr_op(Exec_root* root); + virtual ~Exec_expr_op(); + void alloc(Ctx& ctx, Ctl& ctl); + void evaluate(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setExpr(unsigned i, Exec_expr* expr); +protected: + Exec_expr* m_expr[1 + 2]; +}; + +inline +Exec_expr_op::Code::Code(Expr_op op, const SqlSpec& sqlSpec) : + Exec_expr::Code(m_sqlSpec), + m_op(op), + m_sqlSpec(sqlSpec) +{ +} + +inline +Exec_expr_op::Data::Data(const SqlField& sqlField) : + Exec_expr::Data(m_sqlField), + m_sqlField(sqlField) +{ +} + +inline +Exec_expr_op::Exec_expr_op(Exec_root* root) : + Exec_expr(root) +{ + m_expr[0] = m_expr[1] = m_expr[2] = 0; +} + +// children + +inline const Exec_expr_op::Code& +Exec_expr_op::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_expr_op::Data& +Exec_expr_op::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_expr_op::setExpr(unsigned i, Exec_expr* expr) +{ + ctx_assert(1 <= i && i <= 2 && m_expr[i] == 0); + m_expr[i] = expr; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_expr_param.cpp b/ndb/src/client/odbc/codegen/Code_expr_param.cpp new file mode 100644 index 00000000000..93892cae5e6 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr_param.cpp @@ -0,0 +1,279 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_expr_param.hpp" +#include "Code_root.hpp" + +// Plan_expr_param + +Plan_expr_param::~Plan_expr_param() +{ +} + +Plan_base* +Plan_expr_param::analyze(Ctx& ctx, Ctl& ctl) +{ + m_exec = 0; + ctx_assert(m_paramNumber != 0); + ctx_assert(m_paramNumber < m_root->m_paramList.size()); + m_root->m_paramList[m_paramNumber] = this; + m_sqlType.setType(ctx, SqlType::Unbound); + // check if type is bound now + DescArea& ipd = descArea(Desc_usage_IPD); + if (m_paramNumber <= ipd.getCount()) { + DescRec& rec = ipd.getRecord(m_paramNumber); + OdbcData descData; + rec.getField(ctx, SQL_DESC_TYPE, descData); + if (descData.type() != OdbcData::Undef) { + SQLSMALLINT desc_TYPE = descData.smallint(); + // XXX wrong but fixes sun.jdbc.odbc + if (desc_TYPE == SQL_CHAR) + desc_TYPE = SQL_VARCHAR; + if (desc_TYPE == SQL_CHAR) { + rec.getField(ctx, SQL_DESC_LENGTH, descData); + if (descData.type() != OdbcData::Undef) { + unsigned desc_LENGTH = descData.uinteger(); + m_sqlType.setType(ctx, SqlType::Char, desc_LENGTH); + } + } else if (desc_TYPE == SQL_VARCHAR) { + rec.getField(ctx, SQL_DESC_LENGTH, descData); + if (descData.type() != OdbcData::Undef) { + unsigned desc_LENGTH = descData.uinteger(); + m_sqlType.setType(ctx, SqlType::Varchar, desc_LENGTH); + } + } else if (desc_TYPE == SQL_BINARY) { + rec.getField(ctx, SQL_DESC_LENGTH, descData); + if (descData.type() != OdbcData::Undef) { + unsigned desc_LENGTH = descData.uinteger(); + m_sqlType.setType(ctx, SqlType::Binary, desc_LENGTH); + } + } else if (desc_TYPE == SQL_VARBINARY) { + rec.getField(ctx, SQL_DESC_LENGTH, descData); + if (descData.type() != OdbcData::Undef) { + unsigned desc_LENGTH = descData.uinteger(); + m_sqlType.setType(ctx, SqlType::Varbinary, desc_LENGTH); + } else { + // XXX BLOB hack + unsigned desc_LENGTH = FAKE_BLOB_SIZE; + m_sqlType.setType(ctx, SqlType::Varbinary, desc_LENGTH); + } + } else if (desc_TYPE == SQL_SMALLINT) { + m_sqlType.setType(ctx, SqlType::Smallint); + } else if (desc_TYPE == SQL_INTEGER) { + m_sqlType.setType(ctx, SqlType::Integer); + } else if (desc_TYPE == SQL_BIGINT) { + m_sqlType.setType(ctx, SqlType::Bigint); + } else if (desc_TYPE == SQL_REAL) { + m_sqlType.setType(ctx, SqlType::Real); + } else if (desc_TYPE == SQL_DOUBLE) { + m_sqlType.setType(ctx, SqlType::Double); + } else if (desc_TYPE == SQL_TYPE_TIMESTAMP) { + m_sqlType.setType(ctx, SqlType::Datetime); + // XXX BLOB hack + } else if (desc_TYPE == SQL_LONGVARBINARY) { + m_sqlType.setType(ctx, SqlType::Varbinary, (unsigned)FAKE_BLOB_SIZE); + } else { + ctx.pushStatus(Error::Gen, "parameter %u unsupported SQL type %d", m_paramNumber, (int)desc_TYPE); + return 0; + } + char buf[100]; + m_sqlType.print(buf, sizeof(buf)); + ctx_log2(("parameter %u SQL type bound to %s", m_paramNumber, buf)); + } + } + return this; +} + +void +Plan_expr_param::describe(Ctx& ctx) +{ + DescArea& ipd = descArea(Desc_usage_IPD); + if (ipd.getCount() < m_paramNumber) + ipd.setCount(ctx, m_paramNumber); + // XXX describe if possible + DescRec& rec = ipd.getRecord(m_paramNumber); +} + +Exec_base* +Plan_expr_param::codegen(Ctx& ctx, Ctl& ctl) +{ + if (m_exec != 0) + return m_exec; + SqlSpec sqlSpec(m_sqlType, SqlSpec::Physical); + // create code + Exec_expr_param* exec = new Exec_expr_param(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + ctx_assert(m_paramNumber != 0); + Exec_expr_param::Code& code = *new Exec_expr_param::Code(sqlSpec, m_paramNumber); + exec->setCode(code); + m_exec = exec; + return exec; +} + +void +Plan_expr_param::print(Ctx& ctx) +{ + ctx.print(" [param %u]", m_paramNumber); +} + +bool +Plan_expr_param::isEqual(const Plan_expr* expr) const +{ + ctx_assert(expr != 0); + if (expr->type() != Plan_expr::TypeParam) + return false; + const Plan_expr_param* expr2 = static_cast(expr); + // params are not equal ever + return false; +} + +bool +Plan_expr_param::isGroupBy(const Plan_expr_row* row) const +{ + // params are constants + return true; +} + +// Exec_expr_param + +Exec_expr_param::Code::~Code() +{ +} + +Exec_expr_param::Data::~Data() +{ + delete m_extField; + m_extField = 0; +} + +Exec_expr_param::~Exec_expr_param() +{ +} + +void +Exec_expr_param::alloc(Ctx& ctx, Ctl& ctl) +{ + if (m_data != 0) + return; + const Code& code = getCode(); + SqlField sqlField(code.sqlSpec()); + Data& data = *new Data(sqlField); + setData(data); +} + +void +Exec_expr_param::bind(Ctx& ctx) +{ + const Code& code = getCode(); + Data& data = getData(); + DescArea& apd = descArea(Desc_usage_APD); + if (apd.getCount() < code.m_paramNumber) { + ctx_log1(("parameter %u is not bound", code.m_paramNumber)); + return; + } + const unsigned paramNumber = code.m_paramNumber; + DescRec& rec = apd.getRecord(paramNumber); + OdbcData descData; + // create type + rec.getField(ctx, SQL_DESC_TYPE, descData); + if (descData.type() == OdbcData::Undef) { + ctx.pushStatus(Error::Gen, "parameter %u external type not defined", paramNumber); + return; + } + ExtType extType; + SQLSMALLINT desc_TYPE = descData.smallint(); + switch (desc_TYPE) { + case SQL_C_CHAR: + case SQL_C_SHORT: // for sun.jdbc.odbc + case SQL_C_SSHORT: + case SQL_C_USHORT: + case SQL_C_LONG: // for sun.jdbc.odbc + case SQL_C_SLONG: + case SQL_C_ULONG: + case SQL_C_SBIGINT: + case SQL_C_UBIGINT: + case SQL_C_FLOAT: + case SQL_C_DOUBLE: + case SQL_C_TYPE_TIMESTAMP: + case SQL_C_BINARY: // XXX BLOB hack + break; + default: + ctx.pushStatus(Error::Gen, "parameter %u unsupported external type %d", paramNumber, (int)desc_TYPE); + return; + } + extType.setType(ctx, static_cast(desc_TYPE)); + ExtSpec extSpec(extType); + // create data field + rec.getField(ctx, SQL_DESC_DATA_PTR, descData); + if (descData.type() == OdbcData::Undef) { + ctx.pushStatus(Error::Gen, "parameter %u data address not defined", paramNumber); + return; + } + SQLPOINTER desc_DATA_PTR = descData.pointer(); + rec.getField(ctx, SQL_DESC_OCTET_LENGTH, descData); + if (descData.type() == OdbcData::Undef) { + ctx.pushStatus(Error::Gen, "parameter %u data length not defined", paramNumber); + return; + } + SQLINTEGER desc_OCTET_LENGTH = descData.integer(); + rec.getField(ctx, SQL_DESC_INDICATOR_PTR, descData); + if (descData.type() == OdbcData::Undef) { + ctx.pushStatus(Error::Gen, "parameter %u indicator address not defined", paramNumber); + return; + } + SQLINTEGER* desc_INDICATOR_PTR = descData.integerPtr(); + ctx_log4(("parameter %u bind to 0x%x %d 0x%x", paramNumber, (unsigned)desc_DATA_PTR, (int)desc_OCTET_LENGTH, (unsigned)desc_INDICATOR_PTR)); + ExtField& extField = *new ExtField(extSpec, desc_DATA_PTR, desc_OCTET_LENGTH, desc_INDICATOR_PTR, paramNumber); + data.m_atExec = false; + if (desc_INDICATOR_PTR != 0 && *desc_INDICATOR_PTR < 0) { + if (*desc_INDICATOR_PTR == SQL_NULL_DATA) { + ; + } else if (*desc_INDICATOR_PTR == SQL_DATA_AT_EXEC) { + data.m_atExec = true; + } else if (*desc_INDICATOR_PTR <= SQL_LEN_DATA_AT_EXEC(0)) { + data.m_atExec = true; + } + } + delete data.m_extField; + data.m_extField = &extField; +} + +void +Exec_expr_param::evaluate(Ctx& ctx, Ctl& ctl) +{ + if (ctl.m_postEval) + return; + const Code& code = getCode(); + Data& data = getData(); + if (data.m_atExec) + return; + ctx_assert(data.m_extField != 0); + data.m_sqlField.copyin(ctx, *data.m_extField); +} + +void +Exec_expr_param::close(Ctx& ctx) +{ + Data& data = getData(); + data.m_extPos = -1; +} + +void +Exec_expr_param::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx.print(" [param %u]", code.m_paramNumber); +} diff --git a/ndb/src/client/odbc/codegen/Code_expr_param.hpp b/ndb/src/client/odbc/codegen/Code_expr_param.hpp new file mode 100644 index 00000000000..783e5c087b4 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr_param.hpp @@ -0,0 +1,136 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_expr_param_hpp +#define ODBC_CODEGEN_Code_expr_param_hpp + +#include +#include +#include "Code_expr.hpp" + +/** + * @class Plan_expr_param + * @brief Constant expression value in PlanTree + */ +class Plan_expr_param : public Plan_expr { +public: + Plan_expr_param(Plan_root* root, unsigned paramNumber); + virtual ~Plan_expr_param(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + void describe(Ctx& ctx); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + bool isEqual(const Plan_expr* expr) const; + bool isGroupBy(const Plan_expr_row* row) const; +protected: + const unsigned m_paramNumber; +}; + +inline +Plan_expr_param::Plan_expr_param(Plan_root* root, unsigned paramNumber) : + Plan_expr(root, TypeParam), + m_paramNumber(paramNumber) +{ +} + +/** + * @class Exec_expr_param + * @brief Constant expression value in ExecTree + */ +class Exec_expr_param : public Exec_expr { +public: + class Code : public Exec_expr::Code { + public: + Code(const SqlSpec& sqlSpec, unsigned paramNumber); + virtual ~Code(); + protected: + friend class Plan_expr_param; + friend class Exec_expr_param; + const SqlSpec m_sqlSpec; + const unsigned m_paramNumber; + }; + class Data : public Exec_expr::Data { + public: + Data(SqlField& sqlField); + virtual ~Data(); + ExtField* extField() const; + protected: + friend class Exec_expr_param; + friend class Exec_root; + SqlField m_sqlField; + ExtField* m_extField; // input binding + bool m_atExec; // data at exec + int m_extPos; // position for SQLPutData (-1 before first call) + }; + Exec_expr_param(Exec_root* root); + virtual ~Exec_expr_param(); + void alloc(Ctx& ctx, Ctl& ctl); + void bind(Ctx& ctx); + void evaluate(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; +}; + +inline +Exec_expr_param::Code::Code(const SqlSpec& sqlSpec, unsigned paramNumber) : + Exec_expr::Code(m_sqlSpec), + m_sqlSpec(sqlSpec), + m_paramNumber(paramNumber) +{ +} + +inline +Exec_expr_param::Data::Data(SqlField& sqlField) : + Exec_expr::Data(m_sqlField), + m_sqlField(sqlField), + m_extField(0), + m_atExec(false), + m_extPos(-1) +{ +} + +inline ExtField* +Exec_expr_param::Data::extField() const +{ + return m_extField; +} + +inline +Exec_expr_param::Exec_expr_param(Exec_root* root) : + Exec_expr(root) +{ +} + +// children + +inline const Exec_expr_param::Code& +Exec_expr_param::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_expr_param::Data& +Exec_expr_param::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_expr_row.cpp b/ndb/src/client/odbc/codegen/Code_expr_row.cpp new file mode 100644 index 00000000000..da1751d41d1 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr_row.cpp @@ -0,0 +1,204 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Code_expr_row.hpp" +#include "Code_expr.hpp" +#include "Code_expr_conv.hpp" +#include "Code_dml_row.hpp" +#include "Code_root.hpp" + +// Plan_expr_row + +Plan_expr_row::~Plan_expr_row() +{ +} + +Plan_base* +Plan_expr_row::analyze(Ctx& ctx, Ctl& ctl) +{ + unsigned size = getSize(); + // analyze subexpressions + m_anyAggr = false; + m_allBound = true; + for (unsigned i = 1; i <= size; i++) { + Plan_expr* expr1 = getExpr(i); + Plan_expr* expr2 = static_cast(expr1->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + setExpr(i, expr2); + if (expr2->isAggr()) + m_anyAggr = true; + if (! expr2->isBound()) + m_allBound = false; + } + // insert conversions if requested XXX ugly hack + if (ctl.m_dmlRow != 0) { + if (ctl.m_dmlRow->getSize() > getSize()) { + ctx.pushStatus(Sqlstate::_21S01, Error::Gen, "not enough values (%u > %u)", ctl.m_dmlRow->getSize(), getSize()); + return 0; + } + if (ctl.m_dmlRow->getSize() < getSize()) { + ctx.pushStatus(Sqlstate::_21S01, Error::Gen, "too many values (%u < %u)", ctl.m_dmlRow->getSize(), getSize()); + return 0; + } + for (unsigned i = 1; i <= size; i++) { + const SqlType& sqlType = ctl.m_dmlRow->getColumn(i)->sqlType(); + Plan_expr_conv* exprConv = new Plan_expr_conv(m_root, sqlType); + m_root->saveNode(exprConv); + exprConv->setExpr(getExpr(i)); + Plan_expr* expr = static_cast(exprConv->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(expr != 0); + setExpr(i, expr); + } + } + // set aliases + m_aliasList.resize(1 + size); + for (unsigned i = 1; i <= size; i++) { + if (m_aliasList[i].empty()) { + setAlias(i, getExpr(i)->getAlias()); + } + } + // node was not replaced + return this; +} + +Exec_base* +Plan_expr_row::codegen(Ctx& ctx, Ctl& ctl) +{ + unsigned size = getSize(); + Exec_expr_row* exec = new Exec_expr_row(ctl.m_execRoot, size); + ctl.m_execRoot->saveNode(exec); + SqlSpecs sqlSpecs(size); + // create code for subexpressions + for (unsigned i = 1; i <= size; i++) { + Plan_expr* planExpr = getExpr(i); + Exec_expr* execExpr = static_cast(planExpr->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execExpr != 0); + exec->setExpr(i, execExpr); + const SqlSpec sqlSpec(execExpr->getCode().sqlSpec(), SqlSpec::Reference); + sqlSpecs.setEntry(i, sqlSpec); + } + // create alias list + Exec_expr_row::Code::Alias* aliasList = new Exec_expr_row::Code::Alias[1 + size]; + strcpy(aliasList[0], "?"); + for (unsigned i = 1; i <= size; i++) { + const char* s = m_aliasList[i].c_str(); + if (strlen(s) == 0) + s = getExpr(i)->getAlias().c_str(); + unsigned n = strlen(s); + if (n >= sizeof(Exec_expr_row::Code::Alias)) + n = sizeof(Exec_expr_row::Code::Alias) - 1; + strncpy(aliasList[i], s, n); + aliasList[i][n] = 0; + } + // create the code + Exec_expr_row::Code& code = *new Exec_expr_row::Code(sqlSpecs, aliasList); + exec->setCode(code); + return exec; +} + +void +Plan_expr_row::print(Ctx& ctx) +{ + const unsigned size = getSize(); + ctx.print(" [expr_row"); + for (unsigned i = 1; i <= size; i++) { + Plan_base* a = m_exprList[i]; + a == 0 ? ctx.print(" -") : a->print(ctx); + } + ctx.print("]"); +} + +bool +Plan_expr_row::isAllGroupBy(const Plan_expr_row* row) const +{ + const unsigned size = getSize(); + for (unsigned i = 1; i <= size; i++) { + if (! getExpr(i)->isGroupBy(row)) + return false; + } + return true; +} + +// Exec_expr_row + +Exec_expr_row::Code::~Code() +{ + delete[] m_aliasList; +} + +Exec_expr_row::Data::~Data() +{ +} + +Exec_expr_row::~Exec_expr_row() +{ + delete[] m_expr; +} + +void +Exec_expr_row::alloc(Ctx& ctx, Ctl& ctl) +{ + // allocate subexpressions + for (unsigned i = 1; i <= m_size; i++) { + getExpr(i)->alloc(ctx, ctl); + } + // construct SqlRow of references + const Code& code = getCode(); + SqlRow sqlRow(getCode().m_sqlSpecs); + for (unsigned i = 1; i <= m_size; i++) { + const Exec_expr::Data& dataExpr = getExpr(i)->getData(); + const SqlSpec& sqlSpec = code.m_sqlSpecs.getEntry(i); + const SqlField sqlField(sqlSpec, &dataExpr.sqlField()); + sqlRow.setEntry(i, sqlField); + } + // create the data + Data& data = *new Data(sqlRow); + setData(data); +} + +void +Exec_expr_row::evaluate(Ctx& ctx, Ctl& ctl) +{ + for (unsigned i = 1; i <= m_size; i++) { + getExpr(i)->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + } +} + +void +Exec_expr_row::close(Ctx& ctx) +{ + for (unsigned i = 1; i <= m_size; i++) { + getExpr(i)->close(ctx); + } +} + +void +Exec_expr_row::print(Ctx& ctx) +{ + ctx.print(" [expr_row"); + for (unsigned i = 1; i <= m_size; i++) { + getExpr(i)->print(ctx); + } + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_expr_row.hpp b/ndb/src/client/odbc/codegen/Code_expr_row.hpp new file mode 100644 index 00000000000..94527931dba --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_expr_row.hpp @@ -0,0 +1,272 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_expr_row_hpp +#define ODBC_CODEGEN_Code_expr_row_hpp + +#include +#include +#include +#include "Code_base.hpp" +#include "Code_expr.hpp" + +class Plan_expr; + +/** + * @class Plan_expr_row + * @brief Row of expressions in PlanTree + * + * Used for select, value, and order by rows. + */ +class Plan_expr_row : public Plan_base { +public: + Plan_expr_row(Plan_root* root); + virtual ~Plan_expr_row(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setAsterisk(); + bool getAsterisk() const; + unsigned getSize() const; + Plan_expr* getExpr(unsigned i) const; + void setExpr(unsigned i, Plan_expr* expr); + void addExpr(Plan_expr* expr); + void addExpr(Plan_expr* expr, const BaseString& alias); + void setAlias(unsigned i, const BaseString& alias); + void addExpr(Plan_expr* expr, bool asc); + bool anyAggr() const; + bool allBound() const; + bool isAllGroupBy(const Plan_expr_row* row) const; +protected: + friend class Plan_query; + friend class Plan_query_sort; + bool m_asterisk; // early plan node type + ExprVector m_exprList; + typedef std::vector AliasList; + AliasList m_aliasList; + typedef std::vector AscList; + AscList m_ascList; + bool m_anyAggr; // at least one aggreate + bool m_allBound; // all bound +}; + +inline +Plan_expr_row::Plan_expr_row(Plan_root* root) : + Plan_base(root), + m_asterisk(false), + m_exprList(1), + m_aliasList(1), + m_ascList(1), + m_anyAggr(false), + m_allBound(false) +{ +} + +// children + +inline void +Plan_expr_row::setAsterisk() +{ + m_asterisk = true; +} + +inline bool +Plan_expr_row::getAsterisk() const +{ + return m_asterisk; +} + +inline unsigned +Plan_expr_row::getSize() const +{ + ctx_assert(m_exprList.size() >= 1); + return m_exprList.size() - 1; +} + +inline void +Plan_expr_row::addExpr(Plan_expr* expr) +{ + ctx_assert(expr != 0); + addExpr(expr, expr->m_alias); +} + +inline void +Plan_expr_row::addExpr(Plan_expr* expr, const BaseString& alias) +{ + ctx_assert(expr != 0); + m_exprList.push_back(expr); + m_aliasList.push_back(alias); +} + +inline void +Plan_expr_row::addExpr(Plan_expr* expr, bool asc) +{ + ctx_assert(expr != 0); + m_exprList.push_back(expr); + m_ascList.push_back(asc); +} + +inline void +Plan_expr_row::setExpr(unsigned i, Plan_expr* expr) +{ + ctx_assert(1 <= i && i < m_exprList.size() && expr != 0); + m_exprList[i] = expr; +} + +inline Plan_expr* +Plan_expr_row::getExpr(unsigned i) const +{ + ctx_assert(1 <= i && i < m_exprList.size() && m_exprList[i] != 0); + return m_exprList[i]; +} + +inline void +Plan_expr_row::setAlias(unsigned i, const BaseString& alias) +{ + ctx_assert(1 <= i && i < m_aliasList.size()); + m_aliasList[i] = alias; +} + +inline bool +Plan_expr_row::anyAggr() const +{ + return m_anyAggr; +} + +inline bool +Plan_expr_row::allBound() const +{ + return m_allBound; +} + +/** + * @class Expr_expr_row + * @brief Row of expressions in ExecTree + */ +class Exec_expr_row : public Exec_base { +public: + class Code : public Exec_base::Code { + public: + typedef char Alias[40]; + Code(const SqlSpecs& sqlSpecs, const Alias* aliasList); + virtual ~Code(); + const SqlSpecs& sqlSpecs() const; + const char* getAlias(unsigned i) const; + protected: + friend class Exec_expr_row; + const SqlSpecs m_sqlSpecs; + const Alias* m_aliasList; + }; + class Data : public Exec_base::Data { + public: + Data(const SqlRow& sqlRow); + virtual ~Data(); + const SqlRow& sqlRow() const; + protected: + friend class Exec_expr_row; + SqlRow m_sqlRow; + }; + Exec_expr_row(Exec_root* root, unsigned size); + virtual ~Exec_expr_row(); + void alloc(Ctx& ctx, Ctl& ctl); + void evaluate(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + Exec_expr* getExpr(unsigned i) const; + void setExpr(unsigned i, Exec_expr* expr); +protected: + Exec_expr** m_expr; // numbered from 1 + unsigned m_size; +}; + +inline +Exec_expr_row::Code::Code(const SqlSpecs& sqlSpecs, const Alias* aliasList) : + m_sqlSpecs(sqlSpecs), + m_aliasList(aliasList) +{ +} + +inline const SqlSpecs& +Exec_expr_row::Code::sqlSpecs() const +{ + return m_sqlSpecs; +} + +inline const char* +Exec_expr_row::Code::getAlias(unsigned i) const +{ + ctx_assert(1 <= i && i <= m_sqlSpecs.count() && m_aliasList != 0); + return m_aliasList[i]; +} + +inline +Exec_expr_row::Data::Data(const SqlRow& sqlRow) : + m_sqlRow(sqlRow) +{ +} + +inline const SqlRow& +Exec_expr_row::Data::sqlRow() const +{ + return m_sqlRow; +} + +inline +Exec_expr_row::Exec_expr_row(Exec_root* root, unsigned size) : + Exec_base(root), + m_expr(new Exec_expr* [1 + size]), + m_size(size) +{ + m_expr[0] = (Exec_expr*)-1; + for (unsigned i = 1; i <= m_size; i++) + m_expr[i] = 0; +} + +// children + +inline const Exec_expr_row::Code& +Exec_expr_row::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_expr_row::Data& +Exec_expr_row::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline Exec_expr* +Exec_expr_row::getExpr(unsigned i) const +{ + ctx_assert(1 <= i && i <= m_size && m_expr != 0 && m_expr[i] != 0); + return m_expr[i]; +} + +inline void +Exec_expr_row::setExpr(unsigned i, Exec_expr* expr) +{ + ctx_assert(1 <= i && i <= m_size && m_expr != 0 && m_expr[i] == 0); + m_expr[i] = expr; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_idx_column.cpp b/ndb/src/client/odbc/codegen/Code_idx_column.cpp new file mode 100644 index 00000000000..584ffef3e01 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_idx_column.cpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include "Code_idx_column.hpp" +#include "Code_expr_conv.hpp" +#include "Code_root.hpp" + +// Plan_idx_column + +Plan_idx_column::~Plan_idx_column() +{ +} + +Plan_base* +Plan_idx_column::analyze(Ctx& ctx, Ctl& ctl) +{ + analyzeColumn(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +Exec_base* +Plan_idx_column::codegen(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(false); + return 0; +} + +void +Plan_idx_column::print(Ctx& ctx) +{ + ctx.print(" [idx_column %s]", getPrintName()); +} diff --git a/ndb/src/client/odbc/codegen/Code_idx_column.hpp b/ndb/src/client/odbc/codegen/Code_idx_column.hpp new file mode 100644 index 00000000000..209ed705b48 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_idx_column.hpp @@ -0,0 +1,50 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_idx_column_hpp +#define ODBC_CODEGEN_Code_idx_column_hpp + +#include +#include "Code_column.hpp" +#include "Code_data_type.hpp" +#include "Code_expr.hpp" + +class DictColumn; +class Plan_table; + +/** + * @class Plan_idx_column + * @brief Column in create index statement + */ +class Plan_idx_column : public Plan_base, public Plan_column { +public: + Plan_idx_column(Plan_root* root, const BaseString& name); + virtual ~Plan_idx_column(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); +protected: + friend class Plan_create_row; +}; + +inline +Plan_idx_column::Plan_idx_column(Plan_root* root, const BaseString& name) : + Plan_base(root), + Plan_column(Type_idx, name) +{ +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_insert.cpp b/ndb/src/client/odbc/codegen/Code_insert.cpp new file mode 100644 index 00000000000..c442186c181 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_insert.cpp @@ -0,0 +1,253 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "Code_insert.hpp" +#include "Code_query_repeat.hpp" +#include "Code_query_project.hpp" +#include "Code_table.hpp" +#include "Code_root.hpp" + +// Plan_insert + +Plan_insert::~Plan_insert() +{ +} + +Plan_base* +Plan_insert::analyze(Ctx& ctx, Ctl& ctl) +{ + stmtArea().stmtInfo().setName(Stmt_name_insert); + ctx_assert(m_table != 0); + m_table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + // handle MySql syntax + if (m_mysqlRow != 0) { + setDmlRow(m_mysqlRow->m_dmlRow); + setExprRow(m_mysqlRow->m_exprRow); + m_mysqlRow = 0; + } + if (m_dmlRow == 0) { + // construct column list + setDmlRow(new Plan_dml_row(m_root)); + m_root->saveNode(m_dmlRow); + const DictTable& dictTable = m_table->dictTable(); + unsigned n = dictTable.getSize(); + for (unsigned i = 1; i <= n; i++) { + DictColumn* dictColumn = dictTable.getColumn(i); + Plan_dml_column* column = new Plan_dml_column(m_root, dictColumn->getName()); + m_root->saveNode(column); + m_dmlRow->addColumn(column); + } + } + // set name resolution scope + ctl.m_tableList.resize(1 + 1); // indexed from 1 + ctl.m_tableList[1] = m_table; + // analyze the dml columns + m_dmlRow->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + ctl.m_dmlRow = m_dmlRow; // row type to convert to + if (m_query != 0) { + m_query->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + } else if (m_select == 0) { + // analyze the expression row + m_exprRow->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + // transform the row into query + Plan_query_repeat* queryRepeat = new Plan_query_repeat(m_root, 1); + m_root->saveNode(queryRepeat); + Plan_query_project* queryProject = new Plan_query_project(m_root); + m_root->saveNode(queryProject); + queryProject->setQuery(queryRepeat); + queryProject->setRow(m_exprRow); + setQuery(queryProject); + } else { + // analyze the select into query + Plan_query* query = static_cast(m_select->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + setQuery(query); + } + return this; +} + +void +Plan_insert::describe(Ctx& ctx) +{ + stmtArea().setFunction(ctx, "INSERT", SQL_DIAG_INSERT); +} + +Exec_base* +Plan_insert::codegen(Ctx& ctx, Ctl& ctl) +{ + // create code for the query + ctx_assert(m_query != 0); + Exec_query* execQuery = static_cast(m_query->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execQuery != 0); + // set up + ctx_assert(m_table != 0); + const BaseString& tableName = m_table->getName(); + const DictTable& dictTable = m_table->dictTable(); + const ColumnVector& columns = m_table->dmlColumns(); + ctx_assert(columns.size() > 0); + const unsigned attrCount = columns.size() - 1; + // create the code + Exec_insert::Code& code = *new Exec_insert::Code(); + code.m_insertOp = m_insertOp; + code.m_tableName = strcpy(new char[tableName.length() + 1], tableName.c_str()); + code.m_attrCount = attrCount; + code.m_attrId = new NdbAttrId[1 + attrCount]; + code.m_isKey = new bool[1 + attrCount]; + code.m_attrId[0] = (NdbAttrId)-1; + code.m_tupleId = dictTable.tupleId(); // maybe 0 + code.m_autoIncrement = dictTable.autoIncrement(); // maybe 0 + unsigned k; + if ((k = code.m_tupleId) != 0 || (k = code.m_autoIncrement) != 0) { + const DictColumn& dictColumn = *dictTable.getColumn(k); + code.m_idType = dictColumn.sqlType(); + } + for (unsigned i = 1; i <= attrCount; i++) { + Plan_column* column = columns[i]; + ctx_assert(column != 0); + const DictColumn& dictColumn = column->dictColumn(); + code.m_attrId[i] = dictColumn.getAttrId(); + code.m_isKey[i] = dictColumn.isKey(); + } + // default values XXX a mess + code.m_defaultCount = 0; + for (unsigned j = 1; j <= dictTable.getSize(); j++) { + const DictColumn& dictColumn = *dictTable.getColumn(j); + if (dictColumn.getDefaultValue() != 0 && ! code.findAttrId(dictColumn.getAttrId())) + code.m_defaultCount++; + } + if (code.m_defaultCount != 0) { + code.m_defaultId = new NdbAttrId[1 + code.m_defaultCount]; + for (unsigned i = 0, j = 1; j <= dictTable.getSize(); j++) { + const DictColumn& dictColumn = *dictTable.getColumn(j); + if (dictColumn.getDefaultValue() != 0 && ! code.findAttrId(dictColumn.getAttrId())) + code.m_defaultId[++i] = dictColumn.getAttrId(); + } + SqlSpecs sqlSpecs(code.m_defaultCount); + for (unsigned i = 0, j = 1; j <= dictTable.getSize(); j++) { + const DictColumn& dictColumn = *dictTable.getColumn(j); + if (dictColumn.getDefaultValue() != 0 && ! code.findAttrId(dictColumn.getAttrId())) { + SqlSpec sqlSpec(dictColumn.sqlType(), SqlSpec::Physical); + sqlSpecs.setEntry(++i, sqlSpec); + } + } + code.m_defaultValue = new SqlRow(sqlSpecs); + for (unsigned i = 0, j = 1; j <= dictTable.getSize(); j++) { + const DictColumn& dictColumn = *dictTable.getColumn(j); + if (dictColumn.getDefaultValue() != 0 && ! code.findAttrId(dictColumn.getAttrId())) { + const char* defaultValue = dictColumn.getDefaultValue(); + ExtType extType(ExtType::Char); + ExtSpec extSpec(extType); + SQLINTEGER ind = SQL_NTS; + ExtField extField(extSpec, (SQLPOINTER)defaultValue, 0, &ind); + SqlField& f = code.m_defaultValue->getEntry(++i); + f.copyin(ctx, extField); + if (! ctx.ok()) + return 0; + } + } + } + // create the exec + Exec_insert* exec = new Exec_insert(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + exec->setCode(code); + exec->setQuery(execQuery); + return exec; +} + +void +Plan_insert::print(Ctx& ctx) +{ + ctx.print(" [%s", m_insertOp == Insert_op_insert ? "insert" : "write"); + Plan_base* a[] = { m_table, m_dmlRow, m_exprRow, m_query }; + printList(ctx, a, 4); + ctx.print("]"); +} + +// Exec_insert + +Exec_insert::Code::~Code() +{ + delete[] m_tableName; + delete[] m_attrId; + delete[] m_isKey; + delete[] m_defaultId; + delete m_defaultValue; +} + +bool +Exec_insert::Code::findAttrId(NdbAttrId attrId) const +{ + for (unsigned i = 1; i <= m_attrCount; i++) { + if (m_attrId[i] == attrId) + return true; + } + return false; +} + +Exec_insert::Data::~Data() +{ +} + +Exec_insert::~Exec_insert() +{ +} + +void +Exec_insert::alloc(Ctx& ctx, Ctl& ctl) +{ + // allocate the query + ctx_assert(m_query != 0); + m_query->alloc(ctx, ctl); + // create data + Data& data = *new Data(); + setData(data); +} + +void +Exec_insert::close(Ctx& ctx) +{ +} + +void +Exec_insert::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx_assert(m_query != 0); + ctx.print(" [insert"); + ctx.print(" attrId="); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + if (i > 1) + ctx.print(","); + ctx.print("%u", (unsigned)code.m_attrId[i]); + } + ctx.print(" table=%s", code.m_tableName); + m_query->print(ctx); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_insert.hpp b/ndb/src/client/odbc/codegen/Code_insert.hpp new file mode 100644 index 00000000000..748b092e33a --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_insert.hpp @@ -0,0 +1,229 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_insert_hpp +#define ODBC_CODEGEN_Code_insert_hpp + +#include +#include "Code_base.hpp" +#include "Code_dml.hpp" +#include "Code_dml_row.hpp" +#include "Code_expr_row.hpp" +#include "Code_select.hpp" +#include "Code_query.hpp" +#include "Code_table.hpp" +#include "Code_set_row.hpp" + +enum Insert_op { + Insert_op_undef = 0, + Insert_op_insert = 1, + Insert_op_write = 2 +}; + +/** + * @class Plan_insert + * @brief Insert in PlanTree + * + * Insert. Becomes directly executable. + */ +class Plan_insert : public Plan_dml { +public: + Plan_insert(Plan_root* root, Insert_op insertOp); + virtual ~Plan_insert(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + void describe(Ctx& ctx); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setTable(Plan_table* table); + Plan_dml_row* getDmlRow() const; + void setDmlRow(Plan_dml_row* dmlRow); + void setExprRow(Plan_expr_row* exprRow); + void setSelect(Plan_select* select); + void setQuery(Plan_query* query); + void setMysqlRow(Plan_set_row* mysqlRow); +protected: + Insert_op m_insertOp; + Plan_table* m_table; + Plan_dml_row* m_dmlRow; + Plan_expr_row* m_exprRow; + Plan_select* m_select; + Plan_query* m_query; + Plan_set_row* m_mysqlRow; +}; + +inline +Plan_insert::Plan_insert(Plan_root* root, Insert_op insertOp) : + Plan_dml(root), + m_insertOp(insertOp), + m_table(0), + m_dmlRow(0), + m_exprRow(0), + m_select(0), + m_query(0), + m_mysqlRow(0) +{ +} + +// children + +inline void +Plan_insert::setTable(Plan_table* table) +{ + ctx_assert(table != 0); + m_table = table; +} + +inline void +Plan_insert::setDmlRow(Plan_dml_row* dmlRow) +{ + ctx_assert(dmlRow != 0); + m_dmlRow = dmlRow; +} + +inline Plan_dml_row* +Plan_insert::getDmlRow() const +{ + ctx_assert(m_dmlRow != 0); + return m_dmlRow; +} + +inline void +Plan_insert::setExprRow(Plan_expr_row* exprRow) +{ + ctx_assert(exprRow != 0); + m_exprRow = exprRow; +} + +inline void +Plan_insert::setSelect(Plan_select* select) +{ + ctx_assert(select != 0); + m_select = select; +} + +inline void +Plan_insert::setQuery(Plan_query* query) +{ + ctx_assert(query != 0); + m_query = query; +} + +inline void +Plan_insert::setMysqlRow(Plan_set_row* mysqlRow) +{ + ctx_assert(mysqlRow != 0); + m_mysqlRow = mysqlRow; +} + +/** + * @class Exec_insert + * @brief Executable insert + */ +class Exec_insert : public Exec_dml { +public: + class Code : public Exec_dml::Code { + public: + Code(); + virtual ~Code(); + protected: + friend class Plan_insert; + friend class Exec_insert; + Insert_op m_insertOp; + char* m_tableName; + unsigned m_attrCount; + NdbAttrId* m_attrId; + bool* m_isKey; + unsigned m_tupleId; // position of tuple id + unsigned m_autoIncrement; // position of ai key + SqlType m_idType; // type of tuple id or ai key + unsigned m_defaultCount; + NdbAttrId* m_defaultId; + SqlRow* m_defaultValue; + bool findAttrId(NdbAttrId attrId) const; + }; + class Data : public Exec_dml::Data { + public: + Data(); + virtual ~Data(); + protected: + friend class Exec_insert; + }; + Exec_insert(Exec_root* root); + virtual ~Exec_insert(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setQuery(Exec_query* query); +private: + Exec_query* m_query; +}; + +inline +Exec_insert::Code::Code() : + m_insertOp(Insert_op_undef), + m_tableName(0), + m_attrCount(0), + m_attrId(0), + m_isKey(0), + m_tupleId(0), + m_autoIncrement(0), + m_defaultCount(0), + m_defaultId(0), + m_defaultValue(0) +{ +} + +inline +Exec_insert::Data::Data() +{ +} + +inline +Exec_insert::Exec_insert(Exec_root* root) : + Exec_dml(root), + m_query(0) +{ +} + +// children + +inline const Exec_insert::Code& +Exec_insert::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_insert::Data& +Exec_insert::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_insert::setQuery(Exec_query* query) +{ + ctx_assert(m_query == 0 && query != 0); + m_query = query; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_pred.cpp b/ndb/src/client/odbc/codegen/Code_pred.cpp new file mode 100644 index 00000000000..fe7cac7606e --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_pred.cpp @@ -0,0 +1,70 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_pred.hpp" +#include "Code_pred_op.hpp" +#include "Code_root.hpp" + +// Plan_pred + +Plan_pred::~Plan_pred() +{ +} + +bool +Plan_pred::isGroupBy(const Plan_expr_row* row) const +{ + return false; +} + +Plan_pred* +Plan_pred::opAnd(Plan_pred* pred2) +{ + Plan_pred_op* predAnd = new Plan_pred_op(m_root, Pred_op::And); + m_root->saveNode(predAnd); + predAnd->setPred(1, this); + predAnd->setPred(2, pred2); + return predAnd; +} + +// Exec_pred + +Exec_pred::Code::~Code() +{ +} + +Exec_pred::Data::~Data() +{ +} + +Exec_pred::~Exec_pred() +{ +} + +Pred_value& +Exec_pred::Data::groupValue(unsigned i, bool initFlag) +{ + if (m_groupValue.size() == 0) { + m_groupValue.resize(1); + } + if (initFlag) { + //unsigned i2 = m_groupValue.size(); + //ctx_assert(i == i2); + m_groupValue.push_back(Pred_value_unknown); + } + ctx_assert(i != 0 && i < m_groupValue.size()); + return m_groupValue[i]; +} diff --git a/ndb/src/client/odbc/codegen/Code_pred.hpp b/ndb/src/client/odbc/codegen/Code_pred.hpp new file mode 100644 index 00000000000..a77c1161fa1 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_pred.hpp @@ -0,0 +1,172 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_pred_hpp +#define ODBC_CODEGEN_Code_pred_hpp + +#include +#include +#include "Code_base.hpp" + +enum Pred_value { + Pred_value_unknown = -1, + Pred_value_false = 0, + Pred_value_true = 1 +}; + +class Ctx; +class Plan_expr_row; +class Exec_pred; + +/** + * @class Plan_pred + * @brief Base class for predicates in PlanTree + * + * Predicate represents a boolean value. + */ +class Plan_pred : public Plan_base { +public: + // type is convenient since RTTI cannot be used + enum Type { + TypeUndefined = 0, + TypeComp = 1, + TypeOp = 2 + }; + Plan_pred(Plan_root* root, Type type); + virtual ~Plan_pred() = 0; + Type type() const; + const TableSet& tableSet() const; + const TableSet& noInterp() const; + virtual bool isGroupBy(const Plan_expr_row* row) const; + // helpers + Plan_pred* opAnd(Plan_pred* pred2); +protected: + const Type m_type; + TableSet m_tableSet; // depends on these tables + TableSet m_noInterp; // cannot use interpreted TUP program on these tables + Exec_pred* m_exec; // probably stupid +}; + +inline +Plan_pred::Plan_pred(Plan_root* root, Type type) : + Plan_base(root), + m_type(type), + m_exec(0) +{ +} + +inline Plan_pred::Type +Plan_pred::type() const +{ + return m_type; +} + +inline const Plan_pred::TableSet& +Plan_pred::tableSet() const +{ + return m_tableSet; +} + +inline const Plan_pred::TableSet& +Plan_pred::noInterp() const +{ + return m_noInterp; +} + +/** + * @class Exec_pred + * @brief Base class for predicates in ExecTree + */ +class Exec_pred : public Exec_base { +public: + class Code : public Exec_base::Code { + public: + Code(); + virtual ~Code() = 0; + protected: + friend class Exec_pred; + }; + class Data : public Exec_base::Data { + public: + Data(); + virtual ~Data() = 0; + Pred_value getValue() const; + Pred_value groupValue(unsigned i) const; + protected: + friend class Exec_pred; + Pred_value m_value; // the value + // group-by data + typedef std::vector GroupValue; + GroupValue m_groupValue; + Pred_value& groupValue(unsigned i, bool initFlag); + }; + Exec_pred(Exec_root* root); + virtual ~Exec_pred() = 0; + virtual void execInterp(Ctx& ctx, Ctl& ctl) = 0; + virtual void evaluate(Ctx& ctx, Ctl& ctl) = 0; + // children + const Code& getCode() const; + Data& getData() const; +}; + +inline +Exec_pred::Code::Code() +{ +} + +inline +Exec_pred::Data::Data() : + m_value(Pred_value_unknown) +{ +} + +inline Pred_value +Exec_pred::Data::getValue() const +{ + return m_value; +} + +inline Pred_value +Exec_pred::Data::groupValue(unsigned i) const +{ + ctx_assert(i != 0 && i < m_groupValue.size()); + return m_groupValue[i]; +} + +inline +Exec_pred::Exec_pred(Exec_root* root) : + Exec_base(root) +{ +} + +// children + +inline const Exec_pred::Code& +Exec_pred::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_pred::Data& +Exec_pred::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_pred_op.cpp b/ndb/src/client/odbc/codegen/Code_pred_op.cpp new file mode 100644 index 00000000000..29736e45818 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_pred_op.cpp @@ -0,0 +1,188 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_pred.hpp" +#include "Code_pred_op.hpp" +#include "Code_root.hpp" + +// Pred_op + +const char* +Pred_op::name() const +{ + switch (m_opcode) { + case And: + return "and"; + case Or: + return "or"; + case Not: + return "not"; + } + ctx_assert(false); + return ""; +} + +unsigned +Pred_op::arity() const +{ + switch (m_opcode) { + case And: + case Or: + return 2; + case Not: + return 1; + } + ctx_assert(false); + return 0; +} + +// Plan_pred_op + +Plan_pred_op::~Plan_pred_op() +{ +} + +Plan_base* +Plan_pred_op::analyze(Ctx& ctx, Ctl& ctl) +{ + m_exec = 0; + unsigned arity = m_op.arity(); + // check if we remain in top-level AND-clause + const bool topand = ctl.m_topand; + if (m_op.m_opcode != Pred_op::And) + ctl.m_topand = false; + // analyze sub-predicates + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_pred[i] != 0); + m_pred[i]->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + } + // save top level predicate on list + if (topand && ! ctl.m_topand) { + ctl.m_topcomp.push_back(this); + } + ctl.m_topand = topand; + // table dependencies are union from operands + m_tableSet.clear(); + for (unsigned i = 1; i <= arity; i++) { + const TableSet& ts = m_pred[i]->tableSet(); + m_tableSet.insert(ts.begin(), ts.end()); + } + // set of tables for which interpreter cannot be used + m_noInterp.clear(); + for (unsigned i = 1; i <= arity; i++) { + const TableSet& ts = m_pred[i]->noInterp(); + m_noInterp.insert(ts.begin(), ts.end()); + } + return this; +} + +Exec_base* +Plan_pred_op::codegen(Ctx& ctx, Ctl& ctl) +{ + if (m_exec != 0) + return m_exec; + unsigned arity = m_op.arity(); + Exec_pred_op* exec = new Exec_pred_op(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + // create code for operands + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_pred[i] != 0); + Exec_pred* execPred = static_cast(m_pred[i]->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execPred != 0); + exec->setPred(i, execPred); + } + // create the code + Exec_pred_op::Code& code = *new Exec_pred_op::Code(m_op); + exec->setCode(code); + m_exec = exec; + return exec; +} + +void +Plan_pred_op::print(Ctx& ctx) +{ + ctx.print(" [%s", m_op.name()); + Plan_base* a[] = { m_pred[1], m_pred[2] }; + printList(ctx, a, m_op.arity()); + ctx.print("]"); +} + +bool +Plan_pred_op::isGroupBy(const Plan_expr_row* row) const +{ + const unsigned arity = m_op.arity(); + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_pred[i] != 0); + if (! m_pred[i]->isGroupBy(row)) + return false; + } + return true; +} + +// Code_pred_op + +Exec_pred_op::Code::~Code() +{ +} + +Exec_pred_op::Data::~Data() +{ +} + +Exec_pred_op::~Exec_pred_op() +{ +} + +void +Exec_pred_op::alloc(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + // allocate sub-predicates + unsigned arity = code.m_op.arity(); + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_pred[i] != 0); + m_pred[i]->alloc(ctx, ctl); + if (! ctx.ok()) + return; + } + Data& data = *new Data; + setData(data); +} + +void +Exec_pred_op::close(Ctx& ctx) +{ + const Code& code = getCode(); + unsigned arity = code.m_op.arity(); + for (unsigned i = 1; i <= arity; i++) { + ctx_assert(m_pred[i] != 0); + m_pred[i]->close(ctx); + } +} + +void +Exec_pred_op::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx.print(" [%s", code.m_op.name()); + Exec_base* a[] = { m_pred[1], m_pred[2] }; + printList(ctx, a, code.m_op.arity()); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_pred_op.hpp b/ndb/src/client/odbc/codegen/Code_pred_op.hpp new file mode 100644 index 00000000000..9130bc3cb81 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_pred_op.hpp @@ -0,0 +1,158 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_pred_op_hpp +#define ODBC_CODEGEN_Code_pred_op_hpp + +#include +#include +#include "Code_pred.hpp" + +/** + * @class Pred_op + * @brief Boolean operators + */ +struct Pred_op { + enum Opcode { + And = 1, // binary + Or, + Not // unary + }; + Pred_op(Opcode opcode); + const char* name() const; + unsigned arity() const; + Opcode m_opcode; +}; + +inline +Pred_op::Pred_op(Opcode opcode) : + m_opcode(opcode) +{ +} + +/** + * @class Plan_pred_op + * @brief Operator node in a predicate in PlanTree + */ +class Plan_pred_op : public Plan_pred { +public: + Plan_pred_op(Plan_root* root, Pred_op op); + virtual ~Plan_pred_op(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + bool isGroupBy(const Plan_expr_row* row) const; + // children + void setPred(unsigned i, Plan_pred* pred); +protected: + friend class Plan_pred; + Pred_op m_op; + Plan_pred* m_pred[1 + 2]; +}; + +inline +Plan_pred_op::Plan_pred_op(Plan_root* root, Pred_op op) : + Plan_pred(root, TypeOp), + m_op(op) +{ + m_pred[0] = m_pred[1] = m_pred[2] = 0; +} + +inline void +Plan_pred_op::setPred(unsigned i, Plan_pred* pred) +{ + ctx_assert(1 <= i && i <= m_op.arity() && pred != 0); + m_pred[i] = pred; +} + +/** + * @class Exec_pred_op + * @brief Operator node in a predicate in ExecTree + */ +class Exec_pred_op : public Exec_pred { +public: + class Code : public Exec_pred::Code { + public: + Code(Pred_op op); + virtual ~Code(); + protected: + friend class Exec_pred_op; + Pred_op m_op; + }; + class Data : public Exec_pred::Data { + public: + Data(); + virtual ~Data(); + protected: + friend class Exec_pred_op; + }; + Exec_pred_op(Exec_root* root); + virtual ~Exec_pred_op(); + void alloc(Ctx& ctx, Ctl& ctl); + void execInterp(Ctx& ctx, Ctl& ctl); + void evaluate(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setPred(unsigned i, Exec_pred* pred); +protected: + Exec_pred* m_pred[1 + 2]; +}; + +inline +Exec_pred_op::Code::Code(Pred_op op) : + m_op(op) +{ +} + +inline +Exec_pred_op::Data::Data() +{ +} + +inline +Exec_pred_op::Exec_pred_op(Exec_root* root) : + Exec_pred(root) +{ + m_pred[0] = m_pred[1] = m_pred[2] = 0; +} + +// children + +inline const Exec_pred_op::Code& +Exec_pred_op::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_pred_op::Data& +Exec_pred_op::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_pred_op::setPred(unsigned i, Exec_pred* pred) +{ + ctx_assert(1 <= i && i <= 2 && m_pred[i] == 0); + m_pred[i] = pred; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_query.cpp b/ndb/src/client/odbc/codegen/Code_query.cpp new file mode 100644 index 00000000000..9e983942601 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query.cpp @@ -0,0 +1,299 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Code_query.hpp" +#include "Code_query_project.hpp" +#include "Code_query_count.hpp" + +// Plan_query + +Plan_query::~Plan_query() +{ +} + +Plan_expr_row* +Plan_query::getRow() +{ + ctx_assert(false); + return 0; +} + +void +Plan_query::describe(Ctx& ctx) +{ + const Plan_expr_row* exprRow = getRow(); + const unsigned count = exprRow->getSize(); + // create IRD + DescArea& ird = descArea(Desc_usage_IRD); + ird.setCount(ctx, count); + for (unsigned i = 1; i <= count; i++) { + DescRec& rec = ird.getRecord(i); + const Plan_expr* expr = exprRow->m_exprList[i]; + const SqlType& sqlType = expr->sqlType(); + // data type + SQLSMALLINT desc_TYPE = sqlType.type(); + rec.setField(SQL_DESC_TYPE, desc_TYPE); + SQLSMALLINT desc_CONCISE_TYPE = desc_TYPE; + rec.setField(SQL_DESC_CONCISE_TYPE, desc_CONCISE_TYPE); + SQLSMALLINT desc_DESC_DATETIME_INTERVAL_CODE = 0; + rec.setField(SQL_DESC_DATETIME_INTERVAL_CODE, desc_DESC_DATETIME_INTERVAL_CODE); + // nullable + SQLSMALLINT desc_NULLABLE = sqlType.nullable() ? SQL_NULLABLE : SQL_NO_NULLS; + rec.setField(SQL_DESC_NULLABLE, desc_NULLABLE); + // unsigned + SQLSMALLINT desc_UNSIGNED; + switch (sqlType.type()) { + case SQL_SMALLINT: + case SQL_INTEGER: + case SQL_BIGINT: + desc_UNSIGNED = sqlType.unSigned() ? SQL_TRUE : SQL_FALSE; + break; + default: + desc_UNSIGNED = SQL_TRUE; // thus spake microsoft + break; + } + rec.setField(SQL_DESC_UNSIGNED, desc_UNSIGNED); + // sizes + SQLUINTEGER desc_LENGTH = sqlType.length(); + rec.setField(SQL_DESC_LENGTH, desc_LENGTH); + SQLINTEGER desc_OCTET_LENGTH = sqlType.size(); + rec.setField(SQL_DESC_OCTET_LENGTH, desc_OCTET_LENGTH); + SQLINTEGER desc_DISPLAY_SIZE = sqlType.displaySize(); + rec.setField(SQL_DESC_DISPLAY_SIZE, desc_DISPLAY_SIZE); + // name + ctx_assert(i < exprRow->m_aliasList.size()); + const char* desc_NAME = exprRow->m_aliasList[i].c_str(); + rec.setField(SQL_DESC_NAME, desc_NAME); + } + ctx_log3(("describe %u columns done", count)); + stmtArea().setFunction(ctx, "SELECT CURSOR", SQL_DIAG_SELECT_CURSOR); +} + +// Exec_query + +Exec_query::Code::~Code() +{ +} + +Exec_query::Data::~Data() +{ + delete m_extRow; + m_extRow = 0; + delete[] m_extPos; + m_extPos = 0; +} + +Exec_query::~Exec_query() +{ +} + +const Exec_query* +Exec_query::getRawQuery() const +{ + ctx_assert(false); + return 0; +} + +void +Exec_query::bind(Ctx& ctx) +{ + const Code& code = getCode(); + const SqlSpecs& sqlSpecs = code.sqlSpecs(); + const unsigned count = sqlSpecs.count(); + // read ARD + DescArea& ard = descArea(Desc_usage_ARD); + const unsigned ardCount = ard.getCount(); + // create specification row + ExtSpecs extSpecs(count); + for (unsigned i = 1; i <= count; i++) { + ExtType extType; + if (i <= ardCount) { + OdbcData descData; + DescRec& rec = ard.getRecord(i); + // check for unbound column + rec.getField(ctx, SQL_DESC_DATA_PTR, descData); + SQLPOINTER desc_DATA_PTR = descData.type() != OdbcData::Undef ? descData.pointer() : 0; + if (desc_DATA_PTR == 0) { + extType.setType(ctx, ExtType::Unbound); + } else { + rec.getField(ctx, SQL_DESC_TYPE, descData); + if (descData.type() == OdbcData::Undef) { + ctx.pushStatus(Error::Gen, "query column %u: external type not defined", i); + return; + } + SQLSMALLINT desc_TYPE = descData.smallint(); + if (desc_TYPE == SQL_C_DEFAULT) { + if (i <= code.m_sqlSpecs.count()) + desc_TYPE = code.m_sqlSpecs.getEntry(i).sqlType().sqlcdefault(ctx); + } + switch (desc_TYPE) { + case SQL_C_CHAR: + case SQL_C_BINARY: + case SQL_C_SHORT: // for sun.jdbc.odbc + case SQL_C_SSHORT: + case SQL_C_USHORT: + case SQL_C_LONG: // for sun.jdbc.odbc + case SQL_C_SLONG: + case SQL_C_ULONG: + case SQL_C_SBIGINT: + case SQL_C_UBIGINT: + case SQL_C_FLOAT: + case SQL_C_DOUBLE: + case SQL_C_TYPE_TIMESTAMP: + break; + default: + ctx.pushStatus(Error::Gen, "query column %u: unsupported external type %d", i, (int)desc_TYPE); + return; + } + extType.setType(ctx, static_cast(desc_TYPE)); + } + } else { + extType.setType(ctx, ExtType::Unbound); + } + const ExtSpec extSpec(extType); + extSpecs.setEntry(i, extSpec); + } + // create data row + ExtRow& extRow = *new ExtRow(extSpecs); + unsigned boundCount = 0; + for (unsigned i = 1; i <= count; i++) { + const ExtSpec& extSpec = extSpecs.getEntry(i); + if (extSpec.extType().type() != ExtType::Unbound) { + OdbcData descData; + DescRec& rec = ard.getRecord(i); + rec.getField(ctx, SQL_DESC_DATA_PTR, descData); + SQLPOINTER desc_DATA_PTR = descData.type() != OdbcData::Undef ? descData.pointer() : 0; + rec.getField(ctx, SQL_DESC_OCTET_LENGTH, descData); + SQLINTEGER desc_OCTET_LENGTH = descData.type() != OdbcData::Undef ? descData.integer() : 0; + rec.getField(ctx, SQL_DESC_INDICATOR_PTR, descData); + SQLINTEGER* desc_INDICATOR_PTR = descData.type() != OdbcData::Undef ? descData.integerPtr() : 0; + ctx_log4(("column %u: bind to 0x%x %d 0x%x", i, (unsigned)desc_DATA_PTR, (int)desc_OCTET_LENGTH, (unsigned)desc_INDICATOR_PTR)); + ExtField extField(extSpec, desc_DATA_PTR, desc_OCTET_LENGTH, desc_INDICATOR_PTR, i); + extRow.setEntry(i, extField); + boundCount++; + } else { + ExtField extField(extSpec, i); + extRow.setEntry(i, extField); + } + } + Data& data = getData(); + delete data.m_extRow; + data.m_extRow = &extRow; + ctx_log3(("bound %u out of %u columns", boundCount, count)); +} + +// execute and fetch + +void +Exec_query::execute(Ctx& ctx, Ctl& ctl) +{ + Data& data = getData(); + execImpl(ctx, ctl); + if (! ctx.ok()) + return; + data.initState(); + if (m_topLevel) { + stmtArea().setRowCount(ctx, data.getCount()); + } +} + +bool +Exec_query::fetch(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + if (data.fetch(ctx, ctl)) { + if (m_topLevel) { + stmtArea().setRowCount(ctx, data.getCount()); + } + if (data.m_extRow != 0) { + data.sqlRow().copyout(ctx, *data.m_extRow); + if (! ctx.ok()) + return false; + } + if (data.m_extPos != 0) { + const unsigned count = code.sqlSpecs().count(); + for (unsigned i = 0; i <= count; i++) { + data.m_extPos[i] = 0; + } + } + return true; + } + if (m_topLevel) { + stmtArea().setRowCount(ctx, data.getCount()); + if (ctx.ok()) { + ctx.setCode(SQL_NO_DATA); + } + } + return false; +} + +// odbc support + +void +Exec_query::sqlGetData(Ctx& ctx, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, SQLPOINTER targetValue, SQLINTEGER bufferLength, SQLINTEGER* strlen_or_Ind) +{ + const Code& code = getCode(); + Data& data = getData(); + const SqlSpecs& sqlSpecs = code.m_sqlSpecs; + const unsigned count = sqlSpecs.count(); + if (columnNumber == 0 || columnNumber > count) { + ctx.pushStatus(Sqlstate::_07009, Error::Gen, "column index %u is not within 1 to %u", (unsigned)columnNumber, count); + return; + } + // create positions array on first use + if (data.m_extPos == 0) { + data.m_extPos = new int[1 + count]; + for (unsigned i = 0; i <= count; i++) { + data.m_extPos[i] = 0; + } + } + if (targetType == SQL_ARD_TYPE) { + // get type from ARD + DescArea& ard = descArea(Desc_usage_ARD); + const unsigned ardCount = ard.getCount(); + if (columnNumber <= ardCount) { + OdbcData descData; + DescRec& rec = ard.getRecord(columnNumber); + rec.getField(ctx, SQL_DESC_CONCISE_TYPE, descData); + if (descData.type() != OdbcData::Undef) { + targetType = descData.smallint(); + } + } + if (targetType == SQL_ARD_TYPE) { + ctx.pushStatus(Sqlstate::_07009, Error::Gen, "output column %u type not bound - cannot use SQL_ARD_TYPE", (unsigned)columnNumber); + return; + } + } + ExtType extType; + if (targetValue != 0) { + extType.setType(ctx, static_cast(targetType)); + // check if supported + if (! ctx.ok()) + return; + } else { + extType.setType(ctx, ExtType::Unbound); + } + ExtSpec extSpec(extType); + ExtField extField(extSpec, targetValue, bufferLength, strlen_or_Ind, columnNumber); + // copy out and update position + extField.setPos(data.m_extPos[columnNumber]); + const SqlRow& sqlRow = data.sqlRow(); + const SqlField& sqlField = sqlRow.getEntry(columnNumber); + sqlField.copyout(ctx, extField); + data.m_extPos[columnNumber] = extField.getPos(); +} diff --git a/ndb/src/client/odbc/codegen/Code_query.hpp b/ndb/src/client/odbc/codegen/Code_query.hpp new file mode 100644 index 00000000000..97f98f859ff --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query.hpp @@ -0,0 +1,155 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_query_hpp +#define ODBC_CODEGEN_Code_query_hpp + +#include +#include +#include +#include "Code_stmt.hpp" + +class Plan_expr_row; +class Plan_table; +class Exec_expr_row; + +/** + * @class Plan_query + * @brief Base class for queries in PlanTree + */ +class Plan_query : public Plan_stmt { +public: + Plan_query(Plan_root* root); + virtual ~Plan_query() = 0; + void describe(Ctx& ctx); + virtual Plan_expr_row* getRow(); +}; + +inline +Plan_query::Plan_query(Plan_root* root) : + Plan_stmt(root) +{ +} + +/** + * @class Exec_query + * @brief Base class for executable queries. + * + * Executable queriable statement. + */ +class Exec_query : public Exec_stmt { +public: + class Code : public Exec_stmt::Code { + public: + Code(const SqlSpecs& sqlSpecs); + virtual ~Code() = 0; + const SqlSpecs& sqlSpecs() const; + protected: + friend class Exec_query; + const SqlSpecs& m_sqlSpecs; // subclass must contain + }; + class Data : public Exec_stmt::Data, public ResultSet { + public: + Data(Exec_query* node, const SqlRow& sqlRow); + virtual ~Data() = 0; + const SqlRow& sqlRow() const; + ExtRow* extRow() const; + bool fetchImpl(Ctx& ctx, Ctl& ctl); + protected: + friend class Exec_query; + Exec_query* const m_node; + ExtRow* m_extRow; // output bindings + int* m_extPos; // positions for SQLGetData + }; + Exec_query(Exec_root* root); + virtual ~Exec_query() = 0; + void bind(Ctx& ctx); + void execute(Ctx& ctx, Ctl& ctl); + bool fetch(Ctx& ctx, Ctl& ctl); + // children + const Code& getCode() const; + Data& getData() const; + virtual const Exec_query* getRawQuery() const; + // odbc support + void sqlGetData(Ctx& ctx, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, SQLPOINTER targetValue, SQLINTEGER bufferLength, SQLINTEGER* strlen_or_Ind); +protected: + friend class Data; + virtual void execImpl(Ctx& ctx, Ctl& ctl) = 0; + virtual bool fetchImpl(Ctx& ctx, Ctl& ctl) = 0; +}; + +inline +Exec_query::Code::Code(const SqlSpecs& sqlSpecs) : + m_sqlSpecs(sqlSpecs) +{ +} + +inline const SqlSpecs& +Exec_query::Code::sqlSpecs() const +{ + return m_sqlSpecs; +} + +inline +Exec_query::Data::Data(Exec_query* node, const SqlRow& sqlRow) : + ResultSet(sqlRow), + m_node(node), + m_extRow(0), + m_extPos(0) +{ +} + +inline const SqlRow& +Exec_query::Data::sqlRow() const +{ + return static_cast(m_dataRow); +} + +inline ExtRow* +Exec_query::Data::extRow() const +{ + return m_extRow; +} + +inline bool +Exec_query::Data::fetchImpl(Ctx& ctx, Ctl& ctl) +{ + return m_node->fetchImpl(ctx, ctl); +} + +inline +Exec_query::Exec_query(Exec_root* root) : + Exec_stmt(root) +{ +} + +// children + +inline const Exec_query::Code& +Exec_query::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_query::Data& +Exec_query::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_query_count.cpp b/ndb/src/client/odbc/codegen/Code_query_count.cpp new file mode 100644 index 00000000000..f52c41df802 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_count.cpp @@ -0,0 +1,177 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "Code_query_count.hpp" +#include "Code_column.hpp" +#include "Code_expr_row.hpp" +#include "Code_root.hpp" + +// Plan_query_count + +Plan_query_count::~Plan_query_count() +{ +} + +Plan_expr_row* +Plan_query_count::getRow() +{ + ctx_assert(m_exprRow != 0); + return m_exprRow; +} + +Plan_base* +Plan_query_count::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_exprRow != 0); + ctl.m_aggrok = true; + ctl.m_aggrin = false; + m_exprRow->analyze(ctx, ctl); + ctl.m_aggrok = false; + if (! ctx.ok()) + return 0; + ctx_assert(m_query != 0); + m_query->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +Exec_base* +Plan_query_count::codegen(Ctx& ctx, Ctl& ctl) +{ + // create code for the subquery + ctx_assert(m_query != 0); + Exec_query* execQuery = static_cast(m_query->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execQuery != 0); + // create code for the row based on query code + ctx_assert(m_exprRow != 0); + ctl.m_execQuery = execQuery; + Exec_expr_row* execRow = static_cast(m_exprRow->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execRow != 0); + Exec_query_count* exec = new Exec_query_count(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + // re-use SqlSpecs from the row + const SqlSpecs& sqlSpecs = execRow->getCode().sqlSpecs(); + Exec_query_count::Code& code = *new Exec_query_count::Code(sqlSpecs); + exec->setCode(code); + exec->setQuery(execQuery); + exec->setRow(execRow); + return exec; +} + +void +Plan_query_count::print(Ctx& ctx) +{ + ctx.print(" [query_count"); + Plan_base* a[] = { m_query, m_exprRow }; + printList(ctx, a, sizeof(a)/sizeof(a[0])); + ctx.print("]"); +} + +// Exec_query_count + +Exec_query_count::Code::~Code() +{ +} + +Exec_query_count::Data::~Data() +{ +} + +Exec_query_count::~Exec_query_count() +{ +} + +const Exec_query* +Exec_query_count::getRawQuery() const +{ + ctx_assert(m_query != 0); + return m_query; +} + +void +Exec_query_count::alloc(Ctx& ctx, Ctl& ctl) +{ + // allocate the subquery + ctx_assert(m_query != 0); + m_query->alloc(ctx, ctl); + // allocate the row based on subquery data + ctx_assert(m_exprRow != 0); + ctl.m_query = m_query; + m_exprRow->alloc(ctx, ctl); + if (! ctx.ok()) + return; + // re-use SqlRow from the expression row + const SqlRow& sqlRow = m_exprRow->getData().sqlRow(); + Data& data = *new Data(this, sqlRow); + setData(data); +} + +void +Exec_query_count::execImpl(Ctx& ctx, Ctl& ctl) +{ + Data& data = getData(); + // zero counters + ctx_assert(m_exprRow != 0); + m_exprRow->close(ctx); + data.m_done = false; + // execute the subquery + ctx_assert(m_query != 0); + m_query->execute(ctx, ctl); +} + +bool +Exec_query_count::fetchImpl(Ctx& ctx, Ctl& ctl) +{ + Data& data = getData(); + // returns one row only + if (data.m_done) + return false; + ctx_assert(m_query != 0 && m_exprRow != 0); + while (m_query->fetch(ctx, ctl)) { + // accumulate values + m_exprRow->evaluate(ctx, ctl); + if (! ctx.ok()) + return false; + } + data.m_done = true; + return true; +} + +void +Exec_query_count::close(Ctx& ctx) +{ + ctx_assert(m_query != 0); + m_query->close(ctx); + ctx_assert(m_exprRow != 0); + m_exprRow->close(ctx); +} + +void +Exec_query_count::print(Ctx& ctx) +{ + ctx.print(" [query_count"); + Exec_base* a[] = { m_query }; + printList(ctx, a, 1); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_query_count.hpp b/ndb/src/client/odbc/codegen/Code_query_count.hpp new file mode 100644 index 00000000000..a094eba4519 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_count.hpp @@ -0,0 +1,162 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_query_count_hpp +#define ODBC_CODEGEN_Code_query_count_hpp + +#include +#include "Code_query.hpp" +#include "Code_expr_row.hpp" +#include "Code_root.hpp" + +class Ctx; + +/** + * @class Plan_query_count + * @brief Select count and other aggregates (no group by) + */ +class Plan_query_count : public Plan_query { +public: + Plan_query_count(Plan_root* root); + virtual ~Plan_query_count(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setQuery(Plan_query* query); + void setRow(Plan_expr_row* exprRow); +protected: + Plan_expr_row* getRow(); + Plan_query* m_query; + Plan_expr_row* m_exprRow; +}; + +inline +Plan_query_count::Plan_query_count(Plan_root* root) : + Plan_query(root), + m_query(0), + m_exprRow(0) +{ +} + +// children + +inline void +Plan_query_count::setQuery(Plan_query* query) +{ + ctx_assert(query != 0); + m_query = query; +} + +inline void +Plan_query_count::setRow(Plan_expr_row* exprRow) +{ + ctx_assert(exprRow != 0); + m_exprRow = exprRow; +} + +/** + * @class Exec_query_count + * @brief Select count and other aggregates (no group by) + */ +class Exec_query_count : public Exec_query { +public: + class Code : public Exec_query::Code { + public: + Code(const SqlSpecs& sqlSpecs); + virtual ~Code(); + protected: + friend class Exec_query_count; + // sets reference to Sqlspecs from the row + }; + class Data : public Exec_query::Data { + public: + Data(Exec_query_count* node, const SqlRow& sqlRow); + virtual ~Data(); + protected: + friend class Exec_query_count; + // sets reference to SqlRow from the row + bool m_done; // returns one row + }; + Exec_query_count(Exec_root* root); + virtual ~Exec_query_count(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + bool fetchImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setQuery(Exec_query* query); + void setRow(Exec_expr_row* exprRow); + const Exec_query* getRawQuery() const; +protected: + Exec_query* m_query; + Exec_expr_row* m_exprRow; +}; + +inline +Exec_query_count::Code::Code(const SqlSpecs& sqlSpecs) : + Exec_query::Code(sqlSpecs) +{ +} + +inline +Exec_query_count::Data::Data(Exec_query_count* node, const SqlRow& sqlRow) : + Exec_query::Data(node, sqlRow) +{ +} + +inline +Exec_query_count::Exec_query_count(Exec_root* root) : + Exec_query(root), + m_query(0), + m_exprRow(0) +{ +} + +// children + +inline const Exec_query_count::Code& +Exec_query_count::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_query_count::Data& +Exec_query_count::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_query_count::setQuery(Exec_query* query) +{ + ctx_assert(query != 0); + m_query = query; +} + +inline void +Exec_query_count::setRow(Exec_expr_row* exprRow) +{ + ctx_assert(m_exprRow == 0 && exprRow != 0); + m_exprRow = exprRow; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_query_distinct.cpp b/ndb/src/client/odbc/codegen/Code_query_distinct.cpp new file mode 100644 index 00000000000..4cbfbfe812d --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_distinct.cpp @@ -0,0 +1,204 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Code_query_distinct.hpp" +#include "Code_root.hpp" + +// Plan_query_distinct + +Plan_query_distinct::~Plan_query_distinct() +{ +} + +Plan_expr_row* +Plan_query_distinct::getRow() +{ + ctx_assert(m_query != 0); + return m_query->getRow(); +} + +Plan_base* +Plan_query_distinct::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_query != 0); + m_query->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +Exec_base* +Plan_query_distinct::codegen(Ctx& ctx, Ctl& ctl) +{ + // create code for the subquery + ctx_assert(m_query != 0); + Exec_query* execQuery = static_cast(m_query->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execQuery != 0); + // the exec node + Exec_query_distinct* exec = new Exec_query_distinct(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + // re-use SqlSpecs from subquery + const Exec_query::Code& codeQuery = execQuery->getCode(); + const SqlSpecs& sqlSpecs = codeQuery.sqlSpecs(); + Exec_query_distinct::Code& code = *new Exec_query_distinct::Code(sqlSpecs); + exec->setCode(code); + exec->setQuery(execQuery); + return exec; +} + +void +Plan_query_distinct::print(Ctx& ctx) +{ + ctx.print(" [query_distinct"); + Plan_base* a[] = { m_query }; + printList(ctx, a, 1); + ctx.print("]"); +} + +// Exec_query_distinct + +Exec_query_distinct::Code::~Code() +{ +} + +Exec_query_distinct::Data::~Data() +{ + for (DistinctList::iterator i = m_groupList.begin(); i != m_groupList.end(); i++) { + delete (*i).first; + } +} + +Exec_query_distinct::~Exec_query_distinct() +{ +} + +const Exec_query* +Exec_query_distinct::getRawQuery() const +{ + ctx_assert(m_query != 0); + return m_query->getRawQuery(); +} + +void +Exec_query_distinct::alloc(Ctx& ctx, Ctl& ctl) +{ + // allocate subquery + ctx_assert(m_query != 0); + m_query->alloc(ctx, ctl); + if (! ctx.ok()) + return; + Data& data = *new Data(this, getCode().sqlSpecs()); + setData(data); +} + +void +Exec_query_distinct::execImpl(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_query != 0); + m_query->execute(ctx, ctl); +} + +bool +DistinctLess::operator()(const SqlRow* s1, const SqlRow* s2) const +{ + ctx_assert(s1 != 0 && s2 != 0); + const SqlRow& r1 = *s1; + const SqlRow& r2 = *s2; + for (unsigned i = 1; i <= r1.count(); i++) { + const SqlField& f1 = r1.getEntry(i); + const SqlField& f2 = r2.getEntry(i); + // nulls last is default in oracle + const bool f1null = f1.sqlNull(); + const bool f2null = f2.sqlNull(); + if (f1null && f2null) + continue; + if (! f1null && f2null) + return true; + if (f1null && ! f2null) + return false; + if (f1.less(f2)) + return true; + if (f2.less(f1)) + return false; + } + return false; +} + +bool +Exec_query_distinct::fetchImpl(Ctx& ctx, Ctl& ctl) +{ + Data& data = getData(); + ctx_assert(m_query != 0); + if (! data.m_grouped) { + // read and group all rows + while (m_query->fetch(ctx, ctl)) { + const SqlRow* dataRow = &m_query->getData().sqlRow(); + DistinctList::iterator i = data.m_groupList.find(dataRow); + if (i != data.m_groupList.end()) + continue; + unsigned index = data.m_count++; + dataRow = dataRow->copy(); + const DistinctList::value_type groupPair(dataRow, index); + data.m_groupList.insert(groupPair); + data.m_groupVector.push_back(dataRow); + } + if (! ctx.ok()) + return false; + data.m_index = 0; + data.m_grouped = true; + } + ctx_assert(data.m_count == data.m_groupVector.size()); + if (data.m_index < data.m_count) { + const SqlRow* currRow = data.m_groupVector[data.m_index]; + // make our SqlRow reference to it + for (unsigned i = 1; i <= data.m_sqlRow.count(); i++) { + const SqlField& currField = currRow->getEntry(i); + SqlSpec sqlSpec(currField.sqlSpec(), SqlSpec::Reference); + SqlField sqlField(sqlSpec, &currField); + data.m_sqlRow.setEntry(i, sqlField); + } + data.m_index++; + return true; + } + return false; +} + +void +Exec_query_distinct::close(Ctx& ctx) +{ + Data& data = getData(); + ctx_assert(m_query != 0); + m_query->close(ctx); + data.m_grouped = false; + data.m_count = 0; + for (DistinctList::iterator i = data.m_groupList.begin(); i != data.m_groupList.end(); i++) { + delete (*i).first; + } + data.m_groupList.clear(); + data.m_groupVector.clear(); +} + +void +Exec_query_distinct::print(Ctx& ctx) +{ + ctx.print(" [query_distinct"); + Exec_base* a[] = { m_query }; + printList(ctx, a, 1); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_query_distinct.hpp b/ndb/src/client/odbc/codegen/Code_query_distinct.hpp new file mode 100644 index 00000000000..62c46bda901 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_distinct.hpp @@ -0,0 +1,165 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_query_distinct_hpp +#define ODBC_CODEGEN_Code_query_distinct_hpp + +#include +#include +#include "Code_query.hpp" +#include "Code_expr_row.hpp" +#include "Code_pred.hpp" + +/** + * @class Plan_query_distinct + * @brief Group-by node in PlanTree + */ +class Plan_query_distinct : public Plan_query { +public: + Plan_query_distinct(Plan_root* root); + virtual ~Plan_query_distinct(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setQuery(Plan_query* query); + Plan_expr_row* getRow(); +protected: + Plan_query* m_query; +}; + +inline +Plan_query_distinct::Plan_query_distinct(Plan_root* root) : + Plan_query(root), + m_query(0) +{ +} + +// children + +inline void +Plan_query_distinct::setQuery(Plan_query* query) +{ + ctx_assert(query != 0); + m_query = query; +} + +/** + * Distinct preserves order of input rows so we use 2 data structures: + * map = index and vector = row (index >= 0). + */ + +class Exec_query_distinct; + +struct DistinctLess : std::binary_function { + bool operator()(const SqlRow* s1, const SqlRow* s2) const; +}; + +typedef std::map DistinctList; + +typedef std::vector DistinctVector; + +/** + * @class Exec_query_distinct + * @brief Group-by node in ExecTree + */ +class Exec_query_distinct : public Exec_query { +public: + class Code : public Exec_query::Code { + public: + Code(const SqlSpecs& sqlSpecs); + virtual ~Code(); + protected: + friend class Exec_query_distinct; + // sets reference to Sqlspecs from subquery + }; + class Data : public Exec_query::Data { + public: + Data(Exec_query_distinct* node, const SqlSpecs& sqlSpecs); + virtual ~Data(); + protected: + friend class Exec_query_distinct; + SqlRow m_sqlRow; // current row + bool m_grouped; // fetch and group-by done + unsigned m_count; + DistinctList m_groupList; + DistinctVector m_groupVector; + unsigned m_index; + }; + Exec_query_distinct(Exec_root* root); + virtual ~Exec_query_distinct(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + bool fetchImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setQuery(Exec_query* query); + const Exec_query* getRawQuery() const; +protected: + friend class Exec_query; + Exec_query* m_query; +}; + +inline +Exec_query_distinct::Code::Code(const SqlSpecs& sqlSpecs) : + Exec_query::Code(sqlSpecs) +{ +} + +inline +Exec_query_distinct::Data::Data(Exec_query_distinct* node, const SqlSpecs& sqlSpecs) : + Exec_query::Data(node, m_sqlRow), + m_sqlRow(sqlSpecs), + m_grouped(false), + m_count(0), + m_index(0) +{ +} + +inline +Exec_query_distinct::Exec_query_distinct(Exec_root* root) : + Exec_query(root), + m_query(0) +{ +} + +// children + +inline const Exec_query_distinct::Code& +Exec_query_distinct::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_query_distinct::Data& +Exec_query_distinct::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_query_distinct::setQuery(Exec_query* query) +{ + ctx_assert(m_query == 0 && query != 0); + m_query = query; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_query_filter.cpp b/ndb/src/client/odbc/codegen/Code_query_filter.cpp new file mode 100644 index 00000000000..934a24d182d --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_filter.cpp @@ -0,0 +1,161 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_query_filter.hpp" +#include "Code_query_join.hpp" +#include "Code_query_scan.hpp" +#include "Code_root.hpp" + +// Plan_query_filter + +Plan_query_filter::~Plan_query_filter() +{ +} + +Plan_base* +Plan_query_filter::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_query != 0); + m_query->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + ctx_assert(m_pred != 0); + m_pred->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +Exec_base* +Plan_query_filter::codegen(Ctx& ctx, Ctl& ctl) +{ + // generate code for the subquery + ctx_assert(m_query != 0); + Exec_query* execQuery = static_cast(m_query->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execQuery != 0); + // create code for the predicate based on query code + Exec_pred* execPred = 0; + ctl.m_execQuery = execQuery; + ctx_assert(m_topTable != 0); + ctl.m_topTable = m_topTable; + ctx_assert(m_pred != 0); + execPred = static_cast(m_pred->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execPred != 0); + ctl.m_topTable = 0; + // re-use SqlSpecs from subquery + const Exec_query::Code& codeQuery = execQuery->getCode(); + const SqlSpecs& sqlSpecs = codeQuery.sqlSpecs(); + Exec_query_filter* exec = new Exec_query_filter(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + Exec_query_filter::Code& code = *new Exec_query_filter::Code(sqlSpecs); + exec->setCode(code); + exec->setQuery(execQuery); + exec->setPred(execPred); + return exec; +} + +void +Plan_query_filter::print(Ctx& ctx) +{ + ctx.print(" [query_filter"); + Plan_base* a[] = { m_query, m_pred }; + printList(ctx, a, 2); + ctx.print("]"); +} + +// Exec_query_filter + +Exec_query_filter::Code::~Code() +{ +} + +Exec_query_filter::Data::~Data() +{ +} + +Exec_query_filter::~Exec_query_filter() +{ +} + +void +Exec_query_filter::alloc(Ctx& ctx, Ctl& ctl) +{ + // allocate the subquery + ctx_assert(m_query != 0); + m_query->alloc(ctx, ctl); + if (! ctx.ok()) + return; + // allocate the predicate + ctl.m_query = m_query; + ctx_assert(m_pred != 0); + m_pred->alloc(ctx, ctl); + if (! ctx.ok()) + return; + // re-use SqlRow from subquery + Exec_query::Data& dataQuery = m_query->getData(); + Data& data = *new Data(this, dataQuery.sqlRow()); + setData(data); +} + +void +Exec_query_filter::execImpl(Ctx& ctx, Ctl& ctl) +{ + // execute subquery + ctx_assert(m_query != 0); + m_query->execute(ctx, ctl); +} + +bool +Exec_query_filter::fetchImpl(Ctx& ctx, Ctl& ctl) +{ + // invoke fetch on subquery until predicate is true + ctx_assert(m_query != 0); + while (m_query->fetch(ctx, ctl)) { + ctx_assert(m_pred != 0); + m_pred->evaluate(ctx, ctl); + if (! ctx.ok()) + return false; + if (m_pred->getData().getValue() == Pred_value_true) { + ctl.m_postEval = true; + m_pred->evaluate(ctx, ctl); + ctl.m_postEval = false; + return true; + } + } + return false; +} + +void +Exec_query_filter::close(Ctx& ctx) +{ + ctx_assert(m_query != 0); + m_query->close(ctx); + ctx_assert(m_pred != 0); + m_pred->close(ctx); +} + +void +Exec_query_filter::print(Ctx& ctx) +{ + ctx.print(" [query_filter"); + Exec_base* a[] = { m_query, m_pred }; + printList(ctx, a, 2); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_query_filter.hpp b/ndb/src/client/odbc/codegen/Code_query_filter.hpp new file mode 100644 index 00000000000..60cbf0f86a7 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_filter.hpp @@ -0,0 +1,162 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_query_filter_hpp +#define ODBC_CODEGEN_Code_query_filter_hpp + +#include +#include "Code_query.hpp" +#include "Code_table_list.hpp" +#include "Code_pred.hpp" + +/** + * @class Plan_query_filter + * @brief Filter node in PlanTree + */ +class Plan_query_filter : public Plan_query { +public: + Plan_query_filter(Plan_root* root); + virtual ~Plan_query_filter(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setQuery(Plan_query* query); + void setPred(Plan_pred* pred); +protected: + friend class Plan_select; + friend class Plan_update; + friend class Plan_delete; + Plan_query* m_query; + Plan_pred* m_pred; + Plan_table* m_topTable; // top level table for interpreted progs +}; + +inline +Plan_query_filter::Plan_query_filter(Plan_root* root) : + Plan_query(root), + m_query(0), + m_pred(0), + m_topTable(0) +{ +} + +// children + +inline void +Plan_query_filter::setQuery(Plan_query* query) +{ + ctx_assert(query != 0); + m_query = query; +} + +inline void +Plan_query_filter::setPred(Plan_pred* pred) +{ + ctx_assert(pred != 0); + m_pred = pred; +} + +/** + * @class Exec_query_filter + * @brief Filter node in ExecTree + */ +class Exec_query_filter : public Exec_query { +public: + class Code : public Exec_query::Code { + public: + Code(const SqlSpecs& sqlSpecs); + virtual ~Code(); + protected: + friend class Exec_query_filter; + // sets reference to SqlSpecs from subquery + }; + class Data : public Exec_query::Data { + public: + Data(Exec_query_filter* node, const SqlRow& sqlRow); + virtual ~Data(); + protected: + friend class Exec_query_filter; + // sets reference to SqlRow from subquery + }; + Exec_query_filter(Exec_root* root); + virtual ~Exec_query_filter(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + bool fetchImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setQuery(Exec_query* query); + void setPred(Exec_pred* pred); +protected: + Exec_query* m_query; + Exec_pred* m_pred; +}; + +inline +Exec_query_filter::Code::Code(const SqlSpecs& sqlSpecs) : + Exec_query::Code(sqlSpecs) +{ +} + +inline +Exec_query_filter::Data::Data(Exec_query_filter* node, const SqlRow& sqlRow) : + Exec_query::Data(node, sqlRow) +{ +} + +inline +Exec_query_filter::Exec_query_filter(Exec_root* root) : + Exec_query(root), + m_query(0), + m_pred(0) +{ +} + +// children + +inline const Exec_query_filter::Code& +Exec_query_filter::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_query_filter::Data& +Exec_query_filter::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_query_filter::setQuery(Exec_query* query) +{ + ctx_assert(query != 0); + m_query = query; +} + +inline void +Exec_query_filter::setPred(Exec_pred* pred) +{ + ctx_assert(pred != 0); + m_pred = pred; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_query_group.cpp b/ndb/src/client/odbc/codegen/Code_query_group.cpp new file mode 100644 index 00000000000..c3019efaa85 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_group.cpp @@ -0,0 +1,301 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Code_query_group.hpp" +#include "Code_root.hpp" + +// Plan_query_group + +Plan_query_group::~Plan_query_group() +{ +} + +Plan_expr_row* +Plan_query_group::getRow() +{ + ctx_assert(m_dataRow != 0); + return m_dataRow; +} + +Plan_base* +Plan_query_group::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_query != 0); + m_query->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + ctx_assert(m_dataRow != 0); + m_dataRow->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + ctx_assert(m_groupRow != 0); + m_groupRow->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + if (m_havingPred != 0) { + ctl.m_having = true; + m_havingPred->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + ctl.m_having = false; + } + return this; +} + +Exec_base* +Plan_query_group::codegen(Ctx& ctx, Ctl& ctl) +{ + // create code for the subquery + ctx_assert(m_query != 0); + Exec_query* execQuery = static_cast(m_query->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execQuery != 0); + // create code for the rows based on query code + ctl.m_execQuery = execQuery; + ctx_assert(m_dataRow != 0); + Exec_expr_row* execDataRow = static_cast(m_dataRow->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execDataRow != 0); + ctx_assert(m_groupRow != 0); + Exec_expr_row* execGroupRow = static_cast(m_groupRow->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execGroupRow != 0); + Exec_pred* execHavingPred = 0; + if (m_havingPred != 0) { + ctl.m_having = true; + execHavingPred = static_cast(m_havingPred->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execHavingPred != 0); + ctl.m_having = false; + } + // the exec node + Exec_query_group* exec = new Exec_query_group(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + // re-use SqlSpecs from data row + const SqlSpecs& sqlSpecs = execDataRow->getCode().sqlSpecs(); + Exec_query_group::Code& code = *new Exec_query_group::Code(sqlSpecs); + exec->setCode(code); + exec->setQuery(execQuery); + exec->setDataRow(execDataRow); + exec->setGroupRow(execGroupRow); + if (execHavingPred != 0) + exec->setHavingPred(execHavingPred); + return exec; +} + +void +Plan_query_group::print(Ctx& ctx) +{ + ctx.print(" [query_group"); + Plan_base* a[] = { m_query, m_dataRow, m_groupRow }; + printList(ctx, a, 3); + ctx.print("]"); +} + +// Exec_query_group + +Exec_query_group::Code::~Code() +{ +} + +Exec_query_group::Data::~Data() +{ + for (GroupList::iterator i = m_groupList.begin(); i != m_groupList.end(); i++) { + delete (*i).first; + } +} + +Exec_query_group::~Exec_query_group() +{ +} + +const Exec_query* +Exec_query_group::getRawQuery() const +{ + ctx_assert(m_query != 0); + return m_query; +} + +void +Exec_query_group::alloc(Ctx& ctx, Ctl& ctl) +{ + // allocate subquery + ctx_assert(m_query != 0); + m_query->alloc(ctx, ctl); + if (! ctx.ok()) + return; + // allocate rows based on subquery data + ctl.m_query = m_query; + ctx_assert(m_dataRow != 0); + m_dataRow->alloc(ctx, ctl); + if (! ctx.ok()) + return; + ctx_assert(m_groupRow != 0); + m_groupRow->alloc(ctx, ctl); + if (! ctx.ok()) + return; + if (m_havingPred != 0) { + m_havingPred->alloc(ctx, ctl); + if (! ctx.ok()) + return; + } + Data& data = *new Data(this, getCode().sqlSpecs()); + setData(data); +} + +void +Exec_query_group::execImpl(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_query != 0); + m_query->execute(ctx, ctl); +} + +bool +GroupLess::operator()(const SqlRow* s1, const SqlRow* s2) const +{ + ctx_assert(s1 != 0 && s2 != 0); + const SqlRow& r1 = *s1; + const SqlRow& r2 = *s2; + for (unsigned i = 1; i <= r1.count(); i++) { + const SqlField& f1 = r1.getEntry(i); + const SqlField& f2 = r2.getEntry(i); + // nulls last is default in oracle + const bool f1null = f1.sqlNull(); + const bool f2null = f2.sqlNull(); + if (f1null && f2null) + continue; + if (! f1null && f2null) + return true; + if (f1null && ! f2null) + return false; + if (f1.less(f2)) + return true; + if (f2.less(f1)) + return false; + } + return false; +} + +bool +Exec_query_group::fetchImpl(Ctx& ctx, Ctl& ctl) +{ + Data& data = getData(); + ctx_assert(m_query != 0 && m_groupRow != 0); + if (! data.m_grouped) { + // read and group all rows + while (m_query->fetch(ctx, ctl)) { + // evaluate and insert group-by values + m_groupRow->evaluate(ctx, ctl); + if (! ctx.ok()) + return false; + const SqlRow* groupRow = 0; + unsigned index = 0; + bool init; + GroupList::iterator i = data.m_groupList.find(&m_groupRow->getData().sqlRow()); + if (i == data.m_groupList.end()) { + groupRow = m_groupRow->getData().sqlRow().copy(); + index = ++data.m_count; + const GroupList::value_type groupPair(groupRow, index); + data.m_groupList.insert(groupPair); + init = true; + } else { + groupRow = (*i).first; + index = (*i).second; + ctx_assert(groupRow != 0 && index != 0); + init = false; + } + // evaluate rows saving expression values at index position + ctl.m_groupIndex = index; + ctl.m_groupInit = init; + m_dataRow->evaluate(ctx, ctl); + if (! ctx.ok()) + return false; + if (m_havingPred != 0) { + m_havingPred->evaluate(ctx, ctl); + if (! ctx.ok()) + return false; + } + if (ctl.m_sortRow != 0) { + ctl.m_sortRow->evaluate(ctx, ctl); + if (! ctx.ok()) + return false; + } + ctl.m_groupIndex = 0; + } + if (! ctx.ok()) + return false; + data.m_iterator = data.m_groupList.begin(); + data.m_grouped = true; + } + while (data.m_iterator != data.m_groupList.end()) { + const SqlRow* groupRow = (*data.m_iterator).first; + const unsigned index = (*data.m_iterator).second; + ctx_assert(groupRow != 0 && index != 0); + if (m_havingPred != 0) { + Pred_value v = m_havingPred->getData().groupValue(index); + if (v != Pred_value_true) { + data.m_iterator++; + continue; + } + } + // make our SqlRow reference to the saved values + for (unsigned i = 1; i <= data.m_sqlRow.count(); i++) { + const SqlField& currField = m_dataRow->getExpr(i)->getData().groupField(index); + SqlSpec sqlSpec(currField.sqlSpec(), SqlSpec::Reference); + SqlField sqlField(sqlSpec, &currField); + data.m_sqlRow.setEntry(i, sqlField); + } + // send group index up for possible order by + ctl.m_groupIndex = index; + data.m_iterator++; + return true; + } + return false; +} + +void +Exec_query_group::close(Ctx& ctx) +{ + Data& data = getData(); + ctx_assert(m_query != 0); + m_query->close(ctx); + ctx_assert(m_dataRow != 0); + m_dataRow->close(ctx); + ctx_assert(m_groupRow != 0); + m_groupRow->close(ctx); + if (m_havingPred != 0) + m_havingPred->close(ctx); + data.m_grouped = false; + data.m_count = 0; + for (GroupList::iterator i = data.m_groupList.begin(); i != data.m_groupList.end(); i++) { + delete (*i).first; + } + data.m_groupList.clear(); +} + +void +Exec_query_group::print(Ctx& ctx) +{ + ctx.print(" [query_group"); + Exec_base* a[] = { m_query, m_dataRow, m_groupRow }; + printList(ctx, a, 3); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_query_group.hpp b/ndb/src/client/odbc/codegen/Code_query_group.hpp new file mode 100644 index 00000000000..e79022c5284 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_group.hpp @@ -0,0 +1,221 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_query_group_hpp +#define ODBC_CODEGEN_Code_query_group_hpp + +#include +#include +#include "Code_query.hpp" +#include "Code_expr_row.hpp" +#include "Code_pred.hpp" + +/** + * @class Plan_query_group + * @brief Group-by node in PlanTree + */ +class Plan_query_group : public Plan_query { +public: + Plan_query_group(Plan_root* root); + virtual ~Plan_query_group(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setQuery(Plan_query* query); + void setDataRow(Plan_expr_row* dataRow); + void setGroupRow(Plan_expr_row* groupRow); + void setHavingPred(Plan_pred* havingPred); + Plan_expr_row* getRow(); +protected: + Plan_query* m_query; + Plan_expr_row* m_dataRow; + Plan_expr_row* m_groupRow; + Plan_pred* m_havingPred; +}; + +inline +Plan_query_group::Plan_query_group(Plan_root* root) : + Plan_query(root), + m_query(0), + m_dataRow(0), + m_groupRow(0), + m_havingPred(0) +{ +} + +// children + +inline void +Plan_query_group::setQuery(Plan_query* query) +{ + ctx_assert(query != 0); + m_query = query; +} + +inline void +Plan_query_group::setDataRow(Plan_expr_row* dataRow) +{ + ctx_assert(dataRow != 0); + m_dataRow = dataRow; +} + +inline void +Plan_query_group::setGroupRow(Plan_expr_row* groupRow) +{ + ctx_assert(groupRow != 0); + m_groupRow = groupRow; +} + +inline void +Plan_query_group::setHavingPred(Plan_pred* havingPred) +{ + ctx_assert(havingPred != 0); + m_havingPred = havingPred; +} + +/** + * Group-by uses a std::map. Key is values grouped by. Data is unique index + * (starting at 1) into arrays in expression data. + */ + +class Exec_query_group; + +struct GroupLess : std::binary_function { + bool operator()(const SqlRow* s1, const SqlRow* s2) const; +}; + +typedef std::map GroupList; + +/** + * @class Exec_query_group + * @brief Group-by node in ExecTree + */ +class Exec_query_group : public Exec_query { +public: + class Code : public Exec_query::Code { + public: + Code(const SqlSpecs& sqlSpecs); + virtual ~Code(); + protected: + friend class Exec_query_group; + // sets reference to Sqlspecs from subquery + }; + class Data : public Exec_query::Data { + public: + Data(Exec_query_group* node, const SqlSpecs& sqlSpecs); + virtual ~Data(); + protected: + friend class Exec_query_group; + SqlRow m_sqlRow; // current row + bool m_grouped; // fetch and group-by done + unsigned m_count; + GroupList m_groupList; + GroupList::iterator m_iterator; + }; + Exec_query_group(Exec_root* root); + virtual ~Exec_query_group(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + bool fetchImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setQuery(Exec_query* query); + void setDataRow(Exec_expr_row* dataRow); + void setGroupRow(Exec_expr_row* groupRow); + void setHavingPred(Exec_pred* havingPred); + const Exec_query* getRawQuery() const; +protected: + friend class Exec_query; + Exec_query* m_query; + Exec_expr_row* m_dataRow; + Exec_expr_row* m_groupRow; + Exec_pred* m_havingPred; +}; + +inline +Exec_query_group::Code::Code(const SqlSpecs& sqlSpecs) : + Exec_query::Code(sqlSpecs) +{ +} + +inline +Exec_query_group::Data::Data(Exec_query_group* node, const SqlSpecs& sqlSpecs) : + Exec_query::Data(node, m_sqlRow), + m_sqlRow(sqlSpecs), + m_grouped(false), + m_count(0) +{ +} + +inline +Exec_query_group::Exec_query_group(Exec_root* root) : + Exec_query(root), + m_query(0), + m_dataRow(0), + m_groupRow(0), + m_havingPred(0) +{ +} + +// children + +inline const Exec_query_group::Code& +Exec_query_group::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_query_group::Data& +Exec_query_group::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_query_group::setQuery(Exec_query* query) +{ + ctx_assert(m_query == 0 && query != 0); + m_query = query; +} + +inline void +Exec_query_group::setDataRow(Exec_expr_row* dataRow) +{ + ctx_assert(m_dataRow == 0 && dataRow != 0); + m_dataRow = dataRow; +} + +inline void +Exec_query_group::setGroupRow(Exec_expr_row* groupRow) +{ + ctx_assert(m_groupRow == 0 && groupRow != 0); + m_groupRow = groupRow; +} + +inline void +Exec_query_group::setHavingPred(Exec_pred* havingPred) +{ + ctx_assert(m_havingPred == 0 && havingPred != 0); + m_havingPred = havingPred; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_query_index.cpp b/ndb/src/client/odbc/codegen/Code_query_index.cpp new file mode 100644 index 00000000000..ee19d6123cc --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_index.cpp @@ -0,0 +1,186 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "Code_query_index.hpp" +#include "Code_column.hpp" +#include "Code_expr.hpp" +#include "Code_root.hpp" + +// Plan_query_index + +Plan_query_index::~Plan_query_index() +{ +} + +Plan_base* +Plan_query_index::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_table != 0); + m_table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +Exec_base* +Plan_query_index::codegen(Ctx& ctx, Ctl& ctl) +{ + // set up + ctx_assert(m_table != 0 && m_index != 0); + const BaseString& tableName = m_table->getName(); + ctx_assert(m_index->m_dictIndex != 0); + const DictIndex& dictIndex = *m_index->m_dictIndex; + const BaseString& indexName = dictIndex.getName(); + const unsigned keyCount = m_index->m_keyCount; + const ColumnVector& columns = m_table->exprColumns(); + ctx_assert(columns.size() > 0); + const unsigned attrCount = columns.size() - 1; + // create the code + Exec_query_index::Code& code = *new Exec_query_index::Code(keyCount, attrCount); + code.m_tableName = strcpy(new char[tableName.length() + 1], tableName.c_str()); + code.m_indexName = strcpy(new char[indexName.length() + 1], indexName.c_str()); + // key attributes + code.m_keyId = new NdbAttrId[1 + keyCount]; + code.m_keyId[0] = (NdbAttrId)-1; + for (unsigned k = 1; k <= keyCount; k++) { + const DictColumn* keyColumn = dictIndex.getColumn(k); + const SqlType& sqlType = keyColumn->sqlType(); + SqlSpec sqlSpec(sqlType, SqlSpec::Physical); + code.m_keySpecs.setEntry(k, sqlSpec); + code.m_keyId[k] = k - 1; // index column order + } + // matching expressions + ctx_assert(m_index->m_keyFound); + const ExprVector& keyEq = m_index->m_keyEq; + ctx_assert(keyEq.size() == 1 + keyCount); + code.m_keyMatch = new Exec_expr* [1 + keyCount]; + code.m_keyMatch[0] = 0; + for (unsigned k = 1; k <= keyCount; k++) { + Plan_expr* expr = keyEq[k]; + Exec_expr* execExpr = static_cast(expr->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execExpr != 0); + code.m_keyMatch[k] = execExpr; + } + // queried attributes + code.m_attrId = new NdbAttrId[1 + attrCount]; + code.m_attrId[0] = (NdbAttrId)-1; + for (unsigned i = 1; i <= attrCount; i++) { + Plan_column* column = columns[i]; + ctx_assert(column != 0); + const DictColumn& dictColumn = column->dictColumn(); + const SqlType& sqlType = dictColumn.sqlType(); + SqlSpec sqlSpec(sqlType, SqlSpec::Physical); + code.m_sqlSpecs.setEntry(i, sqlSpec); + code.m_attrId[i] = dictColumn.getAttrId(); + } + // create the exec + Exec_query_index* exec = new Exec_query_index(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + exec->setCode(code); + return exec; +} + +void +Plan_query_index::print(Ctx& ctx) +{ + ctx.print(" [query_index"); + Plan_base* a[] = { m_table }; + printList(ctx, a, 1); + ctx.print("]"); +} + +// Exec_query_index + +Exec_query_index::Code::~Code() +{ + delete[] m_tableName; + delete[] m_keyId; + delete[] m_keyMatch; + delete[] m_attrId; +} + +Exec_query_index::Data::~Data() +{ + delete[] m_recAttr; +} + +Exec_query_index::~Exec_query_index() +{ +} + +void +Exec_query_index::alloc(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + // create data + Data& data = *new Data(this, code.sqlSpecs()); + setData(data); + // allocate matching expressions + for (unsigned k = 1; k <= code.m_keyCount; k++) { + Exec_expr* expr = code.m_keyMatch[k]; + ctx_assert(expr != 0); + expr->alloc(ctx, ctl); + if (! ctx.ok()) + return; + } + // needed for isNULL + data.m_recAttr = new NdbRecAttr* [1 + code.m_attrCount]; + for (unsigned i = 0; i <= code.m_attrCount; i++) { + data.m_recAttr[i] = 0; + } +} + +void +Exec_query_index::close(Ctx& ctx) +{ + Data& data = getData(); + if (data.m_con != 0) { + Ndb* const ndb = ndbObject(); + ndb->closeTransaction(data.m_con); + data.m_con = 0; + data.m_op = 0; + data.m_done = true; + ctx_log2(("lookup closed at statement close")); + } +} + +void +Exec_query_index::print(Ctx& ctx) +{ + ctx.print(" [query_index"); + if (m_code != 0) { + const Code& code = getCode(); + ctx.print(" keyId="); + for (unsigned i = 1; i <= code.m_keyCount; i++) { + if (i > 1) + ctx.print(","); + ctx.print("%u", (unsigned)code.m_keyId[i]); + } + ctx.print(" attrId="); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + if (i > 1) + ctx.print(","); + ctx.print("%u", (unsigned)code.m_attrId[i]); + } + ctx.print(" table=%s", code.m_tableName); + } + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_query_index.hpp b/ndb/src/client/odbc/codegen/Code_query_index.hpp new file mode 100644 index 00000000000..87affd50580 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_index.hpp @@ -0,0 +1,160 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_query_index_hpp +#define ODBC_CODEGEN_Code_query_index_hpp + +#include +#include "Code_query.hpp" +#include "Code_table.hpp" + +class Ctx; +class StmtArea; +class NdbConnection; +class NdbOperation; +class NdbRecAttr; + +/** + * @class Plan_query_index + * @brief Full select (no where clause) + */ +class Plan_query_index : public Plan_query { +public: + Plan_query_index(Plan_root* root); + virtual ~Plan_query_index(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setTable(Plan_table* table, Plan_table::Index* index); +protected: + Plan_table* m_table; + Plan_table::Index* m_index; +}; + +inline +Plan_query_index::Plan_query_index(Plan_root* root) : + Plan_query(root), + m_table(0), + m_index(0) +{ +} + +// children + +inline void +Plan_query_index::setTable(Plan_table* table, Plan_table::Index* index) +{ + ctx_assert(table != 0 && index != 0 && index == &table->m_indexList[index->m_pos] && index->m_pos != 0); + m_table = table; + m_index = index; +} + +/** + * @class Exec_query_index + * @brief Full select (no where clause) + */ +class Exec_query_index : public Exec_query { +public: + class Code : public Exec_query::Code { + public: + Code(unsigned keyCount, unsigned attrCount); + virtual ~Code(); + protected: + friend class Plan_query_index; + friend class Exec_query_index; + const char* m_tableName; + const char* m_indexName; + unsigned m_keyCount; + SqlSpecs m_keySpecs; // key types + NdbAttrId* m_keyId; + Exec_expr** m_keyMatch; // XXX pointers for now + unsigned m_attrCount; + SqlSpecs m_sqlSpecs; + NdbAttrId* m_attrId; + }; + class Data : public Exec_query::Data { + public: + Data(Exec_query_index* node, const SqlSpecs& sqlSpecs); + virtual ~Data(); + protected: + friend class Exec_query_index; + SqlRow m_sqlRow; + NdbConnection* m_con; + NdbOperation* m_op; + NdbRecAttr** m_recAttr; + bool m_done; // returns one row + }; + Exec_query_index(Exec_root* root); + virtual ~Exec_query_index(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + bool fetchImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; +}; + +inline +Exec_query_index::Code::Code(unsigned keyCount, unsigned attrCount) : + Exec_query::Code(m_sqlSpecs), + m_tableName(0), + m_indexName(0), + m_keyCount(keyCount), + m_keySpecs(keyCount), + m_keyId(0), + m_attrCount(attrCount), + m_sqlSpecs(attrCount), + m_attrId(0) +{ +} + +inline +Exec_query_index::Data::Data(Exec_query_index* node, const SqlSpecs& sqlSpecs) : + Exec_query::Data(node, m_sqlRow), + m_sqlRow(sqlSpecs), + m_con(0), + m_op(0), + m_recAttr(0), + m_done(false) +{ +} + +inline +Exec_query_index::Exec_query_index(Exec_root* root) : + Exec_query(root) +{ +} + +// children + +inline const Exec_query_index::Code& +Exec_query_index::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_query_index::Data& +Exec_query_index::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_query_join.cpp b/ndb/src/client/odbc/codegen/Code_query_join.cpp new file mode 100644 index 00000000000..89aafe13610 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_join.cpp @@ -0,0 +1,192 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_query.hpp" +#include "Code_query_join.hpp" +#include "Code_query_scan.hpp" +#include "Code_root.hpp" + +// Plan_query_join + +Plan_query_join::~Plan_query_join() +{ +} + +Plan_base* +Plan_query_join::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_inner != 0); + m_inner->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + ctx_assert(m_outer != 0); + m_outer->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +Exec_base* +Plan_query_join::codegen(Ctx& ctx, Ctl& ctl) +{ + // generate code for subqueries + ctx_assert(m_inner != 0); + Exec_query* execInner = static_cast(m_inner->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execInner != 0); + ctx_assert(m_outer != 0); + ctl.m_execQuery = execInner; + Exec_query* execOuter = static_cast(m_outer->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execOuter != 0); + // combine sql specs from subqueries + const SqlSpecs& specsInner = execInner->getCode().sqlSpecs(); + const SqlSpecs& specsOuter = execOuter->getCode().sqlSpecs(); + SqlSpecs sqlSpecs(specsInner.count() + specsOuter.count()); + for (unsigned i = 1; i <= specsInner.count(); i++) { + const SqlSpec sqlSpec(specsInner.getEntry(i), SqlSpec::Reference); + sqlSpecs.setEntry(i, sqlSpec); + } + for (unsigned i = 1; i <= specsOuter.count(); i++) { + const SqlSpec sqlSpec(specsOuter.getEntry(i), SqlSpec::Reference); + sqlSpecs.setEntry(specsInner.count() + i, sqlSpec); + } + // create the code + Exec_query_join* exec = new Exec_query_join(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + exec->setInner(execInner); + exec->setOuter(execOuter); + Exec_query_join::Code& code = *new Exec_query_join::Code(sqlSpecs); + exec->setCode(code); + return exec; +} + +void +Plan_query_join::print(Ctx& ctx) +{ + ctx.print(" [query_join"); + Plan_base* a[] = { m_inner, m_outer }; + printList(ctx, a, 2); + ctx.print("]"); +} + +// Exec_query_join + +Exec_query_join::Code::~Code() +{ +} + +Exec_query_join::Data::~Data() +{ +} + +Exec_query_join::~Exec_query_join() +{ +} + +void +Exec_query_join::alloc(Ctx& ctx, Ctl& ctl) +{ + // allocate the subqueries + ctx_assert(m_inner != 0); + m_inner->alloc(ctx, ctl); + if (! ctx.ok()) + return; + ctx_assert(m_outer != 0); + ctl.m_query = m_inner; + m_outer->alloc(ctx, ctl); + if (! ctx.ok()) + return; + // combine data rows from subqueries + const Code& code = getCode(); + const SqlRow& rowInner = m_inner->getData().sqlRow(); + const SqlRow& rowOuter = m_outer->getData().sqlRow(); + SqlRow sqlRow(code.m_sqlSpecs); + for (unsigned i = 1; i <= rowInner.count(); i++) { + const SqlSpec& sqlSpec = code.m_sqlSpecs.getEntry(i); + const SqlField sqlField(sqlSpec, &rowInner.getEntry(i)); + sqlRow.setEntry(i, sqlField); + } + for (unsigned i = 1; i <= rowOuter.count(); i++) { + const SqlSpec& sqlSpec = code.m_sqlSpecs.getEntry(rowInner.count() + i); + const SqlField sqlField(sqlSpec, &rowOuter.getEntry(i)); + sqlRow.setEntry(rowInner.count() + i, sqlField); + } + // create the data + Data& data = *new Data(this, sqlRow); + setData(data); +} + +void +Exec_query_join::execImpl(Ctx& ctx, Ctl& ctl) +{ + // execute only inner query + ctx_assert(m_inner != 0); + m_inner->execute(ctx, ctl); +} + +bool +Exec_query_join::fetchImpl(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_inner != 0); + ctx_assert(m_outer != 0); + if (getData().getState() == ResultSet::State_init) { + // fetch first row from inner + if (! m_inner->fetch(ctx, ctl)) + return false; + } + while (1) { + if (m_outer->getData().getState() == ResultSet::State_end) { + // execute or re-execute outer + Ctl ctl(0); + m_outer->close(ctx); + if (! ctx.ok()) + return false; + m_outer->execute(ctx, ctl); + if (! ctx.ok()) + return false; + } + if (! m_outer->fetch(ctx, ctl)) { + if (! ctx.ok()) + return false; + // fetch next row from inner + if (! m_inner->fetch(ctx, ctl)) + return false; + } + else + return true; + } +} + +void +Exec_query_join::close(Ctx& ctx) +{ + ctx_assert(m_inner != 0); + m_inner->close(ctx); + ctx_assert(m_outer != 0); + m_outer->close(ctx); +} + +void +Exec_query_join::print(Ctx& ctx) +{ + ctx.print(" [query_join"); + Exec_base* a[] = { m_inner, m_outer }; + printList(ctx, a, 2); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_query_join.hpp b/ndb/src/client/odbc/codegen/Code_query_join.hpp new file mode 100644 index 00000000000..f6ac9205329 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_join.hpp @@ -0,0 +1,159 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_query_join_hpp +#define ODBC_CODEGEN_Code_query_join_hpp + +#include +#include "Code_query.hpp" +#include "Code_table_list.hpp" +#include "Code_pred.hpp" + +/** + * @class Plan_query_join + * @brief Filter node in PlanTree + */ +class Plan_query_join : public Plan_query { +public: + Plan_query_join(Plan_root* root); + virtual ~Plan_query_join(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setInner(Plan_query* query); + void setOuter(Plan_query* query); +protected: + Plan_query* m_inner; + Plan_query* m_outer; +}; + +inline +Plan_query_join::Plan_query_join(Plan_root* root) : + Plan_query(root), + m_inner(0), + m_outer(0) +{ +} + +// children + +inline void +Plan_query_join::setInner(Plan_query* query) +{ + ctx_assert(query != 0); + m_inner = query; +} + +inline void +Plan_query_join::setOuter(Plan_query* query) +{ + ctx_assert(query != 0); + m_outer = query; +} + +/** + * @class Exec_query_join + * @brief Filter node in ExecTree + */ +class Exec_query_join : public Exec_query { +public: + class Code : public Exec_query::Code { + public: + Code(const SqlSpecs& sqlSpecs); + virtual ~Code(); + protected: + friend class Exec_query_join; + SqlSpecs m_sqlSpecs; + }; + class Data : public Exec_query::Data { + public: + Data(Exec_query_join* node, const SqlRow& sqlRow); + virtual ~Data(); + protected: + friend class Exec_query_join; + SqlRow m_sqlRow; + }; + Exec_query_join(Exec_root* root); + virtual ~Exec_query_join(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + bool fetchImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setInner(Exec_query* query); + void setOuter(Exec_query* query); +protected: + Exec_query* m_inner; + Exec_query* m_outer; +}; + +inline +Exec_query_join::Code::Code(const SqlSpecs& sqlSpecs) : + Exec_query::Code(m_sqlSpecs), + m_sqlSpecs(sqlSpecs) +{ +} + +inline +Exec_query_join::Data::Data(Exec_query_join* node, const SqlRow& sqlRow) : + Exec_query::Data(node, m_sqlRow), + m_sqlRow(sqlRow) +{ +} + +inline +Exec_query_join::Exec_query_join(Exec_root* root) : + Exec_query(root), + m_inner(0), + m_outer(0) +{ +} + +// children + +inline const Exec_query_join::Code& +Exec_query_join::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_query_join::Data& +Exec_query_join::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_query_join::setInner(Exec_query* query) +{ + ctx_assert(query != 0); + m_inner = query; +} + +inline void +Exec_query_join::setOuter(Exec_query* query) +{ + ctx_assert(query != 0); + m_outer = query; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_query_lookup.cpp b/ndb/src/client/odbc/codegen/Code_query_lookup.cpp new file mode 100644 index 00000000000..bad4199190b --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_lookup.cpp @@ -0,0 +1,184 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "Code_query_lookup.hpp" +#include "Code_column.hpp" +#include "Code_expr.hpp" +#include "Code_root.hpp" + +// Plan_query_lookup + +Plan_query_lookup::~Plan_query_lookup() +{ +} + +Plan_base* +Plan_query_lookup::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_table != 0); + m_table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +Exec_base* +Plan_query_lookup::codegen(Ctx& ctx, Ctl& ctl) +{ + // set up + ctx_assert(m_table != 0); + const BaseString& tableName = m_table->getName(); + const DictTable& dictTable = m_table->dictTable(); + const unsigned keyCount = dictTable.keyCount(); + const ColumnVector& columns = m_table->exprColumns(); + ctx_assert(columns.size() > 0); + const unsigned attrCount = columns.size() - 1; + // create the code + Exec_query_lookup::Code& code = *new Exec_query_lookup::Code(keyCount, attrCount); + code.m_tableName = strcpy(new char[tableName.length() + 1], tableName.c_str()); + // key attributes + code.m_keyId = new NdbAttrId[1 + keyCount]; + code.m_keyId[0] = (NdbAttrId)-1; + for (unsigned k = 1; k <= keyCount; k++) { + const DictColumn* keyColumn = dictTable.getKey(k); + const SqlType& sqlType = keyColumn->sqlType(); + SqlSpec sqlSpec(sqlType, SqlSpec::Physical); + code.m_keySpecs.setEntry(k, sqlSpec); + code.m_keyId[k] = keyColumn->getAttrId(); + } + // matching expressions + const Plan_table::Index& index = m_table->m_indexList[0]; + ctx_assert(index.m_keyFound); + const ExprVector& keyEq = index.m_keyEq; + ctx_assert(keyEq.size() == 1 + keyCount); + code.m_keyMatch = new Exec_expr* [1 + keyCount]; + code.m_keyMatch[0] = 0; + for (unsigned k = 1; k <= keyCount; k++) { + Plan_expr* expr = keyEq[k]; + Exec_expr* execExpr = static_cast(expr->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execExpr != 0); + code.m_keyMatch[k] = execExpr; + } + // queried attributes + code.m_attrId = new NdbAttrId[1 + attrCount]; + code.m_attrId[0] = (NdbAttrId)-1; + for (unsigned i = 1; i <= attrCount; i++) { + Plan_column* column = columns[i]; + ctx_assert(column != 0); + const DictColumn& dictColumn = column->dictColumn(); + const SqlType& sqlType = dictColumn.sqlType(); + SqlSpec sqlSpec(sqlType, SqlSpec::Physical); + code.m_sqlSpecs.setEntry(i, sqlSpec); + code.m_attrId[i] = dictColumn.getAttrId(); + } + // create the exec + Exec_query_lookup* exec = new Exec_query_lookup(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + exec->setCode(code); + return exec; +} + +void +Plan_query_lookup::print(Ctx& ctx) +{ + ctx.print(" [query_lookup"); + Plan_base* a[] = { m_table }; + printList(ctx, a, 1); + ctx.print("]"); +} + +// Exec_query_lookup + +Exec_query_lookup::Code::~Code() +{ + delete[] m_tableName; + delete[] m_keyId; + delete[] m_keyMatch; + delete[] m_attrId; +} + +Exec_query_lookup::Data::~Data() +{ + delete[] m_recAttr; +} + +Exec_query_lookup::~Exec_query_lookup() +{ +} + +void +Exec_query_lookup::alloc(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + // create data + Data& data = *new Data(this, code.sqlSpecs()); + setData(data); + // allocate matching expressions + for (unsigned k = 1; k <= code.m_keyCount; k++) { + Exec_expr* expr = code.m_keyMatch[k]; + ctx_assert(expr != 0); + expr->alloc(ctx, ctl); + if (! ctx.ok()) + return; + } + // needed for isNULL + data.m_recAttr = new NdbRecAttr* [1 + code.m_attrCount]; + for (unsigned i = 0; i <= code.m_attrCount; i++) { + data.m_recAttr[i] = 0; + } +} + +void +Exec_query_lookup::close(Ctx& ctx) +{ + Data& data = getData(); + if (data.m_con != 0) { + Ndb* const ndb = ndbObject(); + ndb->closeTransaction(data.m_con); + data.m_con = 0; + data.m_op = 0; + data.m_done = true; + ctx_log2(("lookup closed at statement close")); + } +} + +void +Exec_query_lookup::print(Ctx& ctx) +{ + ctx.print(" [query_lookup"); + if (m_code != 0) { + const Code& code = getCode(); + ctx.print(" keyId="); + for (unsigned i = 1; i <= code.m_keyCount; i++) { + if (i > 1) + ctx.print(","); + ctx.print("%u", (unsigned)code.m_keyId[i]); + } + ctx.print(" attrId="); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + if (i > 1) + ctx.print(","); + ctx.print("%u", (unsigned)code.m_attrId[i]); + } + ctx.print(" table=%s", code.m_tableName); + } + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_query_lookup.hpp b/ndb/src/client/odbc/codegen/Code_query_lookup.hpp new file mode 100644 index 00000000000..e66623d4030 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_lookup.hpp @@ -0,0 +1,155 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_query_lookup_hpp +#define ODBC_CODEGEN_Code_query_lookup_hpp + +#include +#include "Code_query.hpp" +#include "Code_table.hpp" + +class Ctx; +class StmtArea; +class NdbConnection; +class NdbOperation; +class NdbRecAttr; + +/** + * @class Plan_query_lookup + * @brief Full select (no where clause) + */ +class Plan_query_lookup : public Plan_query { +public: + Plan_query_lookup(Plan_root* root); + virtual ~Plan_query_lookup(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setTable(Plan_table* table); +protected: + Plan_table* m_table; +}; + +inline +Plan_query_lookup::Plan_query_lookup(Plan_root* root) : + Plan_query(root), + m_table(0) +{ +} + +// children + +inline void +Plan_query_lookup::setTable(Plan_table* table) +{ + ctx_assert(table != 0); + m_table = table; +} + +/** + * @class Exec_query_lookup + * @brief Full select (no where clause) + */ +class Exec_query_lookup : public Exec_query { +public: + class Code : public Exec_query::Code { + public: + Code(unsigned keyCount, unsigned attrCount); + virtual ~Code(); + protected: + friend class Plan_query_lookup; + friend class Exec_query_lookup; + char* m_tableName; + unsigned m_keyCount; + SqlSpecs m_keySpecs; // key types + NdbAttrId* m_keyId; + Exec_expr** m_keyMatch; // XXX pointers for now + unsigned m_attrCount; + SqlSpecs m_sqlSpecs; + NdbAttrId* m_attrId; + }; + class Data : public Exec_query::Data { + public: + Data(Exec_query_lookup* node, const SqlSpecs& sqlSpecs); + virtual ~Data(); + protected: + friend class Exec_query_lookup; + SqlRow m_sqlRow; + NdbConnection* m_con; + NdbOperation* m_op; + NdbRecAttr** m_recAttr; + bool m_done; // returns one row + }; + Exec_query_lookup(Exec_root* root); + virtual ~Exec_query_lookup(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + bool fetchImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; +}; + +inline +Exec_query_lookup::Code::Code(unsigned keyCount, unsigned attrCount) : + Exec_query::Code(m_sqlSpecs), + m_tableName(0), + m_keyCount(keyCount), + m_keySpecs(keyCount), + m_keyId(0), + m_attrCount(attrCount), + m_sqlSpecs(attrCount), + m_attrId(0) +{ +} + +inline +Exec_query_lookup::Data::Data(Exec_query_lookup* node, const SqlSpecs& sqlSpecs) : + Exec_query::Data(node, m_sqlRow), + m_sqlRow(sqlSpecs), + m_con(0), + m_op(0), + m_recAttr(0), + m_done(false) +{ +} + +inline +Exec_query_lookup::Exec_query_lookup(Exec_root* root) : + Exec_query(root) +{ +} + +// children + +inline const Exec_query_lookup::Code& +Exec_query_lookup::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_query_lookup::Data& +Exec_query_lookup::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_query_project.cpp b/ndb/src/client/odbc/codegen/Code_query_project.cpp new file mode 100644 index 00000000000..54043ce3d5d --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_project.cpp @@ -0,0 +1,184 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_query_project.hpp" +#include "Code_root.hpp" + +// Plan_query_project + +Plan_query_project::~Plan_query_project() +{ +} + +Plan_base* +Plan_query_project::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_query != 0); + m_query->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + ctx_assert(m_exprRow != 0); + ctl.m_aggrok = true; + ctl.m_aggrin = false; + m_exprRow->analyze(ctx, ctl); + ctl.m_aggrok = false; + if (! ctx.ok()) + return 0; + return this; +} + +Plan_expr_row* +Plan_query_project::getRow() +{ + ctx_assert(m_exprRow != 0); + return m_exprRow; +} + +Exec_base* +Plan_query_project::codegen(Ctx& ctx, Ctl& ctl) +{ + // create code for the subquery + ctx_assert(m_query != 0); + Exec_query* execQuery = static_cast(m_query->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execQuery != 0); + // create code for the row based on query code + ctx_assert(m_exprRow != 0); + ctl.m_execQuery = execQuery; + Exec_expr_row* execRow = static_cast(m_exprRow->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execRow != 0); + Exec_query_project* exec = new Exec_query_project(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + // re-use SqlSpecs from the row + const SqlSpecs& sqlSpecs = execRow->getCode().sqlSpecs(); + Exec_query_project::Code& code = *new Exec_query_project::Code(sqlSpecs); + code.m_limitOff = m_limitOff; + code.m_limitCnt = m_limitCnt; + exec->setCode(code); + exec->setQuery(execQuery); + exec->setRow(execRow); + return exec; +} + +void +Plan_query_project::print(Ctx& ctx) +{ + ctx.print(" [query_project"); + Plan_base* a[] = { m_query, m_exprRow }; + printList(ctx, a, 2); + ctx.print("]"); +} + +// Exec_query_project + +Exec_query_project::Code::~Code() +{ +} + +Exec_query_project::Data::~Data() +{ +} + +Exec_query_project::~Exec_query_project() +{ +} + +const Exec_query* +Exec_query_project::getRawQuery() const +{ + ctx_assert(m_query != 0); + return m_query; +} + +void +Exec_query_project::alloc(Ctx& ctx, Ctl& ctl) +{ + // allocate the subquery + ctx_assert(m_query != 0); + m_query->alloc(ctx, ctl); + if (! ctx.ok()) + return; + // allocate the row based on subquery data + ctx_assert(m_exprRow != 0); + ctl.m_query = m_query; + m_exprRow->alloc(ctx, ctl); + if (! ctx.ok()) + return; + // re-use SqlRow from the expression row + const SqlRow& sqlRow = m_exprRow->getData().sqlRow(); + Data& data = *new Data(this, sqlRow); + setData(data); +} + +void +Exec_query_project::execImpl(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_query != 0); + m_query->execute(ctx, ctl); +} + +bool +Exec_query_project::fetchImpl(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + ctx_assert(m_query != 0); + while (1) { + if (! m_query->fetch(ctx, ctl)) + return false; + ctx_assert(m_exprRow != 0); + m_exprRow->evaluate(ctx, ctl); + if (! ctx.ok()) + return false; + ctl.m_postEval = true; + m_exprRow->evaluate(ctx, ctl); + ctl.m_postEval = false; + const int n = ++data.m_cnt; + const int o = code.m_limitOff <= 0 ? 0 : code.m_limitOff; + const int c = code.m_limitCnt; + if (n <= o) + continue; + if (c < 0) + break; + if (n - o <= c) + break; + return false; + } + return true; +} + +void +Exec_query_project::close(Ctx& ctx) +{ + Data& data = getData(); + data.m_cnt = 0; + ctx_assert(m_query != 0); + m_query->close(ctx); + ctx_assert(m_exprRow != 0); + m_exprRow->close(ctx); +} + +void +Exec_query_project::print(Ctx& ctx) +{ + ctx.print(" [query_project"); + Exec_base* a[] = { m_query, m_exprRow }; + printList(ctx, a, 2); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_query_project.hpp b/ndb/src/client/odbc/codegen/Code_query_project.hpp new file mode 100644 index 00000000000..545685ab9df --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_project.hpp @@ -0,0 +1,178 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_query_project_hpp +#define ODBC_CODEGEN_Code_query_project_hpp + +#include +#include "Code_query.hpp" +#include "Code_expr_row.hpp" + +/** + * @class Plan_query_project + * @brief Project node in PlanTree + */ +class Plan_query_project : public Plan_query { +public: + Plan_query_project(Plan_root* root); + virtual ~Plan_query_project(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setQuery(Plan_query* query); + void setRow(Plan_expr_row* exprRow); + void setLimit(int off, int cnt); +protected: + Plan_expr_row* getRow(); + Plan_query* m_query; + Plan_expr_row* m_exprRow; + int m_limitOff; + int m_limitCnt; +}; + +inline +Plan_query_project::Plan_query_project(Plan_root* root) : + Plan_query(root), + m_query(0), + m_exprRow(0), + m_limitOff(0), + m_limitCnt(-1) +{ +} + +// children + +inline void +Plan_query_project::setQuery(Plan_query* query) +{ + ctx_assert(query != 0); + m_query = query; +} + +inline void +Plan_query_project::setRow(Plan_expr_row* exprRow) +{ + ctx_assert(exprRow != 0); + m_exprRow = exprRow; +} + +inline void +Plan_query_project::setLimit(int off, int cnt) +{ + m_limitOff = off; + m_limitCnt = cnt; +} + +/** + * @class Exec_query_project + * @brief Project node in ExecTree + */ +class Exec_query_project : public Exec_query { +public: + class Code : public Exec_query::Code { + public: + Code(const SqlSpecs& sqlSpecs); + virtual ~Code(); + protected: + friend class Plan_query_project; + friend class Exec_query_project; + // sets reference to Sqlspecs from the row + int m_limitOff; + int m_limitCnt; + }; + class Data : public Exec_query::Data { + public: + Data(Exec_query_project* node, const SqlRow& sqlRow); + virtual ~Data(); + protected: + friend class Exec_query_project; + // sets reference to SqlRow from the row + unsigned m_cnt; + }; + Exec_query_project(Exec_root* root); + virtual ~Exec_query_project(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + bool fetchImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setQuery(Exec_query* query); + void setRow(Exec_expr_row* exprRow); + const Exec_query* getRawQuery() const; +protected: + friend class Exec_query; + Exec_query* m_query; + Exec_expr_row* m_exprRow; +}; + +inline +Exec_query_project::Code::Code(const SqlSpecs& sqlSpecs) : + Exec_query::Code(sqlSpecs), + m_limitOff(0), + m_limitCnt(-1) +{ +} + +inline +Exec_query_project::Data::Data(Exec_query_project* node, const SqlRow& sqlRow) : + Exec_query::Data(node, sqlRow), + m_cnt(0) +{ +} + +inline +Exec_query_project::Exec_query_project(Exec_root* root) : + Exec_query(root), + m_query(0), + m_exprRow(0) +{ +} + +// children + +inline const Exec_query_project::Code& +Exec_query_project::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_query_project::Data& +Exec_query_project::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_query_project::setQuery(Exec_query* query) +{ + ctx_assert(m_query == 0 && query != 0); + m_query = query; +} + +inline void +Exec_query_project::setRow(Exec_expr_row* exprRow) +{ + ctx_assert(m_exprRow == 0 && exprRow != 0); + m_exprRow = exprRow; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_query_range.cpp b/ndb/src/client/odbc/codegen/Code_query_range.cpp new file mode 100644 index 00000000000..5d29c5af315 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_range.cpp @@ -0,0 +1,211 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "Code_query_range.hpp" +#include "Code_column.hpp" +#include "Code_expr.hpp" +#include "Code_root.hpp" + +// Plan_query_range + +Plan_query_range::~Plan_query_range() +{ +} + +Plan_base* +Plan_query_range::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_table != 0); + m_table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +Exec_base* +Plan_query_range::codegen(Ctx& ctx, Ctl& ctl) +{ + // set up + ctx_assert(m_table != 0 && m_index != 0); + const BaseString& tableName = m_table->getName(); + ctx_assert(m_index->m_dictIndex != 0); + const DictIndex& dictIndex = *m_index->m_dictIndex; + const BaseString& indexName = dictIndex.getName(); + const unsigned keyCount = m_index->m_keyCountUsed; + const ColumnVector& columns = m_table->exprColumns(); + ctx_assert(columns.size() > 0); + const unsigned attrCount = columns.size() - 1; + // create the code + Exec_query_range::Code& code = *new Exec_query_range::Code(keyCount, attrCount); + code.m_tableName = strcpy(new char[tableName.length() + 1], tableName.c_str()); + code.m_indexName = strcpy(new char[indexName.length() + 1], indexName.c_str()); + code.m_exclusive = m_exclusive; + // key attributes + code.m_keyId = new NdbAttrId[1 + keyCount]; + code.m_keyId[0] = (NdbAttrId)-1; + for (unsigned k = 1; k <= keyCount; k++) { + const DictColumn* keyColumn = dictIndex.getColumn(k); + const SqlType& sqlType = keyColumn->sqlType(); + SqlSpec sqlSpec(sqlType, SqlSpec::Physical); + code.m_keySpecs.setEntry(k, sqlSpec); + code.m_keyId[k] = k - 1; // index column order + } + // matching expressions + ctx_assert(m_index->m_keyFound); + const ExprVector& keyEq = m_index->m_keyEq; + // check size matches + ctx_assert(keyEq.size() == 1 + keyCount); + code.m_keyMatch = new Exec_expr* [1 + keyCount]; + code.m_keyMatch[0] = 0; + for (unsigned k = 1; k <= keyCount; k++) { + Plan_expr* expr = keyEq[k]; + Exec_expr* execExpr = static_cast(expr->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execExpr != 0); + code.m_keyMatch[k] = execExpr; + } + // queried attributes + code.m_attrId = new NdbAttrId[1 + attrCount]; + code.m_attrId[0] = (NdbAttrId)-1; + for (unsigned i = 1; i <= attrCount; i++) { + Plan_column* column = columns[i]; + ctx_assert(column != 0); + const DictColumn& dictColumn = column->dictColumn(); + const SqlType& sqlType = dictColumn.sqlType(); + SqlSpec sqlSpec(sqlType, SqlSpec::Physical); + code.m_sqlSpecs.setEntry(i, sqlSpec); + code.m_attrId[i] = dictColumn.getAttrId(); + } + // create the exec + Exec_query_range* exec = new Exec_query_range(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + exec->setCode(code); + // interpreter + ctl.m_execQuery = exec; + Exec_pred* execInterp = 0; + ctl.m_topTable = m_table; + if (m_interp != 0) { + execInterp = static_cast(m_interp->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execInterp != 0); + } + ctl.m_topTable = 0; + if (m_interp != 0) + exec->setInterp(execInterp); + return exec; +} + +void +Plan_query_range::print(Ctx& ctx) +{ + ctx.print(" [query_range"); + Plan_base* a[] = { m_table }; + printList(ctx, a, 1); + ctx.print("]"); +} + +// Exec_query_range + +Exec_query_range::Code::~Code() +{ + delete[] m_tableName; + delete[] m_keyId; + delete[] m_keyMatch; + delete[] m_attrId; +} + +Exec_query_range::Data::~Data() +{ + delete[] m_recAttr; +} + +Exec_query_range::~Exec_query_range() +{ +} + +void +Exec_query_range::alloc(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + // create data + Data& data = *new Data(this, code.sqlSpecs()); + setData(data); + // allocate matching expressions + for (unsigned k = 1; k <= code.m_keyCount; k++) { + Exec_expr* expr = code.m_keyMatch[k]; + ctx_assert(expr != 0); + expr->alloc(ctx, ctl); + if (! ctx.ok()) + return; + } + // needed for isNULL + data.m_recAttr = new NdbRecAttr* [1 + code.m_attrCount]; + for (unsigned i = 0; i <= code.m_attrCount; i++) { + data.m_recAttr[i] = 0; + } + // parallel + data.m_parallel = code.m_exclusive ? 1 : 240; // best supported + // interpreter + if (m_interp != 0) { + //m_interp->alloc(ctx, ctl); XXX + if (! ctx.ok()) + return; + } +} + +void +Exec_query_range::close(Ctx& ctx) +{ + Data& data = getData(); + if (data.m_con != 0) { + Ndb* const ndb = ndbObject(); + ndb->closeTransaction(data.m_con); + data.m_con = 0; + data.m_op = 0; + data.m_done = true; + ctx_log2(("lookup closed at statement close")); + } + // if (m_interp != 0) + // m_interp->close(ctx); +} + +void +Exec_query_range::print(Ctx& ctx) +{ + ctx.print(" [query_range"); + if (m_code != 0) { + const Code& code = getCode(); + ctx.print(" keyId="); + for (unsigned i = 1; i <= code.m_keyCount; i++) { + if (i > 1) + ctx.print(","); + ctx.print("%u", (unsigned)code.m_keyId[i]); + } + ctx.print(" attrId="); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + if (i > 1) + ctx.print(","); + ctx.print("%u", (unsigned)code.m_attrId[i]); + } + ctx.print(" table=%s", code.m_tableName); + } + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_query_range.hpp b/ndb/src/client/odbc/codegen/Code_query_range.hpp new file mode 100644 index 00000000000..4438189522c --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_range.hpp @@ -0,0 +1,186 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_query_range_hpp +#define ODBC_CODEGEN_Code_query_range_hpp + +#include +#include "Code_query.hpp" +#include "Code_table.hpp" +#include "Code_pred.hpp" + +class Ctx; +class StmtArea; +class NdbConnection; +class NdbOperation; +class NdbRecAttr; + +/* + * Range scan via ordered index. We implement only the case of equality + * on an initial sequence of index keys. + */ + +class Plan_query_range : public Plan_query { +public: + Plan_query_range(Plan_root* root); + virtual ~Plan_query_range(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + void setTable(Plan_table* table, Plan_table::Index* index); + void setInterp(Plan_pred* interp); + void setExclusive(); +protected: + Plan_table* m_table; + Plan_table::Index* m_index; + Plan_pred* m_interp; + bool m_exclusive; +}; + +inline +Plan_query_range::Plan_query_range(Plan_root* root) : + Plan_query(root), + m_table(0), + m_index(0), + m_interp(0), + m_exclusive(false) +{ +} + +inline void +Plan_query_range::setTable(Plan_table* table, Plan_table::Index* index) +{ + ctx_assert(table != 0 && index != 0 && index == &table->m_indexList[index->m_pos] && index->m_pos != 0); + m_table = table; + m_index = index; +} + +inline void +Plan_query_range::setInterp(Plan_pred* interp) +{ + ctx_assert(interp != 0); + m_interp = interp; +} + +inline void +Plan_query_range::setExclusive() +{ + m_exclusive = true; +} + +class Exec_query_range : public Exec_query { +public: + class Code : public Exec_query::Code { + public: + Code(unsigned keyCount, unsigned attrCount); + virtual ~Code(); + protected: + friend class Plan_query_range; + friend class Exec_query_range; + const char* m_tableName; + const char* m_indexName; + unsigned m_keyCount; + SqlSpecs m_keySpecs; // key types + NdbAttrId* m_keyId; + Exec_expr** m_keyMatch; // XXX pointers for now + unsigned m_attrCount; + SqlSpecs m_sqlSpecs; + NdbAttrId* m_attrId; + bool m_exclusive; + }; + class Data : public Exec_query::Data { + public: + Data(Exec_query_range* node, const SqlSpecs& sqlSpecs); + virtual ~Data(); + protected: + friend class Exec_query_range; + SqlRow m_sqlRow; + NdbConnection* m_con; + NdbOperation* m_op; + NdbRecAttr** m_recAttr; + unsigned m_parallel; + bool m_done; // if no match possible due to range + }; + Exec_query_range(Exec_root* root); + virtual ~Exec_query_range(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + bool fetchImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + const Code& getCode() const; + Data& getData() const; + void setInterp(Exec_pred* interp); +protected: + Exec_pred* m_interp; +}; + +inline +Exec_query_range::Code::Code(unsigned keyCount, unsigned attrCount) : + Exec_query::Code(m_sqlSpecs), + m_tableName(0), + m_indexName(0), + m_keyCount(keyCount), + m_keySpecs(keyCount), + m_keyId(0), + m_attrCount(attrCount), + m_sqlSpecs(attrCount), + m_attrId(0), + m_exclusive(false) +{ +} + +inline +Exec_query_range::Data::Data(Exec_query_range* node, const SqlSpecs& sqlSpecs) : + Exec_query::Data(node, m_sqlRow), + m_sqlRow(sqlSpecs), + m_con(0), + m_op(0), + m_recAttr(0), + m_parallel(1), + m_done(false) +{ +} + +inline +Exec_query_range::Exec_query_range(Exec_root* root) : + Exec_query(root), + m_interp(0) +{ +} + +inline const Exec_query_range::Code& +Exec_query_range::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_query_range::Data& +Exec_query_range::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_query_range::setInterp(Exec_pred* interp) +{ + ctx_assert(interp != 0); + m_interp = interp; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_query_repeat.cpp b/ndb/src/client/odbc/codegen/Code_query_repeat.cpp new file mode 100644 index 00000000000..8b295a97916 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_repeat.cpp @@ -0,0 +1,109 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_query_repeat.hpp" +#include "Code_root.hpp" + +// Plan_query_repeat + +Plan_query_repeat::~Plan_query_repeat() +{ +} + +Plan_base* +Plan_query_repeat::analyze(Ctx& ctx, Ctl& ctl) +{ + return this; +} + +Exec_base* +Plan_query_repeat::codegen(Ctx& ctx, Ctl& ctl) +{ + Exec_query_repeat* exec = new Exec_query_repeat(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + // SqlSpecs is empty + const SqlSpecs sqlSpecs(0); + Exec_query_repeat::Code& code = *new Exec_query_repeat::Code(sqlSpecs, m_forever, m_maxcount); + exec->setCode(code); + return exec; +} + +void +Plan_query_repeat::print(Ctx& ctx) +{ + ctx.print(" [query_repeat"); + if (! m_forever) + ctx.print(" %ld", (long)m_maxcount); + ctx.print("]"); +} + +// Exec_query_repeat + +Exec_query_repeat::Code::~Code() +{ +} + +Exec_query_repeat::Data::~Data() +{ +} + +Exec_query_repeat::~Exec_query_repeat() +{ +} + +void +Exec_query_repeat::alloc(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + // SqlRow is empty + Data& data = *new Data(this, code.sqlSpecs()); + setData(data); +} + +void +Exec_query_repeat::execImpl(Ctx& ctx, Ctl& ctl) +{ + Data& data = getData(); + data.m_count = 0; +} + +bool +Exec_query_repeat::fetchImpl(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + // fetch until count is up + if (code.m_forever || data.m_count < code.m_maxcount) { + data.m_count++; + return true; + } + return false; +} + +void +Exec_query_repeat::close(Ctx& ctx) +{ +} + +void +Exec_query_repeat::print(Ctx& ctx) +{ + const Code& code = getCode(); + ctx.print(" [query_repeat"); + if (! code.m_forever) + ctx.print(" %ld", (long)code.m_maxcount); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_query_repeat.hpp b/ndb/src/client/odbc/codegen/Code_query_repeat.hpp new file mode 100644 index 00000000000..90d6ef55104 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_repeat.hpp @@ -0,0 +1,133 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_query_repeat_hpp +#define ODBC_CODEGEN_Code_query_repeat_hpp + +#include +#include "Code_query.hpp" +#include "Code_expr_row.hpp" + +/** + * @class Plan_query_repeat + * @brief Constant query node in PlanTree + */ +class Plan_query_repeat : public Plan_query { +public: + Plan_query_repeat(Plan_root* root); + Plan_query_repeat(Plan_root* root, CountType maxcount); + virtual ~Plan_query_repeat(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); +private: + bool m_forever; + CountType m_maxcount; +}; + +inline +Plan_query_repeat::Plan_query_repeat(Plan_root* root) : + Plan_query(root), + m_forever(true), + m_maxcount(0) +{ +} + +inline +Plan_query_repeat::Plan_query_repeat(Plan_root* root, CountType maxcount) : + Plan_query(root), + m_forever(false), + m_maxcount(maxcount) +{ +} + +/** + * @class Exec_query_repeat + * @brief Constant query node in ExecTree + */ +class Exec_query_repeat : public Exec_query { +public: + class Code : public Exec_query::Code { + public: + Code(const SqlSpecs& sqlSpecs, bool forever, CountType maxcount); + virtual ~Code(); + protected: + friend class Exec_query_repeat; + SqlSpecs m_sqlSpecs; + bool m_forever; + CountType m_maxcount; + }; + class Data : public Exec_query::Data { + public: + Data(Exec_query_repeat* node, const SqlSpecs& sqlSpecs); + virtual ~Data(); + protected: + friend class Exec_query_repeat; + SqlRow m_sqlRow; + CountType m_count; + }; + Exec_query_repeat(Exec_root* root); + virtual ~Exec_query_repeat(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + bool fetchImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; +}; + +inline +Exec_query_repeat::Code::Code(const SqlSpecs& sqlSpecs, bool forever, CountType maxcount) : + Exec_query::Code(m_sqlSpecs), + m_sqlSpecs(sqlSpecs), + m_forever(forever), + m_maxcount(maxcount) +{ +} + +inline +Exec_query_repeat::Data::Data(Exec_query_repeat* node, const SqlSpecs& sqlSpecs) : + Exec_query::Data(node, m_sqlRow), + m_sqlRow(sqlSpecs), + m_count(0) +{ +} + +inline +Exec_query_repeat::Exec_query_repeat(Exec_root* root) : + Exec_query(root) +{ +} + +// children + +inline const Exec_query_repeat::Code& +Exec_query_repeat::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_query_repeat::Data& +Exec_query_repeat::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_query_scan.cpp b/ndb/src/client/odbc/codegen/Code_query_scan.cpp new file mode 100644 index 00000000000..1c0f58980e5 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_scan.cpp @@ -0,0 +1,177 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include "Code_query_scan.hpp" +#include "Code_column.hpp" +#include "Code_root.hpp" + +// Plan_query_scan + +Plan_query_scan::~Plan_query_scan() +{ +} + +Plan_base* +Plan_query_scan::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_table != 0); + m_table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + if (m_interp != 0) { + m_interp = static_cast(m_interp->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(m_interp != 0); + } + return this; +} + +Exec_base* +Plan_query_scan::codegen(Ctx& ctx, Ctl& ctl) +{ + // set up + ctx_assert(m_table != 0); + const BaseString& tableName = m_table->getName(); + const DictTable& dictTable = m_table->dictTable(); + const ColumnVector& columns = m_table->exprColumns(); + ctx_assert(columns.size() > 0); + const unsigned attrCount = columns.size() - 1; + // create the code + Exec_query_scan::Code& code = *new Exec_query_scan::Code(attrCount); + code.m_tableName = strcpy(new char[tableName.length() + 1], tableName.c_str()); + code.m_exclusive = m_exclusive; + // queried attributes + code.m_attrId = new NdbAttrId[1 + attrCount]; + code.m_attrId[0] = (NdbAttrId)-1; + for (unsigned i = 1; i <= attrCount; i++) { + Plan_column* column = columns[i]; + ctx_assert(column != 0); + const DictColumn& dictColumn = column->dictColumn(); + const SqlType& sqlType = dictColumn.sqlType(); + SqlSpec sqlSpec(sqlType, SqlSpec::Physical); + code.m_sqlSpecs.setEntry(i, sqlSpec); + code.m_attrId[i] = dictColumn.getAttrId(); + } + // create the exec + Exec_query_scan* exec = new Exec_query_scan(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + exec->setCode(code); + // interpreter + Exec_pred* execInterp = 0; + ctl.m_execQuery = exec; + ctl.m_topTable = m_table; + if (m_interp != 0) { + execInterp = static_cast(m_interp->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execInterp != 0); + } + ctl.m_topTable = 0; + if (m_interp != 0) + exec->setInterp(execInterp); + return exec; +} + +void +Plan_query_scan::print(Ctx& ctx) +{ + ctx.print(" [query_scan"); + Plan_base* a[] = { m_table, m_interp }; + printList(ctx, a, 2); + ctx.print("]"); +} + +// Exec_query_scan + +Exec_query_scan::Code::~Code() +{ + delete[] m_tableName; + delete[] m_attrId; +} + +Exec_query_scan::Data::~Data() +{ + delete[] m_recAttr; +} + +Exec_query_scan::~Exec_query_scan() +{ +} + +void +Exec_query_scan::alloc(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + // create data + Data& data = *new Data(this, code.sqlSpecs()); + // needed for isNULL + data.m_recAttr = new NdbRecAttr* [1 + code.m_attrCount]; + for (unsigned i = 0; i <= code.m_attrCount; i++) { + data.m_recAttr[i] = 0; + } + data.m_parallel = code.m_exclusive ? 1 : 240; // best supported + setData(data); + // interpreter + ctl.m_query = this; + if (m_interp != 0) { + //m_interp->alloc(ctx, ctl); XXX + if (! ctx.ok()) + return; + } +} + +void +Exec_query_scan::close(Ctx& ctx) +{ + Data& data = getData(); + if (data.m_con != 0) { + Ndb* const ndb = ndbObject(); + int ret = data.m_con->stopScan(); + if (ret == -1) { + ctx.pushStatus(ndb, data.m_con, data.m_op, "stopScan"); + } + ndb->closeTransaction(data.m_con); + data.m_con = 0; + data.m_op = 0; + ctx_log2(("scan closed at statement close")); + } + if (m_interp != 0) + m_interp->close(ctx); +} + +void +Exec_query_scan::print(Ctx& ctx) +{ + ctx.print(" [query_scan"); + if (m_code != 0) { + const Code& code = getCode(); + ctx.print(" attrId="); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + if (i > 1) + ctx.print(","); + ctx.print("%u", (unsigned)code.m_attrId[i]); + } + ctx.print(" table=%s", code.m_tableName); + } + if (m_interp != 0) + m_interp->print(ctx); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_query_scan.hpp b/ndb/src/client/odbc/codegen/Code_query_scan.hpp new file mode 100644 index 00000000000..d6d1630ddf8 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_scan.hpp @@ -0,0 +1,174 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_query_scan_hpp +#define ODBC_CODEGEN_Code_query_scan_hpp + +#include +#include "Code_query.hpp" +#include "Code_table.hpp" +#include "Code_pred.hpp" + +class Ctx; +class StmtArea; +class NdbConnection; +class NdbOperation; +class NdbRecAttr; + +/* + * Table scan. + */ + +class Plan_query_scan : public Plan_query { +public: + Plan_query_scan(Plan_root* root); + virtual ~Plan_query_scan(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + void setTable(Plan_table* table); + void setInterp(Plan_pred* interp); + void setExclusive(); +protected: + Plan_table* m_table; + Plan_pred* m_interp; + bool m_exclusive; // exclusive +}; + +inline +Plan_query_scan::Plan_query_scan(Plan_root* root) : + Plan_query(root), + m_table(0), + m_interp(0), + m_exclusive(false) +{ +} + +inline void +Plan_query_scan::setTable(Plan_table* table) +{ + ctx_assert(table != 0); + m_table = table; +} + +inline void +Plan_query_scan::setInterp(Plan_pred* interp) +{ + ctx_assert(interp != 0); + m_interp = interp; +} + +inline void +Plan_query_scan::setExclusive() +{ + m_exclusive = true; +} + +class Exec_query_scan : public Exec_query { +public: + class Code : public Exec_query::Code { + public: + Code(unsigned attrCount); + virtual ~Code(); + protected: + friend class Plan_query_scan; + friend class Exec_query_scan; + char* m_tableName; + unsigned m_attrCount; + SqlSpecs m_sqlSpecs; + NdbAttrId* m_attrId; + bool m_exclusive; + }; + class Data : public Exec_query::Data { + public: + Data(Exec_query_scan* node, const SqlSpecs& sqlSpecs); + virtual ~Data(); + protected: + friend class Exec_query_scan; + SqlRow m_sqlRow; + NdbConnection* m_con; + NdbOperation* m_op; + NdbRecAttr** m_recAttr; + unsigned m_parallel; // parallelism could be runtime option + }; + Exec_query_scan(Exec_root* root); + virtual ~Exec_query_scan(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + bool fetchImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setInterp(Exec_pred* interp); +protected: + Exec_pred* m_interp; +}; + +inline +Exec_query_scan::Code::Code(unsigned attrCount) : + Exec_query::Code(m_sqlSpecs), + m_tableName(0), + m_attrCount(attrCount), + m_sqlSpecs(attrCount), + m_attrId(0), + m_exclusive(false) +{ +} + +inline +Exec_query_scan::Data::Data(Exec_query_scan* node, const SqlSpecs& sqlSpecs) : + Exec_query::Data(node, m_sqlRow), + m_sqlRow(sqlSpecs), + m_con(0), + m_op(0), + m_recAttr(0), + m_parallel(1) +{ +} + +inline +Exec_query_scan::Exec_query_scan(Exec_root* root) : + Exec_query(root), + m_interp(0) +{ +} + +// children + +inline const Exec_query_scan::Code& +Exec_query_scan::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_query_scan::Data& +Exec_query_scan::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_query_scan::setInterp(Exec_pred* interp) +{ + ctx_assert(interp != 0); + m_interp = interp; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_query_sort.cpp b/ndb/src/client/odbc/codegen/Code_query_sort.cpp new file mode 100644 index 00000000000..4ea6db8c4e2 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_sort.cpp @@ -0,0 +1,239 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Code_query_sort.hpp" +#include "Code_root.hpp" + +// Plan_query_sort + +Plan_query_sort::~Plan_query_sort() +{ +} + +Plan_expr_row* +Plan_query_sort::getRow() +{ + ctx_assert(m_query != 0); + return m_query->getRow(); +} + +Plan_base* +Plan_query_sort::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_query != 0); + m_query->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + ctx_assert(m_sortRow != 0); + m_sortRow->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +Exec_base* +Plan_query_sort::codegen(Ctx& ctx, Ctl& ctl) +{ + // create code for the subquery + ctx_assert(m_query != 0); + Exec_query* execQuery = static_cast(m_query->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execQuery != 0); + // create code for the row based on query code + ctx_assert(m_sortRow != 0); + ctl.m_execQuery = execQuery->getRawQuery(); + Exec_expr_row* execRow = static_cast(m_sortRow->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execRow != 0); + Exec_query_sort* exec = new Exec_query_sort(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + // re-use SqlSpecs from subquery + const Exec_query::Code& codeQuery = execQuery->getCode(); + const SqlSpecs& sqlSpecs = codeQuery.sqlSpecs(); + // make asc + unsigned size = m_sortRow->getSize(); + bool* asc = new bool[1 + size]; + for (unsigned i = 1; i <= size; i++) { + asc[i] = m_sortRow->m_ascList[i]; + } + Exec_query_sort::Code& code = *new Exec_query_sort::Code(sqlSpecs, asc); + exec->setCode(code); + exec->setQuery(execQuery); + exec->setRow(execRow); + return exec; +} + +void +Plan_query_sort::print(Ctx& ctx) +{ + ctx.print(" [query_sort"); + Plan_base* a[] = { m_query, m_sortRow }; + printList(ctx, a, 2); + ctx.print("]"); +} + +// Exec_query_sort + +Exec_query_sort::Code::~Code() +{ +} + +Exec_query_sort::Data::~Data() +{ + for (unsigned i = 0; i < m_sortList.size(); i++) { + SortItem& sortItem = m_sortList[i]; + delete sortItem.m_dataRow; + delete sortItem.m_sortRow; + } +} + +Exec_query_sort::~Exec_query_sort() +{ +} + +void +Exec_query_sort::alloc(Ctx& ctx, Ctl& ctl) +{ + // allocate subquery + ctx_assert(m_query != 0); + m_query->alloc(ctx, ctl); + if (! ctx.ok()) + return; + // allocate sort row based on subquery data + ctx_assert(m_sortRow != 0); + ctl.m_query = m_query->getRawQuery(); + m_sortRow->alloc(ctx, ctl); + if (! ctx.ok()) + return; + Data& data = *new Data(this, getCode().sqlSpecs()); + setData(data); +} + +void +Exec_query_sort::execImpl(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_query != 0 && m_sortRow != 0); + ctl.m_sortRow = m_sortRow; + m_query->execute(ctx, ctl); +} + +bool +SortLess::operator()(SortItem s1, SortItem s2) const +{ + const Exec_query_sort::Code& code = m_node->getCode(); + const SqlRow& r1 = *s1.m_sortRow; + const SqlRow& r2 = *s2.m_sortRow; + for (unsigned i = 1; i <= r1.count(); i++) { + const SqlField& f1 = r1.getEntry(i); + const SqlField& f2 = r2.getEntry(i); + // nulls last is default in oracle + bool f1null = f1.sqlNull(); + bool f2null = f2.sqlNull(); + if (f1null && f2null) + continue; + if (! f1null && f2null) + return code.getAsc(i) ? true : false; + if (f1null && ! f2null) + return code.getAsc(i) ? false : true; + if (f1.less(f2)) + return code.getAsc(i) ? true : false; + if (f2.less(f1)) + return code.getAsc(i) ? false : true; + } + return false; +} + +bool +Exec_query_sort::fetchImpl(Ctx& ctx, Ctl& ctl) +{ + Data& data = getData(); + ctx_assert(m_query != 0 && m_sortRow != 0); + ctl.m_sortRow = m_sortRow; + if (! data.m_sorted) { + // read and cache all rows + data.m_count = 0; + while (m_query->fetch(ctx, ctl)) { + const SqlRow* dataRow = m_query->getData().sqlRow().copy(); + const SqlRow* sortRow = 0; + if (ctl.m_groupIndex == 0) { + // evaluate sort row + m_sortRow->evaluate(ctx, ctl); + if (! ctx.ok()) + return false; + sortRow = m_sortRow->getData().sqlRow().copy(); + } else { + // evaluate done by group-by + SqlRow tmpSortRow(m_sortRow->getCode().sqlSpecs()); + for (unsigned i = 1; i <= tmpSortRow.count(); i++) { + tmpSortRow.setEntry(i, m_sortRow->getExpr(i)->getData().groupField(ctl.m_groupIndex)); + } + sortRow = tmpSortRow.copy(); + } + SortItem sortItem(dataRow, sortRow); + data.m_sortList.push_back(sortItem); + data.m_count++; + } + data.m_index = 0; + if (! ctx.ok()) + return false; + // sort the rows XXX use iterated stable_sort + SortLess sortLess(this); + std::sort(data.m_sortList.begin(), data.m_sortList.end(), sortLess); + data.m_sorted = true; + } + if (data.m_index < data.m_count) { + // make our SqlRow reference to current row + const SqlRow& currRow = *data.m_sortList[data.m_index].m_dataRow; + for (unsigned i = 1; i <= data.m_sqlRow.count(); i++) { + const SqlField& currField = currRow.getEntry(i); + SqlSpec sqlSpec(currField.sqlSpec(), SqlSpec::Reference); + SqlField sqlField(sqlSpec, &currField); + data.m_sqlRow.setEntry(i, sqlField); + } + data.m_index++; + return true; + } + return false; +} + +void +Exec_query_sort::close(Ctx& ctx) +{ + Data& data = getData(); + ctx_assert(m_query != 0); + m_query->close(ctx); + data.m_sorted = false; + for (unsigned i = 0; i < data.m_sortList.size(); i++) { + SortItem& sortItem = data.m_sortList[i]; + delete sortItem.m_dataRow; + delete sortItem.m_sortRow; + } + data.m_sortList.clear(); + data.m_count = 0; + data.m_index = 0; +} + +void +Exec_query_sort::print(Ctx& ctx) +{ + ctx.print(" [query_sort"); + Exec_base* a[] = { m_query, m_sortRow }; + printList(ctx, a, 2); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_query_sort.hpp b/ndb/src/client/odbc/codegen/Code_query_sort.hpp new file mode 100644 index 00000000000..d1aa03d9aef --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_sort.hpp @@ -0,0 +1,208 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_query_sort_hpp +#define ODBC_CODEGEN_Code_query_sort_hpp + +#include +#include +#include "Code_query.hpp" +#include "Code_expr_row.hpp" + +/** + * @class Plan_query_sort + * @brief Project node in PlanTree + */ +class Plan_query_sort : public Plan_query { +public: + Plan_query_sort(Plan_root* root); + virtual ~Plan_query_sort(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setQuery(Plan_query* query); + void setRow(Plan_expr_row* sortRow); +protected: + Plan_expr_row* getRow(); + Plan_query* m_query; + Plan_expr_row* m_sortRow; +}; + +inline +Plan_query_sort::Plan_query_sort(Plan_root* root) : + Plan_query(root), + m_query(0), + m_sortRow(0) +{ +} + +// children + +inline void +Plan_query_sort::setQuery(Plan_query* query) +{ + ctx_assert(query != 0); + m_query = query; +} + +inline void +Plan_query_sort::setRow(Plan_expr_row* sortRow) +{ + ctx_assert(sortRow != 0); + m_sortRow = sortRow; +} + +/** + * Item to sort includes data row and sort row. + */ +struct SortItem { + SortItem(const SqlRow* dataRow, const SqlRow* sortRow); + const SqlRow* m_dataRow; // copy of fetched row from subquery + const SqlRow* m_sortRow; // copy of values to sort on +}; + +typedef std::vector SortList; + +class Exec_query_sort; + +struct SortLess : std::binary_function { + SortLess(const Exec_query_sort* node); + const Exec_query_sort* m_node; + bool operator()(SortItem s1, SortItem s2) const; +}; + +inline +SortItem::SortItem(const SqlRow* dataRow, const SqlRow* sortRow) : + m_dataRow(dataRow), + m_sortRow(sortRow) +{ +} + +inline +SortLess::SortLess(const Exec_query_sort* node) : + m_node(node) +{ +} + +/** + * @class Exec_query_sort + * @brief Project node in ExecTree + */ +class Exec_query_sort : public Exec_query { +public: + class Code : public Exec_query::Code { + public: + Code(const SqlSpecs& sqlSpecs, bool* asc); + virtual ~Code(); + bool getAsc(unsigned i) const; + protected: + friend class Exec_query_sort; + const bool* const m_asc; + // sets reference to Sqlspecs from subquery + }; + class Data : public Exec_query::Data { + public: + Data(Exec_query_sort* node, const SqlSpecs& sqlSpecs); + virtual ~Data(); + protected: + friend class Exec_query_sort; + SqlRow m_sqlRow; // current row + bool m_sorted; // fetch and sort done + SortList m_sortList; + unsigned m_count; // number of rows + unsigned m_index; // current fetch index + }; + Exec_query_sort(Exec_root* root); + virtual ~Exec_query_sort(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + bool fetchImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setQuery(Exec_query* query); + void setRow(Exec_expr_row* sortRow); +protected: + friend class Exec_query; + Exec_query* m_query; + Exec_expr_row* m_sortRow; +}; + +inline +Exec_query_sort::Code::Code(const SqlSpecs& sqlSpecs, bool* asc) : + Exec_query::Code(sqlSpecs), + m_asc(asc) +{ +} + +inline bool +Exec_query_sort::Code::getAsc(unsigned i) const +{ + return m_asc[i]; +} + +inline +Exec_query_sort::Data::Data(Exec_query_sort* node, const SqlSpecs& sqlSpecs) : + Exec_query::Data(node, m_sqlRow), + m_sqlRow(sqlSpecs), + m_sorted(false), + m_count(0), + m_index(0) +{ +} + +inline +Exec_query_sort::Exec_query_sort(Exec_root* root) : + Exec_query(root), + m_query(0), + m_sortRow(0) +{ +} + +// children + +inline const Exec_query_sort::Code& +Exec_query_sort::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_query_sort::Data& +Exec_query_sort::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_query_sort::setQuery(Exec_query* query) +{ + ctx_assert(m_query == 0 && query != 0); + m_query = query; +} + +inline void +Exec_query_sort::setRow(Exec_expr_row* sortRow) +{ + ctx_assert(m_sortRow == 0 && sortRow != 0); + m_sortRow = sortRow; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_query_sys.cpp b/ndb/src/client/odbc/codegen/Code_query_sys.cpp new file mode 100644 index 00000000000..affe3dc1264 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_sys.cpp @@ -0,0 +1,130 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include "Code_query_sys.hpp" +#include "Code_column.hpp" +#include "Code_root.hpp" + +// Plan_query_sys + +Plan_query_sys::~Plan_query_sys() +{ +} + +Plan_base* +Plan_query_sys::analyze(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_table != 0); + m_table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +Exec_base* +Plan_query_sys::codegen(Ctx& ctx, Ctl& ctl) +{ + // set up + ctx_assert(m_table != 0); + const DictTable& dictTable = m_table->dictTable(); + const ColumnVector& columns = m_table->exprColumns(); + ctx_assert(columns.size() > 0); + const unsigned attrCount = columns.size() - 1; + // create the code + Exec_query_sys::Code& code = *new Exec_query_sys::Code(attrCount); + code.m_sysId = dictTable.sysId(); + // queried attributes + code.m_attrId = new NdbAttrId[1 + attrCount]; + code.m_attrId[0] = (NdbAttrId)-1; + for (unsigned i = 1; i <= attrCount; i++) { + Plan_column* column = columns[i]; + ctx_assert(column != 0); + const DictColumn& dictColumn = column->dictColumn(); + const SqlType& sqlType = dictColumn.sqlType(); + SqlSpec sqlSpec(sqlType, SqlSpec::Physical); + code.m_sqlSpecs.setEntry(i, sqlSpec); + code.m_attrId[i] = dictColumn.getAttrId(); + } + // create the exec + Exec_query_sys* exec = new Exec_query_sys(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + exec->setCode(code); + return exec; +} + +void +Plan_query_sys::print(Ctx& ctx) +{ + ctx.print(" [query_sys"); + Plan_base* a[] = { m_table }; + printList(ctx, a, 1); + ctx.print("]"); +} + +// Exec_query_sys + +Exec_query_sys::Code::~Code() +{ + delete[] m_attrId; +} + +Exec_query_sys::Data::~Data() +{ +} + +Exec_query_sys::~Exec_query_sys() +{ +} + +void +Exec_query_sys::alloc(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + // create data + Data& data = *new Data(this, code.sqlSpecs()); + setData(data); +} + +void +Exec_query_sys::close(Ctx& ctx) +{ + Data& data = getData(); + data.m_rowPos = 0; + data.m_tablePos = 0; + data.m_attrPos = 0; + data.m_keyPos = 0; +} + +void +Exec_query_sys::print(Ctx& ctx) +{ + ctx.print(" [query_sys"); + if (m_code != 0) { + const Code& code = getCode(); + ctx.print(" attrId="); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + if (i > 1) + ctx.print(","); + ctx.print("%u", (unsigned)code.m_attrId[i]); + } + ctx.print(" sysId=%u", (unsigned)code.m_sysId); + } + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_query_sys.hpp b/ndb/src/client/odbc/codegen/Code_query_sys.hpp new file mode 100644 index 00000000000..8eb069d0413 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_query_sys.hpp @@ -0,0 +1,148 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_query_sys_hpp +#define ODBC_CODEGEN_Code_query_sys_hpp + +#include +#include +#include "Code_query.hpp" +#include "Code_table.hpp" + +class Ctx; +class StmtArea; +class NdbConnection; +class NdbOperation; +class NdbRecAttr; + +/** + * @class Plan_query_sys + * @brief Full select (no where clause) + */ +class Plan_query_sys : public Plan_query { +public: + Plan_query_sys(Plan_root* root); + virtual ~Plan_query_sys(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setTable(Plan_table* table); +protected: + Plan_table* m_table; +}; + +inline +Plan_query_sys::Plan_query_sys(Plan_root* root) : + Plan_query(root), + m_table(0) +{ +} + +// children + +inline void +Plan_query_sys::setTable(Plan_table* table) +{ + ctx_assert(table != 0); + m_table = table; +} + +/** + * @class Exec_query_sys + * @brief Full select (no where clause) + */ +class Exec_query_sys : public Exec_query { +public: + class Code : public Exec_query::Code { + public: + Code(unsigned attrCount); + virtual ~Code(); + protected: + friend class Plan_query_sys; + friend class Exec_query_sys; + DictSys::Id m_sysId; + unsigned m_attrCount; + SqlSpecs m_sqlSpecs; + NdbAttrId* m_attrId; + }; + class Data : public Exec_query::Data { + public: + Data(Exec_query_sys* node, const SqlSpecs& sqlSpecs); + virtual ~Data(); + protected: + friend class Exec_query_sys; + SqlRow m_sqlRow; + // for typeinfo + unsigned m_rowPos; + // for tables and columns + NdbDictionary::Dictionary::List m_objectList; + unsigned m_tablePos; + unsigned m_attrPos; + unsigned m_keyPos; + }; + Exec_query_sys(Exec_root* root); + virtual ~Exec_query_sys(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + bool fetchImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; +}; + +inline +Exec_query_sys::Code::Code(unsigned attrCount) : + Exec_query::Code(m_sqlSpecs), + m_sysId(DictSys::Undef), + m_attrCount(attrCount), + m_sqlSpecs(attrCount), + m_attrId(0) +{ +} + +inline +Exec_query_sys::Data::Data(Exec_query_sys* node, const SqlSpecs& sqlSpecs) : + Exec_query::Data(node, m_sqlRow), + m_sqlRow(sqlSpecs) +{ +} + +inline +Exec_query_sys::Exec_query_sys(Exec_root* root) : + Exec_query(root) +{ +} + +// children + +inline const Exec_query_sys::Code& +Exec_query_sys::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_query_sys::Data& +Exec_query_sys::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_root.cpp b/ndb/src/client/odbc/codegen/Code_root.cpp new file mode 100644 index 00000000000..4f45bdffdaf --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_root.cpp @@ -0,0 +1,307 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Code_root.hpp" +#include "Code_stmt.hpp" +#include "Code_query.hpp" +#include "Code_expr_param.hpp" +#include "Code_root.hpp" + +// Plan_root + +Plan_root::~Plan_root() +{ +} + +Plan_base* +Plan_root::analyze(Ctx& ctx, Ctl& ctl) +{ + // analyze statement + ctx_assert(m_stmt != 0); + m_stmt = static_cast(m_stmt->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(m_stmt != 0); + // analyze parameters + ctx_assert(m_paramList.size() > 0); + const unsigned paramCount = m_paramList.size() - 1; + DescArea& ipd = descArea(Desc_usage_IPD); + ipd.setCount(ctx, paramCount); + for (unsigned i = 1; i <= paramCount; i++) { + Plan_expr_param* param = m_paramList[i]; + ctx_assert(param != 0); + // analyze the parameter + param->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + } + // must return self + return this; +} + +void +Plan_root::describe(Ctx& ctx) +{ + // describe statement + ctx_assert(m_stmt != 0); + m_stmt->describe(ctx); + // describe parameters + ctx_assert(m_paramList.size() > 0); + const unsigned paramCount = m_paramList.size() - 1; + DescArea& ipd = descArea(Desc_usage_IPD); + ipd.setCount(ctx, paramCount); + unsigned unbound = 0; + for (unsigned i = 1; i <= paramCount; i++) { + Plan_expr_param* param = m_paramList[i]; + ctx_assert(param != 0); + // describe the parameter + param->describe(ctx); + // check if SQL type is bound + ctx_assert(param->sqlType().type() != SqlType::Undef); + if (param->sqlType().type() == SqlType::Unbound) + unbound++; + } + if (unbound > 0) + ctx_log2(("%u out of %u params have unbound SQL type", unbound, paramCount)); + m_stmtArea.m_unbound = unbound; +} + +Exec_base* +Plan_root::codegen(Ctx& ctx, Ctl& ctl) +{ + Exec_root* execRoot = new Exec_root(m_stmtArea); + Exec_root::Code& code = *new Exec_root::Code; + execRoot->setCode(code); + // set root in helper struct + ctl.m_execRoot = execRoot; + // generate code for the statement + ctx_assert(m_stmt != 0); + Exec_stmt* execStmt = static_cast(m_stmt->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + execRoot->setStmt(execStmt); + // create parameters list + execRoot->m_paramList.resize(m_paramList.size()); + for (unsigned i = 1; i < m_paramList.size(); i++) { + Plan_expr_param* param = m_paramList[i]; + ctx_assert(param != 0); + Exec_expr_param* execParam = static_cast(param->codegen(ctx, ctl)); + ctx_assert(execParam != 0); + execRoot->m_paramList[i] = execParam; + } + return execRoot; +} + +void +Plan_root::print(Ctx& ctx) +{ + ctx.print("[root"); + Plan_base* a[] = { m_stmt }; + printList(ctx, a, 1); + ctx.print("]\n"); +} + +void +Plan_root::saveNode(Plan_base* node) +{ + ctx_assert(node != 0); + m_nodeList.push_back(node); +} + +void +Plan_root::freeNodeList() +{ + for (NodeList::iterator i = m_nodeList.begin(); i != m_nodeList.end(); i++) { + Plan_base* node = *i; + *i = 0; + delete node; + } + m_nodeList.clear(); +} + +// Exec_root + +Exec_root::Code::~Code() +{ +} + +Exec_root::Data::~Data() +{ +} + +Exec_root::~Exec_root() +{ +} + +StmtArea& +Exec_root::stmtArea() const +{ + return m_stmtArea; +} + +void +Exec_root::alloc(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_stmt != 0); + m_stmt->alloc(ctx, ctl); +} + +void +Exec_root::bind(Ctx& ctx) +{ + // bind output cols + ctx_assert(m_stmt != 0); + m_stmt->bind(ctx); + // bind input params + for (unsigned i = 1; i < m_paramList.size(); i++) { + Exec_expr_param* param = m_paramList[i]; + ctx_assert(param != 0); + param->bind(ctx); + if (! ctx.ok()) + return; + } +} + +void +Exec_root::execute(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_stmt != 0); + // check if data is needed + for (unsigned i = 1; i < m_paramList.size(); i++) { + Exec_expr_param* param = m_paramList[i]; + ctx_assert(param != 0); + Exec_expr_param::Data& paramData = param->getData(); + if (paramData.m_atExec && paramData.m_extPos == -1) { + ctx.setCode(SQL_NEED_DATA); + return; + } + } + m_stmt->execute(ctx, ctl); +} + +void +Exec_root::fetch(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(m_stmt != 0); + Exec_query* query = static_cast(m_stmt); + ctx_assert(query != 0); + query->fetch(ctx, ctl); +} + +void +Exec_root::close(Ctx& ctx) +{ + ctx_assert(m_stmt != 0); + m_stmt->close(ctx); + for (unsigned i = 1; i < m_paramList.size(); i++) { + Exec_expr_param* param = m_paramList[i]; + ctx_assert(param != 0); + param->close(ctx); + } +} + +void +Exec_root::print(Ctx& ctx) +{ + ctx.print("[root"); + Exec_base* a[] = { m_stmt }; + printList(ctx, a, sizeof(a)/sizeof(a[0])); + ctx.print("]\n"); +} + +void +Exec_root::saveNode(Exec_base* node) +{ + ctx_assert(node != 0); + m_nodeList.push_back(node); +} + +void +Exec_root::freeNodeList() +{ + for (NodeList::iterator i = m_nodeList.begin(); i != m_nodeList.end(); i++) { + Exec_base* node = *i; + *i = 0; + delete node; + } + m_nodeList.clear(); +} + +// odbc support + +void +Exec_root::sqlGetData(Ctx& ctx, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, SQLPOINTER targetValue, SQLINTEGER bufferLength, SQLINTEGER* strlen_or_Ind) +{ + ctx_assert(m_stmt != 0); + Exec_query* query = static_cast(m_stmt); + ctx_assert(query != 0); + query->sqlGetData(ctx, columnNumber, targetType, targetValue, bufferLength, strlen_or_Ind); +} + +void +Exec_root::sqlParamData(Ctx& ctx, SQLPOINTER* value) +{ + ctx_assert(m_paramList.size() > 0); + unsigned count = m_paramList.size() - 1; + for (unsigned i = 1; i <= count; i++) { + Exec_expr_param* param = m_paramList[i]; + ctx_assert(param != 0); + Exec_expr_param::Data& paramData = param->getData(); + if (! paramData.m_atExec || paramData.m_extPos >= 0) + continue; + ctx_assert(paramData.m_extField != 0); + ExtField& extField = *paramData.m_extField; + if (value != 0) + *value = extField.m_dataPtr; + m_paramData = i; + ctx.setCode(SQL_NEED_DATA); + return; + } +} + +void +Exec_root::sqlPutData(Ctx& ctx, SQLPOINTER data, SQLINTEGER strlen_or_Ind) +{ + ctx_assert(m_paramList.size() > 0); + unsigned count = m_paramList.size() - 1; + unsigned i = m_paramData; + if (i == 0) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "missing call to SQLParamData"); + return; + } + if (i > count) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "parameter %u out of range 1 to %u", i, count); + return; + } + Exec_expr_param* param = m_paramList[i]; + ctx_assert(param != 0); + Exec_expr_param::Data& paramData = param->getData(); + if (! paramData.m_atExec) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "parameter %u not marked for data-at-exec", i); + return; + } + ctx_assert(paramData.m_extField != 0); + ExtField extField(paramData.m_extField->extSpec(), data, 0, &strlen_or_Ind, i); + if (paramData.m_extPos == -1) + paramData.m_extPos = 0; + extField.setPos(paramData.m_extPos); + // copy in and update position + SqlField& sqlField = paramData.m_sqlField; + sqlField.copyin(ctx, extField); + paramData.m_extPos = extField.getPos(); + ctx_log4(("parameter %u data received", i)); +} diff --git a/ndb/src/client/odbc/codegen/Code_root.hpp b/ndb/src/client/odbc/codegen/Code_root.hpp new file mode 100644 index 00000000000..4f0f96725e3 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_root.hpp @@ -0,0 +1,162 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_root_hpp +#define ODBC_CODEGEN_Code_root_hpp + +#include +#include +#include "Code_base.hpp" +#include "Code_stmt.hpp" + +class SqlField; +class ExtField; + +/** + * @class Plan_root + * @brief Root node above top level statement node + */ +class Plan_root : public Plan_base { +public: + Plan_root(StmtArea& stmtArea); + virtual ~Plan_root(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + void describe(Ctx& ctx); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setStmt(Plan_stmt* stmt); + // save and free nodes + void saveNode(Plan_base* node); + void freeNodeList(); +private: + friend class CodeGen; + friend class Plan_base; + friend class Plan_expr_param; + StmtArea& m_stmtArea; + Plan_stmt* m_stmt; + ParamVector m_paramList; + typedef std::list NodeList; + NodeList m_nodeList; +}; + +inline +Plan_root::Plan_root(StmtArea& stmtArea) : + Plan_base(this), + m_stmtArea(stmtArea), + m_stmt(0) +{ +} + +inline void +Plan_root::setStmt(Plan_stmt* stmt) +{ + ctx_assert(stmt != 0); + m_stmt = stmt; +} + +/** + * @class Exec_root + * @brief Root node above top level statement node + */ +class Exec_root : public Exec_base { +public: + class Code : public Exec_base::Code { + public: + Code(); + virtual ~Code(); + }; + class Data : public Exec_base::Data { + public: + Data(); + virtual ~Data(); + }; + Exec_root(StmtArea& stmtArea); + virtual ~Exec_root(); + StmtArea& stmtArea() const; + void alloc(Ctx& ctx, Ctl& ctl); + void bind(Ctx& ctx); + void execute(Ctx& ctx, Ctl& ctl); + void fetch(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setStmt(Exec_stmt* stmt); + // save and free nodes + void saveNode(Exec_base* node); + void freeNodeList(); + // odbc support + void sqlGetData(Ctx& ctx, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, SQLPOINTER targetValue, SQLINTEGER bufferLength, SQLINTEGER* strlen_or_Ind); + void sqlParamData(Ctx& ctx, SQLPOINTER* value); + void sqlPutData(Ctx& ctx, SQLPOINTER data, SQLINTEGER strlen_or_Ind); +private: + friend class Plan_root; + friend class Exec_base; + friend class CodeGen; + StmtArea& m_stmtArea; + Exec_stmt* m_stmt; + ParamVector m_paramList; + unsigned m_paramData; // position of SQLParamData + typedef std::list NodeList; + NodeList m_nodeList; +}; + +inline +Exec_root::Code::Code() +{ +} + +inline +Exec_root::Data::Data() +{ +} + +inline +Exec_root::Exec_root(StmtArea& stmtArea) : + Exec_base(this), + m_stmtArea(stmtArea), + m_stmt(0), + m_paramData(0) +{ +} + +// children + +inline const Exec_root::Code& +Exec_root::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_root::Data& +Exec_root::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_root::setStmt(Exec_stmt* stmt) +{ + ctx_assert(stmt != 0); + m_stmt = stmt; + m_stmt->m_topLevel = true; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_select.cpp b/ndb/src/client/odbc/codegen/Code_select.cpp new file mode 100644 index 00000000000..611b491968d --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_select.cpp @@ -0,0 +1,406 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "Code_select.hpp" +#include "Code_query_lookup.hpp" +#include "Code_query_index.hpp" +#include "Code_query_scan.hpp" +#include "Code_query_range.hpp" +#include "Code_query_sys.hpp" +#include "Code_query_project.hpp" +#include "Code_query_filter.hpp" +#include "Code_query_join.hpp" +#include "Code_query_count.hpp" +#include "Code_query_sort.hpp" +#include "Code_query_group.hpp" +#include "Code_query_distinct.hpp" +#include "Code_expr_column.hpp" +#include "Code_expr_const.hpp" +#include "Code_pred_op.hpp" +#include "Code_root.hpp" + +Plan_select::~Plan_select() +{ +} + +Plan_base* +Plan_select::analyze(Ctx& ctx, Ctl& ctl) +{ + stmtArea().stmtInfo().setName(Stmt_name_select); + // analyze tables + ctx_assert(m_tableList != 0); + for (unsigned i = 1; i <= m_tableList->countTable(); i++) { + Plan_table* table = m_tableList->getTable(i); + table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + } + ctx_assert(m_exprRow != 0); + if (m_exprRow->getAsterisk()) { + // expand unqualified asterisk to table-qualified columns + setRow(new Plan_expr_row(m_root)); + m_root->saveNode(m_exprRow); + for (unsigned i = 1; i <= m_tableList->countTable(); i++) { + const Plan_table* table = m_tableList->getTable(i); + const DictTable& dictTable = table->dictTable(); + for (unsigned i = 1; i <= dictTable.getSize(); i++) { + DictColumn* dictColumn = dictTable.getColumn(i); + Plan_expr_column* column = new Plan_expr_column(m_root, dictColumn->getName()); + m_root->saveNode(column); + column->setCname(table->getCname()); + m_exprRow->addExpr(column); + } + } + } + // set name resolution scope + ctl.m_tableList = m_tableList->m_tableList; + ctx_assert(ctl.m_tableList.size() >= 1 + 1); + ctl.m_aggrin = false; + // analyze select row + ctl.m_aggrok = true; + ctx_assert(m_exprRow != 0); + m_exprRow = static_cast(m_exprRow->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(m_exprRow != 0); + // analyze group by row + ctl.m_aggrok = false; + if (m_groupRow != 0) { + m_groupRow = static_cast(m_groupRow->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(m_groupRow != 0); + } + // analyze having predicate + ctl.m_aggrok = true; + if (m_havingPred != 0) { + m_havingPred = static_cast(m_havingPred->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(m_havingPred != 0); + } + // ana|yze order by row + ctl.m_aggrok = true; + if (m_sortRow != 0) { + m_sortRow = static_cast(m_sortRow->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(m_sortRow != 0); + } + // analyze the predicate + ctl.m_aggrok = false; + ctl.m_topand = true; + ctl.m_extra = false; + if (m_pred != 0) { + m_pred = static_cast(m_pred->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(m_pred != 0); + } + // check if group by required + if (m_exprRow->anyAggr() && ! m_exprRow->allBound() && m_groupRow == 0) { + ctx.pushStatus(Error::Gen, "missing GROUP BY clause"); + return 0; + } + // in special cases add "group by 1" + if (m_groupRow == 0) { + bool addgb = false; + if (m_havingPred != 0) { + // allowed by oracle but nearly useless + addgb = true; + } else if (m_exprRow->anyAggr() && m_sortRow != 0) { + // allowed by oracle but useless + ctx_assert(m_exprRow->allBound()); + addgb = true; + } + if (addgb) { + ctx_log2(("adding 'group by 1'")); + m_groupRow = new Plan_expr_row(m_root); + m_root->saveNode(m_groupRow); + LexType type(LexType::Integer); + Plan_expr* expr = new Plan_expr_const(m_root, type, "1"); + m_root->saveNode(expr); + m_groupRow->addExpr(expr); + m_groupRow = static_cast(m_groupRow->analyze(ctx, ctl)); + ctx_assert(ctx.ok()); + ctx_assert(m_groupRow != 0); + } + } + // check group by allowed + if (m_groupRow != 0) { + if (! m_exprRow->isAllGroupBy(m_groupRow)) { + ctx.pushStatus(Error::Gen, "invalid GROUP BY expression in SELECT list"); + return 0; + } + if (m_havingPred != 0) { + if (! m_havingPred->isGroupBy(m_groupRow)) { + ctx.pushStatus(Error::Gen, "invalid GROUP BY expression in HAVING clause"); + return 0; + } + } + if (m_sortRow != 0) { + if (! m_sortRow->isAllGroupBy(m_groupRow)) { + ctx.pushStatus(Error::Gen, "invalid GROUP BY expression in ORDER BY clause"); + return 0; + } + } + } + // log top level predicate + { + unsigned n = 0; + for (PredList::iterator i = ctl.m_topcomp.begin(); i != ctl.m_topcomp.end(); i++) + ctx_log2(("top level pred %u: count tables = %u, not interp = %u", + ++n, + (unsigned)(*i)->tableSet().size(), + (unsigned)(*i)->noInterp().size())); + } + // compose the raw query from lookups and scans + Plan_query* queryRaw = 0; + TableVector tableVector(1); + TableSet tsDone; + while (tableVector.size() < ctl.m_tableList.size()) { + Plan_table* tableBest = 0; + Plan_table::Index* indexBest = 0; + for (unsigned n = 1; n < ctl.m_tableList.size(); n++) { + Plan_table* table = ctl.m_tableList[n]; + if (tsDone.find(table) != tsDone.end()) + continue; + // get system table out of the way + if (table->dictTable().sysId()) { + tableBest = table; + break; + } + // find best match for primary key or index + for (unsigned i = 0; i <= table->indexCount(); i++) { + Plan_table::Index& index = table->m_indexList[i]; + table->resolveSet(ctx, index, tsDone); + if (! ctx.ok()) + return 0; + if (! index.m_keyFound) + continue; + // prefer smaller dependency set, smaller rank, less unused keys + int k; + (k = (indexBest == 0)) || + (k = (indexBest->m_keySet.size() - index.m_keySet.size())) || + (k = (indexBest->m_rank - index.m_rank)) || + (k = (indexBest->m_keyCountUnused - index.m_keyCountUnused)); + if (k > 0) { + tableBest = table; + indexBest = &index; + } + } + } + Plan_query* queryNext = 0; + Plan_table* tableNext = 0; + Plan_query_scan* queryScan = 0; // for pushing interpreted program + Plan_query_range* queryRange = 0; // ditto + if (tableBest == 0) { + // scan first unprocessed table + for (unsigned n = 1; n < ctl.m_tableList.size(); n++) { + Plan_table* table = ctl.m_tableList[n]; + if (tsDone.find(table) != tsDone.end()) + continue; + tableNext = table; + break; + } + ctx_assert(tableNext != 0); + queryScan = new Plan_query_scan(m_root); + m_root->saveNode(queryScan); + queryScan->setTable(tableNext); + queryNext = queryScan; + ctx_log2(("optim: scan %s", tableNext->getPrintName())); + } else if (tableBest->dictTable().sysId()) { + // "scan" system table + tableNext = tableBest; + Plan_query_sys* querySys = new Plan_query_sys(m_root); + m_root->saveNode(querySys); + querySys->setTable(tableNext); + queryNext = querySys; + ctx_log2(("optim: scan %s", tableNext->getPrintName())); + } else if (indexBest->m_keySet.size() > 0) { + // scan first table this one depends on + const TableSet& keySet = indexBest->m_keySet; + for (unsigned n = 1; n < ctl.m_tableList.size(); n++) { + Plan_table* table = ctl.m_tableList[n]; + if (keySet.find(table) == keySet.end()) + continue; + ctx_assert(tsDone.find(table) == tsDone.end()); + tableNext = table; + break; + } + ctx_assert(tableNext != 0); + queryScan = new Plan_query_scan(m_root); + m_root->saveNode(queryScan); + queryScan->setTable(tableNext); + queryNext = queryScan; + ctx_log2(("optim: scan %s for %s", tableNext->getPrintName(), tableBest->getPrintName())); + } else if (indexBest->m_rank == 0) { + // primary key depends only on processed tables + tableNext = tableBest; + Plan_query_lookup* queryLookup = new Plan_query_lookup(m_root); + m_root->saveNode(queryLookup); + queryLookup->setTable(tableNext); + queryNext = queryLookup; + ctx_log2(("optim: lookup %s", tableNext->getPrintName())); + } else if (indexBest->m_rank == 1) { + // hash index key depends only on processed tables + tableNext = tableBest; + Plan_query_index* queryIndex = new Plan_query_index(m_root); + m_root->saveNode(queryIndex); + queryIndex->setTable(tableNext, indexBest); + queryNext = queryIndex; + ctx_log2(("optim: lookup %s via index %s", tableNext->getPrintName(), indexBest->m_dictIndex->getName().c_str())); + } else if (indexBest->m_rank == 2) { + // ordered index key depends only on processed tables + tableNext = tableBest; + queryRange = new Plan_query_range(m_root); + m_root->saveNode(queryRange); + queryRange->setTable(tableNext, indexBest); + queryNext = queryRange; + ctx_log2(("optim: range scan %s via index %s", tableNext->getPrintName(), indexBest->m_dictIndex->getName().c_str())); + } else { + ctx_assert(false); + } + if (queryRaw == 0) { + queryRaw = queryNext; + } else { + Plan_query_join* queryJoin = new Plan_query_join(m_root); + m_root->saveNode(queryJoin); + queryJoin->setInner(queryRaw); + queryJoin->setOuter(queryNext); + queryRaw = queryJoin; + } + tableVector.push_back(tableNext); + tsDone.insert(tableNext); + // push down part of top level predicate to table scan or range scan + Plan_pred* predPush = 0; + Plan_pred* predInterp = 0; + PredList::iterator i = ctl.m_topcomp.begin(); + while (i != ctl.m_topcomp.end()) { + const TableSet& ts = (*i)->tableSet(); + if (! std::includes(tsDone.begin(), tsDone.end(), ts.begin(), ts.end())) { + i++; + continue; + } + predPush = predPush == 0 ? *i : predPush->opAnd(*i); + if (queryScan != 0) { + const TableSet& ts2 = (*i)->noInterp(); + if (ts2.find(tableNext) == ts2.end()) + predInterp = predInterp == 0 ? *i : predInterp->opAnd(*i); + } + if (queryRange != 0) { + const TableSet& ts2 = (*i)->noInterp(); + if (ts2.find(tableNext) == ts2.end()) + predInterp = predInterp == 0 ? *i : predInterp->opAnd(*i); + } + // remove it from top level predicate + PredList::iterator j = i; + i++; + ctl.m_topcomp.erase(j); + } + if (predPush != 0) { + Plan_query_filter* queryPush = new Plan_query_filter(m_root); + m_root->saveNode(queryPush); + queryPush->setQuery(queryRaw); + queryPush->setPred(predPush); + queryPush->m_topTable = tableNext; + queryRaw = queryPush; + } + if (predInterp != 0) { + if (queryScan != 0) + queryScan->setInterp(predInterp); + else if (queryRange != 0) + queryRange->setInterp(predInterp); + else + ctx_assert(false); + } + } + ctx_assert(ctl.m_topcomp.empty()); + // set base for column position offsets + for (unsigned n = 1; n < tableVector.size(); n++) { + Plan_table* table = tableVector[n]; + if (n == 1) { + table->m_resOff = 1; + } else { + Plan_table* tablePrev = tableVector[n - 1]; + table->m_resOff = tablePrev->m_resOff + tablePrev->m_exprColumns.size() - 1; + } + } + // next level up is one of project, count, group by + Plan_query* queryTop; + if (m_groupRow == 0) { + if (! m_exprRow->anyAggr()) { + Plan_query_project* queryProject = new Plan_query_project(m_root); + m_root->saveNode(queryProject); + queryProject->setQuery(queryRaw); + queryProject->setRow(m_exprRow); + queryProject->setLimit(m_limitOff, m_limitCnt); + queryTop = queryProject; + } else { + ctx_assert(m_exprRow->allBound()); + Plan_query_count* queryCount = new Plan_query_count(m_root); + m_root->saveNode(queryCount); + queryCount->setQuery(queryRaw); + queryCount->setRow(m_exprRow); + queryTop = queryCount; + } + } else { + Plan_query_group* queryGroup = new Plan_query_group(m_root); + m_root->saveNode(queryGroup); + queryGroup->setQuery(queryRaw); + queryGroup->setDataRow(m_exprRow); + queryGroup->setGroupRow(m_groupRow); + if (m_havingPred != 0) + queryGroup->setHavingPred(m_havingPred); + queryTop = queryGroup; + } + // optional sort becomes new top level + if (m_sortRow != 0) { + Plan_query_sort* querySort = new Plan_query_sort(m_root); + m_root->saveNode(querySort); + querySort->setQuery(queryTop); + querySort->setRow(m_sortRow); + queryTop = querySort; + } + // optional distinct becomes new top level + if (m_distinct) { + Plan_query_distinct* queryDistinct = new Plan_query_distinct(m_root); + m_root->saveNode(queryDistinct); + queryDistinct->setQuery(queryTop); + queryTop = queryDistinct; + } + // return top node + return queryTop; +} + +Exec_base* +Plan_select::codegen(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(false); + return 0; +} + +void +Plan_select::print(Ctx& ctx) +{ + ctx.print(" [select"); + Plan_base* a[] = { m_tableList, m_exprRow, m_pred, m_groupRow, m_havingPred }; + printList(ctx, a, 5); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_select.hpp b/ndb/src/client/odbc/codegen/Code_select.hpp new file mode 100644 index 00000000000..eaa9b801f29 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_select.hpp @@ -0,0 +1,132 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_select_hpp +#define ODBC_CODEGEN_Code_select_hpp + +#include +#include "Code_stmt.hpp" +#include "Code_expr_row.hpp" +#include "Code_table_list.hpp" +#include "Code_pred.hpp" + +/** + * @class Plan_select + * @brief General select in PlanTree + * + * General select. An initial PlanTree node. + */ +class Plan_select : public Plan_stmt { +public: + Plan_select(Plan_root* root); + virtual ~Plan_select(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setList(Plan_table_list* tableList); + void setRow(Plan_expr_row* exprRow); + void setPred(Plan_pred* pred); + void setSort(Plan_expr_row* sortRow); + void setDistinct(bool distinct); + void setGroup(Plan_expr_row* groupRow); + void setHaving(Plan_pred* havingPred); + void setLimit(int off, int cnt); +protected: + Plan_table_list* m_tableList; + Plan_expr_row* m_exprRow; + Plan_pred* m_pred; + Plan_expr_row* m_sortRow; + bool m_distinct; + Plan_expr_row* m_groupRow; + Plan_pred* m_havingPred; + int m_limitOff; + int m_limitCnt; +}; + +inline +Plan_select::Plan_select(Plan_root* root) : + Plan_stmt(root), + m_tableList(0), + m_exprRow(0), + m_pred(0), + m_sortRow(0), + m_distinct(false), + m_groupRow(0), + m_havingPred(0), + m_limitOff(0), + m_limitCnt(-1) +{ +} + +// children + +inline void +Plan_select::setList(Plan_table_list* tableList) +{ + ctx_assert(tableList != 0); + m_tableList = tableList; +} + +inline void +Plan_select::setRow(Plan_expr_row* exprRow) +{ + ctx_assert(exprRow != 0); + m_exprRow = exprRow; +} + +inline void +Plan_select::setPred(Plan_pred* pred) +{ + ctx_assert(pred != 0); + m_pred = pred; +} + +inline void +Plan_select::setSort(Plan_expr_row* sortRow) +{ + ctx_assert(sortRow != 0); + m_sortRow = sortRow; +} + +inline void +Plan_select::setDistinct(bool distinct) +{ + m_distinct = distinct; +} + +inline void +Plan_select::setGroup(Plan_expr_row* groupRow) +{ + ctx_assert(groupRow != 0); + m_groupRow = groupRow; +} + +inline void +Plan_select::setHaving(Plan_pred* havingPred) +{ + ctx_assert(havingPred != 0); + m_havingPred = havingPred; +} + +inline void +Plan_select::setLimit(int off, int cnt) +{ + m_limitOff = off; + m_limitCnt = cnt; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_set_row.cpp b/ndb/src/client/odbc/codegen/Code_set_row.cpp new file mode 100644 index 00000000000..dd13ba0c3f7 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_set_row.cpp @@ -0,0 +1,44 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_set_row.hpp" +#include "Code_dml_column.hpp" + +Plan_set_row::~Plan_set_row() +{ +} + +Plan_base* +Plan_set_row::analyze(Ctx& ctx, Ctl& ctl) +{ + return this; +} + +Exec_base* +Plan_set_row::codegen(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(false); + return 0; +} + +void +Plan_set_row::print(Ctx& ctx) +{ + ctx.print(" [set_row"); + Plan_base* a[] = { m_dmlRow, m_exprRow }; + printList(ctx, a, 2); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_set_row.hpp b/ndb/src/client/odbc/codegen/Code_set_row.hpp new file mode 100644 index 00000000000..10d62826ac7 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_set_row.hpp @@ -0,0 +1,76 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_set_row_hpp +#define ODBC_CODEGEN_Code_set_row_hpp + +#include +#include +#include +#include "Code_base.hpp" +#include "Code_dml_row.hpp" +#include "Code_expr_row.hpp" +#include "Code_root.hpp" + +/** + * @class Plan_set_row + * @brief Row of column assigments in update + * + * Used only in parse. The column and expression rows are moved + * to the update node immediately after parse. + */ +class Plan_set_row : public Plan_base { +public: + Plan_set_row(Plan_root* root); + virtual ~Plan_set_row(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void addColumn(Plan_dml_column* column); + void addExpr(Plan_expr* expr); +protected: + friend class Plan_update; + friend class Plan_insert; // for MySql + Plan_dml_row* m_dmlRow; + Plan_expr_row* m_exprRow; +}; + +inline +Plan_set_row::Plan_set_row(Plan_root* root) : + Plan_base(root) +{ + m_dmlRow = new Plan_dml_row(root); + root->saveNode(m_dmlRow); + m_exprRow = new Plan_expr_row(root); + root->saveNode(m_exprRow); +} + +// children + +inline void +Plan_set_row::addColumn(Plan_dml_column* column) +{ + m_dmlRow->addColumn(column); +} + +inline void +Plan_set_row::addExpr(Plan_expr* expr) +{ + m_exprRow->addExpr(expr); +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_stmt.cpp b/ndb/src/client/odbc/codegen/Code_stmt.cpp new file mode 100644 index 00000000000..d790f667b84 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_stmt.cpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_stmt.hpp" + +// Plan_stmt + +Plan_stmt::~Plan_stmt() +{ +} + +// XXX remove +void +Plan_stmt::describe(Ctx& ctx) +{ + ctx_log1(("unimplemented describe")); +} + +// Exec_stmt + +Exec_stmt::Code::~Code() +{ +} + +Exec_stmt::Data::~Data() +{ +} + +Exec_stmt::~Exec_stmt() +{ +} + +void +Exec_stmt::bind(Ctx& ctx) +{ +} diff --git a/ndb/src/client/odbc/codegen/Code_stmt.hpp b/ndb/src/client/odbc/codegen/Code_stmt.hpp new file mode 100644 index 00000000000..20b7fb965fb --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_stmt.hpp @@ -0,0 +1,76 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_stmt_hpp +#define ODBC_CODEGEN_Code_stmt_hpp + +#include +#include +#include "Code_base.hpp" + +class Ctx; + +/** + * @class Plan_stmt + * @brief Base class for statements in PlanTree + * + * A statement is a complete or partial SQL statement which can + * be optimized into executable statements Exec_stmt. + */ +class Plan_stmt : public Plan_base { +public: + Plan_stmt(Plan_root* root); + virtual ~Plan_stmt() = 0; + virtual void describe(Ctx& ctx); +}; + +inline +Plan_stmt::Plan_stmt(Plan_root* root) : + Plan_base(root) +{ +} + +/** + * @class Exec_stmt + * @brief Base class for statements in ExecTree + */ +class Exec_stmt : public Exec_base { +public: + class Code : public Exec_base::Code { + public: + virtual ~Code() = 0; + }; + class Data : public Exec_base::Data { + public: + virtual ~Data() = 0; + }; + Exec_stmt(Exec_root* root); + virtual ~Exec_stmt() = 0; + virtual void bind(Ctx& ctx); + virtual void execute(Ctx& ctx, Ctl& ctl) = 0; +protected: + friend class Exec_root; + bool m_topLevel; +}; + +inline +Exec_stmt::Exec_stmt(Exec_root* root) : + Exec_base(root), + m_topLevel(false) +{ +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_table.cpp b/ndb/src/client/odbc/codegen/Code_table.cpp new file mode 100644 index 00000000000..ee3c2a2ed07 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_table.cpp @@ -0,0 +1,254 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include +#include "Code_table.hpp" +#include "Code_column.hpp" +#include "Code_expr_column.hpp" + +Plan_table::~Plan_table() +{ +} + +Plan_base* +Plan_table::analyze(Ctx& ctx, Ctl& ctl) +{ + if (m_dictTable != 0) // already done + return this; + DictTable* table = dictSchema().findTable(m_name); + if (table == 0) { + table = dictSchema().loadTable(ctx, m_name); + if (table == 0) { + ctx.pushStatus(Sqlstate::_42S02, Error::Gen, "table %s not found", m_name.c_str()); + return 0; + } + } + m_dictTable = table; + // indexes + m_indexList.resize(1 + m_dictTable->indexCount()); + for (unsigned i = 0; i <= indexCount(); i++) { + Index& index = m_indexList[i]; + index.m_pos = i; + if (index.m_pos == 0) { + index.m_keyCount = m_dictTable->keyCount(); + index.m_rank = 0; + } else { + index.m_dictIndex = m_dictTable->getIndex(i); + index.m_keyCount = index.m_dictIndex->getSize(); + if (index.m_dictIndex->getType() == NdbDictionary::Object::UniqueHashIndex) { + index.m_rank = 1; + } else if (index.m_dictIndex->getType() == NdbDictionary::Object::OrderedIndex) { + index.m_rank = 2; + } else { + ctx_assert(false); + } + } + index.m_keyEqList.resize(1 + index.m_keyCount); + } + return this; +} + +int +Plan_table::resolveColumn(Ctx& ctx, Plan_column* column, bool stripSchemaName) +{ + ctx_assert(column != 0); + bool dml, unq; + switch (column->m_type) { + case Plan_column::Type_expr: + dml = false; + unq = false; + break; + case Plan_column::Type_dml: + dml = true; + unq = true; + break; + case Plan_column::Type_idx: + dml = false; + unq = true; + break; + default: + ctx_assert(false); + break; + } + ColumnVector& columns = ! dml ? m_exprColumns : m_dmlColumns; + const BaseString& name = column->m_name; + const BaseString& cname = column->m_cname; + ctx_log3(("resolve %s column %s in table %s", ! dml ? "expr" : "dml", column->getPrintName(), getPrintName())); + // find column in table + DictColumn* dictColumn = dictTable().findColumn(name); + if (dictColumn == 0) + return 0; + // qualified column must match table correlation name + if (! cname.empty()) { + const char* str; + if (! m_cname.empty()) { + str = m_cname.c_str(); + } else { + str = m_name.c_str(); + if (stripSchemaName && strrchr(str, '.') != 0) + str = strrchr(str, '.') + 1; + } + if (strcmp(cname.c_str(), str) != 0) + return 0; + } + // find in positional list or add to it + unsigned resPos; + for (resPos = 1; resPos < columns.size(); resPos++) { + if (strcmp(columns[resPos]->getName().c_str(), name.c_str()) != 0) + continue; + // these columns must be unique + if (unq) { + ctx.pushStatus(Error::Gen, "duplicate column %s", column->getName().c_str()); + return -1; + } + break; + } + if (resPos >= columns.size()) { + columns.push_back(column); + } + ctx_log3(("resolve to attrId %u pos %u", (unsigned)dictColumn->getAttrId(), resPos)); + column->m_dictColumn = dictColumn; + column->m_resTable = this; + column->m_resPos = resPos; + // found + return 1; +} + +bool +Plan_table::resolveEq(Ctx& ctx, Plan_expr_column* column, Plan_expr* expr) +{ + ctx_assert(m_dictTable != 0); + const TableSet& ts = expr->tableSet(); + TableSet::const_iterator i = ts.find(this); + if (i != ts.end()) + return false; + unsigned found = 0; + for (unsigned i = 0; i <= indexCount(); i++) { + Index& index = m_indexList[i]; + for (unsigned n = 1, cnt = 0; n <= index.m_keyCount; n++) { + const DictColumn* dictColumn = 0; + if (index.m_pos == 0) { + ctx_assert(m_dictTable != 0); + dictColumn = m_dictTable->getKey(n); + } else { + ctx_assert(index.m_dictIndex != 0); + dictColumn = index.m_dictIndex->getColumn(n); + } + if (dictColumn != &column->dictColumn()) + continue; + ctx_assert(++cnt == 1); + index.m_keyEqList[n].push_back(expr); + if (index.m_pos == 0) + ctx_log2(("%s: found match to primary key column %s pos %u", getPrintName(), column->getPrintName(), n)); + else + ctx_log2(("%s: found match to index %s column %s pos %u", getPrintName(), index.m_dictIndex->getName().c_str(), column->getPrintName(), n)); + found++; + } + } + return (found != 0); +} + +void +Plan_table::resolveSet(Ctx& ctx, Index& index, const TableSet& tsDone) +{ + index.m_keyFound = false; + ExprVector keyEq; + keyEq.resize(1 + index.m_keyCount); + resolveSet(ctx, index, tsDone, keyEq, 1); +} + +void +Plan_table::resolveSet(Ctx& ctx, Index& index, const TableSet& tsDone, ExprVector& keyEq, unsigned n) +{ + if (n <= index.m_keyCount) { + // building up combinations + ExprList& keyEqList = index.m_keyEqList[n]; + for (ExprList::iterator i = keyEqList.begin(); i != keyEqList.end(); i++) { + keyEq[n] = *i; + resolveSet(ctx, index, tsDone, keyEq, n + 1); + } + if (! keyEqList.empty() || index.m_rank <= 1 || n == 1) + return; + // ordered index with maximal initial key match + } + TableSet keySet; + for (unsigned i = 1; i <= n - 1; i++) { + const TableSet& tableSet = keyEq[i]->tableSet(); + for (TableSet::const_iterator j = tableSet.begin(); j != tableSet.end(); j++) { + if (tsDone.find(*j) == tsDone.end()) + keySet.insert(*j); + } + } + if (! index.m_keyFound || index.m_keySet.size() > keySet.size()) { + index.m_keyFound = true; + index.m_keyEq = keyEq; + index.m_keySet = keySet; + index.m_keyCountUsed = n - 1; + index.m_keyCountUnused = index.m_keyCount - index.m_keyCountUsed; + // set matching size + index.m_keyEq.resize(1 + index.m_keyCountUsed); + } +} + +bool +Plan_table::exactKey(Ctx& ctx, const Index* indexKey) const +{ + ctx_assert(indexKey != 0 && indexKey == &m_indexList[indexKey->m_pos]); + for (unsigned i = 0; i <= indexCount(); i++) { + const Index& index = m_indexList[i]; + const ExprListVector& keyEqList = index.m_keyEqList; + for (unsigned n = 1; n <= index.m_keyCount; n++) { + if (index.m_pos == indexKey->m_pos) { + ctx_assert(keyEqList[n].size() >= 1); + if (keyEqList[n].size() > 1) { + ctx_log2(("index %u not exact: column %u has %u > 1 matches", + indexKey->m_pos, + n, + (unsigned)keyEqList[n].size())); + return false; + } + } else { + if (keyEqList[n].size() > 0) { + ctx_log2(("index %u not exact: index %u column %u has %u > 0 matches", + indexKey->m_pos, + index.m_pos, + n, + (unsigned)keyEqList[n].size())); + return false; + } + } + } + } + ctx_log2(("index %u is exact", indexKey->m_pos)); + return true; +} + +Exec_base* +Plan_table::codegen(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(false); + return 0; +} + +void +Plan_table::print(Ctx& ctx) +{ + ctx.print(" [table %s]", getPrintName()); +} diff --git a/ndb/src/client/odbc/codegen/Code_table.hpp b/ndb/src/client/odbc/codegen/Code_table.hpp new file mode 100644 index 00000000000..8a95b8fa26c --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_table.hpp @@ -0,0 +1,202 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_table_hpp +#define ODBC_CODEGEN_Code_table_hpp + +#include +#include +#include "Code_base.hpp" + +class DictTable; +class DictColumn; +class DictIndex; +class Plan_query_filter; +class Plan_query_lookup; +class Plan_query_range; +class Plan_column; +class Plan_expr_column; +class Plan_select; +class Plan_delete; +class Plan_delete_lookup; +class Plan_update; +class Plan_update_lookup; + +/** + * @class Plan_table + * @brief Table node in PlanTree + * + * This is a pure Plan node. Final executable nodes have table + * information built-in. + */ +class Plan_table : public Plan_base { +public: + Plan_table(Plan_root* root, const BaseString& name); + virtual ~Plan_table(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // attributes + const BaseString& getName() const; + const BaseString& getCname() const; + const char* getPrintName() const; + void setCname(const BaseString& cname); + const DictTable& dictTable() const; + unsigned indexCount() const; + // resolve + const ColumnVector& exprColumns() const; + const ColumnVector& dmlColumns() const; +protected: + friend class Plan_column; + friend class Plan_query_filter; + friend class Plan_query_lookup; + friend class Plan_query_index; + friend class Plan_query_range; + friend class Plan_expr_column; + friend class Plan_select; + friend class Plan_delete; + friend class Plan_delete_lookup; + friend class Plan_delete_index; + friend class Plan_update; + friend class Plan_update_lookup; + friend class Plan_update_index; + BaseString m_name; + BaseString m_cname; + BaseString m_printName; + DictTable* m_dictTable; + /* + * Resolve column. Returns 1 on found, 0 on not found, and -1 on error. + * Modifies both table and column data. + */ + int resolveColumn(Ctx& ctx, Plan_column* column, bool stripSchemaName = false); + ColumnVector m_exprColumns; + ColumnVector m_dmlColumns; + /* + * Offset for resolved columns in join. This is sum over m_exprColumns + * lengths for all preceding tables. + */ + unsigned m_resOff; + /* + * Each column in primary key and unique hash index has list of + * expressions it is set equal to in the where-clause (at top level). + */ + bool resolveEq(Ctx& ctx, Plan_expr_column* column, Plan_expr* expr); + /* + * Index struct for primary key and indexes. + */ + struct Index { + Index() : + m_pos(0), + m_keyFound(false), + m_dictIndex(0), + m_rank(~0), + m_keyCount(0), + m_keyCountUsed(0) { + } + unsigned m_pos; + ExprListVector m_keyEqList; + bool m_keyFound; + ExprVector m_keyEq; + TableSet m_keySet; + const DictIndex* m_dictIndex; // for index only + unsigned m_rank; // 0-pk 1-hash index 2-ordered index + unsigned m_keyCount; // number of columns + unsigned m_keyCountUsed; // may be less for ordered index + unsigned m_keyCountUnused; // m_keyCount - m_keyCountUsed + }; + typedef std::vector IndexList; // primary key is entry 0 + IndexList m_indexList; + /* + * Find set of additional tables (maybe empty) required to resolve the key + * columns. + */ + void resolveSet(Ctx& ctx, Index& index, const TableSet& tsDone); + void resolveSet(Ctx& ctx, Index& index, const TableSet& tsDone, ExprVector& keyEq, unsigned n); + /* + * Check for exactly one key or index match. + */ + bool exactKey(Ctx& ctx, const Index* indexKey) const; +}; + +inline +Plan_table::Plan_table(Plan_root* root, const BaseString& name) : + Plan_base(root), + m_name(name), + m_printName(name), + m_dictTable(0), + m_exprColumns(1), // 1-based + m_dmlColumns(1), // 1-based + m_resOff(0), + m_indexList(1) +{ +} + +inline const BaseString& +Plan_table::getName() const +{ + return m_name; +} + +inline const BaseString& +Plan_table::getCname() const +{ + return m_cname; +} + +inline const char* +Plan_table::getPrintName() const +{ + return m_printName.c_str(); +} + +inline void +Plan_table::setCname(const BaseString& cname) +{ + m_cname.assign(cname); + m_printName.assign(m_name); + if (! m_cname.empty()) { + m_printName.append(" "); + m_printName.append(m_cname); + } +} + +inline const DictTable& +Plan_table::dictTable() const +{ + ctx_assert(m_dictTable != 0); + return *m_dictTable; +} + +inline unsigned +Plan_table::indexCount() const +{ + ctx_assert(m_indexList.size() > 0); + return m_indexList.size() - 1; +} + +inline const Plan_table::ColumnVector& +Plan_table::exprColumns() const +{ + return m_exprColumns; +} + +inline const Plan_table::ColumnVector& +Plan_table::dmlColumns() const +{ + return m_dmlColumns; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_table_list.cpp b/ndb/src/client/odbc/codegen/Code_table_list.cpp new file mode 100644 index 00000000000..ea9f4fdc26e --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_table_list.cpp @@ -0,0 +1,53 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Code_table_list.hpp" + +Plan_table_list::~Plan_table_list() +{ +} + +Plan_base* +Plan_table_list::analyze(Ctx& ctx, Ctl& ctl) +{ + // analyze the tables + for (unsigned i = 1, n = countTable(); i <= n; i++) { + Plan_table* table = getTable(i); + table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + } + // node was not replaced + return this; +} + +Exec_base* +Plan_table_list::codegen(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(false); + return 0; +} + +void +Plan_table_list::print(Ctx& ctx) +{ + ctx.print(" [table_list"); + for (unsigned i = 1, n = countTable(); i <= n; i++) { + Plan_base* a[] = { m_tableList[i] }; + printList(ctx, a, 1); + } + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_table_list.hpp b/ndb/src/client/odbc/codegen/Code_table_list.hpp new file mode 100644 index 00000000000..47989166cac --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_table_list.hpp @@ -0,0 +1,73 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_table_list_hpp +#define ODBC_CODEGEN_Code_table_list_hpp + +#include +#include "Code_base.hpp" +#include "Code_table.hpp" + +/** + * @class Plan_table_list + * @brief List of tables in select statement + */ +class Plan_table_list : public Plan_base { +public: + Plan_table_list(Plan_root* root); + virtual ~Plan_table_list(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + unsigned countTable() const; + void addTable(Plan_table* table); + Plan_table* getTable(unsigned i) const; +protected: + friend class Plan_select; + TableVector m_tableList; +}; + +inline +Plan_table_list::Plan_table_list(Plan_root* root) : + Plan_base(root), + m_tableList(1) +{ +} + +// children + +inline unsigned +Plan_table_list::countTable() const +{ + return m_tableList.size() - 1; +} + +inline void +Plan_table_list::addTable(Plan_table* table) +{ + ctx_assert(table != 0); + m_tableList.push_back(table); +} + +inline Plan_table* +Plan_table_list::getTable(unsigned i) const +{ + ctx_assert(1 <= i && i <= countTable() && m_tableList[i] != 0); + return m_tableList[i]; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_update.cpp b/ndb/src/client/odbc/codegen/Code_update.cpp new file mode 100644 index 00000000000..0b33cd628b4 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_update.cpp @@ -0,0 +1,246 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "Code_update.hpp" +#include "Code_update_lookup.hpp" +#include "Code_update_index.hpp" +#include "Code_update_scan.hpp" +#include "Code_table.hpp" +#include "Code_query_project.hpp" +#include "Code_query_filter.hpp" +#include "Code_query_scan.hpp" +#include "Code_query_lookup.hpp" +#include "Code_query_index.hpp" +#include "Code_query_range.hpp" +#include "Code_query_repeat.hpp" +#include "Code_root.hpp" + +// Plan_update + +Plan_update::~Plan_update() +{ +} + +Plan_base* +Plan_update::analyze(Ctx& ctx, Ctl& ctl) +{ + stmtArea().stmtInfo().setName(Stmt_name_update); + // analyze the table + ctx_assert(m_table != 0); + m_table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + // get column and expression rows + ctx_assert(m_setRow != 0); + setDmlRow(m_setRow->m_dmlRow); + setExprRow(m_setRow->m_exprRow); + m_setRow = 0; + // implied by parse + ctx_assert(m_dmlRow->getSize() == m_exprRow->getSize()); + // set name resolution scope + ctl.m_tableList.resize(1 + 1); // indexed from 1 + ctl.m_tableList[1] = m_table; + // analyze the rows + m_dmlRow->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + ctl.m_dmlRow = m_dmlRow; // row type to convert to + ctl.m_const = true; // set to constants + m_exprRow->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + bool setConst = ctl.m_const; + ctl.m_dmlRow = 0; + Plan_dml* stmt = 0; + // top level query is a project + Plan_query_project* queryProject = new Plan_query_project(m_root); + m_root->saveNode(queryProject); + queryProject->setRow(m_exprRow); + if (m_pred != 0) { + // analyze the predicate + ctl.m_topand = true; + ctl.m_extra = false; + m_pred = static_cast(m_pred->analyze(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(m_pred != 0); + // check for key match + Plan_table::Index* indexBest = 0; + for (unsigned i = 0; i <= m_table->indexCount(); i++) { + Plan_table::Index& index = m_table->m_indexList[i]; + TableSet tsDone; + m_table->resolveSet(ctx, index, tsDone); + if (! ctx.ok()) + return 0; + if (! index.m_keyFound) + continue; + // prefer smaller rank, less unused keys + int k; + (k = (indexBest == 0)) || + (k = (indexBest->m_rank - index.m_rank)) || + (k = (indexBest->m_keyCountUnused - index.m_keyCountUnused)); + if (k > 0) + indexBest = &index; + } + if (indexBest != 0) { + const bool exactKey = indexBest->m_rank <= 1 ? m_table->exactKey(ctx, indexBest) : false; + const bool direct = setConst && ! ctl.m_extra && exactKey; + ctx_log3(("update direct=%d: const=%d extra=%d exact=%d", direct, setConst, ctl.m_extra, exactKey)); + if (indexBest->m_rank == 0) { + // primary key + Plan_update_lookup* updateLookup = new Plan_update_lookup(m_root); + m_root->saveNode(updateLookup); + updateLookup->setTable(m_table); + updateLookup->setDmlRow(m_dmlRow); + if (direct) { + // constant values and exact key match + Plan_query_repeat* queryRepeat = new Plan_query_repeat(m_root, 1); + m_root->saveNode(queryRepeat); + queryProject->setQuery(queryRepeat); + } else { + // more conditions or non-constant values + Plan_query_lookup* queryLookup = new Plan_query_lookup(m_root); + m_root->saveNode(queryLookup); + Plan_query_filter* queryFilter = new Plan_query_filter(m_root); + m_root->saveNode(queryFilter); + queryLookup->setTable(m_table); + queryFilter->setQuery(queryLookup); + queryFilter->setPred(m_pred); + queryFilter->m_topTable = m_table; + queryProject->setQuery(queryFilter); + } + updateLookup->setQuery(queryProject); + stmt = updateLookup; + } else if (indexBest->m_rank == 1) { + // hash index + Plan_update_index* updateIndex = new Plan_update_index(m_root); + m_root->saveNode(updateIndex); + updateIndex->setTable(m_table, indexBest); + updateIndex->setDmlRow(m_dmlRow); + if (direct) { + // constant values and exact key match + Plan_query_repeat* queryRepeat = new Plan_query_repeat(m_root, 1); + m_root->saveNode(queryRepeat); + queryProject->setQuery(queryRepeat); + } else { + // more conditions or non-constant values + Plan_query_index* queryIndex = new Plan_query_index(m_root); + m_root->saveNode(queryIndex); + Plan_query_filter* queryFilter = new Plan_query_filter(m_root); + m_root->saveNode(queryFilter); + queryIndex->setTable(m_table, indexBest); + queryFilter->setQuery(queryIndex); + queryFilter->setPred(m_pred); + queryFilter->m_topTable = m_table; + queryProject->setQuery(queryFilter); + } + updateIndex->setQuery(queryProject); + stmt = updateIndex; + } else if (indexBest->m_rank == 2) { + // ordered index + Plan_update_scan* updateScan = new Plan_update_scan(m_root); + m_root->saveNode(updateScan); + updateScan->setTable(m_table); + updateScan->setDmlRow(m_dmlRow); + Plan_query_range* queryRange = new Plan_query_range(m_root); + m_root->saveNode(queryRange); + queryRange->setTable(m_table, indexBest); + queryRange->setExclusive(); + Plan_query_filter* queryFilter = new Plan_query_filter(m_root); + m_root->saveNode(queryFilter); + queryFilter->setQuery(queryRange); + queryFilter->setPred(m_pred); + queryFilter->m_topTable = m_table; + // interpeter + const TableSet& ts2 = m_pred->noInterp(); + ctx_assert(ts2.size() <= 1); + if (ts2.size() == 0) { + queryRange->setInterp(m_pred); + } + queryProject->setQuery(queryFilter); + updateScan->setQuery(queryProject); + stmt = updateScan; + } else { + ctx_assert(false); + } + } else { + // scan update with filter + Plan_update_scan* updateScan = new Plan_update_scan(m_root); + m_root->saveNode(updateScan); + updateScan->setTable(m_table); + updateScan->setDmlRow(m_dmlRow); + Plan_query_scan* queryScan = new Plan_query_scan(m_root); + m_root->saveNode(queryScan); + queryScan->setTable(m_table); + queryScan->setExclusive(); + Plan_query_filter* queryFilter = new Plan_query_filter(m_root); + m_root->saveNode(queryFilter); + queryFilter->setQuery(queryScan); + queryFilter->setPred(m_pred); + queryFilter->m_topTable = m_table; + // interpeter + const TableSet& ts2 = m_pred->noInterp(); + ctx_assert(ts2.size() <= 1); + if (ts2.size() == 0) { + queryScan->setInterp(m_pred); + } + queryProject->setQuery(queryFilter); + updateScan->setQuery(queryProject); + stmt = updateScan; + } + } else { + // scan update without filter + Plan_update_scan* updateScan = new Plan_update_scan(m_root); + m_root->saveNode(updateScan); + updateScan->setTable(m_table); + updateScan->setDmlRow(m_dmlRow); + Plan_query_scan* queryScan = new Plan_query_scan(m_root); + m_root->saveNode(queryScan); + queryScan->setTable(m_table); + queryScan->setExclusive(); + queryProject->setQuery(queryScan); + updateScan->setQuery(queryProject); + stmt = updateScan; + } + // set base for column position offsets + m_table->m_resOff = 1; + return stmt; +} + +void +Plan_update::describe(Ctx& ctx) +{ + stmtArea().setFunction(ctx, "UPDATE WHERE", SQL_DIAG_UPDATE_WHERE); +} + +Exec_base* +Plan_update::codegen(Ctx& ctx, Ctl& ctl) +{ + ctx_assert(false); + return 0; +} + +void +Plan_update::print(Ctx& ctx) +{ + ctx.print(" [update"); + Plan_base* a[] = { m_table, m_setRow, m_dmlRow, m_exprRow }; + printList(ctx, a, 4); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_update.hpp b/ndb/src/client/odbc/codegen/Code_update.hpp new file mode 100644 index 00000000000..380b651518b --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_update.hpp @@ -0,0 +1,102 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_update_hpp +#define ODBC_CODEGEN_Code_update_hpp + +#include +#include "Code_base.hpp" +#include "Code_dml.hpp" +#include "Code_set_row.hpp" +#include "Code_table.hpp" +#include "Code_pred.hpp" +#include "Code_query.hpp" + +/** + * @class Plan_update + * @brief Update in PlanTree + */ +class Plan_update : public Plan_dml { +public: + Plan_update(Plan_root* root); + virtual ~Plan_update(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void describe(Ctx& ctx); + void print(Ctx& ctx); + // children + void setTable(Plan_table* table); + void setRow(Plan_set_row* setRow); + void setDmlRow(Plan_dml_row* dmlRow); + void setExprRow(Plan_expr_row* exprRow); + void setPred(Plan_pred* pred); +protected: + Plan_table* m_table; + Plan_set_row* m_setRow; + Plan_dml_row* m_dmlRow; + Plan_expr_row* m_exprRow; + Plan_pred* m_pred; +}; + +inline +Plan_update::Plan_update(Plan_root* root) : + Plan_dml(root), + m_table(0), + m_setRow(0), + m_dmlRow(0), + m_exprRow(0), + m_pred(0) +{ +} + +// children + +inline void +Plan_update::setTable(Plan_table* table) +{ + ctx_assert(table != 0); + m_table = table; +} + +inline void +Plan_update::setRow(Plan_set_row* setRow) +{ + ctx_assert(setRow != 0); + m_setRow = setRow; +} + +inline void +Plan_update::setDmlRow(Plan_dml_row* dmlRow) +{ + ctx_assert(dmlRow != 0); + m_dmlRow = dmlRow; +} + +inline void +Plan_update::setExprRow(Plan_expr_row* exprRow) +{ + ctx_assert(exprRow != 0); + m_exprRow = exprRow; +} + +inline void +Plan_update::setPred(Plan_pred* pred) +{ + ctx_assert(pred != 0); + m_pred = pred; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_update_index.cpp b/ndb/src/client/odbc/codegen/Code_update_index.cpp new file mode 100644 index 00000000000..6f74db0d913 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_update_index.cpp @@ -0,0 +1,196 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "Code_dml_column.hpp" +#include "Code_expr.hpp" +#include "Code_update_index.hpp" +#include "Code_table.hpp" +#include "Code_root.hpp" + +// Plan_update_index + +Plan_update_index::~Plan_update_index() +{ +} + +Plan_base* +Plan_update_index::analyze(Ctx& ctx, Ctl& ctl) +{ + ctl.m_dmlRow = m_dmlRow; // row type to convert to + ctx_assert(m_query != 0); + m_query->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + ctx_assert(m_table != 0); + m_table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +void +Plan_update_index::describe(Ctx& ctx) +{ + stmtArea().setFunction(ctx, "UPDATE WHERE", SQL_DIAG_UPDATE_WHERE); +} + +Exec_base* +Plan_update_index::codegen(Ctx& ctx, Ctl& ctl) +{ + // generate code for the query + ctx_assert(m_query != 0); + Exec_query* execQuery = static_cast(m_query->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execQuery != 0); + // set up + ctx_assert(m_table != 0 && m_index != 0); + const BaseString& tableName = m_table->getName(); + ctx_assert(m_index->m_dictIndex != 0); + const DictIndex& dictIndex = *m_index->m_dictIndex; + const BaseString& indexName = dictIndex.getName(); + const unsigned keyCount = m_index->m_keyCount; + const ColumnVector& columns = m_table->dmlColumns(); + ctx_assert(columns.size() > 0); + const unsigned attrCount = columns.size() - 1; + // create the code + Exec_update_index::Code& code = *new Exec_update_index::Code(keyCount); + code.m_tableName = strcpy(new char[tableName.length() + 1], tableName.c_str()); + code.m_indexName = strcpy(new char[indexName.length() + 1], indexName.c_str()); + // key attributes + code.m_keyId = new NdbAttrId[1 + keyCount]; + code.m_keyId[0] = (NdbAttrId)-1; + for (unsigned k = 1; k <= keyCount; k++) { + const DictColumn* keyColumn = dictIndex.getColumn(k); + const SqlType& sqlType = keyColumn->sqlType(); + SqlSpec sqlSpec(sqlType, SqlSpec::Physical); + code.m_keySpecs.setEntry(k, sqlSpec); + code.m_keyId[k] = k - 1; // index column order + } + // matching expressions + ctx_assert(m_index->m_keyFound); + const ExprVector& keyEq = m_index->m_keyEq; + ctx_assert(keyEq.size() == 1 + keyCount); + code.m_keyMatch = new Exec_expr* [1 + keyCount]; + code.m_keyMatch[0] = 0; + for (unsigned k = 1; k <= keyCount; k++) { + Plan_expr* expr = keyEq[k]; + Exec_expr* execExpr = static_cast(expr->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execExpr != 0); + code.m_keyMatch[k] = execExpr; + } + // updated attributes + code.m_attrCount = attrCount; + code.m_attrId = new NdbAttrId[1 + attrCount]; + code.m_attrId[0] = (NdbAttrId)-1; + for (unsigned i = 1; i <= attrCount; i++) { + Plan_column* column = columns[i]; + ctx_assert(column != 0); + const DictColumn& dictColumn = column->dictColumn(); + code.m_attrId[i] = dictColumn.getAttrId(); + } + // create the exec + Exec_update_index* exec = new Exec_update_index(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + exec->setCode(code); + exec->setQuery(execQuery); + return exec; +} + +void +Plan_update_index::print(Ctx& ctx) +{ + ctx.print(" [update_index"); + Plan_base* a[] = { m_table, m_query }; + printList(ctx, a, sizeof(a)/sizeof(a[0])); + ctx.print("]"); +} + +// Exec_delete + +Exec_update_index::Code::~Code() +{ + delete[] m_tableName; + delete[] m_keyId; + delete[] m_keyMatch; + delete[] m_attrId; +} + +Exec_update_index::Data::~Data() +{ +} + +Exec_update_index::~Exec_update_index() +{ +} + +void +Exec_update_index::alloc(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + // allocate the subquery + ctx_assert(m_query != 0); + m_query->alloc(ctx, ctl); + if (! ctx.ok()) + return; + // create data + Data& data = *new Data; + setData(data); + // allocate matching expressions + for (unsigned k = 1; k <= code.m_keyCount; k++) { + Exec_expr* expr = code.m_keyMatch[k]; + ctx_assert(expr != 0); + expr->alloc(ctx, ctl); + if (! ctx.ok()) + return; + } +} + +void +Exec_update_index::close(Ctx& ctx) +{ + ctx_assert(m_query != 0); + m_query->close(ctx); +} + +void +Exec_update_index::print(Ctx& ctx) +{ + ctx.print(" [update_index"); + if (m_code != 0) { + const Code& code = getCode(); + ctx.print(" keyId="); + for (unsigned i = 1; i <= code.m_keyCount; i++) { + if (i > 1) + ctx.print(","); + ctx.print("%u", (unsigned)code.m_keyId[i]); + } + ctx.print(" attrId="); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + if (i > 1) + ctx.print(","); + ctx.print("%u", (unsigned)code.m_attrId[i]); + } + } + Exec_base* a[] = { m_query }; + printList(ctx, a, 1); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_update_index.hpp b/ndb/src/client/odbc/codegen/Code_update_index.hpp new file mode 100644 index 00000000000..bbad822650a --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_update_index.hpp @@ -0,0 +1,171 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_update_index_hpp +#define ODBC_CODEGEN_Code_update_index_hpp + +#include +#include "Code_base.hpp" +#include "Code_dml.hpp" +#include "Code_table.hpp" +#include "Code_query.hpp" + +/** + * @class Plan_update_index + * @brief Update in PlanTree + */ +class Plan_update_index : public Plan_dml { +public: + Plan_update_index(Plan_root* root); + virtual ~Plan_update_index(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + void describe(Ctx& ctx); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setTable(Plan_table* table, Plan_table::Index* index); + void setDmlRow(Plan_dml_row* dmlRow); + void setQuery(Plan_query* query); +protected: + Plan_table* m_table; + Plan_table::Index* m_index; + Plan_dml_row* m_dmlRow; + Plan_query* m_query; +}; + +inline +Plan_update_index::Plan_update_index(Plan_root* root) : + Plan_dml(root), + m_table(0), + m_dmlRow(0), + m_query(0) +{ +} + +inline void +Plan_update_index::setTable(Plan_table* table, Plan_table::Index* index) +{ + ctx_assert(table != 0 && index != 0 && index == &table->m_indexList[index->m_pos] && index->m_pos != 0); + m_table = table; + m_index = index; +} + +inline void +Plan_update_index::setDmlRow(Plan_dml_row* dmlRow) +{ + ctx_assert(dmlRow != 0); + m_dmlRow = dmlRow; +} + +inline void +Plan_update_index::setQuery(Plan_query* query) +{ + ctx_assert(query != 0); + m_query = query; +} + +/** + * @class Exec_update_index + * @brief Insert in ExecTree + */ +class Exec_update_index : public Exec_dml { +public: + class Code : public Exec_dml::Code { + public: + Code(unsigned keyCount); + virtual ~Code(); + protected: + friend class Plan_update_index; + friend class Exec_update_index; + const char* m_tableName; + const char* m_indexName; + unsigned m_keyCount; + SqlSpecs m_keySpecs; // key types + NdbAttrId* m_keyId; + Exec_expr** m_keyMatch; // XXX pointers for now + unsigned m_attrCount; + NdbAttrId* m_attrId; + }; + class Data : public Exec_dml::Data { + public: + Data(); + virtual ~Data(); + protected: + friend class Exec_update_index; + }; + Exec_update_index(Exec_root* root); + virtual ~Exec_update_index(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setQuery(Exec_query* query); +protected: + Exec_query* m_query; +}; + +inline +Exec_update_index::Code::Code(unsigned keyCount) : + m_tableName(0), + m_indexName(0), + m_keyCount(keyCount), + m_keySpecs(keyCount), + m_keyId(0), + m_keyMatch(0), + m_attrCount(0), + m_attrId(0) +{ +} + +inline +Exec_update_index::Data::Data() +{ +} + +inline +Exec_update_index::Exec_update_index(Exec_root* root) : + Exec_dml(root), + m_query(0) +{ +} + +// children + +inline const Exec_update_index::Code& +Exec_update_index::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_update_index::Data& +Exec_update_index::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_update_index::setQuery(Exec_query* query) +{ + ctx_assert(query != 0 && m_query == 0); + m_query = query; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_update_lookup.cpp b/ndb/src/client/odbc/codegen/Code_update_lookup.cpp new file mode 100644 index 00000000000..7525fb72692 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_update_lookup.cpp @@ -0,0 +1,194 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "Code_dml_column.hpp" +#include "Code_expr.hpp" +#include "Code_update_lookup.hpp" +#include "Code_table.hpp" +#include "Code_root.hpp" + +// Plan_update_lookup + +Plan_update_lookup::~Plan_update_lookup() +{ +} + +Plan_base* +Plan_update_lookup::analyze(Ctx& ctx, Ctl& ctl) +{ + ctl.m_dmlRow = m_dmlRow; // row type to convert to + ctx_assert(m_query != 0); + m_query->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + ctx_assert(m_table != 0); + m_table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +void +Plan_update_lookup::describe(Ctx& ctx) +{ + stmtArea().setFunction(ctx, "UPDATE WHERE", SQL_DIAG_UPDATE_WHERE); +} + +Exec_base* +Plan_update_lookup::codegen(Ctx& ctx, Ctl& ctl) +{ + // generate code for the query + ctx_assert(m_query != 0); + Exec_query* execQuery = static_cast(m_query->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execQuery != 0); + // set up + ctx_assert(m_table != 0); + const BaseString& tableName = m_table->getName(); + const DictTable& dictTable = m_table->dictTable(); + const unsigned keyCount = dictTable.keyCount(); + const ColumnVector& columns = m_table->dmlColumns(); + ctx_assert(columns.size() > 0); + const unsigned attrCount = columns.size() - 1; + // create the code + Exec_update_lookup::Code& code = *new Exec_update_lookup::Code(keyCount); + code.m_tableName = strcpy(new char[tableName.length() + 1], tableName.c_str()); + // key attributes + code.m_keyId = new NdbAttrId[1 + keyCount]; + code.m_keyId[0] = (NdbAttrId)-1; + for (unsigned k = 1; k <= keyCount; k++) { + const DictColumn* keyColumn = dictTable.getKey(k); + const SqlType& sqlType = keyColumn->sqlType(); + SqlSpec sqlSpec(sqlType, SqlSpec::Physical); + code.m_keySpecs.setEntry(k, sqlSpec); + code.m_keyId[k] = keyColumn->getAttrId(); + } + // matching expressions + const Plan_table::Index& index = m_table->m_indexList[0]; + ctx_assert(index.m_keyFound); + const ExprVector& keyEq = index.m_keyEq; + ctx_assert(keyEq.size() == 1 + keyCount); + code.m_keyMatch = new Exec_expr* [1 + keyCount]; + code.m_keyMatch[0] = 0; + for (unsigned k = 1; k <= keyCount; k++) { + Plan_expr* expr = keyEq[k]; + Exec_expr* execExpr = static_cast(expr->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execExpr != 0); + code.m_keyMatch[k] = execExpr; + } + // updated attributes + code.m_attrCount = attrCount; + code.m_attrId = new NdbAttrId[1 + attrCount]; + code.m_attrId[0] = (NdbAttrId)-1; + for (unsigned i = 1; i <= attrCount; i++) { + Plan_column* column = columns[i]; + ctx_assert(column != 0); + const DictColumn& dictColumn = column->dictColumn(); + code.m_attrId[i] = dictColumn.getAttrId(); + } + // create the exec + Exec_update_lookup* exec = new Exec_update_lookup(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + exec->setCode(code); + exec->setQuery(execQuery); + return exec; +} + +void +Plan_update_lookup::print(Ctx& ctx) +{ + ctx.print(" [update_lookup"); + Plan_base* a[] = { m_table, m_query }; + printList(ctx, a, sizeof(a)/sizeof(a[0])); + ctx.print("]"); +} + +// Exec_delete + +Exec_update_lookup::Code::~Code() +{ + delete[] m_tableName; + delete[] m_keyId; + delete[] m_keyMatch; + delete[] m_attrId; +} + +Exec_update_lookup::Data::~Data() +{ +} + +Exec_update_lookup::~Exec_update_lookup() +{ +} + +void +Exec_update_lookup::alloc(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + // allocate the subquery + ctx_assert(m_query != 0); + m_query->alloc(ctx, ctl); + if (! ctx.ok()) + return; + // create data + Data& data = *new Data; + setData(data); + // allocate matching expressions + for (unsigned k = 1; k <= code.m_keyCount; k++) { + Exec_expr* expr = code.m_keyMatch[k]; + ctx_assert(expr != 0); + expr->alloc(ctx, ctl); + if (! ctx.ok()) + return; + } +} + +void +Exec_update_lookup::close(Ctx& ctx) +{ + ctx_assert(m_query != 0); + m_query->close(ctx); +} + +void +Exec_update_lookup::print(Ctx& ctx) +{ + ctx.print(" [update_lookup"); + if (m_code != 0) { + const Code& code = getCode(); + ctx.print(" keyId="); + for (unsigned i = 1; i <= code.m_keyCount; i++) { + if (i > 1) + ctx.print(","); + ctx.print("%u", (unsigned)code.m_keyId[i]); + } + ctx.print(" attrId="); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + if (i > 1) + ctx.print(","); + ctx.print("%u", (unsigned)code.m_attrId[i]); + } + } + Exec_base* a[] = { m_query }; + printList(ctx, a, 1); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_update_lookup.hpp b/ndb/src/client/odbc/codegen/Code_update_lookup.hpp new file mode 100644 index 00000000000..fc4341880dd --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_update_lookup.hpp @@ -0,0 +1,167 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_update_lookup_hpp +#define ODBC_CODEGEN_Code_update_lookup_hpp + +#include +#include "Code_base.hpp" +#include "Code_dml.hpp" +#include "Code_table.hpp" +#include "Code_query.hpp" + +/** + * @class Plan_update_lookup + * @brief Update in PlanTree + */ +class Plan_update_lookup : public Plan_dml { +public: + Plan_update_lookup(Plan_root* root); + virtual ~Plan_update_lookup(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + void describe(Ctx& ctx); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setTable(Plan_table* table); + void setDmlRow(Plan_dml_row* dmlRow); + void setQuery(Plan_query* query); +protected: + Plan_table* m_table; + Plan_dml_row* m_dmlRow; + Plan_query* m_query; +}; + +inline +Plan_update_lookup::Plan_update_lookup(Plan_root* root) : + Plan_dml(root), + m_table(0), + m_dmlRow(0), + m_query(0) +{ +} + +inline void +Plan_update_lookup::setTable(Plan_table* table) +{ + ctx_assert(table != 0); + m_table = table; +} + +inline void +Plan_update_lookup::setDmlRow(Plan_dml_row* dmlRow) +{ + ctx_assert(dmlRow != 0); + m_dmlRow = dmlRow; +} + +inline void +Plan_update_lookup::setQuery(Plan_query* query) +{ + ctx_assert(query != 0); + m_query = query; +} + +/** + * @class Exec_update_lookup + * @brief Insert in ExecTree + */ +class Exec_update_lookup : public Exec_dml { +public: + class Code : public Exec_dml::Code { + public: + Code(unsigned keyCount); + virtual ~Code(); + protected: + friend class Plan_update_lookup; + friend class Exec_update_lookup; + char* m_tableName; + unsigned m_keyCount; + SqlSpecs m_keySpecs; // key types + NdbAttrId* m_keyId; + Exec_expr** m_keyMatch; // XXX pointers for now + unsigned m_attrCount; + NdbAttrId* m_attrId; + }; + class Data : public Exec_dml::Data { + public: + Data(); + virtual ~Data(); + protected: + friend class Exec_update_lookup; + }; + Exec_update_lookup(Exec_root* root); + virtual ~Exec_update_lookup(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setQuery(Exec_query* query); +protected: + Exec_query* m_query; +}; + +inline +Exec_update_lookup::Code::Code(unsigned keyCount) : + m_tableName(0), + m_keyCount(keyCount), + m_keySpecs(keyCount), + m_keyId(0), + m_keyMatch(0), + m_attrCount(0), + m_attrId(0) +{ +} + +inline +Exec_update_lookup::Data::Data() +{ +} + +inline +Exec_update_lookup::Exec_update_lookup(Exec_root* root) : + Exec_dml(root), + m_query(0) +{ +} + +// children + +inline const Exec_update_lookup::Code& +Exec_update_lookup::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_update_lookup::Data& +Exec_update_lookup::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_update_lookup::setQuery(Exec_query* query) +{ + ctx_assert(query != 0 && m_query == 0); + m_query = query; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Code_update_scan.cpp b/ndb/src/client/odbc/codegen/Code_update_scan.cpp new file mode 100644 index 00000000000..9fac1728469 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_update_scan.cpp @@ -0,0 +1,146 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "Code_dml_column.hpp" +#include "Code_update_scan.hpp" +#include "Code_table.hpp" +#include "Code_root.hpp" + +// Plan_update_scan + +Plan_update_scan::~Plan_update_scan() +{ +} + +Plan_base* +Plan_update_scan::analyze(Ctx& ctx, Ctl& ctl) +{ + ctl.m_dmlRow = m_dmlRow; // row type to convert to + ctx_assert(m_query != 0); + m_query->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + ctx_assert(m_table != 0); + m_table->analyze(ctx, ctl); + if (! ctx.ok()) + return 0; + return this; +} + +void +Plan_update_scan::describe(Ctx& ctx) +{ + stmtArea().setFunction(ctx, "UPDATE WHERE", SQL_DIAG_UPDATE_WHERE); +} + +Exec_base* +Plan_update_scan::codegen(Ctx& ctx, Ctl& ctl) +{ + // generate code for the query + ctx_assert(m_query != 0); + Exec_query* execQuery = static_cast(m_query->codegen(ctx, ctl)); + if (! ctx.ok()) + return 0; + ctx_assert(execQuery != 0); + // set up + ctx_assert(m_table != 0); + const ColumnVector& columns = m_table->dmlColumns(); + ctx_assert(columns.size() > 0); + const unsigned attrCount = columns.size() - 1; + // create the code + Exec_update_scan::Code& code = *new Exec_update_scan::Code(); + // updated attributes + code.m_attrCount = attrCount; + code.m_attrId = new NdbAttrId[1 + attrCount]; + code.m_attrId[0] = (NdbAttrId)-1; + for (unsigned i = 1; i <= attrCount; i++) { + Plan_column* column = columns[i]; + ctx_assert(column != 0); + const DictColumn& dictColumn = column->dictColumn(); + code.m_attrId[i] = dictColumn.getAttrId(); + } + // create the exec + Exec_update_scan* exec = new Exec_update_scan(ctl.m_execRoot); + ctl.m_execRoot->saveNode(exec); + exec->setCode(code); + exec->setQuery(execQuery); + return exec; +} + +void +Plan_update_scan::print(Ctx& ctx) +{ + ctx.print(" [update_scan"); + Plan_base* a[] = { m_table, m_query }; + printList(ctx, a, sizeof(a)/sizeof(a[0])); + ctx.print("]"); +} + +// Exec_delete + +Exec_update_scan::Code::~Code() +{ + delete[] m_attrId; +} + +Exec_update_scan::Data::~Data() +{ +} + +Exec_update_scan::~Exec_update_scan() +{ +} + +void +Exec_update_scan::alloc(Ctx& ctx, Ctl& ctl) +{ + // allocate the subquery + ctx_assert(m_query != 0); + m_query->alloc(ctx, ctl); + if (! ctx.ok()) + return; + // create data + Data& data = *new Data; + setData(data); +} + +void +Exec_update_scan::close(Ctx& ctx) +{ + ctx_assert(m_query != 0); + m_query->close(ctx); +} + +void +Exec_update_scan::print(Ctx& ctx) +{ + ctx.print(" [update_scan"); + if (m_code != 0) { + const Code& code = getCode(); + ctx.print(" attrId="); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + if (i > 1) + ctx.print(","); + ctx.print("%u", (unsigned)code.m_attrId[i]); + } + } + Exec_base* a[] = { m_query }; + printList(ctx, a, 1); + ctx.print("]"); +} diff --git a/ndb/src/client/odbc/codegen/Code_update_scan.hpp b/ndb/src/client/odbc/codegen/Code_update_scan.hpp new file mode 100644 index 00000000000..d742883e561 --- /dev/null +++ b/ndb/src/client/odbc/codegen/Code_update_scan.hpp @@ -0,0 +1,160 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_Code_update_scan_hpp +#define ODBC_CODEGEN_Code_update_scan_hpp + +#include +#include "Code_base.hpp" +#include "Code_dml.hpp" +#include "Code_table.hpp" +#include "Code_pred.hpp" +#include "Code_query.hpp" + +/** + * @class Plan_update_scan + * @brief Update in PlanTree + */ +class Plan_update_scan : public Plan_dml { +public: + Plan_update_scan(Plan_root* root); + virtual ~Plan_update_scan(); + Plan_base* analyze(Ctx& ctx, Ctl& ctl); + void describe(Ctx& ctx); + Exec_base* codegen(Ctx& ctx, Ctl& ctl); + void print(Ctx& ctx); + // children + void setTable(Plan_table* table); + void setDmlRow(Plan_dml_row* dmlRow); + void setQuery(Plan_query* query); +protected: + Plan_table* m_table; + Plan_dml_row* m_dmlRow; + Plan_query* m_query; +}; + +inline +Plan_update_scan::Plan_update_scan(Plan_root* root) : + Plan_dml(root), + m_table(0), + m_dmlRow(0), + m_query(0) +{ +} + +// children + +inline void +Plan_update_scan::setTable(Plan_table* table) +{ + ctx_assert(table != 0); + m_table = table; +} + +inline void +Plan_update_scan::setDmlRow(Plan_dml_row* dmlRow) +{ + ctx_assert(dmlRow != 0); + m_dmlRow = dmlRow; +} + +inline void +Plan_update_scan::setQuery(Plan_query* query) +{ + ctx_assert(query != 0); + m_query = query; +} + +/** + * @class Exec_update_scan + * @brief Insert in ExecTree + */ +class Exec_update_scan : public Exec_dml { +public: + class Code : public Exec_dml::Code { + public: + Code(); + virtual ~Code(); + protected: + friend class Plan_update_scan; + friend class Exec_update_scan; + unsigned m_attrCount; + NdbAttrId* m_attrId; + }; + class Data : public Exec_dml::Data { + public: + Data(); + virtual ~Data(); + protected: + friend class Exec_update_scan; + }; + Exec_update_scan(Exec_root* root); + virtual ~Exec_update_scan(); + void alloc(Ctx& ctx, Ctl& ctl); + void execImpl(Ctx& ctx, Ctl& ctl); + void close(Ctx& ctx); + void print(Ctx& ctx); + // children + const Code& getCode() const; + Data& getData() const; + void setQuery(Exec_query* query); +protected: + Exec_query* m_query; +}; + +inline +Exec_update_scan::Code::Code() : + m_attrCount(0), + m_attrId(0) +{ +} + +inline +Exec_update_scan::Data::Data() +{ +} + +inline +Exec_update_scan::Exec_update_scan(Exec_root* root) : + Exec_dml(root), + m_query(0) +{ +} + +// children + +inline const Exec_update_scan::Code& +Exec_update_scan::getCode() const +{ + const Code* code = static_cast(m_code); + return *code; +} + +inline Exec_update_scan::Data& +Exec_update_scan::getData() const +{ + Data* data = static_cast(m_data); + return *data; +} + +inline void +Exec_update_scan::setQuery(Exec_query* query) +{ + ctx_assert(query != 0 && m_query == 0); + m_query = query; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/Makefile b/ndb/src/client/odbc/codegen/Makefile new file mode 100644 index 00000000000..49e5439556d --- /dev/null +++ b/ndb/src/client/odbc/codegen/Makefile @@ -0,0 +1,104 @@ +include .defs.mk + +TYPE = * + +NONPIC_ARCHIVE = N + +PIC_ARCHIVE = Y + +ARCHIVE_TARGET = odbccodegen + +SOURCES = \ + SimpleScan.lpp \ + SimpleGram.ypp \ + SimpleParser.cpp \ + CodeGen.cpp \ + Code_base.cpp \ + Code_root.cpp \ + Code_stmt.cpp \ + Code_query.cpp \ + Code_dml.cpp \ + Code_ddl.cpp \ + Code_select.cpp \ + Code_pred.cpp \ + Code_pred_op.cpp \ + Code_comp_op.cpp \ + Code_query_project.cpp \ + Code_query_filter.cpp \ + Code_query_join.cpp \ + Code_query_lookup.cpp \ + Code_query_index.cpp \ + Code_query_scan.cpp \ + Code_query_range.cpp \ + Code_query_sys.cpp \ + Code_query_repeat.cpp \ + Code_query_count.cpp \ + Code_query_sort.cpp \ + Code_query_group.cpp \ + Code_query_distinct.cpp \ + Code_expr_row.cpp \ + Code_expr.cpp \ + Code_expr_op.cpp \ + Code_expr_func.cpp \ + Code_expr_conv.cpp \ + Code_expr_column.cpp \ + Code_expr_const.cpp \ + Code_expr_param.cpp \ + Code_update.cpp \ + Code_update_lookup.cpp \ + Code_update_index.cpp \ + Code_update_scan.cpp \ + Code_set_row.cpp \ + Code_insert.cpp \ + Code_dml_row.cpp \ + Code_dml_column.cpp \ + Code_delete.cpp \ + Code_delete_lookup.cpp \ + Code_delete_index.cpp \ + Code_delete_scan.cpp \ + Code_column.cpp \ + Code_table_list.cpp \ + Code_table.cpp \ + Code_create_table.cpp \ + Code_create_index.cpp \ + Code_create_row.cpp \ + Code_ddl_row.cpp \ + Code_ddl_column.cpp \ + Code_ddl_constr.cpp \ + Code_idx_column.cpp \ + Code_data_type.cpp \ + Code_drop_table.cpp \ + Code_drop_index.cpp + +ifeq ($(NDB_OS),WIN32) +CCFLAGS += -I$(call fixpath,.) + +_libs:: FlexLexer.h unistd.h + +endif + +include ../Extra.mk +include $(NDB_TOP)/Epilogue.mk + +ifeq ($(NDB_OS),LINUX) +FLEXHACK = perl -i -pe 's/\bisatty\b/ouencunbwdb2y1bdc/g' +BISONHACK = perl -i -pe 's/^\s*__attribute__\s*\(\(.*\)\)//' +endif + +ifeq ($(NDB_OS),MACOSX) +FLEXHACK = perl -i -pe 's/\bisatty\b/ouencunbwdb2y1bdc/g' +BISONHACK = perl -i -pe 's/^\s*__attribute__\s*\(\(.*\)\)//' +endif + +ifeq ($(NDB_OS),SOLARIS) +BISONHACK = perl -i -pe 's/^\s*__attribute__\s*\(\(.*\)\)//' +endif + +ifeq ($(NDB_OS),WIN32) +unistd.h: + touch unistd.h + +FlexLexer.h: + cp /usr/include/FlexLexer.h . + +endif diff --git a/ndb/src/client/odbc/codegen/SimpleGram.ypp b/ndb/src/client/odbc/codegen/SimpleGram.ypp new file mode 100644 index 00000000000..d49344849d2 --- /dev/null +++ b/ndb/src/client/odbc/codegen/SimpleGram.ypp @@ -0,0 +1,1629 @@ +%{ + +#include +#include +#include +#include "CodeGen.hpp" +#include +#include "SimpleParser.hpp" + +/* redefine globals after headers */ +#define yyparse SimpleParser_yyparse +#if YYDEBUG +#define yydebug SimpleParser_yydebug +#endif + +#define YYLEX_PARAM simpleParserPtr +#define YYPARSE_PARAM simpleParserPtr +#define simpleParser (*static_cast(simpleParserPtr)) + +static int yylex(YYSTYPE* lvalp, void* simpleParserPtr); + +#define yyerror(s) simpleParser.parseError(s) + +#if YYDEBUG +// does not work in bison 1.75 +#undef stderr +#define stderr 0 +#define YYFPRINTF simpleParser.ctx().print +#endif + +// scanner states + +#define pushState(sc) simpleParser.pushState(sc) +#define popState() simpleParser.popState() + +#define StateEval SimpleParser_stateEval +#define StateType SimpleParser_stateType +#define StatePhys SimpleParser_statePhys +extern int SimpleParser_stateEval; +extern int SimpleParser_stateType; +extern int SimpleParser_statePhys; + +struct LimitPair { int off; int cnt; }; + +struct PhysAttr { int storage; int logging; }; + +%} + +%defines +%pure-parser +%verbose + +%union { + Plan_root* m_root; + Plan_stmt* m_stmt; + Plan_select* m_select; + Insert_op m_insert_op; + Plan_insert* m_insert; + Plan_update* m_update; + Plan_delete* m_delete; + Plan_create_table* m_create_table; + Plan_create_index* m_create_index; + NdbDictionary::Object::Type m_index_type; + Plan_create_row* m_create_row; + Plan_ddl_row* m_ddl_row; + Plan_ddl_column* m_ddl_column; + Plan_ddl_constr* m_ddl_constr; + Plan_idx_column* m_idx_column; + Plan_data_type* m_data_type; + Plan_drop_table* m_drop_table; + Plan_drop_index* m_drop_index; + Plan_set_row* m_set_row; + Plan_expr_row* m_expr_row; + bool m_asc_desc; + Plan_pred* m_pred; + Pred_op::Opcode m_pred_opcode; + Comp_op::Opcode m_comp_opcode; + Plan_expr* m_expr; + Expr_op::Opcode m_expr_opcode; + Plan_dml_row* m_dml_row; + Plan_dml_column* m_dml_column; + Plan_table* m_table; + Plan_table_list* m_table_list; + const char* m_string; + struct LimitPair* m_limit; + int m_signed_integer; + bool m_distinct; + struct PhysAttr* m_phys_attr; + NdbDictionary::Object::FragmentType m_storage_attr; + bool m_logging_attr; +} + +/* keywords */ +%token + T_AND + T_ASC + T_AUTO_INCREMENT + T_BIGINT + T_BINARY + T_BLOB + T_BY + T_CHAR + T_CONSTRAINT + T_CREATE + T_DATETIME + T_DEFAULT + T_DELETE + T_DESC + T_DISTINCT + T_DOUBLE + T_DROP + T_FLOAT + T_FOREIGN + T_FROM + T_GROUP + T_HASH + T_HAVING + T_IN + T_INDEX + T_INSERT + T_INT + T_INTEGER + T_INTO + T_IS + T_KEY + T_LARGE + T_LIKE + T_LIMIT + T_LOGGING + T_LONGBLOB + T_MEDIUM + T_NOLOGGING + T_NOT + T_NULL + T_OFFSET + T_ON + T_OR + T_ORDER + T_PRECISION + T_PRIMARY + T_REAL + T_REFERENCES + T_ROWNUM + T_SELECT + T_SET + T_SINGLE + T_SMALL + T_SMALLINT + T_STORAGE + T_SYSDATE + T_TABLE + T_UNIQUE + T_UNSIGNED + T_UPDATE + T_VALUES + T_VARBINARY + T_VARCHAR + T_WHERE + T_WRITE + +/* identifiers and constants */ +%token + T_IDENTIFIER + T_LINTEGER + T_LDECIMAL + T_LREAL + T_STRING + +/* expressions and predicates */ +%token + T_PLUS + T_MINUS + T_TIMES + T_DIVIDE + T_EQ + T_NOTEQ + T_LT + T_LTEQ + T_GT + T_GTEQ + T_QUES + +/* common special symbols */ +%token + T_PERIOD + T_COMMA + T_PARENLEFT + T_PARENRIGHT + T_ASTERISK + T_ASSIGN + +%type root +%type stmt +%type stmt_select +%type stmt_insert +%type insert_op +%type stmt_update +%type stmt_delete +%type create_table +%type create_index +%type index_type +%type create_row +%type create_column +%type create_constr +%type idx_column +%type data_type +%type ddl_row +%type ddl_column +%type drop_table +%type drop_index +%type asc_desc +%type set_row +%type expr_row +%type sort_row +%type where_clause +%type order_clause +%type pred +%type pred1 +%type pred1_op +%type pred2 +%type pred2_op +%type pred3 +%type pred3_op +%type pred4 +%type comp_op +%type expr +%type expr1 +%type expr1_op +%type expr2 +%type expr2_op +%type expr3 +%type expr3_op +%type expr4 +%type expr_column +%type dml_row +%type dml_column +%type value_row +%type value_expr +%type table +%type table_list +%type dot_identifier +%type limit_clause +%type signed_integer +%type distinct_clause +%type group_clause +%type having_clause +%type phys_attr +%type phys_attr2 +%type storage_attr +%type logging_attr + +%% + +root: + stmt + { + Plan_root* root = simpleParser.root(); + root->setStmt($1); + } + ; +stmt: + stmt_select + { + $$ = $1; + } + | + stmt_insert + { + $$ = $1; + } + | + stmt_update + { + $$ = $1; + } + | + stmt_delete + { + $$ = $1; + } + | + create_table + { + $$ = $1; + } + | + create_index + { + $$ = $1; + } + | + drop_table + { + $$ = $1; + } + | + drop_index + { + $$ = $1; + } + ; +stmt_select: + T_SELECT distinct_clause expr_row T_FROM table_list where_clause group_clause having_clause order_clause limit_clause + { + Plan_root* root = simpleParser.root(); + Plan_select* stmt = new Plan_select(root); + root->saveNode(stmt); + stmt->setDistinct($2); + stmt->setRow($3); + stmt->setList($5); + if ($6 != 0) + stmt->setPred($6); + if ($7 != 0) + stmt->setGroup($7); + if ($8 != 0) + stmt->setHaving($8); + if ($9 != 0) + stmt->setSort($9); + if ($10 != 0) { + stmt->setLimit($10->off, $10->cnt); + delete $10; + } + $$ = stmt; + } + ; +stmt_insert: + insert_op T_INTO table T_VALUES T_PARENLEFT value_row T_PARENRIGHT + { + Plan_root* root = simpleParser.root(); + Plan_insert* stmt = new Plan_insert(root, $1); + root->saveNode(stmt); + stmt->setTable($3); + stmt->setExprRow($6); + $$ = stmt; + } + | + insert_op T_INTO table T_PARENLEFT dml_row T_PARENRIGHT T_VALUES T_PARENLEFT value_row T_PARENRIGHT + { + Plan_root* root = simpleParser.root(); + Plan_insert* stmt = new Plan_insert(root, $1); + root->saveNode(stmt); + stmt->setTable($3); + stmt->setDmlRow($5); + stmt->setExprRow($9); + $$ = stmt; + } + | + insert_op T_INTO table stmt_select + { + Plan_root* root = simpleParser.root(); + Plan_insert* stmt = new Plan_insert(root, $1); + root->saveNode(stmt); + stmt->setTable($3); + stmt->setSelect($4); + $$ = stmt; + } + | + insert_op T_INTO table T_PARENLEFT dml_row T_PARENRIGHT stmt_select + { + Plan_root* root = simpleParser.root(); + Plan_insert* stmt = new Plan_insert(root, $1); + root->saveNode(stmt); + stmt->setTable($3); + stmt->setDmlRow($5); + stmt->setSelect($7); + $$ = stmt; + } + | + insert_op T_INTO table T_SET set_row + { + Plan_root* root = simpleParser.root(); + Plan_insert* stmt = new Plan_insert(root, $1); + root->saveNode(stmt); + stmt->setTable($3); + stmt->setMysqlRow($5); + $$ = stmt; + } + ; +insert_op: + T_INSERT + { + $$ = Insert_op_insert; + } + | + T_WRITE + { + $$ = Insert_op_write; + } + ; +stmt_update: + T_UPDATE table T_SET set_row where_clause + { + Plan_root* root = simpleParser.root(); + Plan_update* stmt = new Plan_update(root); + root->saveNode(stmt); + stmt->setTable($2); + stmt->setRow($4); + if ($5 != 0) + stmt->setPred($5); + $$ = stmt; + } + ; +stmt_delete: + T_DELETE T_FROM table where_clause + { + Plan_root* root = simpleParser.root(); + Plan_delete* stmt = new Plan_delete(root); + root->saveNode(stmt); + stmt->setTable($3); + if ($4 != 0) + stmt->setPred($4); + $$ = stmt; + } + ; +create_table: + T_CREATE T_TABLE dot_identifier T_PARENLEFT create_row T_PARENRIGHT phys_attr + { + Plan_root* root = simpleParser.root(); + Plan_create_table* stmt = new Plan_create_table(root, $3); + root->saveNode(stmt); + delete[] $3; + stmt->setCreateRow($5); + if ($7->storage != -1) + stmt->setFragmentType((NdbDictionary::Object::FragmentType)$7->storage); + if ($7->logging != -1) + stmt->setLogging($7->logging); + delete $7; + $$ = stmt; + } + ; +create_row: + create_column + { + Plan_root* root = simpleParser.root(); + Plan_create_row* createRow = new Plan_create_row(root); + root->saveNode(createRow); + createRow->addColumn($1); + $$ = createRow; + } + | + create_constr + { + Plan_root* root = simpleParser.root(); + Plan_create_row* createRow = new Plan_create_row(root); + root->saveNode(createRow); + createRow->addConstr($1); + $$ = createRow; + } + | + create_row T_COMMA create_column + { + Plan_create_row* createRow = $1; + createRow->addColumn($3); + $$ = createRow; + } + | + create_row T_COMMA create_constr + { + Plan_create_row* createRow = $1; + createRow->addConstr($3); + $$ = createRow; + } + | + create_row T_COMMA create_ignore + { + $$ = $1; + } + ; +create_column: + T_IDENTIFIER { pushState(StateType); } data_type { popState(); } + { + Plan_root* root = simpleParser.root(); + Plan_ddl_column* ddlColumn = new Plan_ddl_column(root, $1); + root->saveNode(ddlColumn); + delete[] $1; + ddlColumn->setType($3); + simpleParser.curr(ddlColumn); + } + create_column_rest + { + $$ = simpleParser.curr((Plan_ddl_column*)0); + } + ; +data_type: + T_CHAR T_PARENLEFT T_LINTEGER T_PARENRIGHT dummy_binary + { + Plan_root* root = simpleParser.root(); + SqlType sqlType(simpleParser.ctx(), SqlType::Char, atoi($3), true); + delete[] $3; + if (! simpleParser.ctx().ok()) { + YYABORT; + } + Plan_data_type* dataType = new Plan_data_type(root, sqlType); + root->saveNode(dataType); + $$ = dataType; + } + | + T_BINARY T_PARENLEFT T_LINTEGER T_PARENRIGHT + { + Plan_root* root = simpleParser.root(); + SqlType sqlType(simpleParser.ctx(), SqlType::Binary, atoi($3), true); + delete[] $3; + if (! simpleParser.ctx().ok()) { + YYABORT; + } + Plan_data_type* dataType = new Plan_data_type(root, sqlType); + root->saveNode(dataType); + $$ = dataType; + } + | + T_VARCHAR T_PARENLEFT T_LINTEGER T_PARENRIGHT dummy_binary + { + Plan_root* root = simpleParser.root(); + SqlType sqlType(simpleParser.ctx(), SqlType::Varchar, atoi($3), true); + delete[] $3; + if (! simpleParser.ctx().ok()) { + YYABORT; + } + Plan_data_type* dataType = new Plan_data_type(root, sqlType); + root->saveNode(dataType); + $$ = dataType; + } + | + T_VARBINARY T_PARENLEFT T_LINTEGER T_PARENRIGHT + { + Plan_root* root = simpleParser.root(); + SqlType sqlType(simpleParser.ctx(), SqlType::Varbinary, atoi($3), true); + delete[] $3; + if (! simpleParser.ctx().ok()) { + YYABORT; + } + Plan_data_type* dataType = new Plan_data_type(root, sqlType); + root->saveNode(dataType); + $$ = dataType; + } + | + T_SMALLINT + { + Plan_root* root = simpleParser.root(); + SqlType sqlType(SqlType::Smallint, true); + Plan_data_type* dataType = new Plan_data_type(root, sqlType); + root->saveNode(dataType); + $$ = dataType; + } + | + T_INTEGER + { + Plan_root* root = simpleParser.root(); + SqlType sqlType(SqlType::Integer, true); + Plan_data_type* dataType = new Plan_data_type(root, sqlType); + root->saveNode(dataType); + $$ = dataType; + } + | + T_INT + { + Plan_root* root = simpleParser.root(); + SqlType sqlType(SqlType::Integer, true); + Plan_data_type* dataType = new Plan_data_type(root, sqlType); + root->saveNode(dataType); + $$ = dataType; + } + | + T_BIGINT + { + Plan_root* root = simpleParser.root(); + SqlType sqlType(SqlType::Bigint, true); + Plan_data_type* dataType = new Plan_data_type(root, sqlType); + root->saveNode(dataType); + $$ = dataType; + } + | + T_REAL + { + Plan_root* root = simpleParser.root(); + SqlType sqlType(SqlType::Real, true); + Plan_data_type* dataType = new Plan_data_type(root, sqlType); + root->saveNode(dataType); + $$ = dataType; + } + | + T_FLOAT + { + Plan_root* root = simpleParser.root(); + SqlType sqlType(SqlType::Double, true); + Plan_data_type* dataType = new Plan_data_type(root, sqlType); + root->saveNode(dataType); + $$ = dataType; + } + | + T_DOUBLE T_PRECISION + { + Plan_root* root = simpleParser.root(); + SqlType sqlType(SqlType::Double, true); + Plan_data_type* dataType = new Plan_data_type(root, sqlType); + root->saveNode(dataType); + $$ = dataType; + } + | + T_DATETIME + { + Plan_root* root = simpleParser.root(); + SqlType sqlType(SqlType::Datetime, true); + Plan_data_type* dataType = new Plan_data_type(root, sqlType); + root->saveNode(dataType); + $$ = dataType; + } + | + blob_keyword + { + Plan_root* root = simpleParser.root(); + SqlType sqlType(SqlType::Blob, true); + Plan_data_type* dataType = new Plan_data_type(root, sqlType); + root->saveNode(dataType); + $$ = dataType; + } + ; +dummy_binary: + /* empty */ + | + T_BINARY + ; +blob_keyword: + T_BLOB + | + T_LONGBLOB + ; +create_column_rest: + /* empty */ + | + data_constr_list + ; +data_constr_list: + data_constr + | + data_constr_list data_constr + ; +data_constr: + T_NULL + | + T_NOT T_NULL + { + Plan_ddl_column* ddlColumn = simpleParser.curr((Plan_ddl_column*)0); + ddlColumn->setNotNull(); + } + | + T_UNSIGNED + { + Plan_ddl_column* ddlColumn = simpleParser.curr((Plan_ddl_column*)0); + ddlColumn->setUnSigned(); + } + | + T_PRIMARY T_KEY + { + Plan_ddl_column* ddlColumn = simpleParser.curr((Plan_ddl_column*)0); + ddlColumn->setPrimaryKey(); + } + | + T_AUTO_INCREMENT + { + Plan_ddl_column* ddlColumn = simpleParser.curr((Plan_ddl_column*)0); + ddlColumn->setAutoIncrement(); + } + | + T_DEFAULT expr + { + Plan_ddl_column* ddlColumn = simpleParser.curr((Plan_ddl_column*)0); + ddlColumn->setDefaultValue($2); + } + ; +create_constr: + T_PRIMARY T_KEY T_PARENLEFT ddl_row T_PARENRIGHT + { + Plan_root* root = simpleParser.root(); + Plan_ddl_constr* ddlConstr = new Plan_ddl_constr(root); + root->saveNode(ddlConstr); + ddlConstr->setRow($4); + $$ = ddlConstr; + } + | + T_CONSTRAINT dot_identifier T_PRIMARY T_KEY T_PARENLEFT ddl_row T_PARENRIGHT + { + Plan_root* root = simpleParser.root(); + Plan_ddl_constr* ddlConstr = new Plan_ddl_constr(root); + root->saveNode(ddlConstr); + ddlConstr->setRow($6); + $$ = ddlConstr; + } + ; +create_ignore: + T_INDEX dot_identifier T_PARENLEFT ddl_row T_PARENRIGHT + | + T_FOREIGN T_KEY T_PARENLEFT ddl_row T_PARENRIGHT T_REFERENCES dot_identifier T_PARENLEFT ddl_row T_PARENRIGHT + ; +ddl_row: + ddl_column + { + Plan_root* root = simpleParser.root(); + Plan_ddl_row* ddlRow = new Plan_ddl_row(root); + root->saveNode(ddlRow); + ddlRow->addColumn($1); + $$ = ddlRow; + } + | + ddl_row T_COMMA ddl_column + { + Plan_ddl_row* ddlRow = $1; + ddlRow->addColumn($3); + $$ = ddlRow; + } + ; +ddl_column: + T_IDENTIFIER + { + Plan_root* root = simpleParser.root(); + Plan_ddl_column* column = new Plan_ddl_column(root, $1); + root->saveNode(column); + delete[] $1; + $$ = column; + } + ; +create_index: + T_CREATE index_type T_INDEX dot_identifier T_ON table + { + Plan_root* root = simpleParser.root(); + Plan_create_index* stmt = new Plan_create_index(root, $4); + root->saveNode(stmt); + delete[] $4; + stmt->setType($2); + stmt->setTable($6); + simpleParser.curr(stmt); + } + T_PARENLEFT idx_row T_PARENRIGHT phys_attr + { + $$ = simpleParser.curr((Plan_create_index*)0); + if ($11->storage != -1) + $$->setFragmentType((NdbDictionary::Object::FragmentType)$11->storage); + if ($11->logging != -1) + $$->setLogging($11->logging); + delete $11; + } + ; +index_type: + T_HASH + { + $$ = NdbDictionary::Object::HashIndex; + } + | + T_UNIQUE T_HASH + { + $$ = NdbDictionary::Object::UniqueHashIndex; + } + | + /* empty */ + { + $$ = NdbDictionary::Object::OrderedIndex; + } + | + T_UNIQUE + { + $$ = NdbDictionary::Object::UniqueOrderedIndex; + } + ; +idx_row: + idx_column + { + } + | + idx_row T_COMMA idx_column + { + } + ; +idx_column: + T_IDENTIFIER + { + Plan_root* root = simpleParser.root(); + Plan_idx_column* column = new Plan_idx_column(root, $1); + root->saveNode(column); + delete[] $1; + Plan_create_index* stmt = simpleParser.curr((Plan_create_index*)0); + stmt->addColumn(column); + } + ; +phys_attr: + { pushState(StatePhys); } phys_attr2 { popState(); } + { + $$ = $2; + } + ; +phys_attr2: + /* empty */ + { + $$ = new PhysAttr(); + $$->storage = $$->logging = -1; + } + | + phys_attr2 storage_attr + { + if ($1->storage != -1 && $1->storage != $2) { + simpleParser.ctx().pushStatus(Sqlstate::_42000, Error::Gen, "conflicting STORAGE clauses"); + YYABORT; + } + $$->storage = $2; + } + | + phys_attr2 logging_attr + { + if ($1->logging != -1 && $1->logging != $2) { + simpleParser.ctx().pushStatus(Sqlstate::_42000, Error::Gen, "conflicting LOGGING clauses"); + YYABORT; + } + $$->logging = $2; + } + ; +logging_attr: + T_LOGGING + { + $$ = true; + } + | + T_NOLOGGING + { + $$ = false; + } + ; +storage_attr: + T_STORAGE T_PARENLEFT T_SINGLE T_PARENRIGHT + { + $$ = NdbDictionary::Object::FragSingle; + } + | + T_STORAGE T_PARENLEFT T_SMALL T_PARENRIGHT + { + $$ = NdbDictionary::Object::FragAllSmall; + } + | + T_STORAGE T_PARENLEFT T_MEDIUM T_PARENRIGHT + { + $$ = NdbDictionary::Object::FragAllMedium; + } + | + T_STORAGE T_PARENLEFT T_LARGE T_PARENRIGHT + { + $$ = NdbDictionary::Object::FragAllLarge; + } + ; +drop_table: + T_DROP T_TABLE dot_identifier + { + Plan_root* root = simpleParser.root(); + Plan_drop_table* stmt = new Plan_drop_table(root, $3); + root->saveNode(stmt); + delete[] $3; + $$ = stmt; + } + ; +drop_index: + T_DROP T_INDEX dot_identifier + { + Plan_root* root = simpleParser.root(); + Plan_drop_index* stmt = new Plan_drop_index(root, $3); + root->saveNode(stmt); + delete[] $3; + $$ = stmt; + } + | + T_DROP T_INDEX dot_identifier T_ON dot_identifier + { + Plan_root* root = simpleParser.root(); + Plan_drop_index* stmt = new Plan_drop_index(root, $3, $5); + root->saveNode(stmt); + delete[] $3; + delete[] $5; + $$ = stmt; + } + ; +distinct_clause: + /* empty */ + { + $$ = false; + } + | + T_DISTINCT + { + $$ = true; + } + ; +where_clause: + /* empty */ + { + $$ = 0; + } + | + T_WHERE pred + { + $$ = $2; + } + ; +group_clause: + /* empty */ + { + $$ = 0; + } + | + T_GROUP T_BY value_row + { + $$ = $3; + } + ; +having_clause: + /* empty */ + { + $$ = 0; + } + | + T_HAVING pred + { + $$ = $2; + } + ; +order_clause: + /* empty */ + { + $$ = 0; + } + | + T_ORDER T_BY sort_row + { + $$ = $3; + } + ; +limit_clause: + /* empty */ + { + $$ = 0; + } + | + T_LIMIT signed_integer + { + LimitPair* p = new LimitPair; + p->off = 0; + p->cnt = $2; + $$ = p; + } + | + T_LIMIT signed_integer T_COMMA signed_integer + { + LimitPair* p = new LimitPair; + p->off = $2, + p->cnt = $4; + $$ = p; + } + | + T_LIMIT signed_integer T_OFFSET signed_integer + { + LimitPair* p = new LimitPair; + p->off = $4; + p->cnt = $2; + $$ = p; + } + ; +signed_integer: + T_LINTEGER + { + $$ = atoi($1); + delete[] $1; + } + | + T_MINUS T_LINTEGER + { + $$ = (-1) * atoi($2); + delete[] $2; + } + ; +set_row: + dml_column T_ASSIGN expr + { + Plan_root* root = simpleParser.root(); + Plan_set_row* row = new Plan_set_row(root); + root->saveNode(row); + row->addColumn($1); + row->addExpr($3); + $$ = row; + } + | + set_row T_COMMA dml_column T_ASSIGN expr + { + Plan_set_row* row = $1; + row->addColumn($3); + row->addExpr($5); + $$ = row; + } + ; +dml_row: + dml_column + { + Plan_root* root = simpleParser.root(); + Plan_dml_row* row = new Plan_dml_row(root); + root->saveNode(row); + row->addColumn($1); + $$ = row; + } + | + dml_row T_COMMA dml_column + { + Plan_dml_row* row = $1; + row->addColumn($3); + $$ = row; + } + ; +dml_column: + T_IDENTIFIER + { + Plan_root* root = simpleParser.root(); + Plan_dml_column* column = new Plan_dml_column(root, $1); + root->saveNode(column); + delete[] $1; + $$ = column; + } + ; +value_row: + value_expr + { + Plan_root* root = simpleParser.root(); + Plan_expr_row* row = new Plan_expr_row(root); + root->saveNode(row); + row->addExpr($1); + $$ = row; + } + | + value_row T_COMMA value_expr + { + Plan_expr_row* row = $1; + row->addExpr($3); + $$ = row; + } + ; +value_expr: + expr + { + $$ = $1; + } + ; +sort_row: + expr asc_desc + { + Plan_root* root = simpleParser.root(); + Plan_expr_row* row = new Plan_expr_row(root); + root->saveNode(row); + row->addExpr($1, $2); + $$ = row; + } + | + sort_row T_COMMA expr asc_desc + { + Plan_expr_row* row = $1; + row->addExpr($3, $4); + $$ = row; + } + ; +asc_desc: + /* empty */ + { + $$ = true; + } + | + T_ASC + { + $$ = true; + } + | + T_DESC + { + $$ = false; + } + ; +expr_row: + T_ASTERISK + { + Plan_root* root = simpleParser.root(); + Plan_expr_row* row = new Plan_expr_row(root); + root->saveNode(row); + row->setAsterisk(); + $$ = row; + } + | + T_TIMES /* XXX fix scanner state */ + { + Plan_root* root = simpleParser.root(); + Plan_expr_row* row = new Plan_expr_row(root); + root->saveNode(row); + row->setAsterisk(); + $$ = row; + } + | + expr + { + Plan_root* root = simpleParser.root(); + Plan_expr_row* row = new Plan_expr_row(root); + root->saveNode(row); + row->addExpr($1); + $$ = row; + } + | + expr T_IDENTIFIER + { + Plan_root* root = simpleParser.root(); + Plan_expr_row* row = new Plan_expr_row(root); + root->saveNode(row); + row->addExpr($1, BaseString($2)); + $$ = row; + } + | + expr_row T_COMMA expr + { + Plan_expr_row* row = $1; + row->addExpr($3); + $$ = row; + } + | + expr_row T_COMMA expr T_IDENTIFIER + { + Plan_expr_row* row = $1; + row->addExpr($3, BaseString($4)); + $$ = row; + } + ; +pred: + { pushState(StateEval); } pred1 { popState(); } + { + $$ = $2; + } + ; +pred1: + pred2 + { + $$ = $1; + } + | + pred1 pred1_op pred2 + { + Plan_root* root = simpleParser.root(); + Pred_op op($2); + Plan_pred_op* pred = new Plan_pred_op(root, op); + root->saveNode(pred); + pred->setPred(1, $1); + pred->setPred(2, $3); + $$ = pred; + } + ; +pred1_op: + T_OR + { + $$ = Pred_op::Or; + } + ; +pred2: + pred3 + { + $$ = $1; + } + | + pred2 pred2_op pred3 + { + Plan_root* root = simpleParser.root(); + Pred_op op($2); + Plan_pred_op* pred = new Plan_pred_op(root, op); + root->saveNode(pred); + pred->setPred(1, $1); + pred->setPred(2, $3); + $$ = pred; + } + ; +pred2_op: + T_AND + { + $$ = Pred_op::And; + } + ; +pred3: + pred4 + { + $$ = $1; + } + | + pred3_op pred3 + { + Plan_root* root = simpleParser.root(); + Pred_op op($1); + Plan_pred_op* pred = new Plan_pred_op(root, op); + root->saveNode(pred); + pred->setPred(1, $2); + $$ = pred; + } + ; +pred3_op: + T_NOT + { + $$ = Pred_op::Not; + } + ; +pred4: + T_PARENLEFT pred1 T_PARENRIGHT + { + $$ = $2; + } + | + expr1 comp_op expr1 + { + Plan_root* root = simpleParser.root(); + Comp_op op($2); + Plan_comp_op* comp = new Plan_comp_op(root, op); + root->saveNode(comp); + comp->setExpr(1, $1); + comp->setExpr(2, $3); + $$ = comp; + } + | + expr1 T_IS T_NULL + { + Plan_root* root = simpleParser.root(); + Comp_op op(Comp_op::Isnull); + Plan_comp_op* comp = new Plan_comp_op(root, op); + root->saveNode(comp); + comp->setExpr(1, $1); + $$ = comp; + } + | + expr1 T_IS T_NOT T_NULL + { + Plan_root* root = simpleParser.root(); + Comp_op op(Comp_op::Isnotnull); + Plan_comp_op* comp = new Plan_comp_op(root, op); + root->saveNode(comp); + comp->setExpr(1, $1); + $$ = comp; + } + | + expr1 T_IN T_PARENLEFT value_row T_PARENRIGHT + { + Plan_root* root = simpleParser.root(); + Plan_pred* predOut = 0; // hack directly into Or of Eq + Plan_expr* exprLeft = $1; + Plan_expr_row* row = $4; + for (unsigned i = row->getSize(); i >= 1; i--) { + Plan_expr* exprRight = row->getExpr(i); + Plan_comp_op* comp = new Plan_comp_op(root, Comp_op::Eq); + root->saveNode(comp); + comp->setExpr(1, exprLeft); + comp->setExpr(2, exprRight); + if (predOut == 0) { + predOut = comp; + } else { + Plan_pred_op* pred = new Plan_pred_op(root, Pred_op::Or); + root->saveNode(pred); + pred->setPred(1, predOut); + pred->setPred(2, comp); + predOut = pred; + } + } + $$ = predOut; + } + | + expr1 T_NOT T_IN T_PARENLEFT value_row T_PARENRIGHT + { + Plan_root* root = simpleParser.root(); + Plan_pred* predOut = 0; // hack directly into And of Noteq + Plan_expr* exprLeft = $1; + Plan_expr_row* row = $5; + for (unsigned i = row->getSize(); i >= 1; i--) { + Plan_expr* exprRight = row->getExpr(i); + Plan_comp_op* comp = new Plan_comp_op(root, Comp_op::Noteq); + root->saveNode(comp); + comp->setExpr(1, exprLeft); + comp->setExpr(2, exprRight); + if (predOut == 0) { + predOut = comp; + } else { + Plan_pred_op* pred = new Plan_pred_op(root, Pred_op::And); + root->saveNode(pred); + pred->setPred(1, predOut); + pred->setPred(2, comp); + predOut = pred; + } + } + $$ = predOut; + } + ; +comp_op: + T_EQ + { + $$ = Comp_op::Eq; + } + | + T_NOTEQ + { + $$ = Comp_op::Noteq; + } + | + T_LT + { + $$ = Comp_op::Lt; + } + | + T_LTEQ + { + $$ = Comp_op::Lteq; + } + | + T_GT + { + $$ = Comp_op::Gt; + } + | + T_GTEQ + { + $$ = Comp_op::Gteq; + } + | + T_LIKE + { + $$ = Comp_op::Like; + } + | + T_NOT T_LIKE + { + $$ = Comp_op::Notlike; + } + ; +expr: + { pushState(StateEval); } expr1 { popState(); } + { + $$ = $2; + } + ; +expr1: + expr2 + { + $$ = $1; + } + | + expr1 expr1_op expr2 + { + Plan_root* root = simpleParser.root(); + Expr_op op($2); + Plan_expr_op* expr = new Plan_expr_op(root, op); + root->saveNode(expr); + expr->setExpr(1, $1); + expr->setExpr(2, $3); + $$ = expr; + } + ; +expr1_op: + T_PLUS + { + $$ = Expr_op::Add; + } + | + T_MINUS + { + $$ = Expr_op::Subtract; + } + ; +expr2: + expr3 + { + $$ = $1; + } + | + expr2 expr2_op expr3 + { + Plan_root* root = simpleParser.root(); + Expr_op op($2); + Plan_expr_op* expr = new Plan_expr_op(root, op); + root->saveNode(expr); + expr->setExpr(1, $1); + expr->setExpr(2, $3); + $$ = expr; + } + ; +expr2_op: + T_TIMES + { + $$ = Expr_op::Multiply; + } + | + T_DIVIDE + { + $$ = Expr_op::Divide; + } + ; +expr3: + expr4 + { + $$ = $1; + } + | + expr3_op expr3 + { + Plan_root* root = simpleParser.root(); + Expr_op op($1); + Plan_expr_op* expr = new Plan_expr_op(root, op); + root->saveNode(expr); + expr->setExpr(1, $2); + $$ = expr; + } + ; +expr3_op: + T_PLUS + { + $$ = Expr_op::Plus; + } + | + T_MINUS + { + $$ = Expr_op::Minus; + } + ; +expr4: + T_PARENLEFT expr1 T_PARENRIGHT + { + $$ = $2; + } + | + T_IDENTIFIER T_PARENLEFT expr_row T_PARENRIGHT + { + Plan_root* root = simpleParser.root(); + const Expr_func& spec = Expr_func::find($1); + if (spec.m_name == 0) { + simpleParser.ctx().pushStatus(Sqlstate::_42000, Error::Gen, "unknown function %s", $1); + delete[] $1; + YYABORT; + } + Plan_expr_func* func = new Plan_expr_func(root, spec); + root->saveNode(func); + delete[] $1; + func->setArgs($3); + $$ = func; + } + | + T_ROWNUM + { + Plan_root* root = simpleParser.root(); + const Expr_func& spec = Expr_func::find("ROWNUM"); + ctx_assert(spec.m_name != 0); + Plan_expr_func* func = new Plan_expr_func(root, spec); + root->saveNode(func); + func->setArgs(0); + $$ = func; + } + | + T_SYSDATE + { + Plan_root* root = simpleParser.root(); + const Expr_func& spec = Expr_func::find("SYSDATE"); + ctx_assert(spec.m_name != 0); + Plan_expr_func* func = new Plan_expr_func(root, spec); + root->saveNode(func); + func->setArgs(0); + $$ = func; + } + | + expr_column + { + $$ = $1; + } + | + T_STRING + { + Plan_root* root = simpleParser.root(); + LexType lexType(LexType::Char); + Plan_expr_const* expr = new Plan_expr_const(root, lexType, $1); + root->saveNode(expr); + delete[] $1; + $$ = expr; + } + | + T_LINTEGER + { + Plan_root* root = simpleParser.root(); + LexType lexType(LexType::Integer); + Plan_expr_const* expr = new Plan_expr_const(root, lexType, $1); + root->saveNode(expr); + delete[] $1; + $$ = expr; + } + | + T_LDECIMAL + { + Plan_root* root = simpleParser.root(); + LexType lexType(LexType::Float); + Plan_expr_const* expr = new Plan_expr_const(root, lexType, $1); + root->saveNode(expr); + delete[] $1; + $$ = expr; + } + | + T_LREAL + { + Plan_root* root = simpleParser.root(); + LexType lexType(LexType::Float); + Plan_expr_const* expr = new Plan_expr_const(root, lexType, $1); + root->saveNode(expr); + delete[] $1; + $$ = expr; + } + | + T_NULL + { + Plan_root* root = simpleParser.root(); + LexType lexType(LexType::Null); + Plan_expr_const* expr = new Plan_expr_const(root, lexType, ""); + root->saveNode(expr); + $$ = expr; + } + | + T_QUES + { + Plan_root* root = simpleParser.root(); + unsigned paramNumber = simpleParser.paramNumber(); + ctx_assert(paramNumber != 0); + Plan_expr_param* expr = new Plan_expr_param(root, paramNumber); + root->saveNode(expr); + $$ = expr; + } + ; +expr_column: + T_IDENTIFIER + { + Plan_root* root = simpleParser.root(); + Plan_expr_column* column = new Plan_expr_column(root, $1); + root->saveNode(column); + delete[] $1; + $$ = column; + } + | + T_IDENTIFIER T_PERIOD T_IDENTIFIER + { + Plan_root* root = simpleParser.root(); + Plan_expr_column* column = new Plan_expr_column(root, $3); + root->saveNode(column); + delete[] $3; + column->setCname($1); + $$ = column; + } + | + T_IDENTIFIER T_PERIOD T_IDENTIFIER T_PERIOD T_IDENTIFIER + { + Plan_root* root = simpleParser.root(); + BaseString str; + str.append($1); + str.append("."); + str.append($3); + delete[] $1; + delete[] $3; + Plan_expr_column* column = new Plan_expr_column(root, $5); + root->saveNode(column); + delete[] $5; + column->setCname(str); + $$ = column; + } + ; +table_list: + table + { + Plan_root* root = simpleParser.root(); + Plan_table_list* tableList = new Plan_table_list(root); + root->saveNode(tableList); + tableList->addTable($1); + $$ = tableList; + } + | + table_list T_COMMA table + { + Plan_table_list* tableList = $1; + tableList->addTable($3); + $$ = tableList; + } + ; +table: + dot_identifier + { + Plan_root* root = simpleParser.root(); + Plan_table* table = new Plan_table(root, $1); + root->saveNode(table); + delete[] $1; + $$ = table; + } + | + dot_identifier T_IDENTIFIER + { + Plan_root* root = simpleParser.root(); + Plan_table* table = new Plan_table(root, $1); + root->saveNode(table); + delete[] $1; + table->setCname($2); + delete[] $2; + $$ = table; + } + ; +dot_identifier: + T_IDENTIFIER + { + $$ = $1; + } + | + T_IDENTIFIER T_PERIOD T_IDENTIFIER + { + char* s = new char[strlen($1) + 1 + strlen($3) + 1]; + strcpy(s, $1); + strcat(s, "."); + strcat(s, $3); + delete[] $1; + delete[] $3; + $$ = s; + } + ; + +%% + +static int +yylex(YYSTYPE* lvalp, void* simpleParserPtr) +{ + int ret = simpleParser.yylex(); + *lvalp = simpleParser.yylval(); + return ret; +} + +/* vim: set filetype=yacc: */ diff --git a/ndb/src/client/odbc/codegen/SimpleParser.cpp b/ndb/src/client/odbc/codegen/SimpleParser.cpp new file mode 100644 index 00000000000..62162172bc8 --- /dev/null +++ b/ndb/src/client/odbc/codegen/SimpleParser.cpp @@ -0,0 +1,95 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "SimpleParser.hpp" + +SimpleParser::~SimpleParser() +{ +} + +#ifdef NDB_WIN32 +static NdbMutex & parse_mutex = * NdbMutex_Create(); +#else +static NdbMutex parse_mutex = NDB_MUTEX_INITIALIZER; +#endif + +void +SimpleParser::yyparse() +{ + Ctx& ctx = this->ctx(); + NdbMutex_Lock(&parse_mutex); + ctx_log2(("parse: %s", stmtArea().sqlText().c_str())); +#if YYDEBUG + SimpleParser_yydebug = (m_ctx.logLevel() >= 5); +#endif + SimpleParser_yyparse((void*)this); + NdbMutex_Unlock(&parse_mutex); +} + +void +SimpleParser::pushState(int sc) +{ + yy_push_state(sc); + m_stacksize++; +} + +void +SimpleParser::popState() +{ + ctx_assert(m_stacksize > 0); + yy_pop_state(); + m_stacksize--; +} + +void +SimpleParser::parseError(const char* msg) +{ + ctx().pushStatus(Sqlstate::_42000, Error::Gen, "%s at '%*s' position %u", msg, yyleng, yytext, m_parsePos - yyleng); +} + +int +SimpleParser::LexerInput(char* buf, int max_size) +{ + const BaseString& text = stmtArea().sqlText(); + int n = 0; + const char* const t = text.c_str(); + const unsigned m = text.length(); + while (n < max_size && m_textPos < m) { + buf[n++] = t[m_textPos++]; + m_parsePos++; // XXX simple hack + break; + } + return n; +} + +// XXX just a catch-all (scanner should match all input) +void +SimpleParser::LexerOutput(const char* buf, int size) +{ + if (! ctx().ok()) + return; + const char* msg = "unrecognized input"; + ctx().pushStatus(Sqlstate::_42000, Error::Gen, "%s at '%*s' position %u", msg, size, buf, m_parsePos); +} + +void +SimpleParser::LexerError(const char* msg) +{ + ctx().pushStatus(Sqlstate::_42000, Error::Gen, "%s at '%*s' position %u", msg, yyleng, yytext, m_parsePos); +} diff --git a/ndb/src/client/odbc/codegen/SimpleParser.hpp b/ndb/src/client/odbc/codegen/SimpleParser.hpp new file mode 100644 index 00000000000..abadae8f905 --- /dev/null +++ b/ndb/src/client/odbc/codegen/SimpleParser.hpp @@ -0,0 +1,161 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_SimpleParser_hpp +#define ODBC_CODEGEN_SimpleParser_hpp + +#include +#include "Code_root.hpp" +#include "Code_stmt.hpp" +#include "Code_select.hpp" +#include "Code_pred.hpp" +#include "Code_pred_op.hpp" +#include "Code_comp_op.hpp" +#include "Code_expr_row.hpp" +#include "Code_expr.hpp" +#include "Code_expr_op.hpp" +#include "Code_expr_func.hpp" +#include "Code_expr_column.hpp" +#include "Code_expr_const.hpp" +#include "Code_expr_param.hpp" +#include "Code_update.hpp" +#include "Code_set_row.hpp" +#include "Code_insert.hpp" +#include "Code_dml_row.hpp" +#include "Code_dml_column.hpp" +#include "Code_delete.hpp" +#include "Code_table_list.hpp" +#include "Code_table.hpp" +#include "Code_create_table.hpp" +#include "Code_create_index.hpp" +#include "Code_ddl_row.hpp" +#include "Code_ddl_column.hpp" +#include "Code_ddl_constr.hpp" +#include "Code_data_type.hpp" +#include "Code_drop_table.hpp" +#include "Code_drop_index.hpp" + +#include "SimpleGram.tab.hpp" + +class StmtArea; +class Plan_root; + +class SimpleParser : public yyFlexLexer { +public: + SimpleParser(Ctx& ctx, StmtArea& stmtArea, Plan_root* root); + ~SimpleParser(); + Ctx& ctx(); + StmtArea& stmtArea(); + Plan_root* root(); + void yyparse(); // calls real yyparse + int yylex(); // generated by flex + YYSTYPE yylval(); + void pushState(int sc); // push start condition + void popState(); // pop start condition + unsigned paramNumber() const; + void parseError(const char* msg); + // parser helpers - to avoid creating new Plan tree types + Plan_ddl_column* curr(Plan_ddl_column* p); + Plan_create_index* curr(Plan_create_index* p); +protected: + virtual int LexerInput(char* buf, int max_size); + virtual void LexerOutput(const char* buf, int size); + virtual void LexerError(const char* msg); +private: + Ctx& m_ctx; + StmtArea& m_stmtArea; + Plan_root* const m_root; + unsigned m_textPos; // position in sql text + unsigned m_parsePos; // parse position, to report error + YYSTYPE m_yylval; // token value + BaseString m_string; // storage for edited string token + unsigned m_stacksize; // state stack size + unsigned m_paramNumber; // parameter number + // parser helpers + Plan_ddl_column* m_ddl_column; + Plan_create_index* m_create_index; +}; + +extern int SimpleParser_yyparse(void* simpleParserPtr); +#if YYDEBUG +extern int SimpleParser_yydebug; +#endif + +inline +SimpleParser::SimpleParser(Ctx& ctx, StmtArea& stmtArea, Plan_root* root) : + m_ctx(ctx), + m_stmtArea(stmtArea), + m_root(root), + m_textPos(0), + m_parsePos(0), + m_stacksize(0), + m_paramNumber(0), + // parser helpers + m_ddl_column(0) +{ +} + +inline Ctx& +SimpleParser::ctx() +{ + return m_ctx; +} + +inline StmtArea& +SimpleParser::stmtArea() +{ + return m_stmtArea; +} + +inline Plan_root* +SimpleParser::root() +{ + return m_root; +} + +inline YYSTYPE +SimpleParser::yylval() +{ + return m_yylval; +} + +inline unsigned +SimpleParser::paramNumber() const +{ + return m_paramNumber; +} + +// parser helpers + +inline Plan_ddl_column* +SimpleParser::curr(Plan_ddl_column* p) +{ + if (p != 0) + m_ddl_column = p; + ctx_assert(m_ddl_column != 0); + return m_ddl_column; +} + +inline Plan_create_index* +SimpleParser::curr(Plan_create_index* p) +{ + if (p != 0) + m_create_index = p; + ctx_assert(m_create_index != 0); + return m_create_index; +} + +#endif diff --git a/ndb/src/client/odbc/codegen/SimpleScan.lpp b/ndb/src/client/odbc/codegen/SimpleScan.lpp new file mode 100644 index 00000000000..bd930c08cfa --- /dev/null +++ b/ndb/src/client/odbc/codegen/SimpleScan.lpp @@ -0,0 +1,241 @@ +%{ +#include +#include "SimpleParser.hpp" + +struct SqlKeyword { + const char* m_name; + int m_value; + int m_state; + static const SqlKeyword* find(Ctx& ctx, const char* name, int state); +}; + +%} + +%option c++ +%option yyclass="SimpleParser" +%option stack +%option noyywrap + +space [\040\t\n\r\f] +digit [0-9] +letter [A-Za-z_] +special ("$") +identifier ({letter}({letter}|{digit}|{special})*) +integer {digit}++ +decimal (({digit}*\.{digit}+)|({digit}+\.{digit}*)) +real ((({digit}*\.{digit}+)|({digit}+\.{digit}*)|({digit}+))([Ee][-+]?{digit}+)) + +%s StateEval +%s StateType +%s StatePhys +%x StateString +%x StateQuoted + +%% + +{space} { + } +{identifier} { + const SqlKeyword* key = SqlKeyword::find(m_ctx, (char*)yytext, YYSTATE); + if (key != 0) + return key->m_value; + for (unsigned char* a = (unsigned char*)yytext; *a != 0; a++) { + if (islower(*a)) + *a = toupper(*a); + } + m_yylval.m_string = strcpy(new char[yyleng + 1], yytext); + return T_IDENTIFIER; + } +{integer} { + m_yylval.m_string = strcpy(new char[yyleng + 1], yytext); + return T_LINTEGER; + } +{decimal} { + m_yylval.m_string = strcpy(new char[yyleng + 1], yytext); + return T_LDECIMAL; + } +{real} { + m_yylval.m_string = strcpy(new char[yyleng + 1], yytext); + return T_LREAL; + } +"--".* { + } +"/*" { + int c = 0, d; + while (1) { + d = c; + if ((c = yyinput()) == EOF) { + parseError("unterminated comment"); + yyterminate(); + } + if (d == '*' && c == '/') + break; + } + } +{ +"+" return T_PLUS; +"-" return T_MINUS; +"*" return T_TIMES; +"/" return T_DIVIDE; +"=" return T_EQ; +"!=" return T_NOTEQ; +"^=" return T_NOTEQ; +"<>" return T_NOTEQ; +"<" return T_LT; +"<=" return T_LTEQ; +">" return T_GT; +">=" return T_GTEQ; +"?" m_paramNumber++; return T_QUES; +} + +"." return T_PERIOD; +"," return T_COMMA; +"(" return T_PARENLEFT; +")" return T_PARENRIGHT; +"*" return T_ASTERISK; +"=" return T_ASSIGN; + +"'" { + pushState(StateString); + m_string.assign(""); + } +{ +[^']* { + m_string.append(yytext); + } +"''" { + m_string.append("'"); + } +"'" { + m_yylval.m_string = strcpy(new char[m_string.length() + 1], m_string.c_str()); + popState(); + return T_STRING; + } +} + +\" { + pushState(StateQuoted); + m_string.assign(""); + } +{ +[^"]* { + m_string.append(yytext); + } +\\\" { + m_string.append("\""); + } +\" { + m_yylval.m_string = strcpy(new char[m_string.length() + 1], m_string.c_str()); + popState(); + return T_IDENTIFIER; + } +} + +%% + +// scan states +int SimpleParser_stateEval = StateEval; +int SimpleParser_stateType = StateType; +int SimpleParser_statePhys = StatePhys; + +// keep sorted + +static const SqlKeyword sqlKeyword[] = { + { "AND", T_AND, -1 }, + { "ASC", T_ASC, -1 }, + { "AUTO_INCREMENT", T_AUTO_INCREMENT, -1 }, + { "BIGINT", T_BIGINT, StateType }, + { "BINARY", T_BINARY, StateType }, + { "BLOB", T_BLOB, StateType }, + { "BY", T_BY, -1 }, + { "CHAR", T_CHAR, StateType }, + { "CONSTRAINT", T_CONSTRAINT, -1 }, + { "CREATE", T_CREATE, -1 }, + { "DATETIME", T_DATETIME, StateType }, + { "DEFAULT", T_DEFAULT, -1 }, + { "DELETE", T_DELETE, -1 }, + { "DESC", T_DESC, -1 }, + { "DISTINCT", T_DISTINCT, -1 }, + { "DOUBLE", T_DOUBLE, StateType }, + { "DROP", T_DROP, -1 }, + { "FLOAT", T_FLOAT, StateType }, + { "FOREIGN", T_FOREIGN, -1 }, + { "FROM", T_FROM, -1 }, + { "GROUP", T_GROUP, -1 }, + { "HASH", T_HASH, -1 }, + { "HAVING", T_HAVING, -1 }, + { "IN", T_IN, -1 }, + { "INDEX", T_INDEX, -1 }, + { "INSERT", T_INSERT, -1 }, + { "INT", T_INT, StateType }, + { "INTEGER", T_INTEGER, StateType }, + { "INTO", T_INTO, -1 }, + { "IS", T_IS, -1 }, + { "KEY", T_KEY, -1 }, + { "LARGE", T_LARGE, StatePhys }, + { "LIKE", T_LIKE, -1 }, + { "LIMIT", T_LIMIT, -1 }, + { "LOGGING", T_LOGGING, StatePhys }, + { "LONGBLOB", T_LONGBLOB, StateType }, + { "MEDIUM", T_MEDIUM, StatePhys }, + { "NOLOGGING", T_NOLOGGING, StatePhys }, + { "NOT", T_NOT, -1 }, + { "NULL", T_NULL, -1 }, + { "OFFSET", T_OFFSET, -1 }, + { "ON", T_ON, -1 }, + { "OR", T_OR, -1 }, + { "ORDER", T_ORDER, -1 }, + { "PRECISION", T_PRECISION, StateType }, + { "PRIMARY", T_PRIMARY, -1 }, + { "REAL", T_REAL, StateType }, + { "REFERENCES", T_REFERENCES, -1 }, + { "ROWNUM", T_ROWNUM, -1 }, + { "SELECT", T_SELECT, -1 }, + { "SET", T_SET, -1 }, + { "SINGLE", T_SINGLE, StatePhys }, + { "SMALL", T_SMALL, StatePhys }, + { "SMALLINT", T_SMALLINT, StateType }, + { "STORAGE", T_STORAGE, StatePhys }, + { "SYSDATE", T_SYSDATE, -1 }, + { "TABLE", T_TABLE, -1 }, + { "UNIQUE", T_UNIQUE, -1 }, + { "UNSIGNED", T_UNSIGNED, -1 }, + { "UPDATE", T_UPDATE, -1 }, + { "VALUES", T_VALUES, -1 }, + { "VARBINARY", T_VARBINARY, StateType }, + { "VARCHAR", T_VARCHAR, StateType }, + { "WHERE", T_WHERE, -1 }, + { "WRITE", T_WRITE, -1 } +}; + +static const unsigned sqlKeywordCount = sizeof(sqlKeyword) / sizeof(sqlKeyword[0]); + +const SqlKeyword* +SqlKeyword::find(Ctx& ctx, const char* name, int state) +{ + ctx_log4(("find keyword '%s' lex state = %d", name, state)); + const unsigned maxlen = 99; + char buf[maxlen + 1]; + char* a = buf; + const char* b = name; + while (*b != 0) { + if (a >= buf + maxlen) // will not be found + break; + char c = *b++; + if ('a' <= c && c <= 'z') // locale independent + c -= 'a' - 'A'; + *a++ = c; + } + *a = 0; + for (unsigned i = 0; i < sqlKeywordCount; i++) { + const SqlKeyword* key = &sqlKeyword[i]; + if (strcmp(key->m_name, buf) == 0) { + if (key->m_state != -1 && key->m_state != state) + return 0; + return key; + } + } + return 0; +} + +/* vim: set filetype=lex: */ diff --git a/ndb/src/client/odbc/common/AttrArea.cpp b/ndb/src/client/odbc/common/AttrArea.cpp new file mode 100644 index 00000000000..ff9e085a7f6 --- /dev/null +++ b/ndb/src/client/odbc/common/AttrArea.cpp @@ -0,0 +1,91 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "AttrArea.hpp" + +// AttrSpec + +// AttrField + +// AttrArea + +AttrArea::AttrArea(const AttrSpec* specList) : + m_specList(specList) +{ +} + +AttrArea::~AttrArea() +{ +} + +const AttrSpec& +AttrArea::findSpec(int id) const +{ + const AttrSpec* p; + for (p = m_specList; p->m_mode != Attr_mode_undef; p++) { + if (p->m_id == id) + break; + } + return *p; +} + +void +AttrArea::setAttr(Ctx& ctx, int id, const OdbcData& data) +{ + const AttrSpec& spec = findSpec(id); + if (spec.m_mode == Attr_mode_undef) { + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "undefined attribute id %d", id); + return; + } + ctx_assert(spec.m_type == data.type()); + ctx_assert(spec.m_set != 0); + spec.m_set(ctx, m_handle, data); + if (! ctx.ok()) + return; + Fields::iterator iter; + if (ctx.logLevel() >= 3) { + char buf[100]; + data.print(buf, sizeof(buf)); + ctx_log3(("attr handle 0x%x set id %d = %s", (unsigned)m_handle, id, buf)); + } + iter = m_fields.find(id); + if (iter != m_fields.end()) { + AttrField& field = (*iter).second; + field.setData(data); + return; + } + AttrField field(spec, data); + m_fields.insert(Fields::value_type(id, field)); +} + +void +AttrArea::getAttr(Ctx& ctx, int id, OdbcData& data) +{ + const AttrSpec& spec = findSpec(id); + if (spec.m_mode == Attr_mode_undef) { + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "undefined attribute id %d", id); + return; + } + Fields::iterator iter; + iter = m_fields.find(id); + if (iter != m_fields.end()) { + AttrField& field = (*iter).second; + data.setValue(field.getData()); + return; + } + ctx_assert(spec.m_default != 0); + spec.m_default(ctx, m_handle, data); +} diff --git a/ndb/src/client/odbc/common/AttrArea.hpp b/ndb/src/client/odbc/common/AttrArea.hpp new file mode 100644 index 00000000000..050cce719bf --- /dev/null +++ b/ndb/src/client/odbc/common/AttrArea.hpp @@ -0,0 +1,135 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_HANDLES_AttrArea_hpp +#define ODBC_HANDLES_AttrArea_hpp + +#include +#include +#include "OdbcData.hpp" + +class HandleBase; + +enum AttrMode { + Attr_mode_undef, + Attr_mode_readonly, + Attr_mode_writeonly, + Attr_mode_readwrite +}; + +/** + * @struct AttrSpec + * @brief Attribute specifier + * + * Each handle class has a list of attribute specifiers. + */ +struct AttrSpec { + int m_id; // SQL_ATTR_ identifier + OdbcData::Type m_type; // data type + AttrMode m_mode; // access mode, undef indicates end of list + /** + * Callback for checks and side effects. Called before the + * attribute is stored. May set error status. + */ + typedef void CallbackSet(Ctx& ctx, HandleBase* self, const OdbcData& data); + CallbackSet* m_set; + /** + * Callback to set default value. May set error status. + */ + typedef void CallbackDefault(Ctx& ctx, HandleBase* self, OdbcData& data); + CallbackDefault* m_default; +}; + +/** + * @class AttrField + * @brief Attribute value (stored as OdbcData) + */ +class AttrField { +public: + AttrField(const AttrSpec& attrSpec, const OdbcData& data); + AttrField(const AttrField& field); + ~AttrField(); + void setData(const OdbcData& data); + const OdbcData& getData(); +private: + const AttrSpec& m_spec; + OdbcData m_data; +}; + +inline +AttrField::AttrField(const AttrSpec& spec, const OdbcData& data) : + m_spec(spec), + m_data(data) +{ +} + +inline +AttrField::AttrField(const AttrField& field) : + m_spec(field.m_spec), + m_data(field.m_data) +{ +} + +inline +AttrField::~AttrField() +{ +} + +inline void +AttrField::setData(const OdbcData& data) +{ + ctx_assert(m_spec.m_type == data.type()); + m_data.setValue(data); +} + +inline const OdbcData& +AttrField::getData() +{ + ctx_assert(m_data.type() != OdbcData::Undef); + return m_data; +} + +/** + * @class AttrArea + * @brief Handle attributes + * + * Each handle instance has a list of attribute values stored + * under an AttrArea. Callbacks to handle code provide for + * default values, extra checks, and side-effects. + */ +class AttrArea { +public: + AttrArea(const AttrSpec* specList); + ~AttrArea(); + void setHandle(HandleBase* handle); + const AttrSpec& findSpec(int id) const; + void setAttr(Ctx& ctx, int id, const OdbcData& data); + void getAttr(Ctx& ctx, int id, OdbcData& data); +private: + HandleBase* m_handle; + const AttrSpec* const m_specList; + typedef std::map Fields; + Fields m_fields; +}; + +inline void +AttrArea::setHandle(HandleBase* handle) +{ + ctx_assert(handle != 0); + m_handle = handle; +} + +#endif diff --git a/ndb/src/client/odbc/common/CodeTree.cpp b/ndb/src/client/odbc/common/CodeTree.cpp new file mode 100644 index 00000000000..ebe4840c5f6 --- /dev/null +++ b/ndb/src/client/odbc/common/CodeTree.cpp @@ -0,0 +1,37 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "CodeTree.hpp" + +// PlanTree + +PlanTree::~PlanTree() +{ +} + +// ExecTree + +ExecTree::Code::~Code() +{ +} + +ExecTree::Data::~Data() +{ +} + +ExecTree::~ExecTree() +{ +} diff --git a/ndb/src/client/odbc/common/CodeTree.hpp b/ndb/src/client/odbc/common/CodeTree.hpp new file mode 100644 index 00000000000..1b0ae3199af --- /dev/null +++ b/ndb/src/client/odbc/common/CodeTree.hpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_CODEGEN_CodeTree_hpp +#define ODBC_CODEGEN_CodeTree_hpp + +#include + +/* + * Intermediary statement evalution plan. Starts as parse tree. Final + * format maps directly to ExecTree. + */ +class PlanTree { +public: + virtual ~PlanTree() = 0; +}; + +/* + * Executable code and runtime data. Currently looks like PlanTree. + * Later may change code format to linear "byte code" and move execution + * to a SQL block in NDB kernel. + */ +class ExecTree { +public: + class Code { + public: + virtual ~Code() = 0; + }; + class Data { + public: + virtual ~Data() = 0; + }; + virtual ~ExecTree() = 0; +}; + +#endif diff --git a/ndb/src/client/odbc/common/ConnArea.cpp b/ndb/src/client/odbc/common/ConnArea.cpp new file mode 100644 index 00000000000..d4d3be52a3c --- /dev/null +++ b/ndb/src/client/odbc/common/ConnArea.cpp @@ -0,0 +1,109 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "ConnArea.hpp" + +ConnArea::ConnArea() : + m_state(Free), + m_ndbObject(0), + m_ndbSchemaCon(0), + m_ndbConnection(0), + m_useSchemaCon(0), + m_useConnection(0), + m_autocommit(true), + m_uncommitted(false) +{ + // initialize connection catalog + m_catalog = new DictCatalog(*this); + m_schema = new DictSchema(*this, "NDB"); + m_catalog->addSchema(m_schema); +} + +ConnArea::~ConnArea() +{ + delete m_catalog; +} + +bool +ConnArea::useSchemaCon(Ctx& ctx, bool use) +{ + if (m_state == Free) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "not connected"); + return false; + } + Ndb* ndb = m_ndbObject; + ctx_assert(ndb != 0); + NdbSchemaCon* scon = m_ndbSchemaCon; + if (use) { + if (scon == 0) { + ctx_assert(m_useSchemaCon == 0); + scon = ndb->startSchemaTransaction(); + if (scon == 0) { + ctx.pushStatus(ndb, scon, 0, "startSchemaTransaction"); + return false; + } + m_ndbSchemaCon = scon; + } + m_useSchemaCon++; + } else { + ctx_assert(scon != 0 && m_useSchemaCon != 0); + if (--m_useSchemaCon == 0) { + ndb->closeSchemaTransaction(scon); + m_ndbSchemaCon = 0; + } + } + return true; +} + +bool +ConnArea::useConnection(Ctx& ctx, bool use) +{ + ctx_log3(("useConnection: count before=%u on-off=%d", m_useConnection, (int)use)); + if (m_state == Free) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "not connected"); + return false; + } + Ndb* ndb = m_ndbObject; + ctx_assert(ndb != 0); + NdbConnection* tcon = m_ndbConnection; + if (use) { + if (tcon == 0) { + ctx_assert(m_useConnection == 0); + tcon = ndb->startTransaction(); + if (tcon == 0) { + ctx.pushStatus(ndb, tcon, 0, "startTransaction"); + return false; + } + m_ndbConnection = tcon; + m_state = Transacting; + ctx_log2(("transaction opened")); + } + m_useConnection++; + } else { + ctx_assert(tcon != 0 && m_useConnection != 0); + if (--m_useConnection == 0) { + ndb->closeTransaction(tcon); + m_ndbConnection = 0; + m_uncommitted = false; + m_state = Connected; + ctx_log2(("transaction closed")); + } + } + return true; +} diff --git a/ndb/src/client/odbc/common/ConnArea.hpp b/ndb/src/client/odbc/common/ConnArea.hpp new file mode 100644 index 00000000000..36367a39bae --- /dev/null +++ b/ndb/src/client/odbc/common/ConnArea.hpp @@ -0,0 +1,135 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_COMMON_ConnArea_hpp +#define ODBC_COMMON_ConnArea_hpp + +#include + +class Ctx; +class Ndb; +class NdbSchemaCon; +class NdbConnection; +class DictCatalog; +class DictSchema; + +/** + * @class ConnArea + * @brief Public part of connection handle + */ +class ConnArea { +public: + // state between ODBC function calls + enum State { + Free = 1, // not in use, no Ndb object + Connected = 2, // has Ndb object but no Ndb connection + Transacting = 3 // has Ndb connection + }; + State getState() const; + DictCatalog& dictCatalog() const; + DictSchema& dictSchema() const; + Ndb* ndbObject() const; + NdbSchemaCon* ndbSchemaCon() const; + NdbConnection* ndbConnection() const; + // called from StmtArea + bool useSchemaCon(Ctx& ctx, bool use); + bool useConnection(Ctx& ctx, bool use); + // these just get and set the flag - no semantics + bool autocommit() const; + void autocommit(bool flag); + bool uncommitted() const; + void uncommitted(bool flag); +protected: + ConnArea(); + ~ConnArea(); + State m_state; + DictCatalog* m_catalog; + DictSchema* m_schema; + Ndb* m_ndbObject; + NdbSchemaCon* m_ndbSchemaCon; + NdbConnection* m_ndbConnection; + unsigned m_useSchemaCon; + unsigned m_useConnection; + bool m_autocommit; + bool m_uncommitted; // has uncommitted changes +}; + +inline ConnArea::State +ConnArea::getState() const +{ + return m_state; +} + +inline DictCatalog& +ConnArea::dictCatalog() const +{ + ctx_assert(m_catalog != 0); + return *m_catalog; +} + +inline DictSchema& +ConnArea::dictSchema() const +{ + ctx_assert(m_schema != 0); + return *m_schema; +} + +inline Ndb* +ConnArea::ndbObject() const +{ + ctx_assert(m_ndbObject != 0); + return m_ndbObject; +} + +inline NdbSchemaCon* +ConnArea::ndbSchemaCon() const +{ + ctx_assert(m_ndbSchemaCon != 0); + return m_ndbSchemaCon; +} + +inline NdbConnection* +ConnArea::ndbConnection() const +{ + ctx_assert(m_ndbConnection != 0); + return m_ndbConnection; +} + +inline bool +ConnArea::autocommit() const +{ + return m_autocommit; +} + +inline void +ConnArea::autocommit(bool flag) +{ + m_autocommit = flag; +} + +inline bool +ConnArea::uncommitted() const +{ + return m_uncommitted; +} + +inline void +ConnArea::uncommitted(bool flag) +{ + m_uncommitted = flag; +} + +#endif diff --git a/ndb/src/client/odbc/common/Ctx.cpp b/ndb/src/client/odbc/common/Ctx.cpp new file mode 100644 index 00000000000..85edbd1a63f --- /dev/null +++ b/ndb/src/client/odbc/common/Ctx.cpp @@ -0,0 +1,360 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include +#include +#include +#include "DiagArea.hpp" + +// ctor + +Ctx::Ctx() : + m_diagArea(0) // create on demand +{ + const char* p; + if ((p = getenv("NDB_ODBC_TRACE")) != 0) + m_logLevel = atoi(p); + if ((p = getenv("NDB_ODBC_TRACE_FILE")) != 0 && *p != 0) + strcpy(m_szTraceFile, p); +} + +Ctx::~Ctx() +{ + delete m_diagArea; + m_diagArea = 0; +} + +// handle exceptions + +CtxAssert::CtxAssert(const char* file, int line) : + m_file(file), + m_line(line) +{ + const char* p; + if ((p = getenv("NDB_ODBC_DEBUG")) != 0 && atoi(p) != 0) { + char buf[200]; + snprintf(buf, sizeof(buf), "%s, line %d: assert failed\n", m_file, m_line); + if ((p = getenv("NDB_ODBC_TRACE_FILE")) != 0 && *p != 0) { + FILE* pFile = fopen(p, "a"); + fprintf(pFile, buf); + fflush(pFile); + fclose(pFile); + } else { + fprintf(stderr, buf); + fflush(stderr); + } + abort(); + exit(1); + } +} + +void +Ctx::handleEx(CtxAssert& ctxAssert) +{ + pushStatus(Sqlstate::_IM001, Error::Gen, "exception at %s line %d", ctxAssert.m_file, ctxAssert.m_line); +} + +// logging methods + +int Ctx::m_logLevel = 0; +char Ctx::m_szTraceFile[MAX_PATH]; + +void +Ctx::log(const char* fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + if (m_szTraceFile[0]) { + FILE* pFile = fopen(m_szTraceFile, "a"); + fprintf(pFile, "[NdbOdbc] "); + vfprintf(pFile, fmt, ap); + fprintf(pFile, "\n"); + fflush(pFile); + fclose(pFile); + } else { + printf("[NdbOdbc] "); + vprintf(fmt, ap); + printf("\n"); + fflush(stdout); + } + va_end(ap); +} + +void +Ctx::logSqlEnter(const char* sqlFunction) +{ + Ctx& ctx = *this; + snprintf(m_sqlFunction, sizeof(m_sqlFunction), "%s", sqlFunction); + ctx_log3(("%s", m_sqlFunction)); +} + +void +Ctx::logSqlExit() +{ + Ctx& ctx = *this; + if (m_diagArea == 0) { + ctx_log3(("%s ret=%d", m_sqlFunction, getCode())); + return; + } + int logLevel = diagArea().numStatus() != 0 ? 2 : 3; + ctx_logN(logLevel, ("%s ret=%d diag=%d", m_sqlFunction, diagArea().getCode(), diagArea().numStatus())); + for (unsigned i = 1; i <= diagArea().numStatus(); i++) { + OdbcData state; + OdbcData message; + diagArea().getRecord(ctx, i, SQL_DIAG_SQLSTATE, state); + diagArea().getRecord(ctx, i, SQL_DIAG_MESSAGE_TEXT, message); + ctx_logN(logLevel, ("diag %u: %s - %s", i, state.sqlstate().state(), message.sqlchar())); + } +} + +void +Ctx::print(const char* fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + if (m_szTraceFile[0]) { + FILE* pFile = fopen(m_szTraceFile, "a"); + vfprintf(pFile, fmt, ap); + unsigned n = strlen(fmt); + if (n > 0 && fmt[n-1] == '\n') + fflush(pFile); + fclose(pFile); + } else { + vprintf(fmt, ap); + unsigned n = strlen(fmt); + if (n > 0 && fmt[n-1] == '\n') + fflush(stdout); + } + va_end(ap); +} + +void +Ctx::print(int level, const char* fmt, ...) +{ + if (level > m_logLevel) + return; + va_list ap; + va_start(ap, fmt); + if (m_szTraceFile[0]) { + FILE* pFile = fopen(m_szTraceFile, "a"); + vfprintf(pFile, fmt, ap); + unsigned n = strlen(fmt); + if (n > 0 && fmt[n-1] == '\n') + fflush(pFile); + fclose(pFile); + } else { + vprintf(fmt, ap); + unsigned n = strlen(fmt); + if (n > 0 && fmt[n-1] == '\n') + fflush(stdout); + } + va_end(ap); +} + +// diagnostics + +static const unsigned MessageSize = 512; + +DiagArea& +Ctx::diagArea() const +{ + ctx_assert(m_diagArea != 0); + return *m_diagArea; +} + +DiagArea& +Ctx::diagArea() +{ + if (m_diagArea == 0) + m_diagArea = new DiagArea; + return *m_diagArea; +} + +SQLRETURN +Ctx::getCode() const +{ + if (m_diagArea == 0) + return SQL_SUCCESS; + return diagArea().getCode(); +} + +void +Ctx::setCode(SQLRETURN ret) +{ + diagArea().setCode(ret); +} + +void +Ctx::pushStatus(const Sqlstate& state, SQLINTEGER code, const char* fmt, ...) +{ + char message[MessageSize]; + va_list ap; + va_start(ap, fmt); + vsnprintf(message, sizeof(message), fmt, ap); + va_end(ap); + Error error(state); + error.m_status = NdbError::PermanentError; + error.m_classification = NdbError::ApplicationError; + error.m_code = code; + error.m_message = message; + error.m_sqlFunction = m_sqlFunction; + diagArea().pushStatus(error); +} + +void +Ctx::pushStatus(SQLINTEGER code, const char* fmt, ...) +{ + char message[MessageSize]; + va_list ap; + va_start(ap, fmt); + vsnprintf(message, sizeof(message), fmt, ap); + va_end(ap); + Error error(Sqlstate::_IM000); + error.m_status = NdbError::PermanentError; + error.m_classification = NdbError::ApplicationError; + error.m_code = code; + error.m_message = message; + error.m_sqlFunction = m_sqlFunction; + diagArea().pushStatus(error); +} + +void +Ctx::pushStatus(const NdbError& ndbError, const char* fmt, ...) +{ + char message[MessageSize]; + va_list ap; + va_start(ap, fmt); + snprintf(message, sizeof(message), "%s", ndbError.message); + snprintf(message + strlen(message), sizeof(message) - strlen(message), "%s", " - at "); + vsnprintf(message + strlen(message), sizeof(message) - strlen(message), fmt, ap); + va_end(ap); + Error error(Sqlstate::_IM000); + error.m_status = ndbError.status; + error.m_classification = ndbError.classification; + error.m_code = ndbError.code; + error.m_message = message; + error.m_sqlFunction = m_sqlFunction; + diagArea().pushStatus(error); +} + +void +Ctx::pushStatus(const Ndb* ndb, const char* fmt, ...) +{ + char message[MessageSize]; + va_list ap; + va_start(ap, fmt); + vsnprintf(message, sizeof(message), fmt, ap); + va_end(ap); + bool found = false; + if (ndb != 0) { + const NdbError& ndbError = ndb->getNdbError(); + if (ndbError.code != 0) { + pushStatus(ndbError, "%s", message); + found = true; + } + } + if (! found) { + pushStatus(Error::Gen, "unknown NDB error"); + } +} + +void +Ctx::pushStatus(const Ndb* ndb, const NdbConnection* tcon, const NdbOperation* op, const char* fmt, ...) +{ + char message[MessageSize]; + va_list ap; + va_start(ap, fmt); + vsnprintf(message, sizeof(message), fmt, ap); + va_end(ap); + bool found = false; + if (op != 0) { + const NdbError& ndbError = op->getNdbError(); + if (ndbError.code != 0) { + pushStatus(ndbError, "%s", message); + found = true; + } + } + if (tcon != 0) { + const NdbError& ndbError = tcon->getNdbError(); + if (ndbError.code != 0) { + pushStatus(ndbError, "%s", message); + found = true; + } + } + if (ndb != 0) { + const NdbError& ndbError = ndb->getNdbError(); + if (ndbError.code != 0) { + pushStatus(ndbError, "%s", message); + found = true; + } + } + if (! found) { + pushStatus(Error::Gen, "unknown NDB error"); + } +} + +void +Ctx::pushStatus(const Ndb* ndb, const NdbSchemaCon* scon, const NdbSchemaOp* op, const char* fmt, ...) +{ + char message[MessageSize]; + va_list ap; + va_start(ap, fmt); + vsnprintf(message, sizeof(message), fmt, ap); + va_end(ap); + bool found = false; + if (op != 0) { + const NdbError& ndbError = op->getNdbError(); + if (ndbError.code != 0) { + pushStatus(ndbError, "%s", message); + found = true; + } + } + if (scon != 0) { + const NdbError& ndbError = scon->getNdbError(); + if (ndbError.code != 0) { + pushStatus(ndbError, "%s", message); + found = true; + } + } + if (ndb != 0) { + const NdbError& ndbError = ndb->getNdbError(); + if (ndbError.code != 0) { + pushStatus(ndbError, "%s", message); + found = true; + } + } + if (! found) { + pushStatus(Error::Gen, "unknown NDB error"); + } +} + +// check for error + +bool +Ctx::ok() +{ + if (m_diagArea == 0) + return true; + if (diagArea().getCode() == SQL_SUCCESS) + return true; + if (diagArea().getCode() == SQL_SUCCESS_WITH_INFO) + return true; + return false; +} diff --git a/ndb/src/client/odbc/common/Ctx.hpp b/ndb/src/client/odbc/common/Ctx.hpp new file mode 100644 index 00000000000..d25d45ff0c7 --- /dev/null +++ b/ndb/src/client/odbc/common/Ctx.hpp @@ -0,0 +1,182 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_COMMON_Ctx_hpp +#define ODBC_COMMON_Ctx_hpp + +#include + +class Ndb; +class NdbConnection; +class NdbOperation; +class NdbSchemaCon; +class NdbSchemaOp; +class NdbError; + +class Sqlstate; +class DiagArea; +class CtxOwner; + +#ifndef MAX_PATH +#define MAX_PATH 1024 +#endif + +/** + * @class Error + * @brief Sql state, error codes, and message + */ +struct Error { + enum { + Gen = NDB_ODBC_ERROR_MIN + 1 // unclassified + }; + explicit Error(const Sqlstate& sqlstate); + const Sqlstate& m_sqlstate; + int m_status; + int m_classification; + int m_code; + const char* m_message; + const char* m_sqlFunction; + bool driverError() const; +}; + +inline +Error::Error(const Sqlstate& sqlstate) : + m_sqlstate(sqlstate), + m_status(0), + m_classification(0), + m_code(0), + m_sqlFunction(0) +{ +} + +inline bool +Error::driverError() const +{ + return NDB_ODBC_ERROR_MIN <= m_code && m_code < NDB_ODBC_ERROR_MAX; +} + +#define ctx_assert(x) \ + do { if (x) break; throw CtxAssert(__FILE__, __LINE__); } while (0) + +/** + * @class Assert + * @brief Assert thrown + */ +class CtxAssert { +public: + CtxAssert(const char* file, int line); + const char* const m_file; + const int m_line; +}; + +/** + * @class Ctx + * @brief Context for one ODBC SQL function + * + * Local to the function (not member of the handle) because methods on + * a handle can call methods on other handles. Created in driver/ + * before method calls and saved under the handle on return. Contains + * diag area for the function. Also used as logger. + */ +class Ctx { +public: + Ctx(); + ~Ctx(); + // handle exceptions + void handleEx(CtxAssert& ctxAssert); + // logging methods + int logLevel() const; + void log(const char* fmt, ...) PRINTFLIKE(2,3); + void logSqlEnter(const char* sqlFunction); + void logSqlExit(); + const char* sqlFunction() const; + void print(const char* fmt, ...) PRINTFLIKE(2,3); + void print(int level, const char* fmt, ...) PRINTFLIKE(3,4); + // diagnostics area. + DiagArea& diagArea() const; + DiagArea& diagArea(); + SQLRETURN getCode() const; + void setCode(SQLRETURN ret); + // push diagnostic record + void pushStatus(const Sqlstate& state, SQLINTEGER code, const char* fmt, ...) PRINTFLIKE(4,5); + void pushStatus(SQLINTEGER code, const char* fmt, ...) PRINTFLIKE(3,4); + void pushStatus(const NdbError& ndbError, const char* fmt, ...) PRINTFLIKE(3,4); + void pushStatus(const Ndb* ndb, const char* fmt, ...) PRINTFLIKE(3,4); + void pushStatus(const Ndb* ndb, const NdbConnection* tcon, const NdbOperation* op, const char* fmt, ...) PRINTFLIKE(5,6); + void pushStatus(const Ndb* ndb, const NdbSchemaCon* scon, const NdbSchemaOp* op, const char* fmt, ...) PRINTFLIKE(5,6); + // check if we should continue executing. + bool ok(); +private: + static int m_logLevel; + static char m_szTraceFile[MAX_PATH]; + char m_sqlFunction[32]; // max needed is 20 + DiagArea* m_diagArea; +}; + +inline int +Ctx::logLevel() const +{ + return m_logLevel; +} + +inline const char* +Ctx::sqlFunction() const +{ + return m_sqlFunction; +} + +// logging macros can be used only when ctx is in scope + +#define ctx_logN(n, x) \ + do { if (ctx.logLevel() < (n)) break; ctx.log x; } while (0) + +#if NDB_ODBC_MAX_LOG_LEVEL >= 0 +#define ctx_log0(x) ctx_logN(0, x) +#else +#define ctx_log0(x) +#endif + +#if NDB_ODBC_MAX_LOG_LEVEL >= 1 +#define ctx_log1(x) ctx_logN(1, x) +#else +#define ctx_log1(x) +#endif + +#if NDB_ODBC_MAX_LOG_LEVEL >= 2 +#define ctx_log2(x) ctx_logN(2, x) +#else +#define ctx_log2(x) +#endif + +#if NDB_ODBC_MAX_LOG_LEVEL >= 3 +#define ctx_log3(x) ctx_logN(3, x) +#else +#define ctx_log3(x) +#endif + +#if NDB_ODBC_MAX_LOG_LEVEL >= 4 +#define ctx_log4(x) ctx_logN(4, x) +#else +#define ctx_log4(x) +#endif + +#if NDB_ODBC_MAX_LOG_LEVEL >= 5 +#define ctx_log5(x) ctx_logN(5, x) +#else +#define ctx_log5(x) +#endif + +#endif diff --git a/ndb/src/client/odbc/common/DataField.cpp b/ndb/src/client/odbc/common/DataField.cpp new file mode 100644 index 00000000000..5853f90c08f --- /dev/null +++ b/ndb/src/client/odbc/common/DataField.cpp @@ -0,0 +1,3030 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include +#include +#include "DataField.hpp" +#include + +#ifndef INT_MAX +#define INT_MAX (2147483647) +#endif + +#ifndef INT_MIN +#define INT_MIN (-INT_MAX - 1) +#endif + +#ifndef UINT_MAX +#define UINT_MAX 4294967295U +#endif + +#ifndef FLT_MAX +#define FLT_MAX (3.402823466E+38F) +#endif +#ifndef FLT_MIN +#define FLT_MIN (1.175494351E-38F) +#endif + +#ifdef NDB_WIN32 +#define FMT_I64 "%I64d" +#define FMT_U64 "%I64u" +#else +#define FMT_I64 "%lld" +#define FMT_U64 "%llu" +#endif + +#ifdef NDB_WIN32 +#define strtoll(str, endptr, base) strtoint64(str, endptr, base) +#define strtoull(str, endptr, base) strtouint64(str, endptr, base) + +static Int64 +strtoint64(const char *str, char **endptr, int base) +{ + Int64 x = 0; + while (*str == ' ') + str++; + const char* p = str; + while ('0' <= *p && *p <= '9') + x = 10 * x + *p++ - '0'; + if (p == str) { + *endptr = 0; + return 0; + } + *endptr = (char*)p; + return x; +} + +static Uint64 +strtouint64(const char *str, char **endptr, int base) +{ + Uint64 x = 0; + while (*str == ' ') + str++; + const char* p = str; + while ('0' <= *p && *p <= '9') + x = 10 * x + *p++ - '0'; + if (p == str) { + *endptr = 0; + return 0; + } + *endptr = (char*)p; + return x; +} +#endif + +// LexSpec + +void +LexSpec::convert(Ctx& ctx, const BaseString& value, SqlField& out) +{ + const SqlSpec& sqlSpec = out.sqlSpec(); + const SqlType& sqlType = sqlSpec.sqlType(); + out.alloc(); + if (sqlType.type() == SqlType::Char) { + const SqlChar* s = (const SqlChar*)value.c_str(); + out.sqlChar(s, SQL_NTS); + return; + } + if (sqlType.type() == SqlType::Bigint) { + char* endptr = 0; + SqlBigint n = static_cast(strtoll(value.c_str(), &endptr, 10)); + if (endptr == 0 || *endptr != 0) { + ctx.pushStatus(Error::Gen, "cannot convert '%s' to integer", value.c_str()); + return; + } + out.sqlBigint(n); + return; + } + if (sqlType.type() == SqlType::Double) { + char* endptr = 0; + SqlDouble x = static_cast(strtod(value.c_str(), &endptr)); + if (endptr == 0 || *endptr != 0) { + ctx.pushStatus(Error::Gen, "cannot convert '%s' to number", value.c_str()); + return; + } + out.sqlDouble(x); + return; + } + if (sqlType.type() == SqlType::Null) { + out.u_null.m_nullFlag = true; + return; + } + ctx_assert(false); +} + +// SqlField + +void +SqlField::alloc() +{ + ctx_assert(sqlSpec().store() == SqlSpec::Physical); + const SqlType& sqlType = sqlSpec().sqlType(); + if (sqlType.type() == SqlType::Char || sqlType.type() == SqlType::Varchar) { + unsigned n = sqlType.length(); + if (sqlType.type() == SqlType::Varchar) + n += 2; + if (n > SqlField_CharSmall) { + u_data.m_sqlChar = new SqlChar[n]; + } + } + if (sqlType.type() == SqlType::Binary || sqlType.type() == SqlType::Varbinary) { + unsigned n = sqlType.length(); + if (sqlType.type() == SqlType::Varbinary) + n += 2; + if (n > SqlField_CharSmall) { + u_data.m_sqlChar = new SqlChar[n]; + } + } +} + +void +SqlField::alloc(const SqlField& sqlField) +{ + alloc(); + const SqlType& sqlType = sqlSpec().sqlType(); + if (sqlType.type() == SqlType::Char || sqlType.type() == SqlType::Varchar) { + unsigned n = sqlType.length(); + if (sqlType.type() == SqlType::Varchar) + n += 2; + if (n > SqlField_CharSmall) { + memcpy(u_data.m_sqlChar, sqlField.u_data.m_sqlChar, n); + } + } + if (sqlType.type() == SqlType::Binary || sqlType.type() == SqlType::Varbinary) { + unsigned n = sqlType.length(); + if (sqlType.type() == SqlType::Varbinary) + n += 2; + if (n > SqlField_CharSmall) { + memcpy(u_data.m_sqlChar, sqlField.u_data.m_sqlChar, n); + } + } +} + +const void* +SqlField::addr() const +{ + if (sqlSpec().store() == SqlSpec::Reference) { + ctx_assert(u_data.m_sqlField != 0); + return u_data.m_sqlField->addr(); + } + const SqlType& sqlType = sqlSpec().sqlType(); + if (sqlType.type() == SqlType::Char || sqlType.type() == SqlType::Varchar) { + unsigned n = sqlType.length(); + if (sqlType.type() == SqlType::Varchar) + n += 2; + if (n > SqlField_CharSmall) { + return static_cast(u_data.m_sqlChar); + } + return static_cast(u_data.m_sqlCharSmall); + } + if (sqlType.type() == SqlType::Binary || sqlType.type() == SqlType::Varbinary) { + unsigned n = sqlType.length(); + if (sqlType.type() == SqlType::Varbinary) + n += 2; + if (n > SqlField_CharSmall) { + return static_cast(u_data.m_sqlChar); + } + return static_cast(u_data.m_sqlCharSmall); + } + if (sqlType.type() == SqlType::Smallint) { + return static_cast(&u_data.m_sqlSmallint); + } + if (sqlType.type() == SqlType::Integer) { + return static_cast(&u_data.m_sqlInteger); + } + if (sqlType.type() == SqlType::Bigint) { + return static_cast(&u_data.m_sqlBigint); + } + if (sqlType.type() == SqlType::Real) { + return static_cast(&u_data.m_sqlReal); + } + if (sqlType.type() == SqlType::Double) { + return static_cast(&u_data.m_sqlDouble); + } + if (sqlType.type() == SqlType::Datetime) { + return static_cast(&u_data.m_sqlDatetime); + } + ctx_assert(false); // SqlType::Null has no address + return 0; +} + +void* +SqlField::addr() +{ + const SqlType& sqlType = sqlSpec().sqlType(); + if (sqlType.type() == SqlType::Char || sqlType.type() == SqlType::Varchar) { + unsigned n = sqlType.length(); + if (sqlType.type() == SqlType::Varchar) + n += 2; + if (n > SqlField_CharSmall) { + return static_cast(u_data.m_sqlChar); + } + return static_cast(u_data.m_sqlCharSmall); + } + if (sqlType.type() == SqlType::Binary || sqlType.type() == SqlType::Varbinary) { + unsigned n = sqlType.length(); + if (sqlType.type() == SqlType::Varbinary) + n += 2; + if (n > SqlField_CharSmall) { + return static_cast(u_data.m_sqlChar); + } + return static_cast(u_data.m_sqlCharSmall); + } + if (sqlType.type() == SqlType::Smallint) { + return static_cast(&u_data.m_sqlSmallint); + } + if (sqlType.type() == SqlType::Integer) { + return static_cast(&u_data.m_sqlInteger); + } + if (sqlType.type() == SqlType::Bigint) { + return static_cast(&u_data.m_sqlBigint); + } + if (sqlType.type() == SqlType::Real) { + return static_cast(&u_data.m_sqlReal); + } + if (sqlType.type() == SqlType::Double) { + return static_cast(&u_data.m_sqlDouble); + } + if (sqlType.type() == SqlType::Datetime) { + return static_cast(&u_data.m_sqlDatetime); + } + ctx_assert(false); // SqlType::Null has no address + return 0; +} + +unsigned +SqlField::allocSize() const +{ + const SqlType& sqlType = sqlSpec().sqlType(); + unsigned n = sqlType.size(); + if (sqlType.type() == SqlType::Varchar || sqlType.type() == SqlType::Varbinary) { + n += 2; + } + return n; +} + +void +SqlField::free() +{ + ctx_assert(sqlSpec().store() == SqlSpec::Physical); + const SqlType& sqlType = sqlSpec().sqlType(); + if (sqlType.type() == SqlType::Char || sqlType.type() == SqlType::Varchar) { + unsigned n = sqlType.length(); + if (sqlType.type() == SqlType::Varchar) + n += 2; + if (n > SqlField_CharSmall) { + delete[] u_data.m_sqlChar; + u_data.m_sqlChar = 0; // safety since dtor used explicitly + } + } + if (sqlType.type() == SqlType::Binary || sqlType.type() == SqlType::Varbinary) { + unsigned n = sqlType.length(); + if (sqlType.type() == SqlType::Varbinary) + n += 2; + if (n > SqlField_CharSmall) { + delete[] u_data.m_sqlChar; + u_data.m_sqlChar = 0; // safety since dtor used explicitly + } + } +} + +// get + +const SqlChar* +SqlField::sqlChar() const +{ + if (sqlSpec().store() == SqlSpec::Reference) { + ctx_assert(u_data.m_sqlField != 0); + return u_data.m_sqlField->sqlChar(); + } + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Char); + if (sqlType.length() > SqlField_CharSmall) + return u_data.m_sqlChar; + return u_data.m_sqlCharSmall; +} + +const SqlChar* +SqlField::sqlVarchar(unsigned* length) const +{ +#if NDB_VERSION_MAJOR >= 3 + if (sqlSpec().store() == SqlSpec::Reference) { + ctx_assert(u_data.m_sqlField != 0); + return u_data.m_sqlField->sqlVarchar(length); + } + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Varchar); + const SqlChar* sqlChar; + unsigned n = sqlType.length(); + if (2 + n > SqlField_CharSmall) + sqlChar = u_data.m_sqlChar; + else + sqlChar = u_data.m_sqlCharSmall; + if (length != 0) + *length = (sqlChar[0] << 8) | sqlChar[1]; // big-endian + return sqlChar + 2; +#else + if (sqlSpec().store() == SqlSpec::Reference) { + ctx_assert(u_data.m_sqlField != 0); + return u_data.m_sqlField->sqlVarchar(length); + } + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Varchar); + const SqlChar* sqlChar; + unsigned n = sqlType.length(); + if (n + 2 > SqlField_CharSmall) + sqlChar = u_data.m_sqlChar; + else + sqlChar = u_data.m_sqlCharSmall; + if (length != 0) + *length = (sqlChar[n + 0] << 8) | sqlChar[n + 1]; // big-endian + return sqlChar; +#endif +} + +const SqlChar* +SqlField::sqlBinary() const +{ + if (sqlSpec().store() == SqlSpec::Reference) { + ctx_assert(u_data.m_sqlField != 0); + return u_data.m_sqlField->sqlChar(); + } + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Binary); + if (sqlType.length() > SqlField_CharSmall) + return u_data.m_sqlChar; + return u_data.m_sqlCharSmall; +} + +const SqlChar* +SqlField::sqlVarbinary(unsigned* length) const +{ +#if NDB_VERSION_MAJOR >= 3 + if (sqlSpec().store() == SqlSpec::Reference) { + ctx_assert(u_data.m_sqlField != 0); + return u_data.m_sqlField->sqlVarchar(length); + } + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Varbinary); + const SqlChar* sqlChar; + unsigned n = sqlType.length(); + if (2 + n > SqlField_CharSmall) + sqlChar = u_data.m_sqlChar; + else + sqlChar = u_data.m_sqlCharSmall; + if (length != 0) + *length = (sqlChar[0] << 8) | sqlChar[1]; // big-endian + return sqlChar + 2; +#else + if (sqlSpec().store() == SqlSpec::Reference) { + ctx_assert(u_data.m_sqlField != 0); + return u_data.m_sqlField->sqlVarchar(length); + } + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Varbinary); + const SqlChar* sqlChar; + unsigned n = sqlType.length(); + if (n + 2 > SqlField_CharSmall) + sqlChar = u_data.m_sqlChar; + else + sqlChar = u_data.m_sqlCharSmall; + if (length != 0) + *length = (sqlChar[n + 0] << 8) | sqlChar[n + 1]; // big-endian + return sqlChar; +#endif +} + +SqlSmallint +SqlField::sqlSmallint() const +{ + if (sqlSpec().store() == SqlSpec::Reference) { + ctx_assert(u_data.m_sqlField != 0); + return u_data.m_sqlField->sqlSmallint(); + } + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Smallint); + return u_data.m_sqlSmallint; +} + +SqlInteger +SqlField::sqlInteger() const +{ + if (sqlSpec().store() == SqlSpec::Reference) { + ctx_assert(u_data.m_sqlField != 0); + return u_data.m_sqlField->sqlInteger(); + } + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Integer); + return u_data.m_sqlInteger; +} + +SqlBigint +SqlField::sqlBigint() const +{ + if (sqlSpec().store() == SqlSpec::Reference) { + ctx_assert(u_data.m_sqlField != 0); + return u_data.m_sqlField->sqlBigint(); + } + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Bigint); + return u_data.m_sqlBigint; +} + +SqlReal +SqlField::sqlReal() const +{ + if (sqlSpec().store() == SqlSpec::Reference) { + ctx_assert(u_data.m_sqlField != 0); + return u_data.m_sqlField->sqlReal(); + } + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Real); + return u_data.m_sqlReal; +} + +SqlDouble +SqlField::sqlDouble() const +{ + if (sqlSpec().store() == SqlSpec::Reference) { + ctx_assert(u_data.m_sqlField != 0); + return u_data.m_sqlField->sqlDouble(); + } + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Double); + return u_data.m_sqlDouble; +} + +SqlDatetime +SqlField::sqlDatetime() const +{ + if (sqlSpec().store() == SqlSpec::Reference) { + ctx_assert(u_data.m_sqlField != 0); + return u_data.m_sqlField->sqlDatetime(); + } + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Datetime); + return u_data.m_sqlDatetime; +} + +// set + +void +SqlField::sqlChar(const SqlChar* value, int length) +{ + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Char); + unsigned n = sqlType.length(); + SqlChar* p = n > SqlField_CharSmall ? u_data.m_sqlChar : u_data.m_sqlCharSmall; + const SqlChar* q = value; + unsigned m = length == SQL_NTS ? strlen((const char*)q) : length; + ctx_assert(m <= n); + for (unsigned i = 0; i < m; i++) + *p++ = *q++; + for (unsigned i = m; i < n; i++) + *p++ = 0x20; // space + u_null.m_nullFlag = false; +} + +void +SqlField::sqlVarchar(const SqlChar* value, int length) +{ +#if NDB_VERSION_MAJOR >= 3 + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Varchar); + unsigned n = sqlType.length(); + SqlChar* p = 2 + n > SqlField_CharSmall ? u_data.m_sqlChar : u_data.m_sqlCharSmall; + const SqlChar* q = value; + unsigned m = length == SQL_NTS ? strlen((const char*)q) : length; + ctx_assert(m <= n); + *p++ = (m >> 8) & 0xff; // big-endian + *p++ = (m & 0xff); + for (unsigned i = 0; i < m; i++) + *p++ = *q++; + for (unsigned i = m; i < n; i++) + *p++ = 0x0; // null + u_null.m_nullFlag = false; +#else + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Varchar); + unsigned n = sqlType.length(); + SqlChar* p = n + 2 > SqlField_CharSmall ? u_data.m_sqlChar : u_data.m_sqlCharSmall; + const SqlChar* q = value; + unsigned m = length == SQL_NTS ? strlen((const char*)q) : length; + ctx_assert(m <= n); + for (unsigned i = 0; i < m; i++) + *p++ = *q++; + for (unsigned i = m; i < n; i++) + *p++ = 0x0; // null + *p++ = (m >> 8) & 0xff; // big-endian + *p++ = (m & 0xff); + u_null.m_nullFlag = false; +#endif +} + +void +SqlField::sqlBinary(const SqlChar* value, int length) +{ + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Binary); + unsigned n = sqlType.length(); + SqlChar* p = n > SqlField_CharSmall ? u_data.m_sqlChar : u_data.m_sqlCharSmall; + const SqlChar* q = value; + unsigned m = length; + ctx_assert(m <= n); + for (unsigned i = 0; i < m; i++) + *p++ = *q++; + for (unsigned i = m; i < n; i++) + *p++ = 0x0; // null + u_null.m_nullFlag = false; +} + +void +SqlField::sqlVarbinary(const SqlChar* value, int length) +{ +#if NDB_VERSION_MAJOR >= 3 + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Varbinary); + unsigned n = sqlType.length(); + SqlChar* p = 2 + n > SqlField_CharSmall ? u_data.m_sqlChar : u_data.m_sqlCharSmall; + const SqlChar* q = value; + unsigned m = length; + ctx_assert(m <= n); + *p++ = (m >> 8) & 0xff; // big-endian + *p++ = (m & 0xff); + for (unsigned i = 0; i < m; i++) + *p++ = *q++; + for (unsigned i = m; i < n; i++) + *p++ = 0x0; // null + u_null.m_nullFlag = false; +#else + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Varbinary); + unsigned n = sqlType.length(); + SqlChar* p = n + 2 > SqlField_CharSmall ? u_data.m_sqlChar : u_data.m_sqlCharSmall; + const SqlChar* q = value; + unsigned m = length; + ctx_assert(m <= n); + for (unsigned i = 0; i < m; i++) + *p++ = *q++; + for (unsigned i = m; i < n; i++) + *p++ = 0x0; // null + *p++ = (m >> 8) & 0xff; // big-endian + *p++ = (m & 0xff); + u_null.m_nullFlag = false; +#endif +} + +void +SqlField::sqlSmallint(SqlSmallint value) +{ + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Smallint); + u_data.m_sqlSmallint = value; + u_null.m_nullFlag = false; +} + +void +SqlField::sqlInteger(SqlInteger value) +{ + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Integer); + u_data.m_sqlInteger = value; + u_null.m_nullFlag = false; +} + +void +SqlField::sqlBigint(SqlBigint value) +{ + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Bigint); + u_data.m_sqlBigint = value; + u_null.m_nullFlag = false; +} + +void +SqlField::sqlReal(SqlReal value) +{ + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Real); + u_data.m_sqlReal = value; + u_null.m_nullFlag = false; +} + +void +SqlField::sqlDouble(SqlDouble value) +{ + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Double); + u_data.m_sqlDouble = value; + u_null.m_nullFlag = false; +} + +void +SqlField::sqlDatetime(SqlDatetime value) +{ + const SqlType& sqlType = sqlSpec().sqlType(); + ctx_assert(sqlType.type() == SqlType::Datetime); + u_data.m_sqlDatetime = value; + u_null.m_nullFlag = false; +} + +// get and and set null + +bool +SqlField::sqlNull() const +{ + if (sqlSpec().store() == SqlSpec::Reference) { + ctx_assert(u_data.m_sqlField != 0); + return u_data.m_sqlField->sqlNull(); + } + return u_null.m_nullFlag; +} + +void +SqlField::sqlNull(bool value) +{ + u_null.m_nullFlag = value; +} + +unsigned +SqlField::trim() const +{ + const SqlType& sqlType = sqlSpec().sqlType(); + unsigned n = 0; + const SqlChar* s = 0; + if (sqlType.type() == SqlType::Char) { + n = sqlType.length(); + s = sqlChar(); + } else if (sqlType.type() == SqlType::Varchar) { + s = sqlVarchar(&n); + } else { + ctx_assert(false); + return 0; + } + while (n > 0 && s[n - 1] == 0x20) + n--; + return n; +} + +void +SqlField::copy(Ctx& ctx, SqlField& out) const +{ + const SqlField& f1 = *this; + SqlField& f2 = out; + const SqlType& t1 = f1.sqlSpec().sqlType(); + const SqlType& t2 = f2.sqlSpec().sqlType(); + ctx_assert(t1.type() == t2.type()); + if (f1.sqlNull()) { + f2.sqlNull(true); + return; + } + if (t1.type() == SqlType::Char) { + f2.sqlChar(f1.sqlChar(), t1.length()); + return; + } + if (t1.type() == SqlType::Varchar) { + unsigned length; + const SqlChar* s1 = f1.sqlVarchar(&length); + f2.sqlVarchar(s1, length); + return; + } + if (t1.type() == SqlType::Binary) { + f2.sqlBinary(f1.sqlBinary(), t1.length()); + return; + } + if (t1.type() == SqlType::Varbinary) { + unsigned length; + const SqlChar* s1 = f1.sqlVarbinary(&length); + f2.sqlVarbinary(s1, length); + return; + } + if (t1.type() == SqlType::Smallint) { + f2.sqlSmallint(f1.sqlSmallint()); + return; + } + if (t1.type() == SqlType::Integer) { + f2.sqlInteger(f1.sqlInteger()); + return; + } + if (t1.type() == SqlType::Bigint) { + f2.sqlBigint(f1.sqlBigint()); + return; + } + if (t1.type() == SqlType::Real) { + f2.sqlReal(f1.sqlReal()); + return; + } + if (t1.type() == SqlType::Double) { + f2.sqlDouble(f1.sqlDouble()); + return; + } + if (t1.type() == SqlType::Datetime) { + f2.sqlDatetime(f1.sqlDatetime()); + return; + } + ctx_assert(false); +} + +bool +SqlField::cast(Ctx& ctx, SqlField& out) const +{ + const SqlField& f1 = *this; + SqlField& f2 = out; + if (f1.sqlNull()) { + f2.sqlNull(true); + return true; + } + const SqlType& t1 = f1.sqlSpec().sqlType(); + const SqlType& t2 = f2.sqlSpec().sqlType(); + if (t1.type() == SqlType::Char) { + if (t2.type() == SqlType::Char) { + unsigned n1 = f1.trim(); + if (n1 > t2.length()) + return false; + f2.sqlChar(f1.sqlChar(), n1); + return true; + } + if (t2.type() == SqlType::Varchar) { + unsigned n1 = t1.length(); + if (n1 > t2.length()) + return false; + f2.sqlVarchar(f1.sqlChar(), n1); + return true; + } + if (t2.type() == SqlType::Binary) { + unsigned n1 = t1.length(); + if (n1 > t2.length()) + return false; + f2.sqlBinary(f1.sqlChar(), n1); + return true; + } + if (t2.type() == SqlType::Varbinary) { + unsigned n1 = t1.length(); + if (n1 > t2.length()) + return false; + f2.sqlVarbinary(f1.sqlChar(), n1); + return true; + } + ctx_assert(false); + return false; + } + if (t1.type() == SqlType::Varchar) { + if (t2.type() == SqlType::Char) { + unsigned n1 = f1.trim(); + if (n1 > t2.length()) + return false; + f2.sqlChar(f1.sqlVarchar(0), n1); + return true; + } + if (t2.type() == SqlType::Varchar) { + unsigned n1 = f1.trim(); + if (n1 > t2.length()) + return false; + f2.sqlVarchar(f1.sqlVarchar(0), n1); + return true; + } + if (t2.type() == SqlType::Binary) { + unsigned n1 = t1.length(); + if (n1 > t2.length()) + return false; + f2.sqlBinary(f1.sqlVarchar(0), n1); + return true; + } + if (t2.type() == SqlType::Varbinary) { + unsigned n1 = t1.length(); + if (n1 > t2.length()) + return false; + f2.sqlVarbinary(f1.sqlVarchar(0), n1); + return true; + } + ctx_assert(false); + return false; + } + if (t1.type() == SqlType::Binary) { + if (t2.type() == SqlType::Binary) { + unsigned n1 = t1.length(); + if (n1 > t2.length()) + return false; + f2.sqlBinary(f1.sqlBinary(), n1); + return true; + } + if (t2.type() == SqlType::Varbinary) { + unsigned n1 = t1.length(); + if (n1 > t2.length()) + return false; + f2.sqlVarbinary(f1.sqlBinary(), n1); + return true; + } + ctx_assert(false); + return false; + } + if (t1.type() == SqlType::Varbinary) { + if (t2.type() == SqlType::Binary) { + unsigned n1 = t1.length(); + if (n1 > t2.length()) + return false; + f2.sqlBinary(f1.sqlVarbinary(0), n1); + return true; + } + if (t2.type() == SqlType::Varbinary) { + unsigned n1 = t1.length(); + if (n1 > t2.length()) + return false; + f2.sqlVarbinary(f1.sqlVarbinary(0), n1); + return true; + } + ctx_assert(false); + return false; + } + if (t1.type() == SqlType::Smallint) { + if (! t2.unSigned()) { + SqlSmallint x1 = f1.sqlSmallint(); + if (t2.type() == SqlType::Smallint) { + f2.sqlSmallint(x1); + return true; + } + if (t2.type() == SqlType::Integer) { + SqlInteger x2 = static_cast(x1); + f2.sqlInteger(x2); + return true; + } + if (t2.type() == SqlType::Bigint) { + SqlBigint x2 = static_cast(x1); + f2.sqlBigint(x2); + return true; + } + if (t2.type() == SqlType::Real) { + SqlReal x2 = static_cast(x1); + f2.sqlReal(x2); + return true; + } + if (t2.type() == SqlType::Double) { + SqlDouble x2 = static_cast(x1); + f2.sqlDouble(x2); + return true; + } + } else { + SqlUsmallint x1 = f1.sqlSmallint(); + if (t2.type() == SqlType::Smallint) { + f2.sqlSmallint(x1); + return true; + } + if (t2.type() == SqlType::Integer) { + SqlUinteger x2 = static_cast(x1); + f2.sqlInteger(x2); + return true; + } + if (t2.type() == SqlType::Bigint) { + SqlUbigint x2 = static_cast(x1); + f2.sqlBigint(x2); + return true; + } + } + ctx_assert(false); + return false; + } + if (t1.type() == SqlType::Integer) { + if (! t2.unSigned()) { + SqlInteger x1 = f1.sqlInteger(); + if (t2.type() == SqlType::Smallint) { + SqlSmallint x2 = static_cast(x1); + if (x1 != static_cast(x2)) + return false; + f2.sqlSmallint(x2); + return true; + } + if (t2.type() == SqlType::Integer) { + f2.sqlInteger(x1); + return true; + } + if (t2.type() == SqlType::Bigint) { + SqlBigint x2 = static_cast(x1); + f2.sqlBigint(x2); + return true; + } + if (t2.type() == SqlType::Real) { + SqlReal x2 = static_cast(x1); + f2.sqlReal(x2); + return true; + } + if (t2.type() == SqlType::Double) { + SqlDouble x2 = static_cast(x1); + f2.sqlDouble(x2); + return true; + } + } else { + SqlUinteger x1 = f1.sqlInteger(); + if (t2.type() == SqlType::Smallint) { + SqlUsmallint x2 = static_cast(x1); + if (x1 != static_cast(x2)) + return false; + f2.sqlSmallint(x2); + return true; + } + if (t2.type() == SqlType::Integer) { + f2.sqlInteger(x1); + return true; + } + if (t2.type() == SqlType::Bigint) { + SqlUbigint x2 = static_cast(x1); + f2.sqlBigint(x2); + return true; + } + } + ctx_assert(false); + return false; + } + if (t1.type() == SqlType::Bigint) { + if (! t2.unSigned()) { + SqlBigint x1 = f1.sqlBigint(); + if (t2.type() == SqlType::Smallint) { + SqlSmallint x2 = static_cast(x1); + if (x1 != static_cast(x2)) + return false; + f2.sqlSmallint(x2); + return true; + } + if (t2.type() == SqlType::Integer) { + SqlInteger x2 = static_cast(x1); + if (x1 != static_cast(x2)) + return false; + f2.sqlInteger(x2); + return true; + } + if (t2.type() == SqlType::Bigint) { + f2.sqlBigint(x1); + return true; + } + if (t2.type() == SqlType::Real) { + SqlReal x2 = static_cast(x1); + f2.sqlReal(x2); + return true; + } + if (t2.type() == SqlType::Double) { + SqlDouble x2 = static_cast(x1); + f2.sqlDouble(x2); + return true; + } + } else { + SqlUbigint x1 = f1.sqlBigint(); + if (t2.type() == SqlType::Smallint) { + SqlUsmallint x2 = static_cast(x1); + if (x1 != static_cast(x2)) + return false; + f2.sqlSmallint(x2); + return true; + } + if (t2.type() == SqlType::Integer) { + SqlUinteger x2 = static_cast(x1); + if (x1 != static_cast(x2)) + return false; + f2.sqlInteger(x2); + return true; + } + if (t2.type() == SqlType::Bigint) { + f2.sqlBigint(x1); + return true; + } + } + ctx_assert(false); + return false; + } + if (t1.type() == SqlType::Real) { + SqlReal x1 = f1.sqlReal(); + int off = 0; + if (x1 > 0.0 && x1 - floor(x1) >= 0.5) + off = 1; + if (x1 < 0.0 && x1 - floor(x1) <= 0.5) + off = -1; + bool b = (x1 - floor(x1) < 0.5); + if (t2.type() == SqlType::Smallint) { + SqlSmallint x2 = static_cast(x1) + off; + if (fabs(x1 - static_cast(x2)) >= 1.0) + return false; + f2.sqlSmallint(x2); + return true; + } + if (t2.type() == SqlType::Integer) { + SqlInteger x2 = static_cast(x1) + off; + if (fabs(x1 - static_cast(x2)) >= 1.0) + return false; + f2.sqlInteger(x2); + return true; + } + if (t2.type() == SqlType::Bigint) { + SqlBigint x2 = static_cast(x1) + off; + if (fabs(x1 - static_cast(x2)) >= 1.0) + return false; + f2.sqlBigint(x2); + return true; + } + if (t2.type() == SqlType::Real) { + f2.sqlReal(x1); + return true; + } + if (t2.type() == SqlType::Double) { + SqlDouble x2 = static_cast(x1); + f2.sqlDouble(x2); + return true; + } + ctx_assert(false); + return false; + } + if (t1.type() == SqlType::Double) { + SqlDouble x1 = f1.sqlDouble(); + int off = 0; + if (x1 > 0.0 && x1 - floor(x1) >= 0.5) + off = 1; + if (x1 < 0.0 && x1 - floor(x1) <= 0.5) + off = -1; + bool b = (x1 - floor(x1) < 0.5); + if (t2.type() == SqlType::Smallint) { + SqlSmallint x2 = static_cast(x1) + off; + if (fabs(x1 - static_cast(x2)) >= 1.0) + return false; + f2.sqlSmallint(x2); + return true; + } + if (t2.type() == SqlType::Integer) { + SqlInteger x2 = static_cast(x1) + off; + if (fabs(x1 - static_cast(x2)) >= 1.0) + return false; + f2.sqlInteger(x2); + return true; + } + if (t2.type() == SqlType::Bigint) { + SqlBigint x2 = static_cast(x1) + off; + if (fabs(x1 - static_cast(x2)) >= 1.0) + return false; + f2.sqlBigint(x2); + return true; + } + if (t2.type() == SqlType::Real) { + SqlReal x2 = static_cast(x1); + if (fabs(x1 - static_cast(x2)) >= 1.0) // XXX + return false; + f2.sqlReal(x1); + return true; + } + if (t2.type() == SqlType::Double) { + f2.sqlDouble(x1); + return true; + } + ctx_assert(false); + return false; + } + ctx_assert(false); + return false; +} + +bool +SqlField::less(const SqlField& sqlField) const +{ + const SqlField& f1 = *this; + const SqlField& f2 = sqlField; + const SqlType& t1 = f1.sqlSpec().sqlType(); + const SqlType& t2 = f2.sqlSpec().sqlType(); + ctx_assert(t1.type() == t2.type()); + if (t1.type() == SqlType::Char) { + const SqlChar* s1 = f1.sqlChar(); + const SqlChar* s2 = f2.sqlChar(); + unsigned n1 = t1.length(); + unsigned n2 = t2.length(); + SqlChar c1 = 0; + SqlChar c2 = 0; + unsigned i = 0; + while (i < n1 || i < n2) { + c1 = i < n1 ? s1[i] : 0x20; + c2 = i < n2 ? s2[i] : 0x20; + if (c1 != c2) + break; + i++; + } + return (c1 < c2); + } + if (t1.type() == SqlType::Varchar) { + unsigned n1, n2; + const SqlChar* s1 = f1.sqlVarchar(&n1); + const SqlChar* s2 = f2.sqlVarchar(&n2); + SqlChar c1 = 0; + SqlChar c2 = 0; + unsigned i = 0; + while (i < n1 || i < n2) { + c1 = i < n1 ? s1[i] : 0x0; + c2 = i < n2 ? s2[i] : 0x0; + if (c1 != c2) + break; + i++; + } + return (c1 < c2); + } + if (t1.type() == SqlType::Smallint) { + ctx_assert(t1.unSigned() == t2.unSigned()); + if (! t1.unSigned()) { + SqlSmallint x1 = f1.sqlSmallint(); + SqlSmallint x2 = f2.sqlSmallint(); + return (x1 < x2); + } else { + SqlUsmallint x1 = f1.sqlSmallint(); + SqlUsmallint x2 = f2.sqlSmallint(); + return (x1 < x2); + } + } + if (t1.type() == SqlType::Integer) { + ctx_assert(t1.unSigned() == t2.unSigned()); + if (! t1.unSigned()) { + SqlInteger x1 = f1.sqlInteger(); + SqlInteger x2 = f2.sqlInteger(); + return (x1 < x2); + } else { + SqlUinteger x1 = f1.sqlInteger(); + SqlUinteger x2 = f2.sqlInteger(); + return (x1 < x2); + } + } + if (t1.type() == SqlType::Bigint) { + ctx_assert(t1.unSigned() == t2.unSigned()); + if (! t1.unSigned()) { + SqlBigint x1 = f1.sqlBigint(); + SqlBigint x2 = f2.sqlBigint(); + return (x1 < x2); + } else { + SqlUbigint x1 = f1.sqlBigint(); + SqlUbigint x2 = f2.sqlBigint(); + return (x1 < x2); + } + } + if (t1.type() == SqlType::Real) { + SqlReal x1 = f1.sqlReal(); + SqlReal x2 = f2.sqlReal(); + return (x1 < x2); + } + if (t1.type() == SqlType::Double) { + SqlDouble x1 = f1.sqlDouble(); + SqlDouble x2 = f2.sqlDouble(); + return (x1 < x2); + } + if (t1.type() == SqlType::Datetime) { + SqlDatetime x1 = f1.sqlDatetime(); + SqlDatetime x2 = f2.sqlDatetime(); + return x1.less(x2); + } + ctx_assert(false); +} + +// copy from external + +static bool +copyin_char_char(Ctx& ctx, char* value, unsigned n, const char* ptr, const SQLINTEGER* ind, int* off, SqlChar* addr, int fieldId) +{ + if (off != 0 && *off >= 0) { + if ((unsigned)*off > n) { + ctx.pushStatus(Sqlstate::_22001, Error::Gen, "input parameter %d truncated (%u > %u)", fieldId, (unsigned)*off, n); + return false; + } + value += *off; + n -= *off; + } + unsigned m; + if (ind == 0 || *ind == SQL_NTS) + m = strlen(ptr); + else + m = *ind; + if (m > n) { + ctx.pushStatus(Sqlstate::_22001, Error::Gen, "input parameter %d truncated (%u > %u)", fieldId, m, n); + return false; + } + for (unsigned i = 0; i < m; i++) + value[i] = ptr[i]; + if (off != 0 && *off >= 0) + *off += m; + for (unsigned i = m; i < n; i++) + value[i] = addr == 0 ? 0x20 : 0x0; + if (addr != 0) { + if (off != 0 && *off >= 0) + m = *off; + addr[0] = (m >> 8) & 0xff; + addr[1] = (m & 0xff); + } + return true; +} + +static bool +copyin_binary_binary(Ctx& ctx, char* value, unsigned n, const char* ptr, const SQLINTEGER* ind, int* off, SqlChar* addr, int fieldId) +{ + if (off != 0 && *off >= 0) { + if ((unsigned)*off > n) { + ctx.pushStatus(Sqlstate::_22001, Error::Gen, "input parameter %d truncated (%u > %u)", fieldId, (unsigned)*off, n); + return false; + } + value += *off; + n -= *off; + } + if (ind == 0) { + ctx.pushStatus(Sqlstate::_22001, Error::Gen, "input parameter %d missing length", fieldId); + return false; + } + if (*ind < 0) { + ctx.pushStatus(Sqlstate::_22001, Error::Gen, "input parameter %d invalid length %d", fieldId, (int)*ind); + return false; + } + unsigned m; + m = *ind; + if (m > n) { + ctx.pushStatus(Sqlstate::_22001, Error::Gen, "input parameter %d truncated (%u > %u)", fieldId, m, n); + return false; + } + for (unsigned i = 0; i < m; i++) + value[i] = ptr[i]; + if (off != 0 && *off >= 0) + *off += m; + for (unsigned i = m; i < n; i++) + value[i] = addr == 0 ? 0x0 : 0x0; // just null + if (addr != 0) { + if (off != 0 && *off >= 0) + m = *off; + addr[0] = (m >> 8) & 0xff; + addr[1] = (m & 0xff); + } + return true; +} + +static bool +copyin_signed_char(Ctx& ctx, SqlBigint* value, const char* ptr, int fieldId) +{ + errno = 0; + char* endptr = 0; + SqlBigint x = strtoll(ptr, &endptr, 10); + if (endptr == 0 || *endptr != 0) { + errno = 0; + endptr = 0; + double y = strtod(ptr, &endptr); + if (endptr == 0 || *endptr != 0) { + ctx.pushStatus(Sqlstate::_22005, Error::Gen, "input parameter %d value %s not numeric", fieldId, ptr); + return false; + } else if (errno != 0) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "input parameter %d value %s overflow", fieldId, ptr); + return false; + } + // XXX should handle 123.000 + ctx.pushStatus(Sqlstate::_01004, Error::Gen, "input parameter %d value %s truncated", fieldId, ptr); + x = static_cast(y); + } else if (errno != 0) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "input parameter %d value %s overflow", fieldId, ptr); + return false; + } + *value = x; + return true; +} + +static bool +copyin_double_char(Ctx& ctx, SqlDouble* value, const char* ptr, int fieldId) +{ + errno = 0; + char* endptr = 0; + double x = strtod(ptr, &endptr); + if (endptr == 0 || *endptr != 0) { + ctx.pushStatus(Sqlstate::_22005, Error::Gen, "input parameter %d value %s not numeric", fieldId, ptr); + return false; + } else if (errno != 0) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "input parameter %d value %s overflow", fieldId, ptr); + return false; + } + *value = x; + return true; +} + +void +SqlField::copyin(Ctx& ctx, ExtField& extField) +{ + ctx_assert(extField.extSpec().extType().type() != ExtType::Unbound); + ctx_assert(sqlSpec().store() == SqlSpec::Physical); + SQLINTEGER* indPtr = extField.m_indPtr; + const int fieldId = extField.fieldId(); + if (indPtr != 0 && *indPtr == SQL_NULL_DATA) { + sqlNull(true); + return; + } + const SqlType& sqlType = sqlSpec().sqlType(); + const ExtType& extType = extField.extSpec().extType(); + if (extField.m_pos > 0) { + if (sqlType.type() == SqlType::Char && extType.type() == ExtType::Char) + ; + else if (sqlType.type() == SqlType::Varchar && extType.type() == ExtType::Char) + ; + else { + char buf[40]; + sqlType.print(buf, sizeof(buf)); + ctx.pushStatus(Sqlstate::_HY019, Error::Gen, "cannot send %s data in pieces", buf); + return; + } + } + if (sqlType.type() == SqlType::Char || sqlType.type() == SqlType::Varchar) { + unsigned length = 0; + char* value = 0; + SqlChar* laddr = 0; // Varchar length address + if (sqlType.type() == SqlType::Char) { + length = sqlType.length(); + if (length > SqlField_CharSmall) + value = reinterpret_cast(u_data.m_sqlChar); + else + value = reinterpret_cast(u_data.m_sqlCharSmall); + laddr = 0; + } else { +#if NDB_VERSION_MAJOR >= 3 + length = sqlType.length(); + if (2 + length > SqlField_CharSmall) + value = reinterpret_cast(u_data.m_sqlChar + 2); + else + value = reinterpret_cast(u_data.m_sqlCharSmall + 2); + laddr = (SqlChar*)value - 2; +#else + length = sqlType.length(); + if (length + 2 > SqlField_CharSmall) + value = reinterpret_cast(u_data.m_sqlChar); + else + value = reinterpret_cast(u_data.m_sqlCharSmall); + laddr = (SqlChar*)value + length; +#endif + } + if (extType.type() == ExtType::Char) { + const char* dataPtr = static_cast(extField.m_dataPtr); + int* off = 0; + if (extField.m_pos >= 0) + off = &extField.m_pos; + if (! copyin_char_char(ctx, value, length, dataPtr, indPtr, off, laddr, fieldId)) + return; + sqlNull(false); + return; + } + if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) { + const short* dataPtr = static_cast(extField.m_dataPtr); + char buf[100]; + sprintf(buf, "%hd", *dataPtr); + if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId)) + return; + sqlNull(false); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ushort) { + const unsigned short* dataPtr = static_cast(extField.m_dataPtr); + char buf[100]; + sprintf(buf, "%hu", *dataPtr); + if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId)) + return; + sqlNull(false); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) { + const long* dataPtr = static_cast(extField.m_dataPtr); + char buf[100]; + sprintf(buf, "%ld", *dataPtr); + if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId)) + return; + sqlNull(false); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ulong) { + const unsigned long* dataPtr = static_cast(extField.m_dataPtr); + char buf[100]; + sprintf(buf, "%lu", *dataPtr); + if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId)) + return; + sqlNull(false); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Sbigint) { + const SQLBIGINT* dataPtr = static_cast(extField.m_dataPtr); + char buf[100]; + sprintf(buf, FMT_I64, *dataPtr); + if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId)) + return; + sqlNull(false); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ubigint) { + const SQLUBIGINT* dataPtr = static_cast(extField.m_dataPtr); + char buf[100]; + sprintf(buf, FMT_U64, *dataPtr); + if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId)) + return; + sqlNull(false); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Float) { + const float* dataPtr = static_cast(extField.m_dataPtr); + char buf[100]; + sprintf(buf, "%.7f", (double)*dataPtr); + if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId)) + return; + sqlNull(false); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Double) { + const double* dataPtr = static_cast(extField.m_dataPtr); + char buf[100]; + sprintf(buf, "%.14f", *dataPtr); + if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId)) + return; + sqlNull(false); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + } + if (sqlType.type() == SqlType::Binary || sqlType.type() == SqlType::Varbinary) { + unsigned length = 0; + char* value = 0; + SqlChar* laddr = 0; // Varbinary length address + if (sqlType.type() == SqlType::Binary) { + length = sqlType.length(); + if (length > SqlField_CharSmall) + value = reinterpret_cast(u_data.m_sqlChar); + else + value = reinterpret_cast(u_data.m_sqlCharSmall); + laddr = 0; + } else { +#if NDB_VERSION_MAJOR >= 3 + length = sqlType.length(); + if (2 + length > SqlField_CharSmall) + value = reinterpret_cast(u_data.m_sqlChar + 2); + else + value = reinterpret_cast(u_data.m_sqlCharSmall + 2); + laddr = (SqlChar*)value - 2; +#else + length = sqlType.length(); + if (length + 2 > SqlField_CharSmall) + value = reinterpret_cast(u_data.m_sqlChar); + else + value = reinterpret_cast(u_data.m_sqlCharSmall); + laddr = (SqlChar*)value + length; +#endif + } + if (extType.type() == ExtType::Binary) { + const char* dataPtr = static_cast(extField.m_dataPtr); + int* off = 0; + if (extField.m_pos >= 0) + off = &extField.m_pos; + if (! copyin_binary_binary(ctx, value, length, dataPtr, indPtr, off, laddr, fieldId)) + return; + sqlNull(false); + return; + } + } + if (sqlType.type() == SqlType::Smallint) { + SqlSmallint value; + if (extType.type() == ExtType::Char) { + const char* dataPtr = static_cast(extField.m_dataPtr); + SqlBigint x; + if (! copyin_signed_char(ctx, &x, dataPtr, fieldId)) + return; + value = x; + sqlSmallint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) { + short* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlSmallint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ushort) { + unsigned short* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlSmallint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) { + long* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlSmallint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ulong) { + unsigned long* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlSmallint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Sbigint) { + SQLBIGINT* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlSmallint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ubigint) { + SQLUBIGINT* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlSmallint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Float) { + float* dataPtr = static_cast(extField.m_dataPtr); + value = (SqlSmallint)*dataPtr; + sqlSmallint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Double) { + double* dataPtr = static_cast(extField.m_dataPtr); + value = (SqlSmallint)*dataPtr; + sqlSmallint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + } + if (sqlType.type() == SqlType::Integer) { + SqlInteger value; + if (extType.type() == ExtType::Char) { + const char* dataPtr = static_cast(extField.m_dataPtr); + SqlBigint x; + if (! copyin_signed_char(ctx, &x, dataPtr, fieldId)) + return; + value = x; + sqlInteger(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) { + short* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlInteger(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ushort) { + unsigned short* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlInteger(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) { + long* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlInteger(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ulong) { + unsigned long* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlInteger(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Sbigint) { + SQLBIGINT* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlInteger(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ubigint) { + SQLUBIGINT* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlInteger(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Float) { + float* dataPtr = static_cast(extField.m_dataPtr); + value = (SqlInteger)*dataPtr; + sqlInteger(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Double) { + double* dataPtr = static_cast(extField.m_dataPtr); + value = (SqlInteger)*dataPtr; + sqlInteger(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + } + if (sqlType.type() == SqlType::Bigint) { + SqlBigint value; + if (extType.type() == ExtType::Char) { + const char* dataPtr = static_cast(extField.m_dataPtr); + SqlBigint x; + if (! copyin_signed_char(ctx, &x, dataPtr, fieldId)) + return; + value = x; + sqlBigint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) { + short* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlBigint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ushort) { + unsigned short* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlBigint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) { + long* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlBigint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ulong) { + unsigned long* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlBigint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Sbigint) { + SQLBIGINT* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlBigint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ubigint) { + SQLUBIGINT* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlBigint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Float) { + float* dataPtr = static_cast(extField.m_dataPtr); + value = (SqlBigint)*dataPtr; + sqlBigint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Double) { + double* dataPtr = static_cast(extField.m_dataPtr); + value = (SqlBigint)*dataPtr; + sqlBigint(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + } + if (sqlType.type() == SqlType::Real) { + SqlReal value; + if (extType.type() == ExtType::Char) { + const char* dataPtr = static_cast(extField.m_dataPtr); + SqlDouble x; + if (! copyin_double_char(ctx, &x, dataPtr, fieldId)) + return; + value = x; + sqlReal(x); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) { + short* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlReal(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ushort) { + unsigned short* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlReal(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) { + long* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlReal(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ulong) { + unsigned long* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlReal(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Sbigint) { + SQLBIGINT* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlReal(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ubigint) { + SQLUBIGINT* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlReal(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Float) { + float* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlReal(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Double) { + double* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlReal(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + } + if (sqlType.type() == SqlType::Double) { + SqlDouble value; + if (extType.type() == ExtType::Char) { + const char* dataPtr = static_cast(extField.m_dataPtr); + SqlDouble x; + if (! copyin_double_char(ctx, &x, dataPtr, fieldId)) + return; + value = x; + sqlDouble(x); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) { + short* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlDouble(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ushort) { + unsigned short* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlDouble(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) { + long* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlDouble(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ulong) { + unsigned long* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlDouble(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Sbigint) { + SQLBIGINT* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlDouble(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ubigint) { + SQLUBIGINT* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlDouble(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Float) { + float* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlDouble(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Double) { + double* dataPtr = static_cast(extField.m_dataPtr); + value = *dataPtr; + sqlDouble(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + } + if (sqlType.type() == SqlType::Datetime) { + SqlDatetime value; + if (extType.type() == ExtType::Char) { + // XXX replace sscanf by manual scan or regex + const char* dataPtr = static_cast(extField.m_dataPtr); + int cc = 0; + unsigned yy = 0, mm = 0, dd = 0, HH = 0, MM = 0, SS = 0, ff = 0; + bool setdate = false; + char dummy[10]; + if (sscanf(dataPtr, "%2d%2u-%2u-%2u %2u:%2u:%2u.%4u%1s", &cc, &yy, &mm, &dd, &HH, &MM, &SS, &ff, dummy) == 8) { + ; + } else if (sscanf(dataPtr, "%2d%2u-%2u-%2u %2u:%2u:%2u%1s", &cc, &yy, &mm, &dd, &HH, &MM, &SS, dummy) == 7) { + ; + } else if (sscanf(dataPtr, "%2d%2u-%2u-%2u%1s", &cc, &yy, &mm, &dd, dummy) == 4) { + ; + } else if (sscanf(dataPtr, "%2u:%2u:%2u.%4u%1s", &HH, &MM, &SS, &ff, dummy) == 4) { + setdate = true; + } else if (sscanf(dataPtr, "%2u:%2u:%2u%1s", &HH, &MM, &SS, dummy) == 3) { + setdate = true; + } else { + ctx.pushStatus(Sqlstate::_22008, Error::Gen, "invalid timestamp format '%s'", dataPtr); + return; + } + if (setdate) { + time_t clock = time(0); + struct tm* t = localtime(&clock); + cc = (1900 + t->tm_year) / 100; + yy = (1900 + t->tm_year) % 100; + mm = 1 + t->tm_mon; + dd = t->tm_mday; + } + value.cc(cc); + value.yy(yy); + value.mm(mm); + value.dd(dd); + value.HH(HH); + value.MM(MM); + value.SS(SS); + value.ff(ff); + // XXX write date routines later + if (! value.valid()) { + ctx.pushStatus(Sqlstate::_22008, Error::Gen, "invalid timestamp values '%s'", dataPtr); + return; + } + sqlDatetime(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Timestamp) { + SQL_TIMESTAMP_STRUCT* dataPtr = static_cast(extField.m_dataPtr); + // XXX assume same datatype + value.cc(dataPtr->year / 100); + value.yy(dataPtr->year / 100); + value.mm(dataPtr->month); + value.dd(dataPtr->day); + value.HH(dataPtr->hour); + value.MM(dataPtr->minute); + value.SS(dataPtr->second); + value.ff(dataPtr->fraction); + if (! value.valid()) { + ctx.pushStatus(Sqlstate::_22008, Error::Gen, "invalid timestamp struct"); + return; + } + sqlDatetime(value); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + } + ctx_assert(false); // SqlType::Null not applicable +} + +// copy to external + +static bool +copyout_char_char(Ctx& ctx, const char* value, unsigned n, char* ptr, unsigned len, SQLINTEGER* ind, int* off) +{ + unsigned n2 = n; + if (off != 0 && *off >= 0) { + ctx_assert((unsigned)*off <= n2); + value += *off; + n2 -= *off; + if (len < n2 + 1) { + ctx.pushStatus(Sqlstate::_01004, Error::Gen, "more data at offset %d, current fetch %u, available %u", *off, len, n2); + n2 = len - 1; + } + } else { + if (len < n + 1) { // room for null byte + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "char value '%.*s' overflow (%u < %u)", (int)n, value, (unsigned)len, (unsigned)(len + 1)); + return false; + } + } + memcpy(ptr, value, n2); + ptr[n2] = 0; + if (off != 0 && *off >= 0) { + if (ind != 0) + *ind = n - *off; + *off += n2; + } else { + if (ind != 0) + *ind = n; + } + return true; +} + +static bool +copyout_binary_binary(Ctx& ctx, const char* value, unsigned n, char* ptr, unsigned len, SQLINTEGER* ind, int* off) +{ + unsigned n2 = n; + if (off != 0 && *off >= 0) { + ctx_assert((unsigned)*off <= n2); + value += *off; + n2 -= *off; + if (len < n2 + 1) { + ctx.pushStatus(Sqlstate::_01004, Error::Gen, "more data at offset %d, current fetch %u, available %u", *off, len, n2); + n2 = len - 1; + } + } else { + if (len < n) { // no room for null byte + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "binary value '%.*s' overflow (%u < %u)", (int)n, value, (unsigned)len, (unsigned)n); + return false; + } + } + memcpy(ptr, value, n2); + ptr[n2] = 0; + if (off != 0 && *off >= 0) { + if (ind != 0) + *ind = n - *off; + *off += n2; + } else { + if (ind != 0) + *ind = n; + } + return true; +} + +static bool +copyout_char_signed(Ctx& ctx, const char* value, unsigned n, long* ptr) +{ + while (n > 0 && value[0] == 0x20) { + value++; + n--; + } + char buf[200]; + if (n >= 200) + n = 200 - 1; + memcpy(buf, value, n); + buf[n] = 0; + errno = 0; + char* endptr = 0; + long x = strtol(buf, &endptr, 10); + if (endptr == 0 || *endptr != 0) { + errno = 0; + endptr = 0; + double y = strtod(buf, &endptr); + if (endptr == 0 || *endptr != 0) { + ctx.pushStatus(Sqlstate::_22005, Error::Gen, "value %s not numeric", buf); + return false; + } else if (errno != 0) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf); + return false; + } + // XXX should handle 123.000 + ctx.pushStatus(Sqlstate::_01004, Error::Gen, "value %s truncated", buf); + x = static_cast(y); + } else if (errno != 0) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf); + return false; + } + *ptr = x; + return true; +} + +static bool +copyout_char_bigsigned(Ctx& ctx, const char* value, unsigned n, SQLBIGINT* ptr) +{ + while (n > 0 && value[0] == 0x20) { + value++; + n--; + } + char buf[200]; + if (n >= 200) + n = 200 - 1; + memcpy(buf, value, n); + buf[n] = 0; + errno = 0; + char* endptr = 0; + SQLBIGINT x = strtoll(buf, &endptr, 10); + if (endptr == 0 || *endptr != 0) { + errno = 0; + endptr = 0; + double y = strtod(buf, &endptr); + if (endptr == 0 || *endptr != 0) { + ctx.pushStatus(Sqlstate::_22005, Error::Gen, "value %s not numeric", buf); + return false; + } else if (errno != 0) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf); + return false; + } + // XXX should handle 123.000 + ctx.pushStatus(Sqlstate::_01004, Error::Gen, "value %s truncated", buf); + x = static_cast(y); + } else if (errno != 0) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf); + return false; + } + *ptr = x; + return true; +} + +static bool +copyout_char_unsigned(Ctx& ctx, const char* value, unsigned n, unsigned long* ptr) +{ + while (n > 0 && value[0] == 0x20) { + value++; + n--; + } + char buf[200]; + if (n >= 200) + n = 200 - 1; + memcpy(buf, value, n); + buf[n] = 0; + errno = 0; + char* endptr = 0; + unsigned long x = strtoul(buf, &endptr, 10); + if (endptr == 0 || *endptr != 0) { + errno = 0; + endptr = 0; + double y = strtod(buf, &endptr); + if (endptr == 0 || *endptr != 0) { + ctx.pushStatus(Sqlstate::_22005, Error::Gen, "value %s not numeric", buf); + return false; + } else if (errno != 0) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf); + return false; + } + // XXX should handle 123.000 + ctx.pushStatus(Sqlstate::_01004, Error::Gen, "value %s truncated", buf); + x = static_cast(y); + } else if (errno != 0) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf); + return false; + } + *ptr = x; + return true; +} + +static bool +copyout_char_bigunsigned(Ctx& ctx, const char* value, unsigned n, SQLUBIGINT* ptr) +{ + while (n > 0 && value[0] == 0x20) { + value++; + n--; + } + char buf[200]; + if (n >= 200) + n = 200 - 1; + memcpy(buf, value, n); + buf[n] = 0; + errno = 0; + char* endptr = 0; + SQLUBIGINT x = strtoull(buf, &endptr, 10); + if (endptr == 0 || *endptr != 0) { + errno = 0; + endptr = 0; + double y = strtod(buf, &endptr); + if (endptr == 0 || *endptr != 0) { + ctx.pushStatus(Sqlstate::_22005, Error::Gen, "value %s not numeric", buf); + return false; + } else if (errno != 0) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf); + return false; + } + // XXX should handle 123.000 + ctx.pushStatus(Sqlstate::_01004, Error::Gen, "value %s truncated", buf); + x = static_cast(y); + } else if (errno != 0) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf); + return false; + } + *ptr = x; + return true; +} + +static bool +copyout_char_double(Ctx& ctx, const char* value, unsigned n, double* ptr) +{ + while (n > 0 && value[0] == 0x20) { + value++; + n--; + } + char buf[200]; + if (n >= 200) + n = 200 - 1; + memcpy(buf, value, n); + buf[n] = 0; + errno = 0; + char* endptr = 0; + double x = strtod(value, &endptr); + if (endptr == 0 || *endptr != 0) { + ctx.pushStatus(Sqlstate::_22005, Error::Gen, "value %s not numeric", value); + return false; + } else if (errno != 0) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", value); + return false; + } + *ptr = x; + return true; +} + +static bool +copyout_signed_char(Ctx& ctx, Int64 value, char* ptr, int len, SQLINTEGER* ind) +{ + char buf[100]; + sprintf(buf, FMT_I64, value); + unsigned n = strlen(buf); + if (len <= 0) { + ctx.pushStatus(Sqlstate::_HY090, Error::Gen, "invalid output buffer length %d", len); + return false; + } + if ((unsigned)len < n + 1) { // room for null byte + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf); + return false; + } + strcpy(ptr, buf); + if (ind != 0) + *ind = n; + return true; +} + +static bool +copyout_unsigned_char(Ctx& ctx, Uint64 uvalue, char* ptr, int len, SQLINTEGER* ind) +{ + char buf[100]; + sprintf(buf, FMT_U64, uvalue); + unsigned n = strlen(buf); + if (len <= 0) { + ctx.pushStatus(Sqlstate::_HY090, Error::Gen, "invalid output buffer length %d", len); + return false; + } + if ((unsigned)len < n + 1) { // room for null byte + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf); + return false; + } + strcpy(ptr, buf); + if (ind != 0) + *ind = n; + return true; +} + +static bool +copyout_double_char(Ctx& ctx, double value, unsigned prec, char* ptr, int len, SQLINTEGER* ind) +{ + char buf[100]; + sprintf(buf, "%.*f", (int)prec, value); + char* p = buf + strlen(buf); + while (p > buf + prec) + *--p = 0; + while (p > buf && *(p - 1) == '0') + *--p = 0; + if (p > buf && *(p - 1) == '.') { + *p++ = '0'; + *p = 0; + } + unsigned n = strlen(buf); + if (len <= 0) { + ctx.pushStatus(Sqlstate::_HY090, Error::Gen, "invalid output buffer length %d", len); + return false; + } + if ((unsigned)len < n + 1) { // room for null byte + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf); + return false; + } + strcpy(ptr, buf); + if (ind != 0) + *ind = n; + return true; +} + +void +SqlField::copyout(Ctx& ctx, ExtField& extField) const +{ + if (extField.extSpec().extType().type() == ExtType::Unbound) { + return; // output buffer may be unbound + } + if (sqlSpec().store() == SqlSpec::Reference) { + ctx_assert(u_data.m_sqlField != 0); + u_data.m_sqlField->copyout(ctx, extField); + return; + } + SQLINTEGER* indPtr = extField.m_indPtr; + if (u_null.m_nullFlag) { + if (extField.m_pos > 0) { // second time from SQLGetData + ctx.setCode(SQL_NO_DATA); + return; + } + if (indPtr == 0) { + ctx.pushStatus(Sqlstate::_22002, Error::Gen, "indicator variable required"); + return; + } + *indPtr = SQL_NULL_DATA; + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + const SqlType& sqlType = sqlSpec().sqlType(); + const ExtType& extType = extField.extSpec().extType(); + if (sqlType.type() == SqlType::Char || sqlType.type() == SqlType::Varchar) { + unsigned n = 0; + const char* value = 0; + if (sqlType.type() == SqlType::Char) { + n = sqlType.length(); + value = reinterpret_cast(sqlChar()); + } else { + value = reinterpret_cast(sqlVarchar(&n)); + } + if (extType.type() == ExtType::Char) { + char* dataPtr = static_cast(extField.m_dataPtr); + if (extField.m_dataLen <= 0) { + ctx.pushStatus(Sqlstate::_HY090, Error::Gen, "invalid output buffer length %d", (int)extField.m_dataLen); + return; + } + int* off = 0; + if (extField.m_pos >= 0) { + off = &extField.m_pos; + if ((unsigned)*off >= n) { + ctx.setCode(SQL_NO_DATA); + return; + } + } + if (! copyout_char_char(ctx, value, n, dataPtr, extField.m_dataLen, indPtr, off)) + return; + return; + } + if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) { + if (extField.m_pos > 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + short* dataPtr = static_cast(extField.m_dataPtr); + long x; + if (! copyout_char_signed(ctx, value, n, &x)) + return; + if (x < SHRT_MIN || x > SHRT_MAX) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", value); + return; + } + *dataPtr = static_cast(x); + if (indPtr != 0) + *indPtr = sizeof(short); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ushort) { + if (extField.m_pos > 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + unsigned short* dataPtr = static_cast(extField.m_dataPtr); + unsigned long x; + if (! copyout_char_unsigned(ctx, value, n, &x)) + return; + if (x > USHRT_MAX) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", value); + return; + } + *dataPtr = static_cast(x); + if (indPtr != 0) + *indPtr = sizeof(unsigned short); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) { + if (extField.m_pos > 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + long* dataPtr = static_cast(extField.m_dataPtr); + if (! copyout_char_signed(ctx, value, n, dataPtr)) + return; + if (indPtr != 0) + *indPtr = sizeof(long); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ulong) { + if (extField.m_pos > 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + unsigned long* dataPtr = static_cast(extField.m_dataPtr); + if (! copyout_char_unsigned(ctx, value, n, dataPtr)) + return; + if (indPtr != 0) + *indPtr = sizeof(unsigned long); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Sbigint) { + if (extField.m_pos > 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + SQLBIGINT* dataPtr = static_cast(extField.m_dataPtr); + if (! copyout_char_bigsigned(ctx, value, n, dataPtr)) + return; + if (indPtr != 0) + *indPtr = sizeof(SQLBIGINT); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ubigint) { + if (extField.m_pos > 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + SQLUBIGINT* dataPtr = static_cast(extField.m_dataPtr); + if (! copyout_char_bigunsigned(ctx, value, n, dataPtr)) + return; + if (indPtr != 0) + *indPtr = sizeof(SQLUBIGINT); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Float) { + if (extField.m_pos > 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + float* dataPtr = static_cast(extField.m_dataPtr); + double x; + if (! copyout_char_double(ctx, value, n, &x)) + return; + if (fabs(x) < FLT_MIN || fabs(x) > FLT_MAX) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", value); + return; + } + *dataPtr = static_cast(x); + if (indPtr != 0) + *indPtr = sizeof(float); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Double) { + if (extField.m_pos > 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + double* dataPtr = static_cast(extField.m_dataPtr); + double x; + if (! copyout_char_double(ctx, value, n, &x)) + return; + *dataPtr = static_cast(x); + if (indPtr != 0) + *indPtr = sizeof(double); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + } + if (sqlType.type() == SqlType::Binary || sqlType.type() == SqlType::Varbinary) { + unsigned n = 0; + const char* value = 0; + if (sqlType.type() == SqlType::Binary) { + n = sqlType.length(); + value = reinterpret_cast(sqlBinary()); + } else { + value = reinterpret_cast(sqlVarbinary(&n)); + } + if (extType.type() == ExtType::Binary) { + char* dataPtr = static_cast(extField.m_dataPtr); + if (extField.m_dataLen <= 0) { + ctx.pushStatus(Sqlstate::_HY090, Error::Gen, "invalid output buffer length %d", (int)extField.m_dataLen); + return; + } + int* off = 0; + if (extField.m_pos >= 0) { + off = &extField.m_pos; + if ((unsigned)*off >= n) { + ctx.setCode(SQL_NO_DATA); + return; + } + } + if (! copyout_binary_binary(ctx, value, n, dataPtr, extField.m_dataLen, indPtr, off)) + return; + return; + } + } + if (sqlType.type() == SqlType::Smallint) { + if (extField.m_pos > 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + const SqlSmallint value = sqlSmallint(); + const SqlUsmallint uvalue = value; + if (extType.type() == ExtType::Char) { + char* dataPtr = static_cast(extField.m_dataPtr); + if (! sqlType.unSigned()) { + if (! copyout_signed_char(ctx, value, dataPtr, extField.m_dataLen, indPtr)) + return; + } else { + if (! copyout_unsigned_char(ctx, uvalue, dataPtr, extField.m_dataLen, indPtr)) + return; + } + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) { + short* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(short); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ushort) { + unsigned short* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(uvalue); + if (indPtr != 0) + *indPtr = sizeof(unsigned short); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) { + long* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(long); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ulong) { + unsigned long* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(uvalue); + if (indPtr != 0) + *indPtr = sizeof(unsigned long); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Sbigint) { + SQLBIGINT* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(SQLBIGINT); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ubigint) { + SQLUBIGINT* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(uvalue); + if (indPtr != 0) + *indPtr = sizeof(SQLUBIGINT); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Float) { + float* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(float); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Double) { + double* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(double); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + } + if (sqlType.type() == SqlType::Integer) { + if (extField.m_pos > 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + const SqlInteger value = sqlInteger(); + const SqlUinteger uvalue = value; + if (extType.type() == ExtType::Char) { + char* dataPtr = static_cast(extField.m_dataPtr); + if (! sqlType.unSigned()) { + if (! copyout_signed_char(ctx, value, dataPtr, extField.m_dataLen, indPtr)) + return; + } else { + if (! copyout_unsigned_char(ctx, uvalue, dataPtr, extField.m_dataLen, indPtr)) + return; + } + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) { + short* dataPtr = static_cast(extField.m_dataPtr); + if (value < SHRT_MIN || value > SHRT_MAX) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %d overflow", (int)value); + return; + } + *dataPtr = static_cast(value); + if (indPtr != 0) + *indPtr = sizeof(short); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ushort) { + unsigned short* dataPtr = static_cast(extField.m_dataPtr); + if (uvalue > USHRT_MAX) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %u overflow", uvalue); + return; + } + *dataPtr = static_cast(value); + if (indPtr != 0) + *indPtr = sizeof(unsigned short); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) { + long* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(long); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ulong) { + unsigned long* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(uvalue); + if (indPtr != 0) + *indPtr = sizeof(unsigned long); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Sbigint) { + SQLBIGINT* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(SQLBIGINT); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ubigint) { + SQLUBIGINT* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(uvalue); + if (indPtr != 0) + *indPtr = sizeof(SQLUBIGINT); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Float) { + float* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(float); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Double) { + double* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(double); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + } + if (sqlType.type() == SqlType::Bigint) { + if (extField.m_pos > 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + const SqlBigint value = sqlBigint(); + const SqlUbigint uvalue = value; + if (extType.type() == ExtType::Char) { + char* dataPtr = static_cast(extField.m_dataPtr); + if (! sqlType.unSigned()) { + if (! copyout_signed_char(ctx, value, dataPtr, extField.m_dataLen, indPtr)) + return; + } else { + if (! copyout_unsigned_char(ctx, uvalue, dataPtr, extField.m_dataLen, indPtr)) + return; + } + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) { + short* dataPtr = static_cast(extField.m_dataPtr); + if (value < SHRT_MIN || value > SHRT_MAX) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value " FMT_I64 " overflow", (Int64)value); + return; + } + *dataPtr = static_cast(value); + if (indPtr != 0) + *indPtr = sizeof(short); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ushort) { + unsigned short* dataPtr = static_cast(extField.m_dataPtr); + if (uvalue > USHRT_MAX) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value " FMT_U64 " overflow", (Uint64)uvalue); + return; + } + *dataPtr = static_cast(value); + if (indPtr != 0) + *indPtr = sizeof(unsigned short); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) { + long* dataPtr = static_cast(extField.m_dataPtr); + if (value < INT_MIN || value > INT_MAX) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value " FMT_I64 " overflow", (Int64)value); + return; + } + *dataPtr = static_cast(value); + if (indPtr != 0) + *indPtr = sizeof(long); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ulong) { + unsigned long* dataPtr = static_cast(extField.m_dataPtr); + if (uvalue > UINT_MAX) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value " FMT_U64 " overflow", (Uint64)uvalue); + return; + } + *dataPtr = static_cast(uvalue); + if (indPtr != 0) + *indPtr = sizeof(unsigned long); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Sbigint) { + SQLBIGINT* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(SQLBIGINT); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ubigint) { + SQLUBIGINT* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(uvalue); + if (indPtr != 0) + *indPtr = sizeof(SQLUBIGINT); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Float) { + float* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(float); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Double) { + double* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(double); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + } + if (sqlType.type() == SqlType::Real) { + if (extField.m_pos > 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + const SqlReal value = sqlReal(); + if (extType.type() == ExtType::Char) { + char* dataPtr = static_cast(extField.m_dataPtr); + if (! copyout_double_char(ctx, value, 7, dataPtr, extField.m_dataLen, indPtr)) + return; + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) { + short* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // XXX todo + if (indPtr != 0) + *indPtr = sizeof(short); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ushort) { + unsigned short* dataPtr = static_cast(extField.m_dataPtr); + if (value < 0 || value > USHRT_MAX) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %g overflow", (double)value); + return; + } + *dataPtr = static_cast(value); + if (indPtr != 0) + *indPtr = sizeof(unsigned short); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) { + long* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(long); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ulong) { + unsigned long* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // XXX todo + if (indPtr != 0) + *indPtr = sizeof(unsigned long); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Sbigint) { + SQLBIGINT* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(SQLBIGINT); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ubigint) { + SQLUBIGINT* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); + if (indPtr != 0) + *indPtr = sizeof(SQLUBIGINT); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Float) { + float* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(float); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Double) { + double* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(double); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + } + if (sqlType.type() == SqlType::Double) { + if (extField.m_pos > 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + SqlDouble value = sqlDouble(); + if (extType.type() == ExtType::Char) { + char* dataPtr = static_cast(extField.m_dataPtr); + if (! copyout_double_char(ctx, value, 14, dataPtr, extField.m_dataLen, indPtr)) + return; + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) { + short* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // XXX todo + if (indPtr != 0) + *indPtr = sizeof(short); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ushort) { + unsigned short* dataPtr = static_cast(extField.m_dataPtr); + if (value < 0 || value > USHRT_MAX) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %g overflow", (double)value); + return; + } + *dataPtr = static_cast(value); + if (indPtr != 0) + *indPtr = sizeof(unsigned short); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) { + long* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(long); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ulong) { + unsigned long* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // XXX todo + if (indPtr != 0) + *indPtr = sizeof(unsigned long); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Sbigint) { + SQLBIGINT* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(SQLBIGINT); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Ubigint) { + SQLUBIGINT* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); + if (indPtr != 0) + *indPtr = sizeof(SQLUBIGINT); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Float) { + float* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); // big enough + if (indPtr != 0) + *indPtr = sizeof(float); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Double) { + double* dataPtr = static_cast(extField.m_dataPtr); + *dataPtr = static_cast(value); + if (indPtr != 0) + *indPtr = sizeof(double); + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + } + if (sqlType.type() == SqlType::Datetime) { + if (extField.m_pos > 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + SqlDatetime value = sqlDatetime(); + if (extType.type() == ExtType::Char) { + char* dataPtr = static_cast(extField.m_dataPtr); + char buf[100]; + sprintf(buf, "%02d%02u-%02u-%02u\040%02u:%02u:%02u.%09u", value.cc(), value.yy(), value.mm(), value.dd(), value.HH(), value.MM(), value.SS(), value.ff()); + int n = strlen(buf); + if (extField.m_dataLen < 20) { + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "buffer too small for timestamp %s", buf); + return; + } + if (extField.m_dataLen < n) { + ctx.pushStatus(Sqlstate::_01004, Error::Gen, "truncating fractional part of timestamp %s", buf); + n = extField.m_dataLen; + } + if (! copyout_char_char(ctx, buf, n, dataPtr, extField.m_dataLen, indPtr, 0)) + return; + if (extField.m_pos >= 0) + extField.m_pos = 1; + return; + } + if (extType.type() == ExtType::Timestamp) { + SQL_TIMESTAMP_STRUCT* dataPtr = static_cast(extField.m_dataPtr); + // XXX assume same datatype + dataPtr->year = value.cc() * 100 + value.yy(); + dataPtr->month = value.mm(); + dataPtr->day = value.dd(); + dataPtr->hour = value.HH(); + dataPtr->minute = value.MM(); + dataPtr->second = value.SS(); + dataPtr->fraction = value.ff(); + return; + } + } + ctx_assert(false); // SqlType::Null not applicable +} + +void +SqlField::print(char* buf, unsigned size) const +{ + Ctx ctx; + unsigned n = sqlSpec().sqlType().displaySize(); + SQLINTEGER ind = 0; + ExtType extType(ExtType::Char); + ExtSpec extSpec(extType); + ExtField extField(extSpec, (SQLPOINTER)buf, size, &ind); + buf[0] = 0; + copyout(ctx, extField); + if (ind == SQL_NULL_DATA) + snprintf(buf, size, "NULL"); +} diff --git a/ndb/src/client/odbc/common/DataField.hpp b/ndb/src/client/odbc/common/DataField.hpp new file mode 100644 index 00000000000..65138df25f1 --- /dev/null +++ b/ndb/src/client/odbc/common/DataField.hpp @@ -0,0 +1,446 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_COMMON_DataField_hpp +#define ODBC_COMMON_DataField_hpp + +#include +#include +#include "DataType.hpp" + +/** + * @class SqlSpec + * @brief Specification of data in SQL format + */ +class SqlSpec { +public: + enum Store { + Undef = 0, + Reference = 1, // reference to read-only SqlField of same type + Physical = 2 // stored within or in allocated storage + }; + SqlSpec(); + SqlSpec(const SqlType& sqlType, Store store); + SqlSpec(const SqlSpec& sqlSpec); + SqlSpec(const SqlSpec& sqlSpec, Store store); + const SqlType& sqlType() const; + const Store store() const; + unsigned size() const; +private: + //SqlSpec& operator=(const SqlSpec& sqlSpec); // disallowed + SqlType m_sqlType; + Store m_store; +}; + +/** + * @class ExtSpec + * @brief Specification of data in external format + */ +class ExtSpec { +public: + ExtSpec(); + ExtSpec(const ExtType& extType); + ExtSpec(const ExtSpec& extSpec); + const ExtType& extType() const; + unsigned size() const; + void setValue(const ExtType& extType); +private: + ExtType m_extType; +}; + +/** + * @class LexSpec + * @brief Specification of lexical data + * + * Used only for converting lexical data to SQL data. + */ +class LexSpec { +public: + LexSpec(); + LexSpec(const LexType& lexType); + /** + * Lexical data is represented as string. Following + * converts it to SQL data. + */ + void convert(Ctx& ctx, const BaseString& value, class SqlField& out); +private: + LexType m_lexType; +}; + +// SqlSpec + +inline +SqlSpec::SqlSpec() : + m_store(Undef) +{ +} + +inline +SqlSpec::SqlSpec(const SqlType& sqlType, Store store) : + m_sqlType(sqlType), + m_store(store) +{ +} + +inline +SqlSpec::SqlSpec(const SqlSpec& sqlSpec) : + m_sqlType(sqlSpec.m_sqlType), + m_store(sqlSpec.m_store) +{ +} + +inline +SqlSpec::SqlSpec(const SqlSpec& sqlSpec, Store store) : + m_sqlType(sqlSpec.m_sqlType), + m_store(store) +{ +} + +inline const SqlType& +SqlSpec::sqlType() const +{ + return m_sqlType; +} + +inline const SqlSpec::Store +SqlSpec::store() const +{ + return m_store; +} + +inline unsigned +SqlSpec::size() const +{ + return sqlType().size(); +} + +// ExtSpec + +inline +ExtSpec::ExtSpec() +{ +} + +inline +ExtSpec::ExtSpec(const ExtType& extType) : + m_extType(extType) +{ +} + +inline +ExtSpec::ExtSpec(const ExtSpec& extSpec) : + m_extType(extSpec.m_extType) +{ +} + +inline const ExtType& +ExtSpec::extType() const +{ + return m_extType; +} + +inline unsigned +ExtSpec::size() const +{ + return m_extType.size(); +} + +inline void +ExtSpec::setValue(const ExtType& extType) +{ + m_extType = extType; +} + +// LexSpec + +inline +LexSpec::LexSpec(const LexType& lexType) : + m_lexType(lexType) +{ +} + +/** + * @class SqlField + * @brief Sql data field accessor + */ +class SqlField { +public: + SqlField(); + SqlField(const SqlSpec& sqlSpec); + SqlField(const SqlSpec& sqlSpec, const SqlField* sqlField); + SqlField(const SqlField& sqlField); + ~SqlField(); + const SqlSpec& sqlSpec() const; + const void* addr() const; // address of data + void* addr(); + unsigned allocSize() const; + const SqlChar* sqlChar() const; // get + const SqlChar* sqlVarchar(unsigned* length) const; + const SqlChar* sqlBinary() const; + const SqlChar* sqlVarbinary(unsigned* length) const; + SqlSmallint sqlSmallint() const; + SqlInteger sqlInteger() const; + SqlBigint sqlBigint() const; + SqlReal sqlReal() const; + SqlDouble sqlDouble() const; + SqlDatetime sqlDatetime() const; + void sqlChar(const char* value, int length); // set + void sqlChar(const SqlChar* value, int length); + void sqlVarchar(const char* value, int length); + void sqlVarchar(const SqlChar* value, int length); + void sqlBinary(const char* value, int length); + void sqlBinary(const SqlChar* value, int length); + void sqlVarbinary(const char* value, int length); + void sqlVarbinary(const SqlChar* value, int length); + void sqlSmallint(SqlSmallint value); + void sqlInteger(SqlInteger value); + void sqlBigint(SqlBigint value); + void sqlReal(SqlReal value); + void sqlDouble(SqlDouble value); + void sqlDatetime(SqlDatetime value); + bool sqlNull() const; // get and set null + void sqlNull(bool value); + unsigned trim() const; // right trimmed length + void copy(Ctx& ctx, SqlField& out) const; + bool cast(Ctx& ctx, SqlField& out) const; + bool less(const SqlField& sqlField) const; + // application input and output + void copyin(Ctx& ctx, class ExtField& extField); + void copyout(Ctx& ctx, class ExtField& extField) const; + // print for debugging + void print(char* buf, unsigned size) const; + // public for forte6 + //enum { CharSmall = 20 }; +#define SqlField_CharSmall 20 // redhat-6.2 (egcs-2.91.66) +private: + friend class LexSpec; + friend class SqlRow; + void alloc(); // allocate Physical + void alloc(const SqlField& sqlField); + void free(); // free Physical + SqlSpec m_sqlSpec; + union Data { + Data(); + Data(const SqlField* sqlField); + const SqlField* m_sqlField; + // Physical + SqlChar* m_sqlChar; // all char types + SqlChar m_sqlCharSmall[SqlField_CharSmall]; + SqlSmallint m_sqlSmallint; + SqlInteger m_sqlInteger; + SqlBigint m_sqlBigint; + SqlReal m_sqlReal; + SqlDouble m_sqlDouble; + SqlDatetime m_sqlDatetime; + } u_data; + union Null { + Null(); + bool m_nullFlag; + } u_null; +}; + +/** + * @class ExtField + * @brief External data field accessor + */ +class ExtField { +public: + ExtField(); + ExtField(const ExtSpec& extSpec, int fieldId = 0); + ExtField(const ExtSpec& extSpec, SQLPOINTER dataPtr, SQLINTEGER dataLen, SQLINTEGER* indPtr, int fieldId = 0); + ~ExtField(); + const ExtSpec& extSpec() const; + void setValue(SQLPOINTER dataPtr, SQLINTEGER dataLen); + void setValue(const ExtSpec& extSpec, SQLPOINTER dataPtr, SQLINTEGER dataLen, SQLINTEGER* indPtr); + int fieldId() const; + void setPos(int pos); + int getPos() const; +private: + friend class SqlField; + friend class Exec_root; + ExtSpec m_extSpec; + SQLPOINTER m_dataPtr; // data buffer + SQLINTEGER m_dataLen; // data buffer length + SQLINTEGER* m_indPtr; // null indicator or length + int m_fieldId; // field id > 0 for error messages + int m_pos; // output position for SQLGetData (if != -1) +}; + +inline int +ExtField::fieldId() const +{ + return m_fieldId; +} + +inline void +ExtField::setPos(int pos) +{ + m_pos = pos; +} + +inline int +ExtField::getPos() const +{ + return m_pos; +} + +// SqlField + +inline +SqlField::SqlField() +{ +} + +inline +SqlField::SqlField(const SqlSpec& sqlSpec) : + m_sqlSpec(sqlSpec) +{ + if (m_sqlSpec.store() == SqlSpec::Physical) + alloc(); +} + +inline +SqlField::SqlField(const SqlSpec& sqlSpec, const SqlField* sqlField) : + m_sqlSpec(sqlSpec), + u_data(sqlField) +{ + ctx_assert(m_sqlSpec.store() == SqlSpec::Reference); +} + +inline +SqlField::SqlField(const SqlField& sqlField) : + m_sqlSpec(sqlField.m_sqlSpec), + u_data(sqlField.u_data), + u_null(sqlField.u_null) +{ + if (m_sqlSpec.store() == SqlSpec::Physical) + alloc(sqlField); +} + +inline +SqlField::Data::Data() +{ +} + +inline +SqlField::Data::Data(const SqlField* sqlField) +{ + m_sqlField = sqlField; +} + +inline +SqlField::Null::Null() +{ +} + +inline +SqlField::~SqlField() +{ + if (m_sqlSpec.store() == SqlSpec::Physical) + free(); +} + +inline const SqlSpec& +SqlField::sqlSpec() const +{ + return m_sqlSpec; +} + +inline void +SqlField::sqlChar(const char* value, int length) +{ + sqlChar(reinterpret_cast(value), length); +} + +inline void +SqlField::sqlVarchar(const char* value, int length) +{ + sqlVarchar(reinterpret_cast(value), length); +} + +inline void +SqlField::sqlBinary(const char* value, int length) +{ + sqlBinary(reinterpret_cast(value), length); +} + +inline void +SqlField::sqlVarbinary(const char* value, int length) +{ + sqlVarbinary(reinterpret_cast(value), length); +} + +// ExtField + +inline +ExtField::ExtField() : + m_dataPtr(0), + m_dataLen(0), + m_indPtr(0), + m_pos(-1) +{ +} + +inline +ExtField::ExtField(const ExtSpec& extSpec, int fieldId) : + m_extSpec(extSpec), + m_dataPtr(0), + m_dataLen(0), + m_indPtr(0), + m_fieldId(fieldId), + m_pos(-1) +{ +} + +inline +ExtField::ExtField(const ExtSpec& extSpec, SQLPOINTER dataPtr, SQLINTEGER dataLen, SQLINTEGER* indPtr, int fieldId) : + m_extSpec(extSpec), + m_dataPtr(dataPtr), + m_dataLen(dataLen), + m_indPtr(indPtr), + m_fieldId(fieldId), + m_pos(-1) +{ +} + +inline +ExtField::~ExtField() +{ +} + +inline const ExtSpec& +ExtField::extSpec() const +{ + return m_extSpec; +} + +inline void +ExtField::setValue(SQLPOINTER dataPtr, SQLINTEGER dataLen) +{ + m_dataPtr = dataPtr; + m_dataLen = dataLen; +} + +inline void +ExtField::setValue(const ExtSpec& extSpec, SQLPOINTER dataPtr, SQLINTEGER dataLen, SQLINTEGER* indPtr) +{ + m_extSpec.setValue(extSpec.extType()); + m_dataPtr = dataPtr; + m_dataLen = dataLen; + m_indPtr = indPtr; +} + +#endif diff --git a/ndb/src/client/odbc/common/DataRow.cpp b/ndb/src/client/odbc/common/DataRow.cpp new file mode 100644 index 00000000000..509f2673e0d --- /dev/null +++ b/ndb/src/client/odbc/common/DataRow.cpp @@ -0,0 +1,140 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "DataRow.hpp" + +// SqlSpecs + +SqlSpecs::SqlSpecs(unsigned count) : + m_count(count) +{ + m_sqlSpec = new SqlSpec[1 + count]; +} + +SqlSpecs::SqlSpecs(const SqlSpecs& sqlSpecs) : + m_count(sqlSpecs.m_count) +{ + m_sqlSpec = new SqlSpec[1 + m_count]; + for (unsigned i = 1; i <= m_count; i++) { + void* place = static_cast(&m_sqlSpec[i]); + new (place) SqlSpec(sqlSpecs.m_sqlSpec[i]); + } +} + +SqlSpecs::~SqlSpecs() +{ + delete[] m_sqlSpec; +} + +// ExtSpecs + +ExtSpecs::ExtSpecs(unsigned count) : + m_count(count) +{ + m_extSpec = new ExtSpec[1 + count]; +} + +ExtSpecs::ExtSpecs(const ExtSpecs& extSpecs) : + m_count(extSpecs.m_count) +{ + m_extSpec = new ExtSpec[1 + m_count]; + for (unsigned i = 1; i <= m_count; i++) { + void* place = static_cast(&m_extSpec[i]); + new (place) ExtSpec(extSpecs.m_extSpec[i]); + } +} + +ExtSpecs::~ExtSpecs() +{ + delete[] m_extSpec; +} + +// SqlRow + +SqlRow::SqlRow(const SqlSpecs& sqlSpecs) : + m_sqlSpecs(sqlSpecs) +{ + m_sqlField = new SqlField[1 + count()]; + for (unsigned i = 1; i <= count(); i++) { + SqlField sqlField(m_sqlSpecs.getEntry(i)); + setEntry(i, sqlField); + } +} + +SqlRow::SqlRow(const SqlRow& sqlRow) : + m_sqlSpecs(sqlRow.m_sqlSpecs) +{ + m_sqlField = new SqlField[1 + count()]; + for (unsigned i = 1; i <= count(); i++) { + void* place = static_cast(&m_sqlField[i]); + new (place) SqlField(sqlRow.getEntry(i)); + } +} + +SqlRow::~SqlRow() +{ + for (unsigned i = 1; i <= count(); i++) { + m_sqlField[i].~SqlField(); + } + delete[] m_sqlField; +} + +SqlRow* +SqlRow::copy() const +{ + SqlRow* copyRow = new SqlRow(m_sqlSpecs); + for (unsigned i = 1; i <= count(); i++) { + const SqlField* sqlField = &m_sqlField[i]; + while (sqlField->sqlSpec().store() == SqlSpec::Reference) { + sqlField = sqlField->u_data.m_sqlField; + } + copyRow->setEntry(i, *sqlField); + } + return copyRow; +} + +void +SqlRow::copyout(Ctx& ctx, class ExtRow& extRow) const +{ + for (unsigned i = 1; i <= count(); i++) { + const SqlField& sqlField = getEntry(i); + ExtField& extField = extRow.getEntry(i); + sqlField.copyout(ctx, extField); + } +} + +// ExtRow + +ExtRow::ExtRow(const ExtSpecs& extSpecs) : + m_extSpecs(extSpecs) +{ + m_extField = new ExtField[1 + count()]; +} + +ExtRow::ExtRow(const ExtRow& extRow) : + m_extSpecs(extRow.m_extSpecs) +{ + m_extField = new ExtField[1 + count()]; + for (unsigned i = 1; i <= count(); i++) { + void* place = static_cast(&m_extField[i]); + new (place) ExtField(extRow.getEntry(i)); + } +} + +ExtRow::~ExtRow() +{ + delete[] m_extField; +} diff --git a/ndb/src/client/odbc/common/DataRow.hpp b/ndb/src/client/odbc/common/DataRow.hpp new file mode 100644 index 00000000000..4a5a1e905b9 --- /dev/null +++ b/ndb/src/client/odbc/common/DataRow.hpp @@ -0,0 +1,185 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_COMMON_DataRow_hpp +#define ODBC_COMMON_DataRow_hpp + +#include +#include +#include "DataField.hpp" + +class Ctx; + +/** + * @class SqlSpecs + * @brief Specification of row of SQL data + */ +class SqlSpecs { +public: + SqlSpecs(unsigned count); + SqlSpecs(const SqlSpecs& sqlSpecs); + ~SqlSpecs(); + unsigned count() const; + void setEntry(unsigned i, const SqlSpec& sqlSpec); + const SqlSpec& getEntry(unsigned i) const; +private: + SqlSpecs& operator=(const SqlSpecs& sqlSpecs); // disallowed + const unsigned m_count; + SqlSpec* m_sqlSpec; +}; + +inline unsigned +SqlSpecs::count() const +{ + return m_count; +} + +inline void +SqlSpecs::setEntry(unsigned i, const SqlSpec& sqlSpec) +{ + ctx_assert(m_sqlSpec != 0 && 1 <= i && i <= m_count); + void* place = static_cast(&m_sqlSpec[i]); + new (place) SqlSpec(sqlSpec); +} + +inline const SqlSpec& +SqlSpecs::getEntry(unsigned i) const +{ + ctx_assert(m_sqlSpec != 0 && 1 <= i && i <= m_count); + return m_sqlSpec[i]; +} + +/** + * @class ExtSpecs + * @brief Specification of row of external data + */ +class ExtSpecs { +public: + ExtSpecs(unsigned count); + ExtSpecs(const ExtSpecs& extSpecs); + ~ExtSpecs(); + unsigned count() const; + void setEntry(unsigned i, const ExtSpec& extSpec); + const ExtSpec& getEntry(unsigned i) const; +private: + ExtSpecs& operator=(const ExtSpecs& extSpecs); // disallowed + const unsigned m_count; + ExtSpec* m_extSpec; +}; + +inline unsigned +ExtSpecs::count() const +{ + return m_count; +} + +inline void +ExtSpecs::setEntry(unsigned i, const ExtSpec& extSpec) +{ + ctx_assert(m_extSpec != 0 && 1 <= i && i <= m_count); + void* place = static_cast(&m_extSpec[i]); + new (place) ExtSpec(extSpec); +} + +inline const ExtSpec& +ExtSpecs::getEntry(unsigned i) const +{ + ctx_assert(m_extSpec != 0 && 1 <= i && i <= m_count); + return m_extSpec[i]; +} + +/** + * @class SqlRow + * @brief Sql data row + */ +class SqlRow { +public: + SqlRow(const SqlSpecs& sqlSpecs); + SqlRow(const SqlRow& sqlRow); + ~SqlRow(); + unsigned count() const; + void setEntry(unsigned i, const SqlField& sqlField); + SqlField& getEntry(unsigned i) const; + SqlRow* copy() const; + void copyout(Ctx& ctx, class ExtRow& extRow) const; +private: + SqlRow& operator=(const SqlRow& sqlRow); // disallowed + SqlSpecs m_sqlSpecs; + SqlField* m_sqlField; +}; + +inline unsigned +SqlRow::count() const +{ + return m_sqlSpecs.count(); +} + +inline void +SqlRow::setEntry(unsigned i, const SqlField& sqlField) +{ + ctx_assert(1 <= i && i <= count() && m_sqlField != 0); + m_sqlField[i].~SqlField(); + void* place = static_cast(&m_sqlField[i]); + new (place) SqlField(sqlField); +} + +inline SqlField& +SqlRow::getEntry(unsigned i) const +{ + ctx_assert(1 <= i && i <= count() && m_sqlField != 0); + return m_sqlField[i]; +} + +/** + * @class ExtRow + * @brief External data row + */ +class ExtRow { +public: + ExtRow(const ExtSpecs& extSpecs); + ExtRow(const ExtRow& extRow); + ~ExtRow(); + unsigned count() const; + void setEntry(unsigned i, const ExtField& extField); + ExtField& getEntry(unsigned i) const; +private: + ExtRow& operator=(const ExtRow& extRow); // disallowed + ExtSpecs m_extSpecs; + ExtField* m_extField; +}; + +inline unsigned +ExtRow::count() const +{ + return m_extSpecs.count(); +} + +inline void +ExtRow::setEntry(unsigned i, const ExtField& extField) +{ + ctx_assert(1 <= i && i <= count() && m_extField != 0); + void* place = static_cast(&m_extField[i]); + new (place) ExtField(extField); +} + +inline ExtField& +ExtRow::getEntry(unsigned i) const +{ + ctx_assert(1 <= i && i <= count() && m_extField != 0); + return m_extField[i]; +} + +#endif diff --git a/ndb/src/client/odbc/common/DataType.cpp b/ndb/src/client/odbc/common/DataType.cpp new file mode 100644 index 00000000000..62bd622b9b5 --- /dev/null +++ b/ndb/src/client/odbc/common/DataType.cpp @@ -0,0 +1,546 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "DataType.hpp" +#include + +// SqlType + +SqlType::SqlType() : + m_type(Undef) +{ +} + +SqlType::SqlType(Type type, bool nullable) +{ + Ctx ctx; + setType(ctx, type, nullable); + ctx_assert(ctx.ok()); +} + +SqlType::SqlType(Type type, unsigned length, bool nullable) +{ + Ctx ctx; + setType(ctx, type, length, nullable); + ctx_assert(ctx.ok()); +} + +SqlType::SqlType(Type type, unsigned precision, unsigned scale, bool nullable) +{ + Ctx ctx; + setType(ctx, type, precision, scale, nullable); + ctx_assert(ctx.ok()); +} + +SqlType::SqlType(Ctx& ctx, Type type, bool nullable) +{ + setType(ctx, type, nullable); +} + +SqlType::SqlType(Ctx& ctx, Type type, unsigned length, bool nullable) +{ + setType(ctx, type, length, nullable); +} + +SqlType::SqlType(Ctx& ctx, Type type, unsigned precision, unsigned scale, bool nullable) +{ + setType(ctx, type, precision, scale, nullable); +} + +SqlType::SqlType(Ctx& ctx, const NdbDictionary::Column* ndbColumn) +{ + setType(ctx, ndbColumn); +} + +void +SqlType::setType(Ctx& ctx, Type type, bool nullable) +{ + switch (type) { + case Smallint: + case Integer: + case Bigint: + case Real: + case Double: + case Datetime: + break; + case Blob: + setType(ctx, Varbinary, FAKE_BLOB_SIZE, nullable); // XXX BLOB hack + return; + case Null: + case Unbound: + break; + default: + ctx_assert(false); + break; + } + m_type = type; + m_precision = 0; + m_scale = 0; + m_length = 0; + m_nullable = nullable; + m_unSigned = false; +} + +void +SqlType::setType(Ctx& ctx, Type type, unsigned length, bool nullable) +{ + switch (type) { + case Char: + case Varchar: + case Binary: + case Varbinary: + break; + default: + ctx_assert(false); + break; + } + m_type = type; + m_precision = 0; + m_scale = 0; + m_length = length; + m_nullable = nullable; + m_unSigned = false; +} + +void +SqlType::setType(Ctx& ctx, Type type, unsigned precision, unsigned scale, bool nullable) +{ + ctx_assert(false); // not yet +} + +void +SqlType::setType(Ctx& ctx, const NdbDictionary::Column* ndbColumn) +{ + NdbDictionary::Column::Type type = ndbColumn->getType(); + unsigned length = ndbColumn->getLength(); + unsigned precision = ndbColumn->getPrecision(); + unsigned scale = ndbColumn->getScale(); + bool nullable = ndbColumn->getNullable(); + switch (type) { + case NdbDictionary::Column::Undefined: + break; + case NdbDictionary::Column::Int: + if (length == 1) + setType(ctx, Integer, nullable); + else + setType(ctx, Binary, length * sizeof(SqlInteger), nullable); + return; + case NdbDictionary::Column::Unsigned: + if (length == 1) { + setType(ctx, Integer, nullable); + unSigned(true); + } else + setType(ctx, Binary, length * sizeof(SqlUinteger), nullable); + return; + case NdbDictionary::Column::Bigint: + if (length == 1) + setType(ctx, Bigint, nullable); + else + setType(ctx, Binary, length * sizeof(SqlBigint), nullable); + return; + case NdbDictionary::Column::Bigunsigned: + if (length == 1) { + setType(ctx, Bigint, nullable); + unSigned(true); + } else + setType(ctx, Binary, length * sizeof(SqlBigint), nullable); + return; + case NdbDictionary::Column::Float: + if (length == 1) + setType(ctx, Real, nullable); + else + setType(ctx, Binary, length * sizeof(SqlReal), nullable); + return; + case NdbDictionary::Column::Double: + if (length == 1) + setType(ctx, Double, nullable); + else + setType(ctx, Binary, length * sizeof(SqlDouble), nullable); + return; + case NdbDictionary::Column::Decimal: + setType(ctx, Decimal, precision, scale, nullable); + return; + case NdbDictionary::Column::Char: + setType(ctx, Char, length, nullable); + return; + case NdbDictionary::Column::Varchar: + setType(ctx, Varchar, length, nullable); + return; + case NdbDictionary::Column::Binary: + setType(ctx, Binary, length, nullable); + return; + case NdbDictionary::Column::Varbinary: + setType(ctx, Varbinary, length, nullable); + return; + case NdbDictionary::Column::Datetime: + // XXX not yet + break; + case NdbDictionary::Column::Timespec: + setType(ctx, Datetime, nullable); + return; + case NdbDictionary::Column::Blob: + setType(ctx, Blob, nullable); + return; + default: + break; + } + ctx.pushStatus(Error::Gen, "unsupported NDB type %d", (signed)type); +} + +bool +SqlType::equal(const SqlType& sqlType) const +{ + return + m_type == sqlType.m_type && + m_precision == sqlType.m_precision && + m_scale == sqlType.m_scale && + m_length == sqlType.m_length; +} + +unsigned +SqlType::size() const +{ + switch (m_type) { + case Char: + case Varchar: + case Binary: + case Varbinary: + return m_length; + case Smallint: + return sizeof(SqlSmallint); + case Integer: + return sizeof(SqlInteger); + case Bigint: + return sizeof(SqlBigint); + case Real: + return sizeof(SqlReal); + case Double: + return sizeof(SqlDouble); + case Datetime: + return sizeof(SqlDatetime); + case Null: + return 0; + default: + break; + } + ctx_assert(false); + return 0; +} + +unsigned +SqlType::displaySize() const +{ + switch (m_type) { + case Char: + case Varchar: + return m_length; + case Binary: + case Varbinary: + return m_length; + case Smallint: + return m_unSigned ? 5 : 6; + case Integer: + return m_unSigned ? 10 : 11; + case Bigint: + return m_unSigned ? 20 : 21; + case Real: + return 10; + case Double: + return 20; + case Datetime: + return 30; + case Null: + return 0; + default: + break; + } + ctx_assert(false); + return 0; +} + +void +SqlType::getType(Ctx& ctx, NdbDictionary::Column* ndbColumn) const +{ + switch (m_type) { + case Char: + ndbColumn->setType(NdbDictionary::Column::Char); + ndbColumn->setLength(m_length); + break; + case Varchar: + ndbColumn->setType(NdbDictionary::Column::Varchar); + ndbColumn->setLength(m_length); + break; + case Binary: + ndbColumn->setType(NdbDictionary::Column::Binary); + ndbColumn->setLength(m_length); + break; + case Varbinary: + ndbColumn->setType(NdbDictionary::Column::Varbinary); + ndbColumn->setLength(m_length); + break; + case Smallint: + break; // XXX + case Integer: + if (! m_unSigned) + ndbColumn->setType(NdbDictionary::Column::Int); + else + ndbColumn->setType(NdbDictionary::Column::Unsigned); + ndbColumn->setLength(1); + break; + case Bigint: + if (! m_unSigned) + ndbColumn->setType(NdbDictionary::Column::Bigint); + else + ndbColumn->setType(NdbDictionary::Column::Bigunsigned); + ndbColumn->setLength(1); + break; + case Real: + ndbColumn->setType(NdbDictionary::Column::Float); + ndbColumn->setLength(1); + break; + case Double: + ndbColumn->setType(NdbDictionary::Column::Double); + ndbColumn->setLength(1); + break; + case Datetime: + ndbColumn->setType(NdbDictionary::Column::Timespec); + ndbColumn->setLength(1); + break; + default: + ctx_assert(false); + break; + } + ndbColumn->setNullable(m_nullable); +} + +const char* +SqlType::typeName() const +{ + switch (m_type) { + case Char: + return "CHAR"; + case Varchar: + return "VARCHAR"; + case Binary: + return "BINARY"; + case Varbinary: + return "VARBINARY"; + case Smallint: + return "SMALLINT"; + case Integer: + return "INTEGER"; + case Bigint: + return "BIGINT"; + case Real: + return "REAL"; + case Double: + return "FLOAT"; + case Datetime: + return "DATETIME"; + default: + break; + } + return "UNKNOWN"; +} + +void +SqlType::print(char* buf, unsigned size) const +{ + switch (m_type) { + case Char: + snprintf(buf, size, "char(%d)", m_length); + break; + case Varchar: + snprintf(buf, size, "varchar(%d)", m_length); + break; + case Binary: + snprintf(buf, size, "binary(%d)", m_length); + break; + case Varbinary: + snprintf(buf, size, "varbinary(%d)", m_length); + break; + case Smallint: + snprintf(buf, size, "smallint%s", m_unSigned ? " unsigned" : ""); + break; + case Integer: + snprintf(buf, size, "integer%s", m_unSigned ? " unsigned" : ""); + break; + case Bigint: + snprintf(buf, size, "bigint%s", m_unSigned ? " unsigned" : ""); + break; + case Real: + snprintf(buf, size, "real"); + break; + case Double: + snprintf(buf, size, "double"); + break; + case Datetime: + snprintf(buf, size, "datetime"); + break; + case Null: + snprintf(buf, size, "null"); + break; + case Unbound: + snprintf(buf, size, "unbound"); + break; + default: + snprintf(buf, size, "sqltype(%d)", (int)m_type); + break; + } +} + +// ExtType + +ExtType::ExtType() : + m_type(Undef) +{ +} + +ExtType::ExtType(Type type) +{ + Ctx ctx; + setType(ctx, type); + ctx_assert(ctx.ok()); +} + +ExtType::ExtType(Ctx& ctx, Type type) +{ + setType(ctx, type); +} + +void +ExtType::setType(Ctx& ctx, Type type) +{ + switch (type) { + case Char: + case Short: + case Sshort: + case Ushort: + case Long: + case Slong: + case Ulong: + case Sbigint: + case Ubigint: + case Float: + case Double: + case Timestamp: + case Binary: // XXX BLOB hack + case Unbound: + break; + default: + ctx.pushStatus(Error::Gen, "unsupported external type %d", (int)type); + return; + } + m_type = type; +} + +unsigned +ExtType::size() const +{ + ctx_assert(false); + return 0; +} + +// LexType + +LexType::LexType() : + m_type(Undef) +{ +} + +LexType::LexType(Type type) +{ + Ctx ctx; + setType(ctx, type); + ctx_assert(ctx.ok()); +} + +LexType::LexType(Ctx& ctx, Type type) +{ + setType(ctx, type); +} + +void +LexType::setType(Ctx& ctx, Type type) +{ + switch (type) { + case Char: + case Integer: + case Float: + case Null: + break; + default: + ctx_assert(false); + break; + } + m_type = type; +} + +// convert types + +SQLSMALLINT +SqlType::sqlcdefault(Ctx& ctx) const +{ + switch (m_type) { + case Char: + return SQL_C_CHAR; + case Varchar: + return SQL_C_CHAR; + case Binary: + return SQL_C_BINARY; + case Varbinary: + return SQL_C_BINARY; + case Smallint: + return m_unSigned ? SQL_C_USHORT : SQL_C_SSHORT; + case Integer: + return m_unSigned ? SQL_C_ULONG : SQL_C_SLONG; + case Bigint: + return SQL_C_CHAR; + // or maybe this + return m_unSigned ? SQL_C_UBIGINT : SQL_C_SBIGINT; + case Real: + return SQL_C_FLOAT; + case Double: + return SQL_C_DOUBLE; + case Datetime: + return SQL_C_TYPE_TIMESTAMP; + default: + break; + } + return SQL_C_DEFAULT; // no default +} + +void +LexType::convert(Ctx& ctx, SqlType& out, unsigned length) const +{ + switch (m_type) { + case Char: + out.setType(ctx, SqlType::Char, length, true); + return; + case Integer: + out.setType(ctx, SqlType::Bigint, false); + return; + case Float: + out.setType(ctx, SqlType::Double, false); + return; + case Null: + out.setType(ctx, SqlType::Null, true); + return; + default: + break; + } + ctx.pushStatus(Error::Gen, "unsupported lexical to SQL type conversion"); +} diff --git a/ndb/src/client/odbc/common/DataType.hpp b/ndb/src/client/odbc/common/DataType.hpp new file mode 100644 index 00000000000..ac2ca337e22 --- /dev/null +++ b/ndb/src/client/odbc/common/DataType.hpp @@ -0,0 +1,292 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_COMMON_DataType_hpp +#define ODBC_COMMON_DataType_hpp + +#include +#include +#include +#include +#include + +/** + * Sql data exists in several formats: + * + * - as NDB data at the bottom + * - as SQL data during intermediary processing + * - as external data in user input and output buffers + * - as lexical constants in SQL statement text + * + * Each data format has specific types (e.g. number) and each + * type has specific attributes (e.g. precision). + */ +enum DataFormat { + Undef_format = 0, + Ndb_format = 1, // not used in NDB version >= v2.10 + Sql_format = 2, + Ext_format = 3, + Lex_format = 4 +}; + +#define UndefDataType 990 +#define NullDataType 991 +#define UnboundDataType 992 + +class SqlType; +class ExtType; +class LexType; + +/** + * @class SqlType + * @brief Sql data type + */ +class SqlType { +public: + enum Type { + Undef = UndefDataType, + Char = SQL_CHAR, + Varchar = SQL_VARCHAR, + Longvarchar = SQL_LONGVARCHAR, + Binary = SQL_BINARY, + Varbinary = SQL_VARBINARY, + Longvarbinary = SQL_LONGVARBINARY, + Decimal = SQL_DECIMAL, + Tinyint = SQL_TINYINT, + Smallint = SQL_SMALLINT, + Integer = SQL_INTEGER, + Bigint = SQL_BIGINT, + Real = SQL_REAL, + Double = SQL_DOUBLE, + Date = SQL_DATE, + Datetime = SQL_TYPE_TIMESTAMP, + Blob = SQL_BLOB, + Null = NullDataType, // not an ODBC SQL type + Unbound = UnboundDataType // special for placeholders + }; + SqlType(); + SqlType(Type type, bool nullable = true); + SqlType(Type type, unsigned length, bool nullable = true); + SqlType(Type type, unsigned precision, unsigned scale, bool nullable = true); + SqlType(Ctx& ctx, Type type, bool nullable = true); + SqlType(Ctx& ctx, Type type, unsigned length, bool nullable = true); + SqlType(Ctx& ctx, Type type, unsigned precision, unsigned scale, bool nullable = true); + SqlType(Ctx& ctx, const NdbDictionary::Column* ndbColumn); + Type type() const; + void setType(Ctx& ctx, Type type, bool nullable = true); + void setType(Ctx& ctx, Type type, unsigned length, bool nullable = true); + void setType(Ctx& ctx, Type type, unsigned precision, unsigned scale, bool nullable = true); + void setType(Ctx& ctx, const NdbDictionary::Column* ndbColumn); + bool equal(const SqlType& sqlType) const; + unsigned size() const; + unsigned displaySize() const; + const char* typeName() const; + unsigned length() const; + bool nullable() const; + void nullable(bool value); + bool unSigned() const; + void unSigned(bool value); + // forwards compatible + void getType(Ctx& ctx, NdbDictionary::Column* ndbColumn) const; + // type conversion + SQLSMALLINT sqlcdefault(Ctx& ctx) const; + // print for debugging + void print(char* buf, unsigned size) const; +private: + friend class LexType; + Type m_type; + unsigned m_precision; + unsigned m_scale; + unsigned m_length; + bool m_nullable; + bool m_unSigned; // qualifier instead of separate types +}; + +inline SqlType::Type +SqlType::type() const +{ + return m_type; +} + +inline unsigned +SqlType::length() const +{ + return m_length; +} + +inline bool +SqlType::nullable() const +{ + return m_nullable; +} + +inline void +SqlType::nullable(bool value) +{ + m_nullable = value; +} + +inline bool +SqlType::unSigned() const +{ + return m_unSigned; +} + +inline void +SqlType::unSigned(bool value) +{ + ctx_assert(m_type == Smallint || m_type == Integer || m_type == Bigint); + m_unSigned = value; +} + +/** + * Actual SQL datatypes. + */ +typedef unsigned char SqlChar; // Char and Varchar via pointer +typedef Int16 SqlSmallint; +typedef Int32 SqlInteger; +typedef Int64 SqlBigint; +typedef Uint16 SqlUsmallint; +typedef Uint32 SqlUinteger; +typedef Uint64 SqlUbigint; +typedef float SqlReal; +typedef double SqlDouble; + +// datetime cc yy mm dd HH MM SS 00 ff ff ff ff stored as String(12) +struct SqlDatetime { + int cc() const { return *(signed char*)&m_data[0]; } + void cc(int x) { *(signed char*)&m_data[0] = x; } + unsigned yy() const { return *(unsigned char*)&m_data[1]; } + void yy(unsigned x) { *(unsigned char*)&m_data[1] = x; } + unsigned mm() const { return *(unsigned char*)&m_data[2]; } + void mm(unsigned x) { *(unsigned char*)&m_data[2] = x; } + unsigned dd() const { return *(unsigned char*)&m_data[3]; } + void dd(unsigned x) { *(unsigned char*)&m_data[3] = x; } + unsigned HH() const { return *(unsigned char*)&m_data[4]; } + void HH(unsigned x) { *(unsigned char*)&m_data[4] = x; } + unsigned MM() const { return *(unsigned char*)&m_data[5]; } + void MM(unsigned x) { *(unsigned char*)&m_data[5] = x; } + unsigned SS() const { return *(unsigned char*)&m_data[6]; } + void SS(unsigned x) { *(unsigned char*)&m_data[6] = x; } + unsigned ff() const { + const unsigned char* p = (unsigned char*)&m_data[8]; + unsigned x = 0; + x += *p++ << 24; + x += *p++ << 16; + x += *p++ << 8; + x += *p++; + return x; + } + void ff(unsigned x) { + unsigned char* p = (unsigned char*)&m_data[8]; + *p++ = (x >> 24) & 0xff; + *p++ = (x >> 16) & 0xff; + *p++ = (x >> 8) & 0xff; + *p++ = x & 0xff; + } + bool valid() { return true; } // XXX later + bool less(const SqlDatetime t) const { + if (cc() != t.cc()) + return cc() < t.cc(); + if (yy() != t.yy()) + return yy() < t.yy(); + if (mm() != t.mm()) + return mm() < t.mm(); + if (dd() != t.dd()) + return dd() < t.dd(); + if (HH() != t.HH()) + return HH() < t.HH(); + if (MM() != t.MM()) + return MM() < t.MM(); + if (SS() != t.SS()) + return SS() < t.SS(); + if (ff() != t.ff()) + return ff() < t.ff(); + return false; + } +private: + char m_data[12]; // use array to avoid gaps +}; + +/** + * @class ExtType + * @brief External data type + */ +class ExtType { +public: + enum Type { + Undef = UndefDataType, + Char = SQL_C_CHAR, + Short = SQL_C_SHORT, + Sshort = SQL_C_SSHORT, + Ushort = SQL_C_USHORT, + Long = SQL_C_LONG, // for sun.jdbc.odbc + Slong = SQL_C_SLONG, + Ulong = SQL_C_ULONG, + Sbigint = SQL_C_SBIGINT, + Ubigint = SQL_C_UBIGINT, + Float = SQL_C_FLOAT, + Double = SQL_C_DOUBLE, + Timestamp = SQL_C_TYPE_TIMESTAMP, + Binary = SQL_C_BINARY, // XXX BLOB hack + Unbound = UnboundDataType + }; + ExtType(); + ExtType(Type type); + ExtType(Ctx& ctx, Type type); + Type type() const; + void setType(Ctx& ctx, Type type); + unsigned size() const; +private: + Type m_type; +}; + +inline ExtType::Type +ExtType::type() const +{ + return m_type; +} + +/** + * @class LexType + * @class Lexical data type + */ +class LexType { +public: + enum Type { + Undef = UndefDataType, + Char = 1, + Integer = 2, + Float = 3, + Null = 4 + }; + LexType(); + LexType(Type type); + LexType(Ctx& ctx, Type type); + Type type() const; + void setType(Ctx& ctx, Type type); + void convert(Ctx& ctx, SqlType& out, unsigned length = 0) const; +private: + Type m_type; +}; + +inline LexType::Type +LexType::type() const +{ + return m_type; +} + +#endif diff --git a/ndb/src/client/odbc/common/DescArea.cpp b/ndb/src/client/odbc/common/DescArea.cpp new file mode 100644 index 00000000000..bad9f23d3ef --- /dev/null +++ b/ndb/src/client/odbc/common/DescArea.cpp @@ -0,0 +1,167 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "DescArea.hpp" + +// DescField + +// DescRec + +void +DescRec::setField(int id, const OdbcData& data) +{ + Ctx ctx; + setField(ctx, id, data); + ctx_assert(ctx.ok()); +} + +void +DescRec::getField(int id, OdbcData& data) +{ + Ctx ctx; + getField(ctx, id, data); + ctx_assert(ctx.ok()); +} + +void +DescRec::setField(Ctx& ctx, int id, const OdbcData& data) +{ + Fields::iterator iter; + iter = m_fields.find(id); + if (ctx.logLevel() >= 3) { + char buf[100]; + data.print(buf, sizeof(buf)); + ctx_log3(("set %s rec %d id %d = %s", DescArea::nameUsage(m_area->getUsage()), m_num, id, buf)); + } + if (iter != m_fields.end()) { + DescField& field = (*iter).second; + field.setData(data); + m_area->setBound(false); // XXX could compare data values + return; + } + const DescSpec& spec = m_area->findSpec(id); + if (spec.m_pos != Desc_pos_end) { + DescField field(spec, data); + m_fields.insert(Fields::value_type(id, field)); + m_area->setBound(false); + return; + } + ctx_assert(false); +} + +void +DescRec::getField(Ctx& ctx, int id, OdbcData& data) +{ + Fields::iterator iter; + iter = m_fields.find(id); + if (iter != m_fields.end()) { + DescField& field = (*iter).second; + data.setValue(field.getData()); + return; + } + const DescSpec& spec = m_area->findSpec(id); + if (spec.m_pos != Desc_pos_end) { + data.setValue(); + return; // XXX default value + } + ctx_assert(false); +} + +// DescArea + +DescArea::DescArea(HandleBase* handle, const DescSpec* specList) : + m_handle(handle), + m_specList(specList), + m_alloc(Desc_alloc_undef), + m_usage(Desc_usage_undef), + m_bound(true) // no bind necessary since empty +{ + m_header.m_area = this; + m_header.m_num = -1; + DescRec rec; + rec.m_area = this; + rec.m_num = m_recs.size(); + m_recs.push_back(rec); // add bookmark record + SQLSMALLINT count = 0; + getHeader().setField(SQL_DESC_COUNT, count); + m_bound = true; +} + +DescArea::~DescArea() +{ +} + +const DescSpec& +DescArea::findSpec(int id) +{ + const DescSpec* p; + for (p = m_specList; p->m_pos != Desc_pos_end; p++) { + if (p->m_id == id) + break; + } + return *p; +} + +unsigned +DescArea::getCount() const +{ + ctx_assert(m_recs.size() > 0); + return m_recs.size() - 1; +} + +void +DescArea::setCount(Ctx& ctx, unsigned count) +{ + if (m_recs.size() - 1 == count) + return; + ctx_log3(("set %s count %d to %d", + DescArea::nameUsage(m_usage), + (unsigned)(m_recs.size() - 1), + count)); + m_recs.resize(1 + count); + for (unsigned i = 0; i <= count; i++) { + m_recs[i].m_area = this; + m_recs[i].m_num = i; + } + getHeader().setField(SQL_DESC_COUNT, static_cast(count)); +} + +DescRec& +DescArea::pushRecord() +{ + ctx_assert(m_recs.size() > 0); + DescRec rec; + rec.m_area = this; + rec.m_num = m_recs.size(); + m_recs.push_back(rec); + SQLSMALLINT count = m_recs.size() - 1; + getHeader().setField(SQL_DESC_COUNT, count); + return m_recs.back(); +} + +DescRec& +DescArea::getHeader() +{ + return m_header; +} + +DescRec& +DescArea::getRecord(unsigned num) +{ + ctx_assert(num < m_recs.size()); + return m_recs[num]; +} diff --git a/ndb/src/client/odbc/common/DescArea.hpp b/ndb/src/client/odbc/common/DescArea.hpp new file mode 100644 index 00000000000..e9f552d758d --- /dev/null +++ b/ndb/src/client/odbc/common/DescArea.hpp @@ -0,0 +1,266 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_COMMON_DescArea_hpp +#define ODBC_COMMON_DescArea_hpp + +#include +#include +#include +#include "OdbcData.hpp" + +/** + * Descriptor records. Contains: + * -# header, not called a "record" in this context + * -# bookmark record at index position 0 + * -# descriptor records at index positions starting from 1 + * + * These classes are in common/ since the code is general. + * However each area is associated with a HandleDesc. + * + * DescField - field identified by an SQL_DESC_* constant + * DescRec - header or record, a list of fields + * DescArea - header and all records + */ + +class HandleBase; +class DescField; +class DescRec; +class DescArea; + +enum DescPos { + Desc_pos_undef = 0, + Desc_pos_header, + Desc_pos_record, + Desc_pos_end +}; + +enum DescMode { + Desc_mode_undef = 0, + Desc_mode_readonly, + Desc_mode_writeonly, + Desc_mode_readwrite, + Desc_mode_unused +}; + +struct DescSpec { + DescPos m_pos; // header or record + int m_id; // SQL_DESC_ identifier + OdbcData::Type m_type; // data type + DescMode m_mode[1+4]; // access mode IPD APD IRD ARD + // called before setting value + typedef void CallbackSet(Ctx& ctx, HandleBase* self, const OdbcData& data); + CallbackSet* m_set; + // called to get default value + typedef void CallbackDefault(Ctx& ctx, HandleBase* self, OdbcData& data); + CallbackDefault* m_default; +}; + +enum DescAlloc { + Desc_alloc_undef = 0, + Desc_alloc_auto, + Desc_alloc_user +}; + +enum DescUsage { + Desc_usage_undef = 0, + Desc_usage_IPD = 1, // these must be 1-4 + Desc_usage_IRD = 2, + Desc_usage_APD = 3, + Desc_usage_ARD = 4 +}; + +/** + * @class DescField + * @brief Field identified by an SQL_DESC_* constant + */ +class DescField { +public: + DescField(const DescSpec& spec, const OdbcData& data); + DescField(const DescField& field); + ~DescField(); +private: + friend class DescRec; + void setData(const OdbcData& data); + const OdbcData& getData(); + const DescSpec& m_spec; + OdbcData m_data; +}; + +inline +DescField::DescField(const DescSpec& spec, const OdbcData& data) : + m_spec(spec), + m_data(data) +{ +} + +inline +DescField::DescField(const DescField& field) : + m_spec(field.m_spec), + m_data(field.m_data) +{ +} + +inline +DescField::~DescField() +{ +} + +inline void +DescField::setData(const OdbcData& data) +{ + ctx_assert(m_spec.m_type == data.type()); + m_data.setValue(data); +} + +inline const OdbcData& +DescField::getData() +{ + ctx_assert(m_data.type() != OdbcData::Undef); + return m_data; +} + +/** + * @class DescRec + * @brief Descriptor record, a list of fields + */ +class DescRec { + friend class DescArea; +public: + DescRec(); + ~DescRec(); + void setField(int id, const OdbcData& data); + void getField(int id, OdbcData& data); + void setField(Ctx& ctx, int id, const OdbcData& data); + void getField(Ctx& ctx, int id, OdbcData& data); +private: + DescArea* m_area; + int m_num; // for logging only -1 = header 0 = bookmark + typedef std::map Fields; + Fields m_fields; +}; + +inline +DescRec::DescRec() : + m_area(0) +{ +} + +inline +DescRec::~DescRec() +{ +} + +/** + * @class DescArea + * @brief All records, including header (record 0) + * + * Descriptor area includes a header (record 0) + * and zero or more records at position >= 1. + * Each of these describes one parameter or one column. + * + * - DescArea : Collection of records + * - DescRec : Collection of fields + * - DescField : Contains data of type OdbcData + */ +class DescArea { +public: + DescArea(HandleBase* handle, const DescSpec* specList); + ~DescArea(); + void setAlloc(DescAlloc alloc); + DescAlloc getAlloc() const; + void setUsage(DescUsage usage); + DescUsage getUsage() const; + static const char* nameUsage(DescUsage u); + // find specifier + const DescSpec& findSpec(int id); + // get or set number of records (record 0 not counted) + unsigned getCount() const; + void setCount(Ctx& ctx, unsigned count); + // paush new record (record 0 exists always) + DescRec& pushRecord(); + // get ref to header or to any record + DescRec& getHeader(); + DescRec& getRecord(unsigned num); + // modified since last bind + void setBound(bool bound); + bool isBound() const; +private: + HandleBase* m_handle; + const DescSpec* const m_specList; + DescRec m_header; + typedef std::vector Recs; + Recs m_recs; + DescAlloc m_alloc; + DescUsage m_usage; + bool m_bound; +}; + +inline void +DescArea::setAlloc(DescAlloc alloc) +{ + m_alloc = alloc; +} + +inline DescAlloc +DescArea::getAlloc() const +{ + return m_alloc; +} + +inline void +DescArea::setUsage(DescUsage usage) +{ + m_usage = usage; +} + +inline DescUsage +DescArea::getUsage() const +{ + return m_usage; +} + +inline const char* +DescArea::nameUsage(DescUsage u) +{ + switch (u) { + case Desc_usage_undef: + break; + case Desc_usage_IPD: + return "IPD"; + case Desc_usage_IRD: + return "IRD"; + case Desc_usage_APD: + return "APD"; + case Desc_usage_ARD: + return "ARD"; + } + return "?"; +} + +inline void +DescArea::setBound(bool bound) +{ + m_bound = bound; +} + +inline bool +DescArea::isBound() const +{ + return m_bound; +} + +#endif diff --git a/ndb/src/client/odbc/common/DiagArea.cpp b/ndb/src/client/odbc/common/DiagArea.cpp new file mode 100644 index 00000000000..06e8da89495 --- /dev/null +++ b/ndb/src/client/odbc/common/DiagArea.cpp @@ -0,0 +1,284 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "OdbcData.hpp" +#include "DiagArea.hpp" + +// DiagSpec + +static const DiagSpec +diag_spec_list[] = { + { Diag_pos_header, + SQL_DIAG_CURSOR_ROW_COUNT, + OdbcData::Integer, + Odbc_handle_stmt + }, + { Diag_pos_header, + SQL_DIAG_DYNAMIC_FUNCTION, + OdbcData::Sqlchar, + Odbc_handle_stmt + }, + { Diag_pos_header, + SQL_DIAG_DYNAMIC_FUNCTION_CODE, + OdbcData::Integer, + Odbc_handle_stmt + }, + { Diag_pos_header, + SQL_DIAG_NUMBER, + OdbcData::Integer, + Odbc_handle_all + }, + { Diag_pos_header, + SQL_DIAG_RETURNCODE, + OdbcData::Smallint, + Odbc_handle_all + }, + { Diag_pos_header, + SQL_DIAG_ROW_COUNT, + OdbcData::Integer, + Odbc_handle_stmt + }, + { Diag_pos_status, + SQL_DIAG_CLASS_ORIGIN, + OdbcData::Sqlchar, + Odbc_handle_all + }, + { Diag_pos_status, + SQL_DIAG_COLUMN_NUMBER, + OdbcData::Integer, + Odbc_handle_all + }, + { Diag_pos_status, + SQL_DIAG_CONNECTION_NAME, + OdbcData::Sqlchar, + Odbc_handle_all + }, + { Diag_pos_status, + SQL_DIAG_MESSAGE_TEXT, + OdbcData::Sqlchar, + Odbc_handle_all + }, + { Diag_pos_status, + SQL_DIAG_NATIVE, + OdbcData::Integer, + Odbc_handle_all + }, + { Diag_pos_status, + SQL_DIAG_ROW_NUMBER, + OdbcData::Integer, + Odbc_handle_all + }, + { Diag_pos_status, + SQL_DIAG_SERVER_NAME, + OdbcData::Sqlchar, + Odbc_handle_all + }, + { Diag_pos_status, + SQL_DIAG_SQLSTATE, + OdbcData::Sqlchar, + Odbc_handle_all + }, + { Diag_pos_status, + SQL_DIAG_SUBCLASS_ORIGIN, + OdbcData::Sqlchar, + Odbc_handle_all + }, + { Diag_pos_end, + 0, + OdbcData::Undef, + 0 + } +}; + +const DiagSpec& +DiagSpec::find(int id) +{ + const DiagSpec* p; + for (p = diag_spec_list; p->m_pos != Diag_pos_end; p++) { + if (p->m_id == id) + break; + } + return *p; +} + +// DiagField + +// DiagRec + +void +DiagRec::setField(int id, const OdbcData& data) +{ + Fields::iterator iter; + iter = m_fields.find(id); + if (iter != m_fields.end()) { + DiagField& field = (*iter).second; + field.setData(data); + return; + } + const DiagSpec& spec = DiagSpec::find(id); + if (spec.m_pos != Diag_pos_end) { + DiagField field(spec, data); + m_fields.insert(Fields::value_type(id, field)); + return; + } + ctx_assert(false); +} + +void +DiagRec::getField(Ctx& ctx, int id, OdbcData& data) +{ + Fields::iterator iter; + iter = m_fields.find(id); + if (iter != m_fields.end()) { + DiagField& field = (*iter).second; + data.setValue(field.getData()); + return; + } + const DiagSpec& spec = DiagSpec::find(id); + if (spec.m_pos != Diag_pos_end) { + // success and undefined value says the MS doc + data.setValue(); + return; + } + ctx_assert(false); +} + +// DiagArea + +DiagArea::DiagArea() : + m_recs(1), // add header + m_code(SQL_SUCCESS), + m_recNumber(0) +{ + setHeader(SQL_DIAG_NUMBER, (SQLINTEGER)0); +} + +DiagArea::~DiagArea() { +} + +unsigned +DiagArea::numStatus() +{ + ctx_assert(m_recs.size() > 0); + return m_recs.size() - 1; +} + +void +DiagArea::pushStatus() +{ + ctx_assert(m_recs.size() > 0); + DiagRec rec; + m_recs.push_back(rec); + SQLINTEGER diagNumber = m_recs.size() - 1; + setHeader(SQL_DIAG_NUMBER, diagNumber); +} + +void +DiagArea::setHeader(int id, const OdbcData& data) +{ + ctx_assert(m_recs.size() > 0); + getHeader().setField(id, data); +} + +// set status + +void +DiagArea::setStatus(int id, const OdbcData& data) +{ + getStatus().setField(id, data); +} + +void +DiagArea::setStatus(const Sqlstate& state) +{ + getStatus().setField(SQL_DIAG_SQLSTATE, state); + setCode(state.getCode(m_code)); +} + +void +DiagArea::setStatus(const Error& error) +{ + BaseString message(""); + // bracketed prefixes + message.append(NDB_ODBC_COMPONENT_VENDOR); + message.append(NDB_ODBC_COMPONENT_DRIVER); + if (! error.driverError()) + message.append(NDB_ODBC_COMPONENT_DATABASE); + // native error code + char nativeString[20]; + sprintf(nativeString, "%02d%02d%04d", + (unsigned)error.m_status % 100, + (unsigned)error.m_classification % 100, + (unsigned)error.m_code % 10000); + SQLINTEGER native = atoi(nativeString); + message.appfmt("NDB-%s", nativeString); + // message text + message.append(" "); + message.append(error.m_message); + if (error.m_sqlFunction != 0) + message.appfmt(" (in %s)", error.m_sqlFunction); + // set diag fields + setStatus(error.m_sqlstate); + setStatus(SQL_DIAG_NATIVE, native); + setStatus(SQL_DIAG_MESSAGE_TEXT, message.c_str()); +} + +// push status + +void +DiagArea::pushStatus(const Error& error) +{ + pushStatus(); + setStatus(error); +} + +// record access + +DiagRec& +DiagArea::getHeader() +{ + ctx_assert(m_recs.size() > 0); + return m_recs[0]; +} + +DiagRec& +DiagArea::getStatus() +{ + ctx_assert(m_recs.size() > 1); + return m_recs.back(); +} + +DiagRec& +DiagArea::getRecord(unsigned num) +{ + ctx_assert(num < m_recs.size()); + return m_recs[num]; +} + +void +DiagArea::getRecord(Ctx& ctx, unsigned num, int id, OdbcData& data) +{ + DiagRec& rec = getRecord(num); + rec.getField(ctx, id, data); +} + +void +DiagArea::setCode(SQLRETURN code) +{ + m_code = code; + getHeader().setField(SQL_DIAG_RETURNCODE, (SQLSMALLINT)code); +} diff --git a/ndb/src/client/odbc/common/DiagArea.hpp b/ndb/src/client/odbc/common/DiagArea.hpp new file mode 100644 index 00000000000..79c03de6623 --- /dev/null +++ b/ndb/src/client/odbc/common/DiagArea.hpp @@ -0,0 +1,196 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_COMMON_DiagArea_hpp +#define ODBC_COMMON_DiagArea_hpp + +#include +#include +#include +#include "OdbcData.hpp" + +enum DiagPos { + Diag_pos_undef = 0, + Diag_pos_header, + Diag_pos_status, + Diag_pos_end +}; + +/** + * @class DiagSpec + * @brief Field specification + */ +struct DiagSpec { + DiagPos m_pos; // header or status + int m_id; // SQL_DIAG_ identifier + OdbcData::Type m_type; // data type + unsigned m_handles; // defined for these handle types + // find the spec + static const DiagSpec& find(int id); +}; + +/** + * @class DiagField + * @brief Field identified by an SQL_DIAG_* constant + */ +class DiagField { +public: + DiagField(const DiagSpec& spec, const OdbcData& data); + DiagField(const DiagField& field); + ~DiagField(); + void setData(const OdbcData& data); + const OdbcData& getData(); +private: + const DiagSpec& m_spec; + OdbcData m_data; +}; + +inline +DiagField::DiagField(const DiagSpec& spec, const OdbcData& data) : + m_spec(spec), + m_data(data) +{ +} + +inline +DiagField::DiagField(const DiagField& field) : + m_spec(field.m_spec), + m_data(field.m_data) +{ +} + +inline +DiagField::~DiagField() +{ +} + +inline void +DiagField::setData(const OdbcData& data) +{ + ctx_assert(m_spec.m_type == data.type()); + m_data.setValue(data); +} + +inline const OdbcData& +DiagField::getData() +{ + ctx_assert(m_data.type() != OdbcData::Undef); + return m_data; +} + +/** + * @class DiagRec + * @brief One diagnostic record, a list of fields + */ +class DiagRec { +public: + DiagRec(); + ~DiagRec(); + void setField(int id, const OdbcData& data); + void getField(Ctx& ctx, int id, OdbcData& data); +private: + typedef std::map Fields; + Fields m_fields; +}; + +inline +DiagRec::DiagRec() +{ +} + +inline +DiagRec::~DiagRec() +{ +} + +/** + * @class DiagArea + * @brief All records, including header (record 0) + * + * Diagnostic area includes a header (record 0) and zero or more + * status records at positions >= 1. + */ +class DiagArea { +public: + DiagArea(); + ~DiagArea(); + /** + * Get number of status records. + */ + unsigned numStatus(); + /** + * Push new status record. + */ + void pushStatus(); + /** + * Set field in header. + */ + void setHeader(int id, const OdbcData& data); + /** + * Set field in latest status record. The arguments can + * also be plain int, char*, Sqlstate. The NDB and other + * native errors set Sqlstate _IM000 automatically. + */ + void setStatus(int id, const OdbcData& data); + void setStatus(const Sqlstate& state); + void setStatus(const Error& error); + /** + * Convenience methods to push new status record and set + * some common fields in it. Sqlstate is set always. + */ + void pushStatus(const Error& error); + /** + * Get refs to various records. + */ + DiagRec& getHeader(); + DiagRec& getStatus(); + DiagRec& getRecord(unsigned num); + /** + * Get diag values. + */ + void getRecord(Ctx& ctx, unsigned num, int id, OdbcData& data); + /** + * Get or set return code. + */ + SQLRETURN getCode() const; + void setCode(SQLRETURN ret); + /** + * Get "next" record number (0 when no more). + * Used only by the deprecated SQLError function. + */ + unsigned nextRecNumber(); +private: + typedef std::vector Recs; + Recs m_recs; + SQLRETURN m_code; + unsigned m_recNumber; // for SQLError +}; + +inline SQLRETURN +DiagArea::getCode() const +{ + return m_code; +} + +inline unsigned +DiagArea::nextRecNumber() +{ + if (m_recNumber >= numStatus()) + return 0; + return ++m_recNumber; +} + +#endif diff --git a/ndb/src/client/odbc/common/Makefile b/ndb/src/client/odbc/common/Makefile new file mode 100644 index 00000000000..7ee29738d86 --- /dev/null +++ b/ndb/src/client/odbc/common/Makefile @@ -0,0 +1,29 @@ +include .defs.mk + +TYPE = * + +NONPIC_ARCHIVE = N + +PIC_ARCHIVE = Y + +ARCHIVE_TARGET = odbccommon + +SOURCES = \ + common.cpp \ + Ctx.cpp \ + Sqlstate.cpp \ + OdbcData.cpp \ + DiagArea.cpp \ + AttrArea.cpp \ + DescArea.cpp \ + ConnArea.cpp \ + StmtInfo.cpp \ + StmtArea.cpp \ + CodeTree.cpp \ + ResultArea.cpp \ + DataType.cpp \ + DataField.cpp \ + DataRow.cpp + +include ../Extra.mk +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/client/odbc/common/OdbcData.cpp b/ndb/src/client/odbc/common/OdbcData.cpp new file mode 100644 index 00000000000..d2402c7e0ab --- /dev/null +++ b/ndb/src/client/odbc/common/OdbcData.cpp @@ -0,0 +1,563 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "OdbcData.hpp" + +OdbcData::OdbcData() : + m_type(Undef) +{ +} + +OdbcData::OdbcData(Type type) : + m_type(type) +{ + switch (m_type) { + case Smallint: + m_smallint = 0; + break; + case Usmallint: + m_usmallint = 0; + break; + case Integer: + m_integer = 0; + break; + case Uinteger: + m_uinteger = 0; + break; + case Pointer: + m_pointer = 0; + break; + case SmallintPtr: + m_smallintPtr = 0; + break; + case UsmallintPtr: + m_usmallintPtr = 0; + break; + case IntegerPtr: + m_integerPtr = 0; + break; + case UintegerPtr: + m_uintegerPtr = 0; + break; + case PointerPtr: + m_pointerPtr = 0; + break; + case Sqlchar: + m_sqlchar = 0; + break; + case Sqlstate: + m_sqlstate = 0; + break; + default: + ctx_assert(false); + break; + }; +} + +OdbcData::OdbcData(const OdbcData& odbcData) : + m_type(odbcData.m_type) +{ + switch (m_type) { + case Smallint: + m_smallint = odbcData.m_smallint; + break; + case Usmallint: + m_usmallint = odbcData.m_usmallint; + break; + case Integer: + m_integer = odbcData.m_integer; + break; + case Uinteger: + m_uinteger = odbcData.m_uinteger; + break; + case Pointer: + m_pointer = odbcData.m_pointer; + break; + case SmallintPtr: + m_smallintPtr = odbcData.m_smallintPtr; + break; + case UsmallintPtr: + m_usmallintPtr = odbcData.m_usmallintPtr; + break; + case IntegerPtr: + m_integerPtr = odbcData.m_integerPtr; + break; + case UintegerPtr: + m_uintegerPtr = odbcData.m_uintegerPtr; + break; + case PointerPtr: + m_pointerPtr = odbcData.m_pointerPtr; + break; + case Sqlchar: { + unsigned n = strlen(odbcData.m_sqlchar); + m_sqlchar = new char[n + 1]; + memcpy(m_sqlchar, odbcData.m_sqlchar, n + 1); + break; + } + case Sqlstate: + m_sqlstate = odbcData.m_sqlstate; + break; + default: + ctx_assert(false); + break; + }; +} + +OdbcData::~OdbcData() +{ + switch (m_type) { + case Sqlchar: + delete[] m_sqlchar; + break; + default: + break; + } +} + +void +OdbcData::setValue() +{ + m_type = Undef; +} + +void +OdbcData::setValue(Type type) +{ + if (m_type == Sqlchar) { + delete[] m_sqlchar; + m_sqlchar = 0; + } + switch (m_type) { + case Smallint: + m_smallint = 0; + break; + case Usmallint: + m_usmallint = 0; + break; + case Integer: + m_integer = 0; + break; + case Uinteger: + m_uinteger = 0; + break; + case Pointer: + m_pointer = 0; + break; + case SmallintPtr: + m_smallintPtr = 0; + break; + case UsmallintPtr: + m_usmallintPtr = 0; + break; + case IntegerPtr: + m_integerPtr = 0; + break; + case UintegerPtr: + m_uintegerPtr = 0; + break; + case PointerPtr: + m_pointerPtr = 0; + break; + case Sqlchar: + m_sqlchar = 0; + break; + case Sqlstate: + m_sqlstate = 0; + break; + default: + ctx_assert(false); + break; + }; +} + +void +OdbcData::setValue(const OdbcData odbcData) +{ + if (m_type == Sqlchar) { + delete[] m_sqlchar; + m_sqlchar = 0; + } + m_type = odbcData.m_type; + switch (m_type) { + case Smallint: + m_smallint = odbcData.m_smallint; + break; + case Usmallint: + m_usmallint = odbcData.m_usmallint; + break; + case Integer: + m_integer = odbcData.m_integer; + break; + case Uinteger: + m_uinteger = odbcData.m_uinteger; + break; + case Pointer: + m_pointer = odbcData.m_pointer; + break; + case SmallintPtr: + m_smallintPtr = odbcData.m_smallintPtr; + break; + case UsmallintPtr: + m_usmallintPtr = odbcData.m_usmallintPtr; + break; + case IntegerPtr: + m_integerPtr = odbcData.m_integerPtr; + break; + case UintegerPtr: + m_uintegerPtr = odbcData.m_uintegerPtr; + break; + case PointerPtr: + m_pointerPtr = odbcData.m_pointerPtr; + break; + case Sqlchar: { + unsigned n = strlen(odbcData.m_sqlchar); + m_sqlchar = new char[n + 1]; + memcpy(m_sqlchar, odbcData.m_sqlchar, n + 1); + break; + } + case Sqlstate: + m_sqlstate = odbcData.m_sqlstate; + break; + default: + ctx_assert(false); + break; + }; +} + +// copy in from user buffer + +void +OdbcData::copyin(Ctx& ctx, Type type, SQLPOINTER buf, SQLINTEGER length) +{ + if (m_type == Sqlchar) { + delete[] m_sqlchar; + m_sqlchar = 0; + } + m_type = type; + switch (m_type) { + case Smallint: { + SQLSMALLINT val = 0; + switch (length) { + case 0: + case SQL_IS_SMALLINT: + val = (SQLSMALLINT)(SQLINTEGER)buf; + break; + case SQL_IS_USMALLINT: + val = (SQLUSMALLINT)(SQLUINTEGER)buf; + break; + case SQL_IS_INTEGER: + val = (SQLINTEGER)buf; + break; + case SQL_IS_UINTEGER: + val = (SQLUINTEGER)buf; + break; + default: + ctx.pushStatus(Error::Gen, "smallint input - invalid length %d", (int)length); + return; + } + m_smallint = val; + break; + } + case Usmallint: { + SQLUSMALLINT val = 0; + switch (length) { + case SQL_IS_SMALLINT: + val = (SQLSMALLINT)(SQLINTEGER)buf; + break; + case 0: + case SQL_IS_USMALLINT: + val = (SQLUSMALLINT)(SQLUINTEGER)buf; + break; + case SQL_IS_INTEGER: + val = (SQLINTEGER)buf; + break; + case SQL_IS_UINTEGER: + val = (SQLUINTEGER)buf; + break; + default: + ctx.pushStatus(Error::Gen, "unsigned smallint input - invalid length %d", (int)length); + return; + } + m_usmallint = val; + break; + } + case Integer: { + SQLINTEGER val = 0; + switch (length) { + case SQL_IS_SMALLINT: + val = (SQLSMALLINT)(SQLINTEGER)buf; + break; + case SQL_IS_USMALLINT: + val = (SQLUSMALLINT)(SQLUINTEGER)buf; + break; + case 0: + case SQL_IS_INTEGER: + val = (SQLINTEGER)buf; + break; + case SQL_IS_UINTEGER: + val = (SQLUINTEGER)buf; + break; + default: + ctx.pushStatus(Error::Gen, "integer input - invalid length %d", (int)length); + return; + } + m_integer = val; + break; + } + case Uinteger: { + SQLUINTEGER val = 0; + switch (length) { + case SQL_IS_SMALLINT: + val = (SQLSMALLINT)(SQLINTEGER)buf; + break; + case SQL_IS_USMALLINT: + val = (SQLUSMALLINT)(SQLUINTEGER)buf; + break; + case SQL_IS_INTEGER: + val = (SQLINTEGER)buf; + break; + case 0: + case SQL_IS_UINTEGER: + val = (SQLUINTEGER)buf; + break; + default: + ctx.pushStatus(Error::Gen, "unsigned integer input - invalid length %d", (int)length); + return; + } + m_uinteger = val; + break; + } + case Pointer: { + SQLPOINTER val = 0; + switch (length) { + case 0: + case SQL_IS_POINTER: + val = (SQLPOINTER)buf; + break; + default: + ctx.pushStatus(Error::Gen, "pointer input - invalid length %d", (int)length); + return; + } + m_pointer = val; + break; + } + case SmallintPtr: { + SQLSMALLINT* val = 0; + switch (length) { + case 0: + case SQL_IS_POINTER: + val = (SQLSMALLINT*)buf; + break; + default: + ctx.pushStatus(Error::Gen, "smallint pointer input - invalid length %d", (int)length); + return; + } + m_smallintPtr = val; + break; + } + case UsmallintPtr: { + SQLUSMALLINT* val = 0; + switch (length) { + case 0: + case SQL_IS_POINTER: + val = (SQLUSMALLINT*)buf; + break; + default: + ctx.pushStatus(Error::Gen, "unsigned smallint pointer input - invalid length %d", (int)length); + return; + } + m_usmallintPtr = val; + break; + } + case IntegerPtr: { + SQLINTEGER* val = 0; + switch (length) { + case 0: + case SQL_IS_POINTER: + val = (SQLINTEGER*)buf; + break; + default: + ctx.pushStatus(Error::Gen, "integer pointer input - invalid length %d", (int)length); + return; + } + m_integerPtr = val; + break; + } + case UintegerPtr: { + SQLUINTEGER* val = 0; + switch (length) { + case 0: + case SQL_IS_POINTER: + val = (SQLUINTEGER*)buf; + break; + default: + ctx.pushStatus(Error::Gen, "unsigned integer pointer input - invalid length %d", (int)length); + return; + } + m_uintegerPtr = val; + break; + } + case Sqlchar: { + const char* val = (char*)buf; + if (val == 0) { + ctx.pushStatus(Sqlstate::_HY009, Error::Gen, "null string input"); + return; + } + if (length < 0 && length != SQL_NTS) { + ctx.pushStatus(Error::Gen, "string input - invalid length %d", (int)length); + return; + } + if (length == SQL_NTS) { + m_sqlchar = strcpy(new char[strlen(val) + 1], val); + } else { + m_sqlchar = (char*)memcpy(new char[length + 1], val, length); + m_sqlchar[length] = 0; + } + break; + } + default: + ctx_assert(false); + break; + } +} + +// copy out to user buffer + +void +OdbcData::copyout(Ctx& ctx, SQLPOINTER buf, SQLINTEGER length, SQLINTEGER* total, SQLSMALLINT* total2) +{ + if (buf == 0) { + ctx.setCode(SQL_ERROR); + return; + } + switch (m_type) { + case Smallint: { + SQLSMALLINT* ptr = static_cast(buf); + *ptr = m_smallint; + break; + } + case Usmallint: { + SQLUSMALLINT* ptr = static_cast(buf); + *ptr = m_usmallint; + break; + } + case Integer: { + SQLINTEGER* ptr = static_cast(buf); + *ptr = m_integer; + break; + } + case Uinteger: { + SQLUINTEGER* ptr = static_cast(buf); + *ptr = m_uinteger; + break; + } + case Pointer: { + SQLPOINTER* ptr = static_cast(buf); + *ptr = m_pointer; + break; + } + case Sqlchar: { + char* ptr = static_cast(buf); + if (length < 0 && length != SQL_NTS) { + ctx.setCode(SQL_ERROR); + return; + } + if (length == SQL_NTS) { + strcpy(ptr, m_sqlchar); + } else { + strncpy(ptr, m_sqlchar, length); + } + if (total != 0) + *total = strlen(m_sqlchar); + if (total2 != 0) + *total2 = strlen(m_sqlchar); + break; + } + case Sqlstate: { + char* ptr = static_cast(buf); + const char* state = m_sqlstate->state(); + if (length < 0 && length != SQL_NTS) { + ctx.setCode(SQL_ERROR); + return; + } + if (length == SQL_NTS) { + strcpy(ptr, state); + } else { + strncpy(ptr, state, length); + } + if (total != 0) + *total = strlen(state); + if (total2 != 0) + *total2 = strlen(state); + break; + } + default: + ctx_assert(false); + break; + } +} + +void +OdbcData::print(char* buf, unsigned size) const +{ + switch (m_type) { + case Undef: + snprintf(buf, size, "undef"); + break; + case Smallint: + snprintf(buf, size, "%d", (int)m_smallint); + break; + case Usmallint: + snprintf(buf, size, "%u", (unsigned)m_usmallint); + break; + case Integer: + snprintf(buf, size, "%ld", (long)m_integer); + break; + case Uinteger: + snprintf(buf, size, "%lu", (unsigned long)m_uinteger); + break; + case Pointer: + snprintf(buf, size, "0x%lx", (unsigned long)m_pointer); + break; + case SmallintPtr: + snprintf(buf, size, "0x%lx", (unsigned long)m_smallintPtr); + break; + case UsmallintPtr: + snprintf(buf, size, "0x%lx", (unsigned long)m_usmallintPtr); + break; + case IntegerPtr: + snprintf(buf, size, "0x%lx", (unsigned long)m_integerPtr); + break; + case UintegerPtr: + snprintf(buf, size, "0x%lx", (unsigned long)m_uintegerPtr); + break; + case PointerPtr: + snprintf(buf, size, "0x%lx", (unsigned long)m_pointerPtr); + break; + case Sqlchar: + snprintf(buf, size, "%s", m_sqlchar); + break; + case Sqlstate: + snprintf(buf, size, "%s", m_sqlstate->state()); + break; + default: + snprintf(buf, size, "data(%d)", (int)m_type); + break; + }; +} diff --git a/ndb/src/client/odbc/common/OdbcData.hpp b/ndb/src/client/odbc/common/OdbcData.hpp new file mode 100644 index 00000000000..c1884507cfe --- /dev/null +++ b/ndb/src/client/odbc/common/OdbcData.hpp @@ -0,0 +1,283 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_COMMON_OdbcData_hpp +#define ODBC_COMMON_OdbcData_hpp + +#include +#include + +/** + * @class OdbcData + * @brief Odbc data types and storage + * + * Stores diagnostics, attributes, and descriptors. Also used + * for converting to and from driver function arguments. + */ +class OdbcData { +public: + enum Type { + Undef = 0, + Smallint, + Usmallint, + Integer, + Uinteger, + Pointer, + SmallintPtr, + UsmallintPtr, + IntegerPtr, + UintegerPtr, + PointerPtr, + Sqlchar, + Sqlstate + }; + OdbcData(); + OdbcData(Type type); + OdbcData(const OdbcData& odbcData); + OdbcData(SQLSMALLINT smallint); + OdbcData(SQLUSMALLINT usmallint); + OdbcData(SQLINTEGER integer); + OdbcData(SQLUINTEGER uinteger); + OdbcData(SQLPOINTER pointer); + OdbcData(SQLSMALLINT* smallintPtr); + OdbcData(SQLUSMALLINT* usmallintPtr); + OdbcData(SQLINTEGER* integerPtr); + OdbcData(SQLUINTEGER* uintegerPtr); + OdbcData(SQLPOINTER* pointerPtr); + OdbcData(const char* sqlchar); + OdbcData(const ::Sqlstate& sqlstate); + ~OdbcData(); + Type type() const; + void setValue(); + void setValue(Type type); + void setValue(const OdbcData odbcData); + // get value + SQLSMALLINT smallint() const; + SQLUSMALLINT usmallint() const; + SQLINTEGER integer() const; + SQLUINTEGER uinteger() const; + SQLPOINTER pointer() const; + SQLSMALLINT* smallintPtr() const; + SQLUSMALLINT* usmallintPtr() const; + SQLINTEGER* integerPtr() const; + SQLUINTEGER* uintegerPtr() const; + SQLPOINTER* pointerPtr() const; + const char* sqlchar() const; + const ::Sqlstate& sqlstate() const; + // copy in from user buffer + void copyin(Ctx& ctx, Type type, SQLPOINTER buf, SQLINTEGER length); + // copy out to user buffer + void copyout(Ctx& ctx, SQLPOINTER buf, SQLINTEGER length, SQLINTEGER* total, SQLSMALLINT* total2 = 0); + // logging + void print(char* buf, unsigned size) const; +private: + OdbcData& operator=(const OdbcData& odbcData); // disallowed + Type m_type; + union { + SQLSMALLINT m_smallint; + SQLUSMALLINT m_usmallint; + SQLINTEGER m_integer; + SQLUINTEGER m_uinteger; + SQLPOINTER m_pointer; + SQLSMALLINT* m_smallintPtr; + SQLUSMALLINT* m_usmallintPtr; + SQLINTEGER* m_integerPtr; + SQLUINTEGER* m_uintegerPtr; + SQLPOINTER* m_pointerPtr; + char* m_sqlchar; + const ::Sqlstate* m_sqlstate; + }; +}; + +inline OdbcData::Type +OdbcData::type() const +{ + return m_type; +} + +inline +OdbcData::OdbcData(SQLSMALLINT smallint) : + m_type(Smallint), + m_smallint(smallint) +{ +} + +inline +OdbcData::OdbcData(SQLUSMALLINT usmallint) : + m_type(Usmallint), + m_usmallint(usmallint) +{ +} + +inline +OdbcData::OdbcData(SQLINTEGER integer) : + m_type(Integer), + m_integer(integer) +{ +} + +inline +OdbcData::OdbcData(SQLUINTEGER uinteger) : + m_type(Uinteger), + m_uinteger(uinteger) +{ +} + +inline +OdbcData::OdbcData(SQLPOINTER pointer) : + m_type(Pointer), + m_pointer(pointer) +{ +} + +inline +OdbcData::OdbcData(SQLSMALLINT* smallintPtr) : + m_type(SmallintPtr), + m_smallintPtr(smallintPtr) +{ +} + +inline +OdbcData::OdbcData(SQLUSMALLINT* usmallintPtr) : + m_type(UsmallintPtr), + m_usmallintPtr(usmallintPtr) +{ +} + +inline +OdbcData::OdbcData(SQLINTEGER* integerPtr) : + m_type(IntegerPtr), + m_integerPtr(integerPtr) +{ +} + +inline +OdbcData::OdbcData(SQLUINTEGER* uintegerPtr) : + m_type(UintegerPtr), + m_uintegerPtr(uintegerPtr) +{ +} + +inline +OdbcData::OdbcData(SQLPOINTER* pointerPtr) : + m_type(PointerPtr), + m_pointerPtr(pointerPtr) +{ +} + +inline +OdbcData::OdbcData(const char* sqlchar) : + m_type(Sqlchar) +{ + unsigned n = strlen(sqlchar); + m_sqlchar = new char[n + 1]; + strcpy(m_sqlchar, sqlchar); +} + +inline +OdbcData::OdbcData(const ::Sqlstate& sqlstate) : + m_type(Sqlstate), + m_sqlstate(&sqlstate) +{ +} + +// get value + +inline SQLSMALLINT +OdbcData::smallint() const +{ + ctx_assert(m_type == Smallint); + return m_smallint; +} + +inline SQLUSMALLINT +OdbcData::usmallint() const +{ + ctx_assert(m_type == Usmallint); + return m_usmallint; +} + +inline SQLINTEGER +OdbcData::integer() const +{ + ctx_assert(m_type == Integer); + return m_integer; +} + +inline SQLUINTEGER +OdbcData::uinteger() const +{ + ctx_assert(m_type == Uinteger); + return m_uinteger; +} + +inline SQLPOINTER +OdbcData::pointer() const +{ + ctx_assert(m_type == Pointer); + return m_pointer; +} + +inline SQLSMALLINT* +OdbcData::smallintPtr() const +{ + ctx_assert(m_type == SmallintPtr); + return m_smallintPtr; +} + +inline SQLUSMALLINT* +OdbcData::usmallintPtr() const +{ + ctx_assert(m_type == UsmallintPtr); + return m_usmallintPtr; +} + +inline SQLINTEGER* +OdbcData::integerPtr() const +{ + ctx_assert(m_type == IntegerPtr); + return m_integerPtr; +} + +inline SQLUINTEGER* +OdbcData::uintegerPtr() const +{ + ctx_assert(m_type == UintegerPtr); + return m_uintegerPtr; +} + +inline SQLPOINTER* +OdbcData::pointerPtr() const +{ + ctx_assert(m_type == PointerPtr); + return m_pointerPtr; +} + +inline const char* +OdbcData::sqlchar() const +{ + ctx_assert(m_type == Sqlchar); + return m_sqlchar; +} + +inline const ::Sqlstate& +OdbcData::sqlstate() const +{ + ctx_assert(m_type == Sqlstate); + return *m_sqlstate; +} + +#endif diff --git a/ndb/src/client/odbc/common/ResultArea.cpp b/ndb/src/client/odbc/common/ResultArea.cpp new file mode 100644 index 00000000000..79d7fb0ccc4 --- /dev/null +++ b/ndb/src/client/odbc/common/ResultArea.cpp @@ -0,0 +1,29 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "ResultArea.hpp" + +// ResultArea + +ResultArea::~ResultArea() +{ +} + +// ResultSet + +ResultSet::~ResultSet() +{ +} diff --git a/ndb/src/client/odbc/common/ResultArea.hpp b/ndb/src/client/odbc/common/ResultArea.hpp new file mode 100644 index 00000000000..d4890c44d99 --- /dev/null +++ b/ndb/src/client/odbc/common/ResultArea.hpp @@ -0,0 +1,162 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_COMMON_ResultArea_hpp +#define ODBC_COMMON_ResultArea_hpp + +#include +#include + +class SqlRow; + +/** + * @class ResultArea + * @brief Execution result + * + * ResultArea contains general results from executing SQL + * statements. Data rows from queries are fetched via derived + * class ResultSet. + */ +class ResultArea { +public: + ResultArea(); + virtual ~ResultArea(); + /** + * Get number of rows: + * + * - for queries: number of rows fetched so far + * - for DML statements: number of rows affected + * - for DDL and other statements: 0 + */ + CountType getCount() const; +protected: + void setCount(CountType count); + void addCount(unsigned count = 1); +private: + CountType m_count; +}; + +inline +ResultArea::ResultArea() : + m_count(0) +{ +} + +inline CountType +ResultArea::getCount() const +{ + return m_count; +} + +inline void +ResultArea::setCount(CountType count) +{ + m_count = count; +} + +inline void +ResultArea::addCount(unsigned count) +{ + m_count += count; +} + +/** + * @class ResultSet + * @brief Data rows from queries + * + * ResultSet is an interface implemented by SQL queries and + * virtual queries (such as SQLTables). It has an associated + * data row accessor SqlRow. + */ +class ResultSet : public ResultArea { +public: + ResultSet(const SqlRow& dataRow); + virtual ~ResultSet(); + enum State { + State_init = 1, // before first fetch + State_ok = 2, // last fetch succeeded + State_end = 3 // end of fetch or error + }; + void initState(); + State getState() const; + /** + * Get data accessor. Can be retrieved once and used after + * each successful ResultSet::fetch(). + */ + const SqlRow& dataRow() const; + /** + * Try to fetch one more row from this result set. + * - returns true if a row was fetched + * - returns false on end of fetch + * - returns false on error and sets error status + * It is a fatal error to call fetch after end of fetch. + */ + bool fetch(Ctx& ctx, Exec_base::Ctl& ctl); +protected: + /** + * Implementation of ResultSet::fetch() must be provided by + * each concrete subclass. + */ + virtual bool fetchImpl(Ctx& ctx, Exec_base::Ctl& ctl) = 0; + const SqlRow& m_dataRow; + State m_state; +}; + +inline +ResultSet::ResultSet(const SqlRow& dataRow) : + m_dataRow(dataRow), + m_state(State_end) // explicit initState() is required +{ +} + +inline const SqlRow& +ResultSet::dataRow() const +{ + return m_dataRow; +} + +inline void +ResultSet::initState() +{ + m_state = State_init; + setCount(0); +} + +inline ResultSet::State +ResultSet::getState() const +{ + return m_state; +} + +inline bool +ResultSet::fetch(Ctx& ctx, Exec_base::Ctl& ctl) +{ + if (! (m_state == State_init || m_state == State_ok)) { + // should not happen but return error instead of assert + ctx.pushStatus(Error::Gen, "invalid fetch state %d", (int)m_state); + m_state = State_end; + return false; + } + if (fetchImpl(ctx, ctl)) { + m_state = State_ok; + addCount(); + return true; + } + m_state = State_end; + return false; +} + +#endif diff --git a/ndb/src/client/odbc/common/Sqlstate.cpp b/ndb/src/client/odbc/common/Sqlstate.cpp new file mode 100644 index 00000000000..2d625a7c159 --- /dev/null +++ b/ndb/src/client/odbc/common/Sqlstate.cpp @@ -0,0 +1,93 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +// Initialize Sqlstate records statically. +// They are not used by other static initializers. + +#define make_Sqlstate(state, code) \ + const Sqlstate Sqlstate::_##state(#state, code) + +make_Sqlstate(00000, SQL_SUCCESS); +make_Sqlstate(01004, SQL_SUCCESS_WITH_INFO); +make_Sqlstate(01S02, SQL_SUCCESS_WITH_INFO); +make_Sqlstate(07009, SQL_ERROR); +make_Sqlstate(08003, SQL_ERROR); +make_Sqlstate(21S01, SQL_ERROR); +make_Sqlstate(22001, SQL_ERROR); +make_Sqlstate(22002, SQL_ERROR); +make_Sqlstate(22003, SQL_ERROR); +make_Sqlstate(22005, SQL_ERROR); +make_Sqlstate(22008, SQL_ERROR); +make_Sqlstate(22012, SQL_ERROR); +make_Sqlstate(24000, SQL_ERROR); +make_Sqlstate(25000, SQL_ERROR); +make_Sqlstate(42000, SQL_ERROR); +make_Sqlstate(42S02, SQL_ERROR); +make_Sqlstate(42S22, SQL_ERROR); +make_Sqlstate(HY004, SQL_ERROR); +make_Sqlstate(HY009, SQL_ERROR); +make_Sqlstate(HY010, SQL_ERROR); +make_Sqlstate(HY011, SQL_ERROR); +make_Sqlstate(HY012, SQL_ERROR); +make_Sqlstate(HY014, SQL_ERROR); +make_Sqlstate(HY019, SQL_ERROR); +make_Sqlstate(HY024, SQL_ERROR); +make_Sqlstate(HY090, SQL_ERROR); +make_Sqlstate(HY091, SQL_ERROR); +make_Sqlstate(HY092, SQL_ERROR); +make_Sqlstate(HY095, SQL_ERROR); +make_Sqlstate(HY096, SQL_ERROR); +make_Sqlstate(HYC00, SQL_ERROR); +make_Sqlstate(HYT00, SQL_ERROR); +make_Sqlstate(IM000, SQL_ERROR); // consider all to be errors for now +make_Sqlstate(IM001, SQL_ERROR); +make_Sqlstate(IM999, SQL_ERROR); + +SQLRETURN +Sqlstate::getCode(SQLRETURN code) const +{ + int codes[2]; + int ranks[2]; + codes[0] = code; + codes[1] = m_code; + for (int i = 0; i < 2; i++) { + switch (codes[i]) { + case SQL_SUCCESS: + ranks[i] = 0; + break; + case SQL_SUCCESS_WITH_INFO: + ranks[i] = 1; + break; + case SQL_NO_DATA: + ranks[i] = 2; + break; + case SQL_NEED_DATA: + ranks[i] = 3; + break; + case SQL_ERROR: + ranks[i] = 9; + break; + default: + ctx_assert(false); + ranks[i] = 9; + } + } + if (ranks[0] < ranks[1]) + code = m_code; + return code; +} diff --git a/ndb/src/client/odbc/common/Sqlstate.hpp b/ndb/src/client/odbc/common/Sqlstate.hpp new file mode 100644 index 00000000000..3b4665dc6ca --- /dev/null +++ b/ndb/src/client/odbc/common/Sqlstate.hpp @@ -0,0 +1,85 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_COMMON_SqlState_hpp +#define ODBC_COMMON_SqlState_hpp + +#include + +/** + * SQL states. + */ +class Sqlstate { +public: + static const Sqlstate _00000; // no state + static const Sqlstate _01004; // data converted with truncation + static const Sqlstate _01S02; // option value changed + static const Sqlstate _07009; // invalid descriptor index + static const Sqlstate _08003; // connection not open + static const Sqlstate _21S01; // insert value list does not match column list + static const Sqlstate _22001; // string data, right truncation + static const Sqlstate _22002; // indicator variable required but not supplied + static const Sqlstate _22003; // data overflow + static const Sqlstate _22005; // data is not numeric-literal + static const Sqlstate _22008; // data value is not a valid timestamp + static const Sqlstate _22012; // division by zero + static const Sqlstate _24000; // invalid cursor state + static const Sqlstate _25000; // invalid transaction state + static const Sqlstate _42000; // syntax error or access violation + static const Sqlstate _42S02; // base table or view not found + static const Sqlstate _42S22; // column not found + static const Sqlstate _HY004; // invalid SQL data type + static const Sqlstate _HY009; // invalid use of null pointer + static const Sqlstate _HY010; // function sequence error + static const Sqlstate _HY011; // attribute cannot be set now + static const Sqlstate _HY012; // invalid transaction operation code + static const Sqlstate _HY014; // limit on number of handles exceeded + static const Sqlstate _HY019; // non-character and non-binary data sent in pieces + static const Sqlstate _HY024; // invalid attribute value + static const Sqlstate _HY090; // invalid string or buffer length + static const Sqlstate _HY091; // invalid descriptor field identifier + static const Sqlstate _HY092; // invalid attribute/option identifier + static const Sqlstate _HY095; // function type out of range + static const Sqlstate _HY096; // information type out of range + static const Sqlstate _HYC00; // optional feature not implemented + static const Sqlstate _HYT00; // timeout expired + static const Sqlstate _IM000; // implementation defined + static const Sqlstate _IM001; // driver does not support this function + static const Sqlstate _IM999; // fill in the right state please + // get the 5-char text string + const char* state() const; + // get code or "upgrade" existing code + SQLRETURN getCode(SQLRETURN code = SQL_SUCCESS) const; +private: + Sqlstate(const char* state, const SQLRETURN code); + const char* const m_state; + const SQLRETURN m_code; +}; + +inline const char* +Sqlstate::state() const +{ + return m_state; +} + +inline +Sqlstate::Sqlstate(const char* state, const SQLRETURN code) : + m_state(state), + m_code(code) +{ +} + +#endif diff --git a/ndb/src/client/odbc/common/StmtArea.cpp b/ndb/src/client/odbc/common/StmtArea.cpp new file mode 100644 index 00000000000..5ce2d47d31a --- /dev/null +++ b/ndb/src/client/odbc/common/StmtArea.cpp @@ -0,0 +1,112 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "DiagArea.hpp" +#include "StmtArea.hpp" +#include + +StmtArea::StmtArea(ConnArea& connArea) : + m_connArea(connArea), + m_state(Free), + m_useSchemaCon(false), + m_useConnection(false), + m_planTree(0), + m_execTree(0), + m_unbound(0), + m_rowCount(0), + m_tuplesFetched(0) +{ + for (unsigned i = 0; i <= 4; i++) + m_descArea[i] = 0; +} + +StmtArea::~StmtArea() +{ +} + +void +StmtArea::free(Ctx &ctx) +{ + CodeGen codegen(*this); + codegen.close(ctx); + codegen.free(ctx); + m_sqlText.assign(""); + m_nativeText.assign(""); + useSchemaCon(ctx, false); + useConnection(ctx, false); + m_stmtInfo.free(ctx); + m_planTree = 0; + m_execTree = 0; + m_rowCount = 0; + m_tuplesFetched = 0; + m_unbound = 0; + m_state = Free; +} + +void +StmtArea::setRowCount(Ctx& ctx, CountType rowCount) +{ + m_rowCount = rowCount; + // location + DescArea& ird = descArea(Desc_usage_IRD); + OdbcData data; + ird.getHeader().getField(ctx, SQL_DESC_ROWS_PROCESSED_PTR, data); + if (data.type() != OdbcData::Undef) { + SQLUINTEGER* countPtr = data.uintegerPtr(); + if (countPtr != 0) { + *countPtr = static_cast(m_rowCount); + } + } + // diagnostic + SQLINTEGER count = static_cast(m_rowCount); + ctx.diagArea().setHeader(SQL_DIAG_ROW_COUNT, count); +} + +void +StmtArea::setFunction(Ctx& ctx, const char* function, SQLINTEGER functionCode) +{ + m_stmtInfo.m_function = function; + m_stmtInfo.m_functionCode = functionCode; +} + +void +StmtArea::setFunction(Ctx& ctx) +{ + OdbcData function(m_stmtInfo.m_function); + ctx.diagArea().setHeader(SQL_DIAG_DYNAMIC_FUNCTION, function); + OdbcData functionCode(m_stmtInfo.m_functionCode); + ctx.diagArea().setHeader(SQL_DIAG_DYNAMIC_FUNCTION_CODE, functionCode); +} + +bool +StmtArea::useSchemaCon(Ctx& ctx, bool use) +{ + if (m_useSchemaCon != use) + if (! m_connArea.useSchemaCon(ctx, use)) + return false; + m_useSchemaCon = use; + return true; +} + +bool +StmtArea::useConnection(Ctx& ctx, bool use) +{ + if (m_useConnection != use) + if (! m_connArea.useConnection(ctx, use)) + return false; + m_useConnection = use; + return true; +} diff --git a/ndb/src/client/odbc/common/StmtArea.hpp b/ndb/src/client/odbc/common/StmtArea.hpp new file mode 100644 index 00000000000..a88c6d36e6d --- /dev/null +++ b/ndb/src/client/odbc/common/StmtArea.hpp @@ -0,0 +1,157 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_COMMON_StmtArea_hpp +#define ODBC_COMMON_StmtArea_hpp + +#include +#include "ConnArea.hpp" +#include "StmtInfo.hpp" +#include "DescArea.hpp" + +class PlanTree; +class ExecTree; + +/** + * @class StmtArea + * @brief Public part of statement handle + */ +class StmtArea { +public: + // state between ODBC function calls + enum State { + Free = 1, // not in use + Prepared = 2, // statement prepared, maybe unbound + NeedData = 3, // executed, SQLParamData expected + Open = 4 // cursor open + }; + // connection area shared by all statements + ConnArea& connArea(); + State getState() const; + // SQL text + const BaseString& sqlText(); + BaseString& nativeText(); + // allocate or unallocate connections if necessary + bool useSchemaCon(Ctx& ctx, bool use); + bool useConnection(Ctx& ctx, bool use); + // statement info + StmtInfo& stmtInfo(); + DescArea& descArea(DescUsage u); + unsigned unbound() const; + // set row count here and in diagnostics + void setRowCount(Ctx& ctx, CountType rowCount); + CountType getRowCount() const; + // raw tuple count (tuples fetched from NDB) + void resetTuplesFetched(); + void incTuplesFetched(); + CountType getTuplesFetched() const; + // set dynamic function in StmtInfo only (at prepare) + void setFunction(Ctx& ctx, const char* function, SQLINTEGER functionCode); + // set dynamic function in diagnostics (at execute) + void setFunction(Ctx& ctx); +protected: + friend class CodeGen; + friend class Executor; + friend class Plan_root; + StmtArea(ConnArea& connArea); + ~StmtArea(); + void free(Ctx& ctx); + ConnArea& m_connArea; + State m_state; + BaseString m_sqlText; + BaseString m_nativeText; + bool m_useSchemaCon; + bool m_useConnection; + StmtInfo m_stmtInfo; + // plan tree output from parser and rewritten by analyze + PlanTree* m_planTree; + // exec tree output from analyze + ExecTree* m_execTree; + // pointers within HandleDesc allocated via HandleStmt + DescArea* m_descArea[1+4]; + // parameters with unbound SQL type + unsigned m_unbound; + CountType m_rowCount; + CountType m_tuplesFetched; +}; + +inline ConnArea& +StmtArea::connArea() +{ + return m_connArea; +} + +inline StmtArea::State +StmtArea::getState() const +{ + return m_state; +} + +inline const BaseString& +StmtArea::sqlText() { + return m_sqlText; +} + +inline BaseString& +StmtArea::nativeText() { + return m_nativeText; +} + +inline StmtInfo& +StmtArea::stmtInfo() +{ + return m_stmtInfo; +} + +inline DescArea& +StmtArea::descArea(DescUsage u) +{ + ctx_assert(1 <= u && u <= 4); + ctx_assert(m_descArea[u] != 0); + return *m_descArea[u]; +} + +inline unsigned +StmtArea::unbound() const +{ + return m_unbound; +} + +inline CountType +StmtArea::getRowCount() const +{ + return m_rowCount; +} + +inline void +StmtArea::resetTuplesFetched() +{ + m_tuplesFetched = 0; +} + +inline void +StmtArea::incTuplesFetched() +{ + m_tuplesFetched++; +} + +inline CountType +StmtArea::getTuplesFetched() const +{ + return m_tuplesFetched; +} + +#endif diff --git a/ndb/src/client/odbc/common/StmtInfo.cpp b/ndb/src/client/odbc/common/StmtInfo.cpp new file mode 100644 index 00000000000..3467fb5023e --- /dev/null +++ b/ndb/src/client/odbc/common/StmtInfo.cpp @@ -0,0 +1,78 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "StmtInfo.hpp" + +const char* +StmtInfo::getDesc() const +{ + switch (m_name) { + case Stmt_name_select: + return "select"; + case Stmt_name_insert: + return "insert"; + case Stmt_name_update: + return "update"; + case Stmt_name_delete: + return "delete"; + case Stmt_name_create_table: + return "create table"; + case Stmt_name_create_index: + return "create index"; + case Stmt_name_drop_table: + return "drop table"; + case Stmt_name_drop_index: + return "drop index"; + default: + ctx_assert(false); + break; + } + return ""; +} + +StmtType +StmtInfo::getType() const +{ + StmtType type = Stmt_type_undef; + switch (m_name) { + case Stmt_name_select: // query + type = Stmt_type_query; + break; + case Stmt_name_insert: // DML + case Stmt_name_update: + case Stmt_name_delete: + type = Stmt_type_DML; + break; + case Stmt_name_create_table: // DDL + case Stmt_name_create_index: + case Stmt_name_drop_table: + case Stmt_name_drop_index: + type = Stmt_type_DDL; + break; + default: + ctx_assert(false); + break; + } + return type; +} + +void +StmtInfo::free(Ctx& ctx) +{ + m_name = Stmt_name_undef; + m_function = ""; + m_functionCode = SQL_DIAG_UNKNOWN_STATEMENT; +} diff --git a/ndb/src/client/odbc/common/StmtInfo.hpp b/ndb/src/client/odbc/common/StmtInfo.hpp new file mode 100644 index 00000000000..9cd489be6da --- /dev/null +++ b/ndb/src/client/odbc/common/StmtInfo.hpp @@ -0,0 +1,86 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_COMMON_StmtInfo_hpp +#define ODBC_COMMON_StmtInfo_hpp + +#include + +// general type (determined by SQL command) +enum StmtType { + Stmt_type_undef = 0, + Stmt_type_query, // select + Stmt_type_DML, // insert, update, delete + Stmt_type_DDL, // create, drop, alter table + Stmt_type_info // virtual query +}; + +// specific SQL command (first 1-2 words) +enum StmtName { + Stmt_name_undef = 0, + Stmt_name_select, + Stmt_name_insert, + Stmt_name_update, + Stmt_name_delete, + Stmt_name_create_table, + Stmt_name_create_index, + Stmt_name_drop_table, + Stmt_name_drop_index +}; + +/** + * @class StmtInfo + * @brief Statement Info + * + * Statement info. This is a separate class which could + * be used in cases not tied to statement execution. + */ +class StmtInfo { +public: + StmtInfo(); + void setName(StmtName name); + StmtName getName() const; + const char* getDesc() const; + StmtType getType() const; + void free(Ctx& ctx); +private: + friend class StmtArea; + StmtName m_name; + const char* m_function; // not allocated + SQLINTEGER m_functionCode; +}; + +inline +StmtInfo::StmtInfo() : + m_name(Stmt_name_undef), + m_function(""), + m_functionCode(SQL_DIAG_UNKNOWN_STATEMENT) +{ +} + +inline void +StmtInfo::setName(StmtName name) +{ + m_name = name; +} + +inline StmtName +StmtInfo::getName() const +{ + return m_name; +} + +#endif diff --git a/ndb/src/client/odbc/common/common.cpp b/ndb/src/client/odbc/common/common.cpp new file mode 100644 index 00000000000..73d14c82efe --- /dev/null +++ b/ndb/src/client/odbc/common/common.cpp @@ -0,0 +1,17 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "common.hpp" diff --git a/ndb/src/client/odbc/common/common.hpp b/ndb/src/client/odbc/common/common.hpp new file mode 100644 index 00000000000..e90950df9c5 --- /dev/null +++ b/ndb/src/client/odbc/common/common.hpp @@ -0,0 +1,120 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_COMMON_common_hpp +#define ODBC_COMMON_common_hpp + +// misc defs + +#ifdef NDB_GCC +#define PRINTFLIKE(i,j) __attribute__ ((format (printf, i, j))) +#else +#define PRINTFLIKE(i,j) +#endif + +// odbc defs + +#define ODBCVER 0x0351 + +#ifdef NDB_WIN32 +#include +#endif + +extern "C" { +#include +} +// some types which may be missing +#ifndef SQL_BLOB +#define SQL_BLOB 30 +#endif +#ifndef SQL_BLOB_LOCATOR +#define SQL_BLOB_LOCATOR 31 +#endif +#ifndef SQL_CLOB +#define SQL_CLOB 40 +#endif +#ifndef SQL_CLOB_LOCATOR +#define SQL_CLOB_LOCATOR 41 +#endif + +// until real blobs use Varchar of this size +#define FAKE_BLOB_SIZE 2000 + +#define SQL_HANDLE_ROOT 0 // assume real handles != 0 + +enum OdbcHandle { + Odbc_handle_root = 0, // not an odbc handle + Odbc_handle_env = 1, + Odbc_handle_dbc = 2, + Odbc_handle_stmt = 4, + Odbc_handle_desc = 8, + Odbc_handle_all = (1|2|4|8) +}; + +// ndb defs + +#undef BOOL +#include +// this info not yet on api side +#include +#include + +#ifndef MAX_TAB_NAME_SIZE +#define MAX_TAB_NAME_SIZE 128 +#endif + +#ifndef MAX_ATTR_NAME_SIZE +#define MAX_ATTR_NAME_SIZE 32 +#endif + +#ifndef MAX_ATTR_DEFAULT_VALUE_SIZE +#define MAX_ATTR_DEFAULT_VALUE_SIZE 128 +#endif + +typedef Uint32 NdbAttrId; +typedef Uint64 CountType; + +// ndb odbc defs + +#define NDB_ODBC_COMPONENT_VENDOR "[MySQL]" +#define NDB_ODBC_COMPONENT_DRIVER "[ODBC driver]" +#define NDB_ODBC_COMPONENT_DATABASE "[NDB Cluster]" + +#define NDB_ODBC_VERSION_MAJOR 0 +#define NDB_ODBC_VERSION_MINOR 22 +#define NDB_ODBC_VERSION_STRING "0.22" + +// reserved error codes for non-NDB errors +#define NDB_ODBC_ERROR_MIN 5000 +#define NDB_ODBC_ERROR_MAX 5100 + +// maximum log level compiled in +#ifdef VM_TRACE +#define NDB_ODBC_MAX_LOG_LEVEL 5 +#else +#define NDB_ODBC_MAX_LOG_LEVEL 3 +#endif + +// driver specific statement attribute for number of NDB tuples fetched +#define SQL_ATTR_NDB_TUPLES_FETCHED 66601 + +#include +#include +#include + +#undef assert + +#endif diff --git a/ndb/src/client/odbc/dictionary/DictCatalog.cpp b/ndb/src/client/odbc/dictionary/DictCatalog.cpp new file mode 100644 index 00000000000..433347c9a70 --- /dev/null +++ b/ndb/src/client/odbc/dictionary/DictCatalog.cpp @@ -0,0 +1,42 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "DictCatalog.hpp" +#include "DictSchema.hpp" + +DictCatalog::~DictCatalog() +{ + for (Schemas::iterator i = m_schemas.begin(); i != m_schemas.end(); i++) { + delete *i; + *i = 0; + } +} + +DictSchema* +DictCatalog::findSchema(Ctx& ctx, const BaseString& name) +{ + for (Schemas::iterator i = m_schemas.begin(); i != m_schemas.end(); i++) { + DictSchema* schema = *i; + ctx_assert(schema != 0); + if (strcmp(schema->getName().c_str(), name.c_str()) == 0) + return schema; + } + ctx_assert(strcmp(name.c_str(), "NDB") == 0); + DictSchema* schema = new DictSchema(m_connArea, "NDB"); + m_schemas.push_back(schema); + return schema; +} diff --git a/ndb/src/client/odbc/dictionary/DictCatalog.hpp b/ndb/src/client/odbc/dictionary/DictCatalog.hpp new file mode 100644 index 00000000000..5452990a51b --- /dev/null +++ b/ndb/src/client/odbc/dictionary/DictCatalog.hpp @@ -0,0 +1,64 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_DICTIONARY_DictCatalog_hpp +#define ODBC_DICTIONARY_DictCatalog_hpp + +#include +#include +#include "DictSchema.hpp" + +class Ctx; +class ConnArea; +class DictSchema; + +/** + * @class DictCatalog + * @brief Collection of schemas + */ +class DictCatalog { +public: + DictCatalog(const ConnArea& connArea); + ~DictCatalog(); + const ConnArea& connArea() const; + DictSchema* findSchema(Ctx& ctx, const BaseString& name); + void addSchema(DictSchema* schema); +protected: + const ConnArea& m_connArea; + typedef std::list Schemas; + Schemas m_schemas; +}; + +inline +DictCatalog::DictCatalog(const ConnArea& connArea) : + m_connArea(connArea) +{ +} + +inline const ConnArea& +DictCatalog::connArea() const +{ + return m_connArea; +} + +inline void +DictCatalog::addSchema(DictSchema* schema) +{ + m_schemas.push_back(schema); + schema->setParent(this); +} + +#endif diff --git a/ndb/src/client/odbc/dictionary/DictColumn.cpp b/ndb/src/client/odbc/dictionary/DictColumn.cpp new file mode 100644 index 00000000000..fa0128f1ddb --- /dev/null +++ b/ndb/src/client/odbc/dictionary/DictColumn.cpp @@ -0,0 +1,23 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "DictColumn.hpp" + +DictColumn::~DictColumn() +{ + delete[] m_defaultValue; + m_defaultValue = 0; +} diff --git a/ndb/src/client/odbc/dictionary/DictColumn.hpp b/ndb/src/client/odbc/dictionary/DictColumn.hpp new file mode 100644 index 00000000000..945fb86367b --- /dev/null +++ b/ndb/src/client/odbc/dictionary/DictColumn.hpp @@ -0,0 +1,143 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_DICTIONARY_DictColumn_hpp +#define ODBC_DICTIONARY_DictColumn_hpp + +#include +#include + +class Ctx; +class SqlType; +class ConnArea; +class DictTable; + +/** + * @class DictColumn + * @brief Table column + */ +class DictColumn { +public: + DictColumn(const ConnArea& connArea, const BaseString& name, const SqlType& sqlType); + ~DictColumn(); + const BaseString& getName() const; + const SqlType& sqlType() const; + void setPosition(unsigned position); + unsigned getPosition() const; + void setParent(DictTable* parent); + DictTable* getParent() const; + NdbAttrId getAttrId() const; + bool isKey() const; + bool isTupleId() const; + bool isAutoIncrement() const; + const char* getDefaultValue() const; +protected: + friend class DictSys; + friend class DictTable; + const ConnArea& m_connArea; + const BaseString m_name; + SqlType m_sqlType; + unsigned m_position; + DictTable* m_parent; + bool m_key; // part of key + bool m_tupleId; // the tuple id + bool m_autoIncrement; + const char* m_defaultValue; +}; + +inline +DictColumn::DictColumn(const ConnArea& connArea, const BaseString& name, const SqlType& sqlType) : + m_connArea(connArea), + m_name(name), + m_sqlType(sqlType), + m_position(0), + m_parent(0), + m_key(false), + m_tupleId(false), + m_autoIncrement(false), + m_defaultValue(0) +{ +} + +inline const SqlType& +DictColumn::sqlType() const +{ + return m_sqlType; +} + +inline void +DictColumn::setPosition(unsigned position) +{ + ctx_assert(position != 0); + m_position = position; +} + +inline unsigned +DictColumn::getPosition() const +{ + return m_position; +} + +inline void +DictColumn::setParent(DictTable* parent) +{ + m_parent = parent; +} + +inline DictTable* +DictColumn::getParent() const +{ + return m_parent; +} + +inline const BaseString& +DictColumn::getName() const +{ + return m_name; +} + +inline NdbAttrId +DictColumn::getAttrId() const +{ + ctx_assert(m_position != 0); + return static_cast(m_position - 1); +} + +inline bool +DictColumn::isKey() const +{ + return m_key; +} + +inline bool +DictColumn::isTupleId() const +{ + return m_tupleId; +} + +inline bool +DictColumn::isAutoIncrement() const +{ + return m_autoIncrement; +} + +inline const char* +DictColumn::getDefaultValue() const +{ + return m_defaultValue; +} + +#endif diff --git a/ndb/src/client/odbc/dictionary/DictIndex.cpp b/ndb/src/client/odbc/dictionary/DictIndex.cpp new file mode 100644 index 00000000000..95d93318902 --- /dev/null +++ b/ndb/src/client/odbc/dictionary/DictIndex.cpp @@ -0,0 +1,29 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "DictTable.hpp" +#include "DictIndex.hpp" + +DictIndex::~DictIndex() +{ +} + +void +DictIndex::setColumn(unsigned i, DictColumn* column) +{ + ctx_assert(1 <= i && i <= m_size); + m_columns[i] = column; +} diff --git a/ndb/src/client/odbc/dictionary/DictIndex.hpp b/ndb/src/client/odbc/dictionary/DictIndex.hpp new file mode 100644 index 00000000000..7ba46daaae3 --- /dev/null +++ b/ndb/src/client/odbc/dictionary/DictIndex.hpp @@ -0,0 +1,108 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_DICTIONARY_DictIndex_hpp +#define ODBC_DICTIONARY_DictIndex_hpp + +#include +#include +#include "DictColumn.hpp" + +class Ctx; +class ConnArea; +class DictTable; +class DictColumn; +class DictIndex; + +/** + * @class DictIndex + * @brief Database table + */ +class DictIndex { + friend class DictSchema; +public: + DictIndex(const ConnArea& connArea, const BaseString& name, NdbDictionary::Object::Type type, unsigned size); + ~DictIndex(); + NdbDictionary::Object::Type getType() const; + unsigned getSize() const; + void setTable(DictTable* table); + DictTable* getTable() const; + void setColumn(unsigned i, DictColumn* column); + DictColumn* getColumn(unsigned i) const; + const BaseString& getName() const; + DictColumn* findColumn(const BaseString& name) const; +protected: + const ConnArea& m_connArea; + const BaseString m_name; + const NdbDictionary::Object::Type m_type; + const unsigned m_size; + DictSchema* m_parent; + DictTable* m_table; + typedef std::vector Columns; // pointers to table columns + Columns m_columns; +}; + +inline +DictIndex::DictIndex(const ConnArea& connArea, const BaseString& name, NdbDictionary::Object::Type type, unsigned size) : + m_connArea(connArea), + m_name(name), + m_type(type), + m_size(size), + m_parent(0), + m_columns(1 + size) +{ +} + +inline NdbDictionary::Object::Type +DictIndex::getType() const +{ + return m_type; +} + +inline unsigned +DictIndex::getSize() const +{ + ctx_assert(m_columns.size() == 1 + m_size); + return m_size; +} + +inline void +DictIndex::setTable(DictTable* table) +{ + m_table = table; +} + +inline DictTable* +DictIndex::getTable() const +{ + return m_table; +} + +inline DictColumn* +DictIndex::getColumn(unsigned i) const +{ + ctx_assert(1 <= i && i <= m_size); + ctx_assert(m_columns[i] != 0); + return m_columns[i]; +} + +inline const BaseString& +DictIndex::getName() const +{ + return m_name; +} + +#endif diff --git a/ndb/src/client/odbc/dictionary/DictSchema.cpp b/ndb/src/client/odbc/dictionary/DictSchema.cpp new file mode 100644 index 00000000000..91939cb2f26 --- /dev/null +++ b/ndb/src/client/odbc/dictionary/DictSchema.cpp @@ -0,0 +1,155 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include "DictCatalog.hpp" +#include "DictSchema.hpp" +#include "DictTable.hpp" +#include "DictTable.hpp" +#include "DictColumn.hpp" +#include "DictIndex.hpp" +#include "DictSys.hpp" + +DictSchema::~DictSchema() +{ + for (Tables::iterator i = m_tables.begin(); i != m_tables.end(); i++) { + delete *i; + *i = 0; + } +} + +DictTable* +DictSchema::findTable(const BaseString& name) +{ + for (Tables::iterator i = m_tables.begin(); i != m_tables.end(); i++) { + DictTable* table = *i; + ctx_assert(table != 0); + if (strcmp(table->getName().c_str(), name.c_str()) == 0) + return table; + } + return 0; +} + +void +DictSchema::deleteTable(Ctx& ctx, const BaseString& name) +{ + Tables::iterator i = m_tables.begin(); + while (i != m_tables.end()) { + DictTable* table = *i; + ctx_assert(table != 0); + if (strcmp(table->getName().c_str(), name.c_str()) == 0) { + ctx_log2(("purge table %s from dictionary", name.c_str())); + delete table; + Tables::iterator j = i; + i++; + m_tables.erase(j); + break; + } + i++; + } +} + +void +DictSchema::deleteTableByIndex(Ctx& ctx, const BaseString& indexName) +{ + DictTable* foundTable = 0; + for (Tables::iterator i = m_tables.begin(); i != m_tables.end(); i++) { + DictTable* table = *i; + ctx_assert(table != 0); + for (unsigned k = 1; k <= table->indexCount(); k++) { + const DictIndex* index = table->getIndex(k); + if (strcmp(index->getName().c_str(), indexName.c_str()) == 0) { + foundTable = table; + break; + } + } + if (foundTable != 0) + break; + } + if (foundTable != 0) + deleteTable(ctx, foundTable->getName()); +} + +DictTable* +DictSchema::loadTable(Ctx& ctx, const BaseString& name) +{ + ctx_log4(("%s: load from NDB", name.c_str())); + Ndb* ndb = m_connArea.ndbObject(); + NdbDictionary::Dictionary* ndbDictionary = ndb->getDictionary(); + if (ndbDictionary == 0) { + ctx.pushStatus(ndb, "getDictionary"); + return 0; + } + const NdbDictionary::Table* ndbTable = ndbDictionary->getTable(name.c_str()); + if (ndbTable == 0) { + const NdbError& ndbError = ndbDictionary->getNdbError(); + if (ndbError.code == 709) { + // try built-in system table + DictTable* table = DictSys::loadTable(ctx, this, name); + if (table != 0) { + return table; + } + ctx_log3(("%s: not found in NDB", name.c_str())); + return 0; + } + ctx.pushStatus(ndbDictionary->getNdbError(), "getTable"); + return 0; + } + int nattr = ndbTable->getNoOfColumns(); + DictTable* table = new DictTable(m_connArea, name, nattr); + for (unsigned position = 1; position <= (unsigned)nattr; position++) { + DictColumn* column = table->loadColumn(ctx, position); + if (column == 0) + return 0; + ctx_log4(("add column %u %s", column->getPosition(), column->getName().c_str())); + } + // load indexes + NdbDictionary::Dictionary::List list; + if (ndbDictionary->listIndexes(list, name.c_str()) == -1) { + ctx.pushStatus(ndbDictionary->getNdbError(), "listIndexes"); + return 0; + } + for (unsigned i = 0; i < list.count; i++) { + const NdbDictionary::Dictionary::List::Element& elt = list.elements[i]; + if (elt.state != NdbDictionary::Object::StateOnline) { + ctx_log1(("%s: skip broken index %s", name.c_str(), elt.name)); + continue; + } + if (elt.type != NdbDictionary::Object::UniqueHashIndex && elt.type != NdbDictionary::Object::OrderedIndex) { + ctx_log1(("%s: skip unknown index type %s", name.c_str(), elt.name)); + continue; + } + const NdbDictionary::Index* ndbIndex = ndbDictionary->getIndex(elt.name, name.c_str()); + if (ndbIndex == 0) { + ctx.pushStatus(ndbDictionary->getNdbError(), "table %s getIndex %s", name.c_str(), elt.name); + return 0; + } + DictIndex* index = new DictIndex(m_connArea, elt.name, elt.type, ndbIndex->getNoOfIndexColumns()); + for (unsigned j = 0; j < index->getSize(); j++) { + const char* cname = ndbIndex->getIndexColumn(j); + ctx_assert(cname != 0); + DictColumn* icolumn = table->findColumn(cname); + ctx_assert(icolumn != 0); + index->setColumn(1 + j, icolumn); + } + table->addIndex(index); + ctx_log3(("%s: index %s: load from NDB done", name.c_str(), elt.name)); + } + addTable(table); + ctx_log3(("%s: load from NDB done", name.c_str())); + return table; +} diff --git a/ndb/src/client/odbc/dictionary/DictSchema.hpp b/ndb/src/client/odbc/dictionary/DictSchema.hpp new file mode 100644 index 00000000000..099352edbb9 --- /dev/null +++ b/ndb/src/client/odbc/dictionary/DictSchema.hpp @@ -0,0 +1,89 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_DICTIONARY_DictSchema_hpp +#define ODBC_DICTIONARY_DictSchema_hpp + +#include +#include +#include "DictTable.hpp" + +class Ctx; +class ConnArea; +class DictCatalog; +class DictTable; + +/** + * @class DictSchema + * @brief Collection of tables + */ +class DictSchema { +public: + DictSchema(const ConnArea& connArea, const BaseString& name); + ~DictSchema(); + const BaseString& getName() const; + void setParent(DictCatalog* parent); + DictCatalog* getParent() const; + void addTable(DictTable* table); + DictTable* findTable(const BaseString& name); + DictTable* loadTable(Ctx& ctx, const BaseString& name); + void deleteTable(Ctx& ctx, const BaseString& name); + void deleteTableByIndex(Ctx& ctx, const BaseString& indexName); +protected: + friend class DictCatalog; + friend class DictSys; + const ConnArea& m_connArea; + BaseString m_name; + DictCatalog* m_parent; + typedef std::list Tables; + Tables m_tables; +}; + +inline +DictSchema::DictSchema(const ConnArea& connArea, const BaseString& name) : + m_connArea(connArea), + m_name(name), + m_parent(0) +{ + ctx_assert(strcmp(name.c_str(), "NDB") == 0); +} + +inline const BaseString& +DictSchema::getName() const +{ + return m_name; +} + +inline void +DictSchema::setParent(DictCatalog* parent) +{ + m_parent = parent; +} + +inline DictCatalog* +DictSchema::getParent() const +{ + return m_parent; +} + +inline void +DictSchema::addTable(DictTable* table) +{ + m_tables.push_back(table); + table->setParent(this); +} + +#endif diff --git a/ndb/src/client/odbc/dictionary/DictSys.cpp b/ndb/src/client/odbc/dictionary/DictSys.cpp new file mode 100644 index 00000000000..1ceef66ee57 --- /dev/null +++ b/ndb/src/client/odbc/dictionary/DictSys.cpp @@ -0,0 +1,433 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include "DictSchema.hpp" +#include "DictTable.hpp" +#include "DictColumn.hpp" +#include "DictSys.hpp" + +#define arraySize(x) sizeof(x)/sizeof(x[0]) + +#define MAX_SCHEMA_NAME_LENGTH 32 +#define MAX_REMARKS_LENGTH 256 + +// typeinfo + +static DictSys::Column +column_ODBC_TYPEINFO[] = { + DictSys::Column( + 1, + "TYPE_NAME", + false, + SqlType(SqlType::Varchar, 20, false) + ), + DictSys::Column( + 2, + "DATA_TYPE", + false, + SqlType(SqlType::Integer, false) + ), + DictSys::Column( + 3, + "COLUMN_SIZE", + false, + SqlType(SqlType::Integer, true) + ), + DictSys::Column( + 4, + "LITERAL_PREFIX", + false, + SqlType(SqlType::Varchar, 1, true) + ), + DictSys::Column( + 5, + "LITERAL_SUFFIX", + false, + SqlType(SqlType::Varchar, 1, true) + ), + DictSys::Column( + 6, + "CREATE_PARAMS", + false, + SqlType(SqlType::Varchar, 20, true) + ), + DictSys::Column( + 7, + "NULLABLE", + false, + SqlType(SqlType::Integer, false) + ), + DictSys::Column( + 8, + "CASE_SENSITIVE", + false, + SqlType(SqlType::Integer, false) + ), + DictSys::Column( + 9, + "SEARCHABLE", + false, + SqlType(SqlType::Integer, false) + ), + DictSys::Column( + 10, + "UNSIGNED_ATTRIBUTE", + false, + SqlType(SqlType::Integer, true) + ), + DictSys::Column( + 11, + "FIXED_PREC_SCALE", + false, + SqlType(SqlType::Integer, false) + ), + DictSys::Column( + 12, + "AUTO_UNIQUE_VALUE", + false, + SqlType(SqlType::Integer, true) + ), + DictSys::Column( + 13, + "LOCAL_TYPE_NAME", + false, + SqlType(SqlType::Varchar, 20, true) + ), + DictSys::Column( + 14, + "MINIMUM_SCALE", + false, + SqlType(SqlType::Integer, true) + ), + DictSys::Column( + 15, + "MAXIMUM_SCALE", + false, + SqlType(SqlType::Integer, true) + ), + DictSys::Column( + 16, + "SQL_DATA_TYPE", + false, + SqlType(SqlType::Integer, false) + ), + DictSys::Column( + 17, + "SQL_DATETIME_SUB", + false, + SqlType(SqlType::Integer, true) + ), + DictSys::Column( + 18, + "NUM_PREC_RADIX", + false, + SqlType(SqlType::Integer, true) + ), + DictSys::Column( + 19, + "INTERVAL_PRECISION", + false, + SqlType(SqlType::Integer, true) + ) +}; + +static DictSys::Table +table_ODBC_TYPEINFO( + DictSys::OdbcTypeinfo, + "ODBC$TYPEINFO", + column_ODBC_TYPEINFO, + arraySize(column_ODBC_TYPEINFO) +); + +// tables + +static DictSys::Column +column_ODBC_TABLES[] = { + // perl docs/systables.pl tables -c + DictSys::Column( + 1, + "TABLE_CAT", + false, + SqlType(SqlType::Varchar, MAX_SCHEMA_NAME_LENGTH, true) + ), + DictSys::Column( + 2, + "TABLE_SCHEM", + false, + SqlType(SqlType::Varchar, MAX_SCHEMA_NAME_LENGTH, true) + ), + DictSys::Column( + 3, + "TABLE_NAME", + false, + SqlType(SqlType::Varchar, MAX_TAB_NAME_SIZE, false) + ), + DictSys::Column( + 4, + "TABLE_TYPE", + false, + SqlType(SqlType::Varchar, 20, false) + ), + DictSys::Column( + 5, + "REMARKS", + false, + SqlType(SqlType::Varchar, MAX_REMARKS_LENGTH, true) + ) +}; + +static DictSys::Table +table_ODBC_TABLES( + DictSys::OdbcTables, + "ODBC$TABLES", + column_ODBC_TABLES, + arraySize(column_ODBC_TABLES) +); + +// columns + +static DictSys::Column +column_ODBC_COLUMNS[] = { + // perl docs/systables.pl columns -c + DictSys::Column( + 1, + "TABLE_CAT", + false, + SqlType(SqlType::Varchar, MAX_SCHEMA_NAME_LENGTH, true) + ), + DictSys::Column( + 2, + "TABLE_SCHEM", + false, + SqlType(SqlType::Varchar, MAX_SCHEMA_NAME_LENGTH, true) + ), + DictSys::Column( + 3, + "TABLE_NAME", + false, + SqlType(SqlType::Varchar, MAX_TAB_NAME_SIZE, false) + ), + DictSys::Column( + 4, + "COLUMN_NAME", + false, + SqlType(SqlType::Varchar, MAX_ATTR_NAME_SIZE, false) + ), + DictSys::Column( + 5, + "DATA_TYPE", + false, + SqlType(SqlType::Integer, false) + ), + DictSys::Column( + 6, + "TYPE_NAME", + false, + SqlType(SqlType::Varchar, 20, false) + ), + DictSys::Column( + 7, + "COLUMN_SIZE", + false, + SqlType(SqlType::Integer, true) + ), + DictSys::Column( + 8, + "BUFFER_LENGTH", + false, + SqlType(SqlType::Integer, true) + ), + DictSys::Column( + 9, + "DECIMAL_DIGITS", + false, + SqlType(SqlType::Integer, true) + ), + DictSys::Column( + 10, + "NUM_PREC_RADIX", + false, + SqlType(SqlType::Integer, true) + ), + DictSys::Column( + 11, + "NULLABLE", + false, + SqlType(SqlType::Integer, false) + ), + DictSys::Column( + 12, + "REMARKS", + false, + SqlType(SqlType::Varchar, MAX_REMARKS_LENGTH, true) + ), + DictSys::Column( + 13, + "COLUMN_DEF", + false, + SqlType(SqlType::Varchar, MAX_ATTR_DEFAULT_VALUE_SIZE, true) + ), + DictSys::Column( + 14, + "SQL_DATA_TYPE", + false, + SqlType(SqlType::Integer, false) + ), + DictSys::Column( + 15, + "SQL_DATETIME_SUB", + false, + SqlType(SqlType::Integer, true) + ), + DictSys::Column( + 16, + "CHAR_OCTET_LENGTH", + false, + SqlType(SqlType::Integer, true) + ), + DictSys::Column( + 17, + "ORDINAL_POSITION", + false, + SqlType(SqlType::Integer, false) + ), + DictSys::Column( + 18, + "IS_NULLABLE", + false, + SqlType(SqlType::Varchar, 3, true) + ) +}; + +static DictSys::Table +table_ODBC_COLUMNS( + DictSys::OdbcColumns, + "ODBC$COLUMNS", + column_ODBC_COLUMNS, + arraySize(column_ODBC_COLUMNS) +); + +// primarykeys + +static DictSys::Column +column_ODBC_PRIMARYKEYS[] = { + DictSys::Column( + 1, + "TABLE_CAT", + false, + SqlType(SqlType::Varchar, MAX_SCHEMA_NAME_LENGTH, true) + ), + DictSys::Column( + 2, + "TABLE_SCHEM", + false, + SqlType(SqlType::Varchar, MAX_SCHEMA_NAME_LENGTH, true) + ), + DictSys::Column( + 3, + "TABLE_NAME", + false, + SqlType(SqlType::Varchar, MAX_TAB_NAME_SIZE, false) + ), + DictSys::Column( + 4, + "COLUMN_NAME", + false, + SqlType(SqlType::Varchar, MAX_ATTR_NAME_SIZE, false) + ), + DictSys::Column( + 5, + "KEY_SEQ", + false, + SqlType(SqlType::Integer, false) + ), + DictSys::Column( + 6, + "PK_NAME", + false, + SqlType(SqlType::Varchar, MAX_ATTR_NAME_SIZE, true) + ) +}; + +static DictSys::Table +table_ODBC_PRIMARYKEYS( + DictSys::OdbcPrimarykeys, + "ODBC$PRIMARYKEYS", + column_ODBC_PRIMARYKEYS, + arraySize(column_ODBC_PRIMARYKEYS) +); + +static DictSys::Column +column_DUAL[] = { + DictSys::Column( + 1, + "DUMMY", + false, + SqlType(SqlType::Varchar, 1, false) + ) +}; + +static DictSys::Table +table_DUAL( + DictSys::Dual, + "DUAL", + column_DUAL, + arraySize(column_DUAL) +); + +// all tables + +static const DictSys::Table* +tableList[] = { + &table_ODBC_TYPEINFO, + &table_ODBC_TABLES, + &table_ODBC_COLUMNS, + &table_ODBC_PRIMARYKEYS, + &table_DUAL +}; + +static const unsigned tableCount = arraySize(tableList); + +DictTable* +DictSys::loadTable(Ctx& ctx, DictSchema* schema, const BaseString& name) +{ + const Table* tp = 0; + for (unsigned i = 0; i < tableCount; i++) { + if (strcmp(tableList[i]->m_name, name.c_str()) == 0) { + tp = tableList[i]; + break; + } + } + if (tp == 0) + return 0; + DictTable* table = new DictTable(schema->m_connArea, tp->m_name, tp->m_columnCount); + table->sysId(tp->m_id); + schema->addTable(table); + for (unsigned position = 1; position <= tp->m_columnCount; position++) { + const Column* cp = &tp->m_columnList[position - 1]; + ctx_assert(cp->m_position == position); + const SqlType& sqlType = cp->m_sqlType; + DictColumn* column = new DictColumn(table->m_connArea, cp->m_name, sqlType); + table->setColumn(position, column); + column->m_key = cp->m_key; + if (column->m_key) + table->m_keys.push_back(column); + } + ctx_log3(("%s: system table defined", name.c_str())); + return table; +} diff --git a/ndb/src/client/odbc/dictionary/DictSys.hpp b/ndb/src/client/odbc/dictionary/DictSys.hpp new file mode 100644 index 00000000000..e6fa661fd59 --- /dev/null +++ b/ndb/src/client/odbc/dictionary/DictSys.hpp @@ -0,0 +1,77 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_DICTIONARY_DictSys_hpp +#define ODBC_DICTIONARY_DictSys_hpp + +#include +#include + +class Ctx; +class DictSchema; +class DictTable; +class SqlType; + +/** + * @class DictSys + * @brief Built-in tables (replaced later by real systables) + */ +class DictSys { +public: + enum Id { + Undef = 0, + OdbcTypeinfo = 1, + OdbcTables = 2, + OdbcColumns = 3, + OdbcPrimarykeys = 4, + Dual = 5 + }; + struct Column { + Column(unsigned position, const char* name, bool key, const SqlType& sqlType); + const unsigned m_position; + const char* const m_name; + const bool m_key; + const SqlType m_sqlType; + }; + struct Table { + Table(Id id, const char* name, const Column* columnList, unsigned columnCount); + const Id m_id; + const char* m_name; + const Column* const m_columnList; + const unsigned m_columnCount; + }; + static DictTable* loadTable(Ctx& ctx, DictSchema* schema, const BaseString& name); +}; + +inline +DictSys::Column::Column(unsigned position, const char* name, bool key, const SqlType& sqlType) : + m_position(position), + m_name(name), + m_key(key), + m_sqlType(sqlType) +{ +} + +inline +DictSys::Table::Table(DictSys::Id id, const char* name, const Column* columnList, unsigned columnCount) : + m_id(id), + m_name(name), + m_columnList(columnList), + m_columnCount(columnCount) +{ +} + +#endif diff --git a/ndb/src/client/odbc/dictionary/DictTable.cpp b/ndb/src/client/odbc/dictionary/DictTable.cpp new file mode 100644 index 00000000000..4db7d3b3aec --- /dev/null +++ b/ndb/src/client/odbc/dictionary/DictTable.cpp @@ -0,0 +1,91 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include "DictSchema.hpp" +#include "DictTable.hpp" +#include "DictColumn.hpp" +#include "DictColumn.hpp" + +DictTable::~DictTable() +{ + for (Columns::iterator i = m_columns.begin(); i != m_columns.end(); i++) { + delete *i; + *i = 0; + } + for (Indexes::iterator i = m_indexes.begin(); i != m_indexes.end(); i++) { + delete *i; + *i = 0; + } +} + +DictColumn* +DictTable::findColumn(const BaseString& name) const +{ + for (unsigned i = 1; i <= getSize(); i++) { + DictColumn* column = m_columns[i]; + ctx_assert(column != 0); + if (strcmp(column->getName().c_str(), name.c_str()) == 0) + return column; + } + return 0; +} + +DictColumn* +DictTable::loadColumn(Ctx& ctx, unsigned position) +{ + Ndb* ndb = m_connArea.ndbObject(); + NdbDictionary::Dictionary* ndbDictionary = ndb->getDictionary(); + if (ndbDictionary == 0) { + ctx.pushStatus(ndb, "getDictionary"); + return 0; + } + const NdbDictionary::Table* ndbTable = ndbDictionary->getTable(m_name.c_str()); + ctx_assert(ndbTable != 0); + ctx_assert(position != 0); + NdbAttrId attrId = position - 1; + const NdbDictionary::Column* ndbColumn = ndbTable->getColumn(attrId); + ctx_assert(ndbColumn != 0); + SqlType sqlType(ctx, ndbColumn); + if (! ctx.ok()) + return 0; + DictColumn* column = new DictColumn(m_connArea, ndbColumn->getName(), sqlType); + setColumn(position, column); + column->m_key = column->m_tupleId = false; + if (ndbColumn->getPrimaryKey()) + column->m_key = true; + if (ndbColumn->getTupleKey()) + column->m_key = column->m_tupleId = true; + if (column->m_key) + m_keys.push_back(column); + // props + const char* value; + column->m_autoIncrement = false; + if (ndbColumn->getAutoIncrement()) + column->m_autoIncrement = true; + column->m_defaultValue = 0; + if ((value = ndbColumn->getDefaultValue()) != 0 && strlen(value) != 0) + column->m_defaultValue = strcpy(new char[strlen(value) + 1], value); + ctx_log4(("column %u %s keyFlag=%d idFlag=%d", position, ndbColumn->getName(), column->m_key, column->m_tupleId)); + if (column->m_tupleId) + m_tupleId = position; + if (column->m_autoIncrement) + m_autoIncrement = position; + return column; +} diff --git a/ndb/src/client/odbc/dictionary/DictTable.hpp b/ndb/src/client/odbc/dictionary/DictTable.hpp new file mode 100644 index 00000000000..5cecfff9562 --- /dev/null +++ b/ndb/src/client/odbc/dictionary/DictTable.hpp @@ -0,0 +1,192 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_DICTIONARY_DictTable_hpp +#define ODBC_DICTIONARY_DictTable_hpp + +#include +#include +#include +#include "DictColumn.hpp" +#include "DictIndex.hpp" +#include "DictSys.hpp" + +class Ctx; +class ConnArea; +class DictSchema; +class DictColumn; +class DictIndex; + +/** + * @class DictTable + * @brief Database table + */ +class DictTable { + friend class DictSchema; +public: + DictTable(const ConnArea& connArea, const BaseString& name, unsigned size); + ~DictTable(); + unsigned getSize() const; + void setParent(DictSchema* parent); + DictSchema* getParent() const; + void setColumn(unsigned i, DictColumn* column); + DictColumn* getColumn(unsigned i) const; + const BaseString& getName() const; + DictColumn* findColumn(const BaseString& name) const; + DictColumn* loadColumn(Ctx& ctx, unsigned position); + unsigned keyCount() const; + DictColumn* getKey(unsigned i) const; + unsigned tupleId() const; + unsigned autoIncrement() const; + void sysId(DictSys::Id id); + DictSys::Id sysId() const; + // indexes + void addIndex(DictIndex* index); + unsigned indexCount() const; + const DictIndex* getIndex(unsigned i) const; // indexed from 1 +protected: + friend class DictSys; + const ConnArea& m_connArea; + const BaseString m_name; + unsigned m_size; + DictSchema* m_parent; + typedef std::vector Columns; + Columns m_columns; + Columns m_keys; + unsigned m_tupleId; // tuple id column + unsigned m_autoIncrement; // autoincrement key + DictSys::Id m_sysId; // built-in system table id (if non-zero) + typedef std::vector Indexes; + Indexes m_indexes; +}; + +inline +DictTable::DictTable(const ConnArea& connArea, const BaseString& name, unsigned size) : + m_connArea(connArea), + m_name(name), + m_size(size), + m_parent(0), + m_columns(1 + size), + m_keys(1), // indexed from 1 + m_tupleId(0), + m_autoIncrement(0), + m_sysId(DictSys::Undef), + m_indexes(1) +{ +} + +inline unsigned +DictTable::getSize() const +{ + ctx_assert(m_columns.size() == 1 + m_size); + return m_size; +} + +inline void +DictTable::setParent(DictSchema* parent) +{ + m_parent = parent; +} + +inline DictSchema* +DictTable::getParent() const +{ + return m_parent; +} + +inline void +DictTable::setColumn(unsigned i, DictColumn* column) +{ + ctx_assert(1 <= i && i <= m_size); + m_columns[i] = column; + column->setPosition(i); + column->setParent(this); +} + +inline DictColumn* +DictTable::getColumn(unsigned i) const +{ + ctx_assert(1 <= i && i <= m_size); + ctx_assert(m_columns[i] != 0); + return m_columns[i]; +} + +inline const BaseString& +DictTable::getName() const +{ + return m_name; +} + +inline unsigned +DictTable::keyCount() const +{ + ctx_assert(m_keys.size() >= 1); + return m_keys.size() - 1; +} + +inline DictColumn* +DictTable::getKey(unsigned i) const +{ + ctx_assert(1 <= i && i <= m_keys.size() && m_keys[i] != 0); + return m_keys[i]; +} + +inline unsigned +DictTable::tupleId() const +{ + return m_tupleId; +} + +inline unsigned +DictTable::autoIncrement() const +{ + return m_autoIncrement; +} + +inline void +DictTable::sysId(DictSys::Id id) +{ + m_sysId = id; +} + +inline DictSys::Id +DictTable::sysId() const +{ + return m_sysId; +} + +inline void +DictTable::addIndex(DictIndex* index) +{ + m_indexes.push_back(index); + index->setTable(this); +} + +inline unsigned +DictTable::indexCount() const +{ + ctx_assert(m_indexes.size() >= 1); + return m_indexes.size() - 1; +} + +inline const DictIndex* +DictTable::getIndex(unsigned i) const +{ + ctx_assert(1 <= i && i < m_indexes.size() && m_indexes[i] != 0); + return m_indexes[i]; +} + +#endif diff --git a/ndb/src/client/odbc/dictionary/Makefile b/ndb/src/client/odbc/dictionary/Makefile new file mode 100644 index 00000000000..cdfd3b6ea0c --- /dev/null +++ b/ndb/src/client/odbc/dictionary/Makefile @@ -0,0 +1,20 @@ +include .defs.mk + +TYPE = * + +NONPIC_ARCHIVE = N + +PIC_ARCHIVE = Y + +ARCHIVE_TARGET = odbcdictionary + +SOURCES = \ + DictCatalog.cpp \ + DictSchema.cpp \ + DictTable.cpp \ + DictColumn.cpp \ + DictIndex.cpp \ + DictSys.cpp + +include ../Extra.mk +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/client/odbc/docs/class.fig b/ndb/src/client/odbc/docs/class.fig new file mode 100644 index 00000000000..38c24c1fba4 --- /dev/null +++ b/ndb/src/client/odbc/docs/class.fig @@ -0,0 +1,332 @@ +#FIG 3.2 +Landscape +Flush left +Inches +A4 +100.00 +Single +-2 +1200 2 +6 600 6600 1500 9600 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 600 6600 1500 6600 1500 7200 600 7200 600 6600 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 600 7800 1500 7800 1500 8400 600 8400 600 7800 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 600 9000 1500 9000 1500 9600 600 9600 600 9000 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 60.00 120.00 + 900 9000 900 8400 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 60.00 120.00 + 900 7800 900 7200 +4 0 0 50 0 12 12 0.0000 4 180 420 750 6825 Diag\001 +4 0 0 50 0 12 12 0.0000 4 180 420 750 8025 Diag\001 +4 0 0 50 0 12 12 0.0000 4 135 630 750 8325 Record\001 +4 0 0 50 0 12 12 0.0000 4 180 420 750 9225 Diag\001 +4 0 0 50 0 12 12 0.0000 4 135 525 750 9525 Field\001 +4 0 0 50 0 12 12 0.0000 4 120 420 750 7125 Area\001 +-6 +6 2700 6600 3600 9600 +6 2700 6600 3600 9600 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 2700 6600 3600 6600 3600 7200 2700 7200 2700 6600 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 2700 9000 3600 9000 3600 9600 2700 9600 2700 9000 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 60.00 120.00 + 3000 9000 3000 7200 +4 0 0 50 0 12 12 0.0000 4 120 420 2850 6825 Attr\001 +4 0 0 50 0 12 12 0.0000 4 120 420 2850 9225 Attr\001 +4 0 0 50 0 12 12 0.0000 4 135 525 2850 9525 Field\001 +4 0 0 50 0 12 12 0.0000 4 120 420 2850 7125 Area\001 +-6 +-6 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 3300 3900 4200 3900 4200 4500 3300 4500 3300 3900 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 3300 2700 4200 2700 4200 3300 3300 3300 3300 2700 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 3300 1500 4200 1500 4200 2100 3300 2100 3300 1500 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 3300 300 4200 300 4200 900 3300 900 3300 300 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 1800 2700 2700 2700 2700 3300 1800 3300 1800 2700 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 0 1 2 + 1 1 1.00 60.00 120.00 + 3300 1800 3000 1800 +2 1 0 1 0 7 50 0 -1 0.000 0 0 7 0 1 2 + 1 1 1.00 60.00 120.00 + 3300 3000 3000 3000 +2 1 0 1 0 7 50 0 -1 0.000 0 0 7 0 1 2 + 1 1 1.00 60.00 120.00 + 3300 4200 3000 4200 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 1 2 + 1 1 1.00 60.00 120.00 + 1 1 1.00 60.00 120.00 + 4200 4200 4800 4200 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 60.00 120.00 + 3600 3900 3600 3300 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 60.00 120.00 + 3600 2700 3600 2100 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 60.00 120.00 + 3600 1500 3600 900 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 4800 5100 5700 5100 5700 5700 4800 5700 4800 5100 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 4800 2700 5700 2700 5700 3300 4800 3300 4800 2700 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 4800 3900 5700 3900 5700 4500 4800 4500 4800 3900 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 1 2 + 1 1 1.00 60.00 120.00 + 1 1 1.00 60.00 120.00 + 5100 6600 5100 5700 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 6 + 1 1 1.00 60.00 120.00 + 5100 5100 5100 4800 4500 4800 4500 3600 3900 3600 3900 3300 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 3 + 1 1 1.00 60.00 120.00 + 3600 4500 3600 5400 4800 5400 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 4800 6600 5700 6600 5700 7200 4800 7200 4800 6600 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 4800 7800 5700 7800 5700 8400 4800 8400 4800 7800 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 4800 9000 5700 9000 5700 9600 4800 9600 4800 9000 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 60.00 120.00 + 5100 9000 5100 8400 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 60.00 120.00 + 5100 7800 5100 7200 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 1 2 + 1 1 1.00 60.00 120.00 + 1 1 1.00 60.00 120.00 + 4200 3000 4800 3000 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 6900 2700 7800 2700 7800 3300 6900 3300 6900 2700 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 6900 1500 7800 1500 7800 2100 6900 2100 6900 1500 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 3 + 0 0 1.00 60.00 120.00 + 7200 3300 7200 4050 5700 4050 +2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 3 + 0 0 1.00 60.00 120.00 + 11700 3300 11700 4350 5700 4350 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 5100 3900 5100 3300 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 8400 300 9300 300 9300 900 8400 900 8400 300 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 5100 2700 5100 900 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 0 0 2 + 3000 6600 3000 1800 +2 2 0 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 6900 5100 7800 5100 7800 6000 6900 6000 6900 5100 +2 2 0 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 8400 5100 9300 5100 9300 6000 8400 6000 8400 5100 +2 2 0 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 9900 5100 10800 5100 10800 6000 9900 6000 9900 5100 +2 2 0 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 11400 5100 12300 5100 12300 6000 11400 6000 11400 5100 +2 1 1 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 7800 5550 8400 5550 +2 1 1 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 9300 5550 9900 5550 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 7500 5100 7500 3300 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 10500 5100 10500 3300 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 12000 5100 12000 3300 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 9900 2700 10800 2700 10800 3300 9900 3300 9900 2700 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 11400 2700 12300 2700 12300 3300 11400 3300 11400 2700 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 11400 1500 12300 1500 12300 2100 11400 2100 11400 1500 +2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 + 9900 1500 10800 1500 10800 2100 9900 2100 9900 1500 +2 2 0 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 6900 6600 7800 6600 7800 7200 6900 7200 6900 6600 +2 2 0 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 6900 7800 7800 7800 7800 8400 6900 8400 6900 7800 +2 2 0 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 8400 6600 9300 6600 9300 7200 8400 7200 8400 6600 +2 2 0 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 8400 7800 9300 7800 9300 8400 8400 8400 8400 7800 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 4 + 0 0 1.00 60.00 120.00 + 5700 3000 6300 3000 6300 6900 6900 6900 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 4 + 0 0 1.00 60.00 120.00 + 5700 4200 6000 4200 6000 8100 6900 8100 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 8400 6900 7800 6900 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 8400 8100 7800 8100 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 9900 6900 9300 6900 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 9900 8100 9300 8100 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 11400 6900 10800 6900 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 11400 8100 10800 8100 +2 2 0 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 11400 6600 12300 6600 12300 7200 11400 7200 11400 6600 +2 2 0 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 11400 7800 12300 7800 12300 8400 11400 8400 11400 7800 +2 2 0 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 9900 6600 10800 6600 10800 7200 9900 7200 9900 6600 +2 2 0 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 9900 7800 10800 7800 10800 8400 9900 8400 9900 7800 +2 2 0 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 8400 2700 9300 2700 9300 3300 8400 3300 8400 2700 +2 2 0 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 8400 1500 9300 1500 9300 2100 8400 2100 8400 1500 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 9000 5100 9000 3300 +2 1 1 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 7800 3000 8400 3000 +2 1 1 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 9300 3000 9900 3000 +2 1 1 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 7800 1800 8400 1800 +2 1 1 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 9300 1800 9900 1800 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 11400 3000 10800 3000 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 11400 1800 10800 1800 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 11400 5550 10800 5550 +2 4 0 2 0 7 50 0 -1 6.000 0 0 7 0 0 5 + 5700 900 5700 300 4800 300 4800 900 5700 900 +2 2 1 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 12900 6600 13800 6600 13800 7200 12900 7200 12900 6600 +2 2 1 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 12900 5100 13800 5100 13800 5700 12900 5700 12900 5100 +2 1 1 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 13200 7800 13200 7200 +2 1 1 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 13200 6600 13200 5700 +2 2 1 1 0 7 50 0 -1 4.000 0 0 -1 0 0 5 + 12900 7800 13800 7800 13800 8400 12900 8400 12900 7800 +2 1 1 1 0 7 50 0 -1 4.000 0 0 -1 1 0 3 + 0 0 1.00 60.00 120.00 + 13200 5100 13200 1800 12300 1800 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 1 4 + 0 0 1.00 60.00 120.00 + 0 0 1.00 60.00 120.00 + 5700 7050 6600 7050 6600 7875 6900 7875 +4 0 0 50 0 12 12 0.0000 4 135 630 3375 525 Handle\001 +4 0 0 50 0 12 12 0.0000 4 135 630 3375 1725 Handle\001 +4 0 0 50 0 12 12 0.0000 4 135 630 3375 2925 Handle\001 +4 0 0 50 0 12 12 0.0000 4 135 630 3375 4125 Handle\001 +4 0 0 50 0 12 12 0.0000 4 120 420 3450 825 Root\001 +4 0 0 50 0 12 12 0.0000 4 120 315 3450 2025 Env\001 +4 0 0 50 0 12 12 0.0000 4 135 315 3450 3225 Dbc\001 +4 0 0 50 0 12 12 0.0000 4 120 420 3450 4425 Stmt\001 +4 0 0 50 0 12 12 0.0000 4 135 630 1875 2925 Handle\001 +4 0 0 50 0 12 12 0.0000 4 120 420 1950 3225 Base\001 +4 0 0 50 0 12 12 0.0000 4 135 630 4875 5325 Handle\001 +4 0 0 50 0 12 12 0.0000 4 120 420 4950 5625 Desc\001 +4 0 0 50 0 12 12 0.0000 4 120 420 4875 3225 Area\001 +4 0 0 50 0 12 12 0.0000 4 120 420 4875 2925 Conn\001 +4 0 0 50 0 12 12 0.0000 4 120 420 4875 4425 Area\001 +4 0 0 50 0 12 12 0.0000 4 120 420 4875 4125 Stmt\001 +4 0 0 50 0 12 12 0.0000 4 120 420 4950 6825 Desc\001 +4 0 0 50 0 12 12 0.0000 4 120 420 4950 8025 Desc\001 +4 0 0 50 0 12 12 0.0000 4 135 630 4950 8325 Record\001 +4 0 0 50 0 12 12 0.0000 4 120 420 4950 9225 Desc\001 +4 0 0 50 0 12 12 0.0000 4 120 420 4950 7125 Area\001 +4 0 0 50 0 12 12 0.0000 4 135 525 4950 9525 Field\001 +4 0 0 50 0 12 12 0.0000 4 135 735 3675 5925 ird ard\001 +4 0 0 50 0 12 12 0.0000 4 180 735 3675 5625 ipd apd\001 +4 0 0 50 0 12 12 0.0000 4 135 420 6975 2925 Plan\001 +4 0 0 50 0 12 12 0.0000 4 120 420 6975 3225 root\001 +4 0 0 50 0 12 12 0.0000 4 135 420 6975 1725 Plan\001 +4 0 0 50 0 12 12 0.0000 4 120 420 6975 2025 Tree\001 +4 0 0 50 0 12 12 0.0000 4 120 420 8475 525 Base\001 +4 0 0 50 0 12 12 0.0000 4 120 420 8475 825 Tree\001 +4 0 0 50 0 12 12 0.0000 4 120 315 5025 675 NDB\001 +4 0 0 50 0 14 14 0.0000 4 195 1755 300 525 Class Diagram\001 +4 0 0 50 0 12 12 0.0000 4 135 420 6975 5325 Plan\001 +4 0 0 50 0 12 12 0.0000 4 135 630 6975 5625 delete\001 +4 0 0 50 0 12 12 0.0000 4 135 840 6975 5925 searched\001 +4 0 0 50 0 12 12 0.0000 4 135 420 8475 5325 Plan\001 +4 0 0 50 0 12 12 0.0000 4 135 630 8475 5625 delete\001 +4 0 0 50 0 12 12 0.0000 4 135 420 8475 5925 full\001 +4 0 0 50 0 12 12 0.0000 4 135 420 9975 5325 Code\001 +4 0 0 50 0 12 12 0.0000 4 135 630 9975 5625 delete\001 +4 0 0 50 0 12 12 0.0000 4 135 420 9975 5925 full\001 +4 0 0 50 0 12 12 0.0000 4 120 315 11475 5325 Run\001 +4 0 0 50 0 12 12 0.0000 4 135 630 11475 5625 delete\001 +4 0 0 50 0 12 12 0.0000 4 135 420 11475 5925 full\001 +4 0 0 50 0 12 12 0.0000 4 120 420 9975 3225 root\001 +4 0 0 50 0 12 12 0.0000 4 120 315 11475 2925 Run\001 +4 0 0 50 0 12 12 0.0000 4 120 420 11475 3225 root\001 +4 0 0 50 0 12 12 0.0000 4 120 315 11475 1725 Run\001 +4 0 0 50 0 12 12 0.0000 4 120 420 11475 2025 Tree\001 +4 0 0 50 0 12 12 0.0000 4 135 420 9975 1725 Code\001 +4 0 0 50 0 12 12 0.0000 4 120 420 9975 2025 Tree\001 +4 0 0 50 0 12 12 0.0000 4 135 420 9975 2925 Code\001 +4 0 0 50 0 12 12 0.0000 4 120 420 6975 6825 Conn\001 +4 0 0 50 0 12 12 0.0000 4 180 735 6975 7125 Catalog\001 +4 0 0 50 0 12 12 0.0000 4 120 420 6975 8025 Stmt\001 +4 0 0 50 0 12 12 0.0000 4 180 735 6975 8325 Catalog\001 +4 0 0 50 0 12 12 0.0000 4 120 420 8475 6825 Conn\001 +4 0 0 50 0 12 12 0.0000 4 120 420 8475 8025 Stmt\001 +4 0 0 50 0 12 12 0.0000 4 135 630 8475 7125 Schema\001 +4 0 0 50 0 12 12 0.0000 4 135 630 8475 8325 Schema\001 +4 0 0 50 0 12 12 0.0000 4 120 420 11475 6825 Conn\001 +4 0 0 50 0 12 12 0.0000 4 120 420 11475 8025 Stmt\001 +4 0 0 50 0 12 12 0.0000 4 135 630 11475 7125 Column\001 +4 0 0 50 0 12 12 0.0000 4 135 525 11475 8325 Field\001 +4 0 0 50 0 12 12 0.0000 4 120 420 9975 6825 Conn\001 +4 0 0 50 0 12 12 0.0000 4 120 420 9975 8025 Stmt\001 +4 0 0 50 0 12 12 0.0000 4 135 525 9975 7125 Table\001 +4 0 0 50 0 12 12 0.0000 4 120 315 9975 8325 Row\001 +4 0 0 50 0 12 12 0.0000 4 135 420 8475 1725 Plan\001 +4 0 0 50 0 12 12 0.0000 4 120 420 8475 2025 Tree\001 +4 0 0 50 0 12 12 0.0000 4 135 420 8475 2925 Plan\001 +4 0 0 50 0 12 12 0.0000 4 120 420 8475 3225 root\001 +4 0 0 50 0 14 11 0.0000 4 180 840 675 825 (prelim)\001 +4 0 0 50 0 12 12 0.0000 4 180 525 6375 1350 input\001 +4 0 0 50 0 12 12 0.0000 4 180 840 7725 1350 optimize\001 +4 0 0 50 0 12 12 0.0000 4 165 630 9375 1350 output\001 +4 0 0 50 0 12 12 0.0000 4 120 735 10650 1350 execute\001 +4 0 0 50 0 12 12 0.0000 4 135 525 12075 1350 fetch\001 +4 0 0 50 0 12 12 0.0000 4 135 630 13050 5325 Result\001 +4 0 0 50 0 12 12 0.0000 4 120 315 13050 5625 Set\001 +4 0 0 50 0 12 12 0.0000 4 135 630 13050 6825 Result\001 +4 0 0 50 0 12 12 0.0000 4 120 315 13125 7125 Row\001 +4 0 0 50 0 12 12 0.0000 4 135 630 13050 8025 Result\001 +4 0 0 50 0 12 12 0.0000 4 135 525 13050 8325 Field\001 diff --git a/ndb/src/client/odbc/docs/descfield.pl b/ndb/src/client/odbc/docs/descfield.pl new file mode 100644 index 00000000000..80fef22f303 --- /dev/null +++ b/ndb/src/client/odbc/docs/descfield.pl @@ -0,0 +1,1482 @@ +# usage perl Desc.data +# prints template for DescSpec.cpp +use strict; +my $order = 0; + +# XXX do it later + +# +# odbcsqlsetdescfield.htm +# +my $descSpec = { +# +# +# +# SQLSetDescField +# +# +# +# +# +# +#
+#
+# +# +# +# +#
+# ODBC Programmer's Reference +#
+#
+#
+#
+# +#

SQLSetDescField

+# +#

Conformance

+# +#

Version Introduced: ODBC 3.0
+# Standards Compliance: ISO 92

+# +#

Summary

+# +#

SQLSetDescField sets the value of a single field of a descriptor record.

+# +#

Syntax

+# +# 
SQLRETURN SQLSetDescField(
+#	     SQLHDESC     DescriptorHandle,
+#	     SQLSMALLINT     RecNumber,
+#	     SQLSMALLINT     FieldIdentifier,
+#	     SQLPOINTER     ValuePtr,
+#	     SQLINTEGER     BufferLength);
+# +#

Arguments +# +#

+#
DescriptorHandle
+# +#
[Input]
+# Descriptor handle.
+# +#
RecNumber
+# +#
[Input]
+# Indicates the descriptor record containing the field that the application seeks to set. Descriptor records are numbered from 0, with record number 0 being the bookmark record. The RecNumber argument is ignored for header fields.
+# +#
FieldIdentifier
+# +#
[Input]
+# Indicates the field of the descriptor whose value is to be set. For more information, see "FieldIdentifier Argument" in the "Comments" section.
+# +#
ValuePtr
+# +#
[Input]
+# Pointer to a buffer containing the descriptor information, or a 4-byte value. The data type depends on the value of FieldIdentifier. If ValuePtr is a 4-byte value, either all four of the bytes are used or just two of the four are used, depending on the value of the FieldIdentifier argument.
+# +#
BufferLength
+# +#
[Input]
+# If FieldIdentifier is an ODBC-defined field and ValuePtr points to a character string or a binary buffer, this argument should be the length of *ValuePtr. If FieldIdentifier is an ODBC-defined field and ValuePtr is an integer, BufferLength is ignored. +# +#

If FieldIdentifier is a driver-defined field, the application indicates the nature of the field to the Driver Manager by setting the BufferLength argument. BufferLength can have the following values: +# +# +#

    +#
  • If ValuePtr is a pointer to a character string, then BufferLength is the length of the string or SQL_NTS.
    • +# +#
  • If ValuePtr is a pointer to a binary buffer, then the application places the result of the SQL_LEN_BINARY_ATTR(length) macro in BufferLength. This places a negative value in BufferLength.
    • +# +#
  • If ValuePtr is a pointer to a value other than a character string or a binary string, then BufferLength should have the value SQL_IS_POINTER.
    • +# +#
  • If ValuePtr contains a fixed-length value, then BufferLength is either SQL_IS_INTEGER, SQL_IS_UINTEGER, SQL_IS_SMALLINT, or SQL_IS_USMALLINT, as appropriate.
    • +#
+#
+#
+# +#

Returns

+# +#

SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_ERROR, or SQL_INVALID_HANDLE.

+# +#

Diagnostics

+# +#

When SQLSetDescField returns SQL_ERROR or SQL_SUCCESS_WITH_INFO, an associated SQLSTATE value can be obtained by calling SQLGetDiagRec with a HandleType of SQL_HANDLE_DESC and a Handle of DescriptorHandle. The following table lists the SQLSTATE values commonly returned by SQLSetDescField and explains each one in the context of this function; the notation "(DM)" precedes the descriptions of SQLSTATEs returned by the Driver Manager. The return code associated with each SQLSTATE value is SQL_ERROR, unless noted otherwise.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
SQLSTATEErrorDescription
01000General warningDriver-specific informational message. (Function returns SQL_SUCCESS_WITH_INFO.)
01S02Option value changedThe driver did not support the value specified in *ValuePtr (if ValuePtr was a pointer) or the value in ValuePtr (if ValuePtr was a 4-byte value), or *ValuePtr was invalid because of implementation working conditions, so the driver substituted a similar value. (Function returns SQL_SUCCESS_WITH_INFO.)
07009Invalid descriptor indexThe FieldIdentifier argument was a record field, the RecNumber argument was 0, and the DescriptorHandle argument referred to an IPD handle. +#

The RecNumber argument was less than 0, and the DescriptorHandle argument referred to an ARD or an APD.

+# +#

The RecNumber argument was greater than the maximum number of columns or parameters that the data source can support, and the DescriptorHandle argument referred to an APD or ARD.

+# +#

(DM) The FieldIdentifier argument was SQL_DESC_COUNT, and *ValuePtr argument was less than 0.

+# +#

The RecNumber argument was equal to 0, and the DescriptorHandle argument referred to an implicitly allocated APD. (This error does not occur with an explicitly allocated application descriptor, because it is not known whether an explicitly allocated application descriptor is an APD or ARD until execute time.)

+#
08S01Communication link failureThe communication link between the driver and the data source to which the driver was connected failed before the function completed processing.
22001String data, right
+# truncated		The FieldIdentifier argument was SQL_DESC_NAME, and the BufferLength argument was a value larger than SQL_MAX_IDENTIFIER_LEN.
HY000General errorAn error occurred for which there was no specific SQLSTATE and for which no implementation-specific SQLSTATE was defined. The error message returned by SQLGetDiagRec in the *MessageText buffer describes the error and its cause.
HY001Memory allocation
+# error		The driver was unable to allocate memory required to support execution or completion of the function.
HY010Function sequence error(DM) The DescriptorHandle was associated with a StatementHandle for which an asynchronously executing function (not this one) was called and was still executing when this function was called. +#

(DM) SQLExecute, SQLExecDirect, SQLBulkOperations, or SQLSetPos was called for the StatementHandle with which the DescriptorHandle was associated and returned SQL_NEED_DATA. This function was called before data was sent for all data-at-execution parameters or columns.

+#
HY013Memory management errorThe function call could not be processed because the underlying memory objects could not be accessed, possibly because of low memory conditions.
HY016Cannot modify an implementation row descriptorThe DescriptorHandle argument was associated with an IRD, and the FieldIdentifier argument was not SQL_DESC_ARRAY_STATUS_PTR or SQL_DESC_ROWS_PROCESSED_PTR.
HY021Inconsistent descriptor informationThe SQL_DESC_TYPE and SQL_DESC_DATETIME_INTERVAL_CODE fields do not form a valid ODBC SQL type or a valid driver-specific SQL type (for IPDs) or a valid ODBC C type (for APDs or ARDs). +#

Descriptor information checked during a consistency check was not consistent. (See "Consistency Check" in SQLSetDescRec.)

+#
HY090Invalid string or buffer length(DM) *ValuePtr is a character string, and BufferLength was less than zero but was not equal to SQL_NTS. +#

(DM) The driver was an ODBC 2.x driver, the descriptor was an ARD, the ColumnNumber argument was set to 0, and the value specified for the argument BufferLength was not equal to 4.

+#
HY091Invalid descriptor field identifierThe value specified for the FieldIdentifier argument was not an ODBC-defined field and was not an implementation-defined value. +#

The FieldIdentifier argument was invalid for the DescriptorHandle argument.

+# +#

The FieldIdentifier argument was a read-only, ODBC-defined field.

+#
HY092Invalid attribute/option identifierThe value in *ValuePtr was not valid for the FieldIdentifier argument. +#

The FieldIdentifier argument was SQL_DESC_UNNAMED, and ValuePtr was SQL_NAMED.

+#
HY105Invalid parameter type(DM) The value specified for the SQL_DESC_PARAMETER_TYPE field was invalid. (For more information, see the "InputOutputType Argument" section in SQLBindParameter.)
HYT01Connection timeout expiredThe connection timeout period expired before the data source responded to the request. The connection timeout period is set through SQLSetConnectAttr, SQL_ATTR_CONNECTION_TIMEOUT.
IM001Driver does not support this function(DM) The driver associated with the DescriptorHandle does not support the function.
+# +#

Comments

+# +#

An application can call SQLSetDescField to set any descriptor field one at a time. One call to SQLSetDescField sets a single field in a single descriptor. This function can be called to set any field in any descriptor type, provided the field can be set. (See the table later in this section.)

+# +#

Note   If a call to SQLSetDescField fails, the contents of the descriptor record identified by the RecNumber argument are undefined.

+# +#

Other functions can be called to set multiple descriptor fields with a single call of the function. The SQLSetDescRec function sets a variety of fields that affect the data type and buffer bound to a column or parameter (the SQL_DESC_TYPE, SQL_DESC_DATETIME_INTERVAL_CODE, SQL_DESC_OCTET_LENGTH, SQL_DESC_PRECISION, SQL_DESC_SCALE, SQL_DESC_DATA_PTR, SQL_DESC_OCTET_LENGTH_PTR, and SQL_DESC_INDICATOR_PTR fields). SQLBindCol or SQLBindParameter can be used to make a complete specification for the binding of a column or parameter. These functions set a specific group of descriptor fields with one function call.

+# +#

SQLSetDescField can be called to change the binding buffers by adding an offset to the binding pointers (SQL_DESC_DATA_PTR, SQL_DESC_INDICATOR_PTR, or SQL_DESC_OCTET_LENGTH_PTR). This changes the binding buffers without calling SQLBindCol or SQLBindParameter, which allows an application to change SQL_DESC_DATA_PTR without changing other fields, such as SQL_DESC_DATA_TYPE.

+# +#

If an application calls SQLSetDescField to set any field other than SQL_DESC_COUNT or the deferred fields SQL_DESC_DATA_PTR, SQL_DESC_OCTET_LENGTH_PTR, or SQL_DESC_INDICATOR_PTR, the record becomes unbound.

+# +#

Descriptor header fields are set by calling SQLSetDescField with the appropriate FieldIdentifier. Many header fields are also statement attributes, so they can also be set by a call to SQLSetStmtAttr. This allows applications to set a descriptor field without first obtaining a descriptor handle. When SQLSetDescField is called to set a header field, the RecNumber argument is ignored.

+# +#

A RecNumber of 0 is used to set bookmark fields.

+# +#

Note   The statement attribute SQL_ATTR_USE_BOOKMARKS should always be set before calling SQLSetDescField to set bookmark fields. While this is not mandatory, it is strongly recommended.

+# +#

Sequence of Setting Descriptor Fields

+# +#

When setting descriptor fields by calling SQLSetDescField, the application must follow a specific sequence: +# +#

    +#
  1. The application must first set the SQL_DESC_TYPE, SQL_DESC_CONCISE_TYPE, or SQL_DESC_DATETIME_INTERVAL_CODE field.
    2. +# +#
  2. After one of these fields has been set, the application can set an attribute of a data type, and the driver sets data type attribute fields to the appropriate default values for the data type. Automatic defaulting of type attribute fields ensures that the descriptor is always ready to use once the application has specified a data type. If the application explicitly sets a data type attribute, it is overriding the default attribute.
    3. +# +#
  3. After one of the fields listed in step 1 has been set, and data type attributes have been set, the application can set SQL_DESC_DATA_PTR. This prompts a consistency check of descriptor fields. If the application changes the data type or attributes after setting the SQL_DESC_DATA_PTR field, the driver sets SQL_DESC_DATA_PTR to a null pointer, unbinding the record. This forces the application to complete the proper steps in sequence, before the descriptor record is usable.
    4. +#
+# +#

Initialization of Descriptor Fields

+# +#

When a descriptor is allocated, the fields in the descriptor can be initialized to a default value, be initialized without a default value, or be undefined for the type of descriptor. The following tables indicate the initialization of each field for each type of descriptor, with "D" indicating that the field is initialized with a default, and "ND" indicating that the field is initialized without a default. If a number is shown, the default value of the field is that number. The tables also indicate whether a field is read/write (R/W) or read-only (R).

+# +#

The fields of an IRD have a default value only after the statement has been prepared or executed and the IRD has been populated, not when the statement handle or descriptor has been allocated. Until the IRD has been populated, any attempt to gain access to a field of an IRD will return an error.

+# +#

Some descriptor fields are defined for one or more, but not all, of the descriptor types (ARDs and IRDs, and APDs and IPDs). When a field is undefined for a type of descriptor, it is not needed by any of the functions that use that descriptor.

+# +#

The fields that can be accessed by SQLGetDescField cannot necessarily be set by SQLSetDescField. Fields that can be set by SQLSetDescField are listed in the following tables.

+# +#

The initialization of header fields is outlined in the table that follows.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
Header field nameTypeR/WDefault
SQL_DESC_ALLOC_TYPESQLSMALLINTARD: R
+# APD: R
+# IRD: R
+# IPD: R 		ARD: SQL_DESC_ALLOC_AUTO for implicit or SQL_DESC_ALLOC_USER for explicit +#

APD: SQL_DESC_ALLOC_AUTO for implicit or SQL_DESC_ALLOC_USER for explicit

+# +#

IRD: SQL_DESC_ALLOC_AUTO

+# +#

IPD: SQL_DESC_ALLOC_AUTO

+#
SQL_DESC_ARRAY_SIZESQLUINTEGERARD: R/W
+# APD: R/W
+# IRD: Unused
+# IPD: Unused		ARD:[1]
+# APD:[1]
+# IRD: Unused
+# IPD: Unused
SQL_DESC_ARRAY_STATUS_PTRSQLUSMALLINT*ARD: R/W
+# APD: R/W
+# IRD: R/W
+# IPD: R/W		ARD: Null ptr
+# APD: Null ptr
+# IRD: Null ptr
+# IPD: Null ptr
SQL_DESC_BIND_OFFSET_PTRSQLINTEGER*ARD: R/W
+# APD: R/W
+# IRD: Unused
+# IPD: Unused		ARD: Null ptr
+# APD: Null ptr
+# IRD: Unused
+# IPD: Unused
SQL_DESC_BIND_TYPESQLINTEGERARD: R/W
+# APD: R/W
+# IRD: Unused
+# IPD: Unused		ARD: SQL_BIND_BY_COLUMN +#

APD: SQL_BIND_BY_COLUMN

+# +#

IRD: Unused

+# +#

IPD: Unused

+#
SQL_DESC_COUNTSQLSMALLINTARD: R/W
+# APD: R/W
+# IRD: R
+# IPD: R/W		ARD: 0
+# APD: 0
+# IRD: D
+# IPD: 0
SQL_DESC_ROWS_PROCESSED_PTRSQLUINTEGER*ARD: Unused
+# APD: Unused
+# IRD: R/W
+# IPD: R/W		ARD: Unused
+# APD: Unused
+# IRD: Null ptr
+# IPD: Null ptr
+# +#

[1]   These fields are defined only when the IPD is automatically populated by the driver. If not, they are undefined. If an application attempts to set these fields, SQLSTATE HY091 (Invalid descriptor field identifier) will be returned.

+#

The initialization of record fields is as shown in the following table.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
Record field nameTypeR/WDefault
SQL_DESC_AUTO_UNIQUE_VALUESQLINTEGERARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: Unused		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: Unused
SQL_DESC_BASE_COLUMN_NAMESQLCHAR *ARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: Unused		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: Unused
SQL_DESC_BASE_TABLE_NAMESQLCHAR *ARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: Unused		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: Unused
SQL_DESC_CASE_SENSITIVESQLINTEGERARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: R		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: D[1]
SQL_DESC_CATALOG_NAMESQLCHAR *ARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: Unused		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: Unused
SQL_DESC_CONCISE_TYPESQLSMALLINTARD: R/W
+# APD: R/W
+# IRD: R
+# IPD: R/W		ARD: SQL_C_
+# DEFAULT
+# APD: SQL_C_
+# DEFAULT
+# IRD: D
+# IPD: ND
SQL_DESC_DATA_PTRSQLPOINTERARD: R/W
+# APD: R/W
+# IRD: Unused
+# IPD: Unused		ARD: Null ptr
+# APD: Null ptr
+# IRD: Unused
+# IPD: Unused[2]
SQL_DESC_DATETIME_INTERVAL_CODESQLSMALLINTARD: R/W
+# APD: R/W
+# IRD: R
+# IPD: R/W		ARD: ND
+# APD: ND
+# IRD: D
+# IPD: ND
SQL_DESC_DATETIME_INTERVAL_PRECISIONSQLINTEGERARD: R/W
+# APD: R/W
+# IRD: R
+# IPD: R/W		ARD: ND
+# APD: ND
+# IRD: D
+# IPD: ND
SQL_DESC_DISPLAY_SIZESQLINTEGERARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: Unused		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: Unused
SQL_DESC_FIXED_PREC_SCALESQLSMALLINTARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: R		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: D[1]
SQL_DESC_INDICATOR_PTRSQLINTEGER *ARD: R/W
+# APD: R/W
+# IRD: Unused
+# IPD: Unused		ARD: Null ptr
+# APD: Null ptr
+# IRD: Unused
+# IPD: Unused
SQL_DESC_LABELSQLCHAR *ARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: Unused		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: Unused
SQL_DESC_LENGTHSQLUINTEGERARD: R/W
+# APD: R/W
+# IRD: R
+# IPD: R/W		ARD: ND
+# APD: ND
+# IRD: D
+# IPD: ND
SQL_DESC_LITERAL_PREFIXSQLCHAR *ARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: Unused		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: Unused
SQL_DESC_LITERAL_SUFFIXSQLCHAR *ARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: Unused		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: Unused
SQL_DESC_LOCAL_TYPE_NAMESQLCHAR *ARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: R		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: D[1]
SQL_DESC_NAMESQLCHAR *ARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: R/W		ARD: ND
+# APD: ND
+# IRD: D
+# IPD: ND
SQL_DESC_NULLABLESQLSMALLINTARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: R		ARD: ND
+# APD: ND
+# IRD: D
+# IPD: ND
SQL_DESC_NUM_PREC_RADIXSQLINTEGERARD: R/W
+# APD: R/W
+# IRD: R
+# IPD: R/W		ARD: ND
+# APD: ND
+# IRD: D
+# IPD: ND
SQL_DESC_OCTET_LENGTHSQLINTEGERARD: R/W
+# APD: R/W
+# IRD: R
+# IPD: R/W		ARD: ND
+# APD: ND
+# IRD: D
+# IPD: ND
SQL_DESC_OCTET_LENGTH_PTRSQLINTEGER *ARD: R/W
+# APD: R/W
+# IRD: Unused
+# IPD: Unused		ARD: Null ptr
+# APD: Null ptr
+# IRD: Unused
+# IPD: Unused
SQL_DESC_PARAMETER_TYPESQLSMALLINTARD: Unused
+# APD: Unused
+# IRD: Unused
+# IPD: R/W		ARD: Unused
+# APD: Unused
+# IRD: Unused
+# IPD: D=SQL_PARAM_INPUT
SQL_DESC_PRECISIONSQLSMALLINTARD: R/W
+# APD: R/W
+# IRD: R
+# IPD: R/W		ARD: ND
+# APD: ND
+# IRD: D
+# IPD: ND
SQL_DESC_ROWVERSQLSMALLINTARD: Unused +#

APD: Unused

+# +#

IRD: R

+# +#

IPD: R

+# 		ARD: Unused +#

APD: Unused

+# +#

IRD: ND

+# +#

IPD: ND

+#
SQL_DESC_SCALESQLSMALLINTARD: R/W
+# APD: R/W
+# IRD: R
+# IPD: R/W		ARD: ND
+# APD: ND
+# IRD: D
+# IPD: ND
SQL_DESC_SCHEMA_NAMESQLCHAR *ARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: Unused		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: Unused
SQL_DESC_SEARCHABLESQLSMALLINTARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: Unused		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: Unused
SQL_DESC_TABLE_NAMESQLCHAR *ARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: Unused		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: Unused
SQL_DESC_TYPESQLSMALLINTARD: R/W
+# APD: R/W
+# IRD: R
+# IPD: R/W		ARD: SQL_C_DEFAULT
+# APD: SQL_C_DEFAULT
+# IRD: D
+# IPD: ND
SQL_DESC_TYPE_NAMESQLCHAR *ARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: R		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: D[1]
SQL_DESC_UNNAMEDSQLSMALLINTARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: R/W		ARD: ND
+# APD: ND
+# IRD: D
+# IPD: ND
SQL_DESC_UNSIGNEDSQLSMALLINTARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: R		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: D[1]
SQL_DESC_UPDATABLESQLSMALLINTARD: Unused
+# APD: Unused
+# IRD: R
+# IPD: Unused		ARD: Unused
+# APD: Unused
+# IRD: D
+# IPD: Unused
+# +#

[1]   These fields are defined only when the IPD is automatically populated by the driver. If not, they are undefined. If an application attempts to set these fields, SQLSTATE HY091 (Invalid descriptor field identifier) will be returned.

+#

[2]   The SQL_DESC_DATA_PTR field in the IPD can be set to force a consistency check. In a subsequent call to SQLGetDescField or SQLGetDescRec, the driver is not required to return the value that SQL_DESC_DATA_PTR was set to.

+#

FieldIdentifier Argument

+# +#

The FieldIdentifier argument indicates the descriptor field to be set. A descriptor contains the descriptor header, consisting of the header fields described in the next section, "Header Fields," and zero or more descriptor records, consisting of the record fields described in the section following the "Header Fields" section.

+# +#

Header Fields

+# +#

Each descriptor has a header consisting of the following fields: +# +#

+#
SQL_DESC_ALLOC_TYPE [All]
+# +#
This read-only SQLSMALLINT header field specifies whether the descriptor was allocated automatically by the driver or explicitly by the application. The application can obtain, but not modify, this field. The field is set to SQL_DESC_ALLOC_AUTO by the driver if the descriptor was automatically allocated by the driver. It is set to SQL_DESC_ALLOC_USER by the driver if the descriptor was explicitly allocated by the application.
+# +#
SQL_DESC_ARRAY_SIZE [Application descriptors]
+# +#
In ARDs, this SQLUINTEGER header field specifies the number of rows in the rowset. This is the number of rows to be returned by a call to SQLFetch or SQLFetchScroll or to be operated on by a call to SQLBulkOperations or SQLSetPos. +# +#

In APDs, this SQLUINTEGER header field specifies the number of values for each parameter. +# +# +#

The default value of this field is 1. If SQL_DESC_ARRAY_SIZE is greater than 1, SQL_DESC_DATA_PTR, SQL_DESC_INDICATOR_PTR, and SQL_DESC_OCTET_LENGTH_PTR of the APD or ARD point to arrays. The cardinality of each array is equal to the value of this field. +# +# +#

This field in the ARD can also be set by calling SQLSetStmtAttr with the SQL_ATTR_ROW_ARRAY_SIZE attribute. This field in the APD can also be set by calling SQLSetStmtAttr with the SQL_ATTR_PARAMSET_SIZE attribute. +#

+# +#
SQL_DESC_ARRAY_STATUS_PTR [All]
+# +#
For each descriptor type, this SQLUSMALLINT * header field points to an array of SQLUSMALLINT values. These arrays are named as follows: row status array (IRD), parameter status array (IPD), row operation array (ARD), and parameter operation array (APD). +# +#

In the IRD, this header field points to a row status array containing status values after a call to SQLBulkOperations, SQLFetch, SQLFetchScroll, or SQLSetPos. The array has as many elements as there are rows in the rowset. The application must allocate an array of SQLUSMALLINTs and set this field to point to the array. The field is set to a null pointer by default. The driver will populate the array—unless the SQL_DESC_ARRAY_STATUS_PTR field is set to a null pointer, in which case no status values are generated and the array is not populated. +# +# +#

Caution   Driver behavior is undefined if the application sets the elements of the row status array pointed to by the SQL_DESC_ARRAY_STATUS_PTR field of the IRD. +# +# +#

The array is initially populated by a call to SQLBulkOperations, SQLFetch, SQLFetchScroll, or SQLSetPos. If the call did not return SQL_SUCCESS or SQL_SUCCESS_WITH_INFO, the contents of the array pointed to by this field are undefined. The elements in the array can contain the following values: +# +# +#

    +#
  • SQL_ROW_SUCCESS: The row was successfully fetched and has not changed since it was last fetched.
    • +# +#
  • SQL_ROW_SUCCESS_WITH_INFO: The row was successfully fetched and has not changed since it was last fetched. However, a warning was returned about the row.
    • +# +#
  • SQL_ROW_ERROR: An error occurred while fetching the row.
    • +# +#
  • SQL_ROW_UPDATED: The row was successfully fetched and has been updated since it was last fetched. If the row is fetched again, its status is SQL_ROW_SUCCESS.
    • +# +#
  • SQL_ROW_DELETED: The row has been deleted since it was last fetched.
    • +# +#
  • SQL_ROW_ADDED: The row was inserted by SQLBulkOperations. If the row is fetched again, its status is SQL_ROW_SUCCESS.
    • +# +#
  • SQL_ROW_NOROW: The rowset overlapped the end of the result set, and no row was returned that corresponded to this element of the row status array.
    • +#
+# +# +#

This field in the IRD can also be set by calling SQLSetStmtAttr with the SQL_ATTR_ROW_STATUS_PTR attribute. +# +# +#

The SQL_DESC_ARRAY_STATUS_PTR field of the IRD is valid only after SQL_SUCCESS or SQL_SUCCESS_WITH_INFO has been returned. If the return code is not one of these, the location pointed to by SQL_DESC_ROWS_PROCESSED_PTR is undefined. +# +# +#

In the IPD, this header field points to a parameter status array containing status information for each set of parameter values after a call to SQLExecute or SQLExecDirect. If the call to SQLExecute or SQLExecDirect did not return SQL_SUCCESS or SQL_SUCCESS_WITH_INFO, the contents of the array pointed to by this field are undefined. The application must allocate an array of SQLUSMALLINTs and set this field to point to the array. The driver will populate the array—unless the SQL_DESC_ARRAY_STATUS_PTR field is set to a null pointer, in which case no status values are generated and the array is not populated. The elements in the array can contain the following values: +# +# +#

    +#
  • SQL_PARAM_SUCCESS: The SQL statement was successfully executed for this set of parameters.
    • +# +#
  • SQL_PARAM_SUCCESS_WITH_INFO: The SQL statement was successfully executed for this set of parameters; however, warning information is available in the diagnostics data structure.
    • +# +#
  • SQL_PARAM_ERROR: An error occurred in processing this set of parameters. Additional error information is available in the diagnostics data structure.
    • +# +#
  • SQL_PARAM_UNUSED: This parameter set was unused, possibly due to the fact that some previous parameter set caused an error that aborted further processing, or because SQL_PARAM_IGNORE was set for that set of parameters in the array specified by the SQL_DESC_ARRAY_STATUS_PTR field of the APD.
    • +# +#
  • SQL_PARAM_DIAG_UNAVAILABLE: Diagnostic information is not available. An example of this is when the driver treats arrays of parameters as a monolithic unit and so does not generate this level of error information.
    • +#
+# +# +#

This field in the IPD can also be set by calling SQLSetStmtAttr with the SQL_ATTR_PARAM_STATUS_PTR attribute. +# +# +#

In the ARD, this header field points to a row operation array of values that can be set by the application to indicate whether this row is to be ignored for SQLSetPos operations. The elements in the array can contain the following values: +# +# +#

    +#
  • SQL_ROW_PROCEED: The row is included in the bulk operation using SQLSetPos. (This setting does not guarantee that the operation will occur on the row. If the row has the status SQL_ROW_ERROR in the IRD row status array, the driver might not be able to perform the operation in the row.)
    • +# +#
  • SQL_ROW_IGNORE: The row is excluded from the bulk operation using SQLSetPos.
    • +#
+# +# +#

If no elements of the array are set, all rows are included in the bulk operation. If the value in the SQL_DESC_ARRAY_STATUS_PTR field of the ARD is a null pointer, all rows are included in the bulk operation; the interpretation is the same as if the pointer pointed to a valid array and all elements of the array were SQL_ROW_PROCEED. If an element in the array is set to SQL_ROW_IGNORE, the value in the row status array for the ignored row is not changed. +# +# +#

This field in the ARD can also be set by calling SQLSetStmtAttr with the SQL_ATTR_ROW_OPERATION_PTR attribute. +# +# +#

In the APD, this header field points to a parameter operation array of values that can be set by the application to indicate whether this set of parameters is to be ignored when SQLExecute or SQLExecDirect is called. The elements in the array can contain the following values: +# +# +#

    +#
  • SQL_PARAM_PROCEED: The set of parameters is included in the SQLExecute or SQLExecDirect call.
    • +# +#
  • SQL_PARAM_IGNORE: The set of parameters is excluded from the SQLExecute or SQLExecDirect call.
    • +#
+# +# +#

If no elements of the array are set, all sets of parameters in the array are used in the SQLExecute or SQLExecDirect calls. If the value in the SQL_DESC_ARRAY_STATUS_PTR field of the APD is a null pointer, all sets of parameters are used; the interpretation is the same as if the pointer pointed to a valid array and all elements of the array were SQL_PARAM_PROCEED. +# +# +#

This field in the APD can also be set by calling SQLSetStmtAttr with the SQL_ATTR_PARAM_OPERATION_PTR attribute. +#

+# +#
SQL_DESC_BIND_OFFSET_PTR [Application descriptors]
+# +#
This SQLINTEGER * header field points to the binding offset. It is set to a null pointer by default. If this field is not a null pointer, the driver dereferences the pointer and adds the dereferenced value to each of the deferred fields that has a non-null value in the descriptor record (SQL_DESC_DATA_PTR, SQL_DESC_INDICATOR_PTR, and SQL_DESC_OCTET_LENGTH_PTR) at fetch time and uses the new pointer values when binding. +# +#

The binding offset is always added directly to the values in the SQL_DESC_DATA_PTR, SQL_DESC_INDICATOR_PTR, and SQL_DESC_OCTET_LENGTH_PTR fields. If the offset is changed to a different value, the new value is still added directly to the value in each descriptor field. The new offset is not added to the field value plus any earlier offset. +# +# +#

This field is a deferred field: It is not used at the time it is set but is used at a later time by the driver when it needs to determine addresses for data buffers. +# +# +#

This field in the ARD can also be set by calling SQLSetStmtAttr with the SQL_ATTR_ROW_BIND_OFFSET_PTR attribute. This field in the ARD can also be set by calling SQLSetStmtAttr with the SQL_ATTR_PARAM_BIND_OFFSET_PTR attribute. +# +# +#

For more information, see the description of row-wise binding in SQLFetchScroll and SQLBindParameter. +#

+# +#
SQL_DESC_BIND_TYPE [Application descriptors]
+# +#
This SQLUINTEGER header field sets the binding orientation to be used for binding either columns or parameters. +# +#

In ARDs, this field specifies the binding orientation when SQLFetchScroll or SQLFetch is called on the associated statement handle. +# +# +#

To select column-wise binding for columns, this field is set to SQL_BIND_BY_COLUMN (the default). +# +# +#

This field in the ARD can also be set by calling SQLSetStmtAttr with the SQL_ATTR_ROW_BIND_TYPE Attribute. +# +# +#

In APDs, this field specifies the binding orientation to be used for dynamic parameters. +# +# +#

To select column-wise binding for parameters, this field is set to SQL_BIND_BY_COLUMN (the default). +# +# +#

This field in the APD can also be set by calling SQLSetStmtAttr with the SQL_ATTR_PARAM_BIND_TYPE Attribute. +#

+# +#
SQL_DESC_COUNT [All]
+# +#
This SQLSMALLINT header field specifies the 1-based index of the highest-numbered record that contains data. When the driver sets the data structure for the descriptor, it must also set the SQL_DESC_COUNT field to show how many records are significant. When an application allocates an instance of this data structure, it does not have to specify how many records to reserve room for. As the application specifies the contents of the records, the driver takes any required action to ensure that the descriptor handle refers to a data structure of the adequate size. +# +#

SQL_DESC_COUNT is not a count of all data columns that are bound (if the field is in an ARD) or of all parameters that are bound (if the field is in an APD), but the number of the highest-numbered record. If the highest-numbered column or parameter is unbound, then SQL_DESC_COUNT is changed to the number of the next highest-numbered column or parameter. If a column or a parameter with a number that is less than the number of the highest-numbered column is unbound (by calling SQLBindCol with the TargetValuePtr argument set to a null pointer, or SQLBindParameter with the ParameterValuePtr argument set to a null pointer), SQL_DESC_COUNT is not changed. If additional columns or parameters are bound with numbers greater than the highest-numbered record that contains data, the driver automatically increases the value in the SQL_DESC_COUNT field. If all columns are unbound by calling SQLFreeStmt with the SQL_UNBIND option, the SQL_DESC_COUNT fields in the ARD and IRD are set to 0. If SQLFreeStmt is called with the SQL_RESET_PARAMS option, the SQL_DESC_COUNT fields in the APD and IPD are set to 0. +# +# +#

The value in SQL_DESC_COUNT can be set explicitly by an application by calling SQLSetDescField. If the value in SQL_DESC_COUNT is explicitly decreased, all records with numbers greater than the new value in SQL_DESC_COUNT are effectively removed. If the value in SQL_DESC_COUNT is explicitly set to 0 and the field is in an ARD, all data buffers except a bound bookmark column are released. +# +# +#

The record count in this field of an ARD does not include a bound bookmark column. The only way to unbind a bookmark column is to set the SQL_DESC_DATA_PTR field to a null pointer. +#

+# +#
SQL_DESC_ROWS_PROCESSED_PTR [Implementation descriptors]
+# +#
In an IRD, this SQLUINTEGER * header field points to a buffer containing the number of rows fetched after a call to SQLFetch or SQLFetchScroll, or the number of rows affected in a bulk operation performed by a call to SQLBulkOperations or SQLSetPos, including error rows. +# +#

In an IPD, this SQLUINTEGER * header field points to a buffer containing the number of sets of parameters that have been processed, including error sets. No number will be returned if this is a null pointer. +# +# +#

SQL_DESC_ROWS_PROCESSED_PTR is valid only after SQL_SUCCESS or SQL_SUCCESS_WITH_INFO has been returned after a call to SQLFetch or SQLFetchScroll (for an IRD field) or SQLExecute, SQLExecDirect, or SQLParamData (for an IPD field). If the call that fills in the buffer pointed to by this field does not return SQL_SUCCESS or SQL_SUCCESS_WITH_INFO, the contents of the buffer are undefined, unless it returns SQL_NO_DATA, in which case the value in the buffer is set to 0. +# +# +#

This field in the ARD can also be set by calling SQLSetStmtAttr with the SQL_ATTR_ROWS_FETCHED_PTR attribute. This field in the APD can also be set by calling SQLSetStmtAttr with the SQL_ATTR_PARAMS_PROCESSED_PTR attribute. +# +# +#

The buffer pointed to by this field is allocated by the application. It is a deferred output buffer that is set by the driver. It is set to a null pointer by default. +#

+#
+# +#

Record Fields

+# +#

Each descriptor contains one or more records consisting of fields that define either column data or dynamic parameters, depending on the type of descriptor. Each record is a complete definition of a single column or parameter. +# +#

+#
SQL_DESC_AUTO_UNIQUE_VALUE [IRDs]
+# +#
This read-only SQLINTEGER record field contains SQL_TRUE if the column is an auto-incrementing column, or SQL_FALSE if the column is not an auto-incrementing column. This field is read-only, but the underlying auto-incrementing column is not necessarily read-only.
+# +#
SQL_DESC_BASE_COLUMN_NAME [IRDs]
+# +#
This read-only SQLCHAR * record field contains the base column name for the result set column. If a base column name does not exist (as in the case of columns that are expressions), this variable contains an empty string.
+# +#
SQL_DESC_BASE_TABLE_NAME [IRDs]
+# +#
This read-only SQLCHAR * record field contains the base table name for the result set column. If a base table name cannot be defined or is not applicable, this variable contains an empty string.
+# +#
SQL_DESC_CASE_SENSITIVE [Implementation descriptors]
+# +#
This read-only SQLINTEGER record field contains SQL_TRUE if the column or parameter is treated as case-sensitive for collations and comparisons, or SQL_FALSE if the column is not treated as case-sensitive for collations and comparisons or if it is a noncharacter column.
+# +#
SQL_DESC_CATALOG_NAME [IRDs]
+# +#
This read-only SQLCHAR * record field contains the catalog for the base table that contains the column. The return value is driver-dependent if the column is an expression or if the column is part of a view. If the data source does not support catalogs or the catalog cannot be determined, this variable contains an empty string.
+# +#
SQL_DESC_CONCISE_TYPE [All]
+# +#
This SQLSMALLINT header field specifies the concise data type for all data types, including the datetime and interval data types. +# +#

The values in the SQL_DESC_CONCISE_TYPE, SQL_DESC_TYPE, and SQL_DESC_DATETIME_INTERVAL_CODE fields are interdependent. Each time one of the fields is set, the other must also be set. SQL_DESC_CONCISE_TYPE can be set by a call to SQLBindCol or SQLBindParameter, or SQLSetDescField. SQL_DESC_TYPE can be set by a call to SQLSetDescField or SQLSetDescRec. +# +# +#

If SQL_DESC_CONCISE_TYPE is set to a concise data type other than an interval or datetime data type, the SQL_DESC_TYPE field is set to the same value and the SQL_DESC_DATETIME_INTERVAL_CODE field is set to 0. +# +# +#

If SQL_DESC_CONCISE_TYPE is set to the concise datetime or interval data type, the SQL_DESC_TYPE field is set to the corresponding verbose type (SQL_DATETIME or SQL_INTERVAL) and the SQL_DESC_DATETIME_INTERVAL_CODE field is set to the appropriate subcode. +#

+# +#
SQL_DESC_DATA_PTR [Application descriptors and IPDs]
+# +#
This SQLPOINTER record field points to a variable that will contain the parameter value (for APDs) or the column value (for ARDs). This field is a deferred field. It is not used at the time it is set but is used at a later time by the driver to retrieve data. +# +#

The column specified by the SQL_DESC_DATA_PTR field of the ARD is unbound if the TargetValuePtr argument in a call to SQLBindCol is a null pointer or if the SQL_DESC_DATA_PTR field in the ARD is set by a call to SQLSetDescField or SQLSetDescRec to a null pointer. Other fields are not affected if the SQL_DESC_DATA_PTR field is set to a null pointer. +# +# +#

If the call to SQLFetch or SQLFetchScroll that fills in the buffer pointed to by this field did not return SQL_SUCCESS or SQL_SUCCESS_WITH_INFO, the contents of the buffer are undefined. +# +# +#

Whenever the SQL_DESC_DATA_PTR field of an APD, ARD, or IPD is set, the driver checks that the value in the SQL_DESC_TYPE field contains one of the valid ODBC C data types or a driver-specific data type, and that all other fields affecting the data types are consistent. Prompting a consistency check is the only use of the SQL_DESC_DATA_PTR field of an IPD. Specifically, if an application sets the SQL_DESC_DATA_PTR field of an IPD and later calls SQLGetDescField on this field, it is not necessarily returned the value that it had set. For more information, see "Consistency Checks" in SQLSetDescRec. +#

+# +#
SQL_DESC_DATETIME_INTERVAL_CODE [All]
+# +#
This SQLSMALLINT record field contains the subcode for the specific datetime or interval data type when the SQL_DESC_TYPE field is SQL_DATETIME or SQL_INTERVAL. This is true for both SQL and C data types. The code consists of the data type name with "CODE" substituted for either "TYPE" or "C_TYPE" (for datetime types), or "CODE" substituted for "INTERVAL" or "C_INTERVAL" (for interval types). +# +#

If SQL_DESC_TYPE and SQL_DESC_CONCISE_TYPE in an application descriptor are set to SQL_C_DEFAULT and the descriptor is not associated with a statement handle, the contents of SQL_DESC_DATETIME_INTERVAL_CODE are undefined. +# +# +#

This field can be set for the datetime data types listed in the following table. +# +# +#

+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
Datetime typesDATETIME_INTERVAL_CODE
SQL_TYPE_DATE/SQL_C_TYPE_DATESQL_CODE_DATE
SQL_TYPE_TIME/SQL_C_TYPE_TIMESQL_CODE_TIME
SQL_TYPE_TIMESTAMP/
+# SQL_C_TYPE_TIMESTAMP		SQL_CODE_TIMESTAMP
+# +# +# +#

This field can be set for the interval data types listed in the following table. +# +# +#

+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
Interval typeDATETIME_INTERVAL_CODE
SQL_INTERVAL_DAY/
+# SQL_C_INTERVAL_DAY		SQL_CODE_DAY
SQL_INTERVAL_DAY_TO_HOUR/
+# SQL_C_INTERVAL_DAY_TO_HOUR		SQL_CODE_DAY_TO_HOUR
SQL_INTERVAL_DAY_TO_MINUTE/
+# SQL_C_INTERVAL_DAY_TO_MINUTE		SQL_CODE_DAY_TO_MINUTE
SQL_INTERVAL_DAY_TO_SECOND/
+# SQL_C_INTERVAL_DAY_TO_SECOND		SQL_CODE_DAY_TO_SECOND
SQL_INTERVAL_HOUR/
+# SQL_C_INTERVAL_HOUR		SQL_CODE_HOUR
SQL_INTERVAL_HOUR_TO_MINUTE/
+# SQL_C_INTERVAL_HOUR_TO_MINUTE		SQL_CODE_HOUR_TO_MINUTE
SQL_INTERVAL_HOUR_TO_SECOND/
+# SQL_C_INTERVAL_HOUR_TO_SECOND		SQL_CODE_HOUR_TO_SECOND
SQL_INTERVAL_MINUTE/
+# SQL_C_INTERVAL_MINUTE		SQL_CODE_MINUTE
SQL_INTERVAL_MINUTE_TO_SECOND/
+# SQL_C_INTERVAL_MINUTE_TO_SECOND		SQL_CODE_MINUTE_TO_SECOND
SQL_INTERVAL_MONTH/
+# SQL_C_INTERVAL_MONTH		SQL_CODE_MONTH
SQL_INTERVAL_SECOND/
+# SQL_C_INTERVAL_SECOND		SQL_CODE_SECOND
SQL_INTERVAL_YEAR/
+# SQL_C_INTERVAL_YEAR		SQL_CODE_YEAR
SQL_INTERVAL_YEAR_TO_MONTH/
+# SQL_C_INTERVAL_YEAR_TO_MONTH		SQL_CODE_YEAR_TO_MONTH
+# +# +# +#

For more information about the data intervals and this field, see "Data Type Identifiers and Descriptors" in Appendix D: Data Types. +#

+# +#
SQL_DESC_DATETIME_INTERVAL_PRECISION [All]
+# +#
This SQLINTEGER record field contains the interval leading precision if the SQL_DESC_TYPE field is SQL_INTERVAL. When the SQL_DESC_DATETIME_INTERVAL_CODE field is set to an interval data type, this field is set to the default interval leading precision.
+# +#
SQL_DESC_DISPLAY_SIZE [IRDs]
+# +#
This read-only SQLINTEGER record field contains the maximum number of characters required to display the data from the column.
+# +#
SQL_DESC_FIXED_PREC_SCALE [Implementation descriptors]
+# +#
This read-only SQLSMALLINT record field is set to SQL_TRUE if the column is an exact numeric column and has a fixed precision and nonzero scale, or to SQL_FALSE if the column is not an exact numeric column with a fixed precision and scale.
+# +#
SQL_DESC_INDICATOR_PTR [Application descriptors]
+# +#
In ARDs, this SQLINTEGER * record field points to the indicator variable. This variable contains SQL_NULL_DATA if the column value is a NULL. For APDs, the indicator variable is set to SQL_NULL_DATA to specify NULL dynamic arguments. Otherwise, the variable is zero (unless the values in SQL_DESC_INDICATOR_PTR and SQL_DESC_OCTET_LENGTH_PTR are the same pointer). +# +#

If the SQL_DESC_INDICATOR_PTR field in an ARD is a null pointer, the driver is prevented from returning information about whether the column is NULL or not. If the column is NULL and SQL_DESC_INDICATOR_PTR is a null pointer, SQLSTATE 22002 (Indicator variable required but not supplied) is returned when the driver attempts to populate the buffer after a call to SQLFetch or SQLFetchScroll. If the call to SQLFetch or SQLFetchScroll did not return SQL_SUCCESS or SQL_SUCCESS_WITH_INFO, the contents of the buffer are undefined. +# +# +#

The SQL_DESC_INDICATOR_PTR field determines whether the field pointed to by SQL_DESC_OCTET_LENGTH_PTR is set. If the data value for a column is NULL, the driver sets the indicator variable to SQL_NULL_DATA. The field pointed to by SQL_DESC_OCTET_LENGTH_PTR is then not set. If a NULL value is not encountered during the fetch, the buffer pointed to by SQL_DESC_INDICATOR_PTR is set to zero and the buffer pointed to by SQL_DESC_OCTET_LENGTH_PTR is set to the length of the data. +# +# +#

If the SQL_DESC_INDICATOR_PTR field in an APD is a null pointer, the application cannot use this descriptor record to specify NULL arguments. +# +# +#

This field is a deferred field: It is not used at the time it is set but is used at a later time by the driver to indicate nullability (for ARDs) or to determine nullability (for APDs). +#

+# +#
SQL_DESC_LABEL [IRDs]
+# +#
This read-only SQLCHAR * record field contains the column label or title. If the column does not have a label, this variable contains the column name. If the column is unnamed and unlabeled, this variable contains an empty string.
+# +#
SQL_DESC_LENGTH [All]
+# +#
This SQLUINTEGER record field is either the maximum or actual length of a character string in characters or a binary data type in bytes. It is the maximum length for a fixed-length data type, or the actual length for a variable-length data type. Its value always excludes the null-termination character that ends the character string. For values whose type is SQL_TYPE_DATE, SQL_TYPE_TIME, SQL_TYPE_TIMESTAMP, or one of the SQL interval data types, this field has the length in characters of the character string representation of the datetime or interval value. +# +#

The value in this field may be different from the value for "length" as defined in ODBC 2.x. For more information, see Appendix D: Data Types. +#

+# +#
SQL_DESC_LITERAL_PREFIX [IRDs]
+# +#
This read-only SQLCHAR * record field contains the character or characters that the driver recognizes as a prefix for a literal of this data type. This variable contains an empty string for a data type for which a literal prefix is not applicable.
+# +#
SQL_DESC_LITERAL_SUFFIX [IRDs]
+# +#
This read-only SQLCHAR * record field contains the character or characters that the driver recognizes as a suffix for a literal of this data type. This variable contains an empty string for a data type for which a literal suffix is not applicable.
+# +#
SQL_DESC_LOCAL_TYPE_NAME [Implementation descriptors]
+# +#
This read-only SQLCHAR * record field contains any localized (native language) name for the data type that may be different from the regular name of the data type. If there is no localized name, an empty string is returned. This field is for display purposes only.
+# +#
SQL_DESC_NAME [Implementation descriptors]
+# +#
This SQLCHAR * record field in a row descriptor contains the column alias, if it applies. If the column alias does not apply, the column name is returned. In either case, the driver sets the SQL_DESC_UNNAMED field to SQL_NAMED when it sets the SQL_DESC_NAME field. If there is no column name or a column alias, the driver returns an empty string in the SQL_DESC_NAME field and sets the SQL_DESC_UNNAMED field to SQL_UNNAMED. +# +#

An application can set the SQL_DESC_NAME field of an IPD to a parameter name or alias to specify stored procedure parameters by name. (For more information, see "Binding Parameters by Name (Named Parameters)" in Chapter 9: Executing Statements.) The SQL_DESC_NAME field of an IRD is a read-only field; SQLSTATE HY091 (Invalid descriptor field identifier) will be returned if an application attempts to set it. +# +# +#

In IPDs, this field is undefined if the driver does not support named parameters. If the driver supports named parameters and is capable of describing parameters, the parameter name is returned in this field. +#

+# +#
SQL_DESC_NULLABLE [Implementation descriptors]
+# +#
In IRDs, this read-only SQLSMALLINT record field is SQL_NULLABLE if the column can have NULL values, SQL_NO_NULLS if the column does not have NULL values, or SQL_NULLABLE_UNKNOWN if it is not known whether the column accepts NULL values. This field pertains to the result set column, not the base column. +# +#

In IPDs, this field is always set to SQL_NULLABLE because dynamic parameters are always nullable and cannot be set by an application. +#

+# +#
SQL_DESC_NUM_PREC_RADIX [All]
+# +#
This SQLINTEGER field contains a value of 2 if the data type in the SQL_DESC_TYPE field is an approximate numeric data type, because the SQL_DESC_PRECISION field contains the number of bits. This field contains a value of 10 if the data type in the SQL_DESC_TYPE field is an exact numeric data type, because the SQL_DESC_PRECISION field contains the number of decimal digits. This field is set to 0 for all non-numeric data types.
+# +#
SQL_DESC_OCTET_LENGTH [All]
+# +#
This SQLINTEGER record field contains the length, in bytes, of a character string or binary data type. For fixed-length character or binary types, this is the actual length in bytes. For variable-length character or binary types, this is the maximum length in bytes. This value always excludes space for the null-termination character for implementation descriptors and always includes space for the null-termination character for application descriptors. For application data, this field contains the size of the buffer. For APDs, this field is defined only for output or input/output parameters.
+# +#
SQL_DESC_OCTET_LENGTH_PTR [Application descriptors]
+# +#
This SQLINTEGER * record field points to a variable that will contain the total length in bytes of a dynamic argument (for parameter descriptors) or of a bound column value (for row descriptors). +# +#

For an APD, this value is ignored for all arguments except character string and binary; if this field points to SQL_NTS, the dynamic argument must be null-terminated. To indicate that a bound parameter will be a data-at-execution parameter, an application sets this field in the appropriate record of the APD to a variable that, at execute time, will contain the value SQL_DATA_AT_EXEC or the result of the SQL_LEN_DATA_AT_EXEC macro. If there is more than one such field, SQL_DESC_DATA_PTR can be set to a value uniquely identifying the parameter to help the application determine which parameter is being requested. +# +# +#

If the OCTET_LENGTH_PTR field of an ARD is a null pointer, the driver does not return length information for the column. If the SQL_DESC_OCTET_LENGTH_PTR field of an APD is a null pointer, the driver assumes that character strings and binary values are null-terminated. (Binary values should not be null-terminated but should be given a length to avoid truncation.) +# +# +#

If the call to SQLFetch or SQLFetchScroll that fills in the buffer pointed to by this field did not return SQL_SUCCESS or SQL_SUCCESS_WITH_INFO, the contents of the buffer are undefined. This field is a deferred field. It is not used at the time it is set but is used at a later time by the driver to determine or indicate the octet length of the data. +#

+# +#
SQL_DESC_PARAMETER_TYPE [IPDs]
+# +#
This SQLSMALLINT record field is set to SQL_PARAM_INPUT for an input parameter, SQL_PARAM_INPUT_OUTPUT for an input/output parameter, or SQL_PARAM_OUTPUT for an output parameter. It is set to SQL_PARAM_INPUT by default. +# +#

For an IPD, the field is set to SQL_PARAM_INPUT by default if the IPD is not automatically populated by the driver (the SQL_ATTR_ENABLE_AUTO_IPD statement attribute is SQL_FALSE). An application should set this field in the IPD for parameters that are not input parameters. +#

+# +#
SQL_DESC_PRECISION [All]
+# +#
This SQLSMALLINT record field contains the number of digits for an exact numeric type, the number of bits in the mantissa (binary precision) for an approximate numeric type, or the numbers of digits in the fractional seconds component for the SQL_TYPE_TIME, SQL_TYPE_TIMESTAMP, or SQL_INTERVAL_SECOND data type. This field is undefined for all other data types. +# +#

The value in this field may be different from the value for "precision" as defined in ODBC 2.x. For more information, see Appendix D: Data Types. +#

+# +#
SQL_DESC_ROWVER [Implementation descriptors]
+# +#
This SQLSMALLINT record field indicates whether a column is automatically modified by the DBMS when a row is updated (for example, a column of the type "timestamp" in SQL Server). The value of this record field is set to SQL_TRUE if the column is a row versioning column, and to SQL_FALSE otherwise. This column attribute is similar to calling SQLSpecialColumns with IdentifierType of SQL_ROWVER to determine whether a column is automatically updated.
+# +#
SQL_DESC_SCALE [All]
+# +#
This SQLSMALLINT record field contains the defined scale for decimal and numeric data types. The field is undefined for all other data types. +# +#

The value in this field may be different from the value for "scale" as defined in ODBC 2.x. For more information, see Appendix D: Data Types. +#

+# +#
SQL_DESC_SCHEMA_NAME [IRDs]
+# +#
This read-only SQLCHAR * record field contains the schema name of the base table that contains the column. The return value is driver-dependent if the column is an expression or if the column is part of a view. If the data source does not support schemas or the schema name cannot be determined, this variable contains an empty string.
+# +#
SQL_DESC_SEARCHABLE [IRDs]
+# +#
This read-only SQLSMALLINT record field is set to one of the following values: +# +#
    +#
  • SQL_PRED_NONE if the column cannot be used in a WHERE clause. (This is the same as the SQL_UNSEARCHABLE value in ODBC 2.x.)
    • +# +#
  • SQL_PRED_CHAR if the column can be used in a WHERE clause but only with the LIKE predicate. (This is the same as the SQL_LIKE_ONLY value in ODBC 2.x.)
    • +# +#
  • SQL_PRED_BASIC if the column can be used in a WHERE clause with all the comparison operators except LIKE. (This is the same as the SQL_EXCEPT_LIKE value in ODBC 2.x.)
    • +# +#
  • SQL_PRED_SEARCHABLE if the column can be used in a WHERE clause with any comparison operator.
    • +#
+#
+# +#
SQL_DESC_TABLE_NAME [IRDs]
+# +#
This read-only SQLCHAR * record field contains the name of the base table that contains this column. The return value is driver-dependent if the column is an expression or if the column is part of a view.
+# +#
SQL_DESC_TYPE [All]
+# +#
This SQLSMALLINT record field specifies the concise SQL or C data type for all data types except datetime and interval data types. For the datetime and interval data types, this field specifies the verbose data type, which is SQL_DATETIME or SQL_INTERVAL. +# +#

Whenever this field contains SQL_DATETIME or SQL_INTERVAL, the SQL_DESC_DATETIME_INTERVAL_CODE field must contain the appropriate subcode for the concise type. For datetime data types, SQL_DESC_TYPE contains SQL_DATETIME, and the SQL_DESC_DATETIME_INTERVAL_CODE field contains a subcode for the specific datetime data type. For interval data types, SQL_DESC_TYPE contains SQL_INTERVAL and the SQL_DESC_DATETIME_INTERVAL_CODE field contains a subcode for the specific interval data type. +# +# +#

The values in the SQL_DESC_TYPE and SQL_DESC_CONCISE_TYPE fields are interdependent. Each time one of the fields is set, the other must also be set. SQL_DESC_TYPE can be set by a call to SQLSetDescField or SQLSetDescRec. SQL_DESC_CONCISE_TYPE can be set by a call to SQLBindCol or SQLBindParameter, or SQLSetDescField. +# +# +#

If SQL_DESC_TYPE is set to a concise data type other than an interval or datetime data type, the SQL_DESC_CONCISE_TYPE field is set to the same value and the SQL_DESC_DATETIME_INTERVAL_CODE field is set to 0. +# +# +#

If SQL_DESC_TYPE is set to the verbose datetime or interval data type (SQL_DATETIME or SQL_INTERVAL) and the SQL_DESC_DATETIME_INTERVAL_CODE field is set to the appropriate subcode, the SQL_DESC_CONCISE TYPE field is set to the corresponding concise type. Trying to set SQL_DESC_TYPE to one of the concise datetime or interval types will return SQLSTATE HY021 (Inconsistent descriptor information). +# +# +#

When the SQL_DESC_TYPE field is set by a call to SQLBindCol, SQLBindParameter, or SQLSetDescField, the following fields are set to the following default values, as shown in the table below. The values of the remaining fields of the same record are undefined. +# +# +#

+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
Value of SQL_DESC_TYPEOther fields implicitly set
SQL_CHAR, SQL_VARCHAR, SQL_C_CHAR, SQL_C_VARCHARSQL_DESC_LENGTH is set to 1. SQL_DESC_PRECISION is set to 0.
SQL_DATETIMEWhen SQL_DESC_DATETIME_INTERVAL_CODE is set to SQL_CODE_DATE or SQL_CODE_TIME, SQL_DESC_PRECISION is set to 0. When it is set to SQL_DESC_TIMESTAMP, SQL_DESC_PRECISION is set to 6.
SQL_DECIMAL, SQL_NUMERIC,
+# SQL_C_NUMERIC		SQL_DESC_SCALE is set to 0. SQL_DESC_PRECISION is set to the implementation-defined precision for the respective data type.
SQL_FLOAT, SQL_C_FLOATSQL_DESC_PRECISION is set to the implementation-defined default precision for SQL_FLOAT.
SQL_INTERVALWhen SQL_DESC_DATETIME_INTERVAL_CODE is set to an interval data type, SQL_DESC_DATETIME_INTERVAL_PRECISION is set to 2 (the default interval leading precision). When the interval has a seconds component, SQL_DESC_PRECISION is set to 6 (the default interval seconds precision).
+# +# +# +#

When an application calls SQLSetDescField to set fields of a descriptor rather than calling SQLSetDescRec, the application must first declare the data type. When it does, the other fields indicated in the previous table are implicitly set. If any of the values implicitly set are unacceptable, the application can then call SQLSetDescField or SQLSetDescRec to set the unacceptable value explicitly. +#

+# +#
SQL_DESC_TYPE_NAME [Implementation descriptors]
+# +#
This read-only SQLCHAR * record field contains the data source–dependent type name (for example, "CHAR", "VARCHAR", and so on). If the data type name is unknown, this variable contains an empty string.
+# +#
SQL_DESC_UNNAMED [Implementation descriptors]
+# +#
This SQLSMALLINT record field in a row descriptor is set by the driver to either SQL_NAMED or SQL_UNNAMED when it sets the SQL_DESC_NAME field. If the SQL_DESC_NAME field contains a column alias or if the column alias does not apply, the driver sets the SQL_DESC_UNNAMED field to SQL_NAMED. If an application sets the SQL_DESC_NAME field of an IPD to a parameter name or alias, the driver sets the SQL_DESC_UNNAMED field of the IPD to SQL_NAMED. If there is no column name or a column alias, the driver sets the SQL_DESC_UNNAMED field to SQL_UNNAMED. +# +#

An application can set the SQL_DESC_UNNAMED field of an IPD to SQL_UNNAMED. A driver returns SQLSTATE HY091 (Invalid descriptor field identifier) if an application attempts to set the SQL_DESC_UNNAMED field of an IPD to SQL_NAMED. The SQL_DESC_UNNAMED field of an IRD is read-only; SQLSTATE HY091 (Invalid descriptor field identifier) will be returned if an application attempts to set it. +#

+# +#
SQL_DESC_UNSIGNED [Implementation descriptors]
+# +#
This read-only SQLSMALLINT record field is set to SQL_TRUE if the column type is unsigned or non-numeric, or SQL_FALSE if the column type is signed.
+# +#
SQL_DESC_UPDATABLE [IRDs]
+# +#
This read-only SQLSMALLINT record field is set to one of the following values: +# +#
    +#
  • SQL_ATTR_READ_ONLY if the result set column is read-only.
    • +# +#
  • SQL_ATTR_WRITE if the result set column is read-write.
    • +# +#
  • SQL_ATTR_READWRITE_UNKNOWN if it is not known whether the result set column is updatable or not.
    • +#
+# +# +#

SQL_DESC_UPDATABLE describes the updatability of the column in the result set, not the column in the base table. The updatability of the column in the base table on which this result set column is based may be different than the value in this field. Whether a column is updatable can be based on the data type, user privileges, and the definition of the result set itself. If it is unclear whether a column is updatable, SQL_ATTR_READWRITE_UNKNOWN should be returned. +#

+#
+# +#

Consistency Checks

+# +#

A consistency check is performed by the driver automatically whenever an application passes in a value for the SQL_DESC_DATA_PTR field of the ARD, APD, or IPD. If any of the fields is inconsistent with other fields, SQLSetDescField will return SQLSTATE HY021 (Inconsistent descriptor information). For more information, see "Consistency Check" in SQLSetDescRec.

+# +#

Related Functions

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
For information aboutSee
Binding a columnSQLBindCol
Binding a parameterSQLBindParameter
Getting a descriptor fieldSQLGetDescField
Getting multiple descriptor fieldsSQLGetDescRec
Setting multiple descriptor fieldsSQLSetDescRec
+#

+# +#
+# +# +# +}; diff --git a/ndb/src/client/odbc/docs/diag.txt b/ndb/src/client/odbc/docs/diag.txt new file mode 100644 index 00000000000..a9a0e0f42d0 --- /dev/null +++ b/ndb/src/client/odbc/docs/diag.txt @@ -0,0 +1,48 @@ +# Header Fields + +SQL_DIAG_CURSOR_ROW_COUNT +SQLINTEGER + +SQL_DIAG_DYNAMIC_FUNCTION +SQLCHAR * + +SQL_DIAG_DYNAMIC_FUNCTION_CODE +SQLINTEGER + +SQL_DIAG_NUMBER +SQLINTEGER + +SQL_DIAG_RETURNCODE +SQLRETURN + +SQL_DIAG_ROW_COUNT +SQLINTEGER + +# Record Fields + +SQL_DIAG_CLASS_ORIGIN +SQLCHAR * + +SQL_DIAG_COLUMN_NUMBER +SQLINTEGER + +SQL_DIAG_CONNECTION_NAME +SQLCHAR * + +SQL_DIAG_MESSAGE_TEXT +SQLCHAR * + +SQL_DIAG_NATIVE +SQLINTEGER + +SQL_DIAG_ROW_NUMBER +SQLINTEGER + +SQL_DIAG_SERVER_NAME +SQLCHAR * + +SQL_DIAG_SQLSTATE +SQLCHAR * + +SQL_DIAG_SUBCLASS_ORIGIN +SQLCHAR * diff --git a/ndb/src/client/odbc/docs/getinfo.pl b/ndb/src/client/odbc/docs/getinfo.pl new file mode 100644 index 00000000000..34e26b47bab --- /dev/null +++ b/ndb/src/client/odbc/docs/getinfo.pl @@ -0,0 +1,3676 @@ +# +use strict; + +# +# odbcsqlgetinfo.htm +# +my $info = { +# +# +# +# SQLGetInfo +# +# +# +# +# +# +#
+#
+# +# +# +# +#
+# ODBC Programmer's Reference +#
+#
+#
+#
+# +#

SQLGetInfo

+# +#

Conformance

+# +#

Version Introduced: ODBC 1.0
+# Standards Compliance: ISO 92

+# +#

Summary

+# +#

SQLGetInfo returns general information about the driver and data source associated with a connection.

+# +#

Syntax

+# +# 
SQLRETURN SQLGetInfo(
+#	     SQLHDBC     ConnectionHandle,
+#	     SQLUSMALLINT     InfoType,
+#	     SQLPOINTER     InfoValuePtr,
+#	     SQLSMALLINT     BufferLength,
+#	     SQLSMALLINT *     StringLengthPtr);
+# +#

Arguments +# +#

+#
ConnectionHandle
+# +#
[Input]
+# Connection handle.
+# +#
InfoType
+# +#
[Input]
+# Type of information.
+# +#
InfoValuePtr
+# +#
[Output]
+# Pointer to a buffer in which to return the information. Depending on the InfoType requested, the information returned will be one of the following: a null-terminated character string, an SQLUSMALLINT value, an SQLUINTEGER bitmask, an SQLUINTEGER flag, or a SQLUINTEGER binary value. +# +#

If the InfoType argument is SQL_DRIVER_HDESC or SQL_DRIVER_HSTMT, the InfoValuePtr argument is both input and output. (See the SQL_DRIVER_HDESC or SQL_DRIVER_HSTMT descriptors later in this function description for more information.) +#

+# +#
BufferLength
+# +#
[Input]
+# Length of the *InfoValuePtr buffer. If the value in *InfoValuePtr is not a character string or if InfoValuePtr is a null pointer, the BufferLength argument is ignored. The driver assumes that the size of *InfoValuePtr is SQLUSMALLINT or SQLUINTEGER, based on the InfoType. If *InfoValuePtr is a Unicode string (when calling SQLGetInfoW), the BufferLength argument must be an even number; if not, SQLSTATE HY090 (Invalid string or buffer length) is returned.
+# +#
StringLengthPtr
+# +#
[Output]
+# Pointer to a buffer in which to return the total number of bytes (excluding the null-termination character for character data) available to return in *InfoValuePtr. +# +#

For character data, if the number of bytes available to return is greater than or equal to BufferLength, the information in *InfoValuePtr is truncated to BufferLength bytes minus the length of a null-termination character and is null-terminated by the driver. +# +# +#

For all other types of data, the value of BufferLength is ignored and the driver assumes the size of *InfoValuePtr is SQLUSMALLINT or SQLUINTEGER, depending on the InfoType. +#

+#
+# +#

Returns

+# +#

SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_ERROR, or SQL_INVALID_HANDLE.

+# +#

Diagnostics

+# +#

When SQLGetInfo returns either SQL_ERROR or SQL_SUCCESS_WITH_INFO, an associated SQLSTATE value can be obtained by calling SQLGetDiagRec with a HandleType of SQL_HANDLE_DBC and a Handle of ConnectionHandle. The following table lists the SQLSTATE values commonly returned by SQLGetInfo and explains each one in the context of this function; the notation "(DM)" precedes the descriptions of SQLSTATEs returned by the Driver Manager. The return code associated with each SQLSTATE value is SQL_ERROR, unless noted otherwise.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
SQLSTATEErrorDescription
01000General warningDriver-specific informational message. (Function returns SQL_SUCCESS_WITH_INFO.)
01004String data, right truncatedThe buffer *InfoValuePtr was not large enough to return all of the requested information, so the information was truncated. The length of the requested information in its untruncated form is returned in *StringLengthPtr. (Function returns SQL_SUCCESS_WITH_INFO.)
08003Connection does not exist(DM) The type of information requested in InfoType requires an open connection. Of the information types reserved by ODBC, only SQL_ODBC_VER can be returned without an open connection.
08S01Communication link failureThe communication link between the driver and the data source to which the driver was connected failed before the function completed processing.
HY000General errorAn error occurred for which there was no specific SQLSTATE and for which no implementation-specific SQLSTATE was defined. The error message returned by SQLGetDiagRec in the *MessageText buffer describes the error and its cause.
HY001Memory allocation
+# error		The driver was unable to allocate memory required to support execution or completion of the function.
HY013Memory management errorThe function call could not be processed because the underlying memory objects could not be accessed, possibly because of low memory conditions.
HY024Invalid attribute value(DM) The InfoType argument was SQL_DRIVER_HSTMT, and the value pointed to by InfoValuePtr was not a valid statement handle. +#

(DM) The InfoType argument was SQL_DRIVER_HDESC, and the value pointed to by InfoValuePtr was not a valid descriptor handle.

+#
HY090Invalid string or buffer length(DM) The value specified for argument BufferLength was less than 0. +#

(DM) The value specified for BufferLength was an odd number, and *InfoValuePtr was of a Unicode data type.

+#
HY096Information type out of rangeThe value specified for the argument InfoType was not valid for the version of ODBC supported by the driver.
HYC00Optional field not implementedThe value specified for the argument InfoType was a driver-specific value that is not supported by the driver.
HYT01Connection timeout expiredThe connection timeout period expired before the data source responded to the request. The connection timeout period is set through SQLSetConnectAttr, SQL_ATTR_CONNECTION_TIMEOUT.
IM001Driver does not support this function(DM) The driver corresponding to the ConnectionHandle does not support the function.
+# +#

Comments

+# +#

The currently defined information types are shown in "Information Types," later in this section; it is expected that more will be defined to take advantage of different data sources. A range of information types is reserved by ODBC; driver developers must reserve values for their own driver-specific use from X/Open. SQLGetInfo performs no Unicode conversion or thunking (see Appendix A of the ODBC Programmer's Reference) for driver-defined InfoTypes. For more information, see "Driver-Specific Data Types, Descriptor Types, Information Types, Diagnostic Types, and Attributes" in Chapter 17: Programming Considerations. The format of the information returned in *InfoValuePtr depends on the InfoType requested. SQLGetInfo will return information in one of five different formats: +# +#

    +#
  • A null-terminated character string
    • +# +#
  • An SQLUSMALLINT value
    • +# +#
  • An SQLUINTEGER bitmask
    • +# +#
  • An SQLUINTEGER value
    • +# +#
  • A SQLUINTEGER binary value
    • +#
+# +#

The format of each of the following information types is noted in the type's description. The application must cast the value returned in *InfoValuePtr accordingly. For an example of how an application could retrieve data from a SQLUINTEGER bitmask, see "Code Example."

+# +#

A driver must return a value for each of the information types defined in the tables below. If an information type does not apply to the driver or data source, the driver returns one of the values listed in the following table.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
Format of *InfoValuePtrReturned value
Character string ("Y" or "N")"N"
Character string (not "Y" or "N")Empty string
SQLUSMALLINT0
SQLUINTEGER bitmask or SQLUINTEGER binary value0L
+# +#

For example, if a data source does not support procedures, SQLGetInfo returns the values listed in the following table for the values of InfoType that are related to procedures.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
InfoTypeReturned value
SQL_PROCEDURES"N"
SQL_ACCESSIBLE_PROCEDURES"N"
SQL_MAX_PROCEDURE_NAME_LEN0
SQL_PROCEDURE_TERMEmpty string
+# +#

SQLGetInfo returns SQLSTATE HY096 (Invalid argument value) for values of InfoType that are in the range of information types reserved for use by ODBC but are not defined by the version of ODBC supported by the driver. To determine what version of ODBC a driver conforms to, an application calls SQLGetInfo with the SQL_DRIVER_ODBC_VER information type. SQLGetInfo returns SQLSTATE HYC00 (Optional feature not implemented) for values of InfoType that are in the range of information types reserved for driver-specific use but are not supported by the driver.

+# +#

All calls to SQLGetInfo require an open connection, except when the InfoType is SQL_ODBC_VER, which returns the version of the Driver Manager.

+# +#

Information Types

+# +#

This section lists the information types supported by SQLGetInfo. Information types are grouped categorically and listed alphabetically. Information types that were added or renamed for ODBC 3.x are also listed.

+# +#

Driver Information

+# +#

The following values of the InfoType argument return information about the ODBC driver, such as the number of active statements, the data source name, and the interface standards compliance level:

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
SQL_ACTIVE_ENVIRONMENTSSQL_GETDATA_EXTENSIONS
SQL_ASYNC_MODESQL_INFO_SCHEMA_VIEWS
SQL_BATCH_ROW_COUNTSQL_KEYSET_CURSOR_ATTRIBUTES1
SQL_BATCH_SUPPORTSQL_KEYSET_CURSOR_ATTRIBUTES2
SQL_DATA_SOURCE_NAMESQL_MAX_ASYNC_CONCURRENT_STATEMENTS
SQL_DRIVER_HDBCSQL_MAX_CONCURRENT_ACTIVITIES
SQL_DRIVER_HDESCSQL_MAX_DRIVER_CONNECTIONS
SQL_DRIVER_HENVSQL_ODBC_INTERFACE_CONFORMANCE
SQL_DRIVER_HLIBSQL_ODBC_STANDARD_CLI_CONFORMANCE
SQL_DRIVER_HSTMTSQL_ODBC_VER
SQL_DRIVER_NAMESQL_PARAM_ARRAY_ROW_COUNTS
SQL_DRIVER_ODBC_VERSQL_PARAM_ARRAY_SELECTS
SQL_DRIVER_VERSQL_ROW_UPDATES
SQL_DYNAMIC_CURSOR_ATTRIBUTES1SQL_SEARCH_PATTERN_ESCAPE
SQL_DYNAMIC_CURSOR_ATTRIBUTES2SQL_SERVER_NAME
SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1SQL_STATIC_CURSOR_ATTRIBUTES1
SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2SQL_STATIC_CURSOR_ATTRIBUTES2
SQL_FILE_USAGE 
+# +#

DBMS Product Information

+# +#

The following values of the InfoType argument return information about the DBMS product, such as the DBMS name and version:

+# +#

SQL_DATABASE_NAME
+# SQL_DBMS_NAME
+# SQL_DBMS_VER

+# +#

Data Source Information

+# +#

The following values of the InfoType argument return information about the data source, such as cursor characteristics and transaction capabilities:

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
SQL_ACCESSIBLE_PROCEDURESSQL_MULT_RESULT_SETS
SQL_ACCESSIBLE_TABLESSQL_MULTIPLE_ACTIVE_TXN
SQL_BOOKMARK_PERSISTENCESQL_NEED_LONG_DATA_LEN
SQL_CATALOG_TERMSQL_NULL_COLLATION
SQL_COLLATION_SEQSQL_PROCEDURE_TERM
SQL_CONCAT_NULL_BEHAVIORSQL_SCHEMA_TERM
SQL_CURSOR_COMMIT_BEHAVIORSQL_SCROLL_OPTIONS
SQL_CURSOR_ROLLBACK_BEHAVIORSQL_TABLE_TERM
SQL_CURSOR_SENSITIVITYSQL_TXN_CAPABLE
SQL_DATA_SOURCE_READ_ONLYSQL_TXN_ISOLATION_OPTION
SQL_DEFAULT_TXN_ISOLATIONSQL_USER_NAME
SQL_DESCRIBE_PARAMETER 
+# +#

Supported SQL

+# +#

The following values of the InfoType argument return information about the SQL statements supported by the data source. The SQL syntax of each feature described by these information types is the SQL-92 syntax. These information types do not exhaustively describe the entire SQL-92 grammar. Instead, they describe those parts of the grammar for which data sources commonly offer different levels of support. Specifically, most of the DDL statements in SQL-92 are covered.

+# +#

Applications should determine the general level of supported grammar from the SQL_SQL_CONFORMANCE information type and use the other information types to determine variations from the stated standards compliance level.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
SQL_AGGREGATE_FUNCTIONSSQL_DROP_TABLE
SQL_ALTER_DOMAINSQL_DROP_TRANSLATION
SQL_ALTER_SCHEMASQL_DROP_VIEW
SQL_ALTER_TABLESQL_EXPRESSIONS_IN_ORDERBY
SQL_ANSI_SQL_DATETIME_LITERALSSQL_GROUP_BY
SQL_CATALOG_LOCATION SQL_IDENTIFIER_CASE
SQL_CATALOG_NAMESQL_IDENTIFIER_QUOTE_CHAR
SQL_CATALOG_NAME_SEPARATORSQL_INDEX_KEYWORDS
SQL_CATALOG_USAGESQL_INSERT_STATEMENT
SQL_COLUMN_ALIASSQL_INTEGRITY
SQL_CORRELATION_NAMESQL_KEYWORDS
SQL_CREATE_ASSERTIONSQL_LIKE_ESCAPE_CLAUSE
SQL_CREATE_CHARACTER_SETSQL_NON_NULLABLE_COLUMNS
SQL_CREATE_COLLATIONSQL_SQL_CONFORMANCE
SQL_CREATE_DOMAINSQL_OJ_CAPABILITIES
SQL_CREATE_SCHEMASQL_ORDER_BY_COLUMNS_IN_SELECT
SQL_CREATE_TABLESQL_OUTER_JOINS
SQL_CREATE_TRANSLATIONSQL_PROCEDURES
SQL_DDL_INDEXSQL_QUOTED_IDENTIFIER_CASE
SQL_DROP_ASSERTIONSQL_SCHEMA_USAGE
SQL_DROP_CHARACTER_SETSQL_SPECIAL_CHARACTERS
SQL_DROP_COLLATIONSQL_SUBQUERIES
SQL_DROP_DOMAINSQL_UNION
SQL_DROP_SCHEMA 
+# +#

SQL Limits

+# +#

The following values of the InfoType argument return information about the limits applied to identifiers and clauses in SQL statements, such as the maximum lengths of identifiers and the maximum number of columns in a select list. Limitations can be imposed by either the driver or the data source.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
SQL_MAX_BINARY_LITERAL_LENSQL_MAX_IDENTIFIER_LEN
SQL_MAX_CATALOG_NAME_LENSQL_MAX_INDEX_SIZE
SQL_MAX_CHAR_LITERAL_LENSQL_MAX_PROCEDURE_NAME_LEN
SQL_MAX_COLUMN_NAME_LENSQL_MAX_ROW_SIZE
SQL_MAX_COLUMNS_IN_GROUP_BYSQL_MAX_ROW_SIZE_INCLUDES_LONG
SQL_MAX_COLUMNS_IN_INDEXSQL_MAX_SCHEMA_NAME_LEN
SQL_MAX_COLUMNS_IN_ORDER_BYSQL_MAX_STATEMENT_LEN
SQL_MAX_COLUMNS_IN_SELECTSQL_MAX_TABLE_NAME_LEN
SQL_MAX_COLUMNS_IN_TABLESQL_MAX_TABLES_IN_SELECT
SQL_MAX_CURSOR_NAME_LENSQL_MAX_USER_NAME_LEN
+# +#

Scalar Function Information

+# +#

The following values of the InfoType argument return information about the scalar functions supported by the data source and the driver. For more information about scalar functions, see Appendix E: Scalar Functions.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
SQL_CONVERT_FUNCTIONSSQL_TIMEDATE_ADD_INTERVALS
SQL_NUMERIC_FUNCTIONSSQL_TIMEDATE_DIFF_INTERVALS
SQL_STRING_FUNCTIONSSQL_TIMEDATE_FUNCTIONS
SQL_SYSTEM_FUNCTIONS 
+# +#

Conversion Information

+# +#

The following values of the InfoType argument return a list of the SQL data types to which the data source can convert the specified SQL data type with the CONVERT scalar function:

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
SQL_CONVERT_BIGINTSQL_CONVERT_LONGVARBINARY
SQL_CONVERT_BINARYSQL_CONVERT_LONGVARCHAR
SQL_CONVERT_BITSQL_CONVERT_NUMERIC
SQL_CONVERT_CHARSQL_CONVERT_REAL
SQL_CONVERT_DATESQL_CONVERT_SMALLINT
SQL_CONVERT_DECIMALSQL_CONVERT_TIME
SQL_CONVERT_DOUBLESQL_CONVERT_TIMESTAMP
SQL_CONVERT_FLOATSQL_CONVERT_TINYINT
SQL_CONVERT_INTEGERSQL_CONVERT_VARBINARY
SQL_CONVERT_INTERVAL_YEAR_MONTHSQL_CONVERT_VARCHAR
SQL_CONVERT_INTERVAL_DAY_TIME 
+# +#

Information Types Added for ODBC 3.x

+# +#

The following values of the InfoType argument have been added for ODBC 3.x:

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
SQL_ACTIVE_ENVIRONMENTSSQL_DROP_ASSERTION
SQL_AGGREGATE_FUNCTIONSSQL_DROP_CHARACTER_SET
SQL_ALTER_DOMAINSQL_DROP_COLLATION
SQL_ALTER_SCHEMASQL_DROP_DOMAIN
SQL_ANSI_SQL_DATETIME_LITERALSSQL_DROP_SCHEMA
SQL_ASYNC_MODESQL_DROP_TABLE
SQL_BATCH_ROW_COUNTSQL_DROP_TRANSLATION
SQL_BATCH_SUPPORTSQL_DROP_VIEW
SQL_CATALOG_NAMESQL_DYNAMIC_CURSOR_ATTRIBUTES1
SQL_COLLATION_SEQSQL_DYNAMIC_CURSOR_ATTRIBUTES2
SQL_CONVERT_INTERVAL_YEAR_MONTHSQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1
SQL_CONVERT_INTERVAL_DAY_TIMESQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2
SQL_CREATE_ASSERTIONSQL_INFO_SCHEMA_VIEWS
SQL_CREATE_CHARACTER_SETSQL_INSERT_STATEMENT
SQL_CREATE_COLLATIONSQL_KEYSET_CURSOR_ATTRIBUTES1
SQL_CREATE_DOMAINSQL_KEYSET_CURSOR_ATTRIBUTES2
SQL_CREATE_SCHEMASQL_MAX_ASYNC_CONCURRENT_STATEMENTS
SQL_CREATE_TABLESQL_MAX_IDENTIFIER_LEN
SQL_CREATE_TRANSLATIONSQL_PARAM_ARRAY_ROW_COUNTS
SQL_CURSOR_SENSITIVITYSQL_PARAM_ARRAY_SELECTS
SQL_DDL_INDEXSQL_STATIC_CURSOR_ATTRIBUTES1
SQL_DESCRIBE_PARAMETERSQL_STATIC_CURSOR_ATTRIBUTES2
SQL_DM_VERSQL_XOPEN_CLI_YEAR
SQL_DRIVER_HDESC 
+# +#

Information Types Renamed for ODBC 3.x

+# +#

The following values of the InfoType argument have been renamed for ODBC 3.x.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
ODBC 2.0 InfoTypeODBC 3.x InfoType
SQL_ACTIVE_CONNECTIONSSQL_MAX_DRIVER_CONNECTIONS
SQL_ACTIVE_STATEMENTSSQL_MAX_CONCURRENT_ACTIVITIES
SQL_MAX_OWNER_NAME_LENSQL_MAX_SCHEMA_NAME_LEN
SQL_MAX_QUALIFIER_NAME_LENSQL_MAX_CATALOG_NAME_LEN
SQL_ODBC_SQL_OPT_IEFSQL_INTEGRITY
SQL_OWNER_TERMSQL_SCHEMA_TERM
SQL_OWNER_USAGESQL_SCHEMA_USAGE
SQL_QUALIFIER_LOCATIONSQL_CATALOG_LOCATION
SQL_QUALIFIER_NAME_SEPARATORSQL_CATALOG_NAME_SEPARATOR
SQL_QUALIFIER_TERMSQL_CATALOG_TERM
SQL_QUALIFIER_USAGESQL_CATALOG_USAGE
+# +#

Information Types Deprecated in ODBC 3.x

+# +#

The following values of the InfoType argument have been deprecated in ODBC 3.x. ODBC 3.x drivers must continue to support these information types for backward compatibility with ODBC 2.x applications. (For more information on these types, see "SQLGetInfo Support" in Appendix G: Driver Guidelines for Backward Compatibility.)

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
SQL_FETCH_DIRECTIONSQL_POS_OPERATIONS
SQL_LOCK_TYPESSQL_POSITIONED_STATEMENTS
SQL_ODBC_API_CONFORMANCESQL_SCROLL_CONCURRENCY
SQL_ODBC_SQL_CONFORMANCESQL_STATIC_SENSITIVITY
+# +#

Information Type Descriptions

+# +#

The following table alphabetically lists each information type, the version of ODBC in which it was introduced, and its description.

+#
+# +# +# +# +# +# +# +# +# +# + SQL_ACCESSIBLE_PROCEDURES => { + type => q(YesNo), + }, +# +# +# +# +# + SQL_ACCESSIBLE_TABLES => { + type => q(YesNo), + }, +# +# +# +# +# + SQL_ACTIVE_ENVIRONMENTS => { + type => q(Short), + }, +# +# +# +# +# + SQL_AGGREGATE_FUNCTIONS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_ALTER_DOMAIN => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_ALTER_TABLE => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_ASYNC_MODE => { + type => q(Long), + }, +# +# +# +# +# + SQL_BATCH_ROW_COUNT => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_BATCH_SUPPORT => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_BOOKMARK_PERSISTENCE => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_CATALOG_LOCATION => { + type => q(Short), + }, +# +# +# +# +# + SQL_CATALOG_NAME => { + type => q(YesNo), + }, +# +# +# +# +# + SQL_CATALOG_NAME_SEPARATOR => { + type => q(Char), + }, +# +# +# +# +# + SQL_CATALOG_TERM => { + type => q(Char), + }, +# +# +# +# +# + SQL_CATALOG_USAGE => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_COLLATION_SEQ => { + type => q(Char), + }, +# +# +# +# +# + SQL_COLUMN_ALIAS => { + type => q(YesNo), + }, +# +# +# +# +# + SQL_CONCAT_NULL_BEHAVIOR => { + type => q(Short), + }, +# +# +# +# +# +# +# +# +# +# + SQL_CONVERT_FUNCTIONS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_CORRELATION_NAME => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_CREATE_ASSERTION => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_CREATE_CHARACTER_SET => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_CREATE_COLLATION => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_CREATE_DOMAIN => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_CREATE_SCHEMA => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_CREATE_TABLE => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_CREATE_TRANSLATION => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_CREATE_VIEW => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_CURSOR_COMMIT_BEHAVIOR => { + type => q(Short), + }, +# +# +# +# +# + SQL_CURSOR_ROLLBACK_BEHAVIOR => { + type => q(Short), + }, +# +# +# +# +# + SQL_CURSOR_SENSITIVITY => { + type => q(Long), + }, +# +# +# +# +# + SQL_DATA_SOURCE_NAME => { + type => q(Char), + }, +# +# +# +# +# + SQL_DATA_SOURCE_READ_ONLY => { + type => q(YesNo), + }, +# +# +# +# +# + SQL_DATABASE_NAME => { + type => q(Char), + }, +# +# +# +# +# + SQL_DATETIME_LITERALS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_DBMS_NAME => { + type => q(Char), + }, +# +# +# +# +# + SQL_DBMS_VER => { + type => q(Char), + }, +# +# +# +# +# + SQL_DDL_INDEX => { + type => q(Long), + }, +# +# +# +# +# + SQL_DEFAULT_TXN_ISOLATION => { + type => q(Long), + }, +# +# +# +# +# + SQL_DESCRIBE_PARAMETER => { + type => q(YesNo), + }, +# +# +# +# +# + SQL_DM_VER => { + type => q(Char), + }, +# +# +# +# +# + SQL_DRIVER_HDBC => { + type => q(Long), + }, +# +# +# +# +# + SQL_DRIVER_HDESC => { + type => q(Long), + }, +# +# +# +# +# + SQL_DRIVER_HLIB => { + type => q(Long), + }, +# +# +# +# +# + SQL_DRIVER_HSTMT => { + type => q(Long), + }, +# +# +# +# +# + SQL_DRIVER_NAME => { + type => q(Char), + }, +# +# +# +# +# + SQL_DRIVER_ODBC_VER => { + type => q(Char), + }, +# +# +# +# +# + SQL_DRIVER_VER => { + type => q(Char), + }, +# +# +# +# +# + SQL_DROP_ASSERTION => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_DROP_CHARACTER_SET => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_DROP_COLLATION => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_DROP_DOMAIN => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_DROP_SCHEMA => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_DROP_TABLE => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_DROP_TRANSLATION => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_DROP_VIEW => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_DYNAMIC_CURSOR_ATTRIBUTES1 => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_DYNAMIC_CURSOR_ATTRIBUTES2 => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_EXPRESSIONS_IN_ORDERBY => { + type => q(Char), + }, +# +# +# +# +# + SQL_FILE_USAGE => { + type => q(Short), + }, +# +# +# +# +# + SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1 => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2 => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_GETDATA_EXTENSIONS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_GROUP_BY => { + type => q(Short), + }, +# +# +# +# +# + SQL_IDENTIFIER_CASE => { + type => q(Short), + }, +# +# +# +# +# + SQL_IDENTIFIER_QUOTE_CHAR => { + type => q(Char), + }, +# +# +# +# +# + SQL_INDEX_KEYWORDS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_INFO_SCHEMA_VIEWS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_INSERT_STATEMENT => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_INTEGRITY => { + type => q(YesNo), + }, +# +# +# +# +# + SQL_KEYSET_CURSOR_ATTRIBUTES1 => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_KEYSET_CURSOR_ATTRIBUTES2 => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_KEYWORDS => { + type => q(Char), + }, +# +# +# +# +# + SQL_LIKE_ESCAPE_CLAUSE => { + type => q(YesNo), + }, +# +# +# +# +# + SQL_MAX_ASYNC_CONCURRENT_STATEMENTS => { + type => q(Long), + }, +# +# +# +# +# + SQL_MAX_BINARY_LITERAL_LEN => { + type => q(Long), + }, +# +# +# +# +# + SQL_MAX_CATALOG_NAME_LEN => { + type => q(Short), + }, +# +# +# +# +# + SQL_MAX_CHAR_LITERAL_LEN => { + type => q(Long), + }, +# +# +# +# +# + SQL_MAX_COLUMN_NAME_LEN => { + type => q(Short), + }, +# +# +# +# +# + SQL_MAX_COLUMNS_IN_GROUP_BY => { + type => q(Short), + }, +# +# +# +# +# + SQL_MAX_COLUMNS_IN_INDEX => { + type => q(Short), + }, +# +# +# +# +# + SQL_MAX_COLUMNS_IN_ORDER_BY => { + type => q(Short), + }, +# +# +# +# +# + SQL_MAX_COLUMNS_IN_SELECT => { + type => q(Short), + }, +# +# +# +# +# + SQL_MAX_COLUMNS_IN_TABLE => { + type => q(Short), + }, +# +# +# +# +# + SQL_MAX_CONCURRENT_ACTIVITIES => { + type => q(Short), + }, +# +# +# +# +# + SQL_MAX_CURSOR_NAME_LEN => { + type => q(Short), + }, +# +# +# +# +# + SQL_MAX_DRIVER_CONNECTIONS => { + type => q(Short), + }, +# +# +# +# +# + SQL_MAX_IDENTIFIER_LEN => { + type => q(Short), + }, +# +# +# +# +# + SQL_MAX_INDEX_SIZE => { + type => q(Long), + }, +# +# +# +# +# + SQL_MAX_PROCEDURE_NAME_LEN => { + type => q(Short), + }, +# +# +# +# +# + SQL_MAX_ROW_SIZE => { + type => q(Long), + }, +# +# +# +# +# + SQL_MAX_ROW_SIZE_INCLUDES_LONG => { + type => q(YesNo), + }, +# +# +# +# +# + SQL_MAX_SCHEMA_NAME_LEN => { + type => q(Short), + }, +# +# +# +# +# + SQL_MAX_STATEMENT_LEN => { + type => q(Long), + }, +# +# +# +# +# + SQL_MAX_TABLE_NAME_LEN => { + type => q(Short), + }, +# +# +# +# +# + SQL_MAX_TABLES_IN_SELECT => { + type => q(Short), + }, +# +# +# +# +# + SQL_MAX_USER_NAME_LEN => { + type => q(Short), + }, +# +# +# +# +# + SQL_MULT_RESULT_SETS => { + type => q(YesNo), + }, +# +# +# +# +# + SQL_MULTIPLE_ACTIVE_TXN => { + type => q(YesNo), + }, +# +# +# +# +# + SQL_NEED_LONG_DATA_LEN => { + type => q(YesNo), + }, +# +# +# +# +# + SQL_NON_NULLABLE_COLUMNS => { + type => q(Short), + }, +# +# +# +# +# + SQL_NULL_COLLATION => { + type => q(Short), + }, +# +# +# +# +# + SQL_NUMERIC_FUNCTIONS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_ODBC_INTERFACE_CONFORMANCE => { + type => q(Long), + }, +# +# +# +# +# + SQL_ODBC_VER => { + type => q(Char), + }, +# +# +# +# +# + SQL_OJ_CAPABILITIES => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_ORDER_BY_COLUMNS_IN_SELECT => { + type => q(YesNo), + }, +# +# +# +# +# + SQL_PARAM_ARRAY_ROW_COUNTS => { + type => q(Long), + }, +# +# +# +# +# + SQL_PARAM_ARRAY_SELECTS => { + type => q(Long), + }, +# +# +# +# +# + SQL_PROCEDURE_TERM => { + type => q(Char), + }, +# +# +# +# +# + SQL_PROCEDURES => { + type => q(YesNo), + }, +# +# +# +# +# + SQL_POS_OPERATIONS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_QUOTED_IDENTIFIER_CASE => { + type => q(Short), + }, +# +# +# +# +# + SQL_ROW_UPDATES => { + type => q(YesNo), + }, +# +# +# +# +# + SQL_SCHEMA_TERM => { + type => q(Char), + }, +# +# +# +# +# + SQL_SCHEMA_USAGE => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_SCROLL_OPTIONS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_SEARCH_PATTERN_ESCAPE => { + type => q(Char), + }, +# +# +# +# +# + SQL_SERVER_NAME => { + type => q(Char), + }, +# +# +# +# +# + SQL_SPECIAL_CHARACTERS => { + type => q(Char), + }, +# +# +# +# +# + SQL_SQL_CONFORMANCE => { + type => q(Long), + }, +# +# +# +# +# + SQL_SQL92_DATETIME_FUNCTIONS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_SQL92_FOREIGN_KEY_DELETE_RULE => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_SQL92_FOREIGN_KEY_UPDATE_RULE => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_SQL92_GRANT => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_SQL92_NUMERIC_VALUE_FUNCTIONS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_SQL92_PREDICATES => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_SQL92_RELATIONAL_JOIN_OPERATORS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_SQL92_REVOKE => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_SQL92_ROW_VALUE_CONSTRUCTOR => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_SQL92_STRING_FUNCTIONS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_SQL92_VALUE_EXPRESSIONS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_STANDARD_CLI_CONFORMANCE => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_STATIC_CURSOR_ATTRIBUTES1 => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_STATIC_CURSOR_ATTRIBUTES2 => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_STRING_FUNCTIONS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_SUBQUERIES => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_SYSTEM_FUNCTIONS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_TABLE_TERM => { + type => q(Char), + }, +# +# +# +# +# + SQL_TIMEDATE_ADD_INTERVALS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_TIMEDATE_DIFF_INTERVALS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_TIMEDATE_FUNCTIONS => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_TXN_CAPABLE => { + type => q(Short), + }, +# +# +# +# +# + SQL_TXN_ISOLATION_OPTION => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_UNION => { + type => q(Bitmask), + }, +# +# +# +# +# + SQL_USER_NAME => { + type => q(Char), + }, +# +# +# +# +# + SQL_XOPEN_CLI_YEAR => { + type => q(Char), + }, +#
InfoTypeReturns
SQL_ACCESSIBLE_PROCEDURES
+# (ODBC 1.0)		A character string: "Y" if the user can execute all procedures returned by SQLProcedures; "N" if there may be procedures returned that the user cannot execute.
SQL_ACCESSIBLE_TABLES
+# (ODBC 1.0)		A character string: "Y" if the user is guaranteed SELECT privileges to all tables returned by SQLTables; "N" if there may be tables returned that the user cannot access.
SQL_ACTIVE_ENVIRONMENTS
+# (ODBC 3.0)		An SQLUSMALLINT value specifying the maximum number of active environments that the driver can support. If there is no specified limit or the limit is unknown, this value is set to zero.
SQL_AGGREGATE_FUNCTIONS
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating support for aggregation functions: +#

SQL_AF_ALL
+# SQL_AF_AVG
+# SQL_AF_COUNT
+# SQL_AF_DISTINCT
+# SQL_AF_MAX
+# SQL_AF_MIN
+# SQL_AF_SUM

+# +#

An SQL-92 Entry level–conformant driver will always return all of these options as supported.

+#
SQL_ALTER_DOMAIN
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the ALTER DOMAIN statement, as defined in SQL-92, supported by the data source. An SQL-92 Full level–compliant driver will always return all of the bitmasks. A return value of "0" means that the ALTER DOMAIN statement is not supported. +#

The SQL-92 or FIPS conformance level at which this feature needs to be supported is shown in parentheses next to each bitmask.

+# +#

The following bitmasks are used to determine which clauses are supported:

+# +#

SQL_AD_ADD_DOMAIN_CONSTRAINT = Adding a domain constraint is supported (Full level)

+# +#

SQL_AD_ADD_DOMAIN_DEFAULT = <alter domain> <set domain default clause> is supported (Full level)

+# +#

SQL_AD_CONSTRAINT_NAME_DEFINITION = <constraint name definition clause> is supported for naming domain constraint (Intermediate level)

+# +#

SQL_AD_DROP_DOMAIN_CONSTRAINT = <drop domain constraint clause> is supported (Full level)

+# +#

SQL_AD_DROP_DOMAIN_DEFAULT = <alter domain> <drop domain default clause> is supported (Full level)

+# +#

The following bits specify the supported <constraint attributes> if <add domain constraint> is supported (the SQL_AD_ADD_DOMAIN_CONSTRAINT bit is set):

+# +#

SQL_AD_ADD_CONSTRAINT_DEFERRABLE (Full level)
+# SQL_AD_ADD_CONSTRAINT_NON_DEFERRABLE (Full level)
+# SQL_AD_ADD_CONSTRAINT_INITIALLY_DEFERRED (Full level)
+# SQL_AD_ADD_CONSTRAINT_INITIALLY_IMMEDIATE (Full level)

+#
SQL_ALTER_TABLE
+# (ODBC 2.0)		An SQLUINTEGER bitmask enumerating the clauses in the ALTER TABLE statement supported by the data source. +#

The SQL-92 or FIPS conformance level at which this feature needs to be supported is shown in parentheses next to each bitmask.

+# +#

The following bitmasks are used to determine which clauses are supported:

+# +#

SQL_AT_ADD_COLUMN_COLLATION = <add column> clause is supported, with facility to specify column collation (Full level) (ODBC 3.0)

+# +#

SQL_AT_ADD_COLUMN_DEFAULT = <add column> clause is supported, with facility to specify column defaults (FIPS Transitional level) (ODBC 3.0)

+# +#

SQL_AT_ADD_COLUMN_SINGLE = <add column> is supported (FIPS Transitional level) (ODBC 3.0)

+# +#

SQL_AT_ADD_CONSTRAINT = <add column> clause is supported, with facility to specify column constraints (FIPS Transitional level) (ODBC 3.0)

+# +#

SQL_AT_ADD_TABLE_CONSTRAINT = <add table constraint> clause is supported (FIPS Transitional level) (ODBC 3.0)

+# +#

SQL_AT_CONSTRAINT_NAME_DEFINITION = <constraint name definition> is supported for naming column and table constraints (Intermediate level) (ODBC 3.0)

+# +#

SQL_AT_DROP_COLUMN_CASCADE = <drop column> CASCADE is supported (FIPS Transitional level) (ODBC 3.0)

+# +#

SQL_AT_DROP_COLUMN_DEFAULT = <alter column> <drop column default clause> is supported (Intermediate level) (ODBC 3.0)

+# +#

SQL_AT_DROP_COLUMN_RESTRICT = <drop column> RESTRICT is supported (FIPS Transitional level) (ODBC 3.0)

+# +#

SQL_AT_DROP_TABLE_CONSTRAINT_CASCADE (ODBC 3.0)

+# +#

SQL_AT_DROP_TABLE_CONSTRAINT_RESTRICT = <drop column> RESTRICT is supported (FIPS Transitional level) (ODBC 3.0)

+# +#

SQL_AT_SET_COLUMN_DEFAULT = <alter column> <set column default clause> is supported (Intermediate level) (ODBC 3.0)

+# +#

The following bits specify the support <constraint attributes> if specifying column or table constraints is supported (the SQL_AT_ADD_CONSTRAINT bit is set):

+# +#

SQL_AT_CONSTRAINT_INITIALLY_DEFERRED (Full level) (ODBC 3.0)
+# SQL_AT_CONSTRAINT_INITIALLY_IMMEDIATE (Full level) (ODBC 3.0)
+# SQL_AT_CONSTRAINT_DEFERRABLE (Full level) (ODBC 3.0)
+# SQL_AT_CONSTRAINT_NON_DEFERRABLE (Full level) (ODBC 3.0)

+#
SQL_ASYNC_MODE
+# (ODBC 3.0)		An SQLUINTEGER value indicating the level of asynchronous support in the driver: +#

SQL_AM_CONNECTION = Connection level asynchronous execution is supported. Either all statement handles associated with a given connection handle are in asynchronous mode or all are in synchronous mode. A statement handle on a connection cannot be in asynchronous mode while another statement handle on the same connection is in synchronous mode, and vice versa.

+# +#

SQL_AM_STATEMENT = Statement level asynchronous execution is supported. Some statement handles associated with a connection handle can be in asynchronous mode, while other statement handles on the same connection are in synchronous mode.

+# +#

SQL_AM_NONE = Asynchronous mode is not supported.

+#
SQL_BATCH_ROW_COUNT
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the behavior of the driver with respect to the availability of row counts. The following bitmasks are used in conjunction with the information type: +#

SQL_BRC_ROLLED_UP = Row counts for consecutive INSERT, DELETE, or UPDATE statements are rolled up into one. If this bit is not set, then row counts are available for each individual statement.

+# +#

SQL_BRC_PROCEDURES = Row counts, if any, are available when a batch is executed in a stored procedure. If row counts are available, they can be rolled up or individually available, depending on the SQL_BRC_ROLLED_UP bit.

+# +#

SQL_BRC_EXPLICIT = Row counts, if any, are available when a batch is executed directly by calling SQLExecute or SQLExecDirect. If row counts are available, they can be rolled up or individually available, depending on the SQL_BRC_ROLLED_UP bit.

+#
SQL_BATCH_SUPPORT
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the driver's support for batches. The following bitmasks are used to determine which level is supported: +#

SQL_BS_SELECT_EXPLICIT = The driver supports explicit batches that can have result-set generating statements.

+# +#

SQL_BS_ROW_COUNT_EXPLICIT = The driver supports explicit batches that can have row-count generating statements.

+# +#

SQL_BS_SELECT_PROC = The driver supports explicit procedures that can have result-set generating statements.

+# +#

SQL_BS_ROW_COUNT_PROC = The driver supports explicit procedures that can have row-count generating statements.

+#
SQL_BOOKMARK_PERSISTENCE
+# (ODBC 2.0)		An SQLUINTEGER bitmask enumerating the operations through which bookmarks persist. +#

The following bitmasks are used in conjunction with the flag to determine through which options bookmarks persist:

+# +#

SQL_BP_CLOSE = Bookmarks are valid after an application calls SQLFreeStmt with the SQL_CLOSE option, or SQLCloseCursor to close the cursor associated with a statement.

+# +#

SQL_BP_DELETE = The bookmark for a row is valid after that row has been deleted.

+# +#

SQL_BP_DROP = Bookmarks are valid after an application calls SQLFreeHandle with a HandleType of SQL_HANDLE_STMT to drop a statement.

+# +#

SQL_BP_TRANSACTION = Bookmarks are valid after an application commits or rolls back a transaction.

+# +#

SQL_BP_UPDATE = The bookmark for a row is valid after any column in that row has been updated, including key columns.

+# +#

SQL_BP_OTHER_HSTMT = A bookmark associated with one statement can be used with another statement. Unless SQL_BP_CLOSE or SQL_BP_DROP is specified, the cursor on the first statement must be open.

+#
SQL_CATALOG_LOCATION
+# (ODBC 2.0)		An SQLUSMALLINT value indicating the position of the catalog in a qualified table name: +#

SQL_CL_START
+# SQL_CL_END

+# +#

For example, an Xbase driver returns SQL_CL_START because the directory (catalog) name is at the start of the table name, as in \EMPDATA\EMP.DBF. An ORACLE Server driver returns SQL_CL_END because the catalog is at the end of the table name, as in ADMIN.EMP@EMPDATA.

+# +#

An SQL-92 Full level–conformant driver will always return SQL_CL_START. A value of 0 is returned if catalogs are not supported by the data source. To find out whether catalogs are supported, an application calls SQLGetInfo with the SQL_CATALOG_NAME information type.

+# +#

This InfoType has been renamed for ODBC 3.0 from the ODBC 2.0 InfoType SQL_QUALIFIER_LOCATION.

+#
SQL_CATALOG_NAME
+# (ODBC 3.0)		A character string: "Y" if the server supports catalog names, or "N" if it does not. +#

An SQL-92 Full level–conformant driver will always return "Y".

+#
SQL_CATALOG_NAME_SEPARATOR
+# (ODBC 1.0)		A character string: the character or characters that the data source defines as the separator between a catalog name and the qualified name element that follows or precedes it. +#

An empty string is returned if catalogs are not supported by the data source. To find out whether catalogs are supported, an application calls SQLGetInfo with the SQL_CATALOG_NAME information type. An SQL-92 Full level–conformant driver will always return ".".

+# +#

This InfoType has been renamed for ODBC 3.0 from the ODBC 2.0 InfoType SQL_QUALIFIER_NAME_SEPARATOR.

+#
SQL_CATALOG_TERM
+# (ODBC 1.0)		A character string with the data source vendor's name for a catalog; for example, "database" or "directory". This string can be in upper, lower, or mixed case. +#

An empty string is returned if catalogs are not supported by the data source. To find out whether catalogs are supported, an application calls SQLGetInfo with the SQL_CATALOG_NAME information type. An SQL-92 Full level–conformant driver will always return "catalog".

+# +#

This InfoType has been renamed for ODBC 3.0 from the ODBC 2.0 InfoType SQL_QUALIFIER_TERM.

+#
SQL_CATALOG_USAGE
+# (ODBC 2.0)		An SQLUINTEGER bitmask enumerating the statements in which catalogs can be used. +#

The following bitmasks are used to determine where catalogs can be used:

+# +#

SQL_CU_DML_STATEMENTS = Catalogs are supported in all Data Manipulation Language statements: SELECT, INSERT, UPDATE, DELETE, and if supported, SELECT FOR UPDATE and positioned update and delete statements.

+# +#

SQL_CU_PROCEDURE_INVOCATION = Catalogs are supported in the ODBC procedure invocation statement.

+# +#

SQL_CU_TABLE_DEFINITION = Catalogs are supported in all table definition statements: CREATE TABLE, CREATE VIEW, ALTER TABLE, DROP TABLE, and DROP VIEW.

+# +#

SQL_CU_INDEX_DEFINITION = Catalogs are supported in all index definition statements: CREATE INDEX and DROP INDEX.

+# +#

SQL_CU_PRIVILEGE_DEFINITION = Catalogs are supported in all privilege definition statements: GRANT and REVOKE.

+# +#

A value of 0 is returned if catalogs are not supported by the data source. To find out whether catalogs are supported, an application calls SQLGetInfo with the SQL_CATALOG_NAME information type. An SQL-92 Full level–conformant driver will always return a bitmask with all of these bits set.

+# +#

This InfoType has been renamed for ODBC 3.0 from the ODBC 2.0 InfoType SQL_QUALIFIER_USAGE.

+#
SQL_COLLATION_SEQ
+# (ODBC 3.0)		The name of the collation sequence. This is a character string that indicates the name of the default collation for the default character set for this server (for example, 'ISO 8859-1' or EBCDIC). If this is unknown, an empty string will be returned. An SQL-92 Full level–conformant driver will always return a non-empty string.
SQL_COLUMN_ALIAS
+# (ODBC 2.0)		A character string: "Y" if the data source supports column aliases; otherwise, "N". +#

A column alias is an alternate name that can be specified for a column in the select list by using an AS clause. An SQL-92 Entry level–conformant driver will always return "Y".

+#
SQL_CONCAT_NULL_BEHAVIOR
+# (ODBC 1.0)		An SQLUSMALLINT value indicating how the data source handles the concatenation of NULL valued character data type columns with non-NULL valued character data type columns: +#

SQL_CB_NULL = Result is NULL valued.

+# +#

SQL_CB_NON_NULL = Result is concatenation of non-NULL valued column or columns.

+# +#

An SQL-92 Entry level–conformant driver will always return SQL_CB_NULL.

+#
SQL_CONVERT_BIGINT
+ SQL_CONVERT_BIGINT => { + type => q(Bitmask), + }, +# SQL_CONVERT_BINARY
+ SQL_CONVERT_BINARY => { + type => q(Bitmask), + }, +# SQL_CONVERT_BIT
+ SQL_CONVERT_BIT => { + type => q(Bitmask), + }, +# SQL_CONVERT_CHAR
+ SQL_CONVERT_CHAR => { + type => q(Bitmask), + }, +# SQL_CONVERT_GUID
+ SQL_CONVERT_GUID => { + type => q(Bitmask), + omit => 1, + }, +# SQL_CONVERT_DATE
+ SQL_CONVERT_DATE => { + type => q(Bitmask), + }, +# SQL_CONVERT_DECIMAL
+ SQL_CONVERT_DECIMAL => { + type => q(Bitmask), + }, +# SQL_CONVERT_DOUBLE
+ SQL_CONVERT_DOUBLE => { + type => q(Bitmask), + }, +# SQL_CONVERT_FLOAT
+ SQL_CONVERT_FLOAT => { + type => q(Bitmask), + }, +# SQL_CONVERT_INTEGER
+ SQL_CONVERT_INTEGER => { + type => q(Bitmask), + }, +# SQL_CONVERT_INTERVAL_YEAR_MONTH
+ SQL_CONVERT_INTERVAL_YEAR_MONTH => { + type => q(Bitmask), + }, +# SQL_CONVERT_INTERVAL_DAY_TIME
+ SQL_CONVERT_INTERVAL_DAY_TIME => { + type => q(Bitmask), + }, +# SQL_CONVERT_LONGVARBINARY
+ SQL_CONVERT_LONGVARBINARY => { + type => q(Bitmask), + }, +# SQL_CONVERT_LONGVARCHAR
+ SQL_CONVERT_LONGVARCHAR => { + type => q(Bitmask), + }, +# SQL_CONVERT_NUMERIC
+ SQL_CONVERT_NUMERIC => { + type => q(Bitmask), + }, +# SQL_CONVERT_REAL
+ SQL_CONVERT_REAL => { + type => q(Bitmask), + }, +# SQL_CONVERT_SMALLINT
+ SQL_CONVERT_SMALLINT => { + type => q(Bitmask), + }, +# SQL_CONVERT_TIME
+ SQL_CONVERT_TIME => { + type => q(Bitmask), + }, +# SQL_CONVERT_TIMESTAMP
+ SQL_CONVERT_TIMESTAMP => { + type => q(Bitmask), + }, +# SQL_CONVERT_TINYINT
+ SQL_CONVERT_TINYINT => { + type => q(Bitmask), + }, +# SQL_CONVERT_VARBINARY
+ SQL_CONVERT_VARBINARY => { + type => q(Bitmask), + }, +# SQL_CONVERT_VARCHAR
+ SQL_CONVERT_VARCHAR => { + type => q(Bitmask), + }, +# (ODBC 1.0)		An SQLUINTEGER bitmask. The bitmask indicates the conversions supported by the data source with the CONVERT scalar function for data of the type named in the InfoType. If the bitmask equals zero, the data source does not support any conversions from data of the named type, including conversion to the same data type. +#

For example, to find out if a data source supports the conversion of SQL_INTEGER data to the SQL_BIGINT data type, an application calls SQLGetInfo with the InfoType of SQL_CONVERT_INTEGER. The application performs an AND operation with the returned bitmask and SQL_CVT_BIGINT. If the resulting value is nonzero, the conversion is supported.

+# +#

The following bitmasks are used to determine which conversions are supported:

+# +#

SQL_CVT_BIGINT (ODBC 1.0)
+# SQL_CVT_BINARY (ODBC 1.0)
+# SQL_CVT_BIT (ODBC 1.0)
+# SQL_CVT_GUID (ODBC 3.5)
+# SQL_CVT_CHAR (ODBC 1.0)
+# SQL_CVT_DATE (ODBC 1.0)
+# SQL_CVT_DECIMAL (ODBC 1.0)
+# SQL_CVT_DOUBLE (ODBC 1.0)
+# SQL_CVT_FLOAT (ODBC 1.0)
+# SQL_CVT_INTEGER (ODBC 1.0)
+# SQL_CVT_INTERVAL_YEAR_MONTH (ODBC 3.0)
+# SQL_CVT_INTERVAL_DAY_TIME (ODBC 3.0)
+# SQL_CVT_LONGVARBINARY (ODBC 1.0)
+# SQL_CVT_LONGVARCHAR (ODBC 1.0)
+# SQL_CVT_NUMERIC (ODBC 1.0)
+# SQL_CVT_REAL ODBC 1.0)
+# SQL_CVT_SMALLINT (ODBC 1.0)
+# SQL_CVT_TIME (ODBC 1.0)
+# SQL_CVT_TIMESTAMP (ODBC 1.0)
+# SQL_CVT_TINYINT (ODBC 1.0)
+# SQL_CVT_VARBINARY (ODBC 1.0)
+# SQL_CVT_VARCHAR (ODBC 1.0)

+#
SQL_CONVERT_FUNCTIONS
+# (ODBC 1.0)		An SQLUINTEGER bitmask enumerating the scalar conversion functions supported by the driver and associated data source. +#

The following bitmask is used to determine which conversion functions are supported:

+# +#

SQL_FN_CVT_CAST
+# SQL_FN_CVT_CONVERT

+#
SQL_CORRELATION_NAME
+# (ODBC 1.0)		An SQLUSMALLINT value indicating whether table correlation names are supported: +#

SQL_CN_NONE = Correlation names are not supported.

+# +#

SQL_CN_DIFFERENT = Correlation names are supported but must differ from the names of the tables they represent.

+# +#

SQL_CN_ANY = Correlation names are supported and can be any valid user-defined name.

+# +#

An SQL-92 Entry level–conformant driver will always return SQL_CN_ANY.

+#
SQL_CREATE_ASSERTION
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the CREATE ASSERTION statement, as defined in SQL-92, supported by the data source. +#

The following bitmasks are used to determine which clauses are supported:

+# +#

SQL_CA_CREATE_ASSERTION

+# +#

The following bits specify the supported constraint attribute if the ability to specify constraint attributes explicitly is supported (see the SQL_ALTER_TABLE and SQL_CREATE_TABLE information types):

+# +#

SQL_CA_CONSTRAINT_INITIALLY_DEFERRED
+# SQL_CA_CONSTRAINT_INITIALLY_IMMEDIATE
+# SQL_CA_CONSTRAINT_DEFERRABLE
+# SQL_CA_CONSTRAINT_NON_DEFERRABLE

+# +#

An SQL-92 Full level–conformant driver will always return all of these options as supported. A return value of "0" means that the CREATE ASSERTION statement is not supported.

+#
SQL_CREATE_CHARACTER_SET
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the CREATE CHARACTER SET statement, as defined in SQL-92, supported by the data source. +#

The following bitmasks are used to determine which clauses are supported:

+# +#

SQL_CCS_CREATE_CHARACTER_SET
+# SQL_CCS_COLLATE_CLAUSE
+# SQL_CCS_LIMITED_COLLATION

+# +#

An SQL-92 Full level–conformant driver will always return all of these options as supported. A return value of "0" means that the CREATE CHARACTER SET statement is not supported.

+#
SQL_CREATE_COLLATION
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the CREATE COLLATION statement, as defined in SQL-92, supported by the data source. +#

The following bitmask is used to determine which clauses are supported:

+# +#

SQL_CCOL_CREATE_COLLATION

+# +#

An SQL-92 Full level–conformant driver will always return this option as supported. A return value of "0" means that the CREATE COLLATION statement is not supported.

+#
SQL_CREATE_DOMAIN
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the CREATE DOMAIN statement, as defined in SQL-92, supported by the data source. +#

The following bitmasks are used to determine which clauses are supported:

+# +#

SQL_CDO_CREATE_DOMAIN = The CREATE DOMAIN statement is supported (Intermediate level).

+# +#

SQL_CDO_CONSTRAINT_NAME_DEFINITION = <constraint name definition> is supported for naming domain constraints (Intermediate level).

+# +#

The following bits specify the ability to create column constraints:
+# SQL_CDO_DEFAULT = Specifying domain constraints is supported (Intermediate level)
+# SQL_CDO_CONSTRAINT = Specifying domain defaults is supported (Intermediate level)
+# SQL_CDO_COLLATION = Specifying domain collation is supported (Full level)

+# +#

The following bits specify the supported constraint attributes if specifying domain constraints is supported (SQL_CDO_DEFAULT is set):

+# +#

SQL_CDO_CONSTRAINT_INITIALLY_DEFERRED (Full level)
+# SQL_CDO_CONSTRAINT_INITIALLY_IMMEDIATE (Full level)
+# SQL_CDO_CONSTRAINT_DEFERRABLE (Full level)
+# SQL_CDO_CONSTRAINT_NON_DEFERRABLE (Full level)

+# +#

A return value of "0" means that the CREATE DOMAIN statement is not supported.

+#
SQL_CREATE_SCHEMA
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the CREATE SCHEMA statement, as defined in SQL-92, supported by the data source. +#

The following bitmasks are used to determine which clauses are supported:

+# +#

SQL_CS_CREATE_SCHEMA
+# SQL_CS_AUTHORIZATION
+# SQL_CS_DEFAULT_CHARACTER_SET

+# +#

An SQL-92 Intermediate level–conformant driver will always return the SQL_CS_CREATE_SCHEMA and SQL_CS_AUTHORIZATION options as supported. These must also be supported at the SQL-92 Entry level, but not necessarily as SQL statements. An SQL-92 Full level–conformant driver will always return all of these options as supported.

+#
SQL_CREATE_TABLE
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the CREATE TABLE statement, as defined in SQL-92, supported by the data source. +#

The SQL-92 or FIPS conformance level at which this feature needs to be supported is shown in parentheses next to each bitmask.

+# +#

The following bitmasks are used to determine which clauses are supported:

+# +#

SQL_CT_CREATE_TABLE = The CREATE TABLE statement is supported. (Entry level)

+# +#

SQL_CT_TABLE_CONSTRAINT = Specifying table constraints is supported (FIPS Transitional level)

+# +#

SQL_CT_CONSTRAINT_NAME_DEFINITION = The <constraint name definition> clause is supported for naming column and table constraints (Intermediate level)

+# +#

The following bits specify the ability to create temporary tables:

+# +#

SQL_CT_COMMIT_PRESERVE = Deleted rows are preserved on commit. (Full level)
+# SQL_CT_COMMIT_DELETE = Deleted rows are deleted on commit. (Full level)
+# SQL_CT_GLOBAL_TEMPORARY = Global temporary tables can be created. (Full level)
+# SQL_CT_LOCAL_TEMPORARY = Local temporary tables can be created. (Full level)

+# +#

The following bits specify the ability to create column constraints:

+# +#

SQL_CT_COLUMN_CONSTRAINT = Specifying column constraints is supported (FIPS Transitional level)
+# SQL_CT_COLUMN_DEFAULT = Specifying column defaults is supported (FIPS Transitional level)
+# SQL_CT_COLUMN_COLLATION = Specifying column collation is supported (Full level)

+# +#

The following bits specify the supported constraint attributes if specifying column or table constraints is supported:

+# +#

SQL_CT_CONSTRAINT_INITIALLY_DEFERRED (Full level)
+# SQL_CT_CONSTRAINT_INITIALLY_IMMEDIATE (Full level)
+# SQL_CT_CONSTRAINT_DEFERRABLE (Full level)
+# SQL_CT_CONSTRAINT_NON_DEFERRABLE (Full level)

+#
SQL_CREATE_TRANSLATION
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the CREATE TRANSLATION statement, as defined in SQL-92, supported by the data source. +#

The following bitmask is used to determine which clauses are supported:

+# +#

SQL_CTR_CREATE_TRANSLATION

+# +#

An SQL-92 Full level–conformant driver will always return these options as supported. A return value of "0" means that the CREATE TRANSLATION statement is not supported.

+#
SQL_CREATE_VIEW
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the CREATE VIEW statement, as defined in SQL-92, supported by the data source. +#

The following bitmasks are used to determine which clauses are supported:

+# +#

SQL_CV_CREATE_VIEW
+# SQL_CV_CHECK_OPTION
+# SQL_CV_CASCADED
+# SQL_CV_LOCAL

+# +#

A return value of "0" means that the CREATE VIEW statement is not supported.

+# +#

An SQL-92 Entry level–conformant driver will always return the SQL_CV_CREATE_VIEW and SQL_CV_CHECK_OPTION options as supported.

+# +#

An SQL-92 Full level–conformant driver will always return all of these options as supported.

+#
SQL_CURSOR_COMMIT_BEHAVIOR
+# (ODBC 1.0)		An SQLUSMALLINT value indicating how a COMMIT operation affects cursors and prepared statements in the data source: +#

SQL_CB_DELETE = Close cursors and delete prepared statements. To use the cursor again, the application must reprepare and reexecute the statement.

+# +#

SQL_CB_CLOSE = Close cursors. For prepared statements, the application can call SQLExecute on the statement without calling SQLPrepare again.

+# +#

SQL_CB_PRESERVE = Preserve cursors in the same position as before the COMMIT operation. The application can continue to fetch data, or it can close the cursor and reexecute the statement without repreparing it.

+#
SQL_CURSOR_ROLLBACK_BEHAVIOR
+# (ODBC 1.0)		An SQLUSMALLINT value indicating how a ROLLBACK operation affects cursors and prepared statements in the data source: +#

SQL_CB_DELETE = Close cursors and delete prepared statements. To use the cursor again, the application must reprepare and reexecute the statement.

+# +#

SQL_CB_CLOSE = Close cursors. For prepared statements, the application can call SQLExecute on the statement without calling SQLPrepare again.

+# +#

SQL_CB_PRESERVE = Preserve cursors in the same position as before the ROLLBACK operation. The application can continue to fetch data, or it can close the cursor and reexecute the statement without repreparing it.

+#
SQL_CURSOR_ROLLBACK_SQL_CURSOR_SENSITIVITY
+# (ODBC 3.0)		An SQLUINTEGER value indicating the support for cursor sensitivity: +#

SQL_INSENSITIVE = All cursors on the statement handle show the result set without reflecting any changes made to it by any other cursor within the same transaction.

+# +#

SQL_UNSPECIFIED = It is unspecified whether cursors on the statement handle make visible the changes made to a result set by another cursor within the same transaction. Cursors on the statement handle may make visible none, some, or all such changes.

+# +#

SQL_SENSITIVE = Cursors are sensitive to changes made by other cursors within the same transaction.

+# +#

An SQL-92 Entry level–conformant driver will always return the SQL_UNSPECIFIED option as supported.

+# +#

An SQL-92 Full level–conformant driver will always return the SQL_INSENSITIVE option as supported.

+#
SQL_DATA_SOURCE_NAME
+# (ODBC 1.0)		A character string with the data source name used during connection. If the application called SQLConnect, this is the value of the szDSN argument. If the application called SQLDriverConnect or SQLBrowseConnect, this is the value of the DSN keyword in the connection string passed to the driver. If the connection string did not contain the DSN keyword (such as when it contains the DRIVER keyword), this is an empty string.
SQL_DATA_SOURCE_READ_ONLY
+# (ODBC 1.0)		A character string. "Y" if the data source is set to READ ONLY mode, "N" if it is otherwise. +#

This characteristic pertains only to the data source itself; it is not a characteristic of the driver that enables access to the data source. A driver that is read/write can be used with a data source that is read-only. If a driver is read-only, all of its data sources must be read-only and must return SQL_DATA_SOURCE_READ_ONLY.

+#
SQL_DATABASE_NAME
+# (ODBC 1.0)		A character string with the name of the current database in use, if the data source defines a named object called "database". +#

Note   In ODBC 3.x, the value returned for this InfoType can also be returned by calling SQLGetConnectAttr with an Attribute argument of SQL_ATTR_CURRENT_CATALOG.

+#
SQL_DATETIME_LITERALS
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the SQL-92 datetime literals supported by the data source. Note that these are the datetime literals listed in the SQL-92 specification and are separate from the datetime literal escape clauses defined by ODBC. For more information about the ODBC datetime literal escape clauses, see "Date, Time, Timestamp, and Datetime Interval Literals" in Chapter 8: SQL Statements. +#

A FIPS Transitional level–conformant driver will always return the "1" value in the bitmask for the bits listed below. A value of "0" means that SQL-92 datetime literals are not supported.

+# +#

The following bitmasks are used to determine which literals are supported:

+# +#

SQL_DL_SQL92_DATE
+# SQL_DL_SQL92_TIME
+# SQL_DL_SQL92_TIMESTAMP
+# SQL_DL_SQL92_INTERVAL_YEAR
+# SQL_DL_SQL92_INTERVAL_MONTH
+# SQL_DL_SQL92_INTERVAL_DAY
+# SQL_DL_SQL92_INTERVAL_HOUR
+# SQL_DL_SQL92_INTERVAL_MINUTE
+# SQL_DL_SQL92_INTERVAL_SECOND
+# SQL_DL_SQL92_INTERVAL_YEAR_TO_MONTH
+# SQL_DL_SQL92_INTERVAL_DAY_TO_HOUR

+# +#

SQL_DL_SQL92_INTERVAL_DAY_TO_MINUTE
+# SQL_DL_SQL92_INTERVAL_DAY_TO_SECOND
+# SQL_DL_SQL92_INTERVAL_HOUR_TO_MINUTE
+# SQL_DL_SQL92_INTERVAL_HOUR_TO_SECOND
+# SQL_DL_SQL92_INTERVAL_MINUTE_TO_SECOND

+#
SQL_DBMS_NAME
+# (ODBC 1.0)		A character string with the name of the DBMS product accessed by the driver.
SQL_DBMS_VER
+# (ODBC 1.0)		A character string indicating the version of the DBMS product accessed by the driver. The version is of the form ##.##.####, where the first two digits are the major version, the next two digits are the minor version, and the last four digits are the release version. The driver must render the DBMS product version in this form but can also append the DBMS product-specific version as well. For example, "04.01.0000 Rdb 4.1".
SQL_DDL_INDEX
+# (ODBC 3.0)		An SQLUINTEGER value that indicates support for creation and dropping of indexes: +#

SQL_DI_CREATE_INDEX
+# SQL_DI_DROP_INDEX

+#
SQL_DEFAULT_TXN_ISOLATION
+# (ODBC 1.0)		An SQLUINTEGER value that indicates the default transaction isolation level supported by the driver or data source, or zero if the data source does not support transactions. The following terms are used to define transaction isolation levels: +#

Dirty Read Transaction 1 changes a row. Transaction 2 reads the changed row before transaction 1 commits the change. If transaction 1 rolls back the change, transaction 2 will have read a row that is considered to have never existed.

+# +#

Nonrepeatable Read Transaction 1 reads a row. Transaction 2 updates or deletes that row and commits this change. If transaction 1 attempts to reread the row, it will receive different row values or discover that the row has been deleted.

+# +#

Phantom Transaction 1 reads a set of rows that satisfy some search criteria. Transaction 2 generates one or more rows (through either inserts or updates) that match the search criteria. If transaction 1 reexecutes the statement that reads the rows, it receives a different set of rows.

+# +#

If the data source supports transactions, the driver returns one of the following bitmasks:

+# +#

SQL_TXN_READ_UNCOMMITTED = Dirty reads, nonrepeatable reads, and phantoms are possible.

+# +#

SQL_TXN_READ_COMMITTED = Dirty reads are not possible. Nonrepeatable reads and phantoms are possible.

+# +#

SQL_TXN_REPEATABLE_READ = Dirty reads and nonrepeatable reads are not possible. Phantoms are possible.

+# +#

SQL_TXN_SERIALIZABLE = Transactions are serializable. Serializable transactions do not allow dirty reads, nonrepeatable reads, or phantoms.

+#
SQL_DESCRIBE_PARAMETER
+# (ODBC 3.0)		A character string: "Y" if parameters can be described; "N", if not. +#

An SQL-92 Full level–conformant driver will usually return "Y" because it will support the DESCRIBE INPUT statement. Because this does not directly specify the underlying SQL support, however, describing parameters might not be supported, even in a SQL-92 Full level–conformant driver.

+#
SQL_DM_VER
+# (ODBC 3.0)		A character string with the version of the Driver Manager. The version is of the form ##.##.####.####, where: +#

The first set of two digits is the major ODBC version, as given by the constant SQL_SPEC_MAJOR.

+# +#

The second set of two digits is the minor ODBC version, as given by the constant SQL_SPEC_MINOR.

+# +#

The third set of four digits is the Driver Manager major build number.

+# +#

The last set of four digits is the Driver Manager minor build number.

+#
SQL_DRIVER_HDBC
+# SQL_DRIVER_HENV
+# (ODBC 1.0)		An SQLUINTEGER value, the driver's environment handle or connection handle, determined by the argument InfoType. +#

These information types are implemented by the Driver Manager alone.

+#
SQL_DRIVER_HDESC
+# (ODBC 3.0)		An SQLUINTEGER value, the driver's descriptor handle determined by the Driver Manager's descriptor handle, which must be passed on input in *InfoValuePtr from the application. In this case, InfoValuePtr is both an input and output argument. The input descriptor handle passed in *InfoValuePtr must have been either explicitly or implicitly allocated on the ConnectionHandle. +#

The application should make a copy of the Driver Manager's descriptor handle before calling SQLGetInfo with this information type, to ensure that the handle is not overwritten on output.

+# +#

This information type is implemented by the Driver Manager alone.

+#
SQL_DRIVER_HLIB
+# (ODBC 2.0)		An SQLUINTEGER value, the hinst from the load library returned to the Driver Manager when it loaded the driver DLL (on a Microsoft® Windows® platform) or equivalent on a non-Windows platform. The handle is valid only for the connection handle specified in the call to SQLGetInfo. +#

This information type is implemented by the Driver Manager alone.

+#
SQL_DRIVER_HSTMT
+# (ODBC 1.0)		An SQLUINTEGER value, the driver's statement handle determined by the Driver Manager statement handle, which must be passed on input in *InfoValuePtr from the application. In this case, InfoValuePtr is both an input and an output argument. The input statement handle passed in *InfoValuePtr must have been allocated on the argument ConnectionHandle. +#

The application should make a copy of the Driver Manager's statement handle before calling SQLGetInfo with this information type, to ensure that the handle is not overwritten on output.

+# +#

This information type is implemented by the Driver Manager alone.

+#
SQL_DRIVER_NAME
+# (ODBC 1.0)		A character string with the file name of the driver used to access the data source.
SQL_DRIVER_ODBC_VER
+# (ODBC 2.0)		A character string with the version of ODBC that the driver supports. The version is of the form ##.##, where the first two digits are the major version and the next two digits are the minor version. SQL_SPEC_MAJOR and SQL_SPEC_MINOR define the major and minor version numbers. For the version of ODBC described in this manual, these are 3 and 0, and the driver should return "03.00".
SQL_DRIVER_VER
+# (ODBC 1.0)		A character string with the version of the driver and optionally, a description of the driver. At a minimum, the version is of the form ##.##.####, where the first two digits are the major version, the next two digits are the minor version, and the last four digits are the release version.
SQL_DROP_ASSERTION
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the DROP ASSERTION statement, as defined in SQL-92, supported by the data source. +#

The following bitmask is used to determine which clauses are supported:

+# +#

SQL_DA_DROP_ASSERTION

+# +#

An SQL-92 Full level–conformant driver will always return this option as supported.

+#
SQL_DROP_CHARACTER_SET
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the DROP CHARACTER SET statement, as defined in SQL-92, supported by the data source. +#

The following bitmask is used to determine which clauses are supported:

+# +#

SQL_DCS_DROP_CHARACTER_SET

+# +#

An SQL-92 Full level–conformant driver will always return this option as supported.

+#
SQL_DROP_COLLATION
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the DROP COLLATION statement, as defined in SQL-92, supported by the data source. +#

The following bitmask is used to determine which clauses are supported:

+# +#

SQL_DC_DROP_COLLATION

+# +#

An SQL-92 Full level–conformant driver will always return this option as supported.

+#
SQL_DROP_DOMAIN
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the DROP DOMAIN statement, as defined in SQL-92, supported by the data source. +#

The following bitmasks are used to determine which clauses are supported:

+# +#

SQL_DD_DROP_DOMAIN
+# SQL_DD_CASCADE
+# SQL_DD_RESTRICT

+# +#

An SQL-92 Intermediate level–conformant driver will always return all of these options as supported.

+#
SQL_DROP_SCHEMA
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the DROP SCHEMA statement, as defined in SQL-92, supported by the data source. +#

The following bitmasks are used to determine which clauses are supported:

+# +#

SQL_DS_DROP_SCHEMA
+# SQL_DS_CASCADE
+# SQL_DS_RESTRICT

+# +#

An SQL-92 Intermediate level–conformant driver will always return all of these options as supported.

+#
SQL_DROP_TABLE
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the DROP TABLE statement, as defined in SQL-92, supported by the data source. +#

The following bitmasks are used to determine which clauses are supported:

+# +#

SQL_DT_DROP_TABLE
+# SQL_DT_CASCADE
+# SQL_DT_RESTRICT

+# +#

An FIPS Transitional level–conformant driver will always return all of these options as supported.

+#
SQL_DROP_TRANSLATION
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the DROP TRANSLATION statement, as defined in SQL-92, supported by the data source. +#

The following bitmask is used to determine which clauses are supported:

+# +#

SQL_DTR_DROP_TRANSLATION

+# +#

An SQL-92 Full level–conformant driver will always return this option as supported.

+#
SQL_DROP_VIEW
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses in the DROP VIEW statement, as defined in SQL-92, supported by the data source. +#

The following bitmasks are used to determine which clauses are supported:

+# +#

SQL_DV_DROP_VIEW
+# SQL_DV_CASCADE
+# SQL_DV_RESTRICT

+# +#

An FIPS Transitional level–conformant driver will always return all of these options as supported.

+#
SQL_DYNAMIC_CURSOR_ATTRIBUTES1
+# (ODBC 3.0)		An SQLUINTEGER bitmask that describes the attributes of a dynamic cursor that are supported by the driver. This bitmask contains the first subset of attributes; for the second subset, see SQL_DYNAMIC_CURSOR_ATTRIBUTES2. +#

The following bitmasks are used to determine which attributes are supported:

+# +#

SQL_CA1_NEXT = A FetchOrientation argument of SQL_FETCH_NEXT is supported in a call to SQLFetchScroll when the cursor is a dynamic cursor.

+# +#

SQL_CA1_ABSOLUTE = FetchOrientation arguments of SQL_FETCH_FIRST, SQL_FETCH_LAST, and SQL_FETCH_ABSOLUTE are supported in a call to SQLFetchScroll when the cursor is a dynamic cursor. (The rowset that will be fetched is independent of the current cursor position.)

+# +#

SQL_CA1_RELATIVE = FetchOrientation arguments of SQL_FETCH_PRIOR and SQL_FETCH_RELATIVE are supported in a call to SQLFetchScroll when the cursor is a dynamic cursor. (The rowset that will be fetched is dependent on the current cursor position. Note that this is separated from SQL_FETCH_NEXT because in a forward-only cursor, only SQL_FETCH_NEXT is supported.)

+# +#

SQL_CA1_BOOKMARK = A FetchOrientation argument of SQL_FETCH_BOOKMARK is supported in a call to SQLFetchScroll when the cursor is a dynamic cursor.

+# +#

SQL_CA1_LOCK_EXCLUSIVE = A LockType argument of SQL_LOCK_EXCLUSIVE is supported in a call to SQLSetPos when the cursor is a dynamic cursor.

+# +#

SQL_CA1_LOCK_NO_CHANGE = A LockType argument of SQL_LOCK_NO_CHANGE is supported in a call to SQLSetPos when the cursor is a dynamic cursor.

+# +#

SQL_CA1_LOCK_UNLOCK = A LockType argument of SQL_LOCK_UNLOCK is supported in a call to SQLSetPos when the cursor is a dynamic cursor.

+# +#

SQL_CA1_POS_POSITION = An Operation argument of SQL_POSITION is supported in a call to SQLSetPos when the cursor is a dynamic cursor.

+# +#

SQL_CA1_POS_UPDATE = An Operation argument of SQL_UPDATE is supported in a call to SQLSetPos when the cursor is a dynamic cursor.

+# +#

SQL_CA1_POS_DELETE = An Operation argument of SQL_DELETE is supported in a call to SQLSetPos when the cursor is a dynamic cursor.

+# +#

SQL_CA1_POS_REFRESH = An Operation argument of SQL_REFRESH is supported in a call to SQLSetPos when the cursor is a dynamic cursor.

+# +#

SQL_CA1_POSITIONED_UPDATE = An UPDATE WHERE CURRENT OF SQL statement is supported when the cursor is a dynamic cursor. (An SQL-92 Entry level–conformant driver will always return this option as supported.)

+# +#

SQL_CA1_POSITIONED_DELETE = A DELETE WHERE CURRENT OF SQL statement is supported when the cursor is a dynamic cursor. (An SQL-92 Entry level–conformant driver will always return this option as supported.)

+# +#

SQL_CA1_SELECT_FOR_UPDATE = A SELECT FOR UPDATE SQL statement is supported when the cursor is a dynamic cursor. (An SQL-92 Entry level–conformant driver will always return this option as supported.)

+# +#

SQL_CA1_BULK_ADD = An Operation argument of SQL_ADD is supported in a call to SQLBulkOperations when the cursor is a dynamic cursor.

+# +#

SQL_CA1_BULK_UPDATE_BY_BOOKMARK = An Operation argument of SQL_UPDATE_BY_BOOKMARK is supported in a call to SQLBulkOperations when the cursor is a dynamic cursor.

+# +#

SQL_CA1_BULK_DELETE_BY_BOOKMARK = An Operation argument of SQL_DELETE_BY_BOOKMARK is supported in a call to SQLBulkOperations when the cursor is a dynamic cursor.

+# +#

SQL_CA1_BULK_FETCH_BY_BOOKMARK = An Operation argument of SQL_FETCH_BY_BOOKMARK is supported in a call to SQLBulkOperations when the cursor is a dynamic cursor.

+# +#

An SQL-92 Intermediate level–conformant driver will usually return the SQL_CA1_NEXT, SQL_CA1_ABSOLUTE, and SQL_CA1_RELATIVE options as supported, because it supports scrollable cursors through the embedded SQL FETCH statement. Because this does not directly determine the underlying SQL support, however, scrollable cursors may not be supported, even for an SQL-92 Intermediate level–conformant driver.

+#
SQL_DYNAMIC_CURSOR_ATTRIBUTES2
+# (ODBC 3.0)		An SQLUINTEGER bitmask that describes the attributes of a dynamic cursor that are supported by the driver. This bitmask contains the second subset of attributes; for the first subset, see SQL_DYNAMIC_CURSOR_ATTRIBUTES1. +#

The following bitmasks are used to determine which attributes are supported:

+# +#

SQL_CA2_READ_ONLY_CONCURRENCY = A read-only dynamic cursor, in which no updates are allowed, is supported. (The SQL_ATTR_CONCURRENCY statement attribute can be SQL_CONCUR_READ_ONLY for a dynamic cursor).

+# +#

SQL_CA2_LOCK_CONCURRENCY = A dynamic cursor that uses the lowest level of locking sufficient to ensure that the row can be updated is supported. (The SQL_ATTR_CONCURRENCY statement attribute can be SQL_CONCUR_LOCK for a dynamic cursor.) These locks must be consistent with the transaction isolation level set by the SQL_ATTR_TXN_ISOLATION connection attribute.

+# +#

SQL_CA2_OPT_ROWVER_CONCURRENCY = A dynamic cursor that uses the optimistic concurrency control comparing row versions is supported. (The SQL_ATTR_CONCURRENCY statement attribute can be SQL_CONCUR_ROWVER for a dynamic cursor.)

+# +#

SQL_CA2_OPT_VALUES_CONCURRENCY = A dynamic cursor that uses the optimistic concurrency control comparing values is supported. (The SQL_ATTR_CONCURRENCY statement attribute can be SQL_CONCUR_VALUES for a dynamic cursor.)

+# +#

SQL_CA2_SENSITIVITY_ADDITIONS = Added rows are visible to a dynamic cursor; the cursor can scroll to those rows. (Where these rows are added to the cursor is driver-dependent.)

+# +#

SQL_CA2_SENSITIVITY_DELETIONS = Deleted rows are no longer available to a dynamic cursor, and do not leave a "hole" in the result set; after the dynamic cursor scrolls from a deleted row, it cannot return to that row.

+# +#

SQL_CA2_SENSITIVITY_UPDATES = Updates to rows are visible to a dynamic cursor; if the dynamic cursor scrolls from and returns to an updated row, the data returned by the cursor is the updated data, not the original data.

+# +#

SQL_CA2_MAX_ROWS_SELECT = The SQL_ATTR_MAX_ROWS statement attribute affects SELECT statements when the cursor is a dynamic cursor.

+# +#

SQL_CA2_MAX_ROWS_INSERT = The SQL_ATTR_MAX_ROWS statement attribute affects INSERT statements when the cursor is a dynamic cursor.

+# +#

SQL_CA2_MAX_ROWS_DELETE = The SQL_ATTR_MAX_ROWS statement attribute affects DELETE statements when the cursor is a dynamic cursor.

+# +#

SQL_CA2_MAX_ROWS_UPDATE = The SQL_ATTR_MAX_ROWS statement attribute affects UPDATE statements when the cursor is a dynamic cursor.

+# +#

SQL_CA2_MAX_ROWS_CATALOG = The SQL_ATTR_MAX_ROWS statement attribute affects CATALOG result sets when the cursor is a dynamic cursor.

+# +#

SQL_CA2_MAX_ROWS_AFFECTS_ALL = The SQL_ATTR_MAX_ROWS statement attribute affects SELECT, INSERT, DELETE, and UPDATE statements, and CATALOG result sets, when the cursor is a dynamic cursor.

+# +#

SQL_CA2_CRC_EXACT = The exact row count is available in the SQL_DIAG_CURSOR_ROW_COUNT diagnostic field when the cursor is a dynamic cursor.

+# +#

SQL_CA2_CRC_APPROXIMATE = An approximate row count is available in the SQL_DIAG_CURSOR_ROW_COUNT diagnostic field when the cursor is a dynamic cursor.

+# +#

SQL_CA2_SIMULATE_NON_UNIQUE = The driver does not guarantee that simulated positioned update or delete statements will affect only one row when the cursor is a dynamic cursor; it is the application's responsibility to guarantee this. (If a statement affects more than one row, SQLExecute or SQLExecDirect returns SQLSTATE 01001 [Cursor operation conflict].) To set this behavior, the application calls SQLSetStmtAttr with the SQL_ATTR_SIMULATE_CURSOR attribute set to SQL_SC_NON_UNIQUE.

+# +#

SQL_CA2_SIMULATE_TRY_UNIQUE = The driver attempts to guarantee that simulated positioned update or delete statements will affect only one row when the cursor is a dynamic cursor. The driver always executes such statements, even if they might affect more than one row, such as when there is no unique key. (If a statement affects more than one row, SQLExecute or SQLExecDirect returns SQLSTATE 01001 [Cursor operation conflict].) To set this behavior, the application calls SQLSetStmtAttr with the SQL_ATTR_SIMULATE_CURSOR attribute set to SQL_SC_TRY_UNIQUE.

+# +#

SQL_CA2_SIMULATE_UNIQUE = The driver guarantees that simulated positioned update or delete statements will affect only one row when the cursor is a dynamic cursor. If the driver cannot guarantee this for a given statement, SQLExecDirect or SQLPrepare return SQLSTATE 01001 (Cursor operation conflict). To set this behavior, the application calls SQLSetStmtAttr with the SQL_ATTR_SIMULATE_CURSOR attribute set to SQL_SC_UNIQUE.

+#
SQL_EXPRESSIONS_IN_ORDERBY
+# (ODBC 1.0)		A character string: "Y" if the data source supports expressions in the ORDER BY list; "N" if it does not.
SQL_FILE_USAGE
+# (ODBC 2.0)		An SQLUSMALLINT value indicating how a single-tier driver directly treats files in a data source: +#

SQL_FILE_NOT_SUPPORTED = The driver is not a single-tier driver. For example, an ORACLE driver is a two-tier driver.

+# +#

SQL_FILE_TABLE = A single-tier driver treats files in a data source as tables. For example, an Xbase driver treats each Xbase file as a table.

+# +#

SQL_FILE_CATALOG = A single-tier driver treats files in a data source as a catalog. For example, a Microsoft® Access driver treats each Microsoft Access file as a complete database.

+# +#

An application might use this to determine how users will select data. For example, Xbase users often think of data as stored in files, while ORACLE and MicrosoftAccess users generally think of data as stored in tables.

+# +#

When a user selects an Xbase data source, the application could display the Windows File Open common dialog box; when the user selects a Microsoft Access or ORACLE data source, the application could display a custom Select Table dialog box.

+#
SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1
+# (ODBC 3.0)		An SQLUINTEGER bitmask that describes the attributes of a forward-only cursor that are supported by the driver. This bitmask contains the first subset of attributes; for the second subset, see SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2. +#

The following bitmasks are used to determine which attributes are supported:

+# +#

SQL_CA1_NEXT
+# SQL_CA1_LOCK_EXCLUSIVE
+# SQL_CA1_LOCK_NO_CHANGE
+# SQL_CA1_LOCK_UNLOCK
+# SQL_CA1_POS_POSITION
+# SQL_CA1_POS_UPDATE
+# SQL_CA1_POS_DELETE
+# SQL_CA1_POS_REFRESH
+# SQL_CA1_POSITIONED_UPDATE
+# SQL_CA1_POSITIONED_DELETE
+# SQL_CA1_SELECT_FOR_UPDATE
+# SQL_CA1_BULK_ADD
+# SQL_CA1_BULK_UPDATE_BY_BOOKMARK
+# SQL_CA1_BULK_DELETE_BY_BOOKMARK
+# SQL_CA1_BULK_FETCH_BY_BOOKMARK

+# +#

For descriptions of these bitmasks, see SQL_DYNAMIC_CURSOR_ATTRIBUTES1 (and substitute "forward-only cursor" for "dynamic cursor" in the descriptions).

+#
SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2
+# (ODBC 3.0)		An SQLUINTEGER bitmask that describes the attributes of a forward-only cursor that are supported by the driver. This bitmask contains the second subset of attributes; for the first subset, see SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1. +#

The following bitmasks are used to determine which attributes are supported:

+# +#

SQL_CA2_READ_ONLY_CONCURRENCY
+# SQL_CA2_LOCK_CONCURRENCY
+# SQL_CA2_OPT_ROWVER_CONCURRENCY
+# SQL_CA2_OPT_VALUES_CONCURRENCY
+# SQL_CA2_SENSITIVITY_ADDITIONS
+# SQL_CA2_SENSITIVITY_DELETIONS
+# SQL_CA2_SENSITIVITY_UPDATES
+# SQL_CA2_MAX_ROWS_SELECT
+# SQL_CA2_MAX_ROWS_INSERT
+# SQL_CA2_MAX_ROWS_DELETE
+# SQL_CA2_MAX_ROWS_UPDATE
+# SQL_CA2_MAX_ROWS_CATALOG
+# SQL_CA2_MAX_ROWS_AFFECTS_ALL
+# SQL_CA2_CRC_EXACT
+# SQL_CA2_CRC_APPROXIMATE
+# SQL_CA2_SIMULATE_NON_UNIQUE
+# SQL_CA2_SIMULATE_TRY_UNIQUE
+# SQL_CA2_SIMULATE_UNIQUE

+# +#

For descriptions of these bitmasks, see SQL_DYNAMIC_CURSOR_ATTRIBUTES2 (and substitute "forward-only cursor" for "dynamic cursor" in the descriptions).

+#
SQL_GETDATA_EXTENSIONS
+# (ODBC 2.0)		An SQLUINTEGER bitmask enumerating extensions to SQLGetData. +#

The following bitmasks are used in conjunction with the flag to determine what common extensions the driver supports for SQLGetData:

+# +#

SQL_GD_ANY_COLUMN = SQLGetData can be called for any unbound column, including those before the last bound column. Note that the columns must be called in order of ascending column number unless SQL_GD_ANY_ORDER is also returned.

+# +#

SQL_GD_ANY_ORDER = SQLGetData can be called for unbound columns in any order. Note that SQLGetData can be called only for columns after the last bound column unless SQL_GD_ANY_COLUMN is also returned.

+# +#

SQL_GD_BLOCK = SQLGetData can be called for an unbound column in any row in a block (where the rowset size is greater than 1) of data after positioning to that row with SQLSetPos.

+# +#

SQL_GD_BOUND = SQLGetData can be called for bound columns as well as unbound columns. A driver cannot return this value unless it also returns SQL_GD_ANY_COLUMN.

+# +#

SQLGetData is required to return data only from unbound columns that occur after the last bound column, are called in order of increasing column number, and are not in a row in a block of rows.

+# +#

If a driver supports bookmarks (either fixed-length or variable-length), it must support calling SQLGetData on column 0. This support is required regardless of what the driver returns for a call to SQLGetInfo with the SQL_GETDATA_EXTENSIONS InfoType.

+#
SQL_GROUP_BY
+# (ODBC 2.0)		An SQLUSMALLINT value specifying the relationship between the columns in the GROUP BY clause and the nonaggregated columns in the select list: +#

SQL_GB_COLLATE = A COLLATE clause can be specified at the end of each grouping column. (ODBC 3.0)

+# +#

SQL_GB_NOT_SUPPORTED = GROUP BY clauses are not supported. (ODBC 2.0)

+# +#

SQL_GB_GROUP_BY_EQUALS_SELECT = The GROUP BY clause must contain all nonaggregated columns in the select list. It cannot contain any other columns. For example, SELECT DEPT, MAX(SALARY) FROM EMPLOYEE GROUP BY DEPT. (ODBC 2.0)

+# +#

SQL_GB_GROUP_BY_CONTAINS_SELECT = The GROUP BY clause must contain all nonaggregated columns in the select list. It can contain columns that are not in the select list. For example, SELECT DEPT, MAX(SALARY) FROM EMPLOYEE GROUP BY DEPT, AGE. (ODBC 2.0)

+# +#

SQL_GB_NO_RELATION = The columns in the GROUP BY clause and the select list are not related. The meaning of nongrouped, nonaggregated columns in the select list is data source–dependent. For example, SELECT DEPT, SALARY FROM EMPLOYEE GROUP BY DEPT, AGE. (ODBC 2.0)

+# +#

An SQL-92 Entry level–conformant driver will always return the SQL_GB_GROUP_BY_EQUALS_SELECT option as supported. An SQL-92 Full level–conformant driver will always return the SQL_GB_COLLATE option as supported. If none of the options is supported, the GROUP BY clause is not supported by the data source.

+#
SQL_IDENTIFIER_CASE
+# (ODBC 1.0)		An SQLUSMALLINT value as follows: +#

SQL_IC_UPPER = Identifiers in SQL are not case-sensitive and are stored in uppercase in system catalog.

+# +#

SQL_IC_LOWER = Identifiers in SQL are not case-sensitive and are stored in lowercase in system catalog.

+# +#

SQL_IC_SENSITIVE = Identifiers in SQL are case-sensitive and are stored in mixed case in system catalog.

+# +#

SQL_IC_MIXED = Identifiers in SQL are not case-sensitive and are stored in mixed case in system catalog.

+# +#

Because identifiers in SQL-92 are never case-sensitive, a driver that conforms strictly to SQL-92 (any level) will never return the SQL_IC_SENSITIVE option as supported.

+#
SQL_IDENTIFIER_QUOTE_CHAR
+# (ODBC 1.0)		The character string used as the starting and ending delimiter of a quoted (delimited) identifier in SQL statements. (Identifiers passed as arguments to ODBC functions do not need to be quoted.) If the data source does not support quoted identifiers, a blank is returned. +#

This character string can also be used for quoting catalog function arguments when the connection attribute SQL_ATTR_METADATA_ID is set to SQL_TRUE.

+# +#

Because the identifier quote character in SQL-92 is the double quotation mark ("), a driver that conforms strictly to SQL-92 will always return the double quotation mark character.

+#
SQL_INDEX_KEYWORDS
+# (ODBC 3.0)		An SQLUINTEGER bitmask that enumerates keywords in the CREATE INDEX statement that are supported by the driver: +#

SQL_IK_NONE = None of the keywords is supported.

+# +#

SQL_IK_ASC = ASC keyword is supported.

+# +#

SQL_IK_DESC = DESC keyword is supported.

+# +#

SQL_IK_ALL = All keywords are supported.

+# +#

To see if the CREATE INDEX statement is supported, an application calls SQLGetInfo with the SQL_DLL_INDEX information type.

+#
SQL_INFO_SCHEMA_VIEWS
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the views in the INFORMATION_SCHEMA that are supported by the driver. The views in, and the contents of, INFORMATION_SCHEMA are as defined in SQL-92. +#

The SQL-92 or FIPS conformance level at which this feature needs to be supported is shown in parentheses next to each bitmask.

+# +#

The following bitmasks are used to determine which views are supported:

+# +#

SQL_ISV_ASSERTIONS = Identifies the catalog's assertions that are owned by a given user. (Full level)

+# +#

SQL_ISV_CHARACTER_SETS = Identifies the catalog's character sets that are accessible to a given user. (Intermediate level)

+# +#

SQL_ISV_CHECK_CONSTRAINTS = Identifies the CHECK constraints that are owned by a given user. (Intermediate level)

+# +#

SQL_ISV_COLLATIONS = Identifies the character collations for the catalog that are accessible to a given user. (Full level)

+# +#

SQL_ISV_COLUMN_DOMAIN_USAGE = Identifies columns for the catalog that are dependent on domains defined in the catalog and are owned by a given user. (Intermediate level)

+# +#

SQL_ISV_COLUMN_PRIVILEGES = Identifies the privileges on columns of persistent tables that are available to or granted by a given user. (FIPS Transitional level)

+# +#

SQL_ISV_COLUMNS = Identifies the columns of persistent tables that are accessible to a given user. (FIPS Transitional level)

+# +#

SQL_ISV_CONSTRAINT_COLUMN_USAGE = Similar to CONSTRAINT_TABLE_USAGE view, columns are identified for the various constraints that are owned by a given user. (Intermediate level)

+# +#

SQL_ISV_CONSTRAINT_TABLE_USAGE = Identifies the tables that are used by constraints (referential, unique, and assertions), and are owned by a given user. (Intermediate level)

+# +#

SQL_ISV_DOMAIN_CONSTRAINTS = Identifies the domain constraints (of the domains in the catalog) that are accessible to a given user. (Intermediate level)

+# +#

SQL_ISV_DOMAINS = Identifies the domains defined in a catalog that are accessible to the user. (Intermediate level)

+# +#

SQL_ISV_KEY_COLUMN_USAGE = Identifies columns defined in the catalog that are constrained as keys by a given user. (Intermediate level)

+# +#

SQL_ISV_REFERENTIAL_CONSTRAINTS = Identifies the referential constraints that are owned by a given user. (Intermediate level)

+# +#

SQL_ISV_SCHEMATA = Identifies the schemas that are owned by a given user. (Intermediate level)

+# +#

SQL_ISV_SQL_LANGUAGES = Identifies the SQL conformance levels, options, and dialects supported by the SQL implementation. (Intermediate level)

+# +#

SQL_ISV_TABLE_CONSTRAINTS = Identifies the table constraints that are owned by a given user. (Intermediate level)

+# +#

SQL_ISV_TABLE_PRIVILEGES = Identifies the privileges on persistent tables that are available to or granted by a given user. (FIPS Transitional level)

+# +#

SQL_ISV_TABLES = Identifies the persistent tables defined in a catalog that are accessible to a given user. (FIPS Transitional level)

+# +#

SQL_ISV_TRANSLATIONS = Identifies character translations for the catalog that are accessible to a given user. (Full level)

+# +#

SQL_ISV_USAGE_PRIVILEGES = Identifies the USAGE privileges on catalog objects that are available to or owned by a given user. (FIPS Transitional level)

+# +#

SQL_ISV_VIEW_COLUMN_USAGE = Identifies the columns on which the catalog's views that are owned by a given user are dependent. (Intermediate level)

+# +#

SQL_ISV_VIEW_TABLE_USAGE = Identifies the tables on which the catalog's views that are owned by a given user are dependent. (Intermediate level)

+# +#

SQL_ISV_VIEWS = Identifies the viewed tables defined in this catalog that are accessible to a given user. (FIPS Transitional level)

+#
SQL_INSERT_STATEMENT
+# (ODBC 3.0)		An SQLUINTEGER bitmask that indicates support for INSERT statements: +#

SQL_IS_INSERT_LITERALS

+# +#

SQL_IS_INSERT_SEARCHED

+# +#

SQL_IS_SELECT_INTO

+# +#

An SQL-92 Entry level–conformant driver will always return all of these options as supported.

+#
SQL_INTEGRITY
+# (ODBC 1.0)		A character string: "Y" if the data source supports the Integrity Enhancement Facility; "N" if it does not. +#

This InfoType has been renamed for ODBC 3.0 from the ODBC 2.0 InfoType SQL_ODBC_SQL_OPT_IEF.

+#
SQL_KEYSET_CURSOR_ATTRIBUTES1
+# (ODBC 3.0)		An SQLUINTEGER bitmask that describes the attributes of a keyset cursor that are supported by the driver. This bitmask contains the first subset of attributes; for the second subset, see SQL_KEYSET_CURSOR_ATTRIBUTES2. +#

The following bitmasks are used to determine which attributes are supported:

+# +#

SQL_CA1_NEXT
+# SQL_CA1_ABSOLUTE
+# SQL_CA1_RELATIVE
+# SQL_CA1_BOOKMARK
+# SQL_CA1_LOCK_EXCLUSIVE
+# SQL_CA1_LOCK_NO_CHANGE
+# SQL_CA1_LOCK_UNLOCK
+# SQL_CA1_POS_POSITION
+# SQL_CA1_POS_UPDATE
+# SQL_CA1_POS_DELETE
+# SQL_CA1_POS_REFRESH
+# SQL_CA1_POSITIONED_UPDATE
+# SQL_CA1_POSITIONED_DELETE
+# SQL_CA1_SELECT_FOR_UPDATE
+# SQL_CA1_BULK_ADD
+# SQL_CA1_BULK_UPDATE_BY_BOOKMARK
+# SQL_CA1_BULK_DELETE_BY_BOOKMARK
+# SQL_CA1_BULK_FETCH_BY_BOOKMARK

+# +#

For descriptions of these bitmasks, see SQL_DYNAMIC_CURSOR_ATTRIBUTES1 (and substitute "keyset-driven cursor" for "dynamic cursor" in the descriptions).

+# +#

An SQL-92 Intermediate level–conformant driver will usually return the SQL_CA1_NEXT, SQL_CA1_ABSOLUTE, and SQL_CA1_RELATIVE options as supported, because the driver supports scrollable cursors through the embedded SQL FETCH statement. Because this does not directly determine the underlying SQL support, however, scrollable cursors may not be supported, even for an SQL-92 Intermediate level–conformant driver.

+#
SQL_KEYSET_CURSOR_ATTRIBUTES2
+# (ODBC 3.0)		An SQLUINTEGER bitmask that describes the attributes of a keyset cursor that are supported by the driver. This bitmask contains the second subset of attributes; for the first subset, see SQL_KEYSET_CURSOR_ATTRIBUTES1. +#

The following bitmasks are used to determine which attributes are supported:

+# +#

SQL_CA2_READ_ONLY_CONCURRENCY
+# SQL_CA2_LOCK_CONCURRENCY
+# SQL_CA2_OPT_ROWVER_CONCURRENCY
+# SQL_CA2_OPT_VALUES_CONCURRENCY
+# SQL_CA2_SENSITIVITY_ADDITIONS
+# SQL_CA2_SENSITIVITY_DELETIONS
+# SQL_CA2_SENSITIVITY_UPDATES
+# SQL_CA2_MAX_ROWS_SELECT
+# SQL_CA2_MAX_ROWS_INSERT
+# SQL_CA2_MAX_ROWS_DELETE
+# SQL_CA2_MAX_ROWS_UPDATE
+# SQL_CA2_MAX_ROWS_CATALOG
+# SQL_CA2_MAX_ROWS_AFFECTS_ALL
+# SQL_CA2_CRC_EXACT
+# SQL_CA2_CRC_APPROXIMATE
+# SQL_CA2_SIMULATE_NON_UNIQUE
+# SQL_CA2_SIMULATE_TRY_UNIQUE
+# SQL_CA2_SIMULATE_UNIQUE

+# +#

For descriptions of these bitmasks, see SQL_DYNAMIC_CURSOR_ATTRIBUTES1 (and substitute "keyset-driven cursor" for "dynamic cursor" in the descriptions).

+#
SQL_KEYWORDS
+# (ODBC 2.0)		A character string containing a comma-separated list of all data source–specific keywords. This list does not contain keywords specific to ODBC or keywords used by both the data source and ODBC. This list represents all the reserved keywords; interoperable applications should not use these words in object names. +#

For a list of ODBC keywords, see "List of Reserved Keywords" in Appendix C, "SQL Grammar." The #define value SQL_ODBC_KEYWORDS contains a comma-separated list of ODBC keywords.

+#
SQL_LIKE_ESCAPE_CLAUSE
+# (ODBC 2.0)		A character string: "Y" if the data source supports an escape character for the percent character (%) and underscore character (_) in a LIKE predicate and the driver supports the ODBC syntax for defining a LIKE predicate escape character; "N" otherwise.
SQL_MAX_ASYNC_CONCURRENT_STATEMENTS
+# (ODBC 3.0)		An SQLUINTEGER value specifying the maximum number of active concurrent statements in asynchronous mode that the driver can support on a given connection. If there is no specific limit or the limit is unknown, this value is zero.
SQL_MAX_BINARY_LITERAL_LEN
+# (ODBC 2.0)		An SQLUINTEGER value specifying the maximum length (number of hexadecimal characters, excluding the literal prefix and suffix returned by SQLGetTypeInfo) of a binary literal in an SQL statement. For example, the binary literal 0xFFAA has a length of 4. If there is no maximum length or the length is unknown, this value is set to zero.
SQL_MAX_CATALOG_NAME_LEN
+# (ODBC 1.0)		An SQLUSMALLINT value specifying the maximum length of a catalog name in the data source. If there is no maximum length or the length is unknown, this value is set to zero. +#

An FIPS Full level–conformant driver will return at least 128.

+# +#

This InfoType has been renamed for ODBC 3.0 from the ODBC 2.0 InfoType SQL_MAX_QUALIFIER_NAME_LEN.

+#
SQL_MAX_CHAR_LITERAL_LEN
+# (ODBC 2.0)		An SQLUINTEGER value specifying the maximum length (number of characters, excluding the literal prefix and suffix returned by SQLGetTypeInfo) of a character literal in an SQL statement. If there is no maximum length or the length is unknown, this value is set to zero.
SQL_MAX_COLUMN_NAME_LEN
+# (ODBC 1.0)		An SQLUSMALLINT value specifying the maximum length of a column name in the data source. If there is no maximum length or the length is unknown, this value is set to zero. +#

An FIPS Entry level–conformant driver will return at least 18. An FIPS Intermediate level–conformant driver will return at least 128.

+#
SQL_MAX_COLUMNS_IN_GROUP_BY
+# (ODBC 2.0)		An SQLUSMALLINT value specifying the maximum number of columns allowed in a GROUP BY clause. If there is no specified limit or the limit is unknown, this value is set to zero. +#

An FIPS Entry level–conformant driver will return at least 6. An FIPS Intermediate level–conformant driver will return at least 15.

+#
SQL_MAX_COLUMNS_IN_INDEX
+# (ODBC 2.0)		An SQLUSMALLINT value specifying the maximum number of columns allowed in an index. If there is no specified limit or the limit is unknown, this value is set to zero.
SQL_MAX_COLUMNS_IN_ORDER_BY
+# (ODBC 2.0)		An SQLUSMALLINT value specifying the maximum number of columns allowed in an ORDER BY clause. If there is no specified limit or the limit is unknown, this value is set to zero. +#

An FIPS Entry level–conformant driver will return at least 6. An FIPS Intermediate level–conformant driver will return at least 15.

+#
SQL_MAX_COLUMNS_IN_SELECT
+# (ODBC 2.0)		An SQLUSMALLINT value specifying the maximum number of columns allowed in a select list. If there is no specified limit or the limit is unknown, this value is set to zero. +#

An FIPS Entry level–conformant driver will return at least 100. An FIPS Intermediate level–conformant driver will return at least 250.

+#
SQL_MAX_COLUMNS_IN_TABLE
+# (ODBC 2.0)		An SQLUSMALLINT value specifying the maximum number of columns allowed in a table. If there is no specified limit or the limit is unknown, this value is set to zero. +#

An FIPS Entry level–conformant driver will return at least 100. An FIPS Intermediate level–conformant driver will return at least 250.

+#
SQL_MAX_CONCURRENT_ACTIVITIES
+# (ODBC 1.0)		An SQLUSMALLINT value specifying the maximum number of active statements that the driver can support for a connection. A statement is defined as active if it has results pending, with the term "results" meaning rows from a SELECT operation or rows affected by an INSERT, UPDATE, or DELETE operation (such as a row count), or if it is in a NEED_DATA state. This value can reflect a limitation imposed by either the driver or the data source. If there is no specified limit or the limit is unknown, this value is set to zero. +#

This InfoType has been renamed for ODBC 3.0 from the ODBC 2.0 InfoType SQL_ACTIVE_STATEMENTS.

+#
SQL_MAX_CURSOR_NAME_LEN
+# (ODBC 1.0)		An SQLUSMALLINT value specifying the maximum length of a cursor name in the data source. If there is no maximum length or the length is unknown, this value is set to zero. +#

An FIPS Entry level–conformant driver will return at least 18. An FIPS Intermediate level–conformant driver will return at least 128.

+#
SQL_MAX_DRIVER_CONNECTIONS
+# (ODBC 1.0)		An SQLUSMALLINT value specifying the maximum number of active connections that the driver can support for an environment. This value can reflect a limitation imposed by either the driver or the data source. If there is no specified limit or the limit is unknown, this value is set to zero. +#

This InfoType has been renamed for ODBC 3.0 from the ODBC 2.0 InfoType SQL_ACTIVE_CONNECTIONS.

+#
SQL_MAX_IDENTIFIER_LEN
+# (ODBC 3.0)		An SQLUSMALLINT that indicates the maximum size in characters that the data source supports for user-defined names. +#

An FIPS Entry level–conformant driver will return at least 18. An FIPS Intermediate level–conformant driver will return at least 128.

+#
SQL_MAX_INDEX_SIZE
+# (ODBC 2.0)		An SQLUINTEGER value specifying the maximum number of bytes allowed in the combined fields of an index. If there is no specified limit or the limit is unknown, this value is set to zero.
SQL_MAX_PROCEDURE_NAME_LEN
+# (ODBC 1.0)		An SQLUSMALLINT value specifying the maximum length of a procedure name in the data source. If there is no maximum length or the length is unknown, this value is set to zero.
SQL_MAX_ROW_SIZE
+# (ODBC 2.0)		An SQLUINTEGER value specifying the maximum length of a single row in a table. If there is no specified limit or the limit is unknown, this value is set to zero. +#

An FIPS Entry level–conformant driver will return at least 2,000. An FIPS Intermediate level–conformant driver will return at least 8,000.

+#
SQL_MAX_ROW_SIZE_INCLUDES_LONG
+# (ODBC 3.0)		A character string: "Y" if the maximum row size returned for the SQL_MAX_ROW_SIZE information type includes the length of all SQL_LONGVARCHAR and SQL_LONGVARBINARY columns in the row; "N" otherwise.
SQL_MAX_SCHEMA_NAME_LEN
+# (ODBC 1.0)		An SQLUSMALLINT value specifying the maximum length of a schema name in the data source. If there is no maximum length or the length is unknown, this value is set to zero. +#

An FIPS Entry level–conformant driver will return at least 18. An FIPS Intermediate level–conformant driver will return at least 128.

+# +#

This InfoType has been renamed for ODBC 3.0 from the ODBC 2.0 InfoType SQL_MAX_OWNER_NAME_LEN.

+#
SQL_MAX_STATEMENT_LEN
+# (ODBC 2.0)		An SQLUINTEGER value specifying the maximum length (number of characters, including white space) of an SQL statement. If there is no maximum length or the length is unknown, this value is set to zero.
SQL_MAX_TABLE_NAME_LEN
+# (ODBC 1.0)		An SQLUSMALLINT value specifying the maximum length of a table name in the data source. If there is no maximum length or the length is unknown, this value is set to zero. +#

An FIPS Entry level–conformant driver will return at least 18. An FIPS Intermediate level–conformant driver will return at least 128.

+#
SQL_MAX_TABLES_IN_SELECT
+# (ODBC 2.0)		An SQLUSMALLINT value specifying the maximum number of tables allowed in the FROM clause of a SELECT statement. If there is no specified limit or the limit is unknown, this value is set to zero. +#

An FIPS Entry level–conformant driver will return at least 15. An FIPS Intermediate level–conformant driver will return at least 50.

+#
SQL_MAX_USER_NAME_LEN
+# (ODBC 2.0)		An SQLUSMALLINT value specifying the maximum length of a user name in the data source. If there is no maximum length or the length is unknown, this value is set to zero.
SQL_MULT_RESULT_SETS
+# (ODBC 1.0)		A character string: "Y" if the data source supports multiple result sets, "N" if it does not. +#

For more information on multiple result sets, see "Multiple Results" in Chapter 11: Retrieving Results (Advanced).

+#
SQL_MULTIPLE_ACTIVE_TXN
+# (ODBC 1.0)		A character string: "Y" if the driver supports more than one active transaction at the same time, "N" if only one transaction can be active at any time. +#

The information returned for this information type does not apply in the case of distributed transactions.

+#
SQL_NEED_LONG_DATA_LEN
+# (ODBC 2.0)		A character string: "Y" if the data source needs the length of a long data value (the data type is SQL_LONGVARCHAR, SQL_LONGVARBINARY, or a long data source–specific data type) before that value is sent to the data source, "N" if it does not. For more information, see SQLBindParameter and SQLSetPos.
SQL_NON_NULLABLE_COLUMNS
+# (ODBC 1.0)		An SQLUSMALLINT value specifying whether the data source supports NOT NULL in columns: +#

SQL_NNC_NULL = All columns must be nullable.

+# +#

SQL_NNC_NON_NULL = Columns cannot be nullable. (The data source supports the NOT NULL column constraint in CREATE TABLE statements.)

+# +#

An SQL-92 Entry level–conformant driver will return SQL_NNC_NON_NULL.

+#
SQL_NULL_COLLATION
+# (ODBC 2.0)		An SQLUSMALLINT value specifying where NULLs are sorted in a result set: +#

SQL_NC_END = NULLs are sorted at the end of the result set, regardless of the ASC or DESC keywords.

+# +#

SQL_NC_HIGH = NULLs are sorted at the high end of the result set, depending on the ASC or DESC keywords.

+# +#

SQL_NC_LOW = NULLs are sorted at the low end of the result set, depending on the ASC or DESC keywords.

+# +#

SQL_NC_START = NULLs are sorted at the start of the result set, regardless of the ASC or DESC keywords.

+#
SQL_NUMERIC_FUNCTIONS
+# (ODBC 1.0) +#

The information type was introduced in ODBC 1.0; each bitmask is labeled with the version in which it was introduced.

+# 		An SQLUINTEGER bitmask enumerating the scalar numeric functions supported by the driver and associated data source. +#

The following bitmasks are used to determine which numeric functions are supported:

+# +#

SQL_FN_NUM_ABS (ODBC 1.0)
+# SQL_FN_NUM_ACOS (ODBC 1.0)
+# SQL_FN_NUM_ASIN (ODBC 1.0)
+# SQL_FN_NUM_ATAN (ODBC 1.0)
+# SQL_FN_NUM_ATAN2 (ODBC 1.0)
+# SQL_FN_NUM_CEILING (ODBC 1.0)
+# SQL_FN_NUM_COS (ODBC 1.0)
+# SQL_FN_NUM_COT (ODBC 1.0)
+# SQL_FN_NUM_DEGREES (ODBC 2.0)
+# SQL_FN_NUM_EXP (ODBC 1.0)
+# SQL_FN_NUM_FLOOR (ODBC 1.0)
+# SQL_FN_NUM_LOG (ODBC 1.0)
+# SQL_FN_NUM_LOG10 (ODBC 2.0)
+# SQL_FN_NUM_MOD (ODBC 1.0)
+# SQL_FN_NUM_PI (ODBC 1.0)
+# SQL_FN_NUM_POWER (ODBC 2.0)
+# SQL_FN_NUM_RADIANS (ODBC 2.0)
+# SQL_FN_NUM_RAND (ODBC 1.0)
+# SQL_FN_NUM_ROUND (ODBC 2.0)
+# SQL_FN_NUM_SIGN (ODBC 1.0)
+# SQL_FN_NUM_SIN (ODBC 1.0)
+# SQL_FN_NUM_SQRT (ODBC 1.0)
+# SQL_FN_NUM_TAN (ODBC 1.0)
+# SQL_FN_NUM_TRUNCATE (ODBC 2.0)

+#
SQL_ODBC_INTERFACE_CONFORMANCE
+# (ODBC 3.0)		An SQLUINTEGER value indicating the level of the ODBC 3.x interface that the driver conforms to. +#

SQL_OIC_CORE: The minimum level that all ODBC drivers are expected to conform to. This level includes basic interface elements such as connection functions, functions for preparing and executing an SQL statement, basic result set metadata functions, basic catalog functions, and so on.

+# +#

SQL_OIC_LEVEL1: A level including the core standards compliance level functionality, plus scrollable cursors, bookmarks, positioned updates and deletes, and so on.

+# +#

SQL_OIC_LEVEL2: A level including level 1 standards compliance level functionality, plus advanced features such as sensitive cursors; update, delete, and refresh by bookmarks; stored procedure support; catalog functions for primary and foreign keys; multicatalog support; and so on.

+# +#

For more information, see "Interface Conformance Levels" in Chapter 4: ODBC Fundamentals.

+#
SQL_ODBC_VER
+# (ODBC 1.0)		A character string with the version of ODBC to which the Driver Manager conforms. The version is of the form ##.##.0000, where the first two digits are the major version and the next two digits are the minor version. This is implemented solely in the Driver Manager.
SQL_OJ_CAPABILITIES
+# (ODBC 2.01)		An SQLUINTEGER bitmask enumerating the types of outer joins supported by the driver and data source. The following bitmasks are used to determine which types are supported: +#

SQL_OJ_LEFT = Left outer joins are supported.

+# +#

SQL_OJ_RIGHT = Right outer joins are supported.

+# +#

SQL_OJ_FULL = Full outer joins are supported.

+# +#

SQL_OJ_NESTED = Nested outer joins are supported.

+# +#

SQL_OJ_NOT_ORDERED = The column names in the ON clause of the outer join do not have to be in the same order as their respective table names in the OUTER JOIN clause.

+# +#

SQL_OJ_INNER = The inner table (the right table in a left outer join or the left table in a right outer join) can also be used in an inner join. This does not apply to full outer joins, which do not have an inner table.

+# +#

SQL_OJ_ALL_COMPARISON_OPS = The comparison operator in the ON clause can be any of the ODBC comparison operators. If this bit is not set, only the equals (=) comparison operator can be used in outer joins.

+# +#

If none of these options is returned as supported, no outer join clause is supported.

+# +#

For information on the support of relational join operators in a SELECT statement, as defined by SQL-92, see SQL_SQL92_RELATIONAL_JOIN_OPERATORS.

+#
SQL_ORDER_BY_COLUMNS_IN_SELECT
+# (ODBC 2.0)		A character string: "Y" if the columns in the ORDER BY clause must be in the select list; otherwise, "N".
SQL_PARAM_ARRAY_ROW_COUNTS
+# (ODBC 3.0)		An SQLUINTEGER enumerating the driver's properties regarding the availability of row counts in a parameterized execution. Has the following values: +#

SQL_PARC_BATCH = Individual row counts are available for each set of parameters. This is conceptually equivalent to the driver generating a batch of SQL statements, one for each parameter set in the array. Extended error information can be retrieved by using the SQL_PARAM_STATUS_PTR descriptor field.

+# +#

SQL_PARC_NO_BATCH = There is only one row count available, which is the cumulative row count resulting from the execution of the statement for the entire array of parameters. This is conceptually equivalent to treating the statement along with the entire parameter array as one atomic unit. Errors are handled the same as if one statement were executed.

+#
SQL_PARAM_ARRAY_SELECTS
+# (ODBC 3.0)		An SQLUINTEGER enumerating the driver's properties regarding the availability of result sets in a parameterized execution. Has the following values: +#

SQL_PAS_BATCH = There is one result set available per set of parameters. This is conceptually equivalent to the driver generating a batch of SQL statements, one for each parameter set in the array.

+# +#

SQL_PAS_NO_BATCH = There is only one result set available, which represents the cumulative result set resulting from the execution of the statement for the entire array of parameters. This is conceptually equivalent to treating the statement along with the entire parameter array as one atomic unit.

+# +#

SQL_PAS_NO_SELECT = A driver does not allow a result-set generating statement to be executed with an array of parameters.

+#
SQL_PROCEDURE_TERM
+# (ODBC 1.0)		A character string with the data source vendor's name for a procedure; for example, "database procedure", "stored procedure", "procedure", "package", or "stored query".
SQL_PROCEDURES
+# (ODBC 1.0)		A character string: "Y" if the data source supports procedures and the driver supports the ODBC procedure invocation syntax; "N" otherwise.
SQL_POS_OPERATIONS (ODBC 2.0)An SQLINTEGER bitmask enumerating the support operations in SQLSetPos. +#

The following bitmasks are used in conjunction with the flag to determine which options are supported.

+# +#

SQL_POS_POSITION (ODBC 2.0) SQL_POS_REFRESH (ODBC 2.0) SQL_POS_UPDATE (ODBC 2.0) SQL_POS_DELETE (ODBC 2.0) SQL_POS_ADD (ODBC 2.0)

+#
SQL_QUOTED_IDENTIFIER_CASE
+# (ODBC 2.0)		An SQLUSMALLINT value as follows: +#

SQL_IC_UPPER = Quoted identifiers in SQL are not case-sensitive and are stored in uppercase in the system catalog.

+# +#

SQL_IC_LOWER = Quoted identifiers in SQL are not case-sensitive and are stored in lowercase in the system catalog.

+# +#

SQL_IC_SENSITIVE = Quoted identifiers in SQL are case-sensitive and are stored in mixed case in the system catalog. (In an SQL-92–compliant database, quoted identifiers are always case-sensitive.)

+# +#

SQL_IC_MIXED = Quoted identifiers in SQL are not case-sensitive and are stored in mixed case in the system catalog.

+# +#

An SQL-92 Entry level–conformant driver will always return SQL_IC_SENSITIVE.

+#
SQL_ROW_UPDATES
+# (ODBC 1.0)		A character string: "Y" if a keyset-driven or mixed cursor maintains row versions or values for all fetched rows and therefore can detect any updates made to a row by any user since the row was last fetched. (This applies only to updates, not to deletions or insertions.) The driver can return the SQL_ROW_UPDATED flag to the row status array when SQLFetchScroll is called. Otherwise, "N".
SQL_SCHEMA_TERM
+# (ODBC 1.0)		A character string with the data source vendor's name for an schema; for example, "owner", "Authorization ID", or "Schema". +#

The character string can be returned in upper, lower, or mixed case.

+# +#

An SQL-92 Entry level–conformant driver will always return "schema".

+# +#

This InfoType has been renamed for ODBC 3.0 from the ODBC 2.0 InfoType SQL_OWNER_TERM.

+#
SQL_SCHEMA_USAGE
+# (ODBC 2.0)		An SQLUINTEGER bitmask enumerating the statements in which schemas can be used: +#

SQL_SU_DML_STATEMENTS = Schemas are supported in all Data Manipulation Language statements: SELECT, INSERT, UPDATE, DELETE, and if supported, SELECT FOR UPDATE and positioned update and delete statements.

+# +#

SQL_SU_PROCEDURE_INVOCATION = Schemas are supported in the ODBC procedure invocation statement.

+# +#

SQL_SU_TABLE_DEFINITION = Schemas are supported in all table definition statements: CREATE TABLE, CREATE VIEW, ALTER TABLE, DROP TABLE, and DROP VIEW.

+# +#

SQL_SU_INDEX_DEFINITION = Schemas are supported in all index definition statements: CREATE INDEX and DROP INDEX.

+# +#

SQL_SU_PRIVILEGE_DEFINITION = Schemas are supported in all privilege definition statements: GRANT and REVOKE.

+# +#

An SQL-92 Entry level–conformant driver will always return the SQL_SU_DML_STATEMENTS, SQL_SU_TABLE_DEFINITION, and SQL_SU_PRIVILEGE_DEFINITION options, as supported.

+# +#

This InfoType has been renamed for ODBC 3.0 from the ODBC 2.0 InfoType SQL_OWNER_USAGE.

+#
SQL_SCROLL_OPTIONS
+# (ODBC 1.0) +#

The information type was introduced in ODBC 1.0; each bitmask is labeled with the version in which it was introduced.

+# 		An SQLUINTEGER bitmask enumerating the scroll options supported for scrollable cursors. +#

The following bitmasks are used to determine which options are supported:

+# +#

SQL_SO_FORWARD_ONLY = The cursor only scrolls forward. (ODBC 1.0)

+# +#

SQL_SO_STATIC = The data in the result set is static. (ODBC 2.0)

+# +#

SQL_SO_KEYSET_DRIVEN = The driver saves and uses the keys for every row in the result set. (ODBC 1.0)

+# +#

SQL_SO_DYNAMIC = The driver keeps the keys for every row in the rowset (the keyset size is the same as the rowset size). (ODBC 1.0)

+# +#

SQL_SO_MIXED = The driver keeps the keys for every row in the keyset, and the keyset size is greater than the rowset size. The cursor is keyset-driven inside the keyset and dynamic outside the keyset. (ODBC 1.0)

+# +#

For information about scrollable cursors, see "Scrollable Cursors" in Chapter 11: Retrieving Results (Advanced)

+#
SQL_SEARCH_PATTERN_ESCAPE
+# (ODBC 1.0)		A character string specifying what the driver supports as an escape character that permits the use of the pattern match metacharacters underscore (_) and percent sign (%) as valid characters in search patterns. This escape character applies only for those catalog function arguments that support search strings. If this string is empty, the driver does not support a search-pattern escape character. +#

Because this information type does not indicate general support of the escape character in the LIKE predicate, SQL-92 does not include requirements for this character string.

+# +#

This InfoType is limited to catalog functions. For a description of the use of the escape character in search pattern strings, see "Pattern Value Arguments" in Chapter 7: Catalog Functions.

+#
SQL_SERVER_NAME
+# (ODBC 1.0)		A character string with the actual data source–specific server name; useful when a data source name is used during SQLConnect, SQLDriverConnect, and SQLBrowseConnect.
SQL_SPECIAL_CHARACTERS
+# (ODBC 2.0)		A character string containing all special characters (that is, all characters except a through z, A through Z, 0 through 9, and underscore) that can be used in an identifier name, such as a table name, column column name, or index name, on the data source. For example, "#$^". If an identifier contains one or more of these characters, the identifier must be a delimited identifier.
SQL_SQL_CONFORMANCE
+# (ODBC 3.0)		An SQLUINTEGER value indicating the level of SQL-92 supported by the driver: +#

SQL_SC_SQL92_ENTRY = Entry level SQL-92 compliant.

+# +#

SQL_SC_FIPS127_2_TRANSITIONAL = FIPS 127-2 transitional level compliant.

+# +#

SQL_SC_SQL92_FULL = Full level SQL-92 compliant.

+# +#

SQL_SC_ SQL92_INTERMEDIATE = Intermediate level SQL-92 compliant.

+#
SQL_SQL92_DATETIME_FUNCTIONS
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the datetime scalar functions that are supported by the driver and the associated data source, as defined in SQL-92. +#

The following bitmasks are used to determine which datetime functions are supported:

+# +#

SQL_SDF_CURRENT_DATE
+# SQL_SDF_CURRENT_TIME
+# SQL_SDF_CURRENT_TIMESTAMP

+#
SQL_SQL92_FOREIGN_KEY_DELETE_RULE
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the rules supported for a foreign key in a DELETE statement, as defined in SQL-92. +#

The following bitmasks are used to determine which clauses are supported by the data source:

+# +#

SQL_SFKD_CASCADE
+# SQL_SFKD_NO_ACTION
+# SQL_SFKD_SET_DEFAULT
+# SQL_SFKD_SET_NULL

+# +#

An FIPS Transitional level–conformant driver will always return all of these options as supported.

+#
SQL_SQL92_FOREIGN_KEY_UPDATE_RULE
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the rules supported for a foreign key in an UPDATE statement, as defined in SQL-92. +#

The following bitmasks are used to determine which clauses are supported by the data source:

+# +#

SQL_SFKU_CASCADE
+# SQL_SFKU_NO_ACTION
+# SQL_SFKU_SET_DEFAULT
+# SQL_SFKU_SET_NULL

+# +#

An SQL-92 Full level–conformant driver will always return all of these options as supported.

+#
SQL_SQL92_GRANT
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses supported in the GRANT statement, as defined in SQL-92. +#

The SQL-92 or FIPS conformance level at which this feature needs to be supported is shown in parentheses next to each bitmask.

+# +#

The following bitmasks are used to determine which clauses are supported by the data source:

+# +#

SQL_SG_DELETE_TABLE (Entry level)
+# SQL_SG_INSERT_COLUMN (Intermediate level)
+# SQL_SG_INSERT_TABLE (Entry level)
+# SQL_SG_REFERENCES_TABLE (Entry level)
+# SQL_SG_REFERENCES_COLUMN (Entry level)
+# SQL_SG_SELECT_TABLE (Entry level)
+# SQL_SG_UPDATE_COLUMN (Entry level)
+# SQL_SG_UPDATE_TABLE (Entry level)
+# SQL_SG_USAGE_ON_DOMAIN (FIPS Transitional level)
+# SQL_SG_USAGE_ON_CHARACTER_SET (FIPS Transitional level)
+# SQL_SG_USAGE_ON_COLLATION (FIPS Transitional level)
+# SQL_SG_USAGE_ON_TRANSLATION (FIPS Transitional level)
+# SQL_SG_WITH_GRANT_OPTION (Entry level)

+#
SQL_SQL92_NUMERIC_VALUE_FUNCTIONS
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the numeric value scalar functions that are supported by the driver and the associated data source, as defined in SQL-92. +#

The following bitmasks are used to determine which numeric functions are supported:

+# +#

SQL_SNVF_BIT_LENGTH
+# SQL_SNVF_CHAR_LENGTH
+# SQL_SNVF_CHARACTER_LENGTH
+# SQL_SNVF_EXTRACT
+# SQL_SNVF_OCTET_LENGTH
+# SQL_SNVF_POSITION

+#
SQL_SQL92_PREDICATES
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the predicates supported in a SELECT statement, as defined in SQL-92. +#

The SQL-92 or FIPS conformance level at which this feature needs to be supported is shown in parentheses next to each bitmask.

+# +#

The following bitmasks are used to determine which options are supported by the data source:

+# +#

SQL_SP_BETWEEN (Entry level)
+# SQL_SP_COMPARISON (Entry level)
+# SQL_SP_EXISTS (Entry level)
+# SQL_SP_IN (Entry level)
+# SQL_SP_ISNOTNULL (Entry level)
+# SQL_SP_ISNULL (Entry level)
+# SQL_SP_LIKE (Entry level)
+# SQL_SP_MATCH_FULL (Full level)
+# SQL_SP_MATCH_PARTIAL(Full level)
+# SQL_SP_MATCH_UNIQUE_FULL (Full level)
+# SQL_SP_MATCH_UNIQUE_PARTIAL (Full level)
+# SQL_SP_OVERLAPS (FIPS Transitional level)
+# SQL_SP_QUANTIFIED_COMPARISON (Entry level)
+# SQL_SP_UNIQUE (Entry level)

+#
SQL_SQL92_RELATIONAL_JOIN_OPERATORS
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the relational join operators supported in a SELECT statement, as defined in SQL-92. +#

The SQL-92 or FIPS conformance level at which this feature needs to be supported is shown in parentheses next to each bitmask.

+# +#

The following bitmasks are used to determine which options are supported by the data source:

+# +#

SQL_SRJO_CORRESPONDING_CLAUSE (Intermediate level)
+# SQL_SRJO_CROSS_JOIN (Full level)
+# SQL_SRJO_EXCEPT_JOIN (Intermediate level)
+# SQL_SRJO_FULL_OUTER_JOIN (Intermediate level)
+# SQL_SRJO_INNER_JOIN (FIPS Transitional level)
+# SQL_SRJO_INTERSECT_JOIN (Intermediate level)
+# SQL_SRJO_LEFT_OUTER_JOIN (FIPS Transitional level)
+# SQL_SRJO_NATURAL_JOIN (FIPS Transitional level)
+# SQL_SRJO_RIGHT_OUTER_JOIN (FIPS Transitional level)
+# SQL_SRJO_UNION_JOIN (Full level)

+# +#

SQL_SRJO_INNER_JOIN indicates support for the INNER JOIN syntax, not for the inner join capability. Support for the INNER JOIN syntax is FIPS TRANSITIONAL, while support for the inner join capability is ENTRY.

+#
SQL_SQL92_REVOKE
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the clauses supported in the REVOKE statement, as defined in SQL-92, supported by the data source. +#

The SQL-92 or FIPS conformance level at which this feature needs to be supported is shown in parentheses next to each bitmask.

+# +#

The following bitmasks are used to determine which clauses are supported by the data source:

+# +#

SQL_SR_CASCADE (FIPS Transitional level)
+# SQL_SR_DELETE_TABLE (Entry level)
+# SQL_SR_GRANT_OPTION_FOR (Intermediate level)
+# SQL_SR_INSERT_COLUMN (Intermediate level)
+# SQL_SR_INSERT_TABLE (Entry level)
+# SQL_SR_REFERENCES_COLUMN (Entry level)
+# SQL_SR_REFERENCES_TABLE (Entry level)
+# SQL_SR_RESTRICT (FIPS Transitional level)
+# SQL_SR_SELECT_TABLE (Entry level)
+# SQL_SR_UPDATE_COLUMN (Entry level)
+# SQL_SR_UPDATE_TABLE (Entry level)
+# SQL_SR_USAGE_ON_DOMAIN (FIPS Transitional level)
+# SQL_SR_USAGE_ON_CHARACTER_SET (FIPS Transitional level)
+# SQL_SR_USAGE_ON_COLLATION (FIPS Transitional level)
+# SQL_SR_USAGE_ON_TRANSLATION (FIPS Transitional level)

+#
SQL_SQL92_ROW_VALUE_CONSTRUCTOR
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the row value constructor expressions supported in a SELECT statement, as defined in SQL-92. The following bitmasks are used to determine which options are supported by the data source: +#

SQL_SRVC_VALUE_EXPRESSION
+# SQL_SRVC_NULL
+# SQL_SRVC_DEFAULT
+# SQL_SRVC_ROW_SUBQUERY

+#
SQL_SQL92_STRING_FUNCTIONS
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the string scalar functions that are supported by the driver and the associated data source, as defined in SQL-92. +#

The following bitmasks are used to determine which string functions are supported:

+# +#

SQL_SSF_CONVERT
+# SQL_SSF_LOWER
+# SQL_SSF_UPPER
+# SQL_SSF_SUBSTRING
+# SQL_SSF_TRANSLATE
+# SQL_SSF_TRIM_BOTH
+# SQL_SSF_TRIM_LEADING
+# SQL_SSF_TRIM_TRAILING

+#
SQL_SQL92_VALUE_EXPRESSIONS
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the value expressions supported, as defined in SQL-92. +#

The SQL-92 or FIPS conformance level at which this feature needs to be supported is shown in parentheses next to each bitmask.

+# +#

The following bitmasks are used to determine which options are supported by the data source:

+# +#

SQL_SVE_CASE (Intermediate level)
+# SQL_SVE_CAST (FIPS Transitional level)
+# SQL_SVE_COALESCE (Intermediate level)
+# SQL_SVE_NULLIF (Intermediate level)

+#
SQL_STANDARD_CLI_CONFORMANCE
+# (ODBC 3.0)		An SQLUINTEGER bitmask enumerating the CLI standard or standards to which the driver conforms. The following bitmasks are used to determine which levels the driver conforms to: +#

SQL_SCC_XOPEN_CLI_VERSION1: The driver conforms to the X/Open CLI version 1.

+# +#

SQL_SCC_ISO92_CLI: The driver conforms to the ISO 92 CLI.

+#
SQL_STATIC_CURSOR_ATTRIBUTES1
+# (ODBC 3.0)		An SQLUINTEGER bitmask that describes the attributes of a static cursor that are supported by the driver. This bitmask contains the first subset of attributes; for the second subset, see SQL_STATIC_CURSOR_ATTRIBUTES2. +#

The following bitmasks are used to determine which attributes are supported:

+# +#

SQL_CA1_NEXT
+# SQL_CA1_ABSOLUTE
+# SQL_CA1_RELATIVE
+# SQL_CA1_BOOKMARK
+# SQL_CA1_LOCK_NO_CHANGE
+# SQL_CA1_LOCK_EXCLUSIVE
+# SQL_CA1_LOCK_UNLOCK
+# SQL_CA1_POS_POSITION
+# SQL_CA1_POS_UPDATE
+# SQL_CA1_POS_DELETE
+# SQL_CA1_POS_REFRESH
+# SQL_CA1_POSITIONED_UPDATE
+# SQL_CA1_POSITIONED_DELETE
+# SQL_CA1_SELECT_FOR_UPDATE
+# SQL_CA1_BULK_ADD
+# SQL_CA1_BULK_UPDATE_BY_BOOKMARK
+# SQL_CA1_BULK_DELETE_BY_BOOKMARK
+# SQL_CA1_BULK_FETCH_BY_BOOKMARK

+# +#

For descriptions of these bitmasks, see SQL_DYNAMIC_CURSOR_ATTRIBUTES1 (and substitute "static cursor" for "dynamic cursor" in the descriptions).

+# +#

An SQL-92 Intermediate level–conformant driver will usually return the SQL_CA1_NEXT, SQL_CA1_ABSOLUTE, and SQL_CA1_RELATIVE options as supported, because the driver supports scrollable cursors through the embedded SQL FETCH statement. Because this does not directly determine the underlying SQL support, however, scrollable cursors may not be supported, even for an SQL-92 Intermediate level–conformant driver.

+#
SQL_STATIC_CURSOR_ATTRIBUTES2
+# (ODBC 3.0)		An SQLUINTEGER bitmask that describes the attributes of a static cursor that are supported by the driver. This bitmask contains the second subset of attributes; for the first subset, see SQL_STATIC_CURSOR_ATTRIBUTES1. +#

The following bitmasks are used to determine which attributes are supported:

+# +#

SQL_CA2_READ_ONLY_CONCURRENCY
+# SQL_CA2_LOCK_CONCURRENCY
+# SQL_CA2_OPT_ROWVER_CONCURRENCY
+# SQL_CA2_OPT_VALUES_CONCURRENCY
+# SQL_CA2_SENSITIVITY_ADDITIONS
+# SQL_CA2_SENSITIVITY_DELETIONS
+# SQL_CA2_SENSITIVITY_UPDATES
+# SQL_CA2_MAX_ROWS_SELECT
+# SQL_CA2_MAX_ROWS_INSERT
+# SQL_CA2_MAX_ROWS_DELETE
+# SQL_CA2_MAX_ROWS_UPDATE
+# SQL_CA2_MAX_ROWS_CATALOG
+# SQL_CA2_MAX_ROWS_AFFECTS_ALL
+# SQL_CA2_CRC_EXACT
+# SQL_CA2_CRC_APPROXIMATE
+# SQL_CA2_SIMULATE_NON_UNIQUE
+# SQL_CA2_SIMULATE_TRY_UNIQUE
+# SQL_CA2_SIMULATE_UNIQUE

+# +#

For descriptions of these bitmasks, see SQL_DYNAMIC_CURSOR_ATTRIBUTES2 (and substitute "static cursor" for "dynamic cursor" in the descriptions).

+#
SQL_STRING_FUNCTIONS
+# (ODBC 1.0) +#

The information type was introduced in ODBC 1.0; each bitmask is labeled with the version in which it was introduced.

+# 		An SQLUINTEGER bitmask enumerating the scalar string functions supported by the driver and associated data source. +#

The following bitmasks are used to determine which string functions are supported:

+# +#

SQL_FN_STR_ASCII (ODBC 1.0)
+# SQL_FN_STR_BIT_LENGTH (ODBC 3.0)
+# SQL_FN_STR_CHAR (ODBC 1.0)
+# SQL_FN_STR_CHAR_
+# LENGTH (ODBC 3.0)
+# SQL_FN_STR_CHARACTER_
+# LENGTH (ODBC 3.0)
+# SQL_FN_STR_CONCAT (ODBC 1.0)
+# SQL_FN_STR_DIFFERENCE (ODBC 2.0)
+# SQL_FN_STR_INSERT (ODBC 1.0)
+# SQL_FN_STR_LCASE (ODBC 1.0)
+# SQL_FN_STR_LEFT (ODBC 1.0)
+# SQL_FN_STR_LENGTH (ODBC 1.0)
+# SQL_FN_STR_LOCATE (ODBC 1.0)
+# SQL_FN_STR_LTRIM (ODBC 1.0)
+# SQL_FN_STR_OCTET_
+# LENGTH (ODBC 3.0)
+# SQL_FN_STR_POSITION (ODBC 3.0)
+# SQL_FN_STR_REPEAT (ODBC 1.0)
+# SQL_FN_STR_REPLACE (ODBC 1.0)
+# SQL_FN_STR_RIGHT (ODBC 1.0)
+# SQL_FN_STR_RTRIM (ODBC 1.0)
+# SQL_FN_STR_SOUNDEX (ODBC 2.0)
+# SQL_FN_STR_SPACE (ODBC 2.0)
+# SQL_FN_STR_SUBSTRING (ODBC 1.0)
+# SQL_FN_STR_UCASE (ODBC 1.0)

+# +#

If an application can call the LOCATE scalar function with the string_exp1, string_exp2, and start arguments, the driver returns the SQL_FN_STR_LOCATE bitmask. If an application can call the LOCATE scalar function with only the string_exp1 and string_exp2 arguments, the driver returns the SQL_FN_STR_LOCATE_2 bitmask. Drivers that fully support the LOCATE scalar function return both bitmasks.

+# +#

(For more information, see String Functions in Appendix E, "Scalar Functions.")

+#
SQL_SUBQUERIES
+# (ODBC 2.0)		An SQLUINTEGER bitmask enumerating the predicates that support subqueries: +#

SQL_SQ_CORRELATED_SUBQUERIES
+# SQL_SQ_COMPARISON
+# SQL_SQ_EXISTS
+# SQL_SQ_IN
+# SQL_SQ_QUANTIFIED

+# +#

The SQL_SQ_CORRELATED_SUBQUERIES bitmask indicates that all predicates that support subqueries support correlated subqueries.

+# +#

An SQL-92 Entry level–conformant driver will always return a bitmask in which all of these bits are set.

+#
SQL_SYSTEM_FUNCTIONS
+# (ODBC 1.0)		An SQLUINTEGER bitmask enumerating the scalar system functions supported by the driver and associated data source. +#

The following bitmasks are used to determine which system functions are supported:

+# +#

SQL_FN_SYS_DBNAME
+# SQL_FN_SYS_IFNULL
+# SQL_FN_SYS_USERNAME

+#
SQL_TABLE_TERM
+# (ODBC 1.0)		A character string with the data source vendor's name for a table; for example, "table" or "file". +#

This character string can be in upper, lower, or mixed case.

+# +#

An SQL-92 Entry level–conformant driver will always return "table".

+#
SQL_TIMEDATE_ADD_INTERVALS
+# (ODBC 2.0)		An SQLUINTEGER bitmask enumerating the timestamp intervals supported by the driver and associated data source for the TIMESTAMPADD scalar function. +#

The following bitmasks are used to determine which intervals are supported:

+# +#

SQL_FN_TSI_FRAC_SECOND
+# SQL_FN_TSI_SECOND
+# SQL_FN_TSI_MINUTE
+# SQL_FN_TSI_HOUR
+# SQL_FN_TSI_DAY
+# SQL_FN_TSI_WEEK
+# SQL_FN_TSI_MONTH
+# SQL_FN_TSI_QUARTER
+# SQL_FN_TSI_YEAR

+# +#

An FIPS Transitional level–conformant driver will always return a bitmask in which all of these bits are set.

+#
SQL_TIMEDATE_DIFF_INTERVALS
+# (ODBC 2.0)		An SQLUINTEGER bitmask enumerating the timestamp intervals supported by the driver and associated data source for the TIMESTAMPDIFF scalar function. +#

The following bitmasks are used to determine which intervals are supported:

+# +#

SQL_FN_TSI_FRAC_SECOND
+# SQL_FN_TSI_SECOND
+# SQL_FN_TSI_MINUTE
+# SQL_FN_TSI_HOUR
+# SQL_FN_TSI_DAY
+# SQL_FN_TSI_WEEK
+# SQL_FN_TSI_MONTH
+# SQL_FN_TSI_QUARTER
+# SQL_FN_TSI_YEAR

+# +#

An FIPS Transitional level–conformant driver will always return a bitmask in which all of these bits are set.

+#
SQL_TIMEDATE_FUNCTIONS
+# (ODBC 1.0) +#

The information type was introduced in ODBC 1.0; each bitmask is labeled with the version in which it was introduced.

+# 		An SQLUINTEGER bitmask enumerating the scalar date and time functions supported by the driver and associated data source. +#

The following bitmasks are used to determine which date and time functions are supported:

+# +#

SQL_FN_TD_CURRENT_DATE ODBC 3.0)
+# SQL_FN_TD_CURRENT_TIME (ODBC 3.0)
+# SQL_FN_TD_CURRENT_TIMESTAMP (ODBC 3.0)
+# SQL_FN_TD_CURDATE (ODBC 1.0)
+# SQL_FN_TD_CURTIME (ODBC 1.0)
+# SQL_FN_TD_DAYNAME (ODBC 2.0)
+# SQL_FN_TD_DAYOFMONTH (ODBC 1.0)
+# SQL_FN_TD_DAYOFWEEK (ODBC 1.0)
+# SQL_FN_TD_DAYOFYEAR (ODBC 1.0)
+# SQL_FN_TD_EXTRACT (ODBC 3.0)
+# SQL_FN_TD_HOUR (ODBC 1.0)
+# SQL_FN_TD_MINUTE (ODBC 1.0)
+# SQL_FN_TD_MONTH (ODBC 1.0)
+# SQL_FN_TD_MONTHNAME (ODBC 2.0)
+# SQL_FN_TD_NOW (ODBC 1.0)
+# SQL_FN_TD_QUARTER (ODBC 1.0)
+# SQL_FN_TD_SECOND (ODBC 1.0)
+# SQL_FN_TD_TIMESTAMPADD (ODBC 2.0)
+# SQL_FN_TD_TIMESTAMPDIFF (ODBC 2.0)
+# SQL_FN_TD_WEEK (ODBC 1.0)
+# SQL_FN_TD_YEAR (ODBC 1.0)

+#
SQL_TXN_CAPABLE
+# (ODBC 1.0) +#

The information type was introduced in ODBC 1.0; each return value is labeled with the version in which it was introduced.

+# 		An SQLUSMALLINT value describing the transaction support in the driver or data source: +#

SQL_TC_NONE = Transactions not supported. (ODBC 1.0)

+# +#

SQL_TC_DML = Transactions can contain only Data Manipulation Language (DML) statements (SELECT, INSERT, UPDATE, DELETE). Data Definition Language (DDL) statements encountered in a transaction cause an error. (ODBC 1.0)

+# +#

SQL_TC_DDL_COMMIT = Transactions can contain only DML statements. DDL statements (CREATE TABLE, DROP INDEX, and so on) encountered in a transaction cause the transaction to be committed. (ODBC 2.0)

+# +#

SQL_TC_DDL_IGNORE = Transactions can contain only DML statements. DDL statements encountered in a transaction are ignored. (ODBC 2.0)

+# +#

SQL_TC_ALL = Transactions can contain DDL statements and DML statements in any order. (ODBC 1.0)

+# +#

(Because support of transactions is mandatory in SQL-92, an SQL-92 conformant driver [any level] will never return SQL_TC_NONE.)

+#
SQL_TXN_ISOLATION_OPTION
+# (ODBC 1.0)		An SQLUINTEGER bitmask enumerating the transaction isolation levels available from the driver or data source. +#

The following bitmasks are used in conjunction with the flag to determine which options are supported:

+# +#

SQL_TXN_READ_UNCOMMITTED
+# SQL_TXN_READ_COMMITTED
+# SQL_TXN_REPEATABLE_READ
+# SQL_TXN_SERIALIZABLE

+# +#

For descriptions of these isolation levels, see the description of SQL_DEFAULT_TXN_ISOLATION.

+# +#

To set the transaction isolation level, an application calls SQLSetConnectAttr to set the SQL_ATTR_TXN_ISOLATION attribute. For more information, see SQLSetConnectAttr.

+# +#

An SQL-92 Entry level–conformant driver will always return SQL_TXN_SERIALIZABLE as supported. A FIPS Transitional level–conformant driver will always return all of these options as supported.

+#
SQL_UNION
+# (ODBC 2.0)		An SQLUINTEGER bitmask enumerating the support for the UNION clause: +#

SQL_U_UNION = The data source supports the UNION clause.

+# +#

SQL_U_UNION_ALL = The data source supports the ALL keyword in the UNION clause. (SQLGetInfo returns both SQL_U_UNION and SQL_U_UNION_ALL in this case.)

+# +#

An SQL-92 Entry level–conformant driver will always return both of these options as supported.

+#
SQL_USER_NAME
+# (ODBC 1.0)		A character string with the name used in a particular database, which can be different from the login name.
SQL_XOPEN_CLI_YEAR
+# (ODBC 3.0)		A character string that indicates the year of publication of the X/Open specification with which the version of the ODBC Driver Manager fully complies.
+# +#

Code Example

+# +#

SQLGetInfo returns lists of supported options as an SQLUINTEGER bitmask in *InfoValuePtr. The bitmask for each option is used in conjunction with the flag to determine whether the option is supported.

+# +#

For example, an application could use the following code to determine whether the SUBSTRING scalar function is supported by the driver associated with the connection:

+# +# 
SQLUINTEGER    fFuncs;
+#	
+#	SQLGetInfo(hdbc,
+#	   SQL_STRING_FUNCTIONS,
+#	   (SQLPOINTER)&fFuncs,
+#	   sizeof(fFuncs),
+#	   NULL);
+#	
+#	if (fFuncs & SQL_FN_STR_SUBSTRING)   /* SUBSTRING supported */
+#	      ;
+#	else                                 /* SUBSTRING not supported */
+#	      ;
+# +#

Related Functions

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
For information aboutSee
Returning the setting of a connection attributeSQLGetConnectAttr
Determining whether a driver supports a functionSQLGetFunctions
Returning the setting of a statement attributeSQLGetStmtAttr
Returning information about a data source's data typesSQLGetTypeInfo
+#

+# +#
+# +# +# +}; + +print <{$name}; + my $type = $p->{type}; + $type =~ /^(Char|YesNo|Short|Long|Bitmask)$/ + or die "$name: bad type $type"; + my $defstr = $type eq "YesNo" ? q("N") : $type eq "Char" ? q("") : q(0); + my $s = <{omit}) { + $s ="#if 0\n" . $s . "#endif\n"; + } + print $s; +}; + +print < "UNDEF", + type => q(Undef), + nullable => q(true), + position => 0, + }, +# +# +# +# SQLGetTypeInfo +# +# +# +# +# +# +#
+#
+# +# +# +# +#
+# ODBC Programmer's Reference +#
+#
+#
+#
+# +#

SQLGetTypeInfo

+# +#

Conformance

+# +#

Version Introduced: ODBC 1.0
+# Standards Compliance: ISO 92

+# +#

Summary

+# +#

SQLGetTypeInfo returns information about data types supported by the data source. The driver returns the information in the form of an SQL result set. The data types are intended for use in Data Definition Language (DDL) statements.

+# +#

Important   Applications must use the type names returned in the TYPE_NAME column of the SQLGetTypeInfo result set in ALTER TABLE and CREATE TABLE statements. SQLGetTypeInfo may return more than one row with the same value in the DATA_TYPE column.

+# +#

Syntax

+# +# 
SQLRETURN SQLGetTypeInfo(
+#	     SQLHSTMT     StatementHandle,
+#	     SQLSMALLINT     DataType);
+# +#

Arguments +# +#

+#
StatementHandle
+# +#
[Input]
+# Statement handle for the result set.
+# +#
DataType
+# +#
[Input]
+# The SQL data type. This must be one of the values in the "SQL Data Types" section of Appendix D: Data Types, or a driver-specific SQL data type. SQL_ALL_TYPES specifies that information about all data types should be returned.
+#
+# +#

Returns

+# +#

SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_STILL_EXECUTING, SQL_ERROR, or SQL_INVALID_HANDLE.

+# +#

Diagnostics

+# +#

When SQLGetTypeInfo returns SQL_ERROR or SQL_SUCCESS_WITH_INFO, an associated SQLSTATE value can be obtained by calling SQLGetDiagRec with a HandleType of SQL_HANDLE_STMT and a Handle of StatementHandle. The following table lists the SQLSTATE values commonly returned by SQLGetTypeInfo and explains each one in the context of this function; the notation "(DM)" precedes the descriptions of SQLSTATEs returned by the Driver Manager. The return code associated with each SQLSTATE value is SQL_ERROR, unless noted otherwise.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
SQLSTATEErrorDescription
01000General warningDriver-specific informational message. (Function returns SQL_SUCCESS_WITH_INFO.)
01S02Option value changedA specified statement attribute was invalid because of implementation working conditions, so a similar value was temporarily substituted. (Call SQLGetStmtAttr to determine the temporarily substituted value.) The substitute value is valid for the StatementHandle until the cursor is closed. The statement attributes that can be changed are: SQL_ATTR_CONCURRENCY, SQL_ATTR_CURSOR_TYPE, SQL_ATTR_KEYSET_SIZE, SQL_ATTR_MAX_LENGTH, SQL_ATTR_MAX_ROWS, SQL_ATTR_QUERY_TIMEOUT, and SQL_ATTR_SIMULATE_CURSOR. (Function returns SQL_SUCCESS_WITH_INFO.)
08S01Communication link failureThe communication link between the driver and the data source to which the driver was connected failed before the function completed processing.
24000Invalid cursor stateA cursor was open on the StatementHandle, and SQLFetch or SQLFetchScroll had been called. This error is returned by the Driver Manager if SQLFetch or SQLFetchScroll has not returned SQL_NO_DATA, and is returned by the driver if SQLFetch or SQLFetchScroll has returned SQL_NO_DATA. +#

A result set was open on the StatementHandle, but SQLFetch or SQLFetchScroll had not been called.

+#
40001Serialization failureThe transaction was rolled back due to a resource deadlock with another transaction.
40003Statement completion unknownThe associated connection failed during the execution of this function and the state of the transaction cannot be determined.
HY000General errorAn error occurred for which there was no specific SQLSTATE and for which no implementation-specific SQLSTATE was defined. The error message returned by SQLGetDiagRec in the *MessageText buffer describes the error and its cause.
HY001Memory allocation errorThe driver was unable to allocate memory required to support execution or completion of the function.
HY004Invalid SQL data typeThe value specified for the argument DataType was neither a valid ODBC SQL data type identifier nor a driver-specific data type identifier supported by the driver.
HY008Operation canceledAsynchronous processing was enabled for the StatementHandle, then the function was called and, before it completed execution, SQLCancel was called on the StatementHandle. Then the function was called again on the StatementHandle. +#

The function was called and, before it completed execution, SQLCancel was called on the StatementHandle from a different thread in a multithread application.

+#
HY010Function sequence error(DM) An asynchronously executing function (not this one) was called for the StatementHandle and was still executing when this function was called. +#

(DM) SQLExecute, SQLExecDirect, SQLBulkOperations, or SQLSetPos was called for the StatementHandle and returned SQL_NEED_DATA. This function was called before data was sent for all data-at-execution parameters or columns.

+#
HY013Memory management errorThe function call could not be processed because the underlying memory objects could not be accessed, possibly because of low memory conditions.
HYC00Optional feature not implementedThe combination of the current settings of the SQL_ATTR_CONCURRENCY and SQL_ATTR_CURSOR_TYPE statement attributes was not supported by the driver or data source. +#

The SQL_ATTR_USE_BOOKMARKS statement attribute was set to SQL_UB_VARIABLE, and the SQL_ATTR_CURSOR_TYPE statement attribute was set to a cursor type for which the driver does not support bookmarks.

+#
HYT00Timeout expiredThe query timeout period expired before the data source returned the result set. The timeout period is set through SQLSetStmtAttr, SQL_ATTR_QUERY_TIMEOUT.
HYT01Connection timeout expiredThe connection timeout period expired before the data source responded to the request. The connection timeout period is set through SQLSetConnectAttr, SQL_ATTR_CONNECTION_TIMEOUT.
IM001Driver does not support this function(DM) The driver corresponding to the StatementHandle does not support the function.
+# +#

Comments

+# +#

SQLGetTypeInfo returns the results as a standard result set, ordered by DATA_TYPE and then by how closely the data type maps to the corresponding ODBC SQL data type. Data types defined by the data source take precedence over user-defined data types. Consequently, the sort order is not necessarily consistent but can be generalized as DATA_TYPE first, followed by TYPE_NAME, both ascending. For example, suppose that a data source defined INTEGER and COUNTER data types, where COUNTER is auto-incrementing, and that a user-defined data type WHOLENUM has also been defined. These would be returned in the order INTEGER, WHOLENUM, and COUNTER, because WHOLENUM maps closely to the ODBC SQL data type SQL_INTEGER, while the auto-incrementing data type, even though supported by the data source, does not map closely to an ODBC SQL data type. For information about how this information might be used, see "DDL Statements" in Chapter 8: SQL Statements.

+# +#

If the DataType argument specifies a data type which is valid for the version of ODBC supported by the driver, but is not supported by the driver, then it will return an empty result set.

+# +#

Note   For more information about the general use, arguments, and returned data of ODBC catalog functions, see Chapter 7: Catalog Functions.

+# +#

The following columns have been renamed for ODBC 3.x. The column name changes do not affect backward compatibility because applications bind by column number.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
ODBC 2.0 columnODBC 3.x column
PRECISIONCOLUMN_SIZE
MONEYFIXED_PREC_SCALE
AUTO_INCREMENTAUTO_UNIQUE_VALUE
+# +#

The following columns have been added to the results set returned by SQLGetTypeInfo for ODBC 3.x: +# +#

    +#
  • SQL_DATA_TYPE
    • +# +#
  • INTERVAL_PRECISION
    • +# +#
  • SQL_DATETIME_SUB
    • +# +#
  • NUM_PREC_RADIX
    • +#
+# +#

The following table lists the columns in the result set. Additional columns beyond column 19 (INTERVAL_PRECISION) can be defined by the driver. An application should gain access to driver-specific columns by counting down from the end of the result set rather than specifying an explicit ordinal position. For more information, see "Data Returned by Catalog Functions" in Chapter 7: Catalog Functions.

+# +#

Note   SQLGetTypeInfo might not return all data types. For example, a driver might not return user-defined data types. Applications can use any valid data type, regardless of whether it is returned by SQLGetTypeInfo.

+# +#

The data types returned by SQLGetTypeInfo are those supported by the data source. They are intended for use in Data Definition Language (DDL) statements. Drivers can return result-set data using data types other than the types returned by SQLGetTypeInfo. In creating the result set for a catalog function, the driver might use a data type that is not supported by the data source.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# + { name => "TYPE_NAME", + type => q(Varchar), + length => 20, + nullable => q(false), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "DATA_TYPE", + type => q(Smallint), + length => undef, + nullable => q(false), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "COLUMN_SIZE", + type => q(Integer), + length => undef, + nullable => q(true), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "LITERAL_PREFIX", + type => q(Varchar), + length => 1, + nullable => q(true), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "LITERAL_SUFFIX", + type => q(Varchar), + length => 1, + nullable => q(true), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "CREATE_PARAMS", + type => q(Varchar), + length => 20, + nullable => q(true), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "NULLABLE", + type => q(Smallint), + length => undef, + nullable => q(false), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "CASE_SENSITIVE", + type => q(Smallint), + length => undef, + nullable => q(false), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "SEARCHABLE", + type => q(Smallint), + length => undef, + nullable => q(false), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "UNSIGNED_ATTRIBUTE", + type => q(Smallint), + length => undef, + nullable => q(true), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "FIXED_PREC_SCALE", + type => q(Smallint), + length => undef, + nullable => q(false), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "AUTO_UNIQUE_VALUE", + type => q(Smallint), + length => undef, + nullable => q(true), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "LOCAL_TYPE_NAME", + type => q(Varchar), + length => 20, + nullable => q(true), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "MINIMUM_SCALE", + type => q(Smallint), + length => undef, + nullable => q(true), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "MAXIMUM_SCALE", + type => q(Smallint), + length => undef, + nullable => q(true), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "SQL_DATA_TYPE", + type => q(Smallint), + length => undef, + nullable => q(false), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "SQL_DATETIME_SUB", + type => q(Smallint), + length => undef, + nullable => q(true), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "NUM_PREC_RADIX", + type => q(Integer), + length => undef, + nullable => q(true), + position => ++$position, + }, +# +# +# +# +# +# +# + { name => "INTERVAL_PRECISION", + type => q(Smallint), + length => undef, + nullable => q(true), + position => ++$position, + }, +#

+# Column name		Column
+# number
+# Data type
+# Comments
TYPE_NAME
+# (ODBC 2.0)		1Varchar
+# not NULL		Data source–dependent data-type name; for example, "CHAR()", "VARCHAR()", "MONEY", "LONG VARBINARY", or "CHAR ( ) FOR BIT DATA". Applications must use this name in CREATE TABLE and ALTER TABLE statements.
DATA_TYPE
+# (ODBC 2.0)		2Smallint
+# not NULL		SQL data type. This can be an ODBC SQL data type or a driver-specific SQL data type. For datetime or interval data types, this column returns the concise data type (such as SQL_TYPE_TIME or SQL_INTERVAL_YEAR_TO_MONTH). For a list of valid ODBC SQL data types, see "SQL Data Types" in Appendix D: Data Types. For information about driver-specific SQL data types, see the driver’s documentation.
COLUMN_SIZE
+# (ODBC 2.0)		3IntegerThe maximum column size that the server supports for this data type. For numeric data, this is the maximum precision. For string data, this is the length in characters. For datetime data types, this is the length in characters of the string representation (assuming the maximum allowed precision of the fractional seconds component). NULL is returned for data types where column size is not applicable. For interval data types, this is the number of characters in the character representation of the interval literal (as defined by the interval leading precision; see "Interval Data Type Length" in Appendix D: Data Types). +#

For more information on column size, see "Column Size, Decimal Digits, Transfer Octet Length, and Display Size" in Appendix D: Data Types.

+#
LITERAL_PREFIX
+# (ODBC 2.0)		4VarcharCharacter or characters used to prefix a literal; for example, a single quotation mark (') for character data types or 0x for binary data types; NULL is returned for data types where a literal prefix is not applicable.
LITERAL_SUFFIX
+# (ODBC 2.0)		5VarcharCharacter or characters used to terminate a literal; for example, a single quotation mark (') for character data types; NULL is returned for data types where a literal suffix is not applicable.
CREATE_PARAMS
+# (ODBC 2.0)		6VarcharA list of keywords, separated by commas, corresponding to each parameter that the application may specify in parentheses when using the name that is returned in the TYPE_NAME field. The keywords in the list can be any of the following: length, precision, or scale. They appear in the order that the syntax requires them to be used. For example, CREATE_PARAMS for DECIMAL would be "precision,scale"; CREATE_PARAMS for VARCHAR would equal "length." NULL is returned if there are no parameters for the data type definition; for example, INTEGER. +#

The driver supplies the CREATE_PARAMS text in the language of the country where it is used.

+#
NULLABLE
+# (ODBC 2.0)		7Smallint
+# not NULL		Whether the data type accepts a NULL value: +#

SQL_NO_NULLS if the data type does not accept NULL values.

+# +#

SQL_NULLABLE if the data type accepts NULL values.

+# +#

SQL_NULLABLE_UNKNOWN if it is not known whether the column accepts NULL values.

+#
CASE_SENSITIVE
+# (ODBC 2.0)		8Smallint
+# not NULL		Whether a character data type is case-sensitive in collations and comparisons: +#

SQL_TRUE if the data type is a character data type and is case-sensitive.

+# +#

SQL_FALSE if the data type is not a character data type or is not case-sensitive.

+#
SEARCHABLE
+# (ODBC 2.0)		9Smallint
+# not NULL		How the data type is used in a WHERE clause: +#

SQL_PRED_NONE if the column cannot be used in a WHERE clause. (This is the same as the SQL_UNSEARCHABLE value in ODBC 2.x.)

+# +#

SQL_PRED_CHAR if the column can be used in a WHERE clause, but only with the LIKE predicate. (This is the same as the SQL_LIKE_ONLY value in ODBC 2.x.)

+# +#

SQL_PRED_BASIC if the column can be used in a WHERE clause with all the comparison operators except LIKE (comparison, quantified comparison, BETWEEN, DISTINCT, IN, MATCH, and UNIQUE). (This is the same as the SQL_ALL_EXCEPT_LIKE value in ODBC 2.x.)

+# +#

SQL_SEARCHABLE if the column can be used in a WHERE clause with any comparison operator.

+#
UNSIGNED_ATTRIBUTE
+# (ODBC 2.0)		10SmallintWhether the data type is unsigned: +#

SQL_TRUE if the data type is unsigned.

+# +#

SQL_FALSE if the data type is signed.

+# +#

NULL is returned if the attribute is not applicable to the data type or the data type is not numeric.

+#
FIXED_PREC_SCALE
+# (ODBC 2.0)		11Smallint
+# not NULL		Whether the data type has predefined fixed precision and scale (which are data source–specific), such as a money data type: +#

SQL_TRUE if it has predefined fixed precision and scale.

+# +#

SQL_FALSE if it does not have predefined fixed precision and scale.

+#
AUTO_UNIQUE_VALUE
+# (ODBC 2.0)		12SmallintWhether the data type is autoincrementing: +#

SQL_TRUE if the data type is autoincrementing.

+# +#

SQL_FALSE if the data type is not autoincrementing.

+# +#

NULL is returned if the attribute is not applicable to the data type or the data type is not numeric.

+# +#

An application can insert values into a column having this attribute, but typically cannot update the values in the column.

+# +#

When an insert is made into an auto-increment column, a unique value is inserted into the column at insert time. The increment is not defined, but is data source–specific. An application should not assume that an auto-increment column starts at any particular point or increments by any particular value.

+#
LOCAL_TYPE_NAME
+# (ODBC 2.0)		13VarcharLocalized version of the data source–dependent name of the data type. NULL is returned if a localized name is not supported by the data source. This name is intended for display only, such as in dialog boxes.
MINIMUM_SCALE
+# (ODBC 2.0)		14SmallintThe minimum scale of the data type on the data source. If a data type has a fixed scale, the MINIMUM_SCALE and MAXIMUM_SCALE columns both contain this value. For example, an SQL_TYPE_TIMESTAMP column might have a fixed scale for fractional seconds. NULL is returned where scale is not applicable. For more information, see "Column Size, Decimal Digits, Transfer Octet Length, and Display Size" in Appendix D: Data Types.
MAXIMUM_SCALE
+# (ODBC 2.0)		15SmallintThe maximum scale of the data type on the data source. NULL is returned where scale is not applicable. If the maximum scale is not defined separately on the data source, but is instead defined to be the same as the maximum precision, this column contains the same value as the COLUMN_SIZE column. For more information, see "Column Size, Decimal Digits, Transfer Octet Length, and Display Size" in Appendix D: Data Types.
SQL_DATA_TYPE
+# (ODBC 3.0)		16Smallint NOT NULLThe value of the SQL data type as it appears in the SQL_DESC_TYPE field of the descriptor. This column is the same as the DATA_TYPE column, except for interval and datetime data types. +#

For interval and datetime data types, the SQL_DATA_TYPE field in the result set will return SQL_INTERVAL or SQL_DATETIME, and the SQL_DATETIME_SUB field will return the subcode for the specific interval or datetime data type. (See Appendix D: Data Types.)

+#
SQL_DATETIME_SUB
+# (ODBC 3.0)		17SmallintWhen the value of SQL_DATA_TYPE is SQL_DATETIME or SQL_INTERVAL, this column contains the datetime/interval subcode. For data types other than datetime and interval, this field is NULL. +#

For interval or datetime data types, the SQL_DATA_TYPE field in the result set will return SQL_INTERVAL or SQL_DATETIME, and the SQL_DATETIME_SUB field will return the subcode for the specific interval or datetime data type. (See Appendix D: Data Types.)

+#
NUM_PREC_RADIX
+# (ODBC 3.0)		18IntegerIf the data type is an approximate numeric type, this column contains the value 2 to indicate that COLUMN_SIZE specifies a number of bits. For exact numeric types, this column contains the value 10 to indicate that COLUMN_SIZE specifies a number of decimal digits. Otherwise, this column is NULL.
INTERVAL_PRECISION
+# (ODBC 3.0)		19SmallintIf the data type is an interval data type, then this column contains the value of the interval leading precision. (See "Interval Data Type Precision" in Appendix D: Data Types.) Otherwise, this column is NULL.
+# +#

Attribute information can apply to data types or to specific columns in a result set. SQLGetTypeInfo returns information about attributes associated with data types; SQLColAttribute returns information about attributes associated with columns in a result set.

+# +#

Related Functions

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
For information aboutSee
Binding a buffer to a column in a result setSQLBindCol
Canceling statement processingSQLCancel
Returning information about a column in a result setSQLColAttribute
Fetching a block of data or scrolling through a result setSQLFetchScroll
Fetching a single row or a block of data in a forward-only directionSQLFetch
Returning information about a driver or data sourceSQLGetInfo
+#

+# +#
+# +# +# +); + +my $i4 = " " x 4; +print "// template-begin\n"; +print "#define Varchar Char\n"; +print "#define Smallint Integer\n"; +print "const SqlTypeInfo::Column\nSqlTypeInfo::m_columnList[] = {\n"; +for my $p (@typeinfo) { + print "$i4\{\t$p->{position},\n"; + print "\t\"$p->{name}\",\n"; + my $type = $p->{type}; + if ($p->{position} == 0) { + print "\tSqlType()\n"; + } elsif (! $p->{length}) { + print "\tSqlType(SqlType::$type, $p->{nullable})\n"; + } else { + print "\tSqlType(SqlType::$type, $p->{length}, $p->{nullable})\n"; + } + my $c = $p == $typeinfo[-1] ? "" : ","; + print "$i4\}$c\n"; +} +print "};\n"; +print "#undef Varchar\n"; +print "#undef Smallint\n"; +print "const unsigned\nSqlTypeInfo::m_columnCount = $position;\n"; +print "// template-end\n"; + +# vim: set sw=4: diff --git a/ndb/src/client/odbc/docs/handleattr.pl b/ndb/src/client/odbc/docs/handleattr.pl new file mode 100644 index 00000000000..892d34b105b --- /dev/null +++ b/ndb/src/client/odbc/docs/handleattr.pl @@ -0,0 +1,2232 @@ +# usage: perl Attr.data X (X = Env,Dbc,Stmt) +# prints template for AttrX.cpp +use strict; +my $type = shift; +my $order = 0; + +# +# odbcsqlsetenvattr.htm +# +my $attrEnv = { +# +# +# +# SQLSetEnvAttr +# +# +# +# +# +# +#
+#
+# +# +# +# +#
+# ODBC Programmer's Reference +#
+#
+#
+#
+# +#

SQLSetEnvAttr

+# +#

Conformance

+# +#

Version Introduced: ODBC 3.0
+# Standards Compliance: ISO 92

+# +#

Summary

+# +#

SQLSetEnvAttr sets attributes that govern aspects of environments.

+# +#

Syntax

+# +# 
SQLRETURN SQLSetEnvAttr(
+#	     SQLHENV     EnvironmentHandle,
+#	     SQLINTEGER     Attribute,
+#	     SQLPOINTER     ValuePtr,
+#	     SQLINTEGER     StringLength);
+# +#

Arguments +# +#

+#
EnvironmentHandle
+# +#
[Input]
+# Environment handle.
+# +#
Attribute
+# +#
[Input]
+# Attribute to set, listed in "Comments."
+# +#
ValuePtr
+# +#
[Input]
+# Pointer to the value to be associated with Attribute. Depending on the value of Attribute, ValuePtr will be a 32-bit integer value or point to a null-terminated character string.
+# +#
StringLength
+# +#
[Input] If ValuePtr points to a character string or a binary buffer, this argument should be the length of *ValuePtr. If ValuePtr is an integer, StringLength is ignored.
+#
+# +#

Returns

+# +#

SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_ERROR, or SQL_INVALID_HANDLE.

+# +#

Diagnostics

+# +#

When SQLSetEnvAttr returns SQL_ERROR or SQL_SUCCESS_WITH_INFO, an associated SQLSTATE value can be obtained by calling SQLGetDiagRec with a HandleType of SQL_HANDLE_ENV and a Handle of EnvironmentHandle. The following table lists the SQLSTATE values commonly returned by SQLSetEnvAttr and explains each one in the context of this function; the notation "(DM)" precedes the descriptions of SQLSTATEs returned by the Driver Manager. The return code associated with each SQLSTATE value is SQL_ERROR, unless noted otherwise. If a driver does not support an environment attribute, the error can be returned only during connect time.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
SQLSTATEErrorDescription
01000General warningDriver-specific informational message. (Function returns SQL_SUCCESS_WITH_INFO.)
01S02Option value changedThe driver did not support the value specified in ValuePtr and substituted a similar value. (Function returns SQL_SUCCESS_WITH_INFO.)
HY000General errorAn error occurred for which there was no specific SQLSTATE and for which no implementation-specific SQLSTATE was defined. The error message returned by SQLGetDiagRec in the *MessageText buffer describes the error and its cause.
HY001Memory allocation
+# error		The driver was unable to allocate memory required to support execution or completion of the function.
HY009Invalid use of null pointerThe Attribute argument identified an environment attribute that required a string value, and the ValuePtr argument was a null pointer.
HY010Function sequence error(DM) A connection handle has been allocated on EnvironmentHandle.
HY013Memory management errorThe function call could not be processed because the underlying memory objects could not be accessed, possibly because of low memory conditions.
HY024Invalid attribute valueGiven the specified Attribute value, an invalid value was specified in ValuePtr.
HY090Invalid string or buffer lengthThe StringLength argument was less than 0 but was not SQL_NTS.
HY092Invalid attribute/option identifier(DM) The value specified for the argument Attribute was not valid for the version of ODBC supported by the driver.
HYC00Optional feature not implementedThe value specified for the argument Attribute was a valid ODBC environment attribute for the version of ODBC supported by the driver, but was not supported by the driver. +#

(DM) The Attribute argument was SQL_ATTR_OUTPUT_NTS, and ValuePtr was SQL_FALSE.

+#
+# +#

Comments

+# +#

An application can call SQLSetEnvAttr only if no connection handle is allocated on the environment. All environment attributes successfully set by the application for the environment persist until SQLFreeHandle is called on the environment. More than one environment handle can be allocated simultaneously in ODBC 3.x.

+# +#

The format of information set through ValuePtr depends on the specified Attribute. SQLSetEnvAttr will accept attribute information in one of two different formats: a null-terminated character string or a 32-bit integer value. The format of each is noted in the attribute's description.

+# +#

There are no driver-specific environment attributes.

+# +#

Connection attributes cannot be set by a call to SQLSetEnvAttr. Attempting to do so will return SQLSTATE HY092 (Invalid attribute/option identifier).

+#
+# +# +# +# +# +# +# +# +# +# + SQL_ATTR_CONNECTION_POOLING => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_CP_OFF SQL_CP_ONE_PER_DRIVER SQL_CP_ONE_PER_HENV) ], + default => q(SQL_CP_OFF), + mode => 'rw', + order => ++$order, + }, +# +# +# +# + SQL_ATTR_CP_MATCH => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_CP_STRICT_MATCH SQL_CP_RELAXED_MATCH) ], + default => q(SQL_CP_STRICT_MATCH), + mode => 'rw', + order => ++$order, + }, +# +# +# +# + SQL_ATTR_ODBC_VERSION => { + type => q(SQLINTEGER), + ptr => 0, + value => [ qw(SQL_OV_ODBC3 SQL_OV_ODBC2) ], + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# + SQL_ATTR_OUTPUT_NTS => { + type => q(SQLINTEGER), + ptr => 0, + value => [ qw(SQL_FALSE SQL_TRUE) ], + default => q(SQL_TRUE), + mode => 'rw', + order => ++$order, + } +#
AttributeValuePtr contents
SQL_ATTR_CONNECTION_POOLING
+# (ODBC 3.0)		A 32-bit SQLUINTEGER value that enables or disables connection pooling at the environment level. The following values are used: +#

SQL_CP_OFF = Connection pooling is turned off. This is the default.

+# +#

SQL_CP_ONE_PER_DRIVER = A single connection pool is supported for each driver. Every connection in a pool is associated with one driver.

+# +#

SQL_CP_ONE_PER_HENV = A single connection pool is supported for each environment. Every connection in a pool is associated with one environment.

+# +#

Connection pooling is enabled by calling SQLSetEnvAttr to set the SQL_ATTR_CONNECTION_POOLING attribute to SQL_CP_ONE_PER_DRIVER or SQL_CP_ONE_PER_HENV. This call must be made before the application allocates the shared environment for which connection pooling is to be enabled. The environment handle in the call to SQLSetEnvAttr is set to null, which makes SQL_ATTR_CONNECTION_POOLING a process-level attribute. After connection pooling is enabled, the application then allocates an implicit shared environment by calling SQLAllocHandle with the InputHandle argument set to SQL_HANDLE_ENV.

+# +#

After connection pooling has been enabled and a shared environment has been selected for an application, SQL_ATTR_CONNECTION_POOLING cannot be reset for that environment, because SQLSetEnvAttr is called with a null environment handle when setting this attribute. If this attribute is set while connection pooling is already enabled on a shared environment, the attribute affects only shared environments that are allocated subsequently.

+# +#

For more information, see "ODBC Connection Pooling" in Chapter 6: Connecting to a Data Source or Driver.

+#
SQL_ATTR_CP_MATCH
+# (ODBC 3.0)		A 32-bit SQLUINTEGER value that determines how a connection is chosen from a connection pool. When SQLConnect or SQLDriverConnect is called, the Driver Manager determines which connection is reused from the pool. The Driver Manager attempts to match the connection options in the call and the connection attributes set by the application to the keywords and connection attributes of the connections in the pool. The value of this attribute determines the level of precision of the matching criteria. +#

The following values are used to set the value of this attribute:

+# +#

SQL_CP_STRICT_MATCH = Only connections that exactly match the connection options in the call and the connection attributes set by the application are reused. This is the default.

+# +#

SQL_CP_RELAXED_MATCH = Connections with matching connection string keywords can be used. Keywords must match, but not all connection attributes must match.

+# +#

For more information on how the Driver Manager performs the match in connecting to a pooled connection, see SQLConnect. For more information on connection pooling, see "ODBC Connection Pooling" in Chapter 6: Connecting to a Data Source or Driver.

+#
SQL_ATTR_ODBC_VERSION
+# (ODBC 3.0)		A 32-bit integer that determines whether certain functionality exhibits ODBC 2.x behavior or ODBC 3.x behavior. The following values are used to set the value of this attribute: +#

SQL_OV_ODBC3 = The Driver Manager and driver exhibit the following ODBC 3.x behavior: +# +#

    +#
  • The driver returns and expects ODBC 3.x codes for date, time, and timestamp.
    • +# +#
  • The driver returns ODBC 3.x SQLSTATE codes when SQLError, SQLGetDiagField, or SQLGetDiagRec is called.
    • +# +#
  • The CatalogName argument in a call to SQLTables accepts a search pattern.
    • +#
+# +#

SQL_OV_ODBC2 = The Driver Manager and driver exhibit the following ODBC 2.x behavior. This is especially useful for an ODBC 2.x application working with an ODBC 3.x driver. +# +#

    +#
  • The driver returns and expects ODBC 2.x codes for date, time, and timestamp.
    • +# +#
  • The driver returns ODBC 2.x SQLSTATE codes when SQLError, SQLGetDiagField, or SQLGetDiagRec is called.
    • +# +#
  • The CatalogName argument in a call to SQLTables does not accept a search pattern.
    • +#
+# +#

An application must set this environment attribute before calling any function that has an SQLHENV argument, or the call will return SQLSTATE HY010 (Function sequence error). It is driver-specific whether or not additional behaviors exist for these environmental flags. +# +#

+#
SQL_ATTR_OUTPUT_NTS
+# (ODBC 3.0)		A 32-bit integer that determines how the driver returns string data. If SQL_TRUE, the driver returns string data null-terminated. If SQL_FALSE, the driver does not return string data null-terminated. +#

This attribute defaults to SQL_TRUE. A call to SQLSetEnvAttr to set it to SQL_TRUE returns SQL_SUCCESS. A call to SQLSetEnvAttr to set it to SQL_FALSE returns SQL_ERROR and SQLSTATE HYC00 (Optional feature not implemented).

+#
+# +#

Related Functions

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
For information aboutSee
Allocating a handleSQLAllocHandle
Returning the setting of an environment attributeSQLGetEnvAttr
+#

+# +#
+# +# +# +}; + +# +# odbcsqlsetconnectattr.htm +# +my $attrDbc = { +# +# +# +# SQLSetConnectAttr +# +# +# +# +# +# +#
+#
+# +# +# +# +#
+# ODBC Programmer's Reference +#
+#
+#
+#
+# +#

SQLSetConnectAttr

+# +#

Conformance

+# +#

Version Introduced: ODBC 3.0
+# Standards Compliance: ISO 92

+# +#

Summary

+# +#

SQLSetConnectAttr sets attributes that govern aspects of connections.

+# +#

Note   For more information about what the Driver Manager maps this function to when an ODBC 3.x application is working with an ODBC 2.x driver, see "Mapping Replacement Functions for Backward Compatibility of Applications" in Chapter 17: Programming Considerations.

+# +#

Syntax

+# +# 
SQLRETURN SQLSetConnectAttr(
+#	     SQLHDBC     ConnectionHandle,
+#	     SQLINTEGER     Attribute,
+#	     SQLPOINTER     ValuePtr,
+#	     SQLINTEGER     StringLength);
+# +#

Arguments +# +#

+#
ConnectionHandle
+# +#
[Input]
+# Connection handle.
+# +#
Attribute
+# +#
[Input]
+# Attribute to set, listed in "Comments."
+# +#
ValuePtr
+# +#
[Input]
+# Pointer to the value to be associated with Attribute. Depending on the value of Attribute, ValuePtr will be a 32-bit unsigned integer value or will point to a null-terminated character string. Note that if the Attribute argument is a driver-specific value, the value in ValuePtr may be a signed integer.
+# +#
StringLength
+# +#
[Input]
+# If Attribute is an ODBC-defined attribute and ValuePtr points to a character string or a binary buffer, this argument should be the length of *ValuePtr. If Attribute is an ODBC-defined attribute and ValuePtr is an integer, StringLength is ignored. +# +#

If Attribute is a driver-defined attribute, the application indicates the nature of the attribute to the Driver Manager by setting the StringLength argument. StringLength can have the following values: +# +# +#

    +#
  • If ValuePtr is a pointer to a character string, then StringLength is the length of the string or SQL_NTS.
    • +# +#
  • If ValuePtr is a pointer to a binary buffer, then the application places the result of the SQL_LEN_BINARY_ATTR(length) macro in StringLength. This places a negative value in StringLength.
    • +# +#
  • If ValuePtr is a pointer to a value other than a character string or a binary string, then StringLength should have the value SQL_IS_POINTER.
    • +# +#
  • If ValuePtr contains a fixed-length value, then StringLength is either SQL_IS_INTEGER or SQL_IS_UINTEGER, as appropriate.
    • +#
+#
+#
+# +#

Returns

+# +#

SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_ERROR, or SQL_INVALID_HANDLE.

+# +#

Diagnostics

+# +#

When SQLSetConnectAttr returns SQL_ERROR or SQL_SUCCESS_WITH_INFO, an associated SQLSTATE value can be obtained by calling SQLGetDiagRec with a HandleType of SQL_HANDLE_DBC and a Handle of ConnectionHandle. The following table lists the SQLSTATE values commonly returned by SQLSetConnectAttr and explains each one in the context of this function; the notation "(DM)" precedes the descriptions of SQLSTATEs returned by the Driver Manager. The return code associated with each SQLSTATE value is SQL_ERROR, unless noted otherwise.

+# +#

The driver can return SQL_SUCCESS_WITH_INFO to provide information about the result of setting an option.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
SQLSTATEErrorDescription
01000General warningDriver-specific informational message. (Function returns SQL_SUCCESS_WITH_INFO.)
01S02Option value changedThe driver did not support the value specified in ValuePtr and substituted a similar value. (Function returns SQL_SUCCESS_WITH_INFO.)
08002Connection name in useThe Attribute argument was SQL_ATTR_ODBC_CURSORS, and the driver was already connected to the data source.
08003Connection does not exist(DM) An Attribute value was specified that required an open connection, but the ConnectionHandle was not in a connected state.
08S01Communication link failureThe communication link between the driver and the data source to which the driver was connected failed before the function completed processing.
24000Invalid cursor stateThe Attribute argument was SQL_ATTR_CURRENT_CATALOG, and a result set was pending.
3D000Invalid catalog nameThe Attribute argument was SQL_CURRENT_CATALOG, and the specified catalog name was invalid.
HY000General errorAn error occurred for which there was no specific SQLSTATE and for which no implementation-specific SQLSTATE was defined. The error message returned by SQLGetDiagRec in the *MessageText buffer describes the error and its cause.
HY001Memory allocation errorThe driver was unable to allocate memory required to support execution or completion of the function.
HY009Invalid use of null pointerThe Attribute argument identified a connection attribute that required a string value, and the ValuePtr argument was a null pointer.
HY010Function sequence error(DM) An asynchronously executing function was called for a StatementHandle associated with the ConnectionHandle and was still executing when SQLSetConnectAttr was called. +#

(DM) SQLExecute, SQLExecDirect, SQLBulkOperations, or SQLSetPos was called for a StatementHandle associated with the ConnectionHandle and returned SQL_NEED_DATA. This function was called before data was sent for all data-at-execution parameters or columns.

+# +#

(DM) SQLBrowseConnect was called for the ConnectionHandle and returned SQL_NEED_DATA. This function was called before SQLBrowseConnect returned SQL_SUCCESS_WITH_INFO or SQL_SUCCESS.

+#
HY011Attribute cannot be set nowThe Attribute argument was SQL_ATTR_TXN_ISOLATION, and a transaction was open.
HY013Memory management errorThe function call could not be processed because the underlying memory objects could not be accessed, possibly because of low memory conditions.
HY024Invalid attribute valueGiven the specified Attribute value, an invalid value was specified in ValuePtr. (The Driver Manager returns this SQLSTATE only for connection and statement attributes that accept a discrete set of values, such as SQL_ATTR_ACCESS_MODE or SQL_ATTR_ASYNC_ENABLE. For all other connection and statement attributes, the driver must verify the value specified in ValuePtr.) +#

The Attribute argument was SQL_ATTR_TRACEFILE or SQL_ATTR_TRANSLATE_LIB, and ValuePtr was an empty string.

+#
HY090Invalid string or buffer length(DM) *ValuePtr is a character string, and the StringLength argument was less than 0 but was not SQL_NTS.
HY092Invalid attribute/option identifier(DM) The value specified for the argument Attribute was not valid for the version of ODBC supported by the driver. +#

(DM) The value specified for the argument Attribute was a read-only attribute.

+#
HYC00Optional feature not implementedThe value specified for the argument Attribute was a valid ODBC connection or statement attribute for the version of ODBC supported by the driver but was not supported by the driver.
HYT01Connection timeout expiredThe connection timeout period expired before the data source responded to the request. The connection timeout period is set through SQLSetConnectAttr, SQL_ATTR_CONNECTION_TIMEOUT.
IM001Driver does not support this function(DM) The driver associated with the ConnectionHandle does not support the function.
IM009Unable to load translation DLLThe driver was unable to load the translation DLL that was specified for the connection. This error can be returned only when Attribute is SQL_ATTR_TRANSLATE_LIB.
+# +#

When Attribute is a statement attribute, SQLSetConnectAttr can return any SQLSTATEs returned by SQLSetStmtAttr.

+# +#

Comments

+# +#

For general information about connection attributes, see "Connection Attributes" in Chapter 6: Connecting to a Data Source or Driver.

+# +#

The currently defined attributes and the version of ODBC in which they were introduced are shown in the table later in this section; it is expected that more attributes will be defined to take advantage of different data sources. A range of attributes is reserved by ODBC; driver developers must reserve values for their own driver-specific use from X/Open.

+# +#

Note   The ability to set statement attributes at the connection level by calling SQLSetConnectAttr has been deprecated in ODBC 3.x. ODBC 3.x applications should never set statement attributes at the connection level. ODBC 3.x statement attributes cannot be set at the connection level, with the exception of the SQL_ATTR_METADATA_ID and SQL_ATTR_ASYNC_ENABLE attributes, which are both connection attributes and statement attributes and can be set at either the connection level or the statement level.

+# +#

ODBC 3.x drivers need only support this functionality if they should work with ODBC 2.x applications that set ODBC 2.x statement options at the connection level. For more information, see "SQLSetConnectOption Mapping" in Appendix G: Driver Guidelines for Backward Compatibility.

+# +#

An application can call SQLSetConnectAttr at any time between the time the connection is allocated and freed. All connection and statement attributes successfully set by the application for the connection persist until SQLFreeHandle is called on the connection. For example, if an application calls SQLSetConnectAttr before connecting to a data source, the attribute persists even if SQLSetConnectAttr fails in the driver when the application connects to the data source; if an application sets a driver-specific attribute, the attribute persists even if the application connects to a different driver on the connection.

+# +#

Some connection attributes can be set only before a connection has been made; others can be set only after a connection has been made. The following table indicates those connection attributes that must be set either before or after a connection has been made. Either indicates that the attribute can be set either before or after connection.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
AttributeSet before or after connection?
SQL_ATTR_ACCESS_MODEEither[1]
SQL_ATTR_ASYNC_ENABLEEither[2]
SQL_ATTR_AUTOCOMMITEither
SQL_ATTR_CONNECTION_TIMEOUTEither
SQL_ATTR_CURRENT_CATALOGEither[1]
SQL_ATTR_LOGIN_TIMEOUTBefore
SQL_ATTR_METADATA_IDEither
SQL_ATTR_ODBC_CURSORSBefore
SQL_ATTR_PACKET_SIZEBefore
SQL_ATTR_QUIET_MODEEither
SQL_ATTR_TRACEEither
SQL_ATTR_TRACEFILEEither
SQL_ATTR_TRANSLATE_LIBAfter
SQL_ATTR_TRANSLATE_OPTIONAfter
SQL_ATTR_TXN_ISOLATIONEither[3]
+# +#

[1]   SQL_ATTR_ACCESS_MODE and SQL_ATTR_CURRENT_CATALOG can be set before or after connecting, depending on the driver. However, interoperable applications set them before connecting because some drivers do not support changing these after connecting.

+#

[2]   SQL_ATTR_ASYNC_ENABLE must be set before there is an active statement.

+#

[3]   SQL_ATTR_TXN_ISOLATION can be set only if there are no open transactions on the connection. Some connection attributes support substitution of a similar value if the data source does not support the value specified in *ValuePtr. In such cases, the driver returns SQL_SUCCESS_WITH_INFO and SQLSTATE 01S02 (Option value changed). For example, if Attribute is SQL_ATTR_PACKET_SIZE and *ValuePtr exceeds the maximum packet size, the driver substitutes the maximum size. To determine the substituted value, an application calls SQLGetConnectAttr.

+#

The format of information set in the *ValuePtr buffer depends on the specified Attribute. SQLSetConnectAttr will accept attribute information in one of two different formats: a null-terminated character string or a 32-bit integer value. The format of each is noted in the attribute's description. Character strings pointed to by the ValuePtr argument of SQLSetConnectAttr have a length of StringLength bytes.

+# +#

The StringLength argument is ignored if the length is defined by the attribute, as is the case for all attributes introduced in ODBC 2.x or earlier.

+#
+# +# +# +# +# +# +# +# +# +# + SQL_ATTR_ACCESS_MODE => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_MODE_READ_ONLY SQL_MODE_READ_WRITE) ], + default => q(SQL_MODE_READ_WRITE), + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ASYNC_ENABLE_ON => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_ASYNC_ENABLE_OFF SQL_ASYNC_ENABLE_ON) ], + default => q(SQL_ASYNC_ENABLE_OFF), + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_AUTO_IPD => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_FALSE SQL_TRUE) ], + default => undef, + mode => 'ro', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_AUTOCOMMIT => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_AUTOCOMMIT_OFF SQL_AUTOCOMMIT_ON) ], + default => q(SQL_AUTOCOMMIT_ON), + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_CONNECTION_DEAD => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_CD_FALSE SQL_CD_TRUE) ], + default => undef, + mode => 'ro', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_CONNECTION_TIMEOUT => { + type => q(SQLUINTEGER), + ptr => 0, + value => undef, + default => 0, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_CURRENT_CATALOG => { + type => q(SQLCHAR), + ptr => undef, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_LOGIN_TIMEOUT => { + type => q(SQLUINTEGER), + ptr => 0, + value => undef, + default => 0, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_METADATA_ID => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_FALSE SQL_TRUE) ], + default => q(SQL_FALSE), + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_ODBC_CURSORS => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_CUR_USE_IF_NEEDED SQL_CUR_USE_ODBC SQL_CUR_USE_DRIVER) ], + default => q(SQL_CUR_USE_DRIVER), + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_PACKET_SIZE => { + type => q(SQLUINTEGER), + ptr => 0, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_QUIET_MODE => { + type => q(SQLPOINTER), + ptr => undef, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_TRACE => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_OPT_TRACE_OFF SQL_OPT_TRACE_ON) ], + default => q(SQL_OPT_TRACE_OFF), + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_TRACEFILE => { + type => q(SQLCHAR), + ptr => undef, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_TRANSLATE_LIB => { + type => q(SQLCHAR), + ptr => undef, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_TRANSLATE_OPTION => { + type => q(SQLUINTEGER), + ptr => 0, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_TXN_ISOLATION => { + type => q(SQLUINTEGER), + ptr => 0, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +#
AttributeValuePtr contents
SQL_ATTR_ACCESS_MODE
+# (ODBC 1.0)		An SQLUINTEGER value. SQL_MODE_READ_ONLY is used by the driver or data source as an indicator that the connection is not required to support SQL statements that cause updates to occur. This mode can be used to optimize locking strategies, transaction management, or other areas as appropriate to the driver or data source. The driver is not required to prevent such statements from being submitted to the data source. The behavior of the driver and data source when asked to process SQL statements that are not read-only during a read-only connection is implementation-defined. SQL_MODE_READ_WRITE is the default.
SQL_ATTR_ASYNC_ENABLE
+# (ODBC 3.0)		An SQLUINTEGER value that specifies whether a function called with a statement on the specified connection is executed asynchronously: +#

SQL_ASYNC_ENABLE_OFF = Off (the default)
+# SQL_ASYNC_ENABLE_ON = On

+# +#

Setting SQL_ASYNC_ENABLE_ON enables asynchronous execution for all future statement handles allocated on this connection. It is driver-defined whether this enables asynchronous execution for existing statement handles associated with this connection. An error is returned if asynchronous execution is enabled while there is an active statement on the connection.

+# +#

This attribute can be set whether SQLGetInfo with the SQL_ASYNC_MODE information type returns SQL_AM_CONNECTION or SQL_AM_STATEMENT.

+# +#

After a function has been called asynchronously, only the original function, SQLAllocHandle, SQLCancel, SQLGetDiagField, or SQLGetDiagRec can be called on the statement or the connection associated with StatementHandle, until the original function returns a code other than SQL_STILL_EXECUTING. Any other function called on StatementHandle or the connection associated with StatementHandle returns SQL_ERROR with an SQLSTATE of HY010 (Function sequence error). Functions can be called on other statements. For more information, see "Asynchronous Execution" in Chapter 9: Executing Statements.

+# +#

In general, applications should execute functions asynchronously only on single-thread operating systems. On multithread operating systems, applications should execute functions on separate threads rather than executing them asynchronously on the same thread. Drivers that operate only on multithread operating systems do not need to support asynchronous execution.

+# +#

The following functions can be executed asynchronously:

+# +#

SQLBulkOperations
+# SQLColAttribute
+# SQLColumnPrivileges
+# SQLColumns
+# SQLCopyDesc
+# SQLDescribeCol
+# SQLDescribeParam
+# SQLExecDirect
+# SQLExecute
+# SQLFetch
+# SQLFetchScroll
+# SQLForeignKeys
+# SQLGetData
+# SQLGetDescField[1]
+# SQLGetDescRec[1]
+# SQLGetDiagField
+# SQLGetDiagRec
+# SQLGetTypeInfo
+# SQLMoreResults
+# SQLNumParams
+# SQLNumResultCols
+# SQLParamData
+# SQLPrepare
+# SQLPrimaryKeys
+# SQLProcedureColumns
+# SQLProcedures
+# SQLPutData
+# SQLSetPos
+# SQLSpecialColumns
+# SQLStatistics
+# SQLTablePrivileges
+# SQLTables

+#
SQL_ATTR_AUTO_IPD
+# (ODBC 3.0)		A read-only SQLUINTEGER value that specifies whether automatic population of the IPD after a call to SQLPrepare is supported: +#

SQL_TRUE = Automatic population of the IPD after a call to SQLPrepare is supported by the driver.

+# +#

SQL_FALSE = Automatic population of the IPD after a call to SQLPrepare is not supported by the driver. Servers that do not support prepared statements will not be able to populate the IPD automatically.

+# +#

If SQL_TRUE is returned for the SQL_ATTR_AUTO_IPD connection attribute, the statement attribute SQL_ATTR_ENABLE_AUTO_IPD can be set to turn automatic population of the IPD on or off. If SQL_ATTR_AUTO_IPD is SQL_FALSE, SQL_ATTR_ENABLE_AUTO_IPD cannot be set to SQL_TRUE. The default value of SQL_ATTR_ENABLE_AUTO_IPD is equal to the value of SQL_ATTR_AUTO_IPD.

+# +#

This connection attribute can be returned by SQLGetConnectAttr but cannot be set by SQLSetConnectAttr.

+#
SQL_ATTR_AUTOCOMMIT
+# (ODBC 1.0)		An SQLUINTEGER value that specifies whether to use autocommit or manual-commit mode: +#

SQL_AUTOCOMMIT_OFF = The driver uses manual-commit mode, and the application must explicitly commit or roll back transactions with SQLEndTran.

+# +#

SQL_AUTOCOMMIT_ON = The driver uses autocommit mode. Each statement is committed immediately after it is executed. This is the default. Any open transactions on the connection are committed when SQL_ATTR_AUTOCOMMIT is set to SQL_AUTOCOMMIT_ON to change from manual-commit mode to autocommit mode.

+# +#

For more information, see "Commit Mode" in Chapter 14: Transactions.

+# +#

Important   Some data sources delete the access plans and close the cursors for all statements on a connection each time a statement is committed; autocommit mode can cause this to happen after each nonquery statement is executed or when the cursor is closed for a query. For more information, see the SQL_CURSOR_COMMIT_BEHAVIOR and SQL_CURSOR_ROLLBACK_BEHAVIOR information types in SQLGetInfo and "Effect of Transactions on Cursors and Prepared Statements" in Chapter 14: Transactions.

+# +#

When a batch is executed in autocommit mode, two things are possible. The entire batch can be treated as an autocommitable unit, or each statement in a batch is treated as an autocommitable unit. Certain data sources can support both these behaviors and may provide a way of choosing one or the other. It is driver-defined whether a batch is treated as an autocommitable unit or whether each individual statement within the batch is autocommitable.

+#
SQL_ATTR_CONNECTION_DEAD +#

(ODBC 3.5)

+# 		An SQLUINTERGER value that indicates the state of the connection. If SQL_CD_TRUE, the connection has been lost. If SQL_CD_FALSE, the connection is still active.
SQL_ATTR_CONNECTION_TIMEOUT
+# (ODBC 3.0)		An SQLUINTEGER value corresponding to the number of seconds to wait for any request on the connection to complete before returning to the application. The driver should return SQLSTATE HYT00 (Timeout expired) anytime that it is possible to time out in a situation not associated with query execution or login. +#

If ValuePtr is equal to 0 (the default), there is no timeout.

+#
SQL_ATTR_CURRENT_CATALOG
+# (ODBC 2.0)		A character string containing the name of the catalog to be used by the data source. For example, in SQL Server, the catalog is a database, so the driver sends a USE database statement to the data source, where database is the database specified in *ValuePtr. For a single-tier driver, the catalog might be a directory, so the driver changes its current directory to the directory specified in *ValuePtr.
SQL_ATTR_LOGIN_TIMEOUT
+# (ODBC 1.0)		An SQLUINTEGER value corresponding to the number of seconds to wait for a login request to complete before returning to the application. The default is driver-dependent. If ValuePtr is 0, the timeout is disabled and a connection attempt will wait indefinitely. +#

If the specified timeout exceeds the maximum login timeout in the data source, the driver substitutes that value and returns SQLSTATE 01S02 (Option value changed).

+#
SQL_ATTR_METADATA_ID
+# (ODBC 3.0)		An SQLUINTEGER value that determines how the string arguments of catalog functions are treated. +#

If SQL_TRUE, the string argument of catalog functions are treated as identifiers. The case is not significant. For nondelimited strings, the driver removes any trailing spaces and the string is folded to uppercase. For delimited strings, the driver removes any leading or trailing spaces and takes literally whatever is between the delimiters. If one of these arguments is set to a null pointer, the function returns SQL_ERROR and SQLSTATE HY009 (Invalid use of null pointer).

+# +#

If SQL_FALSE, the string arguments of catalog functions are not treated as identifiers. The case is significant. They can either contain a string search pattern or not, depending on the argument.

+# +#

The default value is SQL_FALSE.

+# +#

The TableType argument of SQLTables, which takes a list of values, is not affected by this attribute.

+# +#

SQL_ATTR_METADATA_ID can also be set on the statement level. (It is the only connection attribute that is also a statement attribute.)

+# +#

For more information, see "Arguments in Catalog Functions" in Chapter 7: Catalog Functions.

+#
SQL_ATTR_ODBC_CURSORS
+# (ODBC 2.0)		An SQLUINTEGER value specifying how the Driver Manager uses the ODBC cursor library: +#

SQL_CUR_USE_IF_NEEDED = The Driver Manager uses the ODBC cursor library only if it is needed. If the driver supports the SQL_FETCH_PRIOR option in SQLFetchScroll, the Driver Manager uses the scrolling capabilities of the driver. Otherwise, it uses the ODBC cursor library.

+# +#

SQL_CUR_USE_ODBC = The Driver Manager uses the ODBC cursor library.

+# +#

SQL_CUR_USE_DRIVER = The Driver Manager uses the scrolling capabilities of the driver. This is the default setting.

+# +#

For more information about the ODBC cursor library, see Appendix F: ODBC Cursor Library.

+#
SQL_ATTR_PACKET_SIZE
+# (ODBC 2.0)		An SQLUINTEGER value specifying the network packet size in bytes. +#

Note   Many data sources either do not support this option or only can return but not set the network packet size.

+# +#

If the specified size exceeds the maximum packet size or is smaller than the minimum packet size, the driver substitutes that value and returns SQLSTATE 01S02 (Option value changed).

+# +#

If the application sets packet size after a connection has already been made, the driver will return SQLSTATE HY011 (Attribute cannot be set now).

+#
SQL_ATTR_QUIET_MODE
+# (ODBC 2.0)		A 32-bit window handle (hwnd). +#

If the window handle is a null pointer, the driver does not display any dialog boxes.

+# +#

If the window handle is not a null pointer, it should be the parent window handle of the application. This is the default. The driver uses this handle to display dialog boxes.

+# +#

Note   The SQL_ATTR_QUIET_MODE connection attribute does not apply to dialog boxes displayed by SQLDriverConnect.

+#
SQL_ATTR_TRACE
+# (ODBC 1.0)		An SQLUINTEGER value telling the Driver Manager whether to perform tracing: +#

SQL_OPT_TRACE_OFF = Tracing off (the default)

+# +#

SQL_OPT_TRACE_ON = Tracing on

+# +#

When tracing is on, the Driver Manager writes each ODBC function call to the trace file.

+# +#

Note   When tracing is on, the Driver Manager can return SQLSTATE IM013 (Trace file error) from any function.

+# +#

An application specifies a trace file with the SQL_ATTR_TRACEFILE option. If the file already exists, the Driver Manager appends to the file. Otherwise, it creates the file. If tracing is on and no trace file has been specified, the Driver Manager writes to the file SQL.LOG in the root directory.

+# +#

An application can set the variable ODBCSharedTraceFlag to enable tracing dynamically. Tracing is then enabled for all ODBC applications currently running. If an application turns tracing off, it is turned off only for that application.

+# +#

If the Trace keyword in the system information is set to 1 when an application calls SQLAllocHandle with a HandleType of SQL_HANDLE_ENV, tracing is enabled for all handles. It is enabled only for the application that called SQLAllocHandle.

+# +#

Calling SQLSetConnectAttr with an Attribute of SQL_ATTR_TRACE does not require that the ConnectionHandle argument be valid and will not return SQL_ERROR if ConnectionHandle is NULL. This attribute applies to all connections.

+#
SQL_ATTR_TRACEFILE
+# (ODBC 1.0)		A null-terminated character string containing the name of the trace file. +#

The default value of the SQL_ATTR_TRACEFILE attribute is specified with the TraceFile keyword in the system information. For more information, see "ODBC Subkey" in Chapter 19: Configuring Data Sources.

+# +#

Calling SQLSetConnectAttr with an Attribute of SQL_ATTR_ TRACEFILE does not require the ConnectionHandle argument to be valid and will not return SQL_ERROR if ConnectionHandle is invalid. This attribute applies to all connections.

+#
SQL_ATTR_TRANSLATE_LIB
+# (ODBC 1.0)		A null-terminated character string containing the name of a library containing the functions SQLDriverToDataSource and SQLDataSourceToDriver that the driver accesses to perform tasks such as character set translation. This option may be specified only if the driver has connected to the data source. The setting of this attribute will persist across connections. For more information about translating data, see "Translation DLLs" in Chapter 17: Programming Considerations, and Chapter 24: Translation DLL Function Reference.
SQL_ATTR_TRANSLATE_OPTION
+# (ODBC 1.0)		A 32-bit flag value that is passed to the translation DLL. This attribute can be specified only if the driver has connected to the data source. For information about translating data, see "Translation DLLs" in Chapter 17: Programming Considerations.
SQL_ATTR_TXN_ISOLATION
+# (ODBC 1.0)		A 32-bit bitmask that sets the transaction isolation level for the current connection. An application must call SQLEndTran to commit or roll back all open transactions on a connection, before calling SQLSetConnectAttr with this option. +#

The valid values for ValuePtr can be determined by calling SQLGetInfo with InfoType equal to SQL_TXN_ISOLATION_OPTIONS.

+# +#

For a description of transaction isolation levels, see the description of the SQL_DEFAULT_TXN_ISOLATION information type in SQLGetInfo and "Transaction Isolation Levels" in Chapter 14: Transactions.

+#
+# +#

[1]   These functions can be called asynchronously only if the descriptor is an implementation descriptor, not an application descriptor.

+#

Code Example

+# +#

See SQLConnect.

+# +#

Related Functions

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
For information aboutSee
Allocating a handleSQLAllocHandle
Returning the setting of a connection
+# attribute		SQLGetConnectAttr
+#

+# +#
+# +# +# +}; + +# +# odbcsqlsetstmtattr.htm +# +my $attrStmt = { +# +# +# +# SQLSetStmtAttr +# +# +# +# +# +# +#
+#
+# +# +# +# +#
+# ODBC Programmer's Reference +#
+#
+#
+#
+# +#

SQLSetStmtAttr

+# +#

Conformance

+# +#

Version Introduced: ODBC 3.0
+# Standards Compliance: ISO 92

+# +#

Summary

+# +#

SQLSetStmtAttr sets attributes related to a statement.

+# +#

Note   For more information about what the Driver Manager maps this function to when an ODBC 3.x application is working with an ODBC 2.x driver, see "Mapping Replacement Functions for Backward Compatibility of Applications" in Chapter 17: Programming Considerations.

+# +#

Syntax

+# +# 
SQLRETURN SQLSetStmtAttr(
+#	     SQLHSTMT     StatementHandle,
+#	     SQLINTEGER     Attribute,
+#	     SQLPOINTER     ValuePtr,
+#	     SQLINTEGER     StringLength);
+# +#

Arguments +# +#

+#
StatementHandle
+# +#
[Input]
+# Statement handle.
+# +#
Attribute
+# +#
[Input]
+# Option to set, listed in "Comments."
+# +#
ValuePtr
+# +#
[Input]
+# Pointer to the value to be associated with Attribute. Depending on the value of Attribute, ValuePtr will be a 32-bit unsigned integer value or a pointer to a null-terminated character string, a binary buffer, or a driver-defined value. If the Attribute argument is a driver-specific value, ValuePtr may be a signed integer.
+# +#
StringLength
+# +#
[Input]
+# If Attribute is an ODBC-defined attribute and ValuePtr points to a character string or a binary buffer, this argument should be the length of *ValuePtr. If Attribute is an ODBC-defined attribute and ValuePtr is an integer, StringLength is ignored. +# +#

If Attribute is a driver-defined attribute, the application indicates the nature of the attribute to the Driver Manager by setting the StringLength argument. StringLength can have the following values: +#

+#
+# +#
    +#
  • If ValuePtr is a pointer to a character string, then StringLength is the length of the string or SQL_NTS.
    • +# +#
  • If ValuePtr is a pointer to a binary buffer, then the application places the result of the SQL_LEN_BINARY_ATTR(length) macro in StringLength. This places a negative value in StringLength.
    • +# +#
  • If ValuePtr is a pointer to a value other than a character string or a binary string, then StringLength should have the value SQL_IS_POINTER.
    • +# +#
  • If ValuePtr contains a fixed-length value, then StringLength is either SQL_IS_INTEGER or SQL_IS_UINTEGER, as appropriate.
    • +#
+# +#

Returns

+# +#

SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_ERROR, or SQL_INVALID_HANDLE.

+# +#

Diagnostics

+# +#

When SQLSetStmtAttr returns SQL_ERROR or SQL_SUCCESS_WITH_INFO, an associated SQLSTATE value may be obtained by calling SQLGetDiagRec with a HandleType of SQL_HANDLE_STMT and a Handle of StatementHandle. The following table lists the SQLSTATE values commonly returned by SQLSetStmtAttr and explains each one in the context of this function; the notation "(DM)" precedes the descriptions of SQLSTATEs returned by the Driver Manager. The return code associated with each SQLSTATE value is SQL_ERROR, unless noted otherwise.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
SQLSTATEErrorDescription
01000General warningDriver-specific informational message. (Function returns SQL_SUCCESS_WITH_INFO.)
01S02Option value changedThe driver did not support the value specified in ValuePtr, or the value specified in ValuePtr was invalid because of implementation working conditions, so the driver substituted a similar value. (SQLGetStmtAttr can be called to determine the temporarily substituted value.) The substitute value is valid for the StatementHandle until the cursor is closed, at which point the statement attribute reverts to its previous value. The statement attributes that can be changed are: +#

SQL_ ATTR_CONCURRENCY
+# SQL_ ATTR_CURSOR_TYPE
+# SQL_ ATTR_KEYSET_SIZE
+# SQL_ ATTR_MAX_LENGTH
+# SQL_ ATTR_MAX_ROWS
+# SQL_ ATTR_QUERY_TIMEOUT
+# SQL_ATTR_ROW_ARRAY_SIZE
+# SQL_ ATTR_SIMULATE_CURSOR

+# +#

(Function returns SQL_SUCCESS_WITH_INFO.)

+#
08S01Communication link failureThe communication link between the driver and the data source to which the driver was connected failed before the function completed processing.
24000Invalid cursor stateThe Attribute was SQL_ATTR_CONCURRENCY, SQL_ATTR_CURSOR_TYPE, SQL_ATTR_SIMULATE_CURSOR, or SQL_ATTR_USE_BOOKMARKS, and the cursor was open.
HY000General errorAn error occurred for which there was no specific SQLSTATE and for which no implementation-specific SQLSTATE was defined. The error message returned by SQLGetDiagRec in the *MessageText buffer describes the error and its cause.
HY001Memory allocation
+# error		The driver was unable to allocate memory required to support execution or completion of the function.
HY009Invalid use of null pointerThe Attribute argument identified a statement attribute that required a string attribute, and the ValuePtr argument was a null pointer.
HY010Function sequence error(DM) An asynchronously executing function was called for the StatementHandle and was still executing when this function was called. +#

(DM) SQLExecute, SQLExecDirect, SQLBulkOperations, or SQLSetPos was called for the StatementHandle and returned SQL_NEED_DATA. This function was called before data was sent for all data-at-execution parameters or columns.

+#
HY011Attribute cannot be set nowThe Attribute was SQL_ATTR_CONCURRENCY, SQL_ ATTR_CURSOR_TYPE, SQL_ ATTR_SIMULATE_CURSOR, or SQL_ ATTR_USE_BOOKMARKS, and the statement was prepared.
HY013Memory management errorThe function call could not be processed because the underlying memory objects could not be accessed, possibly because of low memory conditions.
HY017Invalid use of an automatically allocated descriptor handle(DM) The Attribute argument was SQL_ATTR_IMP_ROW_DESC or SQL_ATTR_IMP_PARAM_DESC. +#

(DM) The Attribute argument was SQL_ATTR_APP_ROW_DESC or SQL_ATTR_APP_PARAM_DESC, and the value in ValuePtr was an implicitly allocated descriptor handle other than the handle originally allocated for the ARD or APD.

+#
HY024Invalid attribute valueGiven the specified Attribute value, an invalid value was specified in ValuePtr. (The Driver Manager returns this SQLSTATE only for connection and statement attributes that accept a discrete set of values, such as SQL_ATTR_ACCESS_MODE or SQL_ ATTR_ASYNC_ENABLE. For all other connection and statement attributes, the driver must verify the value specified in ValuePtr.) +#

The Attribute argument was SQL_ATTR_APP_ROW_DESC or SQL_ATTR_APP_PARAM_DESC, and ValuePtr was an explicitly allocated descriptor handle that is not on the same connection as the StatementHandle argument.

+#
HY090Invalid string or buffer length(DM) *ValuePtr is a character string, and the StringLength argument was less than 0 but was not SQL_NTS.
HY092Invalid attribute/option identifier(DM) The value specified for the argument Attribute was not valid for the version of ODBC supported by the driver. +#

(DM) The value specified for the argument Attribute was a read-only attribute.

+#
HYC00Optional feature not implementedThe value specified for the argument Attribute was a valid ODBC statement attribute for the version of ODBC supported by the driver but was not supported by the driver. +#

The Attribute argument was SQL_ATTR_ASYNC_ENABLE, and a call to SQLGetInfo with an InfoType of SQL_ASYNC_MODE returns SQL_AM_CONNECTION.

+# +#

The Attribute argument was SQL_ATTR_ENABLE_AUTO_IPD, and the value of the connection attribute SQL_ATTR_AUTO_IPD was SQL_FALSE.

+#
HYT01Connection timeout expiredThe connection timeout period expired before the data source responded to the request. The connection timeout period is set through SQLSetConnectAttr, SQL_ATTR_CONNECTION_TIMEOUT.
IM001Driver does not support this function(DM) The driver associated with the StatementHandle does not support the function.
+# +#

Comments

+# +#

Statement attributes for a statement remain in effect until they are changed by another call to SQLSetStmtAttr or until the statement is dropped by calling SQLFreeHandle. Calling SQLFreeStmt with the SQL_CLOSE, SQL_UNBIND, or SQL_RESET_PARAMS option does not reset statement attributes.

+# +#

Some statement attributes support substitution of a similar value if the data source does not support the value specified in ValuePtr. In such cases, the driver returns SQL_SUCCESS_WITH_INFO and SQLSTATE 01S02 (Option value changed). For example, if Attribute is SQL_ATTR_CONCURRENCY and ValuePtr is SQL_CONCUR_ROWVER, and if the data source does not support this, the driver substitutes SQL_CONCUR_VALUES and returns SQL_SUCCESS_WITH_INFO. To determine the substituted value, an application calls SQLGetStmtAttr.

+# +#

The format of information set with ValuePtr depends on the specified Attribute. SQLSetStmtAttr accepts attribute information in one of two different formats: a character string or a 32-bit integer value. The format of each is noted in the attribute's description. This format applies to the information returned for each attribute in SQLGetStmtAttr. Character strings pointed to by the ValuePtr argument of SQLSetStmtAttr have a length of StringLength.

+# +#

Note   The ability to set statement attributes at the connection level by calling SQLSetConnectAttr has been deprecated in ODBC 3.x. ODBC 3.x applications should never set statement attributes at the connection level. ODBC 3.x statement attributes cannot be set at the connection level, with the exception of the SQL_ATTR_METADATA_ID and SQL_ATTR_ASYNC_ENABLE attributes, which are both connection attributes and statement attributes, and can be set at either the connection level or the statement level.

+# +#

ODBC 3.x drivers need only support this functionality if they should work with ODBC 2.x applications that set ODBC 2.x statement options at the connection level. For more information, see "Setting Statement Options on the Connection Level" under "SQLSetConnectOption Mapping" in Appendix G: Driver Guidelines for Backward Compatibility.

+# +#

Statement Attributes That Set Descriptor Fields

+# +#

Many statement attributes correspond to a header field of a descriptor. Setting these attributes actually results in the setting of the descriptor fields. Setting fields by a call to SQLSetStmtAttr rather than to SQLSetDescField has the advantage that a descriptor handle does not have to be obtained for the function call.

+# +#

Caution   Calling SQLSetStmtAttr for one statement can affect other statements. This occurs when the APD or ARD associated with the statement is explicitly allocated and is also associated with other statements. Because SQLSetStmtAttr modifies the APD or ARD, the modifications apply to all statements with which this descriptor is associated. If this is not the required behavior, the application should dissociate this descriptor from the other statements (by calling SQLSetStmtAttr to set the SQL_ATTR_APP_ROW_DESC or SQL_ATTR_APP_PARAM_DESC field to a different descriptor handle) before calling SQLSetStmtAttr again.

+# +#

When a descriptor field is set as a result of the corresponding statement attribute being set, the field is set only for the applicable descriptors that are currently associated with the statement identified by the StatementHandle argument, and the attribute setting does not affect any descriptors that may be associated with that statement in the future. When a descriptor field that is also a statement attribute is set by a call to SQLSetDescField, the corresponding statement attribute is set. If an explicitly allocated descriptor is dissociated from a statement, a statement attribute that corresponds to a header field will revert to the value of the field in the implicitly allocated descriptor.

+# +#

When a statement is allocated (see SQLAllocHandle), four descriptor handles are automatically allocated and associated with the statement. Explicitly allocated descriptor handles can be associated with the statement by calling SQLAllocHandle with an fHandleType of SQL_HANDLE_DESC to allocate a descriptor handle and then calling SQLSetStmtAttr to associate the descriptor handle with the statement.

+# +#

The statement attributes in the following table correspond to descriptor header fields.

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
Statement attributeHeader fieldDesc.
SQL_ATTR_PARAM_BIND_OFFSET_PTRSQL_DESC_BIND_OFFSET_PTRAPD
SQL_ATTR_PARAM_BIND_TYPESQL_DESC_BIND_TYPEAPD
SQL_ATTR_PARAM_OPERATION_PTRSQL_DESC_ARRAY_STATUS_PTRAPD
SQL_ATTR_PARAM_STATUS_PTRSQL_DESC_ARRAY_STATUS_PTRIPD
SQL_ATTR_PARAMS_PROCESSED_PTRSQL_DESC_ROWS_PROCESSED_PTRIPD
SQL_ATTR_PARAMSET_SIZESQL_DESC_ARRAY_SIZEAPD
SQL_ATTR_ROW_ARRAY_SIZESQL_DESC_ARRAY_SIZEARD
SQL_ATTR_ROW_BIND_OFFSET_PTRSQL_DESC_BIND_OFFSET_PTRARD
SQL_ATTR_ROW_BIND_TYPESQL_DESC_BIND_TYPEARD
SQL_ATTR_ROW_OPERATION_PTRSQL_DESC_ARRAY_STATUS_PTRARD
SQL_ATTR_ROW_STATUS_PTRSQL_DESC_ARRAY_STATUS_PTRIRD
SQL_ATTR_ROWS_FETCHED_PTRSQL_DESC_ROWS_PROCESSED_PTRIRD
+# +#

Statement Attributes

+# +#

The currently defined attributes and the version of ODBC in which they were introduced are shown in the following table; it is expected that more attributes will be defined by drivers to take advantage of different data sources. A range of attributes is reserved by ODBC; driver developers must reserve values for their own driver-specific use from X/Open. For more information, see "Driver-Specific Data Types, Descriptor Types, Information Types, Diagnostic Types, and Attributes" in Chapter 17: Programming Considerations.

+#
+# +# +# +# +# +# +# +# +# +# + SQL_ATTR_APP_PARAM_DESC => { + type => q(SQLPOINTER), + ptr => undef, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_APP_ROW_DESC => { + type => q(SQLPOINTER), + ptr => undef, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_ASYNC_ENABLE => { + type => q(SQLUINTEGER), + ptr => 0, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_CONCURRENCY => { + type => q(SQLUINTEGER), + ptr => undef, + value => [ qw(SQL_CONCUR_READ_ONLY SQL_CONCUR_LOCK SQL_CONCUR_ROWVER SQL_CONCUR_ROWVER) ], + default => q(SQL_CONCUR_READ_ONLY), + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_CURSOR_SCROLLABLE => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_NONSCROLLABLE SQL_SCROLLABLE) ], + default => q(SQL_NONSCROLLABLE), + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_CURSOR_SENSITIVITY => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_UNSPECIFIED SQL_INSENSITIVE SQL_SENSITIVE) ], + default => q(SQL_UNSPECIFIED), + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_CURSOR_TYPE => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_CURSOR_FORWARD_ONLY SQL_CURSOR_STATIC SQL_CURSOR_KEYSET_DRIVEN SQL_CURSOR_DYNAMIC) ], + default => q(SQL_CURSOR_FORWARD_ONLY), + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_ENABLE_AUTO_IPD => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_FALSE SQL_TRUE) ], + default => q(SQL_FALSE), + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_FETCH_BOOKMARK_PTR => { + type => q(SQLPOINTER), + ptr => undef, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_IMP_PARAM_DESC => { + type => q(SQLPOINTER), + ptr => undef, + value => undef, + default => undef, + mode => 'ro', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_IMP_ROW_DESC => { + type => q(SQLPOINTER), + ptr => undef, + value => undef, + default => undef, + mode => 'ro', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_KEYSET_SIZE => { + type => q(SQLUINTEGER), + ptr => undef, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_MAX_LENGTH => { + type => q(SQLUINTEGER), + ptr => undef, + value => undef, + default => 0, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_MAX_ROWS => { + type => q(SQLUINTEGER), + ptr => undef, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_METADATA_ID => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_FALSE SQL_TRUE) ], + default => q(SQL_FALSE), + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_NOSCAN => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_NOSCAN_OFF SQL_NOSCAN_ON) ], + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_PARAM_BIND_OFFSET_PTR => { + type => q(SQLUINTEGER), + ptr => 1, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# +# +# +# +# +# + SQL_ATTR_PARAM_BIND_TYPE => { + type => q(SQLUINTEGER), + ptr => 0, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_PARAM_OPERATION_PTR => { + type => q(SQLUSMALLINT), + ptr => 1, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_PARAM_STATUS_PTR => { + type => q(SQLUSMALLINT), + ptr => 1, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_PARAMS_PROCESSED_PTR => { + type => q(SQLUINTEGER), + ptr => 1, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_PARAMSET_SIZE => { + type => q(SQLUINTEGER), + ptr => 0, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_QUERY_TIMEOUT => { + type => q(SQLUINTEGER), + ptr => 0, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_RETRIEVE_DATA => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_RD_ON SQL_RD_OFF) ], + default => q(SQL_RD_ON), + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_ROW_ARRAY_SIZE => { + type => q(SQLUINTEGER), + ptr => 0, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_ROW_BIND_OFFSET_PTR => { + type => q(SQLUINTEGER), + ptr => undef, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_ROW_BIND_TYPE => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_BIND_BY_COLUMN etc) ], + default => q(SQL_BIND_BY_COLUMN), + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_ROW_NUMBER => { + type => q(SQLUINTEGER), + ptr => 0, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_ROW_OPERATION_PTR => { + type => q(SQLUSMALLINT), + ptr => 1, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_ROW_STATUS_PTR => { + type => q(SQLUSMALLINT), + ptr => 1, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_ROWS_FETCHED_PTR => { + type => q(SQLUINTEGER), + ptr => 1, + value => undef, + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_SIMULATE_CURSOR => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_SC_NON_UNIQUE SQL_SC_TRY_UNIQUE SQL_SC_UNIQUE) ], + default => undef, + mode => 'rw', + order => ++$order, + }, +# +# +# +# +# + SQL_ATTR_USE_BOOKMARKS => { + type => q(SQLUINTEGER), + ptr => 0, + value => [ qw(SQL_UB_OFF SQL_UB_VARIABLE SQL_UB_FIXED) ], + default => undef, + mode => 'rw', + order => ++$order, + }, +#
AttributeValuePtr contents
SQL_ATTR_APP_PARAM_DESC
+# (ODBC 3.0)		The handle to the APD for subsequent calls to SQLExecute and SQLExecDirect on the statement handle. The initial value of this attribute is the descriptor implicitly allocated when the statement was initially allocated. If the value of this attribute is set to SQL_NULL_DESC or the handle originally allocated for the descriptor, an explicitly allocated APD handle that was previously associated with the statement handle is dissociated from it and the statement handle reverts to the implicitly allocated APD handle. +#

This attribute cannot be set to a descriptor handle that was implicitly allocated for another statement or to another descriptor handle that was implicitly set on the same statement; implicitly allocated descriptor handles cannot be associated with more than one statement or descriptor handle.

+#
SQL_ATTR_APP_ROW_DESC
+# (ODBC 3.0)		The handle to the ARD for subsequent fetches on the statement handle. The initial value of this attribute is the descriptor implicitly allocated when the statement was initially allocated. If the value of this attribute is set to SQL_NULL_DESC or the handle originally allocated for the descriptor, an explicitly allocated ARD handle that was previously associated with the statement handle is dissociated from it and the statement handle reverts to the implicitly allocated ARD handle. +#

This attribute cannot be set to a descriptor handle that was implicitly allocated for another statement or to another descriptor handle that was implicitly set on the same statement; implicitly allocated descriptor handles cannot be associated with more than one statement or descriptor handle.

+#
SQL_ATTR_ASYNC_ENABLE
+# (ODBC 1.0)		An SQLUINTEGER value that specifies whether a function called with the specified statement is executed asynchronously: +#

SQL_ASYNC_ENABLE_OFF = Off (the default)
+# SQL_ASYNC_ENABLE_ON = On

+# +#

Once a function has been called asynchronously, only the original function, SQLCancel, SQLGetDiagField, or SQLGetDiagRec can be called on the statement, and only the original function, SQLAllocHandle (with a HandleType of SQL_HANDLE_STMT), SQLGetDiagField, SQLGetDiagRec, or SQLGetFunctions can be called on the connection associated with the statement, until the original function returns a code other than SQL_STILL_EXECUTING. Any other function called on the statement or the connection associated with the statement returns SQL_ERROR with an SQLSTATE of HY010 (Function sequence error). Functions can be called on other statements. For more information, see "Asynchronous Execution" in Chapter 9: Executing Statements.

+# +#

For drivers with statement level asynchronous execution support, the statement attribute SQL_ATTR_ASYNC_ENABLE may be set. Its initial value is the same as the value of the connection level attribute with the same name at the time the statement handle was allocated.

+# +#

For drivers with connection-level, asynchronous-execution support, the statement attribute SQL_ATTR_ASYNC_ENABLE is read-only. Its value is the same as the value of the connection level attribute with the same name at the time the statement handle was allocated. Calling SQLSetStmtAttr to set SQL_ATTR_ASYNC_ENABLE when the SQL_ASYNC_MODE InfoType returns SQL_AM_CONNECTION returns SQLSTATE HYC00 (Optional feature not implemented). (See SQLSetConnectAttr for more information.)

+# +#

As a standard practice, applications should execute functions asynchronously only on single-thread operating systems. On multithread operating systems, applications should execute functions on separate threads rather than executing them asynchronously on the same thread. No functionality is lost if drivers that operate only on multithread operating systems do not need to support asynchronous execution.

+# +#

The following functions can be executed asynchronously:

+# +#

SQLBulkOperations
+# SQLColAttribute
+# SQLColumnPrivileges
+# SQLColumns
+# SQLCopyDesc
+# SQLDescribeCol
+# SQLDescribeParam
+# SQLExecDirect
+# SQLExecute
+# SQLFetch
+# SQLFetchScroll
+# SQLForeignKeys
+# SQLGetData
+# SQLGetDescField[1]
+# SQLGetDescRec[1]
+# SQLGetDiagField
+# SQLGetDiagRec
+# SQLGetTypeInfo
+# SQLMoreResults
+# SQLNumParams
+# SQLNumResultCols
+# SQLParamData
+# SQLPrepare
+# SQLPrimaryKeys
+# SQLProcedureColumns
+# SQLProcedures
+# SQLPutData
+# SQLSetPos
+# SQLSpecialColumns
+# SQLStatistics
+# SQLTablePrivileges
+# SQLTables

+#
SQL_ATTR_CONCURRENCY
+# (ODBC 2.0)		An SQLUINTEGER value that specifies the cursor concurrency: +#

SQL_CONCUR_READ_ONLY = Cursor is read-only. No updates are allowed.

+# +#

SQL_CONCUR_LOCK = Cursor uses the lowest level of locking sufficient to ensure that the row can be updated.

+# +#

SQL_CONCUR_ROWVER = Cursor uses optimistic concurrency control, comparing row versions such as SQLBase ROWID or Sybase TIMESTAMP.

+# +#

SQL_CONCUR_VALUES = Cursor uses optimistic concurrency control, comparing values.

+# +#

The default value for SQL_ATTR_CONCURRENCY is SQL_CONCUR_READ_ONLY.

+# +#

This attribute cannot be specified for an open cursor. For more information, see "Concurrency Types" in Chapter 14: Transactions.

+# +#

If the SQL_ATTR_CURSOR_TYPE Attribute is changed to a type that does not support the current value of SQL_ATTR_CONCURRENCY, the value of SQL_ATTR_CONCURRENCY will be changed at execution time, and a warning issued when SQLExecDirect or SQLPrepare is called.

+# +#

If the driver supports the SELECT FOR UPDATE statement and such a statement is executed while the value of SQL_ATTR_CONCURRENCY is set to SQL_CONCUR_READ_ONLY, an error will be returned. If the value of SQL_ATTR_CONCURRENCY is changed to a value that the driver supports for some value of SQL_ATTR_CURSOR_TYPE but not for the current value of SQL_ATTR_CURSOR_TYPE, the value of SQL_ATTR_CURSOR_TYPE will be changed at execution time and SQLSTATE 01S02 (Option value changed) is issued when SQLExecDirect or SQLPrepare is called.

+# +#

If the specified concurrency is not supported by the data source, the driver substitutes a different concurrency and returns SQLSTATE 01S02 (Option value changed). For SQL_CONCUR_VALUES, the driver substitutes SQL_CONCUR_ROWVER, and vice versa. For SQL_CONCUR_LOCK, the driver substitutes, in order, SQL_CONCUR_ROWVER or SQL_CONCUR_VALUES. The validity of the substituted value is not checked until execution time.

+# +#

For more information about the relationship between SQL_ATTR_CONCURRENCY and the other cursor attributes, see "Cursor Characteristics and Cursor Type" in Chapter 11: Retrieving Results (Advanced).

+#
SQL_ATTR_CURSOR_SCROLLABLE
+# (ODBC 3.0)		An SQLUINTEGER value that specifies the level of support that the application requires. Setting this attribute affects subsequent calls to SQLExecDirect and SQLExecute. +#

SQL_NONSCROLLABLE = Scrollable cursors are not required on the statement handle. If the application calls SQLFetchScroll on this handle, the only valid value of FetchOrientation is SQL_FETCH_NEXT. This is the default.

+# +#

SQL_SCROLLABLE = Scrollable cursors are required on the statement handle. When calling SQLFetchScroll, the application may specify any valid value of FetchOrientation, achieving cursor positioning in modes other than the sequential mode.

+# +#

For more information about scrollable cursors, see "Scrollable Cursors" in Chapter 11: Retrieving Results (Advanced). For more information about the relationship between SQL_ATTR_CURSOR_SCROLLABLE and the other cursor attributes, see "Cursor Characteristics and Cursor Type" in Chapter 11: Retrieving Results (Advanced).

+#
SQL_ATTR_CURSOR_SENSITIVITY
+# (ODBC 3.0)		An SQLUINTEGER value that specifies whether cursors on the statement handle make visible the changes made to a result set by another cursor. Setting this attribute affects subsequent calls to SQLExecDirect and SQLExecute. An application can read back the value of this attribute to obtain its initial state or its state as most recently set by the application. +#

SQL_UNSPECIFIED = It is unspecified what the cursor type is and whether cursors on the statement handle make visible the changes made to a result set by another cursor. Cursors on the statement handle may make visible none, some, or all such changes. This is the default.

+# +#

SQL_INSENSITIVE = All cursors on the statement handle show the result set without reflecting any changes made to it by any other cursor. Insensitive cursors are read-only. This corresponds to a static cursor, which has a concurrency that is read-only.

+# +#

SQL_SENSITIVE = All cursors on the statement handle make visible all changes made to a result set by another cursor.

+# +#

For more information about the relationship between SQL_ATTR_CURSOR_SENSITIVITY and the other cursor attributes, see "Cursor Characteristics and Cursor Type" in Chapter 11: Retrieving Results (Advanced).

+#
SQL_ATTR_CURSOR_TYPE
+# (ODBC 2.0)		An SQLUINTEGER value that specifies the cursor type: +#

SQL_CURSOR_FORWARD_ONLY = The cursor only scrolls forward.

+# +#

SQL_CURSOR_STATIC = The data in the result set is static.

+# +#

SQL_CURSOR_KEYSET_DRIVEN = The driver saves and uses the keys for the number of rows specified in the SQL_ATTR_KEYSET_SIZE statement attribute.

+# +#

SQL_CURSOR_DYNAMIC = The driver saves and uses only the keys for the rows in the rowset.

+# +#

The default value is SQL_CURSOR_FORWARD_ONLY. This attribute cannot be specified after the SQL statement has been prepared.

+# +#

If the specified cursor type is not supported by the data source, the driver substitutes a different cursor type and returns SQLSTATE 01S02 (Option value changed). For a mixed or dynamic cursor, the driver substitutes, in order, a keyset-driven or static cursor. For a keyset-driven cursor, the driver substitutes a static cursor.

+# +#

For more information about scrollable cursor types, see "Scrollable Cursor Types" in Chapter 11: Retrieving Results (Advanced). For more information about the relationship between SQL_ATTR_CURSOR_TYPE and the other cursor attributes, see "Cursor Characteristics and Cursor Type" in Chapter 11: Retrieving Results (Advanced).

+#
SQL_ATTR_ENABLE_AUTO_IPD
+# (ODBC 3.0)		An SQLUINTEGER value that specifies whether automatic population of the IPD is performed: +#

SQL_TRUE = Turns on automatic population of the IPD after a call to SQLPrepare. SQL_FALSE = Turns off automatic population of the IPD after a call to SQLPrepare. (An application can still obtain IPD field information by calling SQLDescribeParam, if supported.) The default value of the statement attribute SQL_ATTR_ENABLE_AUTO_IPD is SQL_FALSE. For more information, see "Automatic Population of the IPD" in Chapter 13: Descriptors.

+#
SQL_ATTR_FETCH_BOOKMARK_PTR
+# (ODBC 3.0)		A pointer that points to a binary bookmark value. When SQLFetchScroll is called with fFetchOrientation equal to SQL_FETCH_BOOKMARK, the driver picks up the bookmark value from this field. This field defaults to a null pointer. For more information, see "Scrolling by Bookmark" in Chapter 11: Retrieving Results (Advanced). +#

The value pointed to by this field is not used for delete by bookmark, update by bookmark, or fetch by bookmark operations in SQLBulkOperations, which use bookmarks cached in rowset buffers.

+#
SQL_ATTR_IMP_PARAM_DESC
+# (ODBC 3.0)		The handle to the IPD. The value of this attribute is the descriptor allocated when the statement was initially allocated. The application cannot set this attribute. +#

This attribute can be retrieved by a call to SQLGetStmtAttr but not set by a call to SQLSetStmtAttr.

+#
SQL_ATTR_IMP_ROW_DESC
+# (ODBC 3.0)		The handle to the IRD. The value of this attribute is the descriptor allocated when the statement was initially allocated. The application cannot set this attribute. +#

This attribute can be retrieved by a call to SQLGetStmtAttr but not set by a call to SQLSetStmtAttr.

+#
SQL_ATTR_KEYSET_SIZE
+# (ODBC 2.0)		An SQLUINTEGER that specifies the number of rows in the keyset for a keyset-driven cursor. If the keyset size is 0 (the default), the cursor is fully keyset-driven. If the keyset size is greater than 0, the cursor is mixed (keyset-driven within the keyset and dynamic outside of the keyset). The default keyset size is 0. For more information about keyset-driven cursors, see "Keyset-Driven Cursors" in Chapter 11: Retrieving Results (Advanced). +#

If the specified size exceeds the maximum keyset size, the driver substitutes that size and returns SQLSTATE 01S02 (Option value changed).

+# +#

SQLFetch or SQLFetchScroll returns an error if the keyset size is greater than 0 and less than the rowset size.

+#
SQL_ATTR_MAX_LENGTH
+# (ODBC 1.0)		An SQLUINTEGER value that specifies the maximum amount of data that the driver returns from a character or binary column. If ValuePtr is less than the length of the available data, SQLFetch or SQLGetData truncates the data and returns SQL_SUCCESS. If ValuePtr is 0 (the default), the driver attempts to return all available data. +#

If the specified length is less than the minimum amount of data that the data source can return or greater than the maximum amount of data that the data source can return, the driver substitutes that value and returns SQLSTATE 01S02 (Option value changed).

+# +#

The value of this attribute can be set on an open cursor; however, the setting might not take effect immediately, in which case the driver will return SQLSTATE 01S02 (Option value changed) and reset the attribute to its original value.

+# +#

This attribute is intended to reduce network traffic and should be supported only when the data source (as opposed to the driver) in a multiple-tier driver can implement it. This mechanism should not be used by applications to truncate data; to truncate data received, an application should specify the maximum buffer length in the BufferLength argument in SQLBindCol or SQLGetData.

+#
SQL_ATTR_MAX_ROWS
+# (ODBC 1.0)		An SQLUINTEGER value corresponding to the maximum number of rows to return to the application for a SELECT statement. If *ValuePtr equals 0 (the default), the driver returns all rows. +#

This attribute is intended to reduce network traffic. Conceptually, it is applied when the result set is created and limits the result set to the first ValuePtr rows. If the number of rows in the result set is greater than ValuePtr, the result set is truncated.

+# +#

SQL_ATTR_MAX_ROWS applies to all result sets on the Statement, including those returned by catalog functions. SQL_ATTR_MAX_ROWS establishes a maximum for the value of the cursor row count.

+# +#

A driver should not emulate SQL_ATTR_MAX_ROWS behavior for SQLFetch or SQLFetchScroll (if result set size limitations cannot be implemented at the data source) if it cannot guarantee that SQL_ATTR_MAX_ROWS will be implemented properly.

+# +#

It is driver-defined whether SQL_ATTR_MAX_ROWS applies to statements other than SELECT statements (such as catalog functions).

+# +#

The value of this attribute can be set on an open cursor; however, the setting might not take effect immediately, in which case the driver will return SQLSTATE 01S02 (Option value changed) and reset the attribute to its original value.

+#
SQL_ATTR_METADATA_ID
+# (ODBC 3.0)		An SQLUINTEGER value that determines how the string arguments of catalog functions are treated. +#

If SQL_TRUE, the string argument of catalog functions are treated as identifiers. The case is not significant. For nondelimited strings, the driver removes any trailing spaces and the string is folded to uppercase. For delimited strings, the driver removes any leading or trailing spaces and takes whatever is between the delimiters literally. If one of these arguments is set to a null pointer, the function returns SQL_ERROR and SQLSTATE HY009 (Invalid use of null pointer).

+# +#

If SQL_FALSE, the string arguments of catalog functions are not treated as identifiers. The case is significant. They can either contain a string search pattern or not, depending on the argument.

+# +#

The default value is SQL_FALSE.

+# +#

The TableType argument of SQLTables, which takes a list of values, is not affected by this attribute.

+# +#

SQL_ATTR_METADATA_ID can also be set on the connection level. (It and SQL_ATTR_ASYNC_ENABLE are the only statement attributes that are also connection attributes.)

+# +#

For more information, see "Arguments in Catalog Functions" in Chapter 7: Catalog Functions.

+#
SQL_ATTR_NOSCAN
+# (ODBC 1.0)		An SQLUINTEGER value that indicates whether the driver should scan SQL strings for escape sequences: +#

SQL_NOSCAN_OFF = The driver scans SQL strings for escape sequences (the default).

+# +#

SQL_NOSCAN_ON = The driver does not scan SQL strings for escape sequences. Instead, the driver sends the statement directly to the data source.

+# +#

For more information, see "Escape Sequences in ODBC" in Chapter 8: SQL Statements.

+#
SQL_ATTR_PARAM_BIND_OFFSET_PTR
+# (ODBC 3.0)		An SQLUINTEGER * value that points to an offset added to pointers to change binding of dynamic parameters. If this field is non-null, the driver dereferences the pointer, adds the dereferenced value to each of the deferred fields in the descriptor record (SQL_DESC_DATA_PTR, SQL_DESC_INDICATOR_PTR, and SQL_DESC_OCTET_LENGTH_PTR), and uses the new pointer values when binding. It is set to null by default. +#

The bind offset is always added directly to the SQL_DESC_DATA_PTR, SQL_DESC_INDICATOR_PTR, and SQL_DESC_OCTET_LENGTH_PTR fields. If the offset is changed to a different value, the new value is still added directly to the value in the descriptor field. The new offset is not added to the field value plus any earlier offsets.

+#
SQL_ATTR_PARAM_BIND_OFFSET_PTR
+# (ODBC 3.0) (continued)		For more information, see "Parameter Binding Offsets" in Chapter 9: Executing Statements. +#

Setting this statement attribute sets the SQL_DESC_BIND_OFFSET_PTR field in the APD header.

+#
SQL_ATTR_PARAM_BIND_TYPE
+# (ODBC 3.0)		An SQLUINTEGER value that indicates the binding orientation to be used for dynamic parameters. +#

This field is set to SQL_PARAM_BIND_BY_COLUMN (the default) to select column-wise binding.

+# +#

To select row-wise binding, this field is set to the length of the structure or an instance of a buffer that will be bound to a set of dynamic parameters. This length must include space for all of the bound parameters and any padding of the structure or buffer to ensure that when the address of a bound parameter is incremented with the specified length, the result will point to the beginning of the same parameter in the next set of parameters. When using the sizeof operator in ANSI C, this behavior is guaranteed.

+# +#

For more information, see "Binding Arrays of Parameters" in Chapter 9: Executing Statements.

+# +#

Setting this statement attribute sets the SQL_DESC_ BIND_TYPE field in the APD header.

+#
SQL_ATTR_PARAM_OPERATION_PTR
+# (ODBC 3.0)		An SQLUSMALLINT * value that points to an array of SQLUSMALLINT values used to ignore a parameter during execution of an SQL statement. Each value is set to either SQL_PARAM_PROCEED (for the parameter to be executed) or SQL_PARAM_IGNORE (for the parameter to be ignored). +#

A set of parameters can be ignored during processing by setting the status value in the array pointed to by SQL_DESC_ARRAY_STATUS_PTR in the APD to SQL_PARAM_IGNORE. A set of parameters is processed if its status value is set to SQL_PARAM_PROCEED or if no elements in the array are set.

+# +#

This statement attribute can be set to a null pointer, in which case the driver does not return parameter status values. This attribute can be set at any time, but the new value is not used until the next time SQLExecDirect or SQLExecute is called.

+# +#

For more information, see "Using Arrays of Parameters" in Chapter 9: Executing Statements.

+# +#

Setting this statement attribute sets the SQL_DESC_ARRAY_STATUS_PTR field in the APD header.

+#
SQL_ATTR_PARAM_STATUS_PTR
+# (ODBC 3.0)		An SQLUSMALLINT * value that points to an array of SQLUSMALLINT values containing status information for each row of parameter values after a call to SQLExecute or SQLExecDirect. This field is required only if PARAMSET_SIZE is greater than 1. +#

The status values can contain the following values:

+# +#

SQL_PARAM_SUCCESS: The SQL statement was successfully executed for this set of parameters.

+# +#

SQL_PARAM_SUCCESS_WITH_INFO: The SQL statement was successfully executed for this set of parameters; however, warning information is available in the diagnostics data structure.

+# +#

SQL_PARAM_ERROR: There was an error in processing this set of parameters. Additional error information is available in the diagnostics data structure.

+# +#

SQL_PARAM_UNUSED: This parameter set was unused, possibly due to the fact that some previous parameter set caused an error that aborted further processing, or because SQL_PARAM_IGNORE was set for that set of parameters in the array specified by the SQL_ATTR_PARAM_OPERATION_PTR.

+# +#

SQL_PARAM_DIAG_UNAVAILABLE: The driver treats arrays of parameters as a monolithic unit and so does not generate this level of error information.

+# +#

This statement attribute can be set to a null pointer, in which case the driver does not return parameter status values. This attribute can be set at any time, but the new value is not used until the next time SQLExecute or SQLExecDirect is called. Note that setting this attribute can affect the output parameter behavior implemented by the driver.

+# +#

For more information, see "Using Arrays of Parameters" in Chapter 9: Executing Statements.

+# +#

Setting this statement attribute sets the SQL_DESC_ARRAY_STATUS_PTR field in the IPD header.

+#
SQL_ATTR_PARAMS_PROCESSED_PTR
+# (ODBC 3.0)		An SQLUINTEGER * record field that points to a buffer in which to return the number of sets of parameters that have been processed, including error sets. No number will be returned if this is a null pointer. +#

Setting this statement attribute sets the SQL_DESC_ROWS_PROCESSED_PTR field in the IPD header.

+# +#

If the call to SQLExecDirect or SQLExecute that fills in the buffer pointed to by this attribute does not return SQL_SUCCESS or SQL_SUCCESS_WITH_INFO, the contents of the buffer are undefined.

+# +#

For more information, see "Using Arrays of Parameters" in Chapter 9: Executing Statements.

+#
SQL_ATTR_PARAMSET_SIZE
+# (ODBC 3.0)		An SQLUINTEGER value that specifies the number of values for each parameter. If SQL_ATTR_PARAMSET_SIZE is greater than 1, SQL_DESC_DATA_PTR, SQL_DESC_INDICATOR_PTR, and SQL_DESC_OCTET_LENGTH_PTR of the APD point to arrays. The cardinality of each array is equal to the value of this field. +#

For more information, see "Using Arrays of Parameters" in Chapter 9: Executing Statements.

+# +#

Setting this statement attribute sets the SQL_DESC_ARRAY_SIZE field in the APD header.

+#
SQL_ATTR_QUERY_TIMEOUT
+# (ODBC 1.0)		An SQLUINTEGER value corresponding to the number of seconds to wait for an SQL statement to execute before returning to the application. If ValuePtr is equal to 0 (default), there is no timeout. +#

If the specified timeout exceeds the maximum timeout in the data source or is smaller than the minimum timeout, SQLSetStmtAttr substitutes that value and returns SQLSTATE 01S02 (Option value changed).

+# +#

Note that the application need not call SQLCloseCursor to reuse the statement if a SELECT statement timed out.

+# +#

The query timeout set in this statement attribute is valid in both synchronous and asynchronous modes.

+#
SQL_ATTR_RETRIEVE_DATA
+# (ODBC 2.0)		An SQLUINTEGER value: +#

SQL_RD_ON = SQLFetchScroll and, in ODBC 3.x, SQLFetch retrieve data after it positions the cursor to the specified location. This is the default.

+# +#

SQL_RD_OFF = SQLFetchScroll and, in ODBC 3.x, SQLFetch do not retrieve data after it positions the cursor.

+# +#

By setting SQL_RETRIEVE_DATA to SQL_RD_OFF, an application can verify that a row exists or retrieve a bookmark for the row without incurring the overhead of retrieving rows. For more information, see "Scrolling and Fetching Rows" in Chapter 11: Retrieving Results (Advanced).

+# +#

The value of this attribute can be set on an open cursor; however, the setting might not take effect immediately, in which case the driver will return SQLSTATE 01S02 (Option value changed) and reset the attribute to its original value.

+#
SQL_ATTR_ROW_ARRAY_SIZE
+# (ODBC 3.0)		An SQLUINTEGER value that specifies the number of rows returned by each call to SQLFetch or SQLFetchScroll. It is also the number of rows in a bookmark array used in a bulk bookmark operation in SQLBulkOperations. The default value is 1. +#

If the specified rowset size exceeds the maximum rowset size supported by the data source, the driver substitutes that value and returns SQLSTATE 01S02 (Option value changed).

+# +#

For more information, see "Rowset Size" in Chapter 11: Retrieving Results (Advanced).

+# +#

Setting this statement attribute sets the SQL_DESC_ARRAY_SIZE field in the ARD header.

+#
SQL_ATTR_ROW_BIND_OFFSET_PTR
+# (ODBC 3.0)		An SQLUINTEGER * value that points to an offset added to pointers to change binding of column data. If this field is non-null, the driver dereferences the pointer, adds the dereferenced value to each of the deferred fields in the descriptor record (SQL_DESC_DATA_PTR, SQL_DESC_INDICATOR_PTR, and SQL_DESC_OCTET_LENGTH_PTR), and uses the new pointer values when binding. It is set to null by default. +#

Setting this statement attribute sets the SQL_DESC_BIND_OFFSET_PTR field in the ARD header.

+#
SQL_ATTR_ROW_BIND_TYPE
+# (ODBC 1.0)		An SQLUINTEGER value that sets the binding orientation to be used when SQLFetch or SQLFetchScroll is called on the associated statement. Column-wise binding is selected by setting the value to SQL_BIND_BY_COLUMN. Row-wise binding is selected by setting the value to the length of a structure or an instance of a buffer into which result columns will be bound. +#

If a length is specified, it must include space for all of the bound columns and any padding of the structure or buffer to ensure that when the address of a bound column is incremented with the specified length, the result will point to the beginning of the same column in the next row. When using the sizeof operator with structures or unions in ANSI C, this behavior is guaranteed.

+# +#

Column-wise binding is the default binding orientation for SQLFetch and SQLFetchScroll.

+# +#

For more information, see "Binding Columns for Use with Block Cursors" in Chapter 11: Retrieving Results (Advanced).

+# +#

Setting this statement attribute sets the SQL_DESC_BIND_TYPE field in the ARD header.

+#
SQL_ATTR_ROW_NUMBER
+# (ODBC 2.0)		An SQLUINTEGER value that is the number of the current row in the entire result set. If the number of the current row cannot be determined or there is no current row, the driver returns 0. +#

This attribute can be retrieved by a call to SQLGetStmtAttr but not set by a call to SQLSetStmtAttr.

+#
SQL_ATTR_ROW_OPERATION_PTR
+# (ODBC 3.0)		An SQLUSMALLINT * value that points to an array of SQLUSMALLINT values used to ignore a row during a bulk operation using SQLSetPos. Each value is set to either SQL_ROW_PROCEED (for the row to be included in the bulk operation) or SQL_ROW_IGNORE (for the row to be excluded from the bulk operation). (Rows cannot be ignored by using this array during calls to SQLBulkOperations.) +#

This statement attribute can be set to a null pointer, in which case the driver does not return row status values. This attribute can be set at any time, but the new value is not used until the next time SQLSetPos is called.

+# +#

For more information, see "Updating Rows in the Rowset with SQLSetPos" and "Deleting Rows in the Rowset with SQLSetPos" in Chapter 12: Updating Data.

+# +#

Setting this statement attribute sets the SQL_DESC_ARRAY_STATUS_PTR field in the ARD.

+#
SQL_ATTR_ROW_STATUS_PTR
+# (ODBC 3.0)		An SQLUSMALLINT * value that points to an array of SQLUSMALLINT values containing row status values after a call to SQLFetch or SQLFetchScroll. The array has as many elements as there are rows in the rowset. +#

This statement attribute can be set to a null pointer, in which case the driver does not return row status values. This attribute can be set at any time, but the new value is not used until the next time SQLBulkOperations, SQLFetch, SQLFetchScroll, or SQLSetPos is called.

+# +#

For more information, see "Number of Rows Fetched and Status" in Chapter 11: Retrieving Results (Advanced).

+# +#

Setting this statement attribute sets the SQL_DESC_ARRAY_STATUS_PTR field in the IRD header.

+# +#

This attribute is mapped by an ODBC 2.x driver to the rgbRowStatus array in a call to SQLExtendedFetch.

+#
SQL_ATTR_ROWS_FETCHED_PTR
+# (ODBC 3.0)		An SQLUINTEGER * value that points to a buffer in which to return the number of rows fetched after a call to SQLFetch or SQLFetchScroll; the number of rows affected by a bulk operation performed by a call to SQLSetPos with an Operation argument of SQL_REFRESH; or the number of rows affected by a bulk operation performed by SQLBulkOperations. This number includes error rows. +#

For more information, see "Number of Rows Fetched and Status" in Chapter 11: Retrieving Results (Advanced).

+# +#

Setting this statement attribute sets the SQL_DESC_ROWS_PROCESSED_PTR field in the IRD header.

+# +#

If the call to SQLFetch or SQLFetchScroll that fills in the buffer pointed to by this attribute does not return SQL_SUCCESS or SQL_SUCCESS_WITH_INFO, the contents of the buffer are undefined.

+#
SQL_ATTR_SIMULATE_CURSOR
+# (ODBC 2.0)		An SQLUINTEGER value that specifies whether drivers that simulate positioned update and delete statements guarantee that such statements affect only one single row. +#

To simulate positioned update and delete statements, most drivers construct a searched UPDATE or DELETE statement containing a WHERE clause that specifies the value of each column in the current row. Unless these columns make up a unique key, such a statement can affect more than one row.

+# +#

To guarantee that such statements affect only one row, the driver determines the columns in a unique key and adds these columns to the result set. If an application guarantees that the columns in the result set make up a unique key, the driver is not required to do so. This may reduce execution time.

+# +#

SQL_SC_NON_UNIQUE = The driver does not guarantee that simulated positioned update or delete statements will affect only one row; it is the application's responsibility to do so. If a statement affects more than one row, SQLExecute, SQLExecDirect, or SQLSetPos returns SQLSTATE 01001 (Cursor operation conflict).

+# +#

SQL_SC_TRY_UNIQUE = The driver attempts to guarantee that simulated positioned update or delete statements affect only one row. The driver always executes such statements, even if they might affect more than one row, such as when there is no unique key. If a statement affects more than one row, SQLExecute, SQLExecDirect, or SQLSetPos returns SQLSTATE 01001 (Cursor operation conflict).

+# +#

SQL_SC_UNIQUE = The driver guarantees that simulated positioned update or delete statements affect only one row. If the driver cannot guarantee this for a given statement, SQLExecDirect or SQLPrepare returns an error.

+# +#

If the data source provides native SQL support for positioned update and delete statements and the driver does not simulate cursors, SQL_SUCCESS is returned when SQL_SC_UNIQUE is requested for SQL_SIMULATE_CURSOR. SQL_SUCCESS_WITH_INFO is returned if SQL_SC_TRY_UNIQUE or SQL_SC_NON_UNIQUE is requested. If the data source provides the SQL_SC_TRY_UNIQUE level of support and the driver does not, SQL_SUCCESS is returned for SQL_SC_TRY_UNIQUE and SQL_SUCCESS_WITH_INFO is returned for SQL_SC_NON_UNIQUE.

+# +#

If the specified cursor simulation type is not supported by the data source, the driver substitutes a different simulation type and returns SQLSTATE 01S02 (Option value changed). For SQL_SC_UNIQUE, the driver substitutes, in order, SQL_SC_TRY_UNIQUE or SQL_SC_NON_UNIQUE. For SQL_SC_TRY_UNIQUE, the driver substitutes SQL_SC_NON_UNIQUE.

+# +#

For more information, see "Simulating Positioned Update and Delete Statements" in Chapter 12: Updating Data.

+#
SQL_ATTR_USE_BOOKMARKS
+# (ODBC 2.0)		An SQLUINTEGER value that specifies whether an application will use bookmarks with a cursor: +#

SQL_UB_OFF = Off (the default)

+# +#

SQL_UB_VARIABLE = An application will use bookmarks with a cursor, and the driver will provide variable-length bookmarks if they are supported. SQL_UB_FIXED is deprecated in ODBC 3.x. ODBC 3.x applications should always use variable-length bookmarks, even when working with ODBC 2.x drivers (which supported only 4-byte, fixed-length bookmarks). This is because a fixed-length bookmark is just a special case of a variable-length bookmark. When working with an ODBC 2.x driver, the Driver Manager maps SQL_UB_VARIABLE to SQL_UB_FIXED.

+# +#

To use bookmarks with a cursor, the application must specify this attribute with the SQL_UB_VARIABLE value before opening the cursor.

+# +#

For more information, see "Retrieving Bookmarks" in Chapter 11: Retrieving Results (Advanced).

+#
+# +#

[1]   These functions can be called asynchronously only if the descriptor is an implementation descriptor, not an application descriptor.

+#

See "Column-Wise Binding" and "Row-Wise Binding" in Chapter 11: Retrieving Results (Advanced).

+# +#

Related Functions

+#
+# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
For information aboutSee
Canceling statement processingSQLCancel
Returning the setting of a connection attributeSQLGetConnectAttr
Returning the setting of a statement attributeSQLGetStmtAttr
Setting a connection attributeSQLSetConnectAttr
Setting a single field of the descriptorSQLSetDescField
+#

+# +#
+# +# +# +}; + +my $i3 = " " x 3; +my $i4 = " " x 4; +my $i8 = " " x 8; + +my $type2type = { + SQLSMALLINT => 'Smallint', + SQLUSMALLINT => 'Usmallint', + SQLINTEGER => 'Integer', + SQLUINTEGER => 'Uinteger', + SQLPOINTER => 'Pointer', + SQLCHAR => 'Sqlchar', +}; + +my $attr = + $type eq 'Env' ? $attrEnv : + $type eq 'Dbc' ? $attrDbc : + $type eq 'Stmt' ? $attrStmt : die "bad type $type"; + +my @name = sort { + $attr->{$a}{order} <=> $attr->{$b}{order} +} keys %$attr; + +print "#include \"Handle$type.hpp\"\n"; +my $class = "OdbcData"; + +for my $name (@name) { + my $p = $attr->{$name}; + my $odbctype = $type2type->{$p->{type}} or die $name; + $odbctype .= "Ptr" if $p->{ptr}; + print "\nstatic void\n"; + print "callback_${name}_set(Ctx& ctx, HandleBase* self, const $class& data)\n"; + print "{\n"; + print "${i4}Handle$type* p$type = dynamic_cast(self);\n"; + print "${i4}assert(p$type != 0 && data.type() == ${class}::$odbctype);\n"; + print "}\n"; + print "\nstatic void\n"; + print "callback_${name}_default(Ctx& ctx, HandleBase* self, $class& data)\n"; + print "{\n"; + print "${i4}Handle$type* p$type = dynamic_cast(self);\n"; + print "${i4}assert(p$type != 0);\n"; + print "${i4}data.set();\n"; + print "}\n"; +} + +print "\nAttrSpec Handle${type}::m_attrSpec\[\] = {\n"; +for my $name (@name) { + my $p = $attr->{$name}; + my $odbctype = $type2type->{$p->{type}} or die $name; + $odbctype .= "Ptr" if $p->{ptr}; + print "${i4}\{${i3}$name,\n"; + print "${i8}${class}::$odbctype,\n"; + my $attrmode = + $p->{mode} eq 'rw' ? 'Attr_mode_readwrite' : + $p->{mode} eq 'ro' ? 'Attr_mode_readonly' : die "bad mode $p->{mode}"; + print "${i8}$attrmode,\n"; + print "${i8}callback_${name}_set,\n"; + print "${i8}callback_${name}_default,\n"; + print "${i4}\},\n"; +} +print "${i4}\{${i3}0,\n"; +print "${i8}${class}::Undef,\n"; +print "${i8}Attr_mode_undef,\n"; +print "${i8}0,\n"; +print "${i8}0,\n"; +print "${i4}\},\n"; + +print "};\n"; diff --git a/ndb/src/client/odbc/docs/main.hpp b/ndb/src/client/odbc/docs/main.hpp new file mode 100644 index 00000000000..ebb5b1f235a --- /dev/null +++ b/ndb/src/client/odbc/docs/main.hpp @@ -0,0 +1,104 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/** + @mainpage NDB ODBC + + The ODBC Driver Frontend has: + -# HandleBase : Various ODBC handles + -# AttrArea : Attributes of handles + -# ConnArea : Communication area on connection level between driver parts + -# StmtArea : Communication area on statement level between driver parts + + and controls the following steps: + -# SQL_compiler : Compiles SQL into SQL_code_tree:s + -# Parser : Bison grammar + -# Analyzer : Syntactic and semantic checks (binds names) + -# PlanGen : Generate initial (execution) plan (PlanTree) + -# CodeGen : Generates CodeTree:s out of PlanTree:s + -# Optimizer : Optimizes PlanTree:s + -# Output : Outputs executable CodeTree:s + -# Executor : Executes CodeTree:s + -# CodeTree::allocRun : Allocates runtime data structures (RunTree:s) + -# Dataflow machine : Executes and evaluates statement and expressions + + The Dataflow machine works in four different ways: + -# Non-query statements + -# CodeStmt::execute : Executes (non-query) statement + -# Query statements + -# CodeQuery::execute : Execute Query statement + -# CodeQuery::fetch : Fetch row from CodeQuery node + -# Boolean expressions + -# CodePred::evaluate : Evaluates boolean expression + -# Arithmetical expressions + -# CodeExpr::evaluate : Evaluates arithmetic expression + + The following components are used throughout the NDB ODBC: + -# Context (Ctx) : Info regarding execution/evaluation + -# Diagnostic area (DiagArea) : Errors and warnings (for ODBC user) + -# DescArea : Description of ODBC user input/output bind varibles/columns + -# Dictionary (DictBase) : Lookup info stored in NDB Dictionary + and info regarding temporary + materialized results + -# ResultArea : Execution (temporary) results + + + @section secCompiler SQL_compiler : SQL to SQL_code_tree + + The SQL_compiler takes an SQL statement and translates + it into an SQL_code_tree. The compiler uses an SQL_code_tree + internally during the compilation and the result of the compilation + is a simlified SQL_code_tree. + + The compiler works in the following steps: + -# Parse SQL statments and create SQL_code_tree representing the + statement. + -# Apply Syntax Rules to the SQL_code_tree. Syntax rules are + rules which are not expressed in the SQL grammar, + but are expressed in natural language in the SQL specification. + -# Apply Access Rules to the SQL_code_tree + (this is not implemented, since NDB Cluster has no access control) + -# Apply General Rules to the SQL_code_tree + -# Apply Conformance Rules to the SQL_code_tree + + The resulting simplified SQL_code_tree is represented by a + tree of C++ objects. + + + @section secCodegen Codegen : SQL_code_tree to CodeTree + + CodeGen takes simplified SQL_code_tree:s and transforms them into + CodeTree:s. + + + @section secOptimizer Optimizer : CodeTree to CodeTree + + The implementation of the ODBC optimizer will uses the + PlanTree:s to represent statements and transforms them + into executable format (still PlanTree format). + + @note In the future, more optimizations can be implemented. + + + @section secExecutor Executor : Execute CodeTree + + The Executor uses the following data structures: + -# CodeTree : A read-only quary evaluation plan + -# RunTree : Runtime data structures containing ResultSet:s + + The execution mechanism is actually implemented as a + part of the CodeTree. +*/ diff --git a/ndb/src/client/odbc/docs/ndbodbc.html b/ndb/src/client/odbc/docs/ndbodbc.html new file mode 100644 index 00000000000..6be624dfa1b --- /dev/null +++ b/ndb/src/client/odbc/docs/ndbodbc.html @@ -0,0 +1,659 @@ + + + +ODBC and SQL + + + +

ODBC and SQL - NDB Cluster v2.11

+ +

+NDB Cluster v2.11 includes a version of ODBC and SQL. +

+This document has 4 sections. +

    +
  1. PLATFORMS +
  2. ODBC +
  3. SQL +
  4. DIAGNOSTICS +
+

+Features which are currently incomplete or planned for next release +are marked with v2.x. + +

1. PLATFORMS

+ +

1.1 Linux / Unix

+

+We use RedHat package names to describe supporting software. +Packages starting with perl- are perl modules. +If your installation does not include them you can get them +from a CPAN archive ( ftp://ftp.funet.fi/pub/languages/perl/CPAN ). +

+Version numbers are given only as examples. +Other versions will work. +

+An ODBC driver manager is required, one of: +

    +
  • unixODBC-2.2.3 (this is more common) +
  • libiodbc-3.0.5 +
+

+Additional packages are convenient. +Following include perl scripting interface +and an "interactive SQL" tool dbish: +

    +
  • perl-DBI-1.30 +
  • perl-DBD-ODBC-0.43 +
  • readline-4.2 +
  • perl-Term-ReadLine-Gnu-1.11 +
+

+The NDB ODBC driver is located under NDB Cluster installation +directory and is named libNDB_ODBC.so. +It includes NDB API. +To use it create a text file +/etc/odbc.ini or $HOME/.odbc.ini +containing at least: +

+ + +[ndb] +
+Driver = <path-to-your-NDB-installation>/lib/libNDB_ODBC.so + + +

+Then try the shell command dbish dbi:ODBC:ndb +in an NDB API node directory. + +

1.2 Windows

+ +[ TODO - documentation ] + +

2. ODBC

+ +

2.1 External data types

+ +Usual external data types are supported and converted to and from SQL +data types. +

+ + + + + + +
type description
SQL_C_CHARcharacter buffers
SQL_C_SLONG, etcinteger types
SQL_C_DOUBLE, etcfloating types
SQL_C_TYPE_TIMESTAMPtimestamp
+ +

2.2 ODBC functions

+

+The driver implements basic ODBC functions. +Main exceptions are: +

    +
  • no named cursors +
  • no scrollable cursors +
  • no bulk operations +
  • no asynchronous execution +
+

+Following lists main ODBC 3.0 functions and +their status in the driver. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
functionsupported
SQLAllocHandle +yes +
SQLConnect +yes +
SQLGetInfo +yes +
SQLGetFunctions +yes +
SQLGetTypeInfo +yes +
SQLSetConnectAttr +yes +
SQLGetConnectAttr +yes +
SQLSetEnvAttr +yes +
SQLGetEnvAttr +yes +
SQLSetStmtAttr +yes +
SQLGetStmtAttr +yes +
SQLGetDescField +yes +
SQLGetDescRec +yes +
SQLSetDescField +yes +
SQLSetDescRec +yes +
SQLPrepare +yes +
SQLBindParameter +yes +
SQLGetCursorName +yes, but cursor names cannot be used in SQL +
SQLSetCursorName +yes, but cursor names cannot be used in SQL +
SQLSetScrollOptions +not implemented +
SQLExecute +yes +
SQLExecDirect +yes +
SQLNativeSql +not implemented +
SQLDescribeParam +not supported +
SQLNumParams +yes +
SQLParamData +yes +
SQLPutData +yes +
SQLRowCount +yes +
SQLNumResultCols +yes +
SQLDescribeCol +yes +
SQLColAttribute +yes +
SQLBindCol +yes +
SQLFetch +yes +
SQLFetchScroll +not implemented +
SQLGetData +yes +
SQLSetPos +not implemented +
SQLBulkOperations +not implemented +
SQLMoreResults +yes, but multiple result sets are not supported +
SQLGetDiagField +yes +
SQLGetDiagRec +yes +
SQLColumnPrivileges +not applicable +
SQLColumns +yes +
SQLForeignKeys +not applicable +
SQLPrimaryKeys +yes +
SQLProcedureColumns +not applicable +
SQLProcedures +not applicable +
SQLSpecialColumns +yes v2.x +
SQLStatistics +not applicable +
SQLTablePrivileges +not applicable +
SQLTables +yes +
SQLFreeStmt +yes +
SQLCloseCursor +yes +
SQLCancel +yes +
SQLEndTran +yes +
SQLDisconnect +yes +
SQLFreeHandle +yes +
+ +

3. SQL

+ +

3.1 Data types

+ + + + + + + + + + + + +
type description
CHAR(n)fixed-width blank-padded string
VARCHAR(n)variable length string
INT
INTEGER		integer 32 bits
BIGINTinteger 64 bits
DECIMAL(m,n)exact number with precision and scale v2.x
REALfloat 32 bits
FLOAT
DOUBLE PRECISION		float, at least 64 bits
DATEdate with precision 1 second v2.x
DATETIMEdate with precision 1 nanosecond (SQL_TYPE_TIMESTAMP)
+

+ +Integer types may be qualified as UNSIGNED. +

+Strings and numbers are not converted to each other automatically. +Following is an error (unlike in oracle). +
+

select 123 + '456' from tab
+ +

3.2 Expressions

+ + + + + + + + +
syntax description
NULLnull value
12.34e5integer or decimal or float constant
'abc'string constant
+ - * / ( )arithmetic operations
||string concatenation v2.x
+ +
+Integer and decimal arithmetic is done in BIGINT. +
+Floating arithmetic is done in DOUBLE PRECISION. +
+Numeric literals use largest applicable type. +
+String operations are done in CHAR or in VARCHAR (if any operand is VARCHAR). +
+String literals have type CHAR. + +

3.3 Functions : non-aggregate

+ + + + + + + +
syntax description
SUBSTR() LEFT() RIGHT()substring
TO_NUMBER() TO_CHAR()basic conversions v2.x
ROWNUMrow number in query
SYSDATEcurrent date as DATETIME
+ +

3.4 Functions : aggregate

+ + + + + + +
syntax description
COUNT(*) COUNT(expr)count rows or non-NULL values
MIN(expr) MAX(expr)min and max of strings and numbers
SUM(expr) AVG(expr)sum and average of numbers
+
+GROUP BY and HAVING are supported. + +

3.5 Predicates

+ + + + + + + +
syntax description
IS NULL / IS NOT NULLtest if value is null
< <= = != > >=comparisons
LIKE / NOT LIKEstring matching
AND OR NOT ( )boolean operators
+ +

3.6 Tables

+ +An NDB table requires a primary key. +There are 2 ways to specify it. + +

+

Case 1

+
create table t (
+    a integer not null,
+    b char(20) not null,
+    c float,
+    primary key(a, b)
+)
+
+

+

Case 2

+

+A column can be specified as AUTO_INCREMENT. +The column has following requirements. +

    +
  • it must be the primary key (not just part of one) +
  • its type must be one of the integer types +
+
create table t (
+    a int unsigned auto_increment primary key,
+    b char(20) not null,
+    c float
+)
+
+

+The values of an AUTO_INCREMENT column are unique (until wrap-around) +and form an ascending sequence. +Gaps in the sequence are possible. +

Default values

+Columns can be specified with DEFAULT value +which is used on insert if the column is not on the insert list. +

+

create table t (
+    a int primary key,
+    b int default 100
+)
+insert into t(a) values(1) -- inserts (1,100)
+
+

+The value must evaluate to constant. +Using SYSDATE (if allowed at all) evaluates to table creation time. +

+ +

Logging / nologging

+ +By default tables are created in logging mode, meaning the data +is preserved across database restart. +The mode can be specified explicitly: +

+create table t1 (a int primary key, b int) logging +
+create table t1 (a int primary key, b int) nologging + +

Schemas

+ +Schemas do not exist in current NDB Cluster. +As a convenience, a single period is allowed in table names: +

+

create table mydb.mytable (a int primary key)
+

+ +

Drop table

+ +Deletes a table, all of its indexes, and all data: +

+drop table t + +

3.7 Indexes

+Only unique non-ordered indexes exist currently. +The columns must be not nullable and are stored in same +order as underlying table columns. +

+create unique hash index x1 on t1(b, c) logging +

+Internally, a unique hash index is a table where index key is primary key. +If the index is nologging, it is rebuilt on database restart +before the database is opened. +

+Indexes can of course be dropped: +

+drop index x1 + +

3.8 Select

+ +Features: + +
    +
  • Expressions and predicates +
    select a + b * c from t where a < b + c and (b > c or c > 10) +
  • JOIN to any depth +
    select a.x, b.y, c.z from t1 a, t2 b, t2 c where a.x + b.y < c.z +
  • ORDER BY +
    select * from t1, t2 where a1 > 5 order by b1 + b2, c1 desc +
  • DISTINCT +
    select distinct a, b + c from t +
  • Aggregates without grouping. +
    select count(*), max(a), 1 + sum(b) + avg(c * d) from t +
  • Aggregates with grouping. +
    select a, sum(b) from t group by a having sum(c) > 0 order by a, sum(d) +
+ +Major omissions: +
    +
  • no OUTER JOIN +
  • no subqueries and no EXISTS clause +
+ +Queries are optimized to minimize scans, +by using primary keys and existing unique hash indexes. +Simple predicates in scans (column compared to constant) +are passed to an interpreter in NDB kernel. +Joins are done via nested loops only. +

+

    +
  • SCAN +
    select * from t where a < b +
  • INTERPRETED SCAN (much faster) +
    select * from t1, t2 where t1.a < 10 and t2.b > t1.c +
  • PRIMARY KEY lookup +
    select * from t where pk = 5 and b > 10 +
  • NESTED LOOPS +
    select * from t1, t2, t3 where t1.pk = t2.x and t2.pk = t3.y +
+ +

3.9 Insert and write

+ +Both VALUES and subquery variants can be used. +

+

insert into t(a, c) values (123, 'abc')
+insert into t1(a, c) select a + 10 * b, c from t2
+
+

+For convenience, the non-standard MySql syntax is also supported. +

+

insert into t set a = 123, c = 'abc'
+

+The non-standard operation WRITE is used exactly like INSERT. +The record is updated if it exists. +Otherwise a new record is inserted. +

+

write into t(a, c) values (123, 'abc')
+
+ +

3.10 Update

+ +Update allows no subqueries. +Update is optimized to minimize scans and reads, +by using primary keys and existing unique hash indexes. +

+

    +
  • SCAN +
    update t set a = b + 5, c = d where c > 10 +
  • PRIMARY KEY or INDEX lookup +
    update t set a = b + 5, c = d where pk = 5 and c > 10 +
  • PRIMARY KEY or INDEX direct +
    update t set a = 5, c = 7 where pk = 5 +
+ +

3.11 Delete

+ +Delete allows no subqueries. +Delete is optimized to minimize scans and reads, +by using primary keys and existing unique hash indexes. +

+

    +
  • SCAN +
    delete from t where c > 10 +
  • PRIMARY KEY or INDEX lookup +
    delete from t where pk = 5 and c > 10 +
  • PRIMARY KEY or INDEX direct +
    delete from t where pk = 5 +
+ +

3.12 Virtual tables

+ +The driver implements some virtual tables. +They can only be queried, not modified. +

+

    +
  • DUAL +
    A 1-row table - example: select SYSDATE from DUAL. +
  • ODBC$TYPEINFO +
    Corresponds to SQLGetTypeInfo. +
  • ODBC$TABLES +
    Corresponds to SQLTables but shows all NDB kernel objects. +
  • ODBC$COLUMNS +
    Corresponds to SQLColumns. +
  • ODBC$PRIMARYKEYS +
    Corresponds to SQLPrimaryKeys. +
+ +

4. DIAGNOSTICS

+ +

4.1 Diagnostic records

+ +The driver manager and driver return 3 main diagnostics +(see SQLGetDiagRec). +
    +
  • SQLSTATE (a string of 5 characters) +
  • Native error code +
  • Message text +
+

+Message text format is +

+[Alzato][ODBC driver][NDB Cluster] NDB-ssccnnn error text (in SQLXxx) +

+Here ssccnnnn is native error code (decimal number), with following parts: +

+

  • ss - status +
  • cc - classification +
  • nnnn - error code + +

    +See NDB API guide for further information. +

    +For non-database errors the last prefix [NDB Cluster] is omitted +and native error code is always 02015001. + +

    4.2 Tracing

    + +Following environment variables may be useful. +
      +
    • NDB_ODBC_TRACE +
      +Values ≥ 2 cause SQL execution plan +to be printed on standard output. +
      +Values ≥ 3 show the ODBC API functions +called by the driver manager. +

      +
    • NDB_ODBC_DEBUG +
      +Non-zero value makes the driver abort +the application on unhandled conditions. +
      +By default the ODBC API function is aborted gracefully. +
    + +

    4.3 Thread safety

    +

    +The driver has same thread-safety model as NDB API. +In NDB API each thread must use its own Ndb object. +In NDB ODBC a SQLConnect corresponds to an Ndb object. +It is required that each thread allocates its +own ODBC handles (of all types). + +

    4.4 Data formats

    +

    +SQL types are represented as (old) NDB types as follows. +

    + + + + + + + +
    SQL type NDB type
    CHAR(n)String(n), blank-padded to n
    VARCHAR(n)String(n+2), zero-padded to n, length in last 2 bytes (big-endian)
    integersSigned(x) or UnSigned(x), x=16,32,64, native format
    floatsFloat(x), x=32,64, native format
    DATETIMEString(12) = cc yy mm dd HH MM SS \0 ff ff ff ff (big-endian)
    +

    +Note: SQL types exist now in NDB API in NdbDictionary class. +However they are not yet understood by NDB API operations. + +

    4.5 NDB Cluster limitations

    +

    +

      +
    • Isolation level is READ COMMITTED. +A scan (non-primary-key select of several rows) does not see consistent data. +

      +
    • Inserting into a table from itself is likely to cause a deadlock +or a random result. +
      no: insert into t(a, b) select a*100, b+100 from t +

      +
    • Number of uncommitted rows is limited by NDB configuration +parameter MaxNoOfConcurrentOperations (typical default 4096). +To delete all rows from a large table one may need to do repeatedly: +
      delete from t where rownum < 4000 +
    + +

    4.6 Known problems v2.11

    +

    +Following lists specific known problems. +

      +
    • ORDER BY works only with expressions, +not with column aliases or positions. +
      no: select a+b x from t order by x +
      no: select * from t order by 1, 2, 3 +

      +
    • Join optimizer does not always minimize number of scans. +Changing the order of tables in the statement may help. +
    + +

    4.7 Useful links

    +

    +Microsoft ODBC page +
    +unixODBC home page +
    +iODBC home page + + + diff --git a/ndb/src/client/odbc/docs/select.fig b/ndb/src/client/odbc/docs/select.fig new file mode 100644 index 00000000000..4f51a2085b4 --- /dev/null +++ b/ndb/src/client/odbc/docs/select.fig @@ -0,0 +1,94 @@ +#FIG 3.2 +Landscape +Center +Inches +A4 +92.00 +Single +-2 +1200 2 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 2700 2700 1500 3900 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 3150 2700 3150 3900 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 3600 4500 4800 5700 +2 1 1 1 0 7 50 0 -1 4.000 0 0 7 1 0 2 + 0 0 1.00 60.00 120.00 + 3600 2700 4800 3900 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 2775 4500 1200 5700 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 3150 4500 3150 5700 +2 4 0 1 0 7 50 0 -1 0.000 0 0 7 0 0 5 + 2100 4500 2100 3900 600 3900 600 4500 2100 4500 +2 4 0 1 0 7 50 0 -1 0.000 0 0 7 0 0 5 + 2100 6300 2100 5700 600 5700 600 6300 2100 6300 +2 4 0 1 0 7 50 0 -1 0.000 0 0 7 0 0 5 + 3900 4500 3900 3900 2400 3900 2400 4500 3900 4500 +2 4 1 1 0 7 50 0 -1 4.000 0 0 7 0 0 5 + 5700 4500 5700 3900 4200 3900 4200 4500 5700 4500 +2 4 0 1 0 7 50 0 -1 0.000 0 0 7 0 0 5 + 3900 6300 3900 5700 2400 5700 2400 6300 3900 6300 +2 4 0 1 0 7 50 0 -1 0.000 0 0 7 0 0 5 + 5700 6300 5700 5700 4200 5700 4200 6300 5700 6300 +2 4 0 1 0 7 50 0 -1 0.000 0 0 7 0 0 5 + 8400 2700 8400 2100 6900 2100 6900 2700 8400 2700 +2 4 0 1 0 7 50 0 -1 0.000 0 0 7 0 0 5 + 8400 6300 8400 5700 6900 5700 6900 6300 8400 6300 +2 1 0 1 0 7 50 0 -1 4.000 0 0 7 1 0 2 + 0 0 1.00 60.00 120.00 + 7650 2700 7650 5700 +2 1 0 1 0 7 50 0 -1 4.000 0 0 7 1 0 2 + 0 0 1.00 60.00 120.00 + 7650 6300 7650 7500 +2 1 1 1 0 7 50 0 -1 4.000 0 0 7 1 0 2 + 0 0 1.00 60.00 120.00 + 8100 6300 10575 6900 +2 1 0 1 0 7 50 0 -1 4.000 0 0 7 1 0 2 + 0 0 1.00 60.00 120.00 + 8100 2700 10575 3300 +2 4 0 1 0 7 50 0 -1 0.000 0 0 7 0 0 5 + 11700 3900 11700 3300 10200 3300 10200 3900 11700 3900 +2 4 0 1 0 7 50 0 -1 0.000 0 0 7 0 0 5 + 9900 5400 9900 4800 8400 4800 8400 5400 9900 5400 +2 4 0 1 0 7 50 0 -1 0.000 0 0 7 0 0 5 + 11700 5400 11700 4800 10200 4800 10200 5400 11700 5400 +2 4 0 1 0 7 50 0 -1 0.000 0 0 7 0 0 5 + 13500 5400 13500 4800 12000 4800 12000 5400 13500 5400 +2 1 0 1 0 7 50 0 -1 4.000 0 0 7 1 0 2 + 0 0 1.00 60.00 120.00 + 10500 3900 9300 4800 +2 1 0 1 0 7 50 0 -1 4.000 0 0 7 1 0 2 + 0 0 1.00 60.00 120.00 + 11400 3900 12600 4800 +2 1 0 1 0 7 50 0 -1 4.000 0 0 -1 1 0 2 + 0 0 1.00 60.00 120.00 + 10950 3900 10950 4800 +2 4 0 1 0 7 50 0 -1 0.000 0 0 7 0 0 5 + 8400 8100 8400 7500 6900 7500 6900 8100 8400 8100 +2 4 0 1 0 7 50 0 -1 0.000 0 0 7 0 0 5 + 3900 2700 3900 2100 2400 2100 2400 2700 3900 2700 +2 4 1 1 0 7 50 0 -1 4.000 0 0 7 0 0 5 + 11700 7500 11700 6900 10200 6900 10200 7500 11700 7500 +4 0 0 50 0 14 12 0.0000 4 135 840 900 4275 table T1\001 +4 0 0 50 0 14 20 0.0000 4 240 4125 900 1125 select A, C, 123 from T1/\001 +4 0 0 50 0 14 12 0.0000 4 135 840 825 6075 column A\001 +4 0 0 50 0 14 12 0.0000 4 135 840 2775 6075 column C\001 +4 0 0 50 0 14 12 0.0000 4 135 945 4425 6075 const 123\001 +4 0 0 50 0 14 12 0.0000 4 135 630 4575 4275 clause\001 +4 0 0 50 0 14 12 0.0000 4 90 315 2925 4275 row\001 +4 0 0 50 0 14 12 0.0000 4 180 735 7200 2475 project\001 +4 0 0 50 0 14 12 0.0000 4 135 630 7200 6000 filter\001 +4 0 0 50 0 14 12 0.0000 4 135 840 8625 5100 column 1\001 +4 0 0 50 0 14 12 0.0000 4 135 840 10500 5100 column 2\001 +4 0 0 50 0 14 12 0.0000 4 135 945 12300 5100 const 123\001 +4 0 0 50 0 14 12 0.0000 4 90 315 10650 3600 row\001 +4 0 0 50 0 14 12 0.0000 4 150 840 7200 7800 scan 1,2\001 +4 0 0 50 0 14 12 0.0000 4 135 630 2850 2475 select\001 +4 0 0 50 0 14 12 0.0000 4 135 630 10500 7200 clause\001 diff --git a/ndb/src/client/odbc/docs/systables.pl b/ndb/src/client/odbc/docs/systables.pl new file mode 100644 index 00000000000..728d966a7a4 --- /dev/null +++ b/ndb/src/client/odbc/docs/systables.pl @@ -0,0 +1,2192 @@ +# usage: perl systables.pl {typeinfo|tables|columns|primarykeys} {-l|-c} +use strict; +my $what = shift; +my $opt = shift; +my $listWhat = {}; + +# +# odbcsqlgettypeinfo.htm +# +$listWhat->{typeinfo} = [ +# +# +# +# SQLGetTypeInfo +# +# +# +# +# +# +#

    +#
    +# +# +# +# +#
    +# ODBC Programmer's Reference +#
    +#
    +#
    +#
    +# +#

    SQLGetTypeInfo

    +# +#

    Conformance

    +# +#

    Version Introduced: ODBC 1.0
    +# Standards Compliance: ISO 92

    +# +#

    Summary

    +# +#

    SQLGetTypeInfo returns information about data types supported by the data source. The driver returns the information in the form of an SQL result set. The data types are intended for use in Data Definition Language (DDL) statements.

    +# +#

    Important   Applications must use the type names returned in the TYPE_NAME column of the SQLGetTypeInfo result set in ALTER TABLE and CREATE TABLE statements. SQLGetTypeInfo may return more than one row with the same value in the DATA_TYPE column.

    +# +#

    Syntax

    +# +# 
    SQLRETURN SQLGetTypeInfo(
+#	     SQLHSTMT     StatementHandle,
+#	     SQLSMALLINT     DataType);
    +# +#

    Arguments +# +#

    +#
    StatementHandle
    +# +#
    [Input]
    +# Statement handle for the result set.
    +# +#
    DataType
    +# +#
    [Input]
    +# The SQL data type. This must be one of the values in the "SQL Data Types" section of Appendix D: Data Types, or a driver-specific SQL data type. SQL_ALL_TYPES specifies that information about all data types should be returned.
    +#
    +# +#

    Returns

    +# +#

    SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_STILL_EXECUTING, SQL_ERROR, or SQL_INVALID_HANDLE.

    +# +#

    Diagnostics

    +# +#

    When SQLGetTypeInfo returns SQL_ERROR or SQL_SUCCESS_WITH_INFO, an associated SQLSTATE value can be obtained by calling SQLGetDiagRec with a HandleType of SQL_HANDLE_STMT and a Handle of StatementHandle. The following table lists the SQLSTATE values commonly returned by SQLGetTypeInfo and explains each one in the context of this function; the notation "(DM)" precedes the descriptions of SQLSTATEs returned by the Driver Manager. The return code associated with each SQLSTATE value is SQL_ERROR, unless noted otherwise.

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
    SQLSTATEErrorDescription
    01000General warningDriver-specific informational message. (Function returns SQL_SUCCESS_WITH_INFO.)
    01S02Option value changedA specified statement attribute was invalid because of implementation working conditions, so a similar value was temporarily substituted. (Call SQLGetStmtAttr to determine the temporarily substituted value.) The substitute value is valid for the StatementHandle until the cursor is closed. The statement attributes that can be changed are: SQL_ATTR_CONCURRENCY, SQL_ATTR_CURSOR_TYPE, SQL_ATTR_KEYSET_SIZE, SQL_ATTR_MAX_LENGTH, SQL_ATTR_MAX_ROWS, SQL_ATTR_QUERY_TIMEOUT, and SQL_ATTR_SIMULATE_CURSOR. (Function returns SQL_SUCCESS_WITH_INFO.)
    08S01Communication link failureThe communication link between the driver and the data source to which the driver was connected failed before the function completed processing.
    24000Invalid cursor stateA cursor was open on the StatementHandle, and SQLFetch or SQLFetchScroll had been called. This error is returned by the Driver Manager if SQLFetch or SQLFetchScroll has not returned SQL_NO_DATA, and is returned by the driver if SQLFetch or SQLFetchScroll has returned SQL_NO_DATA. +#

    A result set was open on the StatementHandle, but SQLFetch or SQLFetchScroll had not been called.

    +#
    40001Serialization failureThe transaction was rolled back due to a resource deadlock with another transaction.
    40003Statement completion unknownThe associated connection failed during the execution of this function and the state of the transaction cannot be determined.
    HY000General errorAn error occurred for which there was no specific SQLSTATE and for which no implementation-specific SQLSTATE was defined. The error message returned by SQLGetDiagRec in the *MessageText buffer describes the error and its cause.
    HY001Memory allocation errorThe driver was unable to allocate memory required to support execution or completion of the function.
    HY004Invalid SQL data typeThe value specified for the argument DataType was neither a valid ODBC SQL data type identifier nor a driver-specific data type identifier supported by the driver.
    HY008Operation canceledAsynchronous processing was enabled for the StatementHandle, then the function was called and, before it completed execution, SQLCancel was called on the StatementHandle. Then the function was called again on the StatementHandle. +#

    The function was called and, before it completed execution, SQLCancel was called on the StatementHandle from a different thread in a multithread application.

    +#
    HY010Function sequence error(DM) An asynchronously executing function (not this one) was called for the StatementHandle and was still executing when this function was called. +#

    (DM) SQLExecute, SQLExecDirect, SQLBulkOperations, or SQLSetPos was called for the StatementHandle and returned SQL_NEED_DATA. This function was called before data was sent for all data-at-execution parameters or columns.

    +#
    HY013Memory management errorThe function call could not be processed because the underlying memory objects could not be accessed, possibly because of low memory conditions.
    HYC00Optional feature not implementedThe combination of the current settings of the SQL_ATTR_CONCURRENCY and SQL_ATTR_CURSOR_TYPE statement attributes was not supported by the driver or data source. +#

    The SQL_ATTR_USE_BOOKMARKS statement attribute was set to SQL_UB_VARIABLE, and the SQL_ATTR_CURSOR_TYPE statement attribute was set to a cursor type for which the driver does not support bookmarks.

    +#
    HYT00Timeout expiredThe query timeout period expired before the data source returned the result set. The timeout period is set through SQLSetStmtAttr, SQL_ATTR_QUERY_TIMEOUT.
    HYT01Connection timeout expiredThe connection timeout period expired before the data source responded to the request. The connection timeout period is set through SQLSetConnectAttr, SQL_ATTR_CONNECTION_TIMEOUT.
    IM001Driver does not support this function(DM) The driver corresponding to the StatementHandle does not support the function.
    +# +#

    Comments

    +# +#

    SQLGetTypeInfo returns the results as a standard result set, ordered by DATA_TYPE and then by how closely the data type maps to the corresponding ODBC SQL data type. Data types defined by the data source take precedence over user-defined data types. Consequently, the sort order is not necessarily consistent but can be generalized as DATA_TYPE first, followed by TYPE_NAME, both ascending. For example, suppose that a data source defined INTEGER and COUNTER data types, where COUNTER is auto-incrementing, and that a user-defined data type WHOLENUM has also been defined. These would be returned in the order INTEGER, WHOLENUM, and COUNTER, because WHOLENUM maps closely to the ODBC SQL data type SQL_INTEGER, while the auto-incrementing data type, even though supported by the data source, does not map closely to an ODBC SQL data type. For information about how this information might be used, see "DDL Statements" in Chapter 8: SQL Statements.

    +# +#

    If the DataType argument specifies a data type which is valid for the version of ODBC supported by the driver, but is not supported by the driver, then it will return an empty result set.

    +# +#

    Note   For more information about the general use, arguments, and returned data of ODBC catalog functions, see Chapter 7: Catalog Functions.

    +# +#

    The following columns have been renamed for ODBC 3.x. The column name changes do not affect backward compatibility because applications bind by column number.

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
    ODBC 2.0 columnODBC 3.x column
    PRECISIONCOLUMN_SIZE
    MONEYFIXED_PREC_SCALE
    AUTO_INCREMENTAUTO_UNIQUE_VALUE
    +# +#

    The following columns have been added to the results set returned by SQLGetTypeInfo for ODBC 3.x: +# +#

      +#
    • SQL_DATA_TYPE
      • +# +#
    • INTERVAL_PRECISION
      • +# +#
    • SQL_DATETIME_SUB
      • +# +#
    • NUM_PREC_RADIX
      • +#
    +# +#

    The following table lists the columns in the result set. Additional columns beyond column 19 (INTERVAL_PRECISION) can be defined by the driver. An application should gain access to driver-specific columns by counting down from the end of the result set rather than specifying an explicit ordinal position. For more information, see "Data Returned by Catalog Functions" in Chapter 7: Catalog Functions.

    +# +#

    Note   SQLGetTypeInfo might not return all data types. For example, a driver might not return user-defined data types. Applications can use any valid data type, regardless of whether it is returned by SQLGetTypeInfo.

    +# +#

    The data types returned by SQLGetTypeInfo are those supported by the data source. They are intended for use in Data Definition Language (DDL) statements. Drivers can return result-set data using data types other than the types returned by SQLGetTypeInfo. In creating the result set for a catalog function, the driver might use a data type that is not supported by the data source.

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# + { name => "type_name", + type => "varchar", + length => 20, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "data_type", + type => "smallint", + length => undef, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "column_size", + type => "integer", + length => undef, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "literal_prefix", + type => "varchar", + length => 1, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "literal_suffix", + type => "varchar", + length => 1, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "create_params", + type => "varchar", + length => 20, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "nullable", + type => "smallint", + length => undef, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "case_sensitive", + type => "smallint", + length => undef, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "searchable", + type => "smallint", + length => undef, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "unsigned_attribute", + type => "smallint", + length => undef, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "fixed_prec_scale", + type => "smallint", + length => undef, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "auto_unique_value", + type => "smallint", + length => undef, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "local_type_name", + type => "varchar", + length => 20, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "minimum_scale", + type => "smallint", + length => undef, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "maximum_scale", + type => "smallint", + length => undef, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "sql_data_type", + type => "smallint", + length => undef, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "sql_datetime_sub", + type => "smallint", + length => undef, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "num_prec_radix", + type => "integer", + length => undef, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "interval_precision", + type => "smallint", + length => undef, + nullable => 1, + }, +#

    +# Column name    		Column
    +# number
    +# Data type
    +# Comments
    TYPE_NAME
    +# (ODBC 2.0)    		1Varchar
    +# not NULL    		Data source–dependent data-type name; for example, "CHAR()", "VARCHAR()", "MONEY", "LONG VARBINARY", or "CHAR ( ) FOR BIT DATA". Applications must use this name in CREATE TABLE and ALTER TABLE statements.
    DATA_TYPE
    +# (ODBC 2.0)    		2Smallint
    +# not NULL    		SQL data type. This can be an ODBC SQL data type or a driver-specific SQL data type. For datetime or interval data types, this column returns the concise data type (such as SQL_TYPE_TIME or SQL_INTERVAL_YEAR_TO_MONTH). For a list of valid ODBC SQL data types, see "SQL Data Types" in Appendix D: Data Types. For information about driver-specific SQL data types, see the driver’s documentation.
    COLUMN_SIZE
    +# (ODBC 2.0)    		3IntegerThe maximum column size that the server supports for this data type. For numeric data, this is the maximum precision. For string data, this is the length in characters. For datetime data types, this is the length in characters of the string representation (assuming the maximum allowed precision of the fractional seconds component). NULL is returned for data types where column size is not applicable. For interval data types, this is the number of characters in the character representation of the interval literal (as defined by the interval leading precision; see "Interval Data Type Length" in Appendix D: Data Types). +#

    For more information on column size, see "Column Size, Decimal Digits, Transfer Octet Length, and Display Size" in Appendix D: Data Types.

    +#
    LITERAL_PREFIX
    +# (ODBC 2.0)    		4VarcharCharacter or characters used to prefix a literal; for example, a single quotation mark (') for character data types or 0x for binary data types; NULL is returned for data types where a literal prefix is not applicable.
    LITERAL_SUFFIX
    +# (ODBC 2.0)    		5VarcharCharacter or characters used to terminate a literal; for example, a single quotation mark (') for character data types; NULL is returned for data types where a literal suffix is not applicable.
    CREATE_PARAMS
    +# (ODBC 2.0)    		6VarcharA list of keywords, separated by commas, corresponding to each parameter that the application may specify in parentheses when using the name that is returned in the TYPE_NAME field. The keywords in the list can be any of the following: length, precision, or scale. They appear in the order that the syntax requires them to be used. For example, CREATE_PARAMS for DECIMAL would be "precision,scale"; CREATE_PARAMS for VARCHAR would equal "length." NULL is returned if there are no parameters for the data type definition; for example, INTEGER. +#

    The driver supplies the CREATE_PARAMS text in the language of the country where it is used.

    +#
    NULLABLE
    +# (ODBC 2.0)    		7Smallint
    +# not NULL    		Whether the data type accepts a NULL value: +#

    SQL_NO_NULLS if the data type does not accept NULL values.

    +# +#

    SQL_NULLABLE if the data type accepts NULL values.

    +# +#

    SQL_NULLABLE_UNKNOWN if it is not known whether the column accepts NULL values.

    +#
    CASE_SENSITIVE
    +# (ODBC 2.0)    		8Smallint
    +# not NULL    		Whether a character data type is case-sensitive in collations and comparisons: +#

    SQL_TRUE if the data type is a character data type and is case-sensitive.

    +# +#

    SQL_FALSE if the data type is not a character data type or is not case-sensitive.

    +#
    SEARCHABLE
    +# (ODBC 2.0)    		9Smallint
    +# not NULL    		How the data type is used in a WHERE clause: +#

    SQL_PRED_NONE if the column cannot be used in a WHERE clause. (This is the same as the SQL_UNSEARCHABLE value in ODBC 2.x.)

    +# +#

    SQL_PRED_CHAR if the column can be used in a WHERE clause, but only with the LIKE predicate. (This is the same as the SQL_LIKE_ONLY value in ODBC 2.x.)

    +# +#

    SQL_PRED_BASIC if the column can be used in a WHERE clause with all the comparison operators except LIKE (comparison, quantified comparison, BETWEEN, DISTINCT, IN, MATCH, and UNIQUE). (This is the same as the SQL_ALL_EXCEPT_LIKE value in ODBC 2.x.)

    +# +#

    SQL_SEARCHABLE if the column can be used in a WHERE clause with any comparison operator.

    +#
    UNSIGNED_ATTRIBUTE
    +# (ODBC 2.0)    		10SmallintWhether the data type is unsigned: +#

    SQL_TRUE if the data type is unsigned.

    +# +#

    SQL_FALSE if the data type is signed.

    +# +#

    NULL is returned if the attribute is not applicable to the data type or the data type is not numeric.

    +#
    FIXED_PREC_SCALE
    +# (ODBC 2.0)    		11Smallint
    +# not NULL    		Whether the data type has predefined fixed precision and scale (which are data source–specific), such as a money data type: +#

    SQL_TRUE if it has predefined fixed precision and scale.

    +# +#

    SQL_FALSE if it does not have predefined fixed precision and scale.

    +#
    AUTO_UNIQUE_VALUE
    +# (ODBC 2.0)    		12SmallintWhether the data type is autoincrementing: +#

    SQL_TRUE if the data type is autoincrementing.

    +# +#

    SQL_FALSE if the data type is not autoincrementing.

    +# +#

    NULL is returned if the attribute is not applicable to the data type or the data type is not numeric.

    +# +#

    An application can insert values into a column having this attribute, but typically cannot update the values in the column.

    +# +#

    When an insert is made into an auto-increment column, a unique value is inserted into the column at insert time. The increment is not defined, but is data source–specific. An application should not assume that an auto-increment column starts at any particular point or increments by any particular value.

    +#
    LOCAL_TYPE_NAME
    +# (ODBC 2.0)    		13VarcharLocalized version of the data source–dependent name of the data type. NULL is returned if a localized name is not supported by the data source. This name is intended for display only, such as in dialog boxes.
    MINIMUM_SCALE
    +# (ODBC 2.0)    		14SmallintThe minimum scale of the data type on the data source. If a data type has a fixed scale, the MINIMUM_SCALE and MAXIMUM_SCALE columns both contain this value. For example, an SQL_TYPE_TIMESTAMP column might have a fixed scale for fractional seconds. NULL is returned where scale is not applicable. For more information, see "Column Size, Decimal Digits, Transfer Octet Length, and Display Size" in Appendix D: Data Types.
    MAXIMUM_SCALE
    +# (ODBC 2.0)    		15SmallintThe maximum scale of the data type on the data source. NULL is returned where scale is not applicable. If the maximum scale is not defined separately on the data source, but is instead defined to be the same as the maximum precision, this column contains the same value as the COLUMN_SIZE column. For more information, see "Column Size, Decimal Digits, Transfer Octet Length, and Display Size" in Appendix D: Data Types.
    SQL_DATA_TYPE
    +# (ODBC 3.0)    		16Smallint NOT NULLThe value of the SQL data type as it appears in the SQL_DESC_TYPE field of the descriptor. This column is the same as the DATA_TYPE column, except for interval and datetime data types. +#

    For interval and datetime data types, the SQL_DATA_TYPE field in the result set will return SQL_INTERVAL or SQL_DATETIME, and the SQL_DATETIME_SUB field will return the subcode for the specific interval or datetime data type. (See Appendix D: Data Types.)

    +#
    SQL_DATETIME_SUB
    +# (ODBC 3.0)    		17SmallintWhen the value of SQL_DATA_TYPE is SQL_DATETIME or SQL_INTERVAL, this column contains the datetime/interval subcode. For data types other than datetime and interval, this field is NULL. +#

    For interval or datetime data types, the SQL_DATA_TYPE field in the result set will return SQL_INTERVAL or SQL_DATETIME, and the SQL_DATETIME_SUB field will return the subcode for the specific interval or datetime data type. (See Appendix D: Data Types.)

    +#
    NUM_PREC_RADIX
    +# (ODBC 3.0)    		18IntegerIf the data type is an approximate numeric type, this column contains the value 2 to indicate that COLUMN_SIZE specifies a number of bits. For exact numeric types, this column contains the value 10 to indicate that COLUMN_SIZE specifies a number of decimal digits. Otherwise, this column is NULL.
    INTERVAL_PRECISION
    +# (ODBC 3.0)    		19SmallintIf the data type is an interval data type, then this column contains the value of the interval leading precision. (See "Interval Data Type Precision" in Appendix D: Data Types.) Otherwise, this column is NULL.
    +# +#

    Attribute information can apply to data types or to specific columns in a result set. SQLGetTypeInfo returns information about attributes associated with data types; SQLColAttribute returns information about attributes associated with columns in a result set.

    +# +#

    Related Functions

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
    For information aboutSee
    Binding a buffer to a column in a result setSQLBindCol
    Canceling statement processingSQLCancel
    Returning information about a column in a result setSQLColAttribute
    Fetching a block of data or scrolling through a result setSQLFetchScroll
    Fetching a single row or a block of data in a forward-only directionSQLFetch
    Returning information about a driver or data sourceSQLGetInfo
    +#

    +# +#
    +# +# +# +]; + +# +# odbcsqltables.htm +# +$listWhat->{tables} = [ +# +# +# +# SQLTables +# +# +# +# +# +# +#
    +#
    +# +# +# +# +#
    +# ODBC Programmer's Reference +#
    +#
    +#
    +#
    +# +#

    SQLTables

    +# +#

    Conformance

    +# +#

    Version Introduced: ODBC 1.0
    +# Standards Compliance: X/Open

    +# +#

    Summary

    +# +#

    SQLTables returns the list of table, catalog, or schema names, and table types, stored in a specific data source. The driver returns the information as a result set.

    +# +#

    Syntax

    +# +# 
    SQLRETURN SQLTables(
+#	     SQLHSTMT     StatementHandle,
+#	     SQLCHAR *     CatalogName,
+#	     SQLSMALLINT     NameLength1,
+#	     SQLCHAR *     SchemaName,
+#	     SQLSMALLINT     NameLength2,
+#	     SQLCHAR *     TableName,
+#	     SQLSMALLINT     NameLength3,
+#	     SQLCHAR *     TableType,
+#	     SQLSMALLINT     NameLength4);
    +# +#

    Arguments +# +#

    +#
    StatementHandle
    +# +#
    [Input]
    +# Statement handle for retrieved results.
    +# +#
    CatalogName
    +# +#
    [Input]
    +# Catalog name. The CatalogName argument accepts search patterns if the SQL_ODBC_VERSION environment attribute is SQL_OV_ODBC3; it does not accept search patterns if SQL_OV_ODBC2 is set. If a driver supports catalogs for some tables but not for others, such as when a driver retrieves data from different DBMSs, an empty string ("") denotes those tables that do not have catalogs. +# +#

    If the SQL_ATTR_METADATA_ID statement attribute is set to SQL_TRUE, CatalogName is treated as an identifier and its case is not significant. If it is SQL_FALSE, CatalogName is a pattern value argument; it is treated literally, and its case is significant. For more information, see "Arguments in Catalog Functions" in Chapter 7: Catalog Functions. +#

    +# +#
    NameLength1
    +# +#
    [Input]
    +# Length of *CatalogName.
    +# +#
    SchemaName
    +# +#
    [Input]
    +# String search pattern for schema names. If a driver supports schemas for some tables but not for others, such as when the driver retrieves data from different DBMSs, an empty string ("") denotes those tables that do not have schemas. +# +#

    If the SQL_ATTR_METADATA_ID statement attribute is set to SQL_TRUE, SchemaName is treated as an identifier and its case is not significant. If it is SQL_FALSE, SchemaName is a pattern value argument; it is treated literally, and its case is significant. +#

    +# +#
    NameLength2
    +# +#
    [Input]
    +# Length of *SchemaName.
    +# +#
    TableName
    +# +#
    [Input]
    +# String search pattern for table names. +# +#

    If the SQL_ATTR_METADATA_ID statement attribute is set to SQL_TRUE, TableName is treated as an identifier and its case is not significant. If it is SQL_FALSE, TableName is a pattern value argument; it is treated literally, and its case is significant. +#

    +# +#
    NameLength3
    +# +#
    [Input]
    +# Length of *TableName.
    +# +#
    TableType
    +# +#
    [Input]
    +# List of table types to match. +# +#

    Note that the SQL_ATTR_METADATA_ID statement attribute has no effect upon the TableType argument. TableType is a value list argument, no matter what the setting of SQL_ATTR_METADATA_ID. +#

    +# +#
    NameLength4
    +# +#
    [Input]
    +# Length of *TableType.
    +#
    +# +#

    Returns

    +# +#

    SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_STILL_EXECUTING, SQL_ERROR, or SQL_INVALID_HANDLE.

    +# +#

    Diagnostics

    +# +#

    When SQLTables returns SQL_ERROR or SQL_SUCCESS_WITH_INFO, an associated SQLSTATE value may be obtained by calling SQLGetDiagRec with a HandleType of SQL_HANDLE_STMT and a Handle of StatementHandle. The following table lists the SQLSTATE values commonly returned by SQLTables and explains each one in the context of this function; the notation "(DM)" precedes the descriptions of SQLSTATEs returned by the Driver Manager. The return code associated with each SQLSTATE value is SQL_ERROR, unless noted otherwise.

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
    SQLSTATEErrorDescription
    01000General warningDriver-specific informational message. (Function returns SQL_SUCCESS_WITH_INFO.)
    08S01Communication link failureThe communication link between the driver and the data source to which the driver was connected failed before the function completed processing.
    24000Invalid cursor stateA cursor was open on the StatementHandle, and SQLFetch or SQLFetchScroll had been called. This error is returned by the Driver Manager if SQLFetch or SQLFetchScroll has not returned SQL_NO_DATA and is returned by the driver if SQLFetch or SQLFetchScroll has returned SQL_NO_DATA. +#

    A cursor was open on the StatementHandle, but SQLFetch or SQLFetchScroll had not been called.

    +#
    40001Serialization failureThe transaction was rolled back due to a resource deadlock with another transaction.
    40003Statement completion unknownThe associated connection failed during the execution of this function, and the state of the transaction cannot be determined.
    HY000General errorAn error occurred for which there was no specific SQLSTATE and for which no implementation-specific SQLSTATE was defined. The error message returned by SQLGetDiagRec in the *MessageText buffer describes the error and its cause.
    HY001Memory allocation
    +# error    		The driver was unable to allocate memory required to support execution or completion of the function.
    HY008Operation canceledAsynchronous processing was enabled for the StatementHandle. The function was called, and before it completed execution, SQLCancel was called on the StatementHandle. Then the function was called again on the StatementHandle. +#

    The function was called, and before it completed execution, SQLCancel was called on the StatementHandle from a different thread in a multithread application.

    +#
    HY009Invalid use of null pointerThe SQL_ATTR_METADATA_ID statement attribute was set to SQL_TRUE, the CatalogName argument was a null pointer, and the SQL_CATALOG_NAME InfoType returns that catalog names are supported. +#

    (DM) The SQL_ATTR_METADATA_ID statement attribute was set to SQL_TRUE, and the SchemaName or TableName argument was a null pointer.

    +#
    HY010Function sequence error(DM) An asynchronously executing function (not this one) was called for the StatementHandle and was still executing when this function was called. +#

    (DM) SQLExecute, SQLExecDirect, SQLBulkOperations, or SQLSetPos was called for the StatementHandle and returned SQL_NEED_DATA. This function was called before data was sent for all data-at-execution parameters or columns.

    +#
    HY013Memory management errorThe function call could not be processed because the underlying memory objects could not be accessed, possibly because of low memory conditions.
    HY090Invalid string or buffer length(DM) The value of one of the length arguments was less than 0 but not equal to SQL_NTS. +#

    The value of one of the name length arguments exceeded the maximum length value for the corresponding name.

    +#
    HYC00Optional feature not implementedA catalog was specified, and the driver or data source does not support catalogs. +#

    A schema was specified, and the driver or data source does not support schemas.

    +# +#

    A string search pattern was specified for the catalog name, table schema, or table name, and the data source does not support search patterns for one or more of those arguments.

    +# +#

    The combination of the current settings of the SQL_ATTR_CONCURRENCY and SQL_ATTR_CURSOR_TYPE statement attributes was not supported by the driver or data source.

    +# +#

    The SQL_ATTR_USE_BOOKMARKS statement attribute was set to SQL_UB_VARIABLE, and the SQL_ATTR_CURSOR_TYPE statement attribute was set to a cursor type for which the driver does not support bookmarks.

    +#
    HYT00Timeout expiredThe query timeout period expired before the data source returned the requested result set. The timeout period is set through SQLSetStmtAttr, SQL_ATTR_QUERY_TIMEOUT.
    HYT01Connection timeout expiredThe connection timeout period expired before the data source responded to the request. The connection timeout period is set through SQLSetConnectAttr, SQL_ATTR_CONNECTION_TIMEOUT.
    IM001Driver does not support this function(DM) The driver associated with the StatementHandle does not support the function.
    +# +#

    Comments

    +# +#

    SQLTables lists all tables in the requested range. A user may or may not have SELECT privileges to any of these tables. To check accessibility, an application can: +# +#

      +#
    • Call SQLGetInfo and check the SQL_ACCESSIBLE_TABLES information type.
      • +# +#
    • Call SQLTablePrivileges to check the privileges for each table.
      • +#
    +# +#

    Otherwise, the application must be able to handle a situation where the user selects a table for which SELECT privileges are not granted.

    +# +#

    The SchemaName and TableName arguments accept search patterns. The CatalogName argument accepts search patterns if the SQL_ODBC_VERSION environment attribute is SQL_OV_ODBC3; it does not accept search patterns if SQL_OV_ODBC2 is set. If SQL_OV_ODBC3 is set, an ODBC 3.x driver will require that wildcard characters in the CatalogName argument be escaped to be treated literally. For more information about valid search patterns, see "Pattern Value Arguments" in Chapter 7: Catalog Functions.

    +# +#

    Note   For more information about the general use, arguments, and returned data of ODBC catalog functions, see Chapter 7: Catalog Functions.

    +# +#

    To support enumeration of catalogs, schemas, and table types, the following special semantics are defined for the CatalogName, SchemaName, TableName, and TableType arguments of SQLTables: +# +#

      +#
    • If CatalogName is SQL_ALL_CATALOGS and SchemaName and TableName are empty strings, the result set contains a list of valid catalogs for the data source. (All columns except the TABLE_CAT column contain NULLs.)
      • +# +#
    • If SchemaName is SQL_ALL_SCHEMAS and CatalogName and TableName are empty strings, the result set contains a list of valid schemas for the data source. (All columns except the TABLE_SCHEM column contain NULLs.)
      • +# +#
    • If TableType is SQL_ALL_TABLE_TYPES and CatalogName, SchemaName, and TableName are empty strings, the result set contains a list of valid table types for the data source. (All columns except the TABLE_TYPE column contain NULLs.)
      • +#
    +# +#

    If TableType is not an empty string, it must contain a list of comma-separated values for the types of interest; each value may be enclosed in single quotation marks (') or unquoted—for example, 'TABLE', 'VIEW' or TABLE, VIEW. An application should always specify the table type in uppercase; the driver should convert the table type to whatever case is needed by the data source. If the data source does not support a specified table type, SQLTables does not return any results for that type.

    +# +#

    SQLTables returns the results as a standard result set, ordered by TABLE_TYPE, TABLE_CAT, TABLE_SCHEM, and TABLE_NAME. For information about how this information might be used, see "Uses of Catalog Data" in Chapter 7: Catalog Functions.

    +# +#

    To determine the actual lengths of the TABLE_CAT, TABLE_SCHEM, and TABLE_NAME columns, an application can call SQLGetInfo with the SQL_MAX_CATALOG_NAME_LEN, SQL_MAX_SCHEMA_NAME_LEN, and SQL_MAX_TABLE_NAME_LEN information types.

    +# +#

    The following columns have been renamed for ODBC 3.x. The column name changes do not affect backward compatibility because applications bind by column number.

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
    ODBC 2.0 columnODBC 3.x column
    TABLE_QUALIFIERTABLE_CAT
    TABLE_OWNERTABLE_SCHEM
    +# +#

    The following table lists the columns in the result set. Additional columns beyond column 5 (REMARKS) can be defined by the driver. An application should gain access to driver-specific columns by counting down from the end of the result set rather than specifying an explicit ordinal position. For more information, see "Data Returned by Catalog Functions" in Chapter 7: Catalog Functions.

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# + { name => "table_cat", + type => "varchar", + length => 16, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "table_schem", + type => "varchar", + length => 16, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "table_name", + type => "varchar", + length => 16, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "table_type", + type => "varchar", + length => 20, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "remarks", + type => "varchar", + length => 200, + nullable => 1, + }, +#

    +# Column name    		Column number
    +# Data type
    +# Comments
    TABLE_CAT
    +# (ODBC 1.0)    		1VarcharCatalog name; NULL if not applicable to the data source. If a driver supports catalogs for some tables but not for others, such as when the driver retrieves data from different DBMSs, it returns an empty string ("") for those tables that do not have catalogs.
    TABLE_SCHEM
    +# (ODBC 1.0)    		2VarcharSchema name; NULL if not applicable to the data source. If a driver supports schemas for some tables but not for others, such as when the driver retrieves data from different DBMSs, it returns an empty string ("") for those tables that do not have schemas.
    TABLE_NAME
    +# (ODBC 1.0)    		3VarcharTable name.
    TABLE_TYPE
    +# (ODBC 1.0)    		4VarcharTable type name; one of the following: "TABLE", "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL TEMPORARY", "ALIAS", "SYNONYM", or a data source–specific type name. +#

    The meanings of "ALIAS" and "SYNONYM" are driver-specific.

    +#
    REMARKS
    +# (ODBC 1.0)    		5VarcharA description of the table.
    +# +#

    Code Example

    +# +#

    For a code example of a similar function, see SQLColumns.

    +# +#

    Related Functions

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
    For information aboutSee
    Binding a buffer to a column in a result setSQLBindCol
    Canceling statement processingSQLCancel
    Returning privileges for a column or columnsSQLColumnPrivileges
    Returning the columns in a table or tablesSQLColumns
    Fetching a single row or a block of data in a forward-only directionSQLFetch
    Fetching a block of data or scrolling through a result setSQLFetchScroll
    Returning table statistics and indexesSQLStatistics
    Returning privileges for a table or tablesSQLTablePrivileges
    +#

    +# +#
    +# +# +# +]; + +# +# odbcsqlcolumns.htm +# +$listWhat->{columns} = [ +# +# +# +# SQLColumns +# +# +# +# +# +# +#
    +#
    +# +# +# +# +#
    +# ODBC Programmer's Reference +#
    +#
    +#
    +#
    +# +#

    SQLColumns

    +# +#

    Conformance

    +# +#

    Version Introduced: ODBC 1.0
    +# Standards Compliance: X/Open

    +# +#

    Summary

    +# +#

    SQLColumns returns the list of column names in specified tables. The driver returns this information as a result set on the specified StatementHandle.

    +# +#

    Syntax

    +# +# 
    SQLRETURN SQLColumns(
+#	     SQLHSTMT     StatementHandle,
+#	     SQLCHAR *     CatalogName,
+#	     SQLSMALLINT     NameLength1,
+#	     SQLCHAR *     SchemaName,
+#	     SQLSMALLINT     NameLength2,
+#	     SQLCHAR *     TableName,
+#	     SQLSMALLINT     NameLength3,
+#	     SQLCHAR *     ColumnName,
+#	     SQLSMALLINT     NameLength4);
    +# +#

    Arguments +# +#

    +#
    StatementHandle
    +# +#
    [Input]
    +# Statement handle.
    +# +#
    CatalogName
    +# +#
    [Input]
    +# Catalog name. If a driver supports catalogs for some tables but not for others, such as when the driver retrieves data from different DBMSs, an empty string ("") denotes those tables that do not have catalogs. CatalogName cannot contain a string search pattern.
    +#
    +# +#
    +# If the SQL_ATTR_METADATA_ID statement attribute is set to SQL_TRUE, CatalogName is treated as an identifier and its case is not significant. If it is SQL_FALSE, CatalogName is an ordinary argument; it is treated literally, and its case is significant. For more information, see "Arguments in Catalog Functions" in Chapter 7: Catalog Functions.
    +# +#
    +#
    NameLength1
    +# +#
    [Input]
    +# Length of *CatalogName.
    +# +#
    SchemaName
    +# +#
    [Input]
    +# String search pattern for schema names. If a driver supports schemas for some tables but not for others, such as when the driver retrieves data from different DBMSs, an empty string ("") denotes those tables that do not have schemas.
    +#
    +# +#
    +# If the SQL_ATTR_METADATA_ID statement attribute is set to SQL_TRUE, SchemaName is treated as an identifier and its case is not significant. If it is SQL_FALSE, SchemaName is a pattern value argument; it is treated literally, and its case is significant.
    +# +#
    +#
    NameLength2
    +# +#
    [Input]
    +# Length of *SchemaName.
    +# +#
    TableName
    +# +#
    [Input]
    +# String search pattern for table names.
    +#
    +# +#
    +# If the SQL_ATTR_METADATA_ID statement attribute is set to SQL_TRUE, TableName is treated as an identifier and its case is not significant. If it is SQL_FALSE, TableName is a pattern value argument; it is treated literally, and its case is significant.
    +# +#
    +#
    NameLength3
    +# +#
    [Input]
    +# Length of *TableName.
    +# +#
    ColumnName
    +# +#
    [Input]
    +# String search pattern for column names.
    +#
    +# +#
    +# If the SQL_ATTR_METADATA_ID statement attribute is set to SQL_TRUE, ColumnName is treated as an identifier and its case is not significant. If it is SQL_FALSE, ColumnName is a pattern value argument; it is treated literally, and its case is significant.
    +# +#
    +#
    NameLength4
    +# +#
    [Input]
    +# Length of *ColumnName.
    +#
    +# +#

    Returns

    +# +#

    SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_STILL_EXECUTING, SQL_ERROR, or SQL_INVALID_HANDLE.

    +# +#

    Diagnostics

    +# +#

    When SQLColumns returns SQL_ERROR or SQL_SUCCESS_WITH_INFO, an associated SQLSTATE value may be obtained by calling SQLGetDiagRec with a HandleType of SQL_HANDLE_STMT and a Handle of StatementHandle. The following table lists the SQLSTATE values commonly returned by SQLColumns and explains each one in the context of this function; the notation "(DM)" precedes the descriptions of SQLSTATEs returned by the Driver Manager. The return code associated with each SQLSTATE value is SQL_ERROR, unless noted otherwise.

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
    SQLSTATEErrorDescription
    01000General warningDriver-specific informational message. (Function returns SQL_SUCCESS_WITH_INFO.)
    08S01Communication link failureThe communication link between the driver and the data source to which the driver was connected failed before the function completed processing.
    24000Invalid cursor stateA cursor was open on the StatementHandle, and SQLFetch or SQLFetchScroll had been called. This error is returned by the Driver Manager if SQLFetch or SQLFetchScroll has not returned SQL_NO_DATA, and is returned by the driver if SQLFetch or SQLFetchScroll has returned SQL_NO_DATA. +#

    A cursor was open on the StatementHandle but SQLFetch or SQLFetchScroll had not been called.

    +#
    40001Serialization failureThe transaction was rolled back due to a resource deadlock with another transaction.
    40003Statement completion unknownThe associated connection failed during the execution of this function, and the state of the transaction cannot be determined.
    HY000General errorAn error occurred for which there was no specific SQLSTATE and for which no implementation-specific SQLSTATE was defined. The error message returned by SQLGetDiagRec in the *MessageText buffer describes the error and its cause.
    HY001Memory allocation errorThe driver was unable to allocate memory required to support execution or completion of the function.
    HY008Operation canceledAsynchronous processing was enabled for the StatementHandle. The function was called, and before it completed execution, SQLCancel was called on the StatementHandle. Then the function was called again on the StatementHandle. +#

    The function was called, and before it completed execution, SQLCancel was called on the StatementHandle from a different thread in a multithread application.

    +#
    HY009Invalid use of null pointerThe SQL_ATTR_METADATA_ID statement attribute was set to SQL_TRUE, the CatalogName argument was a null pointer, and the SQL_CATALOG_NAME InfoType returns that catalog names are supported. +#

    (DM) The SQL_ATTR_METADATA_ID statement attribute was set to SQL_TRUE, and the SchemaName, TableName, or ColumnName argument was a null pointer.

    +#
    HY010Function sequence error(DM) An asynchronously executing function (not this one) was called for the StatementHandle and was still executing when this function was called. +#

    (DM) SQLExecute, SQLExecDirect, SQLBulkOperations, or SQLSetPos was called for the StatementHandle and returned SQL_NEED_DATA. This function was called before data was sent for all data-at-execution parameters or columns.

    +#
    HY013Memory management errorThe function call could not be processed because the underlying memory objects could not be accessed, possibly because of low memory conditions.
    HY090Invalid string or buffer length(DM) The value of one of the name length arguments was less than 0 but not equal to SQL_NTS.
      The value of one of the name length arguments exceeded the maximum length value for the corresponding catalog or name. The maximum length of each catalog or name may be obtained by calling SQLGetInfo with the InfoType values. (See "Comments.")
    HYC00Optional feature not implementedA catalog name was specified, and the driver or data source does not support catalogs. +#

    A schema name was specified, and the driver or data source does not support schemas.

    +# +#

    A string search pattern was specified for the schema name, table name, or column name, and the data source does not support search patterns for one or more of those arguments.

    +# +#

    The combination of the current settings of the SQL_ATTR_CONCURRENCY and SQL_ATTR_CURSOR_TYPE statement attributes was not supported by the driver or data source.

    +# +#

    The SQL_ATTR_USE_BOOKMARKS statement attribute was set to SQL_UB_VARIABLE, and the SQL_ATTR_CURSOR_TYPE statement attribute was set to a cursor type for which the driver does not support bookmarks.

    +#
    HYT00Timeout expiredThe query timeout period expired before the data source returned the result set. The timeout period is set through SQLSetStmtAttr, SQL_ATTR_QUERY_TIMEOUT.
    HYT01Connection timeout expiredThe connection timeout period expired before the data source responded to the request. The connection timeout period is set through SQLSetConnectAttr, SQL_ATTR_CONNECTION_TIMEOUT.
    IM001Driver does not support this function(DM) The driver associated with the StatementHandle does not support the function.
    +# +#

    Comments

    +# +#

    This function typically is used before statement execution to retrieve information about columns for a table or tables from the data source's catalog. SQLColumns can be used to retrieve data for all types of items returned by SQLTables. In addition to base tables, this may include (but is not limited to) views, synonyms, system tables, and so on. By contrast, the functions SQLColAttribute and SQLDescribeCol describe the columns in a result set and the function SQLNumResultCols returns the number of columns in a result set. For more information, see "Uses of Catalog Data" in Chapter 7: Catalog Functions.

    +# +#

    Note   For more information about the general use, arguments, and returned data of ODBC catalog functions, see Chapter 7: Catalog Functions.

    +# +#

    SQLColumns returns the results as a standard result set, ordered by TABLE_CAT, TABLE_SCHEM, TABLE_NAME, and ORDINAL_POSITION.

    +# +#

    Note   When an application works with an ODBC 2.x driver, no ORDINAL_POSITION column is returned in the result set. As a result, when working with ODBC 2.x drivers, the order of the columns in the column list returned by SQLColumns is not necessarily the same as the order of the columns returned when the application performs a SELECT statement on all columns in that table.

    +# +#

    Note   SQLColumns might not return all columns. For example, a driver might not return information about pseudo-columns, such as Oracle ROWID. Applications can use any valid column, whether or not it is returned by SQLColumns.

    +# +#

    Some columns that can be returned by SQLStatistics are not returned by SQLColumns. For example, SQLColumns does not return the columns in an index created over an expression or filter, such as SALARY + BENEFITS or DEPT = 0012.

    +# +#

    The lengths of VARCHAR columns are not shown in the table; the actual lengths depend on the data source. To determine the actual lengths of the TABLE_CAT, TABLE_SCHEM, TABLE_NAME, and COLUMN_NAME columns, an application can call SQLGetInfo with the SQL_MAX_CATALOG_NAME_LEN, SQL_MAX_SCHEMA_NAME_LEN, SQL_MAX_TABLE_NAME_LEN, and SQL_MAX_COLUMN_NAME_LEN options.

    +# +#

    The following columns have been renamed for ODBC 3.x. The column name changes do not affect backward compatibility because applications bind by column number.

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
    ODBC 2.0 columnODBC 3.x column
    TABLE_QUALIFIERTABLE_CAT
    TABLE_OWNERTABLE_SCHEM
    PRECISIONCOLUMN_SIZE
    LENGTHBUFFER_LENGTH
    SCALEDECIMAL_DIGITS
    RADIXNUM_PREC_RADIX
    +# +#

    The following columns have been added to the result set returned by SQLColumns for ODBC 3.x:

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
       CHAR_OCTET_LENGTH ORDINAL_POSITION
       COLUMN_DEFSQL_DATA_TYPE
       IS_NULLABLE SQL_DATETIME_SUB
    +# +#

    The following table lists the columns in the result set. Additional columns beyond column 18 (IS_NULLABLE) can be defined by the driver. An application should gain access to driver-specific columns by counting down from the end of the result set rather than specifying an explicit ordinal position. For more information, see "Data Returned by Catalog Functions" in Chapter 7: Catalog Functions.

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# + { name => "table_cat", + type => "varchar", + length => 16, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "table_schem", + type => "varchar", + length => 16, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "table_name", + type => "varchar", + length => 16, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "column_name", + type => "varchar", + length => 16, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "data_type", + type => "smallint", + length => undef, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "type_name", + type => "varchar", + length => 20, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "column_size", + type => "integer", + length => undef, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "buffer_length", + type => "integer", + length => 16, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "decimal_digits", + type => "smallint", + length => undef, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "num_prec_radix", + type => "smallint", + length => undef, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "nullable", + type => "smallint", + length => 16, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "remarks", + type => "varchar", + length => 200, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "column_def", + type => "varchar", + length => 100, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "sql_data_type", + type => "smallint", + length => undef, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "sql_datetime_sub", + type => "smallint", + length => undef, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "char_octet_length", + type => "integer", + length => undef, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "ordinal_position", + type => "integer", + length => undef, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "is_nullable", + type => "varchar", + length => 3, + nullable => 1, + }, +#

    +# Column name    		Column
    +# number
    +# Data type
    +# Comments
    TABLE_CAT
    +# (ODBC 1.0)    		1VarcharCatalog name; NULL if not applicable to the data source. If a driver supports catalogs for some tables but not for others, such as when the driver retrieves data from different DBMSs, it returns an empty string ("") for those tables that do not have catalogs.
    TABLE_SCHEM
    +# (ODBC 1.0)    		2Varchar Schema name; NULL if not applicable to the data source. If a driver supports schemas for some tables but not for others, such as when the driver retrieves data from different DBMSs, it returns an empty string ("") for those tables that do not have schemas.
    TABLE_NAME
    +# (ODBC 1.0)    		3Varchar not NULLTable name.
    COLUMN_NAME
    +# (ODBC 1.0)    		4Varchar not NULLColumn name. The driver returns an empty string for a column that does not have a name.
    DATA_TYPE
    +# (ODBC 1.0)    		5Smallint not NULLSQL data type. This can be an ODBC SQL data type or a driver-specific SQL data type. For datetime and interval data types, this column returns the concise data type (such as SQL_TYPE_DATE or SQL_INTERVAL_YEAR_TO_MONTH, rather than the nonconcise data type such as SQL_DATETIME or SQL_INTERVAL). For a list of valid ODBC SQL data types, see "SQL Data Types" in Appendix D: Data Types. For information about driver-specific SQL data types, see the driver's documentation. +#

    The data types returned for ODBC 3.x and ODBC 2.x applications may be different. For more information, see "Backward Compatibility and Standards Compliance" in Chapter 17: Programming Considerations.

    +#
    TYPE_NAME
    +# (ODBC 1.0)    		6Varchar not NULLData source–dependent data type name; for example, "CHAR", "VARCHAR", "MONEY", "LONG VARBINAR", or "CHAR ( ) FOR BIT DATA".
    COLUMN_SIZE
    +# (ODBC 1.0)     		7IntegerIf DATA_TYPE is SQL_CHAR or SQL_VARCHAR, this column contains the maximum length in characters of the column. For datetime data types, this is the total number of characters required to display the value when converted to characters. For numeric data types, this is either the total number of digits or the total number of bits allowed in the column, according to the NUM_PREC_RADIX column. For interval data types, this is the number of characters in the character representation of the interval literal (as defined by the interval leading precision, see "Interval Data Type Length" in Appendix D: Data Types). For more information, see "Column Size, Decimal Digits, Transfer Octet Length, and Display Size" in Appendix D: Data Types.
    BUFFER_LENGTH
    +# (ODBC 1.0)    		8IntegerThe length in bytes of data transferred on an SQLGetData, SQLFetch, or SQLFetchScroll operation if SQL_C_DEFAULT is specified. For numeric data, this size may be different than the size of the data stored on the data source. This value might be different than COLUMN_SIZE column for character data. For more information about length, see "Column Size, Decimal Digits, Transfer Octet Length, and Display Size" in Appendix D: Data Types.
    DECIMAL_DIGITS
    +# (ODBC 1.0)    		9SmallintThe total number of significant digits to the right of the decimal point. For SQL_TYPE_TIME and SQL_TYPE_TIMESTAMP, this column contains the number of digits in the fractional seconds component. For the other data types, this is the decimal digits of the column on the data source. For interval data types that contain a time component, this column contains the number of digits to the right of the decimal point (fractional seconds). For interval data types that do not contain a time component, this column is 0. For more information about decimal digits, see "Column Size, Decimal Digits, Transfer Octet Length, and Display Size" in Appendix D: Data Types. NULL is returned for data types where DECIMAL_DIGITS is not applicable.
    NUM_PREC_RADIX
    +# (ODBC 1.0)    		10SmallintFor numeric data types, either 10 or 2. If it is 10, the values in COLUMN_SIZE and DECIMAL_DIGITS give the number of decimal digits allowed for the column. For example, a DECIMAL(12,5) column would return a NUM_PREC_RADIX of 10, a COLUMN_SIZE of 12, and a DECIMAL_DIGITS of 5; a FLOAT column could return a NUM_PREC_RADIX of 10, a COLUMN_SIZE of 15, and a DECIMAL_DIGITS of NULL. +#

    If it is 2, the values in COLUMN_SIZE and DECIMAL_DIGITS give the number of bits allowed in the column. For example, a FLOAT column could return a RADIX of 2, a COLUMN_SIZE of 53, and a DECIMAL_DIGITS of NULL.

    +# +#

    NULL is returned for data types where NUM_PREC_RADIX is not applicable.

    +#
    NULLABLE
    +# (ODBC 1.0)    		11Smallint not NULLSQL_NO_NULLS if the column could not include NULL values. +#

    SQL_NULLABLE if the column accepts NULL values.

    +# +#

    SQL_NULLABLE_UNKNOWN if it is not known whether the column accepts NULL values.

    +# +#

    The value returned for this column is different from the value returned for the IS_NULLABLE column. The NULLABLE column indicates with certainty that a column can accept NULLs, but cannot indicate with certainty that a column does not accept NULLs. The IS_NULLABLE column indicates with certainty that a column cannot accept NULLs, but cannot indicate with certainty that a column accepts NULLs.

    +#
    REMARKS
    +# (ODBC 1.0)    		12VarcharA description of the column.
    COLUMN_DEF
    +# (ODBC 3.0)    		13VarcharThe default value of the column. The value in this column should be interpreted as a string if it is enclosed in quotation marks. +#

    If NULL was specified as the default value, then this column is the word NULL, not enclosed in quotation marks. If the default value cannot be represented without truncation, then this column contains TRUNCATED, with no enclosing single quotation marks. If no default value was specified, then this column is NULL.

    +# +#

    The value of COLUMN_DEF can be used in generating a new column definition, except when it contains the value TRUNCATED.

    +#
    SQL_DATA_TYPE
    +# (ODBC 3.0)    		14Smallint not NULLSQL data type, as it appears in the SQL_DESC_TYPE record field in the IRD. This can be an ODBC SQL data type or a driver-specific SQL data type. This column is the same as the DATA_TYPE column, with the exception of datetime and interval data types. This column returns the nonconcise data type (such as SQL_DATETIME or SQL_INTERVAL), rather than the concise data type (such as SQL_TYPE_DATE or SQL_INTERVAL_YEAR_TO_MONTH) for datetime and interval data types. If this column returns SQL_DATETIME or SQL_INTERVAL, the specific data type can be determined from the SQL_DATETIME_SUB column. For a list of valid ODBC SQL data types, see "SQL Data Types" in Appendix D: Data Types. For information about driver-specific SQL data types, see the driver's documentation. +#

    The data types returned for ODBC 3.x and ODBC 2.x applications may be different. For more information, see "Backward Compatibility and Standards Compliance" in Chapter 17: Programming Considerations.

    +#
    SQL_DATETIME_SUB
    +# (ODBC 3.0)    		15SmallintThe subtype code for datetime and interval data types. For other data types, this column returns a NULL. For more information about datetime and interval subcodes, see "SQL_DESC_DATETIME_INTERVAL_CODE" in SQLSetDescField.
    CHAR_OCTET_LENGTH
    +# (ODBC 3.0)    		16IntegerThe maximum length in bytes of a character or binary data type column. For all other data types, this column returns a NULL.
    ORDINAL_POSITION
    +# (ODBC 3.0)    		17Integer not NULLThe ordinal position of the column in the table. The first column in the table is number 1.
    IS_NULLABLE
    +# (ODBC 3.0)    		18Varchar"NO" if the column does not include NULLs. +#

    "YES" if the column could include NULLs.

    +# +#

    This column returns a zero-length string if nullability is unknown.

    +# +#

    ISO rules are followed to determine nullability. An ISO SQL–compliant DBMS cannot return an empty string.

    +# +#

    The value returned for this column is different from the value returned for the NULLABLE column. (See the description of the NULLABLE column.)

    +#
    +# +#

    Code Example

    +# +#

    In the following example, an application declares buffers for the result set returned by SQLColumns. It calls SQLColumns to return a result set that describes each column in the EMPLOYEE table. It then calls SQLBindCol to bind the columns in the result set to the buffers. Finally, the application fetches each row of data with SQLFetch and processes it.

    +# +# 
    #define STR_LEN 128+1
+#	#define REM_LEN 254+1
+#	
+#	/* Declare buffers for result set data */
+#	
+#	SQLCHAR       szCatalog[STR_LEN], szSchema[STR_LEN];
+#	SQLCHAR       szTableName[STR_LEN], szColumnName[STR_LEN];
+#	SQLCHAR       szTypeName[STR_LEN], szRemarks[REM_LEN];
+#	SQLCHAR       szColumnDefault[STR_LEN], szIsNullable[STR_LEN];
+#	SQLINTEGER    ColumnSize, BufferLength, CharOctetLength, OrdinalPosition;
+#	SQLSMALLINT   DataType, DecimalDigits, NumPrecRadix, Nullable;
+#	SQLSMALLINT   SQLDataType, DatetimeSubtypeCode;
+#	SQLRETURN     retcode;
+#	SQLHSTMT      hstmt;
+#	
+#	/* Declare buffers for bytes available to return */
+#	
+#	SQLINTEGER cbCatalog, cbSchema, cbTableName, cbColumnName;
+#	SQLINTEGER cbDataType, cbTypeName, cbColumnSize, cbBufferLength;
+#	SQLINTEGER cbDecimalDigits, cbNumPrecRadix, cbNullable, cbRemarks;
+#	SQLINTEGER cbColumnDefault, cbSQLDataType, cbDatetimeSubtypeCode, cbCharOctetLength;
+#	SQLINTEGER cbOrdinalPosition, cbIsNullable;
+#	
+#	retcode = SQLColumns(hstmt,
+#	         NULL, 0,                /* All catalogs */
+#	         NULL, 0,                /* All schemas */
+#	         "CUSTOMERS", SQL_NTS,   /* CUSTOMERS table */
+#	         NULL, 0);               /* All columns */
+#	
+#	if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {
+#	
+#	   /* Bind columns in result set to buffers */
+#	
+#	   SQLBindCol(hstmt, 1, SQL_C_CHAR, szCatalog, STR_LEN,&cbCatalog);
+#	   SQLBindCol(hstmt, 2, SQL_C_CHAR, szSchema, STR_LEN, &cbSchema);
+#	   SQLBindCol(hstmt, 3, SQL_C_CHAR, szTableName, STR_LEN,&cbTableName);
+#	   SQLBindCol(hstmt, 4, SQL_C_CHAR, szColumnName, STR_LEN, &cbColumnName);
+#	   SQLBindCol(hstmt, 5, SQL_C_SSHORT, &DataType, 0, &cbDataType);
+#	   SQLBindCol(hstmt, 6, SQL_C_CHAR, szTypeName, STR_LEN, &cbTypeName);
+#	   SQLBindCol(hstmt, 7, SQL_C_SLONG, &ColumnSize, 0, &cbColumnSize);
+#	   SQLBindCol(hstmt, 8, SQL_C_SLONG, &BufferLength, 0, &cbBufferLength);
+#	   SQLBindCol(hstmt, 9, SQL_C_SSHORT, &DecimalDigits, 0, &cbDecimalDigits);
+#	   SQLBindCol(hstmt, 10, SQL_C_SSHORT, &NumPrecRadix, 0, &cbNumPrecRadix);
+#	   SQLBindCol(hstmt, 11, SQL_C_SSHORT, &Nullable, 0, &cbNullable);
+#	   SQLBindCol(hstmt, 12, SQL_C_CHAR, szRemarks, REM_LEN, &cbRemarks);
+#	   SQLBindCol(hstmt, 13, SQL_C_CHAR, szColumnDefault, STR_LEN, &cbColumnDefault);
+#	SQLBindCol(hstmt, 14, SQL_C_SSHORT, &SQLDataType, 0, &cbSQLDataType);
+#	   SQLBindCol(hstmt, 15, SQL_C_SSHORT, &DatetimeSubtypeCode, 0,
+#	      &cbDatetimeSubtypeCode);
+#	   SQLBindCol(hstmt, 16, SQL_C_SLONG, &CharOctetLength, 0, &cbCharOctetLength);
+#	   SQLBindCol(hstmt, 17, SQL_C_SLONG, &OrdinalPosition, 0, &cbOrdinalPosition);
+#	   SQLBindCol(hstmt, 18, SQL_C_CHAR, szIsNullable, STR_LEN, &cbIsNullable);
+#	   while(TRUE) {
+#	      retcode = SQLFetch(hstmt);
+#	      if (retcode == SQL_ERROR || retcode == SQL_SUCCESS_WITH_INFO) {
+#	         show_error( );
+#	      }
+#	      if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO){
+#	            ;   /* Process fetched data */
+#	      } else {
+#	         break;
+#	      }
+#	   }
+#	}
    +# +#

    Related Functions

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
    For information aboutSee
    Binding a buffer to a column in a result setSQLBindCol
    Canceling statement processingSQLCancel
    Returning privileges for a column or columnsSQLColumnPrivileges
    Fetching a block of data or scrolling through a result setSQLFetchScroll
    Fetching multiple rows of dataSQLFetch
    Returning columns that uniquely identify a row, or columns automatically updated by a transactionSQLSpecialColumns
    Returning table statistics and indexesSQLStatistics
    Returning a list of tables in a data sourceSQLTables
    Returning privileges for a table or tablesSQLTablePrivileges
    +#

    +# +#
    +# +# +# +]; + +# +# odbcsqlprimarykeys.htm +# +$listWhat->{primarykeys} = [ +# +# +# +# SQLPrimaryKeys +# +# +# +# +# +# +#
    +#
    +# +# +# +# +#
    +# ODBC Programmer's Reference +#
    +#
    +#
    +#
    +# +#

    SQLPrimaryKeys

    +# +#

    Conformance

    +# +#

    Version Introduced: ODBC 1.0
    +# Standards Compliance: ODBC

    +# +#

    Summary

    +# +#

    SQLPrimaryKeys returns the column names that make up the primary key for a table. The driver returns the information as a result set. This function does not support returning primary keys from multiple tables in a single call.

    +# +#

    Syntax

    +# +# 
    SQLRETURN SQLPrimaryKeys(
+#	     SQLHSTMT     StatementHandle,
+#	     SQLCHAR *     CatalogName,
+#	     SQLSMALLINT     NameLength1,
+#	     SQLCHAR *     SchemaName,
+#	     SQLSMALLINT     NameLength2,
+#	     SQLCHAR *     TableName,
+#	     SQLSMALLINT     NameLength3);
    +# +#

    Arguments +# +#

    +#
    StatementHandle
    +# +#
    [Input]
    +# Statement handle.
    +# +#
    CatalogName
    +# +#
    [Input]
    +# Catalog name. If a driver supports catalogs for some tables but not for others, such as when the driver retrieves data from different DBMSs, an empty string ("") denotes those tables that do not have catalogs. CatalogName cannot contain a string search pattern. +# +#

    If the SQL_ATTR_METADATA_ID statement attribute is set to SQL_TRUE, CatalogName is treated as an identifier and its case is not significant. If it is SQL_FALSE, CatalogName is an ordinary argument; it is treated literally, and its case is significant. For more information, see "Arguments in Catalog Functions" in Chapter 7: Catalog Functions. +#

    +# +#
    NameLength1
    +# +#
    [Input]
    +# Length in bytes of *CatalogName.
    +# +#
    SchemaName
    +# +#
    [Input]
    +# Schema name. If a driver supports schemas for some tables but not for others, such as when the driver retrieves data from different DBMSs, an empty string ("") denotes those tables that do not have schemas. SchemaName cannot contain a string search pattern. +# +#

    If the SQL_ATTR_METADATA_ID statement attribute is set to SQL_TRUE, SchemaName is treated as an identifier and its case is not significant. If it is SQL_FALSE, SchemaName is an ordinary argument; it is treated literally, and its case is not significant. +#

    +# +#
    NameLength2
    +# +#
    [Input]
    +# Length in bytes of *SchemaName.
    +# +#
    TableName
    +# +#
    [Input]
    +# Table name. This argument cannot be a null pointer. TableName cannot contain a string search pattern. +# +#

    If the SQL_ATTR_METADATA_ID statement attribute is set to SQL_TRUE, TableName is treated as an identifier and its case is not significant. If it is SQL_FALSE, TableName is an ordinary argument; it is treated literally, and its case is not significant. +#

    +# +#
    NameLength3
    +# +#
    [Input]
    +# Length in bytes of *TableName.
    +#
    +# +#

    Returns

    +# +#

    SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_STILL_EXECUTING, SQL_ERROR, or SQL_INVALID_HANDLE.

    +# +#

    Diagnostics

    +# +#

    When SQLPrimaryKeys returns SQL_ERROR or SQL_SUCCESS_WITH_INFO, an associated SQLSTATE value can be obtained by calling SQLGetDiagRec with a HandleType of SQL_HANDLE_STMT and a Handle of StatementHandle. The following table lists the SQLSTATE values commonly returned by SQLPrimaryKeys and explains each one in the context of this function; the notation "(DM)" precedes the descriptions of SQLSTATEs returned by the Driver Manager. The return code associated with each SQLSTATE value is SQL_ERROR, unless noted otherwise.

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
    SQLSTATEErrorDescription
    01000General warningDriver-specific informational message. (Function returns SQL_SUCCESS_WITH_INFO.)
    08S01Communication link failureThe communication link between the driver and the data source to which the driver was connected failed before the function completed processing.
    24000Invalid cursor state(DM) A cursor was open on the StatementHandle, and SQLFetch or SQLFetchScroll had been called. +#

    A cursor was open on the StatementHandle, but SQLFetch or SQLFetchScroll had not been called.

    +#
    40001Serialization failureThe transaction was rolled back due to a resource deadlock with another transaction.
    40003Statement completion unknownThe associated connection failed during the execution of this function, and the state of the transaction cannot be determined.
    HY000General errorAn error occurred for which there was no specific SQLSTATE and for which no implementation-specific SQLSTATE was defined. The error message returned by SQLGetDiagRec in the *MessageText buffer describes the error and its cause.
    HY001Memory allocation errorThe driver was unable to allocate memory required to support execution or completion of the function.
    HY008Operation canceledAsynchronous processing was enabled for the StatementHandle. The function was called, and before it completed execution, SQLCancel was called on the StatementHandle. Then the function was called again on the StatementHandle. +#

    The function was called, and before it completed execution, SQLCancel was called on the StatementHandle from a different thread in a multithread application.

    +#
    HY009Invalid use of null pointer(DM) The TableName argument was a null pointer. +#

    The SQL_ATTR_METADATA_ID statement attribute was set to SQL_TRUE, the CatalogName argument was a null pointer, and SQLGetInfo with the SQL_CATALOG_NAME information type returns that catalog names are supported.

    +# +#

    (DM) The SQL_ATTR_METADATA_ID statement attribute was set to SQL_TRUE, and the SchemaName argument was a null pointer.

    +#
    HY010Function sequence error(DM) An asynchronously executing function (not this one) was called for the StatementHandle and was still executing when this function was called. +#

    (DM) SQLExecute, SQLExecDirect, SQLBulkOperations, or SQLSetPos was called for the StatementHandle and returned SQL_NEED_DATA. This function was called before data was sent for all data-at-execution parameters or columns.

    +#
    HY013Memory management errorThe function call could not be processed because the underlying memory objects could not be accessed, possibly because of low memory conditions.
    HY090Invalid string or buffer length(DM) The value of one of the name length arguments was less than 0 but not equal to SQL_NTS, and the associated name argument is not a null pointer. +#

    The value of one of the name length arguments exceeded the maximum length value for the corresponding name.

    +#
    HYC00Optional feature not implementedA catalog was specified, and the driver or data source does not support catalogs. +#

    A schema was specified and the driver or data source does not support schemas.

    +# +#

    The combination of the current settings of the SQL_ATTR_CONCURRENCY and SQL_ATTR_CURSOR_TYPE statement attributes was not supported by the driver or data source.

    +# +#

    The SQL_ATTR_USE_BOOKMARKS statement attribute was set to SQL_UB_VARIABLE, and the SQL_ATTR_CURSOR_TYPE statement attribute was set to a cursor type for which the driver does not support bookmarks.

    +#
    HYT00Timeout expiredThe timeout period expired before the data source returned the requested result set. The timeout period is set through SQLSetStmtAttr, SQL_ATTR_QUERY_TIMEOUT.
    HYT01Connection timeout expiredThe connection timeout period expired before the data source responded to the request. The connection timeout period is set through SQLSetConnectAttr, SQL_ATTR_CONNECTION_TIMEOUT.
    IM001Driver does not support this function(DM) The driver associated with the StatementHandle does not support the function.
    +# +#

    Comments

    +# +#

    SQLPrimaryKeys returns the results as a standard result set, ordered by TABLE_CAT, TABLE_SCHEM, TABLE_NAME, and KEY_SEQ. For information about how this information might be used, see "Uses of Catalog Data" in Chapter 7: Catalog Functions.

    +# +#

    The following columns have been renamed for ODBC 3.x. The column name changes do not affect backward compatibility because applications bind by column number.

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
    ODBC 2.0 columnODBC 3.x column
    TABLE_QUALIFIERTABLE_CAT
    TABLE_OWNERTABLE_SCHEM
    +# +#

    To determine the actual lengths of the TABLE_CAT, TABLE_SCHEM, TABLE_NAME, and COLUMN_NAME columns, call SQLGetInfo with the SQL_MAX_CATALOG_NAME_LEN, SQL_MAX_SCHEMA_NAME_LEN, SQL_MAX_TABLE_NAME_LEN, and SQL_MAX_COLUMN_NAME_LEN options.

    +# +#

    Note   For more information about the general use, arguments, and returned data of ODBC catalog functions, see Chapter 7: Catalog Functions.

    +# +#

    The following table lists the columns in the result set. Additional columns beyond column 6 (PK_NAME) can be defined by the driver. An application should gain access to driver-specific columns by counting down from the end of the result set rather than specifying an explicit ordinal position. For more information, see "Data Returned by Catalog Functions" in Chapter 7: Catalog Functions.

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# + { name => "table_cat", + type => "varchar", + length => 16, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "table_schem", + type => "varchar", + length => 16, + nullable => 1, + }, +# +# +# +# +# +# +# + { name => "table_name", + type => "varchar", + length => 16, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "column_name", + type => "varchar", + length => 16, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "key_seq", + type => "smallint", + length => undef, + nullable => 0, + }, +# +# +# +# +# +# +# + { name => "pk_name", + type => "varchar", + length => 16, + nullable => 1, + }, +#

    +# Column name    		Column number
    +# Data type
    +# Comments
    TABLE_CAT
    +# (ODBC 1.0)    		1VarcharPrimary key table catalog name; NULL if not applicable to the data source. If a driver supports catalogs for some tables but not for others, such as when the driver retrieves data from different DBMSs, it returns an empty string ("") for those tables that do not have catalogs.
    TABLE_SCHEM
    +# (ODBC 1.0)    		2VarcharPrimary key table schema name; NULL if not applicable to the data source. If a driver supports schemas for some tables but not for others, such as when the driver retrieves data from different DBMSs, it returns an empty string ("") for those tables that do not have schemas.
    TABLE_NAME
    +# (ODBC 1.0)    		3Varchar
    +# not NULL    		Primary key table name.
    COLUMN_NAME
    +# (ODBC 1.0)    		4Varchar
    +# not NULL    		Primary key column name. The driver returns an empty string for a column that does not have a name.
    KEY_SEQ
    +# (ODBC 1.0)    		5Smallint
    +# not NULL    		Column sequence number in key (starting with 1).
    PK_NAME
    +# (ODBC 2.0)    		6VarcharPrimary key name. NULL if not applicable to the data source.
    +# +#

    Code Example

    +# +#

    See SQLForeignKeys.

    +# +#

    Related Functions

    +#
    +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +#
    For information aboutSee
    Binding a buffer to a column in a result setSQLBindCol
    Canceling statement processingSQLCancel
    Fetching a block of data or scrolling through a result setSQLFetchScroll
    Fetching a single row or a block of data in a forward-only directionSQLFetch
    Returning the columns of foreign keysSQLForeignKeys
    Returning table statistics and indexesSQLStatistics
    +#

    +# +#
    +# +# +# +]; + +my $list = $listWhat->{$what} or die "$what?"; +my $i4 = " " x 4; +if ($opt eq '-l') { + print join(", ", map($_->{name}, @$list)), "\n"; + exit; +} +if ($opt eq '-c') { + my $pos = 0; + for my $p (@$list) { + print "${i4}ConnSys::Column::Column(\n"; + $pos++; + print "\t$pos,\n"; + print "\t\"" . uc($p->{name}) . "\",\n"; + print "\tfalse,\n"; + print "\tNdbType(NdbType::"; + if ($p->{type} eq 'varchar') { + print "String, 8, $p->{length}"; + } else { + print "Signed, 32, 1"; + } + print ", " . ($p->{nullable} ? "true" : "false"); + print ")\n"; + print "${i4}),\n"; + } + exit; +} +print "$opt?\n"; + +# vim: set sw=4: diff --git a/ndb/src/client/odbc/docs/type.txt b/ndb/src/client/odbc/docs/type.txt new file mode 100644 index 00000000000..d7b391afc55 --- /dev/null +++ b/ndb/src/client/odbc/docs/type.txt @@ -0,0 +1,333 @@ +ODBC Programmer's Reference +****** SQL Data Types ****** +Each DBMS defines its own SQL types. Each ODBC driver exposes only those SQL +data types that the associated DBMS defines. How a driver maps DBMS SQL types +to the ODBC-defined SQL type identifiers and how a driver maps DBMS SQL types +to its own driver-specific SQL type identifiers are returned through a call to +SQLGetTypeInfo. A driver also returns the SQL data types when describing the +data types of columns and parameters through calls to SQLColAttribute, +SQLColumns, SQLDescribeCol, SQLDescribeParam, SQLProcedureColumns, and +SQLSpecialColumns. +Note The SQL data types are contained in the SQL_DESC_ CONCISE_TYPE, +SQL_DESC_TYPE, and SQL_DESC_DATETIME_INTERVAL_CODE fields of the implementation +descriptors. Characteristics of the SQL data types are contained in the +SQL_DESC_PRECISION, SQL_DESC_SCALE, SQL_DESC_LENGTH, and SQL_DESC_OCTET_LENGTH +fields of the implementation descriptors. For more information, see "Data_Type +Identifiers_and_Descriptors" later in this appendix. +A given driver and data source do not necessarily support all of the SQL data +types defined in this appendix. A driver's support for SQL data types depends +on the level of SQL-92 that the driver conforms to. To determine the level of +SQL-92 grammar supported by the driver, an application calls SQLGetInfo with +the SQL_SQL_CONFORMANCE information type. Furthermore, a given driver and data +source may support additional, driver-specific SQL data types. To determine +which data types a driver supports, an application calls SQLGetTypeInfo. For +information about driver-specific SQL data types, see the driver's +documentation. For information about the data types in a specific data source, +see the documentation for that data source. +Important The tables throughout this appendix are only guidelines and show +commonly used names, ranges, and limits of SQL data types. A given data source +might support only some of the listed data types, and the characteristics of +the supported data types can differ from those listed. +The following table lists valid SQL type identifiers for all SQL data types. +The table also lists the name and description of the corresponding data type +from SQL-92 (if one exists). +SQL type identifier[1] Typical SQL data Typical type description + type[2] +SQL_CHAR CHAR(n) Character string of fixed + string length n. +SQL_VARCHAR VARCHAR(n) Variable-length character + string with a maximum + string length n. +SQL_LONGVARCHAR LONG VARCHAR Variable length character + data. Maximum length is + data source–dependent.[9] +SQL_WCHAR WCHAR(n) Unicode character string + of fixed string length n +SQL_WVARCHAR VARWCHAR(n) Unicode variable-length + character string with a + maximum string length n +SQL_WLONGVARCHAR LONGWVARCHAR Unicode variable-length + character data. Maximum + length is data + source–dependent +SQL_DECIMAL DECIMAL(p,s) Signed, exact, numeric + value with a precision of + at least p and scale s. + (The maximum precision is + driver-defined.) + (1 <= p <= 15; s <= p). + [4] +SQL_NUMERIC NUMERIC(p,s) Signed, exact, numeric + value with a precision p + and scale s + (1 <= p <= 15; s <= p). + [4] +SQL_SMALLINT SMALLINT Exact numeric value with + precision 5 and scale 0 + (signed: + –32,768 <= n <= 32,767, + unsigned: + 0 <= n <= 65,535)[3]. +SQL_INTEGER INTEGER Exact numeric value with + precision 10 and scale 0 + (signed: + –2[31] <= n <= 2[31] – 1, + unsigned: + 0 <= n <= 2[32] – 1)[3]. +SQL_REAL REAL Signed, approximate, + numeric value with a + binary precision 24 (zero + or absolute value 10[–38] + to 10[38]). +SQL_FLOAT FLOAT(p) Signed, approximate, + numeric value with a + binary precision of at + least p. (The maximum + precision is driver- + defined.)[5] +SQL_DOUBLE DOUBLE PRECISION Signed, approximate, + numeric value with a + binary precision 53 (zero + or absolute value 10 + [–308] to 10[308]). +SQL_BIT BIT Single bit binary data. + [8] +SQL_TINYINT TINYINT Exact numeric value with + precision 3 and scale 0 + (signed: + –128 <= n <= 127, + unsigned: + 0 <= n <= 255)[3]. +SQL_BIGINT BIGINT Exact numeric value with + precision 19 (if signed) + or 20 (if unsigned) and + scale 0 + (signed: + –2[63] <= n <= 2[63] – 1, + + unsigned: + 0 <= n <= 2[64] – 1)[3], + [9]. +SQL_BINARY BINARY(n) Binary data of fixed + length n.[9] +SQL_VARBINARY VARBINARY(n) Variable length binary + data of maximum length n. + The maximum is set by the + user.[9] +SQL_LONGVARBINARY LONG VARBINARY Variable length binary + data. Maximum length is + data source–dependent.[9] +SQL_TYPE_DATE[6] DATE Year, month, and day + fields, conforming to the + rules of the Gregorian + calendar. (See + "Constraints_of_the + Gregorian_Calendar," + later in this appendix.) +SQL_TYPE_TIME[6] TIME(p) Hour, minute, and second + fields, with valid values + for hours of 00 to 23, + valid values for minutes + of 00 to 59, and valid + values for seconds of 00 + to 61. Precision p + indicates the seconds + precision. +SQL_TYPE_TIMESTAMP[6] TIMESTAMP(p) Year, month, day, hour, + minute, and second + fields, with valid values + as defined for the DATE + and TIME data types. +SQL_INTERVAL_MONTH[7] INTERVAL MONTH(p) Number of months between + two dates; p is the + interval leading + precision. +SQL_INTERVAL_YEAR[7] INTERVAL YEAR(p) Number of years between + two dates; p is the + interval leading + precision. +SQL_INTERVAL_YEAR_TO_MONTH[7] INTERVAL YEAR(p) TO Number of years and + MONTH months between two dates; + p is the interval leading + precision. +SQL_INTERVAL_DAY[7] INTERVAL DAY(p) Number of days between + two dates; p is the + interval leading + precision. +SQL_INTERVAL_HOUR[7] INTERVAL HOUR(p) Number of hours between + two date/times; p is the + interval leading + precision. +SQL_INTERVAL_MINUTE[7] INTERVAL MINUTE(p) Number of minutes between + two date/times; p is the + interval leading + precision. +SQL_INTERVAL_SECOND[7] INTERVAL SECOND(p,q) Number of seconds between + two date/times; p is the + interval leading + precision and q is the + interval seconds + precision. +SQL_INTERVAL_DAY_TO_HOUR[7] INTERVAL DAY(p) TO HOUR Number of days/hours + between two date/times; p + is the interval leading + precision. +SQL_INTERVAL_DAY_TO_MINUTE[7] INTERVAL DAY(p) TO Number of days/hours/ + MINUTE minutes between two date/ + times; p is the interval + leading precision. +SQL_INTERVAL_DAY_TO_SECOND[7] INTERVAL DAY(p) TO Number of days/hours/ + SECOND(q) minutes/seconds between + two date/times; p is the + interval leading + precision and q is the + interval seconds + precision. +SQL_INTERVAL_HOUR_TO_MINUTE INTERVAL HOUR(p) TO Number of hours/minutes +[7] MINUTE between two date/times; p + is the interval leading + precision. +SQL_INTERVAL_HOUR_TO_SECOND INTERVAL HOUR(p) TO Number of hours/minutes/ +[7] SECOND(q) seconds between two date/ + times; p is the interval + leading precision and q + is the interval seconds + precision. +SQL_INTERVAL_MINUTE_TO_SECOND INTERVAL MINUTE(p) TO Number of minutes/seconds +[7] SECOND(q) between two date/times; p + is the interval leading + precision and q is the + interval seconds + precision. +SQL_GUID GUID Fixed length Globally + Unique Identifier. +[1] This is the value returned in the DATA_TYPE column by a call to +SQLGetTypeInfo. +[2] This is the value returned in the NAME and CREATE PARAMS column by a call +to SQLGetTypeInfo. The NAME column returns the designation—for example, +CHAR—while the CREATE PARAMS column returns a comma-separated list of creation +parameters such as precision, scale, and length. +[3] An application uses SQLGetTypeInfo or SQLColAttribute to determine if a +particular data type or a particular column in a result set is unsigned. +[4] SQL_DECIMAL and SQL_NUMERIC data types differ only in their precision. +The precision of a DECIMAL(p,s) is an implementation-defined decimal precision +that is no less than p, while the precision of a NUMERIC(p,s) is exactly equal +to p. +[5] Depending on the implementation, the precision of SQL_FLOAT can be either +24 or 53: if it is 24, the SQL_FLOAT data type is the same as SQL_REAL; if it +is 53, the SQL_FLOAT data type is the same as SQL_DOUBLE. +[6] In ODBC 3.x, the SQL date, time, and timestamp data types are +SQL_TYPE_DATE, SQL_TYPE_TIME, and SQL_TYPE_TIMESTAMP, respectively; in ODBC +2.x, the data types are SQL_DATE, SQL_TIME, and SQL_TIMESTAMP. +[7] For more information on the interval SQL data types, see the "Interval +Data_Types" section, later in this appendix. +[8] The SQL_BIT data type has different characteristics than the BIT type in +SQL-92. +[9] This data type has no corresponding data type in SQL-92. +ODBC Programmer's Reference +************ CC DDaattaa TTyyppeess ************ +ODBC C data types indicate the data type of C buffers used to store data in the +application. +All drivers must support all C data types. This is required because all drivers +must support all C types to which SQL types that they support can be converted, +and all drivers support at least one character SQL type. Because the character +SQL type can be converted to and from all C types, all drivers must support all +C types. +The C data type is specified in the SSQQLLBBiinnddCCoolland SSQQLLGGeettDDaattaa functions with the +TargetType argument and in the SSQQLLBBiinnddPPaarraammeetteerr function with the ValueType +argument. It can also be specified by calling SSQQLLSSeettDDeessccFFiieelldd to set the +SQL_DESC_CONCISE_TYPE field of an ARD or APD, or by calling SSQQLLSSeettDDeessccRReecc with +the Type argument (and the SubType argument if needed) and the DescriptorHandle +argument set to the handle of an ARD or APD. +The following table lists valid type identifiers for the C data types. The +table also lists the ODBC C data type that corresponds to each identifier and +the definition of this data type. +CC ttyyppee iiddeennttiiffiieerr OODDBBCC CC ttyyppeeddeeff CC ttyyppee +SQL_C_CHAR SQLCHAR * unsigned char * +SQL_C_SSHORT[j] SQLSMALLINT short int +SQL_C_USHORT[j] SQLUSMALLINT unsigned short int +SQL_C_SLONG[j] SQLINTEGER long int +SQL_C_ULONG[j] SQLUINTEGER unsigned long int +SQL_C_FLOAT SQLREAL float +SQL_C_DOUBLE SQLDOUBLE, SQLFLOAT double +SQL_C_BIT SQLCHAR unsigned char +SQL_C_STINYINT[j] SQLSCHAR signed char +SQL_C_UTINYINT[j] SQLCHAR unsigned char +SQL_C_SBIGINT SQLBIGINT _int64[h] +SQL_C_UBIGINT SQLUBIGINT unsigned _int64[h] +SQL_C_BINARY SQLCHAR * unsigned char * +SQL_C_BOOKMARK[i] BOOKMARK unsigned long int[d] +SQL_C_VARBOOKMARK SQLCHAR * unsigned char * +SQL_C_TYPE_DATE[c] SQL_DATE_STRUCT struct tagDATE_STRUCT { + SQLSMALLINT year; + SQLUSMALLINT month; + SQLUSMALLINT day; + } DATE_STRUCT;[a] +SQL_C_TYPE_TIME[c] SQL_TIME_STRUCT struct tagTIME_STRUCT { + SQLUSMALLINT hour; + SQLUSMALLINT minute; + SQLUSMALLINT second; + } TIME_STRUCT;[a] +SQL_C_TYPE_TIMESTAMP[c] SQL_TIMESTAMP_STRUCT struct tagTIMESTAMP_STRUCT { + SQLSMALLINT year; + SQLUSMALLINT month; + SQLUSMALLINT day; + SQLUSMALLINT hour; + SQLUSMALLINT minute; + SQLUSMALLINT second; + SQLUINTEGER fraction;[b] + } TIMESTAMP_STRUCT;[a] +SQL_C_NUMERIC SQL_NUMERIC_STRUCT struct tagSQL_NUMERIC_STRUCT { + SQLCHAR precision; + SQLSCHAR scale; + SQLCHAR sign[g]; + SQLCHAR + val + [SQL_MAX_NUMERIC_L EN]; + [e], [f] + } SQL_NUMERIC_STRUCT; +SQL_C_GUID SQLGUID struct tagSQLGUID { + DWORD Data1; + WORD Data2; + WORD Data3; + BYTE Data4[8]; + } SQLGUID;[k] +All C interval data SQL_INTERVAL_STRUCT See the "_C_ _I_n_t_e_r_v_a_l_ _S_t_r_u_c_t_u_r_e" +types section, later in this appendix. +[a] The values of the year, month, day, hour, minute, and second fields in +the datetime C data types must conform to the constraints of the Gregorian +calendar. (See "_C_o_n_s_t_r_a_i_n_t_s_ _o_f_ _t_h_e_ _G_r_e_g_o_r_i_a_n_ _C_a_l_e_n_d_a_r" later in this appendix.) +[b] The value of the fraction field is the number of billionths of a second +and ranges from 0 through 999,999,999 (1 less than 1 billion). For example, the +value of the fraction field for a half-second is 500,000,000, for a thousandth +of a second (one millisecond) is 1,000,000, for a millionth of a second (one +microsecond) is 1,000, and for a billionth of a second (one nanosecond) is 1. +[c] In ODBC 2.x, the C date, time, and timestamp data types are SQL_C_DATE, +SQL_C_TIME, and SQL_C_TIMESTAMP. +[d] ODBC 3.x applications should use SQL_C_VARBOOKMARK, not SQL_C_BOOKMARK. +When an ODBC 3.x application works with an ODBC 2.x driver, the ODBC 3.x Driver +Manager will map SQL_C_VARBOOKMARK to SQL_C_BOOKMARK. +[e] A number is stored in the val field of the SQL_NUMERIC_STRUCT structure +as a scaled integer, in little endian mode (the leftmost byte being the least- +significant byte). For example, the number 10.001 base 10, with a scale of 4, +is scaled to an integer of 100010. Because this is 186AA in hexadecimal format, +the value in SQL_NUMERIC_STRUCT would be "AA 86 01 00 00 … 00", with the number +of bytes defined by the SQL_MAX_NUMERIC_LEN ##ddeeffiinnee. +[f] The precision and scale fields of the SQL_C_NUMERIC data type are never +used for input from an application, only for output from the driver to the +application. When the driver writes a numeric value into the +SQL_NUMERIC_STRUCT, it will use its own driver-specific default as the value +for the precision field, and it will use the value in the SQL_DESC_SCALE field +of the application descriptor (which defaults to 0) for the scale field. An +application can provide its own values for precision and scale by setting the +SQL_DESC_PRECISION and SQL_DESC_SCALE fields of the application descriptor. +[g] The sign field is 1 if positive, 0 if negative. +[h] _int64 might not be supplied by some compilers. +[i] _SQL_C_BOOKMARK has been deprecated in ODBC 3.x. +[j] _SQL_C_SHORT, SQL_C_LONG, and SQL_C_TINYINT have been replaced in ODBC by +signed and unsigned types: SQL_C_SSHORT and SQL_C_USHORT, SQL_C_SLONG and +SQL_C_ULONG, and SQL_C_STINYINT and SQL_C_UTINYINT. An ODBC 3.x driver that +should work with ODBC 2.x applications should support SQL_C_SHORT, SQL_C_LONG, +and SQL_C_TINYINT, because when they are called, the Driver Manager passes them +through to the driver. +[k] SQL_C_GUID can be converted only to SQL_CHAR or SQL_WCHAR. diff --git a/ndb/src/client/odbc/driver/Func.data b/ndb/src/client/odbc/driver/Func.data new file mode 100644 index 00000000000..c32671e1135 --- /dev/null +++ b/ndb/src/client/odbc/driver/Func.data @@ -0,0 +1,2822 @@ +$func = { + SQLAllocConnect => { + type => 'SQLRETURN', + name => 'SQLAllocConnect', + param => [ + { + type => 'SQLHENV', + ptr => 0, + name => 'EnvironmentHandle', + index => 0, + }, + { + type => 'SQLHDBC', + ptr => 1, + name => 'ConnectionHandle', + index => 1, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLAllocEnv => { + type => 'SQLRETURN', + name => 'SQLAllocEnv', + param => [ + { + type => 'SQLHENV', + ptr => 1, + name => 'EnvironmentHandle', + index => 0, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLAllocHandle => { + type => 'SQLRETURN', + name => 'SQLAllocHandle', + param => [ + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'HandleType', + index => 0, + }, + { + type => 'SQLHANDLE', + ptr => 0, + name => 'InputHandle', + index => 1, + }, + { + type => 'SQLHANDLE', + ptr => 1, + name => 'OutputHandle', + index => 2, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLAllocHandleStd => { + type => 'SQLRETURN', + name => 'SQLAllocHandleStd', + param => [ + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'fHandleType', + index => 0, + }, + { + type => 'SQLHANDLE', + ptr => 0, + name => 'hInput', + index => 1, + }, + { + type => 'SQLHANDLE', + ptr => 1, + name => 'phOutput', + index => 2, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLAllocStmt => { + type => 'SQLRETURN', + name => 'SQLAllocStmt', + param => [ + { + type => 'SQLHDBC', + ptr => 0, + name => 'ConnectionHandle', + index => 0, + }, + { + type => 'SQLHSTMT', + ptr => 1, + name => 'StatementHandle', + index => 1, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLBindCol => { + type => 'SQLRETURN', + name => 'SQLBindCol', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'ColumnNumber', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'TargetType', + index => 2, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'TargetValue', + index => 3, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'BufferLength', + index => 4, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'StrLen_or_Ind', + index => 5, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLBindParam => { + type => 'SQLRETURN', + name => 'SQLBindParam', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'ParameterNumber', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'ValueType', + index => 2, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'ParameterType', + index => 3, + }, + { + type => 'SQLUINTEGER', + ptr => 0, + name => 'LengthPrecision', + index => 4, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'ParameterScale', + index => 5, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'ParameterValue', + index => 6, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'StrLen_or_Ind', + index => 7, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLBindParameter => { + type => 'SQLRETURN', + name => 'SQLBindParameter', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'hstmt', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'ipar', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'fParamType', + index => 2, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'fCType', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'fSqlType', + index => 4, + }, + { + type => 'SQLUINTEGER', + ptr => 0, + name => 'cbColDef', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'ibScale', + index => 6, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'rgbValue', + index => 7, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'cbValueMax', + index => 8, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'pcbValue', + index => 9, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLBrowseConnect => { + type => 'SQLRETURN', + name => 'SQLBrowseConnect', + param => [ + { + type => 'SQLHDBC', + ptr => 0, + name => 'hdbc', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szConnStrIn', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbConnStrIn', + index => 2, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szConnStrOut', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbConnStrOutMax', + index => 4, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'pcbConnStrOut', + index => 5, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLBulkOperations => { + type => 'SQLRETURN', + name => 'SQLBulkOperations', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'Operation', + index => 1, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLCancel => { + type => 'SQLRETURN', + name => 'SQLCancel', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLCloseCursor => { + type => 'SQLRETURN', + name => 'SQLCloseCursor', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLColAttribute => { + type => 'SQLRETURN', + name => 'SQLColAttribute', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'ColumnNumber', + index => 1, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'FieldIdentifier', + index => 2, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'CharacterAttribute', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'BufferLength', + index => 4, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'StringLength', + index => 5, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'NumericAttribute', + index => 6, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLColAttributes => { + type => 'SQLRETURN', + name => 'SQLColAttributes', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'hstmt', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'icol', + index => 1, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'fDescType', + index => 2, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'rgbDesc', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbDescMax', + index => 4, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'pcbDesc', + index => 5, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'pfDesc', + index => 6, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLColumnPrivileges => { + type => 'SQLRETURN', + name => 'SQLColumnPrivileges', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'hstmt', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szCatalogName', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbCatalogName', + index => 2, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szSchemaName', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbSchemaName', + index => 4, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szTableName', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbTableName', + index => 6, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szColumnName', + index => 7, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbColumnName', + index => 8, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLColumns => { + type => 'SQLRETURN', + name => 'SQLColumns', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'CatalogName', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength1', + index => 2, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'SchemaName', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength2', + index => 4, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'TableName', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength3', + index => 6, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'ColumnName', + index => 7, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength4', + index => 8, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLConnect => { + type => 'SQLRETURN', + name => 'SQLConnect', + param => [ + { + type => 'SQLHDBC', + ptr => 0, + name => 'ConnectionHandle', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'ServerName', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength1', + index => 2, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'UserName', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength2', + index => 4, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'Authentication', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength3', + index => 6, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLCopyDesc => { + type => 'SQLRETURN', + name => 'SQLCopyDesc', + param => [ + { + type => 'SQLHDESC', + ptr => 0, + name => 'SourceDescHandle', + index => 0, + }, + { + type => 'SQLHDESC', + ptr => 0, + name => 'TargetDescHandle', + index => 1, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLDataSources => { + type => 'SQLRETURN', + name => 'SQLDataSources', + param => [ + { + type => 'SQLHENV', + ptr => 0, + name => 'EnvironmentHandle', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'Direction', + index => 1, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'ServerName', + index => 2, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'BufferLength1', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'NameLength1', + index => 4, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'Description', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'BufferLength2', + index => 6, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'NameLength2', + index => 7, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLDescribeCol => { + type => 'SQLRETURN', + name => 'SQLDescribeCol', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'ColumnNumber', + index => 1, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'ColumnName', + index => 2, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'BufferLength', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'NameLength', + index => 4, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'DataType', + index => 5, + }, + { + type => 'SQLUINTEGER', + ptr => 1, + name => 'ColumnSize', + index => 6, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'DecimalDigits', + index => 7, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'Nullable', + index => 8, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLDescribeParam => { + type => 'SQLRETURN', + name => 'SQLDescribeParam', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'hstmt', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'ipar', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'pfSqlType', + index => 2, + }, + { + type => 'SQLUINTEGER', + ptr => 1, + name => 'pcbParamDef', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'pibScale', + index => 4, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'pfNullable', + index => 5, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLDisconnect => { + type => 'SQLRETURN', + name => 'SQLDisconnect', + param => [ + { + type => 'SQLHDBC', + ptr => 0, + name => 'ConnectionHandle', + index => 0, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLDriverConnect => { + type => 'SQLRETURN', + name => 'SQLDriverConnect', + param => [ + { + type => 'SQLHDBC', + ptr => 0, + name => 'hdbc', + index => 0, + }, + { + type => 'SQLHWND', + ptr => 0, + name => 'hwnd', + index => 1, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szConnStrIn', + index => 2, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbConnStrIn', + index => 3, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szConnStrOut', + index => 4, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbConnStrOutMax', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'pcbConnStrOut', + index => 6, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'fDriverCompletion', + index => 7, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLDrivers => { + type => 'SQLRETURN', + name => 'SQLDrivers', + param => [ + { + type => 'SQLHENV', + ptr => 0, + name => 'henv', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'fDirection', + index => 1, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szDriverDesc', + index => 2, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbDriverDescMax', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'pcbDriverDesc', + index => 4, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szDriverAttributes', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbDrvrAttrMax', + index => 6, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'pcbDrvrAttr', + index => 7, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLEndTran => { + type => 'SQLRETURN', + name => 'SQLEndTran', + param => [ + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'HandleType', + index => 0, + }, + { + type => 'SQLHANDLE', + ptr => 0, + name => 'Handle', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'CompletionType', + index => 2, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLError => { + type => 'SQLRETURN', + name => 'SQLError', + param => [ + { + type => 'SQLHENV', + ptr => 0, + name => 'EnvironmentHandle', + index => 0, + }, + { + type => 'SQLHDBC', + ptr => 0, + name => 'ConnectionHandle', + index => 1, + }, + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 2, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'Sqlstate', + index => 3, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'NativeError', + index => 4, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'MessageText', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'BufferLength', + index => 6, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'TextLength', + index => 7, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLExecDirect => { + type => 'SQLRETURN', + name => 'SQLExecDirect', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'StatementText', + index => 1, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'TextLength', + index => 2, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLExecute => { + type => 'SQLRETURN', + name => 'SQLExecute', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLExtendedFetch => { + type => 'SQLRETURN', + name => 'SQLExtendedFetch', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'hstmt', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'fFetchType', + index => 1, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'irow', + index => 2, + }, + { + type => 'SQLUINTEGER', + ptr => 1, + name => 'pcrow', + index => 3, + }, + { + type => 'SQLUSMALLINT', + ptr => 1, + name => 'rgfRowStatus', + index => 4, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLFetch => { + type => 'SQLRETURN', + name => 'SQLFetch', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLFetchScroll => { + type => 'SQLRETURN', + name => 'SQLFetchScroll', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'FetchOrientation', + index => 1, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'FetchOffset', + index => 2, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLForeignKeys => { + type => 'SQLRETURN', + name => 'SQLForeignKeys', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'hstmt', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szPkCatalogName', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbPkCatalogName', + index => 2, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szPkSchemaName', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbPkSchemaName', + index => 4, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szPkTableName', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbPkTableName', + index => 6, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szFkCatalogName', + index => 7, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbFkCatalogName', + index => 8, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szFkSchemaName', + index => 9, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbFkSchemaName', + index => 10, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szFkTableName', + index => 11, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbFkTableName', + index => 12, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLFreeConnect => { + type => 'SQLRETURN', + name => 'SQLFreeConnect', + param => [ + { + type => 'SQLHDBC', + ptr => 0, + name => 'ConnectionHandle', + index => 0, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLFreeEnv => { + type => 'SQLRETURN', + name => 'SQLFreeEnv', + param => [ + { + type => 'SQLHENV', + ptr => 0, + name => 'EnvironmentHandle', + index => 0, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLFreeHandle => { + type => 'SQLRETURN', + name => 'SQLFreeHandle', + param => [ + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'HandleType', + index => 0, + }, + { + type => 'SQLHANDLE', + ptr => 0, + name => 'Handle', + index => 1, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLFreeStmt => { + type => 'SQLRETURN', + name => 'SQLFreeStmt', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'Option', + index => 1, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLGetConnectAttr => { + type => 'SQLRETURN', + name => 'SQLGetConnectAttr', + param => [ + { + type => 'SQLHDBC', + ptr => 0, + name => 'ConnectionHandle', + index => 0, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'Attribute', + index => 1, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'Value', + index => 2, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'BufferLength', + index => 3, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'StringLength', + index => 4, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLGetConnectOption => { + type => 'SQLRETURN', + name => 'SQLGetConnectOption', + param => [ + { + type => 'SQLHDBC', + ptr => 0, + name => 'ConnectionHandle', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'Option', + index => 1, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'Value', + index => 2, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLGetCursorName => { + type => 'SQLRETURN', + name => 'SQLGetCursorName', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'CursorName', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'BufferLength', + index => 2, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'NameLength', + index => 3, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLGetData => { + type => 'SQLRETURN', + name => 'SQLGetData', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'ColumnNumber', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'TargetType', + index => 2, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'TargetValue', + index => 3, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'BufferLength', + index => 4, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'StrLen_or_Ind', + index => 5, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLGetDescField => { + type => 'SQLRETURN', + name => 'SQLGetDescField', + param => [ + { + type => 'SQLHDESC', + ptr => 0, + name => 'DescriptorHandle', + index => 0, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'RecNumber', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'FieldIdentifier', + index => 2, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'Value', + index => 3, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'BufferLength', + index => 4, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'StringLength', + index => 5, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLGetDescRec => { + type => 'SQLRETURN', + name => 'SQLGetDescRec', + param => [ + { + type => 'SQLHDESC', + ptr => 0, + name => 'DescriptorHandle', + index => 0, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'RecNumber', + index => 1, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'Name', + index => 2, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'BufferLength', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'StringLength', + index => 4, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'Type', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'SubType', + index => 6, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'Length', + index => 7, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'Precision', + index => 8, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'Scale', + index => 9, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'Nullable', + index => 10, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLGetDiagField => { + type => 'SQLRETURN', + name => 'SQLGetDiagField', + param => [ + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'HandleType', + index => 0, + }, + { + type => 'SQLHANDLE', + ptr => 0, + name => 'Handle', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'RecNumber', + index => 2, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'DiagIdentifier', + index => 3, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'DiagInfo', + index => 4, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'BufferLength', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'StringLength', + index => 6, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLGetDiagRec => { + type => 'SQLRETURN', + name => 'SQLGetDiagRec', + param => [ + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'HandleType', + index => 0, + }, + { + type => 'SQLHANDLE', + ptr => 0, + name => 'Handle', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'RecNumber', + index => 2, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'Sqlstate', + index => 3, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'NativeError', + index => 4, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'MessageText', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'BufferLength', + index => 6, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'TextLength', + index => 7, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLGetEnvAttr => { + type => 'SQLRETURN', + name => 'SQLGetEnvAttr', + param => [ + { + type => 'SQLHENV', + ptr => 0, + name => 'EnvironmentHandle', + index => 0, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'Attribute', + index => 1, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'Value', + index => 2, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'BufferLength', + index => 3, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'StringLength', + index => 4, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLGetFunctions => { + type => 'SQLRETURN', + name => 'SQLGetFunctions', + param => [ + { + type => 'SQLHDBC', + ptr => 0, + name => 'ConnectionHandle', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'FunctionId', + index => 1, + }, + { + type => 'SQLUSMALLINT', + ptr => 1, + name => 'Supported', + index => 2, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLGetInfo => { + type => 'SQLRETURN', + name => 'SQLGetInfo', + param => [ + { + type => 'SQLHDBC', + ptr => 0, + name => 'ConnectionHandle', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'InfoType', + index => 1, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'InfoValue', + index => 2, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'BufferLength', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'StringLength', + index => 4, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLGetStmtAttr => { + type => 'SQLRETURN', + name => 'SQLGetStmtAttr', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'Attribute', + index => 1, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'Value', + index => 2, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'BufferLength', + index => 3, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'StringLength', + index => 4, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLGetStmtOption => { + type => 'SQLRETURN', + name => 'SQLGetStmtOption', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'Option', + index => 1, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'Value', + index => 2, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLGetTypeInfo => { + type => 'SQLRETURN', + name => 'SQLGetTypeInfo', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'DataType', + index => 1, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLMoreResults => { + type => 'SQLRETURN', + name => 'SQLMoreResults', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'hstmt', + index => 0, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLNativeSql => { + type => 'SQLRETURN', + name => 'SQLNativeSql', + param => [ + { + type => 'SQLHDBC', + ptr => 0, + name => 'hdbc', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szSqlStrIn', + index => 1, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'cbSqlStrIn', + index => 2, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szSqlStr', + index => 3, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'cbSqlStrMax', + index => 4, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'pcbSqlStr', + index => 5, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLNumParams => { + type => 'SQLRETURN', + name => 'SQLNumParams', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'hstmt', + index => 0, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'pcpar', + index => 1, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLNumResultCols => { + type => 'SQLRETURN', + name => 'SQLNumResultCols', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLSMALLINT', + ptr => 1, + name => 'ColumnCount', + index => 1, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLParamData => { + type => 'SQLRETURN', + name => 'SQLParamData', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLPOINTER', + ptr => 1, + name => 'Value', + index => 1, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLParamOptions => { + type => 'SQLRETURN', + name => 'SQLParamOptions', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'hstmt', + index => 0, + }, + { + type => 'SQLUINTEGER', + ptr => 0, + name => 'crow', + index => 1, + }, + { + type => 'SQLUINTEGER', + ptr => 1, + name => 'pirow', + index => 2, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLPrepare => { + type => 'SQLRETURN', + name => 'SQLPrepare', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'StatementText', + index => 1, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'TextLength', + index => 2, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLPrimaryKeys => { + type => 'SQLRETURN', + name => 'SQLPrimaryKeys', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'hstmt', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szCatalogName', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbCatalogName', + index => 2, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szSchemaName', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbSchemaName', + index => 4, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szTableName', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbTableName', + index => 6, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLProcedureColumns => { + type => 'SQLRETURN', + name => 'SQLProcedureColumns', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'hstmt', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szCatalogName', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbCatalogName', + index => 2, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szSchemaName', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbSchemaName', + index => 4, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szProcName', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbProcName', + index => 6, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szColumnName', + index => 7, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbColumnName', + index => 8, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLProcedures => { + type => 'SQLRETURN', + name => 'SQLProcedures', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'hstmt', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szCatalogName', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbCatalogName', + index => 2, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szSchemaName', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbSchemaName', + index => 4, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szProcName', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbProcName', + index => 6, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLPutData => { + type => 'SQLRETURN', + name => 'SQLPutData', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'Data', + index => 1, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'StrLen_or_Ind', + index => 2, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLRowCount => { + type => 'SQLRETURN', + name => 'SQLRowCount', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'RowCount', + index => 1, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLSetConnectAttr => { + type => 'SQLRETURN', + name => 'SQLSetConnectAttr', + param => [ + { + type => 'SQLHDBC', + ptr => 0, + name => 'ConnectionHandle', + index => 0, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'Attribute', + index => 1, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'Value', + index => 2, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'StringLength', + index => 3, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLSetConnectOption => { + type => 'SQLRETURN', + name => 'SQLSetConnectOption', + param => [ + { + type => 'SQLHDBC', + ptr => 0, + name => 'ConnectionHandle', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'Option', + index => 1, + }, + { + type => 'SQLUINTEGER', + ptr => 0, + name => 'Value', + index => 2, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLSetCursorName => { + type => 'SQLRETURN', + name => 'SQLSetCursorName', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'CursorName', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength', + index => 2, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLSetDescField => { + type => 'SQLRETURN', + name => 'SQLSetDescField', + param => [ + { + type => 'SQLHDESC', + ptr => 0, + name => 'DescriptorHandle', + index => 0, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'RecNumber', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'FieldIdentifier', + index => 2, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'Value', + index => 3, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'BufferLength', + index => 4, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLSetDescRec => { + type => 'SQLRETURN', + name => 'SQLSetDescRec', + param => [ + { + type => 'SQLHDESC', + ptr => 0, + name => 'DescriptorHandle', + index => 0, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'RecNumber', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'Type', + index => 2, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'SubType', + index => 3, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'Length', + index => 4, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'Precision', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'Scale', + index => 6, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'Data', + index => 7, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'StringLength', + index => 8, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'Indicator', + index => 9, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLSetEnvAttr => { + type => 'SQLRETURN', + name => 'SQLSetEnvAttr', + param => [ + { + type => 'SQLHENV', + ptr => 0, + name => 'EnvironmentHandle', + index => 0, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'Attribute', + index => 1, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'Value', + index => 2, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'StringLength', + index => 3, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLSetParam => { + type => 'SQLRETURN', + name => 'SQLSetParam', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'ParameterNumber', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'ValueType', + index => 2, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'ParameterType', + index => 3, + }, + { + type => 'SQLUINTEGER', + ptr => 0, + name => 'LengthPrecision', + index => 4, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'ParameterScale', + index => 5, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'ParameterValue', + index => 6, + }, + { + type => 'SQLINTEGER', + ptr => 1, + name => 'StrLen_or_Ind', + index => 7, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLSetPos => { + type => 'SQLRETURN', + name => 'SQLSetPos', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'hstmt', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'irow', + index => 1, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'fOption', + index => 2, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'fLock', + index => 3, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLSetScrollOptions => { + type => 'SQLRETURN', + name => 'SQLSetScrollOptions', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'hstmt', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'fConcurrency', + index => 1, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'crowKeyset', + index => 2, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'crowRowset', + index => 3, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLSetStmtAttr => { + type => 'SQLRETURN', + name => 'SQLSetStmtAttr', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'Attribute', + index => 1, + }, + { + type => 'SQLPOINTER', + ptr => 0, + name => 'Value', + index => 2, + }, + { + type => 'SQLINTEGER', + ptr => 0, + name => 'StringLength', + index => 3, + }, + ], + odbcver => 'ODBCVER >= 0x0300', + }, + SQLSetStmtOption => { + type => 'SQLRETURN', + name => 'SQLSetStmtOption', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'Option', + index => 1, + }, + { + type => 'SQLUINTEGER', + ptr => 0, + name => 'Value', + index => 2, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLSpecialColumns => { + type => 'SQLRETURN', + name => 'SQLSpecialColumns', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'IdentifierType', + index => 1, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'CatalogName', + index => 2, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength1', + index => 3, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'SchemaName', + index => 4, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength2', + index => 5, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'TableName', + index => 6, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength3', + index => 7, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'Scope', + index => 8, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'Nullable', + index => 9, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLStatistics => { + type => 'SQLRETURN', + name => 'SQLStatistics', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'CatalogName', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength1', + index => 2, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'SchemaName', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength2', + index => 4, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'TableName', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength3', + index => 6, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'Unique', + index => 7, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'Reserved', + index => 8, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLTablePrivileges => { + type => 'SQLRETURN', + name => 'SQLTablePrivileges', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'hstmt', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szCatalogName', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbCatalogName', + index => 2, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szSchemaName', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbSchemaName', + index => 4, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'szTableName', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'cbTableName', + index => 6, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLTables => { + type => 'SQLRETURN', + name => 'SQLTables', + param => [ + { + type => 'SQLHSTMT', + ptr => 0, + name => 'StatementHandle', + index => 0, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'CatalogName', + index => 1, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength1', + index => 2, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'SchemaName', + index => 3, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength2', + index => 4, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'TableName', + index => 5, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength3', + index => 6, + }, + { + type => 'SQLCHAR', + ptr => 1, + name => 'TableType', + index => 7, + }, + { + type => 'SQLSMALLINT', + ptr => 0, + name => 'NameLength4', + index => 8, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, + SQLTransact => { + type => 'SQLRETURN', + name => 'SQLTransact', + param => [ + { + type => 'SQLHENV', + ptr => 0, + name => 'EnvironmentHandle', + index => 0, + }, + { + type => 'SQLHDBC', + ptr => 0, + name => 'ConnectionHandle', + index => 1, + }, + { + type => 'SQLUSMALLINT', + ptr => 0, + name => 'CompletionType', + index => 2, + }, + ], + odbcver => 'ODBCVER >= 0x0000', + }, +}; diff --git a/ndb/src/client/odbc/driver/Func.pl b/ndb/src/client/odbc/driver/Func.pl new file mode 100644 index 00000000000..1064a6a6c6e --- /dev/null +++ b/ndb/src/client/odbc/driver/Func.pl @@ -0,0 +1,352 @@ +# + +use strict; +select(STDOUT); +$| = 1; +use vars qw($func); + +my $action = shift; +my @args = @ARGV; +if (! $action) { + print < ... +data -unixodbc -- write new Func.data to stdout +name [-[no]auto -type] [suffix] -- list function names +code -- write auto/*.cpp +diff -- diff against auto/*.cpp +move -- move auto/*.cpp to . +functab -- write struct entiries for SQLGetFunctions +END + exit(0); +} + +# indents +my $i1 = " " x (1*4); +my $i2 = " " x (2*4); +my $i3 = " " x (3*4); +my $i4 = " " x (4*4); + +if ($action eq 'data') { + my @entry = (); + while (@args) { + my $file = shift(@args); + if ($file eq '-unixodbc') { + unshift(@args, ); + next; + } + if ($file eq '-iodbc') { + unshift(@args, ); + next; + } + warn "read $file\n"; + open(F, "<$file") || die "$file: $!"; + my $text = undef; + my $odbcver = undef; + while ($_ = ) { + chomp; + if (/^\s*$/) { + next; + } + if (/^\s*#\s*if\s+(.*\bODBCVER\b.*)$/) { + $odbcver = $1; + $odbcver =~ s/^\s+|\s+$//g; + $odbcver =~ s/^\(+|\)+$//g; + next; + } + if (/^\s*#\s*endif\b/) { + $odbcver = undef; + next; + } + if (/^\s*SQLRETURN\b/) { + $text = ""; + } + if (defined($text)) { + $text .= $_; + if (/;\s*$/) { + push(@entry, { + text => $text, + odbcver => $odbcver || 'ODBCVER >= 0x0000', + }); + $text = undef; + } + } + } + close(F); + } + warn "@{[ scalar @entry ]} entries\n"; + $func = {}; + for my $e (@entry) { + my $text = $e->{text}; + $text =~ s!/\*.+?\*/!!g; + $text =~ s/^\s+|\s+$//g; + $text =~ s/\s\s*/\040/g; + $text =~ /^(SQLRETURN)\s+(SQL_API\s+)?(\w+)\s*\((.*)\)\s*;/ + or warn "discard: $_\n", next; + my $type = $1; + my $name = $3; + my $body = $4; + my $f = {}; + $f->{type} = $type; + $f->{name} = $name; + my @body = split(/,/, $body); + my $param = []; + for my $s (@body) { + $s =~ s/^\s+|\s+$//g; + my($ptype, $pptr, $pname); + if ($s =~ /^(\w+)\s+(\w+)$/) { + $ptype = $1; + $pptr = 0; + $pname = $2; + } elsif ($s =~ /^(\w+)\s*\*\s*(\w+)$/) { + $ptype = $1; + $pptr = 1; + $pname = $2; + } else { + warn "discard: $name: param $s\n"; + $param = undef; + last; + } + my $pindex = scalar @$param; + push(@$param, { + type => $ptype, + ptr => $pptr, + name => $pname, + index => $pindex, + }); + } + $param or next; + $f->{param} = $param; + $f->{odbcver} = $e->{odbcver}; + $func->{$name} + and warn "duplicate: $name\n", next; + $func->{$name} = $f; + } + print "\$func = {\n"; + for my $name (sort keys %$func) { + my $f = $func->{$name}; + print "${i1}$name => {\n"; + print "${i2}type => '$f->{type}',\n"; + print "${i2}name => '$f->{name}',\n"; + print "${i2}param => [\n"; + for my $p (@{$f->{param}}) { + print "${i3}\{\n"; + print "${i4}type => '$p->{type}',\n"; + print "${i4}ptr => $p->{ptr},\n"; + print "${i4}name => '$p->{name}',\n"; + print "${i4}index => $p->{index},\n"; + print "${i3}\},\n"; + } + print "${i2}],\n"; + print "${i2}odbcver => '$f->{odbcver}',\n"; + print "${i1}},\n"; + } + printf "};\n"; + $action = undef; +} + +if ($action eq 'name') { + my %functab = (); # bit in FuncTab + my $functab = "../handles/FuncTab.cpp"; + if (! open(F, "<$functab")) { + warn "$functab: $!"; + } else { + while ($_ = ) { + if (/SQL_API_([A-Z]+)[\s,]*([01])/) { + defined $functab{$1} and die "$_"; + $functab{$1} = $2; + } + } + close(F); + } + require './Func.data'; + my $auto = 1; + my $noauto = 1; + my $type = 0; + while ($args[0] =~ /^-(\w+)$/) { + $noauto = 0 if $1 eq 'auto'; + $auto = 0 if $1 eq 'noauto'; + $type = 1 if $1 eq 'type'; + shift(@args); + } + my $suffix = shift(@args); + for my $name (sort keys %$func) { + my $f = $func->{$name}; + local $/ = undef; + my($x1); + if (open(F, "<$name.cpp")) { + $x1 = ; + close(F); + if ($x1 =~ /\bauto_$name\b/) { + $auto || next; + print "A " if $type; + } else { + $noauto || next; + print "- " if $type; + } + if ($type) { + my $y = $functab{uc $name}; + $y = "?" if $y !~ /^[01]$/; + print "$y "; + my $z = $f->{odbcver}; + $z =~ s/^.*(...)$/$1/; + print "$z "; + } + } + print "$name$suffix\n"; + } + $action = undef; +} + +if ($action eq 'code') { + require './Func.data'; + system("rm -rf auto; mkdir auto"); + for my $name (sort keys %$func) { + my $f = $func->{$name}; + my $file = "auto/$name.cpp"; + open(F, ">$file") || die "$file: $!\n"; + print F "#include \"driver.hpp\"\n"; + print F "\n"; + printf F "#if $f->{odbcver}\n"; + print F "$f->{type} SQL_API\n"; + print F "$f->{name}("; + for my $p (@{$f->{param}}) { + print F "," if $p->{index} > 0; + print F "\n${i1}$p->{type}"; + for (my $i = 0; $i < $p->{ptr}; $i++) { + print F "*"; + } + print F " $p->{name}"; + } + print F ")\n"; + print F "{\n"; + print F "${i1}const char* const sqlFunction = \"$f->{name}\";\n"; + print F "#ifndef auto_$name\n"; + print F "${i1}Ctx ctx;\n"; + print F "${i1}ctx.log(1, \"*** not implemented: %s\", sqlFunction);\n"; + print F "${i1}return SQL_ERROR;\n"; + print F "#else\n"; + my @ihandle = (); + my @ohandle = (); + for my $p (@{$f->{param}}) { + if ($p->{type} =~ /^SQLH(ENV|DBC|STMT|DESC)$/) { + $p->{btype} = lc $1; + my $h = ! $p->{ptr} ? \@ihandle : \@ohandle; + push(@$h, $p); + } + } + if (! @ihandle) { # use root handle instance + push(@ihandle, { + type => 'SQLHROOT', + name => '(SQLHANDLE*)0', + }); + } + for my $p (@ihandle, @ohandle) { + $p->{htype} = "Handle" . (ucfirst lc $p->{btype}); + $p->{hname} = "p" . (ucfirst lc $p->{btype}); + } + if (@ihandle) { + print F "${i1}HandleRoot* const pRoot = HandleRoot::instance();\n"; + } + for my $p (@ihandle) { + print F "${i1}$p->{htype}* $p->{hname} = "; + print F "pRoot->find" . ucfirst($p->{btype}). "($p->{name});\n"; + print F "${i1}if ($p->{hname} == 0)\n"; + print F "${i2}return SQL_INVALID_HANDLE;\n"; + } + { + my $p = $ihandle[0]; + print F "${i1}Ctx& ctx = $p->{hname}->initCtx();\n"; + print F "${i1}ctx.logSqlEnter(sqlFunction);\n"; + } + for my $p (@ohandle) { + print F "${i1}$p->{htype}* $p->{hname} = 0;\n"; + } + { + my $p = $ihandle[0]; + my $fname = $f->{name}; + $fname =~ s/^SQL/sql/; # keep sql prefix + print F "${i1}if (ctx.ok())\n"; + print F "${i2}$p->{hname}->$fname(\n"; + print F "${i3}ctx"; + } + for my $p (@{$f->{param}}) { + if ($p == $ihandle[0]) { + next; + } + print F ","; + print F "\n${i3}"; + if (grep($_ == $p, @ihandle)) { + print F "$p->{hname}"; + } elsif (grep($_ == $p, @ohandle)) { + print F "$p->{name} != 0 ? &$p->{hname} : 0"; + } else { + print F "&" if $p->{ptr} > 0; + print F "$p->{name}"; + } + } + print F "\n${i2});\n"; + for my $p (@ohandle) { + print F "${i1}if ($p->{name} != 0)\n"; + print F "${i2}*$p->{name} = "; + print F "pRoot->from" . ucfirst($p->{btype}) . "($p->{hname});\n"; + } + { + my $p = $ihandle[0]; + print F "${i1}$p->{hname}->saveCtx(ctx);\n"; + } + print F "${i1}ctx.logSqlExit();\n"; + print F "${i1}return ctx.getCode();\n"; + print F "#endif\n"; + print F "}\n"; + print F "#endif // $f->{odbcver}\n"; + close(F); + } + $action = undef; +} + +if ($action eq 'diff' || $action eq 'move') { + require './Func.data'; + for my $name (sort keys %$func) { + local $/ = undef; + my($x1, $x2); + if (open(F, "<$name.cpp")) { + $x1 = ; + close(F); + if ($x1 !~ /\bauto_$name\b/) { + warn "$name.cpp: not auto-generated\n" if $action eq 'move'; + next; + } + } + if (! open(F, "; + close(F); + if ($x1 eq $x2) { + warn "$name: no changes\n" if $action eq 'move'; + next; + } + if ($action eq 'diff') { + print "=" x 40, "\n"; + print "diff $name.cpp auto/", "\n"; + system("diff $name.cpp auto/$name.cpp"); + } else { + rename("auto/$name.cpp", "$name.cpp") + or die "rename $name: $!\n"; + warn "$name: updated\n" if 0; + } + } + $action = undef; +} + +if ($action eq 'functab') { + require './Func.data'; + for my $name (sort keys %$func) { + printf "%4s{%3s%-30s, 0 },\n", "", "", uc "SQL_API_$name"; + } + $action = undef; +} + +$action && die "$action: undefined\n"; + +# vim: set sw=4: diff --git a/ndb/src/client/odbc/driver/Makefile b/ndb/src/client/odbc/driver/Makefile new file mode 100644 index 00000000000..62f82371da4 --- /dev/null +++ b/ndb/src/client/odbc/driver/Makefile @@ -0,0 +1,16 @@ +include .defs.mk + +TYPE = * + +NONPIC_ARCHIVE = N + +PIC_ARCHIVE = Y + +ARCHIVE_TARGET = odbcdriver + +SOURCES = driver.cpp + +SOURCES_EXTRA = $(shell perl Func.pl name .cpp) + +include ../Extra.mk +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/client/odbc/driver/SQLAllocConnect.cpp b/ndb/src/client/odbc/driver/SQLAllocConnect.cpp new file mode 100644 index 00000000000..a7ffd8c89d1 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLAllocConnect.cpp @@ -0,0 +1,52 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLAllocConnect( + SQLHENV EnvironmentHandle, + SQLHDBC* ConnectionHandle) +{ + driver_enter(SQL_API_SQLALLOCCONNECT); + const char* const sqlFunction = "SQLAllocConnect"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleEnv* pEnv = pRoot->findEnv(EnvironmentHandle); + if (pEnv == 0) { + driver_exit(SQL_API_SQLALLOCCONNECT); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + HandleDbc* pDbc = 0; + HandleDbc** ppDbc = 0; + if (ConnectionHandle != 0) + ppDbc = &pDbc; + try { + pEnv->sqlAllocConnect(ctx, ppDbc); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + if (ConnectionHandle != 0) + *ConnectionHandle = static_cast(pDbc); + pEnv->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLALLOCCONNECT); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLAllocEnv.cpp b/ndb/src/client/odbc/driver/SQLAllocEnv.cpp new file mode 100644 index 00000000000..a62dae61008 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLAllocEnv.cpp @@ -0,0 +1,46 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLAllocEnv( + SQLHENV* EnvironmentHandle) +{ + driver_enter(SQL_API_SQLALLOCENV); + const char* const sqlFunction = "SQLAllocEnv"; + HandleRoot* const pRoot = HandleRoot::instance(); + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + HandleEnv* pEnv = 0; + HandleEnv** ppEnv = 0; + if (EnvironmentHandle != 0) + ppEnv = &pEnv; + try { + pRoot->sqlAllocEnv(ctx, ppEnv); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + if (EnvironmentHandle != 0) + *EnvironmentHandle = static_cast(pEnv); + pRoot->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLALLOCENV); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLAllocHandle.cpp b/ndb/src/client/odbc/driver/SQLAllocHandle.cpp new file mode 100644 index 00000000000..9daf6ead946 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLAllocHandle.cpp @@ -0,0 +1,62 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLAllocHandle( + SQLSMALLINT HandleType, + SQLHANDLE InputHandle, + SQLHANDLE* OutputHandle) +{ + driver_enter(SQL_API_SQLALLOCHANDLE); + const char* const sqlFunction = "SQLAllocHandle"; + HandleRoot* const pRoot = HandleRoot::instance(); + SQLSMALLINT parentType = pRoot->findParentType(HandleType); + if (parentType == -1) { + driver_exit(SQL_API_SQLALLOCHANDLE); + return SQL_INVALID_HANDLE; + } + HandleBase* pParent = pRoot->findBase(parentType, InputHandle); + if (pParent == 0) { + driver_exit(SQL_API_SQLALLOCHANDLE); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + HandleBase* pChild = 0; + HandleBase** ppChild = 0; + if (OutputHandle != 0) + ppChild = &pChild; + try { + pParent->sqlAllocHandle(ctx, HandleType, ppChild); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + if (OutputHandle != 0) + *OutputHandle = static_cast(pChild); + if (pRoot == pParent) + pRoot->lockHandle(); + pParent->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + if (pRoot == pParent) + pRoot->unlockHandle(); + driver_exit(SQL_API_SQLALLOCHANDLE); + return ret; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLAllocHandleStd.cpp b/ndb/src/client/odbc/driver/SQLAllocHandleStd.cpp new file mode 100644 index 00000000000..61290e37b7b --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLAllocHandleStd.cpp @@ -0,0 +1,56 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLAllocHandleStd( + SQLSMALLINT fHandleType, + SQLHANDLE hInput, + SQLHANDLE* phOutput) +{ +#ifndef auto_SQLAllocHandleStd + const char* const sqlFunction = "SQLAllocHandleStd"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLALLOCHANDLESTD); + const char* const sqlFunction = "SQLAllocHandleStd"; + HandleRoot* const pRoot = HandleRoot::instance(); + Handle* p = pRoot->find((SQLHANDLE*)0); + if (p == 0) { + driver_exit(SQL_API_SQLALLOCHANDLESTD); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + p->sqlAllocHandleStd( + ctx, + fHandleType, + hInput, + &phOutput + ); + p->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLALLOCHANDLESTD); + return ret; +#endif +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLAllocStmt.cpp b/ndb/src/client/odbc/driver/SQLAllocStmt.cpp new file mode 100644 index 00000000000..bf3f149f5de --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLAllocStmt.cpp @@ -0,0 +1,52 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLAllocStmt( + SQLHDBC ConnectionHandle, + SQLHSTMT* StatementHandle) +{ + driver_enter(SQL_API_SQLALLOCSTMT); + const char* const sqlFunction = "SQLAllocStmt"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDbc* pDbc = pRoot->findDbc(ConnectionHandle); + if (pDbc == 0) { + driver_exit(SQL_API_SQLALLOCSTMT); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + HandleStmt* pStmt = 0; + HandleStmt** ppStmt = 0; + if (StatementHandle != 0) + ppStmt = &pStmt; + try { + pDbc->sqlAllocStmt(ctx, ppStmt); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + if (StatementHandle != 0) + *StatementHandle = static_cast(pStmt); + pDbc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLALLOCSTMT); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLBindCol.cpp b/ndb/src/client/odbc/driver/SQLBindCol.cpp new file mode 100644 index 00000000000..5562334e8cc --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLBindCol.cpp @@ -0,0 +1,50 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLBindCol( + SQLHSTMT StatementHandle, + SQLUSMALLINT ColumnNumber, + SQLSMALLINT TargetType, + SQLPOINTER TargetValue, + SQLINTEGER BufferLength, + SQLINTEGER* StrLen_or_Ind) +{ + driver_enter(SQL_API_SQLBINDCOL); + const char* const sqlFunction = "SQLBindCol"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLBINDCOL); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlBindCol(ctx, ColumnNumber, TargetType, TargetValue, BufferLength, StrLen_or_Ind); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLBINDCOL); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLBindParam.cpp b/ndb/src/client/odbc/driver/SQLBindParam.cpp new file mode 100644 index 00000000000..2fcc17b872f --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLBindParam.cpp @@ -0,0 +1,52 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLBindParam( + SQLHSTMT StatementHandle, + SQLUSMALLINT ParameterNumber, + SQLSMALLINT ValueType, + SQLSMALLINT ParameterType, + SQLUINTEGER LengthPrecision, + SQLSMALLINT ParameterScale, + SQLPOINTER ParameterValue, + SQLINTEGER* StrLen_or_Ind) +{ + driver_enter(SQL_API_SQLBINDPARAM); + const char* const sqlFunction = "SQLBindParam"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLBINDPARAM); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlBindParam(ctx, ParameterNumber, ValueType, ParameterType, LengthPrecision, ParameterScale, ParameterValue, StrLen_or_Ind); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLBINDPARAM); + return ret; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLBindParameter.cpp b/ndb/src/client/odbc/driver/SQLBindParameter.cpp new file mode 100644 index 00000000000..e4ca5bbc731 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLBindParameter.cpp @@ -0,0 +1,54 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLBindParameter( + SQLHSTMT hstmt, + SQLUSMALLINT ipar, + SQLSMALLINT fParamType, + SQLSMALLINT fCType, + SQLSMALLINT fSqlType, + SQLUINTEGER cbColDef, + SQLSMALLINT ibScale, + SQLPOINTER rgbValue, + SQLINTEGER cbValueMax, + SQLINTEGER* pcbValue) +{ + driver_enter(SQL_API_SQLBINDPARAMETER); + const char* const sqlFunction = "SQLBindParameter"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(hstmt); + if (pStmt == 0) { + driver_exit(SQL_API_SQLBINDPARAMETER); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlBindParameter(ctx, ipar, fParamType, fCType, fSqlType, cbColDef, ibScale, rgbValue, cbValueMax, pcbValue); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLBINDPARAMETER); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLBrowseConnect.cpp b/ndb/src/client/odbc/driver/SQLBrowseConnect.cpp new file mode 100644 index 00000000000..7e629e199e5 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLBrowseConnect.cpp @@ -0,0 +1,61 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLBrowseConnect( + SQLHDBC hdbc, + SQLCHAR* szConnStrIn, + SQLSMALLINT cbConnStrIn, + SQLCHAR* szConnStrOut, + SQLSMALLINT cbConnStrOutMax, + SQLSMALLINT* pcbConnStrOut) +{ +#ifndef auto_SQLBrowseConnect + const char* const sqlFunction = "SQLBrowseConnect"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLBROWSECONNECT); + const char* const sqlFunction = "SQLBrowseConnect"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDbc* pDbc = pRoot->findDbc(hdbc); + if (pDbc == 0) { + driver_exit(SQL_API_SQLBROWSECONNECT); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pDbc->sqlBrowseConnect( + ctx, + &szConnStrIn, + cbConnStrIn, + &szConnStrOut, + cbConnStrOutMax, + &pcbConnStrOut + ); + pDbc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLBROWSECONNECT); + return ret; +#endif +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLBulkOperations.cpp b/ndb/src/client/odbc/driver/SQLBulkOperations.cpp new file mode 100644 index 00000000000..7d256d66e3f --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLBulkOperations.cpp @@ -0,0 +1,53 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLBulkOperations( + SQLHSTMT StatementHandle, + SQLSMALLINT Operation) +{ +#ifndef auto_SQLBulkOperations + const char* const sqlFunction = "SQLBulkOperations"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLBULKOPERATIONS); + const char* const sqlFunction = "SQLBulkOperations"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLBULKOPERATIONS); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pStmt->sqlBulkOperations( + ctx, + Operation + ); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLBULKOPERATIONS); + return ret; +#endif +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLCancel.cpp b/ndb/src/client/odbc/driver/SQLCancel.cpp new file mode 100644 index 00000000000..ac4e43c6e89 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLCancel.cpp @@ -0,0 +1,45 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLCancel( + SQLHSTMT StatementHandle) +{ + driver_enter(SQL_API_SQLCANCEL); + const char* const sqlFunction = "SQLCancel"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLCANCEL); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlCancel(ctx); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLCANCEL); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLCloseCursor.cpp b/ndb/src/client/odbc/driver/SQLCloseCursor.cpp new file mode 100644 index 00000000000..26d88c91e3b --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLCloseCursor.cpp @@ -0,0 +1,45 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLCloseCursor( + SQLHSTMT StatementHandle) +{ + driver_enter(SQL_API_SQLCLOSECURSOR); + const char* const sqlFunction = "SQLCloseCursor"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLCLOSECURSOR); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlCloseCursor(ctx); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLCLOSECURSOR); + return ret; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLColAttribute.cpp b/ndb/src/client/odbc/driver/SQLColAttribute.cpp new file mode 100644 index 00000000000..0e7e5446932 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLColAttribute.cpp @@ -0,0 +1,51 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLColAttribute( + SQLHSTMT StatementHandle, + SQLUSMALLINT ColumnNumber, + SQLUSMALLINT FieldIdentifier, + SQLPOINTER CharacterAttribute, + SQLSMALLINT BufferLength, + SQLSMALLINT* StringLength, + SQLPOINTER NumericAttribute) +{ + driver_enter(SQL_API_SQLCOLATTRIBUTE); + const char* const sqlFunction = "SQLColAttribute"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLCOLATTRIBUTE); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlColAttribute(ctx, ColumnNumber, FieldIdentifier, CharacterAttribute, BufferLength, StringLength, NumericAttribute); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLCOLATTRIBUTE); + return ret; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLColAttributes.cpp b/ndb/src/client/odbc/driver/SQLColAttributes.cpp new file mode 100644 index 00000000000..05a4c1d4d37 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLColAttributes.cpp @@ -0,0 +1,51 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLColAttributes( + SQLHSTMT hstmt, + SQLUSMALLINT icol, + SQLUSMALLINT fDescType, + SQLPOINTER rgbDesc, + SQLSMALLINT cbDescMax, + SQLSMALLINT* pcbDesc, + SQLINTEGER* pfDesc) +{ + driver_enter(SQL_API_SQLCOLATTRIBUTES); + const char* const sqlFunction = "SQLColAttributes"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(hstmt); + if (pStmt == 0) { + driver_exit(SQL_API_SQLCOLATTRIBUTES); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlColAttributes(ctx, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLCOLATTRIBUTES); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLColumnPrivileges.cpp b/ndb/src/client/odbc/driver/SQLColumnPrivileges.cpp new file mode 100644 index 00000000000..cfbc9c2bc57 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLColumnPrivileges.cpp @@ -0,0 +1,67 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLColumnPrivileges( + SQLHSTMT hstmt, + SQLCHAR* szCatalogName, + SQLSMALLINT cbCatalogName, + SQLCHAR* szSchemaName, + SQLSMALLINT cbSchemaName, + SQLCHAR* szTableName, + SQLSMALLINT cbTableName, + SQLCHAR* szColumnName, + SQLSMALLINT cbColumnName) +{ +#ifndef auto_SQLColumnPrivileges + const char* const sqlFunction = "SQLColumnPrivileges"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLCOLUMNPRIVILEGES); + const char* const sqlFunction = "SQLColumnPrivileges"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(hstmt); + if (pStmt == 0) { + driver_exit(SQL_API_SQLCOLUMNPRIVILEGES); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pStmt->sqlColumnPrivileges( + ctx, + &szCatalogName, + cbCatalogName, + &szSchemaName, + cbSchemaName, + &szTableName, + cbTableName, + &szColumnName, + cbColumnName + ); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLCOLUMNPRIVILEGES); + return ret; +#endif +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLColumns.cpp b/ndb/src/client/odbc/driver/SQLColumns.cpp new file mode 100644 index 00000000000..4e0b646ee7d --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLColumns.cpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLColumns( + SQLHSTMT StatementHandle, + SQLCHAR* CatalogName, + SQLSMALLINT NameLength1, + SQLCHAR* SchemaName, + SQLSMALLINT NameLength2, + SQLCHAR* TableName, + SQLSMALLINT NameLength3, + SQLCHAR* ColumnName, + SQLSMALLINT NameLength4) +{ + driver_enter(SQL_API_SQLCOLUMNS); + const char* const sqlFunction = "SQLColumns"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLCOLUMNS); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + pStmt->sqlColumns(ctx, CatalogName, NameLength1, SchemaName, NameLength2, TableName, NameLength3, ColumnName, NameLength4); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLCOLUMNS); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLConnect.cpp b/ndb/src/client/odbc/driver/SQLConnect.cpp new file mode 100644 index 00000000000..d8f30ed47e7 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLConnect.cpp @@ -0,0 +1,51 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLConnect( + SQLHDBC ConnectionHandle, + SQLCHAR* ServerName, + SQLSMALLINT NameLength1, + SQLCHAR* UserName, + SQLSMALLINT NameLength2, + SQLCHAR* Authentication, + SQLSMALLINT NameLength3) +{ + driver_enter(SQL_API_SQLCONNECT); + const char* const sqlFunction = "SQLConnect"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDbc* pDbc = pRoot->findDbc(ConnectionHandle); + if (pDbc == 0) { + driver_exit(SQL_API_SQLCONNECT); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pDbc->sqlConnect(ctx, ServerName, NameLength1, UserName, NameLength2, Authentication, NameLength3); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pDbc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLCONNECT); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLCopyDesc.cpp b/ndb/src/client/odbc/driver/SQLCopyDesc.cpp new file mode 100644 index 00000000000..b4d4b2e4122 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLCopyDesc.cpp @@ -0,0 +1,58 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLCopyDesc( + SQLHDESC SourceDescHandle, + SQLHDESC TargetDescHandle) +{ +#ifndef auto_SQLCopyDesc + const char* const sqlFunction = "SQLCopyDesc"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLCOPYDESC); + const char* const sqlFunction = "SQLCopyDesc"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDesc* pDesc = pRoot->findDesc(SourceDescHandle); + if (pDesc == 0) { + driver_exit(SQL_API_SQLCOPYDESC); + return SQL_INVALID_HANDLE; + } + HandleDesc* pDesc = pRoot->findDesc(TargetDescHandle); + if (pDesc == 0) { + driver_exit(SQL_API_SQLCOPYDESC); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pDesc->sqlCopyDesc( + ctx, + pDesc + ); + pDesc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLCOPYDESC); + return ret; +#endif +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLDataSources.cpp b/ndb/src/client/odbc/driver/SQLDataSources.cpp new file mode 100644 index 00000000000..6115e7175f9 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLDataSources.cpp @@ -0,0 +1,65 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLDataSources( + SQLHENV EnvironmentHandle, + SQLUSMALLINT Direction, + SQLCHAR* ServerName, + SQLSMALLINT BufferLength1, + SQLSMALLINT* NameLength1, + SQLCHAR* Description, + SQLSMALLINT BufferLength2, + SQLSMALLINT* NameLength2) +{ +#ifndef auto_SQLDataSources + const char* const sqlFunction = "SQLDataSources"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLDATASOURCES); + const char* const sqlFunction = "SQLDataSources"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleEnv* pEnv = pRoot->findEnv(EnvironmentHandle); + if (pEnv == 0) { + driver_exit(SQL_API_SQLDATASOURCES); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pEnv->sqlDataSources( + ctx, + Direction, + &ServerName, + BufferLength1, + &NameLength1, + &Description, + BufferLength2, + &NameLength2 + ); + pEnv->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLDATASOURCES); + return ret; +#endif +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLDescribeCol.cpp b/ndb/src/client/odbc/driver/SQLDescribeCol.cpp new file mode 100644 index 00000000000..f15ce8962f1 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLDescribeCol.cpp @@ -0,0 +1,53 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLDescribeCol( + SQLHSTMT StatementHandle, + SQLUSMALLINT ColumnNumber, + SQLCHAR* ColumnName, + SQLSMALLINT BufferLength, + SQLSMALLINT* NameLength, + SQLSMALLINT* DataType, + SQLUINTEGER* ColumnSize, + SQLSMALLINT* DecimalDigits, + SQLSMALLINT* Nullable) +{ + driver_enter(SQL_API_SQLDESCRIBECOL); + const char* const sqlFunction = "SQLDescribeCol"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLDESCRIBECOL); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlDescribeCol(ctx, ColumnNumber, ColumnName, BufferLength, NameLength, DataType, ColumnSize, DecimalDigits, Nullable); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLDESCRIBECOL); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLDescribeParam.cpp b/ndb/src/client/odbc/driver/SQLDescribeParam.cpp new file mode 100644 index 00000000000..beff41396fe --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLDescribeParam.cpp @@ -0,0 +1,50 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLDescribeParam( + SQLHSTMT hstmt, + SQLUSMALLINT ipar, + SQLSMALLINT* pfSqlType, + SQLUINTEGER* pcbParamDef, + SQLSMALLINT* pibScale, + SQLSMALLINT* pfNullable) +{ + driver_enter(SQL_API_SQLDESCRIBEPARAM); + const char* const sqlFunction = "SQLDescribeParam"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(hstmt); + if (pStmt == 0) { + driver_exit(SQL_API_SQLDESCRIBEPARAM); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlDescribeParam(ctx, ipar, pfSqlType, pcbParamDef, pibScale, pfNullable); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLDESCRIBEPARAM); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLDisconnect.cpp b/ndb/src/client/odbc/driver/SQLDisconnect.cpp new file mode 100644 index 00000000000..75db5604da8 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLDisconnect.cpp @@ -0,0 +1,45 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLDisconnect( + SQLHDBC ConnectionHandle) +{ + driver_enter(SQL_API_SQLDISCONNECT); + const char* const sqlFunction = "SQLDisconnect"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDbc* pDbc = pRoot->findDbc(ConnectionHandle); + if (pDbc == 0) { + driver_exit(SQL_API_SQLDISCONNECT); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pDbc->sqlDisconnect(ctx); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pDbc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLDISCONNECT); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLDriverConnect.cpp b/ndb/src/client/odbc/driver/SQLDriverConnect.cpp new file mode 100644 index 00000000000..340babd8523 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLDriverConnect.cpp @@ -0,0 +1,52 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLDriverConnect( + SQLHDBC hdbc, + SQLHWND hwnd, + SQLCHAR* szConnStrIn, + SQLSMALLINT cbConnStrIn, + SQLCHAR* szConnStrOut, + SQLSMALLINT cbConnStrOutMax, + SQLSMALLINT* pcbConnStrOut, + SQLUSMALLINT fDriverCompletion) +{ + driver_enter(SQL_API_SQLDRIVERCONNECT); + const char* const sqlFunction = "SQLDriverConnect"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDbc* pDbc = pRoot->findDbc(hdbc); + if (pDbc == 0) { + driver_exit(SQL_API_SQLDRIVERCONNECT); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pDbc->sqlDriverConnect(ctx, hwnd, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut, fDriverCompletion); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pDbc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLDRIVERCONNECT); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLDrivers.cpp b/ndb/src/client/odbc/driver/SQLDrivers.cpp new file mode 100644 index 00000000000..9c52f900992 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLDrivers.cpp @@ -0,0 +1,65 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLDrivers( + SQLHENV henv, + SQLUSMALLINT fDirection, + SQLCHAR* szDriverDesc, + SQLSMALLINT cbDriverDescMax, + SQLSMALLINT* pcbDriverDesc, + SQLCHAR* szDriverAttributes, + SQLSMALLINT cbDrvrAttrMax, + SQLSMALLINT* pcbDrvrAttr) +{ +#ifndef auto_SQLDrivers + const char* const sqlFunction = "SQLDrivers"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLDRIVERS); + const char* const sqlFunction = "SQLDrivers"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleEnv* pEnv = pRoot->findEnv(henv); + if (pEnv == 0) { + driver_exit(SQL_API_SQLDRIVERS); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pEnv->sqlDrivers( + ctx, + fDirection, + &szDriverDesc, + cbDriverDescMax, + &pcbDriverDesc, + &szDriverAttributes, + cbDrvrAttrMax, + &pcbDrvrAttr + ); + pEnv->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLDRIVERS); + return ret; +#endif +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLEndTran.cpp b/ndb/src/client/odbc/driver/SQLEndTran.cpp new file mode 100644 index 00000000000..20b0b2203f5 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLEndTran.cpp @@ -0,0 +1,70 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLEndTran( + SQLSMALLINT HandleType, + SQLHANDLE Handle, + SQLSMALLINT CompletionType) +{ + driver_enter(SQL_API_SQLENDTRAN); + const char* const sqlFunction = "SQLEndTran"; + HandleRoot* const pRoot = HandleRoot::instance(); + if (HandleType == SQL_HANDLE_DBC) { + HandleDbc* pDbc = pRoot->findDbc(Handle); + if (pDbc == 0) { + driver_exit(SQL_API_SQLENDTRAN); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pDbc->sqlEndTran(ctx, CompletionType); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pDbc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLENDTRAN); + return ret; + } + if (HandleType == SQL_HANDLE_ENV) { + HandleEnv* pEnv = pRoot->findEnv(Handle); + if (pEnv == 0) { + driver_exit(SQL_API_SQLENDTRAN); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pEnv->sqlEndTran(ctx, CompletionType); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pEnv->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLENDTRAN); + return ret; + } + driver_exit(SQL_API_SQLENDTRAN); + return SQL_INVALID_HANDLE; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLError.cpp b/ndb/src/client/odbc/driver/SQLError.cpp new file mode 100644 index 00000000000..af78c931d37 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLError.cpp @@ -0,0 +1,67 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLError( + SQLHENV EnvironmentHandle, + SQLHDBC ConnectionHandle, + SQLHSTMT StatementHandle, + SQLCHAR* Sqlstate, + SQLINTEGER* NativeError, + SQLCHAR* MessageText, + SQLSMALLINT BufferLength, + SQLSMALLINT* TextLength) +{ + driver_enter(SQL_API_SQLERROR); + const char* const sqlFunction = "SQLError"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleEnv* pEnv = pRoot->findEnv(EnvironmentHandle); + HandleDbc* pDbc = pRoot->findDbc(ConnectionHandle); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0 && pDbc == 0 && pEnv == 0) { + driver_exit(SQL_API_SQLERROR); + return SQL_INVALID_HANDLE; + } + Ctx ctx; // discard diagnostics + ctx.logSqlEnter(sqlFunction); + if (pStmt != 0) { + try { + pStmt->sqlError(ctx, Sqlstate, NativeError, MessageText, BufferLength, TextLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + } else if (pDbc != 0) { + try { + pDbc->sqlError(ctx, Sqlstate, NativeError, MessageText, BufferLength, TextLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + } else { + try { + pEnv->sqlError(ctx, Sqlstate, NativeError, MessageText, BufferLength, TextLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + } + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLERROR); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLExecDirect.cpp b/ndb/src/client/odbc/driver/SQLExecDirect.cpp new file mode 100644 index 00000000000..0ad99d29cd9 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLExecDirect.cpp @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLExecDirect( + SQLHSTMT StatementHandle, + SQLCHAR* StatementText, + SQLINTEGER TextLength) +{ + driver_enter(SQL_API_SQLEXECDIRECT); + const char* const sqlFunction = "SQLExecDirect"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLEXECDIRECT); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlExecDirect(ctx, StatementText, TextLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLEXECDIRECT); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLExecute.cpp b/ndb/src/client/odbc/driver/SQLExecute.cpp new file mode 100644 index 00000000000..9c30d418f09 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLExecute.cpp @@ -0,0 +1,45 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLExecute( + SQLHSTMT StatementHandle) +{ + driver_enter(SQL_API_SQLEXECUTE); + const char* const sqlFunction = "SQLExecute"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLEXECUTE); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlExecute(ctx); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLEXECUTE); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLExtendedFetch.cpp b/ndb/src/client/odbc/driver/SQLExtendedFetch.cpp new file mode 100644 index 00000000000..e0dd078b5d0 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLExtendedFetch.cpp @@ -0,0 +1,59 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLExtendedFetch( + SQLHSTMT hstmt, + SQLUSMALLINT fFetchType, + SQLINTEGER irow, + SQLUINTEGER* pcrow, + SQLUSMALLINT* rgfRowStatus) +{ +#ifndef auto_SQLExtendedFetch + const char* const sqlFunction = "SQLExtendedFetch"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLEXTENDEDFETCH); + const char* const sqlFunction = "SQLExtendedFetch"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(hstmt); + if (pStmt == 0) { + driver_exit(SQL_API_SQLEXTENDEDFETCH); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pStmt->sqlExtendedFetch( + ctx, + fFetchType, + irow, + &pcrow, + &rgfRowStatus + ); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLEXTENDEDFETCH); + return ret; +#endif +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLFetch.cpp b/ndb/src/client/odbc/driver/SQLFetch.cpp new file mode 100644 index 00000000000..addba7b998c --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLFetch.cpp @@ -0,0 +1,45 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLFetch( + SQLHSTMT StatementHandle) +{ + driver_enter(SQL_API_SQLFETCH); + const char* const sqlFunction = "SQLFetch"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLFETCH); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlFetch(ctx); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLFETCH); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLFetchScroll.cpp b/ndb/src/client/odbc/driver/SQLFetchScroll.cpp new file mode 100644 index 00000000000..cfbfc813fca --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLFetchScroll.cpp @@ -0,0 +1,55 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLFetchScroll( + SQLHSTMT StatementHandle, + SQLSMALLINT FetchOrientation, + SQLINTEGER FetchOffset) +{ +#ifndef auto_SQLFetchScroll + const char* const sqlFunction = "SQLFetchScroll"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLFETCHSCROLL); + const char* const sqlFunction = "SQLFetchScroll"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLFETCHSCROLL); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pStmt->sqlFetchScroll( + ctx, + FetchOrientation, + FetchOffset + ); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLFETCHSCROLL); + return ret; +#endif +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLForeignKeys.cpp b/ndb/src/client/odbc/driver/SQLForeignKeys.cpp new file mode 100644 index 00000000000..886ac6bdaa5 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLForeignKeys.cpp @@ -0,0 +1,75 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLForeignKeys( + SQLHSTMT hstmt, + SQLCHAR* szPkCatalogName, + SQLSMALLINT cbPkCatalogName, + SQLCHAR* szPkSchemaName, + SQLSMALLINT cbPkSchemaName, + SQLCHAR* szPkTableName, + SQLSMALLINT cbPkTableName, + SQLCHAR* szFkCatalogName, + SQLSMALLINT cbFkCatalogName, + SQLCHAR* szFkSchemaName, + SQLSMALLINT cbFkSchemaName, + SQLCHAR* szFkTableName, + SQLSMALLINT cbFkTableName) +{ +#ifndef auto_SQLForeignKeys + const char* const sqlFunction = "SQLForeignKeys"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLFOREIGNKEYS); + const char* const sqlFunction = "SQLForeignKeys"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(hstmt); + if (pStmt == 0) { + driver_exit(SQL_API_SQLFOREIGNKEYS); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pStmt->sqlForeignKeys( + ctx, + &szPkCatalogName, + cbPkCatalogName, + &szPkSchemaName, + cbPkSchemaName, + &szPkTableName, + cbPkTableName, + &szFkCatalogName, + cbFkCatalogName, + &szFkSchemaName, + cbFkSchemaName, + &szFkTableName, + cbFkTableName + ); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLFOREIGNKEYS); + return ret; +#endif +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLFreeConnect.cpp b/ndb/src/client/odbc/driver/SQLFreeConnect.cpp new file mode 100644 index 00000000000..9ac84710cce --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLFreeConnect.cpp @@ -0,0 +1,53 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLFreeConnect( + SQLHDBC ConnectionHandle) +{ + driver_enter(SQL_API_SQLFREECONNECT); + const char* const sqlFunction = "SQLFreeConnect"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDbc* pDbc = pRoot->findDbc(ConnectionHandle); + if (pDbc == 0) { + driver_exit(SQL_API_SQLFREECONNECT); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + HandleEnv* pEnv = pDbc->getEnv(); + try { + pEnv->sqlFreeConnect(ctx, pDbc); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + if (! ctx.ok()) { + pDbc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLFREECONNECT); + return ret; + } + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + delete &ctx; + driver_exit(SQL_API_SQLFREECONNECT); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLFreeEnv.cpp b/ndb/src/client/odbc/driver/SQLFreeEnv.cpp new file mode 100644 index 00000000000..7e35056feb5 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLFreeEnv.cpp @@ -0,0 +1,52 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLFreeEnv( + SQLHENV EnvironmentHandle) +{ + driver_enter(SQL_API_SQLFREEENV); + const char* const sqlFunction = "SQLFreeEnv"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleEnv* pEnv = pRoot->findEnv(EnvironmentHandle); + if (pEnv == 0) { + driver_exit(SQL_API_SQLFREEENV); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pRoot->sqlFreeEnv(ctx, pEnv); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + if (! ctx.ok()) { + pEnv->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLFREEENV); + return ret; + } + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + delete &ctx; + driver_exit(SQL_API_SQLFREEENV); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLFreeHandle.cpp b/ndb/src/client/odbc/driver/SQLFreeHandle.cpp new file mode 100644 index 00000000000..284463cbb07 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLFreeHandle.cpp @@ -0,0 +1,60 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLFreeHandle( + SQLSMALLINT HandleType, + SQLHANDLE Handle) +{ + driver_enter(SQL_API_SQLFREEHANDLE); + const char* const sqlFunction = "SQLFreeHandle"; + HandleRoot* const pRoot = HandleRoot::instance(); + SQLSMALLINT parentType = pRoot->findParentType(HandleType); + if (parentType == -1) { + driver_exit(SQL_API_SQLFREEHANDLE); + return SQL_INVALID_HANDLE; + } + HandleBase* pChild = pRoot->findBase(HandleType, Handle); + if (pChild == 0) { + driver_exit(SQL_API_SQLFREEHANDLE); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + HandleBase* pParent = pChild->getParent(); + ctx_assert(pParent != 0); + try { + pParent->sqlFreeHandle(ctx, HandleType, pChild); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + if (! ctx.ok()) { + pChild->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLFREEHANDLE); + return ret; + } + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + delete &ctx; + driver_exit(SQL_API_SQLFREEHANDLE); + return ret; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLFreeStmt.cpp b/ndb/src/client/odbc/driver/SQLFreeStmt.cpp new file mode 100644 index 00000000000..7af6623a37a --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLFreeStmt.cpp @@ -0,0 +1,54 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLFreeStmt( + SQLHSTMT StatementHandle, + SQLUSMALLINT Option) +{ + driver_enter(SQL_API_SQLFREESTMT); + const char* const sqlFunction = "SQLFreeStmt"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLFREESTMT); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + HandleDbc* pDbc = pStmt->getDbc(); + try { + pDbc->sqlFreeStmt(ctx, pStmt, Option); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + if (! ctx.ok() || Option != SQL_DROP) { + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLFREESTMT); + return ret; + } + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + delete &ctx; + driver_exit(SQL_API_SQLFREESTMT); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLGetConnectAttr.cpp b/ndb/src/client/odbc/driver/SQLGetConnectAttr.cpp new file mode 100644 index 00000000000..66c1f3827e1 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLGetConnectAttr.cpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLGetConnectAttr( + SQLHDBC ConnectionHandle, + SQLINTEGER Attribute, + SQLPOINTER Value, + SQLINTEGER BufferLength, + SQLINTEGER* StringLength) +{ + driver_enter(SQL_API_SQLGETCONNECTATTR); + const char* const sqlFunction = "SQLGetConnectAttr"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDbc* pDbc = pRoot->findDbc(ConnectionHandle); + if (pDbc == 0) { + driver_exit(SQL_API_SQLGETCONNECTATTR); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pDbc->sqlGetConnectAttr(ctx, Attribute, Value, BufferLength, StringLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pDbc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLGETCONNECTATTR); + return ret; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLGetConnectOption.cpp b/ndb/src/client/odbc/driver/SQLGetConnectOption.cpp new file mode 100644 index 00000000000..514bedb12b9 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLGetConnectOption.cpp @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLGetConnectOption( + SQLHDBC ConnectionHandle, + SQLUSMALLINT Option, + SQLPOINTER Value) +{ + driver_enter(SQL_API_SQLGETCONNECTOPTION); + const char* const sqlFunction = "SQLGetConnectOption"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDbc* pDbc = pRoot->findDbc(ConnectionHandle); + if (pDbc == 0) { + driver_exit(SQL_API_SQLGETCONNECTOPTION); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pDbc->sqlGetConnectOption(ctx, Option, Value); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pDbc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLGETCONNECTOPTION); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLGetCursorName.cpp b/ndb/src/client/odbc/driver/SQLGetCursorName.cpp new file mode 100644 index 00000000000..d54bdf42005 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLGetCursorName.cpp @@ -0,0 +1,48 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLGetCursorName( + SQLHSTMT StatementHandle, + SQLCHAR* CursorName, + SQLSMALLINT BufferLength, + SQLSMALLINT* NameLength) +{ + driver_enter(SQL_API_SQLGETCURSORNAME); + const char* const sqlFunction = "SQLGetCursorName"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLGETCURSORNAME); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlGetCursorName(ctx, CursorName, BufferLength, NameLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLGETCURSORNAME); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLGetData.cpp b/ndb/src/client/odbc/driver/SQLGetData.cpp new file mode 100644 index 00000000000..3b6987c515d --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLGetData.cpp @@ -0,0 +1,50 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLGetData( + SQLHSTMT StatementHandle, + SQLUSMALLINT ColumnNumber, + SQLSMALLINT TargetType, + SQLPOINTER TargetValue, + SQLINTEGER BufferLength, + SQLINTEGER* StrLen_or_Ind) +{ + driver_enter(SQL_API_SQLGETDATA); + const char* const sqlFunction = "SQLGetData"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLGETDATA); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlGetData(ctx, ColumnNumber, TargetType, TargetValue, BufferLength, StrLen_or_Ind); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLGETDATA); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLGetDescField.cpp b/ndb/src/client/odbc/driver/SQLGetDescField.cpp new file mode 100644 index 00000000000..6cc390a58ed --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLGetDescField.cpp @@ -0,0 +1,50 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLGetDescField( + SQLHDESC DescriptorHandle, + SQLSMALLINT RecNumber, + SQLSMALLINT FieldIdentifier, + SQLPOINTER Value, + SQLINTEGER BufferLength, + SQLINTEGER* StringLength) +{ + driver_enter(SQL_API_SQLGETDESCFIELD); + const char* const sqlFunction = "SQLGetDescField"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDesc* pDesc = pRoot->findDesc(DescriptorHandle); + if (pDesc == 0) { + driver_exit(SQL_API_SQLGETDESCFIELD); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pDesc->sqlGetDescField(ctx, RecNumber, FieldIdentifier, Value, BufferLength, StringLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pDesc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLGETDESCFIELD); + return ret; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLGetDescRec.cpp b/ndb/src/client/odbc/driver/SQLGetDescRec.cpp new file mode 100644 index 00000000000..c7e9631b075 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLGetDescRec.cpp @@ -0,0 +1,55 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLGetDescRec( + SQLHDESC DescriptorHandle, + SQLSMALLINT RecNumber, + SQLCHAR* Name, + SQLSMALLINT BufferLength, + SQLSMALLINT* StringLength, + SQLSMALLINT* Type, + SQLSMALLINT* SubType, + SQLINTEGER* Length, + SQLSMALLINT* Precision, + SQLSMALLINT* Scale, + SQLSMALLINT* Nullable) +{ + driver_enter(SQL_API_SQLGETDESCREC); + const char* const sqlFunction = "SQLGetDescRec"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDesc* pDesc = pRoot->findDesc(DescriptorHandle); + if (pDesc == 0) { + driver_exit(SQL_API_SQLGETDESCREC); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pDesc->sqlGetDescRec(ctx, RecNumber, Name, BufferLength, StringLength, Type, SubType, Length, Precision, Scale, Nullable); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pDesc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLGETDESCREC); + return ret; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLGetDiagField.cpp b/ndb/src/client/odbc/driver/SQLGetDiagField.cpp new file mode 100644 index 00000000000..3eb34f7ebf6 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLGetDiagField.cpp @@ -0,0 +1,50 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLGetDiagField( + SQLSMALLINT HandleType, + SQLHANDLE Handle, + SQLSMALLINT RecNumber, + SQLSMALLINT DiagIdentifier, + SQLPOINTER DiagInfo, + SQLSMALLINT BufferLength, + SQLSMALLINT* StringLength) +{ + driver_enter(SQL_API_SQLGETDIAGFIELD); + const char* const sqlFunction = "SQLGetDiagField"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleBase* pBase = pRoot->findBase(HandleType, Handle); + if (pBase == 0) { + driver_exit(SQL_API_SQLGETDIAGFIELD); + return SQL_INVALID_HANDLE; + } + Ctx ctx; // discard diagnostics + ctx.logSqlEnter(sqlFunction); + try { + pBase->sqlGetDiagField(ctx, RecNumber, DiagIdentifier, DiagInfo, BufferLength, StringLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLGETDIAGFIELD); + return ret; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLGetDiagRec.cpp b/ndb/src/client/odbc/driver/SQLGetDiagRec.cpp new file mode 100644 index 00000000000..448c5206d76 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLGetDiagRec.cpp @@ -0,0 +1,51 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLGetDiagRec( + SQLSMALLINT HandleType, + SQLHANDLE Handle, + SQLSMALLINT RecNumber, + SQLCHAR* Sqlstate, + SQLINTEGER* NativeError, + SQLCHAR* MessageText, + SQLSMALLINT BufferLength, + SQLSMALLINT* TextLength) +{ + driver_enter(SQL_API_SQLGETDIAGREC); + const char* const sqlFunction = "SQLGetDiagRec"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleBase* pBase = pRoot->findBase(HandleType, Handle); + if (pBase == 0) { + driver_exit(SQL_API_SQLGETDIAGREC); + return SQL_INVALID_HANDLE; + } + Ctx ctx; // discard diagnostics + ctx.logSqlEnter(sqlFunction); + try { + pBase->sqlGetDiagRec(ctx, RecNumber, Sqlstate, NativeError, MessageText, BufferLength, TextLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLGETDIAGREC); + return ret; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLGetEnvAttr.cpp b/ndb/src/client/odbc/driver/SQLGetEnvAttr.cpp new file mode 100644 index 00000000000..c93870326e4 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLGetEnvAttr.cpp @@ -0,0 +1,66 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLGetEnvAttr( + SQLHENV EnvironmentHandle, + SQLINTEGER Attribute, + SQLPOINTER Value, + SQLINTEGER BufferLength, + SQLINTEGER* StringLength) +{ + driver_enter(SQL_API_SQLGETENVATTR); + const char* const sqlFunction = "SQLGetEnvAttr"; + HandleRoot* const pRoot = HandleRoot::instance(); + if (EnvironmentHandle == 0) { + // process-level attributes + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pRoot->sqlGetRootAttr(ctx, Attribute, Value, BufferLength, StringLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pRoot->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLGETENVATTR); + return ret; + } else { + HandleEnv* pEnv = pRoot->findEnv(EnvironmentHandle); + if (pEnv == 0) { + driver_exit(SQL_API_SQLGETENVATTR); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pEnv->sqlGetEnvAttr(ctx, Attribute, Value, BufferLength, StringLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pEnv->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLGETENVATTR); + return ret; + } + return SQL_ERROR; // not reached +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLGetFunctions.cpp b/ndb/src/client/odbc/driver/SQLGetFunctions.cpp new file mode 100644 index 00000000000..68416fab1a6 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLGetFunctions.cpp @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLGetFunctions( + SQLHDBC ConnectionHandle, + SQLUSMALLINT FunctionId, + SQLUSMALLINT* Supported) +{ + driver_enter(SQL_API_SQLGETFUNCTIONS); + const char* const sqlFunction = "SQLGetFunctions"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDbc* pDbc = pRoot->findDbc(ConnectionHandle); + if (pDbc == 0) { + driver_exit(SQL_API_SQLGETFUNCTIONS); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pDbc->sqlGetFunctions(ctx, FunctionId, Supported); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pDbc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLGETFUNCTIONS); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLGetInfo.cpp b/ndb/src/client/odbc/driver/SQLGetInfo.cpp new file mode 100644 index 00000000000..8f0a0d67cfa --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLGetInfo.cpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLGetInfo( + SQLHDBC ConnectionHandle, + SQLUSMALLINT InfoType, + SQLPOINTER InfoValue, + SQLSMALLINT BufferLength, + SQLSMALLINT* StringLength) +{ + driver_enter(SQL_API_SQLGETINFO); + const char* const sqlFunction = "SQLGetInfo"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDbc* pDbc = pRoot->findDbc(ConnectionHandle); + if (pDbc == 0) { + driver_exit(SQL_API_SQLGETINFO); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pDbc->sqlGetInfo(ctx, InfoType, InfoValue, BufferLength, StringLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pDbc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLGETINFO); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLGetStmtAttr.cpp b/ndb/src/client/odbc/driver/SQLGetStmtAttr.cpp new file mode 100644 index 00000000000..990ab68808a --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLGetStmtAttr.cpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLGetStmtAttr( + SQLHSTMT StatementHandle, + SQLINTEGER Attribute, + SQLPOINTER Value, + SQLINTEGER BufferLength, + SQLINTEGER* StringLength) +{ + driver_enter(SQL_API_SQLGETSTMTATTR); + const char* const sqlFunction = "SQLGetStmtAttr"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLGETSTMTATTR); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlGetStmtAttr(ctx, Attribute, Value, BufferLength, StringLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLGETSTMTATTR); + return ret; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLGetStmtOption.cpp b/ndb/src/client/odbc/driver/SQLGetStmtOption.cpp new file mode 100644 index 00000000000..0b5758b1212 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLGetStmtOption.cpp @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLGetStmtOption( + SQLHSTMT StatementHandle, + SQLUSMALLINT Option, + SQLPOINTER Value) +{ + driver_enter(SQL_API_SQLGETSTMTOPTION); + const char* const sqlFunction = "SQLGetStmtOption"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLGETSTMTOPTION); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlGetStmtOption(ctx, Option, Value); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLGETSTMTOPTION); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLGetTypeInfo.cpp b/ndb/src/client/odbc/driver/SQLGetTypeInfo.cpp new file mode 100644 index 00000000000..e6a016cc400 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLGetTypeInfo.cpp @@ -0,0 +1,46 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLGetTypeInfo( + SQLHSTMT StatementHandle, + SQLSMALLINT DataType) +{ + driver_enter(SQL_API_SQLGETTYPEINFO); + const char* const sqlFunction = "SQLGetTypeInfo"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLGETTYPEINFO); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlGetTypeInfo(ctx, DataType); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLGETTYPEINFO); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLMoreResults.cpp b/ndb/src/client/odbc/driver/SQLMoreResults.cpp new file mode 100644 index 00000000000..d23d653a319 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLMoreResults.cpp @@ -0,0 +1,42 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLMoreResults( + SQLHSTMT hstmt) +{ + driver_enter(SQL_API_SQLMORERESULTS); + const char* const sqlFunction = "SQLMoreResults"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(hstmt); + if (pStmt == 0) { + driver_exit(SQL_API_SQLMORERESULTS); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pStmt->sqlMoreResults(ctx); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLMORERESULTS); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLNativeSql.cpp b/ndb/src/client/odbc/driver/SQLNativeSql.cpp new file mode 100644 index 00000000000..fb8a9bbf3d9 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLNativeSql.cpp @@ -0,0 +1,61 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLNativeSql( + SQLHDBC hdbc, + SQLCHAR* szSqlStrIn, + SQLINTEGER cbSqlStrIn, + SQLCHAR* szSqlStr, + SQLINTEGER cbSqlStrMax, + SQLINTEGER* pcbSqlStr) +{ +#ifndef auto_SQLNativeSql + const char* const sqlFunction = "SQLNativeSql"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLNATIVESQL); + const char* const sqlFunction = "SQLNativeSql"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDbc* pDbc = pRoot->findDbc(hdbc); + if (pDbc == 0) { + driver_exit(SQL_API_SQLNATIVESQL); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pDbc->sqlNativeSql( + ctx, + &szSqlStrIn, + cbSqlStrIn, + &szSqlStr, + cbSqlStrMax, + &pcbSqlStr + ); + pDbc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLNATIVESQL); + return ret; +#endif +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLNumParams.cpp b/ndb/src/client/odbc/driver/SQLNumParams.cpp new file mode 100644 index 00000000000..7b1a6a07aec --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLNumParams.cpp @@ -0,0 +1,46 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLNumParams( + SQLHSTMT StatementHandle, + SQLSMALLINT* ParameterCountPtr) +{ + driver_enter(SQL_API_SQLNUMPARAMS); + const char* const sqlFunction = "SQLNumParams"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLNUMPARAMS); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlNumParams(ctx, ParameterCountPtr); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLNUMPARAMS); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLNumResultCols.cpp b/ndb/src/client/odbc/driver/SQLNumResultCols.cpp new file mode 100644 index 00000000000..2e70897a9a2 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLNumResultCols.cpp @@ -0,0 +1,46 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLNumResultCols( + SQLHSTMT StatementHandle, + SQLSMALLINT* ColumnCount) +{ + driver_enter(SQL_API_SQLNUMRESULTCOLS); + const char* const sqlFunction = "SQLNumResultCols"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLNUMRESULTCOLS); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlNumResultCols(ctx, ColumnCount); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLNUMRESULTCOLS); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLParamData.cpp b/ndb/src/client/odbc/driver/SQLParamData.cpp new file mode 100644 index 00000000000..4eb38a010f4 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLParamData.cpp @@ -0,0 +1,46 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLParamData( + SQLHSTMT StatementHandle, + SQLPOINTER* Value) +{ + driver_enter(SQL_API_SQLPARAMDATA); + const char* const sqlFunction = "SQLParamData"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLPARAMDATA); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlParamData(ctx, Value); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLPARAMDATA); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLParamOptions.cpp b/ndb/src/client/odbc/driver/SQLParamOptions.cpp new file mode 100644 index 00000000000..59b7dcf7fa9 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLParamOptions.cpp @@ -0,0 +1,55 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLParamOptions( + SQLHSTMT hstmt, + SQLUINTEGER crow, + SQLUINTEGER* pirow) +{ +#ifndef auto_SQLParamOptions + const char* const sqlFunction = "SQLParamOptions"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLPARAMOPTIONS); + const char* const sqlFunction = "SQLParamOptions"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(hstmt); + if (pStmt == 0) { + driver_exit(SQL_API_SQLPARAMOPTIONS); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pStmt->sqlParamOptions( + ctx, + crow, + &pirow + ); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLPARAMOPTIONS); + return ret; +#endif +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLPrepare.cpp b/ndb/src/client/odbc/driver/SQLPrepare.cpp new file mode 100644 index 00000000000..b1205fa6e3a --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLPrepare.cpp @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLPrepare( + SQLHSTMT StatementHandle, + SQLCHAR* StatementText, + SQLINTEGER TextLength) +{ + driver_enter(SQL_API_SQLPREPARE); + const char* const sqlFunction = "SQLPrepare"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLPREPARE); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlPrepare(ctx, StatementText, TextLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLPREPARE); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLPrimaryKeys.cpp b/ndb/src/client/odbc/driver/SQLPrimaryKeys.cpp new file mode 100644 index 00000000000..2d562ae3e19 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLPrimaryKeys.cpp @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLPrimaryKeys( + SQLHSTMT hstmt, + SQLCHAR* szCatalogName, + SQLSMALLINT cbCatalogName, + SQLCHAR* szSchemaName, + SQLSMALLINT cbSchemaName, + SQLCHAR* szTableName, + SQLSMALLINT cbTableName) +{ + driver_enter(SQL_API_SQLPRIMARYKEYS); + const char* const sqlFunction = "SQLPrimaryKeys"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(hstmt); + if (pStmt == 0) { + driver_exit(SQL_API_SQLPRIMARYKEYS); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + pStmt->sqlPrimaryKeys(ctx, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, szTableName, cbTableName); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLPRIMARYKEYS); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLProcedureColumns.cpp b/ndb/src/client/odbc/driver/SQLProcedureColumns.cpp new file mode 100644 index 00000000000..2e42e428b87 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLProcedureColumns.cpp @@ -0,0 +1,67 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLProcedureColumns( + SQLHSTMT hstmt, + SQLCHAR* szCatalogName, + SQLSMALLINT cbCatalogName, + SQLCHAR* szSchemaName, + SQLSMALLINT cbSchemaName, + SQLCHAR* szProcName, + SQLSMALLINT cbProcName, + SQLCHAR* szColumnName, + SQLSMALLINT cbColumnName) +{ +#ifndef auto_SQLProcedureColumns + const char* const sqlFunction = "SQLProcedureColumns"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLPROCEDURECOLUMNS); + const char* const sqlFunction = "SQLProcedureColumns"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(hstmt); + if (pStmt == 0) { + driver_exit(SQL_API_SQLPROCEDURECOLUMNS); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pStmt->sqlProcedureColumns( + ctx, + &szCatalogName, + cbCatalogName, + &szSchemaName, + cbSchemaName, + &szProcName, + cbProcName, + &szColumnName, + cbColumnName + ); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLPROCEDURECOLUMNS); + return ret; +#endif +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLProcedures.cpp b/ndb/src/client/odbc/driver/SQLProcedures.cpp new file mode 100644 index 00000000000..1f3a9f89073 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLProcedures.cpp @@ -0,0 +1,63 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLProcedures( + SQLHSTMT hstmt, + SQLCHAR* szCatalogName, + SQLSMALLINT cbCatalogName, + SQLCHAR* szSchemaName, + SQLSMALLINT cbSchemaName, + SQLCHAR* szProcName, + SQLSMALLINT cbProcName) +{ +#ifndef auto_SQLProcedures + const char* const sqlFunction = "SQLProcedures"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLPROCEDURES); + const char* const sqlFunction = "SQLProcedures"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(hstmt); + if (pStmt == 0) { + driver_exit(SQL_API_SQLPROCEDURES); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pStmt->sqlProcedures( + ctx, + &szCatalogName, + cbCatalogName, + &szSchemaName, + cbSchemaName, + &szProcName, + cbProcName + ); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLPROCEDURES); + return ret; +#endif +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLPutData.cpp b/ndb/src/client/odbc/driver/SQLPutData.cpp new file mode 100644 index 00000000000..a4715a836d2 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLPutData.cpp @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLPutData( + SQLHSTMT StatementHandle, + SQLPOINTER Data, + SQLINTEGER StrLen_or_Ind) +{ + driver_enter(SQL_API_SQLPUTDATA); + const char* const sqlFunction = "SQLPutData"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLPUTDATA); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlPutData(ctx, Data, StrLen_or_Ind); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLPUTDATA); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLRowCount.cpp b/ndb/src/client/odbc/driver/SQLRowCount.cpp new file mode 100644 index 00000000000..d03f954386a --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLRowCount.cpp @@ -0,0 +1,46 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLRowCount( + SQLHSTMT StatementHandle, + SQLINTEGER* RowCount) +{ + driver_enter(SQL_API_SQLROWCOUNT); + const char* const sqlFunction = "SQLRowCount"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLROWCOUNT); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlRowCount(ctx, RowCount); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLROWCOUNT); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLSetConnectAttr.cpp b/ndb/src/client/odbc/driver/SQLSetConnectAttr.cpp new file mode 100644 index 00000000000..05bfce5e9cd --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLSetConnectAttr.cpp @@ -0,0 +1,48 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLSetConnectAttr( + SQLHDBC ConnectionHandle, + SQLINTEGER Attribute, + SQLPOINTER Value, + SQLINTEGER StringLength) +{ + driver_enter(SQL_API_SQLSETCONNECTATTR); + const char* const sqlFunction = "SQLSetConnectAttr"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDbc* pDbc = pRoot->findDbc(ConnectionHandle); + if (pDbc == 0) { + driver_exit(SQL_API_SQLSETCONNECTATTR); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pDbc->sqlSetConnectAttr(ctx, Attribute, Value, StringLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pDbc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLSETCONNECTATTR); + return ret; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLSetConnectOption.cpp b/ndb/src/client/odbc/driver/SQLSetConnectOption.cpp new file mode 100644 index 00000000000..a4794316971 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLSetConnectOption.cpp @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLSetConnectOption( + SQLHDBC ConnectionHandle, + SQLUSMALLINT Option, + SQLUINTEGER Value) +{ + driver_enter(SQL_API_SQLSETCONNECTOPTION); + const char* const sqlFunction = "SQLSetConnectOption"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDbc* pDbc = pRoot->findDbc(ConnectionHandle); + if (pDbc == 0) { + driver_exit(SQL_API_SQLSETCONNECTOPTION); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pDbc->sqlSetConnectOption(ctx, Option, Value); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pDbc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLSETCONNECTOPTION); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLSetCursorName.cpp b/ndb/src/client/odbc/driver/SQLSetCursorName.cpp new file mode 100644 index 00000000000..291ad817d42 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLSetCursorName.cpp @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLSetCursorName( + SQLHSTMT StatementHandle, + SQLCHAR* CursorName, + SQLSMALLINT NameLength) +{ + driver_enter(SQL_API_SQLSETCURSORNAME); + const char* const sqlFunction = "SQLSetCursorName"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLSETCURSORNAME); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlSetCursorName(ctx, CursorName, NameLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLSETCURSORNAME); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLSetDescField.cpp b/ndb/src/client/odbc/driver/SQLSetDescField.cpp new file mode 100644 index 00000000000..19d34c2f46d --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLSetDescField.cpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLSetDescField( + SQLHDESC DescriptorHandle, + SQLSMALLINT RecNumber, + SQLSMALLINT FieldIdentifier, + SQLPOINTER Value, + SQLINTEGER BufferLength) +{ + driver_enter(SQL_API_SQLSETDESCFIELD); + const char* const sqlFunction = "SQLSetDescField"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDesc* pDesc = pRoot->findDesc(DescriptorHandle); + if (pDesc == 0) { + driver_exit(SQL_API_SQLSETDESCFIELD); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pDesc->sqlSetDescField(ctx, RecNumber, FieldIdentifier, Value, BufferLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pDesc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLSETDESCFIELD); + return ret; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLSetDescRec.cpp b/ndb/src/client/odbc/driver/SQLSetDescRec.cpp new file mode 100644 index 00000000000..80a00514a51 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLSetDescRec.cpp @@ -0,0 +1,54 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLSetDescRec( + SQLHDESC DescriptorHandle, + SQLSMALLINT RecNumber, + SQLSMALLINT Type, + SQLSMALLINT SubType, + SQLINTEGER Length, + SQLSMALLINT Precision, + SQLSMALLINT Scale, + SQLPOINTER Data, + SQLINTEGER* StringLength, + SQLINTEGER* Indicator) +{ + driver_enter(SQL_API_SQLSETDESCREC); + const char* const sqlFunction = "SQLSetDescRec"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleDesc* pDesc = pRoot->findDesc(DescriptorHandle); + if (pDesc == 0) { + driver_exit(SQL_API_SQLSETDESCREC); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pDesc->sqlSetDescRec(ctx, RecNumber, Type, SubType, Length, Precision, Scale, Data, StringLength, Indicator); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pDesc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLSETDESCREC); + return ret; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLSetEnvAttr.cpp b/ndb/src/client/odbc/driver/SQLSetEnvAttr.cpp new file mode 100644 index 00000000000..86364eac5e8 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLSetEnvAttr.cpp @@ -0,0 +1,65 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLSetEnvAttr( + SQLHENV EnvironmentHandle, + SQLINTEGER Attribute, + SQLPOINTER Value, + SQLINTEGER StringLength) +{ + driver_enter(SQL_API_SQLSETENVATTR); + const char* const sqlFunction = "SQLSetEnvAttr"; + HandleRoot* const pRoot = HandleRoot::instance(); + if (EnvironmentHandle == 0) { + // process-level attributes + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pRoot->sqlSetRootAttr(ctx, Attribute, Value, StringLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pRoot->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLSETENVATTR); + return ret; + } else { + HandleEnv* pEnv = pRoot->findEnv(EnvironmentHandle); + if (pEnv == 0) { + driver_exit(SQL_API_SQLSETENVATTR); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pEnv->sqlSetEnvAttr(ctx, Attribute, Value, StringLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pEnv->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLSETENVATTR); + return ret; + } + return SQL_ERROR; // not reached +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLSetParam.cpp b/ndb/src/client/odbc/driver/SQLSetParam.cpp new file mode 100644 index 00000000000..03bde1076d8 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLSetParam.cpp @@ -0,0 +1,52 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLSetParam( + SQLHSTMT StatementHandle, + SQLUSMALLINT ParameterNumber, + SQLSMALLINT ValueType, + SQLSMALLINT ParameterType, + SQLUINTEGER LengthPrecision, + SQLSMALLINT ParameterScale, + SQLPOINTER ParameterValue, + SQLINTEGER* StrLen_or_Ind) +{ + driver_enter(SQL_API_SQLSETPARAM); + const char* const sqlFunction = "SQLSetParam"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLSETPARAM); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlSetParam(ctx, ParameterNumber, ValueType, ParameterType, LengthPrecision, ParameterScale, ParameterValue, StrLen_or_Ind); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLSETPARAM); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLSetPos.cpp b/ndb/src/client/odbc/driver/SQLSetPos.cpp new file mode 100644 index 00000000000..653030f90bc --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLSetPos.cpp @@ -0,0 +1,57 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLSetPos( + SQLHSTMT hstmt, + SQLUSMALLINT irow, + SQLUSMALLINT fOption, + SQLUSMALLINT fLock) +{ +#ifndef auto_SQLSetPos + const char* const sqlFunction = "SQLSetPos"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLSETPOS); + const char* const sqlFunction = "SQLSetPos"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(hstmt); + if (pStmt == 0) { + driver_exit(SQL_API_SQLSETPOS); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pStmt->sqlSetPos( + ctx, + irow, + fOption, + fLock + ); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLSETPOS); + return ret; +#endif +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLSetScrollOptions.cpp b/ndb/src/client/odbc/driver/SQLSetScrollOptions.cpp new file mode 100644 index 00000000000..a5e89d8568b --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLSetScrollOptions.cpp @@ -0,0 +1,57 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLSetScrollOptions( + SQLHSTMT hstmt, + SQLUSMALLINT fConcurrency, + SQLINTEGER crowKeyset, + SQLUSMALLINT crowRowset) +{ +#ifndef auto_SQLSetScrollOptions + const char* const sqlFunction = "SQLSetScrollOptions"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLSETSCROLLOPTIONS); + const char* const sqlFunction = "SQLSetScrollOptions"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(hstmt); + if (pStmt == 0) { + driver_exit(SQL_API_SQLSETSCROLLOPTIONS); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pStmt->sqlSetScrollOptions( + ctx, + fConcurrency, + crowKeyset, + crowRowset + ); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLSETSCROLLOPTIONS); + return ret; +#endif +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLSetStmtAttr.cpp b/ndb/src/client/odbc/driver/SQLSetStmtAttr.cpp new file mode 100644 index 00000000000..9ed6a83b563 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLSetStmtAttr.cpp @@ -0,0 +1,48 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0300 +SQLRETURN SQL_API +SQLSetStmtAttr( + SQLHSTMT StatementHandle, + SQLINTEGER Attribute, + SQLPOINTER Value, + SQLINTEGER StringLength) +{ + driver_enter(SQL_API_SQLSETSTMTATTR); + const char* const sqlFunction = "SQLSetStmtAttr"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLSETSTMTATTR); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlSetStmtAttr(ctx, Attribute, Value, StringLength); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLSETSTMTATTR); + return ret; +} +#endif // ODBCVER >= 0x0300 diff --git a/ndb/src/client/odbc/driver/SQLSetStmtOption.cpp b/ndb/src/client/odbc/driver/SQLSetStmtOption.cpp new file mode 100644 index 00000000000..b403fc8408c --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLSetStmtOption.cpp @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLSetStmtOption( + SQLHSTMT StatementHandle, + SQLUSMALLINT Option, + SQLUINTEGER Value) +{ + driver_enter(SQL_API_SQLSETSTMTOPTION); + const char* const sqlFunction = "SQLSetStmtOption"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLSETSTMTOPTION); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pStmt->sqlSetStmtOption(ctx, Option, Value); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLSETSTMTOPTION); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLSpecialColumns.cpp b/ndb/src/client/odbc/driver/SQLSpecialColumns.cpp new file mode 100644 index 00000000000..5dd92c86053 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLSpecialColumns.cpp @@ -0,0 +1,69 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLSpecialColumns( + SQLHSTMT StatementHandle, + SQLUSMALLINT IdentifierType, + SQLCHAR* CatalogName, + SQLSMALLINT NameLength1, + SQLCHAR* SchemaName, + SQLSMALLINT NameLength2, + SQLCHAR* TableName, + SQLSMALLINT NameLength3, + SQLUSMALLINT Scope, + SQLUSMALLINT Nullable) +{ +#ifndef auto_SQLSpecialColumns + const char* const sqlFunction = "SQLSpecialColumns"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLSPECIALCOLUMNS); + const char* const sqlFunction = "SQLSpecialColumns"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLSPECIALCOLUMNS); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pStmt->sqlSpecialColumns( + ctx, + IdentifierType, + &CatalogName, + NameLength1, + &SchemaName, + NameLength2, + &TableName, + NameLength3, + Scope, + Nullable + ); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLSPECIALCOLUMNS); + return ret; +#endif +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLStatistics.cpp b/ndb/src/client/odbc/driver/SQLStatistics.cpp new file mode 100644 index 00000000000..941fb6249a5 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLStatistics.cpp @@ -0,0 +1,67 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLStatistics( + SQLHSTMT StatementHandle, + SQLCHAR* CatalogName, + SQLSMALLINT NameLength1, + SQLCHAR* SchemaName, + SQLSMALLINT NameLength2, + SQLCHAR* TableName, + SQLSMALLINT NameLength3, + SQLUSMALLINT Unique, + SQLUSMALLINT Reserved) +{ +#ifndef auto_SQLStatistics + const char* const sqlFunction = "SQLStatistics"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLSTATISTICS); + const char* const sqlFunction = "SQLStatistics"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLSTATISTICS); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pStmt->sqlStatistics( + ctx, + &CatalogName, + NameLength1, + &SchemaName, + NameLength2, + &TableName, + NameLength3, + Unique, + Reserved + ); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLSTATISTICS); + return ret; +#endif +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLTablePrivileges.cpp b/ndb/src/client/odbc/driver/SQLTablePrivileges.cpp new file mode 100644 index 00000000000..23c6ad9fc4b --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLTablePrivileges.cpp @@ -0,0 +1,63 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLTablePrivileges( + SQLHSTMT hstmt, + SQLCHAR* szCatalogName, + SQLSMALLINT cbCatalogName, + SQLCHAR* szSchemaName, + SQLSMALLINT cbSchemaName, + SQLCHAR* szTableName, + SQLSMALLINT cbTableName) +{ +#ifndef auto_SQLTablePrivileges + const char* const sqlFunction = "SQLTablePrivileges"; + Ctx ctx; + ctx_log1(("*** not implemented: %s", sqlFunction)); + return SQL_ERROR; +#else + driver_enter(SQL_API_SQLTABLEPRIVILEGES); + const char* const sqlFunction = "SQLTablePrivileges"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(hstmt); + if (pStmt == 0) { + driver_exit(SQL_API_SQLTABLEPRIVILEGES); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + if (ctx.ok()) + pStmt->sqlTablePrivileges( + ctx, + &szCatalogName, + cbCatalogName, + &szSchemaName, + cbSchemaName, + &szTableName, + cbTableName + ); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLTABLEPRIVILEGES); + return ret; +#endif +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLTables.cpp b/ndb/src/client/odbc/driver/SQLTables.cpp new file mode 100644 index 00000000000..b2496bfba87 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLTables.cpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLTables( + SQLHSTMT StatementHandle, + SQLCHAR* CatalogName, + SQLSMALLINT NameLength1, + SQLCHAR* SchemaName, + SQLSMALLINT NameLength2, + SQLCHAR* TableName, + SQLSMALLINT NameLength3, + SQLCHAR* TableType, + SQLSMALLINT NameLength4) +{ + driver_enter(SQL_API_SQLTABLES); + const char* const sqlFunction = "SQLTables"; + HandleRoot* const pRoot = HandleRoot::instance(); + HandleStmt* pStmt = pRoot->findStmt(StatementHandle); + if (pStmt == 0) { + driver_exit(SQL_API_SQLTABLES); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + pStmt->sqlTables(ctx, CatalogName, NameLength1, SchemaName, NameLength2, TableName, NameLength3, TableType, NameLength4); + pStmt->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLTABLES); + return ret; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/SQLTransact.cpp b/ndb/src/client/odbc/driver/SQLTransact.cpp new file mode 100644 index 00000000000..da8b46b1596 --- /dev/null +++ b/ndb/src/client/odbc/driver/SQLTransact.cpp @@ -0,0 +1,71 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "driver.hpp" + +#if ODBCVER >= 0x0000 +SQLRETURN SQL_API +SQLTransact( + SQLHENV EnvironmentHandle, + SQLHDBC ConnectionHandle, + SQLUSMALLINT CompletionType) +{ + driver_enter(SQL_API_SQLTRANSACT); + const char* const sqlFunction = "SQLTransact"; + HandleRoot* const pRoot = HandleRoot::instance(); + // check connection first and ignore environment + if (ConnectionHandle != SQL_NULL_HANDLE) { + HandleDbc* pDbc = pRoot->findDbc(ConnectionHandle); + if (pDbc == 0) { + driver_exit(SQL_API_SQLTRANSACT); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pDbc->sqlTransact(ctx, CompletionType); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pDbc->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLTRANSACT); + return ret; + } + if (EnvironmentHandle != SQL_NULL_HANDLE) { + HandleEnv* pEnv = pRoot->findEnv(EnvironmentHandle); + if (pEnv == 0) { + driver_exit(SQL_API_SQLTRANSACT); + return SQL_INVALID_HANDLE; + } + Ctx& ctx = *new Ctx; + ctx.logSqlEnter(sqlFunction); + try { + pEnv->sqlTransact(ctx, CompletionType); + } catch (CtxAssert& ctxAssert) { + ctx.handleEx(ctxAssert); + } + pEnv->saveCtx(ctx); + ctx.logSqlExit(); + SQLRETURN ret = ctx.getCode(); + driver_exit(SQL_API_SQLTRANSACT); + return ret; + } + driver_exit(SQL_API_SQLTRANSACT); + return SQL_INVALID_HANDLE; +} +#endif // ODBCVER >= 0x0000 diff --git a/ndb/src/client/odbc/driver/driver.cpp b/ndb/src/client/odbc/driver/driver.cpp new file mode 100644 index 00000000000..dabfd5f855b --- /dev/null +++ b/ndb/src/client/odbc/driver/driver.cpp @@ -0,0 +1,150 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "driver.hpp" + +#undef NDB_ODBC_SIG_DFL +#ifdef NDB_ODBC_SIG_DFL +#include +#endif + +// The big mutex (just in case). + +#ifdef NDB_WIN32 +static NdbMutex & driver_mutex = * NdbMutex_Create(); +#else +static NdbMutex driver_mutex = NDB_MUTEX_INITIALIZER; +#endif + +static void +driver_lock() +{ + NdbMutex_Lock(&driver_mutex); +} + +static void +driver_unlock() +{ + NdbMutex_Unlock(&driver_mutex); +} + +// Hooks for function entry and exit. + +static inline void +driver_enter(SQLUSMALLINT functionId) +{ + switch (functionId) { + default: + break; + } +#ifdef NDB_ODBC_SIG_DFL + // XXX need to restore old sig + for (int i = 1; i <= 30; i++) + signal(i, SIG_DFL); +#endif +} + +static inline void +driver_exit(SQLUSMALLINT functionId) +{ + switch (functionId) { + default: + break; + } +} + +// Some C++ compilers (like gcc) cannot merge template code +// in different files. So compile all in one file. + +#include "SQLAllocConnect.cpp" +#include "SQLAllocEnv.cpp" +#include "SQLAllocHandle.cpp" +#include "SQLAllocHandleStd.cpp" +#include "SQLAllocStmt.cpp" +#include "SQLBindCol.cpp" +#include "SQLBindParam.cpp" +#include "SQLBindParameter.cpp" +#include "SQLBrowseConnect.cpp" +#include "SQLBulkOperations.cpp" +#include "SQLCancel.cpp" +#include "SQLCloseCursor.cpp" +#include "SQLColAttribute.cpp" +#include "SQLColAttributes.cpp" +#include "SQLColumnPrivileges.cpp" +#include "SQLColumns.cpp" +#include "SQLConnect.cpp" +#include "SQLCopyDesc.cpp" +#include "SQLDataSources.cpp" +#include "SQLDescribeCol.cpp" +#include "SQLDescribeParam.cpp" +#include "SQLDisconnect.cpp" +#include "SQLDriverConnect.cpp" +#include "SQLDrivers.cpp" +#include "SQLEndTran.cpp" +#include "SQLError.cpp" +#include "SQLExecDirect.cpp" +#include "SQLExecute.cpp" +#include "SQLExtendedFetch.cpp" +#include "SQLFetch.cpp" +#include "SQLFetchScroll.cpp" +#include "SQLForeignKeys.cpp" +#include "SQLFreeConnect.cpp" +#include "SQLFreeEnv.cpp" +#include "SQLFreeHandle.cpp" +#include "SQLFreeStmt.cpp" +#include "SQLGetConnectAttr.cpp" +#include "SQLGetConnectOption.cpp" +#include "SQLGetCursorName.cpp" +#include "SQLGetData.cpp" +#include "SQLGetDescField.cpp" +#include "SQLGetDescRec.cpp" +#include "SQLGetDiagField.cpp" +#include "SQLGetDiagRec.cpp" +#include "SQLGetEnvAttr.cpp" +#include "SQLGetFunctions.cpp" +#include "SQLGetInfo.cpp" +#include "SQLGetStmtAttr.cpp" +#include "SQLGetStmtOption.cpp" +#include "SQLGetTypeInfo.cpp" +#include "SQLMoreResults.cpp" +#include "SQLNativeSql.cpp" +#include "SQLNumParams.cpp" +#include "SQLNumResultCols.cpp" +#include "SQLParamData.cpp" +#include "SQLParamOptions.cpp" +#include "SQLPrepare.cpp" +#include "SQLPrimaryKeys.cpp" +#include "SQLProcedureColumns.cpp" +#include "SQLProcedures.cpp" +#include "SQLPutData.cpp" +#include "SQLRowCount.cpp" +#include "SQLSetConnectAttr.cpp" +#include "SQLSetConnectOption.cpp" +#include "SQLSetCursorName.cpp" +#include "SQLSetDescField.cpp" +#include "SQLSetDescRec.cpp" +#include "SQLSetEnvAttr.cpp" +#include "SQLSetParam.cpp" +#include "SQLSetPos.cpp" +#include "SQLSetScrollOptions.cpp" +#include "SQLSetStmtAttr.cpp" +#include "SQLSetStmtOption.cpp" +#include "SQLSpecialColumns.cpp" +#include "SQLStatistics.cpp" +#include "SQLTablePrivileges.cpp" +#include "SQLTables.cpp" +#include "SQLTransact.cpp" diff --git a/ndb/src/client/odbc/driver/driver.hpp b/ndb/src/client/odbc/driver/driver.hpp new file mode 100644 index 00000000000..96d2e052c0d --- /dev/null +++ b/ndb/src/client/odbc/driver/driver.hpp @@ -0,0 +1,28 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_DRIVER_driver_hpp +#define ODBC_DRIVER_driver_hpp + +#include +#include +#include + +#ifndef NDB_WIN32 +#define SQL_API +#endif + +#endif diff --git a/ndb/src/client/odbc/executor/Exec_comp_op.cpp b/ndb/src/client/odbc/executor/Exec_comp_op.cpp new file mode 100644 index 00000000000..40d3950a592 --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_comp_op.cpp @@ -0,0 +1,518 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include + +void +Exec_comp_op::execInterp(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + const unsigned arity = code.m_op.arity(); + const Comp_op::Opcode opcode = code.m_op.m_opcode; + Data& data = getData(); + ctx_assert(ctl.m_scanFilter != 0); + NdbScanFilter& scanFilter = *ctl.m_scanFilter; + if (code.m_interpColumn == 0) { + // args are constant on this level so evaluate entire predicate + evaluate(ctx, ctl); + if (! ctx.ok()) + return; + if (data.m_value == Pred_value_true) + scanFilter.istrue(); + else + scanFilter.isfalse(); + return; + } + const NdbAttrId interpAttrId = code.m_interpAttrId; + if (arity == 1) { + ctx_assert(m_expr[1] != 0); + const SqlType& t1 = m_expr[1]->getCode().sqlSpec().sqlType(); + const SqlField& f1 = m_expr[1]->getData().sqlField(); + switch (code.m_op.m_opcode) { + case Comp_op::Isnull: + scanFilter.isnull(interpAttrId); + break; + case Comp_op::Isnotnull: + scanFilter.isnotnull(interpAttrId); + break; + default: + ctx_assert(false); + break; + } + } else if (arity == 2) { + ctx_assert(m_expr[1] != 0 && m_expr[2] != 0); + // one is column and the other is constant at this level + ctx_assert(code.m_interpColumn == 1 || code.m_interpColumn == 2); + const unsigned i = code.m_interpColumn; + const unsigned j = 3 - i; + // evaluate the constant + m_expr[j]->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + const SqlType& t1 = m_expr[i]->getCode().sqlSpec().sqlType(); + const SqlField& f1 = m_expr[i]->getData().sqlField(); + const SqlType& t2 = m_expr[j]->getCode().sqlSpec().sqlType(); + const SqlField& f2 = m_expr[j]->getData().sqlField(); + // handle null constant + if (f2.sqlNull()) { + scanFilter.isfalse(); + return; + } + // handle null in interpreter + scanFilter.begin(NdbScanFilter::AND); + scanFilter.isnotnull(interpAttrId); + if (t1.type() == SqlType::Char || t1.type() == SqlType::Varchar) { + const char* v2 = 0; + unsigned n2 = 0; + bool nopad = false; + if (t1.type() == SqlType::Char && t2.type() == SqlType::Char) { + v2 = reinterpret_cast(f2.sqlChar()); + n2 = t2.length(); + nopad = false; + } else if (t1.type() == SqlType::Char && t2.type() == SqlType::Varchar) { + v2 = reinterpret_cast(f2.sqlVarchar(&n2)); + nopad = true; + } else if (t1.type() == SqlType::Varchar && t2.type() == SqlType::Char) { + v2 = reinterpret_cast(f2.sqlChar()); + n2 = t2.length(); + nopad = true; + } else if (t1.type() == SqlType::Varchar && t2.type() == SqlType::Varchar) { + v2 = reinterpret_cast(f2.sqlVarchar(&n2)); + nopad = true; + } else { + ctx_assert(false); + } + switch (opcode) { + case Comp_op::Eq: + scanFilter.eq(interpAttrId, v2, n2, nopad); + break; + case Comp_op::Noteq: + scanFilter.ne(interpAttrId, v2, n2, nopad); + break; + case Comp_op::Lt: + if (i == 1) { + scanFilter.lt(interpAttrId, v2, n2, nopad); + } else { + scanFilter.gt(interpAttrId, v2, n2, nopad); + } + break; + case Comp_op::Lteq: + if (i == 1) { + scanFilter.le(interpAttrId, v2, n2, nopad); + } else { + scanFilter.ge(interpAttrId, v2, n2, nopad); + } + break; + case Comp_op::Gt: + if (i == 1) { + scanFilter.gt(interpAttrId, v2, n2, nopad); + } else { + scanFilter.lt(interpAttrId, v2, n2, nopad); + } + break; + case Comp_op::Gteq: + if (i == 1) { + scanFilter.ge(interpAttrId, v2, n2, nopad); + } else { + scanFilter.le(interpAttrId, v2, n2, nopad); + } + break; + case Comp_op::Like: + scanFilter.like(interpAttrId, v2, n2, nopad); + break; + case Comp_op::Notlike: + scanFilter.notlike(interpAttrId, v2, n2, nopad); + break; + default: + ctx_assert(false); + break; + } + } else if (t1.type() == SqlType::Smallint || t1.type() == SqlType::Integer || t1.type() == SqlType::Bigint) { + ctx_assert(t1.unSigned()); + bool s2 = ! t2.unSigned(); + SqlBigint v2; + SqlUbigint uv2; + if (s2) { + v2 = + t2.type() == SqlType::Smallint ? f2.sqlSmallint() : + t2.type() == SqlType::Integer ? f2.sqlInteger() : f2.sqlBigint(); + uv2 = v2; + } else { + uv2 = + t2.type() == SqlType::Smallint ? (SqlUsmallint)f2.sqlSmallint() : + t2.type() == SqlType::Integer ? (SqlUinteger)f2.sqlInteger() : (SqlUbigint)f2.sqlBigint(); + v2 = uv2; + } + switch (code.m_op.m_opcode) { + case Comp_op::Eq: + if (s2 && v2 < 0) + scanFilter.isfalse(); + else + scanFilter.eq(interpAttrId, uv2); + break; + case Comp_op::Noteq: + if (s2 && v2 < 0) + scanFilter.istrue(); + else + scanFilter.ne(interpAttrId, uv2); + break; + case Comp_op::Lt: + if (i == 1) { + if (s2 && v2 < 0) + scanFilter.isfalse(); + else + scanFilter.lt(interpAttrId, uv2); + } else { + if (s2 && v2 < 0) + scanFilter.istrue(); + else + scanFilter.gt(interpAttrId, uv2); + } + break; + case Comp_op::Lteq: + if (i == 1) { + if (s2 && v2 < 0) + scanFilter.isfalse(); + else + scanFilter.le(interpAttrId, uv2); + } else { + if (s2 && v2 < 0) + scanFilter.istrue(); + else + scanFilter.ge(interpAttrId, uv2); + } + break; + case Comp_op::Gt: + if (i == 1) { + if (s2 && v2 < 0) + scanFilter.istrue(); + else + scanFilter.gt(interpAttrId, uv2); + } else { + if (s2 && v2 < 0) + scanFilter.isfalse(); + else + scanFilter.lt(interpAttrId, uv2); + } + break; + case Comp_op::Gteq: + if (i == 1) { + if (s2 && v2 < 0) + scanFilter.istrue(); + else + scanFilter.ge(interpAttrId, uv2); + } else { + if (s2 && v2 < 0) + scanFilter.isfalse(); + else + scanFilter.le(interpAttrId, uv2); + } + break; + default: + ctx_assert(false); + break; + } + } else { + ctx_assert(false); + } + // end null guard + scanFilter.end(); + } else { + ctx_assert(false); + } +} + +static bool +do_sqlchar_comp(Comp_op::Opcode opcode, const SqlChar* s1, unsigned n1, const SqlChar* s2, unsigned n2, bool padded) +{ + int ret = NdbSqlUtil::char_compare(reinterpret_cast(s1), n1, reinterpret_cast(s2), n2, padded); + switch (opcode) { + case Comp_op::Eq: + return ret == 0; + case Comp_op::Noteq: + return ret != 0; + case Comp_op::Lt: + return ret < 0; + case Comp_op::Lteq: + return ret <= 0; + case Comp_op::Gt: + return ret > 0; + case Comp_op::Gteq: + return ret >= 0; + default: + break; + } + ctx_assert(false); + return false; +} + +static bool +do_sqlchar_like(const SqlChar* s1, unsigned n1, const SqlChar* s2, unsigned n2, bool padded) +{ + bool ret = NdbSqlUtil::char_like(reinterpret_cast(s1), n1, reinterpret_cast(s2), n2, padded); + return ret; +} + +static bool +do_datetime_comp(Comp_op::Opcode opcode, SqlDatetime v1, SqlDatetime v2) +{ + int k = v1.less(v2) ? -1 : v2.less(v1) ? 1 : 0; + switch (opcode) { + case Comp_op::Eq: + return k == 0; + case Comp_op::Noteq: + return k != 0; + case Comp_op::Lt: + return k < 0; + case Comp_op::Lteq: + return k <= 0; + case Comp_op::Gt: + return k > 0; + case Comp_op::Gteq: + return k >= 0; + default: + break; + } + ctx_assert(false); + return false; +} + +void +Exec_comp_op::evaluate(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + const unsigned arity = code.m_op.arity(); + const Comp_op::Opcode opcode = code.m_op.m_opcode; + Data& data = getData(); + Pred_value v = Pred_value_unknown; + if (arity == 1) { + // evaluate sub-expression + ctx_assert(m_expr[1] != 0); + m_expr[1]->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + if (ctl.m_postEval) + return; + // get type and value + const SqlType& t1 = m_expr[1]->getCode().sqlSpec().sqlType(); + const SqlField& f1 = ctl.m_groupIndex == 0 ? m_expr[1]->getData().sqlField() : m_expr[1]->getData().groupField(ctl.m_groupIndex); + switch (code.m_op.m_opcode) { + case Comp_op::Isnull: + v = f1.sqlNull() ? Pred_value_true : Pred_value_false; + break; + case Comp_op::Isnotnull: + v = f1.sqlNull() ? Pred_value_false : Pred_value_true; + break; + default: + ctx_assert(false); + break; + } + } else if (arity == 2) { + // evaluate sub-expressions + ctx_assert(m_expr[1] != 0 && m_expr[2] != 0); + m_expr[1]->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + m_expr[2]->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + if (ctl.m_postEval) + return; + // get types and values + const SqlType& t1 = m_expr[1]->getCode().sqlSpec().sqlType(); + const SqlType& t2 = m_expr[2]->getCode().sqlSpec().sqlType(); + const SqlField& f1 = ctl.m_groupIndex == 0 ? m_expr[1]->getData().sqlField() : m_expr[1]->getData().groupField(ctl.m_groupIndex); + const SqlField& f2 = ctl.m_groupIndex == 0 ? m_expr[2]->getData().sqlField() : m_expr[2]->getData().groupField(ctl.m_groupIndex); + // handle null + if (f1.sqlNull() || f2.sqlNull()) { + v = Pred_value_unknown; + } else if (t1.type() == SqlType::Char) { + const SqlChar* v1 = f1.sqlChar(); + unsigned n1 = t1.length(); + if (t2.type() == SqlType::Char) { + unsigned n2 = t2.length(); + const SqlChar* v2 = f2.sqlChar(); + bool b; + switch (opcode) { + case Comp_op::Like: + b = do_sqlchar_like(v1, n1, v2, n2, true); + break; + case Comp_op::Notlike: + b = ! do_sqlchar_like(v1, n1, v2, n2, true); + break; + default: + b = do_sqlchar_comp(opcode, v1, n1, v2, n2, true); + break; + } + v = b ? Pred_value_true : Pred_value_false; + } else if (t2.type() == SqlType::Varchar) { + unsigned n2 = 0; + const SqlChar* v2 = f2.sqlVarchar(&n2); + bool b; + switch (opcode) { + case Comp_op::Like: + b = do_sqlchar_like(v1, n1, v2, n2, true); + break; + case Comp_op::Notlike: + b = ! do_sqlchar_like(v1, n1, v2, n2, true); + break; + default: + b = do_sqlchar_comp(opcode, v1, n1, v2, n2, false); + break; + } + v = b ? Pred_value_true : Pred_value_false; + } else { + ctx_assert(false); + } + } else if (t1.type() == SqlType::Varchar) { + unsigned n1 = 0; + const SqlChar* v1 = f1.sqlVarchar(&n1); + if (t2.type() == SqlType::Char) { + unsigned n2 = t2.length(); + const SqlChar* v2 = f2.sqlChar(); + bool b; + switch (opcode) { + case Comp_op::Like: + b = do_sqlchar_like(v1, n1, v2, n2, false); + break; + case Comp_op::Notlike: + b = ! do_sqlchar_like(v1, n1, v2, n2, false); + break; + default: + b = do_sqlchar_comp(opcode, v1, n1, v2, n2, false); + break; + } + v = b ? Pred_value_true : Pred_value_false; + } else if (t2.type() == SqlType::Varchar) { + unsigned n2 = 0; + const SqlChar* v2 = f2.sqlVarchar(&n2); + bool b; + switch (opcode) { + case Comp_op::Like: + b = do_sqlchar_like(v1, n1, v2, n2, false); + break; + case Comp_op::Notlike: + b = ! do_sqlchar_like(v1, n1, v2, n2, false); + break; + default: + b = do_sqlchar_comp(opcode, v1, n1, v2, n2, false); + break; + } + v = b ? Pred_value_true : Pred_value_false; + } else { + ctx_assert(false); + } + } else if (t1.type() == SqlType::Smallint || t1.type() == SqlType::Integer || t1.type() == SqlType::Bigint) { + // convert to bigint + bool s1 = ! t1.unSigned(); + bool s2 = ! t2.unSigned(); + SqlBigint v1, v2; + SqlUbigint uv1, uv2; + if (s1) { + v1 = + t1.type() == SqlType::Smallint ? f1.sqlSmallint() : + t1.type() == SqlType::Integer ? f1.sqlInteger() : f1.sqlBigint(); + uv1 = v1; + } else { + uv1 = + t1.type() == SqlType::Smallint ? (SqlUsmallint)f1.sqlSmallint() : + t1.type() == SqlType::Integer ? (SqlUinteger)f1.sqlInteger() : (SqlUbigint)f1.sqlBigint(); + v1 = uv1; + } + if (s2) { + v2 = + t2.type() == SqlType::Smallint ? f2.sqlSmallint() : + t2.type() == SqlType::Integer ? f2.sqlInteger() : f2.sqlBigint(); + uv2 = v2; + } else { + uv2 = + t2.type() == SqlType::Smallint ? (SqlUsmallint)f2.sqlSmallint() : + t2.type() == SqlType::Integer ? (SqlUinteger)f2.sqlInteger() : (SqlUbigint)f2.sqlBigint(); + v2 = uv2; + } + bool b; + switch (opcode) { + case Comp_op::Eq: + b = s1 && s2 ? (v1 == v2) : s1 ? (v1 < 0 ? false : uv1 == uv2) : s2 ? (v2 < 0 ? false : uv1 == uv2) : (uv1 == uv2); + break; + case Comp_op::Noteq: + b = s1 && s2 ? (v1 == v2) : s1 ? (v1 < 0 ? true : uv1 != uv2) : s2 ? (v2 < 0 ? true : uv1 != uv2) : (uv1 != uv2); + break; + case Comp_op::Lt: + b = s1 && s2 ? (v1 < v2) : s1 ? (v1 < 0 ? true : uv1 < uv2) : s2 ? (v2 < 0 ? false : uv1 < uv2) : (uv1 < uv2); + break; + case Comp_op::Lteq: + b = s1 && s2 ? (v1 <= v2) : s1 ? (v1 < 0 ? true : uv1 <= uv2) : s2 ? (v2 < 0 ? false : uv1 <= uv2) : (uv1 <= uv2); + break; + case Comp_op::Gt: + b = s1 && s2 ? (v1 > v2) : s1 ? (v1 < 0 ? false : uv1 > uv2) : s2 ? (v2 < 0 ? true : uv1 > uv2) : (uv1 > uv2); + break; + case Comp_op::Gteq: + b = s1 && s2 ? (v1 >= v2) : s1 ? (v1 < 0 ? false : uv1 >= uv2) : s2 ? (v2 < 0 ? true : uv1 >= uv2) : (uv1 >= uv2); + break; + default: + ctx_assert(false); + break; + } + v = b ? Pred_value_true : Pred_value_false; + } else if (t1.type() == SqlType::Double) { + SqlDouble v1 = f1.sqlDouble(); + SqlDouble v2 = f2.sqlDouble(); + bool b; + switch (opcode) { + case Comp_op::Eq: + b = (v1 == v2); + break; + case Comp_op::Noteq: + b = (v1 != v2); + break; + case Comp_op::Lt: + b = (v1 < v2); + break; + case Comp_op::Lteq: + b = (v1 <= v2); + break; + case Comp_op::Gt: + b = (v1 > v2); + break; + case Comp_op::Gteq: + b = (v1 >= v2); + break; + default: + ctx_assert(false); + break; + } + v = b ? Pred_value_true : Pred_value_false; + } else if (t1.type() == SqlType::Datetime) { + SqlDatetime v1 = f1.sqlDatetime(); + SqlDatetime v2 = f2.sqlDatetime(); + bool b; + b = do_datetime_comp(opcode, v1, v2); + v = b ? Pred_value_true : Pred_value_false; + } else { + ctx_assert(false); + } + } else { + ctx_assert(false); + } + // set result + if (ctl.m_groupIndex == 0) + data.m_value = v; + else + data.groupValue(ctl.m_groupIndex, ctl.m_groupInit) = v; +} diff --git a/ndb/src/client/odbc/executor/Exec_create_index.cpp b/ndb/src/client/odbc/executor/Exec_create_index.cpp new file mode 100644 index 00000000000..3966c6d5db2 --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_create_index.cpp @@ -0,0 +1,46 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include + +void +Exec_create_index::execute(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + NdbDictionary::Dictionary* ndbDictionary = ndb->getDictionary(); + if (ndbDictionary == 0) { + ctx.pushStatus(ndb, "getDictionary"); + return; + } + NdbDictionary::Index ndbIndex(code.m_indexName.c_str()); + ndbIndex.setTable(code.m_tableName.c_str()); + ndbIndex.setType((NdbDictionary::Index::Type)code.m_type); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + ndbIndex.addIndexColumn(code.m_attrList[i]); + } + // setting fragment type not supported in ndb api + ndbIndex.setLogging(code.m_logging); + dictSchema().deleteTable(ctx, code.m_tableName); + if (ndbDictionary->createIndex(ndbIndex) == -1) { + ctx.pushStatus(ndbDictionary->getNdbError(), "createIndex %s", ndbIndex.getName()); + return; + } + ctx_log1(("index %s on %s created", ndbIndex.getName(), ndbIndex.getTable())); +} diff --git a/ndb/src/client/odbc/executor/Exec_create_table.cpp b/ndb/src/client/odbc/executor/Exec_create_table.cpp new file mode 100644 index 00000000000..d6274119371 --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_create_table.cpp @@ -0,0 +1,83 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include + +void +Exec_create_table::execute(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + NdbDictionary::Dictionary* ndbDictionary = ndb->getDictionary(); + if (ndbDictionary == 0) { + ctx.pushStatus(ndb, "getDictionary"); + return; + } + NdbDictionary::Table ndbTable(code.m_tableName.c_str()); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + const Code::Attr& attr = code.m_attrList[i]; + NdbDictionary::Column ndbColumn(attr.m_attrName.c_str()); + if (i == code.m_tupleId) + ndbColumn.setTupleKey(true); // XXX setTupleId() + if (ctx.logLevel() >= 3) { + char buf[100]; + attr.m_sqlType.print(buf, sizeof(buf)); + ctx_log3(("attr %s type %s", ndbColumn.getName(), buf)); + } + if (attr.m_tupleKey) + ndbColumn.setPrimaryKey(true); + attr.m_sqlType.getType(ctx, &ndbColumn); + if (! ctx.ok()) + return; + if (attr.m_autoIncrement) + ndbColumn.setAutoIncrement(true); + char defaultValue[MAX_ATTR_DEFAULT_VALUE_SIZE]; + defaultValue[0] = 0; + if (attr.m_defaultValue != 0) { + // XXX obviously should evalute it at insert time too + attr.m_defaultValue->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + const SqlField& f = attr.m_defaultValue->getData().sqlField(); + const SqlType& t = f.sqlSpec().sqlType(); + // XXX use SqlField cast method instead + SQLINTEGER ind = 0; + ExtType extType(ExtType::Char); + ExtSpec extSpec(extType); + ExtField extField(extSpec, (SQLPOINTER)defaultValue, sizeof(defaultValue), &ind); + f.copyout(ctx, extField); + if (! ctx.ok()) + return; + if (ind == SQL_NULL_DATA) // do not store NULL default + defaultValue[0] = 0; + } + if (defaultValue[0] != 0) + ndbColumn.setDefaultValue(defaultValue); + ndbTable.addColumn(ndbColumn); + } + if (code.m_fragmentType != NdbDictionary::Object::FragUndefined) + ndbTable.setFragmentType(code.m_fragmentType); + ndbTable.setLogging(code.m_logging); + dictSchema().deleteTable(ctx, code.m_tableName); + if (ndbDictionary->createTable(ndbTable) == -1) { + ctx.pushStatus(ndbDictionary->getNdbError(), "createTable %s", ndbTable.getName()); + return; + } + ctx_log1(("table %s created", ndbTable.getName())); +} diff --git a/ndb/src/client/odbc/executor/Exec_delete_index.cpp b/ndb/src/client/odbc/executor/Exec_delete_index.cpp new file mode 100644 index 00000000000..10814654a58 --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_delete_index.cpp @@ -0,0 +1,82 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include +#include + +void +Exec_delete_index::execImpl(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + NdbConnection* const tcon = ndbConnection(); + // execute subquery + ctx_assert(m_query != 0); + m_query->execute(ctx, ctl); + if (! ctx.ok()) + return; + // delete each row from the query + data.setCount(0); + while (m_query->fetch(ctx, ctl)) { + NdbOperation* op = tcon->getNdbIndexOperation(code.m_indexName, code.m_tableName); + if (op == 0) { + ctx.pushStatus(ndb, tcon, 0, "getIndexNdbOperation"); + return; + } + if (op->deleteTuple() == -1) { + ctx.pushStatus(ndb, tcon, op, "deleteTuple"); + return; + } + bool done = false; + for (unsigned k = 1; k <= code.m_keyCount; k++) { + Exec_expr* exprMatch = code.m_keyMatch[k]; + ctx_assert(exprMatch != 0); + exprMatch->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + const SqlField& keyMatch = exprMatch->getData().sqlField(); + SqlField f(code.m_keySpecs.getEntry(k)); + if (! keyMatch.cast(ctx, f)) { + done = true; // match is not possible + break; + } + const NdbAttrId keyId = code.m_keyId[k]; + const void* addr = f.addr(); + const char* value = static_cast(addr); + if (op->equal(keyId, value) == -1) { + ctx.pushStatus(ndb, tcon, op, "equal attrId=%u", (unsigned)keyId); + return; + } + } + if (done) + continue; + if (tcon->execute(NoCommit) == -1) { + // XXX when did 626 move to connection level + if (tcon->getNdbError().code != 626 && op->getNdbError().code != 626) { + ctx.pushStatus(ndb, tcon, op, "execute without commit"); + return; + } + } else { + data.addCount(); + } + } + stmtArea().setRowCount(ctx, data.getCount()); +} diff --git a/ndb/src/client/odbc/executor/Exec_delete_lookup.cpp b/ndb/src/client/odbc/executor/Exec_delete_lookup.cpp new file mode 100644 index 00000000000..d0795286122 --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_delete_lookup.cpp @@ -0,0 +1,82 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include +#include + +void +Exec_delete_lookup::execImpl(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + NdbConnection* const tcon = ndbConnection(); + // execute subquery + ctx_assert(m_query != 0); + m_query->execute(ctx, ctl); + if (! ctx.ok()) + return; + // delete each row from the query + data.setCount(0); + while (m_query->fetch(ctx, ctl)) { + NdbOperation* op = tcon->getNdbOperation(code.m_tableName); + if (op == 0) { + ctx.pushStatus(ndb, tcon, 0, "getNdbOperation"); + return; + } + if (op->deleteTuple() == -1) { + ctx.pushStatus(ndb, tcon, op, "deleteTuple"); + return; + } + bool done = false; + for (unsigned k = 1; k <= code.m_keyCount; k++) { + Exec_expr* exprMatch = code.m_keyMatch[k]; + ctx_assert(exprMatch != 0); + exprMatch->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + const SqlField& keyMatch = exprMatch->getData().sqlField(); + SqlField f(code.m_keySpecs.getEntry(k)); + if (! keyMatch.cast(ctx, f)) { + done = true; // match is not possible + break; + } + const NdbAttrId keyId = code.m_keyId[k]; + const void* addr = f.addr(); + const char* value = static_cast(addr); + if (op->equal(keyId, value) == -1) { + ctx.pushStatus(ndb, tcon, op, "equal attrId=%u", (unsigned)keyId); + return; + } + } + if (done) + continue; + if (tcon->execute(NoCommit) == -1) { + // XXX when did 626 move to connection level + if (tcon->getNdbError().code != 626 && op->getNdbError().code != 626) { + ctx.pushStatus(ndb, tcon, op, "execute without commit"); + return; + } + } else { + data.addCount(); + } + } + stmtArea().setRowCount(ctx, data.getCount()); +} diff --git a/ndb/src/client/odbc/executor/Exec_delete_scan.cpp b/ndb/src/client/odbc/executor/Exec_delete_scan.cpp new file mode 100644 index 00000000000..a0b3b8314b8 --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_delete_scan.cpp @@ -0,0 +1,54 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include + +void +Exec_delete_scan::execImpl(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + NdbConnection* const tcon = ndbConnection(); + // execute subquery + ctx_assert(m_query != 0); + m_query->execute(ctx, ctl); + if (! ctx.ok()) + return; + ctx_assert(ctl.m_scanOp != 0); + // delete each row from the scan + data.setCount(0); + while (m_query->fetch(ctx, ctl)) { + NdbOperation* toOp = ctl.m_scanOp->takeOverForDelete(tcon); + if (toOp == 0) { + ctx.pushStatus(ndb, tcon, ctl.m_scanOp, "takeOverScanOp"); + return; + } + if (tcon->execute(NoCommit) == -1) { + if (toOp->getNdbError().code != 626) { + ctx.pushStatus(ndb, tcon, toOp, "execute without commit"); + return; + } + } else { + data.addCount(); + } + } + stmtArea().setRowCount(ctx, data.getCount()); +} diff --git a/ndb/src/client/odbc/executor/Exec_drop_index.cpp b/ndb/src/client/odbc/executor/Exec_drop_index.cpp new file mode 100644 index 00000000000..6bf451f6911 --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_drop_index.cpp @@ -0,0 +1,38 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include + +void +Exec_drop_index::execute(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + NdbDictionary::Dictionary* ndbDictionary = ndb->getDictionary(); + if (ndbDictionary == 0) { + ctx.pushStatus(ndb, "getDictionary"); + return; + } + dictSchema().deleteTableByIndex(ctx, code.m_indexName); + if (ndbDictionary->dropIndex(code.m_indexName.c_str(), code.m_tableName.c_str()) == -1) { + ctx.pushStatus(ndbDictionary->getNdbError(), "dropIndex %s on %s", code.m_indexName.c_str(), code.m_tableName.c_str()); + return; + } + ctx_log1(("index %s on %s dropped", code.m_indexName.c_str(), code.m_tableName.c_str())); +} diff --git a/ndb/src/client/odbc/executor/Exec_drop_table.cpp b/ndb/src/client/odbc/executor/Exec_drop_table.cpp new file mode 100644 index 00000000000..40d1d42fc61 --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_drop_table.cpp @@ -0,0 +1,38 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include + +void +Exec_drop_table::execute(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + NdbDictionary::Dictionary* ndbDictionary = ndb->getDictionary(); + if (ndbDictionary == 0) { + ctx.pushStatus(ndb, "getDictionary"); + return; + } + dictSchema().deleteTable(ctx, code.m_tableName); + if (ndbDictionary->dropTable(code.m_tableName.c_str()) == -1) { + ctx.pushStatus(ndbDictionary->getNdbError(), "dropTable %s", code.m_tableName.c_str()); + return; + } + ctx_log1(("table %s dropped", code.m_tableName.c_str())); +} diff --git a/ndb/src/client/odbc/executor/Exec_expr_conv.cpp b/ndb/src/client/odbc/executor/Exec_expr_conv.cpp new file mode 100644 index 00000000000..636bfda7d59 --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_expr_conv.cpp @@ -0,0 +1,54 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +void +Exec_expr_conv::evaluate(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + const SqlType& t1 = code.sqlSpec().sqlType(); + SqlField& f1 = ctl.m_groupIndex == 0 ? data.m_sqlField : data.groupField(code.sqlSpec().sqlType() , ctl.m_groupIndex, ctl.m_groupInit); + // evaluate the subexpression + ctx_assert(m_expr != 0); + m_expr->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + if (ctl.m_postEval) + return; + const SqlType& t2 = m_expr->getCode().sqlSpec().sqlType(); + const SqlField& f2 = ctl.m_groupIndex == 0 ? m_expr->getData().sqlField() : m_expr->getData().groupField(ctl.m_groupIndex); + // conversion to null type + if (t1.type() == SqlType::Null) { + f1.sqlNull(true); + return; + } + // conversion of null data + if (f2.sqlNull()) { + f1.sqlNull(true); + return; + } + // try to convert + if (! f2.cast(ctx, f1)) { + char b1[40], b2[40], b3[40]; + t1.print(b1, sizeof(b1)); + t2.print(b2, sizeof(b2)); + f2.print(b3, sizeof(b3)); + ctx.pushStatus(Sqlstate::_22003, Error::Gen, "cannot convert %s [%s] to %s", b2, b3, b1); + return; + } +} diff --git a/ndb/src/client/odbc/executor/Exec_expr_func.cpp b/ndb/src/client/odbc/executor/Exec_expr_func.cpp new file mode 100644 index 00000000000..093d15c6e2b --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_expr_func.cpp @@ -0,0 +1,284 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include + +void +Exec_expr_func::init(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + const SqlType& t = code.sqlSpec().sqlType(); + SqlField& f = ctl.m_groupIndex == 0 ? data.m_sqlField : data.groupField(code.sqlSpec().sqlType(), ctl.m_groupIndex, ctl.m_groupInit); + if (ctl.m_groupIndex >= data.m_groupAcc.size()) + data.m_groupAcc.resize(1 + ctl.m_groupIndex); + Data::Acc& acc = data.m_groupAcc[ctl.m_groupIndex]; + acc.m_count = 0; + Expr_func::Code fc = code.m_func.m_code; + if (fc == Expr_func::Substr || fc == Expr_func::Left || fc == Expr_func::Right) { + } else if (fc == Expr_func::Count) { + f.sqlBigint(0); + } else if (fc == Expr_func::Min || fc == Expr_func::Max) { + f.sqlNull(true); + } else if (fc == Expr_func::Sum) { + f.sqlNull(true); + switch (t.type()) { + case SqlType::Bigint: + acc.m_bigint = 0; + break; + case SqlType::Double: + acc.m_double = 0; + break; + default: + ctx_assert(false); + break; + } + } else if (fc == Expr_func::Avg) { + f.sqlNull(true); + switch (t.type()) { + case SqlType::Double: + acc.m_double = 0.0; + break; + default: + ctx_assert(false); + break; + } + } else if (fc == Expr_func::Rownum) { + // uses only m_count + } else if (fc == Expr_func::Sysdate) { + // set time once + NDB_TICKS secs = 0; + Uint32 micros = 0; + NdbTick_CurrentMicrosecond(&secs, µs); + time_t clock = secs; + struct tm* t = gmtime(&clock); + SqlDatetime& d = acc.m_sysdate; + d.cc((1900 + t->tm_year) / 100); + d.yy((1900 + t->tm_year) % 100); + d.mm(1 + t->tm_mon); + d.dd(t->tm_mday); + d.HH(t->tm_hour); + d.MM(t->tm_min); + d.SS(t->tm_sec); + d.ff(1000 * micros); + } else { + ctx_assert(false); + } +} + +void +Exec_expr_func::evaluate(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + const SqlType& t = code.sqlSpec().sqlType(); + if (ctl.m_groupInit) + init(ctx, ctl); + SqlField& f = ctl.m_groupIndex == 0 ? data.m_sqlField : data.groupField(code.sqlSpec().sqlType(), ctl.m_groupIndex, false); + Data::Acc& acc = data.m_groupAcc[ctl.m_groupIndex]; + Expr_func::Code fc = code.m_func.m_code; + const unsigned narg = code.m_narg; + Exec_expr** args = code.m_args; + ctx_assert(args != 0); + // evaluate arguments + for (unsigned i = 1; i <= narg; i++) { + ctx_assert(args[i] != 0); + unsigned save = ctl.m_groupIndex; + if (code.m_func.m_aggr) + ctl.m_groupIndex = 0; + args[i]->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + ctl.m_groupIndex = save; + } + if (fc == Expr_func::Substr || fc == Expr_func::Left || fc == Expr_func::Right) { + ctx_assert((narg == (unsigned)2) || (narg == (unsigned)(fc == Expr_func::Substr ? 3 : 2))); + const SqlType& t1 = args[1]->getCode().sqlSpec().sqlType(); + const SqlField& f1 = args[1]->getData().sqlField(); + int pos, len; + for (unsigned i = 2; i <= narg; i++) { + int& num = (fc == Expr_func::Substr ? (i == 2 ? pos : len) : len); + const SqlType& t2 = args[i]->getCode().sqlSpec().sqlType(); + const SqlField& f2 = args[i]->getData().sqlField(); + switch (t2.type()) { + case SqlType::Smallint: + num = static_cast(f2.sqlSmallint()); + break; + case SqlType::Integer: + num = static_cast(f2.sqlInteger()); + break; + case SqlType::Bigint: + num = static_cast(f2.sqlBigint()); + break; + default: + ctx_assert(false); + break; + } + } + int length = 0; + const SqlChar* data = 0; + switch (t1.type()) { + case SqlType::Char: + length = t1.length(); + data = f1.sqlChar(); + break; + case SqlType::Varchar: + unsigned ulength; + data = f1.sqlVarchar(&ulength); + length = ulength; + break; + default: + ctx_assert(false); + break; + } + if (fc == Expr_func::Left) + pos = 1; + else if (fc == Expr_func::Right) + pos = len > length ? 1 : length - len + 1; + else if (pos < 0) + pos += length + 1; + if (pos <= 0 || pos > length || len <= 0) { + f.sqlNull(true); // oracle-ish + return; + } + if (len > length - pos + 1) + len = length - pos + 1; + switch (t1.type()) { + case SqlType::Char: + f.sqlChar(data + (pos - 1), len); + break; + case SqlType::Varchar: + f.sqlVarchar(data + (pos - 1), len); + break; + default: + ctx_assert(false); + break; + } + } else if (fc == Expr_func::Count) { + ctx_assert(narg == 0 || narg == 1); + if (ctl.m_postEval) + return; + if (narg == 1) { + const SqlField& f1 = args[1]->getData().sqlField(); + if (f1.sqlNull()) + return; + } + f.sqlBigint(++acc.m_count); + } else if (fc == Expr_func::Min) { + ctx_assert(narg == 1); + if (ctl.m_postEval) + return; + const SqlField& f1 = args[1]->getData().sqlField(); + if (f1.sqlNull()) + return; + if (f.sqlNull() || f1.less(f)) + f1.copy(ctx, f); + } else if (fc == Expr_func::Max) { + ctx_assert(narg == 1); + if (ctl.m_postEval) + return; + const SqlField& f1 = args[1]->getData().sqlField(); + if (f1.sqlNull()) + return; + if (f.sqlNull() || f.less(f1)) + f1.copy(ctx, f); + } else if (fc == Expr_func::Sum) { + ctx_assert(narg == 1); + if (ctl.m_postEval) + return; + const SqlType& t1 = args[1]->getCode().sqlSpec().sqlType(); + const SqlField& f1 = args[1]->getData().sqlField(); + if (f1.sqlNull()) + return; + switch (t.type()) { + case SqlType::Bigint: + switch (t1.type()) { + case SqlType::Integer: + acc.m_bigint += f1.sqlInteger(); + break; + case SqlType::Bigint: + acc.m_bigint += f1.sqlBigint(); + break; + default: + ctx_assert(false); + break; + } + f.sqlBigint(acc.m_bigint); + break; + case SqlType::Double: + switch (t1.type()) { + case SqlType::Real: + acc.m_double += f1.sqlReal(); + break; + case SqlType::Double: + acc.m_double += f1.sqlDouble(); + break; + default: + ctx_assert(false); + break; + } + f.sqlDouble(acc.m_double); + break; + default: + ctx_assert(false); + break; + } + } else if (fc == Expr_func::Avg) { + ctx_assert(narg == 1); + if (ctl.m_postEval) + return; + const SqlType& t1 = args[1]->getCode().sqlSpec().sqlType(); + const SqlField& f1 = args[1]->getData().sqlField(); + if (f1.sqlNull()) + return; + switch (t1.type()) { + case SqlType::Smallint: + acc.m_bigint += f1.sqlSmallint(); + break; + case SqlType::Integer: + acc.m_bigint += f1.sqlInteger(); + break; + case SqlType::Bigint: + acc.m_bigint += f1.sqlBigint(); + break; + case SqlType::Real: + acc.m_double += f1.sqlReal(); + break; + case SqlType::Double: + acc.m_double += f1.sqlDouble(); + break; + default: + ctx_assert(false); + break; + } + f.sqlDouble(acc.m_double / (SqlDouble)++acc.m_count); + } else if (fc == Expr_func::Rownum) { + ctx_assert(narg == 0); + if (! ctl.m_postEval) + f.sqlBigint(1 + acc.m_count); + else + acc.m_count++; + } else if (fc == Expr_func::Sysdate) { + ctx_assert(narg == 0); + if (ctl.m_postEval) + return; + f.sqlDatetime(acc.m_sysdate); + } else { + ctx_assert(false); + } +} diff --git a/ndb/src/client/odbc/executor/Exec_expr_op.cpp b/ndb/src/client/odbc/executor/Exec_expr_op.cpp new file mode 100644 index 00000000000..fc8b6df9f5b --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_expr_op.cpp @@ -0,0 +1,147 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +void +Exec_expr_op::evaluate(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + const SqlType& t = code.sqlSpec().sqlType(); + SqlField& f = ctl.m_groupIndex == 0 ? data.m_sqlField : data.groupField(code.sqlSpec().sqlType(), ctl.m_groupIndex, ctl.m_groupInit); + if (code.m_op.arity() == 1) { + // evaluate sub-expression + ctx_assert(m_expr[1] != 0); + m_expr[1]->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + if (ctl.m_postEval) + return; + const SqlField& f1 = ctl.m_groupIndex == 0 ? m_expr[1]->getData().sqlField() : m_expr[1]->getData().groupField(ctl.m_groupIndex); + // handle null + if (f1.sqlNull()) { + f.sqlNull(true); + return; + } + if (t.type() == SqlType::Bigint) { + SqlBigint v = 0; + SqlBigint v1 = f1.sqlBigint(); + switch (code.m_op.m_opcode) { + case Expr_op::Plus: + v = v1; + break; + case Expr_op::Minus: + v = - v1; + break; + default: + ctx_assert(false); + break; + } + f.sqlBigint(v); + } else if (t.type() == SqlType::Double) { + SqlDouble v = 0; + SqlDouble v1 = f1.sqlDouble(); + switch (code.m_op.m_opcode) { + case Expr_op::Plus: + v = v1; + break; + case Expr_op::Minus: + v = - v1; + break; + default: + ctx_assert(false); + break; + } + f.sqlDouble(v); + } else { + ctx_assert(false); + } + } else if (code.m_op.arity() == 2) { + // evaluate sub-expressions + ctx_assert(m_expr[1] != 0 && m_expr[2] != 0); + m_expr[1]->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + m_expr[2]->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + if (ctl.m_postEval) + return; + const SqlField& f1 = ctl.m_groupIndex == 0 ? m_expr[1]->getData().sqlField() : m_expr[1]->getData().groupField(ctl.m_groupIndex); + const SqlField& f2 = ctl.m_groupIndex == 0 ? m_expr[2]->getData().sqlField() : m_expr[2]->getData().groupField(ctl.m_groupIndex); + // handle null + if (f1.sqlNull() || f2.sqlNull()) { + f.sqlNull(true); + return; + } + if (t.type() == SqlType::Bigint) { + SqlBigint v = 0; + SqlBigint v1 = f1.sqlBigint(); + SqlBigint v2 = f2.sqlBigint(); + switch (code.m_op.m_opcode) { + case Expr_op::Add: + v = v1 + v2; + break; + case Expr_op::Subtract: + v = v1 - v2; + break; + case Expr_op::Multiply: + v = v1 * v2; + break; + case Expr_op::Divide: + if (v2 == 0) { + ctx.pushStatus(Sqlstate::_22012, Error::Gen, "integer division by zero"); + return; + } + v = v1 / v2; + break; + default: + ctx_assert(false); + break; + } + f.sqlBigint(v); + } else if (t.type() == SqlType::Double) { + SqlDouble v = 0; + SqlDouble v1 = f1.sqlDouble(); + SqlDouble v2 = f2.sqlDouble(); + switch (code.m_op.m_opcode) { + case Expr_op::Add: + v = v1 + v2; + break; + case Expr_op::Subtract: + v = v1 - v2; + break; + case Expr_op::Multiply: + v = v1 * v2; + break; + case Expr_op::Divide: + v = v1 / v2; + break; + default: + ctx_assert(false); + break; + } + f.sqlDouble(v); // XXX isnan() + } else { + ctx_assert(false); + } + } else { + ctx_assert(false); + } + // result is not null + f.sqlNull(false); +} diff --git a/ndb/src/client/odbc/executor/Exec_insert.cpp b/ndb/src/client/odbc/executor/Exec_insert.cpp new file mode 100644 index 00000000000..c2612c6aaab --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_insert.cpp @@ -0,0 +1,144 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include + +#ifdef NDB_WIN32 +#define FMT_I64 "%I64d" +#else +#define FMT_I64 "%lld" +#endif + +void +Exec_insert::execImpl(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + NdbConnection* const tcon = ndbConnection(); + // execute subquery + ctx_assert(m_query != 0); + m_query->execute(ctx, ctl); + if (! ctx.ok()) + return; + // insert each row from query + data.setCount(0); + while (m_query->fetch(ctx, ctl)) { + NdbOperation* op = tcon->getNdbOperation(code.m_tableName); + if (op == 0) { + ctx.pushStatus(ndb, tcon, 0, "getNdbOperation"); + return; + } + if (code.m_insertOp == Insert_op_insert) { + if (op->insertTuple() == -1) { + ctx.pushStatus(ndb, tcon, op, "insertTuple"); + return; + } + } else if (code.m_insertOp == Insert_op_write) { + if (op->writeTuple() == -1) { + ctx.pushStatus(ndb, tcon, op, "writeTuple"); + return; + } + } else { + ctx_assert(false); + } + const SqlRow& sqlRow = m_query->getData().sqlRow(); + if (code.m_tupleId != 0) { + Uint64 tid = op->setTupleId(); + if (tid == 0) { + ctx.pushStatus(ndb, tcon, op, "setTupleId attrId=%u", (unsigned)code.m_tupleId); + return; + } + ctx_log3(("generated TupleId " FMT_I64, tid)); + } else if (code.m_autoIncrement != 0) { + // XXX use cache size 1 for birdies and fishies + Uint64 tupleId = ndb->getAutoIncrementValue(code.m_tableName, 1); + if (tupleId == 0) { + ctx.pushStatus(ndb, "getTupleIdFromNdb"); + return; + } + NdbAttrId attrId = code.m_autoIncrement - 1; + SqlSmallint sqlSmallint = 0; + SqlInteger sqlInteger = 0; + SqlBigint sqlBigint = 0; + const char* value = 0; + if (code.m_idType.type() == SqlType::Smallint) { + sqlSmallint = tupleId; + value = (const char*)&sqlSmallint; + } else if (code.m_idType.type() == SqlType::Integer) { + sqlInteger = tupleId; + value = (const char*)&sqlInteger; + } else if (code.m_idType.type() == SqlType::Bigint) { + sqlBigint = tupleId; + value = (const char*)&sqlBigint; + } else { + ctx_assert(false); + } + if (op->equal(attrId, value) == -1) { + ctx.pushStatus(ndb, tcon, op, "equal attrId=%u", (unsigned)attrId); + return; + } + } else { + // normal key attributes + for (unsigned i = 1; i <= sqlRow.count(); i++) { + if (! code.m_isKey[i]) + continue; + NdbAttrId attrId = code.m_attrId[i]; + const SqlField& f = sqlRow.getEntry(i); + const void* addr = f.sqlNull() ? 0 : f.addr(); + const char* value = static_cast(addr); + if (op->equal(attrId, value) == -1) { + ctx.pushStatus(ndb, tcon, op, "equal attrId=%u", (unsigned)attrId); + return; + } + } + } + // non-key attributes + for (unsigned i = 1; i <= sqlRow.count(); i++) { + if (code.m_isKey[i]) + continue; + NdbAttrId attrId = code.m_attrId[i]; + const SqlField& f = sqlRow.getEntry(i); + const void* addr = f.sqlNull() ? 0 : f.addr(); + const char* value = static_cast(addr); + if (op->setValue(attrId, value) == -1) { + ctx.pushStatus(ndb, tcon, op, "setValue attrId=%u", (unsigned)attrId); + return; + } + } + // default non-key values + for (unsigned i = 1; i <= code.m_defaultCount; i++) { + NdbAttrId attrId = code.m_defaultId[i]; + const SqlField& f = code.m_defaultValue->getEntry(i); + const void* addr = f.sqlNull() ? 0 : f.addr(); + const char* value = static_cast(addr); + if (op->setValue(attrId, value) == -1) { + ctx.pushStatus(ndb, tcon, op, "setValue attrId=%u", (unsigned)attrId); + return; + } + } + if (tcon->execute(NoCommit) == -1) { + ctx.pushStatus(ndb, tcon, op, "execute without commit"); + return; + } + data.addCount(); + } + stmtArea().setRowCount(ctx, data.getCount()); +} diff --git a/ndb/src/client/odbc/executor/Exec_pred_op.cpp b/ndb/src/client/odbc/executor/Exec_pred_op.cpp new file mode 100644 index 00000000000..7caa4656473 --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_pred_op.cpp @@ -0,0 +1,197 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include + +struct TableUnary { + Pred_value value1; + Pred_value result; +}; + +struct TableBinary { + Pred_value value1; + Pred_value value2; + Pred_value result; +}; + +static TableUnary +tableNot[] = { + { Pred_value_unknown, Pred_value_unknown }, + { Pred_value_false, Pred_value_true }, + { Pred_value_true, Pred_value_false }, +}; + +static TableBinary +tableAnd[] = { + { Pred_value_unknown, Pred_value_unknown, Pred_value_unknown }, + { Pred_value_unknown, Pred_value_false, Pred_value_false }, + { Pred_value_unknown, Pred_value_true, Pred_value_unknown }, + { Pred_value_false, Pred_value_unknown, Pred_value_false }, + { Pred_value_false, Pred_value_false, Pred_value_false }, + { Pred_value_false, Pred_value_true, Pred_value_false }, + { Pred_value_true, Pred_value_unknown, Pred_value_unknown }, + { Pred_value_true, Pred_value_false, Pred_value_false }, + { Pred_value_true, Pred_value_true, Pred_value_true } +}; + +static TableBinary +tableOr[] = { + { Pred_value_unknown, Pred_value_unknown, Pred_value_unknown }, + { Pred_value_unknown, Pred_value_false, Pred_value_unknown }, + { Pred_value_unknown, Pred_value_true, Pred_value_true }, + { Pred_value_false, Pred_value_unknown, Pred_value_unknown }, + { Pred_value_false, Pred_value_false, Pred_value_false }, + { Pred_value_false, Pred_value_true, Pred_value_true }, + { Pred_value_true, Pred_value_unknown, Pred_value_true }, + { Pred_value_true, Pred_value_false, Pred_value_true }, + { Pred_value_true, Pred_value_true, Pred_value_true } +}; + +void +Exec_pred_op::execInterp(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + ctx_assert(ctl.m_scanFilter != 0); + NdbScanFilter& scanFilter = *ctl.m_scanFilter; + if (code.m_op.arity() == 1) { + ctx_assert(m_pred[1] != 0); + switch (code.m_op.m_opcode) { + case Pred_op::Not: + scanFilter.begin(NdbScanFilter::NAND); + m_pred[1]-> execInterp(ctx, ctl); + if (! ctx.ok()) + return; + scanFilter.end(); + break; + default: + ctx_assert(false); + break; + } + } else if (code.m_op.arity() == 2) { + ctx_assert(m_pred[1] != 0 && m_pred[2] != 0); + switch (code.m_op.m_opcode) { + case Pred_op::And: + scanFilter.begin(NdbScanFilter::AND); + m_pred[1]-> execInterp(ctx, ctl); + if (! ctx.ok()) + return; + m_pred[2]-> execInterp(ctx, ctl); + if (! ctx.ok()) + return; + scanFilter.end(); + break; + case Pred_op::Or: + scanFilter.begin(NdbScanFilter::OR); + m_pred[1]-> execInterp(ctx, ctl); + if (! ctx.ok()) + return; + m_pred[2]-> execInterp(ctx, ctl); + if (! ctx.ok()) + return; + scanFilter.end(); + break; + default: + ctx_assert(false); + break; + } + } else { + ctx_assert(false); + } +} + +void +Exec_pred_op::evaluate(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Pred_value v = Pred_value_unknown; + if (code.m_op.arity() == 1) { + // evaluate sub-expression + ctx_assert(m_pred[1] != 0); + m_pred[1]->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + if (ctl.m_postEval) + return; + Pred_value v1 = ctl.m_groupIndex == 0 ? m_pred[1]->getData().getValue() : m_pred[1]->getData().groupValue(ctl.m_groupIndex); + // look up result + TableUnary* table = 0; + unsigned size = 0; + switch (code.m_op.m_opcode) { + case Pred_op::Not: + table = tableNot; + size = sizeof(tableNot) / sizeof(tableNot[0]); + break; + default: + ctx_assert(false); + break; + } + unsigned i; + for (i = 0; i < size; i++) { + if (table[i].value1 == v1) { + v = table[i].result; + break; + } + } + ctx_assert(i < size); + } else if (code.m_op.arity() == 2) { + // evaluate sub-expressions + ctx_assert(m_pred[1] != 0 && m_pred[2] != 0); + m_pred[1]->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + m_pred[2]->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + if (ctl.m_postEval) + return; + Pred_value v1 = ctl.m_groupIndex == 0 ? m_pred[1]->getData().getValue() : m_pred[1]->getData().groupValue(ctl.m_groupIndex); + Pred_value v2 = ctl.m_groupIndex == 0 ? m_pred[2]->getData().getValue() : m_pred[2]->getData().groupValue(ctl.m_groupIndex); + // look up result + TableBinary* table = 0; + unsigned size = 0; + switch (code.m_op.m_opcode) { + case Pred_op::And: + table = tableAnd; + size = sizeof(tableAnd) / sizeof(tableAnd[0]); + break; + case Pred_op::Or: + table = tableOr; + size = sizeof(tableOr) / sizeof(tableOr[0]); + break; + default: + ctx_assert(false); + break; + } + unsigned i; + for (i = 0; i < size; i++) { + if (table[i].value1 == v1 && table[i].value2 == v2) { + v = table[i].result; + break; + } + } + ctx_assert(i < size); + } else { + ctx_assert(false); + } + // set result + if (ctl.m_groupIndex == 0) + data.m_value = v; + else + data.groupValue(ctl.m_groupIndex, ctl.m_groupInit) = v; +} diff --git a/ndb/src/client/odbc/executor/Exec_query_index.cpp b/ndb/src/client/odbc/executor/Exec_query_index.cpp new file mode 100644 index 00000000000..919743beac2 --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_query_index.cpp @@ -0,0 +1,136 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include +#include + +void +Exec_query_index::execImpl(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + data.m_done = false; + Ndb* const ndb = ndbObject(); + NdbConnection* const tcon = ndbConnection(); + if (data.m_con != 0) { + ndb->closeTransaction(data.m_con); + data.m_con = 0; + data.m_op = 0; + ctx_log2(("lookup closed at re-execute")); + } + const bool unco = connArea().uncommitted(); + if (! unco) { + // use new transaction to not run out of operations + data.m_con = ndb->startTransaction(); + if (data.m_con == 0) { + ctx.pushStatus(ndb, "startTransaction"); + return; + } + } else { + ctx_log3(("lookup using main transaction")); + } + data.m_op = (unco ? tcon : data.m_con)->getNdbIndexOperation(code.m_indexName, code.m_tableName); + if (data.m_op == 0) { + ctx.pushStatus(ndb, (unco ? tcon : data.m_con), 0, "getNdbIndexOperation"); + return; + } + if (data.m_op->readTuple() == -1) { + ctx.pushStatus(ndb, (unco ? tcon : data.m_con), data.m_op, "readTuple"); + return; + } + // key attributes + for (unsigned k = 1; k <= code.m_keyCount; k++) { + Exec_expr* exprMatch = code.m_keyMatch[k]; + ctx_assert(exprMatch != 0); + exprMatch->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + const SqlField& keyMatch = exprMatch->getData().sqlField(); + SqlField f(code.m_keySpecs.getEntry(k)); + if (! keyMatch.cast(ctx, f)) { + data.m_done = true; // match is not possible + return; + } + const NdbAttrId keyId = code.m_keyId[k]; + const void* addr = f.addr(); + const char* value = static_cast(addr); + if (data.m_op->equal(keyId, value) == -1) { + ctx.pushStatus(ndb, (unco ? tcon : data.m_con), data.m_op, "equal attrId=%u", (unsigned)keyId); + return; + } + } + // queried attributes + const SqlRow& sqlRow = data.sqlRow(); + ctx_assert(sqlRow.count() == code.m_attrCount); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + const NdbAttrId attrId = code.m_attrId[i]; + SqlField& f = sqlRow.getEntry(i); + char* addr = static_cast(f.addr()); + NdbRecAttr* recAttr = data.m_op->getValue(attrId, addr); + if (recAttr == 0) { + ctx.pushStatus(ndb, (unco ? tcon : data.m_con), data.m_op, "getValue attrId=%u", (unsigned)attrId); + return; + } + data.m_recAttr[i] = recAttr; + } + if (code.m_attrCount == 0) { // NDB requires one + (void)data.m_op->getValue((NdbAttrId)0); + } + data.setCount(0); + if ((unco ? tcon : data.m_con)->execute(unco ? NoCommit : Commit) == -1) { + // XXX when did 626 move to connection level + if ((unco ? tcon : data.m_con)->getNdbError().code != 626 && data.m_op->getNdbError().code != 626) { + ctx.pushStatus(ndb, (unco ? tcon : data.m_con), data.m_op, "execute xxx"); + return; + } + data.m_done = true; + } else { + stmtArea().incTuplesFetched(); + data.m_done = false; + } + if (! unco) { + ndb->closeTransaction(data.m_con); + data.m_con = 0; + data.m_op = 0; + ctx_log3(("index lookup closed at execute")); + } +} + +bool +Exec_query_index::fetchImpl(Ctx &ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + // returns at most one row + if (data.m_done) + return false; + // set null bits + const SqlRow& sqlRow = data.sqlRow(); + ctx_assert(sqlRow.count() == code.m_attrCount); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + NdbRecAttr* recAttr = data.m_recAttr[i]; + int isNULL = recAttr->isNULL(); + SqlField& f = sqlRow.getEntry(i); + ctx_assert(isNULL == 0 || isNULL == 1); + f.sqlNull(isNULL == 1); + } + data.m_done = true; + return true; +} diff --git a/ndb/src/client/odbc/executor/Exec_query_lookup.cpp b/ndb/src/client/odbc/executor/Exec_query_lookup.cpp new file mode 100644 index 00000000000..599e1a36461 --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_query_lookup.cpp @@ -0,0 +1,136 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include +#include + +void +Exec_query_lookup::execImpl(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + data.m_done = false; + Ndb* const ndb = ndbObject(); + NdbConnection* const tcon = ndbConnection(); + if (data.m_con != 0) { + ndb->closeTransaction(data.m_con); + data.m_con = 0; + data.m_op = 0; + ctx_log2(("lookup closed at re-execute")); + } + const bool unco = connArea().uncommitted(); + if (! unco) { + // use new transaction to not run out of operations + data.m_con = ndb->startTransaction(); + if (data.m_con == 0) { + ctx.pushStatus(ndb, "startTransaction"); + return; + } + } else { + ctx_log3(("lookup using main transaction")); + } + data.m_op = (unco ? tcon : data.m_con)->getNdbOperation(code.m_tableName); + if (data.m_op == 0) { + ctx.pushStatus(ndb, (unco ? tcon : data.m_con), 0, "getNdbOperation"); + return; + } + if (data.m_op->readTuple() == -1) { + ctx.pushStatus(ndb, (unco ? tcon : data.m_con), data.m_op, "readTuple"); + return; + } + // key attributes + for (unsigned k = 1; k <= code.m_keyCount; k++) { + Exec_expr* exprMatch = code.m_keyMatch[k]; + ctx_assert(exprMatch != 0); + exprMatch->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + const SqlField& keyMatch = exprMatch->getData().sqlField(); + SqlField f(code.m_keySpecs.getEntry(k)); + if (! keyMatch.cast(ctx, f)) { + data.m_done = true; // match is not possible + return; + } + const NdbAttrId keyId = code.m_keyId[k]; + const void* addr = f.addr(); + const char* value = static_cast(addr); + if (data.m_op->equal(keyId, value) == -1) { + ctx.pushStatus(ndb, (unco ? tcon : data.m_con), data.m_op, "equal attrId=%u", (unsigned)keyId); + return; + } + } + // queried attributes + const SqlRow& sqlRow = data.sqlRow(); + ctx_assert(sqlRow.count() == code.m_attrCount); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + const NdbAttrId attrId = code.m_attrId[i]; + SqlField& f = sqlRow.getEntry(i); + char* addr = static_cast(f.addr()); + NdbRecAttr* recAttr = data.m_op->getValue(attrId, addr); + if (recAttr == 0) { + ctx.pushStatus(ndb, (unco ? tcon : data.m_con), data.m_op, "getValue attrId=%u", (unsigned)attrId); + return; + } + data.m_recAttr[i] = recAttr; + } + if (code.m_attrCount == 0) { // NDB requires one + (void)data.m_op->getValue((NdbAttrId)0); + } + data.setCount(0); + if ((unco ? tcon : data.m_con)->execute(unco ? NoCommit : Commit) == -1) { + // XXX when did 626 move to connection level + if ((unco ? tcon : data.m_con)->getNdbError().code != 626 && data.m_op->getNdbError().code != 626) { + ctx.pushStatus(ndb, (unco ? tcon : data.m_con), data.m_op, "execute xxx"); + return; + } + data.m_done = true; + } else { + stmtArea().incTuplesFetched(); + data.m_done = false; + } + if (! unco) { + ndb->closeTransaction(data.m_con); + data.m_con = 0; + data.m_op = 0; + ctx_log3(("lookup closed at execute")); + } +} + +bool +Exec_query_lookup::fetchImpl(Ctx &ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + // returns at most one row + if (data.m_done) + return false; + // set null bits + const SqlRow& sqlRow = data.sqlRow(); + ctx_assert(sqlRow.count() == code.m_attrCount); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + NdbRecAttr* recAttr = data.m_recAttr[i]; + int isNULL = recAttr->isNULL(); + SqlField& f = sqlRow.getEntry(i); + ctx_assert(isNULL == 0 || isNULL == 1); + f.sqlNull(isNULL == 1); + } + data.m_done = true; + return true; +} diff --git a/ndb/src/client/odbc/executor/Exec_query_range.cpp b/ndb/src/client/odbc/executor/Exec_query_range.cpp new file mode 100644 index 00000000000..0bc878d760d --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_query_range.cpp @@ -0,0 +1,143 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include +#include + +#define startBuddyTransaction(x) hupp(x) + +void +Exec_query_range::execImpl(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + data.m_done = false; + Ndb* const ndb = ndbObject(); + NdbConnection* const tcon = ndbConnection(); + if (data.m_con != 0) { + data.m_con->stopScan(); + ndb->closeTransaction(data.m_con); + data.m_con = 0; + data.m_op = 0; + ctx_log2(("range scan closed at re-execute")); + } + data.m_con = ndb->startBuddyTransaction(tcon); + if (data.m_con == 0) { + ctx.pushStatus(ndb, tcon, 0, "startBuddyTransaction"); + return; + } + data.m_op = data.m_con->getNdbOperation(code.m_indexName, code.m_tableName); + if (data.m_op == 0) { + ctx.pushStatus(ndb, data.m_con, 0, "getNdbOperation"); + return; + } + if (! code.m_exclusive) { + if (data.m_op->openScanReadCommitted(data.m_parallel) == -1) { + ctx.pushStatus(ndb, data.m_con, data.m_op, "openScanReadCommitted"); + return; + } + } else { + if (data.m_op->openScanExclusive(data.m_parallel) == -1) { + ctx.pushStatus(ndb, data.m_con, data.m_op, "openScanExclusive"); + return; + } + } + // set bounds + for (unsigned k = 1; k <= code.m_keyCount; k++) { + Exec_expr* exprMatch = code.m_keyMatch[k]; + ctx_assert(exprMatch != 0); + exprMatch->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + const SqlField& keyMatch = exprMatch->getData().sqlField(); + SqlField f(code.m_keySpecs.getEntry(k)); + if (! keyMatch.cast(ctx, f)) { + data.m_done = true; // match is not possible + return; + } + const NdbAttrId keyId = code.m_keyId[k]; + const void* addr = f.addr(); + const char* value = static_cast(addr); + const unsigned len = f.allocSize(); + if (data.m_op->setBound(keyId, NdbOperation::BoundEQ, value, len) == -1) { + ctx.pushStatus(ndb, data.m_con, data.m_op, "setBound attrId=%u", (unsigned)keyId); + return; + } + } + // queried attributes + const SqlRow& sqlRow = data.sqlRow(); + ctx_assert(sqlRow.count() == code.m_attrCount); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + const NdbAttrId attrId = code.m_attrId[i]; + SqlField& f = sqlRow.getEntry(i); + char* addr = static_cast(f.addr()); + NdbRecAttr* recAttr = data.m_op->getValue(attrId, addr); + if (recAttr == 0) { + ctx.pushStatus(ndb, data.m_con, data.m_op, "getValue attrId=%u", (unsigned)attrId); + return; + } + data.m_recAttr[i] = recAttr; + } + if (code.m_attrCount == 0) { // NDB requires one + (void)data.m_op->getValue((NdbAttrId)0); + } + data.setCount(0); + if (data.m_con->executeScan() == -1) { + ctx.pushStatus(ndb, data.m_con, data.m_op, "executeScan"); + return; + } + ctx_log2(("range scan %s [%08x] started", ! code.m_exclusive ? "read" : "exclusive", (unsigned)this)); + ctl.m_scanOp = data.m_op; +} + +bool +Exec_query_range::fetchImpl(Ctx &ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + // if never started + if (data.m_done) + return false; + int ret = data.m_con->nextScanResult(); + if (ret != 0) { + if (ret == -1) { + ctx.pushStatus(ndb, data.m_con, data.m_op, "nextScanResult"); + } + data.m_con->stopScan(); + ndb->closeTransaction(data.m_con); + data.m_con = 0; + data.m_op = 0; + ctx_log2(("range scan [%08x] closed at last row", (unsigned)this)); + return false; + } + // set null bits + const SqlRow& sqlRow = data.sqlRow(); + ctx_assert(sqlRow.count() == code.m_attrCount); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + NdbRecAttr* recAttr = data.m_recAttr[i]; + int isNULL = recAttr->isNULL(); + SqlField& f = sqlRow.getEntry(i); + ctx_assert(isNULL == 0 || isNULL == 1); + f.sqlNull(isNULL == 1); + } + stmtArea().incTuplesFetched(); + return true; +} diff --git a/ndb/src/client/odbc/executor/Exec_query_scan.cpp b/ndb/src/client/odbc/executor/Exec_query_scan.cpp new file mode 100644 index 00000000000..213dfdd616d --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_query_scan.cpp @@ -0,0 +1,130 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include +#include + +#define startBuddyTransaction(x) hupp(x) + +void +Exec_query_scan::execImpl(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + NdbConnection* const tcon = ndbConnection(); + if (data.m_con != 0) { + data.m_con->stopScan(); + ndb->closeTransaction(data.m_con); + data.m_con = 0; + data.m_op = 0; + ctx_log2(("scan closed at re-execute")); + } + data.m_con = ndb->startBuddyTransaction(tcon); + if (data.m_con == 0) { + ctx.pushStatus(ndb, tcon, 0, "startBuddyTransaction"); + return; + } + data.m_op = data.m_con->getNdbOperation(code.m_tableName); + if (data.m_op == 0) { + ctx.pushStatus(ndb, data.m_con, 0, "getNdbOperation"); + return; + } + if (! code.m_exclusive) { + if (data.m_op->openScanReadCommitted(data.m_parallel) == -1) { + ctx.pushStatus(ndb, data.m_con, data.m_op, "openScanReadCommitted"); + return; + } + } else { + if (data.m_op->openScanExclusive(data.m_parallel) == -1) { + ctx.pushStatus(ndb, data.m_con, data.m_op, "openScanExclusive"); + return; + } + } + if (m_interp == 0) { + // XXX unnecessary + if (data.m_op->interpret_exit_ok() == -1) { + ctx.pushStatus(ndb, data.m_con, data.m_op, "interpret_exit_ok"); + return; + } + } else { + NdbScanFilter scanFilter(data.m_op); + scanFilter.begin(NdbScanFilter::AND); + ctl.m_scanFilter = &scanFilter; + m_interp->execInterp(ctx, ctl); + if (! ctx.ok()) + return; + scanFilter.end(); + } + const SqlRow& sqlRow = data.sqlRow(); + ctx_assert(sqlRow.count() == code.m_attrCount); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + const NdbAttrId attrId = code.m_attrId[i]; + SqlField& sqlField = sqlRow.getEntry(i); + char* addr = static_cast(sqlField.addr()); + NdbRecAttr* recAttr = data.m_op->getValue(attrId, addr); + if (recAttr == 0) { + ctx.pushStatus(ndb, data.m_con, data.m_op, "getValue attrId=%u", (unsigned)attrId); + return; + } + data.m_recAttr[i] = recAttr; + } + if (code.m_attrCount == 0) { // NDB requires one + (void)data.m_op->getValue((NdbAttrId)0); + } + if (data.m_con->executeScan() == -1) { + ctx.pushStatus(ndb, data.m_con, data.m_op, "executeScan"); + return; + } + ctx_log2(("scan %s [%08x] started", ! code.m_exclusive ? "read" : "exclusive", (unsigned)this)); + ctl.m_scanOp = data.m_op; +} + +bool +Exec_query_scan::fetchImpl(Ctx &ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + int ret = data.m_con->nextScanResult(); + if (ret != 0) { + if (ret == -1) { + ctx.pushStatus(ndb, data.m_con, data.m_op, "nextScanResult"); + } + data.m_con->stopScan(); + ndb->closeTransaction(data.m_con); + data.m_con = 0; + data.m_op = 0; + ctx_log2(("scan [%08x] closed at last row", (unsigned)this)); + return false; + } + // set null bits + const SqlRow& sqlRow = data.sqlRow(); + ctx_assert(sqlRow.count() == code.m_attrCount); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + NdbRecAttr* recAttr = data.m_recAttr[i]; + int isNULL = recAttr->isNULL(); + SqlField& sqlField = sqlRow.getEntry(i); + ctx_assert(isNULL == 0 || isNULL == 1); + sqlField.sqlNull(isNULL == 1); + } + stmtArea().incTuplesFetched(); + return true; +} diff --git a/ndb/src/client/odbc/executor/Exec_query_sys.cpp b/ndb/src/client/odbc/executor/Exec_query_sys.cpp new file mode 100644 index 00000000000..acdc120e609 --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_query_sys.cpp @@ -0,0 +1,761 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include + +#define NULL_CHAR ((char*)0) +#define NULL_INT (-2147483647) + +struct Typeinfo { + const char* m_type_name; // 1 + int m_data_type; // 2 + int m_column_size; // 3 + const char* m_literal_prefix; // 4 + const char* m_literal_suffix; // 5 + const char* m_create_params; // 6 + int m_nullable; // 7 + int m_case_sensitive; // 8 + int m_searchable; // 9 + int m_unsigned_attribute; // 10 + int m_fixed_prec_scale; // 11 + int m_auto_unique_value; // 12 + const char* m_local_type_name; // 13 + int m_minimum_scale; // 14 + int m_maximum_scale; // 15 + int m_sql_data_type; // 16 + int m_sql_datetime_sub; // 17 + int m_num_prec_radix; // 18 + int m_interval_precision; // 19 +}; + +static const Typeinfo +typeinfoList[] = { + { "CHAR", // 1 + SQL_CHAR, // 2 + 8000, // 3 + "'", // 4 + "'", // 5 + "length", // 6 + SQL_NULLABLE, // 7 + SQL_TRUE, // 8 + SQL_SEARCHABLE, // 9 + NULL_INT, // 10 + SQL_FALSE, // 11 + NULL_INT, // 12 + NULL_CHAR, // 13 + NULL_INT, // 14 + NULL_INT, // 15 + SQL_CHAR, // 16 + NULL_INT, // 17 + NULL_INT, // 18 + NULL_INT // 19 + }, + { "VARCHAR", // 1 + SQL_VARCHAR, // 2 + 8000, // 3 + "'", // 4 + "'", // 5 + "length", // 6 + SQL_NULLABLE, // 7 + SQL_TRUE, // 8 + SQL_SEARCHABLE, // 9 + NULL_INT, // 10 + SQL_FALSE, // 11 + NULL_INT, // 12 + NULL_CHAR, // 13 + NULL_INT, // 14 + NULL_INT, // 15 + SQL_VARCHAR, // 16 + NULL_INT, // 17 + NULL_INT, // 18 + NULL_INT // 19 + }, + { "BINARY", // 1 + SQL_BINARY, // 2 + 8000, // 3 + "'", // 4 + "'", // 5 + "length", // 6 + SQL_NULLABLE, // 7 + SQL_TRUE, // 8 + SQL_SEARCHABLE, // 9 + NULL_INT, // 10 + SQL_FALSE, // 11 + NULL_INT, // 12 + NULL_CHAR, // 13 + NULL_INT, // 14 + NULL_INT, // 15 + SQL_BINARY, // 16 + NULL_INT, // 17 + NULL_INT, // 18 + NULL_INT // 19 + }, + { "VARBINARY", // 1 + SQL_VARBINARY, // 2 + 8000, // 3 + "'", // 4 + "'", // 5 + "length", // 6 + SQL_NULLABLE, // 7 + SQL_TRUE, // 8 + SQL_SEARCHABLE, // 9 + NULL_INT, // 10 + SQL_FALSE, // 11 + NULL_INT, // 12 + NULL_CHAR, // 13 + NULL_INT, // 14 + NULL_INT, // 15 + SQL_VARBINARY, // 16 + NULL_INT, // 17 + NULL_INT, // 18 + NULL_INT // 19 + }, + { "SMALLINT", // 1 + SQL_SMALLINT, // 2 + 4, // 3 + NULL_CHAR, // 4 + NULL_CHAR, // 5 + NULL_CHAR, // 6 + SQL_NULLABLE, // 7 + SQL_FALSE, // 8 + SQL_SEARCHABLE, // 9 + SQL_FALSE, // 10 + SQL_TRUE, // 11 + SQL_FALSE, // 12 + NULL_CHAR, // 13 + NULL_INT, // 14 + NULL_INT, // 15 + SQL_SMALLINT, // 16 + NULL_INT, // 17 + 10, // 18 + NULL_INT // 19 + }, + { "SMALLINT UNSIGNED", // 1 + SQL_SMALLINT, // 2 + 4, // 3 + NULL_CHAR, // 4 + NULL_CHAR, // 5 + NULL_CHAR, // 6 + SQL_NULLABLE, // 7 + SQL_FALSE, // 8 + SQL_SEARCHABLE, // 9 + SQL_TRUE, // 10 + SQL_TRUE, // 11 + SQL_FALSE, // 12 + NULL_CHAR, // 13 + NULL_INT, // 14 + NULL_INT, // 15 + SQL_SMALLINT, // 16 + NULL_INT, // 17 + 10, // 18 + NULL_INT // 19 + }, + { "INT", // 1 + SQL_INTEGER, // 2 + 9, // 3 + NULL_CHAR, // 4 + NULL_CHAR, // 5 + NULL_CHAR, // 6 + SQL_NULLABLE, // 7 + SQL_FALSE, // 8 + SQL_SEARCHABLE, // 9 + SQL_FALSE, // 10 + SQL_TRUE, // 11 + SQL_FALSE, // 12 + NULL_CHAR, // 13 + NULL_INT, // 14 + NULL_INT, // 15 + SQL_INTEGER, // 16 + NULL_INT, // 17 + 10, // 18 + NULL_INT // 19 + }, + { "INT UNSIGNED", // 1 + SQL_INTEGER, // 2 + 9, // 3 + NULL_CHAR, // 4 + NULL_CHAR, // 5 + NULL_CHAR, // 6 + SQL_NULLABLE, // 7 + SQL_FALSE, // 8 + SQL_SEARCHABLE, // 9 + SQL_TRUE, // 10 + SQL_TRUE, // 11 + SQL_FALSE, // 12 + NULL_CHAR, // 13 + NULL_INT, // 14 + NULL_INT, // 15 + SQL_INTEGER, // 16 + NULL_INT, // 17 + 10, // 18 + NULL_INT // 19 + }, + { "BIGINT", // 1 + SQL_BIGINT, // 2 + 19, // 3 + NULL_CHAR, // 4 + NULL_CHAR, // 5 + NULL_CHAR, // 6 + SQL_NULLABLE, // 7 + SQL_FALSE, // 8 + SQL_SEARCHABLE, // 9 + SQL_FALSE, // 10 + SQL_TRUE, // 11 + SQL_FALSE, // 12 + NULL_CHAR, // 13 + NULL_INT, // 14 + NULL_INT, // 15 + SQL_BIGINT, // 16 + NULL_INT, // 17 + 10, // 18 + NULL_INT // 19 + }, + { "BIGINT UNSIGNED", // 1 + SQL_BIGINT, // 2 + 19, // 3 + NULL_CHAR, // 4 + NULL_CHAR, // 5 + NULL_CHAR, // 6 + SQL_NULLABLE, // 7 + SQL_FALSE, // 8 + SQL_SEARCHABLE, // 9 + SQL_TRUE, // 10 + SQL_TRUE, // 11 + SQL_FALSE, // 12 + NULL_CHAR, // 13 + NULL_INT, // 14 + NULL_INT, // 15 + SQL_BIGINT, // 16 + NULL_INT, // 17 + 10, // 18 + NULL_INT // 19 + }, + { "REAL", // 1 + SQL_REAL, // 2 + 31, // 3 + NULL_CHAR, // 4 + NULL_CHAR, // 5 + NULL_CHAR, // 6 + SQL_NULLABLE, // 7 + SQL_FALSE, // 8 + SQL_SEARCHABLE, // 9 + SQL_FALSE, // 10 + SQL_TRUE, // 11 + SQL_FALSE, // 12 + NULL_CHAR, // 13 + NULL_INT, // 14 + NULL_INT, // 15 + SQL_REAL, // 16 + NULL_INT, // 17 + 2, // 18 + NULL_INT // 19 + }, + { "FLOAT", // 1 + SQL_DOUBLE, // 2 + 63, // 3 + NULL_CHAR, // 4 + NULL_CHAR, // 5 + NULL_CHAR, // 6 + SQL_NULLABLE, // 7 + SQL_FALSE, // 8 + SQL_SEARCHABLE, // 9 + SQL_FALSE, // 10 + SQL_TRUE, // 11 + SQL_FALSE, // 12 + NULL_CHAR, // 13 + NULL_INT, // 14 + NULL_INT, // 15 + SQL_DOUBLE, // 16 + NULL_INT, // 17 + 2, // 18 + NULL_INT // 19 + }, + { "DATETIME", // 1 + SQL_TYPE_TIMESTAMP, // 2 + 30, // 3 + NULL_CHAR, // 4 + NULL_CHAR, // 5 + NULL_CHAR, // 6 + SQL_NULLABLE, // 7 + SQL_FALSE, // 8 + SQL_SEARCHABLE, // 9 + SQL_FALSE, // 10 + SQL_TRUE, // 11 + SQL_FALSE, // 12 + NULL_CHAR, // 13 + NULL_INT, // 14 + NULL_INT, // 15 + SQL_DATETIME, // 16 XXX + NULL_INT, // 17 + 2, // 18 + NULL_INT // 19 + } +}; + +const unsigned +typeinfoCount = sizeof(typeinfoList)/sizeof(typeinfoList[0]); + +void +Exec_query_sys::execImpl(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + NdbDictionary::Dictionary* ndbDictionary = ndb->getDictionary(); + if (ndbDictionary == 0) { + ctx.pushStatus(ndb, "getDictionary"); + return; + } + if (code.m_sysId == DictSys::OdbcTypeinfo || code.m_sysId == DictSys::Dual) { + data.m_rowPos = 0; // at first entry + return; + } + if (code.m_sysId == DictSys::OdbcTables || code.m_sysId == DictSys::OdbcColumns || code.m_sysId == DictSys::OdbcPrimarykeys) { + // take all objects + if (ndbDictionary->listObjects(data.m_objectList) == -1) { + ctx.pushStatus(ndb, "listObjects"); + return; + } + data.m_tablePos = 0; // at first entry + data.m_attrPos = 0; + data.m_keyPos = 0; + return; + } + ctx_assert(false); +} + +static bool +isNdbTable(const NdbDictionary::Dictionary::List::Element& element) +{ + switch (element.type) { + //case NdbDictionary::Object::SystemTable: + case NdbDictionary::Object::UserTable: + case NdbDictionary::Object::UniqueHashIndex: + case NdbDictionary::Object::HashIndex: + case NdbDictionary::Object::UniqueOrderedIndex: + case NdbDictionary::Object::OrderedIndex: + return true; + default: + break; + } + return false; +} + + +bool +Exec_query_sys::fetchImpl(Ctx &ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + NdbDictionary::Dictionary* ndbDictionary = ndb->getDictionary(); + if (ndbDictionary == 0) { + ctx.pushStatus(ndb, "getDictionary"); + return false; + } + if (code.m_sysId == DictSys::OdbcTypeinfo) { + if (data.m_rowPos >= typeinfoCount) { + return false; + } + SqlRow& row = data.m_sqlRow; + const Typeinfo& typeinfo = typeinfoList[data.m_rowPos++]; + for (unsigned i = 1; i <= code.m_attrCount; i++) { + SqlField& f = data.m_sqlRow.getEntry(i); + switch (1 + code.m_attrId[i]) { + case 1: + if (typeinfo.m_type_name == NULL_CHAR) + f.sqlNull(true); + else + f.sqlVarchar(typeinfo.m_type_name, SQL_NTS); + break; + case 2: + if (typeinfo.m_data_type == NULL_INT) + f.sqlNull(true); + else + f.sqlInteger(typeinfo.m_data_type); + break; + case 3: + if (typeinfo.m_column_size == NULL_INT) + f.sqlNull(true); + else + f.sqlInteger(typeinfo.m_column_size); + break; + case 4: + if (typeinfo.m_literal_prefix == NULL_CHAR) + f.sqlNull(true); + else + f.sqlVarchar(typeinfo.m_literal_prefix, SQL_NTS); + break; + case 5: + if (typeinfo.m_literal_suffix == NULL_CHAR) + f.sqlNull(true); + else + f.sqlVarchar(typeinfo.m_literal_suffix, SQL_NTS); + break; + case 6: + if (typeinfo.m_create_params == NULL_CHAR) + f.sqlNull(true); + else + f.sqlVarchar(typeinfo.m_create_params, SQL_NTS); + break; + case 7: + if (typeinfo.m_nullable == NULL_INT) + f.sqlNull(true); + else + f.sqlInteger(typeinfo.m_nullable); + break; + case 8: + if (typeinfo.m_case_sensitive == NULL_INT) + f.sqlNull(true); + else + f.sqlInteger(typeinfo.m_case_sensitive); + break; + case 9: + if (typeinfo.m_searchable == NULL_INT) + f.sqlNull(true); + else + f.sqlInteger(typeinfo.m_searchable); + break; + case 10: + if (typeinfo.m_unsigned_attribute == NULL_INT) + f.sqlNull(true); + else + f.sqlInteger(typeinfo.m_unsigned_attribute); + break; + case 11: + if (typeinfo.m_fixed_prec_scale == NULL_INT) + f.sqlNull(true); + else + f.sqlInteger(typeinfo.m_fixed_prec_scale); + break; + case 12: + if (typeinfo.m_auto_unique_value == NULL_INT) + f.sqlNull(true); + else + f.sqlInteger(typeinfo.m_auto_unique_value); + break; + case 13: + if (typeinfo.m_local_type_name == NULL_CHAR) + f.sqlNull(true); + else + f.sqlVarchar(typeinfo.m_local_type_name, SQL_NTS); + break; + case 14: + if (typeinfo.m_minimum_scale == NULL_INT) + f.sqlNull(true); + else + f.sqlInteger(typeinfo.m_minimum_scale); + break; + case 15: + if (typeinfo.m_maximum_scale == NULL_INT) + f.sqlNull(true); + else + f.sqlInteger(typeinfo.m_maximum_scale); + break; + case 16: + if (typeinfo.m_sql_data_type == NULL_INT) + f.sqlNull(true); + else + f.sqlInteger(typeinfo.m_sql_data_type); + break; + case 17: + if (typeinfo.m_sql_datetime_sub == NULL_INT) + f.sqlNull(true); + else + f.sqlInteger(typeinfo.m_sql_datetime_sub); + break; + case 18: + if (typeinfo.m_sql_datetime_sub == NULL_INT) + f.sqlNull(true); + else + f.sqlInteger(typeinfo.m_sql_datetime_sub); + break; + case 19: + if (typeinfo.m_interval_precision == NULL_INT) + f.sqlNull(true); + else + f.sqlInteger(typeinfo.m_interval_precision); + break; + default: + ctx_assert(false); + break; + } + } + return true; + } + if (code.m_sysId == DictSys::OdbcTables) { + if (data.m_tablePos >= data.m_objectList.count) { + return false; + } + NdbDictionary::Dictionary::List::Element& element = data.m_objectList.elements[data.m_tablePos++]; + for (unsigned i = 1; i <= code.m_attrCount; i++) { + SqlField& f = data.m_sqlRow.getEntry(i); + switch (1 + code.m_attrId[i]) { + case 1: // TABLE_CAT + f.sqlNull(true); + break; + case 2: // TABLE_SCHEM + f.sqlNull(true); + break; + case 3: // TABLE_NAME + f.sqlVarchar(element.name, SQL_NTS); + break; + case 4: { // TABLE_TYPE + if (element.type == NdbDictionary::Object::SystemTable) + f.sqlVarchar("SYSTEM TABLE", SQL_NTS); + else if (element.type == NdbDictionary::Object::UserTable) + f.sqlVarchar("TABLE", SQL_NTS); + else if (element.type == NdbDictionary::Object::UniqueHashIndex) + f.sqlVarchar("UNIQUE HASH INDEX", SQL_NTS); + else if (element.type == NdbDictionary::Object::HashIndex) + f.sqlVarchar("HASH INDEX", SQL_NTS); + else if (element.type == NdbDictionary::Object::UniqueOrderedIndex) + f.sqlVarchar("UNIQUE INDEX", SQL_NTS); + else if (element.type == NdbDictionary::Object::OrderedIndex) + f.sqlVarchar("INDEX", SQL_NTS); + else if (element.type == NdbDictionary::Object::IndexTrigger) + f.sqlVarchar("INDEX TRIGGER", SQL_NTS); + else if (element.type == NdbDictionary::Object::SubscriptionTrigger) + f.sqlVarchar("SUBSCRIPTION TRIGGER", SQL_NTS); + else if (element.type == NdbDictionary::Object::ReadOnlyConstraint) + f.sqlVarchar("READ ONLY CONSTRAINT", SQL_NTS); + else + f.sqlVarchar("UNKNOWN", SQL_NTS); + } + break; + case 5: // REMARKS + f.sqlNull(true); + break; + default: + ctx_assert(false); + break; + } + } + return true; + } + if (code.m_sysId == DictSys::OdbcColumns) { + if (data.m_tablePos >= data.m_objectList.count) { + return false; + } + const NdbDictionary::Dictionary::List::Element& element = data.m_objectList.elements[data.m_tablePos]; + unsigned nattr; + const NdbDictionary::Table* ndbTable; + nattr = 0; + if (isNdbTable(element)) { + ndbTable = ndbDictionary->getTable(element.name); + if (ndbTable == 0) { + ctx.pushStatus(ndbDictionary->getNdbError(), "getTable %s", element.name); + return false; + } + nattr = ndbTable->getNoOfColumns(); + } + while (data.m_attrPos >= nattr) { + if (++data.m_tablePos >= data.m_objectList.count) { + return false; + } + const NdbDictionary::Dictionary::List::Element& element = data.m_objectList.elements[data.m_tablePos]; + nattr = 0; + if (isNdbTable(element)) { + ndbTable = ndbDictionary->getTable(element.name); + if (ndbTable == 0) { + ctx.pushStatus(ndbDictionary->getNdbError(), "getTable %s", element.name); + return false; + } + data.m_attrPos = 0; + nattr = ndbTable->getNoOfColumns(); + } + } + int attrId = data.m_attrPos++; + const NdbDictionary::Column* ndbColumn = ndbTable->getColumn(attrId); + if (ndbColumn == 0) { + ctx.pushStatus(ndbDictionary->getNdbError(), "getColumn %s.%d", ndbTable->getName(), attrId); + return false; + } + SqlType sqlType(ctx, ndbColumn); + if (! ctx.ok()) + return false; + const char* p; + for (unsigned i = 1; i <= code.m_attrCount; i++) { + SqlField& f = data.m_sqlRow.getEntry(i); + switch (1 + code.m_attrId[i]) { + case 1: // TABLE_CAT + f.sqlNull(true); + break; + case 2: // TABLE_SCHEM + f.sqlNull(true); + break; + case 3: // TABLE_NAME + f.sqlVarchar(ndbTable->getName(), SQL_NTS); + break; + case 4: // COLUMN_NAME + f.sqlVarchar(ndbColumn->getName(), SQL_NTS); + break; + case 5: // DATA_TYPE + f.sqlInteger(sqlType.type()); + break; + case 6: // TYPE_NAME + f.sqlVarchar(sqlType.typeName(), SQL_NTS); + break; + case 7: // COLUMN_SIZE + f.sqlInteger(sqlType.displaySize()); + break; + case 8: // BUFFER_LENGTH + f.sqlInteger(sqlType.size()); + break; + case 9: // DECIMAL_DIGITS + if (sqlType.type() == SqlType::Char) + f.sqlNull(true); + else + f.sqlInteger(0); + break; + case 10: // NUM_PREC_RADIX + if (sqlType.type() == SqlType::Integer || sqlType.type() == SqlType::Bigint) + f.sqlInteger(10); + else + f.sqlNull(true); + break; + case 11: // NULLABLE + if (sqlType.nullable()) + f.sqlInteger(SQL_NULLABLE); + else + f.sqlInteger(SQL_NO_NULLS); + break; + case 12: // REMARKS + f.sqlNull(true); + break; + case 13: // COLUMN_DEF + if ((p = ndbColumn->getDefaultValue()) != 0) + f.sqlVarchar(p, SQL_NTS); + else + f.sqlNull(true); + break; + case 14: // SQL_DATA_TYPE + f.sqlInteger(sqlType.type()); + break; + case 15: // SQL_DATETIME_SUB + f.sqlNull(true); + break; + case 16: // CHAR_OCTET_LENGTH + if (sqlType.type() == SqlType::Char) + f.sqlInteger(sqlType.length()); + else + f.sqlNull(true); + break; + case 17: // ORDINAL_POSITION + f.sqlInteger(1 + attrId); + break; + case 18: // IS_NULLABLE + if (sqlType.nullable()) + f.sqlVarchar("YES", SQL_NTS); + else + f.sqlVarchar("NO", SQL_NTS); + break; + break; + default: + ctx_assert(false); + break; + } + } + return true; + } + if (code.m_sysId == DictSys::OdbcPrimarykeys) { + if (data.m_tablePos >= data.m_objectList.count) { + return false; + } + NdbDictionary::Dictionary::List::Element& element = data.m_objectList.elements[data.m_tablePos]; + unsigned nkeys; + const NdbDictionary::Table* ndbTable; + nkeys = 0; + if (isNdbTable(element)) { + ndbTable = ndbDictionary->getTable(element.name); + if (ndbTable == 0) { + ctx.pushStatus(ndbDictionary->getNdbError(), "getTable %s", element.name); + return false; + } + nkeys = ndbTable->getNoOfPrimaryKeys(); + } + while (data.m_keyPos >= nkeys) { + if (++data.m_tablePos >= data.m_objectList.count) { + return false; + } + NdbDictionary::Dictionary::List::Element& element = data.m_objectList.elements[data.m_tablePos]; + nkeys = 0; + if (isNdbTable(element)) { + ndbTable = ndbDictionary->getTable(element.name); + if (ndbTable == 0) { + ctx.pushStatus(ndbDictionary->getNdbError(), "getTable %s", element.name); + return false; + } + data.m_keyPos = 0; + nkeys = ndbTable->getNoOfPrimaryKeys(); + } + } + unsigned keyPos = data.m_keyPos++; + const char* keyName = ndbTable->getPrimaryKey(keyPos); + if (keyName == 0) + keyName = "?"; + for (unsigned i = 1; i <= code.m_attrCount; i++) { + SqlField& f = data.m_sqlRow.getEntry(i); + switch (1 + code.m_attrId[i]) { + case 1: // TABLE_CAT + f.sqlNull(true); + break; + case 2: // TABLE_SCHEM + f.sqlNull(true); + break; + case 3: // TABLE_NAME + f.sqlVarchar(ndbTable->getName(), SQL_NTS); + break; + case 4: // COLUMN_NAME + f.sqlVarchar(keyName, SQL_NTS); + break; + case 5: // KEY_SEQ + f.sqlInteger(1 + keyPos); + break; + case 6: // PK_NAME + f.sqlNull(true); + break; + default: + ctx_assert(false); + break; + } + } + return true; + } + if (code.m_sysId == DictSys::Dual) { + if (data.m_rowPos > 0) { + return false; + } + data.m_rowPos++; + for (unsigned i = 1; i <= code.m_attrCount; i++) { + SqlField& f = data.m_sqlRow.getEntry(i); + switch (1 + code.m_attrId[i]) { + case 1: // DUMMY + f.sqlVarchar("X", 1); + break; + default: + ctx_assert(false); + break; + } + } + return true; + } + ctx_assert(false); + return false; +} diff --git a/ndb/src/client/odbc/executor/Exec_update_index.cpp b/ndb/src/client/odbc/executor/Exec_update_index.cpp new file mode 100644 index 00000000000..35b6159d8ca --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_update_index.cpp @@ -0,0 +1,96 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include +#include + +void +Exec_update_index::execImpl(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + NdbConnection* const tcon = ndbConnection(); + // execute subquery + ctx_assert(m_query != 0); + m_query->execute(ctx, ctl); + if (! ctx.ok()) + return; + // update each row from the query + while (m_query->fetch(ctx, ctl)) { + NdbOperation* op = tcon->getNdbIndexOperation(code.m_indexName, code.m_tableName); + if (op == 0) { + ctx.pushStatus(ndb, tcon, 0, "getNdbIndexOperation"); + return; + } + if (op->updateTuple() == -1) { + ctx.pushStatus(ndb, tcon, op, "updateTuple"); + return; + } + // key attributes + bool done = false; + for (unsigned k = 1; k <= code.m_keyCount; k++) { + Exec_expr* exprMatch = code.m_keyMatch[k]; + ctx_assert(exprMatch != 0); + exprMatch->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + const SqlField& keyMatch = exprMatch->getData().sqlField(); + SqlField f(code.m_keySpecs.getEntry(k)); + if (! keyMatch.cast(ctx, f)) { + done = true; // match is not possible + break; + } + const NdbAttrId keyId = code.m_keyId[k]; + const void* addr = f.addr(); + const char* value = static_cast(addr); + if (op->equal(keyId, value) == -1) { + ctx.pushStatus(ndb, tcon, op, "equal attrId=%u", (unsigned)keyId); + return; + } + } + if (done) + continue; + // updated attributes + const SqlRow& sqlRow = m_query->getData().sqlRow(); + ctx_assert(sqlRow.count() == code.m_attrCount); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + const NdbAttrId attrId = code.m_attrId[i]; + const SqlField& f = sqlRow.getEntry(i); + const void* addr = f.sqlNull() ? 0 : f.addr(); + const char* value = static_cast(addr); + if (op->setValue(attrId, value) == -1) { + ctx.pushStatus(ndb, tcon, op, "setValue attrId=%u", (unsigned)attrId); + return; + } + } + data.setCount(0); + if (tcon->execute(NoCommit) == -1) { + // XXX when did 626 move to connection level + if (tcon->getNdbError().code != 626 && op->getNdbError().code != 626) { + ctx.pushStatus(ndb, tcon, op, "execute without commit"); + return; + } + } else { + data.addCount(); + } + } + stmtArea().setRowCount(ctx, data.getCount()); +} diff --git a/ndb/src/client/odbc/executor/Exec_update_lookup.cpp b/ndb/src/client/odbc/executor/Exec_update_lookup.cpp new file mode 100644 index 00000000000..2c801372de3 --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_update_lookup.cpp @@ -0,0 +1,96 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include +#include + +void +Exec_update_lookup::execImpl(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + NdbConnection* const tcon = ndbConnection(); + // execute subquery + ctx_assert(m_query != 0); + m_query->execute(ctx, ctl); + if (! ctx.ok()) + return; + // update each row from the query + while (m_query->fetch(ctx, ctl)) { + NdbOperation* op = tcon->getNdbOperation(code.m_tableName); + if (op == 0) { + ctx.pushStatus(ndb, tcon, 0, "getNdbOperation"); + return; + } + if (op->updateTuple() == -1) { + ctx.pushStatus(ndb, tcon, op, "updateTuple"); + return; + } + // key attributes + bool done = false; + for (unsigned k = 1; k <= code.m_keyCount; k++) { + Exec_expr* exprMatch = code.m_keyMatch[k]; + ctx_assert(exprMatch != 0); + exprMatch->evaluate(ctx, ctl); + if (! ctx.ok()) + return; + const SqlField& keyMatch = exprMatch->getData().sqlField(); + SqlField f(code.m_keySpecs.getEntry(k)); + if (! keyMatch.cast(ctx, f)) { + done = true; // match is not possible + break; + } + const NdbAttrId keyId = code.m_keyId[k]; + const void* addr = f.addr(); + const char* value = static_cast(addr); + if (op->equal(keyId, value) == -1) { + ctx.pushStatus(ndb, tcon, op, "equal attrId=%u", (unsigned)keyId); + return; + } + } + if (done) + continue; + // updated attributes + const SqlRow& sqlRow = m_query->getData().sqlRow(); + ctx_assert(sqlRow.count() == code.m_attrCount); + for (unsigned i = 1; i <= code.m_attrCount; i++) { + const NdbAttrId attrId = code.m_attrId[i]; + const SqlField& f = sqlRow.getEntry(i); + const void* addr = f.sqlNull() ? 0 : f.addr(); + const char* value = static_cast(addr); + if (op->setValue(attrId, value) == -1) { + ctx.pushStatus(ndb, tcon, op, "setValue attrId=%u", (unsigned)attrId); + return; + } + } + data.setCount(0); + if (tcon->execute(NoCommit) == -1) { + // XXX when did 626 move to connection level + if (tcon->getNdbError().code != 626 && op->getNdbError().code != 626) { + ctx.pushStatus(ndb, tcon, op, "execute without commit"); + return; + } + } else { + data.addCount(); + } + } + stmtArea().setRowCount(ctx, data.getCount()); +} diff --git a/ndb/src/client/odbc/executor/Exec_update_scan.cpp b/ndb/src/client/odbc/executor/Exec_update_scan.cpp new file mode 100644 index 00000000000..a36fdd27142 --- /dev/null +++ b/ndb/src/client/odbc/executor/Exec_update_scan.cpp @@ -0,0 +1,61 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include + +void +Exec_update_scan::execImpl(Ctx& ctx, Ctl& ctl) +{ + const Code& code = getCode(); + Data& data = getData(); + Ndb* const ndb = ndbObject(); + NdbConnection* const tcon = ndbConnection(); + // execute subquery + ctx_assert(m_query != 0); + m_query->execute(ctx, ctl); + if (! ctx.ok()) + return; + ctx_assert(ctl.m_scanOp != 0); + // update each row from query + data.setCount(0); + while (m_query->fetch(ctx, ctl)) { + NdbOperation* toOp = ctl.m_scanOp->takeOverForUpdate(tcon); + if (toOp == 0) { + ctx.pushStatus(ndb, tcon, ctl.m_scanOp, "takeOverScanOp"); + return; + } + const SqlRow& sqlRow = m_query->getData().sqlRow(); + for (unsigned i = 1; i <= sqlRow.count(); i++) { + const SqlField& f = sqlRow.getEntry(i); + const void* addr = f.sqlNull() ? 0 : f.addr(); + const char* value = static_cast(addr); + if (toOp->setValue(code.m_attrId[i], value) == -1) { + ctx.pushStatus(ndb, tcon, toOp, "setValue"); + return; + } + } + if (tcon->execute(NoCommit) == -1) { + ctx.pushStatus(ndb, tcon, toOp, "execute without commit"); + return; + } + data.addCount(); + } + stmtArea().setRowCount(ctx, data.getCount()); +} diff --git a/ndb/src/client/odbc/executor/Executor.cpp b/ndb/src/client/odbc/executor/Executor.cpp new file mode 100644 index 00000000000..adabb28a4a5 --- /dev/null +++ b/ndb/src/client/odbc/executor/Executor.cpp @@ -0,0 +1,68 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include "Executor.hpp" + +void +Executor::execute(Ctx& ctx) +{ + Exec_base::Ctl ctl(0); + Exec_root* execRoot = static_cast(m_stmtArea.m_execTree); + ctx_assert(execRoot != 0); + rebind(ctx); + if (! ctx.ok()) + return; + execRoot->execute(ctx, ctl); + if (! ctx.ok()) + return; + ctx_log2(("Executor: execute done")); +} + +void +Executor::fetch(Ctx& ctx) +{ + Exec_base::Ctl ctl(0); + Exec_root* execRoot = static_cast(m_stmtArea.m_execTree); + ctx_assert(execRoot != 0); + rebind(ctx); + if (! ctx.ok()) + return; + execRoot->fetch(ctx, ctl); + if (! ctx.ok()) + return; + ctx_log2(("Executor: fetch done")); +} + +void +Executor::rebind(Ctx& ctx) +{ + Exec_root* execRoot = static_cast(m_stmtArea.m_execTree); + ctx_assert(execRoot != 0); + DescArea& apd = m_stmtArea.descArea(Desc_usage_APD); + DescArea& ard = m_stmtArea.descArea(Desc_usage_ARD); + if (! apd.isBound() || ! ard.isBound()) { + ctx_log2(("Executor: rebind required")); + execRoot->bind(ctx); + if (! ctx.ok()) + return; + apd.setBound(true); + ard.setBound(true); + } +} diff --git a/ndb/src/client/odbc/executor/Executor.hpp b/ndb/src/client/odbc/executor/Executor.hpp new file mode 100644 index 00000000000..5edb9d509ac --- /dev/null +++ b/ndb/src/client/odbc/executor/Executor.hpp @@ -0,0 +1,52 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_EXECUTOR_Executor_hpp +#define ODBC_EXECUTOR_Executor_hpp + +#include +class StmtArea; + +/** + * @class Executor + * @brief Executes an ExecTree + */ +class Executor { +public: + Executor(StmtArea& stmtArea); + ~Executor(); + // execute prepared statement + void execute(Ctx& ctx); + // fetch next row from query + void fetch(Ctx& ctx); +private: + // rebind if necessary + void rebind(Ctx& ctx); + StmtArea m_stmtArea; +}; + +inline +Executor::Executor(StmtArea& stmtArea) : + m_stmtArea(stmtArea) +{ +} + +inline +Executor::~Executor() +{ +} + +#endif diff --git a/ndb/src/client/odbc/executor/Makefile b/ndb/src/client/odbc/executor/Makefile new file mode 100644 index 00000000000..d86781e212c --- /dev/null +++ b/ndb/src/client/odbc/executor/Makefile @@ -0,0 +1,36 @@ +include .defs.mk + +TYPE = * + +NONPIC_ARCHIVE = N + +PIC_ARCHIVE = Y + +ARCHIVE_TARGET = odbcexecutor + +SOURCES = \ + Executor.cpp \ + Exec_query_lookup.cpp \ + Exec_query_index.cpp \ + Exec_query_scan.cpp \ + Exec_query_range.cpp \ + Exec_query_sys.cpp \ + Exec_pred_op.cpp \ + Exec_comp_op.cpp \ + Exec_expr_op.cpp \ + Exec_expr_func.cpp \ + Exec_expr_conv.cpp \ + Exec_insert.cpp \ + Exec_update_lookup.cpp \ + Exec_update_index.cpp \ + Exec_update_scan.cpp \ + Exec_delete_lookup.cpp \ + Exec_delete_index.cpp \ + Exec_delete_scan.cpp \ + Exec_create_table.cpp \ + Exec_create_index.cpp \ + Exec_drop_table.cpp \ + Exec_drop_index.cpp + +include ../Extra.mk +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/client/odbc/handles/AttrDbc.cpp b/ndb/src/client/odbc/handles/AttrDbc.cpp new file mode 100644 index 00000000000..4768a8995a2 --- /dev/null +++ b/ndb/src/client/odbc/handles/AttrDbc.cpp @@ -0,0 +1,473 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "HandleDbc.hpp" + +static void +callback_SQL_ATTR_ACCESS_MODE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_MODE_READ_ONLY: + break; + case SQL_MODE_READ_WRITE: + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid access mode value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_ACCESS_MODE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + SQLUINTEGER value = SQL_MODE_READ_WRITE; + data.setValue(value); +} + +static void +callback_SQL_ATTR_ASYNC_ENABLE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_ASYNC_ENABLE_OFF: + break; + case SQL_ASYNC_ENABLE_ON: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "async enable on not supported"); + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid async enable value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_ASYNC_ENABLE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + SQLUINTEGER value = SQL_ASYNC_ENABLE_OFF; + data.setValue(value); +} + +static void +callback_SQL_ATTR_AUTO_IPD_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger); + ctx_assert(false); // read-only +} + +static void +callback_SQL_ATTR_AUTO_IPD_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + SQLUINTEGER value = SQL_FALSE; + data.setValue(value); +} + +static void +callback_SQL_ATTR_AUTOCOMMIT_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_AUTOCOMMIT_OFF: + if (pDbc->autocommit()) { + pDbc->autocommit(false); + pDbc->useConnection(ctx, true); + } + break; + case SQL_AUTOCOMMIT_ON: + if (! pDbc->autocommit()) { + pDbc->autocommit(true); + pDbc->sqlEndTran(ctx, SQL_COMMIT); + pDbc->useConnection(ctx, false); + } + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid autocommit value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_AUTOCOMMIT_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + SQLUINTEGER value = pDbc->autocommit() ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF; + data.setValue(value); +} + +static void +callback_SQL_ATTR_CONNECTION_DEAD_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger); + ctx_assert(false); // read-only +} + +static void +callback_SQL_ATTR_CONNECTION_DEAD_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + SQLUINTEGER value = pDbc->getState() == HandleDbc::Free ? SQL_CD_TRUE : SQL_CD_FALSE; + data.setValue(value); +} + +static void +callback_SQL_ATTR_CONNECTION_TIMEOUT_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger); +} + +static void +callback_SQL_ATTR_CONNECTION_TIMEOUT_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + SQLUINTEGER value = 0; + data.setValue(value); +} + +static void +callback_SQL_ATTR_CURRENT_CATALOG_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Sqlchar); +} + +static void +callback_SQL_ATTR_CURRENT_CATALOG_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + const char* value = "DEFAULT"; + data.setValue(value); +} + +static void +callback_SQL_ATTR_LOGIN_TIMEOUT_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + callback_SQL_ATTR_CONNECTION_TIMEOUT_set(ctx, self, data); +} + +static void +callback_SQL_ATTR_LOGIN_TIMEOUT_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + callback_SQL_ATTR_CONNECTION_TIMEOUT_default(ctx, self, data); +} + +static void +callback_SQL_ATTR_METADATA_ID_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_FALSE: + break; + case SQL_TRUE: + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid metadata id value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_METADATA_ID_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + SQLUINTEGER value = SQL_FALSE; + data.setValue(value); +} + +static void +callback_SQL_ATTR_ODBC_CURSORS_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_CUR_USE_DRIVER: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "cur use driver not supported"); + break; + case SQL_CUR_USE_IF_NEEDED: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "cur use if needed not supported"); + break; + case SQL_CUR_USE_ODBC: + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid odbc cursors value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_ODBC_CURSORS_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + SQLUINTEGER value = SQL_CUR_USE_ODBC; + data.setValue(value); +} + +static void +callback_SQL_ATTR_PACKET_SIZE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "packet size (%u) not supported", (unsigned)value); +} + +static void +callback_SQL_ATTR_PACKET_SIZE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + SQLUINTEGER value = 0; + data.setValue(value); +} + +static void +callback_SQL_ATTR_QUIET_MODE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Pointer); +} + +static void +callback_SQL_ATTR_QUIET_MODE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + data.setValue(); +} + +static void +callback_SQL_ATTR_TRACE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger); +} + +static void +callback_SQL_ATTR_TRACE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + data.setValue(); +} + +static void +callback_SQL_ATTR_TRACEFILE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Sqlchar); +} + +static void +callback_SQL_ATTR_TRACEFILE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + data.setValue(); +} + +static void +callback_SQL_ATTR_TRANSLATE_LIB_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Sqlchar); +} + +static void +callback_SQL_ATTR_TRANSLATE_LIB_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + data.setValue(); +} + +static void +callback_SQL_ATTR_TRANSLATE_OPTION_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger); +} + +static void +callback_SQL_ATTR_TRANSLATE_OPTION_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + data.setValue(); +} + +static void +callback_SQL_ATTR_TXN_ISOLATION_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger); + if (pDbc->getState() == HandleDbc::Free) { + ctx.pushStatus(Sqlstate::_08003, Error::Gen, "not connected"); + return; + } + if (pDbc->getState() == HandleDbc::Transacting) { + ctx.pushStatus(Sqlstate::_HY011, Error::Gen, "transaction is open"); + return; + } + SQLUINTEGER value = data.uinteger(); + SQLUINTEGER mask = SQL_TXN_READ_COMMITTED; + if (! (value & mask)) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "txn isolation level %u not supported", (unsigned)value); + return; + } +} + +static void +callback_SQL_ATTR_TXN_ISOLATION_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDbc* pDbc = static_cast(self); + ctx_assert(pDbc != 0); + SQLUINTEGER value = SQL_TXN_READ_COMMITTED; + data.setValue(value); +} + +AttrSpec HandleDbc::m_attrSpec[] = { + { SQL_ATTR_ACCESS_MODE, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_ACCESS_MODE_set, + callback_SQL_ATTR_ACCESS_MODE_default, + }, + { SQL_ATTR_ASYNC_ENABLE, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_ASYNC_ENABLE_set, + callback_SQL_ATTR_ASYNC_ENABLE_default, + }, + { SQL_ATTR_AUTO_IPD, + OdbcData::Uinteger, + Attr_mode_readonly, + callback_SQL_ATTR_AUTO_IPD_set, + callback_SQL_ATTR_AUTO_IPD_default, + }, + { SQL_ATTR_AUTOCOMMIT, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_AUTOCOMMIT_set, + callback_SQL_ATTR_AUTOCOMMIT_default, + }, + { SQL_ATTR_CONNECTION_DEAD, + OdbcData::Uinteger, + Attr_mode_readonly, + callback_SQL_ATTR_CONNECTION_DEAD_set, + callback_SQL_ATTR_CONNECTION_DEAD_default, + }, + { SQL_ATTR_CONNECTION_TIMEOUT, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_CONNECTION_TIMEOUT_set, + callback_SQL_ATTR_CONNECTION_TIMEOUT_default, + }, + { SQL_ATTR_CURRENT_CATALOG, + OdbcData::Sqlchar, + Attr_mode_readwrite, + callback_SQL_ATTR_CURRENT_CATALOG_set, + callback_SQL_ATTR_CURRENT_CATALOG_default, + }, + { SQL_ATTR_LOGIN_TIMEOUT, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_LOGIN_TIMEOUT_set, + callback_SQL_ATTR_LOGIN_TIMEOUT_default, + }, + { SQL_ATTR_METADATA_ID, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_METADATA_ID_set, + callback_SQL_ATTR_METADATA_ID_default, + }, + { SQL_ATTR_ODBC_CURSORS, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_ODBC_CURSORS_set, + callback_SQL_ATTR_ODBC_CURSORS_default, + }, + { SQL_ATTR_PACKET_SIZE, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_PACKET_SIZE_set, + callback_SQL_ATTR_PACKET_SIZE_default, + }, + { SQL_ATTR_QUIET_MODE, + OdbcData::Pointer, + Attr_mode_readwrite, + callback_SQL_ATTR_QUIET_MODE_set, + callback_SQL_ATTR_QUIET_MODE_default, + }, + { SQL_ATTR_TRACE, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_TRACE_set, + callback_SQL_ATTR_TRACE_default, + }, + { SQL_ATTR_TRACEFILE, + OdbcData::Sqlchar, + Attr_mode_readwrite, + callback_SQL_ATTR_TRACEFILE_set, + callback_SQL_ATTR_TRACEFILE_default, + }, + { SQL_ATTR_TRANSLATE_LIB, + OdbcData::Sqlchar, + Attr_mode_readwrite, + callback_SQL_ATTR_TRANSLATE_LIB_set, + callback_SQL_ATTR_TRANSLATE_LIB_default, + }, + { SQL_ATTR_TRANSLATE_OPTION, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_TRANSLATE_OPTION_set, + callback_SQL_ATTR_TRANSLATE_OPTION_default, + }, + { SQL_ATTR_TXN_ISOLATION, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_TXN_ISOLATION_set, + callback_SQL_ATTR_TXN_ISOLATION_default, + }, + { 0, + OdbcData::Undef, + Attr_mode_undef, + 0, + 0, + }, +}; diff --git a/ndb/src/client/odbc/handles/AttrEnv.cpp b/ndb/src/client/odbc/handles/AttrEnv.cpp new file mode 100644 index 00000000000..3d57fddeb57 --- /dev/null +++ b/ndb/src/client/odbc/handles/AttrEnv.cpp @@ -0,0 +1,123 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "HandleEnv.hpp" + +static void +callback_SQL_ATTR_CP_MATCH_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleEnv* pEnv = static_cast(self); + ctx_assert(pEnv != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_CP_STRICT_MATCH: + break; + case SQL_CP_RELAXED_MATCH: + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid cp match value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_CP_MATCH_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleEnv* pEnv = static_cast(self); + ctx_assert(pEnv != 0); + SQLUINTEGER value = SQL_CP_STRICT_MATCH; + data.setValue(value); +} + +static void +callback_SQL_ATTR_ODBC_VERSION_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleEnv* pEnv = static_cast(self); + ctx_assert(pEnv != 0 && data.type() == OdbcData::Integer); + int version = data.integer(); + switch (version) { + case SQL_OV_ODBC2: + case SQL_OV_ODBC3: + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid ODBC version %d", version); + return; + } + ctx_log1(("odbc version set to %d", version)); +} + +static void +callback_SQL_ATTR_ODBC_VERSION_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleEnv* pEnv = static_cast(self); + ctx_assert(pEnv != 0); + // no default + ctx_log1(("odbc version has not been set")); + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "odbc version has not been set"); +} + +static void +callback_SQL_ATTR_OUTPUT_NTS_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleEnv* pEnv = static_cast(self); + ctx_assert(pEnv != 0 && data.type() == OdbcData::Integer); + SQLINTEGER value = data.integer(); + switch (value) { + case SQL_TRUE: + break; + case SQL_FALSE: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "output nts FALSE not supported"); + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid output nts value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_OUTPUT_NTS_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleEnv* pEnv = static_cast(self); + ctx_assert(pEnv != 0); + data.setValue(); +} + +AttrSpec HandleEnv::m_attrSpec[] = { + { SQL_ATTR_CP_MATCH, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_CP_MATCH_set, + callback_SQL_ATTR_CP_MATCH_default, + }, + { SQL_ATTR_ODBC_VERSION, + OdbcData::Integer, + Attr_mode_readwrite, + callback_SQL_ATTR_ODBC_VERSION_set, + callback_SQL_ATTR_ODBC_VERSION_default, + }, + { SQL_ATTR_OUTPUT_NTS, + OdbcData::Integer, + Attr_mode_readwrite, + callback_SQL_ATTR_OUTPUT_NTS_set, + callback_SQL_ATTR_OUTPUT_NTS_default, + }, + { 0, + OdbcData::Undef, + Attr_mode_undef, + 0, + 0, + }, +}; diff --git a/ndb/src/client/odbc/handles/AttrRoot.cpp b/ndb/src/client/odbc/handles/AttrRoot.cpp new file mode 100644 index 00000000000..d1b264835b6 --- /dev/null +++ b/ndb/src/client/odbc/handles/AttrRoot.cpp @@ -0,0 +1,92 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "HandleRoot.hpp" + +static void +callback_SQL_ATTR_CONNECTION_POOLING_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleRoot* pRoot = static_cast(self); + ctx_assert(pRoot != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_CP_OFF: + break; + case SQL_CP_ONE_PER_DRIVER: + case SQL_CP_ONE_PER_HENV: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "connection pooling not supported"); + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid connection pooling value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_CONNECTION_POOLING_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleRoot* pRoot = static_cast(self); + ctx_assert(pRoot != 0); + SQLUINTEGER value = SQL_CP_OFF; + data.setValue(value); +} + +static void +callback_SQL_ATTR_CP_MATCH_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleRoot* pRoot = static_cast(self); + ctx_assert(pRoot != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_CP_STRICT_MATCH: + break; + case SQL_CP_RELAXED_MATCH: + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid cp match value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_CP_MATCH_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleRoot* pRoot = static_cast(self); + ctx_assert(pRoot != 0); + SQLUINTEGER value = SQL_CP_STRICT_MATCH; + data.setValue(value); +} + +AttrSpec HandleRoot::m_attrSpec[] = { + { SQL_ATTR_CONNECTION_POOLING, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_CONNECTION_POOLING_set, + callback_SQL_ATTR_CONNECTION_POOLING_default, + }, + { SQL_ATTR_CP_MATCH, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_CP_MATCH_set, + callback_SQL_ATTR_CP_MATCH_default, + }, + { 0, + OdbcData::Undef, + Attr_mode_undef, + 0, + 0, + }, +}; diff --git a/ndb/src/client/odbc/handles/AttrStmt.cpp b/ndb/src/client/odbc/handles/AttrStmt.cpp new file mode 100644 index 00000000000..ce9a9c03fd1 --- /dev/null +++ b/ndb/src/client/odbc/handles/AttrStmt.cpp @@ -0,0 +1,1005 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "HandleDbc.hpp" +#include "HandleStmt.hpp" +#include "HandleDesc.hpp" + +static void +callback_SQL_ATTR_APP_PARAM_DESC_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Pointer); + pStmt->setHandleDesc(ctx, Desc_usage_APD, data.pointer()); +} + +static void +callback_SQL_ATTR_APP_PARAM_DESC_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + HandleDesc* apd = pStmt->getHandleDesc(ctx, Desc_usage_APD); + OdbcData value(reinterpret_cast(apd)); + data.setValue(value); +} + +static void +callback_SQL_ATTR_APP_ROW_DESC_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Pointer); + pStmt->setHandleDesc(ctx, Desc_usage_ARD, data.pointer()); +} + +static void +callback_SQL_ATTR_APP_ROW_DESC_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + HandleDesc* ard = pStmt->getHandleDesc(ctx, Desc_usage_ARD); + OdbcData value(reinterpret_cast(ard)); + data.setValue(value); +} + +static void +callback_SQL_ATTR_ASYNC_ENABLE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_ASYNC_ENABLE_OFF: + break; + case SQL_ASYNC_ENABLE_ON: +// ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "async enable ON not supported"); + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid async enable value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_ASYNC_ENABLE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = SQL_ASYNC_ENABLE_OFF; + data.setValue(value); +} + +static void +callback_SQL_ATTR_CONCURRENCY_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_CONCUR_READ_ONLY: + break; + case SQL_CONCUR_LOCK: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "concur lock not supported"); + break; + case SQL_CONCUR_ROWVER: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "concur rowver not supported"); + break; + case SQL_CONCUR_VALUES: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "concur values not supported"); + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid concurrency value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_CONCURRENCY_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = SQL_CONCUR_READ_ONLY; + data.setValue(value); +} + +static void +callback_SQL_ATTR_CURSOR_SCROLLABLE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_NONSCROLLABLE: + break; + case SQL_SCROLLABLE: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "cursor scrollable not supported"); + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid concurrency value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_CURSOR_SCROLLABLE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = SQL_NONSCROLLABLE; + data.setValue(value); +} + +static void +callback_SQL_ATTR_CURSOR_SENSITIVITY_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_UNSPECIFIED: + case SQL_INSENSITIVE: + break; + case SQL_SENSITIVE: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "cursor sensitive not supported"); + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid cursor sensitivity value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_CURSOR_SENSITIVITY_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = SQL_INSENSITIVE; + data.setValue(value); +} + +static void +callback_SQL_ATTR_CURSOR_TYPE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_CURSOR_FORWARD_ONLY: + break; + case SQL_CURSOR_STATIC: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "cursor static not supported"); + break; + case SQL_CURSOR_KEYSET_DRIVEN: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "cursor keyset driven not supported"); + break; + case SQL_CURSOR_DYNAMIC: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "cursor dynamic not supported"); + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid cursor type value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_CURSOR_TYPE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = SQL_CURSOR_FORWARD_ONLY; + data.setValue(value); +} + +static void +callback_SQL_ATTR_ENABLE_AUTO_IPD_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_FALSE: + break; + case SQL_TRUE: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "enable auto IPD not supported"); + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid enable auto IPD value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_ENABLE_AUTO_IPD_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = SQL_FALSE; + data.setValue(value); +} + +static void +callback_SQL_ATTR_FETCH_BOOKMARK_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Pointer); + SQLPOINTER value = data.pointer(); + if (value != 0) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "fetch bookmark ptr not supported"); + return; + } +} + +static void +callback_SQL_ATTR_FETCH_BOOKMARK_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLPOINTER value = 0; + data.setValue(value); +} + +static void +callback_SQL_ATTR_IMP_PARAM_DESC_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Pointer); + ctx_assert(false); // read-only +} + +static void +callback_SQL_ATTR_IMP_PARAM_DESC_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + HandleDesc* ipd = pStmt->getHandleDesc(ctx, Desc_usage_IPD); + OdbcData value(reinterpret_cast(ipd)); + data.setValue(value); +} + +static void +callback_SQL_ATTR_IMP_ROW_DESC_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Pointer); + ctx_assert(false); // read-only +} + +static void +callback_SQL_ATTR_IMP_ROW_DESC_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + HandleDesc* ird = pStmt->getHandleDesc(ctx, Desc_usage_IRD); + OdbcData value(reinterpret_cast(ird)); + data.setValue(value); +} + +static void +callback_SQL_ATTR_KEYSET_SIZE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + if (value != 0) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "keyset size not supported"); + return; + } +} + +static void +callback_SQL_ATTR_KEYSET_SIZE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = 0; + data.setValue(value); +} + +static void +callback_SQL_ATTR_MAX_LENGTH_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + if (value != 0) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "max length not supported"); + return; + } +} + +static void +callback_SQL_ATTR_MAX_LENGTH_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = 0; + data.setValue(value); +} + +static void +callback_SQL_ATTR_MAX_ROWS_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + if (value != 0) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "max rows not supported"); + return; + } +} + +static void +callback_SQL_ATTR_MAX_ROWS_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = 0; + data.setValue(value); +} + +static void +callback_SQL_ATTR_METADATA_ID_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_FALSE: + break; + case SQL_TRUE: + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid metadata id value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_METADATA_ID_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = SQL_FALSE; + data.setValue(value); +} + +static void +callback_SQL_ATTR_NOSCAN_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_NOSCAN_OFF: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "noscan OFF not supported"); + break; + case SQL_NOSCAN_ON: + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid no scan value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_NOSCAN_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = SQL_NOSCAN_ON; + data.setValue(value); +} + +static void +callback_SQL_ATTR_PARAM_BIND_OFFSET_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::UintegerPtr); + SQLUINTEGER* value = data.uintegerPtr(); + if (value != 0) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "param bind offset ptr not supported"); + return; + } +} + +static void +callback_SQL_ATTR_PARAM_BIND_OFFSET_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER* value = 0; + data.setValue(value); +} + +static void +callback_SQL_ATTR_PARAM_BIND_TYPE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + if (value != SQL_PARAM_BIND_BY_COLUMN) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "row-wise param binding not supported"); + return; + } +} + +static void +callback_SQL_ATTR_PARAM_BIND_TYPE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = SQL_PARAM_BIND_BY_COLUMN; + data.setValue(value); +} + +static void +callback_SQL_ATTR_PARAM_OPERATION_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::UsmallintPtr); + SQLUSMALLINT* value = data.usmallintPtr(); + if (value != 0) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "param operation ptr not supported"); + return; + } +} + +static void +callback_SQL_ATTR_PARAM_OPERATION_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUSMALLINT* value = 0; + data.setValue(value); +} + +static void +callback_SQL_ATTR_PARAM_STATUS_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::UsmallintPtr); + SQLUSMALLINT* value = data.usmallintPtr(); + if (value != 0) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "param status ptr not supported"); + return; + } +} + +static void +callback_SQL_ATTR_PARAM_STATUS_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUSMALLINT* value = 0; + data.setValue(value); +} + +static void +callback_SQL_ATTR_PARAMS_PROCESSED_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::UintegerPtr); + SQLUINTEGER* value = data.uintegerPtr(); + if (value != 0) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "params processed ptr not supported"); + return; + } +} + +static void +callback_SQL_ATTR_PARAMS_PROCESSED_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER* value = 0; + data.setValue(value); +} + +static void +callback_SQL_ATTR_PARAMSET_SIZE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + if (value != 1) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "paramset size %u not supported", (unsigned)value); + return; + } +} + +static void +callback_SQL_ATTR_PARAMSET_SIZE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = 1; + data.setValue(value); +} + +static void +callback_SQL_ATTR_QUERY_TIMEOUT_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + if (value != 0) { + ctx.pushStatus(Sqlstate::_01S02, Error::Gen, "query timeout %u replaced by 0", (unsigned)value); + return; + } +} + +static void +callback_SQL_ATTR_QUERY_TIMEOUT_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = 0; + data.setValue(value); +} + +static void +callback_SQL_ATTR_RETRIEVE_DATA_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_RD_ON: + break; + case SQL_RD_OFF: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "retrieve data OFF not supported"); + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid retrieve data value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_RETRIEVE_DATA_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = SQL_RD_ON; + data.setValue(value); +} + +static void +callback_SQL_ATTR_ROW_ARRAY_SIZE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + if (value != 1) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "row array size %u != 1 not supported", (unsigned)value); + return; + } +} + +static void +callback_SQL_ATTR_ROW_ARRAY_SIZE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = 1; + data.setValue(value); +} + +static void +callback_SQL_ATTR_ROW_BIND_OFFSET_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::UintegerPtr); + SQLUINTEGER* value = data.uintegerPtr(); + if (value != 0) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "row bind offset ptr != 0 not supported"); + return; + } +} + +static void +callback_SQL_ATTR_ROW_BIND_OFFSET_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER* value = 0; + data.setValue(value); +} + +static void +callback_SQL_ATTR_ROW_BIND_TYPE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + if (value != SQL_BIND_BY_COLUMN) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "row-wise binding not supported"); + return; + } +} + +static void +callback_SQL_ATTR_ROW_BIND_TYPE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = SQL_BIND_BY_COLUMN; + data.setValue(value); +} + +static void +callback_SQL_ATTR_ROW_NUMBER_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + ctx_assert(false); // read-only +} + +static void +callback_SQL_ATTR_ROW_NUMBER_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = pStmt->getRowCount(); + data.setValue(value); +} + +static void +callback_SQL_ATTR_ROW_OPERATION_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::UsmallintPtr); + SQLUSMALLINT* value = data.usmallintPtr(); + if (value != 0) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "row operation ptr not supported"); + return; + } +} + +static void +callback_SQL_ATTR_ROW_OPERATION_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUSMALLINT* value = 0; + data.setValue(value); +} + +static void +callback_SQL_ATTR_ROW_STATUS_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::UsmallintPtr); + SQLUSMALLINT* value = data.usmallintPtr(); + if (value != 0) { + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "row status ptr not supported"); + return; + } +} + +static void +callback_SQL_ATTR_ROW_STATUS_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUSMALLINT* value = 0; + data.setValue(value); +} + +static void +callback_SQL_ATTR_ROWS_FETCHED_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::UintegerPtr); + SQLUINTEGER* value = data.uintegerPtr(); + HandleDesc* ird = pStmt->getHandleDesc(ctx, Desc_usage_IRD); + ird->sqlSetDescField(ctx, 0, SQL_DESC_ROWS_PROCESSED_PTR, static_cast(value), SQL_IS_POINTER); +} + +static void +callback_SQL_ATTR_ROWS_FETCHED_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER* value = 0; + HandleDesc* ird = pStmt->getHandleDesc(ctx, Desc_usage_IRD); + ird->sqlGetDescField(ctx, 0, SQL_DESC_ROWS_PROCESSED_PTR, &value, SQL_IS_POINTER, 0); + data.setValue(value); +} + +static void +callback_SQL_ATTR_SIMULATE_CURSOR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_SC_NON_UNIQUE: + break; + case SQL_SC_TRY_UNIQUE: + break; + case SQL_SC_UNIQUE: + break; + default: + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid simulate cursor value %u", (unsigned)value); + break; + } +} + +static void +callback_SQL_ATTR_SIMULATE_CURSOR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = SQL_SC_UNIQUE; // XXX if we did + data.setValue(value); +} + +static void +callback_SQL_ATTR_USE_BOOKMARKS_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + SQLUINTEGER value = data.uinteger(); + switch (value) { + case SQL_UB_OFF: + break; + case SQL_UB_VARIABLE: + case SQL_UB_FIXED: + ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "bookmarks not supported"); + return; + } +} + +static void +callback_SQL_ATTR_USE_BOOKMARKS_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = SQL_UB_OFF; + data.setValue(value); +} + +// driver specific + +static void +callback_SQL_ATTR_NDB_TUPLES_FETCHED_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger); + ctx_assert(false); // read-only +} + +static void +callback_SQL_ATTR_NDB_TUPLES_FETCHED_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleStmt* pStmt = static_cast(self); + ctx_assert(pStmt != 0); + SQLUINTEGER value = pStmt->getTuplesFetched(); + data.setValue(value); +} + +AttrSpec HandleStmt::m_attrSpec[] = { + { SQL_ATTR_APP_PARAM_DESC, + OdbcData::Pointer, + Attr_mode_readwrite, + callback_SQL_ATTR_APP_PARAM_DESC_set, + callback_SQL_ATTR_APP_PARAM_DESC_default, + }, + { SQL_ATTR_APP_ROW_DESC, + OdbcData::Pointer, + Attr_mode_readwrite, + callback_SQL_ATTR_APP_ROW_DESC_set, + callback_SQL_ATTR_APP_ROW_DESC_default, + }, + { SQL_ATTR_ASYNC_ENABLE, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_ASYNC_ENABLE_set, + callback_SQL_ATTR_ASYNC_ENABLE_default, + }, + { SQL_ATTR_CONCURRENCY, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_CONCURRENCY_set, + callback_SQL_ATTR_CONCURRENCY_default, + }, + { SQL_ATTR_CURSOR_SCROLLABLE, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_CURSOR_SCROLLABLE_set, + callback_SQL_ATTR_CURSOR_SCROLLABLE_default, + }, + { SQL_ATTR_CURSOR_SENSITIVITY, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_CURSOR_SENSITIVITY_set, + callback_SQL_ATTR_CURSOR_SENSITIVITY_default, + }, + { SQL_ATTR_CURSOR_TYPE, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_CURSOR_TYPE_set, + callback_SQL_ATTR_CURSOR_TYPE_default, + }, + { SQL_ATTR_ENABLE_AUTO_IPD, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_ENABLE_AUTO_IPD_set, + callback_SQL_ATTR_ENABLE_AUTO_IPD_default, + }, + { SQL_ATTR_FETCH_BOOKMARK_PTR, + OdbcData::Pointer, + Attr_mode_readwrite, + callback_SQL_ATTR_FETCH_BOOKMARK_PTR_set, + callback_SQL_ATTR_FETCH_BOOKMARK_PTR_default, + }, + { SQL_ATTR_IMP_PARAM_DESC, + OdbcData::Pointer, + Attr_mode_readonly, + callback_SQL_ATTR_IMP_PARAM_DESC_set, + callback_SQL_ATTR_IMP_PARAM_DESC_default, + }, + { SQL_ATTR_IMP_ROW_DESC, + OdbcData::Pointer, + Attr_mode_readonly, + callback_SQL_ATTR_IMP_ROW_DESC_set, + callback_SQL_ATTR_IMP_ROW_DESC_default, + }, + { SQL_ATTR_KEYSET_SIZE, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_KEYSET_SIZE_set, + callback_SQL_ATTR_KEYSET_SIZE_default, + }, + { SQL_ATTR_MAX_LENGTH, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_MAX_LENGTH_set, + callback_SQL_ATTR_MAX_LENGTH_default, + }, + { SQL_ATTR_MAX_ROWS, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_MAX_ROWS_set, + callback_SQL_ATTR_MAX_ROWS_default, + }, + { SQL_ATTR_METADATA_ID, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_METADATA_ID_set, + callback_SQL_ATTR_METADATA_ID_default, + }, + { SQL_ATTR_NOSCAN, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_NOSCAN_set, + callback_SQL_ATTR_NOSCAN_default, + }, + { SQL_ATTR_PARAM_BIND_OFFSET_PTR, + OdbcData::UintegerPtr, + Attr_mode_readwrite, + callback_SQL_ATTR_PARAM_BIND_OFFSET_PTR_set, + callback_SQL_ATTR_PARAM_BIND_OFFSET_PTR_default, + }, + { SQL_ATTR_PARAM_BIND_TYPE, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_PARAM_BIND_TYPE_set, + callback_SQL_ATTR_PARAM_BIND_TYPE_default, + }, + { SQL_ATTR_PARAM_OPERATION_PTR, + OdbcData::UsmallintPtr, + Attr_mode_readwrite, + callback_SQL_ATTR_PARAM_OPERATION_PTR_set, + callback_SQL_ATTR_PARAM_OPERATION_PTR_default, + }, + { SQL_ATTR_PARAM_STATUS_PTR, + OdbcData::UsmallintPtr, + Attr_mode_readwrite, + callback_SQL_ATTR_PARAM_STATUS_PTR_set, + callback_SQL_ATTR_PARAM_STATUS_PTR_default, + }, + { SQL_ATTR_PARAMS_PROCESSED_PTR, + OdbcData::UintegerPtr, + Attr_mode_readwrite, + callback_SQL_ATTR_PARAMS_PROCESSED_PTR_set, + callback_SQL_ATTR_PARAMS_PROCESSED_PTR_default, + }, + { SQL_ATTR_PARAMSET_SIZE, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_PARAMSET_SIZE_set, + callback_SQL_ATTR_PARAMSET_SIZE_default, + }, + { SQL_ATTR_QUERY_TIMEOUT, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_QUERY_TIMEOUT_set, + callback_SQL_ATTR_QUERY_TIMEOUT_default, + }, + { SQL_ATTR_RETRIEVE_DATA, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_RETRIEVE_DATA_set, + callback_SQL_ATTR_RETRIEVE_DATA_default, + }, + { SQL_ATTR_ROW_ARRAY_SIZE, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_ROW_ARRAY_SIZE_set, + callback_SQL_ATTR_ROW_ARRAY_SIZE_default, + }, + { SQL_ATTR_ROW_BIND_OFFSET_PTR, + OdbcData::UintegerPtr, + Attr_mode_readwrite, + callback_SQL_ATTR_ROW_BIND_OFFSET_PTR_set, + callback_SQL_ATTR_ROW_BIND_OFFSET_PTR_default, + }, + { SQL_ATTR_ROW_BIND_TYPE, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_ROW_BIND_TYPE_set, + callback_SQL_ATTR_ROW_BIND_TYPE_default, + }, + { SQL_ATTR_ROW_NUMBER, + OdbcData::Uinteger, + Attr_mode_readonly, + callback_SQL_ATTR_ROW_NUMBER_set, + callback_SQL_ATTR_ROW_NUMBER_default, + }, + { SQL_ATTR_ROW_OPERATION_PTR, + OdbcData::UsmallintPtr, + Attr_mode_readwrite, + callback_SQL_ATTR_ROW_OPERATION_PTR_set, + callback_SQL_ATTR_ROW_OPERATION_PTR_default, + }, + { SQL_ATTR_ROW_STATUS_PTR, + OdbcData::UsmallintPtr, + Attr_mode_readwrite, + callback_SQL_ATTR_ROW_STATUS_PTR_set, + callback_SQL_ATTR_ROW_STATUS_PTR_default, + }, + { SQL_ATTR_ROWS_FETCHED_PTR, + OdbcData::UintegerPtr, + Attr_mode_readwrite, + callback_SQL_ATTR_ROWS_FETCHED_PTR_set, + callback_SQL_ATTR_ROWS_FETCHED_PTR_default, + }, + { SQL_ATTR_SIMULATE_CURSOR, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_SIMULATE_CURSOR_set, + callback_SQL_ATTR_SIMULATE_CURSOR_default, + }, + { SQL_ATTR_USE_BOOKMARKS, + OdbcData::Uinteger, + Attr_mode_readwrite, + callback_SQL_ATTR_USE_BOOKMARKS_set, + callback_SQL_ATTR_USE_BOOKMARKS_default, + }, + // driver specific + { SQL_ATTR_NDB_TUPLES_FETCHED, + OdbcData::Uinteger, + Attr_mode_readonly, + callback_SQL_ATTR_NDB_TUPLES_FETCHED_set, + callback_SQL_ATTR_NDB_TUPLES_FETCHED_default, + }, + { 0, + OdbcData::Undef, + Attr_mode_undef, + 0, + 0, + }, +}; diff --git a/ndb/src/client/odbc/handles/DescSpec.cpp b/ndb/src/client/odbc/handles/DescSpec.cpp new file mode 100644 index 00000000000..83905cf9822 --- /dev/null +++ b/ndb/src/client/odbc/handles/DescSpec.cpp @@ -0,0 +1,1140 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "HandleDbc.hpp" +#include "HandleDesc.hpp" + +static void +callback_SQL_DESC_ALLOC_TYPE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Smallint); +} + +static void +callback_SQL_DESC_ALLOC_TYPE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_ARRAY_SIZE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Uinteger); +} + +static void +callback_SQL_DESC_ARRAY_SIZE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_ARRAY_STATUS_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::UsmallintPtr); +} + +static void +callback_SQL_DESC_ARRAY_STATUS_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_BIND_OFFSET_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::IntegerPtr); +} + +static void +callback_SQL_DESC_BIND_OFFSET_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_BIND_TYPE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Integer); +} + +static void +callback_SQL_DESC_BIND_TYPE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_COUNT_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Smallint); +} + +static void +callback_SQL_DESC_COUNT_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_ROWS_PROCESSED_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::UintegerPtr); +} + +static void +callback_SQL_DESC_ROWS_PROCESSED_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_AUTO_UNIQUE_VALUE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Integer); +} + +static void +callback_SQL_DESC_AUTO_UNIQUE_VALUE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_BASE_COLUMN_NAME_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Sqlchar); +} + +static void +callback_SQL_DESC_BASE_COLUMN_NAME_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_BASE_TABLE_NAME_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Sqlchar); +} + +static void +callback_SQL_DESC_BASE_TABLE_NAME_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_CASE_SENSITIVE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Integer); +} + +static void +callback_SQL_DESC_CASE_SENSITIVE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_CATALOG_NAME_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Sqlchar); +} + +static void +callback_SQL_DESC_CATALOG_NAME_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_CONCISE_TYPE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Smallint); +} + +static void +callback_SQL_DESC_CONCISE_TYPE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_DATA_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Pointer); +} + +static void +callback_SQL_DESC_DATA_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_DATETIME_INTERVAL_CODE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Smallint); +} + +static void +callback_SQL_DESC_DATETIME_INTERVAL_CODE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_DATETIME_INTERVAL_PRECISION_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Integer); +} + +static void +callback_SQL_DESC_DATETIME_INTERVAL_PRECISION_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_DISPLAY_SIZE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Integer); +} + +static void +callback_SQL_DESC_DISPLAY_SIZE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_FIXED_PREC_SCALE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Smallint); +} + +static void +callback_SQL_DESC_FIXED_PREC_SCALE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_INDICATOR_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::IntegerPtr); +} + +static void +callback_SQL_DESC_INDICATOR_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_LABEL_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Sqlchar); +} + +static void +callback_SQL_DESC_LABEL_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_LENGTH_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Uinteger); +} + +static void +callback_SQL_DESC_LENGTH_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_LITERAL_PREFIX_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Sqlchar); +} + +static void +callback_SQL_DESC_LITERAL_PREFIX_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_LITERAL_SUFFIX_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Sqlchar); +} + +static void +callback_SQL_DESC_LITERAL_SUFFIX_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_LOCAL_TYPE_NAME_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Sqlchar); +} + +static void +callback_SQL_DESC_LOCAL_TYPE_NAME_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_NAME_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Sqlchar); +} + +static void +callback_SQL_DESC_NAME_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_NULLABLE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Smallint); +} + +static void +callback_SQL_DESC_NULLABLE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_NUM_PREC_RADIX_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Integer); +} + +static void +callback_SQL_DESC_NUM_PREC_RADIX_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_OCTET_LENGTH_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Integer); +} + +static void +callback_SQL_DESC_OCTET_LENGTH_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_OCTET_LENGTH_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::IntegerPtr); +} + +static void +callback_SQL_DESC_OCTET_LENGTH_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_PARAMETER_TYPE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Smallint); +} + +static void +callback_SQL_DESC_PARAMETER_TYPE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_PRECISION_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Smallint); +} + +static void +callback_SQL_DESC_PRECISION_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_ROWVER_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Smallint); +} + +static void +callback_SQL_DESC_ROWVER_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_SCALE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Smallint); +} + +static void +callback_SQL_DESC_SCALE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_SCHEMA_NAME_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Sqlchar); +} + +static void +callback_SQL_DESC_SCHEMA_NAME_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_SEARCHABLE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Smallint); +} + +static void +callback_SQL_DESC_SEARCHABLE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_TABLE_NAME_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Sqlchar); +} + +static void +callback_SQL_DESC_TABLE_NAME_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_TYPE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Smallint); +} + +static void +callback_SQL_DESC_TYPE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_TYPE_NAME_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Sqlchar); +} + +static void +callback_SQL_DESC_TYPE_NAME_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_UNNAMED_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Smallint); +} + +static void +callback_SQL_DESC_UNNAMED_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_UNSIGNED_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Smallint); +} + +static void +callback_SQL_DESC_UNSIGNED_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +static void +callback_SQL_DESC_UPDATABLE_set(Ctx& ctx, HandleBase* self, const OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0 && data.type() == OdbcData::Smallint); +} + +static void +callback_SQL_DESC_UPDATABLE_default(Ctx& ctx, HandleBase* self, OdbcData& data) +{ + HandleDesc* pDesc = static_cast(self); + ctx_assert(pDesc != 0); + data.setValue(); +} + +DescSpec HandleDesc::m_descSpec[] = { + { Desc_pos_header, + SQL_DESC_ALLOC_TYPE, + OdbcData::Smallint, + { Desc_mode_undef, + Desc_mode_readonly, + Desc_mode_readonly, + Desc_mode_readonly, + Desc_mode_readonly, + }, + callback_SQL_DESC_ALLOC_TYPE_set, + callback_SQL_DESC_ALLOC_TYPE_default, + }, + { Desc_pos_header, + SQL_DESC_ARRAY_SIZE, + OdbcData::Uinteger, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_readwrite, + Desc_mode_unused, + Desc_mode_readwrite + }, + callback_SQL_DESC_ARRAY_SIZE_set, + callback_SQL_DESC_ARRAY_SIZE_default, + }, + { Desc_pos_header, + SQL_DESC_ARRAY_STATUS_PTR, + OdbcData::UsmallintPtr, + { Desc_mode_undef, + Desc_mode_readwrite, + Desc_mode_readwrite, + Desc_mode_readwrite, + Desc_mode_readwrite + }, + callback_SQL_DESC_ARRAY_STATUS_PTR_set, + callback_SQL_DESC_ARRAY_STATUS_PTR_default, + }, + { Desc_pos_header, + SQL_DESC_BIND_OFFSET_PTR, + OdbcData::IntegerPtr, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_readwrite, + Desc_mode_unused, + Desc_mode_readwrite + }, + callback_SQL_DESC_BIND_OFFSET_PTR_set, + callback_SQL_DESC_BIND_OFFSET_PTR_default, + }, + { Desc_pos_header, + SQL_DESC_BIND_TYPE, + OdbcData::Integer, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_readwrite, + Desc_mode_unused, + Desc_mode_readwrite + }, + callback_SQL_DESC_BIND_TYPE_set, + callback_SQL_DESC_BIND_TYPE_default, + }, + { Desc_pos_header, + SQL_DESC_COUNT, + OdbcData::Smallint, + { Desc_mode_undef, + Desc_mode_readwrite, + Desc_mode_readwrite, + Desc_mode_readonly, + Desc_mode_readwrite + }, + callback_SQL_DESC_COUNT_set, + callback_SQL_DESC_COUNT_default, + }, + { Desc_pos_header, + SQL_DESC_ROWS_PROCESSED_PTR, + OdbcData::UintegerPtr, + { Desc_mode_undef, + Desc_mode_readwrite, + Desc_mode_unused, + Desc_mode_readwrite, + Desc_mode_unused + }, + callback_SQL_DESC_ROWS_PROCESSED_PTR_set, + callback_SQL_DESC_ROWS_PROCESSED_PTR_default, + }, + { Desc_pos_record, + SQL_DESC_AUTO_UNIQUE_VALUE, + OdbcData::Integer, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_AUTO_UNIQUE_VALUE_set, + callback_SQL_DESC_AUTO_UNIQUE_VALUE_default, + }, + { Desc_pos_record, + SQL_DESC_BASE_COLUMN_NAME, + OdbcData::Sqlchar, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_BASE_COLUMN_NAME_set, + callback_SQL_DESC_BASE_COLUMN_NAME_default, + }, + { Desc_pos_record, + SQL_DESC_BASE_TABLE_NAME, + OdbcData::Sqlchar, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_BASE_TABLE_NAME_set, + callback_SQL_DESC_BASE_TABLE_NAME_default, + }, + { Desc_pos_record, + SQL_DESC_CASE_SENSITIVE, + OdbcData::Integer, + { Desc_mode_undef, + Desc_mode_readonly, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_CASE_SENSITIVE_set, + callback_SQL_DESC_CASE_SENSITIVE_default, + }, + { Desc_pos_record, + SQL_DESC_CATALOG_NAME, + OdbcData::Sqlchar, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_CATALOG_NAME_set, + callback_SQL_DESC_CATALOG_NAME_default, + }, + { Desc_pos_record, + SQL_DESC_CONCISE_TYPE, + OdbcData::Smallint, + { Desc_mode_undef, + Desc_mode_readwrite, + Desc_mode_readwrite, + Desc_mode_readonly, + Desc_mode_readwrite + }, + callback_SQL_DESC_CONCISE_TYPE_set, + callback_SQL_DESC_CONCISE_TYPE_default, + }, + { Desc_pos_record, + SQL_DESC_DATA_PTR, + OdbcData::Pointer, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_readwrite, + Desc_mode_unused, + Desc_mode_readwrite + }, + callback_SQL_DESC_DATA_PTR_set, + callback_SQL_DESC_DATA_PTR_default, + }, + { Desc_pos_record, + SQL_DESC_DATETIME_INTERVAL_CODE, + OdbcData::Smallint, + { Desc_mode_undef, + Desc_mode_readwrite, + Desc_mode_readwrite, + Desc_mode_readonly, + Desc_mode_readwrite + }, + callback_SQL_DESC_DATETIME_INTERVAL_CODE_set, + callback_SQL_DESC_DATETIME_INTERVAL_CODE_default, + }, + { Desc_pos_record, + SQL_DESC_DATETIME_INTERVAL_PRECISION, + OdbcData::Integer, + { Desc_mode_undef, + Desc_mode_readwrite, + Desc_mode_readwrite, + Desc_mode_readonly, + Desc_mode_readwrite + }, + callback_SQL_DESC_DATETIME_INTERVAL_PRECISION_set, + callback_SQL_DESC_DATETIME_INTERVAL_PRECISION_default, + }, + { Desc_pos_record, + SQL_DESC_DISPLAY_SIZE, + OdbcData::Integer, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_DISPLAY_SIZE_set, + callback_SQL_DESC_DISPLAY_SIZE_default, + }, + { Desc_pos_record, + SQL_DESC_FIXED_PREC_SCALE, + OdbcData::Smallint, + { Desc_mode_undef, + Desc_mode_readonly, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_FIXED_PREC_SCALE_set, + callback_SQL_DESC_FIXED_PREC_SCALE_default, + }, + { Desc_pos_record, + SQL_DESC_INDICATOR_PTR, + OdbcData::IntegerPtr, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_readwrite, + Desc_mode_unused, + Desc_mode_readwrite + }, + callback_SQL_DESC_INDICATOR_PTR_set, + callback_SQL_DESC_INDICATOR_PTR_default, + }, + { Desc_pos_record, + SQL_DESC_LABEL, + OdbcData::Sqlchar, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_LABEL_set, + callback_SQL_DESC_LABEL_default, + }, + { Desc_pos_record, + SQL_DESC_LENGTH, + OdbcData::Uinteger, + { Desc_mode_undef, + Desc_mode_readwrite, + Desc_mode_readwrite, + Desc_mode_readonly, + Desc_mode_readwrite + }, + callback_SQL_DESC_LENGTH_set, + callback_SQL_DESC_LENGTH_default, + }, + { Desc_pos_record, + SQL_DESC_LITERAL_PREFIX, + OdbcData::Sqlchar, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_LITERAL_PREFIX_set, + callback_SQL_DESC_LITERAL_PREFIX_default, + }, + { Desc_pos_record, + SQL_DESC_LITERAL_SUFFIX, + OdbcData::Sqlchar, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_LITERAL_SUFFIX_set, + callback_SQL_DESC_LITERAL_SUFFIX_default, + }, + { Desc_pos_record, + SQL_DESC_LOCAL_TYPE_NAME, + OdbcData::Sqlchar, + { Desc_mode_undef, + Desc_mode_readonly, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_LOCAL_TYPE_NAME_set, + callback_SQL_DESC_LOCAL_TYPE_NAME_default, + }, + { Desc_pos_record, + SQL_DESC_NAME, + OdbcData::Sqlchar, + { Desc_mode_undef, + Desc_mode_readwrite, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_NAME_set, + callback_SQL_DESC_NAME_default, + }, + { Desc_pos_record, + SQL_DESC_NULLABLE, + OdbcData::Smallint, + { Desc_mode_undef, + Desc_mode_readonly, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_NULLABLE_set, + callback_SQL_DESC_NULLABLE_default, + }, + { Desc_pos_record, + SQL_DESC_NUM_PREC_RADIX, + OdbcData::Integer, + { Desc_mode_undef, + Desc_mode_readwrite, + Desc_mode_readwrite, + Desc_mode_readonly, + Desc_mode_readwrite + }, + callback_SQL_DESC_NUM_PREC_RADIX_set, + callback_SQL_DESC_NUM_PREC_RADIX_default, + }, + { Desc_pos_record, + SQL_DESC_OCTET_LENGTH, + OdbcData::Integer, + { Desc_mode_undef, + Desc_mode_readwrite, + Desc_mode_readwrite, + Desc_mode_readonly, + Desc_mode_readwrite + }, + callback_SQL_DESC_OCTET_LENGTH_set, + callback_SQL_DESC_OCTET_LENGTH_default, + }, + { Desc_pos_record, + SQL_DESC_OCTET_LENGTH_PTR, + OdbcData::IntegerPtr, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_readwrite, + Desc_mode_unused, + Desc_mode_readwrite + }, + callback_SQL_DESC_OCTET_LENGTH_PTR_set, + callback_SQL_DESC_OCTET_LENGTH_PTR_default, + }, + { Desc_pos_record, + SQL_DESC_PARAMETER_TYPE, + OdbcData::Smallint, + { Desc_mode_undef, + Desc_mode_readwrite, + Desc_mode_unused, + Desc_mode_unused, + Desc_mode_unused + }, + callback_SQL_DESC_PARAMETER_TYPE_set, + callback_SQL_DESC_PARAMETER_TYPE_default, + }, + { Desc_pos_record, + SQL_DESC_PRECISION, + OdbcData::Smallint, + { Desc_mode_undef, + Desc_mode_readwrite, + Desc_mode_readwrite, + Desc_mode_readonly, + Desc_mode_readwrite + }, + callback_SQL_DESC_PRECISION_set, + callback_SQL_DESC_PRECISION_default, + }, + { Desc_pos_record, + SQL_DESC_ROWVER, + OdbcData::Smallint, + { Desc_mode_undef, + Desc_mode_readonly, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_ROWVER_set, + callback_SQL_DESC_ROWVER_default, + }, + { Desc_pos_record, + SQL_DESC_SCALE, + OdbcData::Smallint, + { Desc_mode_undef, + Desc_mode_readwrite, + Desc_mode_readwrite, + Desc_mode_readonly, + Desc_mode_readwrite + }, + callback_SQL_DESC_SCALE_set, + callback_SQL_DESC_SCALE_default, + }, + { Desc_pos_record, + SQL_DESC_SCHEMA_NAME, + OdbcData::Sqlchar, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_SCHEMA_NAME_set, + callback_SQL_DESC_SCHEMA_NAME_default, + }, + { Desc_pos_record, + SQL_DESC_SEARCHABLE, + OdbcData::Smallint, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_SEARCHABLE_set, + callback_SQL_DESC_SEARCHABLE_default, + }, + { Desc_pos_record, + SQL_DESC_TABLE_NAME, + OdbcData::Sqlchar, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_TABLE_NAME_set, + callback_SQL_DESC_TABLE_NAME_default, + }, + { Desc_pos_record, + SQL_DESC_TYPE, + OdbcData::Smallint, + { Desc_mode_undef, + Desc_mode_readwrite, + Desc_mode_readwrite, + Desc_mode_readonly, + Desc_mode_readwrite + }, + callback_SQL_DESC_TYPE_set, + callback_SQL_DESC_TYPE_default, + }, + { Desc_pos_record, + SQL_DESC_TYPE_NAME, + OdbcData::Sqlchar, + { Desc_mode_undef, + Desc_mode_readonly, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_TYPE_NAME_set, + callback_SQL_DESC_TYPE_NAME_default, + }, + { Desc_pos_record, + SQL_DESC_UNNAMED, + OdbcData::Smallint, + { Desc_mode_undef, + Desc_mode_readwrite, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_UNNAMED_set, + callback_SQL_DESC_UNNAMED_default, + }, + { Desc_pos_record, + SQL_DESC_UNSIGNED, + OdbcData::Smallint, + { Desc_mode_undef, + Desc_mode_readonly, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_UNSIGNED_set, + callback_SQL_DESC_UNSIGNED_default, + }, + { Desc_pos_record, + SQL_DESC_UPDATABLE, + OdbcData::Smallint, + { Desc_mode_undef, + Desc_mode_unused, + Desc_mode_unused, + Desc_mode_readonly, + Desc_mode_unused + }, + callback_SQL_DESC_UPDATABLE_set, + callback_SQL_DESC_UPDATABLE_default, + }, + { Desc_pos_end, + 0, + OdbcData::Undef, + { Desc_mode_undef, + Desc_mode_undef, + Desc_mode_undef, + Desc_mode_undef, + Desc_mode_undef + }, + 0, + 0 + }, +}; diff --git a/ndb/src/client/odbc/handles/FuncTab.cpp b/ndb/src/client/odbc/handles/FuncTab.cpp new file mode 100644 index 00000000000..6bd744d7a7f --- /dev/null +++ b/ndb/src/client/odbc/handles/FuncTab.cpp @@ -0,0 +1,100 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "HandleDbc.hpp" + +HandleDbc::FuncTab +HandleDbc::m_funcTab[] = { + { SQL_API_SQLALLOCCONNECT , 1 }, + { SQL_API_SQLALLOCENV , 1 }, + { SQL_API_SQLALLOCHANDLE , 1 }, + { SQL_API_SQLALLOCHANDLESTD , 0 }, + { SQL_API_SQLALLOCSTMT , 1 }, + { SQL_API_SQLBINDCOL , 1 }, + { SQL_API_SQLBINDPARAM , 1 }, + { SQL_API_SQLBINDPARAMETER , 1 }, + { SQL_API_SQLBROWSECONNECT , 0 }, + { SQL_API_SQLBULKOPERATIONS , 0 }, + { SQL_API_SQLCANCEL , 1 }, + { SQL_API_SQLCLOSECURSOR , 1 }, + { SQL_API_SQLCOLATTRIBUTE , 1 }, + { SQL_API_SQLCOLATTRIBUTES , 1 }, + { SQL_API_SQLCOLUMNPRIVILEGES , 0 }, + { SQL_API_SQLCOLUMNS , 1 }, + { SQL_API_SQLCONNECT , 1 }, + { SQL_API_SQLCOPYDESC , 0 }, + { SQL_API_SQLDATASOURCES , 0 }, + { SQL_API_SQLDESCRIBECOL , 1 }, + { SQL_API_SQLDESCRIBEPARAM , 0 }, + { SQL_API_SQLDISCONNECT , 1 }, + { SQL_API_SQLDRIVERCONNECT , 1 }, + { SQL_API_SQLDRIVERS , 0 }, + { SQL_API_SQLENDTRAN , 1 }, + { SQL_API_SQLERROR , 1 }, + { SQL_API_SQLEXECDIRECT , 1 }, + { SQL_API_SQLEXECUTE , 1 }, + { SQL_API_SQLEXTENDEDFETCH , 0 }, + { SQL_API_SQLFETCH , 1 }, + { SQL_API_SQLFETCHSCROLL , 0 }, + { SQL_API_SQLFOREIGNKEYS , 0 }, + { SQL_API_SQLFREECONNECT , 1 }, + { SQL_API_SQLFREEENV , 1 }, + { SQL_API_SQLFREEHANDLE , 1 }, + { SQL_API_SQLFREESTMT , 1 }, + { SQL_API_SQLGETCONNECTATTR , 1 }, + { SQL_API_SQLGETCONNECTOPTION , 1 }, + { SQL_API_SQLGETCURSORNAME , 1 }, + { SQL_API_SQLGETDATA , 1 }, + { SQL_API_SQLGETDESCFIELD , 1 }, + { SQL_API_SQLGETDESCREC , 1 }, + { SQL_API_SQLGETDIAGFIELD , 1 }, + { SQL_API_SQLGETDIAGREC , 1 }, + { SQL_API_SQLGETENVATTR , 1 }, + { SQL_API_SQLGETFUNCTIONS , 1 }, + { SQL_API_SQLGETINFO , 1 }, + { SQL_API_SQLGETSTMTATTR , 1 }, + { SQL_API_SQLGETSTMTOPTION , 1 }, + { SQL_API_SQLGETTYPEINFO , 1 }, + { SQL_API_SQLMORERESULTS , 1 }, + { SQL_API_SQLNATIVESQL , 0 }, + { SQL_API_SQLNUMPARAMS , 1 }, + { SQL_API_SQLNUMRESULTCOLS , 1 }, + { SQL_API_SQLPARAMDATA , 1 }, + { SQL_API_SQLPARAMOPTIONS , 0 }, + { SQL_API_SQLPREPARE , 1 }, + { SQL_API_SQLPRIMARYKEYS , 1 }, + { SQL_API_SQLPROCEDURECOLUMNS , 0 }, + { SQL_API_SQLPROCEDURES , 0 }, + { SQL_API_SQLPUTDATA , 1 }, + { SQL_API_SQLROWCOUNT , 1 }, + { SQL_API_SQLSETCONNECTATTR , 1 }, + { SQL_API_SQLSETCONNECTOPTION , 1 }, + { SQL_API_SQLSETCURSORNAME , 1 }, + { SQL_API_SQLSETDESCFIELD , 1 }, + { SQL_API_SQLSETDESCREC , 1 }, + { SQL_API_SQLSETENVATTR , 1 }, + { SQL_API_SQLSETPARAM , 1 }, + { SQL_API_SQLSETPOS , 0 }, + { SQL_API_SQLSETSCROLLOPTIONS , 0 }, + { SQL_API_SQLSETSTMTATTR , 1 }, + { SQL_API_SQLSETSTMTOPTION , 1 }, + { SQL_API_SQLSPECIALCOLUMNS , 0 }, + { SQL_API_SQLSTATISTICS , 0 }, + { SQL_API_SQLTABLEPRIVILEGES , 0 }, + { SQL_API_SQLTABLES , 1 }, + { SQL_API_SQLTRANSACT , 1 }, + { 0 , -1 } +}; diff --git a/ndb/src/client/odbc/handles/HandleBase.cpp b/ndb/src/client/odbc/handles/HandleBase.cpp new file mode 100644 index 00000000000..27379cdc3f8 --- /dev/null +++ b/ndb/src/client/odbc/handles/HandleBase.cpp @@ -0,0 +1,162 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "HandleBase.hpp" + +HandleBase::~HandleBase() +{ + delete m_ctx; + m_ctx = 0; +} + +void +HandleBase::saveCtx(Ctx& ctx) +{ + delete m_ctx; + m_ctx = &ctx; +} + +// get diagnostics + +void +HandleBase::sqlGetDiagField(Ctx& ctx, SQLSMALLINT recNumber, SQLSMALLINT diagIdentifier, SQLPOINTER diagInfo, SQLSMALLINT bufferLength, SQLSMALLINT* stringLength) +{ + const DiagSpec& spec = DiagSpec::find(diagIdentifier); + if (spec.m_pos == Diag_pos_end) { + ctx.setCode(SQL_ERROR); + return; + } + const bool header = (spec.m_pos == Diag_pos_header); + const bool status = (spec.m_pos == Diag_pos_status); + ctx_assert(header || status); + if (! (spec.m_handles & odbcHandle())) { + ctx.setCode(SQL_ERROR); + return; + } + if (header) { + recNumber = 0; // ignored for header fields, so fix it + if (m_ctx == 0) { + if (diagIdentifier == SQL_DIAG_NUMBER) { + SQLINTEGER n = 0; + OdbcData data(n); + data.copyout(ctx, diagInfo, bufferLength, 0, stringLength); + return; + } + if (diagIdentifier == SQL_DIAG_RETURNCODE) { + SQLSMALLINT n = 0; + OdbcData data(n); + data.copyout(ctx, diagInfo, bufferLength, 0, stringLength); + return; + } + return; + } + } + if (status) { + if (recNumber <= 0) { + ctx.setCode(SQL_ERROR); + return; + } + if (m_ctx == 0) { + if ((unsigned)recNumber > 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + return; + } + if ((unsigned)recNumber > m_ctx->diagArea().numStatus()) { + ctx.setCode(SQL_NO_DATA); + return; + } + } + OdbcData data; + ctx_assert(m_ctx != 0); + m_ctx->diagArea().getRecord(ctx, recNumber, diagIdentifier, data); + if (data.type() != OdbcData::Undef) + data.copyout(ctx, diagInfo, bufferLength, 0, stringLength); +} + +void +HandleBase::sqlGetDiagRec(Ctx& ctx, SQLSMALLINT recNumber, SQLCHAR* sqlstate, SQLINTEGER* nativeError, SQLCHAR* messageText, SQLSMALLINT bufferLength, SQLSMALLINT* textLength) +{ + sqlGetDiagField(ctx, recNumber, SQL_DIAG_SQLSTATE, static_cast(sqlstate), 5 + 1, 0); + sqlGetDiagField(ctx, recNumber, SQL_DIAG_NATIVE, static_cast(nativeError), -1, 0); + sqlGetDiagField(ctx, recNumber, SQL_DIAG_MESSAGE_TEXT, static_cast(messageText), bufferLength, textLength); +} + +void +HandleBase::sqlError(Ctx& ctx, SQLCHAR* sqlstate, SQLINTEGER* nativeError, SQLCHAR* messageText, SQLSMALLINT bufferLength, SQLSMALLINT* textLength) +{ + if (m_ctx == 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + const SQLSMALLINT recNumber = m_ctx->diagArea().nextRecNumber(); + if (recNumber == 0) { + ctx.setCode(SQL_NO_DATA); + return; + } + sqlGetDiagField(ctx, recNumber, SQL_DIAG_SQLSTATE, static_cast(sqlstate), 5 + 1, 0); + sqlGetDiagField(ctx, recNumber, SQL_DIAG_NATIVE, static_cast(nativeError), -1, 0); + sqlGetDiagField(ctx, recNumber, SQL_DIAG_MESSAGE_TEXT, static_cast(messageText), bufferLength, textLength); +} + +// common code for attributes + +void +HandleBase::baseSetHandleAttr(Ctx& ctx, AttrArea& attrArea, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER stringLength) +{ + const AttrSpec& spec = attrArea.findSpec(attribute); + if (spec.m_mode == Attr_mode_undef) { // not found + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "undefined attribute id %d", (int)attribute); + return; + } + if (spec.m_mode == Attr_mode_readonly) { // read only + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "read-only attribute id %d", (int)attribute); + return; + } + OdbcData data; + data.copyin(ctx, spec.m_type, value, stringLength); + if (! ctx.ok()) + return; + attrArea.setAttr(ctx, attribute, data); +} + +void +HandleBase::baseGetHandleAttr(Ctx& ctx, AttrArea& attrArea, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLength) +{ + const AttrSpec& spec = attrArea.findSpec(attribute); + if (spec.m_mode == Attr_mode_undef) { // not found + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "undefined attribute id %d", (int)attribute); + return; + } + OdbcData data; + attrArea.getAttr(ctx, attribute, data); + if (! ctx.ok()) + return; + data.copyout(ctx, value, bufferLength, stringLength); +} + +void +HandleBase::baseSetHandleOption(Ctx& ctx, AttrArea& attrArea, SQLUSMALLINT option, SQLUINTEGER value) +{ + baseSetHandleAttr(ctx, attrArea, static_cast(option), reinterpret_cast(value), 0); +} + +void +HandleBase::baseGetHandleOption(Ctx& ctx, AttrArea& attrArea, SQLUSMALLINT option, SQLPOINTER value) +{ + baseGetHandleAttr(ctx, attrArea, static_cast(option), value, SQL_NTS, 0); +} diff --git a/ndb/src/client/odbc/handles/HandleBase.hpp b/ndb/src/client/odbc/handles/HandleBase.hpp new file mode 100644 index 00000000000..fc35c2b559b --- /dev/null +++ b/ndb/src/client/odbc/handles/HandleBase.hpp @@ -0,0 +1,67 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_HANDLES_HandleBase_hpp +#define ODBC_HANDLES_HandleBase_hpp + +#include +#include +#include +#include + +/** + * @class HandleBase + * @brief Base class for handles + * + * Following types of handles exist: + * - HandleRoot : root node + * - HandleEnv : environment handle (SQLHENV) + * - HandleDbc : connection handle (SQLHDBC) + * - HandleStmt : statement handle (SQLHSTMT) + * - HandleDesc : descriptor handle (SQLHDESC) + */ +class HandleRoot; +class HandleBase { +public: + HandleBase(); + virtual ~HandleBase() = 0; + virtual HandleBase* getParent() = 0; + virtual HandleRoot* getRoot() = 0; + virtual OdbcHandle odbcHandle() = 0; + void saveCtx(Ctx& ctx); + // allocate and free handles + virtual void sqlAllocHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase** ppChild) = 0; + virtual void sqlFreeHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase* pChild) = 0; + // get diagnostics + void sqlGetDiagField(Ctx& ctx, SQLSMALLINT recNumber, SQLSMALLINT diagIdentifier, SQLPOINTER diagInfo, SQLSMALLINT bufferLength, SQLSMALLINT* stringLength); + void sqlGetDiagRec(Ctx& ctx, SQLSMALLINT recNumber, SQLCHAR* sqlstate, SQLINTEGER* nativeError, SQLCHAR* messageText, SQLSMALLINT bufferLength, SQLSMALLINT* textLength); + void sqlError(Ctx& ctx, SQLCHAR* sqlstate, SQLINTEGER* nativeError, SQLCHAR* messageText, SQLSMALLINT bufferLength, SQLSMALLINT* textLength); // odbc2.0 + // common code for attributes + void baseSetHandleAttr(Ctx& ctx, AttrArea& attrArea, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER stringLength); + void baseGetHandleAttr(Ctx& ctx, AttrArea& attrArea, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLength); + void baseSetHandleOption(Ctx& ctx, AttrArea& attrArea, SQLUSMALLINT option, SQLUINTEGER value); // odbc2.0 + void baseGetHandleOption(Ctx& ctx, AttrArea& attrArea, SQLUSMALLINT option, SQLPOINTER value); // odbc2.0 +protected: + Ctx* m_ctx; // saved from last ODBC function +}; + +inline +HandleBase::HandleBase() : + m_ctx(0) +{ +} + +#endif diff --git a/ndb/src/client/odbc/handles/HandleDbc.cpp b/ndb/src/client/odbc/handles/HandleDbc.cpp new file mode 100644 index 00000000000..2d5ded2cc21 --- /dev/null +++ b/ndb/src/client/odbc/handles/HandleDbc.cpp @@ -0,0 +1,419 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include +#include "HandleRoot.hpp" +#include "HandleEnv.hpp" +#include "HandleDbc.hpp" +#include "HandleStmt.hpp" +#include "HandleDesc.hpp" +#include "PoolNdb.hpp" + +#ifndef INT_MAX +#define INT_MAX 2147483647 +#endif + +HandleDbc::HandleDbc(HandleEnv* pEnv) : + m_env(pEnv), + m_attrArea(m_attrSpec) +{ + m_attrArea.setHandle(this); +} + +HandleDbc::~HandleDbc() +{ +} + +void +HandleDbc::ctor(Ctx& ctx) +{ +} + +void +HandleDbc::dtor(Ctx& ctx) +{ + if (m_state == Connected) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "cannot delete connection handle - connection is open"); + return; + } + if (m_state == Transacting) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "cannot delete connection handle - transaction is active"); + return; + } +} + +// allocate and free handles + +void +HandleDbc::sqlAllocStmt(Ctx& ctx, HandleStmt** ppStmt) +{ + if (ppStmt == 0) { + ctx.pushStatus(Sqlstate::_HY009, Error::Gen, "cannot allocate statement handle - null return address"); + return; + } + if (m_state == Free) { + ctx.pushStatus(Sqlstate::_08003, Error::Gen, "cannot allocate statement handle - not connected to database"); + return; + } + HandleStmt* pStmt = new HandleStmt(this); + pStmt->ctor(ctx); + if (! ctx.ok()) { + pStmt->dtor(ctx); + delete pStmt; + return; + } + m_listStmt.push_back(pStmt); + getRoot()->record(SQL_HANDLE_STMT, pStmt, true); + *ppStmt = pStmt; +} + +void +HandleDbc::sqlAllocDesc(Ctx& ctx, HandleDesc** ppDesc) +{ + if (ppDesc == 0) { + ctx.pushStatus(Sqlstate::_HY009, Error::Gen, "cannot allocate descriptor handle - null return address"); + return; + } + if (m_state == Free) { + ctx.pushStatus(Sqlstate::_08003, Error::Gen, "cannot allocate descriptor handle - not connected to database"); + return; + } + HandleDesc* pDesc = new HandleDesc(this); + pDesc->ctor(ctx); + if (! ctx.ok()) { + pDesc->dtor(ctx); + delete pDesc; + return; + } + m_listDesc.push_back(pDesc); + getRoot()->record(SQL_HANDLE_DESC, pDesc, true); + *ppDesc = pDesc; +} + +void +HandleDbc::sqlAllocHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase** ppChild) +{ + switch (childType) { + case SQL_HANDLE_STMT: + sqlAllocStmt(ctx, (HandleStmt**)ppChild); + return; + case SQL_HANDLE_DESC: + sqlAllocDesc(ctx, (HandleDesc**)ppChild); + return; + } + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "invalid child handle type %d", (int)childType); +} + +void +HandleDbc::sqlFreeStmt(Ctx& ctx, HandleStmt* pStmt, SQLUSMALLINT iOption) +{ + switch (iOption) { + case SQL_CLOSE: + // no error if not open + if (pStmt->getState() == HandleStmt::Open) + pStmt->sqlCloseCursor(ctx); + return; + case SQL_DROP: + pStmt->dtor(ctx); + if (! ctx.ok()) + return; + m_listStmt.remove(pStmt); + getRoot()->record(SQL_HANDLE_STMT, pStmt, false); + delete pStmt; + return; + case SQL_UNBIND: { + DescArea& ard = pStmt->getHandleDesc(ctx, Desc_usage_ARD)->descArea(); + ard.setCount(ctx, 0); + return; + } + case SQL_RESET_PARAMS: { + DescArea& apd = pStmt->getHandleDesc(ctx, Desc_usage_APD)->descArea(); + apd.setCount(ctx, 0); + // SQLFreeStmt doc misses this part + DescArea& ipd = pStmt->getHandleDesc(ctx, Desc_usage_IPD)->descArea(); + ipd.setCount(ctx, 0); + return; + } + } + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "invalid free statement option %u", (unsigned)iOption); +} + +void +HandleDbc::sqlFreeDesc(Ctx& ctx, HandleDesc* pDesc) +{ + pDesc->dtor(ctx); + if (! ctx.ok()) + return; + m_listDesc.remove(pDesc); + getRoot()->record(SQL_HANDLE_DESC, pDesc, false); + delete pDesc; +} + +void +HandleDbc::sqlFreeHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase* pChild) +{ + switch (childType) { + case SQL_HANDLE_STMT: + sqlFreeStmt(ctx, (HandleStmt*)pChild, SQL_DROP); + return; + case SQL_HANDLE_DESC: + sqlFreeDesc(ctx, (HandleDesc*)pChild); + return; + } + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "invalid child handle type %d", (int)childType); +} + +// attributes and info functions + +static bool +ignore_attr(Ctx& ctx, SQLINTEGER attribute) +{ + switch (attribute) { + case 1246: + ctx_log2(("ignore unknown ADO.NET connect attribute %d", (int)attribute)); + return true; + } + return false; +} + +void +HandleDbc::sqlSetConnectAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER stringLength) +{ + if (ignore_attr(ctx, attribute)) + return; + baseSetHandleAttr(ctx, m_attrArea, attribute, value, stringLength); +} + +void +HandleDbc::sqlGetConnectAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLength) +{ + if (ignore_attr(ctx, attribute)) + return; + baseGetHandleAttr(ctx, m_attrArea, attribute, value, bufferLength, stringLength); +} + +void +HandleDbc::sqlSetConnectOption(Ctx& ctx, SQLUSMALLINT option, SQLUINTEGER value) +{ + if (ignore_attr(ctx, option)) + return; + baseSetHandleOption(ctx, m_attrArea, option, value); +} + +void +HandleDbc::sqlGetConnectOption(Ctx& ctx, SQLUSMALLINT option, SQLPOINTER value) +{ + if (ignore_attr(ctx, option)) + return; + baseGetHandleOption(ctx, m_attrArea, option, value); +} + +void +HandleDbc::sqlGetFunctions(Ctx& ctx, SQLUSMALLINT functionId, SQLUSMALLINT* supported) +{ + if (functionId == SQL_API_ALL_FUNCTIONS) { + for (int i = 0; i < 100; i++) + supported[i] = SQL_FALSE; + FuncTab* f; + for (f = m_funcTab; f->m_supported != -1; f++) { + SQLUSMALLINT id = f->m_functionId; + if (id < 100 && f->m_supported) + supported[id] = SQL_TRUE; + } + } else if (functionId == SQL_API_ODBC3_ALL_FUNCTIONS) { + for (int i = 0; i < SQL_API_ODBC3_ALL_FUNCTIONS_SIZE; i++) + supported[i] = 0; + FuncTab* f; + for (f = m_funcTab; f->m_supported != -1; f++) { + SQLUSMALLINT id = f->m_functionId; + ctx_assert((id >> 4) < SQL_API_ODBC3_ALL_FUNCTIONS_SIZE); + if (f->m_supported) + supported[id >> 4] |= (1 << (id & 0xf)); + } + } else { + FuncTab* f; + for (f = m_funcTab; f->m_supported != -1; f++) { + if (f->m_functionId == functionId) + break; + } + if (f->m_supported != -1) + supported[0] = f->m_supported ? SQL_TRUE : SQL_FALSE; + else + ctx.pushStatus(Sqlstate::_HY095, Error::Gen, "invalid function id %u", (unsigned)functionId); + } +} + +void +HandleDbc::sqlGetInfo(Ctx& ctx, SQLUSMALLINT infoType, SQLPOINTER infoValue, SQLSMALLINT bufferLength, SQLSMALLINT* stringLength) +{ + InfoTab* f; + for (f = m_infoTab; f->m_format != InfoTab::End; f++) { + if (f->m_id == infoType) + break; + } + if (f->m_format == InfoTab::End) { + ctx.pushStatus(Sqlstate::_HY096, Error::Gen, "invalid info type %u", (unsigned)infoType); + return; + } + if (f->m_format == InfoTab::Char || f->m_format == InfoTab::YesNo) { + ctx_log3(("SQLGetInfo: type=%u value='%s'", (unsigned)infoType, f->m_str)); + OdbcData data(f->m_str); + data.copyout(ctx, infoValue, bufferLength, 0, stringLength); + return; + } + if (f->m_format == InfoTab::Short) { + ctx_log3(("SQLGetInfo: type=%u value=%d", (unsigned)infoType, (int)f->m_int)); + OdbcData data((SQLUSMALLINT)f->m_int); + data.copyout(ctx, infoValue, 0, 0); + return; + } + if (f->m_format == InfoTab::Long || f->m_format == InfoTab::Bitmask) { + ctx_log3(("SQLGetInfo: type=%u value=0x%x", (unsigned)infoType, (int)f->m_int)); + OdbcData data((SQLUINTEGER)f->m_int); + data.copyout(ctx, infoValue, 0, 0); + return; + } + ctx_assert(false); +} + +int +HandleDbc::getOdbcVersion(Ctx& ctx) +{ + return m_env->getOdbcVersion(ctx); +} + +// connect and transactions + +void +HandleDbc::sqlConnect(Ctx& ctx, SQLCHAR* serverName, SQLSMALLINT nameLength1, SQLCHAR* userName, SQLSMALLINT nameLength2, SQLCHAR* authentication, SQLSMALLINT nameLength3) +{ + if (m_state != Free) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "already connected"); + return; + } + OdbcData data; + m_attrArea.getAttr(ctx, SQL_ATTR_CONNECTION_TIMEOUT, data); + int timeout = data.uinteger(); + if (timeout <= 0) + timeout = INT_MAX; + PoolNdb* poolNdb = getRoot()->getPoolNdb(); + Ndb* pNdb = poolNdb->allocate(ctx, timeout); + if (pNdb == 0) { + return; + } + m_ndbObject = pNdb; + m_state = Connected; + m_autocommit = true; +} + +void +HandleDbc::sqlDriverConnect(Ctx& ctx, SQLHWND hwnd, SQLCHAR* szConnStrIn, SQLSMALLINT cbConnStrIn, SQLCHAR* szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT* pcbConnStrOut, SQLUSMALLINT fDriverCompletion) +{ + ctx_log2(("driver connect %.*s", cbConnStrIn, szConnStrIn == 0 ? "" : (char*)szConnStrIn)); + sqlConnect(ctx, (SQLCHAR*)"", 0, (SQLCHAR*)"", 0, (SQLCHAR*)"", 0); + if (! ctx.ok()) + return; + OdbcData data("DNS=DEFAULT"); + if (szConnStrOut != 0) // ADO NET + data.copyout(ctx, static_cast(szConnStrOut), cbConnStrOutMax, 0, pcbConnStrOut); +} + +void +HandleDbc::sqlDisconnect(Ctx& ctx) +{ + if (m_state == Free) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "already disconnected"); + return; + } + // XXX missing check for uncommited changes + ListStmt::iterator i = m_listStmt.begin(); + while (i != m_listStmt.end()) { + HandleStmt* pStmt = *i; + ListStmt::iterator j = i++; + pStmt->dtor(ctx); + getRoot()->record(SQL_HANDLE_STMT, pStmt, false); + delete pStmt; + m_listStmt.erase(j); + } + PoolNdb* poolNdb = getRoot()->getPoolNdb(); + poolNdb->release(ctx, m_ndbObject); + m_ndbObject = 0; + m_state = Free; + m_autocommit = true; +} + +void +HandleDbc::sqlEndTran(Ctx& ctx, SQLSMALLINT completionType) +{ + if (completionType != SQL_COMMIT && completionType != SQL_ROLLBACK) { + ctx.pushStatus(Sqlstate::_HY012, Error::Gen, "invalid completion type %d", (int)completionType); + return; + } + if (m_state == Free) { + ctx.pushStatus(Sqlstate::_08003, Error::Gen, "not connected"); + return; + } + Ndb* ndb = m_ndbObject; + ctx_assert(ndb != 0); + if (m_state == Connected) { + ctx_log2(("sqlEndTran: no transaction active")); + return; + } + NdbConnection* tcon = m_ndbConnection; + ctx_assert(tcon != 0); + if (completionType == SQL_COMMIT) { + if (tcon->execute(Commit) == -1) { + if (tcon->getNdbError().code != 626) + ctx.pushStatus(ndb, tcon, 0, "execute commit"); + else + ctx_log1(("ignore no data (626) at execute commit")); + } else { + ctx_log2(("sqlEndTran: transaction commit done")); + m_uncommitted = false; + } + } else { + if (tcon->execute(Rollback) == -1) { + if (tcon->getNdbError().code != 626) + ctx.pushStatus(ndb, tcon, 0, "execute rollback"); + else + ctx_log1(("ignore no data (626) at execute rollback")); + } else { + ctx_log2(("sqlEndTran: transaction rollback done")); + m_uncommitted = false; + } + } + for (ListStmt::iterator i = m_listStmt.begin(); i != m_listStmt.end(); i++) { + HandleStmt* pStmt = *i; + if (pStmt->getState() == HandleStmt::Open) { + pStmt->sqlCloseCursor(ctx); // SQL_CB_CLOSE behaviour + } + pStmt->useConnection(ctx, false); + } + if (! m_autocommit) { + useConnection(ctx, false); + useConnection(ctx, true); + } +} + +void +HandleDbc::sqlTransact(Ctx& ctx, SQLUSMALLINT completionType) +{ + sqlEndTran(ctx, completionType); +} diff --git a/ndb/src/client/odbc/handles/HandleDbc.hpp b/ndb/src/client/odbc/handles/HandleDbc.hpp new file mode 100644 index 00000000000..130df08d02c --- /dev/null +++ b/ndb/src/client/odbc/handles/HandleDbc.hpp @@ -0,0 +1,111 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_HANDLES_HandleDbc_hpp +#define ODBC_HANDLES_HandleDbc_hpp + +#include +#include +#include +#include "HandleBase.hpp" + +class HandleRoot; +class HandleEnv; +class HandleStmt; +class HandleDesc; + +/** + * @class HandleDbc + * @brief Connection handle (SQLHDBC). + */ +class HandleDbc : public HandleBase, public ConnArea { +public: + HandleDbc(HandleEnv* pEnv); + ~HandleDbc(); + void ctor(Ctx& ctx); + void dtor(Ctx& ctx); + HandleEnv* getEnv(); + HandleBase* getParent(); + HandleRoot* getRoot(); + OdbcHandle odbcHandle(); + // allocate and free handles + void sqlAllocStmt(Ctx& ctx, HandleStmt** ppStmt); + void sqlAllocDesc(Ctx& ctx, HandleDesc** ppDesc); + void sqlAllocHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase** ppChild); + void sqlFreeStmt(Ctx& ctx, HandleStmt* pStmt, SQLUSMALLINT iOption); + void sqlFreeDesc(Ctx& ctx, HandleDesc* pDesc); + void sqlFreeHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase* pChild); + // attributes and info functions + void sqlSetConnectAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER stringLength); + void sqlGetConnectAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLength); + void sqlSetConnectOption(Ctx& ctx, SQLUSMALLINT option, SQLUINTEGER value); // odbc2.0 + void sqlGetConnectOption(Ctx& ctx, SQLUSMALLINT option, SQLPOINTER value); // odbc2.0 + void sqlGetFunctions(Ctx& ctx, SQLUSMALLINT functionId, SQLUSMALLINT* supported); + void sqlGetInfo(Ctx& ctx, SQLUSMALLINT infoType, SQLPOINTER infoValue, SQLSMALLINT bufferLength, SQLSMALLINT* stringLength); + int getOdbcVersion(Ctx& ctx); + // connect and transactions + void sqlConnect(Ctx& ctx, SQLCHAR* serverName, SQLSMALLINT nameLength1, SQLCHAR* userName, SQLSMALLINT nameLength2, SQLCHAR* authentication, SQLSMALLINT nameLength3); + void sqlDriverConnect(Ctx& ctx, SQLHWND hwnd, SQLCHAR* szConnStrIn, SQLSMALLINT cbConnStrIn, SQLCHAR* szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT* pcbConnStrOut, SQLUSMALLINT fDriverCompletion); + void sqlDisconnect(Ctx& ctx); + void sqlEndTran(Ctx& ctx, SQLSMALLINT completionType); + void sqlTransact(Ctx& ctx, SQLUSMALLINT completionType); // odbc2.0 +private: + HandleEnv* const m_env; + typedef std::list ListStmt; + ListStmt m_listStmt; + typedef std::list ListDesc; + ListDesc m_listDesc; + static AttrSpec m_attrSpec[]; + AttrArea m_attrArea; + struct FuncTab { + SQLUSMALLINT m_functionId; + int m_supported; + }; + static FuncTab m_funcTab[]; + struct InfoTab { + SQLUSMALLINT m_id; + enum { Char, YesNo, Short, Long, Bitmask, End } m_format; + SQLUINTEGER m_int; + const char* m_str; + }; + static InfoTab m_infoTab[]; +}; + +inline HandleEnv* +HandleDbc::getEnv() +{ + return m_env; +} + +inline HandleBase* +HandleDbc::getParent() +{ + return (HandleBase*)getEnv(); +} + +inline HandleRoot* +HandleDbc::getRoot() +{ + return getParent()->getRoot(); +} + +inline OdbcHandle +HandleDbc::odbcHandle() +{ + return Odbc_handle_dbc; +} + +#endif diff --git a/ndb/src/client/odbc/handles/HandleDesc.cpp b/ndb/src/client/odbc/handles/HandleDesc.cpp new file mode 100644 index 00000000000..4cff1bb8892 --- /dev/null +++ b/ndb/src/client/odbc/handles/HandleDesc.cpp @@ -0,0 +1,254 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "HandleRoot.hpp" +#include "HandleDbc.hpp" +#include "HandleDesc.hpp" + +HandleDesc::HandleDesc(HandleDbc* pDbc) : + m_dbc(pDbc), + m_descArea(this, m_descSpec) +{ +} + +HandleDesc::~HandleDesc() +{ +} + +void +HandleDesc::ctor(Ctx& ctx) +{ +} + +void +HandleDesc::dtor(Ctx& ctx) +{ +} + +// allocate and free handles (no valid case) + +void +HandleDesc::sqlAllocHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase** ppChild) +{ + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "inappropriate handle type"); +} + +void +HandleDesc::sqlFreeHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase* ppChild) +{ + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "inappropriate handle type"); +} + +// set and get descriptor values + +void +HandleDesc::sqlSetDescField(Ctx& ctx, SQLSMALLINT recNumber, SQLSMALLINT fieldIdentifier, SQLPOINTER value, SQLINTEGER bufferLength) +{ + const DescSpec& spec = m_descArea.findSpec(fieldIdentifier); + if (spec.m_pos == Desc_pos_end) { + ctx.pushStatus(Sqlstate::_HY091, Error::Gen, "invalid descriptor id %d", (int)fieldIdentifier); + return; + } + OdbcData data; + data.copyin(ctx, spec.m_type, value, bufferLength); + if (! ctx.ok()) + return; + const bool header = (spec.m_pos == Desc_pos_header); + const bool record = (spec.m_pos == Desc_pos_record); + ctx_assert(header || record); + DescArea& area = m_descArea; + if (header) { + area.getHeader().setField(ctx, fieldIdentifier, data); + } + if (record) { + if (recNumber < 0) { + ctx.pushStatus(Sqlstate::_07009, Error::Gen, "invalid record number %d", (int)recNumber); + return; + } + if (recNumber == 0) { // bookmark record + if (area.getUsage() == Desc_usage_IPD) { + ctx.pushStatus(Sqlstate::_07009, Error::Gen, "cannot set bookmark IPD"); + return; + } + if (area.getUsage() == Desc_usage_APD) { + ctx.pushStatus(Sqlstate::_07009, Error::Gen, "cannot set bookmark APD"); + return; + } + } + area.getRecord(recNumber).setField(ctx, fieldIdentifier, data); + } +} + +void +HandleDesc::sqlGetDescField(Ctx& ctx, SQLSMALLINT recNumber, SQLSMALLINT fieldIdentifier, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLength, SQLSMALLINT* stringLength2) +{ + const DescSpec& spec = m_descArea.findSpec(fieldIdentifier); + if (spec.m_pos == Desc_pos_end) { + ctx.pushStatus(Sqlstate::_HY091, Error::Gen, "invalid descriptor id %d", (int)fieldIdentifier); + return; + } + const bool header = (spec.m_pos == Desc_pos_header); + const bool record = (spec.m_pos == Desc_pos_record); + ctx_assert(header || record); + DescArea& area = m_descArea; + OdbcData data; + if (header) { + area.getHeader().getField(ctx, fieldIdentifier, data); + if (! ctx.ok()) + return; + } + if (record) { + if (recNumber < 0) { + ctx.pushStatus(Sqlstate::_07009, Error::Gen, "invalid record number %d", (int)recNumber); + return; + } + if (recNumber == 0) { // bookmark record + if (area.getUsage() == Desc_usage_IPD) { + ctx.pushStatus(Sqlstate::_07009, Error::Gen, "cannot get bookmark IPD"); + return; + } + if (area.getUsage() == Desc_usage_IRD) { + // XXX check SQL_ATTR_USE_BOOKMARK != SQL_UB_OFF + } + } + if ((unsigned)recNumber > area.getCount()) { + ctx.setCode(SQL_NO_DATA); + return; + } + area.getRecord(recNumber).getField(ctx, fieldIdentifier, data); + if (! ctx.ok()) + return; + } + // if no data, return success and undefined value + if (data.type() == OdbcData::Undef) + return; + data.copyout(ctx, value, bufferLength, stringLength, stringLength2); +} + +void +HandleDesc::sqlColAttribute(Ctx& ctx, SQLUSMALLINT columnNumber, SQLUSMALLINT fieldIdentifier, SQLPOINTER characterAttribute, SQLSMALLINT bufferLength, SQLSMALLINT* stringLength, SQLPOINTER numericAttribute) +{ + ctx_log3(("sqlColAttribute col=%d id=%d", columnNumber, fieldIdentifier)); + if (fieldIdentifier == SQL_COLUMN_LENGTH) { // XXX iODBC workaround + fieldIdentifier = SQL_DESC_LENGTH; + } + if (fieldIdentifier == 1205 || fieldIdentifier == 1206) { + ctx_log2(("ignore unknown OSQL fieldIdentifier %d", (int)fieldIdentifier)); + if (characterAttribute != 0) + *(char*)characterAttribute = 0; + if (stringLength != 0) + *stringLength = 0; + return; + } + const DescSpec& spec = m_descArea.findSpec(fieldIdentifier); + if (spec.m_pos == Desc_pos_end) { + ctx.pushStatus(Sqlstate::_HY091, Error::Gen, "invalid descriptor id %d", (int)fieldIdentifier); + return; + } + if (spec.m_type == OdbcData::Sqlchar || spec.m_type == OdbcData::Sqlstate) + sqlGetDescField(ctx, columnNumber, fieldIdentifier, characterAttribute, bufferLength, 0, stringLength); + else { + sqlGetDescField(ctx, columnNumber, fieldIdentifier, numericAttribute, -1, 0); + } + if (ctx.getCode() == SQL_NO_DATA) { + ctx.setCode(SQL_SUCCESS); + ctx.pushStatus(Sqlstate::_07009, Error::Gen, "invalid column number %d", (int)columnNumber); + } +} + +void +HandleDesc::sqlColAttributes(Ctx& ctx, SQLUSMALLINT icol, SQLUSMALLINT fdescType, SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT* pcbDesc, SQLINTEGER* pfDesc) +{ + ctx_log3(("sqlColAttributes col=%hu id=%hu", icol, fdescType)); + SQLUSMALLINT columnNumber = icol; + SQLUSMALLINT fieldIdentifier; + // XXX incomplete + if (fdescType == SQL_COLUMN_TYPE) { + fieldIdentifier = SQL_DESC_TYPE; + } else if (fdescType == SQL_COLUMN_PRECISION) { + SQLSMALLINT type; + sqlGetDescField(ctx, columnNumber, SQL_DESC_TYPE, static_cast(&type), -1, 0); + if (! ctx.ok()) + return; + switch (type) { + case SQL_CHAR: + case SQL_VARCHAR: + case SQL_BINARY: + case SQL_VARBINARY: + case SQL_LONGVARCHAR: + case SQL_LONGVARBINARY: + case SQL_DATE: + fieldIdentifier = SQL_DESC_LENGTH; + break; + default: + fieldIdentifier = SQL_DESC_PRECISION; + break; + } + } else if (fdescType == SQL_COLUMN_SCALE) { + SQLSMALLINT type; + sqlGetDescField(ctx, columnNumber, SQL_DESC_TYPE, static_cast(&type), -1, 0); + if (! ctx.ok()) + return; + switch (type) { + default: + fieldIdentifier = SQL_DESC_SCALE; + break; + } + } else if (fdescType == SQL_COLUMN_LENGTH) { + SQLSMALLINT type; + sqlGetDescField(ctx, columnNumber, SQL_DESC_TYPE, static_cast(&type), -1, 0); + if (! ctx.ok()) + return; + switch (type) { + default: + fieldIdentifier = SQL_DESC_LENGTH; + break; + } + } else { + fieldIdentifier = fdescType; + } + sqlColAttribute(ctx, columnNumber, fieldIdentifier, rgbDesc, cbDescMax, pcbDesc, pfDesc); +} + +// set and get several common descriptor values + +void +HandleDesc::sqlSetDescRec(Ctx& ctx, SQLSMALLINT recNumber, SQLSMALLINT type, SQLSMALLINT subType, SQLINTEGER length, SQLSMALLINT precision, SQLSMALLINT scale, SQLPOINTER data, SQLINTEGER* stringLength, SQLINTEGER* indicator) +{ + sqlSetDescField(ctx, recNumber, SQL_DESC_TYPE, reinterpret_cast(type), -1); + sqlSetDescField(ctx, recNumber, SQL_DESC_DATETIME_INTERVAL_CODE, reinterpret_cast(subType), -1); + sqlSetDescField(ctx, recNumber, SQL_DESC_OCTET_LENGTH, reinterpret_cast(length), -1); + sqlSetDescField(ctx, recNumber, SQL_DESC_PRECISION, reinterpret_cast(precision), -1); + sqlSetDescField(ctx, recNumber, SQL_DESC_SCALE, reinterpret_cast(scale), -1); + sqlSetDescField(ctx, recNumber, SQL_DESC_DATA_PTR, data, -1); + sqlSetDescField(ctx, recNumber, SQL_DESC_OCTET_LENGTH_PTR, reinterpret_cast(stringLength), -1); + sqlSetDescField(ctx, recNumber, SQL_DESC_INDICATOR_PTR, reinterpret_cast(indicator), -1); +} + +void +HandleDesc::sqlGetDescRec(Ctx& ctx, SQLSMALLINT recNumber, SQLCHAR* name, SQLSMALLINT bufferLength, SQLSMALLINT* stringLength, SQLSMALLINT* type, SQLSMALLINT* subType, SQLINTEGER* length, SQLSMALLINT* precision, SQLSMALLINT* scale, SQLSMALLINT* nullable) +{ + sqlGetDescField(ctx, recNumber, SQL_DESC_NAME, reinterpret_cast(name), bufferLength, 0, stringLength); + sqlGetDescField(ctx, recNumber, SQL_DESC_TYPE, reinterpret_cast(type), -1, 0); + sqlGetDescField(ctx, recNumber, SQL_DESC_DATETIME_INTERVAL_CODE, reinterpret_cast(subType), -1, 0); + sqlGetDescField(ctx, recNumber, SQL_DESC_OCTET_LENGTH, reinterpret_cast(length), -1, 0); + sqlGetDescField(ctx, recNumber, SQL_DESC_PRECISION, reinterpret_cast(precision), -1, 0); + sqlGetDescField(ctx, recNumber, SQL_DESC_SCALE, reinterpret_cast(scale), -1, 0); + sqlGetDescField(ctx, recNumber, SQL_DESC_NULLABLE, reinterpret_cast(nullable), -1, 0); +} diff --git a/ndb/src/client/odbc/handles/HandleDesc.hpp b/ndb/src/client/odbc/handles/HandleDesc.hpp new file mode 100644 index 00000000000..9419697f134 --- /dev/null +++ b/ndb/src/client/odbc/handles/HandleDesc.hpp @@ -0,0 +1,89 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_HANDLES_HandleDesc_hpp +#define ODBC_HANDLES_HandleDesc_hpp + +#include +#include +#include "HandleBase.hpp" + +class HandleRoot; +class HandleDbc; + +/** + * @class HandleDesc + * @brief Descriptor handle (SQLHDESC). + */ +class HandleDesc : public HandleBase { +public: + HandleDesc(HandleDbc* pDbc); + ~HandleDesc(); + void ctor(Ctx& ctx); + void dtor(Ctx& ctx); + HandleDbc* getDbc(); + HandleBase* getParent(); + HandleRoot* getRoot(); + OdbcHandle odbcHandle(); + DescArea& descArea(); + // allocate and free handles (no valid case) + void sqlAllocHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase** ppChild); + void sqlFreeHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase* pChild); + // set and get descriptor values (internal use) + void sqlSetDescField(Ctx& ctx, SQLSMALLINT recNumber, SQLSMALLINT fieldIdentifier, SQLPOINTER value, SQLINTEGER bufferLength); + void sqlGetDescField(Ctx& ctx, SQLSMALLINT recNumber, SQLSMALLINT fieldIdentifier, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLength, SQLSMALLINT* stringLength2 = 0); + void sqlColAttribute(Ctx& ctx, SQLUSMALLINT columnNumber, SQLUSMALLINT fieldIdentifier, SQLPOINTER characterAttribute, SQLSMALLINT bufferLength, SQLSMALLINT* stringLength, SQLPOINTER numericAttribute); + void sqlColAttributes(Ctx& ctx, SQLUSMALLINT icol, SQLUSMALLINT fdescType, SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT* pcbDesc, SQLINTEGER* pfDesc); + // set and get several common descriptor values + void sqlSetDescRec(Ctx& ctx, SQLSMALLINT recNumber, SQLSMALLINT Type, SQLSMALLINT SubType, SQLINTEGER Length, SQLSMALLINT Precision, SQLSMALLINT Scale, SQLPOINTER Data, SQLINTEGER* StringLength, SQLINTEGER* Indicator); + void sqlGetDescRec(Ctx& ctx, SQLSMALLINT recNumber, SQLCHAR* Name, SQLSMALLINT BufferLength, SQLSMALLINT* StringLength, SQLSMALLINT* Type, SQLSMALLINT* SubType, SQLINTEGER* Length, SQLSMALLINT* Precision, SQLSMALLINT* Scale, SQLSMALLINT* Nullable); +private: + HandleDbc* const m_dbc; + static DescSpec m_descSpec[]; + DescArea m_descArea; +}; + +inline HandleDbc* +HandleDesc::getDbc() +{ + return m_dbc; +} + +inline HandleBase* +HandleDesc::getParent() +{ + return (HandleDbc*)getDbc(); +} + +inline HandleRoot* +HandleDesc::getRoot() +{ + return getParent()->getRoot(); +} + +inline OdbcHandle +HandleDesc::odbcHandle() +{ + return Odbc_handle_desc; +} + +inline DescArea& +HandleDesc::descArea() +{ + return m_descArea; +} + +#endif diff --git a/ndb/src/client/odbc/handles/HandleEnv.cpp b/ndb/src/client/odbc/handles/HandleEnv.cpp new file mode 100644 index 00000000000..bc9d8b420a6 --- /dev/null +++ b/ndb/src/client/odbc/handles/HandleEnv.cpp @@ -0,0 +1,144 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "HandleRoot.hpp" +#include "HandleEnv.hpp" +#include "HandleDbc.hpp" + +HandleEnv::HandleEnv(HandleRoot* pRoot) : + m_root(pRoot), + m_attrArea(m_attrSpec) +{ + m_attrArea.setHandle(this); +} + +HandleEnv::~HandleEnv() { +} + +void +HandleEnv::ctor(Ctx& ctx) +{ +} + +void +HandleEnv::dtor(Ctx& ctx) +{ + if (! m_listDbc.empty()) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "cannot delete environment handle - has %u associated connection handles", (unsigned)m_listDbc.size()); + return; + } +} + +// allocate and free handles + +void +HandleEnv::sqlAllocConnect(Ctx& ctx, HandleDbc** ppDbc) +{ + if (getOdbcVersion(ctx) == -1) + return; + if (ppDbc == 0) { + ctx.pushStatus(Sqlstate::_HY009, Error::Gen, "cannot allocate connection handle - null return address"); + return; + } + HandleDbc* pDbc = new HandleDbc(this); + pDbc->ctor(ctx); + if (! ctx.ok()) { + pDbc->dtor(ctx); + delete pDbc; + return; + } + m_listDbc.push_back(pDbc); + getRoot()->record(SQL_HANDLE_DBC, pDbc, true); + *ppDbc = pDbc; +} + +void +HandleEnv::sqlAllocHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase** ppChild) +{ + if (getOdbcVersion(ctx) == -1) + return; + switch (childType) { + case SQL_HANDLE_DBC: + sqlAllocConnect(ctx, (HandleDbc**)ppChild); + return; + } + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "invalid child handle type %d", (int)childType); +} + +void +HandleEnv::sqlFreeConnect(Ctx& ctx, HandleDbc* pDbc) +{ + if (getOdbcVersion(ctx) == -1) + return; + pDbc->dtor(ctx); + if (! ctx.ok()) + return; + m_listDbc.remove(pDbc); + getRoot()->record(SQL_HANDLE_DBC, pDbc, false); + delete pDbc; +} + +void +HandleEnv::sqlFreeHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase* pChild) +{ + if (getOdbcVersion(ctx) == -1) + return; + switch (childType) { + case SQL_HANDLE_DBC: + sqlFreeConnect(ctx, (HandleDbc*)pChild); + return; + } + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "invalid child handle type %d", (int)childType); +} + +// attributes + +void +HandleEnv::sqlSetEnvAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER stringLength) +{ + baseSetHandleAttr(ctx, m_attrArea, attribute, value, stringLength); +} + +void +HandleEnv::sqlGetEnvAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLength) +{ + baseGetHandleAttr(ctx, m_attrArea, attribute, value, bufferLength, stringLength); +} + +int +HandleEnv::getOdbcVersion(Ctx& ctx) +{ + OdbcData data; + m_attrArea.getAttr(ctx, SQL_ATTR_ODBC_VERSION, data); + if (! ctx.ok()) + return -1; + return data.integer(); +} + +// transactions + +void +HandleEnv::sqlEndTran(Ctx& ctx, SQLSMALLINT completionType) +{ + ctx_assert(false); // XXX +} + +void +HandleEnv::sqlTransact(Ctx& ctx, SQLUSMALLINT completionType) +{ + ctx_assert(false); // XXX +} diff --git a/ndb/src/client/odbc/handles/HandleEnv.hpp b/ndb/src/client/odbc/handles/HandleEnv.hpp new file mode 100644 index 00000000000..2b13b0256bc --- /dev/null +++ b/ndb/src/client/odbc/handles/HandleEnv.hpp @@ -0,0 +1,77 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_HANDLES_HandleEnv_hpp +#define ODBC_HANDLES_HandleEnv_hpp + +#include +#include +#include "HandleBase.hpp" + +class HandleRoot; +class HandleDbc; + +/** + * @class HandleEnv + * @brief Environment handle (SQLHENV). + */ +class HandleEnv : public HandleBase { +public: + HandleEnv(HandleRoot* pRoot); + ~HandleEnv(); + void ctor(Ctx& ctx); + void dtor(Ctx& ctx); + HandleRoot* getRoot(); + HandleBase* getParent(); + OdbcHandle odbcHandle(); + // allocate and free handles + void sqlAllocConnect(Ctx& ctx, HandleDbc** ppDbc); + void sqlAllocHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase** ppChild); + void sqlFreeConnect(Ctx& ctx, HandleDbc* pDbc); + void sqlFreeHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase* pChild); + // attributes + void sqlSetEnvAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER stringLength); + void sqlGetEnvAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLength); + int getOdbcVersion(Ctx& ctx); // returns -1 if not set + // transactions + void sqlEndTran(Ctx& ctx, SQLSMALLINT completionType); + void sqlTransact(Ctx& ctx, SQLUSMALLINT completionType); // odbc2.0 +private: + HandleRoot* const m_root; + std::list m_listDbc; + static AttrSpec m_attrSpec[]; + AttrArea m_attrArea; +}; + +inline HandleRoot* +HandleEnv::getRoot() +{ + return m_root; +} + +inline HandleBase* +HandleEnv::getParent() +{ + return (HandleBase*)getRoot(); +} + +inline OdbcHandle +HandleEnv::odbcHandle() +{ + return Odbc_handle_env; +} + +#endif diff --git a/ndb/src/client/odbc/handles/HandleRoot.cpp b/ndb/src/client/odbc/handles/HandleRoot.cpp new file mode 100644 index 00000000000..d901cb5cb7f --- /dev/null +++ b/ndb/src/client/odbc/handles/HandleRoot.cpp @@ -0,0 +1,270 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include "HandleRoot.hpp" +#include "HandleEnv.hpp" +#include "HandleDbc.hpp" +#include "HandleStmt.hpp" +#include "HandleDesc.hpp" +#include "PoolNdb.hpp" + +HandleRoot::HandleRoot() : + m_attrArea(m_attrSpec) +{ + m_attrArea.setHandle(this); + m_poolNdb = new PoolNdb(); +} + +HandleRoot::~HandleRoot() +{ +} + +#ifdef NDB_WIN32 +static NdbMutex & root_mutex = * NdbMutex_Create(); +#else +static NdbMutex root_mutex = NDB_MUTEX_INITIALIZER; +#endif + +HandleRoot* +HandleRoot::instance() +{ + NdbMutex_Lock(&root_mutex); + if (m_instance == 0) + m_instance = new HandleRoot(); + NdbMutex_Unlock(&root_mutex); + return m_instance; +} + +void +HandleRoot::lockHandle() +{ + NdbMutex_Lock(&root_mutex); +} + +void +HandleRoot::unlockHandle() +{ + NdbMutex_Unlock(&root_mutex); +} + +// check and find handle types and handles + +SQLSMALLINT +HandleRoot::findParentType(SQLSMALLINT childType) +{ + switch (childType) { + case SQL_HANDLE_ENV: + return SQL_HANDLE_ROOT; + case SQL_HANDLE_DBC: + return SQL_HANDLE_ENV; + case SQL_HANDLE_STMT: + return SQL_HANDLE_DBC; + case SQL_HANDLE_DESC: + return SQL_HANDLE_DBC; + } + return -1; +} + +HandleBase* +HandleRoot::findBase(SQLSMALLINT handleType, void* pHandle) +{ + switch (handleType) { + case SQL_HANDLE_ROOT: + return getRoot(); + case SQL_HANDLE_ENV: + return findEnv(pHandle); + case SQL_HANDLE_DBC: + return findDbc(pHandle); + case SQL_HANDLE_STMT: + return findStmt(pHandle); + case SQL_HANDLE_DESC: + return findDesc(pHandle); + } + return 0; +} + +HandleEnv* +HandleRoot::findEnv(void* pHandle) +{ + lockHandle(); + ValidList::iterator i = m_validList.find(pHandle); + if (i == m_validList.end() || (*i).second != SQL_HANDLE_ENV) { + unlockHandle(); + return 0; + } + unlockHandle(); + ctx_assert(pHandle != 0); + return static_cast(pHandle); +} + +HandleDbc* +HandleRoot::findDbc(void* pHandle) +{ + lockHandle(); + ValidList::iterator i = m_validList.find(pHandle); + if (i == m_validList.end() || (*i).second != SQL_HANDLE_DBC) { + unlockHandle(); + return 0; + } + unlockHandle(); + ctx_assert(pHandle != 0); + return static_cast(pHandle); +} + +HandleStmt* +HandleRoot::findStmt(void* pHandle) +{ + lockHandle(); + ValidList::iterator i = m_validList.find(pHandle); + if (i == m_validList.end() || (*i).second != SQL_HANDLE_STMT) { + unlockHandle(); + return 0; + } + unlockHandle(); + ctx_assert(pHandle != 0); + return static_cast(pHandle); +} + +HandleDesc* +HandleRoot::findDesc(void* pHandle) +{ + lockHandle(); + ValidList::iterator i = m_validList.find(pHandle); + if (i == m_validList.end() || (*i).second != SQL_HANDLE_DESC) { + unlockHandle(); + return 0; + } + unlockHandle(); + ctx_assert(pHandle != 0); + return static_cast(pHandle); +} + +// add or remove handle from validation list + +void +HandleRoot::record(SQLSMALLINT handleType, HandleBase* pHandle, bool add) +{ + switch (handleType) { + case SQL_HANDLE_ENV: + case SQL_HANDLE_DBC: + case SQL_HANDLE_STMT: + case SQL_HANDLE_DESC: + break; + default: + ctx_assert(false); + break; + } + ctx_assert(pHandle != 0); + lockHandle(); + ValidList::iterator i = m_validList.find(pHandle); + if (add) { + if (i != m_validList.end()) { + unlockHandle(); + ctx_assert(false); + } + m_validList.insert(ValidList::value_type(pHandle, handleType)); + } else { + if (i == m_validList.end() || (*i).second != handleType) { + unlockHandle(); + ctx_assert(false); + } + m_validList.erase(i); + } + unlockHandle(); +} + +// allocate and free handles + +void +HandleRoot::sqlAllocEnv(Ctx& ctx, HandleEnv** ppEnv) +{ + if (ppEnv == 0) { + ctx.pushStatus(Sqlstate::_HY009, Error::Gen, "cannot allocate environment handle - null return address"); + return; + } + HandleEnv* pEnv = new HandleEnv(this); + pEnv->ctor(ctx); + if (! ctx.ok()) { + pEnv->dtor(ctx); + delete pEnv; + return; + } + lockHandle(); + m_listEnv.push_back(pEnv); + unlockHandle(); + getRoot()->record(SQL_HANDLE_ENV, pEnv, true); + *ppEnv = pEnv; +} + +void +HandleRoot::sqlAllocHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase** ppChild) +{ + switch (childType) { + case SQL_HANDLE_ENV: + sqlAllocEnv(ctx, (HandleEnv**)ppChild); + return; + } + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "invalid child handle type %d", (int)childType); +} + +void +HandleRoot::sqlFreeEnv(Ctx& ctx, HandleEnv* pEnv) +{ + pEnv->dtor(ctx); + if (! ctx.ok()) { + return; + } + lockHandle(); + m_listEnv.remove(pEnv); + unlockHandle(); + getRoot()->record(SQL_HANDLE_ENV, pEnv, false); + delete pEnv; +} + +void +HandleRoot::sqlFreeHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase* pChild) +{ + switch (childType) { + case SQL_HANDLE_ENV: + sqlFreeEnv(ctx, (HandleEnv*)pChild); + return; + } + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "invalid child handle type %d", (int)childType); +} + +// process-level attributes + +void +HandleRoot::sqlSetRootAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER stringLength) +{ + lockHandle(); + baseSetHandleAttr(ctx, m_attrArea, attribute, value, stringLength); + unlockHandle(); +} + +void +HandleRoot::sqlGetRootAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLength) +{ + lockHandle(); + baseGetHandleAttr(ctx, m_attrArea, attribute, value, bufferLength, stringLength); + unlockHandle(); +} + +// the instance + +HandleRoot* HandleRoot::m_instance = 0; diff --git a/ndb/src/client/odbc/handles/HandleRoot.hpp b/ndb/src/client/odbc/handles/HandleRoot.hpp new file mode 100644 index 00000000000..08a22b3e400 --- /dev/null +++ b/ndb/src/client/odbc/handles/HandleRoot.hpp @@ -0,0 +1,103 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_HANDLES_HandleRoot_hpp +#define ODBC_HANDLES_HandleRoot_hpp + +#include +#include +#include +#include "HandleBase.hpp" + +class HandleEnv; +class HandleDbc; +class HandleStmt; +class HandleDesc; +class PoolNdb; + +/** + * @class HandleRoot + * @brief The singleton root handle. + * + * This class is the level above HandleEnv. It has a single + * instance. The instance is the root node of dynamically + * allocated handles. The instance is also used to call methods + * not tied to any handle. + */ +class HandleRoot : public HandleBase { +protected: + HandleRoot(); + ~HandleRoot(); +public: + static HandleRoot* instance(); + HandleRoot* getRoot(); + HandleBase* getParent(); + PoolNdb* getPoolNdb(); + OdbcHandle odbcHandle(); + void lockHandle(); + void unlockHandle(); + // check and find handle types and handles + SQLSMALLINT findParentType(SQLSMALLINT childType); + HandleBase* findBase(SQLSMALLINT handleType, void* pHandle); + HandleEnv* findEnv(void* pHandle); + HandleDbc* findDbc(void* pHandle); + HandleStmt* findStmt(void* pHandle); + HandleDesc* findDesc(void* pHandle); + // add or remove handle from validation list + void record(SQLSMALLINT handleType, HandleBase* pHandle, bool add); + // allocate and free handles + void sqlAllocEnv(Ctx& ctx, HandleEnv** ppEnv); + void sqlAllocHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase** ppChild); + void sqlFreeEnv(Ctx& ctx, HandleEnv* pEnv); + void sqlFreeHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase* pChild); + // process-level attributes + void sqlSetRootAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER stringLength); + void sqlGetRootAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLength); +private: + static HandleRoot* m_instance; // the instance + std::list m_listEnv; + PoolNdb* m_poolNdb; + typedef std::map ValidList; + ValidList m_validList; + static AttrSpec m_attrSpec[]; + AttrArea m_attrArea; +}; + +inline HandleRoot* +HandleRoot::getRoot() +{ + return this; +} + +inline HandleBase* +HandleRoot::getParent() +{ + return 0; +} + +inline PoolNdb* +HandleRoot::getPoolNdb() +{ + return m_poolNdb; +} + +inline OdbcHandle +HandleRoot::odbcHandle() +{ + return Odbc_handle_root; +} + +#endif diff --git a/ndb/src/client/odbc/handles/HandleStmt.cpp b/ndb/src/client/odbc/handles/HandleStmt.cpp new file mode 100644 index 00000000000..d33d33dbd5b --- /dev/null +++ b/ndb/src/client/odbc/handles/HandleStmt.cpp @@ -0,0 +1,823 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include "HandleRoot.hpp" +#include "HandleDbc.hpp" +#include "HandleStmt.hpp" +#include "HandleDesc.hpp" + +HandleStmt::HandleStmt(HandleDbc* pDbc) : + StmtArea(*pDbc), + m_dbc(pDbc), + m_attrArea(m_attrSpec) +{ + m_attrArea.setHandle(this); + for (unsigned i = 0; i <= 1; i++) { + for (unsigned u = 0; u <= 4; u++) { + m_handleDesc[i][u] = 0; + } + } +} + +HandleStmt::~HandleStmt() +{ +} + +void +HandleStmt::ctor(Ctx& ctx) +{ + for (unsigned u = 1; u <= 4; u++) { + HandleDesc** ppDesc = &m_handleDesc[0][u]; + m_dbc->sqlAllocDesc(ctx, ppDesc); + if (! ctx.ok()) + return; + m_descArea[u] = &(*ppDesc)->descArea(); + m_descArea[u]->setAlloc(Desc_alloc_auto); + m_descArea[u]->setUsage((DescUsage)u); + } +} + +void +HandleStmt::dtor(Ctx& ctx) +{ + free(ctx); + for (unsigned u = 1; u <= 4; u++) { + HandleDesc** ppDesc = &m_handleDesc[0][u]; + if (*ppDesc != 0) + m_dbc->sqlFreeDesc(ctx, *ppDesc); + *ppDesc = 0; + } +} + +// descriptor handles + +HandleDesc* +HandleStmt::getHandleDesc(Ctx& ctx, DescUsage u) const +{ + ctx_assert(1 <= u && u <= 4); + if (m_handleDesc[1][u] != 0) + return m_handleDesc[1][u]; + return m_handleDesc[0][u]; +} + +void +HandleStmt::setHandleDesc(Ctx& ctx, DescUsage u, SQLPOINTER handle) +{ + ctx_assert(1 <= u && u <= 4); + if (handle == SQL_NULL_HDESC) { + m_handleDesc[1][u] = 0; // revert to implicit + m_descArea[u] = &m_handleDesc[0][u]->descArea(); + return; + } + HandleDesc* pDesc = getRoot()->findDesc(handle); + if (pDesc == 0) { + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "cannot set %s handle to invalid descriptor handle %x", DescArea::nameUsage(u), (unsigned)handle); + return; + } + if (pDesc == m_handleDesc[0][u]) { + m_handleDesc[1][u] = 0; // revert to implicit + m_descArea[u] = &m_handleDesc[0][u]->descArea(); + return; + } + // XXX should check implicit handles on all statements + for (unsigned v = 1; v <= 4; v++) { + if (pDesc == m_handleDesc[0][v]) { + ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "cannot set %s handle to implicitly allocated %s handle", DescArea::nameUsage(u), DescArea::nameUsage((DescUsage)v)); + return; + } + } + m_handleDesc[1][u] = pDesc; + m_descArea[u] = &m_handleDesc[1][u]->descArea(); +} + +// allocate and free handles (no valid case) + +void +HandleStmt::sqlAllocHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase** ppChild) +{ + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "inappropriate handle type"); +} + +void +HandleStmt::sqlFreeHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase* ppChild) +{ + ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "inappropriate handle type"); +} + +// attributes and info + +static bool +ignore_attr(Ctx& ctx, SQLINTEGER attribute) +{ + switch (attribute) { + case 1211: + case 1227: + case 1228: + ctx_log2(("ignore unknown ADO.NET stmt attribute %d", (int)attribute)); + return true; + } + return false; +} + +void +HandleStmt::sqlSetStmtAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER stringLength) +{ + if (ignore_attr(ctx, attribute)) + return; + baseSetHandleAttr(ctx, m_attrArea, attribute, value, stringLength); +} + +void +HandleStmt::sqlGetStmtAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLength) +{ + if (ignore_attr(ctx, attribute)) + return; + baseGetHandleAttr(ctx, m_attrArea, attribute, value, bufferLength, stringLength); +} + +void +HandleStmt::sqlSetStmtOption(Ctx& ctx, SQLUSMALLINT option, SQLUINTEGER value) +{ + if (ignore_attr(ctx, option)) + return; + baseSetHandleOption(ctx, m_attrArea, option, value); +} + +void +HandleStmt::sqlGetStmtOption(Ctx& ctx, SQLUSMALLINT option, SQLPOINTER value) +{ + if (ignore_attr(ctx, option)) + return; + baseGetHandleOption(ctx, m_attrArea, option, value); +} + +void +HandleStmt::sqlGetTypeInfo(Ctx& ctx, SQLSMALLINT dataType) +{ + BaseString text; + // odbc$typeinfo is a (possible unordered) view matching SQLGetTypeInfo result set + text.append("SELECT * FROM odbc$typeinfo"); + if (dataType != SQL_ALL_TYPES) { + switch (dataType) { + case SQL_CHAR: + case SQL_VARCHAR: + case SQL_BINARY: + case SQL_VARBINARY: + case SQL_SMALLINT: + case SQL_INTEGER: + case SQL_BIGINT: + case SQL_REAL: + case SQL_DOUBLE: + break; + default: + // XXX unsupported vs illegal + ctx_log1(("sqlGetTypeInfo: unknown data type %d", (int)dataType)); + break; + } + text.appfmt(" WHERE data_type = %d", (int)dataType); + } + // sort signed before unsigned + text.append(" ORDER BY data_type, unsigned_attribute, type_name"); + sqlExecDirect(ctx, (SQLCHAR*)text.c_str(), text.length()); +} + +void +HandleStmt::sqlTables(Ctx& ctx, SQLCHAR* catalogName, SQLSMALLINT nameLength1, SQLCHAR* schemaName, SQLSMALLINT nameLength2, SQLCHAR* tableName, SQLSMALLINT nameLength3, SQLCHAR* tableType, SQLSMALLINT nameLength4) +{ + BaseString text; + // odbc$tables is a (possibly unordered) view matching SQLTables result set + text.append("SELECT * FROM odbc$tables"); + SQLUINTEGER metadata_id = SQL_FALSE; + sqlGetStmtAttr(ctx, SQL_ATTR_METADATA_ID, (SQLPOINTER)&metadata_id, SQL_IS_POINTER, 0); + if (! ctx.ok()) + return; + unsigned count = 0; + if (catalogName != 0) { + OdbcData data; + data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)catalogName, nameLength1); + if (! ctx.ok()) + return; + text.append(++count == 1 ? " WHERE" : " AND"); + if (getOdbcVersion(ctx) == 2) + text.appfmt(" table_cat = '%s'", data.sqlchar()); + else if (metadata_id == SQL_TRUE) + text.appfmt(" table_cat = '%s'", data.sqlchar()); // XXX UPPER + else + text.appfmt(" table_cat LIKE '%s'", data.sqlchar()); + } + if (schemaName != 0) { + OdbcData data; + data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)schemaName, nameLength2); + if (! ctx.ok()) + return; + text.append(++count == 1 ? " WHERE" : " AND"); + if (metadata_id == SQL_TRUE) + text.appfmt(" table_schem = '%s'", data.sqlchar()); // XXX UPPER + else + text.appfmt(" table_schem LIKE '%s'", data.sqlchar()); + } + if (tableName != 0) { + OdbcData data; + data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)tableName, nameLength3); + if (! ctx.ok()) + return; + text.append(++count == 1 ? " WHERE" : " AND"); + if (metadata_id == SQL_TRUE) + text.appfmt(" table_name = '%s'", data.sqlchar()); // XXX UPPER + else + text.appfmt(" table_name LIKE '%s'", data.sqlchar()); + } + if (tableType != 0) { + OdbcData data; + data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)tableType, nameLength4); + if (! ctx.ok()) + return; + text.append(++count == 1 ? " WHERE" : " AND"); + text.appfmt(" table_type IN (%s)", data.sqlchar()); // XXX UPPER, quotes + } + text.append(" ORDER BY table_type, table_cat, table_schem, table_name"); + sqlExecDirect(ctx, (SQLCHAR*)text.c_str(), text.length()); +} + +void +HandleStmt::sqlColumns(Ctx& ctx, SQLCHAR* catalogName, SQLSMALLINT nameLength1, SQLCHAR* schemaName, SQLSMALLINT nameLength2, SQLCHAR* tableName, SQLSMALLINT nameLength3, SQLCHAR* columnName, SQLSMALLINT nameLength4) +{ + BaseString text; + // odbc$columns is a (possibly unordered) view matching SQLColumns result set + text.append("SELECT * FROM odbc$columns"); + SQLUINTEGER metadata_id = SQL_FALSE; + sqlGetStmtAttr(ctx, SQL_ATTR_METADATA_ID, (SQLPOINTER)&metadata_id, SQL_IS_POINTER, 0); + if (! ctx.ok()) + return; + unsigned count = 0; + if (catalogName != 0) { + OdbcData data; + data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)catalogName, nameLength1); + if (! ctx.ok()) + return; + text.append(++count == 1 ? " WHERE" : " AND"); + if (getOdbcVersion(ctx) == 2) + text.appfmt(" table_cat = '%s'", data.sqlchar()); + else if (metadata_id == SQL_TRUE) + text.appfmt(" table_cat = '%s'", data.sqlchar()); // XXX UPPER + else + text.appfmt(" table_cat LIKE '%s'", data.sqlchar()); + } + if (schemaName != 0) { + OdbcData data; + data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)schemaName, nameLength2); + if (! ctx.ok()) + return; + text.append(++count == 1 ? " WHERE" : " AND"); + if (metadata_id == SQL_TRUE) + text.appfmt(" table_schem = '%s'", data.sqlchar()); // XXX UPPER + else + text.appfmt(" table_schem LIKE '%s'", data.sqlchar()); + } + if (tableName != 0) { + OdbcData data; + data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)tableName, nameLength3); + if (! ctx.ok()) + return; + text.append(++count == 1 ? " WHERE" : " AND"); + if (metadata_id == SQL_TRUE) + text.appfmt(" table_name = '%s'", data.sqlchar()); // XXX UPPER + else + text.appfmt(" table_name LIKE '%s'", data.sqlchar()); + } + if (columnName != 0) { + OdbcData data; + data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)columnName, nameLength4); + if (! ctx.ok()) + return; + text.append(++count == 1 ? " WHERE" : " AND"); + if (metadata_id == SQL_TRUE) + text.appfmt(" column_name = '%s'", data.sqlchar()); // XXX UPPER + else + text.appfmt(" column_name LIKE '%s'", data.sqlchar()); + } + text.append(" ORDER BY table_cat, table_schem, table_name, ordinal_position"); + sqlExecDirect(ctx, (SQLCHAR*)text.c_str(), text.length()); +} + +void +HandleStmt::sqlPrimaryKeys(Ctx& ctx, SQLCHAR* szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR* szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR* szTableName, SQLSMALLINT cbTableName) +{ + BaseString text; + // odbc$primarykeys is a (possible unordered) view matching SQLPrimaryKeys result set + text.append("SELECT * FROM odbc$primarykeys"); + SQLUINTEGER metadata_id = SQL_FALSE; + sqlGetStmtAttr(ctx, SQL_ATTR_METADATA_ID, (SQLPOINTER)&metadata_id, SQL_IS_POINTER, 0); + if (! ctx.ok()) + return; + unsigned count = 0; + if (szCatalogName != 0) { + OdbcData data; + data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)szCatalogName, cbCatalogName); + if (! ctx.ok()) + return; + text.append(++count == 1 ? " WHERE" : " AND"); + if (getOdbcVersion(ctx) == 2) + text.appfmt(" table_cat = '%s'", data.sqlchar()); + else if (metadata_id == SQL_TRUE) + text.appfmt(" table_cat = '%s'", data.sqlchar()); // XXX UPPER + else + text.appfmt(" table_cat = '%s'", data.sqlchar()); // no pattern + } + if (szSchemaName != 0) { + OdbcData data; + data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)szSchemaName, cbSchemaName); + if (! ctx.ok()) + return; + text.append(++count == 1 ? " WHERE" : " AND"); + if (metadata_id == SQL_TRUE) + text.appfmt(" table_schem = '%s'", data.sqlchar()); // XXX UPPER + else + text.appfmt(" table_schem = '%s'", data.sqlchar()); // no pattern + } + if (szTableName != 0) { + OdbcData data; + data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)szTableName, cbTableName); + if (! ctx.ok()) + return; + text.append(++count == 1 ? " WHERE" : " AND"); + if (metadata_id == SQL_TRUE) + text.appfmt(" table_name = '%s'", data.sqlchar()); // XXX UPPER + else + text.appfmt(" table_name = '%s'", data.sqlchar()); // no pattern + } else { // no null + ctx.pushStatus(Sqlstate::_HY009, Error::Gen, "null table name"); + return; + } + text.append(" ORDER BY table_cat, table_schem, table_name, key_seq"); + sqlExecDirect(ctx, (SQLCHAR*)text.c_str(), text.length()); +} + +int +HandleStmt::getOdbcVersion(Ctx& ctx) +{ + return m_dbc->getOdbcVersion(ctx); +} + +// prepare and execute + +void +HandleStmt::sqlPrepare(Ctx& ctx, SQLCHAR* statementText, SQLINTEGER textLength) +{ + if (m_state == Open) { + ctx.pushStatus(Sqlstate::_24000, Error::Gen, "cursor is open"); + return; + } + free(ctx); + const char* text = reinterpret_cast(statementText); + if (textLength == SQL_NTS) { + m_sqlText.assign(text); + } else if (textLength >= 0) { + m_sqlText.assign(text, textLength); + } else { + ctx.pushStatus(Sqlstate::_HY090, Error::Gen, "missing SQL text"); + return; + } + if (! useSchemaCon(ctx, true)) + return; + CodeGen codegen(*this); + codegen.prepare(ctx); + useSchemaCon(ctx, false); + if (! ctx.ok()) { + free(ctx); + return; + } + ctx_log2(("prepared %s statement", m_stmtInfo.getDesc())); + m_state = Prepared; +} + +void +HandleStmt::sqlExecute(Ctx& ctx) +{ + if (m_state == Open) { + ctx.pushStatus(Sqlstate::_24000, Error::Gen, "cursor is open"); + return; + } + StmtType stmtType = m_stmtInfo.getType(); + switch (stmtType) { + case Stmt_type_DDL: + if (! useSchemaCon(ctx, true)) + return; + break; + case Stmt_type_query: + case Stmt_type_DML: + if (! useConnection(ctx, true)) + return; + break; + default: + ctx_assert(false); + break; + } + CodeGen codegen(*this); + codegen.execute(ctx); + // valid only after execute says M$ XXX create this diag only on demand + setFunction(ctx); + if (ctx.getCode() == SQL_NEED_DATA) { + m_state = NeedData; + return; + } + ctx_log2(("execute: fetched %u tuples from NDB", (unsigned)m_tuplesFetched)); + switch (stmtType) { + case Stmt_type_DDL: + codegen.close(ctx); + useSchemaCon(ctx, false); + m_state = Prepared; + break; + case Stmt_type_query: + if (! ctx.ok()) { + codegen.close(ctx); + useConnection(ctx, false); + m_state = Prepared; + } else { + m_state = Open; + } + break; + case Stmt_type_DML: + codegen.close(ctx); + if (m_dbc->autocommit()) { + // even if error + m_dbc->sqlEndTran(ctx, SQL_COMMIT); + } else { + m_dbc->uncommitted(true); // uncommitted changes possible + } + useConnection(ctx, false); + m_state = Prepared; + break; + default: + ctx_assert(false); + break; + } +} + +void +HandleStmt::sqlExecDirect(Ctx& ctx, SQLCHAR* statementText, SQLINTEGER textLength) +{ + sqlPrepare(ctx, statementText, textLength); + if (! ctx.ok()) + return; + sqlExecute(ctx); +} + +void +HandleStmt::sqlFetch(Ctx& ctx) +{ + if (m_state != Open) { + ctx.pushStatus(Sqlstate::_24000, Error::Gen, "cursor is not open"); + return; + } + StmtType stmtType = m_stmtInfo.getType(); + switch (stmtType) { + case Stmt_type_query: { + CodeGen codegen(*this); + codegen.fetch(ctx); + if (! ctx.ok()) { + codegen.close(ctx); + useConnection(ctx, false); + } + break; + } + default: + ctx_assert(false); + break; + } +} + +void +HandleStmt::sqlRowCount(Ctx& ctx, SQLINTEGER* rowCount) +{ + *rowCount = m_rowCount; +} + +void +HandleStmt::sqlMoreResults(Ctx& ctx) +{ + if (m_state == Open) { + sqlCloseCursor(ctx); + if (! ctx.ok()) + return; + } + ctx.setCode(SQL_NO_DATA); +} + +void +HandleStmt::sqlCancel(Ctx& ctx) +{ + if (m_state == NeedData) { + CodeGen codegen(*this); + codegen.close(ctx); + m_state = Prepared; + } +} + +void +HandleStmt::sqlCloseCursor(Ctx& ctx) +{ + if (m_state != Open) { + ctx.pushStatus(Sqlstate::_24000, Error::Gen, "cursor is not open"); + return; + } + ctx_log2(("execute: fetched %u tuples from NDB", (unsigned)m_tuplesFetched)); + StmtType stmtType = m_stmtInfo.getType(); + switch (stmtType) { + case Stmt_type_query: { + CodeGen codegen(*this); + codegen.close(ctx); + useConnection(ctx, false); + m_state = Prepared; + m_rowCount = 0; + m_tuplesFetched = 0; + break; + } + default: + ctx_assert(false); + break; + } +} + +void +HandleStmt::sqlGetCursorName(Ctx& ctx, SQLCHAR* cursorName, SQLSMALLINT bufferLength, SQLSMALLINT* nameLength) +{ + OdbcData name("SQL_CUR_DUMMY"); + name.copyout(ctx, cursorName, bufferLength, 0, nameLength); +} + +void +HandleStmt::sqlSetCursorName(Ctx& ctx, SQLCHAR* cursorName, SQLSMALLINT nameLength) +{ +} + +// special data access + +void +HandleStmt::sqlGetData(Ctx& ctx, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, SQLPOINTER targetValue, SQLINTEGER bufferLength, SQLINTEGER* strlen_or_Ind) +{ + if (m_state != Open) { + ctx.pushStatus(Sqlstate::_24000, Error::Gen, "cursor is not open"); + return; + } + if (bufferLength < 0) { + ctx.pushStatus(Sqlstate::_HY090, Error::Gen, "invalid buffer length %d", (int)bufferLength); + return; + } + CodeGen codegen(*this); + codegen.sqlGetData(ctx, columnNumber, targetType, targetValue, bufferLength, strlen_or_Ind); +} + +void +HandleStmt::sqlParamData(Ctx& ctx, SQLPOINTER* value) +{ + if (m_state != NeedData) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "not expecting data-at-exec"); + return; + } + CodeGen codegen(*this); + codegen.sqlParamData(ctx, value); + if (! ctx.ok()) + return; + sqlExecute(ctx); +} + +void +HandleStmt::sqlPutData(Ctx& ctx, SQLPOINTER data, SQLINTEGER strlen_or_Ind) +{ + if (m_state != NeedData) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "not expecting data-at-exec"); + return; + } + CodeGen codegen(*this); + codegen.sqlPutData(ctx, data, strlen_or_Ind); +} + +// describe statement + +void +HandleStmt::sqlNumParams(Ctx& ctx, SQLSMALLINT* parameterCountPtr) +{ + if (m_state == Free) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "statement is not prepared"); + return; + } + HandleDesc* ipd = getHandleDesc(ctx, Desc_usage_IPD); + ipd->sqlGetDescField(ctx, 0, SQL_DESC_COUNT, static_cast(parameterCountPtr), -1, 0); +} + +void +HandleStmt::sqlDescribeParam(Ctx& ctx, SQLUSMALLINT ipar, SQLSMALLINT* pfSqlType, SQLUINTEGER* pcbParamDef, SQLSMALLINT* pibScale, SQLSMALLINT* pfNullable) +{ + if (m_state == Free) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "statement is not prepared"); + return; + } + HandleDesc* ipd = getHandleDesc(ctx, Desc_usage_IPD); + ipd->sqlGetDescField(ctx, ipar, SQL_DESC_CONCISE_TYPE, static_cast(pfSqlType), -1, 0); + { // XXX fix it + OdbcData data((SQLUINTEGER)0); + data.copyout(ctx, (SQLPOINTER)pcbParamDef, -1, 0); + } + { // XXX fix it + OdbcData data((SQLSMALLINT)0); + data.copyout(ctx, (SQLPOINTER)pibScale, -1, 0); + } + ipd->sqlGetDescField(ctx, ipar, SQL_DESC_NULLABLE, static_cast(pfNullable), -1, 0); +} + +void +HandleStmt::sqlNumResultCols(Ctx& ctx, SQLSMALLINT* columnCount) +{ + if (m_state == Free) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "statement is not prepared"); + return; + } + HandleDesc* const ird = getHandleDesc(ctx, Desc_usage_IRD); + ird->sqlGetDescField(ctx, 0, SQL_DESC_COUNT, static_cast(columnCount), -1, 0); + setFunction(ctx); // unixODBC workaround +} + +void +HandleStmt::sqlDescribeCol(Ctx& ctx, SQLUSMALLINT columnNumber, SQLCHAR* columnName, SQLSMALLINT bufferLength, SQLSMALLINT* nameLength, SQLSMALLINT* dataType, SQLUINTEGER* columnSize, SQLSMALLINT* decimalDigits, SQLSMALLINT* nullable) +{ + if (m_state == Free) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "statement is not prepared"); + return; + } + HandleDesc* const ird = getHandleDesc(ctx, Desc_usage_IRD); + ird->sqlGetDescField(ctx, columnNumber, SQL_DESC_NAME, static_cast(columnName), bufferLength, 0, nameLength); + ird->sqlGetDescField(ctx, columnNumber, SQL_DESC_CONCISE_TYPE, static_cast(dataType), -1, 0); + if (! ctx.ok()) + return; + if (columnSize != 0) { + switch (*dataType) { + case SQL_CHAR: + case SQL_VARCHAR: + case SQL_BINARY: + case SQL_VARBINARY: + ird->sqlGetDescField(ctx, columnNumber, SQL_DESC_LENGTH, static_cast(columnSize), -1, 0); + break; + case SQL_SMALLINT: + *columnSize = 5; + break; + case SQL_INTEGER: + *columnSize = 10; + break; + case SQL_BIGINT: + *columnSize = 20; // XXX 19 for signed + break; + case SQL_REAL: + *columnSize = 7; + break; + case SQL_DOUBLE: + *columnSize = 15; + break; + case SQL_TYPE_TIMESTAMP: + *columnSize = 30; + break; + default: + *columnSize = 0; + break; + } + } + if (decimalDigits != 0) { + switch (*dataType) { + case SQL_SMALLINT: + case SQL_INTEGER: + case SQL_BIGINT: + *decimalDigits = 0; + break; + case SQL_TYPE_TIMESTAMP: + *decimalDigits = 10; + break; + default: + *decimalDigits = 0; + break; + } + } + ird->sqlGetDescField(ctx, columnNumber, SQL_DESC_NULLABLE, static_cast(nullable), -1, 0); +} + +void +HandleStmt::sqlColAttribute(Ctx& ctx, SQLUSMALLINT columnNumber, SQLUSMALLINT fieldIdentifier, SQLPOINTER characterAttribute, SQLSMALLINT bufferLength, SQLSMALLINT* stringLength, SQLPOINTER numericAttribute) +{ + if (m_state == Free) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "statement is not prepared"); + return; + } + HandleDesc* const ird = getHandleDesc(ctx, Desc_usage_IRD); + ird->sqlColAttribute(ctx, columnNumber, fieldIdentifier, characterAttribute, bufferLength, stringLength, numericAttribute); +} + +void +HandleStmt::sqlColAttributes(Ctx& ctx, SQLUSMALLINT icol, SQLUSMALLINT fdescType, SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT* pcbDesc, SQLINTEGER* pfDesc) +{ + if (m_state == Free) { + ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "statement is nor prepared"); + return; + } + HandleDesc* const ird = getHandleDesc(ctx, Desc_usage_IRD); + ird->sqlColAttributes(ctx, icol, fdescType, rgbDesc, cbDescMax, pcbDesc, pfDesc); +} + +// descriptor manipulation + +void +HandleStmt::sqlBindCol(Ctx& ctx, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, SQLPOINTER targetValue, SQLINTEGER bufferLength, SQLINTEGER* strlen_or_Ind) +{ + HandleDesc* const ard = getHandleDesc(ctx, Desc_usage_ARD); + DescArea& desc = ard->descArea(); + if (desc.getCount() < columnNumber) { + desc.setCount(ctx, columnNumber); + } + DescRec& rec = desc.getRecord(columnNumber); + rec.setField(ctx, SQL_DESC_TYPE, targetType); + rec.setField(ctx, SQL_DESC_CONCISE_TYPE, targetType); + rec.setField(ctx, SQL_DESC_DATA_PTR, targetValue); + rec.setField(ctx, SQL_DESC_OCTET_LENGTH, bufferLength); + rec.setField(ctx, SQL_DESC_OCTET_LENGTH_PTR, strlen_or_Ind); + rec.setField(ctx, SQL_DESC_INDICATOR_PTR, strlen_or_Ind); +} + +void +HandleStmt::sqlBindParameter(Ctx& ctx, SQLUSMALLINT ipar, SQLSMALLINT fParamType, SQLSMALLINT fCType, SQLSMALLINT fSqlType, SQLUINTEGER cbColDef, SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLINTEGER cbValueMax, SQLINTEGER* pcbValue) +{ + HandleDesc* const ipd = getHandleDesc(ctx, Desc_usage_IPD); + HandleDesc* const apd = getHandleDesc(ctx, Desc_usage_APD); + DescArea& descIPD = ipd->descArea(); + DescArea& descAPD = apd->descArea(); + if (ipar < 1) { + ctx.pushStatus(Sqlstate::_07009, Error::Gen, "invalid parameter index %u", (unsigned)ipar); + return; + } + if (descIPD.getCount() < ipar) { + descIPD.setCount(ctx, ipar); + } + if (descAPD.getCount() < ipar) { + descAPD.setCount(ctx, ipar); + } + DescRec& recIPD = descIPD.getRecord(ipar); + DescRec& recAPD = descAPD.getRecord(ipar); + recIPD.setField(ctx, SQL_DESC_PARAMETER_TYPE, fParamType); + recAPD.setField(ctx, SQL_DESC_TYPE, fCType); + recAPD.setField(ctx, SQL_DESC_CONCISE_TYPE, fCType); + recIPD.setField(ctx, SQL_DESC_TYPE, fSqlType); + recIPD.setField(ctx, SQL_DESC_CONCISE_TYPE, fSqlType); + switch (fSqlType) { + case SQL_CHAR: // XXX not complete + case SQL_VARCHAR: + case SQL_BINARY: + case SQL_VARBINARY: + recIPD.setField(ctx, SQL_DESC_LENGTH, cbColDef); + break; + case SQL_DECIMAL: + case SQL_NUMERIC: + case SQL_FLOAT: + case SQL_REAL: + case SQL_DOUBLE: + recIPD.setField(ctx, SQL_DESC_PRECISION, cbColDef); + break; + } + switch (fSqlType) { + case SQL_TYPE_TIME: // XXX not complete + case SQL_TYPE_TIMESTAMP: + recIPD.setField(ctx, SQL_DESC_PRECISION, ibScale); + break; + case SQL_NUMERIC: + case SQL_DECIMAL: + recIPD.setField(ctx, SQL_DESC_SCALE, ibScale); + break; + } + recAPD.setField(ctx, SQL_DESC_DATA_PTR, rgbValue); + recAPD.setField(ctx, SQL_DESC_OCTET_LENGTH, cbValueMax); + recAPD.setField(ctx, SQL_DESC_OCTET_LENGTH_PTR, pcbValue); + recAPD.setField(ctx, SQL_DESC_INDICATOR_PTR, pcbValue); +} + +void +HandleStmt::sqlBindParam(Ctx& ctx, SQLUSMALLINT parameterNumber, SQLSMALLINT valueType, SQLSMALLINT parameterType, SQLUINTEGER lengthPrecision, SQLSMALLINT parameterScale, SQLPOINTER parameterValue, SQLINTEGER* strLen_or_Ind) +{ + sqlBindParameter(ctx, parameterNumber, SQL_PARAM_INPUT_OUTPUT, valueType, parameterType, lengthPrecision, parameterScale, parameterValue, SQL_SETPARAM_VALUE_MAX, strLen_or_Ind); +} + +void +HandleStmt::sqlSetParam(Ctx& ctx, SQLUSMALLINT parameterNumber, SQLSMALLINT valueType, SQLSMALLINT parameterType, SQLUINTEGER lengthPrecision, SQLSMALLINT parameterScale, SQLPOINTER parameterValue, SQLINTEGER* strLen_or_Ind) +{ + sqlBindParameter(ctx, parameterNumber, SQL_PARAM_INPUT_OUTPUT, valueType, parameterType, lengthPrecision, parameterScale, parameterValue, SQL_SETPARAM_VALUE_MAX, strLen_or_Ind); +} diff --git a/ndb/src/client/odbc/handles/HandleStmt.hpp b/ndb/src/client/odbc/handles/HandleStmt.hpp new file mode 100644 index 00000000000..0bee138bfc6 --- /dev/null +++ b/ndb/src/client/odbc/handles/HandleStmt.hpp @@ -0,0 +1,117 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_HANDLES_HandleStmt_hpp +#define ODBC_HANDLES_HandleStmt_hpp + +#include +#include +#include +#include "HandleBase.hpp" + +class HandleDbc; +class HandleDesc; + +/** + * @class HandleStmt + * @brief Statement handle (SQLHSTMT). + */ +class HandleStmt : public HandleBase, public StmtArea { +public: + HandleStmt(HandleDbc* pDbc); + ~HandleStmt(); + void ctor(Ctx& ctx); + void dtor(Ctx& ctx); + HandleDbc* getDbc(); + HandleBase* getParent(); + HandleRoot* getRoot(); + OdbcHandle odbcHandle(); + // descriptor handles + HandleDesc* getHandleDesc(Ctx& ctx, DescUsage u) const; + void setHandleDesc(Ctx& ctx, DescUsage u, SQLPOINTER handle); + // allocate and free handles (no valid case) + void sqlAllocHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase** ppChild); + void sqlFreeHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase* pChild); + // attributes and info + void sqlSetStmtAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER stringLength); + void sqlGetStmtAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLength); + void sqlSetStmtOption(Ctx& ctx, SQLUSMALLINT option, SQLUINTEGER value); // odbc2.0 + void sqlGetStmtOption(Ctx& ctx, SQLUSMALLINT option, SQLPOINTER value); // odbc2.0 + void sqlGetTypeInfo(Ctx& ctx, SQLSMALLINT dataType); + void sqlTables(Ctx& ctx, SQLCHAR* catalogName, SQLSMALLINT nameLength1, SQLCHAR* schemaName, SQLSMALLINT nameLength2, SQLCHAR* tableName, SQLSMALLINT nameLength3, SQLCHAR* tableType, SQLSMALLINT nameLength4); + void sqlColumns(Ctx& ctx, SQLCHAR* catalogName, SQLSMALLINT nameLength1, SQLCHAR* schemaName, SQLSMALLINT nameLength2, SQLCHAR* tableName, SQLSMALLINT nameLength3, SQLCHAR* columnName, SQLSMALLINT nameLength4); + void sqlPrimaryKeys(Ctx& ctx, SQLCHAR* szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR* szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR* szTableName, SQLSMALLINT cbTableName); + int getOdbcVersion(Ctx& ctx); + // prepare and execute + void sqlPrepare(Ctx& ctx, SQLCHAR* statementText, SQLINTEGER textLength); + void sqlExecute(Ctx& ctx); + void sqlExecDirect(Ctx& ctx, SQLCHAR* statementText, SQLINTEGER textLength); + void sqlFetch(Ctx& ctx); + void sqlRowCount(Ctx& ctx, SQLINTEGER* rowCount); + void sqlMoreResults(Ctx& ctx); + void sqlCancel(Ctx& ctx); + void sqlCloseCursor(Ctx& ctx); + void sqlGetCursorName(Ctx& ctx, SQLCHAR* cursorName, SQLSMALLINT bufferLength, SQLSMALLINT* nameLength); + void sqlSetCursorName(Ctx& ctx, SQLCHAR* cursorName, SQLSMALLINT nameLength); + // special data access + void sqlGetData(Ctx& ctx, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, SQLPOINTER targetValue, SQLINTEGER bufferLength, SQLINTEGER* strlen_or_Ind); + void sqlParamData(Ctx& ctx, SQLPOINTER* value); + void sqlPutData(Ctx& ctx, SQLPOINTER data, SQLINTEGER strlen_or_Ind); + // describe statement + void sqlNumParams(Ctx& ctx, SQLSMALLINT* ParameterCountPtr); + void sqlDescribeParam(Ctx& ctx, SQLUSMALLINT ipar, SQLSMALLINT* pfSqlType, SQLUINTEGER* pcbParamDef, SQLSMALLINT* pibScale, SQLSMALLINT* pfNullable); + void sqlNumResultCols(Ctx& ctx, SQLSMALLINT* columnCount); + void sqlDescribeCol(Ctx& ctx, SQLUSMALLINT columnNumber, SQLCHAR* columnName, SQLSMALLINT bufferLength, SQLSMALLINT* nameLength, SQLSMALLINT* dataType, SQLUINTEGER* columnSize, SQLSMALLINT* decimalDigits, SQLSMALLINT* nullable); + void sqlColAttribute(Ctx& ctx, SQLUSMALLINT columnNumber, SQLUSMALLINT fieldIdentifier, SQLPOINTER characterAttribute, SQLSMALLINT bufferLength, SQLSMALLINT* stringLength, SQLPOINTER numericAttribute); + void sqlColAttributes(Ctx& ctx, SQLUSMALLINT icol, SQLUSMALLINT fdescType, SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT* pcbDesc, SQLINTEGER* pfDesc); // odbc2.0 + // descriptor manipulation + void sqlBindCol(Ctx& ctx, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, SQLPOINTER targetValue, SQLINTEGER bufferLength, SQLINTEGER* strlen_or_Ind); + void sqlBindParameter(Ctx& ctx, SQLUSMALLINT ipar, SQLSMALLINT fParamType, SQLSMALLINT fCType, SQLSMALLINT fSqlType, SQLUINTEGER cbColDef, SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLINTEGER cbValueMax, SQLINTEGER* pcbValue); + void sqlBindParam(Ctx& ctx, SQLUSMALLINT parameterNumber, SQLSMALLINT valueType, SQLSMALLINT parameterType, SQLUINTEGER lengthPrecision, SQLSMALLINT parameterScale, SQLPOINTER parameterValue, SQLINTEGER* strLen_or_Ind); + void sqlSetParam(Ctx& ctx, SQLUSMALLINT parameterNumber, SQLSMALLINT valueType, SQLSMALLINT parameterType, SQLUINTEGER lengthPrecision, SQLSMALLINT parameterScale, SQLPOINTER parameterValue, SQLINTEGER* strLen_or_Ind); +private: + HandleDbc* const m_dbc; + static AttrSpec m_attrSpec[]; + AttrArea m_attrArea; + // descriptor handles (0-automatic 1-application) + HandleDesc* m_handleDesc[2][1+4]; +}; + +inline HandleDbc* +HandleStmt::getDbc() +{ + return m_dbc; +} + +inline HandleBase* +HandleStmt::getParent() +{ + return (HandleBase*)getDbc(); +} + +inline HandleRoot* +HandleStmt::getRoot() +{ + return getParent()->getRoot(); +} + +inline OdbcHandle +HandleStmt::odbcHandle() +{ + return Odbc_handle_stmt; +} + +#endif diff --git a/ndb/src/client/odbc/handles/InfoTab.cpp b/ndb/src/client/odbc/handles/InfoTab.cpp new file mode 100644 index 00000000000..1a93c4da264 --- /dev/null +++ b/ndb/src/client/odbc/handles/InfoTab.cpp @@ -0,0 +1,878 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "HandleDbc.hpp" + +HandleDbc::InfoTab +HandleDbc::m_infoTab[] = { + { SQL_ACCESSIBLE_PROCEDURES, + InfoTab::YesNo, + 0L, + "N" + }, + { SQL_ACCESSIBLE_TABLES, + InfoTab::YesNo, + 0L, + "Y" + }, + { SQL_ACTIVE_ENVIRONMENTS, + InfoTab::Short, + 0L, + 0 + }, + { SQL_AGGREGATE_FUNCTIONS, + InfoTab::Bitmask, + SQL_AF_AVG | SQL_AF_COUNT | SQL_AF_MAX | SQL_AF_MIN | SQL_AF_SUM, + 0 + }, + { SQL_ALTER_DOMAIN, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_ALTER_TABLE, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_ASYNC_MODE, + InfoTab::Long, + SQL_AM_NONE, + 0 + }, + { SQL_BATCH_ROW_COUNT, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_BATCH_SUPPORT, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_BOOKMARK_PERSISTENCE, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CATALOG_LOCATION, + InfoTab::Short, + 0L, + 0 + }, + { SQL_CATALOG_NAME, + InfoTab::YesNo, + 0L, + "N" + }, + { SQL_CATALOG_NAME_SEPARATOR, + InfoTab::Char, + 0L, + "" + }, + { SQL_CATALOG_TERM, + InfoTab::Char, + 0L, + "" + }, + { SQL_CATALOG_USAGE, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_COLLATION_SEQ, + InfoTab::Char, + 0L, + "ISO 8859-1" + }, + { SQL_COLUMN_ALIAS, + InfoTab::YesNo, + 0L, + "Y" + }, + { SQL_CONCAT_NULL_BEHAVIOR, + InfoTab::Short, + 0L, + 0 + }, + { SQL_CONVERT_BIGINT, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_BINARY, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_BIT, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_CHAR, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_DATE, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_DECIMAL, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_DOUBLE, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_FLOAT, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_FUNCTIONS, + InfoTab::Bitmask, + 0L, + 0 + }, +#if 0 + { SQL_CONVERT_GUID, + InfoTab::Bitmask, + 0L, + 0 + }, +#endif + { SQL_CONVERT_INTEGER, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_INTERVAL_DAY_TIME, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_INTERVAL_YEAR_MONTH, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_LONGVARBINARY, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_LONGVARCHAR, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_NUMERIC, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_REAL, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_SMALLINT, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_TIME, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_TIMESTAMP, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_TINYINT, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_VARBINARY, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CONVERT_VARCHAR, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CORRELATION_NAME, + InfoTab::Bitmask, + SQL_CN_ANY, + 0 + }, + { SQL_CREATE_ASSERTION, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CREATE_CHARACTER_SET, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CREATE_COLLATION, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CREATE_DOMAIN, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CREATE_SCHEMA, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CREATE_TABLE, + InfoTab::Bitmask, + SQL_CT_CREATE_TABLE, + 0 + }, + { SQL_CREATE_TRANSLATION, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CREATE_VIEW, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_CURSOR_COMMIT_BEHAVIOR, + InfoTab::Short, + SQL_CB_CLOSE, + 0 + }, + { SQL_CURSOR_ROLLBACK_BEHAVIOR, + InfoTab::Short, + SQL_CB_CLOSE, + 0 + }, + { SQL_CURSOR_SENSITIVITY, + InfoTab::Long, + 0L, + 0 + }, + { SQL_DATABASE_NAME, + InfoTab::Char, + 0L, + "" + }, + { SQL_DATA_SOURCE_NAME, + InfoTab::Char, + 0L, + "" + }, + { SQL_DATA_SOURCE_READ_ONLY, + InfoTab::YesNo, + 0L, + "N" + }, + { SQL_DATETIME_LITERALS, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_DBMS_NAME, + InfoTab::Char, + 0L, + "" + }, + { SQL_DBMS_VER, + InfoTab::Char, + 0L, + "01.43.0000" + }, + { SQL_DDL_INDEX, + InfoTab::Long, + 0L, + 0 + }, + { SQL_DEFAULT_TXN_ISOLATION, + InfoTab::Long, + SQL_TXN_READ_COMMITTED, + 0 + }, + { SQL_DESCRIBE_PARAMETER, + InfoTab::YesNo, + 0L, + "N" + }, + { SQL_DM_VER, + InfoTab::Char, + 0L, + "" + }, + { SQL_DRIVER_HDBC, + InfoTab::Long, + 0L, + 0 + }, + { SQL_DRIVER_HDESC, + InfoTab::Long, + 0L, + 0 + }, + { SQL_DRIVER_HLIB, + InfoTab::Long, + 0L, + 0 + }, + { SQL_DRIVER_HSTMT, + InfoTab::Long, + 0L, + 0 + }, + { SQL_DRIVER_NAME, + InfoTab::Char, + 0L, + "" + }, + { SQL_DRIVER_ODBC_VER, + InfoTab::Char, + 0L, + "03.00" + }, + { SQL_DRIVER_VER, + InfoTab::Char, + 0L, + "00.10.0000" + }, + { SQL_DROP_ASSERTION, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_DROP_CHARACTER_SET, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_DROP_COLLATION, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_DROP_DOMAIN, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_DROP_SCHEMA, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_DROP_TABLE, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_DROP_TRANSLATION, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_DROP_VIEW, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_DTC_TRANSITION_COST, // not in older MS docs + InfoTab::Bitmask, + 0L, + 0 // SQL_DTC_ENLIST_EXPENSIVE | SQL_DTC_UNENLIST_EXPENSIVE + }, + { SQL_DYNAMIC_CURSOR_ATTRIBUTES1, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_DYNAMIC_CURSOR_ATTRIBUTES2, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_EXPRESSIONS_IN_ORDERBY, + InfoTab::Char, + 0L, + "Y" + }, + { SQL_FILE_USAGE, + InfoTab::Short, + 0L, + 0 + }, + { SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_GETDATA_EXTENSIONS, + InfoTab::Bitmask, + SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER | SQL_GD_BOUND, + 0 + }, + { SQL_GROUP_BY, + InfoTab::Short, + SQL_GB_NOT_SUPPORTED, + 0 + }, + { SQL_IDENTIFIER_CASE, + InfoTab::Short, + SQL_IC_UPPER, + 0 + }, + { SQL_IDENTIFIER_QUOTE_CHAR, + InfoTab::Char, + 0L, + "\"" + }, + { SQL_INDEX_KEYWORDS, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_INFO_SCHEMA_VIEWS, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_INSERT_STATEMENT, + InfoTab::Bitmask, + SQL_IS_INSERT_LITERALS | SQL_IS_SELECT_INTO, + 0 + }, + { SQL_INTEGRITY, + InfoTab::YesNo, + 0L, + "N" + }, + { SQL_KEYSET_CURSOR_ATTRIBUTES1, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_KEYSET_CURSOR_ATTRIBUTES2, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_KEYWORDS, + InfoTab::Char, + 0L, + "" + }, + { SQL_LIKE_ESCAPE_CLAUSE, + InfoTab::YesNo, + 0L, + "N" + }, + { SQL_MAX_ASYNC_CONCURRENT_STATEMENTS, + InfoTab::Long, + 0L, + 0 + }, + { SQL_MAX_BINARY_LITERAL_LEN, + InfoTab::Long, + 0L, + 0 + }, + { SQL_MAX_CATALOG_NAME_LEN, + InfoTab::Short, + 0L, + 0 + }, + { SQL_MAX_CHAR_LITERAL_LEN, + InfoTab::Long, + 0L, + 0 + }, + { SQL_MAX_COLUMN_NAME_LEN, + InfoTab::Short, + 16, + 0 + }, + { SQL_MAX_COLUMNS_IN_GROUP_BY, + InfoTab::Short, + 0L, + 0 + }, + { SQL_MAX_COLUMNS_IN_INDEX, + InfoTab::Short, + 0L, + 0 + }, + { SQL_MAX_COLUMNS_IN_ORDER_BY, + InfoTab::Short, + 0L, + 0 + }, + { SQL_MAX_COLUMNS_IN_SELECT, + InfoTab::Short, + 0L, + 0 + }, + { SQL_MAX_COLUMNS_IN_TABLE, + InfoTab::Short, + 0L, + 0 + }, + { SQL_MAX_CONCURRENT_ACTIVITIES, + InfoTab::Short, + 0L, + 0 + }, + { SQL_MAX_CURSOR_NAME_LEN, + InfoTab::Short, + 0L, + 0 + }, + { SQL_MAX_DRIVER_CONNECTIONS, + InfoTab::Short, + 0L, + 0 + }, + { SQL_MAX_IDENTIFIER_LEN, + InfoTab::Short, + 0L, + 0 + }, + { SQL_MAX_INDEX_SIZE, + InfoTab::Long, + 0L, + 0 + }, + { SQL_MAX_PROCEDURE_NAME_LEN, + InfoTab::Short, + 0L, + 0 + }, + { SQL_MAX_ROW_SIZE, + InfoTab::Long, + 8000, + 0 + }, + { SQL_MAX_ROW_SIZE_INCLUDES_LONG, + InfoTab::YesNo, + 0L, + "Y" + }, + { SQL_MAX_SCHEMA_NAME_LEN, + InfoTab::Short, + 0L, + 0 + }, + { SQL_MAX_STATEMENT_LEN, + InfoTab::Long, + 0L, + 0 + }, + { SQL_MAX_TABLE_NAME_LEN, + InfoTab::Short, + 0L, + 0 + }, + { SQL_MAX_TABLES_IN_SELECT, + InfoTab::Short, + 0L, + 0 + }, + { SQL_MAX_USER_NAME_LEN, + InfoTab::Short, + 0L, + 0 + }, + { SQL_MULTIPLE_ACTIVE_TXN, + InfoTab::YesNo, + 0L, + "N" + }, + { SQL_MULT_RESULT_SETS, + InfoTab::YesNo, + 0L, + "N" + }, + { SQL_NEED_LONG_DATA_LEN, + InfoTab::YesNo, + 0L, + "N" + }, + { SQL_NON_NULLABLE_COLUMNS, + InfoTab::Short, + SQL_NNC_NON_NULL, + 0 + }, + { SQL_NULL_COLLATION, + InfoTab::Short, + SQL_NC_HIGH, + 0 + }, + { SQL_NUMERIC_FUNCTIONS, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_ODBC_INTERFACE_CONFORMANCE, + InfoTab::Long, + SQL_OIC_CORE, + 0 + }, + { SQL_ODBC_VER, + InfoTab::Char, + 0L, + "" + }, + { SQL_OJ_CAPABILITIES, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_ORDER_BY_COLUMNS_IN_SELECT, + InfoTab::YesNo, + 0L, + "N" + }, + { SQL_PARAM_ARRAY_ROW_COUNTS, + InfoTab::Long, + 0L, + 0 + }, + { SQL_PARAM_ARRAY_SELECTS, + InfoTab::Long, + 0L, + 0 + }, + { SQL_POS_OPERATIONS, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_PROCEDURES, + InfoTab::YesNo, + 0L, + "N" + }, + { SQL_PROCEDURE_TERM, + InfoTab::Char, + 0L, + "" + }, + { SQL_QUOTED_IDENTIFIER_CASE, + InfoTab::Short, + SQL_IC_SENSITIVE, + 0 + }, + { SQL_ROW_UPDATES, + InfoTab::YesNo, + 0L, + "N" + }, + { SQL_SCHEMA_TERM, + InfoTab::Char, + 0L, + "" + }, + { SQL_SCHEMA_USAGE, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_SCROLL_OPTIONS, + InfoTab::Bitmask, + SQL_SO_FORWARD_ONLY, + 0 + }, + { SQL_SEARCH_PATTERN_ESCAPE, + InfoTab::Char, + 0L, + "" + }, + { SQL_SERVER_NAME, + InfoTab::Char, + 0L, + "" + }, + { SQL_SPECIAL_CHARACTERS, + InfoTab::Char, + 0L, + "" + }, + { SQL_SQL92_DATETIME_FUNCTIONS, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_SQL92_FOREIGN_KEY_DELETE_RULE, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_SQL92_FOREIGN_KEY_UPDATE_RULE, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_SQL92_GRANT, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_SQL92_NUMERIC_VALUE_FUNCTIONS, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_SQL92_PREDICATES, + InfoTab::Bitmask, + SQL_SP_COMPARISON | SQL_SP_IN | SQL_SP_ISNOTNULL | SQL_SP_ISNULL | SQL_SP_LIKE, + 0 + }, + { SQL_SQL92_RELATIONAL_JOIN_OPERATORS, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_SQL92_REVOKE, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_SQL92_ROW_VALUE_CONSTRUCTOR, + InfoTab::Bitmask, + SQL_SRVC_VALUE_EXPRESSION, + 0 + }, + { SQL_SQL92_STRING_FUNCTIONS, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_SQL92_VALUE_EXPRESSIONS, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_SQL_CONFORMANCE, + InfoTab::Long, + 0L, + 0 + }, + { SQL_STANDARD_CLI_CONFORMANCE, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_STATIC_CURSOR_ATTRIBUTES1, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_STATIC_CURSOR_ATTRIBUTES2, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_STRING_FUNCTIONS, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_SUBQUERIES, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_SYSTEM_FUNCTIONS, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_TABLE_TERM, + InfoTab::Char, + 0L, + "TABLE" + }, + { SQL_TIMEDATE_ADD_INTERVALS, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_TIMEDATE_DIFF_INTERVALS, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_TIMEDATE_FUNCTIONS, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_TXN_CAPABLE, + InfoTab::Short, + SQL_TC_DDL_COMMIT, // XXX do it + 0 + }, + { SQL_TXN_ISOLATION_OPTION, + InfoTab::Bitmask, + SQL_TXN_READ_COMMITTED, + 0 + }, + { SQL_UNION, + InfoTab::Bitmask, + 0L, + 0 + }, + { SQL_USER_NAME, + InfoTab::Char, + 0L, + "" + }, + { SQL_XOPEN_CLI_YEAR, + InfoTab::Char, + 0L, + "" + }, + { 0, + InfoTab::End, + 0L, + 0 + } +}; diff --git a/ndb/src/client/odbc/handles/Makefile b/ndb/src/client/odbc/handles/Makefile new file mode 100644 index 00000000000..d37e7d286ba --- /dev/null +++ b/ndb/src/client/odbc/handles/Makefile @@ -0,0 +1,28 @@ +include .defs.mk + +TYPE = * + +NONPIC_ARCHIVE = N + +PIC_ARCHIVE = Y + +ARCHIVE_TARGET = odbchandles + +SOURCES = \ + HandleBase.cpp \ + HandleRoot.cpp \ + HandleEnv.cpp \ + HandleDbc.cpp \ + HandleStmt.cpp \ + HandleDesc.cpp \ + AttrRoot.cpp \ + AttrEnv.cpp \ + AttrDbc.cpp \ + AttrStmt.cpp \ + PoolNdb.cpp \ + DescSpec.cpp \ + FuncTab.cpp \ + InfoTab.cpp + +include ../Extra.mk +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/client/odbc/handles/PoolNdb.cpp b/ndb/src/client/odbc/handles/PoolNdb.cpp new file mode 100644 index 00000000000..c487ca2b976 --- /dev/null +++ b/ndb/src/client/odbc/handles/PoolNdb.cpp @@ -0,0 +1,80 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include "PoolNdb.hpp" + +#ifdef NDB_WIN32 +static NdbMutex & ndb_mutex = * NdbMutex_Create(); +#else +static NdbMutex ndb_mutex = NDB_MUTEX_INITIALIZER; +#endif + +PoolNdb::PoolNdb() : + m_cntUsed(0), + m_cntFree(0) +{ +} + +PoolNdb::~PoolNdb() +{ +} + +Ndb* +PoolNdb::allocate(Ctx& ctx, int timeout) +{ + NdbMutex_Lock(&ndb_mutex); + Ndb* pNdb; + if (m_cntFree == 0) { + pNdb = new Ndb("TEST_DB"); + pNdb->useFullyQualifiedNames(true); + if (pNdb->init(64) < 0) { + ctx.pushStatus(pNdb, "init"); + delete pNdb; + NdbMutex_Unlock(&ndb_mutex); + return 0; + } + if (pNdb->waitUntilReady(timeout) < 0) { + ctx.pushStatus(Sqlstate::_HYT00, Error::Gen, "connection timeout after %d seconds", timeout); + ctx.pushStatus(pNdb, "waitUntilReady"); + delete pNdb; + NdbMutex_Unlock(&ndb_mutex); + return 0; + } + m_listFree.push_back(pNdb); + m_cntFree++; + } + pNdb = m_listFree.front(); + m_listFree.pop_front(); + m_cntFree--; + m_cntUsed++; + ctx_log1(("alloc Ndb: used=%u free=%u", m_cntUsed, m_cntFree)); + NdbMutex_Unlock(&ndb_mutex); + return pNdb; +} + +void +PoolNdb::release(Ctx& ctx, Ndb* pNdb) +{ + NdbMutex_Lock(&ndb_mutex); + m_listUsed.remove(pNdb); + m_listFree.push_back(pNdb); + m_cntFree++; + m_cntUsed--; + ctx_log1(("free Ndb: used=%u free=%u", m_cntUsed, m_cntFree)); + NdbMutex_Unlock(&ndb_mutex); +} diff --git a/ndb/src/client/odbc/handles/PoolNdb.hpp b/ndb/src/client/odbc/handles/PoolNdb.hpp new file mode 100644 index 00000000000..bea7e72a59f --- /dev/null +++ b/ndb/src/client/odbc/handles/PoolNdb.hpp @@ -0,0 +1,44 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ODBC_HANDLES_PoolNdb_hpp +#define ODBC_HANDLES_PoolNdb_hpp + +#include +#include + +class Ndb; + +/** + * @class PoolNdb + * @brief Pool of Ndb objects. + * + * A class implementing pool of Ndb objects. + */ +class PoolNdb { +public: + PoolNdb(); + ~PoolNdb(); + Ndb* allocate(Ctx& ctx, int timeout); + void release(Ctx& ctx, Ndb* pNdb); +private: + std::list m_listUsed; + std::list m_listFree; + unsigned m_cntUsed; + unsigned m_cntFree; +}; + +#endif diff --git a/ndb/src/client/odbc/handles/handles.hpp b/ndb/src/client/odbc/handles/handles.hpp new file mode 100644 index 00000000000..a9f0fcae888 --- /dev/null +++ b/ndb/src/client/odbc/handles/handles.hpp @@ -0,0 +1,28 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef OBDC_HANDLES_handles_hpp +#define OBDC_HANDLES_handles_hpp + +#include +#include "HandleBase.hpp" +#include "HandleRoot.hpp" +#include "HandleEnv.hpp" +#include "HandleDbc.hpp" +#include "HandleStmt.hpp" +#include "HandleDesc.hpp" + +#endif diff --git a/ndb/src/common/Makefile b/ndb/src/common/Makefile new file mode 100644 index 00000000000..ebde75bf3ec --- /dev/null +++ b/ndb/src/common/Makefile @@ -0,0 +1,15 @@ +include .defs.mk + +LIB_DIRS := \ + portlib \ + debugger \ + util \ + logger + +ifneq ($(USE_EDITLINE), N) +LIB_DIRS += editline +endif + +DIRS := transporter mgmcommon + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/common/debugger/BlockNames.cpp b/ndb/src/common/debugger/BlockNames.cpp new file mode 100644 index 00000000000..44650b84c5c --- /dev/null +++ b/ndb/src/common/debugger/BlockNames.cpp @@ -0,0 +1,39 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include + +const BlockName BlockNames[] = { + { "CMVMI", CMVMI }, + { "DBACC", DBACC }, + { "DBDICT", DBDICT }, + { "DBDIH", DBDIH }, + { "DBLQH", DBLQH }, + { "DBTC", DBTC }, + { "DBTUP", DBTUP }, + { "NDBFS", NDBFS }, + { "NDBCNTR", NDBCNTR }, + { "QMGR", QMGR }, + { "TRIX", TRIX }, + { "BACKUP", BACKUP }, + { "DBUTIL", DBUTIL }, + { "SUMA", SUMA }, + { "GREP", GREP }, + { "DBTUX", DBTUX } +}; + +const BlockNumber NO_OF_BLOCK_NAMES = sizeof(BlockNames) / sizeof(BlockName); diff --git a/ndb/src/common/debugger/DebuggerNames.cpp b/ndb/src/common/debugger/DebuggerNames.cpp new file mode 100644 index 00000000000..fdee978ab54 --- /dev/null +++ b/ndb/src/common/debugger/DebuggerNames.cpp @@ -0,0 +1,154 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "DebuggerNames.hpp" + +#include +#include +#include + +#include +#include +#include + +static const char * localSignalNames[MAX_GSN+1]; +static SignalDataPrintFunction localPrintFunctions[MAX_GSN+1]; +static const char * localBlockNames[NO_OF_BLOCKS]; + +static +int +initSignalNames(const char * dst[], const GsnName src[], unsigned short len){ + for(int i = 0; i<=MAX_GSN; i++) + dst[i] = 0; + + for(int i = 0; i= NO_OF_BLOCKS || dst[index] != 0){ + fprintf(stderr, + "Invalid block name definition: %d %s\n", + src[i].number, src[i].name); + exit(0); + } + dst[index] = src[i].name; + } + return 0; +} + +/** + * Run static initializer + */ +static const int +xxx_DUMMY_SIGNAL_NAMES_xxx = initSignalNames(localSignalNames, + SignalNames, + NO_OF_SIGNAL_NAMES); +static const int +xxx_DUMMY_PRINT_FUNCTIONS_xxx = initSignalPrinters(localPrintFunctions, + SignalDataPrintFunctions, + NO_OF_PRINT_FUNCTIONS); + +static const int +xxx_DUMMY_BLOCK_NAMES_xxx = initBlockNames(localBlockNames, + BlockNames, + NO_OF_BLOCK_NAMES); + +const char * +getSignalName(unsigned short gsn, const char * defVal){ + if(gsn > 0 && gsn <= MAX_GSN) + return (localSignalNames[gsn] ? localSignalNames[gsn] : defVal); + return defVal; +} + +unsigned short +getGsn(const char * signalName){ + return 0; +} + +const char * +getBlockName(unsigned short blockNo, const char * ret){ + if(blockNo >= MIN_BLOCK_NO && blockNo <= MAX_BLOCK_NO) + return localBlockNames[blockNo-MIN_BLOCK_NO]; + if (ret == 0) { + static char buf[20]; + snprintf(buf, sizeof(buf), "BLOCK#%d", (int)blockNo); + return buf; + } + return ret; +} + +unsigned short +getBlockNo(const char * blockName){ + for(int i = 0; i 0 && gsn <= MAX_GSN) + return localPrintFunctions[gsn]; + return 0; +} diff --git a/ndb/src/common/debugger/EventLogger.cpp b/ndb/src/common/debugger/EventLogger.cpp new file mode 100644 index 00000000000..12f01890c54 --- /dev/null +++ b/ndb/src/common/debugger/EventLogger.cpp @@ -0,0 +1,1454 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "EventLogger.hpp" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +// +// PUBLIC +// + +/** + * This matrix defines which event should be printed when + * + * threshold - is in range [0-15] + * severity - DEBUG to ALERT (Type of log message) + */ +const EventLogger::EventRepLogLevelMatrix EventLogger::matrix[] = { + // CONNECTION + { EventReport::Connected, LogLevel::llConnection, 8, LL_INFO }, + { EventReport::Disconnected, LogLevel::llConnection, 8, LL_ALERT }, + { EventReport::CommunicationClosed, LogLevel::llConnection, 8, LL_INFO }, + { EventReport::CommunicationOpened, LogLevel::llConnection, 8, LL_INFO }, + { EventReport::ConnectedApiVersion, LogLevel::llConnection, 8, LL_INFO }, + // CHECKPOINT + { EventReport::GlobalCheckpointStarted, LogLevel::llCheckpoint, 9, LL_INFO }, + { EventReport::GlobalCheckpointCompleted,LogLevel::llCheckpoint,10, LL_INFO }, + { EventReport::LocalCheckpointStarted, LogLevel::llCheckpoint, 7, LL_INFO }, + { EventReport::LocalCheckpointCompleted,LogLevel::llCheckpoint, 8, LL_INFO }, + { EventReport::LCPStoppedInCalcKeepGci, LogLevel::llCheckpoint, 0, LL_ALERT }, + { EventReport::LCPFragmentCompleted, LogLevel::llCheckpoint, 11, LL_INFO }, + { EventReport::UndoLogBlocked, LogLevel::llCheckpoint, 7, LL_INFO }, + + // STARTUP + { EventReport::NDBStartStarted, LogLevel::llStartUp, 1, LL_INFO }, + { EventReport::NDBStartCompleted, LogLevel::llStartUp, 1, LL_INFO }, + { EventReport::STTORRYRecieved, LogLevel::llStartUp,15, LL_INFO }, + { EventReport::StartPhaseCompleted, LogLevel::llStartUp, 4, LL_INFO }, + { EventReport::CM_REGCONF, LogLevel::llStartUp, 3, LL_INFO }, + { EventReport::CM_REGREF, LogLevel::llStartUp, 8, LL_INFO }, + { EventReport::FIND_NEIGHBOURS, LogLevel::llStartUp, 8, LL_INFO }, + { EventReport::NDBStopStarted, LogLevel::llStartUp, 1, LL_INFO }, + { EventReport::NDBStopAborted, LogLevel::llStartUp, 1, LL_INFO }, + { EventReport::StartREDOLog, LogLevel::llStartUp, 10, LL_INFO }, + { EventReport::StartLog, LogLevel::llStartUp, 10, LL_INFO }, + { EventReport::UNDORecordsExecuted, LogLevel::llStartUp, 15, LL_INFO }, + + // NODERESTART + { EventReport::NR_CopyDict, LogLevel::llNodeRestart, 8, LL_INFO }, + { EventReport::NR_CopyDistr, LogLevel::llNodeRestart, 8, LL_INFO }, + { EventReport::NR_CopyFragsStarted, LogLevel::llNodeRestart, 8, LL_INFO }, + { EventReport::NR_CopyFragDone, LogLevel::llNodeRestart, 10, LL_INFO }, + { EventReport::NR_CopyFragsCompleted, LogLevel::llNodeRestart, 8, LL_INFO }, + + { EventReport::NodeFailCompleted, LogLevel::llNodeRestart, 8, LL_ALERT}, + { EventReport::NODE_FAILREP, LogLevel::llNodeRestart, 8, LL_ALERT}, + { EventReport::ArbitState, LogLevel::llNodeRestart, 6, LL_INFO }, + { EventReport::ArbitResult, LogLevel::llNodeRestart, 2, LL_ALERT}, + { EventReport::GCP_TakeoverStarted, LogLevel::llNodeRestart, 7, LL_INFO }, + { EventReport::GCP_TakeoverCompleted, LogLevel::llNodeRestart, 7, LL_INFO }, + { EventReport::LCP_TakeoverStarted, LogLevel::llNodeRestart, 7, LL_INFO }, + { EventReport::LCP_TakeoverCompleted, LogLevel::llNodeRestart, 7, LL_INFO }, + + // STATISTIC + { EventReport::TransReportCounters, LogLevel::llStatistic, 8, LL_INFO }, + { EventReport::OperationReportCounters, LogLevel::llStatistic, 8, LL_INFO }, + { EventReport::TableCreated, LogLevel::llStatistic, 7, LL_INFO }, + { EventReport::JobStatistic, LogLevel::llStatistic, 9, LL_INFO }, + { EventReport::SendBytesStatistic, LogLevel::llStatistic, 9, LL_INFO }, + { EventReport::ReceiveBytesStatistic, LogLevel::llStatistic, 9, LL_INFO }, + { EventReport::MemoryUsage, LogLevel::llStatistic, 5, LL_INFO }, + + // ERROR + { EventReport::TransporterError, LogLevel::llError, 2, LL_ERROR }, + { EventReport::TransporterWarning, LogLevel::llError, 8, LL_WARNING }, + { EventReport::MissedHeartbeat, LogLevel::llError, 8, LL_WARNING }, + { EventReport::DeadDueToHeartbeat, LogLevel::llError, 8, LL_ALERT }, + { EventReport::WarningEvent, LogLevel::llError, 2, LL_WARNING }, + // INFO + { EventReport::SentHeartbeat, LogLevel::llInfo, 12, LL_INFO }, + { EventReport::CreateLogBytes, LogLevel::llInfo, 11, LL_INFO }, + { EventReport::InfoEvent, LogLevel::llInfo, 2, LL_INFO }, + + //Global replication + { EventReport::GrepSubscriptionInfo, LogLevel::llGrep, 7, LL_INFO}, + { EventReport::GrepSubscriptionAlert, LogLevel::llGrep, 7, LL_ALERT} +}; + +const Uint32 EventLogger::matrixSize = sizeof(EventLogger::matrix)/ + sizeof(EventRepLogLevelMatrix); + +/** + * Default log levels for management nodes. + * + * threshold - is in range [0-15] + */ +const EventLogger::EventLogMatrix EventLogger::defEventLogMatrix[] = { + { LogLevel::llStartUp, 7 }, + { LogLevel::llShutdown, 7 }, + { LogLevel::llStatistic, 7 }, + { LogLevel::llCheckpoint, 7 }, + { LogLevel::llNodeRestart, 7 }, + { LogLevel::llConnection, 7 }, + { LogLevel::llError, 15 }, + { LogLevel::llInfo, 7 }, + { LogLevel::llGrep, 7 } +}; + +const Uint32 +EventLogger::defEventLogMatrixSize = sizeof(EventLogger::defEventLogMatrix)/ + sizeof(EventLogMatrix); +/** + * Specifies allowed event categories/log levels that can be set from + * the Management API/interactive shell. + */ +const EventLogger::EventCategoryName EventLogger::eventCategoryNames[] = { + { LogLevel::llStartUp, "STARTUP" }, + { LogLevel::llStatistic, "STATISTIC" }, + { LogLevel::llCheckpoint, "CHECKPOINT" }, + { LogLevel::llNodeRestart, "NODERESTART" }, + { LogLevel::llConnection, "CONNECTION" }, + { LogLevel::llInfo, "INFO" }, + { LogLevel::llGrep, "GREP" } +}; + +const Uint32 +EventLogger::noOfEventCategoryNames = sizeof(EventLogger::eventCategoryNames)/ + sizeof(EventLogger::EventCategoryName); + +char EventLogger::m_text[MAX_TEXT_LENGTH]; + +const char* +EventLogger::getText(int type, + const Uint32* theData, NodeId nodeId) +{ + // TODO: Change the switch implementation... + char theNodeId[32]; + if (nodeId != 0){ + ::snprintf(theNodeId, 32, "Node %u: ", nodeId); + } else { + theNodeId[0] = 0; + } + + EventReport::EventType eventType = (EventReport::EventType)type; + switch (eventType){ + case EventReport::Connected: + ::snprintf(m_text, sizeof(m_text), + "%sNode %u Connected", + theNodeId, + theData[1]); + break; + case EventReport::ConnectedApiVersion: + ::snprintf(m_text, sizeof(m_text), + "%sNode %u: API version %d.%d.%d", + theNodeId, + theData[1], + getMajor(theData[2]), + getMinor(theData[2]), + getBuild(theData[2])); + break; + case EventReport::Disconnected: + ::snprintf(m_text, sizeof(m_text), + "%sNode %u Disconnected", + theNodeId, + theData[1]); + break; + case EventReport::CommunicationClosed: + //----------------------------------------------------------------------- + // REPORT communication to node closed. + //----------------------------------------------------------------------- + ::snprintf(m_text, sizeof(m_text), + "%sCommunication to Node %u closed", + theNodeId, + theData[1]); + break; + case EventReport::CommunicationOpened: + //----------------------------------------------------------------------- + // REPORT communication to node opened. + //----------------------------------------------------------------------- + ::snprintf(m_text, sizeof(m_text), + "%sCommunication to Node %u opened", + theNodeId, + theData[1]); + break; + case EventReport::NDBStartStarted: + //----------------------------------------------------------------------- + // Start of NDB has been initiated. + //----------------------------------------------------------------------- + ::snprintf(m_text, sizeof(m_text), + "%sStart initiated (version %d.%d.%d)", + theNodeId , + getMajor(theData[1]), + getMinor(theData[1]), + getBuild(theData[1])); + break; + case EventReport::NDBStopStarted: + ::snprintf(m_text, sizeof(m_text), + "%s%s shutdown initiated", + theNodeId, + (theData[1] == 1 ? "Cluster" : "Node")); + break; + case EventReport::NDBStopAborted: + ::snprintf(m_text, sizeof(m_text), + "%sNode shutdown aborted", + theNodeId); + break; + case EventReport::NDBStartCompleted: + //----------------------------------------------------------------------- + // Start of NDB has been completed. + //----------------------------------------------------------------------- + ::snprintf(m_text, sizeof(m_text), + "%sStarted (version %d.%d.%d)", + theNodeId , + getMajor(theData[1]), + getMinor(theData[1]), + getBuild(theData[1])); + + break; + case EventReport::STTORRYRecieved: + //----------------------------------------------------------------------- + // STTORRY recevied after restart finished. + //----------------------------------------------------------------------- + ::snprintf(m_text, sizeof(m_text), + "%sSTTORRY received after restart finished", + theNodeId); + break; + case EventReport::StartPhaseCompleted:{ + //----------------------------------------------------------------------- + // REPORT Start phase completed. + //----------------------------------------------------------------------- + const char * type = ""; + switch((NodeState::StartType)theData[2]){ + case NodeState::ST_INITIAL_START: + type = "(initial start)"; + break; + case NodeState::ST_SYSTEM_RESTART: + type = "(system restart)"; + break; + case NodeState::ST_NODE_RESTART: + type = "(node restart)"; + break; + case NodeState::ST_INITIAL_NODE_RESTART: + type = "(initial node restart)"; + break; + case NodeState::ST_ILLEGAL_TYPE: + type = ""; + break; + default:{ + ::snprintf(m_text, sizeof(m_text), + "%sStart phase %u completed (unknown = %d)", + theNodeId, + theData[1], + theData[2]); + return m_text; + } + } + ::snprintf(m_text, sizeof(m_text), + "%sStart phase %u completed %s", + theNodeId, + theData[1], + type); + return m_text; + break; + } + case EventReport::CM_REGCONF: + ::snprintf(m_text, sizeof(m_text), + "%sCM_REGCONF president = %u, own Node = %u, our dynamic id = %u" + , + theNodeId, + theData[2], + theData[1], + theData[3]); + break; + case EventReport::CM_REGREF: + { + const char* line = ""; + switch (theData[3]) { + case 0: + line = "Busy"; + break; + case 1: + line = "Election with wait = false"; + break; + case 2: + line = "Election with wait = false"; + break; + case 3: + line = "Not president"; + break; + case 4: + line = "Election without selecting new candidate"; + break; + default: + line = "No such cause"; + break; + }//switch + + ::snprintf(m_text, sizeof(m_text), + "%sCM_REGREF from Node %u to our Node %u. Cause = %s", + theNodeId, + theData[2], + theData[1], + line); + } + break; + case EventReport::FIND_NEIGHBOURS: + //----------------------------------------------------------------------- + // REPORT Node Restart copied a fragment. + //----------------------------------------------------------------------- + ::snprintf(m_text, + sizeof(m_text), + "%sWe are Node %u with dynamic ID %u, our left neighbour " + "is Node %u, our right is Node %u", + theNodeId, + theData[1], + theData[4], + theData[2], + theData[3]); + break; + case EventReport::NodeFailCompleted: + //----------------------------------------------------------------------- + // REPORT Node failure phase completed. + //----------------------------------------------------------------------- + if (theData[1] == 0) + { + if (theData[3] != 0) { + ::snprintf(m_text, sizeof(m_text), + "%sNode %u completed failure of Node %u", + theNodeId, + theData[3], + theData[2]); + } else { + ::snprintf(m_text, sizeof(m_text), + "%sAll nodes completed failure of Node %u", + theNodeId, + theData[2]); + }//if + } else { + const char* line = ""; + if (theData[1] == DBTC){ + line = "DBTC"; + }else if (theData[1] == DBDICT){ + line = "DBDICT"; + }else if (theData[1] == DBDIH){ + line = "DBDIH"; + }else if (theData[1] == DBLQH){ + line = "DBLQH"; + } + + ::snprintf(m_text, sizeof(m_text), + "%sNode failure of %u %s completed", + theNodeId, + theData[2], + line); + } + break; + case EventReport::NODE_FAILREP: + ::snprintf(m_text, + sizeof(m_text), + "%sNode %u has failed. The Node state at failure " + "was %u", + theNodeId, + theData[1], + theData[2]); + + break; + case EventReport::ArbitState: + //----------------------------------------------------------------------- + // REPORT arbitrator found or lost. + //----------------------------------------------------------------------- + { const ArbitSignalData* sd = (ArbitSignalData*)theData; + char ticketText[ArbitTicket::TextLength + 1]; + char errText[ArbitCode::ErrTextLength + 1]; + const unsigned code = sd->code & 0xFFFF; + const unsigned state = sd->code >> 16; + switch (code) { + case ArbitCode::ThreadStart: + ::snprintf(m_text, sizeof(m_text), + "%sPresident restarts arbitration thread [state=%u]", + theNodeId, state); + break; + case ArbitCode::PrepPart2: + sd->ticket.getText(ticketText, sizeof(ticketText)); + ::snprintf(m_text, sizeof(m_text), + "%sPrepare arbitrator node %u [ticket=%s]", + theNodeId, sd->node, ticketText); + break; + case ArbitCode::PrepAtrun: + sd->ticket.getText(ticketText, sizeof(ticketText)); + ::snprintf(m_text, sizeof(m_text), + "%sReceive arbitrator node %u [ticket=%s]", + theNodeId, sd->node, ticketText); + break; + case ArbitCode::ApiStart: + sd->ticket.getText(ticketText, sizeof(ticketText)); + ::snprintf(m_text, sizeof(m_text), + "%sStarted arbitrator node %u [ticket=%s]", + theNodeId, sd->node, ticketText); + break; + case ArbitCode::ApiFail: + ::snprintf(m_text, sizeof(m_text), + "%sLost arbitrator node %u - process failure [state=%u]", + theNodeId, sd->node, state); + break; + case ArbitCode::ApiExit: + ::snprintf(m_text, sizeof(m_text), + "%sLost arbitrator node %u - process exit [state=%u]", + theNodeId, sd->node, state); + break; + default: + ArbitCode::getErrText(code, errText, sizeof(errText)); + ::snprintf(m_text, sizeof(m_text), + "%sLost arbitrator node %u - %s [state=%u]", + theNodeId, sd->node, errText, state); + break; + } + } + break; + case EventReport::ArbitResult: + //----------------------------------------------------------------------- + // REPORT arbitration result (the failures may not reach us). + //----------------------------------------------------------------------- + { const ArbitSignalData* sd = (ArbitSignalData*)theData; + char errText[ArbitCode::ErrTextLength + 1]; + const unsigned code = sd->code & 0xFFFF; + const unsigned state = sd->code >> 16; + switch (code) { + case ArbitCode::LoseNodes: + ::snprintf(m_text, sizeof(m_text), + "%sArbitration check lost - less than 1/2 nodes left", + theNodeId); + break; + case ArbitCode::WinGroups: + ::snprintf(m_text, sizeof(m_text), + "%sArbitration check won - node group majority", + theNodeId); + break; + case ArbitCode::LoseGroups: + ::snprintf(m_text, sizeof(m_text), + "%sArbitration check lost - missing node group", + theNodeId); + break; + case ArbitCode::Partitioning: + ::snprintf(m_text, sizeof(m_text), + "%sNetwork partitioning - arbitration required", + theNodeId); + break; + case ArbitCode::WinChoose: + ::snprintf(m_text, sizeof(m_text), + "%sArbitration won - positive reply from node %u", + theNodeId, sd->node); + break; + case ArbitCode::LoseChoose: + ::snprintf(m_text, sizeof(m_text), + "%sArbitration lost - negative reply from node %u", + theNodeId, sd->node); + break; + case ArbitCode::LoseNorun: + ::snprintf(m_text, sizeof(m_text), + "%sNetwork partitioning - no arbitrator available", + theNodeId); + break; + case ArbitCode::LoseNocfg: + ::snprintf(m_text, sizeof(m_text), + "%sNetwork partitioning - no arbitrator configured", + theNodeId); + break; + default: + ArbitCode::getErrText(code, errText, sizeof(errText)); + ::snprintf(m_text, sizeof(m_text), + "%sArbitration failure - %s [state=%u]", + theNodeId, errText, state); + break; + } + } + break; + case EventReport::GlobalCheckpointStarted: + //----------------------------------------------------------------------- + // This event reports that a global checkpoint has been started and this + // node is the master of this global checkpoint. + //----------------------------------------------------------------------- + ::snprintf(m_text, + sizeof(m_text), + "%sGlobal checkpoint %u started", + theNodeId, + theData[1]); + break; + case EventReport::GlobalCheckpointCompleted: + //----------------------------------------------------------------------- + // This event reports that a global checkpoint has been completed on this + // node and the node is the master of this global checkpoint. + //----------------------------------------------------------------------- + ::snprintf(m_text, sizeof(m_text), + "%sGlobal checkpoint %u completed", + theNodeId, + theData[1]); + break; + case EventReport::LocalCheckpointStarted: + //----------------------------------------------------------------------- + // This event reports that a local checkpoint has been started and this + // node is the master of this local checkpoint. + //----------------------------------------------------------------------- + ::snprintf(m_text, + sizeof(m_text), + "%sLocal checkpoint %u started. " + "Keep GCI = %u oldest restorable GCI = %u", + theNodeId, + theData[1], + theData[2], + theData[3]); + break; + case EventReport::LocalCheckpointCompleted: + //----------------------------------------------------------------------- + // This event reports that a local checkpoint has been completed on this + // node and the node is the master of this local checkpoint. + //----------------------------------------------------------------------- + ::snprintf(m_text, + sizeof(m_text), + "%sLocal checkpoint %u completed", + theNodeId, + theData[1]); + break; + case EventReport::TableCreated: + //----------------------------------------------------------------------- + // This event reports that a table has been created. + //----------------------------------------------------------------------- + ::snprintf(m_text, sizeof(m_text), + "%sTable with ID = %u created", + theNodeId, + theData[1]); + break; + case EventReport::LCPStoppedInCalcKeepGci: + if (theData[1] == 0) + ::snprintf(m_text, sizeof(m_text), + "%sLocal Checkpoint stopped in CALCULATED_KEEP_GCI", + theNodeId); + break; + case EventReport::NR_CopyDict: + //----------------------------------------------------------------------- + // REPORT Node Restart completed copy of dictionary information. + //----------------------------------------------------------------------- + ::snprintf(m_text, + sizeof(m_text), + "%sNode restart completed copy of dictionary information", + theNodeId); + break; + case EventReport::NR_CopyDistr: + //----------------------------------------------------------------------- + // REPORT Node Restart completed copy of distribution information. + //----------------------------------------------------------------------- + ::snprintf(m_text, + sizeof(m_text), + "%sNode restart completed copy of distribution information", + theNodeId); + break; + case EventReport::NR_CopyFragsStarted: + //----------------------------------------------------------------------- + // REPORT Node Restart is starting to copy the fragments. + //----------------------------------------------------------------------- + ::snprintf(m_text, + sizeof(m_text), + "%sNode restart starting to copy the fragments " + "to Node %u", + theNodeId, + theData[1]); + break; + case EventReport::NR_CopyFragDone: + //----------------------------------------------------------------------- + // REPORT Node Restart copied a fragment. + //----------------------------------------------------------------------- + ::snprintf(m_text, + sizeof(m_text), + "%sTable ID = %u, fragment ID = %u have been copied " + "to Node %u", + theNodeId, + theData[2], + theData[3], + theData[1]); + break; + case EventReport::NR_CopyFragsCompleted: + ::snprintf(m_text, + sizeof(m_text), + "%sNode restart completed copying the fragments " + "to Node %u", + theNodeId, + theData[1]); + break; + case EventReport::LCPFragmentCompleted: + ::snprintf(m_text, + sizeof(m_text), + "%sTable ID = %u, fragment ID = %u has completed LCP " + "on Node %u", + theNodeId, + theData[2], + theData[3], + theData[1]); + break; + case EventReport::TransReportCounters: + // ------------------------------------------------------------------- + // Report information about transaction activity once per 10 seconds. + // ------------------------------------------------------------------- + ::snprintf(m_text, + sizeof(m_text), + "%sTrans. Count = %u, Commit Count = %u, " + "Read Count = %u, Simple Read Count = %u,\n" + "Write Count = %u, AttrInfo Count = %u, " + "Concurrent Operations = %u, Abort Count = %u", + theNodeId, + theData[1], + theData[2], + theData[3], + theData[4], + theData[5], + theData[6], + theData[7], + theData[8]); + break; + case EventReport::OperationReportCounters: + ::snprintf(m_text, sizeof(m_text), + "%sOperations=%u", + theNodeId, + theData[1]); + break; + case EventReport::UndoLogBlocked: + //----------------------------------------------------------------------- + // REPORT Undo Logging blocked due to buffer near to overflow. + //----------------------------------------------------------------------- + ::snprintf(m_text, + sizeof(m_text), + "%sACC Blocked %u and TUP Blocked %u times last second", + theNodeId, + theData[1], + theData[2]); + break; + case EventReport::TransporterError: + case EventReport::TransporterWarning: + ::snprintf(m_text, + sizeof(m_text), + "%sTransporter to node %d reported error 0x%x", + theNodeId, + theData[1], + theData[2]); + break; + case EventReport::MissedHeartbeat: + //----------------------------------------------------------------------- + // REPORT Undo Logging blocked due to buffer near to overflow. + //----------------------------------------------------------------------- + ::snprintf(m_text, + sizeof(m_text), + "%sNode %d missed heartbeat %d", + theNodeId, + theData[1], + theData[2]); + break; + case EventReport::DeadDueToHeartbeat: + //----------------------------------------------------------------------- + // REPORT Undo Logging blocked due to buffer near to overflow. + //----------------------------------------------------------------------- + ::snprintf(m_text, + sizeof(m_text), + "%sNode %d declared dead due to missed heartbeat", + theNodeId, + theData[1]); + break; + case EventReport::JobStatistic: + ::snprintf(m_text, + sizeof(m_text), + "%sMean loop Counter in doJob last 8192 times = %u", + theNodeId, + theData[1]); + break; + case EventReport::SendBytesStatistic: + ::snprintf(m_text, + sizeof(m_text), + "%sMean send size to Node = %d last 4096 sends = %u bytes", + theNodeId, + theData[1], + theData[2]); + break; + case EventReport::ReceiveBytesStatistic: + ::snprintf(m_text, + sizeof(m_text), + "%sMean receive size to Node = %d last 4096 sends = %u bytes", + theNodeId, + theData[1], + theData[2]); + break; + case EventReport::SentHeartbeat: + ::snprintf(m_text, + sizeof(m_text), + "%sNode Sent Heartbeat to node = %d", + theNodeId, + theData[1]); + break; + case EventReport::CreateLogBytes: + ::snprintf(m_text, + sizeof(m_text), + "%sLog part %u, log file %u, MB %u", + theNodeId, + theData[1], + theData[2], + theData[3]); + break; + case EventReport::StartLog: + ::snprintf(m_text, + sizeof(m_text), + "%sLog part %u, start MB %u, stop MB %u, last GCI, log exec %u", + theNodeId, + theData[1], + theData[2], + theData[3], + theData[4]); + break; + case EventReport::StartREDOLog: + ::snprintf(m_text, + sizeof(m_text), + "%sNode: %d StartLog: [GCI Keep: %d LastCompleted: %d NewestRestorable: %d]", + theNodeId, + theData[1], + theData[2], + theData[3], + theData[4]); + break; + case EventReport::UNDORecordsExecuted:{ + const char* line = ""; + if (theData[1] == DBTUP){ + line = "DBTUP"; + }else if (theData[1] == DBACC){ + line = "DBACC"; + } + + ::snprintf(m_text, + sizeof(m_text), + "%s UNDO %s %d [%d %d %d %d %d %d %d %d %d]", + theNodeId, + line, + theData[2], + theData[3], + theData[4], + theData[5], + theData[6], + theData[7], + theData[8], + theData[9], + theData[10], + theData[11]); + } + break; + case EventReport::InfoEvent: + ::snprintf(m_text, + sizeof(m_text), + "%s%s", + theNodeId, + (char *)&theData[1]); + break; + case EventReport::WarningEvent: + ::snprintf(m_text, + sizeof(m_text), + "%s%s", + theNodeId, + (char *)&theData[1]); + break; + case EventReport::GCP_TakeoverStarted: + ::snprintf(m_text, + sizeof(m_text), + "%sGCP Take over started", theNodeId); + break; + case EventReport::GCP_TakeoverCompleted: + ::snprintf(m_text, + sizeof(m_text), + "%sGCP Take over completed", theNodeId); + break; + case EventReport::LCP_TakeoverStarted: + ::snprintf(m_text, + sizeof(m_text), + "%sLCP Take over started", theNodeId); + break; + case EventReport::LCP_TakeoverCompleted: + ::snprintf(m_text, + sizeof(m_text), + "%sLCP Take over completed (state = %d)", + theNodeId, theData[1]); + break; + case EventReport::MemoryUsage:{ + const int gth = theData[1]; + const int size = theData[2]; + const int used = theData[3]; + const int total = theData[4]; + const int block = theData[5]; + const int percent = (used*100)/total; + + ::snprintf(m_text, sizeof(m_text), + "%s%s usage %s %d%s(%d %dK pages of total %d)", + theNodeId, + (block==DBACC ? "Index" : (block == DBTUP ?"Data":"")), + (gth == 0 ? "is" : (gth > 0 ? "increased to" : "decreased to")), + percent, "%", + used, size/1024, total + ); + break; + } + + + case EventReport::GrepSubscriptionInfo : + { + GrepEvent::Subscription event = (GrepEvent::Subscription)theData[1]; + switch(event) { + case GrepEvent::GrepSS_CreateSubIdConf: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::SSCoord: Created subscription id" + " (subId=%d,SubKey=%d)" + " Return code: %d.", + subId, + subKey, + err); + break; + } + case GrepEvent::GrepPS_CreateSubIdConf: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::PSCoord: Created subscription id" + " (subId=%d,SubKey=%d)" + " Return code: %d.", + subId, + subKey, + err); + break; + } + case GrepEvent::GrepSS_SubCreateConf: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + const int nodegrp = theData[5]; + ::snprintf(m_text, sizeof(m_text), + "Grep::SSCoord: Created subscription using" + " (subId=%d,SubKey=%d)" + " in primary system. Primary system has %d nodegroup(s)." + " Return code: %d", + subId, + subKey, + nodegrp, + err); + break; + } + case GrepEvent::GrepPS_SubCreateConf: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::PSCoord: All participants have created " + "subscriptions" + " using (subId=%d,SubKey=%d)." + " Return code: %d", + subId, + subKey, + err); + break; + } + case GrepEvent::GrepSS_SubStartMetaConf: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::SSCoord: Logging started on meta data changes." + " using (subId=%d,SubKey=%d)" + " Return code: %d", + subId, + subKey, + err); + break; + } + case GrepEvent::GrepPS_SubStartMetaConf: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::PSCoord: All participants have started " + "logging meta data" + " changes on the subscription subId=%d,SubKey=%d) " + "(N.I yet)." + " Return code: %d", + subId, + subKey, + err); + break; + } + case GrepEvent::GrepSS_SubStartDataConf: { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::SSCoord: Logging started on table data changes " + " using (subId=%d,SubKey=%d)" + " Return code: %d", + subId, + subKey, + err); + break; + } + case GrepEvent::GrepPS_SubStartDataConf: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::PSCoord: All participants have started logging " + "table data changes on the subscription " + "subId=%d,SubKey=%d)." + " Return code: %d", + subId, + subKey, + err); + break; + } + case GrepEvent::GrepPS_SubSyncMetaConf: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::PSCoord: All participants have started " + " synchronization on meta data (META SCAN) using " + "(subId=%d,SubKey=%d)." + " Return code: %d", + subId, + subKey, + err); + break; + } + case GrepEvent::GrepSS_SubSyncMetaConf: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::SSCoord: Synchronization started (META SCAN) on " + " meta data using (subId=%d,SubKey=%d)" + " Return code: %d", + subId, + subKey, + err); + break; + } + case GrepEvent::GrepPS_SubSyncDataConf: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::PSCoord: All participants have started " + "synchronization " + " on table data (DATA SCAN) using (subId=%d,SubKey=%d)." + " Return code: %d", + subId, + subKey, + err); + break; + } + case GrepEvent::GrepSS_SubSyncDataConf: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + const int gci = theData[5]; + ::snprintf(m_text, sizeof(m_text), + "Grep::SSCoord: Synchronization started (DATA SCAN) on " + "table data using (subId=%d,SubKey=%d). GCI = %d" + " Return code: %d", + subId, + subKey, + gci, + err); + break; + } + case GrepEvent::GrepPS_SubRemoveConf: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::PSCoord: All participants have removed " + "subscription (subId=%d,SubKey=%d). I have cleaned " + "up resources I've used." + " Return code: %d", + subId, + subKey, + err); + break; + } + case GrepEvent::GrepSS_SubRemoveConf: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::SSCoord: Removed subscription " + "(subId=%d,SubKey=%d)" + " Return code: %d", + subId, + subKey, + err); + break; + } + default: + ::snprintf(m_text, + sizeof(m_text), + "%sUnknown GrepSubscriptonInfo event: %d", + theNodeId, + theData[1]); + } + break; + } + + case EventReport::GrepSubscriptionAlert : + { + GrepEvent::Subscription event = (GrepEvent::Subscription)theData[1]; + switch(event) + { + case GrepEvent::GrepSS_CreateSubIdRef: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::SSCoord:Error code: %d Error message: %s" + " (subId=%d,SubKey=%d)", + err, + GrepError::getErrorDesc((GrepError::Code)err), + subId, + subKey); + break; + } + case GrepEvent::GrepSS_SubCreateRef: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::SSCoord: FAILED to Created subscription using" + " (subId=%d,SubKey=%d)in primary system." + " Error code: %d Error Message: %s", + subId, + subKey, + err, + GrepError::getErrorDesc((GrepError::Code)err)); + break; + } + case GrepEvent::GrepSS_SubStartMetaRef: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::SSCoord: Logging failed to start on meta " + "data changes." + " using (subId=%d,SubKey=%d)" + " Error code: %d Error Message: %s", + subId, + subKey, + err, + GrepError::getErrorDesc((GrepError::Code)err)); + break; + } + case GrepEvent::GrepSS_SubStartDataRef: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::SSCoord: Logging FAILED to start on table data " + " changes using (subId=%d,SubKey=%d)" + " Error code: %d Error Message: %s", + subId, + subKey, + err, + GrepError::getErrorDesc((GrepError::Code)err)); + break; + } + case GrepEvent::GrepSS_SubSyncMetaRef: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::SSCoord: Synchronization FAILED (META SCAN) on " + " meta data using (subId=%d,SubKey=%d)" + " Error code: %d Error Message: %s", + subId, + subKey, + err, + GrepError::getErrorDesc((GrepError::Code)err)); + break; + } + case GrepEvent::GrepSS_SubSyncDataRef: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + const int gci = theData[5]; + ::snprintf(m_text, sizeof(m_text), + "Grep::SSCoord: Synchronization FAILED (DATA SCAN) on " + "table data using (subId=%d,SubKey=%d). GCI = %d" + " Error code: %d Error Message: %s", + subId, + subKey, + gci, + err, + GrepError::getErrorDesc((GrepError::Code)err)); + break; + } + case GrepEvent::GrepSS_SubRemoveRef: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::SSCoord: Failed to remove subscription " + "(subId=%d,SubKey=%d). " + " Error code: %d Error Message: %s", + subId, + subKey, + err, + GrepError::getErrorDesc((GrepError::Code)err) + ); + break; + } + + case GrepEvent::GrepPS_CreateSubIdRef: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::PSCoord: Error code: %d Error Message: %s" + " (subId=%d,SubKey=%d)", + err, + GrepError::getErrorDesc((GrepError::Code)err), + subId, + subKey); + break; + } + case GrepEvent::GrepPS_SubCreateRef: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::PSCoord: FAILED to Created subscription using" + " (subId=%d,SubKey=%d)in primary system." + " Error code: %d Error Message: %s", + subId, + subKey, + err, + GrepError::getErrorDesc((GrepError::Code)err)); + break; + } + case GrepEvent::GrepPS_SubStartMetaRef: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::PSCoord: Logging failed to start on meta " + "data changes." + " using (subId=%d,SubKey=%d)" + " Error code: %d Error Message: %s", + subId, + subKey, + err, + GrepError::getErrorDesc((GrepError::Code)err)); + break; + } + case GrepEvent::GrepPS_SubStartDataRef: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::PSCoord: Logging FAILED to start on table data " + " changes using (subId=%d,SubKey=%d)" + " Error code: %d Error Message: %s", + subId, + subKey, + err, + GrepError::getErrorDesc((GrepError::Code)err)); + break; + } + case GrepEvent::GrepPS_SubSyncMetaRef: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::PSCoord: Synchronization FAILED (META SCAN) on " + " meta data using (subId=%d,SubKey=%d)" + " Error code: %d Error Message: %s", + subId, + subKey, + err, + GrepError::getErrorDesc((GrepError::Code)err)); + break; + } + case GrepEvent::GrepPS_SubSyncDataRef: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + const int gci = theData[5]; + ::snprintf(m_text, sizeof(m_text), + "Grep::PSCoord: Synchronization FAILED (DATA SCAN) on " + "table data using (subId=%d,SubKey=%d). GCI = %d. " + " Error code: %d Error Message: %s", + subId, + subKey, + gci, + err, + GrepError::getErrorDesc((GrepError::Code)err)); + break; + } + case GrepEvent::GrepPS_SubRemoveRef: + { + const int subId = theData[2]; + const int subKey = theData[3]; + const int err = theData[4]; + ::snprintf(m_text, sizeof(m_text), + "Grep::PSCoord: Failed to remove subscription " + "(subId=%d,SubKey=%d)." + " Error code: %d Error Message: %s", + subId, + subKey, + err, + GrepError::getErrorDesc((GrepError::Code)err)); + break; + } + case GrepEvent::Rep_Disconnect: + { + const int err = theData[4]; + const int nodeId = theData[5]; + ::snprintf(m_text, sizeof(m_text), + "Rep: Node %d." + " Error code: %d Error Message: %s", + nodeId, + err, + GrepError::getErrorDesc((GrepError::Code)err)); + break; + } + + + default: + ::snprintf(m_text, + sizeof(m_text), + "%sUnknown GrepSubscriptionAlert event: %d", + theNodeId, + theData[1]); + break; + } + break; + } + + default: + ::snprintf(m_text, + sizeof(m_text), + "%sUnknown event: %d", + theNodeId, + theData[0]); + + } + return m_text; +} + +bool +EventLogger::matchEventCategory(const char * str, + LogLevel::EventCategory * cat, + bool exactMatch){ + if(cat == 0 || str == 0) + return false; + + char * tmp = strdup(str); + for(size_t i = 0; i + +/** + * Error descriptions. + */ + +const GrepError::ErrorDescription GrepError::errorDescriptions[] = { + { GrepError::NO_ERROR, + "No error" }, + { GrepError::SUBSCRIPTION_ID_NOMEM, + "Not enough resources to allocate the subscription" }, + { GrepError::SUBSCRIPTION_ID_NOT_FOUND, + "The requested subscription (id, key) does not exist"}, + { GrepError::SUBSCRIPTION_ID_NOT_UNIQUE, + "A subscription with (id, key) does already exist"}, + { GrepError::SUBSCRIPTION_ID_SUMA_FAILED_CREATE, + "Suma failed to create a new subscription id"}, + { GrepError::NULL_VALUE, + "NULL"}, + { GrepError::SEQUENCE_ERROR, + "Error when creating or using sequence."}, + { GrepError::NOSPACE_IN_POOL, + "No space left in pool when trying to seize data"}, + { GrepError::SUBSCRIPTION_ID_ALREADY_EXIST, + "A subscription for this replication channel does already exist"}, + { GrepError::SUBSCRIPTION_NOT_STARTED, + "No subscription is started"}, + { GrepError::SUBSCRIBER_NOT_FOUND, + "The subscriber does not exist in SUMA."}, + { GrepError::WRONG_NO_OF_SECTIONS, + "Something is wrong with the supplied arguments"}, + { GrepError::ILLEGAL_ACTION_WHEN_STOPPING, + "Action can not be performed while channel is in stopping state"}, + { GrepError::SELECTED_TABLE_NOT_FOUND, + "The selected table was not found. "}, + { GrepError::REP_APPLY_LOGRECORD_FAILED, + "Failed applying a log record (permanent error)"}, + { GrepError::REP_APPLY_METARECORD_FAILED, + "Failed applying a meta record (permanent error)"}, + { GrepError::REP_DELETE_NEGATIVE_EPOCH, + "Trying to delete a GCI Buffer using a negative epoch."}, + { GrepError::REP_DELETE_NONEXISTING_EPOCH, + "Trying to delete a non-existing GCI Buffer."}, + { GrepError::REP_NO_CONNECTED_NODES, + "There are no connected nodes in the node group."}, + { GrepError::REP_DISCONNECT, + "Global Replication Server disconnected."}, + { GrepError::COULD_NOT_ALLOCATE_MEM_FOR_SIGNAL, + "Could not allocate memory for signal."}, + { GrepError::REP_NOT_PROPER_TABLE, + "Specified table is not a valid table. " + "Either the format is not // or " + "the table name is too long "}, + { GrepError::REP_TABLE_ALREADY_SELECTED, + "The specified table is already selected for replication" }, + { GrepError::REP_TABLE_NOT_FOUND, + "The specified table was not found" }, + { GrepError::START_OF_COMPONENT_IN_WRONG_STATE, + "Component or protocol can not be started in the current state."}, + { GrepError::START_ALREADY_IN_PROGRESS, + "Start of replication protocol is already in progress."}, + { GrepError::ILLEGAL_STOP_EPOCH_ID, + "It is not possible to stop on the requested epoch id."}, + { GrepError::ILLEGAL_USE_OF_COMMAND, + "The command cannot be executed in this state."}, + { GrepError::CHANNEL_NOT_STOPPABLE, + "It is not possible to stop the in this state."}, + + /** + * Applier stuff + */ + { GrepError::REP_APPLY_NONCOMPLETE_GCIBUFFER, + "Applier: Ordered to apply an incomplete GCI Buffer."}, + { GrepError::REP_APPLY_NULL_GCIBUFFER, + "Applier: Tried to apply a NULL GCI Buffer."}, + { GrepError::REP_APPLIER_START_TRANSACTION, + "Applier: Could not start a transaction."}, + { GrepError::REP_APPLIER_NO_TABLE, + "Applier: Table does not exist"}, + { GrepError::REP_APPLIER_NO_OPERATION, + "Applier: Cannot get NdbOperation record."}, + { GrepError::REP_APPLIER_EXECUTE_TRANSACTION, + "Applier: Execute transaction failed."}, + { GrepError::REP_APPLIER_CREATE_TABLE, + "Applier: Create table failed."}, + { GrepError::REP_APPLIER_PREPARE_TABLE, + "Applier: Prepare table for create failed."}, + + { GrepError::NOT_YET_IMPLEMENTED, + "Command or event not yet implemented."} +}; + + + + + +const Uint32 +GrepError::noOfErrorDescs = sizeof(GrepError::errorDescriptions) / + sizeof(GrepError::ErrorDescription); + + +/** + * gets the corresponding error message to an err code + */ +const char * +GrepError::getErrorDesc(GrepError::Code err) { + + for(Uint32 i = 0; i + +const LogLevel::LogLevelCategoryName LogLevel::LOGLEVEL_CATEGORY_NAME[] = { + {"LogLevelStartup"}, + {"LogLevelShutdown"}, + {"LogLevelStatistic"}, + {"LogLevelCheckpoint"}, + {"LogLevelNodeRestart"}, + {"LogLevelConnection"}, + {"LogLevelError"}, + {"LogLevelInfo"}, + {"LogLevelGrep"} +}; diff --git a/ndb/src/common/debugger/Makefile b/ndb/src/common/debugger/Makefile new file mode 100644 index 00000000000..ac3a4475a54 --- /dev/null +++ b/ndb/src/common/debugger/Makefile @@ -0,0 +1,11 @@ +include .defs.mk + +TYPE := kernel +DIRS := signaldata + +PIC_ARCHIVE := Y +ARCHIVE_TARGET := trace + +SOURCES = SignalLoggerManager.cpp DebuggerNames.cpp BlockNames.cpp LogLevel.cpp EventLogger.cpp GrepError.cpp + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/common/debugger/SignalLoggerManager.cpp b/ndb/src/common/debugger/SignalLoggerManager.cpp new file mode 100644 index 00000000000..e51edbba169 --- /dev/null +++ b/ndb/src/common/debugger/SignalLoggerManager.cpp @@ -0,0 +1,513 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "SignalLoggerManager.hpp" +#include + +#include +#include +#include +#include +#include + +#include + +SignalLoggerManager::SignalLoggerManager() +{ + for (int i = 0; i < NO_OF_BLOCKS; i++){ + logModes[i] = 0; + } + outputStream = 0; +} + +SignalLoggerManager::~SignalLoggerManager() +{ + if(outputStream != 0){ + fflush(outputStream); + fclose(outputStream); + outputStream = 0; + } +} + +FILE * +SignalLoggerManager::setOutputStream(FILE * output) +{ + if(outputStream != 0){ + fflush(outputStream); + } + + FILE * out = outputStream; + outputStream = output; + return out; +} + +FILE * +SignalLoggerManager::getOutputStream() const +{ + return outputStream; +} + +void +SignalLoggerManager::flushSignalLog() +{ + if(outputStream != 0) + fflush(outputStream); +} + +void +SignalLoggerManager::setTrace(unsigned long trace) +{ + traceId = trace; +} + +unsigned long +SignalLoggerManager::getTrace() const +{ + return traceId; +} + +int +getParameter(char *blocks[NO_OF_BLOCKS], const char * par, const char * line) +{ + const char * loc = strstr(line, par); + if(loc == NULL) + return 0; + + loc += strlen(par); + + int found = 0; + + char * copy = strdup(loc); + char * tmp = copy; + bool done = false; + while(!done){ + int len = strcspn(tmp, ", ;:\0"); + if(len == 0) + done = true; + else { + if(* (tmp + len) != ',') + done = true; + * (tmp + len) = 0; + blocks[found] = strdup(tmp); + found ++; + tmp += (len + 1); + } + } + free(copy); + return found; +} + + +#define SLM_OFF 0 +#define SLM_ON 1 +#define SLM_TOGGLE 2 + +int +SignalLoggerManager::log(LogMode logMode, const char * params) +{ + char * blocks[NO_OF_BLOCKS]; + const int count = getParameter(blocks, "BLOCK=", params); + + int cnt = 0; + if((count == 1 && blocks[0] == "ALL") || + count == 0){ + + for (int number = 0; number < NO_OF_BLOCKS; ++number){ + cnt += log(SLM_ON, number, logMode); + } + } else { + for (int i = 0; i < count; ++i){ + BlockNumber number = getBlockNo(blocks[i]); + cnt += log(SLM_ON, number-MIN_BLOCK_NO, logMode); + } + } + for(int i = 0; i= 7){ + fprintf(output, + " H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x\n", + signalData[0], signalData[1], signalData[2], signalData[3], + signalData[4], signalData[5], signalData[6]); + len -= 7; + signalData += 7; + } + if(len > 0){ + for(Uint32 i = 0; i= 3) { + fprintf(output, " *** invalid ***\n"); + return; + } + const Uint32 len = ptr[i].sz; + const Uint32 * data = ptr[i].p; + Uint32 pos = 0; + fprintf(output, " size=%u\n", (unsigned)len); + while (pos < len) { + printDataWord(output, pos, data[pos]); + } + if (len > 0) + putc('\n', output); +} + +void +SignalLoggerManager::printSegmentedSection(FILE * output, + const SignalHeader & sh, + const SegmentedSectionPtr ptr[3], + unsigned i) +{ + fprintf(output, "SECTION %u type=segmented", i); + if (i >= 3) { + fprintf(output, " *** invalid ***\n"); + return; + } + const Uint32 len = ptr[i].sz; + SectionSegment * ssp = ptr[i].p; + Uint32 pos = 0; + fprintf(output, " size=%u\n", (unsigned)len); + while (pos < len) { + if (pos > 0 && pos % SectionSegment::DataLength == 0) { + ssp = g_sectionSegmentPool.getPtr(ssp->m_nextSegment); + } + printDataWord(output, pos, ssp->theData[pos % SectionSegment::DataLength]); + } + if (len > 0) + putc('\n', output); +} + +void +SignalLoggerManager::printDataWord(FILE * output, Uint32 & pos, const Uint32 data) +{ + const char* const hex = "0123456789abcdef"; + if (pos > 0 && pos % 7 == 0) + putc('\n', output); + putc(' ', output); + putc('H', output); + putc('\'', output); + for (int i = 7; i >= 0; i--) + putc(hex[(data >> (i << 2)) & 0xf], output); + pos++; +} diff --git a/ndb/src/common/debugger/signaldata/AccLock.cpp b/ndb/src/common/debugger/signaldata/AccLock.cpp new file mode 100644 index 00000000000..affed431957 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/AccLock.cpp @@ -0,0 +1,75 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include + +bool +printACC_LOCKREQ(FILE* output, const Uint32* theData, Uint32 len, Uint16 rbn) +{ + const AccLockReq* const sig = (const AccLockReq*)theData; + Uint32 reqtype = sig->requestInfo & 0xFF; + switch (sig->returnCode) { + case RNIL: + fprintf(output, " returnCode=RNIL"); + break; + case AccLockReq::Success: + fprintf(output, " returnCode=Success"); + break; + case AccLockReq::IsBlocked: + fprintf(output, " returnCode=IsBlocked"); + break; + case AccLockReq::WouldBlock: + fprintf(output, " returnCode=WouldBlock"); + break; + case AccLockReq::Refused: + fprintf(output, " returnCode=Refused"); + break; + case AccLockReq::NoFreeOp: + fprintf(output, " returnCode=NoFreeOp"); + break; + default: + fprintf(output, " returnCode=%u?", sig->returnCode); + break; + } + switch (reqtype) { + case AccLockReq::LockShared: + fprintf(output, " req=LockShared\n"); + break; + case AccLockReq::LockExclusive: + fprintf(output, " req=LockExclusive\n"); + break; + case AccLockReq::Unlock: + fprintf(output, " req=Unlock\n"); + break; + case AccLockReq::Abort: + fprintf(output, " req=Abort\n"); + break; + default: + fprintf(output, " req=%u\n", reqtype); + break; + } + fprintf(output, " accOpPtr: 0x%x\n", sig->accOpPtr); + if (reqtype == AccLockReq::LockShared || + reqtype == AccLockReq::LockExclusive) { + fprintf(output, " userPtr: 0x%x userRef: 0x%x\n", sig->userPtr, sig->userRef); + fprintf(output, " table: id=%u", sig->tableId); + fprintf(output, " fragment: id=%u ptr=0x%x\n", sig->fragId, sig->fragPtrI); + fprintf(output, " tuple: addr=0x%x hashValue=%x\n", sig->tupAddr, sig->hashValue); + fprintf(output, " transid: %08x %08x\n", sig->transId1, sig->transId2); + } + return true; +} diff --git a/ndb/src/common/debugger/signaldata/AlterIndx.cpp b/ndb/src/common/debugger/signaldata/AlterIndx.cpp new file mode 100644 index 00000000000..e1865136fc3 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/AlterIndx.cpp @@ -0,0 +1,35 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool printALTER_INDX_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const AlterIndxReq * const sig = (AlterIndxReq *) theData; + return false; +} + +bool printALTER_INDX_CONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const AlterIndxConf * const sig = (AlterIndxConf *) theData; + return false; +} + +bool printALTER_INDX_REF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const AlterIndxRef * const sig = (AlterIndxRef *) theData; + return false; +} diff --git a/ndb/src/common/debugger/signaldata/AlterTab.cpp b/ndb/src/common/debugger/signaldata/AlterTab.cpp new file mode 100644 index 00000000000..f9521984095 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/AlterTab.cpp @@ -0,0 +1,38 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool printALTER_TAB_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const AlterTabReq * const sig = (AlterTabReq *) theData; + + return false; +} + +bool printALTER_TAB_CONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const AlterTabConf * const sig = (AlterTabConf *) theData; + + return false; +} + +bool printALTER_TAB_REF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const AlterTabRef * const sig = (AlterTabRef *) theData; + + return false; +} diff --git a/ndb/src/common/debugger/signaldata/AlterTable.cpp b/ndb/src/common/debugger/signaldata/AlterTable.cpp new file mode 100644 index 00000000000..59909c8e490 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/AlterTable.cpp @@ -0,0 +1,38 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool printALTER_TABLE_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const AlterTableReq * const sig = (AlterTableReq *) theData; + + return false; +} + +bool printALTER_TABLE_CONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const AlterTableConf * const sig = (AlterTableConf *) theData; + + return false; +} + +bool printALTER_TABLE_REF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const AlterTableRef * const sig = (AlterTableRef *) theData; + + return false; +} diff --git a/ndb/src/common/debugger/signaldata/AlterTrig.cpp b/ndb/src/common/debugger/signaldata/AlterTrig.cpp new file mode 100644 index 00000000000..d488fd6e348 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/AlterTrig.cpp @@ -0,0 +1,51 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool printALTER_TRIG_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ + const AlterTrigReq * const sig = (AlterTrigReq *) theData; + + fprintf(output, "User: %u, ", sig->getUserRef()); + fprintf(output, "Trigger id: %u, ", sig->getTriggerId()); + fprintf(output, "\n"); + + return false; +} + +bool printALTER_TRIG_CONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ + const AlterTrigConf * const sig = (AlterTrigConf *) theData; + + fprintf(output, "User: %u, ", sig->getUserRef()); + fprintf(output, "Trigger id: %u, ", sig->getTriggerId()); + fprintf(output, "\n"); + + return false; +} + +bool printALTER_TRIG_REF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ + const AlterTrigRef * const sig = (AlterTrigRef *) theData; + + fprintf(output, "User: %u, ", sig->getUserRef()); + fprintf(output, "Trigger id: %u, ", sig->getTriggerId()); + fprintf(output, "Error code: %u, ", sig->getErrorCode()); + fprintf(output, "\n"); + + return false; +} diff --git a/ndb/src/common/debugger/signaldata/BackupImpl.cpp b/ndb/src/common/debugger/signaldata/BackupImpl.cpp new file mode 100644 index 00000000000..be9e43e3df1 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/BackupImpl.cpp @@ -0,0 +1,142 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include + +bool +printDEFINE_BACKUP_REQ(FILE * out, const Uint32 * data, Uint32 len, Uint16 bno){ + DefineBackupReq* sig = (DefineBackupReq*)data; + fprintf(out, " backupPtr: %d backupId: %d clientRef: %d clientData: %d\n", + sig->backupPtr, sig->backupId, sig->clientRef, sig->clientData); + fprintf(out, " backupKey: [ %08x%08x ] DataLength: %d\n", + sig->backupKey[0], sig->backupKey[1], sig->backupDataLen); + char buf[sig->nodes.TextLength + 1]; + fprintf(out, " Nodes: %s\n", sig->nodes.getText(buf)); + return true; +} + +bool +printDEFINE_BACKUP_REF(FILE * out, const Uint32 * data, Uint32 len, Uint16 bno){ + DefineBackupRef* sig = (DefineBackupRef*)data; + fprintf(out, " backupPtr: %d backupId: %d errorCode: %d\n", + sig->backupPtr, sig->backupId, sig->errorCode); + return true; +} + +bool +printDEFINE_BACKUP_CONF(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){ + DefineBackupConf* sig = (DefineBackupConf*)data; + fprintf(out, " backupPtr: %d backupId: %d\n", + sig->backupPtr, sig->backupId); + return true; +} + +bool +printSTART_BACKUP_REQ(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){ + StartBackupReq* sig = (StartBackupReq*)data; + fprintf(out, " backupPtr: %d backupId: %d signalNo: %d of %d\n", + sig->backupPtr, sig->backupId, + sig->signalNo + 1, sig->noOfSignals); + for(Uint32 i = 0; inoOfTableTriggers; i++) + fprintf(out, + " Table: %d Triggers = [ insert: %d update: %d delete: %d ]\n", + sig->tableTriggers[i].tableId, + sig->tableTriggers[i].triggerIds[TriggerEvent::TE_INSERT], + sig->tableTriggers[i].triggerIds[TriggerEvent::TE_UPDATE], + sig->tableTriggers[i].triggerIds[TriggerEvent::TE_DELETE]); + return true; +} + +bool +printSTART_BACKUP_REF(FILE * out, const Uint32 * data, Uint32 len, Uint16 bno){ + StartBackupRef* sig = (StartBackupRef*)data; + fprintf(out, " backupPtr: %d backupId: %d errorCode: %d\n", + sig->backupPtr, sig->backupId, sig->errorCode); + return true; +} + +bool +printSTART_BACKUP_CONF(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){ + StartBackupConf* sig = (StartBackupConf*)data; + fprintf(out, " backupPtr: %d backupId: %d\n", + sig->backupPtr, sig->backupId); + return true; +} + +bool +printBACKUP_FRAGMENT_REQ(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){ + BackupFragmentReq* sig = (BackupFragmentReq*)data; + fprintf(out, " backupPtr: %d backupId: %d\n", + sig->backupPtr, sig->backupId); + fprintf(out, " tableId: %d fragmentNo: %d (count = %d)\n", + sig->tableId, sig->fragmentNo, sig->count); + return true; +} + +bool +printBACKUP_FRAGMENT_REF(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){ + BackupFragmentRef* sig = (BackupFragmentRef*)data; + fprintf(out, " backupPtr: %d backupId: %d\n", + sig->backupPtr, sig->backupId); + fprintf(out, " tableId: %d fragmentNo: %d errorCode: %d\n", + sig->tableId, sig->fragmentNo, sig->errorCode); + return true; +} + +bool +printBACKUP_FRAGMENT_CONF(FILE * out, const Uint32 * data, Uint32 l, Uint16 b){ + BackupFragmentConf* sig = (BackupFragmentConf*)data; + fprintf(out, " backupPtr: %d backupId: %d\n", + sig->backupPtr, sig->backupId); + fprintf(out, " tableId: %d fragmentNo: %d records: %d bytes: %d\n", + sig->tableId, sig->fragmentNo, sig->noOfRecords, sig->noOfBytes); + return true; +} + +bool +printSTOP_BACKUP_REQ(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){ + StopBackupReq* sig = (StopBackupReq*)data; + fprintf(out, " backupPtr: %d backupId: %d\n", + sig->backupPtr, sig->backupId); + return true; +} + +bool +printSTOP_BACKUP_REF(FILE * out, const Uint32 * data, Uint32 len, Uint16 bno){ + StopBackupRef* sig = (StopBackupRef*)data; + fprintf(out, " backupPtr: %d backupId: %d errorCode: %d\n", + sig->backupPtr, sig->backupId, sig->errorCode); + return true; +} + +bool +printSTOP_BACKUP_CONF(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){ + StopBackupConf* sig = (StopBackupConf*)data; + fprintf(out, " backupPtr: %d backupId: %d\n", + sig->backupPtr, sig->backupId); + return true; +} + +bool +printBACKUP_STATUS_REQ(FILE *, const Uint32 *, Uint32, Uint16){ + return false; +} + +bool +printBACKUP_STATUS_CONF(FILE *, const Uint32 *, Uint32, Uint16){ + return false; +} diff --git a/ndb/src/common/debugger/signaldata/BackupSignalData.cpp b/ndb/src/common/debugger/signaldata/BackupSignalData.cpp new file mode 100644 index 00000000000..4b0a0e07b66 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/BackupSignalData.cpp @@ -0,0 +1,129 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include + +bool +printBACKUP_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 bno){ + BackupReq* sig = (BackupReq*)theData; + fprintf(output, " senderData: %d DataLength: %d\n", + sig->senderData, + sig->backupDataLen); + return true; +} + +bool +printBACKUP_DATA(FILE * output, const Uint32 * theData, Uint32 len, Uint16 bno){ + BackupData * sig = (BackupData*)theData; + if(sig->requestType == BackupData::ClientToMaster){ + fprintf(output, " ClientToMaster: senderData: %d backupId: %d\n", + sig->senderData, sig->backupId); + } else if(sig->requestType == BackupData::MasterToSlave){ + fprintf(output, " MasterToSlave: backupPtr: %d backupId: %d\n", + sig->backupPtr, sig->backupId); + } + return false; +} + +bool +printBACKUP_REF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 bno){ + + BackupRef* sig = (BackupRef*)theData; + fprintf(output, " senderData: %d errorCode: %d masterRef: %d\n", + sig->senderData, + sig->errorCode, + sig->masterRef); + return true; +} + +bool +printBACKUP_CONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 bno){ + BackupConf* sig = (BackupConf*)theData; + fprintf(output, " senderData: %d backupId: %d\n", + sig->senderData, + sig->backupId); + return true; +} + +bool +printBACKUP_ABORT_REP(FILE * out, const Uint32 * data, Uint32 len, Uint16 bno){ + BackupAbortRep* sig = (BackupAbortRep*)data; + fprintf(out, " senderData: %d backupId: %d reason: %d\n", + sig->senderData, + sig->backupId, + sig->reason); + return true; +} + +bool +printBACKUP_COMPLETE_REP(FILE * out, const Uint32 * data, Uint32 len, Uint16 b){ + BackupCompleteRep* sig = (BackupCompleteRep*)data; + fprintf(out, " senderData: %d backupId: %d records: %d bytes: %d\n", + sig->senderData, + sig->backupId, + sig->noOfRecords, + sig->noOfBytes); + return true; +} + +bool +printBACKUP_NF_COMPLETE_REP(FILE*, const Uint32*, Uint32, Uint16){ + return false; +} + +bool +printABORT_BACKUP_ORD(FILE * out, const Uint32 * data, Uint32 len, Uint16 b){ + AbortBackupOrd* sig = (AbortBackupOrd*)data; + + AbortBackupOrd::RequestType rt =(AbortBackupOrd::RequestType)sig->requestType; + switch(rt){ + case AbortBackupOrd::ClientAbort: + fprintf(out, " ClientAbort: senderData: %d backupId: %d\n", + sig->senderData, sig->backupId); + return true; + break; + case AbortBackupOrd::BackupComplete: + fprintf(out, " BackupComplete: backupPtr: %d backupId: %d\n", + sig->backupPtr, sig->backupId); + return true; + case AbortBackupOrd::BackupFailure: + fprintf(out, " BackupFailure: backupPtr: %d backupId: %d\n", + sig->backupPtr, sig->backupId); + return true; + case AbortBackupOrd::LogBufferFull: + fprintf(out, " LogBufferFull: backupPtr: %d backupId: %d\n", + sig->backupPtr, sig->backupId); + return true; + break; + case AbortBackupOrd::FileOrScanError: + fprintf(out, " FileOrScanError: backupPtr: %d backupId: %d\n", + sig->backupPtr, sig->backupId); + return true; + break; + case AbortBackupOrd::BackupFailureDueToNodeFail: + fprintf(out, " BackupFailureDueToNodeFail: backupPtr: %d backupId: %d\n", + sig->backupPtr, sig->backupId); + return true; + break; + case AbortBackupOrd::OkToClean: + fprintf(out, " OkToClean: backupPtr: %d backupId: %d\n", + sig->backupPtr, sig->backupId); + return true; + break; + } + return false; +} diff --git a/ndb/src/common/debugger/signaldata/CloseComReqConf.cpp b/ndb/src/common/debugger/signaldata/CloseComReqConf.cpp new file mode 100644 index 00000000000..11ee0948c17 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/CloseComReqConf.cpp @@ -0,0 +1,53 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include +#include + +bool +printCLOSECOMREQCONF(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 receiverBlockNo){ + + CloseComReqConf * cc = (CloseComReqConf*)theData; + + fprintf(output, " xxxBlockRef = (%d, %d) failNo = %d noOfNodes = %d\n", + refToBlock(cc->xxxBlockRef), refToNode(cc->xxxBlockRef), + cc->failNo, cc->noOfNodes); + + int hits = 0; + fprintf(output, " Nodes: "); + for(int i = 0; itheNodes, i)){ + hits++; + fprintf(output, " %d", i); + } + if(hits == 16){ + fprintf(output, "\n Nodes: "); + hits = 0; + } + } + if(hits != 0) + fprintf(output, "\n"); + + return true; +} + + diff --git a/ndb/src/common/debugger/signaldata/ContinueB.cpp b/ndb/src/common/debugger/signaldata/ContinueB.cpp new file mode 100644 index 00000000000..054909d961e --- /dev/null +++ b/ndb/src/common/debugger/signaldata/ContinueB.cpp @@ -0,0 +1,36 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include +#include +#include + +bool +printCONTINUEB(FILE * output, const Uint32 * theData, Uint32 len, + Uint16 receiverBlockNo){ + if(receiverBlockNo == DBDIH){ + return printCONTINUEB_DBDIH(output, theData, len); + } else if(receiverBlockNo == NDBFS) { + return printCONTINUEB_NDBFS(output, theData, len); + } + + return false; +} + + diff --git a/ndb/src/common/debugger/signaldata/CopyGCI.cpp b/ndb/src/common/debugger/signaldata/CopyGCI.cpp new file mode 100644 index 00000000000..96186e82525 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/CopyGCI.cpp @@ -0,0 +1,58 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +static +void +print(char * buf, size_t buf_len, CopyGCIReq::CopyReason r){ + switch(r){ + case CopyGCIReq::IDLE: + snprintf(buf, buf_len, "IDLE"); + break; + case CopyGCIReq::LOCAL_CHECKPOINT: + snprintf(buf, buf_len, "LOCAL_CHECKPOINT"); + break; + case CopyGCIReq::RESTART: + snprintf(buf, buf_len, "RESTART"); + break; + case CopyGCIReq::GLOBAL_CHECKPOINT: + snprintf(buf, buf_len, "GLOBAL_CHECKPOINT"); + break; + case CopyGCIReq::INITIAL_START_COMPLETED: + snprintf(buf, buf_len, "INITIAL_START_COMPLETED"); + break; + default: + snprintf(buf, buf_len, ""); + } +} + +bool +printCOPY_GCI_REQ(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 recBlockNo){ + CopyGCIReq * sig = (CopyGCIReq*)theData; + + static char buf[255]; + print(buf, sizeof(buf), (CopyGCIReq::CopyReason)sig->copyReason); + + fprintf(output, " SenderData: %d CopyReason: %s StartWord: %d\n", + sig->anyData, + buf, + sig->startWord); + return false; +} diff --git a/ndb/src/common/debugger/signaldata/CreateEvnt.cpp b/ndb/src/common/debugger/signaldata/CreateEvnt.cpp new file mode 100644 index 00000000000..7b497d6a974 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/CreateEvnt.cpp @@ -0,0 +1,38 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool printCREATE_EVNT_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const CreateEvntReq * const sig = (CreateEvntReq *) theData; + + return false; +} + +bool printCREATE_EVNT_CONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const CreateEvntConf * const sig = (CreateEvntConf *) theData; + + return false; +} + +bool printCREATE_EVNT_REF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const CreateEvntRef * const sig = (CreateEvntRef *) theData; + + return false; +} diff --git a/ndb/src/common/debugger/signaldata/CreateFragmentation.cpp b/ndb/src/common/debugger/signaldata/CreateFragmentation.cpp new file mode 100644 index 00000000000..6685345f17a --- /dev/null +++ b/ndb/src/common/debugger/signaldata/CreateFragmentation.cpp @@ -0,0 +1,56 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printCREATE_FRAGMENTATION_REQ(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const CreateFragmentationReq * const sig = (CreateFragmentationReq *)theData; + fprintf(output, " senderRef: %x\n", sig->senderRef); + fprintf(output, " senderData: %x\n", sig->senderData); + fprintf(output, " fragmentationType: %x\n", sig->fragmentationType); + fprintf(output, " noOfFragments: %x\n", sig->noOfFragments); + fprintf(output, " fragmentNode: %x\n", sig->fragmentNode); + if (sig->primaryTableId == RNIL) + fprintf(output, " primaryTableId: none\n", sig->primaryTableId); + else + fprintf(output, " primaryTableId: %x\n", sig->primaryTableId); + return true; +} + +bool +printCREATE_FRAGMENTATION_REF(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const CreateFragmentationRef * const sig = (CreateFragmentationRef *)theData; + fprintf(output, " senderRef: %x\n", sig->senderRef); + fprintf(output, " senderData: %x\n", sig->senderData); + fprintf(output, " errorCode: %x\n", sig->errorCode); + return true; +} + +bool +printCREATE_FRAGMENTATION_CONF(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const CreateFragmentationConf * const sig = + (CreateFragmentationConf *)theData; + fprintf(output, " senderRef: %x\n", sig->senderRef); + fprintf(output, " senderData: %x\n", sig->senderData); + fprintf(output, " noOfReplicas: %x\n", sig->noOfReplicas); + fprintf(output, " noOfFragments: %x\n", sig->noOfFragments); + return true; +} + diff --git a/ndb/src/common/debugger/signaldata/CreateIndx.cpp b/ndb/src/common/debugger/signaldata/CreateIndx.cpp new file mode 100644 index 00000000000..8fcbb9279ed --- /dev/null +++ b/ndb/src/common/debugger/signaldata/CreateIndx.cpp @@ -0,0 +1,38 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool printCREATE_INDX_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const CreateIndxReq * const sig = (CreateIndxReq *) theData; + + return false; +} + +bool printCREATE_INDX_CONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const CreateIndxConf * const sig = (CreateIndxConf *) theData; + + return false; +} + +bool printCREATE_INDX_REF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const CreateIndxRef * const sig = (CreateIndxRef *) theData; + + return false; +} diff --git a/ndb/src/common/debugger/signaldata/CreateTrig.cpp b/ndb/src/common/debugger/signaldata/CreateTrig.cpp new file mode 100644 index 00000000000..d8360dec4d5 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/CreateTrig.cpp @@ -0,0 +1,120 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool printCREATE_TRIG_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ + const CreateTrigReq * const sig = (CreateTrigReq *) theData; + + //char triggerName[MAX_TAB_NAME_SIZE]; + char triggerType[32]; + char triggerActionTime[32]; + char triggerEvent[32]; + + //sig->getTriggerName((char *) &triggerName); + switch (sig->getTriggerType()) { + case(TriggerType::SECONDARY_INDEX): + snprintf(triggerType, sizeof(triggerType), "SECONDARY_INDEX"); + break; + case(TriggerType::SUBSCRIPTION): + snprintf(triggerType, sizeof(triggerType), "SUBSCRIPTION"); + break; + case(TriggerType::ORDERED_INDEX): + snprintf(triggerType, sizeof(triggerType), "ORDERED_INDEX"); + break; + default: + snprintf(triggerType, sizeof(triggerType), "UNKNOWN [%d]", (int)sig->getTriggerType()); + break; + } + switch (sig->getTriggerActionTime()) { + case (TriggerActionTime::TA_BEFORE): + snprintf(triggerActionTime, sizeof(triggerActionTime), "BEFORE"); + break; + case(TriggerActionTime::TA_AFTER): + snprintf(triggerActionTime, sizeof(triggerActionTime), "AFTER"); + break; + case (TriggerActionTime::TA_DEFERRED): + snprintf(triggerActionTime, sizeof(triggerActionTime), "DEFERRED"); + break; + case (TriggerActionTime::TA_DETACHED): + snprintf(triggerActionTime, sizeof(triggerActionTime), "DETACHED"); + break; + default: + snprintf(triggerActionTime, sizeof(triggerActionTime), + "UNKNOWN [%d]", (int)sig->getTriggerActionTime()); + break; + } + switch (sig->getTriggerEvent()) { + case (TriggerEvent::TE_INSERT): + snprintf(triggerEvent, sizeof(triggerEvent), "INSERT"); + break; + case(TriggerEvent::TE_DELETE): + snprintf(triggerEvent, sizeof(triggerEvent), "DELETE"); + break; + case(TriggerEvent::TE_UPDATE): + snprintf(triggerEvent, sizeof(triggerEvent), "UPDATE"); + break; + case(TriggerEvent::TE_CUSTOM): + snprintf(triggerEvent, sizeof(triggerEvent), "CUSTOM"); + break; + default: + snprintf(triggerEvent, sizeof(triggerEvent), "UNKNOWN [%d]", (int)sig->getTriggerEvent()); + break; + } + + fprintf(output, "User: %u, ", sig->getUserRef()); + //fprintf(output, "Trigger name: \"%s\"\n", triggerName); + fprintf(output, "Type: %s, ", triggerType); + fprintf(output, "Action: %s, ", triggerActionTime); + fprintf(output, "Event: %s, ", triggerEvent); + fprintf(output, "Trigger id: %u, ", sig->getTriggerId()); + fprintf(output, "Table id: %u, ", sig->getTableId()); + fprintf(output, "Monitor replicas: %s ", (sig->getMonitorReplicas())?"true":"false"); + fprintf(output, "Monitor all attributes: %s ", (sig->getMonitorAllAttributes())?"true":"false"); + const AttributeMask& attributeMask = sig->getAttributeMask(); + + char buf[attributeMask.TextLength + 1]; + fprintf(output, "Attribute mask: %s", attributeMask.getText(buf)); + fprintf(output, "\n"); + + return false; +} + +bool printCREATE_TRIG_CONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ + const CreateTrigConf * const sig = (CreateTrigConf *) theData; + + fprintf(output, "User: %u, ", sig->getUserRef()); + fprintf(output, "Trigger id: %u, ", sig->getTriggerId()); + fprintf(output, "Table id: %u, ", sig->getTableId()); + fprintf(output, "\n"); + + return false; +} + +bool printCREATE_TRIG_REF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ + const CreateTrigRef * const sig = (CreateTrigRef *) theData; + + fprintf(output, "User: %u, ", sig->getUserRef()); + fprintf(output, "Trigger id: %u, ", sig->getTriggerId()); + fprintf(output, "Table id: %u, ", sig->getTableId()); + fprintf(output, "Error code: %u, ", sig->getErrorCode()); + fprintf(output, "\n"); + + return false; +} diff --git a/ndb/src/common/debugger/signaldata/DictTabInfo.cpp b/ndb/src/common/debugger/signaldata/DictTabInfo.cpp new file mode 100644 index 00000000000..a0e0195adad --- /dev/null +++ b/ndb/src/common/debugger/signaldata/DictTabInfo.cpp @@ -0,0 +1,153 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include + +//static +const +SimpleProperties::SP2StructMapping +DictTabInfo::TableMapping[] = { + DTIMAPS(Table, TableName, TableName, 0, MAX_TAB_NAME_SIZE), + DTIMAP(Table, TableId, TableId), + DTIMAP(Table, SecondTableId, SecondTableId), + DTIMAPS(Table, PrimaryTable, PrimaryTable, 0, MAX_TAB_NAME_SIZE), + DTIMAP(Table, PrimaryTableId, PrimaryTableId), + DTIMAP2(Table, TableLoggedFlag, TableLoggedFlag, 0, 1), + DTIMAP2(Table, TableKValue, TableKValue, 6, 6), + DTIMAP2(Table, MinLoadFactor, MinLoadFactor, 0, 90), + DTIMAP2(Table, MaxLoadFactor, MaxLoadFactor, 25, 110), + DTIMAP2(Table, FragmentTypeVal, FragmentType, 0, 3), + DTIMAP2(Table, TableStorageVal, TableStorage, 0, 0), + DTIMAP2(Table, ScanOptimised, ScanOptimised, 0, 0), + DTIMAP2(Table, FragmentKeyTypeVal, FragmentKeyType, 0, 2), + DTIMAP2(Table, TableTypeVal, TableType, 1, 3), + DTIMAP(Table, NoOfKeyAttr, NoOfKeyAttr), + DTIMAP2(Table, NoOfAttributes, NoOfAttributes, 1, MAX_ATTRIBUTES_IN_TABLE), + DTIMAP(Table, NoOfNullable, NoOfNullable), + DTIMAP2(Table, NoOfVariable, NoOfVariable, 0, 0), + DTIMAP(Table, KeyLength, KeyLength), + DTIMAP(Table, TableVersion, TableVersion), + DTIMAP(Table, IndexState, IndexState), + DTIMAP(Table, InsertTriggerId, InsertTriggerId), + DTIMAP(Table, UpdateTriggerId, UpdateTriggerId), + DTIMAP(Table, DeleteTriggerId, DeleteTriggerId), + DTIMAP(Table, CustomTriggerId, CustomTriggerId), + DTIMAP2(Table, FrmLen, FrmLen, 0, MAX_FRM_DATA_SIZE), + DTIMAPB(Table, FrmData, FrmData, 0, MAX_FRM_DATA_SIZE, FrmLen), + DTIBREAK(AttributeName) +}; + +//static +const Uint32 DictTabInfo::TableMappingSize = +sizeof(DictTabInfo::TableMapping) / sizeof(SimpleProperties::SP2StructMapping); + +//static +const +SimpleProperties::SP2StructMapping +DictTabInfo::AttributeMapping[] = { + DTIMAPS(Attribute, AttributeName, AttributeName, 0, MAX_ATTR_NAME_SIZE), + DTIMAP(Attribute, AttributeId, AttributeId), + DTIMAP2(Attribute, AttributeType, AttributeType, 0, 3), + DTIMAP2(Attribute, AttributeSize, AttributeSize, 3, 7), + DTIMAP2(Attribute, AttributeArraySize, AttributeArraySize, 0, 65535), + DTIMAP2(Attribute, AttributeKeyFlag, AttributeKeyFlag, 0, 1), + DTIMAP2(Attribute, AttributeStorage, AttributeStorage, 0, 0), + DTIMAP2(Attribute, AttributeNullableFlag, AttributeNullableFlag, 0, 1), + DTIMAP2(Attribute, AttributeDGroup, AttributeDGroup, 0, 1), + DTIMAP2(Attribute, AttributeDKey, AttributeDKey, 0, 1), + DTIMAP2(Attribute, AttributeStoredInd, AttributeStoredInd, 0, 1), + DTIMAP2(Attribute, AttributeGroup, AttributeGroup, 0, 0), + DTIMAP(Attribute, AttributeExtType, AttributeExtType), + DTIMAP(Attribute, AttributeExtPrecision, AttributeExtPrecision), + DTIMAP(Attribute, AttributeExtScale, AttributeExtScale), + DTIMAP(Attribute, AttributeExtLength, AttributeExtLength), + DTIMAP2(Attribute, AttributeAutoIncrement, AttributeAutoIncrement, 0, 1), + DTIMAPS(Attribute, AttributeDefaultValue, AttributeDefaultValue, + 0, MAX_ATTR_DEFAULT_VALUE_SIZE), + DTIBREAK(AttributeEnd) +}; + +//static +const Uint32 DictTabInfo::AttributeMappingSize = +sizeof(DictTabInfo::AttributeMapping) / +sizeof(SimpleProperties::SP2StructMapping); + +bool printDICTTABINFO(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) +{ +// const DictTabInfo * const sig = (DictTabInfo *) theData; + + fprintf(output, "Signal data: "); + Uint32 i = 0; + while (i < len) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + return true; +} + +void +DictTabInfo::Table::init(){ + memset(TableName, 0, sizeof(TableName));//TableName[0] = 0; + TableId = ~0; + SecondTableId = ~0; + memset(PrimaryTable, 0, sizeof(PrimaryTable));//PrimaryTable[0] = 0; // Only used when "index" + PrimaryTableId = RNIL; + TableLoggedFlag = 1; + NoOfKeyAttr = 0; + NoOfAttributes = 0; + NoOfNullable = 0; + NoOfVariable = 0; + TableKValue = 6; + MinLoadFactor = 78; + MaxLoadFactor = 80; + KeyLength = 0; + FragmentType = DictTabInfo::AllNodesSmallTable; + TableStorage = 0; + ScanOptimised = 0; + FragmentKeyType = DictTabInfo::PrimaryKey; + TableType = DictTabInfo::UndefTableType; + TableVersion = 0; + IndexState = ~0; + InsertTriggerId = RNIL; + UpdateTriggerId = RNIL; + DeleteTriggerId = RNIL; + CustomTriggerId = RNIL; + FrmLen = 0; + memset(FrmData, 0, sizeof(FrmData)); +} + +void +DictTabInfo::Attribute::init(){ + memset(AttributeName, 0, sizeof(AttributeName));//AttributeName[0] = 0; + AttributeId = 0; + AttributeType = DictTabInfo::UnSignedType; + AttributeSize = DictTabInfo::a32Bit; + AttributeArraySize = 1; + AttributeKeyFlag = 0; + AttributeStorage = 1; + AttributeNullableFlag = 0; + AttributeDGroup = 0; + AttributeDKey = 0; + AttributeStoredInd = 1; + AttributeGroup = 0; + AttributeExtType = 0, + AttributeExtPrecision = 0, + AttributeExtScale = 0, + AttributeExtLength = 0, + AttributeAutoIncrement = false; + memset(AttributeDefaultValue, 0, sizeof(AttributeDefaultValue));//AttributeDefaultValue[0] = 0; +}; diff --git a/ndb/src/common/debugger/signaldata/DihContinueB.cpp b/ndb/src/common/debugger/signaldata/DihContinueB.cpp new file mode 100644 index 00000000000..94453e76d72 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/DihContinueB.cpp @@ -0,0 +1,217 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include + +bool +printCONTINUEB_DBDIH(FILE * output, const Uint32 * theData, Uint32 len){ + + switch (theData[0]) { + case DihContinueB::ZPACK_TABLE_INTO_PAGES: + fprintf(output, " Pack Table Into Pages: %d\n", theData[1]); + return true; + break; + case DihContinueB::ZPACK_FRAG_INTO_PAGES: + fprintf(output, " Pack Frag Into Pages: Table: %d Fragment: %d PageIndex: %d WordIndex: %d\n", + theData[1], theData[2], theData[3], theData[4]); + return true; + break; + case DihContinueB::ZREAD_PAGES_INTO_TABLE: + fprintf(output, " Read Pages Into Table: %d\n", theData[1]); + return true; + break; + case DihContinueB::ZREAD_PAGES_INTO_FRAG: + fprintf(output, " Read Pages Into Frag: Table: %d Fragment: %d PageIndex: %d WordIndex: %d\n", + theData[1], theData[2], theData[3], theData[4]); + return true; + break; +#if 0 + case DihContinueB::ZREAD_TAB_DESCRIPTION: + fprintf(output, " Read Table description: %d\n", theData[1]); + return true; + break; +#endif + case DihContinueB::ZCOPY_TABLE: + fprintf(output, " Copy Table: %d\n", theData[1]); + return true; + break; + case DihContinueB::ZCOPY_TABLE_NODE: + fprintf(output, " Copy table node: TableId: %d NodeId: %d\n", + theData[1], theData[2]); + fprintf(output, "PageIndex: %d WordIndex: %d NoOfWords: %d\n", + theData[3], theData[4], theData[5]); + return true; + break; + case DihContinueB::ZSTART_FRAGMENT: + fprintf(output, " Start fragment: Table: %d Fragment: %d\n", + theData[1], theData[2]); + return true; + break; + case DihContinueB::ZCOMPLETE_RESTART: + fprintf(output, "Complete Restart\n"); + return true; + break; + case DihContinueB::ZREAD_TABLE_FROM_PAGES: + fprintf(output, " Read Table From Pages: Table: %d\n", theData[1]); + return true; + break; + case DihContinueB::ZSR_PHASE2_READ_TABLE: + fprintf(output, " Phase 2 Read Table: Table: %d\n", theData[1]); + return true; + break; + case DihContinueB::ZCHECK_TC_COUNTER: + fprintf(output, " Check Tc Counter from place %d\n", theData[1]); + return true; + break; + case DihContinueB::ZCALCULATE_KEEP_GCI: + fprintf(output, " Calc Keep GCI: Table: %d Fragment: %d\n", + theData[1], theData[2]); + return true; + break; + case DihContinueB::ZSTORE_NEW_LCP_ID: + fprintf(output, " Store New LCP Id\n"); + return true; + break; + case DihContinueB::ZTABLE_UPDATE: + fprintf(output, " Table Update: Table: %d\n", theData[1]); + return true; + break; + case DihContinueB::ZCHECK_LCP_COMPLETED: + fprintf(output, " Check LCP Completed: TableId %d\n", theData[1]); + return true; + break; + case DihContinueB::ZINIT_LCP: + fprintf(output, " Init LCP: Table: %d\n", theData[1]); + return true; + break; + case DihContinueB::ZADD_TABLE_MASTER_PAGES: + fprintf(output, " Add Table Master Pages: Table: %d\n", theData[1]); + return true; + break; + case DihContinueB::ZDIH_ADD_TABLE_MASTER: + fprintf(output, " Dih Add Table Master: Table: %d\n", theData[1]); + return true; + break; + case DihContinueB::ZADD_TABLE_SLAVE_PAGES: + fprintf(output, " Add Table Slave Pages: Table: %d\n", theData[1]); + return true; + break; + case DihContinueB::ZDIH_ADD_TABLE_SLAVE: + fprintf(output, " Add Table Slave: Table: %d\n", theData[1]); + return true; + break; + case DihContinueB::ZSTART_GCP: + fprintf(output, " Start GCP\n"); + return true; + break; + case DihContinueB::ZCOPY_GCI: + fprintf(output, " Copy GCI\n"); + return true; + break; + case DihContinueB::ZEMPTY_VERIFY_QUEUE: + fprintf(output, " Empty Verify Queue\n"); + return true; + break; + case DihContinueB::ZCHECK_GCP_STOP: + fprintf(output, " Check GCP Stop\n"); + if (len == 6){ + fprintf(output, "coldGcpStatus = %d\n", theData[1]); + fprintf(output, "cgcpStatus = %d\n", theData[2]); + fprintf(output, "coldGcpId = %d\n", theData[3]); + fprintf(output, "cnewgcp = %d\n", theData[4]); + fprintf(output, "cgcpSameCounter = %d\n", theData[5]); + } + return true; + break; + case DihContinueB::ZREMOVE_NODE_FROM_TABLE: + fprintf(output, " Remove Node From Table: Node: %d Table: %d\n", + theData[1], theData[2]); + return true; + break; + case DihContinueB::ZCOPY_NODE: + fprintf(output, " Copy Node: Table: %d\n", theData[1]); + return true; + break; + case DihContinueB::ZSTART_TAKE_OVER: + fprintf(output, " Start Take Over: TakeOverPtr: %d, startNode: %d, toNode: %d\n", + theData[1], theData[2], theData[3]); + return true; + break; + case DihContinueB::ZCHECK_START_TAKE_OVER: + fprintf(output, " Check Start Take Over\n"); + return true; + break; + case DihContinueB::ZTO_START_COPY_FRAG: + fprintf(output, " To Start Copy Frag: TakeOverPtr: %d\n", theData[1]); + return true; + break; + case DihContinueB::ZINVALIDATE_NODE_LCP: + fprintf(output, " Invalide LCP: NodeId: %d TableId %d\n", + theData[1], theData[2]); + return true; + break; + case DihContinueB::ZINITIALISE_RECORDS: + fprintf(output, " Initialise Records: tdata0: %d\n", theData[1]); + return true; + break; + case DihContinueB::ZSTART_PERMREQ_AGAIN: + fprintf(output, " START_PERMREQ again for node: %d\n", theData[1]); + return true; + break; + case DihContinueB::SwitchReplica: + fprintf(output, " NodeId = %d TableId = %d FragNo = %d\n", + theData[1], theData[2], theData[3]); + return true; + break; + case DihContinueB::ZSEND_START_TO: + fprintf(output, " Send Start Take Over: TakeOverPtr: %d, startNode: %d, toNode: %d\n", + theData[1], theData[2], theData[3]); + return true; + break; + case DihContinueB::ZSEND_UPDATE_TO: + fprintf(output, " Send Update Take Over: TakeOverPtr: %d, startNode: %d, toNode: %d\n", + theData[1], theData[2], theData[3]); + return true; + break; + case DihContinueB::ZSEND_END_TO: + fprintf(output, " Send End Take Over: TakeOverPtr: %d, startNode: %d, toNode: %d\n", + theData[1], theData[2], theData[3]); + return true; + break; + case DihContinueB::ZSEND_ADD_FRAG: + fprintf(output, " Send Add Fragment: TakeOverPtr: %d, startNode: %d, toNode: %d\n", + theData[1], theData[2], theData[3]); + return true; + break; + case DihContinueB::ZSEND_CREATE_FRAG: + fprintf(output, " Send Create Fragment: TakeOverPtr: %d, storedType: %d, start Gci: %d, startNode: %d, toNode: %d\n", + theData[1], theData[2], theData[3], theData[4], theData[5]); + return true; + break; + case DihContinueB::WAIT_DROP_TAB_WRITING_TO_FILE: + fprintf(output, " Wait drop tab writing to file TableId: %d\n", theData[1]); + return true; + case DihContinueB::CHECK_WAIT_DROP_TAB_FAILED_LQH: + fprintf(output, " Wait drop tab FailedNodeId: %d TableId: %d\n", + theData[1], theData[2]); + return true; + default: + fprintf(output, " Default system error lab...\n"); + break; + }//switch + return false; +} diff --git a/ndb/src/common/debugger/signaldata/DihSwitchReplicaReq.cpp b/ndb/src/common/debugger/signaldata/DihSwitchReplicaReq.cpp new file mode 100644 index 00000000000..2e4318f4033 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/DihSwitchReplicaReq.cpp @@ -0,0 +1,48 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include + +bool +printDIH_SWITCH_REPLICA_REQ(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 recBlockNo){ + + DihSwitchReplicaReq * req = (DihSwitchReplicaReq *)&theData[0]; + + const Uint32 requestInfo = req->requestInfo; + + switch(DihSwitchReplicaReq::getRequestType(requestInfo)){ + case DihSwitchReplicaReq::RemoveNodeAsPrimary:{ + fprintf(output, " RemoveNodeAsPrimary: Node=%d", req->nodeId); + if(DihSwitchReplicaReq::getAllTables(requestInfo)) + fprintf(output, " All Tables"); + else + fprintf(output, " TableId=%d", req->tableId); + + if(DihSwitchReplicaReq::getDistribute(requestInfo)) + fprintf(output, " Distribute"); + fprintf(output, "\n"); + return true; + } + break; + default: + fprintf(output, " Unknown request type:\n"); + } + return false; +} diff --git a/ndb/src/common/debugger/signaldata/DisconnectRep.cpp b/ndb/src/common/debugger/signaldata/DisconnectRep.cpp new file mode 100644 index 00000000000..3a73747a978 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/DisconnectRep.cpp @@ -0,0 +1,30 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + +#include + +bool +printDISCONNECT_REP(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + + const DisconnectRep * const sig = (DisconnectRep *) theData; + + fprintf(output, " NodeId: %d, ErrorCode: %d\n", + sig->nodeId, sig->err); + + return true; +} diff --git a/ndb/src/common/debugger/signaldata/DropIndx.cpp b/ndb/src/common/debugger/signaldata/DropIndx.cpp new file mode 100644 index 00000000000..0d59a981a18 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/DropIndx.cpp @@ -0,0 +1,38 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool printDROP_INDX_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const DropIndxReq * const sig = (DropIndxReq *) theData; + + return false; +} + +bool printDROP_INDX_CONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const DropIndxConf * const sig = (DropIndxConf *) theData; + + return false; +} + +bool printDROP_INDX_REF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ +// const DropIndxRef * const sig = (DropIndxRef *) theData; + + return false; +} diff --git a/ndb/src/common/debugger/signaldata/DropTab.cpp b/ndb/src/common/debugger/signaldata/DropTab.cpp new file mode 100644 index 00000000000..83c95b0e344 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/DropTab.cpp @@ -0,0 +1,50 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printDROP_TAB_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ + const DropTabReq * const sig = (DropTabReq *) theData; + + fprintf(output, + " senderRef: %x senderData: %d TableId: %d requestType: %d\n", + sig->senderRef, sig->senderData, sig->tableId, sig->requestType); + return true; +} + +bool printDROP_TAB_CONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ + const DropTabConf * const sig = (DropTabConf *) theData; + + fprintf(output, + " senderRef: %x senderData: %d TableId: %d\n", + sig->senderRef, sig->senderData, sig->tableId); + + return true; +} + +bool printDROP_TAB_REF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ + const DropTabRef * const sig = (DropTabRef *) theData; + + fprintf(output, + " senderRef: %x senderData: %d TableId: %d errorCode: %d\n", + sig->senderRef, sig->senderData, sig->tableId, sig->errorCode); + + return true; +} diff --git a/ndb/src/common/debugger/signaldata/DropTrig.cpp b/ndb/src/common/debugger/signaldata/DropTrig.cpp new file mode 100644 index 00000000000..54e8734439f --- /dev/null +++ b/ndb/src/common/debugger/signaldata/DropTrig.cpp @@ -0,0 +1,89 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool printDROP_TRIG_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ + const DropTrigReq * const sig = (DropTrigReq *) theData; + + //char triggerName[MAX_TAB_NAME_SIZE]; + //char triggerType[32]; + //char triggerActionTime[32]; + //char triggerEvent[32]; + + //sig->getTriggerName((char *) &triggerName); + //switch(sig->getTriggerType()) { + //case(TriggerType::SECONDARY_INDEX): + //strcpy(triggerType, "SECONDARY_INDEX"); + //break; + //case(TriggerType::SUBSCRIPTION): + //strcpy(triggerType, "SUBSCRIPTION"); + //break; + //default: + //strcpy(triggerType, "UNSUPPORTED"); + //} + //strcpy(triggerActionTime, + //(sig->getTriggerActionTime() == TriggerActionTime::BEFORE)? + //"BEFORE":"AFTER"); + //switch(sig->getTriggerEvent()) { + //case (TriggerEvent::TE_INSERT): + //strcpy(triggerEvent, "INSERT"); + //break; + //case(TriggerEvent::TE_DELETE): + //strcpy(triggerEvent, "DELETE"); + //break; + //case(TriggerEvent::TE_UPDATE): + //strcpy(triggerEvent, "UPDATE"); + //break; + //} + + fprintf(output, "User: %u, ", sig->getUserRef()); + //fprintf(output, "Trigger name: \"%s\"\n", triggerName); + //fprintf(output, "Type: %s, ", triggerType); + //fprintf(output, "Action: %s, ", triggerActionTime); + //fprintf(output, "Event: %s, ", triggerEvent); + fprintf(output, "Trigger id: %u, ", sig->getTriggerId()); + fprintf(output, "Table id: %u, ", sig->getTableId()); + fprintf(output, "\n"); + + return false; +} + +bool printDROP_TRIG_CONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ + const DropTrigConf * const sig = (DropTrigConf *) theData; + + fprintf(output, "User: %u, ", sig->getUserRef()); + fprintf(output, "Trigger id: %u, ", sig->getTriggerId()); + fprintf(output, "Table id: %u, ", sig->getTableId()); + fprintf(output, "\n"); + + return false; +} + +bool printDROP_TRIG_REF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ + const DropTrigRef * const sig = (DropTrigRef *) theData; + + fprintf(output, "User: %u, ", sig->getUserRef()); + fprintf(output, "Trigger id: %u, ", sig->getTriggerId()); + fprintf(output, "Table id: %u, ", sig->getTableId()); + fprintf(output, "Error code: %u, ", sig->getErrorCode()); + fprintf(output, "\n"); + + return false; +} diff --git a/ndb/src/common/debugger/signaldata/FailRep.cpp b/ndb/src/common/debugger/signaldata/FailRep.cpp new file mode 100644 index 00000000000..d70912fe8c7 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/FailRep.cpp @@ -0,0 +1,31 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + +#include + +bool +printFAIL_REP(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + + const FailRep * const sig = (FailRep *) theData; + + fprintf(output, " FailedNode: %d, FailCause: %d\n", + sig->failNodeId, sig->failCause); + + + return true; +} diff --git a/ndb/src/common/debugger/signaldata/FireTrigOrd.cpp b/ndb/src/common/debugger/signaldata/FireTrigOrd.cpp new file mode 100644 index 00000000000..d86aa2e06de --- /dev/null +++ b/ndb/src/common/debugger/signaldata/FireTrigOrd.cpp @@ -0,0 +1,56 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include + +static +const char * +trigEvent(Uint32 i){ + switch(i){ + case TriggerEvent::TE_INSERT: + return "insert"; + break; + case TriggerEvent::TE_UPDATE: + return "update"; + break; + case TriggerEvent::TE_DELETE: + return "delete"; + break; + } + return "UNKNOWN"; +} + +bool +printFIRE_TRIG_ORD(FILE * output, const Uint32 * theData, Uint32 len, + Uint16 receiverBlockNo) +{ + const FireTrigOrd * const sig = (FireTrigOrd *) theData; + + fprintf(output, " TriggerId: %d TriggerEvent: %s\n", + sig->getTriggerId(), + trigEvent(sig->getTriggerEvent())); + fprintf(output, " UserRef: (%d, %d) User data: %x\n", + refToNode(sig->getUserRef()), + refToBlock(sig->getUserRef()), + sig->getConnectionPtr()); + fprintf(output, " Signal: PK=%d BEFORE=%d AFTER=%d\n", + sig->getNoOfPrimaryKeyWords(), + sig->getNoOfBeforeValueWords(), + sig->getNoOfAfterValueWords()); + + return true; +} diff --git a/ndb/src/common/debugger/signaldata/FsAppendReq.cpp b/ndb/src/common/debugger/signaldata/FsAppendReq.cpp new file mode 100644 index 00000000000..6e443ffe5fc --- /dev/null +++ b/ndb/src/common/debugger/signaldata/FsAppendReq.cpp @@ -0,0 +1,38 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + +#include + +bool +printFSAPPENDREQ(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo){ + + bool ret = true; + + const FsAppendReq * const sig = (FsAppendReq *) theData; + + fprintf(output, " FilePointer: %d\n", sig->filePointer); + fprintf(output, " UserReference: H\'%.8x, UserPointer: H\'%.8x\n", + sig->userReference, sig->userPointer); + + fprintf(output, " varIndex: %d offset: %d size: %d\n", + sig->varIndex, + sig->offset, + sig->size); + return ret; +} diff --git a/ndb/src/common/debugger/signaldata/FsCloseReq.cpp b/ndb/src/common/debugger/signaldata/FsCloseReq.cpp new file mode 100644 index 00000000000..143250b7db1 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/FsCloseReq.cpp @@ -0,0 +1,40 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + +#include + +bool +printFSCLOSEREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + + const FsCloseReq * const sig = (FsCloseReq *) theData; + + fprintf(output, " UserPointer: %d\n", + sig->userPointer); + fprintf(output, " FilePointer: %d\n", + sig->filePointer); + fprintf(output, " UserReference: H\'%.8x\n", + sig->userReference); + + fprintf(output, " Flags: H\'%.8x, ", sig->fileFlag); + if (sig->getRemoveFileFlag(sig->fileFlag) == true) + fprintf(output, "Remove file"); + else + fprintf(output, "Don't remove file"); + fprintf(output, "\n"); + return true; +} diff --git a/ndb/src/common/debugger/signaldata/FsConf.cpp b/ndb/src/common/debugger/signaldata/FsConf.cpp new file mode 100644 index 00000000000..f0ab57aadcf --- /dev/null +++ b/ndb/src/common/debugger/signaldata/FsConf.cpp @@ -0,0 +1,33 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + +#include + +bool +printFSCONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + + const FsConf * const sig = (FsConf *) theData; + + fprintf(output, " UserPointer: %d\n", sig->userPointer); + + if (len > 1){ + // Only valid if this is a FSOPENCONF + fprintf(output, " FilePointer: %d\n", sig->filePointer); + } + return true; +} diff --git a/ndb/src/common/debugger/signaldata/FsOpenReq.cpp b/ndb/src/common/debugger/signaldata/FsOpenReq.cpp new file mode 100644 index 00000000000..31d351a8a84 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/FsOpenReq.cpp @@ -0,0 +1,59 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + +#include + +bool +printFSOPENREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + + const FsOpenReq * const sig = (FsOpenReq *) theData; + + + fprintf(output, " UserReference: H\'%.8x, userPointer: H\'%.8x\n", + sig->userReference, sig->userPointer); + fprintf(output, " FileNumber[1-4]: H\'%.8x H\'%.8x H\'%.8x H\'%.8x\n", + sig->fileNumber[0], sig->fileNumber[1], sig->fileNumber[2], sig->fileNumber[3]); + fprintf(output, " FileFlags: H\'%.8x ", + sig->fileFlags); + + // File open mode must be one of ReadOnly, WriteOnly or ReadWrite + const Uint32 flags = sig->fileFlags; + switch(flags & 3){ + case FsOpenReq::OM_READONLY: + fprintf(output, "Open read only"); + break; + case FsOpenReq::OM_WRITEONLY: + fprintf(output, "Open write only"); + break; + case FsOpenReq::OM_READWRITE: + fprintf(output, "Open read and write"); + break; + default: + fprintf(output, "Open mode unknown!"); + } + + if (flags & FsOpenReq::OM_CREATE) + fprintf(output, ", Create new file"); + if (flags & FsOpenReq::OM_TRUNCATE) + fprintf(output, ", Truncate existing file"); + if (flags & FsOpenReq::OM_APPEND) + fprintf(output, ", Append"); + + fprintf(output, "\n"); + return true; +} diff --git a/ndb/src/common/debugger/signaldata/FsReadWriteReq.cpp b/ndb/src/common/debugger/signaldata/FsReadWriteReq.cpp new file mode 100644 index 00000000000..ad9cb623c17 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/FsReadWriteReq.cpp @@ -0,0 +1,85 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + +#include + +bool +printFSREADWRITEREQ(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo){ + + bool ret = true; + + const FsReadWriteReq * const sig = (FsReadWriteReq *) theData; + + fprintf(output, " UserPointer: %d\n", sig->userPointer); + fprintf(output, " FilePointer: %d\n", sig->filePointer); + fprintf(output, " UserReference: H\'%.8x", sig->userReference); + + fprintf(output, " Operation flag: H\'%.8x (", sig->operationFlag); + if (sig->getSyncFlag(sig->operationFlag) == true) + fprintf(output, "Sync,"); + else + fprintf(output, "No sync,"); + + fprintf(output, " Format="); + switch(sig->getFormatFlag(sig->operationFlag)){ + case FsReadWriteReq::fsFormatListOfPairs: + fprintf(output, "List of pairs)\n"); + break; + case FsReadWriteReq::fsFormatArrayOfPages: + fprintf(output, "Array of pages)\n"); + break; + case FsReadWriteReq::fsFormatListOfMemPages: + fprintf(output, "List of mem pages)\n"); + break; + default: + fprintf(output, "fsFormatMax not handled\n"); + ret = false; + break; + } + + fprintf(output, " varIndex: %d\n", + sig->varIndex); + fprintf(output, " numberOfPages: %d\n", + sig->numberOfPages); + fprintf(output, " pageData: "); + + + switch(sig->getFormatFlag(sig->operationFlag)){ + case FsReadWriteReq::fsFormatListOfPairs: + for (unsigned int i = 0; i < sig->numberOfPages*2; i += 2){ + fprintf(output, " H\'%.8x, H\'%.8x\n", sig->data.pageData[i], + sig->data.pageData[i + 1]); + } + break; + case FsReadWriteReq::fsFormatArrayOfPages: + fprintf(output, " H\'%.8x, H\'%.8x\n", sig->data.pageData[0], + sig->data.pageData[1]); + break; + case FsReadWriteReq::fsFormatListOfMemPages: + for (unsigned int i = 0; i < (sig->numberOfPages + 1); i++){ + fprintf(output, " H\'%.8x, ", sig->data.pageData[i]); + } + break; + default: + fprintf(output, "Impossible event\n"); + } + + fprintf(output, "\n"); + return ret; +} diff --git a/ndb/src/common/debugger/signaldata/FsRef.cpp b/ndb/src/common/debugger/signaldata/FsRef.cpp new file mode 100644 index 00000000000..ccf3d6da9c8 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/FsRef.cpp @@ -0,0 +1,75 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + +#include + +bool +printFSREF(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo){ + + bool ret = true; + + const FsRef * const sig = (FsRef *) theData; + + fprintf(output, " UserPointer: %d\n", + sig->userPointer); + + fprintf(output, " ErrorCode: %d, ", sig->errorCode); + switch (sig->getErrorCode(sig->errorCode)){ + case FsRef::fsErrNone: + fprintf(output, "No error"); + break; + case FsRef::fsErrHardwareFailed: + fprintf(output, "Hardware failure!"); + break; + case FsRef::fsErrUserError: + fprintf(output, "User error!"); + break; + case FsRef::fsErrEnvironmentError: + fprintf(output, "Environment error!"); + break; + case FsRef::fsErrTemporaryNotAccessible: + fprintf(output, "Temporary not accesible!"); + break; + case FsRef::fsErrNoSpaceLeftOnDevice: + fprintf(output, "No space left on device!"); + break; + case FsRef::fsErrPermissionDenied: + fprintf(output, "Permission denied!"); + break; + case FsRef::fsErrInvalidParameters: + fprintf(output, "Invalid parameters!"); + break; + case FsRef::fsErrNoMoreResources: + fprintf(output, "No more resources!"); + break; + case FsRef::fsErrFileDoesNotExist: + fprintf(output, "File does not exist!"); + break; + + case FsRef::fsErrUnknown: + default: + fprintf(output, "Unknown!"); + ret = false; + break; + } + fprintf(output, "\n"); + fprintf(output, " OS ErrorCode: %d \n", sig->osErrorCode); + + return ret; +} diff --git a/ndb/src/common/debugger/signaldata/GCPSave.cpp b/ndb/src/common/debugger/signaldata/GCPSave.cpp new file mode 100644 index 00000000000..7566f004bfd --- /dev/null +++ b/ndb/src/common/debugger/signaldata/GCPSave.cpp @@ -0,0 +1,78 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include + +bool +printGCPSaveReq(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 receiverBlockNo){ + + GCPSaveReq * sr = (GCPSaveReq*)theData; + + fprintf(output, " dihBlockRef = (%d, %d) dihPtr = %d gci = %d\n", + refToBlock(sr->dihBlockRef), refToNode(sr->dihBlockRef), + sr->dihPtr, sr->gci); + + return true; +} + +bool +printGCPSaveRef(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 receiverBlockNo){ + + GCPSaveRef * sr = (GCPSaveRef*)theData; + + fprintf(output, " nodeId = %d dihPtr = %d gci = %d reason: ", + sr->nodeId, + sr->dihPtr, sr->gci); + + switch(sr->errorCode){ + case GCPSaveRef::NodeShutdownInProgress: + fprintf(output, "NodeShutdownInProgress\n"); + break; + case GCPSaveRef::FakedSignalDueToNodeFailure: + fprintf(output, "FakedSignalDueToNodeFailure\n"); + break; + default: + fprintf(output, "Unknown reason: %d\n", sr->errorCode); + return false; + } + + return true; +} + +bool +printGCPSaveConf(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 receiverBlockNo){ + + GCPSaveConf * sr = (GCPSaveConf*)theData; + + fprintf(output, " nodeId = %d dihPtr = %d gci = %d\n", + sr->nodeId, + sr->dihPtr, sr->gci); + + return true; +} + + diff --git a/ndb/src/common/debugger/signaldata/IndxAttrInfo.cpp b/ndb/src/common/debugger/signaldata/IndxAttrInfo.cpp new file mode 100755 index 00000000000..2ef5feaada7 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/IndxAttrInfo.cpp @@ -0,0 +1,31 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printINDXATTRINFO(FILE * output, const Uint32 * theData, Uint32 len, + Uint16 receiverBlockNo) +{ +// const IndxAttrInfo * const sig = (IndxAttrInfo *) theData; + + Uint32 i = 0; + while (i < len) + fprintf(output, " H\'%.8x", theData[i++]); + fprintf(output,"\n"); + + return true; +} diff --git a/ndb/src/common/debugger/signaldata/IndxKeyInfo.cpp b/ndb/src/common/debugger/signaldata/IndxKeyInfo.cpp new file mode 100755 index 00000000000..6fe5567188d --- /dev/null +++ b/ndb/src/common/debugger/signaldata/IndxKeyInfo.cpp @@ -0,0 +1,31 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printINDXKEYINFO(FILE * output, const Uint32 * theData, Uint32 len, + Uint16 receiverBlockNo) +{ +// const IndxKeyInfo * const sig = (IndxKeyInfo *) theData; + + Uint32 i = 0; + while (i < len) + fprintf(output, " H\'%.8x", theData[i++]); + fprintf(output,"\n"); + + return true; +} diff --git a/ndb/src/common/debugger/signaldata/LCP.cpp b/ndb/src/common/debugger/signaldata/LCP.cpp new file mode 100644 index 00000000000..825659d13b3 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/LCP.cpp @@ -0,0 +1,88 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include + +bool +printSTART_LCP_REQ(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo){ + + const StartLcpReq * const sig = (StartLcpReq *) theData; + + char buf1[sig->participatingDIH.TextLength+1], buf2[sig->participatingLQH.TextLength+1]; + fprintf(output, + " Sender: %d LcpId: %d\n" + " ParticipatingDIH = %s\n" + " ParticipatingLQH = %s\n", + refToNode(sig->senderRef), sig->lcpId, + sig->participatingDIH.getText(buf1), + sig->participatingLQH.getText(buf2)); + + return true; +} + +bool +printSTART_LCP_CONF(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo){ + + const StartLcpConf * const sig = (StartLcpConf *) theData; + + fprintf(output, " Sender: %d LcpId: %d\n", + refToNode(sig->senderRef), sig->lcpId); + + return true; +} + +bool +printLCP_FRAG_ORD(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo){ + + const LcpFragOrd * const sig = (LcpFragOrd *) theData; + + fprintf(output, " LcpId: %d LcpNo: %d Table: %d Fragment: %d\n", + sig->lcpId, sig->lcpNo, sig->tableId, sig->fragmentId); + + fprintf(output, " KeepGCI: %d LastFragmentFlag: %d\n", + sig->keepGci, sig->lastFragmentFlag); + return true; +} + +bool +printLCP_FRAG_REP(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo){ + + const LcpFragRep * const sig = (LcpFragRep *) theData; + + fprintf(output, " LcpId: %d LcpNo: %d NodeId: %d Table: %d Fragment: %d\n", + sig->lcpId, sig->lcpNo, sig->nodeId, sig->tableId, sig->fragId); + fprintf(output, " Max GCI Started: %d Max GCI Completed: %d\n", + sig->maxGciStarted, sig->maxGciCompleted); + return true; +} + +bool +printLCP_COMPLETE_REP(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo){ + + const LcpCompleteRep * const sig = (LcpCompleteRep *) theData; + + fprintf(output, " LcpId: %d NodeId: %d Block: %s\n", + sig->lcpId, sig->nodeId, getBlockName(sig->blockNo)); + return true; +} diff --git a/ndb/src/common/debugger/signaldata/LqhFrag.cpp b/ndb/src/common/debugger/signaldata/LqhFrag.cpp new file mode 100644 index 00000000000..6d727959a67 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/LqhFrag.cpp @@ -0,0 +1,61 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include + +bool +printLQH_FRAG_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 recB){ + LqhFragReq* sig = (LqhFragReq*)theData; + + fprintf(output, " senderData: %d senderRef: %x", + sig->senderData, sig->senderRef); + fprintf(output, " tableId: %d fragmentId: %d tableType: %d", + sig->tableId, sig->fragmentId, sig->tableType); + if (sig->primaryTableId == RNIL) + fprintf(output, " primaryTableId: RNIL\n"); + else + fprintf(output, " primaryTableId: %d\n", sig->primaryTableId); + fprintf(output, " localKeyLength: %d maxLoadFactor: %d minLoadFactor: %d\n", + sig->localKeyLength, sig->maxLoadFactor, sig->minLoadFactor); + fprintf(output, " kValue: %d lh3DistrBits: %d lh3PageBits: %d\n", + sig->kValue, sig->lh3DistrBits, sig->lh3PageBits); + + fprintf(output, " noOfAttributes: %d noOfNullAttributes: %d keyLength: %d\n", + sig->noOfAttributes, sig->noOfNullAttributes, sig->keyLength); + + fprintf(output, " noOfPagesToPreAllocate: %d schemaVersion: %d nextLCP: %d\n", + sig->noOfPagesToPreAllocate, sig->schemaVersion, sig->nextLCP); + + return true; +} +bool +printLQH_FRAG_CONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 rec){ + LqhFragConf* sig = (LqhFragConf*)theData; + + fprintf(output, " senderData: %d lqhFragPtr: %d\n", + sig->senderData, sig->lqhFragPtr); + return true; +} + +bool +printLQH_FRAG_REF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 rec){ + LqhFragRef* sig = (LqhFragRef*)theData; + + fprintf(output, " senderData: %d errorCode: %d\n", + sig->senderData, sig->errorCode); + return true; +} diff --git a/ndb/src/common/debugger/signaldata/LqhKey.cpp b/ndb/src/common/debugger/signaldata/LqhKey.cpp new file mode 100644 index 00000000000..2796437fd8b --- /dev/null +++ b/ndb/src/common/debugger/signaldata/LqhKey.cpp @@ -0,0 +1,161 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printLQHKEYREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + + const LqhKeyReq * const sig = (LqhKeyReq *) theData; + + fprintf(output, + " ClientPtr = H\'%.8x hashValue = H\'%.8x tcBlockRef = H\'%.8x\n" + " transId1 = H\'%.8x transId2 = H\'%.8x savePointId = H\'%.8x\n", + sig->clientConnectPtr, // DATA 0 + sig->hashValue, // DATA 2 + sig->tcBlockref, // DATA 4 + sig->transId1, // DATA 7 + sig->transId2, // DATA 8 + sig->savePointId // DATA 9 + ); + + const Uint32 reqInfo = sig->requestInfo; + const Uint32 attrLen = sig->attrLen; + + fprintf(output, + " Op: %d Lock: %d Flags: ", + LqhKeyReq::getOperation(reqInfo), + LqhKeyReq::getLockType(reqInfo)); + if(LqhKeyReq::getSimpleFlag(reqInfo)) + fprintf(output, "Simple "); + if(LqhKeyReq::getDirtyFlag(reqInfo)) + fprintf(output, "Dirty "); + if(LqhKeyReq::getInterpretedFlag(reqInfo)) + fprintf(output, "Interpreted "); + if(LqhKeyReq::getScanTakeOverFlag(attrLen)) + fprintf(output, "ScanTakeOver "); + if(LqhKeyReq::getMarkerFlag(reqInfo)) + fprintf(output, "CommitAckMarker "); + + fprintf(output, "ScanInfo/noFiredTriggers: H\'%x\n", sig->scanInfo); + + fprintf(output, + " AttrLen: %d (%d in this) KeyLen: %d TableId: %d SchemaVer: %d\n", + LqhKeyReq::getAttrLen(attrLen), + LqhKeyReq::getAIInLqhKeyReq(reqInfo), + LqhKeyReq::getKeyLen(reqInfo), + LqhKeyReq::getTableId(sig->tableSchemaVersion), + LqhKeyReq::getSchemaVersion(sig->tableSchemaVersion)); + + fprintf(output, + " FragId: %d ReplicaNo: %d LastReplica: %d NextNodeId: %d\n", + LqhKeyReq::getFragmentId(sig->fragmentData), + LqhKeyReq::getSeqNoReplica(reqInfo), + LqhKeyReq::getLastReplicaNo(reqInfo), + LqhKeyReq::getNextReplicaNodeId(sig->fragmentData)); + + bool printed = false; + Uint32 nextPos = LqhKeyReq::getApplicationAddressFlag(reqInfo) << 1; + if(nextPos != 0){ + fprintf(output, + " ApiRef: H\'%.8x ApiOpRef: H\'%.8x", + sig->variableData[0], + sig->variableData[1]); + printed = true; + } + + if(LqhKeyReq::getSameClientAndTcFlag(reqInfo)){ + fprintf(output, " TcOpRec: H\'%.8x", sig->variableData[nextPos]); + nextPos++; + printed = true; + } + + Uint32 tmp = LqhKeyReq::getLastReplicaNo(reqInfo) - + LqhKeyReq::getSeqNoReplica(reqInfo); + if(tmp > 1){ + NodeId node2 = sig->variableData[nextPos] & 0xffff; + NodeId node3 = sig->variableData[nextPos] >> 16; + fprintf(output, " NextNodeId2: %d NextNodeId3: %d", + node2, node3); + nextPos ++; + printed = true; + } + if(printed) + fprintf(output, "\n"); + + printed = false; + if(LqhKeyReq::getStoredProcFlag(attrLen)){ + fprintf(output, " StoredProcId: %d", sig->variableData[nextPos]); + nextPos++; + printed = true; + } + + if(LqhKeyReq::getReturnedReadLenAIFlag(reqInfo)){ + fprintf(output, " ReturnedReadLenAI: %d", + sig->variableData[nextPos]); + nextPos++; + printed = true; + } + + const UintR keyLen = LqhKeyReq::getKeyLen(reqInfo); + if(keyLen > 0){ + fprintf(output, " KeyInfo: "); + for(UintR i = 0; ivariableData[nextPos]); + fprintf(output, "\n"); + } + + if(!LqhKeyReq::getInterpretedFlag(reqInfo)){ + fprintf(output, " AttrInfo: "); + for(int i = 0; ivariableData[nextPos]); + fprintf(output, "\n"); + } else { + fprintf(output, " InitialReadSize: %d InterpretedSize: %d " + "FinalUpdateSize: %d FinalReadSize: %d SubroutineSize: %d\n", + sig->variableData[nextPos+0], sig->variableData[nextPos+1], + sig->variableData[nextPos+2], sig->variableData[nextPos+3], + sig->variableData[nextPos+4]); + nextPos += 5; + } + return true; +} + +bool +printLQHKEYCONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ +// const LqhKeyConf * const sig = (LqhKeyConf *) theData; + + fprintf(output, "Signal data: "); + Uint32 i = 0; + while (i < len) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + + return true; +} + +bool +printLQHKEYREF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ +// const LqhKeyRef * const sig = (LqhKeyRef *) theData; + + fprintf(output, "Signal data: "); + Uint32 i = 0; + while (i < len) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + + return true; +} diff --git a/ndb/src/common/debugger/signaldata/LqhTrans.cpp b/ndb/src/common/debugger/signaldata/LqhTrans.cpp new file mode 100644 index 00000000000..8282530cae6 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/LqhTrans.cpp @@ -0,0 +1,40 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printLQH_TRANSCONF(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const LqhTransConf * const sig = (LqhTransConf *)theData; + fprintf(output, " tcRef: %x\n", sig->tcRef); + fprintf(output, " lqhNodeId: %x\n", sig->lqhNodeId); + fprintf(output, " operationStatus: %x\n", sig->operationStatus); + fprintf(output, " transId1: %x\n", sig->transId1); + fprintf(output, " transId2: %x\n", sig->transId2); + fprintf(output, " apiRef: %x\n", sig->apiRef); + fprintf(output, " apiOpRec: %x\n", sig->apiOpRec); + fprintf(output, " lqhConnectPtr: %x\n", sig->lqhConnectPtr); + fprintf(output, " oldTcOpRec: %x\n", sig->oldTcOpRec); + fprintf(output, " requestInfo: %x\n", sig->requestInfo); + fprintf(output, " gci: %x\n", sig->gci); + fprintf(output, " nextNodeId1: %x\n", sig->nextNodeId1); + fprintf(output, " nextNodeId2: %x\n", sig->nextNodeId2); + fprintf(output, " nextNodeId3: %x\n", sig->nextNodeId3); + fprintf(output, " tableId: %x\n", sig->tableId); + return true; +} + diff --git a/ndb/src/common/debugger/signaldata/Makefile b/ndb/src/common/debugger/signaldata/Makefile new file mode 100644 index 00000000000..5e86aaf97c0 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/Makefile @@ -0,0 +1,32 @@ +include .defs.mk + +TYPE := ndbapi + +PIC_ARCHIVE := Y +ARCHIVE_TARGET := signaldataprint + +SOURCES = TcKeyReq.cpp TcKeyConf.cpp TcKeyRef.cpp \ + TcRollbackRep.cpp \ + TupKey.cpp TupCommit.cpp LqhKey.cpp \ + FsOpenReq.cpp FsCloseReq.cpp FsRef.cpp FsConf.cpp FsReadWriteReq.cpp\ + SignalDataPrint.cpp SignalNames.cpp \ + ContinueB.cpp DihContinueB.cpp NdbfsContinueB.cpp \ + CloseComReqConf.cpp PackedSignal.cpp PrepFailReqRef.cpp \ + GCPSave.cpp DictTabInfo.cpp \ + AlterTable.cpp AlterTab.cpp \ + CreateTrig.cpp AlterTrig.cpp DropTrig.cpp \ + FireTrigOrd.cpp TrigAttrInfo.cpp \ + CreateIndx.cpp AlterIndx.cpp DropIndx.cpp TcIndx.cpp \ + IndxKeyInfo.cpp IndxAttrInfo.cpp \ + FsAppendReq.cpp ScanTab.cpp \ + BackupImpl.cpp BackupSignalData.cpp \ + UtilSequence.cpp UtilPrepare.cpp UtilDelete.cpp UtilExecute.cpp \ + LqhFrag.cpp DropTab.cpp PrepDropTab.cpp LCP.cpp MasterLCP.cpp \ + CopyGCI.cpp SystemError.cpp StartRec.cpp NFCompleteRep.cpp \ + FailRep.cpp DisconnectRep.cpp SignalDroppedRep.cpp \ + SumaImpl.cpp NdbSttor.cpp CreateFragmentation.cpp \ + UtilLock.cpp TuxMaint.cpp TupAccess.cpp AccLock.cpp \ + LqhTrans.cpp + +include $(NDB_TOP)/Epilogue.mk + diff --git a/ndb/src/common/debugger/signaldata/MasterLCP.cpp b/ndb/src/common/debugger/signaldata/MasterLCP.cpp new file mode 100644 index 00000000000..aa30404524f --- /dev/null +++ b/ndb/src/common/debugger/signaldata/MasterLCP.cpp @@ -0,0 +1,87 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include + +static +void +print(char *buf, size_t buf_len, MasterLCPConf::State s){ + switch(s){ + case MasterLCPConf::LCP_STATUS_IDLE: + snprintf(buf, buf_len, "LCP_STATUS_IDLE"); + break; + case MasterLCPConf::LCP_STATUS_ACTIVE: + snprintf(buf, buf_len, "LCP_STATUS_ACTIVE"); + break; + case MasterLCPConf::LCP_TAB_COMPLETED: + snprintf(buf, buf_len, "LCP_TAB_COMPLETED"); + break; + case MasterLCPConf::LCP_TAB_SAVED: + snprintf(buf, buf_len, "LCP_TAB_SAVED"); + break; + } +} + +NdbOut & +operator<<(NdbOut& out, const MasterLCPConf::State& s){ + static char buf[255]; + print(buf, sizeof(buf), s); + out << buf; + return out; +} + +bool +printMASTER_LCP_CONF(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 recBlockNo){ + + MasterLCPConf * sig = (MasterLCPConf *)&theData[0]; + + static char buf[255]; + print(buf, sizeof(buf), (MasterLCPConf::State)sig->lcpState); + fprintf(output, " senderNode=%d failedNode=%d SenderState=%s\n", + sig->senderNodeId, sig->failedNodeId, buf); + return true; +} + +bool +printMASTER_LCP_REQ(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 recBlockNo){ + + MasterLCPReq * sig = (MasterLCPReq *)&theData[0]; + + fprintf(output, " masterRef=(node=%d, block=%d), failedNode=%d\n", + refToNode(sig->masterRef), refToBlock(sig->masterRef), + sig->failedNodeId); + return true; +} + +bool +printMASTER_LCP_REF(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 recBlockNo){ + + MasterLCPRef * sig = (MasterLCPRef *)&theData[0]; + fprintf(output, " senderNode=%d failedNode=%d\n", + sig->senderNodeId, sig->failedNodeId); + return true; +} diff --git a/ndb/src/common/debugger/signaldata/NFCompleteRep.cpp b/ndb/src/common/debugger/signaldata/NFCompleteRep.cpp new file mode 100644 index 00000000000..20f7ea99871 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/NFCompleteRep.cpp @@ -0,0 +1,44 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include + +bool +printNF_COMPLETE_REP(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 recBlockNo){ + + NFCompleteRep * sig = (NFCompleteRep*)theData; + const char * who = getBlockName(sig->blockNo, 0); + + if(who == 0){ + fprintf(output, + " Node: %d has completed failure of node %d\n", + sig->nodeId, sig->failedNodeId); + } else { + fprintf(output, + " Node: %d block: %s has completed failure of node %d\n", + sig->nodeId, who, sig->failedNodeId); + } + + fprintf(output, "Sent from line: %d\n", + sig->from); + + return true; +}; diff --git a/ndb/src/common/debugger/signaldata/NdbSttor.cpp b/ndb/src/common/debugger/signaldata/NdbSttor.cpp new file mode 100644 index 00000000000..9fd081313be --- /dev/null +++ b/ndb/src/common/debugger/signaldata/NdbSttor.cpp @@ -0,0 +1,50 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printNDB_STTOR(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const NdbSttor * const sig = (NdbSttor *)theData; + fprintf(output, " senderRef: %x\n", sig->senderRef); + fprintf(output, " nodeId: %x\n", sig->nodeId); + fprintf(output, " internalStartPhase: %x\n", sig->internalStartPhase); + fprintf(output, " typeOfStart: %x\n", sig->typeOfStart); + fprintf(output, " masterNodeId: %x\n", sig->masterNodeId); + + int left = len - NdbSttor::SignalLength; + if(left > 0){ + fprintf(output, " config: "); + for(int i = 0; iconfig[i]); + if(((i + 1) % 7) == 0 && (i+1) < left){ + fprintf(output, "\n config: "); + } + } + fprintf(output, "\n"); + } + return true; +} + +bool +printNDB_STTORRY(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const NdbSttorry * const sig = (NdbSttorry *)theData; + fprintf(output, " senderRef: %x\n", sig->senderRef); + return true; +} + diff --git a/ndb/src/common/debugger/signaldata/NdbfsContinueB.cpp b/ndb/src/common/debugger/signaldata/NdbfsContinueB.cpp new file mode 100644 index 00000000000..b3c7a61136e --- /dev/null +++ b/ndb/src/common/debugger/signaldata/NdbfsContinueB.cpp @@ -0,0 +1,38 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include + +bool +printCONTINUEB_NDBFS(FILE * output, const Uint32 * theData, Uint32 len){ + + switch (theData[0]) { + case NdbfsContinueB::ZSCAN_MEMORYCHANNEL_10MS_DELAY: + fprintf(output, " Scanning the memory channel every 10ms\n"); + return true; + break; + case NdbfsContinueB::ZSCAN_MEMORYCHANNEL_NO_DELAY: + fprintf(output, " Scanning the memory channel again with no delay\n"); + return true; + break; + default: + fprintf(output, " Default system error lab...\n"); + return false; + break; + }//switch + return false; +} diff --git a/ndb/src/common/debugger/signaldata/PackedSignal.cpp b/ndb/src/common/debugger/signaldata/PackedSignal.cpp new file mode 100644 index 00000000000..f0f7aee74e4 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/PackedSignal.cpp @@ -0,0 +1,104 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include + +bool +printPACKED_SIGNAL(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + fprintf(output, "Signal data: "); + Uint32 i = 0; + while (i < len) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + fprintf(output, "--------- Begin Packed Signals --------\n"); + // Print each signal separately + for (i = 0; i < len;) { + switch (PackedSignal::getSignalType(theData[i])) { + case ZCOMMIT: { + Uint32 signalLength = 4; + fprintf(output, "--------------- Signal ----------------\n"); + fprintf(output, "r.bn: %u \"%s\", length: %u \"COMMIT\"\n", + receiverBlockNo, getBlockName(receiverBlockNo,""), signalLength); + fprintf(output, "Signal data: "); + for(Uint32 j = 0; j < signalLength; j++) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + break; + } + case ZCOMPLETE: { + Uint32 signalLength = 3; + fprintf(output, "--------------- Signal ----------------\n"); + fprintf(output, "r.bn: %u \"%s\", length: %u \"COMPLETE\"\n", + receiverBlockNo, getBlockName(receiverBlockNo,""), signalLength); + fprintf(output, "Signal data: "); + for(Uint32 j = 0; j < signalLength; j++) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + break; + } + case ZCOMMITTED: { + Uint32 signalLength = 3; + fprintf(output, "--------------- Signal ----------------\n"); + fprintf(output, "r.bn: %u \"%s\", length: %u \"COMMITTED\"\n", + receiverBlockNo, getBlockName(receiverBlockNo,""), signalLength); + fprintf(output, "Signal data: "); + for(Uint32 j = 0; j < signalLength; j++) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + break; + } + case ZCOMPLETED: { + Uint32 signalLength = 3; + fprintf(output, "--------------- Signal ----------------\n"); + fprintf(output, "r.bn: %u \"%s\", length: %u \"COMPLETED\"\n", + receiverBlockNo, getBlockName(receiverBlockNo,""), signalLength); + fprintf(output, "Signal data: "); + for(Uint32 j = 0; j < signalLength; j++) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + break; + } + case ZLQHKEYCONF: { + Uint32 signalLength = LqhKeyConf::SignalLength; + + fprintf(output, "--------------- Signal ----------------\n"); + fprintf(output, "r.bn: %u \"%s\", length: %u \"LQHKEYCONF\"\n", + receiverBlockNo, getBlockName(receiverBlockNo,""), signalLength); + printLQHKEYCONF(output, theData + i, signalLength, receiverBlockNo); + i += signalLength; + break; + } + case ZREMOVE_MARKER: { + Uint32 signalLength = 2; + fprintf(output, "--------------- Signal ----------------\n"); + fprintf(output, "r.bn: %u \"%s\", length: %u \"REMOVE_MARKER\"\n", + receiverBlockNo, getBlockName(receiverBlockNo,""), signalLength); + fprintf(output, "Signal data: "); + i++; // Skip first word! + for(Uint32 j = 0; j < signalLength; j++) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + break; + } + default: + fprintf(output, "Unknown signal type\n"); + } + }//for + fprintf(output, "--------- End Packed Signals ----------\n"); + return true; +} diff --git a/ndb/src/common/debugger/signaldata/PrepDropTab.cpp b/ndb/src/common/debugger/signaldata/PrepDropTab.cpp new file mode 100644 index 00000000000..59001bcd6f6 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/PrepDropTab.cpp @@ -0,0 +1,50 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printPREP_DROP_TAB_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ + const PrepDropTabReq * const sig = (PrepDropTabReq *) theData; + + fprintf(output, + " senderRef: %x senderData: %d TableId: %d\n", + sig->senderRef, sig->senderData, sig->tableId); + return true; +} + +bool printPREP_DROP_TAB_CONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ + const PrepDropTabConf * const sig = (PrepDropTabConf *) theData; + + fprintf(output, + " senderRef: %x senderData: %d TableId: %d\n", + sig->senderRef, sig->senderData, sig->tableId); + + return true; +} + +bool printPREP_DROP_TAB_REF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo) +{ + const PrepDropTabRef * const sig = (PrepDropTabRef *) theData; + + fprintf(output, + " senderRef: %x senderData: %d TableId: %d errorCode: %d\n", + sig->senderRef, sig->senderData, sig->tableId, sig->errorCode); + + return true; +} diff --git a/ndb/src/common/debugger/signaldata/PrepFailReqRef.cpp b/ndb/src/common/debugger/signaldata/PrepFailReqRef.cpp new file mode 100644 index 00000000000..f3b4b97f0fd --- /dev/null +++ b/ndb/src/common/debugger/signaldata/PrepFailReqRef.cpp @@ -0,0 +1,53 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include +#include + +bool +printPREPFAILREQREF(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 receiverBlockNo){ + + PrepFailReqRef * cc = (PrepFailReqRef*)theData; + + fprintf(output, " xxxBlockRef = (%d, %d) failNo = %d noOfNodes = %d\n", + refToBlock(cc->xxxBlockRef), refToNode(cc->xxxBlockRef), + cc->failNo, cc->noOfNodes); + + int hits = 0; + fprintf(output, " Nodes: "); + for(int i = 0; itheNodes, i)){ + hits++; + fprintf(output, " %d", i); + } + if(hits == 16){ + fprintf(output, "\n Nodes: "); + hits = 0; + } + } + if(hits != 0) + fprintf(output, "\n"); + + return true; +} + + diff --git a/ndb/src/common/debugger/signaldata/ScanTab.cpp b/ndb/src/common/debugger/signaldata/ScanTab.cpp new file mode 100644 index 00000000000..b4246059f6a --- /dev/null +++ b/ndb/src/common/debugger/signaldata/ScanTab.cpp @@ -0,0 +1,163 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + +#include +#include +#include + +bool +printSCANTABREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + + const ScanTabReq * const sig = (ScanTabReq *) theData; + + const UintR requestInfo = sig->requestInfo; + + fprintf(output, " apiConnectPtr: H\'%.8x\n", + sig->apiConnectPtr); + fprintf(output, " requestInfo: H\'%.8x:\n", requestInfo); + fprintf(output, " Parallellism: %u, LockMode: %u, Holdlock: %u, RangeScan: %u\n", + sig->getParallelism(requestInfo), sig->getLockMode(requestInfo), sig->getHoldLockFlag(requestInfo), sig->getRangeScanFlag(requestInfo)); + + fprintf(output, " attrLen: %d, tableId: %d, tableSchemaVer: %d\n", + sig->attrLen, sig->tableId, sig->tableSchemaVersion); + + fprintf(output, " transId(1, 2): (H\'%.8x, H\'%.8x) storedProcId: H\'%.8x\n", + sig->transId1, sig->transId2, sig->storedProcId); + + fprintf(output, " OperationPtr(s):\n"); + for(int i = 0; i<16; i=i+4){ + fprintf(output, " H\'%.8x, H\'%.8x, H\'%.8x, H\'%.8x\n", + sig->apiOperationPtr[i], sig->apiOperationPtr[i+1], + sig->apiOperationPtr[i+2], sig->apiOperationPtr[i+3]); + } + return false; +} + +bool +printSCANTABCONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + + const ScanTabConf * const sig = (ScanTabConf *) theData; + + const UintR requestInfo = sig->requestInfo; + + fprintf(output, " apiConnectPtr: H\'%.8x\n", + sig->apiConnectPtr); + fprintf(output, " transId(1, 2): (H\'%.8x, H\'%.8x)\n", + sig->transId1, sig->transId2); + + fprintf(output, " requestInfo: H\'%.8x(Operations: %u, ScanStatus: %u(\"", + requestInfo, sig->getOperations(requestInfo), sig->getScanStatus(requestInfo)); + switch(sig->getScanStatus(requestInfo)){ + case 0: + fprintf(output, "ZFALSE"); + break; + case 1: + fprintf(output, "ZTRUE"); + break; + case 2: + fprintf(output, "ZCLOSED"); + break; + default: + fprintf(output, "UNKNOWN"); + break; + } + fprintf(output, "\"))\n"); +#if 0 + fprintf(output, " Operation(s):\n"); + for(int i = 0; i<16; i++){ + fprintf(output, " [%.2u]ix=%d l=%.2d,", + i, sig->getIdx(sig->operLenAndIdx[i]), sig->getLen(sig->operLenAndIdx[i])); + if (((i+1) % 4) == 0) + fprintf(output, "\n"); + } +#endif + return false; +} + +bool +printSCANTABINFO(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + + const ScanTabInfo * const sig = (ScanTabInfo *) theData; + + fprintf(output, " apiConnectPtr: H\'%.8x\n", + sig->apiConnectPtr); + + fprintf(output, " Operation(s):\n"); + for(int i = 0; i<16; i++){ + fprintf(output, " [%.2u]ix=%d l=%.2d,", + i, sig->getIdx(sig->operLenAndIdx[i]), sig->getLen(sig->operLenAndIdx[i])); + if (((i+1) % 4) == 0) + fprintf(output, "\n"); + } + + return false; +} + +bool +printSCANTABREF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + + const ScanTabRef * const sig = (ScanTabRef *) theData; + + fprintf(output, " apiConnectPtr: H\'%.8x\n", + sig->apiConnectPtr); + + fprintf(output, " transId(1, 2): (H\'%.8x, H\'%.8x)\n", + sig->transId1, sig->transId2); + + fprintf(output, " Errorcode: %u\n", sig->errorCode); + + // fprintf(output, " sendScanNextReqWithClose: %u\n", sig->sendScanNextReqWithClose); + return false; +} + + +bool +printSCANFRAGNEXTREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + const ScanFragNextReq * const sig = (ScanFragNextReq *) theData; + + fprintf(output, " senderData: H\'%.8x\n", + sig->senderData); + + fprintf(output, " transId(1, 2): (H\'%.8x, H\'%.8x)\n", + sig->transId1, sig->transId2); + + fprintf(output, " Close scan: %u\n", sig->closeFlag); + + return false; +} + +bool +printSCANNEXTREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + + if(receiverBlockNo == DBTC){ + const ScanNextReq * const sig = (ScanNextReq *) theData; + + fprintf(output, " aipConnectPtr: H\'%.8x\n", + sig->apiConnectPtr); + + fprintf(output, " transId(1, 2): (H\'%.8x, H\'%.8x)\n", + sig->transId1, sig->transId2); + + fprintf(output, " Stop this scan: %u\n", sig->stopScan); + } + if (receiverBlockNo == DBLQH){ + return printSCANFRAGNEXTREQ(output, theData, len, receiverBlockNo); + } + return false; +} + diff --git a/ndb/src/common/debugger/signaldata/SignalDataPrint.cpp b/ndb/src/common/debugger/signaldata/SignalDataPrint.cpp new file mode 100644 index 00000000000..2236d0c0af1 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/SignalDataPrint.cpp @@ -0,0 +1,254 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + +#include "GlobalSignalNumbers.h" +#include "signaldata/SignalDataPrint.hpp" +#include "signaldata/TcKeyReq.hpp" +#include "signaldata/TcKeyConf.hpp" +#include "signaldata/TcKeyRef.hpp" +#include "signaldata/LqhKey.hpp" +#include "signaldata/TupKey.hpp" +#include "signaldata/TupCommit.hpp" +#include "signaldata/FsOpenReq.hpp" +#include "signaldata/FsCloseReq.hpp" +#include "signaldata/FsReadWriteReq.hpp" +#include "signaldata/FsRef.hpp" +#include "signaldata/FsConf.hpp" +#include "signaldata/CloseComReqConf.hpp" +#include "signaldata/PackedSignal.hpp" +#include "signaldata/PrepFailReqRef.hpp" +#include "signaldata/DictTabInfo.hpp" +#include "signaldata/AlterTable.hpp" +#include "signaldata/AlterTab.hpp" +#include "signaldata/CreateTrig.hpp" +#include "signaldata/AlterTrig.hpp" +#include "signaldata/DropTrig.hpp" +#include "signaldata/FireTrigOrd.hpp" +#include "signaldata/TrigAttrInfo.hpp" +#include "signaldata/CreateIndx.hpp" +#include "signaldata/AlterIndx.hpp" +#include "signaldata/DropIndx.hpp" +#include "signaldata/TcIndx.hpp" +#include "signaldata/IndxKeyInfo.hpp" +#include "signaldata/IndxAttrInfo.hpp" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +bool printCONTINUEB(FILE *, const Uint32 *, Uint32, Uint16); + +/** + * This is the register + */ +const NameFunctionPair +SignalDataPrintFunctions[] = { + { GSN_TCKEYREQ, printTCKEYREQ }, + { GSN_TCKEYCONF, printTCKEYCONF }, + { GSN_TCKEYREF, printTCKEYREF }, + { GSN_LQHKEYREQ, printLQHKEYREQ }, + { GSN_LQHKEYCONF, printLQHKEYCONF }, + { GSN_LQHKEYREF, printLQHKEYREF }, + { GSN_TUPKEYREQ, printTUPKEYREQ }, + { GSN_TUPKEYCONF, printTUPKEYCONF }, + { GSN_TUPKEYREF, printTUPKEYREF }, + { GSN_TUP_COMMITREQ, printTUPCOMMITREQ }, + { GSN_CONTINUEB, printCONTINUEB }, + { GSN_FSOPENREQ, printFSOPENREQ }, + { GSN_FSCLOSEREQ, printFSCLOSEREQ }, + { GSN_FSREADREQ, printFSREADWRITEREQ }, + { GSN_FSWRITEREQ, printFSREADWRITEREQ }, + { GSN_FSCLOSEREF, printFSREF }, + { GSN_FSOPENREF, printFSREF }, + { GSN_FSWRITEREF, printFSREF }, + { GSN_FSREADREF, printFSREF }, + { GSN_FSSYNCREF, printFSREF }, + { GSN_FSCLOSECONF, printFSCONF }, + { GSN_FSOPENCONF, printFSCONF }, + { GSN_FSWRITECONF, printFSCONF }, + { GSN_FSREADCONF, printFSCONF }, + { GSN_FSSYNCCONF, printFSCONF }, + { GSN_CLOSE_COMREQ, printCLOSECOMREQCONF }, + { GSN_CLOSE_COMCONF, printCLOSECOMREQCONF }, + { GSN_PACKED_SIGNAL, printPACKED_SIGNAL }, + { GSN_PREP_FAILREQ, printPREPFAILREQREF }, + { GSN_PREP_FAILREF, printPREPFAILREQREF }, + { GSN_ALTER_TABLE_REQ, printALTER_TABLE_REQ }, + { GSN_ALTER_TABLE_CONF, printALTER_TABLE_CONF }, + { GSN_ALTER_TABLE_REF, printALTER_TABLE_REF }, + { GSN_ALTER_TAB_REQ, printALTER_TAB_REQ }, + { GSN_ALTER_TAB_CONF, printALTER_TAB_CONF }, + { GSN_ALTER_TAB_REF, printALTER_TAB_REF }, + { GSN_CREATE_TRIG_REQ, printCREATE_TRIG_REQ }, + { GSN_CREATE_TRIG_CONF, printCREATE_TRIG_CONF }, + { GSN_CREATE_TRIG_REF, printCREATE_TRIG_REF }, + { GSN_ALTER_TRIG_REQ, printALTER_TRIG_REQ }, + { GSN_ALTER_TRIG_CONF, printALTER_TRIG_CONF }, + { GSN_ALTER_TRIG_REF, printALTER_TRIG_REF }, + { GSN_DROP_TRIG_REQ, printDROP_TRIG_REQ }, + { GSN_DROP_TRIG_CONF, printDROP_TRIG_CONF }, + { GSN_DROP_TRIG_REF, printDROP_TRIG_REF }, + { GSN_FIRE_TRIG_ORD, printFIRE_TRIG_ORD }, + { GSN_TRIG_ATTRINFO, printTRIG_ATTRINFO }, + { GSN_CREATE_INDX_REQ, printCREATE_INDX_REQ }, + { GSN_CREATE_INDX_CONF, printCREATE_INDX_CONF }, + { GSN_CREATE_INDX_REF, printCREATE_INDX_REF }, + { GSN_DROP_INDX_REQ, printDROP_INDX_REQ }, + { GSN_DROP_INDX_CONF, printDROP_INDX_CONF }, + { GSN_DROP_INDX_REF, printDROP_INDX_REF }, + { GSN_ALTER_INDX_REQ, printALTER_INDX_REQ }, + { GSN_ALTER_INDX_CONF, printALTER_INDX_CONF }, + { GSN_ALTER_INDX_REF, printALTER_INDX_REF }, + { GSN_TCINDXREQ, printTCINDXREQ }, + { GSN_TCINDXCONF, printTCINDXCONF }, + { GSN_TCINDXREF, printTCINDXREF }, + { GSN_INDXKEYINFO, printINDXKEYINFO }, + { GSN_INDXATTRINFO, printINDXATTRINFO }, + //{ GSN_TCINDXNEXTREQ, printTCINDXNEXTREQ }, + //{ GSN_TCINDEXNEXTCONF, printTCINDEXNEXTCONF }, + //{ GSN_TCINDEXNEXREF, printTCINDEXNEXREF }, + { GSN_FSAPPENDREQ, printFSAPPENDREQ }, + { GSN_BACKUP_REQ, printBACKUP_REQ }, + { GSN_BACKUP_DATA, printBACKUP_DATA }, + { GSN_BACKUP_REF, printBACKUP_REF }, + { GSN_BACKUP_CONF, printBACKUP_CONF }, + { GSN_ABORT_BACKUP_ORD, printABORT_BACKUP_ORD }, + { GSN_BACKUP_ABORT_REP, printBACKUP_ABORT_REP }, + { GSN_BACKUP_COMPLETE_REP, printBACKUP_COMPLETE_REP }, + { GSN_BACKUP_NF_COMPLETE_REP, printBACKUP_NF_COMPLETE_REP }, + { GSN_DEFINE_BACKUP_REQ, printDEFINE_BACKUP_REQ }, + { GSN_DEFINE_BACKUP_REF, printDEFINE_BACKUP_REF }, + { GSN_DEFINE_BACKUP_CONF, printDEFINE_BACKUP_CONF }, + { GSN_START_BACKUP_REQ, printSTART_BACKUP_REQ }, + { GSN_START_BACKUP_REF, printSTART_BACKUP_REF }, + { GSN_START_BACKUP_CONF, printSTART_BACKUP_CONF }, + { GSN_BACKUP_FRAGMENT_REQ, printBACKUP_FRAGMENT_REQ }, + { GSN_BACKUP_FRAGMENT_REF, printBACKUP_FRAGMENT_REF }, + { GSN_BACKUP_FRAGMENT_CONF, printBACKUP_FRAGMENT_CONF }, + { GSN_STOP_BACKUP_REQ, printSTOP_BACKUP_REQ }, + { GSN_STOP_BACKUP_REF, printSTOP_BACKUP_REF }, + { GSN_STOP_BACKUP_CONF, printSTOP_BACKUP_CONF }, + { GSN_BACKUP_STATUS_REQ, printBACKUP_STATUS_REQ }, + //{ GSN_BACKUP_STATUS_REF, printBACKUP_STATUS_REF }, + { GSN_BACKUP_STATUS_CONF, printBACKUP_STATUS_CONF }, + { GSN_UTIL_SEQUENCE_REQ, printUTIL_SEQUENCE_REQ }, + { GSN_UTIL_SEQUENCE_REF, printUTIL_SEQUENCE_REF }, + { GSN_UTIL_SEQUENCE_CONF, printUTIL_SEQUENCE_CONF }, + { GSN_UTIL_PREPARE_REQ, printUTIL_PREPARE_REQ }, + { GSN_UTIL_PREPARE_REF, printUTIL_PREPARE_REF }, + { GSN_UTIL_PREPARE_CONF, printUTIL_PREPARE_CONF }, + { GSN_UTIL_EXECUTE_REQ, printUTIL_EXECUTE_REQ }, + { GSN_UTIL_EXECUTE_REF, printUTIL_EXECUTE_REF }, + { GSN_UTIL_EXECUTE_CONF, printUTIL_EXECUTE_CONF }, + { GSN_SCAN_TABREQ, printSCANTABREQ }, + { GSN_SCAN_TABCONF, printSCANTABCONF }, + { GSN_SCAN_TABREF, printSCANTABREF }, + { GSN_SCAN_NEXTREQ, printSCANNEXTREQ }, + { GSN_LQHFRAGREQ, printLQH_FRAG_REQ }, + { GSN_LQHFRAGREF, printLQH_FRAG_REF }, + { GSN_LQHFRAGCONF, printLQH_FRAG_CONF }, + { GSN_PREP_DROP_TAB_REQ, printPREP_DROP_TAB_REQ }, + { GSN_PREP_DROP_TAB_REF, printPREP_DROP_TAB_REF }, + { GSN_PREP_DROP_TAB_CONF, printPREP_DROP_TAB_CONF }, + { GSN_DROP_TAB_REQ, printDROP_TAB_REQ }, + { GSN_DROP_TAB_REF, printDROP_TAB_REF }, + { GSN_DROP_TAB_CONF, printDROP_TAB_CONF }, + { GSN_LCP_FRAG_ORD, printLCP_FRAG_ORD }, + { GSN_LCP_FRAG_REP, printLCP_FRAG_REP }, + { GSN_LCP_COMPLETE_REP, printLCP_COMPLETE_REP }, + { GSN_START_LCP_REQ, printSTART_LCP_REQ }, + { GSN_START_LCP_CONF, printSTART_LCP_CONF }, + { GSN_MASTER_LCPREQ, printMASTER_LCP_REQ }, + { GSN_MASTER_LCPREF, printMASTER_LCP_REF }, + { GSN_MASTER_LCPCONF, printMASTER_LCP_CONF }, + { GSN_COPY_GCIREQ, printCOPY_GCI_REQ }, + { GSN_SYSTEM_ERROR, printSYSTEM_ERROR }, + { GSN_START_RECREQ, printSTART_REC_REQ }, + { GSN_START_RECCONF, printSTART_REC_CONF }, + { GSN_NF_COMPLETEREP, printNF_COMPLETE_REP }, + { GSN_SIGNAL_DROPPED_REP, printSIGNAL_DROPPED_REP }, + { GSN_FAIL_REP, printFAIL_REP }, + { GSN_DISCONNECT_REP, printDISCONNECT_REP }, + + { GSN_SUB_CREATE_REQ, printSUB_CREATE_REQ }, + //{ GSN_SUB_CREATE_REF, printSUB_CREATE_REF }, + { GSN_SUB_CREATE_CONF, printSUB_CREATE_CONF }, + { GSN_SUB_START_REQ, printSUB_START_REQ }, + { GSN_SUB_START_REF, printSUB_START_REF }, + { GSN_SUB_START_CONF, printSUB_START_CONF }, + { GSN_SUB_SYNC_REQ, printSUB_SYNC_REQ }, + { GSN_SUB_SYNC_REF, printSUB_SYNC_REF }, + { GSN_SUB_SYNC_CONF, printSUB_SYNC_CONF }, + { GSN_SUB_META_DATA, printSUB_META_DATA }, + { GSN_SUB_TABLE_DATA, printSUB_TABLE_DATA }, + { GSN_SUB_SYNC_CONTINUE_REQ, printSUB_SYNC_CONTINUE_REQ }, + { GSN_SUB_SYNC_CONTINUE_REF, printSUB_SYNC_CONTINUE_REF }, + { GSN_SUB_SYNC_CONTINUE_CONF, printSUB_SYNC_CONTINUE_CONF }, + { GSN_SUB_GCP_COMPLETE_REP, printSUB_GCP_COMPLETE_REP } + + ,{ GSN_CREATE_FRAGMENTATION_REQ, printCREATE_FRAGMENTATION_REQ } + ,{ GSN_CREATE_FRAGMENTATION_REF, printCREATE_FRAGMENTATION_REF } + ,{ GSN_CREATE_FRAGMENTATION_CONF, printCREATE_FRAGMENTATION_CONF } + + ,{ GSN_UTIL_CREATE_LOCK_REQ, printUTIL_CREATE_LOCK_REQ } + ,{ GSN_UTIL_CREATE_LOCK_REF, printUTIL_CREATE_LOCK_REF } + ,{ GSN_UTIL_CREATE_LOCK_CONF, printUTIL_CREATE_LOCK_CONF } + ,{ GSN_UTIL_DESTROY_LOCK_REQ, printUTIL_DESTROY_LOCK_REQ } + ,{ GSN_UTIL_DESTROY_LOCK_REF, printUTIL_DESTROY_LOCK_REF } + ,{ GSN_UTIL_DESTROY_LOCK_CONF, printUTIL_DESTROY_LOCK_CONF } + ,{ GSN_UTIL_LOCK_REQ, printUTIL_LOCK_REQ } + ,{ GSN_UTIL_LOCK_REF, printUTIL_LOCK_REF } + ,{ GSN_UTIL_LOCK_CONF, printUTIL_LOCK_CONF } + ,{ GSN_UTIL_UNLOCK_REQ, printUTIL_UNLOCK_REQ } + ,{ GSN_UTIL_UNLOCK_REF, printUTIL_UNLOCK_REF } + ,{ GSN_UTIL_UNLOCK_CONF, printUTIL_UNLOCK_CONF } + ,{ GSN_TUX_MAINT_REQ, printTUX_MAINT_REQ } + ,{ GSN_TUP_READ_ATTRS, printTUP_READ_ATTRS } + ,{ GSN_TUP_QUERY_TH, printTUP_QUERY_TH } + ,{ GSN_TUP_STORE_TH, printTUP_STORE_TH } + ,{ GSN_ACC_LOCKREQ, printACC_LOCKREQ } + ,{ GSN_LQH_TRANSCONF, printLQH_TRANSCONF } +}; + +const unsigned short NO_OF_PRINT_FUNCTIONS = sizeof(SignalDataPrintFunctions)/sizeof(NameFunctionPair); + + + diff --git a/ndb/src/common/debugger/signaldata/SignalDroppedRep.cpp b/ndb/src/common/debugger/signaldata/SignalDroppedRep.cpp new file mode 100644 index 00000000000..be31b4edb22 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/SignalDroppedRep.cpp @@ -0,0 +1,34 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include + +bool +printSIGNAL_DROPPED_REP(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 recBlockNo){ + SignalDroppedRep * sig = (SignalDroppedRep*)theData; + + fprintf(output, " originalGsn: %s(%d) Length: %d SectionCount: %d\n", + getSignalName(sig->originalGsn), + sig->originalGsn, + sig->originalLength, + sig->originalSectionCount); + return false; +} diff --git a/ndb/src/common/debugger/signaldata/SignalNames.cpp b/ndb/src/common/debugger/signaldata/SignalNames.cpp new file mode 100644 index 00000000000..4e5c8603db1 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/SignalNames.cpp @@ -0,0 +1,673 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "GlobalSignalNumbers.h" + +const GsnName SignalNames [] = { + { GSN_API_REGCONF, "API_REGCONF" } + ,{ GSN_API_REGREF, "API_REGREF" } + ,{ GSN_API_REGREQ, "API_REGREQ" } + ,{ GSN_ATTRINFO, "ATTRINFO" } + ,{ GSN_SCHEMA_INFO, "SCHEMA_INFO" } + ,{ GSN_SCHEMA_INFOCONF, "SCHEMA_INFOCONF" } + ,{ GSN_GET_SCHEMA_INFOREQ, "GET_SCHEMA_INFOREQ" } + ,{ GSN_DIHNDBTAMPER, "DIHNDBTAMPER" } + ,{ GSN_KEYINFO, "KEYINFO" } + ,{ GSN_KEYINFO20, "KEYINFO20" } + ,{ GSN_KEYINFO20_R, "KEYINFO20_R" } + ,{ GSN_NODE_FAILREP, "NODE_FAILREP" } + ,{ GSN_READCONF, "READCONF" } + ,{ GSN_SCAN_NEXTREQ, "SCAN_NEXTREQ" } + ,{ GSN_SCAN_TABCONF, "SCAN_TABCONF" } + ,{ GSN_SCAN_TABINFO, "SCAN_TABINFO" } + ,{ GSN_SCAN_TABREF, "SCAN_TABREF" } + ,{ GSN_SCAN_TABREQ, "SCAN_TABREQ" } + ,{ GSN_TC_COMMITCONF, "TC_COMMITCONF" } + ,{ GSN_TC_COMMITREF, "TC_COMMITREF" } + ,{ GSN_TC_COMMITREQ, "TC_COMMITREQ" } + ,{ GSN_TCKEY_FAILCONF, "TCKEY_FAILCONF" } + ,{ GSN_TCKEY_FAILREF, "TCKEY_FAILREF" } + ,{ GSN_TCKEYCONF, "TCKEYCONF" } + ,{ GSN_TCKEYREF, "TCKEYREF" } + ,{ GSN_TCKEYREQ, "TCKEYREQ" } + ,{ GSN_TCRELEASECONF, "TCRELEASECONF" } + ,{ GSN_TCRELEASEREF, "TCRELEASEREF" } + ,{ GSN_TCRELEASEREQ, "TCRELEASEREQ" } + ,{ GSN_TCROLLBACKCONF, "TCROLLBACKCONF" } + ,{ GSN_TCROLLBACKREF, "TCROLLBACKREF" } + ,{ GSN_TCROLLBACKREQ, "TCROLLBACKREQ" } + ,{ GSN_TCROLLBACKREP, "TCROLLBACKREP" } + ,{ GSN_TCSEIZECONF, "TCSEIZECONF" } + ,{ GSN_TCSEIZEREF, "TCSEIZEREF" } + ,{ GSN_TCSEIZEREQ, "TCSEIZEREQ" } + ,{ GSN_TRANSID_AI, "TRANSID_AI" } + ,{ GSN_TRANSID_AI_R, "TRANSID_AI_R" } + ,{ GSN_ABORT, "ABORT" } + ,{ GSN_ABORTCONF, "ABORTCONF" } + ,{ GSN_ABORTED, "ABORTED" } + ,{ GSN_ABORTREQ, "ABORTREQ" } + ,{ GSN_ACC_ABORTCONF, "ACC_ABORTCONF" } + ,{ GSN_ACC_ABORTREQ, "ACC_ABORTREQ" } + ,{ GSN_ACC_CHECK_SCAN, "ACC_CHECK_SCAN" } + ,{ GSN_ACC_COMMITCONF, "ACC_COMMITCONF" } + ,{ GSN_ACC_COMMITREQ, "ACC_COMMITREQ" } + ,{ GSN_ACC_CONTOPCONF, "ACC_CONTOPCONF" } + ,{ GSN_ACC_CONTOPREQ, "ACC_CONTOPREQ" } + ,{ GSN_ACC_LCPCONF, "ACC_LCPCONF" } + ,{ GSN_ACC_LCPREF, "ACC_LCPREF" } + ,{ GSN_ACC_LCPREQ, "ACC_LCPREQ" } + ,{ GSN_ACC_LCPSTARTED, "ACC_LCPSTARTED" } + ,{ GSN_ACC_OVER_REC, "ACC_OVER_REC" } + ,{ GSN_ACC_SAVE_PAGES, "ACC_SAVE_PAGES" } + ,{ GSN_ACC_SCAN_INFO, "ACC_SCAN_INFO" } + ,{ GSN_ACC_SCAN_INFO24, "ACC_SCAN_INFO24" } + ,{ GSN_ACC_SCANCONF, "ACC_SCANCONF" } + ,{ GSN_ACC_SCANREF, "ACC_SCANREF" } + ,{ GSN_ACC_SCANREQ, "ACC_SCANREQ" } + ,{ GSN_ACC_SRCONF, "ACC_SRCONF" } + ,{ GSN_ACC_SRREF, "ACC_SRREF" } + ,{ GSN_ACC_SRREQ, "ACC_SRREQ" } + ,{ GSN_ACC_TO_CONF, "ACC_TO_CONF" } + ,{ GSN_ACC_TO_REF, "ACC_TO_REF" } + ,{ GSN_ACC_TO_REQ, "ACC_TO_REQ" } + ,{ GSN_ACCFRAGCONF, "ACCFRAGCONF" } + ,{ GSN_ACCFRAGREF, "ACCFRAGREF" } + ,{ GSN_ACCFRAGREQ, "ACCFRAGREQ" } + ,{ GSN_ACCKEYCONF, "ACCKEYCONF" } + ,{ GSN_ACCKEYREF, "ACCKEYREF" } + ,{ GSN_ACCKEYREQ, "ACCKEYREQ" } + ,{ GSN_ACCMINUPDATE, "ACCMINUPDATE" } + ,{ GSN_ACCSEIZECONF, "ACCSEIZECONF" } + ,{ GSN_ACCSEIZEREF, "ACCSEIZEREF" } + ,{ GSN_ACCSEIZEREQ, "ACCSEIZEREQ" } + ,{ GSN_ACCUPDATECONF, "ACCUPDATECONF" } + ,{ GSN_ACCUPDATEKEY, "ACCUPDATEKEY" } + ,{ GSN_ACCUPDATEREF, "ACCUPDATEREF" } + ,{ GSN_ADD_FRAGCONF, "ADD_FRAGCONF" } + ,{ GSN_ADD_FRAGREF, "ADD_FRAGREF" } + ,{ GSN_ADD_FRAGREQ, "ADD_FRAGREQ" } + ,{ GSN_API_FAILCONF, "API_FAILCONF" } + ,{ GSN_API_FAILREQ, "API_FAILREQ" } + ,{ GSN_APPL_CHANGEREP, "APPL_CHANGEREP" } + // ,{ GSN_APPL_ERROR, "APPL_ERROR" } + ,{ GSN_APPL_HB, "APPL_HB" } + ,{ GSN_APPL_HBREQ, "APPL_HBREQ" } + ,{ GSN_APPL_REGCONF, "APPL_REGCONF" } + ,{ GSN_APPL_REGREF, "APPL_REGREF" } + ,{ GSN_APPL_REGREQ, "APPL_REGREQ" } + ,{ GSN_APPL_RUN, "APPL_RUN" } + ,{ GSN_APPL_STARTCONF, "APPL_STARTCONF" } + ,{ GSN_APPL_STARTREG, "APPL_STARTREG" } + ,{ GSN_CHECK_LCP_STOP, "CHECK_LCP_STOP" } + ,{ GSN_CLOSE_COMCONF, "CLOSE_COMCONF" } + ,{ GSN_CLOSE_COMREQ, "CLOSE_COMREQ" } + ,{ GSN_CM_ACKADD, "CM_ACKADD" } + ,{ GSN_CM_ACKALARM, "CM_ACKALARM" } + ,{ GSN_CM_ADD, "CM_ADD" } + ,{ GSN_CM_APPCHG, "CM_APPCHG" } + ,{ GSN_CM_HEARTBEAT, "CM_HEARTBEAT" } + ,{ GSN_CM_INFOCONF, "CM_INFOCONF" } + ,{ GSN_CM_INFOREQ, "CM_INFOREQ" } + ,{ GSN_CM_INIT, "CM_INIT" } + ,{ GSN_CM_NODEINFOCONF, "CM_NODEINFOCONF" } + ,{ GSN_CM_NODEINFOREF, "CM_NODEINFOREF" } + ,{ GSN_CM_NODEINFOREQ, "CM_NODEINFOREQ" } + ,{ GSN_CM_REGCONF, "CM_REGCONF" } + ,{ GSN_CM_REGREF, "CM_REGREF" } + ,{ GSN_CM_REGREQ, "CM_REGREQ" } + ,{ GSN_CM_RUN, "CM_RUN" } + ,{ GSN_CMVMI_CFGCONF, "CMVMI_CFGCONF" } + ,{ GSN_CMVMI_CFGREQ, "CMVMI_CFGREQ" } + ,{ GSN_CNTR_CHANGEREP, "CNTR_CHANGEREP" } + ,{ GSN_CNTR_MASTERCONF, "CNTR_MASTERCONF" } + ,{ GSN_CNTR_MASTERREF, "CNTR_MASTERREF" } + ,{ GSN_CNTR_MASTERREQ, "CNTR_MASTERREQ" } + ,{ GSN_CNTR_WAITREP, "CNTR_WAITREP" } + ,{ GSN_COMMIT, "COMMIT" } + ,{ GSN_COMMIT_FAILCONF, "COMMIT_FAILCONF" } + ,{ GSN_COMMIT_FAILREQ, "COMMIT_FAILREQ" } + ,{ GSN_COMMITCONF, "COMMITCONF" } + ,{ GSN_COMMITREQ, "COMMITREQ" } + ,{ GSN_COMMITTED, "COMMITTED" } + ,{ GSN_LCP_FRAG_ORD, "LCP_FRAG_ORD" } + ,{ GSN_LCP_FRAG_REP, "LCP_FRAG_REP" } + ,{ GSN_LCP_COMPLETE_REP, "LCP_COMPLETE_REP" } + ,{ GSN_START_LCP_REQ, "START_LCP_REQ" } + ,{ GSN_START_LCP_CONF, "START_LCP_CONF" } + ,{ GSN_COMPLETE, "COMPLETE" } + ,{ GSN_COMPLETECONF, "COMPLETECONF" } + ,{ GSN_COMPLETED, "COMPLETED" } + ,{ GSN_COMPLETEREQ, "COMPLETEREQ" } + ,{ GSN_CONNECT_REP, "CONNECT_REP" } + ,{ GSN_CONTINUEB, "CONTINUEB" } + ,{ GSN_COPY_ACTIVECONF, "COPY_ACTIVECONF" } + ,{ GSN_COPY_ACTIVEREF, "COPY_ACTIVEREF" } + ,{ GSN_COPY_ACTIVEREQ, "COPY_ACTIVEREQ" } + ,{ GSN_COPY_FRAGCONF, "COPY_FRAGCONF" } + ,{ GSN_COPY_FRAGREF, "COPY_FRAGREF" } + ,{ GSN_COPY_FRAGREQ, "COPY_FRAGREQ" } + ,{ GSN_COPY_GCICONF, "COPY_GCICONF" } + ,{ GSN_COPY_GCIREQ, "COPY_GCIREQ" } + ,{ GSN_COPY_STATECONF, "COPY_STATECONF" } + ,{ GSN_COPY_STATEREQ, "COPY_STATEREQ" } + ,{ GSN_COPY_TABCONF, "COPY_TABCONF" } + ,{ GSN_COPY_TABREQ, "COPY_TABREQ" } + ,{ GSN_CREATE_FRAGCONF, "CREATE_FRAGCONF" } + ,{ GSN_CREATE_FRAGREF, "CREATE_FRAGREF" } + ,{ GSN_CREATE_FRAGREQ, "CREATE_FRAGREQ" } + ,{ GSN_DEBUG_SIG, "DEBUG_SIG" } + ,{ GSN_DI_FCOUNTCONF, "DI_FCOUNTCONF" } + ,{ GSN_DI_FCOUNTREF, "DI_FCOUNTREF" } + ,{ GSN_DI_FCOUNTREQ, "DI_FCOUNTREQ" } + ,{ GSN_DIADDTABCONF, "DIADDTABCONF" } + ,{ GSN_DIADDTABREF, "DIADDTABREF" } + ,{ GSN_DIADDTABREQ, "DIADDTABREQ" } + ,{ GSN_DICTSTARTCONF, "DICTSTARTCONF" } + ,{ GSN_DICTSTARTREQ, "DICTSTARTREQ" } + ,{ GSN_LIST_TABLES_REQ, "LIST_TABLES_REQ" } + ,{ GSN_LIST_TABLES_CONF, "LIST_TABLES_CONF" } + ,{ GSN_DIGETNODESCONF, "DIGETNODESCONF" } + ,{ GSN_DIGETNODESREF, "DIGETNODESREF" } + ,{ GSN_DIGETNODESREQ, "DIGETNODESREQ" } + ,{ GSN_DIGETPRIMCONF, "DIGETPRIMCONF" } + ,{ GSN_DIGETPRIMREF, "DIGETPRIMREF" } + ,{ GSN_DIGETPRIMREQ, "DIGETPRIMREQ" } + ,{ GSN_DIH_RESTARTCONF, "DIH_RESTARTCONF" } + ,{ GSN_DIH_RESTARTREF, "DIH_RESTARTREF" } + ,{ GSN_DIH_RESTARTREQ, "DIH_RESTARTREQ" } + + ,{ GSN_DIRELEASECONF, "DIRELEASECONF" } + ,{ GSN_DIRELEASEREF, "DIRELEASEREF" } + ,{ GSN_DIRELEASEREQ, "DIRELEASEREQ" } + ,{ GSN_DISCONNECT_REP, "DISCONNECT_REP" } + ,{ GSN_DISEIZECONF, "DISEIZECONF" } + ,{ GSN_DISEIZEREF, "DISEIZEREF" } + ,{ GSN_DISEIZEREQ, "DISEIZEREQ" } + ,{ GSN_DIVERIFYCONF, "DIVERIFYCONF" } + ,{ GSN_DIVERIFYREF, "DIVERIFYREF" } + ,{ GSN_DIVERIFYREQ, "DIVERIFYREQ" } + ,{ GSN_EMPTY_LCP_REQ, "EMPTY_LCP_REQ" } + ,{ GSN_EMPTY_LCP_CONF, "EMPTY_LCP_CONF" } + ,{ GSN_ENABLE_COMORD, "ENABLE_COMORD" } + ,{ GSN_END_LCPCONF, "END_LCPCONF" } + ,{ GSN_END_LCPREQ, "END_LCPREQ" } + ,{ GSN_END_TOCONF, "END_TOCONF" } + ,{ GSN_END_TOREQ, "END_TOREQ" } + ,{ GSN_EVENT_REP, "EVENT_REP" } + ,{ GSN_EXEC_FRAGCONF, "EXEC_FRAGCONF" } + ,{ GSN_EXEC_FRAGREF, "EXEC_FRAGREF" } + ,{ GSN_EXEC_FRAGREQ, "EXEC_FRAGREQ" } + ,{ GSN_EXEC_SRCONF, "EXEC_SRCONF" } + ,{ GSN_EXEC_SRREQ, "EXEC_SRREQ" } + ,{ GSN_EXPANDCHECK2, "EXPANDCHECK2" } + ,{ GSN_FAIL_REP, "FAIL_REP" } + ,{ GSN_FSCLOSECONF, "FSCLOSECONF" } + ,{ GSN_FSCLOSEREF, "FSCLOSEREF" } + ,{ GSN_FSCLOSEREQ, "FSCLOSEREQ" } + ,{ GSN_FSOPENCONF, "FSOPENCONF" } + ,{ GSN_FSOPENREF, "FSOPENREF" } + ,{ GSN_FSOPENREQ, "FSOPENREQ" } + ,{ GSN_FSREADCONF, "FSREADCONF" } + ,{ GSN_FSREADREF, "FSREADREF" } + ,{ GSN_FSREADREQ, "FSREADREQ" } + ,{ GSN_FSSYNCCONF, "FSSYNCCONF" } + ,{ GSN_FSSYNCREF, "FSSYNCREF" } + ,{ GSN_FSSYNCREQ, "FSSYNCREQ" } + ,{ GSN_FSWRITECONF, "FSWRITECONF" } + ,{ GSN_FSWRITEREF, "FSWRITEREF" } + ,{ GSN_FSWRITEREQ, "FSWRITEREQ" } + ,{ GSN_FSAPPENDCONF, "FSAPPENDCONF" } + ,{ GSN_FSAPPENDREF, "FSAPPENDREF" } + ,{ GSN_FSAPPENDREQ, "FSAPPENDREQ" } + ,{ GSN_FSREMOVECONF, "FSREMOVECONF" } + ,{ GSN_FSREMOVEREF, "FSREMOVEREF" } + ,{ GSN_FSREMOVEREQ, "FSREMOVEREQ" } + ,{ GSN_GCP_ABORT, "GCP_ABORT" } + ,{ GSN_GCP_ABORTED, "GCP_ABORTED" } + ,{ GSN_GCP_COMMIT, "GCP_COMMIT" } + ,{ GSN_GCP_NODEFINISH, "GCP_NODEFINISH" } + ,{ GSN_GCP_NOMORETRANS, "GCP_NOMORETRANS" } + ,{ GSN_GCP_PREPARE, "GCP_PREPARE" } + ,{ GSN_GCP_PREPARECONF, "GCP_PREPARECONF" } + ,{ GSN_GCP_PREPAREREF, "GCP_PREPAREREF" } + ,{ GSN_GCP_SAVECONF, "GCP_SAVECONF" } + ,{ GSN_GCP_SAVEREF, "GCP_SAVEREF" } + ,{ GSN_GCP_SAVEREQ, "GCP_SAVEREQ" } + ,{ GSN_GCP_TCFINISHED, "GCP_TCFINISHED" } + ,{ GSN_GET_TABINFOREF, "GET_TABINFOREF" } + ,{ GSN_GET_TABINFOREQ, "GET_TABINFOREQ" } + ,{ GSN_GET_TABINFO_CONF, "GET_TABINFO_CONF" } + ,{ GSN_GETGCICONF, "GETGCICONF" } + ,{ GSN_GETGCIREQ, "GETGCIREQ" } + ,{ GSN_HOT_SPAREREP, "HOT_SPAREREP" } + ,{ GSN_INCL_NODECONF, "INCL_NODECONF" } + ,{ GSN_INCL_NODEREF, "INCL_NODEREF" } + ,{ GSN_INCL_NODEREQ, "INCL_NODEREQ" } + ,{ GSN_LCP_FRAGIDCONF, "LCP_FRAGIDCONF" } + ,{ GSN_LCP_FRAGIDREF, "LCP_FRAGIDREF" } + ,{ GSN_LCP_FRAGIDREQ, "LCP_FRAGIDREQ" } + ,{ GSN_LCP_HOLDOPCONF, "LCP_HOLDOPCONF" } + ,{ GSN_LCP_HOLDOPREF, "LCP_HOLDOPREF" } + ,{ GSN_LCP_HOLDOPREQ, "LCP_HOLDOPREQ" } + ,{ GSN_LQH_RESTART_OP, "LQH_RESTART_OP" } + ,{ GSN_LQH_TRANSCONF, "LQH_TRANSCONF" } + ,{ GSN_LQH_TRANSREQ, "LQH_TRANSREQ" } + ,{ GSN_LQHADDATTCONF, "LQHADDATTCONF" } + ,{ GSN_LQHADDATTREF, "LQHADDATTREF" } + ,{ GSN_LQHADDATTREQ, "LQHADDATTREQ" } + ,{ GSN_LQHFRAGCONF, "LQHFRAGCONF" } + ,{ GSN_LQHFRAGREF, "LQHFRAGREF" } + ,{ GSN_LQHFRAGREQ, "LQHFRAGREQ" } + ,{ GSN_LQHKEYCONF, "LQHKEYCONF" } + ,{ GSN_LQHKEYREF, "LQHKEYREF" } + ,{ GSN_LQHKEYREQ, "LQHKEYREQ" } + ,{ GSN_MASTER_GCPCONF, "MASTER_GCPCONF" } + ,{ GSN_MASTER_GCPREF, "MASTER_GCPREF" } + ,{ GSN_MASTER_GCPREQ, "MASTER_GCPREQ" } + ,{ GSN_MASTER_LCPCONF, "MASTER_LCPCONF" } + ,{ GSN_MASTER_LCPREF, "MASTER_LCPREF" } + ,{ GSN_MASTER_LCPREQ, "MASTER_LCPREQ" } + ,{ GSN_MEMCHECKCONF, "MEMCHECKCONF" } + ,{ GSN_MEMCHECKREQ, "MEMCHECKREQ" } + ,{ GSN_NDB_FAILCONF, "NDB_FAILCONF" } + ,{ GSN_NDB_STARTCONF, "NDB_STARTCONF" } + ,{ GSN_NDB_STARTREF, "NDB_STARTREF" } + ,{ GSN_NDB_STARTREQ, "NDB_STARTREQ" } + ,{ GSN_NDB_STTOR, "NDB_STTOR" } + ,{ GSN_NDB_STTORRY, "NDB_STTORRY" } + ,{ GSN_NDB_TAMPER, "NDB_TAMPER" } + ,{ GSN_NEXT_SCANCONF, "NEXT_SCANCONF" } + ,{ GSN_NEXT_SCANREF, "NEXT_SCANREF" } + ,{ GSN_NEXT_SCANREQ, "NEXT_SCANREQ" } + ,{ GSN_NEXTOPERATION, "NEXTOPERATION" } + ,{ GSN_NF_COMPLETEREP, "NF_COMPLETEREP" } + ,{ GSN_NODE_STATESCONF, "NODE_STATESCONF" } + ,{ GSN_NODE_STATESREF, "NODE_STATESREF" } + ,{ GSN_NODE_STATESREQ, "NODE_STATESREQ" } + ,{ GSN_OPEN_COMCONF, "OPEN_COMCONF" } + ,{ GSN_OPEN_COMREF, "OPEN_COMREF" } + ,{ GSN_OPEN_COMREQ, "OPEN_COMREQ" } + ,{ GSN_PACKED_SIGNAL, "PACKED_SIGNAL" } + ,{ GSN_PREP_FAILCONF, "PREP_FAILCONF" } + ,{ GSN_PREP_FAILREF, "PREP_FAILREF" } + ,{ GSN_PREP_FAILREQ, "PREP_FAILREQ" } + ,{ GSN_PRES_TOCONF, "PRES_TOCONF" } + ,{ GSN_PRES_TOREQ, "PRES_TOREQ" } + ,{ GSN_READ_NODESCONF, "READ_NODESCONF" } + ,{ GSN_READ_NODESREF, "READ_NODESREF" } + ,{ GSN_READ_NODESREQ, "READ_NODESREQ" } + ,{ GSN_SCAN_FRAGCONF, "SCAN_FRAGCONF" } + ,{ GSN_SCAN_FRAGREF, "SCAN_FRAGREF" } + ,{ GSN_SCAN_FRAGREQ, "SCAN_FRAGREQ" } + ,{ GSN_SCAN_HBREP, "SCAN_HBREP" } + ,{ GSN_SCAN_PROCCONF, "SCAN_PROCCONF" } + ,{ GSN_SCAN_PROCREQ, "SCAN_PROCREQ" } + ,{ GSN_SEND_PACKED, "SEND_PACKED" } + ,{ GSN_SET_LOGLEVELORD, "SET_LOGLEVELORD" } + ,{ GSN_SHRINKCHECK2, "SHRINKCHECK2" } + ,{ GSN_SIZEALT_ACK, "SIZEALT_ACK" } + ,{ GSN_SIZEALT_REP, "SIZEALT_REP" } + ,{ GSN_SR_FRAGIDCONF, "SR_FRAGIDCONF" } + ,{ GSN_SR_FRAGIDREF, "SR_FRAGIDREF" } + ,{ GSN_SR_FRAGIDREQ, "SR_FRAGIDREQ" } + ,{ GSN_START_COPYCONF, "START_COPYCONF" } + ,{ GSN_START_COPYREF, "START_COPYREF" } + ,{ GSN_START_COPYREQ, "START_COPYREQ" } + ,{ GSN_START_EXEC_SR, "START_EXEC_SR" } + ,{ GSN_START_FRAGCONF, "START_FRAGCONF" } + ,{ GSN_START_FRAGREF, "START_FRAGREF" } + ,{ GSN_START_FRAGREQ, "START_FRAGREQ" } + ,{ GSN_START_LCP_REF, "START_LCP_REF" } + ,{ GSN_START_LCP_ROUND, "START_LCP_ROUND" } + ,{ GSN_START_MECONF, "START_MECONF" } + ,{ GSN_START_MEREF, "START_MEREF" } + ,{ GSN_START_MEREQ, "START_MEREQ" } + ,{ GSN_START_PERMCONF, "START_PERMCONF" } + ,{ GSN_START_PERMREF, "START_PERMREF" } + ,{ GSN_START_PERMREQ, "START_PERMREQ" } + ,{ GSN_START_RECCONF, "START_RECCONF" } + ,{ GSN_START_RECREF, "START_RECREF" } + ,{ GSN_START_RECREQ, "START_RECREQ" } + ,{ GSN_START_TOCONF, "START_TOCONF" } + ,{ GSN_START_TOREQ, "START_TOREQ" } + ,{ GSN_STORED_PROCCONF, "STORED_PROCCONF" } + ,{ GSN_STORED_PROCREF, "STORED_PROCREF" } + ,{ GSN_STORED_PROCREQ, "STORED_PROCREQ" } + ,{ GSN_STTOR, "STTOR" } + ,{ GSN_STTORRY, "STTORRY" } + ,{ GSN_SYSTEM_ERROR, "SYSTEM_ERROR" } + ,{ GSN_TAB_COMMITCONF, "TAB_COMMITCONF" } + ,{ GSN_TAB_COMMITREF, "TAB_COMMITREF" } + ,{ GSN_TAB_COMMITREQ, "TAB_COMMITREQ" } + ,{ GSN_TAKE_OVERTCCONF, "TAKE_OVERTCCONF" } + ,{ GSN_TAKE_OVERTCREQ, "TAKE_OVERTCREQ" } + ,{ GSN_TC_CLOPSIZECONF, "TC_CLOPSIZECONF" } + ,{ GSN_TC_CLOPSIZEREQ, "TC_CLOPSIZEREQ" } + ,{ GSN_TC_SCHVERCONF, "TC_SCHVERCONF" } + ,{ GSN_TC_SCHVERREQ, "TC_SCHVERREQ" } + ,{ GSN_TCGETOPSIZECONF, "TCGETOPSIZECONF" } + ,{ GSN_TCGETOPSIZEREQ, "TCGETOPSIZEREQ" } + ,{ GSN_TEST_ORD, "TEST_ORD" } + ,{ GSN_TESTSIG, "TESTSIG" } + ,{ GSN_TIME_SIGNAL, "TIME_SIGNAL" } + ,{ GSN_TUP_ABORTREQ, "TUP_ABORTREQ" } + ,{ GSN_TUP_ADD_ATTCONF, "TUP_ADD_ATTCONF" } + ,{ GSN_TUP_ADD_ATTRREF, "TUP_ADD_ATTRREF" } + ,{ GSN_TUP_ADD_ATTRREQ, "TUP_ADD_ATTRREQ" } + ,{ GSN_TUP_ATTRINFO, "TUP_ATTRINFO" } + ,{ GSN_TUP_COMMITREQ, "TUP_COMMITREQ" } + ,{ GSN_TUP_LCPCONF, "TUP_LCPCONF" } + ,{ GSN_TUP_LCPREF, "TUP_LCPREF" } + ,{ GSN_TUP_LCPREQ, "TUP_LCPREQ" } + ,{ GSN_TUP_LCPSTARTED, "TUP_LCPSTARTED" } + ,{ GSN_TUP_PREPLCPCONF, "TUP_PREPLCPCONF" } + ,{ GSN_TUP_PREPLCPREF, "TUP_PREPLCPREF" } + ,{ GSN_TUP_PREPLCPREQ, "TUP_PREPLCPREQ" } + ,{ GSN_TUP_SRCONF, "TUP_SRCONF" } + ,{ GSN_TUP_SRREF, "TUP_SRREF" } + ,{ GSN_TUP_SRREQ, "TUP_SRREQ" } + ,{ GSN_TUPFRAGCONF, "TUPFRAGCONF" } + ,{ GSN_TUPFRAGREF, "TUPFRAGREF" } + ,{ GSN_TUPFRAGREQ, "TUPFRAGREQ" } + ,{ GSN_TUPKEYCONF, "TUPKEYCONF" } + ,{ GSN_TUPKEYREF, "TUPKEYREF" } + ,{ GSN_TUPKEYREQ, "TUPKEYREQ" } + ,{ GSN_TUPRELEASECONF, "TUPRELEASECONF" } + ,{ GSN_TUPRELEASEREF, "TUPRELEASEREF" } + ,{ GSN_TUPRELEASEREQ, "TUPRELEASEREQ" } + ,{ GSN_TUPSEIZECONF, "TUPSEIZECONF" } + ,{ GSN_TUPSEIZEREF, "TUPSEIZEREF" } + ,{ GSN_TUPSEIZEREQ, "TUPSEIZEREQ" } + ,{ GSN_UNBLO_DICTCONF, "UNBLO_DICTCONF" } + ,{ GSN_UNBLO_DICTREQ, "UNBLO_DICTREQ" } + ,{ GSN_UPDATE_TOCONF, "UPDATE_TOCONF" } + ,{ GSN_UPDATE_TOREF, "UPDATE_TOREF" } + ,{ GSN_UPDATE_TOREQ, "UPDATE_TOREQ" } + ,{ GSN_VOTE_MASTERORD, "VOTE_MASTERORD" } + ,{ GSN_TUP_ALLOCREQ, "TUP_ALLOCREQ" } + ,{ GSN_LQH_ALLOCREQ, "LQH_ALLOCREQ" } + ,{ GSN_TUP_DEALLOCREQ, "TUP_DEALLOCREQ" } + ,{ GSN_TUP_WRITELOG_REQ, "TUP_WRITELOG_REQ" } + ,{ GSN_LQH_WRITELOG_REQ, "LQH_WRITELOG_REQ" } + + ,{ GSN_STATISTICS_REQ, "STATISTICS_REQ" } + ,{ GSN_START_ORD, "START_ORD" } + ,{ GSN_STOP_ORD, "STOP_ORD" } + ,{ GSN_TAMPER_ORD, "TAMPER_ORD" } + ,{ GSN_SET_VAR_REQ, "SET_VAR_REQ" } + ,{ GSN_SET_VAR_CONF, "SET_VAR_CONF" } + ,{ GSN_SET_VAR_REF, "SET_VAR_REF" } + ,{ GSN_STATISTICS_CONF, "STATISTICS_CONF" } + + ,{ GSN_EVENT_SUBSCRIBE_REQ, "EVENT_SUBSCRIBE_REQ" } + ,{ GSN_EVENT_SUBSCRIBE_CONF, "EVENT_SUBSCRIBE_CONF" } + ,{ GSN_EVENT_SUBSCRIBE_REF, "EVENT_SUBSCRIBE_REF" } + ,{ GSN_ACC_COM_BLOCK, "ACC_COM_BLOCK" } + ,{ GSN_ACC_COM_UNBLOCK, "ACC_COM_UNBLOCK" } + ,{ GSN_TUP_COM_BLOCK, "TUP_COM_BLOCK" } + ,{ GSN_TUP_COM_UNBLOCK, "TUP_COM_UNBLOCK" } + ,{ GSN_DUMP_STATE_ORD, "DUMP_STATE_ORD" } + + ,{ GSN_START_INFOREQ, "START_INFOREQ" } + ,{ GSN_START_INFOREF, "START_INFOREF" } + ,{ GSN_START_INFOCONF, "START_INFOCONF" } + + ,{ GSN_CHECKNODEGROUPSREQ, "CHECKNODEGROUPSREQ" } + ,{ GSN_CHECKNODEGROUPSCONF, "CHECKNODEGROUPSCONF" } + + ,{ GSN_ARBIT_CFG, "ARBIT_CFG" } + ,{ GSN_ARBIT_PREPREQ, "ARBIT_PREPREQ" } + ,{ GSN_ARBIT_PREPCONF, "ARBIT_PREPCONF" } + ,{ GSN_ARBIT_PREPREF, "ARBIT_PREPREF" } + ,{ GSN_ARBIT_STARTREQ, "ARBIT_STARTREQ" } + ,{ GSN_ARBIT_STARTCONF, "ARBIT_STARTCONF" } + ,{ GSN_ARBIT_STARTREF, "ARBIT_STARTREF" } + ,{ GSN_ARBIT_CHOOSEREQ, "ARBIT_CHOOSEREQ" } + ,{ GSN_ARBIT_CHOOSECONF, "ARBIT_CHOOSECONF" } + ,{ GSN_ARBIT_CHOOSEREF, "ARBIT_CHOOSEREF" } + ,{ GSN_ARBIT_STOPORD, "ARBIT_STOPORD" } + ,{ GSN_ARBIT_STOPREP, "ARBIT_STOPREP" } + + ,{ GSN_TC_COMMIT_ACK, "TC_COMMIT_ACK" } + ,{ GSN_REMOVE_MARKER_ORD, "REMOVE_MARKER_ORD" } + + ,{ GSN_NODE_STATE_REP, "NODE_STATE_REP" } + ,{ GSN_CHANGE_NODE_STATE_REQ, "CHANGE_NODE_STATE_REQ" } + ,{ GSN_CHANGE_NODE_STATE_CONF, "CHANGE_NODE_STATE_CONF" } + + ,{ GSN_BLOCK_COMMIT_ORD, "BLOCK_COMMIT_ORD" } + ,{ GSN_UNBLOCK_COMMIT_ORD, "UNBLOCK_COMMIT_ORD" } + + ,{ GSN_DIH_SWITCH_REPLICA_REQ, "DIH_SWITCH_REPLICA_REQ" } + ,{ GSN_DIH_SWITCH_REPLICA_REF, "DIH_SWITCH_REPLICA_REF" } + ,{ GSN_DIH_SWITCH_REPLICA_CONF, "DIH_SWITCH_REPLICA_CONF" } + + ,{ GSN_STOP_PERM_REQ, "STOP_PERM_REQ" } + ,{ GSN_STOP_PERM_REF, "STOP_PERM_REF" } + ,{ GSN_STOP_PERM_CONF, "STOP_PERM_CONF" } + + ,{ GSN_STOP_ME_REQ, "STOP_ME_REQ" } + ,{ GSN_STOP_ME_REF, "STOP_ME_REF" } + ,{ GSN_STOP_ME_CONF, "STOP_ME_CONF" } + + ,{ GSN_WAIT_GCP_REQ, "WAIT_GCP_REQ" } + ,{ GSN_WAIT_GCP_REF, "WAIT_GCP_REF" } + ,{ GSN_WAIT_GCP_CONF, "WAIT_GCP_CONF" } + + ,{ GSN_STOP_REQ, "STOP_REQ" } + ,{ GSN_STOP_REF, "STOP_REF" } + + ,{ GSN_ABORT_ALL_REQ, "ABORT_ALL_REQ" } + ,{ GSN_ABORT_ALL_REF, "ABORT_ALL_REF" } + ,{ GSN_ABORT_ALL_CONF, "ABORT_ALL_CONF" } + + ,{ GSN_DROP_TABLE_REQ, "DROP_TABLE_REQ" } + ,{ GSN_DROP_TABLE_REF, "DROP_TABLE_REF" } + ,{ GSN_DROP_TABLE_CONF, "DROP_TABLE_CONF" } + + ,{ GSN_DROP_TAB_REQ, "DROP_TAB_REQ" } + ,{ GSN_DROP_TAB_REF, "DROP_TAB_REF" } + ,{ GSN_DROP_TAB_CONF, "DROP_TAB_CONF" } + + ,{ GSN_PREP_DROP_TAB_REQ, "PREP_DROP_TAB_REQ" } + ,{ GSN_PREP_DROP_TAB_REF, "PREP_DROP_TAB_REF" } + ,{ GSN_PREP_DROP_TAB_CONF, "PREP_DROP_TAB_CONF" } + + ,{ GSN_WAIT_DROP_TAB_REQ, "WAIT_DROP_TAB_REQ" } + ,{ GSN_WAIT_DROP_TAB_REF, "WAIT_DROP_TAB_REF" } + ,{ GSN_WAIT_DROP_TAB_CONF, "WAIT_DROP_TAB_CONF" } + + ,{ GSN_CREATE_TRIG_REQ, "CREATE_TRIG_REQ" } + ,{ GSN_CREATE_TRIG_CONF, "CREATE_TRIG_CONF" } + ,{ GSN_CREATE_TRIG_REF, "CREATE_TRIG_REF" } + ,{ GSN_ALTER_TRIG_REQ, "ALTER_TRIG_REQ" } + ,{ GSN_ALTER_TRIG_CONF, "ALTER_TRIG_CONF" } + ,{ GSN_ALTER_TRIG_REF, "ALTER_TRIG_REF" } + ,{ GSN_DROP_TRIG_REQ, "DROP_TRIG_REQ" } + ,{ GSN_DROP_TRIG_CONF, "DROP_TRIG_CONF" } + ,{ GSN_DROP_TRIG_REF, "DROP_TRIG_REF" } + ,{ GSN_FIRE_TRIG_ORD, "FIRE_TRIG_ORD" } + ,{ GSN_TRIG_ATTRINFO, "TRIG_ATTRINFO" } + + ,{ GSN_CREATE_INDX_REQ, "CREATE_INDX_REQ" } + ,{ GSN_CREATE_INDX_CONF, "CREATE_INDX_CONF" } + ,{ GSN_CREATE_INDX_REF, "CREATE_INDX_REF" } + ,{ GSN_DROP_INDX_REQ, "DROP_INDX_REQ" } + ,{ GSN_DROP_INDX_CONF, "DROP_INDX_CONF" } + ,{ GSN_DROP_INDX_REF, "DROP_INDX_REF" } + ,{ GSN_ALTER_INDX_REQ, "ALTER_INDX_REQ" } + ,{ GSN_ALTER_INDX_CONF, "ALTER_INDX_CONF" } + ,{ GSN_ALTER_INDX_REF, "ALTER_INDX_REF" } + ,{ GSN_TCINDXREQ, "TCINDXREQ" } + ,{ GSN_TCINDXCONF, "TCINDXCONF" } + ,{ GSN_TCINDXREF, "TCINDXREF" } + ,{ GSN_INDXKEYINFO, "INDXKEYINFO" } + ,{ GSN_INDXATTRINFO, "INDXATTRINFO" } + ,{ GSN_BUILDINDXREQ, "BUILDINDXREQ" } + ,{ GSN_BUILDINDXCONF, "BUILDINDXCONF" } + ,{ GSN_BUILDINDXREF, "BUILDINDXREF" } + //,{ GSN_TCINDXNEXTREQ, "TCINDXNEXTREQ" } + //,{ GSN_TCINDEXNEXTCONF, "TCINDEXNEXTCONF" } + //,{ GSN_TCINDEXNEXREF, "TCINDEXNEXREF" } + + ,{ GSN_CREATE_EVNT_REQ, "CREATE_EVNT_REQ" } + ,{ GSN_CREATE_EVNT_CONF, "CREATE_EVNT_CONF" } + ,{ GSN_CREATE_EVNT_REF, "CREATE_EVNT_REF" } + + ,{ GSN_SUMA_START_ME, "SUMA_START_ME" } + ,{ GSN_SUMA_HANDOVER_REQ, "SUMA_HANDOVER_REQ"} + ,{ GSN_SUMA_HANDOVER_CONF, "SUMA_HANDOVER_CONF"} + + ,{ GSN_DROP_EVNT_REQ, "DROP_EVNT_REQ" } + ,{ GSN_DROP_EVNT_CONF, "DROP_EVNT_CONF" } + ,{ GSN_DROP_EVNT_REF, "DROP_EVNT_REF" } + + ,{ GSN_BACKUP_TRIG_REQ, "BACKUP_TRIG_REQ" } + ,{ GSN_BACKUP_REQ, "BACKUP_REQ" } + ,{ GSN_BACKUP_DATA, "BACKUP_DATA" } + ,{ GSN_BACKUP_REF, "BACKUP_REF" } + ,{ GSN_BACKUP_CONF, "BACKUP_CONF" } + ,{ GSN_ABORT_BACKUP_ORD, "ABORT_BACKUP_ORD" } + ,{ GSN_BACKUP_ABORT_REP, "BACKUP_ABORT_REP" } + ,{ GSN_BACKUP_COMPLETE_REP, "BACKUP_COMPLETE_REP" } + ,{ GSN_BACKUP_NF_COMPLETE_REP, "BACKUP_NF_COMPLETE_REP" } + ,{ GSN_DEFINE_BACKUP_REQ, "DEFINE_BACKUP_REQ" } + ,{ GSN_DEFINE_BACKUP_REF, "DEFINE_BACKUP_REF" } + ,{ GSN_DEFINE_BACKUP_CONF, "DEFINE_BACKUP_CONF" } + ,{ GSN_START_BACKUP_REQ, "START_BACKUP_REQ" } + ,{ GSN_START_BACKUP_REF, "START_BACKUP_REF" } + ,{ GSN_START_BACKUP_CONF, "START_BACKUP_CONF" } + ,{ GSN_BACKUP_FRAGMENT_REQ, "BACKUP_FRAGMENT_REQ" } + ,{ GSN_BACKUP_FRAGMENT_REF, "BACKUP_FRAGMENT_REF" } + ,{ GSN_BACKUP_FRAGMENT_CONF, "BACKUP_FRAGMENT_CONF" } + ,{ GSN_STOP_BACKUP_REQ, "STOP_BACKUP_REQ" } + ,{ GSN_STOP_BACKUP_REF, "STOP_BACKUP_REF" } + ,{ GSN_STOP_BACKUP_CONF, "STOP_BACKUP_CONF" } + ,{ GSN_BACKUP_STATUS_REQ, "BACKUP_STATUS_REQ" } + ,{ GSN_BACKUP_STATUS_REF, "BACKUP_STATUS_REF" } + ,{ GSN_BACKUP_STATUS_CONF, "BACKUP_STATUS_CONF" } + ,{ GSN_SIGNAL_DROPPED_REP, "SIGNAL_DROPPED_REP" } + ,{ GSN_CONTINUE_FRAGMENTED, "CONTINUE_FRAGMENTED" } + + /** Util Block Services **/ + ,{ GSN_UTIL_SEQUENCE_REQ, "UTIL_SEQUENCE_REQ" } + ,{ GSN_UTIL_SEQUENCE_REF, "UTIL_SEQUENCE_REF" } + ,{ GSN_UTIL_SEQUENCE_CONF, "UTIL_SEQUENCE_CONF" } + ,{ GSN_UTIL_PREPARE_REQ, "UTIL_PREPARE_REQ" } + ,{ GSN_UTIL_PREPARE_CONF, "UTIL_PREPARE_CONF" } + ,{ GSN_UTIL_PREPARE_REF, "UTIL_PREPARE_REF" } + ,{ GSN_UTIL_EXECUTE_REQ, "UTIL_EXECUTE_REQ" } + ,{ GSN_UTIL_EXECUTE_CONF, "UTIL_EXECUTE_CONF" } + ,{ GSN_UTIL_EXECUTE_REF, "UTIL_EXECUTE_REF" } + ,{ GSN_UTIL_RELEASE_REQ, "UTIL_RELEASE_REQ" } + ,{ GSN_UTIL_RELEASE_CONF, "UTIL_RELEASE_CONF" } + ,{ GSN_UTIL_RELEASE_REF, "UTIL_RELASE_REF" } + + ,{ GSN_GREP_CREATE_REQ, "GREP_CREATE_REQ" }, + { GSN_GREP_CREATE_REF, "GREP_CREATE_REF" }, + { GSN_GREP_CREATE_CONF, "GREP_CREATE_CONF" }, + { GSN_GREP_START_REQ, "GREP_START_REQ" }, + { GSN_GREP_START_REF, "GREP_START_REF" }, + { GSN_GREP_START_CONF, "GREP_START_CONF" }, + { GSN_GREP_SYNC_REQ, "GREP_SYNC_REQ" }, + { GSN_GREP_SYNC_REF, "GREP_SYNC_REF" }, + { GSN_GREP_SYNC_CONF, "GREP_SYNC_CONF" }, + //{ GSN_REP_CONNECT_REQ, "REP_CONNECT_REQ" }, Not used + //{ GSN_REP_CONNECT_REF, "REP_CONNECT_REF" }, Not used + //{ GSN_REP_CONNECT_CONF, "REP_CONNECT_CONF" }, Not used + { GSN_REP_WAITGCP_REQ, "REP_WAIT_GCP_REQ" }, + { GSN_REP_WAITGCP_REF, "REP_WAIT_GCP_REF" }, + { GSN_REP_WAITGCP_CONF, "REP_WAIT_GCP_CONF" }, + { GSN_GREP_WAITGCP_REQ, "GREP_WAIT_GCP_REQ" }, + { GSN_GREP_WAITGCP_REF, "GREP_WAIT_GCP_REF" }, + { GSN_GREP_WAITGCP_CONF, "GREP_WAIT_GCP_CONF" } + + /* Suma Block Services **/ + ,{ GSN_SUB_CREATE_REQ, "SUB_CREATE_REQ" } + ,{ GSN_SUB_CREATE_REF, "SUB_CREATE_REF" } + ,{ GSN_SUB_CREATE_CONF, "SUB_CREATE_CONF" } + ,{ GSN_SUB_START_REQ, "SUB_START_REQ" } + ,{ GSN_SUB_START_REF, "SUB_START_REF" } + ,{ GSN_SUB_START_CONF, "SUB_START_CONF" } + ,{ GSN_SUB_STOP_REQ, "SUB_STOP_REQ" } + ,{ GSN_SUB_STOP_REF, "SUB_STOP_REF" } + ,{ GSN_SUB_STOP_CONF, "SUB_STOP_CONF" } + ,{ GSN_SUB_SYNC_REQ, "SUB_SYNC_REQ" } + ,{ GSN_SUB_SYNC_REF, "SUB_SYNC_REF" } + ,{ GSN_SUB_SYNC_CONF, "SUB_SYNC_CONF" } + ,{ GSN_SUB_META_DATA, "SUB_META_DATA" } + ,{ GSN_SUB_TABLE_DATA, "SUB_TABLE_DATA" } + ,{ GSN_SUB_SYNC_CONTINUE_REQ, "SUB_SYNC_CONTINUE_REQ" } + ,{ GSN_SUB_SYNC_CONTINUE_REF, "SUB_SYNC_CONTINUE_REF" } + ,{ GSN_SUB_SYNC_CONTINUE_CONF, "SUB_SYNC_CONTINUE_CONF" } + ,{ GSN_SUB_GCP_COMPLETE_REP, "SUB_GCP_COMPLETE_REP" } + ,{ GSN_SUB_GCP_COMPLETE_ACC, "SUB_GCP_COMPLETE_ACC" } + + ,{ GSN_CREATE_SUBID_REQ, "CREATE_SUBID_REQ" } + ,{ GSN_CREATE_SUBID_REF, "CREATE_SUBID_REF" } + ,{ GSN_CREATE_SUBID_CONF, "CREATE_SUBID_CONF" } + + ,{ GSN_CREATE_TABLE_REQ, "CREATE_TABLE_REQ" } + ,{ GSN_CREATE_TABLE_REF, "CREATE_TABLE_REF" } + ,{ GSN_CREATE_TABLE_CONF, "CREATE_TABLE_CONF" } + + ,{ GSN_CREATE_TAB_REQ, "CREATE_TAB_REQ" } + ,{ GSN_CREATE_TAB_REF, "CREATE_TAB_REF" } + ,{ GSN_CREATE_TAB_CONF, "CREATE_TAB_CONF" } + + ,{ GSN_ALTER_TABLE_REQ, "ALTER_TABLE_REQ" } + ,{ GSN_ALTER_TABLE_REF, "ALTER_TABLE_REF" } + ,{ GSN_ALTER_TABLE_CONF, "ALTER_TABLE_CONF" } + + ,{ GSN_ALTER_TAB_REQ, "ALTER_TAB_REQ" } + ,{ GSN_ALTER_TAB_REF, "ALTER_TAB_REF" } + ,{ GSN_ALTER_TAB_CONF, "ALTER_TAB_CONF" } + + ,{ GSN_CREATE_FRAGMENTATION_REQ, "CREATE_FRAGMENTATION_REQ" } + ,{ GSN_CREATE_FRAGMENTATION_REF, "CREATE_FRAGMENTATION_REF" } + ,{ GSN_CREATE_FRAGMENTATION_CONF, "CREATE_FRAGMENTATION_CONF" } + + ,{ GSN_UTIL_CREATE_LOCK_REQ, "UTIL_CREATE_LOCK_REQ" } + ,{ GSN_UTIL_CREATE_LOCK_REF, "UTIL_CREATE_LOCK_REF" } + ,{ GSN_UTIL_CREATE_LOCK_CONF, "UTIL_CREATE_LOCK_CONF" } + ,{ GSN_UTIL_DESTROY_LOCK_REQ, "UTIL_DESTROY_LOCK_REQ" } + ,{ GSN_UTIL_DESTROY_LOCK_REF, "UTIL_DESTROY_LOCK_REF" } + ,{ GSN_UTIL_DESTROY_LOCK_CONF, "UTIL_DESTROY_LOCK_CONF" } + ,{ GSN_UTIL_LOCK_REQ, "UTIL_LOCK_REQ" } + ,{ GSN_UTIL_LOCK_REF, "UTIL_LOCK_REF" } + ,{ GSN_UTIL_LOCK_CONF, "UTIL_LOCK_CONF" } + ,{ GSN_UTIL_UNLOCK_REQ, "UTIL_UNLOCK_REQ" } + ,{ GSN_UTIL_UNLOCK_REF, "UTIL_UNLOCK_REF" } + ,{ GSN_UTIL_UNLOCK_CONF, "UTIL_UNLOCK_CONF" } + + /* TUX */ + ,{ GSN_TUXFRAGREQ, "TUXFRAGREQ" } + ,{ GSN_TUXFRAGCONF, "TUXFRAGCONF" } + ,{ GSN_TUXFRAGREF, "TUXFRAGREF" } + ,{ GSN_TUX_ADD_ATTRREQ, "TUX_ADD_ATTRREQ" } + ,{ GSN_TUX_ADD_ATTRCONF, "TUX_ADD_ATTRCONF" } + ,{ GSN_TUX_ADD_ATTRREF, "TUX_ADD_ATTRREF" } + ,{ GSN_TUX_MAINT_REQ, "TUX_MAINT_REQ" } + ,{ GSN_TUX_MAINT_CONF, "TUX_MAINT_CONF" } + ,{ GSN_TUX_MAINT_REF, "TUX_MAINT_REF" } + ,{ GSN_TUP_READ_ATTRS, "TUP_READ_ATTRS" } + ,{ GSN_TUP_QUERY_TH, "TUP_QUERY_TH" } + ,{ GSN_TUP_STORE_TH, "TUP_STORE_TH" } + ,{ GSN_TUX_BOUND_INFO, "TUX_BOUND_INFO" } + ,{ GSN_ACC_LOCKREQ, "ACC_LOCKREQ" } + +}; +const unsigned short NO_OF_SIGNAL_NAMES = sizeof(SignalNames)/sizeof(GsnName); diff --git a/ndb/src/common/debugger/signaldata/StartRec.cpp b/ndb/src/common/debugger/signaldata/StartRec.cpp new file mode 100644 index 00000000000..482e3cb0728 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/StartRec.cpp @@ -0,0 +1,52 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include + +bool +printSTART_REC_REQ(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 recBlockNo){ + StartRecReq * sig = (StartRecReq *) theData; + + fprintf(output, " receivingNodeId: %d senderRef: (%d, %d)\n", + sig->receivingNodeId, + refToNode(sig->senderRef), + refToBlock(sig->senderRef)); + + fprintf(output, " keepGci: %d lastCompletedGci: %d newestGci: %d\n", + sig->keepGci, + sig->lastCompletedGci, + sig->newestGci); + + return true; +} + +bool +printSTART_REC_CONF(FILE * output, + const Uint32 * theData, + Uint32 len, + Uint16 recBlockNo){ + StartRecConf * sig = (StartRecConf *) theData; + + fprintf(output, " startingNodeId: %d\n", + sig->startingNodeId); + + return true; +} diff --git a/ndb/src/common/debugger/signaldata/SumaImpl.cpp b/ndb/src/common/debugger/signaldata/SumaImpl.cpp new file mode 100644 index 00000000000..558842ed2ba --- /dev/null +++ b/ndb/src/common/debugger/signaldata/SumaImpl.cpp @@ -0,0 +1,167 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printSUB_CREATE_REQ(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const SubCreateReq * const sig = (SubCreateReq *)theData; + fprintf(output, " subscriberRef: %x\n", sig->subscriberRef); + fprintf(output, " subscriberData: %x\n", sig->subscriberData); + fprintf(output, " subscriptionId: %x\n", sig->subscriptionId); + fprintf(output, " subscriptionKey: %x\n", sig->subscriptionKey); + fprintf(output, " subscriptionType: %x\n", sig->subscriptionType); + fprintf(output, " tableId: %x\n", sig->tableId); + return false; +} + +bool +printSUB_CREATE_CONF(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const SubCreateConf * const sig = (SubCreateConf *)theData; + fprintf(output, " subscriptionId: %x\n", sig->subscriptionId); + fprintf(output, " subscriptionKey: %x\n", sig->subscriptionKey); + fprintf(output, " subscriberData: %x\n", sig->subscriberData); + return false; +} + +bool +printSUB_START_REQ(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const SubStartReq * const sig = (SubStartReq *)theData; + fprintf(output, " subscriptionId: %x\n", sig->subscriptionId); + fprintf(output, " subscriptionKey: %x\n", sig->subscriptionKey); + fprintf(output, " startPart: %x\n", sig->part); + return false; +} + +bool +printSUB_START_REF(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const SubStartRef * const sig = (SubStartRef *)theData; + fprintf(output, " subscriptionId: %x\n", sig->subscriptionId); + fprintf(output, " subscriptionKey: %x\n", sig->subscriptionKey); + fprintf(output, " startPart: %x\n", sig->part); + fprintf(output, " subscriberData: %x\n", sig->subscriberData); + fprintf(output, " err: %x\n", sig->err); + return false; +} + +bool +printSUB_START_CONF(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const SubStartConf * const sig = (SubStartConf *)theData; + fprintf(output, " subscriptionId: %x\n", sig->subscriptionId); + fprintf(output, " subscriptionKey: %x\n", sig->subscriptionKey); + fprintf(output, " startPart: %x\n", sig->part); + fprintf(output, " subscriberData: %x\n", sig->subscriberData); + return false; +} + +bool +printSUB_SYNC_REQ(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const SubSyncReq * const sig = (SubSyncReq *)theData; + fprintf(output, " subscriptionId: %x\n", sig->subscriptionId); + fprintf(output, " subscriptionKey: %x\n", sig->subscriptionKey); + fprintf(output, " syncPart: %x\n", sig->part); + return false; +} + +bool +printSUB_SYNC_REF(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const SubSyncRef * const sig = (SubSyncRef *)theData; + fprintf(output, " subscriptionId: %x\n", sig->subscriptionId); + fprintf(output, " subscriptionKey: %x\n", sig->subscriptionKey); + fprintf(output, " syncPart: %x\n", sig->part); + fprintf(output, " subscriberData: %x\n", sig->subscriberData); + fprintf(output, " err: %x\n", sig->err); + return false; +} + +bool +printSUB_SYNC_CONF(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const SubSyncConf * const sig = (SubSyncConf *)theData; + fprintf(output, " subscriptionId: %x\n", sig->subscriptionId); + fprintf(output, " subscriptionKey: %x\n", sig->subscriptionKey); + fprintf(output, " syncPart: %x\n", sig->part); + fprintf(output, " subscriberData: %x\n", sig->subscriberData); + return false; +} + +bool +printSUB_META_DATA(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const SubMetaData * const sig = (SubMetaData *)theData; + fprintf(output, " gci: %x\n", sig->gci); + fprintf(output, " senderData: %x\n", sig->senderData); + fprintf(output, " subscriberData: %x\n", sig->subscriberData); + fprintf(output, " tableId: %x\n", sig->tableId); + return false; +} + +bool +printSUB_TABLE_DATA(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const SubTableData * const sig = (SubTableData *)theData; + fprintf(output, " senderData: %x\n", sig->senderData); + fprintf(output, " subscriberData: %x\n", sig->subscriberData); + fprintf(output, " gci: %x\n", sig->gci); + fprintf(output, " tableId: %x\n", sig->tableId); + fprintf(output, " operation: %x\n", sig->operation); + fprintf(output, " noOfAttributes: %x\n", sig->noOfAttributes); + fprintf(output, " dataSize: %x\n", sig->dataSize); + return false; +} + +bool +printSUB_SYNC_CONTINUE_REQ(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const SubSyncContinueReq * const sig = (SubSyncContinueReq *)theData; + fprintf(output, " subscriberData: %x\n", sig->subscriberData); + fprintf(output, " noOfRowsSent: %x\n", sig->noOfRowsSent); + return false; +} + +bool +printSUB_SYNC_CONTINUE_REF(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const SubSyncContinueRef * const sig = (SubSyncContinueRef *)theData; + fprintf(output, " subscriptionId: %x\n", sig->subscriptionId); + fprintf(output, " subscriptionKey: %x\n", sig->subscriptionKey); + return false; +} + +bool +printSUB_SYNC_CONTINUE_CONF(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const SubSyncContinueConf * const sig = (SubSyncContinueConf *)theData; + fprintf(output, " subscriptionId: %x\n", sig->subscriptionId); + fprintf(output, " subscriptionKey: %x\n", sig->subscriptionKey); + return false; +} + +bool +printSUB_GCP_COMPLETE_REP(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) { + const SubGcpCompleteRep * const sig = (SubGcpCompleteRep *)theData; + fprintf(output, " gci: %x\n", sig->gci); + return false; +} + diff --git a/ndb/src/common/debugger/signaldata/SystemError.cpp b/ndb/src/common/debugger/signaldata/SystemError.cpp new file mode 100644 index 00000000000..5ed7dc6b18d --- /dev/null +++ b/ndb/src/common/debugger/signaldata/SystemError.cpp @@ -0,0 +1,41 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include +#include + +bool +printSYSTEM_ERROR(FILE * output, const Uint32 * theData, Uint32 len, + Uint16 receiverBlockNo){ + + const SystemError * const sig = (SystemError *) theData; + + fprintf(output, "errorRef: H\'%.8x\n", + sig->errorRef); + fprintf(output, "errorCode: %d\n", + sig->errorCode); + fprintf(output, "data1: H\'%.8x\n", + sig->data1); + fprintf(output, "data2: H\'%.8x\n", + sig->data2); + + return true; +} + + diff --git a/ndb/src/common/debugger/signaldata/TcIndx.cpp b/ndb/src/common/debugger/signaldata/TcIndx.cpp new file mode 100644 index 00000000000..6bfa29eff15 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/TcIndx.cpp @@ -0,0 +1,159 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include + +bool +printTCINDXREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + + const TcIndxReq * const sig = (TcIndxReq *) theData; + + UintR requestInfo = sig->requestInfo; + UintR scanInfo = sig->scanInfo; + + fprintf(output, " apiConnectPtr: H\'%.8x, senderData: H\'%.8x\n", + sig->apiConnectPtr, sig->senderData); + + fprintf(output, " Operation: %s, Flags: ", + sig->getOperationType(requestInfo) == ZREAD ? "Read" : + sig->getOperationType(requestInfo) == ZREAD_EX ? "Read-Ex" : + sig->getOperationType(requestInfo) == ZUPDATE ? "Update" : + sig->getOperationType(requestInfo) == ZINSERT ? "Insert" : + sig->getOperationType(requestInfo) == ZDELETE ? "Delete" : + sig->getOperationType(requestInfo) == ZWRITE ? "Write" : + "Unknown"); + + { + if(sig->getDirtyFlag(requestInfo)){ + fprintf(output, "Dirty "); + } + if(sig->getStartFlag(requestInfo)){ + fprintf(output, "Start "); + } + if (TcKeyReq::getExecuteFlag(sig->requestInfo)) { + fprintf(output, "Execute "); + } + if(sig->getCommitFlag(requestInfo)){ + fprintf(output, "Commit, Type = "); + UintR TcommitType = sig->getCommitType(requestInfo); + if (TcommitType == TcIndxReq::CommitIfFailFree) { + fprintf(output, "FailFree "); + } else if (TcommitType == TcIndxReq::TryCommit) { + fprintf(output, "TryCommit "); + } else if (TcommitType == TcIndxReq::CommitAsMuchAsPossible) { + fprintf(output, "Always "); + }//if + } + if(sig->getSimpleFlag(requestInfo)){ + fprintf(output, "Simple "); + } + if(sig->getInterpretedFlag(requestInfo)){ + fprintf(output, "Interpreted "); + } + if(sig->getDistributionGroupFlag(requestInfo)){ + fprintf(output, "DGroup = %d ", sig->distrGroupHashValue); + } + if(sig->getDistributionKeyFlag(sig->requestInfo)){ + fprintf(output, "DKey = %d ", sig->distributionKeySize); + } + fprintf(output, "\n"); + } + + const int indexLen = sig->getIndexLength(requestInfo); + const int attrInThis = sig->getAIInTcIndxReq(requestInfo); + fprintf(output, + " indexLen: %d, attrLen: %d, AI in this: %d, indexId: %d, " + "indexSchemaVer: %d, API Ver: %d\n", + indexLen, sig->attrLen, attrInThis, + sig->indexId, sig->indexSchemaVersion, sig->getAPIVersion(scanInfo)); + + fprintf(output, " transId(1, 2): (H\'%.8x, H\'%.8x)\n -- Variable Data --\n", + sig->transId1, sig->transId2); + + Uint32 restLen = (len - 8); + const Uint32 * rest = &sig->scanInfo; + while(restLen >= 7){ + fprintf(output, + " H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x\n", + rest[0], rest[1], rest[2], rest[3], + rest[4], rest[5], rest[6]); + restLen -= 7; + rest += 7; + } + if(restLen > 0){ + for(Uint32 i = 0; iconfInfo; + Uint32 noOfOp = TcIndxConf::getNoOfOperations(confInfo); + while (i < len) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + fprintf(output, "apiConnectPtr: H'%.8x, gci: %u, transId:(H'%.8x, H'%.8x)\n", + sig->apiConnectPtr, sig->gci, sig->transId1, sig->transId2); + + fprintf(output, "noOfOperations: %u, commitFlag: %s, markerFlag: %s\n", + noOfOp, + (TcIndxConf::getCommitFlag(confInfo) == 0)?"false":"true", + (TcIndxConf::getMarkerFlag(confInfo) == 0)?"false":"true"); + fprintf(output, "Operations:\n"); + for(i = 0; i < noOfOp; i++) { + fprintf(output, + "apiOperationPtr: H'%.8x, attrInfoLen: %u\n", + sig->operations[i].apiOperationPtr, + sig->operations[i].attrInfoLen); + } + } + + return true; +} + +bool +printTCINDXREF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + +// const TcIndxRef * const sig = (TcIndxRef *) theData; + + fprintf(output, "Signal data: "); + Uint32 i = 0; + while (i < len) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + + return true; +} + diff --git a/ndb/src/common/debugger/signaldata/TcKeyConf.cpp b/ndb/src/common/debugger/signaldata/TcKeyConf.cpp new file mode 100644 index 00000000000..727e097a464 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/TcKeyConf.cpp @@ -0,0 +1,59 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include + +bool +printTCKEYCONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + + + if (receiverBlockNo == API_PACKED) { + fprintf(output, "Signal data: "); + Uint32 i = 0; + while (i < len) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + } + else { + const TcKeyConf * const sig = (TcKeyConf *) theData; + + fprintf(output, "Signal data: "); + Uint32 i = 0; + Uint32 confInfo = sig->confInfo; + Uint32 noOfOp = TcKeyConf::getNoOfOperations(confInfo); + if (noOfOp > 10) noOfOp = 10; + while (i < len) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + fprintf(output, "apiConnectPtr: H'%.8x, gci: %u, transId:(H'%.8x, H'%.8x)\n", + sig->apiConnectPtr, sig->gci, sig->transId1, sig->transId2); + + fprintf(output, "noOfOperations: %u, commitFlag: %s, markerFlag: %s\n", + noOfOp, + (TcKeyConf::getCommitFlag(confInfo) == 0)?"false":"true", + (TcKeyConf::getMarkerFlag(confInfo) == 0)?"false":"true"); + fprintf(output, "Operations:\n"); + for(i = 0; i < noOfOp; i++) { + fprintf(output, + "apiOperationPtr: H'%.8x, attrInfoLen: %u\n", + sig->operations[i].apiOperationPtr, + sig->operations[i].attrInfoLen); + } + } + + return true; +} diff --git a/ndb/src/common/debugger/signaldata/TcKeyRef.cpp b/ndb/src/common/debugger/signaldata/TcKeyRef.cpp new file mode 100644 index 00000000000..0dba9909caf --- /dev/null +++ b/ndb/src/common/debugger/signaldata/TcKeyRef.cpp @@ -0,0 +1,28 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printTCKEYREF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + fprintf(output, "Signal data: "); + Uint32 i = 0; + while (i < len) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + + return true; +} diff --git a/ndb/src/common/debugger/signaldata/TcKeyReq.cpp b/ndb/src/common/debugger/signaldata/TcKeyReq.cpp new file mode 100644 index 00000000000..7304872ff9c --- /dev/null +++ b/ndb/src/common/debugger/signaldata/TcKeyReq.cpp @@ -0,0 +1,114 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + +#include + +bool +printTCKEYREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + + const TcKeyReq * const sig = (TcKeyReq *) theData; + + UintR requestInfo = sig->requestInfo; + + fprintf(output, " apiConnectPtr: H\'%.8x, apiOperationPtr: H\'%.8x\n", + sig->apiConnectPtr, sig->apiOperationPtr); + fprintf(output, " Operation: %s, Flags: ", + sig->getOperationType(requestInfo) == ZREAD ? "Read" : + sig->getOperationType(requestInfo) == ZREAD_EX ? "Read-Ex" : + sig->getOperationType(requestInfo) == ZUPDATE ? "Update" : + sig->getOperationType(requestInfo) == ZINSERT ? "Insert" : + sig->getOperationType(requestInfo) == ZDELETE ? "Delete" : + sig->getOperationType(requestInfo) == ZWRITE ? "Write" : + "Unknown"); + { + if(sig->getDirtyFlag(requestInfo)){ + fprintf(output, "Dirty "); + } + if(sig->getStartFlag(requestInfo)){ + fprintf(output, "Start "); + } + if(sig->getExecuteFlag(requestInfo)){ + fprintf(output, "Execute "); + } + if(sig->getCommitFlag(requestInfo)){ + fprintf(output, "Commit "); + } + if (sig->getExecutingTrigger(requestInfo)) { + fprintf(output, "Trigger "); + } + + UintR TcommitType = sig->getAbortOption(requestInfo); + if (TcommitType == TcKeyReq::AbortOnError) { + fprintf(output, "AbortOnError "); + } else if (TcommitType == TcKeyReq::IgnoreError) { + fprintf(output, "IgnoreError "); + }//if + + if(sig->getSimpleFlag(requestInfo)){ + fprintf(output, "Simple "); + } + if(sig->getScanIndFlag(requestInfo)){ + fprintf(output, "ScanInd "); + } + if(sig->getInterpretedFlag(requestInfo)){ + fprintf(output, "Interpreted "); + } + if(sig->getDistributionGroupFlag(requestInfo)){ + fprintf(output, "DGroup = %d ", sig->distrGroupHashValue); + } + if(sig->getDistributionKeyFlag(sig->requestInfo)){ + fprintf(output, "DKey = %d ", sig->distributionKeySize); + } + fprintf(output, "\n"); + } + + const int keyLen = sig->getKeyLength(requestInfo); + const int attrInThis = sig->getAIInTcKeyReq(requestInfo); + const int attrLen = sig->getAttrinfoLen(sig->attrLen); + const int apiVer = sig->getAPIVersion(sig->attrLen); + fprintf(output, + " keyLen: %d, attrLen: %d, AI in this: %d, tableId: %d, " + "tableSchemaVer: %d, API Ver: %d\n", + keyLen, attrLen, attrInThis, + sig->tableId, sig->tableSchemaVersion, apiVer); + + fprintf(output, " transId(1, 2): (H\'%.8x, H\'%.8x)\n -- Variable Data --\n", + sig->transId1, sig->transId2); + + if (len >= TcKeyReq::StaticLength) { + Uint32 restLen = (len - TcKeyReq::StaticLength); + const Uint32 * rest = &sig->scanInfo; + while(restLen >= 7){ + fprintf(output, + " H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x\n", + rest[0], rest[1], rest[2], rest[3], + rest[4], rest[5], rest[6]); + restLen -= 7; + rest += 7; + } + if(restLen > 0){ + for(Uint32 i = 0; i + +bool +printTCROLLBACKREP(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + fprintf(output, "Signal data: "); + Uint32 i = 0; + while (i < len) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + + return true; +} diff --git a/ndb/src/common/debugger/signaldata/TrigAttrInfo.cpp b/ndb/src/common/debugger/signaldata/TrigAttrInfo.cpp new file mode 100644 index 00000000000..7a8d176ec61 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/TrigAttrInfo.cpp @@ -0,0 +1,53 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +static +const char * +tatype(Uint32 i){ + switch(i){ + case TrigAttrInfo::PRIMARY_KEY: + return "PK"; + break; + case TrigAttrInfo::BEFORE_VALUES: + return "BEFORE"; + break; + case TrigAttrInfo::AFTER_VALUES: + return "AFTER"; + break; + } + return "UNKNOWN"; +} + +bool +printTRIG_ATTRINFO(FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) +{ + const TrigAttrInfo * const sig = (TrigAttrInfo *) theData; + + fprintf(output, " TriggerId: %d Type: %s ConnectPtr: %x\n", + sig->getTriggerId(), + tatype(sig->getAttrInfoType()), + sig->getConnectionPtr()); + + Uint32 i = 0; + while (i < len - TrigAttrInfo::StaticLength) + fprintf(output, " H\'%.8x", sig->getData()[i++]); + fprintf(output,"\n"); + + return true; +} diff --git a/ndb/src/common/debugger/signaldata/TupAccess.cpp b/ndb/src/common/debugger/signaldata/TupAccess.cpp new file mode 100644 index 00000000000..e94d4636cf5 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/TupAccess.cpp @@ -0,0 +1,131 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include + +bool +printTUP_READ_ATTRS(FILE* output, const Uint32* theData, Uint32 len, Uint16 rbn) +{ + const TupReadAttrs* const sig = (const TupReadAttrs*)theData; + if (sig->errorCode == RNIL) + fprintf(output, " errorCode=RNIL flags=%x\n", sig->requestInfo); + else + fprintf(output, " errorCode=%u flags=%x\n", sig->errorCode, sig->requestInfo); + fprintf(output, " table: id=%u", sig->tableId); + fprintf(output, " fragment: id=%u ptr=0x%x\n", sig->fragId, sig->fragPtrI); + fprintf(output, " tuple: addr=0x%x version=%u", sig->tupAddr, sig->tupVersion); + fprintf(output, " realPage=0x%x offset=%u\n", sig->pageId, sig->pageOffset); + const Uint32* buffer = (const Uint32*)sig + TupReadAttrs::SignalLength; + Uint32 attrCount = buffer[0]; + bool readKeys = (sig->requestInfo & TupReadAttrs::ReadKeys); + if (sig->errorCode == RNIL && ! readKeys || + sig->errorCode == 0 && readKeys) { + fprintf(output, " input: attrCount=%u\n", attrCount); + for (unsigned i = 0; i < attrCount; i++) { + AttributeHeader ah(buffer[1 + i]); + fprintf(output, " %u: attrId=%u\n", i, ah.getAttributeId()); + } + } + if (sig->errorCode == 0) { + fprintf(output, " output: attrCount=%u\n", attrCount); + Uint32 pos = 1 + attrCount; + for (unsigned i = 0; i < attrCount; i++) { + AttributeHeader ah(buffer[pos++]); + fprintf(output, " %u: attrId=%u dataSize=%u\n", i, ah.getAttributeId(), ah.getDataSize()); + Uint32 next = pos + ah.getDataSize(); + Uint32 printpos = 0; + while (pos < next) { + SignalLoggerManager::printDataWord(output, printpos, buffer[pos]); + pos++; + } + if (ah.getDataSize() > 0) + fprintf(output, "\n"); + } + } + return true; +} + +bool +printTUP_QUERY_TH(FILE* output, const Uint32* theData, Uint32 len, Uint16 rbn) +{ + const TupQueryTh* const sig = (const TupQueryTh*)theData; + fprintf(output, "tableId = %u, fragId = %u ", sig->tableId, sig->fragId); + fprintf(output, "tuple: addr = 0x%x version = %u\n", sig->tupAddr, + sig->tupVersion); + fprintf(output, "transId1 = 0x%x, transId2 = 0x%x, savePointId = %u\n", + sig->transId1, sig->transId2, sig->savePointId); + return true; +} + +bool +printTUP_STORE_TH(FILE* output, const Uint32* theData, Uint32 len, Uint16 rbn) +{ + const TupStoreTh* const sig = (const TupStoreTh*)theData; + if (sig->errorCode == RNIL) + fprintf(output, " errorCode=RNIL\n"); + else + fprintf(output, " errorCode=%u\n", sig->errorCode); + fprintf(output, " table: id=%u", sig->tableId); + fprintf(output, " fragment: id=%u ptr=0x%x\n", sig->fragId, sig->fragPtrI); + fprintf(output, " tuple: addr=0x%x", sig->tupAddr); + if ((sig->tupAddr & 0x1) == 0) { + fprintf(output, " fragPage=0x%x index=%u", + sig->tupAddr >> MAX_TUPLES_BITS, + (sig->tupAddr & ((1 <> 1); + fprintf(output, " realPage=0x%x offset=%u\n", sig->pageId, sig->pageOffset); + } else { + fprintf(output, " cacheId=%u\n", + sig->tupAddr >> 1); + } + if (sig->tupVersion != 0) { + fprintf(output, " version=%u ***invalid***\n", sig->tupVersion); + } + bool showdata = true; + switch (sig->opCode) { + case TupStoreTh::OpRead: + fprintf(output, " operation=Read\n"); + showdata = false; + break; + case TupStoreTh::OpInsert: + fprintf(output, " operation=Insert\n"); + break; + case TupStoreTh::OpUpdate: + fprintf(output, " operation=Update\n"); + break; + case TupStoreTh::OpDelete: + fprintf(output, " operation=Delete\n"); + showdata = false; + break; + default: + fprintf(output, " operation=%u ***invalid***\n", sig->opCode); + break; + } + fprintf(output, " data: offset=%u size=%u", sig->dataOffset, sig->dataSize); + if (! showdata) { + fprintf(output, " [not printed]\n"); + } else { + fprintf(output, "\n"); + const Uint32* buffer = (const Uint32*)sig + TupStoreTh::SignalLength; + Uint32 pos = 0; + while (pos < sig->dataSize) + SignalLoggerManager::printDataWord(output, pos, buffer[sig->dataOffset + pos]); + if (sig->dataSize > 0) + fprintf(output, "\n"); + } + return true; +}; diff --git a/ndb/src/common/debugger/signaldata/TupCommit.cpp b/ndb/src/common/debugger/signaldata/TupCommit.cpp new file mode 100644 index 00000000000..d0391b2a8e6 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/TupCommit.cpp @@ -0,0 +1,28 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printTUPCOMMITREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + fprintf(output, "Signal data: "); + Uint32 i = 0; + while (i < len) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + + return true; +} diff --git a/ndb/src/common/debugger/signaldata/TupKey.cpp b/ndb/src/common/debugger/signaldata/TupKey.cpp new file mode 100644 index 00000000000..134b5fde8bc --- /dev/null +++ b/ndb/src/common/debugger/signaldata/TupKey.cpp @@ -0,0 +1,50 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printTUPKEYREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + fprintf(output, "Signal data: "); + Uint32 i = 0; + while (i < len) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + + return true; +} + +bool +printTUPKEYCONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + fprintf(output, "Signal data: "); + Uint32 i = 0; + while (i < len) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + + return true; +} + +bool +printTUPKEYREF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo){ + fprintf(output, "Signal data: "); + Uint32 i = 0; + while (i < len) + fprintf(output, "H\'%.8x ", theData[i++]); + fprintf(output,"\n"); + + return true; +} diff --git a/ndb/src/common/debugger/signaldata/TuxMaint.cpp b/ndb/src/common/debugger/signaldata/TuxMaint.cpp new file mode 100644 index 00000000000..06ac475382c --- /dev/null +++ b/ndb/src/common/debugger/signaldata/TuxMaint.cpp @@ -0,0 +1,45 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include + +bool +printTUX_MAINT_REQ(FILE* output, const Uint32* theData, Uint32 len, Uint16 rbn) +{ + //const bool inOut = rbn & (1 << 15); + const TuxMaintReq* const sig = (const TuxMaintReq*)theData; + fprintf(output, " errorCode=%d\n", sig->errorCode); + fprintf(output, " table: id=%d", sig->tableId); + fprintf(output, " index: id=%d", sig->indexId); + fprintf(output, " fragment: id=%d\n", sig->fragId); + fprintf(output, " tuple: addr=0x%x version=%d\n", sig->tupAddr, sig->tupVersion); + const Uint32 opCode = sig->opInfo & 0xFF; + const Uint32 opFlag = sig->opInfo >> 8; + switch (opCode ) { + case TuxMaintReq::OpAdd: + fprintf(output, " opCode=Add opFlag=%u\n", opFlag); + break; + case TuxMaintReq::OpRemove: + fprintf(output, " opCode=Remove opFlag=%u\n", opFlag); + break; + default: + fprintf(output, " opInfo=%x ***invalid***\n", sig->opInfo); + break; + } + return true; +} diff --git a/ndb/src/common/debugger/signaldata/UtilDelete.cpp b/ndb/src/common/debugger/signaldata/UtilDelete.cpp new file mode 100644 index 00000000000..b6ba53559ac --- /dev/null +++ b/ndb/src/common/debugger/signaldata/UtilDelete.cpp @@ -0,0 +1,65 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printUTIL_DELETE_REQ(FILE * out, const Uint32 * data, Uint32 l, Uint16 b){ + (void)l; // Don't want compiler warning + (void)b; // Don't want compiler warning + + UtilDeleteReq* sig = (UtilDeleteReq*)data; + fprintf(out, " senderData: %d prepareId: %d totalDataLen: %d\n", + sig->senderData, + sig->prepareId, + sig->totalDataLen); + fprintf(out, + " H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x\n" + " H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x\n" + " H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x\n", + sig->attrData[0], sig->attrData[1], sig->attrData[2], + sig->attrData[3], sig->attrData[4], sig->attrData[5], + sig->attrData[6], sig->attrData[7], sig->attrData[8], + sig->attrData[9], sig->attrData[10], sig->attrData[11], + sig->attrData[12], sig->attrData[13], sig->attrData[14], + sig->attrData[15], sig->attrData[16], sig->attrData[17], + sig->attrData[18], sig->attrData[19], sig->attrData[20], + sig->attrData[21] + ); + + return true; +} + +bool +printUTIL_DELETE_CONF(FILE * out, const Uint32 * data, Uint32 l, Uint16 b){ + (void)l; // Don't want compiler warning + (void)b; // Don't want compiler warning + + UtilDeleteConf* sig = (UtilDeleteConf*)data; + fprintf(out, " senderData: %d\n", sig->senderData); + return true; +} + +bool +printUTIL_DELETE_REF(FILE * out, const Uint32 * data, Uint32 l, Uint16 b){ + (void)l; // Don't want compiler warning + (void)b; // Don't want compiler warning + + UtilDeleteRef* sig = (UtilDeleteRef*)data; + fprintf(out, " senderData: %d\n", sig->senderData); + fprintf(out, " errorCode: %d\n", sig->errorCode); + return true; +} diff --git a/ndb/src/common/debugger/signaldata/UtilExecute.cpp b/ndb/src/common/debugger/signaldata/UtilExecute.cpp new file mode 100644 index 00000000000..2c88fa174d4 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/UtilExecute.cpp @@ -0,0 +1,59 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printUTIL_EXECUTE_REQ(FILE* out, const Uint32 * data, Uint32 len, Uint16 rec) +{ + const UtilExecuteReq* const sig = (UtilExecuteReq*)data; + fprintf(out, " senderRef: H'%.8x, senderData: H'%.8x prepareId: %d\n", + sig->senderRef, + sig->senderData, + sig->prepareId); + return true; +} + +bool +printUTIL_EXECUTE_CONF(FILE* out, const Uint32 * data, Uint32 len, Uint16 rec) +{ + UtilExecuteConf* sig = (UtilExecuteConf*)data; + fprintf(out, " senderData: H'%.8x\n", + sig->senderData); + return true; +} + +bool +printUTIL_EXECUTE_REF(FILE* out, const Uint32 * data, Uint32 len, Uint16 rec) +{ + UtilExecuteRef* sig = (UtilExecuteRef*)data; + fprintf(out, " senderData: H'%.8x, ", sig->senderData); + fprintf(out, " errorCode: %s, ", + sig->errorCode == UtilExecuteRef::IllegalKeyNumber ? + "IllegalKeyNumber" : + sig->errorCode == UtilExecuteRef::IllegalAttrNumber ? + "IllegalAttrNumber" : + sig->errorCode == UtilExecuteRef::TCError ? + "TCError" : + sig->errorCode == UtilExecuteRef::IllegalPrepareId ? + "IllegalPrepareId" : + sig->errorCode == UtilExecuteRef::AllocationError ? + "AllocationError" : + "Unknown"); + fprintf(out, " TCErrorCode: %d\n", + sig->TCErrorCode); + return true; +} diff --git a/ndb/src/common/debugger/signaldata/UtilLock.cpp b/ndb/src/common/debugger/signaldata/UtilLock.cpp new file mode 100644 index 00000000000..34e37c3e2d8 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/UtilLock.cpp @@ -0,0 +1,158 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printUTIL_LOCK_REQ (FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) +{ + const UtilLockReq *const sig = (UtilLockReq *) theData; + fprintf (output, " senderData: %x\n", sig->senderData); + fprintf (output, " senderRef: %x\n", sig->senderRef); + fprintf (output, " lockId: %x\n", sig->lockId); + fprintf (output, " requestInfo: %x\n", sig->requestInfo); + return true; +} + +bool +printUTIL_LOCK_CONF (FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) +{ + const UtilLockConf *const sig = (UtilLockConf *) theData; + fprintf (output, " senderData: %x\n", sig->senderData); + fprintf (output, " senderRef: %x\n", sig->senderRef); + fprintf (output, " lockId: %x\n", sig->lockId); + fprintf (output, " lockKey: %x\n", sig->lockKey); + return true; +} + +bool +printUTIL_LOCK_REF (FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) +{ + const UtilLockRef *const sig = (UtilLockRef *) theData; + fprintf (output, " senderData: %x\n", sig->senderData); + fprintf (output, " senderRef: %x\n", sig->senderRef); + fprintf (output, " lockId: %x\n", sig->lockId); + fprintf (output, " errorCode: %x\n", sig->errorCode); + return true; +} + +bool +printUTIL_UNLOCK_REQ (FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) +{ + const UtilUnlockReq *const sig = (UtilUnlockReq *) theData; + fprintf (output, " senderData: %x\n", sig->senderData); + fprintf (output, " senderRef: %x\n", sig->senderRef); + fprintf (output, " lockId: %x\n", sig->lockId); + fprintf (output, " lockKey: %x\n", sig->lockKey); + return true; +} + +bool +printUTIL_UNLOCK_CONF (FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) +{ + const UtilUnlockConf *const sig = (UtilUnlockConf *) theData; + fprintf (output, " senderData: %x\n", sig->senderData); + fprintf (output, " senderRef: %x\n", sig->senderRef); + fprintf (output, " lockId: %x\n", sig->lockId); + return true; +} + +bool +printUTIL_UNLOCK_REF (FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) +{ + const UtilUnlockRef *const sig = (UtilUnlockRef *) theData; + fprintf (output, " senderData: %x\n", sig->senderData); + fprintf (output, " senderRef: %x\n", sig->senderRef); + fprintf (output, " lockId: %x\n", sig->lockId); + fprintf (output, " errorCode: %x\n", sig->errorCode); + return true; +} + +bool +printUTIL_CREATE_LOCK_REQ (FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) +{ + const UtilCreateLockReq *const sig = (UtilCreateLockReq *) theData; + fprintf (output, " senderData: %x\n", sig->senderData); + fprintf (output, " senderRef: %x\n", sig->senderRef); + fprintf (output, " lockId: %x\n", sig->lockId); + fprintf (output, " lockType: %x\n", sig->lockType); + return true; +} + +bool +printUTIL_CREATE_LOCK_REF (FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) +{ + const UtilCreateLockRef *const sig = (UtilCreateLockRef *) theData; + fprintf (output, " senderData: %x\n", sig->senderData); + fprintf (output, " senderRef: %x\n", sig->senderRef); + fprintf (output, " lockId: %x\n", sig->lockId); + fprintf (output, " errorCode: %x\n", sig->errorCode); + return true; +} + +bool +printUTIL_CREATE_LOCK_CONF (FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) +{ + const UtilCreateLockConf *const sig = (UtilCreateLockConf *) theData; + fprintf (output, " senderData: %x\n", sig->senderData); + fprintf (output, " senderRef: %x\n", sig->senderRef); + fprintf (output, " lockId: %x\n", sig->lockId); + return true; +} + +bool +printUTIL_DESTROY_LOCK_REQ (FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) +{ + const UtilDestroyLockReq *const sig = (UtilDestroyLockReq *) theData; + fprintf (output, " senderData: %x\n", sig->senderData); + fprintf (output, " senderRef: %x\n", sig->senderRef); + fprintf (output, " lockId: %x\n", sig->lockId); + fprintf (output, " lockKey: %x\n", sig->lockKey); + return true; +} + +bool +printUTIL_DESTROY_LOCK_REF (FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) +{ + const UtilDestroyLockRef *const sig = (UtilDestroyLockRef *) theData; + fprintf (output, " senderData: %x\n", sig->senderData); + fprintf (output, " senderRef: %x\n", sig->senderRef); + fprintf (output, " lockId: %x\n", sig->lockId); + fprintf (output, " errorCode: %x\n", sig->errorCode); + return true; +} + +bool +printUTIL_DESTROY_LOCK_CONF (FILE * output, const Uint32 * theData, + Uint32 len, Uint16 receiverBlockNo) +{ + const UtilDestroyLockConf *const sig = (UtilDestroyLockConf *) theData; + fprintf (output, " senderData: %x\n", sig->senderData); + fprintf (output, " senderRef: %x\n", sig->senderRef); + fprintf (output, " lockId: %x\n", sig->lockId); + return true; +} diff --git a/ndb/src/common/debugger/signaldata/UtilPrepare.cpp b/ndb/src/common/debugger/signaldata/UtilPrepare.cpp new file mode 100644 index 00000000000..adc2e299380 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/UtilPrepare.cpp @@ -0,0 +1,64 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +bool +printUTIL_PREPARE_REQ(FILE* out, const Uint32 * data, Uint32 len, Uint16 rec) +{ + UtilPrepareReq* sig = (UtilPrepareReq*)data; + fprintf(out, " senderRef: H'%.8x senderData: H'%.8x\n", + sig->senderRef, + sig->senderData); + + return true; +} + +bool +printUTIL_PREPARE_CONF(FILE* out, const Uint32 * data, Uint32 len, Uint16 rec) +{ + UtilPrepareConf* sig = (UtilPrepareConf*)data; + fprintf(out, " senderData: H'%.8x prepareId: %d\n", + sig->senderData, + sig->prepareId); + return true; +} + +bool +printUTIL_PREPARE_REF(FILE* out, const Uint32 * data, Uint32 len, Uint16 rec) +{ + UtilPrepareRef* sig = (UtilPrepareRef*)data; + fprintf(out, " senderData: H'%.8x, ", sig->senderData); + fprintf(out, " error: %d, ", sig->errorCode); + + fprintf(out, " errorMsg: "); + switch(sig->errorCode) { + case UtilPrepareRef::NO_ERROR: + fprintf(out, "No error"); + break; + case UtilPrepareRef::PREPARE_SEIZE_ERROR: + fprintf(out, "Failed to seize Prepare record"); + break; + case UtilPrepareRef::PREPARED_OPERATION_SEIZE_ERROR: + fprintf(out, "Failed to seize PreparedOperation record"); + break; + case UtilPrepareRef::DICT_TAB_INFO_ERROR: + fprintf(out, "Failed to get table info from DICT"); + break; + } + fprintf(out, "\n"); + return true; +} diff --git a/ndb/src/common/debugger/signaldata/UtilSequence.cpp b/ndb/src/common/debugger/signaldata/UtilSequence.cpp new file mode 100644 index 00000000000..e91999d9abf --- /dev/null +++ b/ndb/src/common/debugger/signaldata/UtilSequence.cpp @@ -0,0 +1,67 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +inline +const char * +type2string(UtilSequenceReq::RequestType type){ + switch(type){ + case UtilSequenceReq::NextVal: + return "NextVal"; + case UtilSequenceReq::CurrVal: + return "CurrVal"; + case UtilSequenceReq::Create: + return "Create"; + default: + return "Unknown"; + } +} + +bool +printUTIL_SEQUENCE_REQ(FILE * out, const Uint32 * data, Uint32 l, Uint16 b){ + UtilSequenceReq* sig = (UtilSequenceReq*)data; + fprintf(out, " senderData: %d sequenceId: %d RequestType: %s\n", + sig->senderData, + sig->sequenceId, + type2string((UtilSequenceReq::RequestType)sig->requestType)); + return true; +} + +bool +printUTIL_SEQUENCE_CONF(FILE * out, const Uint32 * data, Uint32 l, Uint16 b){ + UtilSequenceConf* sig = (UtilSequenceConf*)data; + fprintf(out, " senderData: %d sequenceId: %d RequestType: %s\n", + sig->senderData, + sig->sequenceId, + type2string((UtilSequenceReq::RequestType)sig->requestType)); + fprintf(out, " val: [ %d %d ]\n", + sig->sequenceValue[0], + sig->sequenceValue[1]); + return true; +} + +bool +printUTIL_SEQUENCE_REF(FILE * out, const Uint32 * data, Uint32 l, Uint16 b){ + UtilSequenceRef* sig = (UtilSequenceRef*)data; + fprintf(out, " senderData: %d sequenceId: %d RequestType: %s\n", + sig->senderData, + sig->sequenceId, + type2string((UtilSequenceReq::RequestType)sig->requestType)); + fprintf(out, " errorCode: %d, TCErrorCode: %d\n", + sig->errorCode, sig->TCErrorCode); + return true; +} diff --git a/ndb/src/common/debugger/signaldata/print.awk b/ndb/src/common/debugger/signaldata/print.awk new file mode 100644 index 00000000000..9730fb4a236 --- /dev/null +++ b/ndb/src/common/debugger/signaldata/print.awk @@ -0,0 +1,55 @@ +BEGIN { + m_curr=""; + m_count=0; + m_level=0; +} +/^[ ]*class[ ]+.*{/ { + if(m_curr != ""){ + print; + print "ERROR: " m_curr; + exit; + } + m_curr = $2; +} +/{/ { + m_level++; +} +/bool print/{ + m_print=$3; + i=index($3, "("); + if(i > 0){ + m_print=substr($3, 0, i-1); + } +} + +/[ ]+Uint32[ ]+[^)]*;/ { + if(m_level >= 0){ + m=$2; + i=index($2, ";"); + if(i > 0){ + m=substr($2, 0, i-1); + } + m_members[m_count]=m; + m_count++; + } +} +/^[ ]*}[ ]*;/ { + m_level--; + if(m_level == 0){ + if(m_count > 0 && m_print != ""){ + print "bool"; + print m_print "(FILE * output, const Uint32 * theData, "; + print "Uint32 len, Uint16 receiverBlockNo) {"; + print "const " m_curr " * const sig = (" m_curr " *)theData;"; + for(i = 0; i" m_members[i] ");"; + } + print "return true;"; + print "}"; + print ""; + } + m_curr=""; + m_print=""; + m_count=0; + } +} diff --git a/ndb/src/common/editline/MANIFEST b/ndb/src/common/editline/MANIFEST new file mode 100644 index 00000000000..dc8b4b36f88 --- /dev/null +++ b/ndb/src/common/editline/MANIFEST @@ -0,0 +1,15 @@ +File Name Description +-------------------------------------------------------- +README Release notes and copyright +MANIFEST This shipping list +Make.os9 OS-9 makefile +Makefile Unix makefile +complete.c Filename completion routines +editline.3 Manual page for editline library +editline.c Line-editing routines +editline_internal.h Internal library header file +os9.h OS-9-specific declarations +sysos9.c OS-9-specific routines +sysunix.c Unix-specific routines +testit.c Test driver +unix.h Unix-specific declarations diff --git a/ndb/src/common/editline/Makefile b/ndb/src/common/editline/Makefile new file mode 100644 index 00000000000..800df8f0f31 --- /dev/null +++ b/ndb/src/common/editline/Makefile @@ -0,0 +1,18 @@ +include .defs.mk + +TYPE := + +ARCHIVE_TARGET := editline + +CFLAGS += -DANSI_ARROWS -DHAVE_TCGETATTR -DSYS_UNIX + +ifeq ($(NDB_OS), WIN32) +SOURCES = editline_win32.c +else +SOURCES = complete.c editline.c sysunix.c +endif + +DIRS := test + +include $(NDB_TOP)/Epilogue.mk + diff --git a/ndb/src/common/editline/README b/ndb/src/common/editline/README new file mode 100644 index 00000000000..537c7bd8611 --- /dev/null +++ b/ndb/src/common/editline/README @@ -0,0 +1,53 @@ +-- +NOTE: This version has been modified by Ericsson/Alzato. Please +see the cvs changelog for more details. +-- + +$Revision: 1.2 $ + +This is a line-editing library. It can be linked into almost any +program to provide command-line editing and recall. + +It is call-compatible with the FSF readline library, but it is a +fraction of the size (and offers fewer features). It does not use +standard I/O. It is distributed under a "C News-like" copyright. + +Configuration is done in the Makefile. Type "make testit" to get +a small slow shell for testing. + +This contains some changes since the posting to comp.sources.misc: + - Bugfix for completion on absolute pathnames. + - Better handling of M-n versus showing raw 8bit chars. + - Better signal handling. + - Now supports termios/termio/sgttyb ioctl's. + - Add M-m command to toggle how 8bit data is displayed. +The following changes, made since the last public release, come from +J.G. Vons : + - History-searching no longer redraws the line wrong + - Added ESC-ESC as synonym for ESC-? + - SIGQUIT (normally ^\) now sends a signal, not indicating EOF. + - Fixed some typo's and unclear wording in the manpage. + - Fixed completion when all entries shared a common prefix. + - Fixed some meta-char line-redrawing bugs. + +Enjoy, + Rich $alz + + + Copyright 1992,1993 Simmule Turner and Rich Salz. All rights reserved. + + This software is not subject to any license of the American Telephone + and Telegraph Company or of the Regents of the University of California. + + Permission is granted to anyone to use this software for any purpose on + any computer system, and to alter it and redistribute it freely, subject + to the following restrictions: + 1. The authors are not responsible for the consequences of use of this + software, no matter how awful, even if they arise from flaws in it. + 2. The origin of this software must not be misrepresented, either by + explicit claim or by omission. Since few users ever read sources, + credits must appear in the documentation. + 3. Altered versions must be plainly marked as such, and must not be + misrepresented as being the original software. Since few users + ever read sources, credits must appear in the documentation. + 4. This notice may not be removed or altered. diff --git a/ndb/src/common/editline/complete.c b/ndb/src/common/editline/complete.c new file mode 100644 index 00000000000..d1f8b1d3ff4 --- /dev/null +++ b/ndb/src/common/editline/complete.c @@ -0,0 +1,211 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* -*- c-basic-offset: 4; -*- +** $Revision: 1.8 $ +** +** History and file completion functions for editline library. +*/ +#include "editline_internal.h" + + +/* +** strcmp-like sorting predicate for qsort. +*/ +static int +compare(const void *p1, const void *p2) +{ + const char **v1; + const char **v2; + + v1 = (const char **)p1; + v2 = (const char **)p2; + return strcmp(*v1, *v2); +} + +/* +** Fill in *avp with an array of names that match file, up to its length. +** Ignore . and .. . +*/ +static int +FindMatches(char *dir, char *file, char ***avp) +{ + char **av; + char **new; + char *p; + DIR *dp; + struct dirent *ep; + size_t ac; + size_t len; + + if ((dp = opendir(dir)) == NULL) + return 0; + + av = NULL; + ac = 0; + len = strlen(file); + while ((ep = readdir(dp)) != NULL) { + p = ep->d_name; + if (p[0] == '.' && (p[1] == '\0' || (p[1] == '.' && p[2] == '\0'))) + continue; + if (len && strncmp(p, file, len) != 0) + continue; + + if ((ac % MEM_INC) == 0) { + if ((new = malloc(sizeof(char*) * (ac + MEM_INC))) == NULL) + break; + if (ac) { + memcpy(new, av, ac * sizeof (char **)); + free(av); + } + *avp = av = new; + } + + if ((av[ac] = strdup(p)) == NULL) { + if (ac == 0) + free(av); + break; + } + ac++; + } + + /* Clean up and return. */ + (void)closedir(dp); + if (ac) + qsort(av, ac, sizeof (char **), compare); + return ac; +} + +/* +** Split a pathname into allocated directory and trailing filename parts. +*/ +static int +SplitPath(char *path, char **dirpart, char ** filepart) +{ + static char DOT[] = "."; + char *dpart; + char *fpart; + + if ((fpart = strrchr(path, '/')) == NULL) { + if ((dpart = strdup(DOT)) == NULL) + return -1; + if ((fpart = strdup(path)) == NULL) { + free(dpart); + return -1; + } + } + else { + if ((dpart = strdup(path)) == NULL) + return -1; + dpart[fpart - path + 1] = '\0'; + if ((fpart = strdup(++fpart)) == NULL) { + free(dpart); + return -1; + } + } + *dirpart = dpart; + *filepart = fpart; + return 0; +} + +/* +** Attempt to complete the pathname, returning an allocated copy. +** Fill in *unique if we completed it, or set it to 0 if ambiguous. +*/ +char * +rl_complete(char *pathname,int *unique) +{ + char **av; + char *dir; + char *file; + char *new; + char *p; + size_t ac; + size_t end; + size_t i; + size_t j; + size_t len; + size_t new_len; + size_t p_len; + + if (SplitPath(pathname, &dir, &file) < 0) + return NULL; + if ((ac = FindMatches(dir, file, &av)) == 0) { + free(dir); + free(file); + return NULL; + } + + p = NULL; + len = strlen(file); + if (ac == 1) { + /* Exactly one match -- finish it off. */ + *unique = 1; + j = strlen(av[0]) - len + 2; + p_len = sizeof(char) * (j + 1); + if ((p = malloc(p_len)) != NULL) { + memcpy(p, av[0] + len, j); + new_len = sizeof(char) * (strlen(dir) + strlen(av[0]) + 2); + new = malloc(new_len); + if(new != NULL) { + snprintf(new, new_len, "%s/%s", dir, av[0]); + rl_add_slash(new, p, p_len); + free(new); + } + } + } + else { + /* Find largest matching substring. */ + for (*unique = 0, i = len, end = strlen(av[0]); i < end; i++) + for (j = 1; j < ac; j++) + if (av[0][i] != av[j][i]) + goto breakout; +breakout: + if (i > len) { + j = i - len + 1; + if ((p = malloc(sizeof(char) * j)) != NULL) { + memcpy(p, av[0] + len, j); + p[j - 1] = '\0'; + } + } + } + + /* Clean up and return. */ + free(dir); + free(file); + for (i = 0; i < ac; i++) + free(av[i]); + free(av); + return p; +} + +/* +** Return all possible completions. +*/ +int +rl_list_possib(char *pathname, char ***avp) +{ + char *dir; + char *file; + int ac; + + if (SplitPath(pathname, &dir, &file) < 0) + return 0; + ac = FindMatches(dir, file, avp); + free(dir); + free(file); + return ac; +} diff --git a/ndb/src/common/editline/editline.3 b/ndb/src/common/editline/editline.3 new file mode 100644 index 00000000000..159cc7f87bb --- /dev/null +++ b/ndb/src/common/editline/editline.3 @@ -0,0 +1,178 @@ +.\" $Revision: 1.1 $ +.TH EDITLINE 3 +.SH NAME +editline \- command-line editing library with history +.SH SYNOPSIS +.nf +.B "char *" +.B "readline(prompt)" +.B " char *prompt;" + +.B "void" +.B "add_history(line)" +.B " char *line;" +.fi +.SH DESCRIPTION +.I Editline +is a library that provides an line-editing interface with text recall. +It is intended to be compatible with the +.I readline +library provided by the Free Software Foundation, but much smaller. +The bulk of this manual page describes the user interface. +.PP +The +.I readline +routine returns a line of text with the trailing newline removed. +The data is returned in a buffer allocated with +.IR malloc (3), +so the space should be released with +.IR free (3) +when the calling program is done with it. +Before accepting input from the user, the specified +.I prompt +is displayed on the terminal. +.PP +The +.I add_history +routine makes a copy of the specified +.I line +and adds it to the internal history list. +.SS "User Interface" +A program that uses this library provides a simple emacs-like editing +interface to its users. +A line may be edited before it is sent to the calling program by typing either +control characters or escape sequences. +A control character, shown as a caret followed by a letter, is typed by +holding down the ``control'' key while the letter is typed. +For example, ``^A'' is a control-A. +An escape sequence is entered by typing the ``escape'' key followed by one or +more characters. +The escape key is abbreviated as ``ESC''. +Note that unlike control keys, case matters in escape sequences; ``ESC\ F'' +is not the same as ``ESC\ f''. +.PP +An editing command may be typed anywhere on the line, not just at the +beginning. +In addition, a return may also be typed anywhere on the line, not just at +the end. +.PP +Most editing commands may be given a repeat count, +.IR n , +where +.I n +is a number. +To enter a repeat count, type the escape key, the number, and then +the command to execute. +For example, ``ESC\ 4\ ^f'' moves forward four characters. +If a command may be given a repeat count then the text ``[n]'' is given at the +end of its description. +.PP +The following control characters are accepted: +.RS +.nf +.ta \w'ESC DEL 'u +^A Move to the beginning of the line +^B Move left (backwards) [n] +^D Delete character [n] +^E Move to end of line +^F Move right (forwards) [n] +^G Ring the bell +^H Delete character before cursor (backspace key) [n] +^I Complete filename (tab key); see below +^J Done with line (return key) +^K Kill to end of line (or column [n]) +^L Redisplay line +^M Done with line (alternate return key) +^N Get next line from history [n] +^P Get previous line from history [n] +^R Search backward (forward if [n]) through history for text; +\& prefixing the string with a caret (^) forces it to +\& match only at the beginning of a history line +^T Transpose characters +^V Insert next character, even if it is an edit command +^W Wipe to the mark +^X^X Exchange current location and mark +^Y Yank back last killed text +^[ Start an escape sequence (escape key) +^]c Move forward to next character ``c'' +^? Delete character before cursor (delete key) [n] +.fi +.RE +.PP +The following escape sequences are provided. +.RS +.nf +.ta \w'ESC DEL 'u +ESC\ ^H Delete previous word (backspace key) [n] +ESC\ DEL Delete previous word (delete key) [n] +ESC\ ESC Show possible completions; see below +ESC\ SP Set the mark (space key); see ^X^X and ^Y above +ESC\ . Get the last (or [n]'th) word from previous line +ESC\ ? Show possible completions; see below +ESC\ < Move to start of history +ESC\ > Move to end of history +ESC\ b Move backward a word [n] +ESC\ d Delete word under cursor [n] +ESC\ f Move forward a word [n] +ESC\ l Make word lowercase [n] +ESC\ m Toggle if 8bit chars display as themselves or with +\& an ``M\-'' prefix +ESC\ u Make word uppercase [n] +ESC\ y Yank back last killed text +ESC\ w Make area up to mark yankable +ESC\ nn Set repeat count to the number nn +ESC\ C Read from environment variable ``_C_'', where C is +\& an uppercase letter +.fi +.RE +.PP +The +.I editline +library has a small macro facility. +If you type the escape key followed by an uppercase letter, +.IR C , +then the contents of the environment variable +.I _C_ +are read in as if you had typed them at the keyboard. +For example, if the variable +.I _L_ +contains the following: +.RS +^A^Kecho '^V^[[H^V^[[2J'^M +.RE +Then typing ``ESC L'' will move to the beginning of the line, kill the +entire line, enter the echo command needed to clear the terminal (if your +terminal is like a VT-100), and send the line back to the shell. +.PP +The +.I editline +library also does filename completion. +Suppose the root directory has the following files in it: +.RS +.nf +.ta \w'core 'u +bin vmunix +core vmunix.old +.fi +.RE +If you type ``rm\ /v'' and then the tab key. +.I Editline +will then finish off as much of the name as possible by adding ``munix''. +Because the name is not unique, it will then beep. +If you type the escape key followed by either a question mark or another +escape, it will display the two choices. +If you then type a period and a tab, the library will finish off the filename +for you: +.RS +.nf +.RI "rm /v[TAB]" munix ".[TAB]" old +.fi +.RE +The tab key is shown by ``[TAB]'' and the automatically-entered text +is shown in italics. +.SH "BUGS AND LIMITATIONS" +Cannot handle lines more than 80 columns. +.SH AUTHORS +Simmule R. Turner +and Rich $alz . +Original manual page by DaviD W. Sanderson . diff --git a/ndb/src/common/editline/editline.c b/ndb/src/common/editline/editline.c new file mode 100644 index 00000000000..0529d18b952 --- /dev/null +++ b/ndb/src/common/editline/editline.c @@ -0,0 +1,1514 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* -*- c-basic-offset: 4; -*- +** $Revision: 1.6 $ +** +** Main editing routines for editline library. +*/ +#include "editline_internal.h" +#include +#include +#include + +/* +** Manifest constants. +*/ +#define SCREEN_WIDTH 80 +#define SCREEN_ROWS 24 +#define NO_ARG (-1) +#define DEL 127 +#define TAB '\t' +#define CTL(x) ((x) & 0x1F) +#define ISCTL(x) ((x) && (x) < ' ') +#define UNCTL(x) ((x) + 64) +#define META(x) ((x) | 0x80) +#define ISMETA(x) ((x) & 0x80) +#define UNMETA(x) ((x) & 0x7F) +#define MAPSIZE 32 +#define METAMAPSIZE 16 +#if !defined(HIST_SIZE) +#define HIST_SIZE 20 +#endif /* !defined(HIST_SIZE) */ + +/* +** Command status codes. +*/ +typedef enum _STATUS { + CSdone, CSeof, CSmove, CSdispatch, CSstay, CSsignal +} STATUS; + +/* +** The type of case-changing to perform. +*/ +typedef enum _CASE { + TOupper, TOlower +} CASE; + +/* +** Key to command mapping. +*/ +typedef struct _KEYMAP { + char Key; + char Active; + STATUS (*Function)(); +} KEYMAP; + +/* +** Command history structure. +*/ +typedef struct _HISTORY { + int Size; + int Pos; + char *Lines[HIST_SIZE]; +} HISTORY; + +/* +** Globals. +*/ +int rl_eof; +int rl_erase; +int rl_intr; +int rl_kill; +int rl_quit; +#if defined(DO_SIGTSTP) +int rl_susp; +#endif /* defined(DO_SIGTSTP) */ + +static char NIL[] = ""; +static const char *Input = NIL; +static char *Line; +static const char *Prompt; +static char *Yanked; +static char *Screen; +static char NEWLINE[]= CRLF; +static HISTORY H; +static int Repeat; +static int End; +static int Mark; +static int OldPoint; +static int Point; +static int PushBack; +static int Pushed; +static int Signal; +static KEYMAP Map[MAPSIZE]; +static KEYMAP MetaMap[METAMAPSIZE]; +static size_t Length; +static size_t ScreenCount; +static size_t ScreenSize; +static char *backspace; +static int TTYwidth; +static int TTYrows; + +/* Display print 8-bit chars as `M-x' or as the actual 8-bit char? */ +int rl_meta_chars = 1; + +/* +** Declarations. +*/ +static char *editinput(); + +#if defined(USE_TERMCAP) +extern char *getenv(); +extern char *tgetstr(); +extern int tgetent(); +extern int tgetnum(); +#endif /* defined(USE_TERMCAP) */ + +/* +** TTY input/output functions. +*/ + +static void +TTYflush() +{ + if (ScreenCount) { + (void)write(1, Screen, ScreenCount); + ScreenCount = 0; + } +} + +static void +TTYput(const char c) +{ + Screen[ScreenCount] = c; + if (++ScreenCount >= ScreenSize - 1) { + ScreenSize += SCREEN_INC; + Screen = realloc(Screen, sizeof(char) * ScreenSize); + /* XXX what to do if realloc failes? */ + } +} + +static void +TTYputs(const char *p) +{ + while (*p) + TTYput(*p++); +} + +static void +TTYshow(char c) +{ + if (c == DEL) { + TTYput('^'); + TTYput('?'); + } + else if (c == TAB) { + /* XXX */ + } + else if (ISCTL(c)) { + TTYput('^'); + TTYput(UNCTL(c)); + } + else if (rl_meta_chars && ISMETA(c)) { + TTYput('M'); + TTYput('-'); + TTYput(UNMETA(c)); + } + else + TTYput(c); +} + +static void +TTYstring(char *p) +{ + while (*p) + TTYshow(*p++); +} + +static int +TTYget() +{ + char c; + + TTYflush(); + if (Pushed) { + Pushed = 0; + return PushBack; + } + if (*Input) + return *Input++; + return read(0, &c, (size_t)1) == 1 ? c : EOF; +} + +#define TTYback() (backspace ? TTYputs((const char *)backspace) : TTYput('\b')) + +static void +TTYbackn(int n) +{ + while (--n >= 0) + TTYback(); +} + +static void +TTYinfo() +{ + static int init; +#if defined(USE_TERMCAP) + char *term; + char buff[2048]; + char *bp; + char *p; +#endif /* defined(USE_TERMCAP) */ +#if defined(TIOCGWINSZ) + struct winsize W; +#endif /* defined(TIOCGWINSZ) */ + + if (init) { +#if defined(TIOCGWINSZ) + /* Perhaps we got resized. */ + if (ioctl(0, TIOCGWINSZ, &W) >= 0 + && W.ws_col > 0 && W.ws_row > 0) { + TTYwidth = (int)W.ws_col; + TTYrows = (int)W.ws_row; + } +#endif /* defined(TIOCGWINSZ) */ + return; + } + init++; + + TTYwidth = TTYrows = 0; +#if defined(USE_TERMCAP) + bp = &buff[0]; + if ((term = getenv("TERM")) == NULL) + term = "dumb"; + if (tgetent(buff, term) < 0) { + TTYwidth = SCREEN_WIDTH; + TTYrows = SCREEN_ROWS; + return; + } + p = tgetstr("le", &bp); + backspace = p ? strdup(p) : NULL; + TTYwidth = tgetnum("co"); + TTYrows = tgetnum("li"); +#endif /* defined(USE_TERMCAP) */ + +#if defined(TIOCGWINSZ) + if (ioctl(0, TIOCGWINSZ, &W) >= 0) { + TTYwidth = (int)W.ws_col; + TTYrows = (int)W.ws_row; + } +#endif /* defined(TIOCGWINSZ) */ + + if (TTYwidth <= 0 || TTYrows <= 0) { + TTYwidth = SCREEN_WIDTH; + TTYrows = SCREEN_ROWS; + } +} + + +/* +** Print an array of words in columns. +*/ +static void +columns(int ac, char **av) +{ + char *p; + int i; + int j; + int k; + int len; + int skip; + int longest; + int cols; + + /* Find longest name, determine column count from that. */ + for (longest = 0, i = 0; i < ac; i++) + if ((j = strlen((char *)av[i])) > longest) + longest = j; + cols = TTYwidth / (longest + 3); + + TTYputs((const char *)NEWLINE); + for (skip = ac / cols + 1, i = 0; i < skip; i++) { + for (j = i; j < ac; j += skip) { + for (p = av[j], len = strlen((char *)p), k = len; --k >= 0; p++) + TTYput(*p); + if (j + skip < ac) + while (++len < longest + 3) + TTYput(' '); + } + TTYputs((const char *)NEWLINE); + } +} + +static void +reposition() +{ + int i; + char *p; + + TTYput('\r'); + TTYputs((const char *)Prompt); + for (i = Point, p = Line; --i >= 0; p++) + TTYshow(*p); +} + +static void +left(STATUS Change) +{ + char c; + + TTYback(); + if (Point) { + c = Line[Point - 1]; + if (c == TAB) { + /* XXX */ + } + else if (ISCTL(c)) + TTYback(); + else if (rl_meta_chars && ISMETA(c)) { + TTYback(); + TTYback(); + } + } + if (Change == CSmove) + Point--; +} + +static void +right(STATUS Change) +{ + TTYshow(Line[Point]); + if (Change == CSmove) + Point++; +} + +static STATUS +ring_bell() +{ + TTYput('\07'); + TTYflush(); + return CSstay; +} + +static STATUS +do_macro(int c) +{ + char name[4]; + + name[0] = '_'; + name[1] = c; + name[2] = '_'; + name[3] = '\0'; + + if ((Input = (char *)getenv((char *)name)) == NULL) { + Input = NIL; + return ring_bell(); + } + return CSstay; +} + +static STATUS +do_forward(STATUS move) +{ + int i; + char *p; + + i = 0; + do { + p = &Line[Point]; + for ( ; Point < End && (*p == ' ' || !isalnum((int)*p)); Point++, p++) + if (move == CSmove) + right(CSstay); + + for (; Point < End && isalnum((int)*p); Point++, p++) + if (move == CSmove) + right(CSstay); + + if (Point == End) + break; + } while (++i < Repeat); + + return CSstay; +} + +static STATUS +do_case(CASE type) +{ + int i; + int end; + int count; + char *p; + + (void)do_forward(CSstay); + if (OldPoint != Point) { + if ((count = Point - OldPoint) < 0) + count = -count; + Point = OldPoint; + if ((end = Point + count) > End) + end = End; + for (i = Point, p = &Line[i]; i < end; i++, p++) { + if (type == TOupper) { + if (islower((int)*p)) + *p = toupper((int)*p); + } + else if (isupper((int)*p)) + *p = tolower((int)*p); + right(CSmove); + } + } + return CSstay; +} + +static STATUS +case_down_word() +{ + return do_case(TOlower); +} + +static STATUS +case_up_word() +{ + return do_case(TOupper); +} + +static void +ceol() +{ + int extras; + int i; + char *p; + + for (extras = 0, i = Point, p = &Line[i]; i <= End; i++, p++) { + TTYput(' '); + if (*p == TAB) { + /* XXX */ + } + else if (ISCTL(*p)) { + TTYput(' '); + extras++; + } + else if (rl_meta_chars && ISMETA(*p)) { + TTYput(' '); + TTYput(' '); + extras += 2; + } + } + + for (i += extras; i > Point; i--) + TTYback(); +} + +static void +clear_line() +{ + Point = -strlen(Prompt); + TTYput('\r'); + ceol(); + Point = 0; + End = 0; + Line[0] = '\0'; +} + +static STATUS +insert_string(char *p) +{ + size_t len; + int i; + char *new; + char *q; + + len = strlen((char *)p); + if (End + len >= Length) { + if ((new = malloc(sizeof(char) * (Length + len + MEM_INC))) == NULL) + return CSstay; + if (Length) { + memcpy(new, Line, Length); + free(Line); + } + Line = new; + Length += len + MEM_INC; + } + + for (q = &Line[Point], i = End - Point; --i >= 0; ) + q[len + i] = q[i]; + memcpy(&Line[Point], p, len); + End += len; + Line[End] = '\0'; + TTYstring(&Line[Point]); + Point += len; + + return Point == End ? CSstay : CSmove; +} + +static STATUS +redisplay() +{ + TTYputs((const char *)NEWLINE); + TTYputs((const char *)Prompt); + TTYstring(Line); + return CSmove; +} + +static STATUS +redisplay_no_nl() +{ + TTYput('\r'); + TTYputs((const char *)Prompt); + TTYstring(Line); + return CSmove; +} + +static STATUS +toggle_meta_mode() +{ + rl_meta_chars = !rl_meta_chars; + return redisplay(); +} + + +static char * +next_hist() +{ + return H.Pos >= H.Size - 1 ? NULL : H.Lines[++H.Pos]; +} + +static char * +prev_hist() +{ + return H.Pos == 0 ? NULL : H.Lines[--H.Pos]; +} + +static STATUS +do_insert_hist(char *p) +{ + if (p == NULL) + return ring_bell(); + Point = 0; + reposition(); + ceol(); + End = 0; + return insert_string(p); +} + +static STATUS +do_hist(char *(*move)()) +{ + char *p; + int i; + + i = 0; + do { + if ((p = (*move)()) == NULL) + return ring_bell(); + } while (++i < Repeat); + return do_insert_hist(p); +} + +static STATUS +h_next() +{ + return do_hist(next_hist); +} + +static STATUS +h_prev() +{ + return do_hist(prev_hist); +} + +static STATUS +h_first() +{ + return do_insert_hist(H.Lines[H.Pos = 0]); +} + +static STATUS +h_last() +{ + return do_insert_hist(H.Lines[H.Pos = H.Size - 1]); +} + +/* +** Return zero if pat appears as a substring in text. +*/ +static int +substrcmp(char *text, char *pat,int len) +{ + char c; + + if ((c = *pat) == '\0') + return *text == '\0'; + for ( ; *text; text++) + if (*text == c && strncmp(text, pat, len) == 0) + return 0; + return 1; +} + +static char * +search_hist(char *search,char *(*move)()) +{ + static char *old_search; + int len; + int pos; + int (*match)(); + char *pat; + + /* Save or get remembered search pattern. */ + if (search && *search) { + if (old_search) + free(old_search); + old_search = strdup(search); + } + else { + if (old_search == NULL || *old_search == '\0') + return NULL; + search = old_search; + } + + /* Set up pattern-finder. */ + if (*search == '^') { + match = strncmp; + pat = (char *)(search + 1); + } + else { + match = substrcmp; + pat = (char *)search; + } + len = strlen(pat); + + for (pos = H.Pos; (*move)() != NULL; ) + if ((*match)((char *)H.Lines[H.Pos], pat, len) == 0) + return H.Lines[H.Pos]; + H.Pos = pos; + return NULL; +} + +static STATUS +h_search() +{ + static int Searching; + const char *old_prompt; + char *(*move)(); + char *p; + + if (Searching) + return ring_bell(); + Searching = 1; + + clear_line(); + old_prompt = Prompt; + Prompt = "Search: "; + TTYputs((const char *)Prompt); + move = Repeat == NO_ARG ? prev_hist : next_hist; + p = editinput(); + Searching = 0; + if (p == NULL && Signal > 0) { + Signal = 0; + clear_line(); + Prompt = old_prompt; + return redisplay_no_nl(); + } + p = search_hist(p, move); + clear_line(); + Prompt = old_prompt; + if (p == NULL) { + (void)ring_bell(); + return redisplay_no_nl(); + } + return do_insert_hist(p); +} + +static STATUS +fd_char() +{ + int i; + + i = 0; + do { + if (Point >= End) + break; + right(CSmove); + } while (++i < Repeat); + return CSstay; +} + +static void +save_yank(int begin, int i) +{ + if (Yanked) { + free(Yanked); + Yanked = NULL; + } + + if (i < 1) + return; + + if ((Yanked = malloc(sizeof(char) * (i + 1))) != NULL) { + memcpy(Yanked, &Line[begin], i); + Yanked[i] = '\0'; + } +} + +static STATUS +delete_string(int count) +{ + int i; + char *p; + + if (count <= 0 || End == Point) + return ring_bell(); + + if (count == 1 && Point == End - 1) { + /* Optimize common case of delete at end of line. */ + End--; + p = &Line[Point]; + i = 1; + TTYput(' '); + if (*p == TAB) { + /* XXX */ + } + else if (ISCTL(*p)) { + i = 2; + TTYput(' '); + } + else if (rl_meta_chars && ISMETA(*p)) { + i = 3; + TTYput(' '); + TTYput(' '); + } + TTYbackn(i); + *p = '\0'; + return CSmove; + } + if (Point + count > End && (count = End - Point) <= 0) + return CSstay; + + if (count > 1) + save_yank(Point, count); + + ceol(); + for (p = &Line[Point], i = End - (Point + count) + 1; --i >= 0; p++) + p[0] = p[count]; + End -= count; + TTYstring(&Line[Point]); + return CSmove; +} + +static STATUS +bk_char() +{ + int i; + + i = 0; + do { + if (Point == 0) + break; + left(CSmove); + } while (++i < Repeat); + + return CSstay; +} + +static STATUS +bk_del_char() +{ + int i; + + i = 0; + do { + if (Point == 0) + break; + left(CSmove); + } while (++i < Repeat); + + return delete_string(i); +} + +static STATUS +kill_line() +{ + int i; + + if (Repeat != NO_ARG) { + if (Repeat < Point) { + i = Point; + Point = Repeat; + reposition(); + (void)delete_string(i - Point); + } + else if (Repeat > Point) { + right(CSmove); + (void)delete_string(Repeat - Point - 1); + } + return CSmove; + } + + save_yank(Point, End - Point); + ceol(); + Line[Point] = '\0'; + End = Point; + return CSstay; +} + +static STATUS +insert_char(int c) +{ + STATUS s; + char buff[2]; + char *p; + char *q; + int i; + + if (Repeat == NO_ARG || Repeat < 2) { + buff[0] = c; + buff[1] = '\0'; + return insert_string(buff); + } + + if ((p = malloc(sizeof(char) * (Repeat + 1))) == NULL) + return CSstay; + for (i = Repeat, q = p; --i >= 0; ) + *q++ = c; + *q = '\0'; + Repeat = 0; + s = insert_string(p); + free(p); + return s; +} + +static STATUS +meta() +{ + int c; + KEYMAP *kp; + + if ((c = TTYget()) == EOF) + return CSeof; +#if defined(ANSI_ARROWS) + /* Also include VT-100 arrows. */ + if (c == '[' || c == 'O') + switch ((int)(c = TTYget())) { + default: return ring_bell(); + case EOF: return CSeof; + case 'A': return h_prev(); + case 'B': return h_next(); + case 'C': return fd_char(); + case 'D': return bk_char(); + } +#endif /* defined(ANSI_ARROWS) */ + + if (isdigit(c)) { + for (Repeat = c - '0'; (c = TTYget()) != EOF && isdigit(c); ) + Repeat = Repeat * 10 + c - '0'; + Pushed = 1; + PushBack = c; + return CSstay; + } + + if (isupper(c)) + return do_macro(c); + for (OldPoint = Point, kp = MetaMap; kp < &MetaMap[METAMAPSIZE]; kp++) + if (kp->Key == c && kp->Active) + return (*kp->Function)(); + + return ring_bell(); +} + +static STATUS +emacs(int c) +{ + STATUS s; + KEYMAP *kp; + +#if 0 + /* This test makes it impossible to enter eight-bit characters when + * meta-char mode is enabled. */ + if (rl_meta_chars && ISMETA(c)) { + Pushed = 1; + PushBack = UNMETA(c); + return meta(); + } +#endif /* 0 */ + for (kp = Map; kp < &Map[MAPSIZE]; kp++) + if (kp->Key == c && kp->Active) + break; + s = kp < &Map[MAPSIZE] ? (*kp->Function)() : insert_char((int)c); + if (!Pushed) + /* No pushback means no repeat count; hacky, but true. */ + Repeat = NO_ARG; + return s; +} + +static STATUS +TTYspecial(int c) +{ + if (rl_meta_chars && ISMETA(c)) + return CSdispatch; + + if (c == rl_erase || c == DEL) + return bk_del_char(); + if (c == rl_kill) { + if (Point != 0) { + Point = 0; + reposition(); + } + Repeat = NO_ARG; + return kill_line(); + } + if (c == rl_eof && Point == 0 && End == 0) + return CSeof; + if (c == rl_intr) { + Signal = SIGINT; + return CSsignal; + } + if (c == rl_quit) { + Signal = SIGQUIT; + return CSsignal; + } +#if defined(DO_SIGTSTP) + if (c == rl_susp) { + Signal = SIGTSTP; + return CSsignal; + } +#endif /* defined(DO_SIGTSTP) */ + + return CSdispatch; +} + +static char * +editinput() +{ + int c; + + Repeat = NO_ARG; + OldPoint = Point = Mark = End = 0; + Line[0] = '\0'; + + Signal = -1; + while ((c = TTYget()) != EOF) + switch (TTYspecial(c)) { + case CSdone: + return Line; + case CSeof: + return NULL; + case CSsignal: + return (char *)""; + case CSmove: + reposition(); + break; + case CSdispatch: + switch (emacs(c)) { + case CSdone: + return Line; + case CSeof: + return NULL; + case CSsignal: + return (char *)""; + case CSmove: + reposition(); + break; + case CSdispatch: + case CSstay: + break; + } + break; + case CSstay: + break; + } + return NULL; +} + +static void +hist_add(char *p) +{ + int i; + + if ((p = strdup(p)) == NULL) + return; + if (H.Size < HIST_SIZE) + H.Lines[H.Size++] = p; + else { + free(H.Lines[0]); + for (i = 0; i < HIST_SIZE - 1; i++) + H.Lines[i] = H.Lines[i + 1]; + H.Lines[i] = p; + } + H.Pos = H.Size - 1; +} + +static char * +read_redirected() +{ + int size; + char *p; + char *line; + char *end; + + for (size = MEM_INC, p = line = malloc(sizeof(char) * size), end = p + size; ; p++) { + if (p == end) { + size += MEM_INC; + p = line = realloc(line, size); + end = p + size; + } + if (read(0, p, 1) <= 0) { + /* Ignore "incomplete" lines at EOF, just like we do for a tty. */ + free(line); + return NULL; + } + if (*p == '\n') + break; + } + *p = '\0'; + return line; +} + +/* +** For compatibility with FSF readline. +*/ +/* ARGSUSED0 */ +void +rl_reset_terminal(char *p) +{ + (void)p; /* Suppress warning */ +} + +void +rl_initialize() +{ +} + +int +rl_insert(int count, int c) +{ + if (count > 0) { + Repeat = count; + (void)insert_char(c); + (void)redisplay_no_nl(); + } + return 0; +} + +int (*rl_event_hook)(); + +int +rl_key_action(int c, char flag) +{ + KEYMAP *kp; + int size; + + (void)flag; /* Suppress warning */ + + if (ISMETA(c)) { + kp = MetaMap; + size = METAMAPSIZE; + } + else { + kp = Map; + size = MAPSIZE; + } + for ( ; --size >= 0; kp++) + if (kp->Key == c) { + kp->Active = c ? 1 : 0; + return 1; + } + return -1; +} + +char * +readline(const char *prompt) +{ + char *line; + int s; + + if (!isatty(0)) { + TTYflush(); + return read_redirected(); + } + + if (Line == NULL) { + Length = MEM_INC; + if ((Line = malloc(sizeof(char) * Length)) == NULL) + return NULL; + } + + TTYinfo(); + rl_ttyset(0); + hist_add(NIL); + ScreenSize = SCREEN_INC; + Screen = malloc(sizeof(char) * ScreenSize); + Prompt = prompt ? prompt : (char *)NIL; + TTYputs((const char *)Prompt); + if ((line = editinput()) != NULL) { + line = strdup(line); + TTYputs((const char *)NEWLINE); + TTYflush(); + } + rl_ttyset(1); + free(Screen); + free(H.Lines[--H.Size]); + if (Signal > 0) { + s = Signal; + Signal = 0; + (void)kill(getpid(), s); + } + return (char *)line; +} + +void +add_history(char *p) +{ + if (p == NULL || *p == '\0') + return; + +#if defined(UNIQUE_HISTORY) + if (H.Size && strcmp(p, H.Lines[H.Size - 1]) == 0) + return; +#endif /* defined(UNIQUE_HISTORY) */ + hist_add((char *)p); +} + + +static STATUS +beg_line() +{ + if (Point) { + Point = 0; + return CSmove; + } + return CSstay; +} + +static STATUS +del_char() +{ + return delete_string(Repeat == NO_ARG ? 1 : Repeat); +} + +static STATUS +end_line() +{ + if (Point != End) { + Point = End; + return CSmove; + } + return CSstay; +} + +/* +** Return allocated copy of word under cursor, moving cursor after the +** word. +*/ +static char * +find_word() +{ + static char SEPS[] = "\"#;&|^$=`'{}()<>\n\t "; + char *p; + char *new; + size_t len; + + /* Move forward to end of word. */ + p = &Line[Point]; + for ( ; Point < End && strchr(SEPS, (char)*p) == NULL; Point++, p++) + right(CSstay); + + /* Back up to beginning of word. */ + for (p = &Line[Point]; p > Line && strchr(SEPS, (char)p[-1]) == NULL; p--) + continue; + len = Point - (p - Line) + 1; + if ((new = malloc(sizeof(char) * len)) == NULL) + return NULL; + memcpy(new, p, len); + new[len - 1] = '\0'; + return new; +} + +static STATUS +c_complete() +{ + char *p; + char *word; + int unique; + + word = find_word(); + p = (char *)rl_complete((char *)word, &unique); + if (word) + free(word); + if (p && *p) { + (void)insert_string(p); + if (!unique) + (void)ring_bell(); + free(p); + return redisplay_no_nl(); + } + return ring_bell(); +} + +static STATUS +c_possible() +{ + char **av; + char *word; + int ac; + + word = find_word(); + ac = rl_list_possib((char *)word, (char ***)&av); + if (word) + free(word); + if (ac) { + columns(ac, av); + while (--ac >= 0) + free(av[ac]); + free(av); + return redisplay_no_nl(); + } + return ring_bell(); +} + +static STATUS +accept_line() +{ + Line[End] = '\0'; + return CSdone; +} + +static STATUS +transpose() +{ + char c; + + if (Point) { + if (Point == End) + left(CSmove); + c = Line[Point - 1]; + left(CSstay); + Line[Point - 1] = Line[Point]; + TTYshow(Line[Point - 1]); + Line[Point++] = c; + TTYshow(c); + } + return CSstay; +} + +static STATUS +quote() +{ + int c; + + return (c = TTYget()) == EOF ? CSeof : insert_char((int)c); +} + +static STATUS +wipe() +{ + int i; + + if (Mark > End) + return ring_bell(); + + if (Point > Mark) { + i = Point; + Point = Mark; + Mark = i; + reposition(); + } + + return delete_string(Mark - Point); +} + +static STATUS +mk_set() +{ + Mark = Point; + return CSstay; +} + +static STATUS +exchange() +{ + int c; + + if ((c = TTYget()) != CTL('X')) + return c == EOF ? CSeof : ring_bell(); + + if ((c = Mark) <= End) { + Mark = Point; + Point = c; + return CSmove; + } + return CSstay; +} + +static STATUS +yank() +{ + if (Yanked && *Yanked) + return insert_string(Yanked); + return CSstay; +} + +static STATUS +copy_region() +{ + if (Mark > End) + return ring_bell(); + + if (Point > Mark) + save_yank(Mark, Point - Mark); + else + save_yank(Point, Mark - Point); + + return CSstay; +} + +static STATUS +move_to_char() +{ + int c; + int i; + char *p; + + if ((c = TTYget()) == EOF) + return CSeof; + for (i = Point + 1, p = &Line[i]; i < End; i++, p++) + if (*p == c) { + Point = i; + return CSmove; + } + return CSstay; +} + +static STATUS +fd_word() +{ + return do_forward(CSmove); +} + +static STATUS +fd_kill_word() +{ + int i; + + (void)do_forward(CSstay); + if (OldPoint != Point) { + i = Point - OldPoint; + Point = OldPoint; + return delete_string(i); + } + return CSstay; +} + +static STATUS +bk_word() +{ + int i; + char *p; + + i = 0; + do { + for (p = &Line[Point]; p > Line && !isalnum((int)p[-1]); p--) + left(CSmove); + + for (; p > Line && p[-1] != ' ' && isalnum((int)p[-1]); p--) + left(CSmove); + + if (Point == 0) + break; + } while (++i < Repeat); + + return CSstay; +} + +static STATUS +bk_kill_word() +{ + (void)bk_word(); + if (OldPoint != Point) + return delete_string(OldPoint - Point); + return CSstay; +} + +static int +argify(char *line, char ***avp) +{ + char *c; + char **p; + char **new; + int ac; + int i; + + i = MEM_INC; + if ((*avp = p = malloc(sizeof(char*) * i))== NULL) + return 0; + + for (c = line; isspace((int)*c); c++) + continue; + if (*c == '\n' || *c == '\0') + return 0; + + for (ac = 0, p[ac++] = c; *c && *c != '\n'; ) { + if (isspace((int)*c)) { + *c++ = '\0'; + if (*c && *c != '\n') { + if (ac + 1 == i) { + new = malloc(sizeof(char*) * (i + MEM_INC)); + if (new == NULL) { + p[ac] = NULL; + return ac; + } + memcpy(new, p, i * sizeof (char **)); + i += MEM_INC; + free(p); + *avp = p = new; + } + p[ac++] = c; + } + } + else + c++; + } + *c = '\0'; + p[ac] = NULL; + return ac; +} + +static STATUS +last_argument() +{ + char **av; + char *p; + STATUS s; + int ac; + + if (H.Size == 1 || (p = H.Lines[H.Size - 2]) == NULL) + return ring_bell(); + + if ((p = strdup(p)) == NULL) + return CSstay; + ac = argify(p, &av); + + if (Repeat != NO_ARG) + s = Repeat < ac ? insert_string(av[Repeat]) : ring_bell(); + else + s = ac ? insert_string(av[ac - 1]) : CSstay; + + if (ac) + free(av); + free(p); + return s; +} + +static KEYMAP Map[MAPSIZE] = { + { CTL('@'), 1, ring_bell }, + { CTL('A'), 1, beg_line }, + { CTL('B'), 1, bk_char }, + { CTL('D'), 1, del_char }, + { CTL('E'), 1, end_line }, + { CTL('F'), 1, fd_char }, + { CTL('G'), 1, ring_bell }, + { CTL('H'), 1, bk_del_char }, + { CTL('I'), 1, c_complete }, + { CTL('J'), 1, accept_line }, + { CTL('K'), 1, kill_line }, + { CTL('L'), 1, redisplay }, + { CTL('M'), 1, accept_line }, + { CTL('N'), 1, h_next }, + { CTL('O'), 1, ring_bell }, + { CTL('P'), 1, h_prev }, + { CTL('Q'), 1, ring_bell }, + { CTL('R'), 1, h_search }, + { CTL('S'), 1, ring_bell }, + { CTL('T'), 1, transpose }, + { CTL('U'), 1, ring_bell }, + { CTL('V'), 1, quote }, + { CTL('W'), 1, wipe }, + { CTL('X'), 1, exchange }, + { CTL('Y'), 1, yank }, + { CTL('Z'), 1, ring_bell }, + { CTL('['), 1, meta }, + { CTL(']'), 1, move_to_char }, + { CTL('^'), 1, ring_bell }, + { CTL('_'), 1, ring_bell }, +}; + +static KEYMAP MetaMap[16]= { + { CTL('H'), 1, bk_kill_word }, + { CTL('['), 1, c_possible }, + { DEL, 1, bk_kill_word }, + { ' ', 1, mk_set }, + { '.', 1, last_argument }, + { '<', 1, h_first }, + { '>', 1, h_last }, + { '?', 1, c_possible }, + { 'b', 1, bk_word }, + { 'd', 1, fd_kill_word }, + { 'f', 1, fd_word }, + { 'l', 1, case_down_word }, + { 'm', 1, toggle_meta_mode}, + { 'u', 1, case_up_word }, + { 'y', 1, yank }, + { 'w', 1, copy_region }, +}; diff --git a/ndb/src/common/editline/editline_internal.h b/ndb/src/common/editline/editline_internal.h new file mode 100644 index 00000000000..93c13e55edc --- /dev/null +++ b/ndb/src/common/editline/editline_internal.h @@ -0,0 +1,47 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* $Revision: 1.2 $ +** +** Internal header file for editline library. +*/ + +#include +#include +#include +#if defined(SYS_UNIX) +#include "unix.h" +#endif /* defined(SYS_UNIX) */ + +#define MEM_INC 64 +#define SCREEN_INC 256 + +/* +** Variables and routines internal to this package. +*/ +extern int rl_eof; +extern int rl_erase; +extern int rl_intr; +extern int rl_kill; +extern int rl_quit; +#if defined(DO_SIGTSTP) +extern int rl_susp; +#endif /* defined(DO_SIGTSTP) */ +extern char *rl_complete(); +extern int rl_list_possib(); +extern void rl_ttyset(); +extern void rl_add_slash(); + diff --git a/ndb/src/common/editline/editline_win32.c b/ndb/src/common/editline/editline_win32.c new file mode 100644 index 00000000000..feef0108523 --- /dev/null +++ b/ndb/src/common/editline/editline_win32.c @@ -0,0 +1,33 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include + + +char* readline(const char* prompt) +{ + char* szBuf; + printf(prompt); + szBuf = (char*)malloc(256); + return gets(szBuf); +} + +void add_history(char* pch) +{ +} + diff --git a/ndb/src/common/editline/sysunix.c b/ndb/src/common/editline/sysunix.c new file mode 100644 index 00000000000..000bca78dfc --- /dev/null +++ b/ndb/src/common/editline/sysunix.c @@ -0,0 +1,143 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* $Revision: 1.4 $ +** +** Unix system-dependant routines for editline library. +*/ +#include "editline_internal.h" + +#if defined(HAVE_TCGETATTR) +#include + +void +rl_ttyset(int Reset) +{ + static struct termios old; + struct termios new; + + if (Reset == 0) { + if (tcgetattr(0, &old) < 0) perror("tcgetattr"); + rl_erase = old.c_cc[VERASE]; + rl_kill = old.c_cc[VKILL]; + rl_eof = old.c_cc[VEOF]; + rl_intr = old.c_cc[VINTR]; + rl_quit = old.c_cc[VQUIT]; +#if defined(DO_SIGTSTP) + rl_susp = old.c_cc[VSUSP]; +#endif /* defined(DO_SIGTSTP) */ + + new = old; + new.c_lflag &= ~(ECHO | ICANON | ISIG); + new.c_iflag &= ~(ISTRIP | INPCK); + new.c_cc[VMIN] = 1; + new.c_cc[VTIME] = 0; + if (tcsetattr(0, TCSADRAIN, &new) < 0) perror("tcsetattr"); + } + else + (void)tcsetattr(0, TCSADRAIN, &old); +} + +#else +#if defined(HAVE_TERMIO) +#include + +void +rl_ttyset(int Reset) +{ + static struct termio old; + struct termio new; + + if (Reset == 0) { + (void)ioctl(0, TCGETA, &old); + rl_erase = old.c_cc[VERASE]; + rl_kill = old.c_cc[VKILL]; + rl_eof = old.c_cc[VEOF]; + rl_intr = old.c_cc[VINTR]; + rl_quit = old.c_cc[VQUIT]; +#if defined(DO_SIGTSTP) + rl_susp = old.c_cc[VSUSP]; +#endif /* defined(DO_SIGTSTP) */ + + new = old; + new.c_lflag &= ~(ECHO | ICANON | ISIG); + new.c_iflag &= ~(ISTRIP | INPCK); + new.c_cc[VMIN] = 1; + new.c_cc[VTIME] = 0; + (void)ioctl(0, TCSETAW, &new); + } + else + (void)ioctl(0, TCSETAW, &old); +} + +#else +#include + +void +rl_ttyset(int Reset) +{ + static struct sgttyb old_sgttyb; + static struct tchars old_tchars; + struct sgttyb new_sgttyb; + struct tchars new_tchars; +#if defined(DO_SIGTSTP) + struct ltchars old_ltchars; +#endif /* defined(DO_SIGTSTP) */ + + if (Reset == 0) { + (void)ioctl(0, TIOCGETP, &old_sgttyb); + rl_erase = old_sgttyb.sg_erase; + rl_kill = old_sgttyb.sg_kill; + + (void)ioctl(0, TIOCGETC, &old_tchars); + rl_eof = old_tchars.t_eofc; + rl_intr = old_tchars.t_intrc; + rl_quit = old_tchars.t_quitc; + +#if defined(DO_SIGTSTP) + (void)ioctl(0, TIOCGLTC, &old_ltchars); + rl_susp = old_ltchars.t_suspc; +#endif /* defined(DO_SIGTSTP) */ + + new_sgttyb = old_sgttyb; + new_sgttyb.sg_flags &= ~ECHO; + new_sgttyb.sg_flags |= RAW; +#if defined(PASS8) + new_sgttyb.sg_flags |= PASS8; +#endif /* defined(PASS8) */ + (void)ioctl(0, TIOCSETP, &new_sgttyb); + + new_tchars = old_tchars; + new_tchars.t_intrc = -1; + new_tchars.t_quitc = -1; + (void)ioctl(0, TIOCSETC, &new_tchars); + } + else { + (void)ioctl(0, TIOCSETP, &old_sgttyb); + (void)ioctl(0, TIOCSETC, &old_tchars); + } +} +#endif /* defined(HAVE_TERMIO) */ +#endif /* defined(HAVE_TCGETATTR) */ + +void +rl_add_slash(char *path, char *p, size_t p_len) +{ + struct stat Sb; + + if (stat(path, &Sb) >= 0) + (void)strlcat(p, S_ISDIR(Sb.st_mode) ? "/" : " ", p_len); +} diff --git a/ndb/src/common/editline/test/Makefile b/ndb/src/common/editline/test/Makefile new file mode 100644 index 00000000000..20229d0aa62 --- /dev/null +++ b/ndb/src/common/editline/test/Makefile @@ -0,0 +1,10 @@ +include .defs.mk + +TYPE := util + +BIN_TARGET := editline_test +BIN_TARGET_ARCHIVES := editline + +SOURCES = testit.c + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/common/editline/test/testit.c b/ndb/src/common/editline/test/testit.c new file mode 100644 index 00000000000..9a7dfb7bbdf --- /dev/null +++ b/ndb/src/common/editline/test/testit.c @@ -0,0 +1,59 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* -*- c-basic-offset: 4; -*- +** $Revision: 1.5 $ +** +** A "micro-shell" to test editline library. +** If given any arguments, commands aren't executed. +*/ +#include +#include +#include + +#include +#include + +int +main(int argc, char **argv) +{ + char *prompt; + char *p; + int doit; + + (void)argv; /* Suppress warning */ + + doit = argc == 1; + if ((prompt = getenv("TESTPROMPT")) == NULL) + prompt = "testit> "; + + while ((p = readline(prompt)) != NULL) { + (void)printf("\t\t\t|%s|\n", p); + if (doit) { + if (strncmp(p, "cd ", 3) == 0) { + if (chdir(&p[3]) < 0) + perror(&p[3]); + } else { + if (system(p) != 0) + perror(p); + } + } + add_history(p); + free(p); + } + + return 0; +} diff --git a/ndb/src/common/editline/unix.h b/ndb/src/common/editline/unix.h new file mode 100644 index 00000000000..582c4888856 --- /dev/null +++ b/ndb/src/common/editline/unix.h @@ -0,0 +1,26 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* $Revision: 1.3 $ +** +** Editline system header file for Unix. +*/ + +#define CRLF "\r\n" + +#include +#include +#include diff --git a/ndb/src/common/logger/ConsoleLogHandler.cpp b/ndb/src/common/logger/ConsoleLogHandler.cpp new file mode 100644 index 00000000000..8f6a45fe5dd --- /dev/null +++ b/ndb/src/common/logger/ConsoleLogHandler.cpp @@ -0,0 +1,68 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "ConsoleLogHandler.hpp" + +#include + +ConsoleLogHandler::ConsoleLogHandler() : LogHandler() +{ +} + +ConsoleLogHandler::~ConsoleLogHandler() +{ + +} + +bool +ConsoleLogHandler::open() +{ + return true; +} + +bool +ConsoleLogHandler::close() +{ + return true; +} + +// +// PROTECTED +// +void +ConsoleLogHandler::writeHeader(const char* pCategory, Logger::LoggerLevel level) +{ + char str[LogHandler::MAX_HEADER_LENGTH]; + ndbout << getDefaultHeader(str, pCategory, level); +} + +void +ConsoleLogHandler::writeMessage(const char* pMsg) +{ + ndbout << pMsg; +} + +void +ConsoleLogHandler::writeFooter() +{ + ndbout << getDefaultFooter(); +} + + +bool +ConsoleLogHandler::setParam(const BaseString ¶m, const BaseString &value) { + return false; +} diff --git a/ndb/src/common/logger/FileLogHandler.cpp b/ndb/src/common/logger/FileLogHandler.cpp new file mode 100644 index 00000000000..f3d547b4fe7 --- /dev/null +++ b/ndb/src/common/logger/FileLogHandler.cpp @@ -0,0 +1,241 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "FileLogHandler.hpp" + +#include + +#include +#include + +#include +#include + +// +// PUBLIC +// + +FileLogHandler::FileLogHandler() : + LogHandler(), + m_maxNoFiles(MAX_NO_FILES), + m_maxFileSize(MAX_FILE_SIZE), + m_maxLogEntries(MAX_LOG_ENTRIES) + +{ + m_pLogFile = new File("logger.log", "a+"); +} + +FileLogHandler::FileLogHandler(const char* aFileName, + int maxNoFiles, + long maxFileSize, + unsigned int maxLogEntries) : + LogHandler(), + m_maxNoFiles(maxNoFiles), + m_maxFileSize(maxFileSize), + m_maxLogEntries(maxLogEntries) +{ + m_pLogFile = new File(aFileName, "a+"); +} + +FileLogHandler::~FileLogHandler() +{ + delete m_pLogFile; +} + +bool +FileLogHandler::open() +{ + bool rc = true; + + if (m_pLogFile->open()) + { + if (isTimeForNewFile()) + { + if (!createNewFile()) + { + setErrorCode(errno); + rc = false; + } + } + } + else + { + setErrorCode(errno); + rc = false; + } + + return rc; +} + +bool +FileLogHandler::close() +{ + bool rc = true; + if (!m_pLogFile->close()) + { + setErrorCode(errno); + rc = false; + } + + return rc; +} + +void +FileLogHandler::writeHeader(const char* pCategory, Logger::LoggerLevel level) +{ + char str[LogHandler::MAX_HEADER_LENGTH]; + m_pLogFile->writeChar(getDefaultHeader(str, pCategory, level)); +} + +void +FileLogHandler::writeMessage(const char* pMsg) +{ + m_pLogFile->writeChar(pMsg); +} + +void +FileLogHandler::writeFooter() +{ + static int callCount = 0; + m_pLogFile->writeChar(getDefaultFooter()); + /** + * The reason I also check the number of log entries instead of + * only the log size, is that I do not want to check the file size + * after each log entry which requires system calls and is quite slow. + * TODO: Any better way? + */ + if (callCount % m_maxLogEntries != 0) // Check every m_maxLogEntries + { + if (isTimeForNewFile()) + { + if (!createNewFile()) + { + // Baby one more time... + createNewFile(); + } + } + callCount = 0; + } + callCount++; + + // Needed on Cello since writes to the flash disk does not happen until + // we flush and fsync. + m_pLogFile->flush(); +} + + +// +// PRIVATE +// + +bool +FileLogHandler::isTimeForNewFile() +{ + return (m_pLogFile->size() >= m_maxFileSize); +} + +bool +FileLogHandler::createNewFile() +{ + bool rc = true; + int fileNo = 1; + char newName[MAXPATHLEN]; + + do + { + if (fileNo >= m_maxNoFiles) + { + fileNo = 1; + ::snprintf(newName, sizeof(newName), + "%s.%d", m_pLogFile->getName(), fileNo); + break; + } + ::snprintf(newName, sizeof(newName), + "%s.%d", m_pLogFile->getName(), fileNo++); + + } while (File::exists(newName)); + + m_pLogFile->close(); + if (!File::rename(m_pLogFile->getName(), newName)) + { + setErrorCode(errno); + rc = false; + } + + // Open again + if (!m_pLogFile->open()) + { + setErrorCode(errno); + rc = false; + } + + return rc; +} + +bool +FileLogHandler::setParam(const BaseString ¶m, const BaseString &value){ + if(param == "filename") + return setFilename(value); + if(param == "maxsize") + return setMaxSize(value); + if(param == "maxfiles") + return setMaxFiles(value); + return false; +} + +bool +FileLogHandler::setFilename(const BaseString &filename) { + close(); + if(m_pLogFile) + delete m_pLogFile; + m_pLogFile = new File(filename.c_str(), "a+"); + open(); + return true; +}; + +bool +FileLogHandler::setMaxSize(const BaseString &size) { + char *end; + long val = strtol(size.c_str(), &end, 0); /* XXX */ + if(size.c_str() == end) + return false; + if(strncasecmp("M", end, 1) == 0) + val *= 1024*1024; + if(strncasecmp("k", end, 1) == 0) + val *= 1024; + + m_maxFileSize = val; + + return true; +}; + +bool +FileLogHandler::setMaxFiles(const BaseString &files) { + char *end; + long val = strtol(files.c_str(), &end, 0); + if(files.c_str() == end) + return false; + m_maxNoFiles = val; + + return true; +}; + +bool +FileLogHandler::checkParams() { + if(m_pLogFile == NULL) + return false; + return true; +} diff --git a/ndb/src/common/logger/LogHandler.cpp b/ndb/src/common/logger/LogHandler.cpp new file mode 100644 index 00000000000..d1445555e87 --- /dev/null +++ b/ndb/src/common/logger/LogHandler.cpp @@ -0,0 +1,142 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "LogHandler.hpp" + +#include +#include + +#include + +// +// PUBLIC +// +LogHandler::LogHandler() : + m_pDateTimeFormat("%d-%.2d-%.2d %.2d:%.2d:%.2d"), + m_errorCode(0) +{ +} + +LogHandler::~LogHandler() +{ +} + +void +LogHandler::append(const char* pCategory, Logger::LoggerLevel level, + const char* pMsg) +{ + writeHeader(pCategory, level); + writeMessage(pMsg); + writeFooter(); +} + +const char* +LogHandler::getDefaultHeader(char* pStr, const char* pCategory, + Logger::LoggerLevel level) const +{ + char time[MAX_DATE_TIME_HEADER_LENGTH]; + ::snprintf(pStr, MAX_HEADER_LENGTH, "%s [%s] %s -- ", + getTimeAsString((char*)time), + pCategory, + Logger::LoggerLevelNames[level]); + + return pStr; +} + + +const char* +LogHandler::getDefaultFooter() const +{ + return "\n"; +} + +const char* +LogHandler::getDateTimeFormat() const +{ + return m_pDateTimeFormat; +} + +void +LogHandler::setDateTimeFormat(const char* pFormat) +{ + m_pDateTimeFormat = (char*)pFormat; +} + +char* +LogHandler::getTimeAsString(char* pStr) const +{ + struct tm* tm_now; + time_t now; + now = ::time((time_t*)NULL); +#ifdef NDB_WIN32 + tm_now = localtime(&now); +#else + tm_now = ::localtime(&now); //uses the "current" timezone +#endif + + ::snprintf(pStr, MAX_DATE_TIME_HEADER_LENGTH, + m_pDateTimeFormat, + tm_now->tm_year + 1900, + tm_now->tm_mon + 1, //month is [0,11]. +1 -> [1,12] + tm_now->tm_mday, + tm_now->tm_hour, + tm_now->tm_min, + tm_now->tm_sec); + + return pStr; +} + +int +LogHandler::getErrorCode() const +{ + return m_errorCode; +} + +void +LogHandler::setErrorCode(int code) +{ + m_errorCode = code; +} + +bool +LogHandler::parseParams(const BaseString &_params) { + Vector v_args; + + bool ret = true; + + _params.split(v_args, ","); + for(size_t i=0; i < v_args.size(); i++) { + Vector v_param_value; + + v_args[i].split(v_param_value, "=", 2); + if(v_param_value.size() == 2 && + !setParam(v_param_value[0], v_param_value[1])) + ret = false; + } + + if(!checkParams()) + ret = false; + return ret; +} + +bool +LogHandler::checkParams() { + return true; +} + +// +// PRIVATE +// diff --git a/ndb/src/common/logger/LogHandlerList.cpp b/ndb/src/common/logger/LogHandlerList.cpp new file mode 100644 index 00000000000..f020ad23e56 --- /dev/null +++ b/ndb/src/common/logger/LogHandlerList.cpp @@ -0,0 +1,183 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "LogHandlerList.hpp" + +#include +#include +#include + +// +// PUBLIC +// + +LogHandlerList::LogHandlerList() : + m_size(0), + m_pHeadNode(NULL), + m_pTailNode(NULL), + m_pCurrNode(NULL) +{ +} + +LogHandlerList::~LogHandlerList() +{ + removeAll(); +} + +void +LogHandlerList::add(LogHandler* pNewHandler) +{ + LogHandlerNode* pNode = new LogHandlerNode(); + + if (m_pHeadNode == NULL) + { + m_pHeadNode = pNode; + pNode->pPrev = NULL; + } + else + { + m_pTailNode->pNext = pNode; + pNode->pPrev = m_pTailNode; + } + m_pTailNode = pNode; + pNode->pNext = NULL; + pNode->pHandler = pNewHandler; + + m_size++; +} + +bool +LogHandlerList::remove(LogHandler* pRemoveHandler) +{ + LogHandlerNode* pNode = m_pHeadNode; + bool removed = false; + do + { + if (pNode->pHandler == pRemoveHandler) + { + removeNode(pNode); + removed = true; + break; + } + } while ( (pNode = next(pNode)) != NULL); + + return removed; +} + +void +LogHandlerList::removeAll() +{ + while (m_pHeadNode != NULL) + { + removeNode(m_pHeadNode); + } +} + +LogHandler* +LogHandlerList::next() +{ + LogHandler* pHandler = NULL; + if (m_pCurrNode == NULL) + { + m_pCurrNode = m_pHeadNode; + if (m_pCurrNode != NULL) + { + pHandler = m_pCurrNode->pHandler; + } + } + else + { + m_pCurrNode = next(m_pCurrNode); // Next node + if (m_pCurrNode != NULL) + { + pHandler = m_pCurrNode->pHandler; + } + } + + return pHandler; +} + +int +LogHandlerList::size() const +{ + return m_size; +} + +// +// PRIVATE +// + +LogHandlerList::LogHandlerNode* +LogHandlerList::next(LogHandlerNode* pNode) +{ + LogHandlerNode* pCurr = pNode; + if (pNode->pNext != NULL) + { + pCurr = pNode->pNext; + } + else + { + // Tail + pCurr = NULL; + } + return pCurr; +} + +LogHandlerList::LogHandlerNode* +LogHandlerList::prev(LogHandlerNode* pNode) +{ + LogHandlerNode* pCurr = pNode; + if (pNode->pPrev != NULL) // head + { + pCurr = pNode->pPrev; + } + else + { + // Head + pCurr = NULL; + } + + return pCurr; +} + +void +LogHandlerList::removeNode(LogHandlerNode* pNode) +{ + if (pNode->pPrev == NULL) // If head + { + m_pHeadNode = pNode->pNext; + } + else + { + pNode->pPrev->pNext = pNode->pNext; + } + + if (pNode->pNext == NULL) // if tail + { + m_pTailNode = pNode->pPrev; + } + else + { + pNode->pNext->pPrev = pNode->pPrev; + } + + pNode->pNext = NULL; + pNode->pPrev = NULL; + delete pNode->pHandler; // Delete log handler + delete pNode; + + m_size--; +} diff --git a/ndb/src/common/logger/LogHandlerList.hpp b/ndb/src/common/logger/LogHandlerList.hpp new file mode 100644 index 00000000000..7c001a28a76 --- /dev/null +++ b/ndb/src/common/logger/LogHandlerList.hpp @@ -0,0 +1,93 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef LOGHANDLERLIST_H +#define LOGHANDLERLIST_H + +class LogHandler; + +/** + * Provides a simple linked list of log handlers. + * + * @see LogHandler + * @version #@ $Id: LogHandlerList.hpp,v 1.2 2002/03/14 13:07:21 eyualex Exp $ + */ +class LogHandlerList +{ +public: + /** + * Default Constructor. + */ + LogHandlerList(); + + /** + * Destructor. + */ + ~LogHandlerList(); + + /** + * Adds a new log handler. + * + * @param pNewHandler log handler. + */ + void add(LogHandler* pNewHandler); + + /** + * Removes a log handler from the list and call its destructor. + * + * @param pRemoveHandler the handler to remove + */ + bool remove(LogHandler* pRemoveHandler); + + /** + * Removes all log handlers. + */ + void removeAll(); + + /** + * Returns the next log handler in the list. + * returns a log handler or NULL. + */ + LogHandler* next(); + + /** + * Returns the size of the list. + */ + int size() const; +private: + /** List node */ + struct LogHandlerNode + { + LogHandlerNode* pPrev; + LogHandlerNode* pNext; + LogHandler* pHandler; + }; + + LogHandlerNode* next(LogHandlerNode* pNode); + LogHandlerNode* prev(LogHandlerNode* pNode); + + void removeNode(LogHandlerNode* pNode); + + int m_size; + + LogHandlerNode* m_pHeadNode; + LogHandlerNode* m_pTailNode; + LogHandlerNode* m_pCurrNode; +}; + +#endif + + diff --git a/ndb/src/common/logger/Logger.cpp b/ndb/src/common/logger/Logger.cpp new file mode 100644 index 00000000000..6eaafd91854 --- /dev/null +++ b/ndb/src/common/logger/Logger.cpp @@ -0,0 +1,358 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +#include "Logger.hpp" + +#include +#include +#include +#include "LogHandlerList.hpp" + +#if !defined NDB_OSE || !defined NDB_SOFTOSE || !defined NDB_WIN32 +#include +#endif + +#include +#include +#include + +#include + +// +// PUBLIC +// +const char* Logger::LoggerLevelNames[] = { "OFF ", + "DEBUG ", + "INFO ", + "WARNING ", + "ERROR ", + "CRITICAL", + "ALERT ", + "ALL " + }; +Logger::Logger() : + m_pCategory("Logger"), + m_pConsoleHandler(NULL), + m_pFileHandler(NULL), + m_pSyslogHandler(NULL) +{ + m_pHandlerList = new LogHandlerList(); + m_logLevels[LL_INFO] = true; +} + +Logger::~Logger() +{ + removeAllHandlers(); + delete m_pHandlerList; +} + +void +Logger::setCategory(const char* pCategory) +{ + m_pCategory = pCategory; +} + +bool +Logger::createConsoleHandler() +{ + bool rc = true; + if (m_pConsoleHandler == NULL) + { + m_pConsoleHandler = new ConsoleLogHandler(); + if (!addHandler(m_pConsoleHandler)) // TODO: check error code + { + rc = false; + delete m_pConsoleHandler; + m_pConsoleHandler = NULL; + } + } + + return rc; +} + +void +Logger::removeConsoleHandler() +{ + if (removeHandler(m_pConsoleHandler)) + { + m_pConsoleHandler = NULL; + } +} + +bool +Logger::createFileHandler() +{ + bool rc = true; + if (m_pFileHandler == NULL) + { + m_pFileHandler = new FileLogHandler(); + if (!addHandler(m_pFileHandler)) // TODO: check error code + { + rc = false; + delete m_pFileHandler; + m_pFileHandler = NULL; + } + } + + return rc; +} + +void +Logger::removeFileHandler() +{ + if (removeHandler(m_pFileHandler)) + { + m_pFileHandler = NULL; + } +} + +bool +Logger::createSyslogHandler() +{ + bool rc = true; + if (m_pSyslogHandler == NULL) + { +#if defined NDB_OSE || defined NDB_SOFTOSE || defined NDB_WIN32 + m_pSyslogHandler = new ConsoleLogHandler(); +#else + m_pSyslogHandler = new SysLogHandler(); +#endif + if (!addHandler(m_pSyslogHandler)) // TODO: check error code + { + rc = false; + delete m_pSyslogHandler; + m_pSyslogHandler = NULL; + } + } + + return rc; +} + +void +Logger::removeSyslogHandler() +{ + if (removeHandler(m_pSyslogHandler)) + { + m_pSyslogHandler = NULL; + } +} + +bool +Logger::addHandler(LogHandler* pHandler) +{ + assert(pHandler != NULL); + + bool rc = pHandler->open(); + if (rc) + { + m_pHandlerList->add(pHandler); + } + else + { + delete pHandler; + } + + return rc; +} + +bool +Logger::addHandler(const BaseString &logstring) { + size_t i; + Vector logdest; + Vectorloghandlers; + + logstring.split(logdest, ";"); + + for(i = 0; i < logdest.size(); i++) { + Vector v_type_args; + logdest[i].split(v_type_args, ":", 2); + + BaseString type(v_type_args[0]); + BaseString params; + if(v_type_args.size() >= 2) + params = v_type_args[1]; + + LogHandler *handler = NULL; + + if(type == "SYSLOG") { + handler = new SysLogHandler(); + } else if(type == "FILE") + handler = new FileLogHandler(); + else if(type == "CONSOLE") + handler = new ConsoleLogHandler(); + + if(handler == NULL) + return false; + if(!handler->parseParams(params)) + return false; + loghandlers.push_back(handler); + } + + for(i = 0; i < loghandlers.size(); i++) + addHandler(loghandlers[i]); + + return true; /* @todo handle errors */ +} + +bool +Logger::removeHandler(LogHandler* pHandler) +{ + int rc = false; + if (pHandler != NULL) + { + rc = m_pHandlerList->remove(pHandler); + } + + return rc; +} + +void +Logger::removeAllHandlers() +{ + m_pHandlerList->removeAll(); +} + +bool +Logger::isEnable(LoggerLevel logLevel) const +{ + return m_logLevels[logLevel]; +} + +void +Logger::enable(LoggerLevel logLevel) +{ + if (logLevel == LL_ALL) + { + for (int i = 1; i < MAX_LOG_LEVELS; i++) + { + m_logLevels[i] = true; + } + } + else + { + m_logLevels[logLevel] = true; + } +} + +void +Logger::enable(LoggerLevel fromLogLevel, LoggerLevel toLogLevel) +{ + if (fromLogLevel > toLogLevel) + { + LoggerLevel tmp = toLogLevel; + toLogLevel = fromLogLevel; + fromLogLevel = tmp; + } + + for (int i = fromLogLevel; i <= toLogLevel; i++) + { + m_logLevels[i] = true; + } +} + +void +Logger::disable(LoggerLevel logLevel) +{ + if (logLevel == LL_ALL) + { + for (int i = 0; i < MAX_LOG_LEVELS; i++) + { + m_logLevels[i] = false; + } + } + else + { + m_logLevels[logLevel] = false; + } +} + +void +Logger::alert(const char* pMsg, ...) const +{ + va_list ap; + va_start(ap, pMsg); + log(LL_ALERT, pMsg, ap); + va_end(ap); +} + +void +Logger::critical(const char* pMsg, ...) const +{ + va_list ap; + va_start(ap, pMsg); + log(LL_CRITICAL, pMsg, ap); + va_end(ap); +} +void +Logger::error(const char* pMsg, ...) const +{ + va_list ap; + va_start(ap, pMsg); + log(LL_ERROR, pMsg, ap); + va_end(ap); +} +void +Logger::warning(const char* pMsg, ...) const +{ + va_list ap; + va_start(ap, pMsg); + log(LL_WARNING, pMsg, ap); + va_end(ap); +} + +void +Logger::info(const char* pMsg, ...) const +{ + va_list ap; + va_start(ap, pMsg); + log(LL_INFO, pMsg, ap); + va_end(ap); +} + +void +Logger::debug(const char* pMsg, ...) const +{ + va_list ap; + va_start(ap, pMsg); + log(LL_DEBUG, pMsg, ap); + va_end(ap); +} + +// +// PROTECTED +// + +void +Logger::log(LoggerLevel logLevel, const char* pMsg, va_list ap) const +{ + if (m_logLevels[LL_OFF] == false && m_logLevels[logLevel]) + { + LogHandler* pHandler = NULL; + while ( (pHandler = m_pHandlerList->next()) != NULL) + { + char buf[1024]; + vsnprintf(buf, sizeof(buf), pMsg, ap); + pHandler->append(m_pCategory, logLevel, buf); + } + } +} + +// +// PRIVATE +// + diff --git a/ndb/src/common/logger/Makefile b/ndb/src/common/logger/Makefile new file mode 100644 index 00000000000..994eb86ba35 --- /dev/null +++ b/ndb/src/common/logger/Makefile @@ -0,0 +1,27 @@ +include .defs.mk + +TYPE := ndbapi + +PIC_ARCHIVE := Y +ARCHIVE_TARGET := logger + +DIRS := loggertest + +SOURCES := Logger.cpp LogHandlerList.cpp LogHandler.cpp \ + ConsoleLogHandler.cpp FileLogHandler.cpp + +ifeq ($(NDB_OS), OSE) +NO_SYSLOG := Y +endif + +ifeq ($(NDB_OS), WIN32) +NO_SYSLOG := Y +endif + +ifneq ($(NO_SYSLOG), Y) +SOURCES += SysLogHandler.cpp +endif + +include $(NDB_TOP)/Epilogue.mk + + diff --git a/ndb/src/common/logger/SysLogHandler.cpp b/ndb/src/common/logger/SysLogHandler.cpp new file mode 100644 index 00000000000..f3511bf5638 --- /dev/null +++ b/ndb/src/common/logger/SysLogHandler.cpp @@ -0,0 +1,159 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "SysLogHandler.hpp" + +#include +#include + +// +// PUBLIC +// + +SysLogHandler::SysLogHandler() : + m_severity(LOG_INFO), + m_pIdentity("NDB"), + m_facility(LOG_USER) +{ +} + +SysLogHandler::SysLogHandler(const char* pIdentity, int facility) : + m_severity(LOG_INFO), + m_pIdentity(pIdentity), + m_facility(facility) +{ + +} + +SysLogHandler::~SysLogHandler() +{ +} + +bool +SysLogHandler::open() +{ + ::setlogmask(LOG_UPTO(LOG_DEBUG)); // Log from EMERGENCY down to DEBUG + ::openlog(m_pIdentity, LOG_PID|LOG_CONS|LOG_ODELAY, m_facility); // PID, CONSOLE delay openlog + + return true; +} + +bool +SysLogHandler::close() +{ + ::closelog(); + + return true; +} + +void +SysLogHandler::writeHeader(const char* pCategory, Logger::LoggerLevel level) +{ + // Save category to be used by writeMessage... + m_pCategory = pCategory; + // Map LogLevel to syslog severity + switch (level) + { + case Logger::LL_ALERT: + m_severity = LOG_ALERT; + break; + case Logger::LL_CRITICAL: + m_severity = LOG_CRIT; + break; + case Logger::LL_ERROR: + m_severity = LOG_ERR; + break; + case Logger::LL_WARNING: + m_severity = LOG_WARNING; + break; + case Logger::LL_INFO: + m_severity = LOG_INFO; + break; + case Logger::LL_DEBUG: + m_severity = LOG_DEBUG; + break; + default: + m_severity = LOG_INFO; + break; + } + +} + +void +SysLogHandler::writeMessage(const char* pMsg) +{ + ::syslog(m_facility | m_severity, "[%s] %s", m_pCategory, pMsg); +} + +void +SysLogHandler::writeFooter() +{ + // Need to close it everytime? Do we run out of file descriptors? + //::closelog(); +} + +bool +SysLogHandler::setParam(const BaseString ¶m, const BaseString &value) { + if(param == "facility") { + return setFacility(value); + } + return false; +} + +static const struct syslog_facility { + char *name; + int value; +} facilitynames[] = { + { "auth", LOG_AUTH }, +#ifdef LOG_AUTHPRIV + { "authpriv", LOG_AUTHPRIV }, +#endif + { "cron", LOG_CRON }, + { "daemon", LOG_DAEMON }, +#ifdef LOG_FTP + { "ftp", LOG_FTP }, +#endif + { "kern", LOG_KERN }, + { "lpr", LOG_LPR }, + { "mail", LOG_MAIL }, + { "news", LOG_NEWS }, + { "syslog", LOG_SYSLOG }, + { "user", LOG_USER }, + { "uucp", LOG_UUCP }, + { "local0", LOG_LOCAL0 }, + { "local1", LOG_LOCAL1 }, + { "local2", LOG_LOCAL2 }, + { "local3", LOG_LOCAL3 }, + { "local4", LOG_LOCAL4 }, + { "local5", LOG_LOCAL5 }, + { "local6", LOG_LOCAL6 }, + { "local7", LOG_LOCAL7 }, + { NULL, -1 } +}; + +bool +SysLogHandler::setFacility(const BaseString &facility) { + const struct syslog_facility *c; + for(c = facilitynames; c->name != NULL; c++) { + if(facility == c->name) { + m_facility = c->value; + close(); + open(); + return true; + } + } + return false; +} diff --git a/ndb/src/common/logger/listtest/LogHandlerListUnitTest.cpp b/ndb/src/common/logger/listtest/LogHandlerListUnitTest.cpp new file mode 100644 index 00000000000..22f67d15659 --- /dev/null +++ b/ndb/src/common/logger/listtest/LogHandlerListUnitTest.cpp @@ -0,0 +1,165 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "LogHandlerListUnitTest.hpp" + +#include +#include +#include + +#include + +#include +#include + +typedef bool (*TESTFUNC)(const char*); +typedef struct +{ + const char* name; + TESTFUNC test; +}Tests; + +static Tests testCases[] = { {"Add", &LogHandlerListUnitTest::testAdd}, + {"Remove", &LogHandlerListUnitTest::testRemove}, + {"Traverse Next", &LogHandlerListUnitTest::testTraverseNext} + }; + + +int testFailed = 0; + +int main(int argc, char* argv[]) +{ + char str[256]; + int testCount = (sizeof(testCases) / sizeof(Tests)); + ndbout << "Starting " << testCount << " tests..." << endl; + for (int i = 0; i < testCount; i++) + { + ndbout << "-- " << " Test " << i + 1 + << " [" << testCases[i].name << "] --" << endl; + snprintf(str, 256, "%s %s %s %d", "Logging ", + testCases[i].name, " message ", i); + if (testCases[i].test(str)) + { + ndbout << "-- Passed --" << endl; + } + else + { + ndbout << "-- Failed -- " << endl; + } + + } + ndbout << endl << "-- " << testCount - testFailed << " passed, " + << testFailed << " failed --" << endl; + + return 0; +} + +bool +LogHandlerListUnitTest::testAdd(const char* msg) +{ + bool rc = true; + LogHandlerList list; + int size = 10; + for (int i = 0; i < size; i++) + { + list.add(new ConsoleLogHandler()); + } + if (list.size() != size) + { + rc = false; + } + ndbout << "List size: " << list.size() << endl; + + + return rc; +} +bool +LogHandlerListUnitTest::testRemove(const char* msg) +{ + bool rc = true; + + LogHandlerList list; + int size = 10; + LogHandler* pHandlers[10]; + for (int i = 0; i < size; i++) + { + pHandlers[i] = new ConsoleLogHandler(); + list.add(pHandlers[i]); + } + + // Remove + + for (int i = 0; i < size; i++) + { + if (!list.remove(pHandlers[i])) + { + ndbout << "Could not remove handler!" << endl; + } + else + { + ndbout << "List size: " << list.size() << endl; + } + } + + return rc; + +} +bool +LogHandlerListUnitTest::testTraverseNext(const char* msg) +{ + bool rc = true; + LogHandlerList list; + int size = 10; + LogHandler* pHandlers[10]; + + for (int i = 0; i < size; i++) + { + char* str = new char[3]; + pHandlers[i] = new ConsoleLogHandler(); + ::snprintf(str, 3, "%d", i); + pHandlers[i]->setDateTimeFormat(str); + list.add(pHandlers[i]); + } + + ndbout << "List size: " << list.size() << endl; + + LogHandler* pHandler = NULL; + int i = 0; + while ((pHandler = list.next()) != NULL) + { + ndbout << "Handler[" << i++ << "]:dateformat = " + << pHandler->getDateTimeFormat() << endl; + } + + list.removeAll(); + + return rc; + +} + +void +LogHandlerListUnitTest::error(const char* msg) +{ + testFailed++; + ndbout << "Test failed: " << msg << endl; +} + +LogHandlerListUnitTest::LogHandlerListUnitTest() +{ +} +LogHandlerListUnitTest::~LogHandlerListUnitTest() +{ +} diff --git a/ndb/src/common/logger/listtest/LogHandlerListUnitTest.hpp b/ndb/src/common/logger/listtest/LogHandlerListUnitTest.hpp new file mode 100644 index 00000000000..e98a2722b8d --- /dev/null +++ b/ndb/src/common/logger/listtest/LogHandlerListUnitTest.hpp @@ -0,0 +1,40 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef LOGHANDLERLISTUNITTEST_H +#define LOGHANDLERLISTUNITTEST_H + +#include "LogHandlerList.hpp" + +/** + * Unit test of LogHandlerList. + * + * @version #@ $Id: LogHandlerListUnitTest.hpp,v 1.1 2002/03/13 17:59:15 eyualex Exp $ + */ +class LogHandlerListUnitTest +{ +public: + + static bool testAdd(const char* msg); + static bool testRemove(const char* msg); + static bool testTraverseNext(const char* msg); + + void error(const char* msg); + + LogHandlerListUnitTest(); + ~LogHandlerListUnitTest(); +}; +#endif diff --git a/ndb/src/common/logger/listtest/Makefile b/ndb/src/common/logger/listtest/Makefile new file mode 100644 index 00000000000..4688a5e5a2f --- /dev/null +++ b/ndb/src/common/logger/listtest/Makefile @@ -0,0 +1,14 @@ +include .defs.mk + +TYPE := + +BIN_TARGET := listtest +BIN_TARGET_ARCHIVES := portlib logger general + +SOURCES := LogHandlerListUnitTest.cpp + +CCFLAGS_LOC += -I../ -I$(NDB_TOP)/include/logger -I$(NDB_TOP)/include/portlib + +include $(NDB_TOP)/Epilogue.mk + + diff --git a/ndb/src/common/logger/loggertest/LoggerUnitTest.cpp b/ndb/src/common/logger/loggertest/LoggerUnitTest.cpp new file mode 100644 index 00000000000..4b0241a0b03 --- /dev/null +++ b/ndb/src/common/logger/loggertest/LoggerUnitTest.cpp @@ -0,0 +1,201 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "LoggerUnitTest.hpp" + +#include +#include +#include + +#if !defined NDB_OSE || !defined NDB_SOFTOSE +#include +#endif + +#include +#include +#include + +#include +#include + +typedef bool (*TESTFUNC)(const char*); +typedef struct +{ + const char* name; + TESTFUNC test; +}Tests; + +static Tests testCases[] = { {"Alert", &LoggerUnitTest::testAlert}, + {"Critical", &LoggerUnitTest::testCritical}, + {"Error", &LoggerUnitTest::testError}, + {"Warning", &LoggerUnitTest::testWarning}, + {"Info", &LoggerUnitTest::testInfo}, + {"Debug", &LoggerUnitTest::testDebug}, + {"Info to Critical", &LoggerUnitTest::testInfoCritical}, + {"All", &LoggerUnitTest::testAll}, + {"Off", &LoggerUnitTest::testOff} + }; + +static Logger logger; +int testFailed = 0; + +NDB_COMMAND(loggertest, "loggertest", "loggertest -console | -file", + "loggertest", 16384) +{ + if (argc < 2) + { +#if defined NDB_OSE || defined NDB_SOFTOSE + ndbout << "Usage: loggertest -console | -file" << endl; +#else + ndbout << "Usage: loggertest -console | -file | -syslog" << endl; +#endif + return 0; + } + + if (strcmp(argv[1], "-console") == 0) + { + logger.createConsoleHandler(); + } + else if (strcmp(argv[1], "-file") == 0) + { + logger.createFileHandler(); + //logger.addHandler(new FileLogHandler(argv[2])); + } +#if !defined NDB_OSE || !defined NDB_SOFTOSE + else if (strcmp(argv[1], "-syslog") == 0) + { + logger.createSyslogHandler(); + } +#endif + + logger.disable(Logger::LL_ALL); + + char str[256]; + int testCount = (sizeof(testCases) / sizeof(Tests)); + ndbout << "Starting " << testCount << " tests..." << endl; + for (int i = 0; i < testCount; i++) + { + ndbout << "-- " << " Test " << i + 1 + << " [" << testCases[i].name << "] --" << endl; + ::snprintf(str, 256, "%s %s %s %d", "Logging ", + testCases[i].name, " message ", i); + if (testCases[i].test(str)) + { + ndbout << "-- Passed --" << endl; + } + else + { + ndbout << "-- Failed -- " << endl; + } + + } + ndbout << endl << "-- " << testCount - testFailed << " passed, " + << testFailed << " failed --" << endl; + + logger.removeAllHandlers(); // Need to remove all for OSE, + // because logger is global + return 0; +} + +bool +LoggerUnitTest::logTo(Logger::LoggerLevel from, Logger::LoggerLevel to, const char* msg) +{ + logger.enable(from, to); + return logTo(from, msg); +} + +bool +LoggerUnitTest::logTo(Logger::LoggerLevel level, const char* msg) +{ + logger.enable(level); + logger.alert(msg); + logger.critical(msg); + logger.error(msg); + logger.warning(msg); + logger.info(msg); + logger.debug(msg); + logger.disable(level); + return true; +} + +bool +LoggerUnitTest::testAll(const char* msg) +{ + return logTo(Logger::LL_ALL, msg); +} + +bool +LoggerUnitTest::testOff(const char* msg) +{ + return logTo(Logger::LL_OFF, msg); + +} + +bool +LoggerUnitTest::testAlert(const char* msg) +{ + return logTo(Logger::LL_ALERT, msg); +} + +bool +LoggerUnitTest::testCritical(const char* msg) +{ + return logTo(Logger::LL_CRITICAL, msg); +} + +bool +LoggerUnitTest::testError(const char* msg) +{ + return logTo(Logger::LL_ERROR, msg); +} + +bool +LoggerUnitTest::testWarning(const char* msg) +{ + return logTo(Logger::LL_WARNING, msg); +} + +bool +LoggerUnitTest::testInfo(const char* msg) +{ + return logTo(Logger::LL_INFO, msg); +} + +bool +LoggerUnitTest::testDebug(const char* msg) +{ + return logTo(Logger::LL_DEBUG, msg); +} + +bool +LoggerUnitTest::testInfoCritical(const char* msg) +{ + return logTo(Logger::LL_CRITICAL, Logger::LL_INFO, msg); +} + +void +LoggerUnitTest::error(const char* msg) +{ + testFailed++; + ndbout << "Test failed: " << msg << endl; +} + +LoggerUnitTest::LoggerUnitTest() +{ +} +LoggerUnitTest::~LoggerUnitTest() +{ +} diff --git a/ndb/src/common/logger/loggertest/LoggerUnitTest.hpp b/ndb/src/common/logger/loggertest/LoggerUnitTest.hpp new file mode 100644 index 00000000000..79f560750d5 --- /dev/null +++ b/ndb/src/common/logger/loggertest/LoggerUnitTest.hpp @@ -0,0 +1,49 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef LOGGERUNITTEST_H +#define LOGGERUNITTEST_H + +#include "Logger.hpp" + +/** + * Unit test of Logger. + * + * @version #@ $Id: LoggerUnitTest.hpp,v 1.1 2002/03/13 17:55:31 eyualex Exp $ + */ +class LoggerUnitTest +{ +public: + + static bool testAll(const char* msg); + static bool testOff(const char* msg); + static bool testAlert(const char* msg); + static bool testCritical(const char* msg); + static bool testError(const char* msg); + static bool testWarning(const char* msg); + static bool testInfo(const char* msg); + static bool testDebug(const char* msg); + static bool testInfoCritical(const char* msg); + + static bool logTo(Logger::LoggerLevel level, const char* msg); + static bool logTo(Logger::LoggerLevel from, Logger::LoggerLevel to, const char* msg); + + void error(const char* msg); + + LoggerUnitTest(); + ~LoggerUnitTest(); +}; +#endif diff --git a/ndb/src/common/logger/loggertest/Makefile b/ndb/src/common/logger/loggertest/Makefile new file mode 100644 index 00000000000..0aef0ca2bce --- /dev/null +++ b/ndb/src/common/logger/loggertest/Makefile @@ -0,0 +1,16 @@ +include .defs.mk + +TYPE := + +BIN_TARGET := loggertest +BIN_TARGET_ARCHIVES := logger portlib general + +SOURCES := LoggerUnitTest.cpp + +CCFLAGS_LOC += -I$(NDB_TOP)/include/logger \ + -I$(NDB_TOP)/include/util \ + -I$(NDB_TOP)/include/portlib + +include $(NDB_TOP)/Epilogue.mk + + diff --git a/ndb/src/common/mgmcommon/Config.cpp b/ndb/src/common/mgmcommon/Config.cpp new file mode 100644 index 00000000000..5492394ee4a --- /dev/null +++ b/ndb/src/common/mgmcommon/Config.cpp @@ -0,0 +1,255 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Config.hpp" +#include +#include +#include "MgmtErrorReporter.hpp" +#include +#include "ConfigInfo.hpp" + +//***************************************************************************** +// Ctor / Dtor +//***************************************************************************** + +Config::Config() { + m_info = new ConfigInfo(); +} + +Config::Config(const Config & org) : + Properties(org) { + + m_info = new ConfigInfo(); +} + +Config::Config(const Properties & org) : + Properties(org) { + + m_info = new ConfigInfo(); +} + +Config::~Config() { + delete m_info; +} + +/*****************************************************************************/ + +void +Config::printAllNameValuePairs(NdbOut &out, + const Properties *prop, + const char* s) const { + Properties::Iterator it(prop); + const Properties * section = m_info->getInfo(s); + for (const char* n = it.first(); n != NULL; n = it.next()) { + Uint32 int_value; + const char* str_value; + + if (m_info->getStatus(section, n) == ConfigInfo::INTERNAL) + continue; + if (m_info->getStatus(section, n) == ConfigInfo::DEPRICATED) + continue; + if (m_info->getStatus(section, n) == ConfigInfo::NOTIMPLEMENTED) + continue; + + out << n << ": "; + + switch (m_info->getType(section, n)) { + case ConfigInfo::INT: + MGM_REQUIRE(prop->get(n, &int_value)); + out << int_value; + break; + + case ConfigInfo::BOOL: + MGM_REQUIRE(prop->get(n, &int_value)); + if (int_value) { + out << "Y"; + } else { + out << "N"; + } + break; + case ConfigInfo::STRING: + MGM_REQUIRE(prop->get(n, &str_value)); + out << str_value; + break; + } + out << endl; + } +} + +/*****************************************************************************/ + +void Config::printConfigFile(NdbOut &out) const { + Uint32 noOfNodes, noOfConnections, noOfComputers; + MGM_REQUIRE(get("NoOfNodes", &noOfNodes)); + MGM_REQUIRE(get("NoOfConnections", &noOfConnections)); + MGM_REQUIRE(get("NoOfComputers", &noOfComputers)); + + out << + "######################################################################" << + endl << + "#" << endl << + "# NDB Cluster System configuration" << endl << + "#" << endl << + "######################################################################" << + endl << + "# No of nodes (DB, API or MGM): " << noOfNodes << endl << + "# No of connections: " << noOfConnections << endl << + "######################################################################" << + endl; + + /************************** + * Print COMPUTER configs * + **************************/ + const char * name; + Properties::Iterator it(this); + for(name = it.first(); name != NULL; name = it.next()){ + if(strncasecmp("Computer_", name, 9) == 0){ + + const Properties *prop; + out << endl << "[COMPUTER]" << endl; + MGM_REQUIRE(get(name, &prop)); + printAllNameValuePairs(out, prop, "COMPUTER"); + + out << endl << + "###################################################################" << + endl; + + } else if(strncasecmp("Node_", name, 5) == 0){ + /********************** + * Print NODE configs * + **********************/ + const Properties *prop; + const char *s; + + MGM_REQUIRE(get(name, &prop)); + MGM_REQUIRE(prop->get("Type", &s)); + out << endl << "[" << s << "]" << endl; + printAllNameValuePairs(out, prop, s); + + out << endl << + "###################################################################" << + endl; + } else if(strncasecmp("Connection_", name, 11) == 0){ + /**************************** + * Print CONNECTION configs * + ****************************/ + const Properties *prop; + const char *s; + + MGM_REQUIRE(get(name, &prop)); + MGM_REQUIRE(prop->get("Type", &s)); + out << endl << "[" << s << "]" << endl; + printAllNameValuePairs(out, prop, s); + + out << endl << + "###################################################################" << + endl; + } else if(strncasecmp("SYSTEM", name, strlen("SYSTEM")) == 0) { + /************************ + * Print SYSTEM configs * + ************************/ + const Properties *prop; + + MGM_REQUIRE(get(name, &prop)); + out << endl << "[SYSTEM]" << endl; + printAllNameValuePairs(out, prop, "SYSTEM"); + + out << endl << + "###################################################################" << + endl; + } + } +} + +const +ConfigInfo* Config::getConfigInfo() const { + return m_info; +} + +Uint32 +Config::getGenerationNumber() const { + Uint32 ret; + const Properties *prop = NULL; + + get("SYSTEM", &prop); + + if(prop != NULL) + if(prop->get("ConfigGenerationNumber", &ret)) + return ret; + + return 0; +} + +int +Config::setGenerationNumber(Uint32 gen) { + Properties *prop = NULL; + + getCopy("SYSTEM", &prop); + + if(prop != NULL) { + MGM_REQUIRE(prop->put("ConfigGenerationNumber", gen, true)); + MGM_REQUIRE(put("SYSTEM", prop, true)); + return 0; + } + return -1; +} + +bool +Config::change(const BaseString §ion, + const BaseString ¶m, + const BaseString &value) { + const char *name; + Properties::Iterator it(this); + + for(name = it.first(); name != NULL; name = it.next()) { + Properties *prop = NULL; + if(strcasecmp(section.c_str(), name) == 0) { + getCopy(name, &prop); + if(prop == NULL) /* doesn't exist */ + return false; + if(value == "") { + prop->remove(param.c_str()); + put(section.c_str(), prop, true); + } else { + PropertiesType t; + if(!prop->getTypeOf(param.c_str(), &t)) /* doesn't exist */ + return false; + switch(t) { + case PropertiesType_Uint32: + long val; + char *ep; + errno = 0; + val = strtol(value.c_str(), &ep, 0); + if(value.length() == 0 || *ep != '\0') /* not a number */ + return false; + if(errno == ERANGE) + return false; + prop->put(param.c_str(), (unsigned int)val, true); + put(section.c_str(), prop, true); + break; + case PropertiesType_char: + prop->put(param.c_str(), value.c_str(), true); + put(section.c_str(), prop, true); + break; + default: + return false; + } + } + break; + } + } + return true; +} diff --git a/ndb/src/common/mgmcommon/Config.hpp b/ndb/src/common/mgmcommon/Config.hpp new file mode 100644 index 00000000000..1314abe004a --- /dev/null +++ b/ndb/src/common/mgmcommon/Config.hpp @@ -0,0 +1,86 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef Config_H +#define Config_H + +#include +#include + +#include + +#include +#include +#include +#include +#include + +/** + * @class Config + * @brief Cluster Configuration (corresponds to initial configuration file) + * + * Contains all cluster configuration parameters. + * + * The information includes all configurable parameters for a NDB cluster: + * - DB, API and MGM nodes with all their properties, + * - Connections between nodes and computers the nodes will execute on. + * + * The following categories (sections) of configuration parameters exists: + * - COMPUTER, DB, MGM, API, TCP, SCI, SHM, OSE + */ +class Config : public Properties { +public: + /** + * Constructor which loads the object with an Properties object + */ + Config(const Config & org); + Config(const Properties & org); + Config(); + virtual ~Config(); + + /** + * Prints the configuration in configfile format + */ + void printConfigFile(NdbOut &out = ndbout) const; + void printConfigFile(OutputStream &out) const { + NdbOut ndb(out); + printConfigFile(ndb); + } + + const class ConfigInfo* getConfigInfo() const; + + Uint32 getGenerationNumber() const; + int setGenerationNumber(Uint32); + + /** Change configuration + */ + bool change(const BaseString §ion, + const BaseString ¶m, + const BaseString &value); + +private: + + void printAllNameValuePairs(NdbOut &out, + const Properties *prop, + const char* section) const; + + /** + * Information about parameters (min, max values etc) + */ + const class ConfigInfo* m_info; +}; + +#endif // Config_H diff --git a/ndb/src/common/mgmcommon/ConfigInfo.cpp b/ndb/src/common/mgmcommon/ConfigInfo.cpp new file mode 100644 index 00000000000..da6024d946f --- /dev/null +++ b/ndb/src/common/mgmcommon/ConfigInfo.cpp @@ -0,0 +1,2629 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "ConfigInfo.hpp" +#define MAX_LINE_LENGTH 255 + +/**************************************************************************** + * Section names + ****************************************************************************/ +const char* +ConfigInfo::m_sectionNames[]={ + "SYSTEM", + "EXTERNAL SYSTEM", + "COMPUTER", + + "DB", + "MGM", + "API", + "REP", + "EXTERNAL REP", + + "TCP", + "SCI", + "SHM", + "OSE" +}; +const int ConfigInfo::m_noOfSectionNames = +sizeof(m_sectionNames)/sizeof(char*); + + +/**************************************************************************** + * Section Rules declarations + ****************************************************************************/ +bool transformComputer(InitConfigFileParser::Context & ctx, const char *); +bool transformSystem(InitConfigFileParser::Context & ctx, const char *); +bool transformExternalSystem(InitConfigFileParser::Context & ctx, const char *); +bool transformNode(InitConfigFileParser::Context & ctx, const char *); +bool transformExtNode(InitConfigFileParser::Context & ctx, const char *); +bool transformConnection(InitConfigFileParser::Context & ctx, const char *); +bool applyDefaultValues(InitConfigFileParser::Context & ctx, const char *); +bool checkMandatory(InitConfigFileParser::Context & ctx, const char *); +bool fixPortNumber(InitConfigFileParser::Context & ctx, const char *); +bool fixShmkey(InitConfigFileParser::Context & ctx, const char *); +bool checkDbConstraints(InitConfigFileParser::Context & ctx, const char *); +bool checkConnectionConstraints(InitConfigFileParser::Context &, const char *); +bool fixHostname(InitConfigFileParser::Context & ctx, const char * data); +bool fixNodeId(InitConfigFileParser::Context & ctx, const char * data); +bool fixExtConnection(InitConfigFileParser::Context & ctx, const char * data); + +const ConfigInfo::SectionRule +ConfigInfo::m_SectionRules[] = { + { "SYSTEM", transformSystem, 0 }, + { "EXTERNAL SYSTEM", transformExternalSystem, 0 }, + { "COMPUTER", transformComputer, 0 }, + + { "DB", transformNode, 0 }, + { "API", transformNode, 0 }, + { "MGM", transformNode, 0 }, + { "REP", transformNode, 0 }, + { "EXTERNAL REP", transformExtNode, 0 }, + + { "TCP", transformConnection, 0 }, + { "SHM", transformConnection, 0 }, + { "SCI", transformConnection, 0 }, + { "OSE", transformConnection, 0 }, + + { "TCP", fixPortNumber, 0 }, + //{ "SHM", fixShmKey, 0 }, + + { "COMPUTER", applyDefaultValues, 0 }, + + { "DB", applyDefaultValues, 0 }, + { "API", applyDefaultValues, 0 }, + { "MGM", applyDefaultValues, 0 }, + { "REP", applyDefaultValues, 0 }, + { "EXTERNAL REP", applyDefaultValues, 0 }, + + { "TCP", applyDefaultValues, 0 }, + { "SHM", applyDefaultValues, 0 }, + { "SCI", applyDefaultValues, 0 }, + { "OSE", applyDefaultValues, 0 }, + + { "DB", checkDbConstraints, 0 }, + + { "TCP", fixNodeId, "NodeId1" }, + { "TCP", fixNodeId, "NodeId2" }, + { "SHM", fixNodeId, "NodeId1" }, + { "SHM", fixNodeId, "NodeId2" }, + { "SCI", fixNodeId, "NodeId1" }, + { "SCI", fixNodeId, "NodeId2" }, + { "OSE", fixNodeId, "NodeId1" }, + { "OSE", fixNodeId, "NodeId2" }, + + /** + * fixExtConnection must be after fixNodeId + */ + { "TCP", fixExtConnection, 0 }, + { "SHM", fixExtConnection, 0 }, + { "SCI", fixExtConnection, 0 }, + { "OSE", fixExtConnection, 0 }, + + /** + * checkConnectionConstraints must be after fixExtConnection + */ + { "TCP", checkConnectionConstraints, 0 }, + { "SHM", checkConnectionConstraints, 0 }, + { "SCI", checkConnectionConstraints, 0 }, + { "OSE", checkConnectionConstraints, 0 }, + + { "COMPUTER", checkMandatory, 0 }, + + { "DB", checkMandatory, 0 }, + { "API", checkMandatory, 0 }, + { "MGM", checkMandatory, 0 }, + { "REP", checkMandatory, 0 }, + + { "TCP", checkMandatory, 0 }, + { "SHM", checkMandatory, 0 }, + { "SCI", checkMandatory, 0 }, + { "OSE", checkMandatory, 0 }, + + { "TCP", fixHostname, "HostName1" }, + { "TCP", fixHostname, "HostName2" }, + { "OSE", fixHostname, "HostName1" }, + { "OSE", fixHostname, "HostName2" }, +}; +const int ConfigInfo::m_NoOfRules = sizeof(m_SectionRules)/sizeof(SectionRule); + +/** + * The default constructors create objects with suitable values for the + * configuration parameters. + * + * Some are however given the value MANDATORY which means that the value + * must be specified in the configuration file. + * + * Min and max values are also given for some parameters. + * - Attr1: Name in file (initial config file) + * - Attr2: Name in prop (properties object) + * - Attr3: Name of Section (in init config file) + * - Attr4: Updateable + * - Attr5: Type of parameter (INT or BOOL) + * - Attr6: Default Value (number only) + * - Attr7: Min value + * - Attr8: Max value + * + * Parameter constraints are coded in file Config.cpp. + * + * ******************************************************************* + * Parameters used under development should be marked "NOTIMPLEMENTED" + * ******************************************************************* + */ +const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = { + + /**************************************************************************** + * COMPUTER + ****************************************************************************/ + + {"Id", + "Id", + "COMPUTER", + "Name of computer", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + MANDATORY, + 0, + 0}, + + {"HostName", + "HostName", + "COMPUTER", + "Hostname of computer (e.g. mysql.com)", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + MANDATORY, + 0, + 0x7FFFFFFF}, + + {"ByteOrder", + "ByteOrder", + "COMPUTER", + "Not yet implemented", + ConfigInfo::USED, // Actually not used, but since it is MANDATORY, + // we don't want any warning message + false, + ConfigInfo::STRING, + MANDATORY, // Big == 0, Little == 1, NotSet == 2 (?) + 0, + 0x7FFFFFFF}, + + /**************************************************************************** + * DB + ****************************************************************************/ + + {"Id", + "Id", + "DB", + "Number identifying the database node (DB)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + MANDATORY, + 1, + (MAX_NODES - 1)}, + + {"Type", + "Type", + "DB", + "Type of node (Should have value DB)", + ConfigInfo::INTERNAL, + false, + ConfigInfo::STRING, + 0, + 0, + 0}, + + {"NoOfReplicas", + "NoOfReplicas", + "DB", + "Number of copies of all data in the database (1-4)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + MANDATORY, + 1, + 4}, + + {"MaxNoOfAttributes", + "MaxNoOfAttributes", + "DB", + "Total number of attributes stored in database. I.e. sum over all tables", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 1000, + 32, + 4096}, + + {"MaxNoOfTables", + "MaxNoOfTables", + "DB", + "Total number of tables stored in the database", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 32, + 8, + 128}, + + {"MaxNoOfIndexes", + "MaxNoOfIndexes", + "DB", + "Total number of indexes that can be defined in the system", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 128, + 0, + 2048}, + + {"MaxNoOfConcurrentIndexOperations", + "MaxNoOfConcurrentIndexOperations", + "DB", + "Total number of index operations that can execute simultaneously on one DB node", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 8192, + 0, + 1000000 + }, + + {"MaxNoOfTriggers", + "MaxNoOfTriggers", + "DB", + "Total number of triggers that can be defined in the system", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 768, + 0, + 2432}, + + {"MaxNoOfFiredTriggers", + "MaxNoOfFiredTriggers", + "DB", + "Total number of triggers that can fire simultaneously in one DB node", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 1000, + 0, + 1000000}, + + {"ExecuteOnComputer", + "ExecuteOnComputer", + "DB", + "String referencing an earlier defined COMPUTER", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + MANDATORY, + 0, + 0x7FFFFFFF}, + + {"MaxNoOfSavedMessages", + "MaxNoOfSavedMessages", + "DB", + "Max number of error messages in error log and max number of trace files", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 25, + 0, + 0x7FFFFFFF}, + + {"LockPagesInMainMemory", + "LockPagesInMainMemory", + "DB", + "If set to yes, then NDB Cluster data will not be swapped out to disk", + ConfigInfo::USED, + true, + ConfigInfo::BOOL, + false, + 0, + 0x7FFFFFFF}, + + {"SleepWhenIdle", + "SleepWhenIdle", + "DB", + "?", + ConfigInfo::DEPRICATED, + true, + ConfigInfo::BOOL, + true, + 0, + 0x7FFFFFFF}, + + {"NoOfSignalsToExecuteBetweenCommunicationInterfacePoll", + "NoOfSignalsToExecuteBetweenCommunicationInterfacePoll", + "DB", + "?", + ConfigInfo::DEPRICATED, + true, + ConfigInfo::INT, + 20, + 1, + 0x7FFFFFFF}, + + {"TimeBetweenWatchDogCheck", + "TimeBetweenWatchDogCheck", + "DB", + "Time between execution checks inside a database node", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 4000, + 70, + 0x7FFFFFFF}, + + {"StopOnError", + "StopOnError", + "DB", + "If set to N, the DB automatically restarts/recovers in case of node failure", + ConfigInfo::USED, + true, + ConfigInfo::BOOL, + true, + 0, + 0x7FFFFFFF}, + + { "RestartOnErrorInsert", + "RestartOnErrorInsert", + "DB", + "See src/kernel/vm/Emulator.hpp NdbRestartType for details", + ConfigInfo::INTERNAL, + true, + ConfigInfo::INT, + 2, + 0, + 4 }, + + {"MaxNoOfConcurrentOperations", + "MaxNoOfConcurrentOperations", + "DB", + "Max no of op:s on DB (op:s within a transaction are concurrently executed)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 8192, + 32, + 1000000}, + + {"MaxNoOfConcurrentTransactions", + "MaxNoOfConcurrentTransactions", + "DB", + "Max number of transaction executing concurrently on the DB node", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 4096, + 32, + 1000000}, + + {"MaxNoOfConcurrentScans", + "MaxNoOfConcurrentScans", + "DB", + "Max number of scans executing concurrently on the DB node", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 25, + 2, + 500}, + + {"TransactionBufferMemory", + "TransactionBufferMemory", + "DB", + "Dynamic buffer space (in bytes) for key and attribute data allocated for each DB node", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 1024000, + 1024, + 0x7FFFFFFF}, + + {"NoOfIndexPages", + "NoOfIndexPages", + "DB", + "Number of 8k byte pages on each DB node for storing indexes", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 3000, + 128, + 192000}, + + {"MemorySpaceIndexes", + "NoOfIndexPages", + "DB", + "Depricated", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::INT, + UNDEFINED, + 128, + 192000}, + + {"NoOfDataPages", + "NoOfDataPages", + "DB", + "Number of 8k byte pages on each DB node for storing data", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 10000, + 128, + 400000}, + + {"MemorySpaceTuples", + "NoOfDataPages", + "DB", + "Depricated", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::INT, + UNDEFINED, + 128, + 400000}, + + {"NoOfDiskBufferPages", + "NoOfDiskBufferPages", + "DB", + "?", + ConfigInfo::NOTIMPLEMENTED, + false, + ConfigInfo::INT, + 0, + 0, + 0}, + + {"MemoryDiskPages", + "NoOfDiskBufferPages", + "DB", + "?", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::INT, + UNDEFINED, + 0, + 0}, + + {"NoOfFreeDiskClusters", + "NoOfFreeDiskClusters", + "DB", + "?", + ConfigInfo::NOTIMPLEMENTED, + false, + ConfigInfo::INT, + 0, + 0, + 0}, + + {"NoOfDiskClusters", + "NoOfDiskClusters", + "DB", + "?", + ConfigInfo::NOTIMPLEMENTED, + false, + ConfigInfo::INT, + 0, + 0, + 0x7FFFFFFF}, + + {"TimeToWaitAlive", + "TimeToWaitAlive", + "DB", + "Time to wait for other nodes to become alive during initial system start", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 25, + 2, + 4000}, + + {"HeartbeatIntervalDbDb", + "HeartbeatIntervalDbDb", + "DB", + "Time between DB-to-DB heartbeats. DB considered dead after 3 missed HBs", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 1500, + 10, + 0x7FFFFFFF}, + + {"HeartbeatIntervalDbApi", + "HeartbeatIntervalDbApi", + "DB", + "Time between API-to-DB heartbeats. API connection closed after 3 missed HBs", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 1500, + 100, + 0x7FFFFFFF}, + + {"TimeBetweenLocalCheckpoints", + "TimeBetweenLocalCheckpoints", + "DB", + "Time between taking snapshots of the database (expressed in 2log of bytes)", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 20, + 0, + 31}, + + {"TimeBetweenGlobalCheckpoints", + "TimeBetweenGlobalCheckpoints", + "DB", + "Time between doing group commit of transactions to disk", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 2000, + 10, + 32000}, + + {"NoOfFragmentLogFiles", + "NoOfFragmentLogFiles", + "DB", + "No of 16 Mbyte Redo log files in each of 4 file sets belonging to DB node", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 8, + 1, + 0x7FFFFFFF}, + + {"MaxNoOfOpenFiles", + "MaxNoOfOpenFiles", + "DB", + "Max number of files open per DB node.(One thread is created per file)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 40, + 20, + 256}, + + {"NoOfConcurrentCheckpointsDuringRestart", + "NoOfConcurrentCheckpointsDuringRestart", + "DB", + "?", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 1, + 1, + 4}, + + {"TimeBetweenInactiveTransactionAbortCheck", + "TimeBetweenInactiveTransactionAbortCheck", + "DB", + "Time between inactive transaction checks", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 1000, + 1000, + 0x7FFFFFFF}, + + {"TransactionInactiveTimeout", + "TransactionInactiveTimeout", + "DB", + "Time application can wait before executing another transaction part (ms).\n" + "This is the time the transaction coordinator waits for the application\n" + "to execute or send another part (query, statement) of the transaction.\n" + "If the application takes too long time, the transaction gets aborted.\n" + "Timeout set to 0 means that we don't timeout at all on application wait.", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 3000, + 0, + 0x7FFFFFFF}, + + {"TransactionDeadlockDetectionTimeout", + "TransactionDeadlockDetectionTimeout", + "DB", + "Time transaction can be executing in a DB node (ms).\n" + "This is the time the transaction coordinator waits for each database node\n" + "of the transaction to execute a request. If the database node takes too\n" + "long time, the transaction gets aborted.", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 3000, + 50, + 0x7FFFFFFF}, + + {"TransactionInactiveTimeBeforeAbort", + "TransactionInactiveTimeBeforeAbort", + "DB", + "Time a transaction can be inactive before getting aborted (ms)", + ConfigInfo::DEPRICATED, + true, + ConfigInfo::INT, + 3000, + 20, + 0x7FFFFFFF}, + + {"NoOfConcurrentProcessesHandleTakeover", + "NoOfConcurrentProcessesHandleTakeover", + "DB", + "?", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 1, + 1, + 15}, + + {"NoOfConcurrentCheckpointsAfterRestart", + "NoOfConcurrentCheckpointsAfterRestart", + "DB", + "?", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 1, + 1, + 4}, + + {"NoOfDiskPagesToDiskDuringRestartTUP", + "NoOfDiskPagesToDiskDuringRestartTUP", + "DB", + "?", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 50, + 1, + 0x7FFFFFFF}, + + {"NoOfDiskPagesToDiskAfterRestartTUP", + "NoOfDiskPagesToDiskAfterRestartTUP", + "DB", + "?", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 10, + 1, + 0x7FFFFFFF}, + + {"NoOfDiskPagesToDiskDuringRestartACC", + "NoOfDiskPagesToDiskDuringRestartACC", + "DB", + "?", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 25, + 1, + 0x7FFFFFFF}, + + {"NoOfDiskPagesToDiskAfterRestartACC", + "NoOfDiskPagesToDiskAfterRestartACC", + "DB", + "?", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 5, + 1, + 0x7FFFFFFF}, + + {"NoOfDiskClustersPerDiskFile", + "NoOfDiskClustersPerDiskFile", + "DB", + "?", + ConfigInfo::NOTIMPLEMENTED, + false, + ConfigInfo::INT, + 0, + 0, + 0x7FFFFFFF}, + + {"NoOfDiskFiles", + "NoOfDiskFiles", + "DB", + "?", + ConfigInfo::NOTIMPLEMENTED, + false, + ConfigInfo::INT, + 0, + 0, + 0x7FFFFFFF}, + + {"ArbitrationTimeout", + "ArbitrationTimeout", + "DB", + "Max time (milliseconds) database partion waits for arbitration signal", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 1000, + 10, + 0x7FFFFFFF}, + + {"FileSystemPath", + "FileSystemPath", + "DB", + "Path to directory where the DB node stores its data (directory must exist)", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"LogLevelStartup", + "LogLevelStartup", + "DB", + "Node startup info printed on stdout", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 1, + 0, + 15}, + + {"LogLevelShutdown", + "LogLevelShutdown", + "DB", + "Node shutdown info printed on stdout", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 0, + 0, + 15}, + + {"LogLevelStatistic", + "LogLevelStatistic", + "DB", + "Transaction, operation, transporter info printed on stdout", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 0, + 0, + 15}, + + {"LogLevelCheckpoint", + "LogLevelCheckpoint", + "DB", + "Local and Global checkpoint info printed on stdout", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 0, + 0, + 15}, + + {"LogLevelNodeRestart", + "LogLevelNodeRestart", + "DB", + "Node restart, node failure info printed on stdout", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 0, + 0, + 15}, + + {"LogLevelConnection", + "LogLevelConnection", + "DB", + "Node connect/disconnect info printed on stdout", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 0, + 0, + 15}, + + {"LogLevelError", + "LogLevelError", + "DB", + "Transporter, heartbeat errors printed on stdout", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 0, + 0, + 15}, + + {"LogLevelInfo", + "LogLevelInfo", + "DB", + "Heartbeat and log info printed on stdout", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 0, + 0, + 15}, + + /** + * Backup + */ + { "ParallelBackups", + "ParallelBackups", + "DB", + "Maximum number of parallel backups", + ConfigInfo::NOTIMPLEMENTED, + false, + ConfigInfo::INT, + 1, + 1, + 1 }, + + { "BackupMemory", + "BackupMemory", + "DB", + "Total memory allocated for backups per node (in bytes)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + (2 * 1024 * 1024) + (2 * 1024 * 1024), // sum of BackupDataBufferSize and BackupLogBufferSize + 0, + 0x7FFFFFFF }, + + { "BackupDataBufferSize", + "BackupDataBufferSize", + "DB", + "Default size of databuffer for a backup (in bytes)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + (2 * 1024 * 1024), // remember to change BackupMemory + 0, + 0x7FFFFFFF }, + + { "BackupLogBufferSize", + "BackupLogBufferSize", + "DB", + "Default size of logbuffer for a backup (in bytes)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + (2 * 1024 * 1024), // remember to change BackupMemory + 0, + 0x7FFFFFFF }, + + { "BackupWriteSize", + "BackupWriteSize", + "DB", + "Default size of filesystem writes made by backup (in bytes)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 32768, + 0, + 0x7FFFFFFF }, + + /**************************************************************************** + * REP + ****************************************************************************/ + + {"Id", + "Id", + "REP", + "Number identifying replication node (REP)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + MANDATORY, + 1, + (MAX_NODES - 1)}, + + {"Type", + "Type", + "REP", + "Type of node (Should have value REP)", + ConfigInfo::INTERNAL, + false, + ConfigInfo::STRING, + 0, + 0, + 0}, + + {"ExecuteOnComputer", + "ExecuteOnComputer", + "REP", + "String referencing an earlier defined COMPUTER", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + MANDATORY, + 0, + 0x7FFFFFFF}, + + /**************************************************************************** + * EXTERNAL REP + ****************************************************************************/ + + {"Id", + "Id", + "EXTERNAL REP", + "Number identifying external (i.e. in another NDB Cluster) replication node (REP)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + MANDATORY, + 1, + (MAX_NODES - 1)}, + + {"Type", + "Type", + "EXTERNAL REP", + "Type of node (Should have value REP)", + ConfigInfo::INTERNAL, + false, + ConfigInfo::STRING, + 0, + 0, + 0}, + + {"System", + "System", + "EXTERNAL REP", + "System name of system hosting node", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + 0, + 0, + 0}, + + {"HeartbeatIntervalRepRep", + "HeartbeatIntervalRepRep", + "EXTERNAL REP", + "Time between REP-REP heartbeats. Connection closed after 3 missed HBs", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 3000, + 100, + 0x7FFFFFFF}, + + /**************************************************************************** + * API + ****************************************************************************/ + + {"Id", + "Id", + "API", + "Number identifying application node (API)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + MANDATORY, + 1, + (MAX_NODES - 1)}, + + {"Type", + "Type", + "API", + "Type of node (Should have value API)", + ConfigInfo::INTERNAL, + false, + ConfigInfo::STRING, + 0, + 0, + 0}, + + {"ExecuteOnComputer", + "ExecuteOnComputer", + "API", + "String referencing an earlier defined COMPUTER", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + MANDATORY, + 0, + 0x7FFFFFFF}, + + {"MaxNoOfSavedMessages", + "MaxNoOfSavedMessages", + "API", + "Max number of error messages in error log and max number of trace files", + ConfigInfo::USED, + true, + ConfigInfo::INT, + 25, + 0, + 0x7FFFFFFF}, + + {"SleepWhenIdle", + "SleepWhenIdle", + "API", + "?", + ConfigInfo::DEPRICATED, + true, + ConfigInfo::BOOL, + true, + 0, + 0x7FFFFFFF}, + + {"ArbitrationRank", + "ArbitrationRank", + "API", + "If 0, then API is not arbitrator. Kernel selects arbitrators in order 1, 2", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 2, + 0, + 2}, + + {"ArbitrationDelay", + "ArbitrationDelay", + "API", + "When asked to arbitrate, arbitrator waits this long before voting (msec)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 0, + 0, + 0x7FFFFFFF}, + + /**************************************************************************** + * MGM + ****************************************************************************/ + + {"Id", + "Id", + "MGM", + "Number identifying the management server node (MGM)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + MANDATORY, + 1, + (MAX_NODES - 1)}, + + {"Type", + "Type", + "MGM", + "Type of node (Should have value MGM)", + ConfigInfo::INTERNAL, + false, + ConfigInfo::STRING, + 0, + 0, + 0}, + + {"ExecuteOnComputer", + "ExecuteOnComputer", + "MGM", + "String referencing an earlier defined COMPUTER", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + MANDATORY, + 0, + 0x7FFFFFFF}, + + // SHOULD THIS REALLY BE DEFINABLE FOR MGM ??? + {"MaxNoOfSavedMessages", + "MaxNoOfSavedMessages", + "MGM", + "Max number of error messages in error log and max number of trace files", + ConfigInfo::DEPRICATED, + true, + ConfigInfo::INT, + 25, + 0, + 0x7FFFFFFF}, + + {"MaxNoOfSavedEvents", + "MaxNoOfSavedEvents", + "MGM", + "", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 100, + 0, + 0x7FFFFFFF}, + + {"PortNumber", + "PortNumber", + "MGM", + "Port number to give commands to/fetch configurations from management server", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 2200, + 0, + 0x7FFFFFFF}, + + {"PortNumberStats", + "PortNumberStats", + "MGM", + "Port number used to get statistical information from a management server", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 2199, + 0, + 0x7FFFFFFF}, + + {"ArbitrationRank", + "ArbitrationRank", + "MGM", + "If 0, then MGM is not arbitrator. Kernel selects arbitrators in order 1, 2", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 2, + 0, + 2}, + + {"ArbitrationDelay", + "ArbitrationDelay", + "MGM", + "", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 0, + 0, + 0x7FFFFFFF}, + + /***************************************************************************** + * SYSTEM + ****************************************************************************/ + + {"Name", + "Name", + "SYSTEM", + "Name of system (NDB Cluster)", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + MANDATORY, + 0, + 0}, + + {"ReplicationRole", + "ReplicationRole", + "SYSTEM", + "Role in Global Replication (None, Primary, or Standby)", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + UNDEFINED, + 0, + 0}, + + {"LogDestination", + "LogDestination", + "MGM", + "String describing where logmessages are sent", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + 0, + 0, + 0x7FFFFFFF}, + + {"PrimaryMGMNode", + "PrimaryMGMNode", + "SYSTEM", + "Node id of Primary MGM node", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 0, + 0, + 0x7FFFFFFF}, + + {"ConfigGenerationNumber", + "ConfigGenerationNumber", + "SYSTEM", + "Configuration generation number", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 0, + 0, + 0x7FFFFFFF}, + + {"Name", + "Name", + "EXTERNAL SYSTEM", + "Name of external system (another NDB Cluster)", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + MANDATORY, + 0, + 0}, + + /***************************************************************************** + * TCP + ****************************************************************************/ + + {"Type", + "Type", + "TCP", + "", + ConfigInfo::INTERNAL, + false, + ConfigInfo::STRING, + 0, + 0, + 0x7FFFFFFF}, + + {"HostName1", + "HostName1", + "TCP", + "Name of computer on one side of the connection", + ConfigInfo::INTERNAL, + false, + ConfigInfo::STRING, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"HostName2", + "HostName2", + "TCP", + "Name of computer on one side of the connection", + ConfigInfo::INTERNAL, + false, + ConfigInfo::STRING, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"NodeId1", + "NodeId1", + "TCP", + "Id of node (DB, API or MGM) on one side of the connection", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + MANDATORY, + 0, + 0x7FFFFFFF}, + + {"ProcessId1", + "NodeId1", + "TCP", + "Depricated", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::INT, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"NodeId2", + "NodeId2", + "TCP", + "Id of node (DB, API or MGM) on one side of the connection", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + MANDATORY, + 0, + 0x7FFFFFFF}, + + {"ProcessId2", + "NodeId2", + "TCP", + "Depricated", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::INT, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"IpAddress1", + "HostName1", + "TCP", + "IP address of first node in connection.", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"IpAddress2", + "HostName2", + "TCP", + "IP address of second node in connection.", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + UNDEFINED, + 0, + 0}, + + {"SendSignalId", + "SendSignalId", + "TCP", + "Sends id in each signal. Used in trace files.", + ConfigInfo::USED, + false, + ConfigInfo::BOOL, + true, + 0, + 0x7FFFFFFF}, + + {"Compression", + "Compression", + "TCP", + "If compression is enabled, then all signals between nodes are compressed", + ConfigInfo::USED, + false, + ConfigInfo::BOOL, + false, + 0, + 0x7FFFFFFF}, + + {"Checksum", + "Checksum", + "TCP", + "If checksum is enabled, all signals between nodes are checked for errors", + ConfigInfo::USED, + false, + ConfigInfo::BOOL, + false, + 0, + 0x7FFFFFFF}, + + {"PortNumber", + "PortNumber", + "TCP", + "Port used for this transporter", + ConfigInfo::USED, + false, + ConfigInfo::INT, + MANDATORY, + 0, + 0x7FFFFFFF}, + + {"SendBufferSize", + "SendBufferSize", + "TCP", + "Size of buffer for signals sent from this node (in no of signals)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 16, + 1, + 0x7FFFFFFF}, + + {"MaxReceiveSize", + "MaxReceiveSize", + "TCP", + "Size of buffer for signals received by this node (in no of signals)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 4, + 1, + 0x7FFFFFFF}, + + {"Proxy", + "Proxy", + "TCP", + "", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + UNDEFINED, + 0, + 0}, + + /***************************************************************************** + * SHM + ****************************************************************************/ + + {"Type", + "Type", + "SHM", + "", + ConfigInfo::INTERNAL, + false, + ConfigInfo::STRING, + 0, + 0, + 0x7FFFFFFF}, + + {"NodeId1", + "NodeId1", + "SHM", + "Id of node (DB, API or MGM) on one side of the connection", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + MANDATORY, + 0, + 0x7FFFFFFF}, + + {"ProcessId1", + "NodeId1", + "SHM", + "Depricated", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::STRING, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"NodeId2", + "NodeId2", + "SHM", + "Id of node (DB, API or MGM) on one side of the connection", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + MANDATORY, + 0, + 0x7FFFFFFF}, + + {"ProcessId2", + "NodeId2", + "SHM", + "Depricated", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::STRING, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"SendSignalId", + "SendSignalId", + "SHM", + "Sends id in each signal. Used in trace files.", + ConfigInfo::USED, + false, + ConfigInfo::BOOL, + false, + 0, + 0x7FFFFFFF}, + + {"Compression", + "Compression", + "SHM", + "If compression is enabled, then all signals between nodes are compressed", + ConfigInfo::USED, + false, + ConfigInfo::BOOL, + false, + 0, + 0x7FFFFFFF}, + + {"Checksum", + "Checksum", + "SHM", + "If checksum is enabled, all signals between nodes are checked for errors", + ConfigInfo::USED, + false, + ConfigInfo::BOOL, + true, + 0, + 0x7FFFFFFF}, + + {"ShmKey", + "ShmKey", + "SHM", + "A shared memory key", + ConfigInfo::USED, + false, + ConfigInfo::INT, + MANDATORY, + 0, + 0x7FFFFFFF }, + + {"ShmSize", + "ShmSize", + "SHM", + "Size of shared memory segment", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 1048576, + 4096, + 0x7FFFFFFF}, + + /***************************************************************************** + * SCI + ****************************************************************************/ + + {"NodeId1", + "NodeId1", + "SCI", + "Id of node (DB, API or MGM) on one side of the connection", + ConfigInfo::USED, + false, + ConfigInfo::INT, + MANDATORY, + 0, + 0x7FFFFFFF}, + + {"ProcessId1", + "NodeId1", + "SCI", + "Depricated", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::INT, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"NodeId2", + "NodeId2", + "SCI", + "Id of node (DB, API or MGM) on one side of the connection", + ConfigInfo::USED, + false, + ConfigInfo::INT, + MANDATORY, + 0, + 0x7FFFFFFF}, + + {"ProcessId2", + "NodeId2", + "SCI", + "Depricated", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::INT, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"SciId0", + "SciId0", + "SCI", + "Local SCI-node id for adapter 0 (a computer can have two adapters)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + MANDATORY, + 0, + 0x7FFFFFFF}, + + {"SciId1", + "SciId1", + "SCI", + "Local SCI-node id for adapter 1 (a computer can have two adapters)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + MANDATORY, + 0, + 0x7FFFFFFF}, + + {"SendSignalId", + "SendSignalId", + "SCI", + "Sends id in each signal. Used in trace files.", + ConfigInfo::USED, + false, + ConfigInfo::BOOL, + true, + 0, + 0x7FFFFFFF}, + + {"Compression", + "Compression", + "SCI", + "If compression is enabled, then all signals between nodes are compressed", + ConfigInfo::USED, + false, + ConfigInfo::BOOL, + false, + 0, + 0x7FFFFFFF}, + + {"Checksum", + "Checksum", + "SCI", + "If checksum is enabled, all signals between nodes are checked for errors", + ConfigInfo::USED, + false, + ConfigInfo::BOOL, + false, + 0, + 0x7FFFFFFF}, + + {"SendLimit", + "SendLimit", + "SCI", + "Transporter send buffer contents are sent when this no of bytes is buffered", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 2048, + 512, + 0x7FFFFFFF}, + + {"SharedBufferSize", + "SharedBufferSize", + "SCI", + "Size of shared memory segment", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 1048576, + 262144, + 0x7FFFFFFF}, + + {"Node1_NoOfAdapters", + "Node1_NoOfAdapters", + "SCI", + "", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::INT, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"Node2_NoOfAdapters", + "Node2_NoOfAdapters", + "SCI", + "", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::INT, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"Node1_Adapter", + "Node1_Adapter", + "SCI", + "", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::INT, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"Node2_Adapter", + "Node2_Adapter", + "SCI", + "", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::INT, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + /***************************************************************************** + * OSE + ****************************************************************************/ + + {"Type", + "Type", + "OSE", + "", + ConfigInfo::INTERNAL, + false, + ConfigInfo::STRING, + 0, + 0, + 0x7FFFFFFF}, + + {"HostName1", + "HostName1", + "OSE", + "Name of computer on one side of the connection", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"HostName2", + "HostName2", + "OSE", + "Name of computer on one side of the connection", + ConfigInfo::USED, + false, + ConfigInfo::STRING, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"NodeId1", + "NodeId1", + "OSE", + "Id of node (DB, API or MGM) on one side of the connection", + ConfigInfo::USED, + false, + ConfigInfo::INT, + MANDATORY, + 0, + 0x7FFFFFFF}, + + {"ProcessId1", + "NodeId1", + "OSE", + "Depricated", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::INT, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"NodeId2", + "NodeId2", + "OSE", + "Id of node (DB, API or MGM) on one side of the connection", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::INT, + UNDEFINED, + 0, + 0x7FFFFFFF}, + + {"ProcessId2", + "NodeId2", + "OSE", + "Depricated", + ConfigInfo::USED, + false, + ConfigInfo::INT, + MANDATORY, + 0, + 0x7FFFFFFF}, + + {"SendSignalId", + "SendSignalId", + "OSE", + "Sends id in each signal. Used in trace files.", + ConfigInfo::USED, + false, + ConfigInfo::BOOL, + true, + 0, + 0x7FFFFFFF}, + + {"Compression", + "Compression", + "OSE", + "If compression is enabled, then all signals between nodes are compressed", + ConfigInfo::USED, + false, + ConfigInfo::BOOL, + false, + 0, + 0x7FFFFFFF}, + + {"Checksum", + "Checksum", + "OSE", + "If checksum is enabled, all signals between nodes are checked for errors", + ConfigInfo::USED, + false, + ConfigInfo::BOOL, + false, + 0, + 0x7FFFFFFF}, + + // Should not be part of OSE ? + {"SharedBufferSize", + "SharedBufferSize", + "OSE", + "?", + ConfigInfo::DEPRICATED, + false, + ConfigInfo::INT, + UNDEFINED, + 2000, + 0x7FFFFFFF}, + + {"PrioASignalSize", + "PrioASignalSize", + "OSE", + "Size of priority A signals (in bytes)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 1000, + 0, + 0x7FFFFFFF}, + + {"PrioBSignalSize", + "PrioBSignalSize", + "OSE", + "Size of priority B signals (in bytes)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 1000, + 0, + 0x7FFFFFFF}, + + {"ReceiveArraySize", + "ReceiveArraySize", + "OSE", + "Number of OSE signals checked for correct ordering (in no of OSE signals)", + ConfigInfo::USED, + false, + ConfigInfo::INT, + 10, + 0, + 0x7FFFFFFF} +}; + +const int ConfigInfo::m_NoOfParams = sizeof(m_ParamInfo) / sizeof(ParamInfo); + + +/**************************************************************************** + * Ctor + ****************************************************************************/ +inline void require(bool v) { if(!v) abort();} + +ConfigInfo::ConfigInfo() { + Properties *section; + const Properties *oldpinfo; + + m_info.setCaseInsensitiveNames(true); + m_systemDefaults.setCaseInsensitiveNames(true); + + for (int i=0; iget(param._fname, &oldpinfo)) { + ndbout << "Error: Parameter " << param._fname + << " defined twice in section " << param._section + << "." << endl; + exit(-1); + } + + // Add new pinfo to section + section->put(param._fname, &pinfo); + + // Replace section with modified section + m_info.put(param._section, section, true); + + { + Properties * p; + if(!m_systemDefaults.getCopy(param._section, &p)){ + p = new Properties(); + p->setCaseInsensitiveNames(true); + } + if(param._type != STRING && + param._default != UNDEFINED && + param._default != MANDATORY){ + require(p->put(param._pname, param._default)); + } + require(m_systemDefaults.put(param._section, p, true)); + delete p; + } + } + + for (int i=0; icontains(m_ParamInfo[i]._pname)) { + ndbout << "Check that each pname has an fname failed." << endl; + ndbout << "Parameter \"" << m_ParamInfo[i]._pname + << "\" does not exist in section \"" + << m_ParamInfo[i]._section << "\"." << endl; + ndbout << "Edit file " << __FILE__ << "." << endl; + exit(-1); + } + } +} + +/**************************************************************************** + * Getters + ****************************************************************************/ +inline void warning(const char * src, const char * arg){ + ndbout << "Illegal call to ConfigInfo::" << src << "() - " << arg << endl; + abort(); +} + +const Properties * +ConfigInfo::getInfo(const char * section) const { + const Properties * p; + if(!m_info.get(section, &p)){ + warning("getInfo", section); + } + return p; +} + +const Properties * +ConfigInfo::getDefaults(const char * section) const { + const Properties * p; + if(!m_systemDefaults.get(section, &p)){ + warning("getDefaults", section); + } + return p; +} + +static +Uint32 +getInfoInt(const Properties * section, + const char* fname, const char * type){ + Uint32 val; + const Properties * p; + if (section->get(fname, &p) && p->get(type, &val)) { + return val; + } + warning(type, fname); + return val; +} + +static +const char * +getInfoString(const Properties * section, + const char* fname, const char * type){ + const char* val; + const Properties * p; + if (section->get(fname, &p) && p->get(type, &val)) { + return val; + } + warning(type, fname); + return val; +} + +Uint32 +ConfigInfo::getMax(const Properties * section, const char* fname) const { + return getInfoInt(section, fname, "Max"); +} + +Uint32 +ConfigInfo::getMin(const Properties * section, const char* fname) const { + return getInfoInt(section, fname, "Min"); +} + +Uint32 +ConfigInfo::getDefault(const Properties * section, const char* fname) const { + return getInfoInt(section, fname, "Default"); +} + +const char* +ConfigInfo::getPName(const Properties * section, const char* fname) const { + return getInfoString(section, fname, "Pname"); +} + +const char* +ConfigInfo::getDescription(const Properties * section, + const char* fname) const { + return getInfoString(section, fname, "Description"); +} + +bool +ConfigInfo::isSection(const char * section) const { + for (int i = 0; i max){ + warning("verify", fname); + } + if (value >= min && value <= max) + return true; + else + return false; +} + +ConfigInfo::Type +ConfigInfo::getType(const Properties * section, const char* fname) const { + return (ConfigInfo::Type) getInfoInt(section, fname, "Type"); +} + +ConfigInfo::Status +ConfigInfo::getStatus(const Properties * section, const char* fname) const { + return (ConfigInfo::Status) getInfoInt(section, fname, "Status"); +} + +/**************************************************************************** + * Printers + ****************************************************************************/ + +void ConfigInfo::print() const { + Properties::Iterator it(&m_info); + for (const char* n = it.first(); n != NULL; n = it.next()) { + print(n); + } +} + +void ConfigInfo::print(const char* section) const { + ndbout << "****** " << section << " ******" << endl << endl; + const Properties * sec = getInfo(section); + Properties::Iterator it(sec); + for (const char* n = it.first(); n != NULL; n = it.next()) { + // Skip entries with different F- and P-names + if (strcmp(n, getPName(sec, n))) continue; + if (getStatus(sec, n) == ConfigInfo::INTERNAL) continue; + if (getStatus(sec, n) == ConfigInfo::DEPRICATED) continue; + if (getStatus(sec, n) == ConfigInfo::NOTIMPLEMENTED) continue; + print(sec, n); + } +} + +void ConfigInfo::print(const Properties * section, + const char* parameter) const { + ndbout << getPName(section, parameter); + // ndbout << getDescription(section, parameter) << endl; + switch (getType(section, parameter)) { + case ConfigInfo::BOOL: + ndbout << " (Boolean value)" << endl; + ndbout << getDescription(section, parameter) << endl; + if (getDefault(section, parameter) == false) { + ndbout << "Default: N (Legal values: Y, N)" << endl; + } else if (getDefault(section, parameter) == true) { + ndbout << "Default: Y (Legal values: Y, N)" << endl; + } else if (getDefault(section, parameter) == MANDATORY) { + ndbout << "MANDATORY (Legal values: Y, N)" << endl; + } else { + ndbout << "UNKNOWN" << endl; + } + ndbout << endl; + break; + + case ConfigInfo::INT: + ndbout << " (Non-negative Integer)" << endl; + ndbout << getDescription(section, parameter) << endl; + if (getDefault(section, parameter) == MANDATORY) { + ndbout << "MANDATORY ("; + } else if (getDefault(section, parameter) == UNDEFINED) { + ndbout << "UNDEFINED ("; + } else { + ndbout << "Default: " << getDefault(section, parameter) << " ("; + } + ndbout << "Min: " << getMin(section, parameter) << ", "; + ndbout << "Max: " << getMax(section, parameter) << ")" << endl; + ndbout << endl; + break; + + case ConfigInfo::STRING: + ndbout << " (String)" << endl; + ndbout << getDescription(section, parameter) << endl; + if (getDefault(section, parameter) == MANDATORY) { + ndbout << "MANDATORY" << endl; + } else { + ndbout << "No default value" << endl; + } + ndbout << endl; + break; + } +} + +/**************************************************************************** + * Section Rules + ****************************************************************************/ + +/** + * Node rule: Add "Type" and update "NoOfNodes" + */ +bool +transformNode(InitConfigFileParser::Context & ctx, const char * data){ + + Uint32 id; + if(!ctx.m_currentSection->get("Id", &id)){ + ctx.reportError("Mandatory parameter Id missing from section " + "[%s] starting at line: %d", + ctx.fname, ctx.m_sectionLineno); + return false; + } + snprintf(ctx.pname, sizeof(ctx.pname), "Node_%d", id); + + ctx.m_currentSection->put("Type", ctx.fname); + + Uint32 nodes = 0; + ctx.m_userProperties.get("NoOfNodes", &nodes); + ctx.m_userProperties.put("NoOfNodes", ++nodes, true); + + return true; +} + +bool +transformExtNode(InitConfigFileParser::Context & ctx, const char * data){ + + Uint32 id; + const char * systemName; + + if(!ctx.m_currentSection->get("Id", &id)){ + ctx.reportError("Mandatory parameter 'Id' missing from section " + "[%s] starting at line: %d", + ctx.fname, ctx.m_sectionLineno); + return false; + } + + if(!ctx.m_currentSection->get("System", &systemName)){ + ctx.reportError("Mandatory parameter 'System' missing from section " + "[%s] starting at line: %d", + ctx.fname, ctx.m_sectionLineno); + return false; + } + + ctx.m_currentSection->put("Type", ctx.fname); + + Uint32 nodes = 0; + ctx.m_userProperties.get("ExtNoOfNodes", &nodes); + require(ctx.m_userProperties.put("ExtNoOfNodes",++nodes, true)); + + snprintf(ctx.pname, sizeof(ctx.pname), "EXTERNAL SYSTEM_%s:Node_%d", + systemName, id); + + return true; +} + +/** + * Connection rule: Update "NoOfConnections" + */ +bool +transformConnection(InitConfigFileParser::Context & ctx, const char * data){ + + Uint32 connections = 0; + ctx.m_userProperties.get("NoOfConnections", &connections); + snprintf(ctx.pname, sizeof(ctx.pname), "Connection_%d", connections); + ctx.m_userProperties.put("NoOfConnections", ++connections, true); + + ctx.m_currentSection->put("Type", ctx.fname); + return true; +} + +/** + * System rule: Just add it + */ +bool +transformSystem(InitConfigFileParser::Context & ctx, const char * data){ + + const char * name; + if(!ctx.m_currentSection->get("Name", &name)){ + ctx.reportError("Mandatory parameter Name missing from section " + "[%s] starting at line: %d", + ctx.fname, ctx.m_sectionLineno); + return false; + } + snprintf(ctx.pname, sizeof(ctx.pname), "SYSTEM_%s", name); + + return true; +} + +/** + * External system rule: Just add it + */ +bool +transformExternalSystem(InitConfigFileParser::Context & ctx, const char * data){ + const char * name; + if(!ctx.m_currentSection->get("Name", &name)){ + ctx.reportError("Mandatory parameter Name missing from section " + "[%s] starting at line: %d", + ctx.fname, ctx.m_sectionLineno); + return false; + } + snprintf(ctx.pname, sizeof(ctx.pname), "EXTERNAL SYSTEM_%s", name); + + return true; +} + +/** + * Computer rule: Update "NoOfComputers", add "Type" + */ +bool +transformComputer(InitConfigFileParser::Context & ctx, const char * data){ + const char * id; + if(!ctx.m_currentSection->get("Id", &id)){ + ctx.reportError("Mandatory parameter Id missing from section " + "[%s] starting at line: %d", + ctx.fname, ctx.m_sectionLineno); + return false; + } + snprintf(ctx.pname, sizeof(ctx.pname), "Computer_%s", id); + + Uint32 computers = 0; + ctx.m_userProperties.get("NoOfComputers", &computers); + ctx.m_userProperties.put("NoOfComputers", ++computers, true); + + return true; +} + +/** + * Apply default values + */ +void +applyDefaultValues(InitConfigFileParser::Context & ctx, + const Properties * defaults){ + if(defaults != NULL){ + Properties::Iterator it(defaults); + + for(const char * name = it.first(); name != NULL; name = it.next()){ + if(!ctx.m_currentSection->contains(name)){ + switch (ctx.m_info->getType(ctx.m_currentInfo, name)){ + case ConfigInfo::INT: + case ConfigInfo::BOOL:{ + Uint32 val = 0; + ::require(defaults->get(name, &val)); + ctx.m_currentSection->put(name, val); + break; + } + case ConfigInfo::STRING:{ + const char * val; + ::require(defaults->get(name, &val)); + ctx.m_currentSection->put(name, val); + break; + } + } + } + } + } +} + +bool +applyDefaultValues(InitConfigFileParser::Context & ctx, const char * data){ + + applyDefaultValues(ctx, ctx.m_userDefaults); + applyDefaultValues(ctx, ctx.m_systemDefaults); + + return true; +} + +/** + * Check that a section contains all MANDATORY parameters + */ +bool +checkMandatory(InitConfigFileParser::Context & ctx, const char * data){ + + Properties::Iterator it(ctx.m_currentInfo); + for(const char * name = it.first(); name != NULL; name = it.next()){ + const Properties * info = NULL; + ::require(ctx.m_currentInfo->get(name, &info)); + Uint32 val; + if(info->get("Default", &val) && val == MANDATORY){ + const char * pname; + const char * fname; + ::require(info->get("Pname", &pname)); + ::require(info->get("Fname", &fname)); + if(!ctx.m_currentSection->contains(pname)){ + ctx.reportError("Mandatory parameter %s missing from section " + "[%s] starting at line: %d", + fname, ctx.fname, ctx.m_sectionLineno); + return false; + } + } + } + return true; +} + +/** + * Connection rule: Fix node id + * + * Transform a string "NodeidX" (e.g. "uppsala.32") + * into a Uint32 "NodeIdX" (e.g. 32) and a string "SystemX" (e.g. "uppsala"). + */ +bool fixNodeId(InitConfigFileParser::Context & ctx, const char * data){ + + char buf[] = "NodeIdX"; buf[6] = data[sizeof("NodeI")]; + char sysbuf[] = "SystemX"; sysbuf[6] = data[sizeof("NodeI")]; + const char* nodeId; + require(ctx.m_currentSection->get(buf, &nodeId)); + + char tmpLine[MAX_LINE_LENGTH]; + strncpy(tmpLine, nodeId, MAX_LINE_LENGTH); + char* token1 = strtok(tmpLine, "."); + char* token2 = strtok(NULL, "."); + Uint32 id; + + if (token2 == NULL) { // Only a number given + errno = 0; + char* p; + id = strtol(token1, &p, 10); + if (errno != 0) warning("STRTOK1", nodeId); + require(ctx.m_currentSection->put(buf, id, true)); + } else { // A pair given (e.g. "uppsala.32") + errno = 0; + char* p; + id = strtol(token2, &p, 10); + if (errno != 0) warning("STRTOK2", nodeId); + require(ctx.m_currentSection->put(buf, id, true)); + require(ctx.m_currentSection->put(sysbuf, token1)); + } + + return true; +} + +/** + * @returns true if connection is external (one node is external) + * Also returns: + * - name of external system in parameter extSystemName, and + * - nodeId of external node in parameter extSystemNodeId. + */ +bool +isExtConnection(InitConfigFileParser::Context & ctx, + const char **extSystemName, Uint32 * extSystemNodeId){ + + Uint32 nodeId1, nodeId2; + + if (ctx.m_currentSection->contains("System1") && + ctx.m_currentSection->get("System1", extSystemName) && + ctx.m_currentSection->get("NodeId1", &nodeId1)) { + *extSystemNodeId = nodeId1; + return true; + } + + if (ctx.m_currentSection->contains("System2") && + ctx.m_currentSection->get("System2", extSystemName) && + ctx.m_currentSection->get("NodeId2", &nodeId2)) { + *extSystemNodeId = nodeId2; + return true; + } + + return false; +} + +/** + * External Connection Rule: + * If connection is to an external system, then move connection into + * external system configuration (i.e. a sub-property). + */ +bool +fixExtConnection(InitConfigFileParser::Context & ctx, const char * data){ + + const char * extSystemName; + Uint32 extSystemNodeId; + + if (isExtConnection(ctx, &extSystemName, &extSystemNodeId)) { + + Uint32 connections = 0; + ctx.m_userProperties.get("ExtNoOfConnections", &connections); + require(ctx.m_userProperties.put("ExtNoOfConnections",++connections, true)); + + char tmpLine1[MAX_LINE_LENGTH]; + snprintf(tmpLine1, MAX_LINE_LENGTH, "Connection_%d", connections-1); + + /** + * Section: EXTERNAL SYSTEM_ + */ + char extSystemPropName[MAX_LINE_LENGTH]; + strncpy(extSystemPropName, "EXTERNAL SYSTEM_", MAX_LINE_LENGTH); + strncat(extSystemPropName, extSystemName, MAX_LINE_LENGTH); + strncat(extSystemPropName, ":", MAX_LINE_LENGTH); + strncat(extSystemPropName, tmpLine1, MAX_LINE_LENGTH); + + /** + * Increase number of external connections for the system + * + * @todo Limitation: Only one external system is allowed + */ + require(ctx.m_userProperties.put("ExtSystem", extSystemName, true)); + + /** + * Make sure section is stored in right place + */ + strncpy(ctx.pname, extSystemPropName, MAX_LINE_LENGTH); + + /** + * Since this is an external connection, + * decrease number of internal connections + */ + require(ctx.m_userProperties.get("NoOfConnections", &connections)); + require(ctx.m_userProperties.put("NoOfConnections", --connections, true)); + } + + return true; +} + +/** + * Connection rule: Fix hostname + * + * Unless Hostname is not already specified, do steps: + * -# Via Connection's NodeId lookup Node + * -# Via Node's ExecuteOnComputer lookup Hostname + * -# Add HostName to Connection + */ +bool +fixHostname(InitConfigFileParser::Context & ctx, const char * data){ + + char buf[] = "NodeIdX"; buf[6] = data[sizeof("HostNam")]; + char sysbuf[] = "SystemX"; sysbuf[6] = data[sizeof("HostNam")]; + + if(!ctx.m_currentSection->contains(data)){ + Uint32 id = 0; + require(ctx.m_currentSection->get(buf, &id)); + + const Properties * node; + require(ctx.m_config->get("Node", id, &node)); + + const char * compId; + require(node->get("ExecuteOnComputer", &compId)); + + const Properties * computer; + char tmp[255]; + snprintf(tmp, sizeof(tmp), "Computer_%s", compId); + require(ctx.m_config->get(tmp, &computer)); + + const char * hostname; + require(computer->get("HostName", &hostname)); + require(ctx.m_currentSection->put(data, hostname)); + } + return true; +} + +/** + * Connection rule: Fix port number (using a port number adder) + */ +bool +fixPortNumber(InitConfigFileParser::Context & ctx, const char * data){ + + if(!ctx.m_currentSection->contains("PortNumber")){ + Uint32 adder = 0; + ctx.m_userProperties.get("PortNumberAdder", &adder); + Uint32 base = 0; + if(!ctx.m_userDefaults->get("PortNumber", &base) && + !ctx.m_systemDefaults->get("PortNumber", &base)){ + return true; + } + ctx.m_currentSection->put("PortNumber", base + adder); + adder++; + ctx.m_userProperties.put("PortNumberAdder", adder, true); + } + return true; +} + +/** + * DB Node rule: Check various constraints + */ +bool +checkDbConstraints(InitConfigFileParser::Context & ctx, const char *){ + + Uint32 t1 = 0, t2 = 0; + ctx.m_currentSection->get("MaxNoOfConcurrentOperations", &t1); + ctx.m_currentSection->get("MaxNoOfConcurrentTransactions", &t2); + + if (t1 < t2) { + ctx.reportError("MaxNoOfConcurrentOperations must be greater than " + "MaxNoOfConcurrentTransactions - [%s] starting at line: %d", + ctx.fname, ctx.m_sectionLineno); + return false; + } + + Uint32 replicas = 0, otherReplicas; + ctx.m_currentSection->get("NoOfReplicas", &replicas); + if(ctx.m_userProperties.get("NoOfReplicas", &otherReplicas)){ + if(replicas != otherReplicas){ + ctx.reportError("NoOfReplicas defined differently on different nodes" + " - [%s] starting at line: %d", + ctx.fname, ctx.m_sectionLineno); + return false; + } + } else { + ctx.m_userProperties.put("NoOfReplicas", replicas); + } + + return true; +} + +/** + * Connection rule: Check varius constraints + */ +bool +checkConnectionConstraints(InitConfigFileParser::Context & ctx, const char *){ + + Uint32 id1 = 0, id2 = 0; + ctx.m_currentSection->get("NodeId1", &id1); + ctx.m_currentSection->get("NodeId2", &id2); + + // If external connection, just accept it + if (ctx.m_currentSection->contains("System1") || + ctx.m_currentSection->contains("System2")) + return true; + + if(id1 == id2){ + ctx.reportError("Illegal connection from node to itself" + " - [%s] starting at line: %d", + ctx.fname, ctx.m_sectionLineno); + return false; + } + + const Properties * node1; + if(!ctx.m_config->get("Node", id1, &node1)){ + ctx.reportError("Connection refering to undefined node: %d" + " - [%s] starting at line: %d", + id1, ctx.fname, ctx.m_sectionLineno); + return false; + } + + const Properties * node2; + if(!ctx.m_config->get("Node", id2, &node2)){ + ctx.reportError("Connection refering to undefined node: %d" + " - [%s] starting at line: %d", + id2, ctx.fname, ctx.m_sectionLineno); + return false; + } + + const char * type1; + const char * type2; + require(node1->get("Type", &type1)); + require(node2->get("Type", &type2)); + + /** + * Report error if the following are true + * -# None of the nodes is of type DB + * -# Not both of them are MGMs + * -# None of them contain a "SystemX" name + */ + if((strcmp(type1, "DB") != 0 && strcmp(type2, "DB") != 0) && + !(strcmp(type1, "MGM") == 0 && strcmp(type2, "MGM") == 0) && + !ctx.m_currentSection->contains("System1") && + !ctx.m_currentSection->contains("System2")){ + ctx.reportError("Invalid connection between node %d (%s) and node %d (%s)" + " - [%s] starting at line: %d", + id1, type1, id2, type2, + ctx.fname, ctx.m_sectionLineno); + return false; + } + return true; +} diff --git a/ndb/src/common/mgmcommon/ConfigInfo.hpp b/ndb/src/common/mgmcommon/ConfigInfo.hpp new file mode 100644 index 00000000000..43041a3f772 --- /dev/null +++ b/ndb/src/common/mgmcommon/ConfigInfo.hpp @@ -0,0 +1,120 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ConfigInfo_H +#define ConfigInfo_H + +#include +#include +#include +#include +#include "InitConfigFileParser.hpp" + +/** + * A MANDATORY parameters must be specified in the config file + * An UNDEFINED parameter may or may not be specified in the config file + */ +static const Uint32 MANDATORY = ~0; // Default value for mandatory params. +static const Uint32 UNDEFINED = (~0)-1; // Default value for undefined params. + +/** + * @class ConfigInfo + * @brief Metainformation about ALL cluster configuration parameters + * + * Use the getters to find out metainformation about parameters. + */ +class ConfigInfo { +public: + enum Type {BOOL, INT, STRING}; + enum Status {USED, ///< Active + DEPRICATED, ///< Can be, but should not be used anymore + NOTIMPLEMENTED, ///< Can not be used currently. Is ignored. + INTERNAL ///< Not configurable by the user + }; + + /** + * Entry for one configuration parameter + */ + struct ParamInfo { + const char* _fname; + const char* _pname; + const char* _section; + const char* _description; + Status _status; + bool _updateable; + Type _type; + Uint32 _default; + Uint32 _min; + Uint32 _max; + }; + + /** + * Entry for one section rule + */ + struct SectionRule { + const char * m_section; + bool (* m_sectionRule)(struct InitConfigFileParser::Context &, + const char * m_ruleData); + const char * m_ruleData; + }; + + ConfigInfo(); + + /** + * Checks if the suggested value is valid for the suggested parameter + * (i.e. if it is >= than min and <= than max). + * + * @param section Init Config file section name + * @param fname Name of parameter + * @param value Value to check + * @return true if parameter value is valid. + * + * @note Result is not defined if section/name are wrong! + */ + bool verify(const Properties* section, const char* fname, Uint32 value) const; + bool isSection(const char*) const; + + const char* getPName(const Properties * section, const char* fname) const; + const char* getDescription(const Properties * section, const char* fname) const; + Type getType(const Properties * section, const char* fname) const; + Status getStatus(const Properties* section, const char* fname) const; + Uint32 getMin(const Properties * section, const char* fname) const; + Uint32 getMax(const Properties * section, const char* fname) const; + Uint32 getDefault(const Properties * section, const char* fname) const; + + const Properties * getInfo(const char * section) const; + const Properties * getDefaults(const char * section) const; + + void print() const; + void print(const char* section) const; + void print(const Properties * section, const char* parameter) const; + +private: + Properties m_info; + Properties m_systemDefaults; + + static const ParamInfo m_ParamInfo[]; + static const int m_NoOfParams; + + static const char* m_sectionNames[]; + static const int m_noOfSectionNames; + +public: + static const SectionRule m_SectionRules[]; + static const int m_NoOfRules; +}; + +#endif // ConfigInfo_H diff --git a/ndb/src/common/mgmcommon/ConfigRetriever.cpp b/ndb/src/common/mgmcommon/ConfigRetriever.cpp new file mode 100644 index 00000000000..a3f26454df6 --- /dev/null +++ b/ndb/src/common/mgmcommon/ConfigRetriever.cpp @@ -0,0 +1,514 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +#include "LocalConfig.hpp" +#include +#include + +#include +#include +#include +#include +#include "MgmtErrorReporter.hpp" + +#include +#include + +#include +#include +#include +#include +#include + +#include + +//**************************************************************************** +//**************************************************************************** + +ConfigRetriever::ConfigRetriever() { + + _localConfigFileName = NULL; + m_defaultConnectString = NULL; + + + errorString = 0; + _localConfig = new LocalConfig(); + m_connectString = NULL; +} + +ConfigRetriever::~ConfigRetriever(){ + if(_localConfigFileName != 0) + free(_localConfigFileName); + + if(m_defaultConnectString != 0) + free(m_defaultConnectString); + + if(m_connectString != 0) + free(m_connectString); + + if(errorString != 0) + free(errorString); + + delete _localConfig; +} + + +//**************************************************************************** +//**************************************************************************** + +int +ConfigRetriever::init(bool onlyNodeId) { + if (_localConfig->init(onlyNodeId, m_connectString, _localConfigFileName, m_defaultConnectString)) { + return _ownNodeId = (*_localConfig)._ownNodeId; + } + + setError(CR_ERROR, "error in retrieving contact info for mgmtsrvr"); + _localConfig->printError(); + _localConfig->printUsage(); + + return -1; +} + +//**************************************************************************** +//**************************************************************************** + +Properties * +ConfigRetriever::getConfig(const char * nodeType, int versionId) { + Properties * p = getConfig(versionId); + + if (p == 0) { + char err_buf[255]; + snprintf(err_buf, sizeof(err_buf), + "No configuration retrieved for this %s node ", nodeType); + setError(CR_ERROR, err_buf); + return 0; + } + + const Uint32 nodeId = _ownNodeId; + + if (strcmp(nodeType, "DB") == 0) { + if (!verifyProperties("DB", p, nodeId, versionId)) return 0; + } else if (strcmp(nodeType, "API") == 0) { + if (!verifyProperties("API", p, nodeId, versionId)) return 0; + } else if (strcmp(nodeType, "REP") == 0) { + if (!verifyProperties("REP", p, nodeId, versionId)) return 0; + } else if (strcmp(nodeType, "MGM") == 0) { + if (!verifyProperties("MGM", p, nodeId, versionId)) return 0; + } else { + return 0; + } + + return p; +} + + +//**************************************************************************** +//**************************************************************************** +Properties * +ConfigRetriever::getConfig(int verId) { + + int res = init(); + if (res == -1) { + return 0; + } + + if (_localConfig->items == 0){ + setError(CR_ERROR, "No Management Servers configured in local config file"); + return 0; + } + + int retry = 1; + int retry_max = 12; // Max number of retry attempts + int retry_interval= 5; // Seconds between each retry + do { + Uint32 type = CR_ERROR; + for (int i = 0; i<_localConfig->items; i++){ + MgmtSrvrId * m = _localConfig->ids[i]; + Properties * p = 0; + const Uint32 nodeId = _ownNodeId; + switch(m->type){ + case MgmId_TCP: + p = getConfig(m->data.tcp.remoteHost, m->data.tcp.port, nodeId, verId); + break; + case MgmId_File: + p = getConfig(m->data.file.filename, nodeId, verId); + break; + default: + setError(CR_ERROR, "Unknown error type"); + break; + } + + if (p != 0) { + return p; + } + if(latestErrorType == CR_RETRY) + type = CR_RETRY; + } // for + + if(type == CR_RETRY){ + REPORT_WARNING("Failed to retrieve cluster configuration"); + ndbout << "(Cause of failure: " << getErrorString() << ")" << endl; + ndbout << "Attempt " << retry << " of " << retry_max << ". " + << "Trying again in "<unpack(buf2, bytes+4)){ + snprintf(buf, sizeof(buf), "Error while unpacking %d,%d", + p->getPropertiesErrno(), + p->getOSErrno()); + setError(CR_ERROR, buf); + delete []buf2; + delete p; + return 0; + } + delete []buf2; + + NDB_CLOSE_SOCKET(sockfd); + + return p; + +} + +Properties * +ConfigRetriever::getConfig(const char * filename, + Uint32 nodeId, + int versionId){ + + struct stat sbuf; + const int res = stat(filename, &sbuf); + if(res != 0){ + char buf[255]; + snprintf(buf, sizeof(buf), "Could not find file: \"%s\"", filename); + setError(CR_ERROR, buf); + return 0; + } + const Uint32 bytes = sbuf.st_size; + + Uint32 * buf2 = new Uint32[bytes/4+1]; + + FILE * f = fopen(filename, "rb"); + if(f == 0){ + setError(CR_ERROR, "Failed to open file"); + delete []buf2; + return 0; + } + Uint32 sz = fread(buf2, 1, bytes, f); + fclose(f); + if(sz != bytes){ + setError(CR_ERROR, "Failed to read file"); + delete []buf2; + return 0; + } + + Properties * p = new Properties(); + if(!p->unpack(buf2, bytes+4)){ + char buf[255]; + snprintf(buf, sizeof(buf), "Error while unpacking %d,%d", + p->getPropertiesErrno(), + p->getOSErrno()); + setError(CR_ERROR, buf); + delete []buf2; + delete p; + return 0; + } + delete [] buf2; + + return p; +} + +bool +ConfigRetriever::verifyProperties(const char* nodeType, Properties * p, + Uint32 nodeId, int versionId){ + + Uint32 t = 0; + const Properties *tmp; + const char *type; + + if (p == 0) return false; + + bool compatible = false; + if (p->get("Version", &t)) + if (global_ndb_check) + compatible = ndbCompatible_ndb_mgmt(versionId, t); + else + compatible = ndbCompatible_api_mgmt(versionId, t); + + if(!compatible){ // if(!p->get("Version", &t) || versionId != (int)t){ + setError(CR_ERROR, "Invalid configuration version"); + delete p; + return false; + } + + if(!p->get("LocalNodeId", &t) || nodeId != t){ + setError(CR_ERROR, "Invalid node identity in configuration"); + delete p; + return false; + } + + if(!p->get("Node", nodeId, &tmp)){ + setError(CR_ERROR, "Internal error while processing configuration"); + ndbout_c("nodeId = %d", nodeId); + p->print(); + delete p; + return false; + } + + if(!tmp->get("Type", &type) || strcmp(type, nodeType)) { + if (!(!strcmp(type, "REP") && !strcmp(nodeType, "API"))) { + char buf[1024]; + snprintf(buf, sizeof(buf), + "Configuration error: Node with id %d is not of type %s.\n" + "Check local config file: %s", nodeId, nodeType, + _localConfigFileName); + setError(CR_ERROR, buf); + return false; + } + } + + return true; +} + +void +ConfigRetriever::setError(ErrorType et, const char * s){ + if(errorString != 0){ + free(errorString); + } + if(s == 0) + errorString = 0; + else + errorString = strdup(s); + latestErrorType = et; +} + + +const char * +ConfigRetriever::getErrorString(){ + return errorString; +} + +void +ConfigRetriever::setLocalConfigFileName(const char * localConfigFileName) { + if(_localConfigFileName != 0) + free(_localConfigFileName); + if(localConfigFileName != 0) + _localConfigFileName = strdup(localConfigFileName); + else + _localConfigFileName = 0; +} + +void +ConfigRetriever::setConnectString(const char * connectString) { + if(m_connectString != 0) + free(m_connectString); + if (connectString != 0) { + m_connectString = strdup(connectString); + } else { + m_connectString = 0; + } +} + +/** + * @note Do not use! Use the one above if possible. /elathal + */ +void +ConfigRetriever::setDefaultConnectString(const char * defaultConnectString) { + if(m_defaultConnectString != 0) + free(m_defaultConnectString); + if (defaultConnectString != 0) { + m_defaultConnectString = strdup(defaultConnectString); + } else { + m_defaultConnectString = 0; + } +} diff --git a/ndb/src/common/mgmcommon/IPCConfig.cpp b/ndb/src/common/mgmcommon/IPCConfig.cpp new file mode 100644 index 00000000000..f75cf806cc0 --- /dev/null +++ b/ndb/src/common/mgmcommon/IPCConfig.cpp @@ -0,0 +1,336 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "IPCConfig.hpp" +#include +#include +#include +#include +#include + +#if defined DEBUG_TRANSPORTER +#define DEBUG(t) ndbout << __FILE__ << ":" << __LINE__ << ":" << t << endl; +#else +#define DEBUG(t) +#endif + +IPCConfig::IPCConfig(Properties * p) +{ + theNoOfRemoteNodes = 0; + the_ownId = 0; + if(p != 0) + props = new Properties(* p); + else + props = 0; +} + + +IPCConfig::~IPCConfig() +{ + if(props != 0){ + delete props; + } +} + +int +IPCConfig::init(){ + Uint32 nodeId; + + if(props == 0) return -1; + if(!props->get("LocalNodeId", &nodeId)) { + DEBUG( "Did not find local node id." ); + return -1; + } + the_ownId = nodeId; + + Uint32 noOfConnections; + if(!props->get("NoOfConnections", &noOfConnections)) { + DEBUG( "Did not find noOfConnections." ); + return -1; + } + + for(Uint32 i = 0; iget("Connection", i, &tmp)) { + DEBUG( "Did not find Connection." ); + return -1; + } + if(!tmp->get("NodeId1", &node1)) { + DEBUG( "Did not find NodeId1." ); + return -1; + } + if(!tmp->get("NodeId2", &node2)) { + DEBUG( "Did not find NodeId2." ); + return -1; + } + + if(node1 == the_ownId && node2 != the_ownId) + if(!addRemoteNodeId(node2)) { + DEBUG( "addRemoteNodeId(node2) failed." ); + return -1; + } + + if(node1 != the_ownId && node2 == the_ownId) + if(!addRemoteNodeId(node1)) { + DEBUG( "addRemoteNodeId(node2) failed." ); + return -1; + } + } + return 0; +} + +bool +IPCConfig::addRemoteNodeId(NodeId nodeId){ + for(int i = 0; iget("NoOfConnections", &noOfConnections)) return -1; + + for (Uint32 i = 0; i < noOfConnections; i++){ + const Properties * tmp; + Uint32 nodeId1, nodeId2; + const char * host1; + const char * host2; + + if(!props->get("Connection", i, &tmp)) continue; + if(!tmp->get("NodeId1", &nodeId1)) continue; + if(!tmp->get("NodeId2", &nodeId2)) continue; + if(nodeId1 != the_ownId && nodeId2 != the_ownId) continue; + + Uint32 sendSignalId; + Uint32 compression; + Uint32 checksum; + if(!tmp->get("SendSignalId", &sendSignalId)) continue; + if(!tmp->get("Compression", &compression)) continue; + if(!tmp->get("Checksum", &checksum)) continue; + + const char * type; + if(!tmp->get("Type", &type)) continue; + + if(strcmp("SHM", type) == 0){ + SHM_TransporterConfiguration conf; + conf.localNodeId = the_ownId; + conf.remoteNodeId = (nodeId1 != the_ownId ? nodeId1 : nodeId2); + conf.byteOrder = 0; + conf.compression = compression; + conf.checksum = checksum; + conf.signalId = sendSignalId; + + if(!tmp->get("ShmKey", &conf.shmKey)) continue; + if(!tmp->get("ShmSize", &conf.shmSize)) continue; + + if(!theTransporterRegistry->createTransporter(&conf)){ + ndbout << "Failed to create SHM Transporter from: " + << conf.localNodeId << " to: " << conf.remoteNodeId << endl; + continue; + } else { + noOfTransportersCreated++; + continue; + } + + } else if(strcmp("SCI", type) == 0){ + SCI_TransporterConfiguration conf; + conf.localNodeId = the_ownId; + conf.remoteNodeId = (nodeId1 != the_ownId ? nodeId1 : nodeId2); + conf.byteOrder = 0; + conf.compression = compression; + conf.checksum = checksum; + conf.signalId = sendSignalId; + + if(!tmp->get("SendLimit", &conf.sendLimit)) continue; + if(!tmp->get("SharedBufferSize", &conf.bufferSize)) continue; + + if(the_ownId == nodeId1){ + if(!tmp->get("Node1_NoOfAdapters", &conf.nLocalAdapters)) continue; + if(!tmp->get("Node2_NoOfAdapters", &conf.nRemoteAdapters)) continue; + if(!tmp->get("Node2_Adapter", 0, &conf.remoteSciNodeId0)) continue; + + if(conf.nRemoteAdapters > 1){ + if(!tmp->get("Node2_Adapter", 1, &conf.remoteSciNodeId1)) continue; + } + } else { + if(!tmp->get("Node2_NoOfAdapters", &conf.nLocalAdapters)) continue; + if(!tmp->get("Node1_NoOfAdapters", &conf.nRemoteAdapters)) continue; + if(!tmp->get("Node1_Adapter", 0, &conf.remoteSciNodeId0)) continue; + + if(conf.nRemoteAdapters > 1){ + if(!tmp->get("Node1_Adapter", 1, &conf.remoteSciNodeId1)) continue; + } + } + + if(!theTransporterRegistry->createTransporter(&conf)){ + ndbout << "Failed to create SCI Transporter from: " + << conf.localNodeId << " to: " << conf.remoteNodeId << endl; + continue; + } else { + noOfTransportersCreated++; + continue; + } + } + + if(!tmp->get("HostName1", &host1)) continue; + if(!tmp->get("HostName2", &host2)) continue; + + Uint32 ownNodeId; + Uint32 remoteNodeId; + const char * ownHostName; + const char * remoteHostName; + + if(nodeId1 == the_ownId){ + ownNodeId = nodeId1; + ownHostName = host1; + remoteNodeId = nodeId2; + remoteHostName = host2; + } else if(nodeId2 == the_ownId){ + ownNodeId = nodeId2; + ownHostName = host2; + remoteNodeId = nodeId1; + remoteHostName = host1; + } else { + continue; + } + + if(strcmp("TCP", type) == 0){ + TCP_TransporterConfiguration conf; + + if(!tmp->get("PortNumber", &conf.port)) continue; + if(!tmp->get("SendBufferSize", &conf.sendBufferSize)) continue; + if(!tmp->get("MaxReceiveSize", &conf.maxReceiveSize)) continue; + + const char * proxy; + if (tmp->get("Proxy", &proxy)) { + if (strlen(proxy) > 0 && nodeId2 == the_ownId) { + // TODO handle host:port + conf.port = atoi(proxy); + } + } + conf.sendBufferSize *= MAX_MESSAGE_SIZE; + conf.maxReceiveSize *= MAX_MESSAGE_SIZE; + + conf.remoteHostName = remoteHostName; + conf.localHostName = ownHostName; + conf.remoteNodeId = remoteNodeId; + conf.localNodeId = ownNodeId; + conf.byteOrder = 0; + conf.compression = compression; + conf.checksum = checksum; + conf.signalId = sendSignalId; + + if(!theTransporterRegistry->createTransporter(&conf)){ + ndbout << "Failed to create TCP Transporter from: " + << ownNodeId << " to: " << remoteNodeId << endl; + } else { + noOfTransportersCreated++; + } + + } else if(strcmp("OSE", type) == 0){ + + OSE_TransporterConfiguration conf; + + if(!tmp->get("PrioASignalSize", &conf.prioASignalSize)) + continue; + if(!tmp->get("PrioBSignalSize", &conf.prioBSignalSize)) + continue; + if(!tmp->get("ReceiveArraySize", &conf.receiveBufferSize)) + continue; + + conf.remoteHostName = remoteHostName; + conf.localHostName = ownHostName; + conf.remoteNodeId = remoteNodeId; + conf.localNodeId = ownNodeId; + conf.byteOrder = 0; + conf.compression = compression; + conf.checksum = checksum; + conf.signalId = sendSignalId; + + if(!theTransporterRegistry->createTransporter(&conf)){ + ndbout << "Failed to create OSE Transporter from: " + << ownNodeId << " to: " << remoteNodeId << endl; + } else { + noOfTransportersCreated++; + } + } else { + continue; + } + } + return noOfTransportersCreated; +} + +/** + * Supply a nodeId, + * and get next higher node id + * Returns false if none found + */ +bool +IPCConfig::getNextRemoteNodeId(NodeId & nodeId) const { + NodeId returnNode = MAX_NODES + 1; + for(int i = 0; i nodeId){ + if(theRemoteNodeIds[i] < returnNode){ + returnNode = theRemoteNodeIds[i]; + } + } + if(returnNode == (MAX_NODES + 1)) + return false; + nodeId = returnNode; + return true; +} + + +Uint32 +IPCConfig::getREPHBFrequency(NodeId id) const { + const Properties * tmp; + Uint32 out; + + /** + * Todo: Fix correct heartbeat + */ + if (!props->get("Node", id, &tmp) || + !tmp->get("HeartbeatIntervalRepRep", &out)) { + DEBUG("Illegal Node or HeartbeatIntervalRepRep in config."); + out = 10000; + } + + return out; +} + +const char* +IPCConfig::getNodeType(NodeId id) const { + const char * out; + const Properties * tmp; + + if (!props->get("Node", id, &tmp) || !tmp->get("Type", &out)) { + DEBUG("Illegal Node or NodeType in config."); + out = "Unknown"; + } + + return out; +} diff --git a/ndb/src/common/mgmcommon/InitConfigFileParser.cpp b/ndb/src/common/mgmcommon/InitConfigFileParser.cpp new file mode 100644 index 00000000000..33652fa472c --- /dev/null +++ b/ndb/src/common/mgmcommon/InitConfigFileParser.cpp @@ -0,0 +1,544 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "InitConfigFileParser.hpp" +#include +#include +#include "Config.hpp" +#include "MgmtErrorReporter.hpp" +#include +#include "ConfigInfo.hpp" +#include +#include +#include + +const int MAX_LINE_LENGTH = 120; // Max length of line of text in config file +static void trim(char *); + +static void require(bool v) { if(!v) abort();} + +//**************************************************************************** +// Ctor / Dtor +//**************************************************************************** +InitConfigFileParser::InitConfigFileParser(const char* initialConfigFileName){ + + m_initConfigStream = fopen(initialConfigFileName, "r"); + + m_info = new ConfigInfo(); + m_config = new Config(); + m_defaults = new Properties(); + m_defaults->setCaseInsensitiveNames(true); +} + +InitConfigFileParser::~InitConfigFileParser() { + if (m_initConfigStream != NULL) fclose(m_initConfigStream); + + delete m_info; + delete m_config; + delete m_defaults; +} + +//**************************************************************************** +// Read Config File +//**************************************************************************** +bool InitConfigFileParser::readConfigFile() { + + char line[MAX_LINE_LENGTH]; + + Context ctx; + ctx.m_lineno = 0; + ctx.m_currentSection = 0; + + ctx.m_info = m_info; + ctx.m_config = m_config; + ctx.m_defaults = m_defaults; + + /************* + * Open file * + *************/ + if (m_initConfigStream == NULL) { + ctx.reportError("Could not open file."); + return false; + } + + /*********************** + * While lines to read * + ***********************/ + while (fgets(line, MAX_LINE_LENGTH, m_initConfigStream)) { + ctx.m_lineno++; + + trim(line); + + if (isEmptyLine(line)) // Skip if line is empty or comment + continue; + + // End with NULL instead of newline + if (line[strlen(line)-1] == '\n') + line[strlen(line)-1] = '\0'; + + /******************************** + * 1. Parse new default section * + ********************************/ + if (char* section = parseDefaultSectionHeader(line)) { + if(!storeSection(ctx)){ + free(section); + ctx.reportError("Could not store previous default section " + "of configuration file."); + return false; + } + + snprintf(ctx.fname, sizeof(ctx.fname), section); free(section); + ctx.type = InitConfigFileParser::DefaultSection; + ctx.m_sectionLineno = ctx.m_lineno; + ctx.m_currentSection = new Properties(); + ctx.m_userDefaults = NULL; + ctx.m_currentInfo = m_info->getInfo(ctx.fname); + ctx.m_systemDefaults = m_info->getDefaults(ctx.fname); + continue; + } + + /************************ + * 2. Parse new section * + ************************/ + if (char* section = parseSectionHeader(line)) { + if(!storeSection(ctx)){ + free(section); + ctx.reportError("Could not store previous section " + "of configuration file."); + return false; + } + + snprintf(ctx.fname, sizeof(ctx.fname), section); + free(section); + ctx.type = InitConfigFileParser::Section; + ctx.m_sectionLineno = ctx.m_lineno; + ctx.m_currentSection = new Properties(); + ctx.m_userDefaults = getSection(ctx.fname, m_defaults); + ctx.m_currentInfo = m_info->getInfo(ctx.fname); + ctx.m_systemDefaults = m_info->getDefaults(ctx.fname); + continue; + } + + /**************************** + * 3. Parse name-value pair * + ****************************/ + if (!parseNameValuePair(ctx, line)) { + ctx.reportError("Could not parse name-value pair in config file."); + return false; + } + } + + if(!storeSection(ctx)) { + ctx.reportError("Could not store section of configuration file."); + return false; + } + + Uint32 nConnections = 0; + Uint32 nComputers = 0; + Uint32 nNodes = 0; + Uint32 nExtConnections = 0; + const char * system = "?"; + ctx.m_userProperties.get("NoOfConnections", &nConnections); + ctx.m_userProperties.get("NoOfComputers", &nComputers); + ctx.m_userProperties.get("NoOfNodes", &nNodes); + ctx.m_userProperties.get("ExtNoOfConnections", &nExtConnections); + ctx.m_userProperties.get("ExtSystem", &system); + m_config->put("NoOfConnections", nConnections); + m_config->put("NoOfComputers", nComputers); + m_config->put("NoOfNodes", nNodes); + + char tmpLine[MAX_LINE_LENGTH]; + snprintf(tmpLine, MAX_LINE_LENGTH, "EXTERNAL SYSTEM_"); + strncat(tmpLine, system, MAX_LINE_LENGTH); + strncat(tmpLine, ":NoOfConnections", MAX_LINE_LENGTH); + m_config->put(tmpLine, nExtConnections); + + if (ferror(m_initConfigStream)) { + ctx.reportError("Failure in reading"); + return false; + } + return true; +} + +//**************************************************************************** +// Parse Name-Value Pair +//**************************************************************************** + +bool InitConfigFileParser::parseNameValuePair(Context& ctx, const char* line) { + + char tmpLine[MAX_LINE_LENGTH]; + char fname[MAX_LINE_LENGTH], rest[MAX_LINE_LENGTH]; + char* t; + + if (ctx.m_currentSection == NULL){ + ctx.reportError("Value specified outside section"); + return false; + } + + strncpy(tmpLine, line, MAX_LINE_LENGTH); + + // ************************************* + // Check if a separator exists in line + // ************************************* + if (!strchr(tmpLine, ':')) { + ctx.reportError("Parse error"); + return false; + } + + // ******************************************* + // Get pointer to substring before separator + // ******************************************* + t = strtok(tmpLine, ":"); + + // ***************************************** + // Count number of tokens before separator + // ***************************************** + if (sscanf(t, "%120s%120s", fname, rest) != 1) { + ctx.reportError("Multiple names before \':\'"); + return false; + } + if (!ctx.m_currentInfo->contains(fname)) { + ctx.reportError("[%s] Unknown parameter: %s", ctx.fname, fname); + return false; + } + ConfigInfo::Status status = m_info->getStatus(ctx.m_currentInfo, fname); + if (status == ConfigInfo::NOTIMPLEMENTED) { + ctx.reportWarning("[%s] %s not yet implemented", ctx.fname, fname); + } + if (status == ConfigInfo::DEPRICATED) { + ctx.reportWarning("[%s] %s is depricated", ctx.fname, fname); + } + + // ****************************************** + // Get pointer to substring after separator + // ****************************************** + t = strtok(NULL, "\0"); + if (t == NULL) { + ctx.reportError("No value for parameter"); + return false; + } + + // ****************************************** + // Remove prefix and postfix spaces and tabs + // ******************************************* + trim(t); + + // *********************** + // Store name-value pair + // *********************** + return storeNameValuePair(ctx, fname, t); +} + + +//**************************************************************************** +// STORE NAME-VALUE pair in properties section +//**************************************************************************** + +bool +InitConfigFileParser::storeNameValuePair(Context& ctx, + const char* fname, + const char* value) { + + const char * pname = m_info->getPName(ctx.m_currentInfo, fname); + + if (ctx.m_currentSection->contains(pname)) { + ctx.reportError("[%s] Parameter %s specified twice", ctx.fname, fname); + return false; + } + + // *********************** + // Store name-value pair + // *********************** + + switch(m_info->getType(ctx.m_currentInfo, fname)){ + case ConfigInfo::BOOL: { + bool value_bool; + if (!convertStringToBool(value, value_bool)) { + ctx.reportError("Illegal boolean value for parameter %s", fname); + return false; + } + MGM_REQUIRE(ctx.m_currentSection->put(pname, value_bool)); + break; + } + case ConfigInfo::INT:{ + Uint32 value_int; + if (!convertStringToUint32(value, value_int)) { + ctx.reportError("Illegal integer value for parameter %s", fname); + return false; + } + if (!m_info->verify(ctx.m_currentInfo, fname, value_int)) { + ctx.reportError("Illegal value %s for parameter %s.\n" + "Legal values are between %d and %d", value, fname, + m_info->getMin(ctx.m_currentInfo, fname), + m_info->getMax(ctx.m_currentInfo, fname)); + return false; + } + MGM_REQUIRE(ctx.m_currentSection->put(pname, value_int)); + break; + } + case ConfigInfo::STRING: + MGM_REQUIRE(ctx.m_currentSection->put(pname, value)); + break; + } + return true; +} + +//**************************************************************************** +// Is Empty Line +//**************************************************************************** + +bool InitConfigFileParser::isEmptyLine(const char* line) const { + int i; + + // Check if it is a comment line + if (line[0] == '#') return true; + + // Check if it is a line with only spaces + for (i = 0; i < MAX_LINE_LENGTH && line[i] != '\n' && line[i] != '\0'; i++) { + if (line[i] != ' ' && line[i] != '\t') return false; + } + return true; +} + +//**************************************************************************** +// Convert String to Int +//**************************************************************************** +bool InitConfigFileParser::convertStringToUint32(const char* s, + Uint32& val, + Uint32 log10base) { + if (s == NULL) + return false; + if (strlen(s) == 0) + return false; + + errno = 0; + char* p; + long v = strtol(s, &p, 10); + if (errno != 0) + return false; + + long mul = 0; + if (p != &s[strlen(s)]){ + char * tmp = strdup(p); + trim(tmp); + switch(tmp[0]){ + case 'k': + case 'K': + mul = 10; + break; + case 'M': + mul = 20; + break; + case 'G': + mul = 30; + break; + default: + free(tmp); + return false; + } + free(tmp); + } + + val = (v << mul); + return true; +} + +bool InitConfigFileParser::convertStringToBool(const char* s, bool& val) { + if (s == NULL) return false; + if (strlen(s) == 0) return false; + + if (!strcmp(s, "Y") || !strcmp(s, "y") || + !strcmp(s, "Yes") || !strcmp(s, "YES") || !strcmp(s, "yes") || + !strcmp(s, "True") || !strcmp(s, "TRUE") || !strcmp(s, "true")) { + val = true; + return true; + } + + if (!strcmp(s, "N") || !strcmp(s, "n") || + !strcmp(s, "No") || !strcmp(s, "NO") || !strcmp(s, "no") || + !strcmp(s, "False") || !strcmp(s, "FALSE") || !strcmp(s, "false")) { + val = false; + return true; + } + + return false; // Failure to convert +} + +//**************************************************************************** +// Get Config +//**************************************************************************** +const Config* InitConfigFileParser::getConfig() { + Uint32 nConnections = 0; + Uint32 nComputers = 0; + Uint32 nNodes = 0; + m_config->get("NoOfConnections", &nConnections); + m_config->get("NoOfComputers", &nComputers); + m_config->get("NoOfNodes", &nNodes); + + return m_config; +} + + +//**************************************************************************** +// Parse Section Header +//**************************************************************************** +static void +trim(char * str){ + int len = strlen(str); + for(len--; + (str[len] == '\r' || str[len] == '\n' || + str[len] == ' ' || str[len] == '\t') && + len > 0; + len--) + str[len] = 0; + + int pos = 0; + while(str[pos] == ' ' || str[pos] == '\t') + pos++; + + if(str[pos] == '\"' && str[len] == '\"') { + pos++; + str[len] = 0; + len--; + } + + memmove(str, &str[pos], len - pos + 2); +} + +char* +InitConfigFileParser::parseSectionHeader(const char* line) const { + char * tmp = strdup(line); + + if(tmp[0] != '['){ + free(tmp); + return NULL; + } + + if(tmp[strlen(tmp)-1] != ']'){ + free(tmp); + return NULL; + } + tmp[strlen(tmp)-1] = 0; + + tmp[0] = ' '; + trim(tmp); + + // Lookup token among sections + if(!m_info->isSection(tmp)) return NULL; + if(m_info->getInfo(tmp)) return tmp; + + free(tmp); + return NULL; +} + +//**************************************************************************** +// Parse Default Section Header +//**************************************************************************** + +char* +InitConfigFileParser::parseDefaultSectionHeader(const char* line) const { + static char token1[MAX_LINE_LENGTH], token2[MAX_LINE_LENGTH]; + + int no = sscanf(line, "[%120[A-Za-z] %120[A-Za-z]]", token1, token2); + + // Not correct no of tokens + if (no != 2) return NULL; + + // Not correct keyword at end + if (!strcmp(token2, "DEFAULT") == 0) return NULL; + + if(m_info->getInfo(token1)){ + return strdup(token1); + } + + // Did not find section + return NULL; +} + +const Properties * +InitConfigFileParser::getSection(const char * name, const Properties * src){ + const Properties * p; + if(src && src->get(name, &p)) + return p; + + return 0; +} + +//**************************************************************************** +// STORE section +//**************************************************************************** +bool +InitConfigFileParser::storeSection(Context& ctx){ + if(ctx.m_currentSection == NULL) + return true; + + for(int i = strlen(ctx.fname) - 1; i>=0; i--){ + ctx.fname[i] = toupper(ctx.fname[i]); + } + + snprintf(ctx.pname, sizeof(ctx.pname), ctx.fname); + + char buf[255]; + if(ctx.type == InitConfigFileParser::Section) + snprintf(buf, sizeof(buf), "%s", ctx.fname); + if(ctx.type == InitConfigFileParser::DefaultSection) + snprintf(buf, sizeof(buf), "%s DEFAULT", ctx.fname); + + snprintf(ctx.fname, sizeof(ctx.fname), buf); + for(int i = 0; im_NoOfRules; i++){ + const ConfigInfo::SectionRule & rule = m_info->m_SectionRules[i]; + if(strcmp(rule.m_section, ctx.fname) == 0) + if(!(* rule.m_sectionRule)(ctx, rule.m_ruleData)){ + return false; + } + } + + if(ctx.type == InitConfigFileParser::DefaultSection) + require(m_defaults->put(ctx.pname, ctx.m_currentSection)); + + if(ctx.type == InitConfigFileParser::Section) + require(m_config->put(ctx.pname, ctx.m_currentSection)); + + delete ctx.m_currentSection; ctx.m_currentSection = NULL; + + return true; +} + +void +InitConfigFileParser::Context::reportError(const char * fmt, ...){ + va_list ap; + char buf[1000]; + + va_start(ap, fmt); + if (fmt != 0) + vsnprintf(buf, sizeof(buf)-1, fmt, ap); + ndbout << "Error line " << m_lineno << ": " << buf << endl; + va_end(ap); + + //m_currentSection->print(); +} + +void +InitConfigFileParser::Context::reportWarning(const char * fmt, ...){ + va_list ap; + char buf[1000]; + + va_start(ap, fmt); + if (fmt != 0) + vsnprintf(buf, sizeof(buf)-1, fmt, ap); + ndbout << "Warning line " << m_lineno << ": " << buf << endl; + va_end(ap); +} diff --git a/ndb/src/common/mgmcommon/InitConfigFileParser.hpp b/ndb/src/common/mgmcommon/InitConfigFileParser.hpp new file mode 100644 index 00000000000..1e85067396c --- /dev/null +++ b/ndb/src/common/mgmcommon/InitConfigFileParser.hpp @@ -0,0 +1,142 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef InitConfigFileParser_H +#define InitConfigFileParser_H + +#include +#include + +class Config; +class ConfigInfo; + +/** + * @class InitConfigFileParser + * @brief Reads initial config file and returns Config object + * + * This class contains one public method InitConfigFileParser::getConfig, + * which reads an initial configuration file and returns a Config + * object if the config file has correct syntax and semantic. + */ +class InitConfigFileParser { +public: + enum ContextSectionType { Undefined, Section, DefaultSection }; + + /** + * Context = Which section in init config file we are currently parsing + */ + struct Context { + ContextSectionType type; ///< Section type (e.g. default section,section) + char fname[256]; ///< Section name occuring in init config file + char pname[256]; ///< Section name stored in properties object + Uint32 m_lineno; ///< Current line no in config file + Uint32 m_sectionLineno; ///< Where did current section start + + const ConfigInfo * m_info; // The config info + const Properties * m_config; // The config object + const Properties * m_defaults; // The user defaults + + Properties * m_currentSection; // The current section I'm in + const Properties * m_userDefaults; // The defaults of this section + const Properties * m_systemDefaults; // The syst. defaults for this section + const Properties * m_currentInfo; // The "info" for this section + + Properties m_userProperties; // User properties (temporary values) + + public: + void reportError(const char * msg, ...); + void reportWarning(const char * msg, ...); + }; + + + /** + * Constructor + * @param initialConfigFileName: Name of the initial configuration file + */ + InitConfigFileParser(const char* initialConfigFileName); + ~InitConfigFileParser(); + + /** + * Reads the initial configuration file, checks syntax and semantic + * and stores internally the values of all parameters. + * + * @returns true if succeeded, o/w false (e.g. incorrect config file) + */ + bool readConfigFile(); + + /** + * Get config. Must execute InitConfigFileParser::readConfigFile first. + * + * @returns Config if succeeded, o/w NULL + */ + const Config* getConfig(); + + +private: + /** + * Check if line only contains space/comments + * @param line: The line to check + * @return true if spaces/comments only, false otherwise + */ + bool isEmptyLine(const char* line) const; + + /** + * Checks if line contains a section header + * @param line: String to search + * @return section header if matching some section header, NULL otherwise + */ + char* parseSectionHeader(const char* line) const; + + /** + * Checks if line contains a default header + * @param line: String to search + * @return section header if matching some section header, NULL otherwise + */ + char* parseDefaultSectionHeader(const char* line) const; + + bool parseNameValuePair(Context&, const char* line); + bool storeNameValuePair(Context&, const char* fname, const char* value); + + bool convertStringToUint32(const char* s, Uint32& val, Uint32 log10base = 0); + bool convertStringToBool(const char* s, bool& val); + + const Properties* getSection(const char * name, const Properties* src); + + /*************************************************************************** + * VARIABLES + ***************************************************************************/ + FILE* m_initConfigStream; + + /** + * Information about parameters (min, max values etc) + */ + const ConfigInfo* m_info; + + /** + * Configuration from initial configuration file + * (returned by InitConfigFileParser::readConfigFile) + */ + Config* m_config; + + /** + * Default values specified in default sections + */ + Properties* m_defaults; + + bool storeSection(Context&); +}; + +#endif // InitConfigFileParser_H diff --git a/ndb/src/common/mgmcommon/LocalConfig.cpp b/ndb/src/common/mgmcommon/LocalConfig.cpp new file mode 100644 index 00000000000..12e685ced34 --- /dev/null +++ b/ndb/src/common/mgmcommon/LocalConfig.cpp @@ -0,0 +1,308 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "LocalConfig.hpp" +#include +#include + +LocalConfig::LocalConfig(){ + ids = 0; size = 0; items = 0; + error_line = 0; error_msg[0] = 0; +} + +bool +LocalConfig::init(bool onlyNodeId, + const char *connectString, + const char *fileName, + const char *defaultConnectString) { + /** + * Escalation: + * 1. Check connectString + * 2. Check given filename + * 3. Check environment variable NDB_CONNECTSTRING + * 4. Check Ndb.cfg in NDB_HOME + * 5. Check Ndb.cfg in cwd + * 6. Check defaultConnectString + */ + + //1. Check connectString + if(connectString != 0) { + if(readConnectString(connectString, onlyNodeId)){ + return true; + } + return false; + } + + //2. Check given filename + if (fileName && strlen(fileName) > 0) { + bool fopenError; + if(readFile(fileName, fopenError, onlyNodeId)){ + return true; + } + return false; + } + + //3. Check environment variable + char buf[255]; + if(NdbEnv_GetEnv("NDB_CONNECTSTRING", buf, sizeof(buf)) && + strlen(buf) != 0){ + if(readConnectString(buf, onlyNodeId)){ + return true; + } + return false; + } + + //4. Check Ndb.cfg in NDB_HOME + { + bool fopenError; + char buf[256]; + if(readFile(NdbConfig_NdbCfgName(buf, sizeof(buf), 1 /*true*/), fopenError, onlyNodeId)){ + return true; + } + if (!fopenError) + return false; + } + + //5. Check Ndb.cfg in cwd + { + bool fopenError; + char buf[256]; + if(readFile(NdbConfig_NdbCfgName(buf, sizeof(buf), 0 /*false*/), fopenError, onlyNodeId)){ + return true; + } + if (!fopenError) + return false; + } + + //6. Check defaultConnectString + if(defaultConnectString != 0) { + if(readConnectString(defaultConnectString, onlyNodeId)){ + return true; + } + return false; + } + + setError(0, ""); + + return false; +} + +LocalConfig::~LocalConfig(){ + for(int i = 0; itype == MgmId_TCP) + free(ids[i]->data.tcp.remoteHost); + else if(ids[i]->type == MgmId_File) + free(ids[i]->data.file.filename); + delete ids[i]; + } + if(ids != 0) + delete[] ids; +} + +void LocalConfig::add(MgmtSrvrId * i){ + if(items == size){ + MgmtSrvrId ** tmp = new MgmtSrvrId * [size+10]; + if(ids != 0){ + memcpy(tmp, ids, items*sizeof(MgmtSrvrId *)); + delete []ids; + } + ids = tmp; + } + ids[items] = i; + items++; +} + +void LocalConfig::setError(int lineNumber, const char * _msg) { + error_line = lineNumber; + strncpy(error_msg, _msg, sizeof(error_msg)); +} + +void LocalConfig::printError() const { + ndbout << "Local configuration error"<< endl + << "Line: "<< error_line << ", " << error_msg << endl << endl; +} + +void LocalConfig::printUsage() const { + ndbout << "This node needs information on how to connect"<export NDB_CONNECTSTRING=\"nodeid=11;host=localhost:2200\"" + <type = MgmId_TCP; + mgmtSrvrId->data.tcp.remoteHost = strdup(tempString); + mgmtSrvrId->data.tcp.port = port; + add(mgmtSrvrId); + return true; + } + } + return false; +} + +bool +LocalConfig::parseFileName(const char * buf){ + char tempString[100]; + for(int i = 0; fileNameTokens[i] != 0; i++) { + if (sscanf(buf, fileNameTokens[i], tempString) == 1) { + MgmtSrvrId* mgmtSrvrId = new MgmtSrvrId(); + mgmtSrvrId->type = MgmId_File; + mgmtSrvrId->data.file.filename = strdup(tempString); + add(mgmtSrvrId); + return true; + } + } + return false; +} + +bool +LocalConfig::parseString(const char * connectString, bool onlyNodeId, char *line){ + bool return_value = true; + + char * for_strtok; + char * copy = strdup(connectString); + + bool b_nodeId = false; + bool found_other = false; + + for (char *tok = strtok_r(copy,";",&for_strtok); + tok != 0 && !(onlyNodeId && b_nodeId); + tok = strtok_r(NULL, ";", &for_strtok)) { + + if (tok[0] == '#') continue; + + if (!b_nodeId) // only one nodeid definition allowed + if (b_nodeId = parseNodeId(tok)) + continue; + if (onlyNodeId) + continue; + if (found_other = parseHostName(tok)) + continue; + if (found_other = parseFileName(tok)) + continue; + + snprintf(line, 150, "Unexpected entry: \"%s\"", tok); + return_value = false; + break; + } + + if (return_value && !onlyNodeId && !found_other) { + return_value = false; + snprintf(line, 150, "Missing host/file name extry in \"%s\"", connectString); + } + + free(copy); + return return_value; +} + +bool LocalConfig::readFile(const char * filename, bool &fopenError, bool onlyNodeId) +{ + char line[150], line2[150]; + + fopenError = false; + + FILE * file = fopen(filename, "r"); + if(file == 0){ + snprintf(line, 150, "Unable to open local config file: %s", filename); + setError(0, line); + fopenError = true; + return false; + } + + int sz = 1024; + char* theString = (char*)malloc(sz); + theString[0] = 0; + + fgets(theString, sz, file); + while (fgets(line+1, 100, file)) { + line[0] = ';'; + while (strlen(theString) + strlen(line) >= sz) { + sz = sz*2; + char *newString = (char*)malloc(sz); + strcpy(newString, theString); + free(theString); + theString = newString; + } + strcat(theString, line); + } + + bool return_value = parseString(theString, onlyNodeId, line); + + if (!return_value) { + snprintf(line2, 150, "Reading %s: %s", filename, line); + setError(0,line2); + } + + free(theString); + fclose(file); + return return_value; +} + +bool +LocalConfig::readConnectString(const char * connectString, bool onlyNodeId){ + char line[150], line2[150]; + bool return_value = parseString(connectString, onlyNodeId, line); + if (!return_value) { + snprintf(line2, 150, "Reading NDB_CONNECTSTRING \"%s\": %s", connectString, line); + setError(0,line2); + } + return return_value; +} diff --git a/ndb/src/common/mgmcommon/LocalConfig.hpp b/ndb/src/common/mgmcommon/LocalConfig.hpp new file mode 100644 index 00000000000..ec7b572e92d --- /dev/null +++ b/ndb/src/common/mgmcommon/LocalConfig.hpp @@ -0,0 +1,83 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef LocalConfig_H +#define LocalConfig_H + +#include +#include +#include +#include + +//**************************************************************************** +// Description: The class LocalConfig corresponds to the information possible +// to give in the local configuration file. +//***************************************************************************** + +enum MgmtSrvrId_Type { + MgmId_TCP = 0, + MgmId_File = 1 +}; + +struct MgmtSrvrId { + MgmtSrvrId_Type type; + union { + struct { + char * remoteHost; + unsigned int port; + } tcp; + struct { + char * filename; + } file; + } data; +}; + +struct LocalConfig { + + int _ownNodeId; + + int size; + int items; + MgmtSrvrId ** ids; + + int error_line; + char error_msg[256]; + + LocalConfig(); + ~LocalConfig(); + bool init(bool onlyNodeId = false, + const char *connectString = 0, + const char *fileName = 0, + const char *defaultConnectString = 0); + + void add(MgmtSrvrId *i); + + void printError() const; + void printUsage() const; + + void setError(int lineNumber, const char * _msg); + bool readConnectString(const char * connectString, bool onlyNodeId = false); + bool readFile(const char * filename, bool &fopenError, bool onlyNodeId = false); + bool parseLine(char * line, int lineNumber); + + bool parseNodeId(const char *buf); + bool parseHostName(const char *buf); + bool parseFileName(const char *buf); + bool parseString(const char *buf, bool onlyNodeId, char *line); +}; + +#endif // LocalConfig_H + diff --git a/ndb/src/common/mgmcommon/Makefile b/ndb/src/common/mgmcommon/Makefile new file mode 100644 index 00000000000..2db7be01d60 --- /dev/null +++ b/ndb/src/common/mgmcommon/Makefile @@ -0,0 +1,26 @@ +include .defs.mk + +TYPE := ndbapi mgmapiclient + +PIC_ARCHIVE := Y +ARCHIVE_TARGET := mgmsrvcommon + +DIRS := printConfig + +SOURCES = \ + LocalConfig.cpp \ + Config.cpp \ + ConfigInfo.cpp \ + ConfigRetriever.cpp \ + InitConfigFileParser.cpp \ + IPCConfig.cpp + +SOURCES.c = NdbConfig.c + +include $(NDB_TOP)/Epilogue.mk + + + + + + diff --git a/ndb/src/common/mgmcommon/NdbConfig.c b/ndb/src/common/mgmcommon/NdbConfig.c new file mode 100644 index 00000000000..b12d9fcfaf9 --- /dev/null +++ b/ndb/src/common/mgmcommon/NdbConfig.c @@ -0,0 +1,61 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include + +const char* +NdbConfig_HomePath(char* buf, int buflen){ + const char* p; + p = NdbEnv_GetEnv("NDB_HOME", buf, buflen); + if (p == NULL){ + strlcpy(buf, "", buflen); + p = buf; + } else { + const int len = strlen(buf); + if(len != 0 && buf[len-1] != '/'){ + buf[len] = '/'; + buf[len+1] = 0; + } + } + return p; +} + +const char* +NdbConfig_NdbCfgName(char* buf, int buflen, int with_ndb_home){ + if (with_ndb_home) + NdbConfig_HomePath(buf, buflen); + else + buf[0] = 0; + strlcat(buf, "Ndb.cfg", buflen); + return buf; +} + +const char* +NdbConfig_ErrorFileName(char* buf, int buflen){ + NdbConfig_HomePath(buf, buflen); + strlcat(buf, "error.log", buflen); + return buf; +} + +const char* +NdbConfig_ClusterLogFileName(char* buf, int buflen){ + NdbConfig_HomePath(buf, buflen); + strlcat(buf, "cluster.log", buflen); + return buf; +} diff --git a/ndb/src/common/mgmcommon/printConfig/Makefile b/ndb/src/common/mgmcommon/printConfig/Makefile new file mode 100644 index 00000000000..9194316da87 --- /dev/null +++ b/ndb/src/common/mgmcommon/printConfig/Makefile @@ -0,0 +1,14 @@ +include .defs.mk + +TYPE := ndbapi mgmapiclient + +BIN_TARGET := printConfig +BIN_TARGET_ARCHIVES := general portlib + +CCFLAGS_LOC += -I.. + +SOURCES := printConfig.cpp + +SOURCES.c := ../ConfigRetriever.c ../NdbConfig.c ../LocalConfig.c + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/common/mgmcommon/printConfig/printConfig.cpp b/ndb/src/common/mgmcommon/printConfig/printConfig.cpp new file mode 100644 index 00000000000..7260a84ce7a --- /dev/null +++ b/ndb/src/common/mgmcommon/printConfig/printConfig.cpp @@ -0,0 +1,89 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include +#include +#include + +void usage(const char * prg){ + ndbout << "Usage " << prg + << " host []" << endl; + + char buf[255]; + for(unsigned i = 0; i []" + << endl; +} + +NDB_COMMAND(printConfig, + "printConfig", "printConfig", "Prints configuration", 16384){ + if(argc < 4){ + usage(argv[0]); + return 0; + } + if(strcmp("file", argv[1]) != 0 && strcmp("host", argv[1]) != 0){ + usage(argv[0]); + return 0; + } + + if(strcmp("host", argv[1]) == 0 && argc < 5){ + usage(argv[0]); + return 0; + } + + Properties * p = 0; + ConfigRetriever c; + + if(strcmp("host", argv[1]) == 0){ + int verId = 0; + if(argc > 5) + verId = atoi(argv[5]); + + ndbout << "Getting config from: " << argv[2] << ":" << atoi(argv[3]) + << " NodeId =" << atoi(argv[4]) + << " VersionId = " << verId << endl; + + p = c.getConfig(argv[2], + atoi(argv[3]), + atoi(argv[4]), + verId); + } else if (strcmp("file", argv[1]) == 0){ + int verId = 0; + if(argc > 4) + verId = atoi(argv[4]); + + ndbout << "Getting config from: " << argv[2] + << " NodeId =" << atoi(argv[3]) + << " VersionId = " << verId << endl; + + p = c.getConfig(argv[2], atoi(argv[3]), verId); + } + + if(p != 0){ + p->print(stdout); + } else { + ndbout << "Configuration not found: " << c.getErrorString() << endl; + } + + delete p; + + return 0; +} diff --git a/ndb/src/common/portlib/Makefile b/ndb/src/common/portlib/Makefile new file mode 100644 index 00000000000..a928fc1e6d7 --- /dev/null +++ b/ndb/src/common/portlib/Makefile @@ -0,0 +1,43 @@ +include .defs.mk + +DIRS := + +ifeq ($(NDB_OS), SOFTOSE) +DIRS += ose +endif + +ifeq ($(NDB_OS), OSE) +DIRS += ose +endif + +ifeq ($(NDB_OS), SIMCELLO) +DIRS += ose +endif + +ifeq ($(NDB_OS), LINUX) +DIRS += unix +endif + +ifeq ($(NDB_OS), MACOSX) +DIRS += unix +endif + +ifeq ($(NDB_OS), SOLARIS) +DIRS += unix +endif + +ifeq ($(NDB_OS), SOLARIS6) +DIRS += unix +endif + +ifeq ($(NDB_OS), HPUX) +DIRS += unix +endif + +ifeq ($(NDB_OS), WIN32) +DIRS += win32 +endif + + +include $(NDB_TOP)/Epilogue.mk + diff --git a/ndb/src/common/portlib/memtest/Makefile b/ndb/src/common/portlib/memtest/Makefile new file mode 100644 index 00000000000..716cdbdea82 --- /dev/null +++ b/ndb/src/common/portlib/memtest/Makefile @@ -0,0 +1,12 @@ +CC=gcc +LD=$(CC) +SOURCES=memtest.c +OUTPUT=memtest +all: + $(CC) $(SOURCES) -o $(OUTPUT) + +debug: + $(CC) -g $(SOURCES) -o $(OUTPUT) + +clean: rm -rf *.o + rm -rf core* diff --git a/ndb/src/common/portlib/memtest/memtest.c b/ndb/src/common/portlib/memtest/memtest.c new file mode 100644 index 00000000000..d23235b7aa2 --- /dev/null +++ b/ndb/src/common/portlib/memtest/memtest.c @@ -0,0 +1,245 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + +#include +#include +#include +#include +long long getMilli(); +long long getMicro(); +void malloctest(int loopcount, int memsize, int touch); +void freetest(int loopcount, int memsize); +void mmaptest(int loopcount, int memsize, int touch); +void unmaptest(int loopcount, int memsize); + + +main(int argc, char ** argv) +{ + + int loopcount; + int memsize; + if(argc < 4) { + printf("Usage: memtest X loopcount memsize(MB)\n"); + printf("where X = \n"); + printf("1 : malloc test \n"); + printf("2 : mmap test \n"); + printf("3 : malloc test + touch pages\n"); + printf("4 : mmap test + touch pages\n"); + printf("5 : malloc/free test \n"); + printf("6 : mmap/munmap test \n"); + printf("loopcount - number of loops\n"); + printf("memsize - memory segment size to allocate in MB.\n"); + exit(1); + } + + + loopcount = atoi(argv[2]); + memsize = atoi(argv[3]); + switch(atoi(argv[1])) { + case 1: malloctest(loopcount, memsize , 0 ); + break; + case 2: mmaptest(loopcount, memsize,0); + break; + case 3: malloctest(loopcount, memsize,1); + break; + case 4: mmaptest(loopcount, memsize,1); + break; + case 5: freetest(loopcount, memsize); + break; + case 6: unmaptest(loopcount, memsize); + break; + default: + break; + } +} + +long long getMilli() { + struct timeval tick_time; + gettimeofday(&tick_time, 0); + + return + ((long long)tick_time.tv_sec) * ((long long)1000) + + ((long long)tick_time.tv_usec) / ((long long)1000); +} + +long long getMicro(){ + struct timeval tick_time; + int res = gettimeofday(&tick_time, 0); + + long long secs = tick_time.tv_sec; + long long micros = tick_time.tv_usec; + + micros = secs*1000000+micros; + return micros; +} + +void malloctest(int loopcount, int memsize, int touch) { + long long start=0; + int total=0; + int i=0, j=0; + int size=memsize*1024*1024; //bytes; + float mean; + char * ptr =0; + + printf("Staring malloctest "); + if(touch) + printf("with touch\n"); + else + printf("\n"); + + start=getMicro(); + + for(i=0; i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +struct ThreadData +{ + char * mapAddr; + Uint32 mapSize; + Uint32 chunk; + Uint32 idx; + +}; + +long long getMilli(); +long long getMicro(); + + +void* mapSegment(void * arg); +void* unmapSegment(void * arg); + + +void* mapSegment(void * arg) { + + ThreadData * threadArgs; + long long start=0; + int total=0; + int id = *(int *)arg; + threadArgs = new ThreadData [1]; + Uint32 size=5*1024*1024; + struct NdbThread* unmapthread_var; + void *status = 0; + int run = 1; + int max=0, min =100000000, sum=0; + while(run < 1001) { + start=getMicro(); + char * ptr =(char*) mmap(0, + size, + PROT_READ|PROT_WRITE, + MAP_PRIVATE|MAP_ANONYMOUS, + 0, + 0); + + total=(int)(getMicro()-start); + + ndbout << "T" << id << ": mmap took : " << total << " microsecs. " + << " Run: " << run ; + ndbout_c(" mapped @ %p \n", ptr); + + if(total>max) + max = total; + if(totalmapSize; + Uint32 chunk = threadData->chunk; + mapAddr = threadData->mapAddr; + + + + freeAddr = mapAddr+mapSize-chunk; + NdbSleep_MilliSleep(100); + for(Uint32 i=0;i +#include + +#include +#include +#include +#include +#include +#include + +/** + * NOTE: To use NdbMem from a OSE system ose_mms has to be defined + * as a "Required External Process"(see OSE Kernel User's Guide/R1.1(p. 148)), + * like this: + * EXT_PROC(ose_mms, ose_mms, 50000) + * This will create a global variable ose_mms_ that is used from here. + */ + +union SIGNAL +{ + SIGSELECT sigNo; + struct MmsListDomainRequest mmsListDomainRequest; + struct MmsListDomainReply mmsListDomainReply; +}; /* union SIGNAL */ + +extern PROCESS ose_mms_; + +struct ARegion +{ + unsigned long int address; + unsigned long int size; + char name[32]; + + U32 resident; /* Boolean, nonzero if resident. */ + U32 access; /* See values for AccessType (above) .*/ + U32 type; /* either RAM-mem (1) or Io-mem (2) */ + U32 cache; /* 0-copyback,1-writethrough, 2-CacheInhibit.*/ +}; + +NDB_COMMAND(mmslist, "mmslist", "mmslist", "LIst the MMS memory segments", 4096){ + if (argc == 1){ + + static SIGSELECT allocate_sig[] = {1,MMS_LIST_DOMAIN_REPLY}; + union SIGNAL *sig; + + /* Send request to list all segments and regions. */ + sig = alloc(sizeof(struct MmsListDomainRequest), + MMS_LIST_DOMAIN_REQUEST); + send(&sig, ose_mms_); + + while (true){ + sig = receive(allocate_sig); + if (sig != NIL){ + if (sig->mmsListDomainReply.status == MMS_SUCCESS){ + /* Print domain info */ + ndbout << "=================================" << endl; + ndbout << "domain: " << sig->mmsListDomainReply.domain << endl; + ndbout << "name : " << sig->mmsListDomainReply.name << endl; + ndbout << "used : " << sig->mmsListDomainReply.used << endl; + ndbout << "lock : " << sig->mmsListDomainReply.lock << endl; + ndbout << "numOfRegions:" << sig->mmsListDomainReply.numOfRegions << endl; + struct ARegion * tmp = (struct ARegion*)&sig->mmsListDomainReply.regions[0]; + for (int i = 0; i < sig->mmsListDomainReply.numOfRegions && i < 256; i++){ + ndbout << i << ": adress=" << tmp->address << + ", size=" << tmp->size << + ", name=" << tmp->name << + ", resident=" << tmp->resident << + ", access=" << tmp->access << + ", type=" << tmp->type << + ", cache=" << tmp->cache << endl; + tmp++; + } + + free_buf(&sig); + }else{ + free_buf(&sig); + break; + } + } + + } + + }else{ + ndbout << "Usage: mmslist" << endl; + } + return NULL; +} diff --git a/ndb/src/common/portlib/mmstest/mmstest.cpp b/ndb/src/common/portlib/mmstest/mmstest.cpp new file mode 100644 index 00000000000..6ebb5064aaf --- /dev/null +++ b/ndb/src/common/portlib/mmstest/mmstest.cpp @@ -0,0 +1,76 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "NdbThread.h" +#include +#include + +#include + +NDB_COMMAND(ndbmem, "ndbmem", "ndbmem", "Test the ndbmem functionality", 4096){ + + ndbout << "Starting test of NdbMem" << endl; + ndbout << "=======================" << endl; + + ndbout << "Creating NdbMem" << endl; + NdbMem_Create(); + + + ndbout << "NdbMem - test 1" << endl; + if (argc == 2){ + int size1 = atoi(argv[1]); + ndbout << "Allocate and test "<"<< endl; + } + + return NULL; + +} + + + diff --git a/ndb/src/common/portlib/ose/Makefile b/ndb/src/common/portlib/ose/Makefile new file mode 100644 index 00000000000..4ef93b7824a --- /dev/null +++ b/ndb/src/common/portlib/ose/Makefile @@ -0,0 +1,31 @@ +include .defs.mk + +TYPE := + +PIC_ARCHIVE := Y +ARCHIVE_TARGET := portlib + +SOURCES = NdbOut.cpp + +SOURCES.c = NdbCondition.c \ + NdbMutex.c \ + NdbSleep.c \ + NdbTick.c \ + NdbEnv.c \ + NdbThread.c \ + NdbHost.c \ + NdbTCP.c + +ifeq ($(NDB_OS), SOFTOSE) + SOURCES += NdbMem_SoftOse.cpp +else + SOURCES.c += NdbMem.c +endif + +include $(NDB_TOP)/Epilogue.mk + + + + + + diff --git a/ndb/src/common/portlib/ose/NdbCondition.c b/ndb/src/common/portlib/ose/NdbCondition.c new file mode 100644 index 00000000000..2ab6e49006b --- /dev/null +++ b/ndb/src/common/portlib/ose/NdbCondition.c @@ -0,0 +1,244 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbCondition.h" +#include +#include +#include +#include + +#include + +#include "NdbConditionOSE.h" +struct NdbCondition +{ + PROCESS condserv_pid; +}; + + +OS_PROCESS(ndbcond_serv){ + + union SIGNAL* sig; + union SIGNAL* sig2; + + static const SIGSELECT sel_signal[] = {2, NDBCOND_SIGNAL, NDBCOND_BROADCAST}; + static const SIGSELECT sel_cond[] = {2, NDBCOND_WAIT, NDBCOND_WAITTIMEOUT}; + + for(;;){ + /* Receive condition wait signal */ + sig = receive((SIGSELECT*)sel_cond); + if (sig != NIL){ + switch (sig->sigNo){ + + case NDBCOND_WAIT: + /* Wait for a SIGNAL or BROADCAST from anyone */ + sig2 = receive((SIGSELECT*)sel_signal); + if (sig2 != NIL){ + switch(sig2->sigNo){ + + case NDBCOND_SIGNAL: + ((struct NdbCondWait*)sig)->status = NDBCOND_SIGNALED; + /* Send signal back to the one waiting for this condition */ + send(&sig, sender(&sig)); + break; + case NDBCOND_BROADCAST: + /* Not handled yet */ + assert(1==0); + break; + default: + assert(1==0); + break; + } + free_buf(&sig2); + } + break; + + case NDBCOND_WAITTIMEOUT: + /* Wait for a SIGNAL or BROADCAST from anyone */ + sig2 = receive_w_tmo(((struct NdbCondWaitTimeout*)sig)->timeout, (SIGSELECT*)sel_signal); + if (sig2 != NIL){ + switch(sig2->sigNo){ + + case NDBCOND_SIGNAL: + ((struct NdbCondWaitTimeout*)sig)->status = NDBCOND_SIGNALED; + /* Send signal back to the one waiting for this condition */ + send(&sig, sender(&sig)); + break; + case NDBCOND_BROADCAST: + /* Not handled yet */ + assert(1==0); + break; + default: + assert(1==0); + break; + } + free_buf(&sig2); + }else{ + ((struct NdbCondWaitTimeout*)sig)->status = NDBCOND_TIMEOUT; + send(&sig, sender(&sig)); + } + break; + + default: + assert(1==0); + break; + + } + } + + } +} + + +struct NdbCondition* +NdbCondition_Create(void) +{ + struct NdbCondition* tmpCond; + + + tmpCond = (struct NdbCondition*)malloc(sizeof(struct NdbCondition)); + + if (tmpCond == NULL) + return NULL; + + /** + * Start this process with a quite high + * priority, we want it to be responsive + */ + tmpCond->condserv_pid = create_process(OS_PRI_PROC, /* Process type */ + "ndbcond_serv", /* Name */ + ndbcond_serv, /* Entry point */ + 2048, /* Stack size */ + 10, /* Priority */ + 0, /* Time slice */ + get_bid(current_process()), /* Block */ + NULL, /* Redir table */ + 0, + 0); + + start(tmpCond->condserv_pid); + + return tmpCond; +} + + +int +NdbCondition_Wait(struct NdbCondition* p_cond, + NdbMutex* p_mutex) +{ + static const SIGSELECT sel_cond[] = {1, NDBCOND_WAIT}; + union SIGNAL* sig; + int result; + if (p_cond == NULL || p_mutex == NULL) + return 0; + + sig = alloc(sizeof(struct NdbCondWait), NDBCOND_WAIT); + send(&sig, p_cond->condserv_pid); + + NdbMutex_Unlock(p_mutex); + + result = 1; + while(NIL == (sig = receive_from((OSTIME)-1, (SIGSELECT*)sel_cond, p_cond->condserv_pid))); + if (sig != NIL){ + if (sig->sigNo == NDBCOND_WAIT){ + /* Condition is signaled */ + result = 0; + }else{ + assert(1==0); + } + free_buf(&sig); + + } + NdbMutex_Lock(p_mutex); + + return result; +} + + +int +NdbCondition_WaitTimeout(struct NdbCondition* p_cond, + NdbMutex* p_mutex, + int msecs){ + static const SIGSELECT sel_cond[] = {1, NDBCOND_WAITTIMEOUT}; + union SIGNAL* sig; + int result; + if (p_cond == NULL || p_mutex == NULL) + return 0; + + sig = alloc(sizeof(struct NdbCondWaitTimeout), NDBCOND_WAITTIMEOUT); + ((struct NdbCondWaitTimeout*)sig)->timeout = msecs; + send(&sig, p_cond->condserv_pid); + + NdbMutex_Unlock(p_mutex); + + result = 1; + while(NIL == (sig = receive_from((OSTIME)-1, (SIGSELECT*)sel_cond, p_cond->condserv_pid))); + if (sig != NIL){ + if (sig->sigNo == NDBCOND_WAITTIMEOUT){ + /* Condition is signaled */ + result = 0; + }else{ + assert(1==0); + } + free_buf(&sig); + + } + + NdbMutex_Lock(p_mutex); + + return result; +} + + +int +NdbCondition_Signal(struct NdbCondition* p_cond){ + + union SIGNAL* sig; + if (p_cond == NULL) + return 1; + + sig = alloc(sizeof(struct NdbCondSignal), NDBCOND_SIGNAL); + send(&sig, p_cond->condserv_pid); + + return 0; +} + + +int NdbCondition_Broadcast(struct NdbCondition* p_cond) +{ + union SIGNAL* sig; + if (p_cond == NULL) + return 1; + + sig = alloc(sizeof(struct NdbCondBroadcast), NDBCOND_BROADCAST); + send(&sig, p_cond->condserv_pid); + + return 0; +} + + +int NdbCondition_Destroy(struct NdbCondition* p_cond) +{ + if (p_cond == NULL) + return 1; + + kill_proc(p_cond->condserv_pid); + free(p_cond); + + return 0; +} + diff --git a/ndb/src/common/portlib/ose/NdbConditionOSE.h b/ndb/src/common/portlib/ose/NdbConditionOSE.h new file mode 100644 index 00000000000..bd0306261cc --- /dev/null +++ b/ndb/src/common/portlib/ose/NdbConditionOSE.h @@ -0,0 +1,103 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDB_CONDITIONOSE_H +#define NDB_CONDITIONOSE_H + + +#ifdef __cplusplus +extern "C" { +#endif + + +#define NDBCOND_SIGBASE 4000 + +#define NDBCOND_WAIT (NDBCOND_SIGBASE + 1) /* !-SIGNO(struct NdbCondWait)-! */ +#define NDBCOND_WAITTIMEOUT (NDBCOND_SIGBASE + 2) /* !-SIGNO(struct NdbCondWaitTimeOut)-! */ +#define NDBCOND_SIGNAL (NDBCOND_SIGBASE + 3) /* !-SIGNO(struct NdbCondSignal)-! */ +#define NDBCOND_BROADCAST (NDBCOND_SIGBASE + 4) /* !-SIGNO(struct NdbCondBroadcast)-! */ + + +const char * +sigNo2String(SIGSELECT sigNo){ + switch(sigNo){ + case NDBCOND_WAIT: + return "NDBCOND_WAIT"; + break; + case NDBCOND_WAITTIMEOUT: + return "NDBCOND_WAITTIMEOUT"; + break; + case NDBCOND_SIGNAL: + return "NDBCOND_SIGNAL"; + break; + case NDBCOND_BROADCAST: + return "NDBCOND_BROADCAST"; + break; + } + return "UNKNOWN"; +} + +struct NdbCondWait +{ + SIGSELECT sigNo; + int status; +}; + +/** + * Signal received + */ +#define NDBCOND_SIGNALED 1 + +/** + * Timeout occured + */ +#define NDBCOND_TIMEOUT 2 + +struct NdbCondWaitTimeout +{ + SIGSELECT sigNo; + int timeout; + int status; + +}; + +struct NdbCondSignal +{ + SIGSELECT sigNo; +}; + +struct NdbCondBroadcast +{ + SIGSELECT sigNo; +}; + + +union SIGNAL +{ + SIGSELECT sigNo; + struct NdbCondWait condWait; + struct NdbCondWaitTimeout condWaitTimeout; + struct NdbCondSignal condSignal; + struct NdbCondBroadcast condBroadcast; +}; + + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/ndb/src/common/portlib/ose/NdbEnv.c b/ndb/src/common/portlib/ose/NdbEnv.c new file mode 100644 index 00000000000..e2ac4d879d2 --- /dev/null +++ b/ndb/src/common/portlib/ose/NdbEnv.c @@ -0,0 +1,55 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbEnv.h" +#include +#include + +const char* NdbEnv_GetEnv(const char* name, char * buf, int buflen) +{ + /** + * All environment variables are associated with a process + * it's important to read env from the correct process + * for now read from own process, own block and last the "ose_shell" process. + * + * TODO! What process should this be read from in the future? + * + */ + PROCESS proc_; + char* p = NULL; + /* Look in own process */ + p = get_env(current_process(), (char*)name); + if (p == NULL){ + /* Look in block process */ + p = get_env(get_bid(current_process()), (char*)name); + if (p == NULL){ + /* Look in ose_shell process */ + if (hunt("ose_shell", 0, &proc_, NULL)){ + p = get_env(proc_, (char*)name); + } + } + } + + if (p != NULL){ + strncpy(buf, p, buflen); + buf[buflen-1] = 0; + free_buf((union SIGNAL **)&p); + p = buf; + } + return p; +} + diff --git a/ndb/src/common/portlib/ose/NdbHost.c b/ndb/src/common/portlib/ose/NdbHost.c new file mode 100644 index 00000000000..f5e1e511c16 --- /dev/null +++ b/ndb/src/common/portlib/ose/NdbHost.c @@ -0,0 +1,55 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbHost.h" +#include + + +#include +#include + +union SIGNAL +{ + SIGSELECT sigNo; + struct InetIfUp inetIfUp; +}; + +int NdbHost_GetHostName(char* buf) +{ +#if 0 + extern PROCESS ose_inet_; + union SIGNAL *signal; + static const SIGSELECT select_if_up_reply[] = { 1, INET_IF_UP_REPLY }; + + signal = alloc(sizeof(struct InetIfUp), INET_IF_UP_REQUEST); + strcpy(signal->inetIfUp.ifName, "*"); + send((union SIGNAL **)&signal, ose_inet_); + signal = receive((SIGSELECT *)select_if_up_reply); + strcpy(buf, signal->inetIfUp.ifName); + free_buf(&signal); + return 0; +#else + return -1; +#endif +} + + +int NdbHost_GetProcessId(void) +{ + return current_process(); +} + diff --git a/ndb/src/common/portlib/ose/NdbMem.c b/ndb/src/common/portlib/ose/NdbMem.c new file mode 100644 index 00000000000..6d922e4c073 --- /dev/null +++ b/ndb/src/common/portlib/ose/NdbMem.c @@ -0,0 +1,183 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbMem.h" + +#include + +#if defined NDB_OSE +#include +#include +#include +#include +#include +#include + +// Page size for mp750 is 4096 bytes. +#define PAGE_SIZE 4096 + +/** + * NOTE: To use NdbMem from a OSE system ose_mms has to be defined + * as a "Required External Process"(see OSE Kernel User's Guide/R1.1(p. 148)), + * like this in osemain.con: + * EXT_PROC(ose_mms, ose_mms, 50000) + * This will create a global variable ose_mms_ that is used from here. + */ + +union SIGNAL +{ + SIGSELECT sigNo; + struct MmsAllocateRegionRequest mmsAllocateRegionRequest; + struct MmsAllocateRegionReply mmsAllocateRegionReply; + struct MmsFreeRegionRequest mmsFreeRegionRequest; + struct MmsFreeRegionReply mmsFreeRegionReply; +}; /* union SIGNAL */ + +extern PROCESS ose_mms_; + +void NdbMem_Create(void) +{ + /* Do nothing */ + return; +} + +void NdbMem_Destroy(void) +{ + /* Do nothing */ + return; +} + +void* NdbMem_Allocate(size_t size) +{ + static SIGSELECT allocate_sig[] = {1,MMS_ALLOCATE_REGION_REPLY}; + union SIGNAL *sig; + U32 allocatedAdress; + + assert(size > 0); + + // Only allowed to allocate multiples of the page size. + if(size % PAGE_SIZE != 0) { + size += PAGE_SIZE - size%PAGE_SIZE; + } + + /* Allocate a new region in the callers memory segment. */ + sig = alloc(sizeof(struct MmsAllocateRegionRequest), + MMS_ALLOCATE_REGION_REQUEST); + /* -1: The callers domain is used */ + sig->mmsAllocateRegionRequest.domain = (MemoryDomain)-1; + sig->mmsAllocateRegionRequest.useAddr = False; + sig->mmsAllocateRegionRequest.size = size; + sig->mmsAllocateRegionRequest.access = SuperRW_UserRW; + sig->mmsAllocateRegionRequest.resident = False; + sig->mmsAllocateRegionRequest.memory = CodeData; + sig->mmsAllocateRegionRequest.cache = CopyBack; + strcpy(sig->mmsAllocateRegionRequest.name, "NDB_DATA"); + send(&sig, ose_mms_); + sig = receive(allocate_sig); + + if (sig->mmsAllocateRegionReply.status != MMS_SUCCESS){ + /* Memory allocation failed, make sure this function returns NULL */ + allocatedAdress = NULL; + } + else{ + allocatedAdress = sig->mmsAllocateRegionReply.address; + } + free_buf(&sig); + return (void*)allocatedAdress; +} + +void* NdbMem_AllocateAlign(size_t size, size_t alignment) +{ + return NdbMem_Allocate(size); +} + + +void NdbMem_Free(void* ptr) +{ + static SIGSELECT free_sig[] = {1,MMS_FREE_REGION_REPLY}; + union SIGNAL *sig; + + /* Free a region in the callers domain. */ + sig = alloc(sizeof(struct MmsFreeRegionRequest), + MMS_FREE_REGION_REQUEST); + sig->mmsFreeRegionRequest.address = (U32)ptr; + send(&sig, ose_mms_); + sig = receive(free_sig); + + if (sig->mmsFreeRegionReply.status != MMS_SUCCESS){ + ndbout_c("The MMS Region could not be deallocated.\r\n"); + error(sig->mmsFreeRegionReply.status); + }; + free_buf(&sig); +} + +int NdbMem_MemLockAll(){ + return -1; +} + +int NdbMem_MemUnlockAll(){ + return -1; +} + +#else +#include +#include + + +void NdbMem_Create() +{ + /* Do nothing */ + return; +} + +void NdbMem_Destroy() +{ + /* Do nothing */ + return; +} + +void* NdbMem_Allocate(size_t size) +{ + assert(size > 0); + return (void*)malloc(size); +} + +void* NdbMem_AllocateAlign(size_t size, size_t alignment) +{ + /* + return (void*)memalign(alignment, size); + TEMP fix + */ + return (void*)malloc(size); +} + + +void NdbMem_Free(void* ptr) +{ + free(ptr); +} + + +int NdbMem_MemLockAll(){ + return -1; +} + +int NdbMem_MemUnlockAll(){ + return -1; +} + +#endif diff --git a/ndb/src/common/portlib/ose/NdbMem_SoftOse.cpp b/ndb/src/common/portlib/ose/NdbMem_SoftOse.cpp new file mode 100644 index 00000000000..cad22c0474b --- /dev/null +++ b/ndb/src/common/portlib/ose/NdbMem_SoftOse.cpp @@ -0,0 +1,53 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "NdbMem.h" + +extern "C" +void NdbMem_Create() +{ +} +extern "C" +void NdbMem_Destroy() +{ +} + +extern "C" +void* NdbMem_Allocate(size_t size) +{ + return new char[size]; +} + +extern "C" +void* NdbMem_AllocateAlign(size_t size, size_t alignment) +{ + return NdbMem_Allocate(size); +} + +extern "C" +void NdbMem_Free(void* ptr) +{ + delete [] (char *)(ptr); +} + +int NdbMem_MemLockAll(){ + return -1; +} + +int NdbMem_MemUnlockAll(){ + return -1; +} + diff --git a/ndb/src/common/portlib/ose/NdbMutex.c b/ndb/src/common/portlib/ose/NdbMutex.c new file mode 100644 index 00000000000..859ddefd536 --- /dev/null +++ b/ndb/src/common/portlib/ose/NdbMutex.c @@ -0,0 +1,86 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbMutex.h" + +#include +#include +#include + + +NdbMutex* NdbMutex_Create(void) +{ + NdbMutex* pNdbMutex; + + pNdbMutex = create_sem(1); + + return pNdbMutex; +} + + +int NdbMutex_Destroy(NdbMutex* p_mutex) +{ + + if (p_mutex == NULL) + return -1; + + kill_sem(p_mutex); + + return 0; + +} + + +int NdbMutex_Lock(NdbMutex* p_mutex) +{ + if (p_mutex == NULL) + return -1; + + wait_sem(p_mutex); + + return 0; +} + + +int NdbMutex_Unlock(NdbMutex* p_mutex) +{ + + if (p_mutex == NULL) + return -1; + + signal_sem(p_mutex); + + return 0; +} + + +int NdbMutex_Trylock(NdbMutex* p_mutex) +{ + int result = -1; + + if (p_mutex != NULL) { + OSSEMVAL semvalue = get_sem(p_mutex); + if (semvalue > 0) { + wait_sem(p_mutex); + result = 0; + } + } + + return result; + +} + diff --git a/ndb/src/common/portlib/ose/NdbOut.cpp b/ndb/src/common/portlib/ose/NdbOut.cpp new file mode 100644 index 00000000000..0ee12249ff5 --- /dev/null +++ b/ndb/src/common/portlib/ose/NdbOut.cpp @@ -0,0 +1,99 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "NdbOut.hpp" +#include +#include +#include +#include + + +#if defined NDB_SOFTOSE +#include +#define printfunc dbgprintf +#else +#define printfunc printf +#endif + +static char const* const endlineString = "\r\n"; + +static int CtrlC = 0; +NdbOut ndbout; + + +NdbOut& NdbOut::operator<<(int aVal) +{ + char* format; + char HexFormat[] = "0x%08x"; + char DecFormat[] = "%d"; + if (isHexFormat == 1) + format = HexFormat; + else + format = DecFormat; + + printfunc(format, aVal); + return *this; +} + +NdbOut& NdbOut::operator<<(char* pVal) +{ + printfunc("%s", pVal); + return *this; +} + +NdbOut& NdbOut::endline() +{ + isHexFormat = 0; // Reset hex to normal, if user forgot this + printfunc(endlineString); + return *this; +} + +NdbOut& NdbOut::flushline() +{ + isHexFormat = 0; // Reset hex to normal, if user forgot this + return *this; +} + +NdbOut& NdbOut::setHexFormat(int _format) +{ + isHexFormat = _format; + return *this; +} + +NdbOut::NdbOut() +{ + CtrlC = 0; + isHexFormat = 0; +} + +NdbOut::~NdbOut() +{ +} + + + +extern "C" +void +ndbout_c(const char * fmt, ...){ + va_list ap; + char buf[1000]; + + va_start(ap, fmt); + if (fmt != 0) + vsnprintf(buf, sizeof(buf)-1, fmt, ap); + ndbout << buf << endl; + va_end(ap); +} diff --git a/ndb/src/common/portlib/ose/NdbSleep.c b/ndb/src/common/portlib/ose/NdbSleep.c new file mode 100644 index 00000000000..70fd83117ef --- /dev/null +++ b/ndb/src/common/portlib/ose/NdbSleep.c @@ -0,0 +1,36 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbSleep.h" + +#include + + +int +NdbSleep_MilliSleep(int milliseconds){ + const OSTIME millisecond_delay = milliseconds; + delay(millisecond_delay); + return 0; +} + +int +NdbSleep_SecSleep(int seconds){ + const OSTIME millisecond_delay = seconds*1000; + delay(millisecond_delay); + return 0; +} + diff --git a/ndb/src/common/portlib/ose/NdbTCP.c b/ndb/src/common/portlib/ose/NdbTCP.c new file mode 100644 index 00000000000..9994697b3f8 --- /dev/null +++ b/ndb/src/common/portlib/ose/NdbTCP.c @@ -0,0 +1,38 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbTCP.h" + + +int +Ndb_getInAddr(struct in_addr * dst, const char *address) { + struct hostent * host; + host = gethostbyname_r(address); + if(host != 0){ + dst->s_addr = ((struct in_addr *) *host->h_addr_list)->s_addr; + free_buf((union SIGNAL **)&host); + return 0; + } + /* Try it as aaa.bbb.ccc.ddd. */ + dst->s_addr = inet_addr(address); + if (dst->s_addr != INADDR_NONE) { + return 0; + } + return -1; +} + + diff --git a/ndb/src/common/portlib/ose/NdbThread.c b/ndb/src/common/portlib/ose/NdbThread.c new file mode 100644 index 00000000000..41a5f181c40 --- /dev/null +++ b/ndb/src/common/portlib/ose/NdbThread.c @@ -0,0 +1,184 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbThread.h" +#include +#include +#include +#include +#include + +#define MAX_THREAD_NAME 16 + + +struct NdbThread +{ + PROCESS pid; + char thread_name[MAX_THREAD_NAME]; +}; + +#define NDBTHREAD_SIGBASE 4010 + +#define NDBTHREAD_START (NDBTHREAD_SIGBASE + 1) /* !-SIGNO(struct NdbThreadStart)-! */ + +struct NdbThreadStart +{ + SIGSELECT sigNo; + NDB_THREAD_FUNC* func; + NDB_THREAD_ARG arg; +}; + +struct NdbThreadStopped +{ + SIGSELECT sigNo; +}; + +union SIGNAL +{ + SIGSELECT sigNo; + struct NdbThreadStart threadStart; + struct NdbThreadStopped threadStopped; +}; + +OS_PROCESS(thread_starter){ + static const SIGSELECT sel_start[] = {1, NDBTHREAD_START}; + struct NdbThreadStart* sigstart; + union SIGNAL* sig; + + /* Receive function adress and params */ + sig = receive((SIGSELECT*)sel_start); + if (sig != NIL){ + if (sig->sigNo == NDBTHREAD_START){ + sigstart = ((struct NdbThreadStart*)sig); + /* Execute function with arg */ + (*sigstart->func)(sigstart->arg); + }else{ + assert(1==0); + } + free_buf(&sig); + } +} + +struct NdbThread* NdbThread_Create(NDB_THREAD_FUNC* p_thread_func, + NDB_THREAD_ARG *p_thread_arg, + const NDB_THREAD_STACKSIZE thread_stack_size, + const char* p_thread_name, + NDB_THREAD_PRIO thread_prio) +{ + struct NdbThread* tmpThread; + union SIGNAL* sig; + int ose_prio; + + if (p_thread_func == NULL) + return 0; + + tmpThread = (struct NdbThread*)malloc(sizeof(struct NdbThread)); + if (tmpThread == NULL) + return NULL; + + strncpy((char*)&tmpThread->thread_name, p_thread_name, MAX_THREAD_NAME); + + switch(thread_prio){ + case NDB_THREAD_PRIO_HIGHEST: + ose_prio = 1; + break; + case NDB_THREAD_PRIO_HIGH: + ose_prio = 10; + break; + case NDB_THREAD_PRIO_MEAN: + ose_prio = 16; + break; + case NDB_THREAD_PRIO_LOW: + ose_prio = 23; + break; + case NDB_THREAD_PRIO_LOWEST: + ose_prio = 31; + break; + default: + return NULL; + break; + } + + /* Create process */ + tmpThread->pid = create_process(OS_PRI_PROC, /* Process type */ + (char*)p_thread_name, /* Name */ + thread_starter, /* Entry point */ + thread_stack_size, /* Stack size */ + ose_prio, /* Priority */ + 0, /* Time slice */ + get_bid(current_process()), /* Block */ + NULL, /* Redir table */ + 0, + 0); + + /* Send params to process */ + sig = alloc(sizeof(struct NdbThreadStart), NDBTHREAD_START); + ((struct NdbThreadStart*)sig)->func = p_thread_func; + ((struct NdbThreadStart*)sig)->arg = p_thread_arg; + send(&sig, tmpThread->pid); + + /* Enable NDB_HOME environment variable for the thread */ + { + /* Hardcoded NDB_HOME...*/ + char* ndb_home_env = get_env(current_process(), "NDB_HOME"); + if (ndb_home_env != NULL) + { + /* Set NDB_HOME */ + int rc = set_env(tmpThread->pid, "NDB_HOME", ndb_home_env); + if (rc != 0) + { + /* Not really a problem */ + } + } /* Enable NDB_HOME */ + } + + /* Start process */ + start(tmpThread->pid); + + return tmpThread; +} + + + +void NdbThread_Destroy(struct NdbThread** p_thread) +{ + free(* p_thread); * p_thread = 0; +} + + +int NdbThread_WaitFor(struct NdbThread* p_wait_thread, void** status) +{ + while(hunt(p_wait_thread->thread_name, 0, NULL, NULL) != 0) + delay(1000); + + * status = 0; + + return 0; +} + + +void NdbThread_Exit(int a) +{ + kill_proc(current_process()); +} + + +int NdbThread_SetConcurrencyLevel(int level) +{ + return 0; +} + diff --git a/ndb/src/common/portlib/ose/NdbTick.c b/ndb/src/common/portlib/ose/NdbTick.c new file mode 100644 index 00000000000..c3deae2bec3 --- /dev/null +++ b/ndb/src/common/portlib/ose/NdbTick.c @@ -0,0 +1,64 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbTick.h" +#include + +#define NANOSEC_PER_SEC 1000000000 +#define MICROSEC_PER_SEC 1000000 +#define MILLISEC_PER_SEC 1000 +#define MICROSEC_PER_MILLISEC 1000 +#define MILLISEC_PER_NANOSEC 1000000 + +#ifdef NDB_OSE +NDB_TICKS NdbTick_CurrentMillisecond(void) +{ + return get_ticks()*4; +} +#include +int +NdbTick_CurrentMicrosecond(NDB_TICKS * secs, Uint32 * micros){ + struct TimePair tvp; + rtc_get_time(&tvp); + * secs = tvp.seconds; + * micros = tvp.micros; + return 0; +} + +#endif + +#if defined NDB_SOFTOSE +NDB_TICKS NdbTick_CurrentMillisecond(void) +{ + /** + * Depends on the interval counter in solaris + * that means each "tick" in OSE is really 10 milliseconds + */ + return get_ticks()*10; +} + +#include +int +NdbTick_CurrentMicrosecond(NDB_TICKS * secs, Uint32 * micros){ + struct TimePair tvp; + rtc_get_time(&tvp); + * secs = tvp.seconds; + * micros = tvp.micros; + return 0; +} +#endif + diff --git a/ndb/src/common/portlib/test/Makefile b/ndb/src/common/portlib/test/Makefile new file mode 100644 index 00000000000..4edc98ede75 --- /dev/null +++ b/ndb/src/common/portlib/test/Makefile @@ -0,0 +1,15 @@ +include .defs.mk + +TYPE := kernel + +BIN_TARGET := PortLibTest +BIN_TARGET_ARCHIVES := portlib general + +SOURCES = NdbPortLibTest.cpp + +include $(NDB_TOP)/Epilogue.mk + + + + + diff --git a/ndb/src/common/portlib/test/NdbPortLibTest.cpp b/ndb/src/common/portlib/test/NdbPortLibTest.cpp new file mode 100644 index 00000000000..8a5c8f4a878 --- /dev/null +++ b/ndb/src/common/portlib/test/NdbPortLibTest.cpp @@ -0,0 +1,621 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/** + * NdbPortLibTest.cpp + * Test the functionality of portlib + * TODO - Add tests for NdbMem + */ + + + +#include "NdbOut.hpp" +#include "NdbThread.h" +#include "NdbMutex.h" +#include "NdbCondition.h" +#include "NdbSleep.h" +#include "NdbTick.h" +#include "NdbEnv.h" +#include "NdbHost.h" +#include "NdbMain.h" + +#include +#include +#include +#include + +int TestHasFailed; +int verbose = 0; + +static void fail(const char* test, const char* cause) +{ + TestHasFailed = 1; + ndbout << test << " failed, " << cause << endl; +} + +// test 1 variables and funcs + +extern "C" void* thread1func(void* arg) +{ + int arg1; + int returnvalue = 8; + arg1 = *(int*)arg; + ndbout << "thread1: thread1func called with arg = " << arg1 << endl; + + // delay(1000); + if (arg1 != 7) + fail("TEST1", "Wrong arg"); + + NdbThread_Exit(returnvalue); + + return NULL; + +} + +// test 2 variables and funcs + +NdbMutex* test2mutex; + +extern "C" void* test2func(void* arg) +{ + + int arg1; + arg1 = *(int*)arg; + ndbout << "thread" << arg1 << " started in test2func" << endl; + + if (NdbMutex_Lock(test2mutex) != 0) + fail("TEST2", "Failed to lock mutex"); + + ndbout << "thread" << arg1 << ", test2func " << endl; + + if (NdbMutex_Unlock(test2mutex) != 0) + fail("TEST2", "Failed to unlock mutex"); + + int returnvalue = arg1; + NdbThread_Exit(returnvalue); + + return NULL; + +} + + +// test 3 and 7 variables and funcs + +NdbMutex* testmutex; +NdbCondition* testcond; +int testthreadsdone; + +extern "C" void* testfunc(void* arg) +{ + int tmpVar; + int threadno; + int result; + + threadno = *(int*)arg; + + ndbout << "Thread" << threadno << " started in testfunc" << endl; + do + { + + if ((threadno % 2) == 0) + result = NdbSleep_SecSleep(1); + else + result = NdbSleep_MilliSleep(100); + + if (result != 0) + fail("TEST3", "Wrong result from sleep function"); + + if (NdbMutex_Lock(testmutex) != 0) + fail("TEST3", "Wrong result from NdbMutex_Lock function"); + + ndbout << "thread" << threadno << ", testfunc " << endl; + testthreadsdone++; + tmpVar = testthreadsdone; + + if (NdbCondition_Signal(testcond) != 0) + fail("TEST3", "Wrong result from NdbCondition_Signal function"); + + if (NdbMutex_Unlock(testmutex) != 0) + fail("TEST3", "Wrong result from NdbMutex_Unlock function"); + + } + while(tmpVar<100); + + NdbThread_Exit(0); + return NULL; +} + +extern "C" void* testTryLockfunc(void* arg) +{ + int tmpVar = 0; + int threadno; + int result; + + threadno = *(int*)arg; + + ndbout << "Thread" << threadno << " started" << endl; + do + { + + if ((threadno % 2) == 0) + result = NdbSleep_SecSleep(1); + else + result = NdbSleep_MilliSleep(100); + + if (result != 0) + fail("TEST3", "Wrong result from sleep function"); + + if (NdbMutex_Trylock(testmutex) == 0){ + + ndbout << "thread" << threadno << ", testTryLockfunc locked" << endl; + testthreadsdone++; + tmpVar = testthreadsdone; + + if (NdbCondition_Signal(testcond) != 0) + fail("TEST3", "Wrong result from NdbCondition_Signal function"); + + if (NdbMutex_Unlock(testmutex) != 0) + fail("TEST3", "Wrong result from NdbMutex_Unlock function"); + } + + } + while(tmpVar<100); + + NdbThread_Exit(0); + return NULL; +} + + + +void testMicros(int count); +Uint64 time_diff(Uint64 s1, Uint64 s2, Uint32 m1, Uint32 m2); + +NDB_COMMAND(PortLibTest, "portlibtest", "portlibtest", "Test the portable function layer", 4096){ + + ndbout << "= TESTING ARGUMENT PASSING ============" << endl; + ndbout << "ARGC: " << argc << endl; + for(int i = 1; i < argc; i++){ + ndbout << " ARGV"<= m1) + diff += (m2 - m1); + else { + diff += m2; + diff -= m1; + } + + // if(0) + // ndbout("(s1,m1) = (%d, %d) (s2,m2) = (%d, %d) -> diff = %d\n", + // (Uint32)s1,m1,(Uint32)s2,m2, (Uint32)diff); + + return diff; +}; + +void +testMicros(int count){ + Uint32 avg = 0; + Uint32 sum2 = 0; + + for(int i = 0; i (r*1000)){ + avg += (m - (r*1000)); + sum2 += (m - (r*1000)) * (m - (r*1000)); + } else { + avg += ((r*1000) - m); + sum2 += ((r*1000) - m) * ((r*1000) - m); + } +#if 0 + m /= 1000; + if(m > r && ((m - r) > 10)){ + ndbout << "Difference to big: " << (m - r) << " - Test failed" << endl; + TestHasFailed = 1; + } + if(m < r && ((r - m) > 10)){ + ndbout << "Difference to big: " << (r - m) << " - Test failed" << endl; + TestHasFailed = 1; + } +#endif + } + + Uint32 dev = (avg * avg - sum2) / count; dev /= count; + avg /= count; + + Uint32 t = 0; + while((t*t) +#include +#include +#include +#if defined NDB_MACOSX +#include +#else +#include +#endif + +#include + +struct NdbCondition +{ + pthread_cond_t cond; +}; + + + +struct NdbCondition* +NdbCondition_Create(void) +{ + struct NdbCondition* tmpCond; + int result; + + tmpCond = (struct NdbCondition*)malloc(sizeof(struct NdbCondition)); + + if (tmpCond == NULL) + return NULL; + + result = pthread_cond_init(&tmpCond->cond, NULL); + + assert(result==0); + return tmpCond; +} + + + +int +NdbCondition_Wait(struct NdbCondition* p_cond, + NdbMutex* p_mutex) +{ + int result; + + if (p_cond == NULL || p_mutex == NULL) + return 1; + + result = pthread_cond_wait(&p_cond->cond, p_mutex); + + return result; +} + +#if defined NDB_SOLARIS || defined NDB_HPUX +#include +int +NdbCondition_WaitTimeout(struct NdbCondition* p_cond, + NdbMutex* p_mutex, + int msecs){ + int result; + struct timespec abstime; + int secs = 0; + + if (p_cond == NULL || p_mutex == NULL) + return 1; + + clock_gettime(CLOCK_REALTIME, &abstime); + + if(msecs >= 1000){ + secs = msecs / 1000; + msecs = msecs % 1000; + } + + abstime.tv_sec += secs; + abstime.tv_nsec += msecs * 1000000; + if (abstime.tv_nsec >= 1000000000) { + abstime.tv_sec += 1; + abstime.tv_nsec -= 1000000000; + } + + result = pthread_cond_timedwait(&p_cond->cond, p_mutex, &abstime); + + return result; +} +#endif + +#if defined NDB_LINUX || defined NDB_MACOSX +#include +#include + +int +NdbCondition_WaitTimeout(struct NdbCondition* p_cond, + NdbMutex* p_mutex, + int msecs){ + int result; + struct timespec abstime; + struct timeval tick_time; + int secs = 0; + + if (p_cond == NULL || p_mutex == NULL) + return 1; + + gettimeofday(&tick_time, 0); + + if(msecs >= 1000){ + secs = msecs / 1000; + msecs = msecs % 1000; + } + + + abstime.tv_sec = tick_time.tv_sec + secs; + abstime.tv_nsec = tick_time.tv_usec * 1000 + msecs * 1000000; + if (abstime.tv_nsec >= 1000000000) { + abstime.tv_sec += 1; + abstime.tv_nsec -= 1000000000; + } + + result = pthread_cond_timedwait(&p_cond->cond, p_mutex, &abstime); + + return result; +} +#endif + + +int +NdbCondition_Signal(struct NdbCondition* p_cond){ + int result; + + if (p_cond == NULL) + return 1; + + result = pthread_cond_signal(&p_cond->cond); + + return result; +} + + +int NdbCondition_Broadcast(struct NdbCondition* p_cond) +{ + int result; + + if (p_cond == NULL) + return 1; + + result = pthread_cond_broadcast(&p_cond->cond); + + return result; +} + + +int NdbCondition_Destroy(struct NdbCondition* p_cond) +{ + int result; + + if (p_cond == NULL) + return 1; + + result = pthread_cond_destroy(&p_cond->cond); + free(p_cond); + + return 0; +} + diff --git a/ndb/src/common/portlib/unix/NdbDaemon.c b/ndb/src/common/portlib/unix/NdbDaemon.c new file mode 100644 index 00000000000..fc114266c9d --- /dev/null +++ b/ndb/src/common/portlib/unix/NdbDaemon.c @@ -0,0 +1,170 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "NdbDaemon.h" +#include + +#ifdef NDB_LINUX +#include +#include +#include +#include +#include +#include +#include +#endif + +#ifdef NDB_SOLARIS +#include +#include +#include +#include +#include +#include +#include +#endif + +#define NdbDaemon_ErrorSize 500 +#if defined(NDB_LINUX) || defined(NDB_SOLARIS) +long NdbDaemon_DaemonPid; +int NdbDaemon_ErrorCode; +char NdbDaemon_ErrorText[NdbDaemon_ErrorSize]; +#endif +int +NdbDaemon_Make(const char* lockfile, const char* logfile, unsigned flags) +{ + /* XXX fix other unixes */ +#if defined(NDB_LINUX) || defined(NDB_SOLARIS) + int lockfd = -1, logfd = -1, n; + char buf[64]; + + /* Check that we have write access to lock file */ + assert(lockfile != NULL); + lockfd = open(lockfile, O_CREAT|O_RDWR, 0644); + if (lockfd == -1) { + NdbDaemon_ErrorCode = errno; + snprintf(NdbDaemon_ErrorText, NdbDaemon_ErrorSize, + "%s: open for write failed: %s", lockfile, strerror(errno)); + return -1; + } + /* Read any old pid from lock file */ + buf[0] = 0; + n = read(lockfd, buf, sizeof(buf)); + if (n < 0) { + NdbDaemon_ErrorCode = errno; + snprintf(NdbDaemon_ErrorText, NdbDaemon_ErrorSize, + "%s: read failed: %s", lockfile, strerror(errno)); + return -1; + } + NdbDaemon_DaemonPid = atol(buf); + if (lseek(lockfd, 0, SEEK_SET) == -1) { + NdbDaemon_ErrorCode = errno; + snprintf(NdbDaemon_ErrorText, NdbDaemon_ErrorSize, + "%s: lseek failed: %s", lockfile, strerror(errno)); + return -1; + } + /* Test for lock before becoming daemon */ + if (lockf(lockfd, F_TEST, 0) == -1) { + if (errno == EACCES || errno == EAGAIN) { /* results may vary */ + snprintf(NdbDaemon_ErrorText, NdbDaemon_ErrorSize, + "%s: already locked by pid=%ld", lockfile, NdbDaemon_DaemonPid); + return -1; + } + NdbDaemon_ErrorCode = errno; + snprintf(NdbDaemon_ErrorText, NdbDaemon_ErrorSize, + "%s: lock test failed: %s", lockfile, strerror(errno)); + return -1; + } + /* Test open log file before becoming daemon */ + if (logfile != NULL) { + logfd = open(logfile, O_CREAT|O_WRONLY|O_APPEND, 0644); + if (logfd == -1) { + NdbDaemon_ErrorCode = errno; + snprintf(NdbDaemon_ErrorText, NdbDaemon_ErrorSize, + "%s: open for write failed: %s", logfile, strerror(errno)); + return -1; + } + } + /* Fork */ + n = fork(); + if (n == -1) { + NdbDaemon_ErrorCode = errno; + snprintf(NdbDaemon_ErrorText, NdbDaemon_ErrorSize, + "fork failed: %s", strerror(errno)); + return -1; + } + /* Exit if we are the parent */ + if (n != 0) { + exit(0); + } + /* Running in child process */ + NdbDaemon_DaemonPid = getpid(); + /* Lock the lock file (likely to succeed due to test above) */ + if (lockf(lockfd, F_LOCK, 0) == -1) { + NdbDaemon_ErrorCode = errno; + snprintf(NdbDaemon_ErrorText, NdbDaemon_ErrorSize, + "%s: lock failed: %s", lockfile, strerror(errno)); + return -1; + } + /* Become process group leader */ + if (setsid() == -1) { + NdbDaemon_ErrorCode = errno; + snprintf(NdbDaemon_ErrorText, NdbDaemon_ErrorSize, + "setsid failed: %s", strerror(errno)); + return -1; + } + /* Write pid to lock file */ + if (ftruncate(lockfd, 0) == -1) { + NdbDaemon_ErrorCode = errno; + snprintf(NdbDaemon_ErrorText, NdbDaemon_ErrorSize, + "%s: ftruncate failed: %s", lockfile, strerror(errno)); + return -1; + } + sprintf(buf, "%ld\n", NdbDaemon_DaemonPid); + n = strlen(buf); + if (write(lockfd, buf, n) != n) { + NdbDaemon_ErrorCode = errno; + snprintf(NdbDaemon_ErrorText, NdbDaemon_ErrorSize, + "%s: write failed: %s", lockfile, strerror(errno)); + return -1; + } + /* Do input/output redirections (assume fd 0,1,2 not in use) */ + close(0); + open("/dev/null", O_RDONLY); + if (logfile != 0) { + dup2(logfd, 1); + dup2(logfd, 2); + close(logfd); + } +#endif + /* Success */ + return 0; +} + +#ifdef NDB_DAEMON_TEST + +int +main() +{ + if (NdbDaemon_Make("test.pid", "test.log", 0) == -1) { + fprintf(stderr, "NdbDaemon_Make: %s\n", NdbDaemon_ErrorText); + return 1; + } + sleep(10); + return 0; +} + +#endif diff --git a/ndb/src/common/portlib/unix/NdbEnv.c b/ndb/src/common/portlib/unix/NdbEnv.c new file mode 100644 index 00000000000..b01e3b239ca --- /dev/null +++ b/ndb/src/common/portlib/unix/NdbEnv.c @@ -0,0 +1,34 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbEnv.h" +#include +#include + +const char* NdbEnv_GetEnv(const char* name, char * buf, int buflen) +{ + char* p = NULL; + p = getenv(name); + + if (p != NULL && buf != NULL){ + strncpy(buf, p, buflen); + buf[buflen-1] = 0; + } + return p; + +} + diff --git a/ndb/src/common/portlib/unix/NdbHost.c b/ndb/src/common/portlib/unix/NdbHost.c new file mode 100644 index 00000000000..8d2a23fccda --- /dev/null +++ b/ndb/src/common/portlib/unix/NdbHost.c @@ -0,0 +1,34 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbHost.h" +#include + +int NdbHost_GetHostName(char* buf) +{ + if (gethostname(buf, MAXHOSTNAMELEN) != 0) + { + return -1; + } + return 0; +} + +int NdbHost_GetProcessId(void) +{ + return getpid(); +} + diff --git a/ndb/src/common/portlib/unix/NdbMem.c b/ndb/src/common/portlib/unix/NdbMem.c new file mode 100644 index 00000000000..a18cf30cc8a --- /dev/null +++ b/ndb/src/common/portlib/unix/NdbMem.c @@ -0,0 +1,76 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbMem.h" + +#include +#include +#include +#ifndef NDB_MACOSX +#include +#endif + +void NdbMem_Create() +{ + /* Do nothing */ + return; +} + +void NdbMem_Destroy() +{ + /* Do nothing */ + return; +} + +void* NdbMem_Allocate(size_t size) +{ + assert(size > 0); + return (void*)malloc(size); +} + +void* NdbMem_AllocateAlign(size_t size, size_t alignment) +{ + /* + return (void*)memalign(alignment, size); + TEMP fix + */ + return (void*)malloc(size); +} + + +void NdbMem_Free(void* ptr) +{ + free(ptr); +} + + +int NdbMem_MemLockAll(){ +#if defined NDB_MACOSX + return 0; +#else + return mlockall(MCL_CURRENT | MCL_FUTURE); +#endif +} + +int NdbMem_MemUnlockAll(){ +#if defined NDB_MACOSX + return 0; +#else + return munlockall(); +#endif +} + diff --git a/ndb/src/common/portlib/unix/NdbMutex.c b/ndb/src/common/portlib/unix/NdbMutex.c new file mode 100644 index 00000000000..3cadc0667e7 --- /dev/null +++ b/ndb/src/common/portlib/unix/NdbMutex.c @@ -0,0 +1,93 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbMutex.h" + +#include +#include +#include + +NdbMutex* NdbMutex_Create(void) +{ + NdbMutex* pNdbMutex; + int result; + + pNdbMutex = (NdbMutex*)malloc(sizeof(NdbMutex)); + + if (pNdbMutex == NULL) + return NULL; + + result = pthread_mutex_init(pNdbMutex, NULL); + assert(result == 0); + + return pNdbMutex; + +} + + +int NdbMutex_Destroy(NdbMutex* p_mutex) +{ + int result; + + if (p_mutex == NULL) + return -1; + + result = pthread_mutex_destroy(p_mutex); + free(p_mutex); + + return result; + +} + + +int NdbMutex_Lock(NdbMutex* p_mutex) +{ + int result; + + if (p_mutex == NULL) + return -1; + + result = pthread_mutex_lock(p_mutex); + + return result; +} + + +int NdbMutex_Unlock(NdbMutex* p_mutex) +{ + int result; + + if (p_mutex == NULL) + return -1; + + result = pthread_mutex_unlock(p_mutex); + + return result; +} + + +int NdbMutex_Trylock(NdbMutex* p_mutex) +{ + int result = -1; + + if (p_mutex != NULL) { + result = pthread_mutex_trylock(p_mutex); + } + + return result; +} + diff --git a/ndb/src/common/portlib/unix/NdbSleep.c b/ndb/src/common/portlib/unix/NdbSleep.c new file mode 100644 index 00000000000..35132d7f9c7 --- /dev/null +++ b/ndb/src/common/portlib/unix/NdbSleep.c @@ -0,0 +1,48 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbSleep.h" + + +#ifdef NDB_SOLARIS +#include +#include +#endif + +#if defined NDB_LINUX || defined NDB_HPUX || defined NDB_MACOSX +#include +#include +#endif + +int +NdbSleep_MilliSleep(int milliseconds){ + int result = 0; + struct timespec sleeptime; + sleeptime.tv_sec = milliseconds / 1000; + sleeptime.tv_nsec = (milliseconds - (sleeptime.tv_sec * 1000)) * 1000000; + result = nanosleep(&sleeptime, NULL); + return result; +} + +int +NdbSleep_SecSleep(int seconds){ + int result = 0; + result = sleep(seconds); + return result; +} + + diff --git a/ndb/src/common/portlib/unix/NdbTCP.c b/ndb/src/common/portlib/unix/NdbTCP.c new file mode 100644 index 00000000000..c2613c211c5 --- /dev/null +++ b/ndb/src/common/portlib/unix/NdbTCP.c @@ -0,0 +1,60 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbTCP.h" + + +#ifdef NDB_SOLARIS +int +Ndb_getInAddr(struct in_addr * dst, const char *address) { + struct hostent host, * hostPtr; + char buf[1024]; + int h_errno; + hostPtr = gethostbyname_r(address, &host, &buf[0], 1024, &h_errno); + if (hostPtr != NULL) { + dst->s_addr = ((struct in_addr *) *hostPtr->h_addr_list)->s_addr; + return 0; + } + + /* Try it as aaa.bbb.ccc.ddd. */ + dst->s_addr = inet_addr(address); + if (dst->s_addr != -1) { + return 0; + } + return -1; +} +#endif + +#if defined NDB_LINUX || defined NDB_HPUX || defined NDB_MACOSX +int +Ndb_getInAddr(struct in_addr * dst, const char *address) { + struct hostent * hostPtr; + hostPtr = gethostbyname(address); + if (hostPtr != NULL) { + dst->s_addr = ((struct in_addr *) *hostPtr->h_addr_list)->s_addr; + return 0; + } + + /* Try it as aaa.bbb.ccc.ddd. */ + dst->s_addr = inet_addr(address); + if (dst->s_addr != -1) { + return 0; + } + return -1; +} +#endif + diff --git a/ndb/src/common/portlib/unix/NdbThread.c b/ndb/src/common/portlib/unix/NdbThread.c new file mode 100644 index 00000000000..3665c4c9159 --- /dev/null +++ b/ndb/src/common/portlib/unix/NdbThread.c @@ -0,0 +1,119 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbThread.h" +#include +#ifdef NDB_MACOSX +#include +#else +#include +#endif +#include +#include +#include + +#define MAX_THREAD_NAME 16 + + +struct NdbThread +{ + pthread_t thread; + char thread_name[MAX_THREAD_NAME]; +}; + + + +struct NdbThread* NdbThread_Create(NDB_THREAD_FUNC *p_thread_func, + NDB_THREAD_ARG *p_thread_arg, + const NDB_THREAD_STACKSIZE thread_stack_size, + const char* p_thread_name, + NDB_THREAD_PRIO thread_prio) +{ + struct NdbThread* tmpThread; + int result; + pthread_attr_t thread_attr; + + if (p_thread_func == NULL) + return 0; + + tmpThread = (struct NdbThread*)malloc(sizeof(struct NdbThread)); + if (tmpThread == NULL) + return NULL; + + snprintf(tmpThread->thread_name, sizeof(tmpThread->thread_name), + "%s", p_thread_name); + + pthread_attr_init(&thread_attr); + pthread_attr_setstacksize(&thread_attr, thread_stack_size); +#if defined NDB_SOLARIS +#if !defined NDB_SOLARIS6 + /* Guard stack overflow with a 2k databuffer */ + pthread_attr_setguardsize(&thread_attr, 2048); +#endif +#endif + + pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLE); + result = pthread_create(&tmpThread->thread, + &thread_attr, + p_thread_func, + p_thread_arg); + assert(result==0); + + pthread_attr_destroy(&thread_attr); + return tmpThread; +} + + +void NdbThread_Destroy(struct NdbThread** p_thread) +{ + if (*p_thread != NULL){ + free(* p_thread); + * p_thread = 0; + } +} + + +int NdbThread_WaitFor(struct NdbThread* p_wait_thread, void** status) +{ + int result; + + if (p_wait_thread == NULL) + return 0; + + if (p_wait_thread->thread == NULL) + return 0; + + result = pthread_join(p_wait_thread->thread, status); + + return result; +} + + +void NdbThread_Exit(int status) +{ + pthread_exit(&status); +} + + +int NdbThread_SetConcurrencyLevel(int level) +{ +#ifndef NDB_SOLARIS6 + return pthread_setconcurrency(level); +#else + return 0; +#endif +} diff --git a/ndb/src/common/portlib/unix/NdbTick.c b/ndb/src/common/portlib/unix/NdbTick.c new file mode 100644 index 00000000000..5adb4ec80c2 --- /dev/null +++ b/ndb/src/common/portlib/unix/NdbTick.c @@ -0,0 +1,110 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbTick.h" +#include + +#define NANOSEC_PER_SEC 1000000000 +#define MICROSEC_PER_SEC 1000000 +#define MILLISEC_PER_SEC 1000 +#define MICROSEC_PER_MILLISEC 1000 +#define MILLISEC_PER_NANOSEC 1000000 + + +#if defined NDB_SOLARIS || NDB_HPUX +NDB_TICKS NdbTick_CurrentMillisecond(void) +{ + struct timespec tick_time; + clock_gettime(CLOCK_REALTIME, &tick_time); + + return + ((NDB_TICKS)tick_time.tv_sec) * ((NDB_TICKS)MILLISEC_PER_SEC) + + ((NDB_TICKS)tick_time.tv_nsec) / ((NDB_TICKS)MILLISEC_PER_NANOSEC); +} + +int +NdbTick_CurrentMicrosecond(NDB_TICKS * secs, Uint32 * micros){ + struct timespec t; + int res = clock_gettime(CLOCK_REALTIME, &t); + * secs = t.tv_sec; + * micros = t.tv_nsec / 1000; + return res; +} +#endif + +#if defined NDB_LINUX || NDB_MACOSX +#include +#include +NDB_TICKS NdbTick_CurrentMillisecond(void) +{ + struct timeval tick_time; + gettimeofday(&tick_time, 0); + + return + ((NDB_TICKS)tick_time.tv_sec) * ((NDB_TICKS)MILLISEC_PER_SEC) + + ((NDB_TICKS)tick_time.tv_usec) / ((NDB_TICKS)MICROSEC_PER_MILLISEC); +} + +int +NdbTick_CurrentMicrosecond(NDB_TICKS * secs, Uint32 * micros){ + struct timeval tick_time; + int res = gettimeofday(&tick_time, 0); + + if(secs==0) { + NDB_TICKS secs = tick_time.tv_sec; + *micros = tick_time.tv_usec; + *micros = secs*1000000+*micros; + } else { + * secs = tick_time.tv_sec; + * micros = tick_time.tv_usec; + } + return res; +} + +#endif +#ifdef TIME_MEASUREMENT +int +NdbTick_getMicroTimer(struct MicroSecondTimer* input_timer) +{ + NDB_TICKS secs; + Uint32 mics; + int ret_value; + ret_value = NdbTick_CurrentMicrosecond(&secs, &mics); + input_timer->seconds = secs; + input_timer->micro_seconds = (NDB_TICKS)mics; + return ret_value; +} + +NDB_TICKS +NdbTick_getMicrosPassed(struct MicroSecondTimer start, + struct MicroSecondTimer stop) +{ + NDB_TICKS ret_value = (NDB_TICKS)0; + if (start.seconds < stop.seconds) { + NDB_TICKS sec_passed = stop.seconds - start.seconds; + ret_value = ((NDB_TICKS)MICROSEC_PER_SEC) * sec_passed; + } else if (start.seconds > stop.seconds) { + return ret_value; + }//if + if (start.micro_seconds < stop.micro_seconds) { + ret_value += (stop.micro_seconds - start.micro_seconds); + } else if (ret_value != (NDB_TICKS)0) { + ret_value -= (start.micro_seconds - stop.micro_seconds); + }//if + return ret_value; +} +#endif diff --git a/ndb/src/common/portlib/win32/Makefile b/ndb/src/common/portlib/win32/Makefile new file mode 100644 index 00000000000..bb29ac5547e --- /dev/null +++ b/ndb/src/common/portlib/win32/Makefile @@ -0,0 +1,30 @@ +include .defs.mk + +TYPE := util + +PIC_ARCHIVE := Y +ARCHIVE_TARGET := portlib + +SOURCES.c = NdbCondition.c \ + NdbMutex.c \ + NdbSleep.c \ + NdbTick.c \ + NdbEnv.c \ + NdbThread.c \ + NdbHost.c \ + NdbTCP.c \ + NdbDaemon.c + +ifeq ($(NDB_OS), SOFTOSE) + SOURCES += NdbMem_SoftOse.cpp +else + SOURCES.c += NdbMem.c +endif + +include $(NDB_TOP)/Epilogue.mk + + + + + + diff --git a/ndb/src/common/portlib/win32/NdbCondition.c b/ndb/src/common/portlib/win32/NdbCondition.c new file mode 100644 index 00000000000..12b508cf33b --- /dev/null +++ b/ndb/src/common/portlib/win32/NdbCondition.c @@ -0,0 +1,184 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include +#include +#include + +#include "NdbCondition.h" +#include + + +struct NdbCondition +{ + long nWaiters; + NdbMutex* pNdbMutexWaitersLock; + HANDLE hSemaphore; + HANDLE hEventWaitersDone; + int bWasBroadcast; +}; + + +struct NdbCondition* +NdbCondition_Create(void) +{ + int result = 0; + struct NdbCondition* pNdbCondition = (struct NdbCondition*)malloc(sizeof(struct NdbCondition)); + if(!pNdbCondition) + return 0; + + pNdbCondition->nWaiters = 0; + pNdbCondition->bWasBroadcast = 0; + if(!(pNdbCondition->hSemaphore = CreateSemaphore(0, 0, MAXLONG, 0))) + result = -1; + else if(!(pNdbCondition->pNdbMutexWaitersLock = NdbMutex_Create())) + result = -1; + else if(!(pNdbCondition->hEventWaitersDone = CreateEvent(0, 0, 0, 0))) + result = -1; + + assert(!result); + return pNdbCondition; +} + + +int +NdbCondition_Wait(struct NdbCondition* p_cond, + NdbMutex* p_mutex) +{ + int result; + int bLastWaiter; + if(!p_cond || !p_mutex) + return 1; + + NdbMutex_Lock(p_cond->pNdbMutexWaitersLock); + p_cond->nWaiters++; + NdbMutex_Unlock(p_cond->pNdbMutexWaitersLock); + + if(NdbMutex_Unlock(p_mutex)) + return -1; + result = WaitForSingleObject (p_cond->hSemaphore, INFINITE); + + NdbMutex_Lock(p_cond->pNdbMutexWaitersLock); + p_cond->nWaiters--; + bLastWaiter = (p_cond->bWasBroadcast && p_cond->nWaiters==0); + NdbMutex_Unlock(p_cond->pNdbMutexWaitersLock); + + if(result==WAIT_OBJECT_0 && bLastWaiter) + SetEvent(p_cond->hEventWaitersDone); + + NdbMutex_Lock(p_mutex); + return result; +} + + +int +NdbCondition_WaitTimeout(struct NdbCondition* p_cond, + NdbMutex* p_mutex, + int msecs) +{ + int result; + int bLastWaiter; + if (!p_cond || !p_mutex) + return 1; + + NdbMutex_Lock(p_cond->pNdbMutexWaitersLock); + p_cond->nWaiters++; + NdbMutex_Unlock(p_cond->pNdbMutexWaitersLock); + if(msecs<0) + msecs = 0; + + if(NdbMutex_Unlock(p_mutex)) + return -1; + result = WaitForSingleObject(p_cond->hSemaphore, msecs); + + NdbMutex_Lock(p_cond->pNdbMutexWaitersLock); + p_cond->nWaiters--; + bLastWaiter = (p_cond->bWasBroadcast && p_cond->nWaiters==0); + NdbMutex_Unlock(p_cond->pNdbMutexWaitersLock); + + if(result!=WAIT_OBJECT_0) + result = -1; + + if(bLastWaiter) + SetEvent(p_cond->hEventWaitersDone); + + NdbMutex_Lock(p_mutex); + return result; +} + + +int +NdbCondition_Signal(struct NdbCondition* p_cond) +{ + int bHaveWaiters; + if(!p_cond) + return 1; + + NdbMutex_Lock(p_cond->pNdbMutexWaitersLock); + bHaveWaiters = (p_cond->nWaiters > 0); + NdbMutex_Unlock(p_cond->pNdbMutexWaitersLock); + + if(bHaveWaiters) + return (ReleaseSemaphore(p_cond->hSemaphore, 1, 0) ? 0 : -1); + else + return 0; +} + + +int NdbCondition_Broadcast(struct NdbCondition* p_cond) +{ + int bHaveWaiters; + int result = 0; + if(!p_cond) + return 1; + + NdbMutex_Lock(p_cond->pNdbMutexWaitersLock); + bHaveWaiters = 0; + if(p_cond->nWaiters > 0) + { + p_cond->bWasBroadcast = !0; + bHaveWaiters = 1; + } + NdbMutex_Unlock(p_cond->pNdbMutexWaitersLock); + if(bHaveWaiters) + { + if(!ReleaseSemaphore(p_cond->hSemaphore, p_cond->nWaiters, 0)) + result = -1; + else if(WaitForSingleObject (p_cond->hEventWaitersDone, INFINITE) != WAIT_OBJECT_0) + result = -1; + p_cond->bWasBroadcast = 0; + } + return result; +} + + +int NdbCondition_Destroy(struct NdbCondition* p_cond) +{ + int result; + if(!p_cond) + return 1; + + CloseHandle(p_cond->hEventWaitersDone); + NdbMutex_Destroy(p_cond->pNdbMutexWaitersLock); + result = (CloseHandle(p_cond->hSemaphore) ? 0 : -1); + + free(p_cond); + return 0; +} + diff --git a/ndb/src/common/portlib/win32/NdbDaemon.c b/ndb/src/common/portlib/win32/NdbDaemon.c new file mode 100644 index 00000000000..b96d4c20260 --- /dev/null +++ b/ndb/src/common/portlib/win32/NdbDaemon.c @@ -0,0 +1,44 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "NdbDaemon.h" + +#define NdbDaemon_ErrorSize 500 +long NdbDaemon_DaemonPid; +int NdbDaemon_ErrorCode; +char NdbDaemon_ErrorText[NdbDaemon_ErrorSize]; + +int +NdbDaemon_Make(const char* lockfile, const char* logfile, unsigned flags) +{ + // XXX do something + return 0; +} + +#ifdef NDB_DAEMON_TEST + +int +main() +{ + if (NdbDaemon_Make("test.pid", "test.log", 0) == -1) { + fprintf(stderr, "NdbDaemon_Make: %s\n", NdbDaemon_ErrorText); + return 1; + } + sleep(10); + return 0; +} + +#endif diff --git a/ndb/src/common/portlib/win32/NdbEnv.c b/ndb/src/common/portlib/win32/NdbEnv.c new file mode 100644 index 00000000000..0df703a5e97 --- /dev/null +++ b/ndb/src/common/portlib/win32/NdbEnv.c @@ -0,0 +1,33 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbEnv.h" +#include +#include + +const char* NdbEnv_GetEnv(const char* name, char * buf, int buflen) +{ + char* p = NULL; + p = getenv(name); + + if (p != NULL && buf != NULL){ + strncpy(buf, p, buflen); + buf[buflen-1] = 0; + } + return p; +} + diff --git a/ndb/src/common/portlib/win32/NdbHost.c b/ndb/src/common/portlib/win32/NdbHost.c new file mode 100644 index 00000000000..f91dd1a531c --- /dev/null +++ b/ndb/src/common/portlib/win32/NdbHost.c @@ -0,0 +1,53 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbHost.h" +#include +#include + + +int NdbHost_GetHostName(char* buf) +{ + /* We must initialize TCP/IP if we want to call gethostname */ + WORD wVersionRequested; + WSADATA wsaData; + int err; + + wVersionRequested = MAKEWORD( 2, 0 ); + err = WSAStartup( wVersionRequested, &wsaData ); + if ( err != 0 ) { + /** + * Tell the user that we couldn't find a usable + * WinSock DLL. + */ + return -1; + } + + /* Get host name */ + if(gethostname(buf, MAXHOSTNAMELEN)) + { + return -1; + } + return 0; +} + + +int NdbHost_GetProcessId(void) +{ + return _getpid(); +} + diff --git a/ndb/src/common/portlib/win32/NdbMem.c b/ndb/src/common/portlib/win32/NdbMem.c new file mode 100644 index 00000000000..274dc31353f --- /dev/null +++ b/ndb/src/common/portlib/win32/NdbMem.c @@ -0,0 +1,237 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include + +#include "NdbMem.h" + + +struct AWEINFO +{ + SIZE_T dwSizeInBytesRequested; + ULONG_PTR nNumberOfPagesRequested; + ULONG_PTR nNumberOfPagesActual; + ULONG_PTR nNumberOfPagesFreed; + ULONG_PTR* pnPhysicalMemoryPageArray; + void* pRegionReserved; +}; + +const size_t cNdbMem_nMaxAWEinfo = 256; +size_t gNdbMem_nAWEinfo = 0; + +struct AWEINFO* gNdbMem_pAWEinfo = 0; + + +void ShowLastError(const char* szContext, const char* szFunction) +{ + DWORD dwError = GetLastError(); + LPVOID lpMsgBuf; + FormatMessage( + FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + dwError, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + (LPTSTR)&lpMsgBuf, + 0, + NULL + ); + printf("%s : %s failed : %lu : %s\n", szContext, szFunction, dwError, (char*)lpMsgBuf); + LocalFree(lpMsgBuf); +} + + + +void NdbMem_Create() +{ + // Address Windowing Extensions + struct PRIVINFO + { + DWORD Count; + LUID_AND_ATTRIBUTES Privilege[1]; + } Info; + + HANDLE hProcess = GetCurrentProcess(); + HANDLE hToken; + if(!OpenProcessToken(hProcess, TOKEN_ADJUST_PRIVILEGES, &hToken)) + { + ShowLastError("NdbMem_Create", "OpenProcessToken"); + } + + Info.Count = 1; + Info.Privilege[0].Attributes = SE_PRIVILEGE_ENABLED; + if(!LookupPrivilegeValue(0, SE_LOCK_MEMORY_NAME, &(Info.Privilege[0].Luid))) + { + ShowLastError("NdbMem_Create", "LookupPrivilegeValue"); + } + + if(!AdjustTokenPrivileges(hToken, FALSE, (PTOKEN_PRIVILEGES)&Info, 0, 0, 0)) + { + ShowLastError("NdbMem_Create", "AdjustTokenPrivileges"); + } + + if(!CloseHandle(hToken)) + { + ShowLastError("NdbMem_Create", "CloseHandle"); + } + + return; +} + +void NdbMem_Destroy() +{ + /* Do nothing */ + return; +} + +void* NdbMem_Allocate(size_t size) +{ + // Address Windowing Extensions + struct AWEINFO* pAWEinfo; + HANDLE hProcess; + SYSTEM_INFO sysinfo; + + if(!gNdbMem_pAWEinfo) + { + gNdbMem_pAWEinfo = VirtualAlloc(0, + sizeof(struct AWEINFO)*cNdbMem_nMaxAWEinfo, + MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE); + } + + assert(gNdbMem_nAWEinfo < cNdbMem_nMaxAWEinfo); + pAWEinfo = gNdbMem_pAWEinfo+gNdbMem_nAWEinfo++; + + hProcess = GetCurrentProcess(); + GetSystemInfo(&sysinfo); + pAWEinfo->nNumberOfPagesRequested = (size+sysinfo.dwPageSize-1)/sysinfo.dwPageSize; + pAWEinfo->pnPhysicalMemoryPageArray = VirtualAlloc(0, + sizeof(ULONG_PTR)*pAWEinfo->nNumberOfPagesRequested, + MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE); + pAWEinfo->nNumberOfPagesActual = pAWEinfo->nNumberOfPagesRequested; + if(!AllocateUserPhysicalPages(hProcess, &(pAWEinfo->nNumberOfPagesActual), pAWEinfo->pnPhysicalMemoryPageArray)) + { + ShowLastError("NdbMem_Allocate", "AllocateUserPhysicalPages"); + return 0; + } + if(pAWEinfo->nNumberOfPagesRequested != pAWEinfo->nNumberOfPagesActual) + { + ShowLastError("NdbMem_Allocate", "nNumberOfPagesRequested != nNumberOfPagesActual"); + return 0; + } + + pAWEinfo->dwSizeInBytesRequested = size; + pAWEinfo->pRegionReserved = VirtualAlloc(0, pAWEinfo->dwSizeInBytesRequested, MEM_RESERVE | MEM_PHYSICAL, PAGE_READWRITE); + if(!pAWEinfo->pRegionReserved) + { + ShowLastError("NdbMem_Allocate", "VirtualAlloc"); + return 0; + } + + if(!MapUserPhysicalPages(pAWEinfo->pRegionReserved, pAWEinfo->nNumberOfPagesActual, pAWEinfo->pnPhysicalMemoryPageArray)) + { + ShowLastError("NdbMem_Allocate", "MapUserPhysicalPages"); + return 0; + } + + /* + printf("allocate AWE memory: %lu bytes, %lu pages, address %lx\n", + pAWEinfo->dwSizeInBytesRequested, + pAWEinfo->nNumberOfPagesActual, + pAWEinfo->pRegionReserved); + */ + return pAWEinfo->pRegionReserved; +} + + +void* NdbMem_AllocateAlign(size_t size, size_t alignment) +{ + /* + return (void*)memalign(alignment, size); + TEMP fix + */ + return NdbMem_Allocate(size); +} + + +void NdbMem_Free(void* ptr) +{ + // VirtualFree(ptr, 0, MEM_DECOMMIT|MEM_RELEASE); + + // Address Windowing Extensions + struct AWEINFO* pAWEinfo = 0; + size_t i; + HANDLE hProcess; + + for(i=0; inNumberOfPagesActual, 0)) + { + ShowLastError("NdbMem_Free", "MapUserPhysicalPages"); + } + + if(!VirtualFree(ptr, 0, MEM_RELEASE)) + { + ShowLastError("NdbMem_Free", "VirtualFree"); + } + + pAWEinfo->nNumberOfPagesFreed = pAWEinfo->nNumberOfPagesActual; + if(!FreeUserPhysicalPages(hProcess, &(pAWEinfo->nNumberOfPagesFreed), pAWEinfo->pnPhysicalMemoryPageArray)) + { + ShowLastError("NdbMem_Free", "FreeUserPhysicalPages"); + } + + VirtualFree(pAWEinfo->pnPhysicalMemoryPageArray, 0, MEM_DECOMMIT|MEM_RELEASE); +} + + +int NdbMem_MemLockAll() +{ + /* + HANDLE hProcess = GetCurrentProcess(); + SIZE_T nMinimumWorkingSetSize; + SIZE_T nMaximumWorkingSetSize; + GetProcessWorkingSetSize(hProcess, &nMinimumWorkingSetSize, &nMaximumWorkingSetSize); + ndbout << "nMinimumWorkingSetSize=" << nMinimumWorkingSetSize << ", nMaximumWorkingSetSize=" << nMaximumWorkingSetSize << endl; + + SetProcessWorkingSetSize(hProcess, 50000000, 100000000); + + GetProcessWorkingSetSize(hProcess, &nMinimumWorkingSetSize, &nMaximumWorkingSetSize); + ndbout << "nMinimumWorkingSetSize=" << nMinimumWorkingSetSize << ", nMaximumWorkingSetSize=" << nMaximumWorkingSetSize << endl; + */ + return -1; +} + +int NdbMem_MemUnlockAll() +{ + //VirtualUnlock(); + return -1; +} + diff --git a/ndb/src/common/portlib/win32/NdbMutex.c b/ndb/src/common/portlib/win32/NdbMutex.c new file mode 100644 index 00000000000..c93384d91db --- /dev/null +++ b/ndb/src/common/portlib/win32/NdbMutex.c @@ -0,0 +1,78 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include +#include +#include + +#include "NdbMutex.h" + + +NdbMutex* NdbMutex_Create(void) +{ + NdbMutex* pNdbMutex = (NdbMutex*)malloc(sizeof(NdbMutex)); + if(!pNdbMutex) + return 0; + + InitializeCriticalSection(pNdbMutex); + return pNdbMutex; +} + + +int NdbMutex_Destroy(NdbMutex* p_mutex) +{ + if(!p_mutex) + return -1; + + DeleteCriticalSection(p_mutex); + free(p_mutex); + return 0; +} + + +int NdbMutex_Lock(NdbMutex* p_mutex) +{ + if(!p_mutex) + return -1; + + EnterCriticalSection (p_mutex); + return 0; +} + + +int NdbMutex_Unlock(NdbMutex* p_mutex) +{ + if(!p_mutex) + return -1; + + LeaveCriticalSection(p_mutex); + return 0; +} + + +int NdbMutex_Trylock(NdbMutex* p_mutex) +{ + int result = -1; + if(p_mutex) + { + result = (TryEnterCriticalSection(p_mutex) ? 0 : -1); + } + return result; +} + diff --git a/ndb/src/common/portlib/win32/NdbSleep.c b/ndb/src/common/portlib/win32/NdbSleep.c new file mode 100644 index 00000000000..ac0f44dd07f --- /dev/null +++ b/ndb/src/common/portlib/win32/NdbSleep.c @@ -0,0 +1,35 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbSleep.h" + +#include + + +int +NdbSleep_MilliSleep(int milliseconds) +{ + Sleep(milliseconds); + return 0; +} + +int +NdbSleep_SecSleep(int seconds) +{ + return NdbSleep_MilliSleep(seconds*1000); +} + diff --git a/ndb/src/common/portlib/win32/NdbTCP.c b/ndb/src/common/portlib/win32/NdbTCP.c new file mode 100644 index 00000000000..483a53bd606 --- /dev/null +++ b/ndb/src/common/portlib/win32/NdbTCP.c @@ -0,0 +1,39 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "NdbTCP.h" + +int +Ndb_getInAddr(struct in_addr * dst, const char *address) +{ + struct hostent * hostPtr; + + /* Try it as aaa.bbb.ccc.ddd. */ + dst->s_addr = inet_addr(address); + if (dst->s_addr != -1) { + return 0; + } + + hostPtr = gethostbyname(address); + if (hostPtr != NULL) { + dst->s_addr = ((struct in_addr *) *hostPtr->h_addr_list)->s_addr; + return 0; + } + + return -1; +} + diff --git a/ndb/src/common/portlib/win32/NdbThread.c b/ndb/src/common/portlib/win32/NdbThread.c new file mode 100644 index 00000000000..ae3c74be70d --- /dev/null +++ b/ndb/src/common/portlib/win32/NdbThread.c @@ -0,0 +1,118 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include + +#include "NdbThread.h" + + +#define MAX_THREAD_NAME 16 + +typedef unsigned (WINAPI* NDB_WIN32_THREAD_FUNC)(void*); + + +struct NdbThread +{ + HANDLE hThread; + unsigned nThreadId; + char thread_name[MAX_THREAD_NAME]; +}; + + +struct NdbThread* NdbThread_Create(NDB_THREAD_FUNC *p_thread_func, + NDB_THREAD_ARG *p_thread_arg, + const NDB_THREAD_STACKSIZE thread_stack_size, + const char* p_thread_name, + NDB_THREAD_PRIO thread_prio) +{ + struct NdbThread* tmpThread; + unsigned initflag; + int nPriority = 0; + + if(!p_thread_func) + return 0; + + tmpThread = (struct NdbThread*)malloc(sizeof(struct NdbThread)); + if(!tmpThread) + return 0; + + strncpy((char*)&tmpThread->thread_name, p_thread_name, MAX_THREAD_NAME); + + switch(thread_prio) + { + case NDB_THREAD_PRIO_HIGHEST: nPriority=THREAD_PRIORITY_HIGHEST; break; + case NDB_THREAD_PRIO_HIGH: nPriority=THREAD_PRIORITY_ABOVE_NORMAL; break; + case NDB_THREAD_PRIO_MEAN: nPriority=THREAD_PRIORITY_NORMAL; break; + case NDB_THREAD_PRIO_LOW: nPriority=THREAD_PRIORITY_BELOW_NORMAL; break; + case NDB_THREAD_PRIO_LOWEST: nPriority=THREAD_PRIORITY_LOWEST; break; + } + initflag = (nPriority ? CREATE_SUSPENDED : 0); + + tmpThread->hThread = (HANDLE)_beginthreadex(0, thread_stack_size, + (NDB_WIN32_THREAD_FUNC)p_thread_func, p_thread_arg, + initflag, &tmpThread->nThreadId); + + if(nPriority && tmpThread->hThread) + { + SetThreadPriority(tmpThread->hThread, nPriority); + ResumeThread (tmpThread->hThread); + } + + assert(tmpThread->hThread); + return tmpThread; +} + + +void NdbThread_Destroy(struct NdbThread** p_thread) +{ + CloseHandle((*p_thread)->hThread); + (*p_thread)->hThread = 0; + free(*p_thread); + *p_thread = 0; +} + + +int NdbThread_WaitFor(struct NdbThread* p_wait_thread, void** status) +{ + void *local_status = 0; + if (status == 0) + status = &local_status; + + if(WaitForSingleObject(p_wait_thread->hThread, INFINITE) == WAIT_OBJECT_0 + && GetExitCodeThread(p_wait_thread->hThread, (LPDWORD)status)) + { + CloseHandle(p_wait_thread->hThread); + p_wait_thread->hThread = 0; + return 0; + } + return -1; +} + + +void NdbThread_Exit(int status) +{ + _endthreadex((DWORD) status); +} + + +int NdbThread_SetConcurrencyLevel(int level) +{ + return 0; +} + diff --git a/ndb/src/common/portlib/win32/NdbTick.c b/ndb/src/common/portlib/win32/NdbTick.c new file mode 100644 index 00000000000..e3a67d8437d --- /dev/null +++ b/ndb/src/common/portlib/win32/NdbTick.c @@ -0,0 +1,64 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include "NdbTick.h" + +/* +#define FILETIME_PER_MICROSEC 10 +#define FILETIME_PER_MILLISEC 10000 +#define FILETIME_PER_SEC 10000000 + + +NDB_TICKS NdbTick_CurrentMillisecond(void) +{ + ULONGLONG ullTime; + GetSystemTimeAsFileTime((LPFILETIME)&ullTime); + return (ullTime / FILETIME_PER_MILLISEC); +} + +int +NdbTick_CurrentMicrosecond(NDB_TICKS * secs, Uint32 * micros) +{ + ULONGLONG ullTime; + GetSystemTimeAsFileTime((LPFILETIME)&ullTime); + *secs = (ullTime / FILETIME_PER_SEC); + *micros = (Uint32)((ullTime % FILETIME_PER_SEC) / FILETIME_PER_MICROSEC); + return 0; +} +*/ + + +NDB_TICKS NdbTick_CurrentMillisecond(void) +{ + LARGE_INTEGER liCount, liFreq; + QueryPerformanceCounter(&liCount); + QueryPerformanceFrequency(&liFreq); + return (liCount.QuadPart*1000) / liFreq.QuadPart; +} + +int +NdbTick_CurrentMicrosecond(NDB_TICKS * secs, Uint32 * micros) +{ + LARGE_INTEGER liCount, liFreq; + QueryPerformanceCounter(&liCount); + QueryPerformanceFrequency(&liFreq); + *secs = liCount.QuadPart / liFreq.QuadPart; + liCount.QuadPart -= *secs * liFreq.QuadPart; + *micros = (liCount.QuadPart*1000000) / liFreq.QuadPart; + return 0; +} diff --git a/ndb/src/common/transporter/Makefile b/ndb/src/common/transporter/Makefile new file mode 100644 index 00000000000..3bd23b627d3 --- /dev/null +++ b/ndb/src/common/transporter/Makefile @@ -0,0 +1,62 @@ +include .defs.mk + +TYPE := util + +PIC_ARCHIVE := Y +ARCHIVE_TARGET := transporter +DIRS := basictest perftest + +# Source files of non-templated classes (.cpp files) +SOURCES = \ + Transporter.cpp \ + SendBuffer.cpp \ + SHM_Transporter.cpp \ + TCP_Transporter.cpp \ + TransporterRegistry.cpp \ + Packer.cpp + +DIRS := basictest perftest + +CCFLAGS_LOC += -I$(call fixpath,$(NDB_TOP)/include/kernel) \ + -I$(call fixpath,$(NDB_TOP)/include/transporter) + +ifeq ($(NDB_OS), WIN32) +SOURCES += SHM_Transporter.win32.cpp +endif + +ifeq ($(NDB_OS), SOLARIS) +SOURCES += SHM_Transporter.unix.cpp +endif + +ifeq ($(NDB_OS), HPUX) +SOURCES += SHM_Transporter.unix.cpp +endif + +ifeq ($(NDB_OS), MACOSX) +SOURCES += SHM_Transporter.unix.cpp +endif + +ifeq ($(NDB_OS), IBMAIX) +SOURCES += SHM_Transporter.unix.cpp +endif + +ifeq ($(NDB_OS), TRU64X) +SOURCES += SHM_Transporter.unix.cpp +endif + +ifeq ($(NDB_OS), LINUX) +SOURCES += SHM_Transporter.unix.cpp +ifeq ($(NDB_SCI), Y) +SOURCES += SCI_Transporter.cpp +endif +endif + + +ifneq ($(findstring OSE, $(NDB_OS)),) + SOURCES += OSE_Transporter.cpp + SOURCES += OSE_Receiver.cpp +endif + + + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/common/transporter/OSE_Receiver.cpp b/ndb/src/common/transporter/OSE_Receiver.cpp new file mode 100644 index 00000000000..558dee92d8d --- /dev/null +++ b/ndb/src/common/transporter/OSE_Receiver.cpp @@ -0,0 +1,360 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "OSE_Receiver.hpp" +#include "OSE_Transporter.hpp" +#include "TransporterCallback.hpp" +#include +#include "TransporterInternalDefinitions.hpp" +#include + +OSE_Receiver::OSE_Receiver(TransporterRegistry * tr, + int _recBufSize, + NodeId _localNodeId) { + theTransporterRegistry = tr; + + recBufSize = _recBufSize; + recBufReadIndex = 0; + recBufWriteIndex = 0; + receiveBuffer = new union SIGNAL * [recBufSize]; + + waitStackCount = 0; + waitStackSize = _recBufSize; + waitStack = new union SIGNAL * [waitStackSize]; + + nextSigId = new Uint32[MAX_NTRANSPORTERS]; + for (int i = 0; i < MAX_NTRANSPORTERS; i++) + nextSigId[i] = 0; + + phantomCreated = false; + localNodeId = _localNodeId; + snprintf(localHostName, sizeof(localHostName), + "ndb_node%d", localNodeId); + + DEBUG("localNodeId = " << localNodeId << " -> localHostName = " + << localHostName); +} + +OSE_Receiver::~OSE_Receiver(){ + while(recBufReadIndex != recBufWriteIndex){ + free_buf(&receiveBuffer[recBufReadIndex]); + recBufReadIndex = (recBufReadIndex + 1) % recBufSize; + } + delete [] receiveBuffer; + destroyPhantom(); +} + +PROCESS +OSE_Receiver::createPhantom(){ + redir.sig = 1; + redir.pid = current_process(); + + if(!phantomCreated){ + phantomPid = create_process + (OS_PHANTOM, // Type + localHostName, // Name + NULL, // Entry point + 0, // Stack size + 0, // Prio - Not used + (OSTIME)0, // Timeslice - Not used + 0, // Block - current block + &redir, + (OSVECTOR)0, // vector + (OSUSER)0); // user + phantomCreated = true; + DEBUG("Created phantom pid: " << hex << phantomPid); + } + return phantomPid; +} + +void +OSE_Receiver::destroyPhantom(){ + if(phantomCreated){ + DEBUG("Destroying phantom pid: " << hex << phantomPid); + kill_proc(phantomPid); + phantomCreated = false; + } +} + +static SIGSELECT PRIO_A_SIGNALS[] = { 6, + NDB_TRANSPORTER_PRIO_A, + NDB_TRANSPORTER_HUNT, + NDB_TRANSPORTER_CONNECT_REQ, + NDB_TRANSPORTER_CONNECT_REF, + NDB_TRANSPORTER_CONNECT_CONF, + NDB_TRANSPORTER_DISCONNECT_ORD +}; + +static SIGSELECT PRIO_B_SIGNALS[] = { 1, + NDB_TRANSPORTER_DATA +}; + +/** + * Check waitstack for signals that are next in sequence + * Put any found signal in receive buffer + * Returns true if one signal is found + */ +bool +OSE_Receiver::checkWaitStack(NodeId _nodeId){ + + for(int i = 0; i < waitStackCount; i++){ + if (waitStack[i]->dataSignal.senderNodeId == _nodeId && + waitStack[i]->dataSignal.sigId == nextSigId[_nodeId]){ + + ndbout_c("INFO: signal popped from waitStack, sigId = %d", + waitStack[i]->dataSignal.sigId); + + if(isFull()){ + ndbout_c("ERROR: receiveBuffer is full"); + reportError(callbackObj, _nodeId, TE_RECEIVE_BUFFER_FULL); + return false; + } + + // The next signal was found, put it in the receive buffer + insertReceiveBuffer(waitStack[i]); + + // Increase sequence id, set it to the next expected id + nextSigId[_nodeId]++; + + // Move signals below up one step + for(int j = i; j < waitStackCount-1; j++) + waitStack[j] = waitStack[j+1]; + waitStack[waitStackCount] = NULL; + waitStackCount--; + + // return true since signal was found + return true; + } + } + return false; +} + +/** + * Clear waitstack for signals from node with _nodeId + */ +void +OSE_Receiver::clearWaitStack(NodeId _nodeId){ + + for(int i = 0; i < waitStackCount; i++){ + if (waitStack[i]->dataSignal.senderNodeId == _nodeId){ + + // Free signal buffer + free_buf(&waitStack[i]); + + // Move signals below up one step + for(int j = i; j < waitStackCount-1; j++) + waitStack[j] = waitStack[j+1]; + waitStack[waitStackCount] = NULL; + waitStackCount--; + } + } + nextSigId[_nodeId] = 0; +} + + +inline +void +OSE_Receiver::insertWaitStack(union SIGNAL* _sig){ + if (waitStackCount <= waitStackSize){ + waitStack[waitStackCount] = _sig; + waitStackCount++; + } else { + ndbout_c("ERROR: waitStack is full"); + reportError(callbackObj, localNodeId, TE_WAIT_STACK_FULL); + } +} + +bool +OSE_Receiver::doReceive(Uint32 timeOutMillis) { + if(isFull()) + return false; + + union SIGNAL * sig = receive_w_tmo(0, + PRIO_A_SIGNALS); + if(sig == NIL){ + sig = receive_w_tmo(timeOutMillis, + PRIO_B_SIGNALS); + if(sig == NIL) + return false; + } + + DEBUG("Received signal: " << sig->sigNo << " " + << sigNo2String(sig->sigNo)); + + switch(sig->sigNo){ + case NDB_TRANSPORTER_PRIO_A: + { + OSE_Transporter * t = getTransporter(sig->dataSignal.senderNodeId); + if (t != 0 && t->isConnected()){ + insertReceiveBuffer(sig); + } else { + free_buf(&sig); + } + } + break; + case NDB_TRANSPORTER_DATA: + { + OSE_Transporter * t = getTransporter(sig->dataSignal.senderNodeId); + if (t != 0 && t->isConnected()){ + int nodeId = sig->dataSignal.senderNodeId; + Uint32 currSigId = sig->dataSignal.sigId; + + /** + * Check if signal is the next in sequence + * nextSigId is always set to the next sigId to wait for + */ + if (nextSigId[nodeId] == currSigId){ + + // Insert in receive buffer + insertReceiveBuffer(sig); + + // Increase sequence id, set it to the next expected id + nextSigId[nodeId]++; + + // Check if there are any signal in the wait stack + if (waitStackCount > 0){ + while(checkWaitStack(nodeId)); + } + } else { + // Signal was not received in correct order + // Check values and put it in the waitStack + ndbout_c("WARNING: sigId out of order," + " currSigId = %d, nextSigId = %d", + currSigId, nextSigId[nodeId]); + + if (currSigId < nextSigId[nodeId]){ + // Current recieved sigId was smaller than nextSigId + // There is no use to put it in the waitStack + ndbout_c("ERROR: recieved sigId was smaller than nextSigId"); + reportError(callbackObj, nodeId, TE_TOO_SMALL_SIGID); + return false; + } + + if (currSigId > (nextSigId[nodeId] + waitStackSize)){ + // Current sigId was larger than nextSigId + size of waitStack + // we can never "save" so many signal's on the stack + ndbout_c("ERROR: currSigId > (nextSigId + size of waitStack)"); + reportError(callbackObj, nodeId, TE_TOO_LARGE_SIGID); + return false; + } + + // Insert in wait stack + insertWaitStack(sig); + } + } else { + free_buf(&sig); + } + } + break; + case NDB_TRANSPORTER_HUNT: + { + NdbTransporterHunt * s = (NdbTransporterHunt*)sig; + OSE_Transporter * t = getTransporter(s->remoteNodeId); + if(t != 0) + t->huntReceived(s); + free_buf(&sig); + } + break; + case NDB_TRANSPORTER_CONNECT_REQ: + { + NdbTransporterConnectReq * s = (NdbTransporterConnectReq*)sig; + OSE_Transporter * t = getTransporter(s->senderNodeId); + if(t != 0){ + if(t->connectReq(s)){ + clearWaitStack(s->senderNodeId); + clearRecvBuffer(s->senderNodeId); + } + } + free_buf(&sig); + } + break; + case NDB_TRANSPORTER_CONNECT_REF: + { + NdbTransporterConnectRef * s = (NdbTransporterConnectRef*)sig; + OSE_Transporter * t = getTransporter(s->senderNodeId); + if(t != 0){ + if(t->connectRef(s)){ + clearWaitStack(s->senderNodeId); + clearRecvBuffer(s->senderNodeId); + } + } + free_buf(&sig); + } + break; + case NDB_TRANSPORTER_CONNECT_CONF: + { + NdbTransporterConnectConf * s = (NdbTransporterConnectConf*)sig; + OSE_Transporter * t = getTransporter(s->senderNodeId); + if(t != 0){ + if(t->connectConf(s)){ + clearWaitStack(s->senderNodeId); + clearRecvBuffer(s->senderNodeId); + } + } + free_buf(&sig); + } + break; + case NDB_TRANSPORTER_DISCONNECT_ORD: + { + NdbTransporterDisconnectOrd * s = (NdbTransporterDisconnectOrd*)sig; + OSE_Transporter * t = getTransporter(s->senderNodeId); + if(t != 0){ + if(t->disconnectOrd(s)){ + clearWaitStack(s->senderNodeId); + clearRecvBuffer(s->senderNodeId); + } + } + free_buf(&sig); + } + } + return true; +} + +OSE_Transporter * +OSE_Receiver::getTransporter(NodeId nodeId){ + if(theTransporterRegistry->theTransporterTypes[nodeId] != tt_OSE_TRANSPORTER) + return 0; + return (OSE_Transporter *) + theTransporterRegistry->theTransporters[nodeId]; +} + +void +OSE_Receiver::clearRecvBuffer(NodeId nodeId){ + int tmpIndex = 0; + union SIGNAL** tmp = new union SIGNAL * [recBufSize]; + + /** + * Put all signal that I want to keep into tmp + */ + while(recBufReadIndex != recBufWriteIndex){ + if(receiveBuffer[recBufReadIndex]->dataSignal.senderNodeId != nodeId){ + tmp[tmpIndex] = receiveBuffer[recBufReadIndex]; + tmpIndex++; + } else { + free_buf(&receiveBuffer[recBufReadIndex]); + } + recBufReadIndex = (recBufReadIndex + 1) % recBufSize; + } + + /** + * Put all signals that I kept back into receiveBuffer + */ + for(int i = 0; i + +class OSE_Receiver { +public: + OSE_Receiver(class TransporterRegistry *, + int recBufSize, + NodeId localNodeId); + + ~OSE_Receiver(); + + bool hasData() const ; + bool isFull() const ; + + Uint32 getReceiveData(NodeId * remoteNodeId, + Uint32 ** readPtr); + + void updateReceiveDataPtr(Uint32 szRead); + + bool doReceive(Uint32 timeOutMillis); + + PROCESS createPhantom(); + void destroyPhantom(); + +private: + class TransporterRegistry * theTransporterRegistry; + + NodeId localNodeId; + char localHostName[255]; + + bool phantomCreated; + PROCESS phantomPid; + struct OS_redir_entry redir; + + int recBufReadIndex; + int recBufWriteIndex; + int recBufSize; + union SIGNAL **receiveBuffer; + + // Stack for signals that are received out of order + int waitStackCount; + int waitStackSize; + union SIGNAL** waitStack; + + // Counters for the next signal id + Uint32* nextSigId; + + class OSE_Transporter * getTransporter(NodeId nodeId); + + void insertReceiveBuffer(union SIGNAL * _sig); + void clearRecvBuffer(NodeId _nodeId); + bool checkWaitStack(NodeId _nodeId); + void clearWaitStack(NodeId _nodeId); + void insertWaitStack(union SIGNAL* _sig); +}; + +inline +bool +OSE_Receiver::hasData () const { + return recBufReadIndex != recBufWriteIndex; +} + +inline +bool +OSE_Receiver::isFull () const { + return ((recBufWriteIndex + 1) % recBufSize) == recBufWriteIndex; +} + +inline +Uint32 +OSE_Receiver::getReceiveData(NodeId * remoteNodeId, + Uint32 ** readPtr){ + NdbTransporterData *s = (NdbTransporterData *)receiveBuffer[recBufReadIndex]; + if(recBufReadIndex != recBufWriteIndex){ + * remoteNodeId = s->senderNodeId; + * readPtr = &s->data[0]; + return s->length; + } + return 0; +} + +inline +void +OSE_Receiver::updateReceiveDataPtr(Uint32 bytesRead){ + if(bytesRead != 0){ + free_buf(&receiveBuffer[recBufReadIndex]); + recBufReadIndex = (recBufReadIndex + 1) % recBufSize; + } +} + +inline +void +OSE_Receiver::insertReceiveBuffer(union SIGNAL * _sig){ + receiveBuffer[recBufWriteIndex] = _sig; + recBufWriteIndex = (recBufWriteIndex + 1) % recBufSize; +} + + +#endif diff --git a/ndb/src/common/transporter/OSE_Signals.hpp b/ndb/src/common/transporter/OSE_Signals.hpp new file mode 100644 index 00000000000..3f6cc07b473 --- /dev/null +++ b/ndb/src/common/transporter/OSE_Signals.hpp @@ -0,0 +1,144 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef OSE_SIGNALS_HPP +#define OSE_SIGNALS_HPP + +#include +#include + +#define NDB_TRANSPORTER_SIGBASE 3000 + +#define NDB_TRANSPORTER_DATA (NDB_TRANSPORTER_SIGBASE + 1) /* !-SIGNO(struct NdbTransporterData)-! */ +#define NDB_TRANSPORTER_HUNT (NDB_TRANSPORTER_SIGBASE + 2) /* !-SIGNO(struct NdbTransporterHunt)-! */ +#define NDB_TRANSPORTER_CONNECT_REQ (NDB_TRANSPORTER_SIGBASE + 3) /* !-SIGNO(struct NdbTransporterConnectReq)-! */ +#define NDB_TRANSPORTER_CONNECT_REF (NDB_TRANSPORTER_SIGBASE + 4) /* !-SIGNO(struct NdbTransporterConnectRef)-! */ +#define NDB_TRANSPORTER_CONNECT_CONF (NDB_TRANSPORTER_SIGBASE + 5) /* !-SIGNO(struct NdbTransporterConnectConf)-! */ +#define NDB_TRANSPORTER_DISCONNECT_ORD (NDB_TRANSPORTER_SIGBASE + 6) /* !-SIGNO(struct NdbTransporterDisconnectOrd)-! */ +#define NDB_TRANSPORTER_PRIO_A (NDB_TRANSPORTER_SIGBASE + 7) + +inline +const char * +sigNo2String(SIGSELECT sigNo){ + switch(sigNo){ + case NDB_TRANSPORTER_PRIO_A: + return "PRIO_A_DATA"; + break; + case NDB_TRANSPORTER_DATA: + return "PRIO_B_DATA"; + break; + case NDB_TRANSPORTER_HUNT: + return "HUNT"; + break; + case NDB_TRANSPORTER_CONNECT_REQ: + return "CONNECT_REQ"; + break; + case NDB_TRANSPORTER_CONNECT_REF: + return "CONNECT_REF"; + break; + case NDB_TRANSPORTER_CONNECT_CONF: + return "CONNECT_CONF"; + break; + case NDB_TRANSPORTER_DISCONNECT_ORD: + return "DISCONNECT_ORD"; + break; + } + return "UNKNOWN"; +} + +struct NdbTransporterData +{ + SIGSELECT sigNo; + Uint32 sigId; // Sequence number for this signal + Uint32 senderNodeId; + Uint32 length; + Uint32 data[1]; +}; + +struct NdbTransporterData_PrioA +{ + SIGSELECT sigNo; + Uint32 sigId; // Sequence number for this signal + Uint32 senderNodeId; + Uint32 length; + Uint32 data[1]; +}; + +struct NdbTransporterHunt +{ + SIGSELECT sigNo; + NodeId remoteNodeId; +}; + + +struct NdbTransporterConnectReq +{ + SIGSELECT sigNo; + NodeId remoteNodeId; + NodeId senderNodeId; +}; + + +struct NdbTransporterConnectConf +{ + SIGSELECT sigNo; + NodeId remoteNodeId; + NodeId senderNodeId; +}; + +struct NdbTransporterConnectRef +{ + SIGSELECT sigNo; + NodeId remoteNodeId; + NodeId senderNodeId; + Uint32 reason; + + /** + * Node is not accepting connections + */ + static const Uint32 INVALID_STATE = 1; +}; + +struct NdbTransporterDisconnectOrd +{ + SIGSELECT sigNo; + NodeId senderNodeId; + Uint32 reason; + + /** + * Process died + */ + static const Uint32 PROCESS_DIED = 1; + + /** + * Ndb disconnected + */ + static const Uint32 NDB_DISCONNECT = 2; +}; + +union SIGNAL +{ + SIGSELECT sigNo; + struct NdbTransporterData dataSignal; + struct NdbTransporterData prioAData; + struct NdbTransporterHunt ndbHunt; + struct NdbTransporterConnectReq ndbConnectReq; + struct NdbTransporterConnectRef ndbConnectRef; + struct NdbTransporterConnectConf ndbConnectConf; + struct NdbTransporterDisconnectOrd ndbDisconnect; +}; + +#endif diff --git a/ndb/src/common/transporter/OSE_Transporter.cpp b/ndb/src/common/transporter/OSE_Transporter.cpp new file mode 100644 index 00000000000..a7a5ed81ce2 --- /dev/null +++ b/ndb/src/common/transporter/OSE_Transporter.cpp @@ -0,0 +1,487 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "OSE_Transporter.hpp" +#include "OSE_Signals.hpp" + +#include +#include "TransporterInternalDefinitions.hpp" + +#include + +#include +#include +#include +#include +#include + +OSE_Transporter::OSE_Transporter(int _prioASignalSize, + int _prioBSignalSize, + NodeId localNodeId, + const char * lHostName, + NodeId remoteNodeId, + const char * rHostName, + int byteorder, + bool compression, + bool checksum, + bool signalId, + Uint32 reportFreq) : + Transporter(localNodeId, + remoteNodeId, + byteorder, + compression, + checksum, + signalId), + isServer(localNodeId < remoteNodeId) +{ + + signalIdCounter = 0; + prioBSignalSize = _prioBSignalSize; + + if (strcmp(lHostName, rHostName) == 0){ + snprintf(remoteNodeName, sizeof(remoteNodeName), + "ndb_node%d", remoteNodeId); + } else { + snprintf(remoteNodeName, sizeof(remoteNodeName), + "%s/ndb_node%d", rHostName, remoteNodeId); + } + + prioBSignal = NIL; +} + +OSE_Transporter::~OSE_Transporter() { + +#if 0 + /** + * Don't free these buffers since they have already been freed + * when the process allocating them died (wild pointers) + */ + if(prioBSignal != NIL) + free_buf(&prioBSignal); +#endif +} + +bool +OSE_Transporter::initTransporter() { + + struct OS_pcb * pcb = get_pcb(current_process()); + if(pcb != NULL){ + if(pcb->type != OS_ILLEGAL){ + if(prioBSignalSize > pcb->max_sigsize){ + DEBUG("prioBSignalSize(" << prioBSignalSize << ") > max_sigsize(" + << pcb->max_sigsize << ") using max_sigsize"); + prioBSignalSize = pcb->max_sigsize; + } + } + free_buf((union SIGNAL **)&pcb); + } + + maxPrioBDataSize = prioBSignalSize; + maxPrioBDataSize -= (sizeof(NdbTransporterData) + MAX_MESSAGE_SIZE - 4); + + if(maxPrioBDataSize < 0){ + +#ifdef DEBUG_TRANSPORTER + printf("maxPrioBDataSize < 0 %d\n", + maxPrioBDataSize); +#endif + return false; + } + + initSignals(); + + return true; +} + +void +OSE_Transporter::initSignals(){ + if(prioBSignal == NIL){ + prioBSignal = alloc(prioBSignalSize, NDB_TRANSPORTER_DATA); + prioBInsertPtr = &prioBSignal->dataSignal.data[0]; + + prioBSignal->dataSignal.length = 0; + prioBSignal->dataSignal.senderNodeId = localNodeId; + } + dataToSend = 0; +} + +NdbTransporterData * +OSE_Transporter::allocPrioASignal(Uint32 messageLenBytes) const +{ + + const Uint32 lenBytes = messageLenBytes + sizeof(NdbTransporterData) - 4; + + NdbTransporterData * sig = + (NdbTransporterData*)alloc(lenBytes, NDB_TRANSPORTER_PRIO_A); + + sig->length = 0; + sig->senderNodeId = localNodeId; + + return sig; +} + +Uint32 * +OSE_Transporter::getWritePtr(Uint32 lenBytes, Uint32 prio){ + if(prio >= 1){ + prio = 1; + insertPtr = prioBInsertPtr; + signal = (NdbTransporterData*)prioBSignal; + } else { + signal = allocPrioASignal(lenBytes); + insertPtr = &signal->data[0]; + } + return insertPtr; +} + +void +OSE_Transporter::updateWritePtr(Uint32 lenBytes, Uint32 prio){ + + Uint32 bufferSize = signal->length; + bufferSize += lenBytes; + signal->length = bufferSize; + if(prio >= 1){ + prioBInsertPtr += (lenBytes / 4); + if(bufferSize >= maxPrioBDataSize) + doSend(); + } else { + /** + * Prio A signal are sent directly + */ + signal->sigId = 0; + + ::send((union SIGNAL**)&signal, remoteNodePid); + } +} + +#if 0 +int getSeq(int _seq){ + if (_seq > 0){ + switch (_seq % 100){ + case 10: + return _seq - 1; + case 9: + return _seq + 1; + default: + return _seq; + } + }else{ + return _seq; + } +} +int getSeq(int _seq){ + + switch (_seq % 40){ + case 10: + return _seq-4; + case 9: + return _seq-2; + case 8: + return _seq; + case 7: + return _seq+2; + case 6: + return _seq+4; + + + case 30: + return _seq-9; + case 29: + return _seq-7; + case 28: + return _seq-5; + case 27: + return _seq-3; + case 26: + return _seq-1; + case 25: + return _seq+1; + case 24: + return _seq+3; + case 23: + return _seq+5; + case 22: + return _seq+7; + case 21: + return _seq+9; + + default: + return _seq; + + } +} +#endif + +void +OSE_Transporter::doSend() { + /** + * restore is always called to make sure the signal buffer is taken over + * by a process that is alive, this will otherwise lead to that these buffers + * are removed when the process that allocated them dies + */ + restore(prioBSignal); + if(prioBSignal->dataSignal.length > 0){ + + prioBSignal->dataSignal.sigId = signalIdCounter; + signalIdCounter++; + + ::send(&prioBSignal, remoteNodePid); + } + + initSignals(); +} + +void +OSE_Transporter::doConnect() { + + NdbMutex_Lock(theMutexPtr); + if(_connecting || _disconnecting || _connected){ + NdbMutex_Unlock(theMutexPtr); + return; + } + + _connecting = true; + signalIdCounter = 0; + + if(isServer){ + DEBUG("Waiting for connect req: "); + state = WAITING_FOR_CONNECT_REQ; + } else { + state = WAITING_FOR_HUNT; + + DEBUG("Hunting for: " << remoteNodeName); + + union SIGNAL* huntsig; + huntsig = alloc(sizeof(NdbTransporterHunt), NDB_TRANSPORTER_HUNT); + huntsig->ndbHunt.remoteNodeId = remoteNodeId; + hunt(remoteNodeName, 0, NULL, &huntsig); + } + NdbMutex_Unlock(theMutexPtr); +} + +void +OSE_Transporter::doDisconnect() { + NdbMutex_Lock(theMutexPtr); + + switch(state){ + case DISCONNECTED: + case WAITING_FOR_HUNT: + case WAITING_FOR_CONNECT_REQ: + case WAITING_FOR_CONNECT_CONF: + break; + case CONNECTED: + { +#if 0 + /** + * There should not be anything in the buffer that needs to be sent here + */ + DEBUG("Doing send before disconnect"); + doSend(); +#endif + union SIGNAL * sig = alloc(sizeof(NdbTransporterDisconnectOrd), + NDB_TRANSPORTER_DISCONNECT_ORD); + sig->ndbDisconnect.senderNodeId = localNodeId; + sig->ndbDisconnect.reason = NdbTransporterDisconnectOrd::NDB_DISCONNECT; + ::send(&sig, remoteNodePid); + detach(&remoteNodeRef); + + } + break; + } + state = DISCONNECTED; + + _connected = false; + _connecting = false; + _disconnecting = false; + + NdbMutex_Unlock(theMutexPtr); +} + +void +OSE_Transporter::huntReceived(struct NdbTransporterHunt * sig){ + if(isServer){ + WARNING("Hunt received for server: remoteNodeId: " << + sig->remoteNodeId); + return; + } + + if(state != WAITING_FOR_HUNT){ + WARNING("Hunt received while in state: " << state); + return; + } + remoteNodePid = sender((union SIGNAL**)&sig); + union SIGNAL * signal = alloc(sizeof(NdbTransporterConnectReq), + NDB_TRANSPORTER_CONNECT_REQ); + signal->ndbConnectReq.remoteNodeId = remoteNodeId; + signal->ndbConnectReq.senderNodeId = localNodeId; + + DEBUG("Sending connect req to pid: " << hex << remoteNodePid); + + ::send(&signal, remoteNodePid); + state = WAITING_FOR_CONNECT_CONF; + return; +} + +bool +OSE_Transporter::connectReq(struct NdbTransporterConnectReq * sig){ + if(!isServer){ + WARNING("OSE Connect Req received for client: senderNodeId: " << + sig->senderNodeId); + return false; + } + + if(state != WAITING_FOR_CONNECT_REQ){ + PROCESS pid = sender((union SIGNAL**)&sig); + union SIGNAL * signal = alloc(sizeof(NdbTransporterConnectRef), + NDB_TRANSPORTER_CONNECT_REF); + signal->ndbConnectRef.senderNodeId = localNodeId; + signal->ndbConnectRef.reason = NdbTransporterConnectRef::INVALID_STATE; + + DEBUG("Sending connect ref to pid: " << hex << pid); + + ::send(&signal, pid); + return false; + } + + NdbMutex_Lock(theMutexPtr); + + if(prioBSignal != NIL){ + restore(prioBSignal); + free_buf(&prioBSignal); + } + initSignals(); + + remoteNodePid = sender((union SIGNAL**)&sig); + union SIGNAL * signal = alloc(sizeof(NdbTransporterConnectRef), + NDB_TRANSPORTER_CONNECT_CONF); + signal->ndbConnectConf.senderNodeId = localNodeId; + signal->ndbConnectConf.remoteNodeId = remoteNodeId; + + union SIGNAL * discon = alloc(sizeof(NdbTransporterDisconnectOrd), + NDB_TRANSPORTER_DISCONNECT_ORD); + discon->ndbDisconnect.senderNodeId = remoteNodeId; + discon->ndbDisconnect.reason = NdbTransporterDisconnectOrd::PROCESS_DIED; + + DEBUG("Attaching to pid: " << hex << remoteNodePid); + + remoteNodeRef = attach(&discon, remoteNodePid); + + DEBUG("Sending connect conf to pid: " << hex << remoteNodePid); + + ::send(&signal, remoteNodePid); + state = CONNECTED; + + _connected = true; + _connecting = false; + _disconnecting = false; + + NdbMutex_Unlock(theMutexPtr); + + return true; +} + +bool +OSE_Transporter::connectRef(struct NdbTransporterConnectRef * sig){ + if(isServer){ + WARNING("OSE Connect Ref received for server: senderNodeId: " << + sig->senderNodeId); + return false; + } + if(state != WAITING_FOR_CONNECT_CONF){ + WARNING("OSE Connect Ref received for client while in state: " << + state << " senderNodeId: " << sig->senderNodeId); + return false; + } + doDisconnect(); +#if 0 + /** + * Don't call connect directly, wait until the next time + * checkConnections is called which will trigger a new connect attempt + */ + doConnect(); +#endif + return true; +} + + +bool +OSE_Transporter::connectConf(struct NdbTransporterConnectConf * sig){ + if(isServer){ + WARNING("OSE Connect Conf received for server: senderNodeId: " << + sig->senderNodeId); + return false; + } + if(state != WAITING_FOR_CONNECT_CONF){ + WARNING("OSE Connect Conf received while in state: " << + state); + return false; + } + NdbMutex_Lock(theMutexPtr); + + // Free the buffers to get rid of any "junk" that they might contain + if(prioBSignal != NIL){ + restore(prioBSignal); + free_buf(&prioBSignal); + } + initSignals(); + + union SIGNAL * discon = alloc(sizeof(NdbTransporterDisconnectOrd), + NDB_TRANSPORTER_DISCONNECT_ORD); + discon->ndbDisconnect.senderNodeId = remoteNodeId; + discon->ndbDisconnect.reason= NdbTransporterDisconnectOrd::PROCESS_DIED; + + remoteNodeRef = attach(&discon, remoteNodePid); + + state = CONNECTED; + _connected = true; + _connecting = false; + _disconnecting = false; + + // Free the buffers to get rid of any "junk" that they might contain + if(prioBSignal != NIL){ + restore(prioBSignal); + free_buf(&prioBSignal); + } + initSignals(); + + NdbMutex_Unlock(theMutexPtr); + return true; +} + + +bool +OSE_Transporter::disconnectOrd(struct NdbTransporterDisconnectOrd * sig){ + if(state != CONNECTED){ + WARNING("OSE Disconnect Ord received while in state: " << state << + " reason: " << sig->reason); + return false; + } + + if(sig->reason == NdbTransporterDisconnectOrd::PROCESS_DIED){ + state = DISCONNECTED; + } + + doDisconnect(); + reportDisconnect(callbackObj, remoteNodeId,0); + return true; +} + + + + + + + diff --git a/ndb/src/common/transporter/OSE_Transporter.hpp b/ndb/src/common/transporter/OSE_Transporter.hpp new file mode 100644 index 00000000000..4fd06130477 --- /dev/null +++ b/ndb/src/common/transporter/OSE_Transporter.hpp @@ -0,0 +1,158 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +//**************************************************************************** +// +// AUTHOR +// Magnus Svensson +// +// NAME +// OSE_Transporter +// +// DESCRIPTION +// A OSE_Transporter instance is created when OSE-signal communication +// shall be used (user specified). It handles connect, disconnect, +// send and receive. +// +// +// +//***************************************************************************/ +#ifndef OSE_Transporter_H +#define OSE_Transporter_H + +#include "Transporter.hpp" + +#include "ose.h" + +class OSE_Transporter : public Transporter { + friend class OSE_Receiver; + friend class TransporterRegistry; +public: + + // Initialize member variables + OSE_Transporter(int prioASignalSize, + int prioBSignalSize, + NodeId localNodeId, + const char * lHostName, + NodeId remoteNodeId, + const char * rHostName, + int byteorder, + bool compression, + bool checksum, + bool signalId, + Uint32 reportFreq = 4096); + + // Disconnect, delete send buffers and receive buffer + ~OSE_Transporter(); + + /** + * Allocate buffers for sending and receiving + */ + bool initTransporter(); + + /** + * Connect + */ + virtual void doConnect(); + + /** + * Disconnect + */ + virtual void doDisconnect(); + + Uint32 * getWritePtr(Uint32 lenBytes, Uint32 prio); + void updateWritePtr(Uint32 lenBytes, Uint32 prio); + + /** + * Retrieves the contents of the send buffers, copies it into + * an OSE signal and sends it. Until the send buffers are empty + */ + void doSend(); + + bool hasDataToSend() const { + return prioBSignal->dataSignal.length > 0; + } + +protected: + /** + * Not implemented + * OSE uses async connect/disconnect + */ + virtual bool connectImpl(Uint32 timeOut){ + return false; + } + + /** + * Not implemented + * OSE uses async connect/disconnect + */ + virtual void disconnectImpl(){ + } + +private: + const bool isServer; + + int maxPrioBDataSize; + + /** + * Remote node name + * On same machine: ndb_node1 + * On remote machine: rhost/ndb_node1 + **/ + PROCESS remoteNodePid; + OSATTREF remoteNodeRef; + char remoteNodeName[256]; + + Uint32 signalIdCounter; + + int prioBSignalSize; + + Uint32 * prioBInsertPtr; + union SIGNAL * prioBSignal; + + struct NdbTransporterData * allocPrioASignal(Uint32 lenBytes) const; + + /** + * Statistics + */ + Uint32 reportFreq; + Uint32 receiveCount; + Uint64 receiveSize; + Uint32 sendCount; + Uint64 sendSize; + + void initSignals(); + + /** + * OSE Receiver callbacks + */ + void huntReceived(struct NdbTransporterHunt * sig); + bool connectReq(struct NdbTransporterConnectReq * sig); + bool connectRef(struct NdbTransporterConnectRef * sig); + bool connectConf(struct NdbTransporterConnectConf * sig); + bool disconnectOrd(struct NdbTransporterDisconnectOrd * sig); + + enum OSETransporterState { + DISCONNECTED = 0, + WAITING_FOR_HUNT = 1, + WAITING_FOR_CONNECT_REQ = 2, + WAITING_FOR_CONNECT_CONF = 3, + CONNECTED = 4 + } state; +}; + +// Define of OSE_Transporter_H +#endif diff --git a/ndb/src/common/transporter/Packer.cpp b/ndb/src/common/transporter/Packer.cpp new file mode 100644 index 00000000000..77bd66d1ba9 --- /dev/null +++ b/ndb/src/common/transporter/Packer.cpp @@ -0,0 +1,502 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Packer.hpp" +#include +#include +#include + +#include + +Uint32 +TransporterRegistry::unpack(Uint32 * readPtr, + Uint32 sizeOfData, + NodeId remoteNodeId, + IOState state) { + SignalHeader signalHeader; + LinearSectionPtr ptr[3]; + + Uint32 usedData = 0; + + if(state == NoHalt || state == HaltOutput){ + while(sizeOfData >= 4 + sizeof(Protocol6)){ + Uint32 word1 = readPtr[0]; + Uint32 word2 = readPtr[1]; + Uint32 word3 = readPtr[2]; + +#if 0 + if(Protocol6::getByteOrder(word1) != MY_OWN_BYTE_ORDER){ + //Do funky stuff + } +#endif + + const Uint16 messageLen32 = Protocol6::getMessageLength(word1); + const Uint32 messageLenBytes = ((Uint32)messageLen32) << 2; + + if(messageLen32 == 0 || messageLen32 > MAX_MESSAGE_SIZE){ + DEBUG("Message Size = " << messageLenBytes); + reportError(callbackObj, remoteNodeId, TE_INVALID_MESSAGE_LENGTH); + return usedData; + }//if + + if (sizeOfData < messageLenBytes) { + break; + }//if + + if(Protocol6::getCheckSumIncluded(word1)){ + const Uint32 tmpLen = messageLen32 - 1; + const Uint32 checkSumSent = readPtr[tmpLen]; + const Uint32 checkSumComputed = computeChecksum(&readPtr[0], tmpLen); + + if(checkSumComputed != checkSumSent){ + reportError(callbackObj, remoteNodeId, TE_INVALID_CHECKSUM); + return usedData; + }//if + }//if + +#if 0 + if(Protocol6::getCompressed(word1)){ + //Do funky stuff + }//if +#endif + + Protocol6::createSignalHeader(&signalHeader, word1, word2, word3); + + Uint32 sBlockNum = signalHeader.theSendersBlockRef; + sBlockNum = numberToRef(sBlockNum, remoteNodeId); + signalHeader.theSendersBlockRef = sBlockNum; + + Uint8 prio = Protocol6::getPrio(word1); + + Uint32 * signalData = &readPtr[3]; + + if(Protocol6::getSignalIdIncluded(word1) == 0){ + signalHeader.theSendersSignalId = ~0; + } else { + signalHeader.theSendersSignalId = * signalData; + signalData ++; + }//if + + Uint32 * sectionPtr = signalData + signalHeader.theLength; + Uint32 * sectionData = sectionPtr + signalHeader.m_noOfSections; + for(Uint32 i = 0; i= 4 + sizeof(Protocol6)){ + Uint32 word1 = readPtr[0]; + Uint32 word2 = readPtr[1]; + Uint32 word3 = readPtr[2]; + +#if 0 + if(Protocol6::getByteOrder(word1) != MY_OWN_BYTE_ORDER){ + //Do funky stuff + }//if +#endif + + const Uint16 messageLen32 = Protocol6::getMessageLength(word1); + const Uint32 messageLenBytes = ((Uint32)messageLen32) << 2; + if(messageLen32 == 0 || messageLen32 > MAX_MESSAGE_SIZE){ + DEBUG("Message Size = " << messageLenBytes); + reportError(callbackObj, remoteNodeId, TE_INVALID_MESSAGE_LENGTH); + return usedData; + }//if + + if (sizeOfData < messageLenBytes) { + break; + }//if + + if(Protocol6::getCheckSumIncluded(word1)){ + const Uint32 tmpLen = messageLen32 - 1; + const Uint32 checkSumSent = readPtr[tmpLen]; + const Uint32 checkSumComputed = computeChecksum(&readPtr[0], tmpLen); + + if(checkSumComputed != checkSumSent){ + + //theTransporters[remoteNodeId]->disconnect(); + reportError(callbackObj, remoteNodeId, TE_INVALID_CHECKSUM); + return usedData; + }//if + }//if + +#if 0 + if(Protocol6::getCompressed(word1)){ + //Do funky stuff + }//if +#endif + + Protocol6::createSignalHeader(&signalHeader, word1, word2, word3); + + Uint32 rBlockNum = signalHeader.theReceiversBlockNumber; + + if(rBlockNum == 252){ + Uint32 sBlockNum = signalHeader.theSendersBlockRef; + sBlockNum = numberToRef(sBlockNum, remoteNodeId); + signalHeader.theSendersBlockRef = sBlockNum; + + Uint8 prio = Protocol6::getPrio(word1); + + Uint32 * signalData = &readPtr[3]; + + if(Protocol6::getSignalIdIncluded(word1) == 0){ + signalHeader.theSendersSignalId = ~0; + } else { + signalHeader.theSendersSignalId = * signalData; + signalData ++; + }//if + + Uint32 * sectionPtr = signalData + signalHeader.theLength; + Uint32 * sectionData = sectionPtr + signalHeader.m_noOfSections; + for(Uint32 i = 0; i MAX_MESSAGE_SIZE){ + DEBUG("Message Size(words) = " << messageLen32); + reportError(callbackObj, remoteNodeId, TE_INVALID_MESSAGE_LENGTH); + return readPtr; + }//if + + if(Protocol6::getCheckSumIncluded(word1)){ + const Uint32 tmpLen = messageLen32 - 1; + const Uint32 checkSumSent = readPtr[tmpLen]; + const Uint32 checkSumComputed = computeChecksum(&readPtr[0], tmpLen); + + if(checkSumComputed != checkSumSent){ + reportError(callbackObj, remoteNodeId, TE_INVALID_CHECKSUM); + return readPtr; + }//if + }//if + +#if 0 + if(Protocol6::getCompressed(word1)){ + //Do funky stuff + }//if +#endif + + Protocol6::createSignalHeader(&signalHeader, word1, word2, word3); + + Uint32 sBlockNum = signalHeader.theSendersBlockRef; + sBlockNum = numberToRef(sBlockNum, remoteNodeId); + signalHeader.theSendersBlockRef = sBlockNum; + + Uint8 prio = Protocol6::getPrio(word1); + + Uint32 * signalData = &readPtr[3]; + + if(Protocol6::getSignalIdIncluded(word1) == 0){ + signalHeader.theSendersSignalId = ~0; + } else { + signalHeader.theSendersSignalId = * signalData; + signalData ++; + }//if + + Uint32 * sectionPtr = signalData + signalHeader.theLength; + Uint32 * sectionData = sectionPtr + signalHeader.m_noOfSections; + for(Uint32 i = 0; i MAX_MESSAGE_SIZE){ + DEBUG("Message Size(words) = " << messageLen32); + reportError(callbackObj, remoteNodeId, TE_INVALID_MESSAGE_LENGTH); + return readPtr; + }//if + + if(Protocol6::getCheckSumIncluded(word1)){ + const Uint32 tmpLen = messageLen32 - 1; + const Uint32 checkSumSent = readPtr[tmpLen]; + const Uint32 checkSumComputed = computeChecksum(&readPtr[0], tmpLen); + + if(checkSumComputed != checkSumSent){ + + //theTransporters[remoteNodeId]->disconnect(); + reportError(callbackObj, remoteNodeId, TE_INVALID_CHECKSUM); + return readPtr; + }//if + }//if + +#if 0 + if(Protocol6::getCompressed(word1)){ + //Do funky stuff + }//if +#endif + + Protocol6::createSignalHeader(&signalHeader, word1, word2, word3); + + Uint32 rBlockNum = signalHeader.theReceiversBlockNumber; + + if(rBlockNum == 252){ + Uint32 sBlockNum = signalHeader.theSendersBlockRef; + sBlockNum = numberToRef(sBlockNum, remoteNodeId); + signalHeader.theSendersBlockRef = sBlockNum; + + Uint8 prio = Protocol6::getPrio(word1); + + Uint32 * signalData = &readPtr[3]; + + if(Protocol6::getSignalIdIncluded(word1) == 0){ + signalHeader.theSendersSignalId = ~0; + } else { + signalHeader.theSendersSignalId = * signalData; + signalData ++; + }//if + + Uint32 * sectionPtr = signalData + signalHeader.theLength; + Uint32 * sectionData = sectionPtr + signalHeader.m_noOfSections; + for(Uint32 i = 0; itheLength; + Uint32 no_segs = header->m_noOfSections; + + Uint32 len32 = + dataLen32 + no_segs + + checksumUsed + signalIdUsed + (sizeof(Protocol6)/4); + + + for(Uint32 i = 0; itheSignalId; + tmpInserPtr++; + } + + memcpy(tmpInserPtr, theData, 4 * dataLen32); + + tmpInserPtr += dataLen32; + for(Uint32 i = 0; itheLength; + Uint32 no_segs = header->m_noOfSections; + + Uint32 len32 = + dataLen32 + no_segs + + checksumUsed + signalIdUsed + (sizeof(Protocol6)/4); + + for(Uint32 i = 0; itheSignalId; + tmpInserPtr++; + } + + memcpy(tmpInserPtr, theData, 4 * dataLen32); + + tmpInserPtr += dataLen32; + for(Uint32 i = 0; i +#include "TransporterInternalDefinitions.hpp" + +class Packer { + Uint32 preComputedWord1; + Uint32 checksumUsed; // Checksum shall be included in the message + Uint32 signalIdUsed; // Senders signal id shall be included in the message +public: + Packer(bool signalId, bool checksum); + + Uint32 getMessageLength(const SignalHeader* header, + const LinearSectionPtr ptr[3]) const ; + + + Uint32 getMessageLength(const SignalHeader* header, + const SegmentedSectionPtr ptr[3]) const ; + + void pack(Uint32 * insertPtr, + Uint32 prio, + const SignalHeader* header, + const Uint32* data, + const LinearSectionPtr ptr[3]) const ; + + void pack(Uint32 * insertPtr, + Uint32 prio, + const SignalHeader* header, + const Uint32* data, + class SectionSegmentPool & thePool, + const SegmentedSectionPtr ptr[3]) const ; +}; + +inline +Uint32 +Packer::getMessageLength(const SignalHeader* header, + const LinearSectionPtr ptr[3]) const { + Uint32 tLen32 = header->theLength; + Uint32 no_seg = header->m_noOfSections; + tLen32 += checksumUsed; + tLen32 += signalIdUsed; + tLen32 += no_seg; + + for(Uint32 i = 0; itheLength; + Uint32 no_seg = header->m_noOfSections; + tLen32 += checksumUsed; + tLen32 += signalIdUsed; + tLen32 += no_seg; + + for(Uint32 i = 0; i +#include +#include +#include +#include +#include +#if 0 +#include +#include +#endif +#include "TransporterInternalDefinitions.hpp" +#include + +#define FLAGS 0 + +SCI_Transporter::SCI_Transporter(Uint32 packetSize, + Uint32 bufferSize, + Uint32 nAdapters, + Uint16 remoteSciNodeId0, + Uint16 remoteSciNodeId1, + NodeId _localNodeId, + NodeId _remoteNodeId, + int byte_order, + bool compr, + bool chksm, + bool signalId, + Uint32 reportFreq) : + Transporter(_localNodeId, _remoteNodeId, byte_order, compr, chksm, signalId) +{ + m_PacketSize = (packetSize + 3)/4 ; + m_BufferSize = bufferSize; + m_sendBuffer.m_buffer = NULL; + + m_RemoteSciNodeId = remoteSciNodeId0; + + if(remoteSciNodeId0 == 0 || remoteSciNodeId1 == 0) + m_numberOfRemoteNodes=1; + else + m_numberOfRemoteNodes=2; + + m_RemoteSciNodeId1 = remoteSciNodeId1; + + + m_initLocal=false; + m_remoteNodes= new Uint16[m_numberOfRemoteNodes]; + if(m_remoteNodes == NULL) { + //DO WHAT?? + } + m_swapCounter=0; + m_failCounter=0; + m_remoteNodes[0]=remoteSciNodeId0; + m_remoteNodes[1]=remoteSciNodeId1; + m_adapters = nAdapters; + // The maximum number of times to try and create, + // start and destroy a sequence + m_ActiveAdapterId=0; + m_StandbyAdapterId=1; + + m_mapped = false; + m_sciinit=false; + + sciAdapters= new SciAdapter[nAdapters* (sizeof (SciAdapter))]; + if(sciAdapters==NULL) { + } + m_SourceSegm= new sourceSegm[nAdapters* (sizeof (sourceSegm))]; + if(m_SourceSegm==NULL) { + } + m_TargetSegm= new targetSegm[nAdapters* (sizeof (targetSegm))]; + if(m_TargetSegm==NULL) { + } + m_reportFreq= reportFreq; + + //reset all statistic counters. +#ifdef DEBUG_TRANSPORTER + i1024=0; + i2048=0; + i2049=0; + i10242048=0; + i20484096=0; + i4096=0; + i4097=0; +#endif + +} + + + +void SCI_Transporter::disconnectImpl() +{ + sci_error_t err; + if(m_mapped){ + setDisconnect(); +#ifdef DEBUG_TRANSPORTER + ndbout << "DisconnectImpl " << getConnectionStatus() << endl; + ndbout << "remote node " << remoteNodeId << endl; +#endif + disconnectRemote(); + disconnectLocal(); + } + + // Empty send buffer + + m_sendBuffer.m_dataSize = 0; + + m_initLocal=false; + m_mapped = false; + + if(m_sciinit) { + for(Uint32 i=0; i4096: " << i4097 << endl; + +#endif + +} + + +bool SCI_Transporter::initTransporter() { + if(m_BufferSize < (2*MAX_MESSAGE_SIZE)){ + m_BufferSize = 2 * MAX_MESSAGE_SIZE; + } + + // Allocate buffers for sending + Uint32 sz = 0; + if(m_BufferSize < (m_PacketSize * 4)){ + sz = m_BufferSize + MAX_MESSAGE_SIZE; + } else { + /** + * 3 packages + */ + sz = (m_PacketSize * 4) * 3 + MAX_MESSAGE_SIZE; + } + + m_sendBuffer.m_bufferSize = 4 * ((sz + 3) / 4); + m_sendBuffer.m_buffer = new Uint32[m_sendBuffer.m_bufferSize / 4]; + m_sendBuffer.m_dataSize = 0; + + if(!getLinkStatus(m_ActiveAdapterId) || + !getLinkStatus(m_StandbyAdapterId)) { +#ifdef DEBUG_TRANSPORTER + ndbout << "The link is not fully operational. " << endl; + ndbout << "Check the cables and the switches" << endl; +#endif + //reportDisconnect(remoteNodeId, 0); + //doDisconnect(); + //NDB should terminate + reportError(callbackObj, localNodeId, TE_SCI_LINK_ERROR); + return false; + } + + return true; +} // initTransporter() + + + +Uint32 SCI_Transporter::getLocalNodeId(Uint32 adapterNo) +{ + sci_query_adapter_t queryAdapter; + sci_error_t error; + Uint32 _localNodeId; + + queryAdapter.subcommand = SCI_Q_ADAPTER_NODEID; + queryAdapter.localAdapterNo = adapterNo; + queryAdapter.data = &_localNodeId; + + SCIQuery(SCI_Q_ADAPTER,(void*)(&queryAdapter),(Uint32)NULL,&error); + + if(error != SCI_ERR_OK) + return 0; + return _localNodeId; +} + + +bool SCI_Transporter::getLinkStatus(Uint32 adapterNo) +{ + sci_query_adapter_t queryAdapter; + sci_error_t error; + int linkstatus; + queryAdapter.subcommand = SCI_Q_ADAPTER_LINK_OPERATIONAL; + + queryAdapter.localAdapterNo = adapterNo; + queryAdapter.data = &linkstatus; + + SCIQuery(SCI_Q_ADAPTER,(void*)(&queryAdapter),(Uint32)NULL,&error); + + if(error != SCI_ERR_OK) { +#ifdef DEBUG_TRANSPORTER + ndbout << "error querying adapter " << endl; +#endif + return false; + } + if(linkstatus<=0) + return false; + return true; +} + + + +sci_error_t SCI_Transporter::initLocalSegment() { + Uint32 segmentSize = m_BufferSize; + Uint32 offset = 0; + sci_error_t err; + if(!m_sciinit) { + for(Uint32 i=0; i 0){ +#ifdef DEBUG_TRANSPORTER + if(sizeToSend < 1024 ) + i1024++; + if(sizeToSend > 1024 && sizeToSend < 2048 ) + i10242048++; + if(sizeToSend==2048) + i2048++; + if(sizeToSend>2048 && sizeToSend < 4096) + i20484096++; + if(sizeToSend==4096) + i4096++; + if(sizeToSend==4097) + i4097++; +#endif + if(startSequence(m_ActiveAdapterId)!=SCI_ERR_OK) { +#ifdef DEBUG_TRANSPORTER + ndbout << "Start sequence failed" << endl; +#endif + reportError(callbackObj, remoteNodeId, TE_SCI_UNABLE_TO_START_SEQUENCE); + return false; + } + + + tryagain: + Uint32 * insertPtr = (Uint32 *) + (m_TargetSegm[m_ActiveAdapterId].writer)->getWritePtr(sizeToSend); + + if(insertPtr != 0) { + + const Uint32 remoteOffset=(Uint32) + ((char*)insertPtr - + (char*)(m_TargetSegm[m_ActiveAdapterId].mappedMemory)); + + SCIMemCpy(m_TargetSegm[m_ActiveAdapterId].sequence, + (void*)sendPtr, + m_TargetSegm[m_ActiveAdapterId].rhm[m_ActiveAdapterId].map, + remoteOffset, + sizeToSend, + SCI_FLAG_ERROR_CHECK, + &err); + + + if(err == SCI_ERR_OUT_OF_RANGE) { +#ifdef DEBUG_TRANSPORTER + ndbout << "Data transfer : out of range error \n" << endl; +#endif + goto tryagain; + } + if(err == SCI_ERR_SIZE_ALIGNMENT) { +#ifdef DEBUG_TRANSPORTER + ndbout << "Data transfer : aligne\n" << endl; +#endif + goto tryagain; + } + if(err == SCI_ERR_OFFSET_ALIGNMENT) { +#ifdef DEBUG_TRANSPORTER + ndbout << "Data transfer : offset alignment\n" << endl; +#endif + goto tryagain; + } + if(err == SCI_ERR_TRANSFER_FAILED) { + //(m_TargetSegm[m_StandbyAdapterId].writer)->heavyLock(); + if(getLinkStatus(m_ActiveAdapterId)) { + retry++; + if(retry>3) { + reportError(callbackObj, + remoteNodeId, TE_SCI_UNRECOVERABLE_DATA_TFX_ERROR); + return false; + } + goto tryagain; + } + m_failCounter++; + Uint32 temp=m_ActiveAdapterId; + switch(m_swapCounter) { + case 0: + /**swap from active (0) to standby (1)*/ + if(getLinkStatus(m_StandbyAdapterId)) { +#ifdef DEBUG_TRANSPORTER + ndbout << "Swapping from 0 to 1 " << endl; +#endif + failoverShmWriter(); + SCIStoreBarrier(m_TargetSegm[m_StandbyAdapterId].sequence,0); + m_ActiveAdapterId=m_StandbyAdapterId; + m_StandbyAdapterId=temp; + SCIRemoveSequence((m_TargetSegm[m_StandbyAdapterId].sequence), + FLAGS, + &err); + if(err!=SCI_ERR_OK) { + reportError(callbackObj, + remoteNodeId, TE_SCI_UNABLE_TO_REMOVE_SEQUENCE); + return false; + } + if(startSequence(m_ActiveAdapterId)!=SCI_ERR_OK) { +#ifdef DEBUG_TRANSPORTER + ndbout << "Start sequence failed" << endl; +#endif + reportError(callbackObj, + remoteNodeId, TE_SCI_UNABLE_TO_START_SEQUENCE); + return false; + } + m_swapCounter++; +#ifdef DEBUG_TRANSPORTER + ndbout << "failover complete.." << endl; +#endif + goto tryagain; + } else { + reportError(callbackObj, + remoteNodeId, TE_SCI_UNRECOVERABLE_DATA_TFX_ERROR); + return false; + } + return false; + break; + case 1: + /** swap back from 1 to 0 + must check that the link is up */ + + if(getLinkStatus(m_StandbyAdapterId)) { + failoverShmWriter(); + m_ActiveAdapterId=m_StandbyAdapterId; + m_StandbyAdapterId=temp; +#ifdef DEBUG_TRANSPORTER + ndbout << "Swapping from 1 to 0 " << endl; +#endif + if(createSequence(m_ActiveAdapterId)!=SCI_ERR_OK) { + reportError(callbackObj, + remoteNodeId, TE_SCI_UNABLE_TO_CREATE_SEQUENCE); + return false; + } + if(startSequence(m_ActiveAdapterId)!=SCI_ERR_OK) { +#ifdef DEBUG_TRANSPORTER + ndbout << "startSequence failed... disconnecting" << endl; +#endif + reportError(callbackObj, + remoteNodeId, TE_SCI_UNABLE_TO_START_SEQUENCE); + return false; + } + + SCIRemoveSequence((m_TargetSegm[m_StandbyAdapterId].sequence) + , FLAGS, + &err); + if(err!=SCI_ERR_OK) { + reportError(callbackObj, + remoteNodeId, TE_SCI_UNABLE_TO_REMOVE_SEQUENCE); + return false; + } + + if(createSequence(m_StandbyAdapterId)!=SCI_ERR_OK) { + reportError(callbackObj, + remoteNodeId, TE_SCI_UNABLE_TO_CREATE_SEQUENCE); + return false; + } + + m_swapCounter=0; + +#ifdef DEBUG_TRANSPORTER + ndbout << "failover complete.." << endl; +#endif + goto tryagain; + + } else { + reportError(callbackObj, + remoteNodeId, TE_SCI_UNRECOVERABLE_DATA_TFX_ERROR); + return false; + } + + break; + default: + reportError(callbackObj, + remoteNodeId, TE_SCI_UNRECOVERABLE_DATA_TFX_ERROR); + return false; + break; + } + } else { + SHM_Writer * writer = (m_TargetSegm[m_ActiveAdapterId].writer); + writer->updateWritePtr(sizeToSend); + + Uint32 sendLimit = writer->getBufferSize(); + sendLimit -= writer->getWriteIndex(); + + m_sendBuffer.m_dataSize = 0; + m_sendBuffer.m_forceSendLimit = sendLimit; + } + + } else { + /** + * If we end up here, the SCI segment is full. + */ +#ifdef DEBUG_TRANSPORTER + ndbout << "the segment is full for some reason" << endl; +#endif + return false; + } //if + } + + return true; +} // doSend() + + + +void SCI_Transporter::failoverShmWriter() { +#if 0 + (m_TargetSegm[m_StandbyAdapterId].writer) + ->copyIndexes((m_TargetSegm[m_StandbyAdapterId].writer)); +#endif +} //failoverShm + + +void SCI_Transporter::setupLocalSegment() +{ + + Uint32 sharedSize = 0; + sharedSize += 16; //SHM_Reader::getSharedSize(); + sharedSize += 16; //SHM_Writer::getSharedSize(); + sharedSize += 32; //SHM_Writer::getSharedSize(); + sharedSize =4096; //start of the buffer is page aligend + + Uint32 sizeOfBuffer = m_BufferSize; + + sizeOfBuffer -= sharedSize; + + Uint32 * localReadIndex = + (Uint32*)m_SourceSegm[m_ActiveAdapterId].mappedMemory; + Uint32 * localWriteIndex = + (Uint32*)(localReadIndex+ 1); + + Uint32 * localEndOfDataIndex = (Uint32*) + (localReadIndex + 2); + + m_localStatusFlag = (Uint32*)(localReadIndex + 3); + + Uint32 * sharedLockIndex = (Uint32*) + (localReadIndex + 4); + + Uint32 * sharedHeavyLock = (Uint32*) + (localReadIndex + 5); + + char * localStartOfBuf = (char*) + ((char*)m_SourceSegm[m_ActiveAdapterId].mappedMemory+sharedSize); + + + * localReadIndex = * localWriteIndex = 0; + * localEndOfDataIndex = sizeOfBuffer -1; + + const Uint32 slack = MAX_MESSAGE_SIZE; + + reader = new SHM_Reader(localStartOfBuf, + sizeOfBuffer, + slack, + localReadIndex, + localWriteIndex); + + * localReadIndex = 0; + * localWriteIndex = 0; + + reader->clear(); +} //setupLocalSegment + + + +void SCI_Transporter::setupRemoteSegment() +{ + Uint32 sharedSize = 0; + sharedSize += 16; //SHM_Reader::getSharedSize(); + sharedSize += 16; //SHM_Writer::getSharedSize(); + sharedSize += 32; + sharedSize =4096; //start of the buffer is page aligend + + + Uint32 sizeOfBuffer = m_BufferSize; + sizeOfBuffer -= sharedSize; + Uint32 * segPtr = (Uint32*) m_TargetSegm[m_StandbyAdapterId].mappedMemory ; + + Uint32 * remoteReadIndex2 = (Uint32*)segPtr; + Uint32 * remoteWriteIndex2 = (Uint32*) (segPtr + 1); + Uint32 * remoteEndOfDataIndex2 = (Uint32*) (segPtr + 2); + Uint32 * sharedLockIndex2 = (Uint32*) (segPtr + 3); + m_remoteStatusFlag2 = (Uint32*)(segPtr + 4); + Uint32 * sharedHeavyLock2 = (Uint32*) (segPtr + 5); + + + char * remoteStartOfBuf2 = ( char*)((char *)segPtr+sharedSize); + + segPtr = (Uint32*) m_TargetSegm[m_ActiveAdapterId].mappedMemory ; + + Uint32 * remoteReadIndex = (Uint32*)segPtr; + Uint32 * remoteWriteIndex = (Uint32*) (segPtr + 1); + Uint32 * remoteEndOfDataIndex = (Uint32*) (segPtr + 2); + Uint32 * sharedLockIndex = (Uint32*) (segPtr + 3); + m_remoteStatusFlag = (Uint32*)(segPtr + 4); + Uint32 * sharedHeavyLock = (Uint32*) (segPtr + 5); + + char * remoteStartOfBuf = ( char*)((char*)segPtr+(sharedSize)); + + * remoteReadIndex = * remoteWriteIndex = 0; + * remoteReadIndex2 = * remoteWriteIndex2 = 0; + * remoteEndOfDataIndex = sizeOfBuffer - 1; + * remoteEndOfDataIndex2 = sizeOfBuffer - 1; + + /** + * setup two writers. writer2 is used to mirror the changes of + * writer on the standby + * segment, so that in the case of a failover, we can switch + * to the stdby seg. quickly.* + */ + const Uint32 slack = MAX_MESSAGE_SIZE; + + writer = new SHM_Writer(remoteStartOfBuf, + sizeOfBuffer, + slack, + remoteReadIndex, + remoteWriteIndex); + + writer2 = new SHM_Writer(remoteStartOfBuf2, + sizeOfBuffer, + slack, + remoteReadIndex2, + remoteWriteIndex2); + + * remoteReadIndex = 0; + * remoteWriteIndex = 0; + + writer->clear(); + writer2->clear(); + + m_TargetSegm[0].writer=writer; + m_TargetSegm[1].writer=writer2; + + m_sendBuffer.m_forceSendLimit = writer->getBufferSize(); + + if(createSequence(m_ActiveAdapterId)!=SCI_ERR_OK) { + reportThreadError(remoteNodeId, TE_SCI_UNABLE_TO_CREATE_SEQUENCE); + doDisconnect(); + } + if(createSequence(m_StandbyAdapterId)!=SCI_ERR_OK) { + reportThreadError(remoteNodeId, TE_SCI_UNABLE_TO_CREATE_SEQUENCE); + doDisconnect(); + } + + +} //setupRemoteSegment + + +bool SCI_Transporter::connectImpl(Uint32 timeout) { + + sci_error_t err; + Uint32 offset = 0; + + if(!m_initLocal) { + if(initLocalSegment()!=SCI_ERR_OK){ + NdbSleep_MilliSleep(timeout); + //NDB SHOULD TERMINATE AND COMPUTER REBOOTED! + reportThreadError(localNodeId, TE_SCI_CANNOT_INIT_LOCALSEGMENT); + return false; + } + m_initLocal=true; + } + + if(!m_mapped ) { + + for(Uint32 i=0; i < m_adapters ; i++) { + m_TargetSegm[i].rhm[i].remoteHandle=0; + SCIConnectSegment(sciAdapters[i].scidesc, + &(m_TargetSegm[i].rhm[i].remoteHandle), + m_remoteNodes[i], + remoteSegmentId(localNodeId, remoteNodeId), + i, + 0, + 0, + 0, + 0, + &err); + + if(err != SCI_ERR_OK) { + NdbSleep_MilliSleep(timeout); + return false; + } + + } + + + // Map the remote memory segment into program space + for(Uint32 i=0; i < m_adapters ; i++) { + m_TargetSegm[i].mappedMemory = + SCIMapRemoteSegment((m_TargetSegm[i].rhm[i].remoteHandle), + &(m_TargetSegm[i].rhm[i].map), + offset, + m_BufferSize, + NULL, + FLAGS, + &err); + + + if(err!= SCI_ERR_OK) { +#ifdef DEBUG_TRANSPORTER + ndbout_c("\nCannot map a segment to the remote node %d."); + ndbout_c("Error code 0x%x",m_RemoteSciNodeId, err); +#endif + //NDB SHOULD TERMINATE AND COMPUTER REBOOTED! + reportThreadError(remoteNodeId, TE_SCI_CANNOT_MAP_REMOTESEGMENT); + return false; + } + + + } + m_mapped=true; + setupRemoteSegment(); + setConnected(); +#ifdef DEBUG_TRANSPORTER + ndbout << "connected and mapped to segment : " << endl; + ndbout << "remoteNode: " << m_remoteNodes[0] << endl; + ndbout << "remoteNode: " << m_remotenodes[1] << endl; + ndbout << "remoteSegId: " + << remoteSegmentId(localNodeId, remoteNodeId) + << endl; +#endif + return true; + } + else { + return getConnectionStatus(); + } +} // connectImpl() + + +sci_error_t SCI_Transporter::createSequence(Uint32 adapterid) { + sci_error_t err; + SCICreateMapSequence((m_TargetSegm[adapterid].rhm[adapterid].map), + &(m_TargetSegm[adapterid].sequence), + SCI_FLAG_FAST_BARRIER, + &err); + + + return err; +} // createSequence() + + +sci_error_t SCI_Transporter::startSequence(Uint32 adapterid) { + + sci_error_t err; + /** Perform preliminary error check on an SCI adapter before starting a + * sequence of read and write operations on the mapped segment. + */ + m_SequenceStatus = SCIStartSequence( + (m_TargetSegm[adapterid].sequence), + FLAGS, &err); + + + // If there still is an error then data cannot be safely send + return err; +} // startSequence() + + + +bool SCI_Transporter::disconnectLocal() +{ + sci_error_t err; + m_ActiveAdapterId=0; + + /** Free resources used by a local segment + */ + + SCIUnmapSegment(m_SourceSegm[0].lhm[0].map,0,&err); + if(err!=SCI_ERR_OK) { + reportError(callbackObj, + remoteNodeId, TE_SCI_UNABLE_TO_UNMAP_SEGMENT); + return false; + } + + SCIRemoveSegment((m_SourceSegm[m_ActiveAdapterId].localHandle), + FLAGS, + &err); + + if(err!=SCI_ERR_OK) { + reportError(callbackObj, remoteNodeId, TE_SCI_UNABLE_TO_REMOVE_SEGMENT); + return false; + } + + if(err == SCI_ERR_OK) { +#ifdef DEBUG_TRANSPORTER + printf("Local memory segment is unmapped and removed\n" ); +#endif + } + return true; +} // disconnectLocal() + + +bool SCI_Transporter::disconnectRemote() { + sci_error_t err; + for(Uint32 i=0; i m_PacketSize) { + /**------------------------------------------------- + * Buffer is full and we are ready to send. We will + * not wait since the signal is already in the buffer. + * Force flag set has the same indication that we + * should always send. If it is not possible to send + * we will not worry since we will soon be back for + * a renewed trial. + *------------------------------------------------- + */ + doSend(); + } +} + +enum SciStatus { + SCIDISCONNECT = 1, + SCICONNECTED = 2 +}; + +bool +SCI_Transporter::getConnectionStatus() { + if(*m_localStatusFlag == SCICONNECTED && + (*m_remoteStatusFlag == SCICONNECTED || + *m_remoteStatusFlag2 == SCICONNECTED)) + return true; + else + return false; +} + + +void +SCI_Transporter::setConnected() { + *m_remoteStatusFlag = SCICONNECTED; + *m_remoteStatusFlag2 = SCICONNECTED; + *m_localStatusFlag = SCICONNECTED; +} + + +void +SCI_Transporter::setDisconnect() { + if(getLinkStatus(m_ActiveAdapterId)) + *m_remoteStatusFlag = SCIDISCONNECT; + if(getLinkStatus(m_StandbyAdapterId)) + *m_remoteStatusFlag2 = SCIDISCONNECT; +} + + +bool +SCI_Transporter::checkConnected() { + if (*m_localStatusFlag == SCIDISCONNECT) { + return false; + } + else + return true; +} + +static bool init = false; + +bool +SCI_Transporter::initSCI() { + if(!init){ + sci_error_t error; + // Initialize SISCI library + SCIInitialize(0, &error); + if(error != SCI_ERR_OK) { +#ifdef DEBUG_TRANSPORTER + ndbout_c("\nCannot initialize SISCI library."); + ndbout_c("\nInconsistency between SISCI library and SISCI driver.Error code 0x%x", error); +#endif + return false; + } + init = true; + } + return true; +} + + + + + diff --git a/ndb/src/common/transporter/SCI_Transporter.hpp b/ndb/src/common/transporter/SCI_Transporter.hpp new file mode 100644 index 00000000000..03496c2ce21 --- /dev/null +++ b/ndb/src/common/transporter/SCI_Transporter.hpp @@ -0,0 +1,390 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SCI_Transporter_H +#define SCI_Transporter_H +#include "Transporter.hpp" +#include "SHM_Buffer.hpp" + + +#include +#include +#include + +#include + + /** + * The SCI Transporter + * + * The design goal of the SCI transporter is to deliver high performance + * data transfers (low latency, high bandwidth) combined with very high + * availability (failover support). + * High performance is an inherit feature of SCI and the, whereas failover + * support is implemented at the application level. + * In SCI the programming model is similar to the shared memory paradigm. + * A process on one node (A) allocates a memory segment and import the + * segment to its virtual address space. Another node (B) can connect to + * the segment and map this segment into its virtual address space. + * If A writes data to the segment, then B can read it and vice versa, through + * ordinary loads and stores. This is also called PIO (programmable IO), and + * is one thing that distinguish SCI from other interconnects such as, + * ethernet, Gig-e, Myrinet, and Infiniband. By using PIO, lower network + * latency is achieved, compared to the interconnects mentioned above. + * In order for NDB to utilize SCI, the SCI transporter relies on the + * SISCI api. The SISCI api provides a high level abstraction to the low + * level SCI driver called PCISCI driver. + * The SISCI api provides functions to setup, export, and import + * memory segments in a process virtual address space, and also functions to + * guarantee the correctness of data transfers between nodes. Basically, the + * + * In NDB Cluster, each SCI transporter creates a local segment + * that is mapped into the virtual address space. After the creation of the + * local segment, the SCI transporter connects to a segment created by another + * transporter at a remote node, and the maps the remote segment into its + * virtual address space. However, since NDB Cluster relies on redundancy + * at the network level, by using dual SCI adapters communica + * + * + */ + + +/** + * class SCITransporter + * @brief - main class for the SCI transporter. + */ +class SCI_Transporter : public Transporter { + friend class TransporterRegistry; +public: + + /** + * Init the transporter. Allocate sendbuffers and open a SCI virtual device + * for each adapter. + * @return true if successful, otherwize false + */ + bool initTransporter(); + + + /** + * Creates a sequence for error checking. + * @param adapterid the adapter on which to create a new sequence. + * @return SCI_ERR_OK if ok, otherwize something else. + */ + sci_error_t createSequence(Uint32 adapterid); + + + /** + * starts a sequence for error checking. + * The actual checking that a sequence is correct is done implicitly + * in SCIMemCpy (in doSend). + * @param adapterid the adapter on which to start the sequence. + * @return SCI_ERR_OK if ok, otherwize something else. + */ + sci_error_t startSequence(Uint32 adapterid); + + + /** Initiate Local Segment: create a memory segment, + * prepare a memory segment, map the local segment + * into memory space and make segment available. + * @return SCI_ERR_OK if ok, otherwize something else. + */ + sci_error_t initLocalSegment(); + + /** + * Calculate the segment id for the remote segment + * @param localNodeId - local id (e.g. 1 = mgm , 2 = ndb.2 etc.) + * @param remoteNodeId - remote id (e.g. 1 = mgm , 2 = ndb.2 etc.) + * @return a segment id + */ + Uint32 remoteSegmentId(Uint16 localNodeId, Uint16 remoteNodeId); + + // Get local segment id (inline) + Uint32 hostSegmentId(Uint16 localNodeId, Uint16 remoteNodeId); + + /** + * closeSCI closes the SCI virtual device + */ + void closeSCI(); + + + /** + * Check the status of the remote node, + * if it is connected or has disconnected + * @return true if connected, otherwize false. + */ + bool checkConnected(); + + /** + * Check if the segment are properly connected to each other (remotely + * and locally). + * @return True if the both the local segment is mapped and the + * remote segment is mapped. Otherwize false. + */ + bool getConnectionStatus(); + +private: + SCI_Transporter(Uint32 packetSize, + Uint32 bufferSize, + Uint32 nAdapters, + Uint16 remoteSciNodeId0, + Uint16 remoteSciNodeId1, + NodeId localNodeID, + NodeId remoteNodeID, + int byteorder, + bool compression, + bool checksum, + bool signalId, + Uint32 reportFreq = 4096); + + /** + * Destructor. Disconnects the transporter. + */ + ~SCI_Transporter(); + bool m_mapped; + bool m_initLocal; + bool m_sciinit; + Uint32 m_swapCounter; + Uint32 m_failCounter; + /** + * For statistics on transfered packets + */ +#ifdef DEBUG_TRANSPORTER + Uint32 i1024; + Uint32 i2048; + Uint32 i2049; + Uint32 i10242048; + Uint32 i20484096; + Uint32 i4096; + Uint32 i4097; +#endif + + volatile Uint32 * m_localStatusFlag; + volatile Uint32 * m_remoteStatusFlag; + volatile Uint32 * m_remoteStatusFlag2; + + struct { + Uint32 * m_buffer; // The buffer + Uint32 m_dataSize; // No of words in buffer + Uint32 m_bufferSize; // Buffer size + Uint32 m_forceSendLimit; // Send when buffer is this full + + bool full() const { return (m_dataSize * 4) > m_forceSendLimit ;} + } m_sendBuffer; + + SHM_Reader * reader; + SHM_Writer * writer; + SHM_Writer * writer2; + + /** + * Statistics + */ + Uint32 m_reportFreq; + + + Uint32 m_adapters; + Uint32 m_numberOfRemoteNodes; + + Uint16* m_remoteNodes; + + typedef struct SciAdapter { + sci_desc_t scidesc; + Uint32 localSciNodeId; + bool linkStatus; + } SciAdapter; + + SciAdapter* sciAdapters; + Uint32 m_ActiveAdapterId; + Uint32 m_StandbyAdapterId; + + typedef struct sourceSegm { + sci_local_segment_t localHandle; // Handle to local segment to be mapped + struct localHandleMap { + sci_map_t map; // Handle to the new mapped segment. + // 2 = max adapters in one node + } lhm[2]; + + volatile void *mappedMemory; // Used when reading + } sourceSegm; + + typedef struct targetSegm { + struct remoteHandleMap { + sci_remote_segment_t remoteHandle; //Handle to local segment to be mapped + sci_map_t map; //Handle to the new mapped segment + } rhm[2]; + + sci_sequence_status_t m_SequenceStatus; // Used for error checking + sci_sequence_t sequence; + volatile void * mappedMemory; // Used when writing + SHM_Writer * writer; + } targetSegm; + + sci_sequence_status_t m_SequenceStatus; // Used for error checking + + + // Shared between all SCI users active=(either prim or second) + sci_desc_t activeSCIDescriptor; + + sourceSegm* m_SourceSegm; // Local segment reference + targetSegm* m_TargetSegm; // Remote segment reference + + Uint32 m_LocalAdapterId; // Adapter Id + Uint16 m_LocalSciNodeId; // The SCI-node Id of this machine (adapter 0) + Uint16 m_LocalSciNodeId1; // The SCI-node Id of this machine (adapter 1) + Uint16 m_RemoteSciNodeId; // The SCI-node Id of remote machine (adapter 0) + Uint16 m_RemoteSciNodeId1; // The SCI-node Id of remote machine (adapter 1) + + Uint32 m_PacketSize; // The size of each data packet + Uint32 m_BufferSize; // Mapped SCI buffer size + + Uint32 * getWritePtr(Uint32 lenBytes, Uint32 prio); + void updateWritePtr(Uint32 lenBytes, Uint32 prio); + + /** + * doSend. Copies the data from the source (the send buffer) to the + * shared mem. segment. + * Sequences are used for error checking. + * If an error occurs, the transfer is retried. + * If the link that we need to swap to is broken, we will disconnect. + * @return Returns true if datatransfer ok. If not retriable + * then false is returned. + */ + bool doSend(); + + /** + * @param adapterNo the adapter for which to retrieve the node id. + * @return Returns the node id for an adapter. + */ + Uint32 getLocalNodeId(Uint32 adapterNo); + + bool hasDataToRead() const { + return reader->empty() == false; + } + + bool hasDataToSend() const { + return m_sendBuffer.m_dataSize > 0; + } + + /** + * Make the local segment unavailable, no new connections will be accepted. + * @return Returns true if the segment was successfully disconnected. + */ + bool disconnectLocal(); + + /** + * Make the local segment unavailable, no new connections will be accepted. + * @return Returns true if the segment was successfully disconnected. + */ + bool disconnectRemote(); + + void resetToInitialState(); + + /** + * It is always possible to send data with SCI! + * @return True (always) + */ + bool sendIsPossible(struct timeval * timeout); + + + void getReceivePtr(Uint32 ** ptr, Uint32 ** eod){ + reader->getReadPtr(* ptr, * eod); + } + + void updateReceivePtr(Uint32 * ptr){ + reader->updateReadPtr(ptr); + } + + /** + * Corresponds to SHM_Transporter::setupBuffers() + * Initiates the start pointer of the buffer and read pointers. + * Initiate the localSegment for the SHM reader. + */ + void setupLocalSegment(); + + /** + * Initiate the remoteSegment for the SHM writer + */ + void setupRemoteSegment(); + + /** + * Set the connect flag in the remote memory segment (write through) + */ + void setConnected(); + + /** + * Set the disconnect flag in the remote memory segment (write through) + */ + void setDisconnect(); + + /** + * Check if there is a link between the adapter and the switch + * @param adapterNo the adapter for which to retrieve the link status. + * @return Returns true if there is a link between adapter and switch. + * Otherwize false is returned and the cables must be checked. + */ + bool getLinkStatus(Uint32 adapterNo); + + /** + * failoverShmWriter takes the state of the active writer and inserts into + * the standby writer. + */ + void failoverShmWriter(); + + +protected: + + /** Perform a connection between segment + * This is a client node, trying to connect to a remote segment. + * @param timeout, the time the connect thread sleeps before + * retrying. + * @return Returns true on success, otherwize falser + */ + bool connectImpl(Uint32 timeOutMillis); + + /** + * We will disconnect if: + * -# the other node has disconnected from us + * -# unrecoverable error in transmission, on both adapters + * -# if we are shutdown properly + */ + void disconnectImpl(); + + static bool initSCI(); +}; + + +/** The theLocalAdapterId combined with the theRemoteNodeId constructs + * (SCI ids)* a unique identifier for the local segment + */ +inline +Uint32 +SCI_Transporter::hostSegmentId(Uint16 SciLocalNodeId, + Uint16 SciRemoteNodeId) { + + return (SciLocalNodeId << 16) | SciRemoteNodeId; +} + +/** The theLocalAdapterId combined with the theRemoteNodeId constructs + * (SCI ids)* a unique identifier for the remote segment + */ +inline +Uint32 +SCI_Transporter::remoteSegmentId(Uint16 SciLocalNodeId, + Uint16 SciRemoteNodeId) { + + return (SciRemoteNodeId << 16) | SciLocalNodeId; +} + + +#endif diff --git a/ndb/src/common/transporter/SHM_Buffer.hpp b/ndb/src/common/transporter/SHM_Buffer.hpp new file mode 100644 index 00000000000..43250853fee --- /dev/null +++ b/ndb/src/common/transporter/SHM_Buffer.hpp @@ -0,0 +1,217 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SHM_BUFFER_HPP +#define SHM_BUFFER_HPP + +#include +#include +#include +#include + +/** + * These classes implement a circular buffer + * + * One reader and one writer + */ + +/** + * SHM_Reader + * + * Use as follows: + * getReadPtr(ptr, sz); + * for(int i = 0; i= m_bufferSize){ + tReadIndex = 0; //-= m_bufferSize; + } + + m_readIndex = tReadIndex; + * m_sharedReadIndex = tReadIndex; +} + +#define WRITER_SLACK 4 + +class SHM_Writer { +public: + SHM_Writer(char * const _startOfBuffer, + Uint32 _sizeOfBuffer, + Uint32 _slack, + Uint32 * _readIndex, + Uint32 * _writeIndex) : + m_startOfBuffer(_startOfBuffer), + m_totalBufferSize(_sizeOfBuffer), + m_bufferSize(_sizeOfBuffer - _slack), + m_sharedReadIndex(_readIndex), + m_sharedWriteIndex(_writeIndex) + { + } + + void clear() { + m_writeIndex = * m_sharedWriteIndex; + } + + inline char * getWritePtr(Uint32 sz); + inline void updateWritePtr(Uint32 sz); + + inline Uint32 getWriteIndex() const { return m_writeIndex;} + inline Uint32 getBufferSize() const { return m_bufferSize;} + + inline void copyIndexes(SHM_Writer * standbyWriter); + +private: + char * const m_startOfBuffer; + Uint32 m_totalBufferSize; + Uint32 m_bufferSize; + + Uint32 m_writeIndex; + + Uint32 * m_sharedReadIndex; + Uint32 * m_sharedWriteIndex; +}; + +inline +char * +SHM_Writer::getWritePtr(Uint32 sz){ + Uint32 tReadIndex = * m_sharedReadIndex; + Uint32 tWriteIndex = m_writeIndex; + + char * ptr = &m_startOfBuffer[tWriteIndex]; + + Uint32 free; + if(tReadIndex <= tWriteIndex){ + free = m_bufferSize + tReadIndex - tWriteIndex; + } else { + free = tReadIndex - tWriteIndex; + } + + sz += 4; + if(sz < free){ + return ptr; + } + + return 0; +} + +inline +void +SHM_Writer::updateWritePtr(Uint32 sz){ + + assert(m_writeIndex == * m_sharedWriteIndex); + + Uint32 tWriteIndex = m_writeIndex; + tWriteIndex += sz; + + assert(tWriteIndex < m_totalBufferSize); + + if(tWriteIndex >= m_bufferSize){ + tWriteIndex = 0; //-= m_bufferSize; + } + + m_writeIndex = tWriteIndex; + * m_sharedWriteIndex = tWriteIndex; +} + +#endif diff --git a/ndb/src/common/transporter/SHM_Transporter.cpp b/ndb/src/common/transporter/SHM_Transporter.cpp new file mode 100644 index 00000000000..f18b775efa4 --- /dev/null +++ b/ndb/src/common/transporter/SHM_Transporter.cpp @@ -0,0 +1,238 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "SHM_Transporter.hpp" +#include "TransporterInternalDefinitions.hpp" +#include +#include +#include + +#include +#include + +#ifdef NDB_WIN32 +#include +#else +#include +#include +#endif + + +SHM_Transporter::SHM_Transporter(NodeId lNodeId, + NodeId rNodeId, + key_t _shmKey, + Uint32 _shmSize, + bool compression, + bool checksum, + bool signalId) : + Transporter(lNodeId, + rNodeId, + 0, + compression, + checksum, + signalId), + isServer(lNodeId < rNodeId), + shmKey(_shmKey), + shmSize(_shmSize) +{ + _shmSegCreated = false; + _attached = false; + + shmBuf = 0; + reader = 0; + writer = 0; + + setupBuffersDone=false; +#ifdef DEBUG_TRANSPORTER + printf("shm key (%d - %d) = %d\n", lNodeId, rNodeId, shmKey); +#endif +} + +SHM_Transporter::~SHM_Transporter(){ + doDisconnect(); +} + +bool +SHM_Transporter::initTransporter(){ + return true; +} + +bool +SHM_Transporter::connectImpl(Uint32 timeOutMillis){ + bool res; + if(isServer) + res = connectServer(timeOutMillis); + else + res = connectClient(timeOutMillis); + return res; +} + +void +SHM_Transporter::setupBuffers(){ + Uint32 sharedSize = 0; + sharedSize += 28; //SHM_Reader::getSharedSize(); + sharedSize += 28; //SHM_Writer::getSharedSize(); + + const Uint32 slack = MAX_MESSAGE_SIZE; + + /** + * NOTE: There is 7th shared variable in Win2k (sharedCountAttached). + */ + Uint32 sizeOfBuffer = shmSize; + sizeOfBuffer -= 2*sharedSize; + sizeOfBuffer /= 2; + + Uint32 * base1 = (Uint32*)shmBuf; + + Uint32 * sharedReadIndex1 = base1; + Uint32 * sharedWriteIndex1 = base1 + 1; + serverStatusFlag = base1 + 4; + char * startOfBuf1 = shmBuf+sharedSize; + + Uint32 * base2 = (Uint32*)(shmBuf + sizeOfBuffer + sharedSize); + Uint32 * sharedReadIndex2 = base2; + Uint32 * sharedWriteIndex2 = base2 + 1; + clientStatusFlag = base2 + 4; + char * startOfBuf2 = ((char *)base2)+sharedSize; + + * sharedReadIndex2 = * sharedWriteIndex2 = 0; + + if(isServer){ + * serverStatusFlag = 0; + reader = new SHM_Reader(startOfBuf1, + sizeOfBuffer, + slack, + sharedReadIndex1, + sharedWriteIndex1); + + writer = new SHM_Writer(startOfBuf2, + sizeOfBuffer, + slack, + sharedReadIndex2, + sharedWriteIndex2); + + * sharedReadIndex1 = 0; + * sharedWriteIndex2 = 0; + + * sharedReadIndex2 = 0; + * sharedWriteIndex1 = 0; + + reader->clear(); + writer->clear(); + + * serverStatusFlag = 1; + +#ifdef DEBUG_TRANSPORTER + printf("-- (%d - %d) - Server -\n", localNodeId, remoteNodeId); + printf("Reader at: %d (%p)\n", startOfBuf1 - shmBuf, startOfBuf1); + printf("sharedReadIndex1 at %d (%p) = %d\n", + (char*)sharedReadIndex1-shmBuf, + sharedReadIndex1, *sharedReadIndex1); + printf("sharedWriteIndex1 at %d (%p) = %d\n", + (char*)sharedWriteIndex1-shmBuf, + sharedWriteIndex1, *sharedWriteIndex1); + + printf("Writer at: %d (%p)\n", startOfBuf2 - shmBuf, startOfBuf2); + printf("sharedReadIndex2 at %d (%p) = %d\n", + (char*)sharedReadIndex2-shmBuf, + sharedReadIndex2, *sharedReadIndex2); + printf("sharedWriteIndex2 at %d (%p) = %d\n", + (char*)sharedWriteIndex2-shmBuf, + sharedWriteIndex2, *sharedWriteIndex2); + + printf("sizeOfBuffer = %d\n", sizeOfBuffer); +#endif + } else { + * clientStatusFlag = 0; + reader = new SHM_Reader(startOfBuf2, + sizeOfBuffer, + slack, + sharedReadIndex2, + sharedWriteIndex2); + + writer = new SHM_Writer(startOfBuf1, + sizeOfBuffer, + slack, + sharedReadIndex1, + sharedWriteIndex1); + + * sharedReadIndex2 = 0; + * sharedWriteIndex1 = 0; + + reader->clear(); + writer->clear(); + * clientStatusFlag = 1; +#ifdef DEBUG_TRANSPORTER + printf("-- (%d - %d) - Client -\n", localNodeId, remoteNodeId); + printf("Reader at: %d (%p)\n", startOfBuf2 - shmBuf, startOfBuf2); + printf("sharedReadIndex2 at %d (%p) = %d\n", + (char*)sharedReadIndex2-shmBuf, + sharedReadIndex2, *sharedReadIndex2); + printf("sharedWriteIndex2 at %d (%p) = %d\n", + (char*)sharedWriteIndex2-shmBuf, + sharedWriteIndex2, *sharedWriteIndex2); + + printf("Writer at: %d (%p)\n", startOfBuf1 - shmBuf, startOfBuf1); + printf("sharedReadIndex1 at %d (%p) = %d\n", + (char*)sharedReadIndex1-shmBuf, + sharedReadIndex1, *sharedReadIndex1); + printf("sharedWriteIndex1 at %d (%p) = %d\n", + (char*)sharedWriteIndex1-shmBuf, + sharedWriteIndex1, *sharedWriteIndex1); + + printf("sizeOfBuffer = %d\n", sizeOfBuffer); +#endif + } +#ifdef DEBUG_TRANSPORTER + printf("Mapping from %p to %p\n", shmBuf, shmBuf+shmSize); +#endif +} + +#if 0 +SendStatus +SHM_Transporter::prepareSend(const SignalHeader * const signalHeader, + Uint8 prio, + const Uint32 * const signalData, + const LinearSegmentPtr ptr[3], + bool force){ + + if(isConnected()){ + + const Uint32 lenBytes = m_packer.getMessageLength(signalHeader, ptr); + + Uint32 * insertPtr = (Uint32 *)writer->getWritePtr(lenBytes); + + if(insertPtr != 0){ + + m_packer.pack(insertPtr, prio, signalHeader, signalData, ptr); + + /** + * Do funky membar stuff + */ + + writer->updateWritePtr(lenBytes); + return SEND_OK; + + } else { + // NdbSleep_MilliSleep(3); + //goto tryagain; + return SEND_BUFFER_FULL; + } + } + return SEND_DISCONNECTED; +} +#endif diff --git a/ndb/src/common/transporter/SHM_Transporter.hpp b/ndb/src/common/transporter/SHM_Transporter.hpp new file mode 100644 index 00000000000..da4566515e3 --- /dev/null +++ b/ndb/src/common/transporter/SHM_Transporter.hpp @@ -0,0 +1,156 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SHM_Transporter_H +#define SHM_Transporter_H + +#include "Transporter.hpp" +#include "SHM_Buffer.hpp" + +#ifdef NDB_WIN32 +typedef Uint32 key_t; +#endif + +/** + * class SHMTransporter + * @brief - main class for the SHM transporter. + */ + +class SHM_Transporter : public Transporter { + friend class TransporterRegistry; +public: + SHM_Transporter(NodeId lNodeId, + NodeId rNodeId, + key_t shmKey, + Uint32 shmSize, + bool compression, + bool checksum, + bool signalId); + + /** + * SHM destructor + */ + virtual ~SHM_Transporter(); + + /** + * Do initialization + */ + bool initTransporter(); + + Uint32 * getWritePtr(Uint32 lenBytes, Uint32 prio){ + return (Uint32 *)writer->getWritePtr(lenBytes); + } + + void updateWritePtr(Uint32 lenBytes, Uint32 prio){ + writer->updateWritePtr(lenBytes); + } + + void getReceivePtr(Uint32 ** ptr, Uint32 ** eod){ + reader->getReadPtr(* ptr, * eod); + } + + void updateReceivePtr(Uint32 * ptr){ + reader->updateReadPtr(ptr); + } + +protected: + /** + * disconnect a segmnet + * -# deletes the shm buffer associated with a segment + * -# marks the segment for removal + */ + void disconnectImpl(); + + /** + * Invokes the connectServer or connectClient. + * @param timeOutMillis - the timeout the connect thread waits before + * retrying. + * @return True if connectImpl successful, otherwise false. + */ + bool connectImpl(Uint32 timeOutMillis); + + /** + * Blocking + * + * -# Create shm segment + * -# Attach to it + * -# Wait for someone to attach (max wait = timeout), then rerun again + * until connection established. + * @param timeOutMillis - the time to sleep before (ms) trying again. + * @returns - True if the server managed to hook up with the client, + * i.e., both agrees that the other one has setup the segment. + * Otherwise false. + */ + bool connectServer(Uint32 timeOutMillis); + + /** + * Blocking + * + * -# Attach to shm segment + * -# Check if the segment is setup + * -# Check if the server set it up + * -# If all clear, return. + * @param timeOutMillis - the time to sleep before (ms) trying again. + * @returns - True if the client managed to hook up with the server, + * i.e., both agrees that the other one has setup the segment. + * Otherwise false. + */ + bool connectClient(Uint32 timeOutMillis); + + + /** + * Check if there are two processes attached to the segment (a connection) + * @return - True if the above holds. Otherwise false. + */ + bool checkConnected(); + + + /** + * Initialises the SHM_Reader and SHM_Writer on the segment + */ + void setupBuffers(); + +private: + bool _shmSegCreated; + bool _attached; + + const bool isServer; + key_t shmKey; + volatile Uint32 * serverStatusFlag; + volatile Uint32 * clientStatusFlag; + bool setupBuffersDone; + +#ifdef NDB_WIN32 + HANDLE hFileMapping; +#else + int shmId; +#endif + + int shmSize; + char * shmBuf; + + SHM_Reader * reader; + SHM_Writer * writer; + + /** + * @return - True if the reader has data to read on its segment. + */ + bool hasDataToRead() const { + return reader->empty() == false; + } +}; + +#endif diff --git a/ndb/src/common/transporter/SHM_Transporter.unix.cpp b/ndb/src/common/transporter/SHM_Transporter.unix.cpp new file mode 100644 index 00000000000..975c1191aea --- /dev/null +++ b/ndb/src/common/transporter/SHM_Transporter.unix.cpp @@ -0,0 +1,179 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "SHM_Transporter.hpp" +#include "TransporterInternalDefinitions.hpp" +#include +#include +#include + +#include + + +#include +#include + + + +bool +SHM_Transporter::connectServer(Uint32 timeOutMillis){ + if(!_shmSegCreated){ + shmId = shmget(shmKey, shmSize, IPC_CREAT | 960); + if(shmId == -1){ + perror("shmget: "); + reportThreadError(remoteNodeId, TE_SHM_UNABLE_TO_CREATE_SEGMENT); + NdbSleep_MilliSleep(timeOutMillis); + return false; + } + _shmSegCreated = true; + } + + if(!_attached){ + shmBuf = (char *)shmat(shmId, 0, 0); + if(shmBuf == 0){ + perror("shmat: "); + reportThreadError(remoteNodeId, TE_SHM_UNABLE_TO_ATTACH_SEGMENT); + NdbSleep_MilliSleep(timeOutMillis); + return false; + } + _attached = true; + } + + struct shmid_ds info; + const int res = shmctl(shmId, IPC_STAT, &info); + if(res == -1){ + perror("shmctl: "); + reportThreadError(remoteNodeId, TE_SHM_IPC_STAT); + NdbSleep_MilliSleep(timeOutMillis); + return false; + } + + if(info.shm_nattch == 2 && !setupBuffersDone) { + setupBuffers(); + setupBuffersDone=true; + } + + if(setupBuffersDone) { + NdbSleep_MilliSleep(timeOutMillis); + if(*serverStatusFlag==1 && *clientStatusFlag==1) + return true; + } + + + if(info.shm_nattch > 2){ + reportThreadError(remoteNodeId, TE_SHM_DISCONNECT); + NdbSleep_MilliSleep(timeOutMillis); + return false; + } + + NdbSleep_MilliSleep(timeOutMillis); + return false; +} + +bool +SHM_Transporter::connectClient(Uint32 timeOutMillis){ + if(!_shmSegCreated){ + + shmId = shmget(shmKey, shmSize, 0); + if(shmId == -1){ + NdbSleep_MilliSleep(timeOutMillis); + return false; + } + _shmSegCreated = true; + } + + if(!_attached){ + shmBuf = (char *)shmat(shmId, 0, 0); + if(shmBuf == 0){ + reportThreadError(remoteNodeId, TE_SHM_UNABLE_TO_ATTACH_SEGMENT); + NdbSleep_MilliSleep(timeOutMillis); + return false; + } + _attached = true; + } + + struct shmid_ds info; + + const int res = shmctl(shmId, IPC_STAT, &info); + if(res == -1){ + reportThreadError(remoteNodeId, TE_SHM_IPC_STAT); + NdbSleep_MilliSleep(timeOutMillis); + return false; + } + + + if(info.shm_nattch == 2 && !setupBuffersDone) { + setupBuffers(); + setupBuffersDone=true; + } + + if(setupBuffersDone) { + NdbSleep_MilliSleep(timeOutMillis); + if(*serverStatusFlag==1 && *clientStatusFlag==1) + return true; + } + + if(info.shm_nattch > 2){ + reportThreadError(remoteNodeId, TE_SHM_DISCONNECT); + NdbSleep_MilliSleep(timeOutMillis); + return false; + } + + NdbSleep_MilliSleep(timeOutMillis); + return false; +} + +bool +SHM_Transporter::checkConnected(){ + struct shmid_ds info; + const int res = shmctl(shmId, IPC_STAT, &info); + if(res == -1){ + reportError(callbackObj, remoteNodeId, TE_SHM_IPC_STAT); + return false; + } + + if(info.shm_nattch != 2){ + reportError(callbackObj, remoteNodeId, TE_SHM_DISCONNECT); + return false; + } + return true; +} + +void +SHM_Transporter::disconnectImpl(){ + if(_attached){ + const int res = shmdt(shmBuf); + if(res == -1){ + perror("shmdelete: "); + return; + } + _attached = false; + if(!isServer && _shmSegCreated) + _shmSegCreated = false; + } + + if(isServer && _shmSegCreated){ + const int res = shmctl(shmId, IPC_RMID, 0); + if(res == -1){ + reportError(callbackObj, remoteNodeId, TE_SHM_UNABLE_TO_REMOVE_SEGMENT); + return; + } + _shmSegCreated = false; + } + setupBuffersDone=false; +} + diff --git a/ndb/src/common/transporter/SHM_Transporter.win32.cpp b/ndb/src/common/transporter/SHM_Transporter.win32.cpp new file mode 100644 index 00000000000..4ba52c9179d --- /dev/null +++ b/ndb/src/common/transporter/SHM_Transporter.win32.cpp @@ -0,0 +1,172 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "SHM_Transporter.hpp" +#include "TransporterInternalDefinitions.hpp" +#include +#include +#include + +#include + +#include + + +bool +SHM_Transporter::connectServer(Uint32 timeOutMillis){ + if(!_shmSegCreated) + { + char szName[32]; + sprintf(szName, "ndb%lu", shmKey); + hFileMapping = CreateFileMapping(INVALID_HANDLE_VALUE, + 0, + PAGE_READWRITE, + 0, + shmSize, + szName); + + if(!hFileMapping) + { + reportThreadError(remoteNodeId, TE_SHM_UNABLE_TO_CREATE_SEGMENT); + NdbSleep_MilliSleep(timeOutMillis); + return false; + } + _shmSegCreated = true; + } + + if(!_attached){ + shmBuf = (char*)MapViewOfFile(hFileMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0); + if(shmBuf == 0){ + reportThreadError(remoteNodeId, TE_SHM_UNABLE_TO_ATTACH_SEGMENT); + NdbSleep_MilliSleep(timeOutMillis); + return false; + } + volatile Uint32 * sharedCountAttached = + (volatile Uint32*)(shmBuf + 6*sizeof(Uint32*)); + ++*sharedCountAttached; + _attached = true; + } + + volatile Uint32 * sharedCountAttached = + (volatile Uint32*)(shmBuf + 6*sizeof(Uint32*)); + + if(*sharedCountAttached == 2 && !setupBuffersDone) { + setupBuffers(); + setupBuffersDone=true; + } + if(*sharedCountAttached > 2) { + reportThreadError(remoteNodeId, TE_SHM_DISCONNECT); + return false; + } + + if(setupBuffersDone) { + NdbSleep_MilliSleep(timeOutMillis); + if(*serverStatusFlag==1 && *clientStatusFlag==1) + return true; + } + + NdbSleep_MilliSleep(timeOutMillis); + return false; +} + +bool +SHM_Transporter::connectClient(Uint32 timeOutMillis){ + if(!_shmSegCreated) + { + char szName[32]; + sprintf(szName, "ndb%lu", shmKey); + hFileMapping = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, szName); + + if(!hFileMapping) + { + NdbSleep_MilliSleep(timeOutMillis); + return false; + } + _shmSegCreated = true; + } + + if(!_attached){ + shmBuf = (char*)MapViewOfFile(hFileMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0); + if(shmBuf == 0){ + reportThreadError(remoteNodeId, TE_SHM_UNABLE_TO_ATTACH_SEGMENT); + NdbSleep_MilliSleep(timeOutMillis); + return false; + } + volatile Uint32 * sharedCountAttached = + (volatile Uint32*)(shmBuf + 6*sizeof(Uint32*)); + ++*sharedCountAttached; + _attached = true; + } + + volatile Uint32 * sharedCountAttached = + (volatile Uint32*)(shmBuf + 6*sizeof(Uint32*)); + + if(*sharedCountAttached == 2 && !setupBuffersDone) { + setupBuffers(); + setupBuffersDone=true; + } + + if(setupBuffersDone) { + if(*serverStatusFlag==1 && *clientStatusFlag==1) + return true; + } + NdbSleep_MilliSleep(timeOutMillis); + return false; + +} + + +bool +SHM_Transporter::checkConnected(){ + volatile Uint32 * sharedCountAttached = + (volatile Uint32*)(shmBuf + 6*sizeof(Uint32*)); + if(*sharedCountAttached != 2) { + reportError(callbackObj, remoteNodeId, TE_SHM_DISCONNECT); + return false; + } + return true; +} + +void +SHM_Transporter::disconnectImpl(){ + if(_attached) { + volatile Uint32 * sharedCountAttached = + (volatile Uint32*)(shmBuf + 6*sizeof(Uint32*)); + + --*sharedCountAttached; + + if(!UnmapViewOfFile(shmBuf)) { + reportError(callbackObj, remoteNodeId, TE_SHM_UNABLE_TO_REMOVE_SEGMENT); + return; + } + + _attached = false; + if(!isServer && _shmSegCreated) + _shmSegCreated = false; + } + + if(_shmSegCreated){ + if(!CloseHandle(hFileMapping)) { + reportError(callbackObj, remoteNodeId, TE_SHM_UNABLE_TO_REMOVE_SEGMENT); + return; + } + _shmSegCreated = false; + } + setupBuffersDone=false; + +} + diff --git a/ndb/src/common/transporter/SendBuffer.cpp b/ndb/src/common/transporter/SendBuffer.cpp new file mode 100644 index 00000000000..58cad96931f --- /dev/null +++ b/ndb/src/common/transporter/SendBuffer.cpp @@ -0,0 +1,89 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "SendBuffer.hpp" +#include "TransporterInternalDefinitions.hpp" + +SendBuffer::SendBuffer(Uint32 bufSize) { + + sizeOfBuffer = bufSize; + if(sizeOfBuffer < MAX_MESSAGE_SIZE) + sizeOfBuffer = 2 * MAX_MESSAGE_SIZE; + startOfBuffer = NULL; + + // Initalise pointers + endOfBuffer = NULL; + insertPtr = NULL; + sendPtr = NULL; + sendDataSize = 0; + dataSize = 0; +} + +bool +SendBuffer::initBuffer(Uint32 aRemoteNodeId) { + + // Allocate memory for the buffer +#ifdef DEBUG_TRANSPORTER + ndbout << "Allocating " << sizeOfBuffer << " bytes for send buffer" << endl; +#endif + + startOfBuffer = new Uint32[(sizeOfBuffer >> 2) + 1]; + endOfBuffer = startOfBuffer + (sizeOfBuffer >> 2); + + emptyBuffer(); + theRemoteNodeId = aRemoteNodeId; + return true; +} + +SendBuffer::~SendBuffer() { + // Deallocate the buffer memory + if(startOfBuffer != NULL) + delete[] startOfBuffer; +} + +int +SendBuffer::bufferSize() { + return dataSize; +} + +Uint32 +SendBuffer::bufferSizeRemaining() { + return (sizeOfBuffer - dataSize); +} + +void +SendBuffer::emptyBuffer() { + insertPtr = startOfBuffer; + sendPtr = (char*)startOfBuffer; + dataSize = 0; + sendDataSize = 0; +} + +#ifdef DEBUG_TRANSPORTER +void +SendBuffer::print() { + + printf("SendBuffer status printouts\n"); + + printf( "sizeOfBuffer: %d\n", sizeOfBuffer); + printf( "startOfBuffer: %.8x\n", startOfBuffer); + printf( "endOfBuffer: %.8x\n", endOfBuffer); + printf( "insertPtr: %.8x\n", insertPtr); + printf( "sendPtr: %.8x\n", sendPtr); + printf( "sendDataSize: %d\n", sendDataSize); + printf( "dataSize: %d\n", dataSize); +} +#endif diff --git a/ndb/src/common/transporter/SendBuffer.hpp b/ndb/src/common/transporter/SendBuffer.hpp new file mode 100644 index 00000000000..75ef0708e83 --- /dev/null +++ b/ndb/src/common/transporter/SendBuffer.hpp @@ -0,0 +1,191 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +//**************************************************************************** +// +// NAME +// SendBuffer +// +// DESCRIPTION +// The SendBuffer is a circular buffer storing signals waiting to be sent. +// The signals can be of variable size and are copied into the buffer +// in Protocol 6 format. There will be two SendBuffer instances +// (priority level A and B) for each transporter using a buffer for +// sending. The buffering will in most cases be done to send as big +// packages as possible over TCP/IP. +// +//***************************************************************************/ +#ifndef SendBuffer_H +#define SendBuffer_H + +#include "TransporterDefinitions.hpp" +#include +#include + +#ifdef DEBUG_TRANSPORTER +#include +#endif + +class SendBuffer { + friend class TCP_Transporter; +public: + // Set member variables + SendBuffer(Uint32 bufSize); + + // Deallocate the buffer memory + ~SendBuffer(); + + // Allocate memory for the buffer and initialize the buffer pointers + bool initBuffer(Uint32 aRemoteNodeId); + + // Number of bytes remaining in the buffer + Uint32 bufferSizeRemaining(); + + // Number of bytes of data in the buffer + int bufferSize(); + + // Empty the buffer + void emptyBuffer(); + + /** + * The transporter calls updateBuffer after a retrieve followed by + * a successful send, to update the cirkular buffer pointers. + * updateBuffer is called with the number of bytes really sent, + * it may be that it is less than what was retrived from the buffer. + * If that is the case there will be an incomplete message (slack) + * in the SendBuffer. + * + * Returns 0 if buffer empty + * else ~0 + */ + Uint32 bytesSent(Uint32 len); + +#ifdef DEBUG_TRANSPORTER + // Prints the buffer status on the screen. Can be used for testing purposes. + void print(); +#endif + + Uint32* getInsertPtr(Uint32 bytes); + void updateInsertPtr(Uint32 bytes); + +private: + + Uint32 sizeOfBuffer; // Length, in number of bytes, of the buffer memory + Uint32 dataSize; // Number of bytes in buffer + + Uint32 * startOfBuffer; // Pointer to the start of the buffer memory + Uint32 * endOfBuffer; // Pointer to end of buffer + + Uint32 * insertPtr; // Where to insert next + + char * sendPtr; // Where data to send starts + Uint32 sendDataSize; // Num bytes to send + + Uint32 theRemoteNodeId; +}; + +inline +Uint32 +SendBuffer::bytesSent(Uint32 bytes) { + + if(bytes > dataSize){ +#ifdef DEBUG_TRANSPORTER + printf("bytes(%d) > dataSize(%d)\n", bytes, dataSize); +#endif + abort(); + // reportError(0 ,theRemoteNodeId, TE_INVALID_MESSAGE_LENGTH); + return 0; + }//if + + if(bytes > sendDataSize){ +#ifdef DEBUG_TRANSPORTER + printf("bytes(%d) > sendDataSize(%d)\n", bytes, sendDataSize); +#endif + abort(); + //reportError(0,theRemoteNodeId, TE_INVALID_MESSAGE_LENGTH); + return 0; + }//if + + dataSize -= bytes; + sendPtr += bytes; + sendDataSize -= bytes; + + if(sendDataSize == 0){ + if(sendPtr > (char*)insertPtr){ + sendPtr = (char *)startOfBuffer; + sendDataSize = dataSize; + } else { + sendPtr = ((char*)insertPtr) - dataSize; + sendDataSize = dataSize; + } + } + + if(dataSize == 0) + return 0; + return ~0; +} + +inline +Uint32* +SendBuffer::getInsertPtr(Uint32 len){ + if (bufferSizeRemaining() < len){ + return 0; + } + + const char * const tmpInsertPtr = (char *) insertPtr; + + if(tmpInsertPtr >= sendPtr){ + // Is there enough space at the end of the buffer? + if ((tmpInsertPtr + len) < (char*)endOfBuffer){ + sendDataSize += len; + return insertPtr; + } else { + // We have passed the end of the cirkular buffer, + // must start from the beginning + // Is there enough space in the beginning of the buffer? + if ((Uint32)(sendPtr - (char *)startOfBuffer) <= len){ + // Not enough space available, insert failed + return 0; + } else { + // There is space available at the beginning of the buffer + // We start from the beginning, set endOfData and insertPtr + insertPtr = startOfBuffer; + if(sendDataSize != 0){ + return insertPtr; + } + sendPtr = (char *)startOfBuffer; + sendDataSize = len; + return insertPtr; + } + } + } else { + // sendPtr > insertPtr + // Is there enought room + if((tmpInsertPtr + len) < sendPtr){ + return insertPtr; + } + return 0; + } +} + +inline +void +SendBuffer::updateInsertPtr(Uint32 lenBytes){ + dataSize += lenBytes; + insertPtr += (lenBytes / 4); +} + +#endif // Define of SendBuffer_H diff --git a/ndb/src/common/transporter/TCP_Transporter.cpp b/ndb/src/common/transporter/TCP_Transporter.cpp new file mode 100644 index 00000000000..8a7d1741636 --- /dev/null +++ b/ndb/src/common/transporter/TCP_Transporter.cpp @@ -0,0 +1,603 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "TCP_Transporter.hpp" +#include +#include +// End of stuff to be moved + +#if defined NDB_OSE || defined NDB_SOFTOSE +#define inet_send inet_send +#else +#include +#define inet_send send +#endif + +#include + + +#ifdef NDB_WIN32 +class ndbstrerror +{ +public: + ndbstrerror(int iError); + ~ndbstrerror(void); + operator char*(void) { return m_szError; }; + +private: + int m_iError; + char* m_szError; +}; + +ndbstrerror::ndbstrerror(int iError) +: m_iError(iError) +{ + FormatMessage( + FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, + 0, + iError, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + (LPTSTR)&m_szError, + 0, + 0); +} + +ndbstrerror::~ndbstrerror(void) +{ + LocalFree( m_szError ); + m_szError = 0; +} +#else +#define ndbstrerror strerror +#endif + +TCP_Transporter::TCP_Transporter(int sendBufSize, int maxRecvSize, + int portNo, + const char *rHostName, + const char *lHostName, + NodeId rNodeId, NodeId lNodeId, + int byte_order, + bool compr, bool chksm, bool signalId, + Uint32 _reportFreq) : + Transporter(lNodeId, rNodeId, byte_order, compr, chksm, signalId), + m_sendBuffer(sendBufSize), + isServer(lNodeId < rNodeId), + port(portNo) +{ + maxReceiveSize = maxRecvSize; + + strncpy(remoteHostName, rHostName, sizeof(remoteHostName)); + + // Initialize member variables + Ndb_getInAddr(&remoteHostAddress, rHostName); + + Ndb_getInAddr(&localHostAddress, lHostName); + theSocket = NDB_INVALID_SOCKET; + + sendCount = receiveCount = 0; + sendSize = receiveSize = 0; + reportFreq = _reportFreq; + + sockOptRcvBufSize = 70080; + sockOptSndBufSize = 71540; + sockOptNodelay = 1; + sockOptTcpMaxSeg = 4096; +} + +TCP_Transporter::~TCP_Transporter() { + + // Disconnect + if (theSocket != NDB_INVALID_SOCKET) + doDisconnect(); + + // Delete send buffers + + // Delete receive buffer!! + receiveBuffer.destroy(); +} + +bool +TCP_Transporter::initTransporter() { + + // Allocate buffer for receiving + // Let it be the maximum size we receive plus 8 kB for any earlier received + // incomplete messages (slack) + Uint32 recBufSize = maxReceiveSize; + if(recBufSize < MAX_MESSAGE_SIZE){ + recBufSize = MAX_MESSAGE_SIZE; + } + + if(!receiveBuffer.init(recBufSize+MAX_MESSAGE_SIZE)){ + return false; + } + + // Allocate buffers for sending + if (!m_sendBuffer.initBuffer(remoteNodeId)) { + // XXX What shall be done here? + // The same is valid for the other init-methods + return false; + } + + return true; +} + +void +TCP_Transporter::setSocketOptions(){ + if (setsockopt(theSocket, SOL_SOCKET, SO_RCVBUF, + (char*)&sockOptRcvBufSize, sizeof(sockOptRcvBufSize)) < 0) { +#ifdef DEBUG_TRANSPORTER + ndbout_c("The setsockopt SO_RCVBUF error code = %d", InetErrno); +#endif + }//if + + if (setsockopt(theSocket, SOL_SOCKET, SO_SNDBUF, + (char*)&sockOptSndBufSize, sizeof(sockOptSndBufSize)) < 0) { +#ifdef DEBUG_TRANSPORTER + ndbout_c("The setsockopt SO_SNDBUF error code = %d", InetErrno); +#endif + }//if + + //----------------------------------------------- + // Set the TCP_NODELAY option so also small packets are sent + // as soon as possible + //----------------------------------------------- + if (setsockopt(theSocket, IPPROTO_TCP, TCP_NODELAY, + (char*)&sockOptNodelay, sizeof(sockOptNodelay)) < 0) { +#ifdef DEBUG_TRANSPORTER + ndbout_c("The setsockopt TCP_NODELAY error code = %d", InetErrno); +#endif + }//if +} + + +#ifdef NDB_WIN32 + +bool +TCP_Transporter::setSocketNonBlocking(NDB_SOCKET_TYPE socket){ + unsigned long ul = 1; + if(ioctlsocket(socket, FIONBIO, &ul)) + { +#ifdef DEBUG_TRANSPORTER + ndbout_c("Set non-blocking server error3: %d", InetErrno); +#endif + }//if + return true; +} + +#else + +bool +TCP_Transporter::setSocketNonBlocking(NDB_SOCKET_TYPE socket){ + int flags; + flags = fcntl(socket, F_GETFL, 0); + if (flags < 0) { +#ifdef DEBUG_TRANSPORTER + ndbout_c("Set non-blocking server error1: %s", strerror(InetErrno)); +#endif + }//if + flags |= NDB_NONBLOCK; + if (fcntl(socket, F_SETFL, flags) == -1) { +#ifdef DEBUG_TRANSPORTER + ndbout_c("Set non-blocking server error2: %s", strerror(InetErrno)); +#endif + }//if + return true; +} + +#endif + +bool +TCP_Transporter::sendIsPossible(struct timeval * timeout) { +#ifdef NDB_OSE + /** + * In OSE you cant do select without owning a socket, + * and since this method might be called by any thread in the api + * we choose not to implementet and always return true after sleeping + * a while. + * + * Note that this only sensible as long as the sockets are non blocking + */ + if(theSocket >= 0){ + Uint32 timeOutMillis = timeout->tv_sec * 1000 + timeout->tv_usec / 1000; + NdbSleep_MilliSleep(timeOutMillis); + return true; + } + return false; +#else + if(theSocket != NDB_INVALID_SOCKET){ + fd_set writeset; + FD_ZERO(&writeset); + FD_SET(theSocket, &writeset); + + int selectReply = select(theSocket + 1, NULL, &writeset, NULL, timeout); + + if ((selectReply > 0) && FD_ISSET(theSocket, &writeset)) + return true; + else + return false; + } + return false; +#endif +} + + +Uint32 * +TCP_Transporter::getWritePtr(Uint32 lenBytes, Uint32 prio){ + + Uint32 * insertPtr = m_sendBuffer.getInsertPtr(lenBytes); + + struct timeval timeout = {0, 10000}; + + if (insertPtr == 0) { + //------------------------------------------------- + // Buffer was completely full. We have severe problems. + // We will attempt to wait for a small time + //------------------------------------------------- + if(sendIsPossible(&timeout)) { + //------------------------------------------------- + // Send is possible after the small timeout. + //------------------------------------------------- + if(!doSend()){ + return 0; + } else { + //------------------------------------------------- + // Since send was successful we will make a renewed + // attempt at inserting the signal into the buffer. + //------------------------------------------------- + insertPtr = m_sendBuffer.getInsertPtr(lenBytes); + }//if + } else { + return 0; + }//if + } + return insertPtr; +} + +void +TCP_Transporter::updateWritePtr(Uint32 lenBytes, Uint32 prio){ + m_sendBuffer.updateInsertPtr(lenBytes); + + const int bufsize = m_sendBuffer.bufferSize(); + if(bufsize > TCP_SEND_LIMIT) { + //------------------------------------------------- + // Buffer is full and we are ready to send. We will + // not wait since the signal is already in the buffer. + // Force flag set has the same indication that we + // should always send. If it is not possible to send + // we will not worry since we will soon be back for + // a renewed trial. + //------------------------------------------------- + struct timeval no_timeout = {0,0}; + if(sendIsPossible(&no_timeout)) { + //------------------------------------------------- + // Send was possible, attempt at a send. + //------------------------------------------------- + doSend(); + }//if + } +} + +#define DISCONNECT_ERRNO(e, sz) ((sz == 0) || \ + (!((sz == -1) && (e == EAGAIN) || (e == EWOULDBLOCK) || (e == EINTR)))) + + +bool +TCP_Transporter::doSend() { + // If no sendbuffers are used nothing is done + // Sends the contents of the SendBuffers until they are empty + // or until select does not select the socket for write. + // Before calling send, the socket must be selected for write + // using "select" + // It writes on the external TCP/IP interface until the send buffer is empty + // and as long as write is possible (test it using select) + + // Empty the SendBuffers + + const char * const sendPtr = m_sendBuffer.sendPtr; + const Uint32 sizeToSend = m_sendBuffer.sendDataSize; + if (sizeToSend > 0){ + const int nBytesSent = inet_send(theSocket, sendPtr, sizeToSend, 0); + + if (nBytesSent > 0) { + m_sendBuffer.bytesSent(nBytesSent); + + sendCount ++; + sendSize += nBytesSent; + if(sendCount == reportFreq){ + reportSendLen(callbackObj,remoteNodeId, sendCount, sendSize); + sendCount = 0; + sendSize = 0; + } + } else { + // Send failed +#if defined DEBUG_TRANSPORTER + ndbout_c("Send Failure(disconnect==%d) to node = %d nBytesSent = %d " + "errno = %d strerror = %s", + DISCONNECT_ERRNO(InetErrno, nBytesSent), + remoteNodeId, nBytesSent, InetErrno, + (char*)ndbstrerror(InetErrno)); +#endif + if(DISCONNECT_ERRNO(InetErrno, nBytesSent)){ + doDisconnect(); + reportDisconnect(callbackObj, remoteNodeId, InetErrno); + } + + return false; + } + } + return true; +} + +int +TCP_Transporter::doReceive() { + // Select-function must return the socket for read + // before this method is called + // It reads the external TCP/IP interface once + + const int nBytesRead = recv(theSocket, + receiveBuffer.insertPtr, maxReceiveSize, 0); + + if (nBytesRead > 0) { + receiveBuffer.sizeOfData += nBytesRead; + receiveBuffer.insertPtr += nBytesRead; + + if(receiveBuffer.sizeOfData > receiveBuffer.sizeOfBuffer){ +#ifdef DEBUG_TRANSPORTER + ndbout_c("receiveBuffer.sizeOfData(%d) > receiveBuffer.sizeOfBuffer(%d)", + receiveBuffer.sizeOfData, receiveBuffer.sizeOfBuffer); + ndbout_c("nBytesRead = %d", nBytesRead); +#endif + ndbout_c("receiveBuffer.sizeOfData(%d) > receiveBuffer.sizeOfBuffer(%d)", + receiveBuffer.sizeOfData, receiveBuffer.sizeOfBuffer); + reportError(callbackObj, remoteNodeId, TE_INVALID_MESSAGE_LENGTH); + return 0; + } + + receiveCount ++; + receiveSize += nBytesRead; + if(receiveCount == reportFreq){ + reportReceiveLen(callbackObj, remoteNodeId, receiveCount, receiveSize); + receiveCount = 0; + receiveSize = 0; + } + return nBytesRead; + } else { +#if defined DEBUG_TRANSPORTER + ndbout_c("Receive Failure(disconnect==%d) to node = %d nBytesSent = %d " + "errno = %d strerror = %s", + DISCONNECT_ERRNO(InetErrno, nBytesRead), + remoteNodeId, nBytesRead, InetErrno, + (char*)ndbstrerror(InetErrno)); +#endif + if(DISCONNECT_ERRNO(InetErrno, nBytesRead)){ + // The remote node has closed down + doDisconnect(); + reportDisconnect(callbackObj, remoteNodeId,InetErrno); + } + } + return nBytesRead; +} + +bool +TCP_Transporter::connectImpl(Uint32 timeOutMillis){ + struct timeval timeout = {0, 0}; + timeout.tv_sec = timeOutMillis / 1000; + timeout.tv_usec = (timeOutMillis % 1000)*1000; + + bool retVal = false; + + if(isServer){ + if(theSocket == NDB_INVALID_SOCKET){ + startTCPServer(); + } + if(theSocket == NDB_INVALID_SOCKET) + { + NdbSleep_MilliSleep(timeOutMillis); + return false; + } + retVal = acceptClient(&timeout); + } else { + // Is client + retVal = connectClient(&timeout); + } + + if(!retVal) { + NdbSleep_MilliSleep(timeOutMillis); + return false; + } + +#if defined NDB_OSE || defined NDB_SOFTOSE + if(setsockopt(theSocket, SOL_SOCKET, SO_OSEOWNER, + &theReceiverPid, sizeof(PROCESS)) != 0){ + + ndbout << "Failed to transfer ownership of socket" << endl; + NDB_CLOSE_SOCKET(theSocket); + theSocket = -1; + return false; + } +#endif + + return true; +} + + +void +TCP_Transporter::disconnectImpl() { + if(theSocket != NDB_INVALID_SOCKET){ + if(NDB_CLOSE_SOCKET(theSocket) < 0){ + reportError(callbackObj, remoteNodeId, TE_ERROR_CLOSING_SOCKET); + } + } + + // Empty send och receive buffers + receiveBuffer.clear(); + m_sendBuffer.emptyBuffer(); + + theSocket = NDB_INVALID_SOCKET; +} + +bool +TCP_Transporter::startTCPServer() { + + int bindResult, listenResult; + + // The server variable is the remote server when we are a client + // htonl and htons returns the parameter in network byte order + // INADDR_ANY tells the OS kernel to choose the IP address + struct sockaddr_in server; + memset((void*)&server, 0, sizeof(server)); + server.sin_family = AF_INET; + server.sin_addr.s_addr = localHostAddress.s_addr; + server.sin_port = htons(port); + + if (theSocket != NDB_INVALID_SOCKET) { + return true; // Server socket is already initialized + } + + // Create the socket + theSocket = socket(AF_INET, SOCK_STREAM, 0); + if (theSocket == NDB_INVALID_SOCKET) { + reportThreadError(remoteNodeId, TE_COULD_NOT_CREATE_SOCKET); + return false; + } + + // Set the socket reuse addr to true, so we are sure we can bind the + // socket + int reuseAddr = 1; + setsockopt(theSocket, SOL_SOCKET, SO_REUSEADDR, + (char*)&reuseAddr, sizeof(reuseAddr)); + + // Set the TCP_NODELAY option so also small packets are sent + // as soon as possible + int nodelay = 1; + setsockopt(theSocket, IPPROTO_TCP, TCP_NODELAY, + (char*)&nodelay, sizeof(nodelay)); + + // Bind the socket + bindResult = bind(theSocket, (struct sockaddr *) &server, + sizeof(server)); + if (bindResult < 0) { + reportThreadError(remoteNodeId, TE_COULD_NOT_BIND_SOCKET); + NDB_CLOSE_SOCKET(theSocket); + theSocket = NDB_INVALID_SOCKET; + return false; + } + + // Perform listen. + listenResult = listen(theSocket, 1); + if (listenResult == 1) { + reportThreadError(remoteNodeId, TE_LISTEN_FAILED); + NDB_CLOSE_SOCKET(theSocket); + theSocket = NDB_INVALID_SOCKET; + return false; + } + + return true; +} + + +bool +TCP_Transporter::acceptClient (struct timeval * timeout){ + + struct sockaddr_in clientAddress; + + fd_set readset; + FD_ZERO(&readset); + FD_SET(theSocket, &readset); + const int res = select(theSocket + 1, &readset, 0, 0, timeout); + if(res == 0) + return false; + + if(res < 0){ + reportThreadError(remoteNodeId, TE_ERROR_IN_SELECT_BEFORE_ACCEPT); + return false; + } + + NDB_SOCKLEN_T clientAddressLen = sizeof(clientAddress); + const NDB_SOCKET_TYPE clientSocket = accept(theSocket, + (struct sockaddr*)&clientAddress, + &clientAddressLen); + if (clientSocket == NDB_INVALID_SOCKET) { + reportThreadError(remoteNodeId, TE_ACCEPT_RETURN_ERROR); + return false; + } + + if (clientAddress.sin_addr.s_addr != remoteHostAddress.s_addr) { + ndbout_c("Wrong client connecting!"); + ndbout_c("connecting address: %s", inet_ntoa(clientAddress.sin_addr)); + ndbout_c("expecting address: %s", inet_ntoa(remoteHostAddress)); + // The newly connected host is not the remote host + // we wanted to connect to. Disconnect it. + // XXX This is not valid. We cannot disconnect it. + NDB_CLOSE_SOCKET(clientSocket); + return false; + } else { + NDB_CLOSE_SOCKET(theSocket); + theSocket = clientSocket; + setSocketOptions(); + setSocketNonBlocking(theSocket); + return true; + } +} + +bool +TCP_Transporter::connectClient (struct timeval * timeout){ + + // Create the socket + theSocket = socket(AF_INET, SOCK_STREAM, 0); + if (theSocket == NDB_INVALID_SOCKET) { + reportThreadError(remoteNodeId, TE_COULD_NOT_CREATE_SOCKET); + return false; + } + + struct sockaddr_in server; + memset((void*)&server, 0, sizeof(server)); + server.sin_family = AF_INET; + server.sin_addr = remoteHostAddress; + server.sin_port = htons(port); + + struct sockaddr_in client; + memset((void*)&client, 0, sizeof(client)); + client.sin_family = AF_INET; + client.sin_addr = localHostAddress; + client.sin_port = 0; // Any port + + // Bind the socket + const int bindResult = bind(theSocket, (struct sockaddr *) &client, + sizeof(client)); + if (bindResult < 0) { + reportThreadError(remoteNodeId, TE_COULD_NOT_BIND_SOCKET); + NDB_CLOSE_SOCKET(theSocket); + theSocket = NDB_INVALID_SOCKET; + return false; + } + + const int connectRes = ::connect(theSocket, (struct sockaddr *) &server, + sizeof(server)); + if(connectRes == 0){ + setSocketOptions(); + setSocketNonBlocking(theSocket); + return true; + } + + NDB_CLOSE_SOCKET(theSocket); + theSocket = NDB_INVALID_SOCKET; + return false; +} + + + diff --git a/ndb/src/common/transporter/TCP_Transporter.hpp b/ndb/src/common/transporter/TCP_Transporter.hpp new file mode 100644 index 00000000000..30b730a5b1c --- /dev/null +++ b/ndb/src/common/transporter/TCP_Transporter.hpp @@ -0,0 +1,290 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +//**************************************************************************** +// +// AUTHOR +// Åsa Fransson +// +// NAME +// TCP_Transporter +// +// DESCRIPTION +// A TCP_Transporter instance is created when TCP/IP-communication +// shall be used (user specified). It handles connect, disconnect, +// send and receive. +// +// +// +//***************************************************************************/ +#ifndef TCP_Transporter_H +#define TCP_Transporter_H + +#include "Transporter.hpp" +#include "SendBuffer.hpp" + +#include + +struct ReceiveBuffer { + Uint32 *startOfBuffer; // Pointer to start of the receive buffer + Uint32 *readPtr; // Pointer to start reading data + + char *insertPtr; // Pointer to first position in the receiveBuffer + // in which to insert received data. Earlier + // received incomplete messages (slack) are + // copied into the first part of the receiveBuffer + + Uint32 sizeOfData; // In bytes + Uint32 sizeOfBuffer; + + bool init(int bytes); + void destroy(); + + void clear(); + void incompleteMessage(); +}; + +class TCP_Transporter : public Transporter { + friend class TransporterRegistry; +private: + // Initialize member variables + TCP_Transporter(int sendBufferSize, int maxReceiveSize, + int port, + const char *rHostName, + const char *lHostName, + NodeId rHostId, NodeId lHostId, + int byteorder, + bool compression, bool checksum, bool signalId, + Uint32 reportFreq = 4096); + + // Disconnect, delete send buffers and receive buffer + virtual ~TCP_Transporter(); + + /** + * Allocate buffers for sending and receiving + */ + bool initTransporter(); + + Uint32 * getWritePtr(Uint32 lenBytes, Uint32 prio); + void updateWritePtr(Uint32 lenBytes, Uint32 prio); + + bool hasDataToSend() const ; + + /** + * Retrieves the contents of the send buffers and writes it on + * the external TCP/IP interface until the send buffers are empty + * and as long as write is possible. + */ + bool doSend(); + + /** + * It reads the external TCP/IP interface once + * and puts the data in the receiveBuffer + */ + int doReceive(); + + /** + * Returns socket (used for select) + */ + NDB_SOCKET_TYPE getSocket() const; + + /** + * Get Receive Data + * + * Returns - no of bytes to read + * and set ptr + */ + virtual Uint32 getReceiveData(Uint32 ** ptr); + + /** + * Update receive data ptr + */ + virtual void updateReceiveDataPtr(Uint32 bytesRead); + +protected: + /** + * Setup client/server and perform connect/accept + * Is used both by clients and servers + * A client connects to the remote server + * A server accepts any new connections + */ + bool connectImpl(Uint32 timeOutMillis); + + /** + * Disconnects a TCP/IP node. Empty send and receivebuffer. + */ + void disconnectImpl(); + +private: + /** + * Send buffers + */ + SendBuffer m_sendBuffer; + + const bool isServer; + const unsigned int port; + + // Sending/Receiving socket used by both client and server + NDB_SOCKET_TYPE theSocket; + + Uint32 maxReceiveSize; + + /** + * Remote host name/and address + */ + char remoteHostName[256]; + struct in_addr remoteHostAddress; + struct in_addr localHostAddress; + + /** + * Socket options + */ + int sockOptRcvBufSize; + int sockOptSndBufSize; + int sockOptNodelay; + int sockOptTcpMaxSeg; + + void setSocketOptions(); + + static bool setSocketNonBlocking(NDB_SOCKET_TYPE aSocket); + + bool sendIsPossible(struct timeval * timeout); + + /** + * startTCPServer - None blocking + * + * create a server socket + * bind + * listen + * + * Note: Does not call accept + */ + bool startTCPServer(); + + /** + * acceptClient - Blocking + * + * Accept a connection + * checks if "right" client has connected + * if so + * close server socket + * else + * close newly created socket and goto begin + */ + bool acceptClient(struct timeval * timeout); + + /** + * Creates a client socket + * + * Note does not call connect + */ + bool createClientSocket(); + + /** + * connectClient - Blocking + * + * connects to remote host + */ + bool connectClient(struct timeval * timeout); + + /** + * Statistics + */ + Uint32 reportFreq; + Uint32 receiveCount; + Uint64 receiveSize; + Uint32 sendCount; + Uint64 sendSize; + + ReceiveBuffer receiveBuffer; + +#if defined NDB_OSE || defined NDB_SOFTOSE + PROCESS theReceiverPid; +#endif +}; + +inline +NDB_SOCKET_TYPE +TCP_Transporter::getSocket() const { + return theSocket; +} + +inline +Uint32 +TCP_Transporter::getReceiveData(Uint32 ** ptr){ + (* ptr) = receiveBuffer.readPtr; + return receiveBuffer.sizeOfData; +} + +inline +void +TCP_Transporter::updateReceiveDataPtr(Uint32 bytesRead){ + char * ptr = (char *)receiveBuffer.readPtr; + ptr += bytesRead; + receiveBuffer.readPtr = (Uint32*)ptr; + receiveBuffer.sizeOfData -= bytesRead; + receiveBuffer.incompleteMessage(); +} + +inline +bool +TCP_Transporter::hasDataToSend() const { + return m_sendBuffer.dataSize > 0; +} + +inline +bool +ReceiveBuffer::init(int bytes){ +#ifdef DEBUG_TRANSPORTER + ndbout << "Allocating " << bytes << " bytes as receivebuffer" << endl; +#endif + + startOfBuffer = new Uint32[((bytes + 0) >> 2) + 1]; + sizeOfBuffer = bytes + sizeof(Uint32); + clear(); + return true; +} + +inline +void +ReceiveBuffer::destroy(){ + delete[] startOfBuffer; + sizeOfBuffer = 0; + startOfBuffer = 0; + clear(); +} + +inline +void +ReceiveBuffer::clear(){ + readPtr = startOfBuffer; + insertPtr = (char *)startOfBuffer; + sizeOfData = 0; +} + +inline +void +ReceiveBuffer::incompleteMessage() { + if(startOfBuffer != readPtr){ + if(sizeOfData != 0) + memmove(startOfBuffer, readPtr, sizeOfData); + readPtr = startOfBuffer; + insertPtr = ((char *)startOfBuffer) + sizeOfData; + } +} + + +#endif // Define of TCP_Transporter_H diff --git a/ndb/src/common/transporter/Transporter.cpp b/ndb/src/common/transporter/Transporter.cpp new file mode 100644 index 00000000000..1e19a8375ba --- /dev/null +++ b/ndb/src/common/transporter/Transporter.cpp @@ -0,0 +1,147 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "Transporter.hpp" +#include "TransporterInternalDefinitions.hpp" +#include +#include + +Transporter::Transporter(NodeId lNodeId, NodeId rNodeId, + int _byteorder, + bool _compression, bool _checksum, bool _signalId) + : localNodeId(lNodeId), remoteNodeId(rNodeId), + m_packer(_signalId, _checksum) +{ + byteOrder = _byteorder; + compressionUsed = _compression; + checksumUsed = _checksum; + signalIdUsed = _signalId; + + _threadError = TE_NO_ERROR; + + _connecting = false; + _disconnecting = false; + _connected = false; + _timeOutMillis = 1000; + theThreadPtr = NULL; + theMutexPtr = NdbMutex_Create(); +} + +Transporter::~Transporter(){ + NdbMutex_Destroy(theMutexPtr); + + if(theThreadPtr != 0){ + void * retVal; + NdbThread_WaitFor(theThreadPtr, &retVal); + NdbThread_Destroy(&theThreadPtr); + } +} + +extern "C" +void * +runConnect_C(void * me) +{ + runConnect(me); + NdbThread_Exit(0); + return NULL; +} + +void * +runConnect(void * me){ + Transporter * t = (Transporter *) me; + + DEBUG("Connect thread to " << t->remoteNodeId << " started"); + + while(true){ + NdbMutex_Lock(t->theMutexPtr); + if(t->_disconnecting){ + t->_connecting = false; + NdbMutex_Unlock(t->theMutexPtr); + DEBUG("Connect Thread " << t->remoteNodeId << " stop due to disconnect"); + return 0; + } + NdbMutex_Unlock(t->theMutexPtr); + + bool res = t->connectImpl(t->_timeOutMillis); // 1000 ms + DEBUG("Waiting for " << t->remoteNodeId << "..."); + if(res){ + t->_connected = true; + t->_connecting = false; + t->_errorCount = 0; + t->_threadError = TE_NO_ERROR; + DEBUG("Connect Thread " << t->remoteNodeId << " stop due to connect"); + return 0; + } + } +} + +void +Transporter::doConnect() { + + NdbMutex_Lock(theMutexPtr); + if(_connecting || _disconnecting || _connected){ + NdbMutex_Unlock(theMutexPtr); + return; + } + + _connecting = true; + + _threadError = TE_NO_ERROR; + + // Start thread + + char buf[16]; + snprintf(buf, sizeof(buf), "ndb_con_%d", remoteNodeId); + + if(theThreadPtr != 0){ + void * retVal; + NdbThread_WaitFor(theThreadPtr, &retVal); + NdbThread_Destroy(&theThreadPtr); + } + + theThreadPtr = NdbThread_Create(runConnect_C, + (void**)this, + 32768, + buf, + NDB_THREAD_PRIO_LOW); + + NdbSleep_MilliSleep(100); // Let thread start + + NdbMutex_Unlock(theMutexPtr); +} + +void +Transporter::doDisconnect() { + + NdbMutex_Lock(theMutexPtr); + _disconnecting = true; + while(_connecting){ + DEBUG("Waiting for connect to finish..."); + + NdbMutex_Unlock(theMutexPtr); + NdbSleep_MilliSleep(500); + NdbMutex_Lock(theMutexPtr); + } + + _connected = false; + + disconnectImpl(); + _threadError = TE_NO_ERROR; + _disconnecting = false; + + NdbMutex_Unlock(theMutexPtr); +} diff --git a/ndb/src/common/transporter/Transporter.hpp b/ndb/src/common/transporter/Transporter.hpp new file mode 100644 index 00000000000..c562451a1b0 --- /dev/null +++ b/ndb/src/common/transporter/Transporter.hpp @@ -0,0 +1,177 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef Transporter_H +#define Transporter_H + +#include +#include "TransporterDefinitions.hpp" +#include "Packer.hpp" + +#include +#include + +class Transporter { + friend class TransporterRegistry; +public: + virtual bool initTransporter() = 0; + + /** + * Destructor + */ + virtual ~Transporter(); + + /** + * None blocking + * Use isConnected() to check status + */ + virtual void doConnect(); + + /** + * Blocking + */ + virtual void doDisconnect(); + + virtual Uint32 * getWritePtr(Uint32 lenBytes, Uint32 prio) = 0; + virtual void updateWritePtr(Uint32 lenBytes, Uint32 prio) = 0; + + /** + * Are we currently connected + */ + bool isConnected() const; + + /** + * Remote Node Id + */ + NodeId getRemoteNodeId() const; + + + /** + * Set callback object + */ + void setCallbackObject(void * callback); + +protected: + Transporter(NodeId lNodeId, + NodeId rNodeId, + int byteorder, + bool compression, + bool checksum, + bool signalId); + + /** + * Blocking, for max timeOut milli seconds + * Returns true if connect succeded + */ + virtual bool connectImpl(Uint32 timeOut) = 0; + + /** + * Blocking + */ + virtual void disconnectImpl() = 0; + + const NodeId localNodeId; + const NodeId remoteNodeId; + + unsigned createIndex; + + int byteOrder; + bool compressionUsed; + bool checksumUsed; + bool signalIdUsed; + Packer m_packer; + + +private: + /** + * Thread and mutex for connect + */ + NdbThread* theThreadPtr; + friend void* runConnect(void * me); + +protected: + /** + * Error reporting from connect thread(s) + */ + void reportThreadError(NodeId nodeId, + TransporterError errorCode); + Uint32 getErrorCount(); + TransporterError getThreadError(); + void resetThreadError(); + TransporterError _threadError; + Uint32 _timeOutMillis; + Uint32 _errorCount; + +protected: + NdbMutex* theMutexPtr; + bool _connected; // Are we connected + bool _connecting; // Connect thread is running + bool _disconnecting; // We are disconnecting + + void * callbackObj; +}; + +inline +bool +Transporter::isConnected() const { + return _connected; +} + +inline +NodeId +Transporter::getRemoteNodeId() const { + return remoteNodeId; +} + +inline +void +Transporter::reportThreadError(NodeId nodeId, TransporterError errorCode) +{ +#if 0 + ndbout_c("Transporter::reportThreadError (NodeId: %d, Error code: %d)", + nodeId, errorCode); +#endif + _threadError = errorCode; + _errorCount++; +} + +inline +TransporterError +Transporter::getThreadError(){ + return _threadError; +} + +inline +Uint32 +Transporter::getErrorCount() +{ + return _errorCount; +} + +inline +void +Transporter::resetThreadError() +{ + _threadError = TE_NO_ERROR; +} + +inline +void +Transporter::setCallbackObject(void * callback) { + callbackObj = callback; +} + +#endif // Define of Transporter_H diff --git a/ndb/src/common/transporter/TransporterInternalDefinitions.hpp b/ndb/src/common/transporter/TransporterInternalDefinitions.hpp new file mode 100644 index 00000000000..18d54ca1e89 --- /dev/null +++ b/ndb/src/common/transporter/TransporterInternalDefinitions.hpp @@ -0,0 +1,323 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef TransporterInternalDefinitions_H +#define TransporterInternalDefinitions_H + +#if defined DEBUG_TRANSPORTER || defined VM_TRACE +#include +#endif + +#ifdef NDB_SOLARIS +#define NDB_TCP_TRANSPORTER +//#define NDB_SCI_TRANSPORTER +#define NDB_SHM_TRANSPORTER +#elif defined NDB_OSE || defined NDB_SOFTOSE +#define NDB_TCP_TRANSPORTER +#define NDB_OSE_TRANSPORTER +#elif defined NDB_LINUX +#define NDB_TCP_TRANSPORTER +#define NDB_SCI_TRANSPORTER +#define NDB_SHM_TRANSPORTER +#elif defined NDB_WIN32 +#define NDB_TCP_TRANSPORTER +#elif defined NDB_HPUX +#define NDB_TCP_TRANSPORTER +#define NDB_SHM_TRANSPORTER +#elif defined NDB_MACOSX +#define NDB_TCP_TRANSPORTER +#define NDB_SHM_TRANSPORTER +#elif defined NDB_IBMAIX +#define NDB_TCP_TRANSPORTER +#define NDB_SHM_TRANSPORTER +#elif defined NDB_TRU64X +#define NDB_TCP_TRANSPORTER +#define NDB_SHM_TRANSPORTER +#else +#error unsupported platform +#endif + +#ifndef HAVE_SCI +#ifdef NDB_SCI_TRANSPORTER +#undef NDB_SCI_TRANSPORTER +#endif +#endif + +#ifdef DEBUG_TRANSPORTER +#define DEBUG(x) ndbout << x << endl +#else +#define DEBUG(x) +#endif + +#if defined VM_TRACE || defined DEBUG_TRANSPORTER +#define WARNING(X) ndbout << X << endl; +#else +#define WARNING(X) +#endif + +// Calculate a checksum +inline +Uint32 +computeChecksum(const Uint32 * const startOfData, int nWords) { + Uint32 chksum = startOfData[0]; + for (int i=1; i < nWords; i++) + chksum ^= startOfData[i]; + return chksum; +} + +struct Protocol6 { + Uint32 word1; + Uint32 word2; + Uint32 word3; + +/** + * + * b = Byte order - 4 Bits (Note 1 significant bit) + * g = GSN - 16 Bits + * p = Prio - 2 Bits + * c = Checksum included - 1 Bit + * z = Compression - 1 Bit + * v = Version id - 4 Bits + * i = Signal id included - 1 Bit + * m = Message length - 16 Bits (0-65536) (In word -> 0-256k bytes) + * d = Signal data length - 5 Bits (0-31) + * t = trace - 6 Bits (0-63) + * r = Recievers block no - 16 Bits + * s = Senders block no - 16 Bits + * u = Unused - 7 Bits + * f = FragmentInfo1 - 1 Bit + * h = FragmentInfo2 - 1 bit + * n = No of segments - 2 Bits + + * Word 1 + * + * + * 1111111111222222222233 + * 01234567890123456789012345678901 + * bfizcppbmmmmmmmmmmmmmmmmbhdddddb + + ** + * Word 2 + * + * 1111111111222222222233 + * 01234567890123456789012345678901 + * ggggggggggggggggvvvvttttttnn + + ** + * Word 3 + * + * 1111111111222222222233 + * 01234567890123456789012345678901 + * rrrrrrrrrrrrrrrrssssssssssssssss + + ** + * Word 4 (Optional Signal Id) + */ + + /** + * 0 = Big endian (Sparc), 1 = Little endian (Intel) + */ + static Uint32 getByteOrder (const Uint32 & word1); + static Uint32 getCompressed (const Uint32 & word1); + static Uint32 getSignalIdIncluded(const Uint32 & word1); + static Uint32 getCheckSumIncluded(const Uint32 & word1); + static Uint32 getPrio (const Uint32 & word1); + static Uint32 getMessageLength (const Uint32 & word1); + + static void setByteOrder (Uint32 & word1, Uint32 byteOrder); + static void setCompressed (Uint32 & word1, Uint32 compressed); + static void setSignalIdIncluded(Uint32 & word1, Uint32 signalId); + static void setCheckSumIncluded(Uint32 & word1, Uint32 checkSum); + static void setPrio (Uint32 & word1, Uint32 prio); + static void setMessageLength (Uint32 & word1, Uint32 messageLen); + + static void createSignalHeader(SignalHeader * const dst, + const Uint32 & word1, + const Uint32 & word2, + const Uint32 & word3); + + static void createProtocol6Header(Uint32 & word1, + Uint32 & word2, + Uint32 & word3, + const SignalHeader * const src); +}; + +#define WORD1_BYTEORDER_MASK (0x81000081) +#define WORD1_SIGNALID_MASK (0x00000004) +#define WORD1_COMPRESSED_MASK (0x00000008) +#define WORD1_CHECKSUM_MASK (0x00000010) +#define WORD1_PRIO_MASK (0x00000060) +#define WORD1_MESSAGELEN_MASK (0x00FFFF00) +#define WORD1_SIGNAL_LEN_MASK (0x7C000000) +#define WORD1_FRAG_INF_MASK (0x00000002) +#define WORD1_FRAG_INF2_MASK (0x02000000) + +#define WORD1_FRAG_INF_SHIFT (1) +#define WORD1_SIGNALID_SHIFT (2) +#define WORD1_COMPRESSED_SHIFT (3) +#define WORD1_CHECKSUM_SHIFT (4) +#define WORD1_PRIO_SHIFT (5) +#define WORD1_MESSAGELEN_SHIFT (8) +#define WORD1_FRAG_INF2_SHIFT (25) +#define WORD1_SIGNAL_LEN_SHIFT (26) + +#define WORD2_VERID_GSN_MASK (0x000FFFFF) +#define WORD2_TRACE_MASK (0x03f00000) +#define WORD2_SEC_COUNT_MASK (0x0c000000) + +#define WORD2_TRACE_SHIFT (20) +#define WORD2_SEC_COUNT_SHIFT (26) + +#define WORD3_SENDER_MASK (0x0000FFFF) +#define WORD3_RECEIVER_MASK (0xFFFF0000) + +#define WORD3_RECEIVER_SHIFT (16) + +inline +Uint32 +Protocol6::getByteOrder(const Uint32 & word1){ + return word1 & 1; +} + +inline +Uint32 +Protocol6::getCompressed(const Uint32 & word1){ + return (word1 & WORD1_COMPRESSED_MASK) >> WORD1_COMPRESSED_SHIFT; +} + +inline +Uint32 +Protocol6::getSignalIdIncluded(const Uint32 & word1){ + return (word1 & WORD1_SIGNALID_MASK) >> WORD1_SIGNALID_SHIFT; +} + +inline +Uint32 +Protocol6::getCheckSumIncluded(const Uint32 & word1){ + return (word1 & WORD1_CHECKSUM_MASK) >> WORD1_CHECKSUM_SHIFT; +} + +inline +Uint32 +Protocol6::getMessageLength(const Uint32 & word1){ + return (word1 & WORD1_MESSAGELEN_MASK) >> WORD1_MESSAGELEN_SHIFT; +} + +inline +Uint32 +Protocol6::getPrio(const Uint32 & word1){ + return (word1 & WORD1_PRIO_MASK) >> WORD1_PRIO_SHIFT; +} + +inline +void +Protocol6::setByteOrder(Uint32 & word1, Uint32 byteOrder){ + Uint32 tmp = byteOrder; + tmp |= (tmp << 7); + tmp |= (tmp << 24); + word1 |= (tmp & WORD1_BYTEORDER_MASK); +} + +inline +void +Protocol6::setCompressed(Uint32 & word1, Uint32 compressed){ + word1 |= ((compressed << WORD1_COMPRESSED_SHIFT) & WORD1_COMPRESSED_MASK); +} + +inline +void +Protocol6::setSignalIdIncluded(Uint32 & word1, Uint32 signalId){ + word1 |= ((signalId << WORD1_SIGNALID_SHIFT) & WORD1_SIGNALID_MASK); +} + +inline +void +Protocol6::setCheckSumIncluded(Uint32 & word1, Uint32 checkSum){ + word1 |= ((checkSum << WORD1_CHECKSUM_SHIFT) & WORD1_CHECKSUM_MASK); +} + +inline +void +Protocol6::setMessageLength(Uint32 & word1, Uint32 messageLen){ + word1 |= ((messageLen << WORD1_MESSAGELEN_SHIFT) & WORD1_MESSAGELEN_MASK); +} + +inline +void +Protocol6::setPrio(Uint32 & word1, Uint32 prio){ + word1 |= ((prio << WORD1_PRIO_SHIFT) & WORD1_PRIO_MASK); +} + +inline +void +Protocol6::createSignalHeader(SignalHeader * const dst, + const Uint32 & word1, + const Uint32 & word2, + const Uint32 & word3){ + + Uint32 signal_len = (word1 & WORD1_SIGNAL_LEN_MASK)>> WORD1_SIGNAL_LEN_SHIFT; + Uint32 fragInfo1 = (word1 & WORD1_FRAG_INF_MASK) >> (WORD1_FRAG_INF_SHIFT-1); + Uint32 fragInfo2 = (word1 & WORD1_FRAG_INF2_MASK) >> (WORD1_FRAG_INF2_SHIFT); + Uint32 trace = (word2 & WORD2_TRACE_MASK) >> WORD2_TRACE_SHIFT; + Uint32 verid_gsn = (word2 & WORD2_VERID_GSN_MASK); + Uint32 secCount = (word2 & WORD2_SEC_COUNT_MASK) >> WORD2_SEC_COUNT_SHIFT; + + dst->theTrace = trace; + dst->m_noOfSections = secCount; + dst->m_fragmentInfo = fragInfo1 | fragInfo2; + + dst->theLength = signal_len; + dst->theVerId_signalNumber = verid_gsn; + + Uint32 sBlockNum = (word3 & WORD3_SENDER_MASK); + Uint32 rBlockNum = (word3 & WORD3_RECEIVER_MASK) >> WORD3_RECEIVER_SHIFT; + + dst->theSendersBlockRef = sBlockNum; + dst->theReceiversBlockNumber = rBlockNum; +} + +inline +void +Protocol6::createProtocol6Header(Uint32 & word1, + Uint32 & word2, + Uint32 & word3, + const SignalHeader * const src){ + const Uint32 signal_len = src->theLength; + const Uint32 fragInfo = src->m_fragmentInfo; + const Uint32 fragInfo1 = (fragInfo & 2); + const Uint32 fragInfo2 = (fragInfo & 1); + + const Uint32 trace = src->theTrace; + const Uint32 verid_gsn = src->theVerId_signalNumber; + const Uint32 secCount = src->m_noOfSections; + + word1 |= ((signal_len << WORD1_SIGNAL_LEN_SHIFT) & WORD1_SIGNAL_LEN_MASK); + word1 |= ((fragInfo1 << (WORD1_FRAG_INF_SHIFT-1)) & WORD1_FRAG_INF_MASK); + word1 |= ((fragInfo2 << WORD1_FRAG_INF2_SHIFT) & WORD1_FRAG_INF2_MASK); + + word2 |= ((trace << WORD2_TRACE_SHIFT) & WORD2_TRACE_MASK); + word2 |= (verid_gsn & WORD2_VERID_GSN_MASK); + word2 |= ((secCount << WORD2_SEC_COUNT_SHIFT) & WORD2_SEC_COUNT_MASK); + + Uint32 sBlockNum = src->theSendersBlockRef ; + Uint32 rBlockNum = src->theReceiversBlockNumber ; + + word3 |= (sBlockNum & WORD3_SENDER_MASK); + word3 |= ((rBlockNum << WORD3_RECEIVER_SHIFT) & WORD3_RECEIVER_MASK); +} + +// Define of TransporterInternalDefinitions_H +#endif diff --git a/ndb/src/common/transporter/TransporterRegistry.cpp b/ndb/src/common/transporter/TransporterRegistry.cpp new file mode 100644 index 00000000000..dcd957f40ce --- /dev/null +++ b/ndb/src/common/transporter/TransporterRegistry.cpp @@ -0,0 +1,1188 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "TransporterRegistry.hpp" +#include "TransporterInternalDefinitions.hpp" + +#include "Transporter.hpp" + +#include +#include + +#ifdef NDB_TCP_TRANSPORTER +#include "TCP_Transporter.hpp" +#endif + +#ifdef NDB_OSE_TRANSPORTER +#include "OSE_Receiver.hpp" +#include "OSE_Transporter.hpp" +#endif + +#ifdef NDB_SCI_TRANSPORTER +#include "SCI_Transporter.hpp" +#endif + +#ifdef NDB_SHM_TRANSPORTER +#include "SHM_Transporter.hpp" +#endif + +#include "TransporterCallback.hpp" +#include "NdbOut.hpp" +#include +#include +#define STEPPING 1 + +TransporterRegistry::TransporterRegistry(void * callback, + unsigned _maxTransporters, + unsigned sizeOfLongSignalMemory) { + + nodeIdSpecified = false; + maxTransporters = _maxTransporters; + sendCounter = 1; + m_ccCount = 0; + m_ccIndex = 0; + m_ccStep = STEPPING; + m_ccReady = false; + m_nTransportersPerformConnect=0; + + callbackObj=callback; + + theTCPTransporters = new TCP_Transporter * [maxTransporters]; + theSCITransporters = new SCI_Transporter * [maxTransporters]; + theSHMTransporters = new SHM_Transporter * [maxTransporters]; + theOSETransporters = new OSE_Transporter * [maxTransporters]; + theTransporterTypes = new TransporterType [maxTransporters]; + theTransporters = new Transporter * [maxTransporters]; + performStates = new PerformState [maxTransporters]; + ioStates = new IOState [maxTransporters]; + + // Initialize member variables + nTransporters = 0; + nTCPTransporters = 0; + nSCITransporters = 0; + nSHMTransporters = 0; + nOSETransporters = 0; + + // Initialize the transporter arrays + for (unsigned i=0; idestroyPhantom(); + delete theOSEReceiver; + theOSEReceiver = 0; + } +#endif +} + +void +TransporterRegistry::removeAll(){ + for(unsigned i = 0; igetRemoteNodeId()); + } +} + +void +TransporterRegistry::disconnectAll(){ + for(unsigned i = 0; idoDisconnect(); + } +} + +bool +TransporterRegistry::init(NodeId nodeId) { + nodeIdSpecified = true; + localNodeId = nodeId; + + DEBUG("TransporterRegistry started node: " << localNodeId); + + // return allocateLongSignalMemoryPool(nLargeSegments); + return true; +} + +bool +TransporterRegistry::createTransporter(TCP_TransporterConfiguration *config) { +#ifdef NDB_TCP_TRANSPORTER + + if(!nodeIdSpecified){ + init(config->localNodeId); + } + + if(config->localNodeId != localNodeId) + return false; + + if(theTransporters[config->remoteNodeId] != NULL) + return false; + + + TCP_Transporter * t = new TCP_Transporter(config->sendBufferSize, + config->maxReceiveSize, + config->port, + config->remoteHostName, + config->localHostName, + config->remoteNodeId, + localNodeId, + config->byteOrder, + config->compression, + config->checksum, + config->signalId); + if (t == NULL) + return false; + else if (!t->initTransporter()) { + delete t; + return false; + } + + t->setCallbackObject(callbackObj); + + // Put the transporter in the transporter arrays + theTCPTransporters[nTCPTransporters] = t; + theTransporters[t->getRemoteNodeId()] = t; + theTransporterTypes[t->getRemoteNodeId()] = tt_TCP_TRANSPORTER; + performStates[t->getRemoteNodeId()] = PerformNothing; + nTransporters++; + nTCPTransporters++; + +#if defined NDB_OSE || defined NDB_SOFTOSE + t->theReceiverPid = theReceiverPid; +#endif + + return true; +#else + return false; +#endif +} + +bool +TransporterRegistry::createTransporter(OSE_TransporterConfiguration *conf) { +#ifdef NDB_OSE_TRANSPORTER + + if(!nodeIdSpecified){ + init(conf->localNodeId); + } + + if(conf->localNodeId != localNodeId) + return false; + + if(theTransporters[conf->remoteNodeId] != NULL) + return false; + + if(theOSEReceiver == NULL){ + theOSEReceiver = new OSE_Receiver(this, + 10, + localNodeId); + } + + OSE_Transporter * t = new OSE_Transporter(conf->prioASignalSize, + conf->prioBSignalSize, + localNodeId, + conf->localHostName, + conf->remoteNodeId, + conf->remoteHostName, + conf->byteOrder, + conf->compression, + conf->checksum, + conf->signalId); + if (t == NULL) + return false; + else if (!t->initTransporter()) { + delete t; + return false; + } + t->setCallbackObject(callbackObj); + // Put the transporter in the transporter arrays + theOSETransporters[nOSETransporters] = t; + theTransporters[t->getRemoteNodeId()] = t; + theTransporterTypes[t->getRemoteNodeId()] = tt_OSE_TRANSPORTER; + performStates[t->getRemoteNodeId()] = PerformNothing; + + nTransporters++; + nOSETransporters++; + + return true; +#else + return false; +#endif +} + +bool +TransporterRegistry::createTransporter(SCI_TransporterConfiguration *config) { +#ifdef NDB_SCI_TRANSPORTER + + if(!SCI_Transporter::initSCI()) + abort(); + + if(!nodeIdSpecified){ + init(config->localNodeId); + } + + if(config->localNodeId != localNodeId) + return false; + + if(theTransporters[config->remoteNodeId] != NULL) + return false; + + SCI_Transporter * t = new SCI_Transporter(config->sendLimit, + config->bufferSize, + config->nLocalAdapters, + config->remoteSciNodeId0, + config->remoteSciNodeId1, + localNodeId, + config->remoteNodeId, + config->byteOrder, + config->compression, + config->checksum, + config->signalId); + + if (t == NULL) + return false; + else if (!t->initTransporter()) { + delete t; + return false; + } + t->setCallbackObject(callbackObj); + // Put the transporter in the transporter arrays + theSCITransporters[nSCITransporters] = t; + theTransporters[t->getRemoteNodeId()] = t; + theTransporterTypes[t->getRemoteNodeId()] = tt_SCI_TRANSPORTER; + performStates[t->getRemoteNodeId()] = PerformNothing; + nTransporters++; + nSCITransporters++; + + return true; +#else + return false; +#endif +} + +bool +TransporterRegistry::createTransporter(SHM_TransporterConfiguration *config) { +#ifdef NDB_SHM_TRANSPORTER + if(!nodeIdSpecified){ + init(config->localNodeId); + } + + if(config->localNodeId != localNodeId) + return false; + + if(theTransporters[config->remoteNodeId] != NULL) + return false; + + SHM_Transporter * t = new SHM_Transporter(config->localNodeId, + config->remoteNodeId, + config->shmKey, + config->shmSize, + config->compression, + config->checksum, + config->signalId + ); + if (t == NULL) + return false; + else if (!t->initTransporter()) { + delete t; + return false; + } + t->setCallbackObject(callbackObj); + // Put the transporter in the transporter arrays + theSHMTransporters[nSHMTransporters] = t; + theTransporters[t->getRemoteNodeId()] = t; + theTransporterTypes[t->getRemoteNodeId()] = tt_SHM_TRANSPORTER; + performStates[t->getRemoteNodeId()] = PerformNothing; + + nTransporters++; + nSHMTransporters++; + + return true; +#else + return false; +#endif +} + + +void +TransporterRegistry::removeTransporter(NodeId nodeId) { + + DEBUG("Removing transporter from " << localNodeId + << " to " << nodeId); + + if(theTransporters[nodeId] == NULL) + return; + + theTransporters[nodeId]->doDisconnect(); + + const TransporterType type = theTransporterTypes[nodeId]; + + int ind = 0; + switch(type){ + case tt_TCP_TRANSPORTER: +#ifdef NDB_TCP_TRANSPORTER + for(; ind < nTCPTransporters; ind++) + if(theTCPTransporters[ind]->getRemoteNodeId() == nodeId) + break; + ind++; + for(; indgetRemoteNodeId() == nodeId) + break; + ind++; + for(; indgetRemoteNodeId() == nodeId) + break; + ind++; + for(; indgetRemoteNodeId() == nodeId) + break; + ind++; + for(; indtheReceiversBlockNumber == 252))) { + + if(t->isConnected()){ + Uint32 lenBytes = t->m_packer.getMessageLength(signalHeader, ptr); + if(lenBytes <= MAX_MESSAGE_SIZE){ + Uint32 * insertPtr = t->getWritePtr(lenBytes, prio); + if(insertPtr != 0){ + t->m_packer.pack(insertPtr, prio, signalHeader, signalData, ptr); + t->updateWritePtr(lenBytes, prio); + return SEND_OK; + } + + int sleepTime = 2; + + /** + * @note: on linux/i386 the granularity is 10ms + * so sleepTime = 2 generates a 10 ms sleep. + */ + for(int i = 0; i<50; i++){ + if((nSHMTransporters+nSCITransporters) == 0) + NdbSleep_MilliSleep(sleepTime); + insertPtr = t->getWritePtr(lenBytes, prio); + if(insertPtr != 0){ + t->m_packer.pack(insertPtr, prio, signalHeader, signalData, ptr); + t->updateWritePtr(lenBytes, prio); + break; + } + } + + if(insertPtr != 0){ + /** + * Send buffer full, but resend works + */ + reportError(callbackObj, nodeId, TE_SEND_BUFFER_FULL); + return SEND_OK; + } + + WARNING("Signal to " << nodeId << " lost(buffer)"); + reportError(callbackObj, nodeId, TE_SIGNAL_LOST_SEND_BUFFER_FULL); + return SEND_BUFFER_FULL; + } else { + return SEND_MESSAGE_TOO_BIG; + } + } else { + DEBUG("Signal to " << nodeId << " lost(disconnect) "); + return SEND_DISCONNECTED; + } + } else { + DEBUG("Discarding message to block: " + << signalHeader->theReceiversBlockNumber + << " node: " << nodeId); + + if(t == NULL) + return SEND_UNKNOWN_NODE; + + return SEND_BLOCKED; + } +} + +SendStatus +TransporterRegistry::prepareSend(const SignalHeader * const signalHeader, + Uint8 prio, + const Uint32 * const signalData, + NodeId nodeId, + class SectionSegmentPool & thePool, + const SegmentedSectionPtr ptr[3]){ + + + Transporter *t = theTransporters[nodeId]; + if(t != NULL && + (((ioStates[nodeId] != HaltOutput) && (ioStates[nodeId] != HaltIO)) || + (signalHeader->theReceiversBlockNumber == 252))) { + + if(t->isConnected()){ + Uint32 lenBytes = t->m_packer.getMessageLength(signalHeader, ptr); + if(lenBytes <= MAX_MESSAGE_SIZE){ + Uint32 * insertPtr = t->getWritePtr(lenBytes, prio); + if(insertPtr != 0){ + t->m_packer.pack(insertPtr, prio, signalHeader, signalData, thePool, ptr); + t->updateWritePtr(lenBytes, prio); + return SEND_OK; + } + + + /** + * @note: on linux/i386 the granularity is 10ms + * so sleepTime = 2 generates a 10 ms sleep. + */ + int sleepTime = 2; + for(int i = 0; i<50; i++){ + if((nSHMTransporters+nSCITransporters) == 0) + NdbSleep_MilliSleep(sleepTime); + insertPtr = t->getWritePtr(lenBytes, prio); + if(insertPtr != 0){ + t->m_packer.pack(insertPtr, prio, signalHeader, signalData, thePool, ptr); + t->updateWritePtr(lenBytes, prio); + break; + } + } + + if(insertPtr != 0){ + /** + * Send buffer full, but resend works + */ + reportError(callbackObj, nodeId, TE_SEND_BUFFER_FULL); + return SEND_OK; + } + + WARNING("Signal to " << nodeId << " lost(buffer)"); + reportError(callbackObj, nodeId, TE_SIGNAL_LOST_SEND_BUFFER_FULL); + return SEND_BUFFER_FULL; + } else { + return SEND_MESSAGE_TOO_BIG; + } + } else { + DEBUG("Signal to " << nodeId << " lost(disconnect) "); + return SEND_DISCONNECTED; + } + } else { + DEBUG("Discarding message to block: " + << signalHeader->theReceiversBlockNumber + << " node: " << nodeId); + + if(t == NULL) + return SEND_UNKNOWN_NODE; + + return SEND_BLOCKED; + } +} + +void +TransporterRegistry::external_IO(Uint32 timeOutMillis) { + //----------------------------------------------------------- + // Most of the time we will send the buffers here and then wait + // for new signals. Thus we start by sending without timeout + // followed by the receive part where we expect to sleep for + // a while. + //----------------------------------------------------------- + if(pollReceive(timeOutMillis)){ + performReceive(); + } + performSend(); +} + +Uint32 +TransporterRegistry::pollReceive(Uint32 timeOutMillis){ + Uint32 retVal = 0; +#ifdef NDB_OSE_TRANSPORTER + retVal |= poll_OSE(timeOutMillis); + retVal |= poll_TCP(0); + return retVal; +#endif + + if((nSHMTransporters+nSCITransporters) > 0) + timeOutMillis=0; +#ifdef NDB_TCP_TRANSPORTER + if(nTCPTransporters > 0) + retVal |= poll_TCP(timeOutMillis); + else + tcpReadSelectReply = 0; +#endif +#ifdef NDB_SCI_TRANSPORTER + if(nSCITransporters > 0) + retVal |= poll_SCI(timeOutMillis); +#endif +#ifdef NDB_SHM_TRANSPORTER + if(nSHMTransporters > 0) + retVal |= poll_SHM(timeOutMillis); +#endif + return retVal; +} + + +#ifdef NDB_SCI_TRANSPORTER +Uint32 +TransporterRegistry::poll_SCI(Uint32 timeOutMillis){ + + for (int i=0; iisConnected()) { + if(t->hasDataToRead()) + return 1; + } + } + return 0; +} +#endif + + +#ifdef NDB_SHM_TRANSPORTER +Uint32 +TransporterRegistry::poll_SHM(Uint32 timeOutMillis) +{ + for(int j=0; j < 20; j++) + for (int i=0; iisConnected()) { + if(t->hasDataToRead()) { + return 1; + } + } + } + /** + * @note: granularity of linux/i386 timer is not good enough. + * Can't sleep if using SHM as it is now. + */ + /* + if(timeOutMillis > 0) + NdbSleep_MilliSleep(timeOutMillis); + else + NdbSleep_MilliSleep(1); + */ + return 0; +#if 0 + NDB_TICKS startTime = NdbTick_CurrentMillisecond(); + for(int i=0; i<100; i++) { + for (int i=0; iisConnected()) { + if(t->hasDataToRead()){ + return 1; + } + else + continue; + } + else + continue; + } + + if(NdbTick_CurrentMillisecond() > (startTime +timeOutMillis)) + return 0; + } + NdbSleep_MilliSleep(5); + return 0; + +#endif +#if 0 + + for(int j=0; j < 100; j++) { + for (int i=0; iisConnected()) { + if(t->hasDataToRead()) + return 1; + } + } + } + return 0; +#endif +} + + +#endif + +#ifdef NDB_OSE_TRANSPORTER +Uint32 +TransporterRegistry::poll_OSE(Uint32 timeOutMillis){ + if(theOSEReceiver != NULL){ + return theOSEReceiver->doReceive(timeOutMillis); + } + NdbSleep_MilliSleep(timeOutMillis); + return 0; +} +#endif + +#ifdef NDB_TCP_TRANSPORTER +Uint32 +TransporterRegistry::poll_TCP(Uint32 timeOutMillis){ + + if (nTCPTransporters == 0){ + tcpReadSelectReply = 0; + return 0; + } + + struct timeval timeout; +#ifdef NDB_OSE + + // Return directly if there are no TCP transporters configured + + if(timeOutMillis <= 1){ + timeout.tv_sec = 0; + timeout.tv_usec = 1025; + } else { + timeout.tv_sec = timeOutMillis / 1000; + timeout.tv_usec = (timeOutMillis % 1000) * 1000; + } +#else + timeout.tv_sec = timeOutMillis / 1000; + timeout.tv_usec = (timeOutMillis % 1000) * 1000; +#endif + + NDB_SOCKET_TYPE maxSocketValue = 0; + + // Needed for TCP/IP connections + // The read- and writeset are used by select + + FD_ZERO(&tcpReadset); + + // Prepare for sending and receiving + for (int i = 0; i < nTCPTransporters; i++) { + TCP_Transporter * t = theTCPTransporters[i]; + + // If the transporter is connected + if (t->isConnected()) { + + const NDB_SOCKET_TYPE socket = t->getSocket(); + // Find the highest socket value. It will be used by select + if (socket > maxSocketValue) + maxSocketValue = socket; + + // Put the connected transporters in the socket read-set + FD_SET(socket, &tcpReadset); + } + } + + // The highest socket value plus one + maxSocketValue++; + + tcpReadSelectReply = select(maxSocketValue, &tcpReadset, 0, 0, &timeout); +#ifdef NDB_WIN32 + if(tcpReadSelectReply == SOCKET_ERROR) + { + NdbSleep_MilliSleep(timeOutMillis); + } +#endif + + return tcpReadSelectReply; +} +#endif + + +void +TransporterRegistry::performReceive(){ +#ifdef NDB_OSE_TRANSPORTER + if(theOSEReceiver != 0){ + while(theOSEReceiver->hasData()){ + NodeId remoteNodeId; + Uint32 * readPtr; + Uint32 sz = theOSEReceiver->getReceiveData(&remoteNodeId, &readPtr); + Uint32 szUsed = unpack(readPtr, + sz, + remoteNodeId, + ioStates[remoteNodeId]); +#ifdef DEBUG_TRANSPORTER + /** + * OSE transporter can handle executions of + * half signals + */ + assert(sz == szUsed); +#endif + theOSEReceiver->updateReceiveDataPtr(szUsed); + theOSEReceiver->doReceive(0); + // checkJobBuffer(); + } + } +#endif + +#ifdef NDB_TCP_TRANSPORTER + if(tcpReadSelectReply > 0){ + for (int i=0; igetRemoteNodeId(); + const NDB_SOCKET_TYPE socket = t->getSocket(); + if(performStates[nodeId] == PerformIO){ + if(t->isConnected() && FD_ISSET(socket, &tcpReadset)) { + const int receiveSize = t->doReceive(); + if(receiveSize > 0){ + Uint32 * ptr; + Uint32 sz = t->getReceiveData(&ptr); + Uint32 szUsed = unpack(ptr, sz, nodeId, ioStates[nodeId]); + t->updateReceiveDataPtr(szUsed); + } + } + } + } + } +#endif + + +#ifdef NDB_SCI_TRANSPORTER + //performReceive + //do prepareReceive on the SCI transporters (prepareReceive(t,,,,)) + for (int i=0; igetRemoteNodeId(); + if(performStates[nodeId] == PerformIO){ + if(t->isConnected() && t->checkConnected()){ + Uint32 * readPtr, * eodPtr; + t->getReceivePtr(&readPtr, &eodPtr); + readPtr = unpack(readPtr, eodPtr, nodeId, ioStates[nodeId]); + t->updateReceivePtr(readPtr); + } + } + } +#endif +#ifdef NDB_SHM_TRANSPORTER + for (int i=0; igetRemoteNodeId(); + if(performStates[nodeId] == PerformIO){ + if(t->isConnected() && t->checkConnected()){ + Uint32 * readPtr, * eodPtr; + t->getReceivePtr(&readPtr, &eodPtr); + readPtr = unpack(readPtr, eodPtr, nodeId, ioStates[nodeId]); + t->updateReceivePtr(readPtr); + } + } + } +#endif +} + +static int x = 0; +void +TransporterRegistry::performSend(){ + + sendCounter = 1; + +#ifdef NDB_OSE_TRANSPORTER + for (int i = 0; i < nOSETransporters; i++){ + OSE_Transporter *t = theOSETransporters[i]; + if((performStates[t->getRemoteNodeId()] == PerformIO) && + (t->isConnected())) { + t->doSend(); + }//if + }//for +#endif + +#ifdef NDB_TCP_TRANSPORTER +#ifdef NDB_OSE + { + int maxSocketValue = 0; + + // Needed for TCP/IP connections + // The writeset are used by select + fd_set writeset; + FD_ZERO(&writeset); + + // Prepare for sending and receiving + for (int i = 0; i < nTCPTransporters; i++) { + TCP_Transporter * t = theTCPTransporters[i]; + + // If the transporter is connected + if ((t->hasDataToSend()) && (t->isConnected())) { + const int socket = t->getSocket(); + // Find the highest socket value. It will be used by select + if (socket > maxSocketValue) { + maxSocketValue = socket; + }//if + FD_SET(socket, &writeset); + }//if + }//for + + // The highest socket value plus one + if(maxSocketValue == 0) + return; + + maxSocketValue++; + struct timeval timeout = { 0, 1025 }; + Uint32 tmp = select(maxSocketValue, 0, &writeset, 0, &timeout); + + if (tmp == 0) { + return; + }//if + for (int i = 0; i < nTCPTransporters; i++) { + TCP_Transporter *t = theTCPTransporters[i]; + const NodeId nodeId = t->getRemoteNodeId(); + const int socket = t->getSocket(); + if(performStates[nodeId] == PerformIO){ + if(t->isConnected() && FD_ISSET(socket, &writeset)) { + t->doSend(); + }//if + }//if + }//for + } +#endif +#ifdef NDB_TCP_TRANSPORTER + for (int i = x; i < nTCPTransporters; i++) { + TCP_Transporter *t = theTCPTransporters[i]; + if (t && + (t->hasDataToSend()) && + (t->isConnected()) && + (performStates[t->getRemoteNodeId()] == PerformIO)) { + t->doSend(); + }//if + }//for + for (int i = 0; i < x && i < nTCPTransporters; i++) { + TCP_Transporter *t = theTCPTransporters[i]; + if (t && + (t->hasDataToSend()) && + (t->isConnected()) && + (performStates[t->getRemoteNodeId()] == PerformIO)) { + t->doSend(); + }//if + }//for + x++; + if (x == nTCPTransporters) x = 0; +#endif +#endif +#ifdef NDB_SCI_TRANSPORTER + //scroll through the SCI transporters, + // get each transporter, check if connected, send data + for (int i=0; igetRemoteNodeId(); + + if(performStates[nodeId] == PerformIO){ + if(t->isConnected() && t->hasDataToSend()) { + t->doSend(); + } //if + } //if + } //if +#endif +} + +int +TransporterRegistry::forceSendCheck(int sendLimit){ + int tSendCounter = sendCounter; + sendCounter = tSendCounter + 1; + if (tSendCounter >= sendLimit) { + performSend(); + sendCounter = 1; + return 1; + }//if + return 0; +}//TransporterRegistry::forceSendCheck() + +#ifdef DEBUG_TRANSPORTER +void +TransporterRegistry::printState(){ + ndbout << "-- TransporterRegistry -- " << endl << endl + << "Transporters = " << nTransporters << endl; + for(int i = 0; igetRemoteNodeId(); + ndbout << "Transporter: " << remoteNodeId + << " PerformState: " << performStates[remoteNodeId] + << " IOState: " << ioStates[remoteNodeId] << endl; + } +} +#endif + +PerformState +TransporterRegistry::performState(NodeId nodeId) { + return performStates[nodeId]; +} + +#ifdef DEBUG_TRANSPORTER +const char * +performStateString(PerformState state){ + switch(state){ + case PerformNothing: + return "PerformNothing"; + break; + case PerformIO: + return "PerformIO"; + break; + case PerformConnect: + return "PerformConnect"; + break; + case PerformDisconnect: + return "PerformDisconnect"; + break; + case RemoveTransporter: + return "RemoveTransporter"; + break; + } + return "Unknown"; +} +#endif + +void +TransporterRegistry::setPerformState(NodeId nodeId, PerformState state) { + DEBUG("TransporterRegistry::setPerformState(" + << nodeId << ", " << performStateString(state) << ")"); + + performStates[nodeId] = state; +} + +void +TransporterRegistry::setPerformState(PerformState state) { + int count = 0; + int index = 0; + while(count < nTransporters){ + if(theTransporters[index] != 0){ + setPerformState(theTransporters[index]->getRemoteNodeId(), state); + count ++; + } + index ++; + } +} + +IOState +TransporterRegistry::ioState(NodeId nodeId) { + return ioStates[nodeId]; +} + +void +TransporterRegistry::setIOState(NodeId nodeId, IOState state) { + DEBUG("TransporterRegistry::setIOState(" + << nodeId << ", " << state << ")"); + ioStates[nodeId] = state; +} + +void +TransporterRegistry::startReceiving(){ +#ifdef NDB_OSE_TRANSPORTER + if(theOSEReceiver != NULL){ + theOSEReceiver->createPhantom(); + } +#endif + +#ifdef NDB_OSE + theOSEJunkSocketRecv = socket(AF_INET, SOCK_STREAM, 0); +#endif + +#if defined NDB_OSE || defined NDB_SOFTOSE + theReceiverPid = current_process(); + for(int i = 0; itheReceiverPid = theReceiverPid; +#endif +} + +void +TransporterRegistry::stopReceiving(){ +#ifdef NDB_OSE_TRANSPORTER + if(theOSEReceiver != NULL){ + theOSEReceiver->destroyPhantom(); + } +#endif + + /** + * Disconnect all transporters, this includes detach from remote node + * and since that must be done from the same process that called attach + * it's done here in the receive thread + */ + disconnectAll(); + +#if defined NDB_OSE || defined NDB_SOFTOSE + if(theOSEJunkSocketRecv > 0) + close(theOSEJunkSocketRecv); + theOSEJunkSocketRecv = -1; +#endif + +} + +void +TransporterRegistry::startSending(){ +#if defined NDB_OSE || defined NDB_SOFTOSE + theOSEJunkSocketSend = socket(AF_INET, SOCK_STREAM, 0); +#endif +} + +void +TransporterRegistry::stopSending(){ +#if defined NDB_OSE || defined NDB_SOFTOSE + if(theOSEJunkSocketSend > 0) + close(theOSEJunkSocketSend); + theOSEJunkSocketSend = -1; +#endif +} + +/** + * The old implementation did not scale with a large + * number of nodes. (Watchdog killed NDB because + * it took too long time to allocated threads in + * doConnect. + * + * The new implementation only checks the connection + * for a number of transporters (STEPPING), until to + * the point where all transporters has executed + * doConnect once. After that, the behaviour is as + * in the old implemenation, i.e, checking the connection + * for all transporters. + * @todo: instead of STEPPING, maybe we should only + * allow checkConnections to execute for a certain + * time that somehow factors in heartbeat times and + * watchdog times. + * + */ + +void +TransporterRegistry::checkConnections(){ + if(m_ccStep > nTransporters) + m_ccStep = nTransporters; + + while(m_ccCount < m_ccStep){ + if(theTransporters[m_ccIndex] != 0){ + Transporter * t = theTransporters[m_ccIndex]; + const NodeId nodeId = t->getRemoteNodeId(); + if(t->getThreadError() != 0) { + reportError(callbackObj, nodeId, t->getThreadError()); + t->resetThreadError(); + } + + switch(performStates[nodeId]){ + case PerformConnect: + if(!t->isConnected()){ + t->doConnect(); + if(m_nTransportersPerformConnect!=nTransporters) + m_nTransportersPerformConnect++; + + } else { + performStates[nodeId] = PerformIO; + reportConnect(callbackObj, nodeId); + } + break; + case PerformDisconnect: + { + bool wasConnected = t->isConnected(); + t->doDisconnect(); + performStates[nodeId] = PerformNothing; + if(wasConnected){ + reportDisconnect(callbackObj, nodeId,0); + } + } + break; + case RemoveTransporter: + removeTransporter(nodeId); + break; + case PerformNothing: + case PerformIO: + break; + } + m_ccCount ++; + } + m_ccIndex ++; + } + + if(!m_ccReady) { + if(m_ccCount < nTransporters) { + if(nTransporters - m_ccStep < STEPPING) + m_ccStep += nTransporters-m_ccStep; + else + m_ccStep += STEPPING; + + // ndbout_c("count %d step %d ", m_ccCount, m_ccStep); + } + else { + m_ccCount = 0; + m_ccIndex = 0; + m_ccStep = STEPPING; + // ndbout_c("count %d step %d ", m_ccCount, m_ccStep); + } + } + if((nTransporters == m_nTransportersPerformConnect) || m_ccReady) { + m_ccReady = true; + m_ccCount = 0; + m_ccIndex = 0; + m_ccStep = nTransporters; + // ndbout_c("alla count %d step %d ", m_ccCount, m_ccStep); + } + +}//TransporterRegistry::checkConnections() + +NdbOut & operator <<(NdbOut & out, SignalHeader & sh){ + out << "-- Signal Header --" << endl; + out << "theLength: " << sh.theLength << endl; + out << "gsn: " << sh.theVerId_signalNumber << endl; + out << "recBlockNo: " << sh.theReceiversBlockNumber << endl; + out << "sendBlockRef: " << sh.theSendersBlockRef << endl; + out << "sendersSig: " << sh.theSendersSignalId << endl; + out << "theSignalId: " << sh.theSignalId << endl; + out << "trace: " << (int)sh.theTrace << endl; + return out; +} diff --git a/ndb/src/common/transporter/basictest/Makefile b/ndb/src/common/transporter/basictest/Makefile new file mode 100644 index 00000000000..d86af360408 --- /dev/null +++ b/ndb/src/common/transporter/basictest/Makefile @@ -0,0 +1,15 @@ +include .defs.mk + +TYPE := ndbapi + +BIN_TARGET := basicTransporterTest +BIN_TARGET_ARCHIVES := transporter portlib general + +SOURCES = basicTransporterTest.cpp + +include $(NDB_TOP)/Epilogue.mk + + + + + diff --git a/ndb/src/common/transporter/basictest/basicTransporterTest.cpp b/ndb/src/common/transporter/basictest/basicTransporterTest.cpp new file mode 100644 index 00000000000..5d8186badb8 --- /dev/null +++ b/ndb/src/common/transporter/basictest/basicTransporterTest.cpp @@ -0,0 +1,536 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "TransporterRegistry.hpp" +#include "TransporterDefinitions.hpp" +#include "TransporterCallback.hpp" +#include + +#include +#include +#include +#include +#include +#include +#include + +int basePortTCP = 17000; + +SCI_TransporterConfiguration sciTemplate = { + 8000, + // Packet size + 2500000, // Buffer size + 2, // number of adapters + 1, // remote node id SCI + 2, // Remote node Id SCI + 0, // local ndb node id (server) + 0, // remote ndb node id (client) + 0, // byteOrder; + false, // compression; + true, // checksum; + true // signalId; +}; + +TCP_TransporterConfiguration tcpTemplate = { + 17000, // port; + "", // remoteHostName; + "", // localhostname + 2, // remoteNodeId; + 1, // localNodeId; + 10000, // sendBufferSize - Size of SendBuffer of priority B + 10000, // maxReceiveSize - Maximum no of bytes to receive + 0, // byteOrder; + false, // compression; + true, // checksum; + true // signalId; +}; + +OSE_TransporterConfiguration oseTemplate = { + "", // remoteHostName; + "", // localHostName; + 0, // remoteNodeId; + 0, // localNodeId; + false, // compression; + true, // checksum; + true, // signalId; + 0, // byteOrder; + + 2000, // prioASignalSize; + 1000, // prioBSignalSize; + 10 +}; + +SHM_TransporterConfiguration shmTemplate = { + 0, //remoteNodeId + 0, //localNodeId; + false, //compression + true, //checksum; + true, //signalId; + 0, //byteOrder; + 123, //shmKey; + 2500000 //shmSize; +}; + +TransporterRegistry *tReg = 0; + +#ifndef OSE_DELTA +#include +#endif + +extern "C" +void +signalHandler(int signo){ +#ifndef OSE_DELTA + ::signal(13, signalHandler); +#endif + char buf[255]; + sprintf(buf,"Signal: %d\n", signo); + ndbout << buf << endl; +} + +void +usage(const char * progName){ + ndbout << "Usage: " << progName << " localNodeId localHostName" + << " remoteHostName1 remoteHostName2" << endl; + ndbout << " type = shm tcp ose sci" << endl; + ndbout << " localNodeId - 1 to 3" << endl; +} + +typedef void (* CreateTransporterFunc)(void * conf, + NodeId localNodeId, + NodeId remoteNodeId, + const char * localHostName, + const char * remoteHostName); + +void createOSETransporter(void *, NodeId, NodeId, const char *, const char *); +void createSCITransporter(void *, NodeId, NodeId, const char *, const char *); +void createTCPTransporter(void *, NodeId, NodeId, const char *, const char *); +void createSHMTransporter(void *, NodeId, NodeId, const char *, const char *); + +int signalReceived[4]; + +int +main(int argc, const char **argv){ + + signalHandler(0); + + for(int i = 0; i<4; i++) + signalReceived[i] = 0; + + if(argc < 5){ + usage(argv[0]); + return 0; + } + + Uint32 noOfConnections = 0; + const char * progName = argv[0]; + const char * type = argv[1]; + const NodeId localNodeId = atoi(argv[2]); + const char * localHostName = argv[3]; + const char * remoteHost1 = argv[4]; + const char * remoteHost2 = NULL; + + if(argc == 5) + noOfConnections = 1; + else { + noOfConnections = 2; + remoteHost2 = argv[5]; + } + + if(localNodeId < 1 || localNodeId > 3){ + ndbout << "localNodeId = " << localNodeId << endl << endl; + usage(progName); + return 0; + } + + ndbout << "-----------------" << endl; + ndbout << "localNodeId: " << localNodeId << endl; + ndbout << "localHostName: " << localHostName << endl; + ndbout << "remoteHost1 (node " << (localNodeId == 1?2:1) << "): " + << remoteHost1 << endl; + if(noOfConnections == 2){ + ndbout << "remoteHost2 (node " << (localNodeId == 3?2:3) << "): " + << remoteHost2 << endl; + } + ndbout << "-----------------" << endl; + + void * confTemplate = 0; + CreateTransporterFunc func = 0; + + if(strcasecmp(type, "tcp") == 0){ + func = createTCPTransporter; + confTemplate = &tcpTemplate; + } else if(strcasecmp(type, "ose") == 0){ + func = createOSETransporter; + confTemplate = &oseTemplate; + } else if(strcasecmp(type, "sci") == 0){ + func = createSCITransporter; + confTemplate = &sciTemplate; + } else if(strcasecmp(type, "shm") == 0){ + func = createSHMTransporter; + confTemplate = &shmTemplate; + } else { + ndbout << "Unsupported transporter type" << endl; + return 0; + } + + ndbout << "Creating transporter registry" << endl; + tReg = new TransporterRegistry; + tReg->init(localNodeId); + + switch(localNodeId){ + case 1: + (* func)(confTemplate, 1, 2, localHostName, remoteHost1); + if(noOfConnections == 2) + (* func)(confTemplate, 1, 3, localHostName, remoteHost2); + break; + case 2: + (* func)(confTemplate, 2, 1, localHostName, remoteHost1); + if(noOfConnections == 2) + (* func)(confTemplate, 2, 3, localHostName, remoteHost2); + break; + case 3: + (* func)(confTemplate, 3, 1, localHostName, remoteHost1); + if(noOfConnections == 2) + (* func)(confTemplate, 3, 2, localHostName, remoteHost2); + break; + } + + ndbout << "Doing startSending/startReceiving" << endl; + tReg->startSending(); + tReg->startReceiving(); + + ndbout << "Connecting" << endl; + tReg->setPerformState(PerformConnect); + tReg->checkConnections(); + + unsigned sum = 0; + do { + sum = 0; + for(int i = 0; i<4; i++) + sum += signalReceived[i]; + + tReg->checkConnections(); + + tReg->external_IO(500); + NdbSleep_MilliSleep(500); + + ndbout << "In main loop" << endl; + } while(sum != 2*noOfConnections); + + ndbout << "Doing setPerformState(Disconnect)" << endl; + tReg->setPerformState(PerformDisconnect); + + ndbout << "Doing checkConnections()" << endl; + tReg->checkConnections(); + + ndbout << "Sleeping 3 secs" << endl; + NdbSleep_SecSleep(3); + + ndbout << "Deleting transporter registry" << endl; + delete tReg; tReg = 0; + + return 0; +} + +void +checkData(SignalHeader * const header, Uint8 prio, Uint32 * const theData, + LinearSectionPtr ptr[3]){ + Uint32 expectedLength = 0; + if(prio == 0) + expectedLength = 17; + else + expectedLength = 19; + + if(header->theLength != expectedLength){ + ndbout << "Unexpected signal length: " << header->theLength + << " expected: " << expectedLength << endl; + abort(); + } + + if(header->theVerId_signalNumber != expectedLength + 1) + abort(); + + if(header->theReceiversBlockNumber != expectedLength + 2) + abort(); + + if(refToBlock(header->theSendersBlockRef) != expectedLength + 3) + abort(); + + if(header->theSendersSignalId != expectedLength + 5) + abort(); + + if(header->theTrace != expectedLength + 6) + abort(); + + if(header->m_noOfSections != (prio == 0 ? 0 : 1)) + abort(); + + if(header->m_fragmentInfo != (prio + 1)) + abort(); + + Uint32 dataWordStart = header->theLength ; + for(unsigned i = 0; itheLength; i++){ + if(theData[i] != i){ //dataWordStart){ + ndbout << "data corrupt!\n" << endl; + abort(); + } + dataWordStart ^= (~i*i); + } + + if(prio != 0){ + ndbout_c("Found section"); + if(ptr[0].sz != header->theLength) + abort(); + + if(memcmp(ptr[0].p, theData, (ptr[0].sz * 4)) != 0) + abort(); + } +} + +void +sendSignalTo(NodeId nodeId, int prio){ + SignalHeader sh; + sh.theLength = (prio == 0 ? 17 : 19); + sh.theVerId_signalNumber = sh.theLength + 1; + sh.theReceiversBlockNumber = sh.theLength + 2; + sh.theSendersBlockRef = sh.theLength + 3; + sh.theSendersSignalId = sh.theLength + 4; + sh.theSignalId = sh.theLength + 5; + sh.theTrace = sh.theLength + 6; + sh.m_noOfSections = (prio == 0 ? 0 : 1); + sh.m_fragmentInfo = prio + 1; + + Uint32 theData[25]; + + Uint32 dataWordStart = sh.theLength; + for(unsigned i = 0; itheSendersBlockRef); + + ndbout << "Recieved prio " << (int)prio << " signal from node: " + << nodeId + << " gsn = " << header->theVerId_signalNumber << endl; + checkData(header, prio, theData, ptr); + ndbout << " Data is ok!\n" << endl; + + signalReceived[nodeId]++; + + if(prio == 0) + sendSignalTo(nodeId, 1); + else + tReg->setPerformState(nodeId, PerformDisconnect); +} + +void +copy(Uint32 * & insertPtr, + class SectionSegmentPool & thePool, const SegmentedSectionPtr & _ptr){ + abort(); +} + +void +reportError(void* callbackObj, NodeId nodeId, TransporterError errorCode){ + char buf[255]; + sprintf(buf, "reportError (%d, %x)", nodeId, errorCode); + ndbout << buf << endl; + if(errorCode & 0x8000){ + tReg->setPerformState(nodeId, PerformDisconnect); + abort(); + } +} + +/** + * Report average send theLength in bytes (4096 last sends) + */ +void +reportSendLen(void* callbackObj, NodeId nodeId, Uint32 count, Uint64 bytes){ + char buf[255]; + sprintf(buf, "reportSendLen(%d, %d)", nodeId, (Uint32)(bytes/count)); + ndbout << buf << endl; +} + +/** + * Report average receive theLength in bytes (4096 last receives) + */ +void +reportReceiveLen(void* callbackObj, NodeId nodeId, Uint32 count, Uint64 bytes){ + char buf[255]; + sprintf(buf, "reportReceiveLen(%d, %d)", nodeId, (Uint32)(bytes/count)); + ndbout << buf << endl; +} + +/** + * Report connection established + */ +void +reportConnect(void* callbackObj, NodeId nodeId){ + char buf[255]; + sprintf(buf, "reportConnect(%d)", nodeId); + ndbout << buf << endl; + tReg->setPerformState(nodeId, PerformIO); + + sendSignalTo(nodeId, 0); +} + +/** + * Report connection broken + */ +void +reportDisconnect(void* callbackObj, NodeId nodeId, Uint32 errNo){ + char buf[255]; + sprintf(buf, "reportDisconnect(%d)", nodeId); + ndbout << buf << endl; + if(signalReceived[nodeId] < 2) + tReg->setPerformState(nodeId, PerformConnect); +} + +int +checkJobBuffer() { + /** + * Check to see if jobbbuffers are starting to get full + * and if so call doJob + */ + return 0; +} + +void +createOSETransporter(void * _conf, + NodeId localNodeId, + NodeId remoteNodeId, + const char * localHostName, + const char * remoteHostName){ + ndbout << "Creating OSE transporter from node " + << localNodeId << "(" << localHostName << ") to " + << remoteNodeId << "(" << remoteHostName << ")..." << endl;; + + OSE_TransporterConfiguration * conf = (OSE_TransporterConfiguration*)_conf; + + conf->localNodeId = localNodeId; + conf->localHostName = localHostName; + conf->remoteNodeId = remoteNodeId; + conf->remoteHostName = remoteHostName; + bool res = tReg->createTransporter(conf); + if(res) + ndbout << "... -- Success " << endl; + else + ndbout << "... -- Failure " << endl; +} + +void +createTCPTransporter(void * _conf, + NodeId localNodeId, + NodeId remoteNodeId, + const char * localHostName, + const char * remoteHostName){ + ndbout << "Creating TCP transporter from node " + << localNodeId << "(" << localHostName << ") to " + << remoteNodeId << "(" << remoteHostName << ")..." << endl;; + + TCP_TransporterConfiguration * conf = (TCP_TransporterConfiguration*)_conf; + + int port; + if(localNodeId == 1 && remoteNodeId == 2) port = basePortTCP + 0; + if(localNodeId == 1 && remoteNodeId == 3) port = basePortTCP + 1; + if(localNodeId == 2 && remoteNodeId == 1) port = basePortTCP + 0; + if(localNodeId == 2 && remoteNodeId == 3) port = basePortTCP + 2; + if(localNodeId == 3 && remoteNodeId == 1) port = basePortTCP + 1; + if(localNodeId == 3 && remoteNodeId == 2) port = basePortTCP + 2; + + conf->localNodeId = localNodeId; + conf->localHostName = localHostName; + conf->remoteNodeId = remoteNodeId; + conf->remoteHostName = remoteHostName; + conf->port = port; + bool res = tReg->createTransporter(conf); + if(res) + ndbout << "... -- Success " << endl; + else + ndbout << "... -- Failure " << endl; +} + +void +createSCITransporter(void * _conf, + NodeId localNodeId, + NodeId remoteNodeId, + const char * localHostName, + const char * remoteHostName){ + + + ndbout << "Creating SCI transporter from node " + << localNodeId << "(" << localHostName << ") to " + << remoteNodeId << "(" << remoteHostName << ")..." << endl;; + + + SCI_TransporterConfiguration * conf = (SCI_TransporterConfiguration*)_conf; + + conf->remoteSciNodeId0= (Uint16)atoi(localHostName); + conf->remoteSciNodeId1= (Uint16)atoi(remoteHostName); + + + conf->localNodeId = localNodeId; + conf->remoteNodeId = remoteNodeId; + + bool res = tReg->createTransporter(conf); + if(res) + ndbout << "... -- Success " << endl; + else + ndbout << "... -- Failure " << endl; +} + +void +createSHMTransporter(void * _conf, + NodeId localNodeId, + NodeId remoteNodeId, + const char * localHostName, + const char * remoteHostName){ + + + ndbout << "Creating SHM transporter from node " + << localNodeId << "(" << localHostName << ") to " + << remoteNodeId << "(" << remoteHostName << ")..." << endl;; + + + SHM_TransporterConfiguration * conf = (SHM_TransporterConfiguration*)_conf; + + conf->localNodeId = localNodeId; + conf->remoteNodeId = remoteNodeId; + + bool res = tReg->createTransporter(conf); + if(res) + ndbout << "... -- Success " << endl; + else + ndbout << "... -- Failure " << endl; +} diff --git a/ndb/src/common/transporter/buddy.cpp b/ndb/src/common/transporter/buddy.cpp new file mode 100644 index 00000000000..c65aad1df2c --- /dev/null +++ b/ndb/src/common/transporter/buddy.cpp @@ -0,0 +1,328 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "buddy.hpp" +#include +#include + + +void Chunk256::setFree(bool free){ + // Bit 0 of allocationTimeStamp represents if the segment is free or not + Uint32 offMask = 0x0; // A mask to set the 0 bit to 0 + allocationTimeStamp = 0x0; + if(free) + // Set this bit to 0, if segment should be free + allocationTimeStamp = allocationTimeStamp & offMask; +} + +bool Chunk256::getFree(){ + Uint32 offMask = 0x0; + return ((allocationTimeStamp | offMask) == offMask ? true : false); +} + +void Chunk256::setAllocationTimeStamp(Uint32 cTime){ + // Bits 1-31 of allocationTimeStamp represent the allocation time for segment + + // printf("\nSet allocation time. Current time %d", cTime); + Uint32 onMask = 0x80000000; // A mask to set the 0 bit to 1 + allocationTimeStamp = 0x0; + allocationTimeStamp = onMask | cTime; +} + +Uint32 Chunk256::getAllocationTimeStamp(){ + Uint32 onMask = 0x80000000; + allocationTimeStamp = allocationTimeStamp ^ onMask; + printf("\nGet allocation time. Time is %d", allocationTimeStamp); + return allocationTimeStamp; +}; + +bool BuddyMemory::allocate(int nChunksToAllocate) { + + // Allocate the memory block needed. This memory is deallocated in the + // destructor of TransporterRegistry. + + printf("\nAllocating %d chunks...", nChunksToAllocate); + + startOfMemoryBlock = (Uint32*) malloc(256 * nChunksToAllocate); + + if (startOfMemoryBlock == NULL) + return false; + + // Allocate the array of 256-byte chunks + chunk = new Chunk256[nChunksToAllocate]; + + // Initialize the chunk-array. Every 8 kB segment consists of 32 chunks. + // Set all chunks to free and set the prev and next pointer + for (int i=0; i < nChunksToAllocate; i++) { + chunk[i].setFree(true); + if (i%32 == 0) { + // The first chunk in every segment will point to the prev and next segment + chunk[i].prevSegmentOfSameSize = i-32; + chunk[i].nextSegmentOfSameSize = i + 32; + chunk[0].prevSegmentOfSameSize = END_OF_CHUNK_LIST; + chunk[totalNoOfChunks-32].nextSegmentOfSameSize = END_OF_CHUNK_LIST; + } else { + // The rest of the chunks in the segments have undefined prev and next pointers + chunk[i].prevSegmentOfSameSize = UNDEFINED_CHUNK; + chunk[i].nextSegmentOfSameSize = UNDEFINED_CHUNK; + } + } + + // Initialize the freeSegment-pointers + for (int i=0; i 256) + segmSize ++; + printf("\nSegment size: %f", pow(2,int(8+segmSize))); + + while ((segmSize <= sz_GET_MAX) && (freeSegment[segmSize] == UNDEFINED_CHUNK)) + segmSize++; + + segm = freeSegment[segmSize]; + if (segm != UNDEFINED_CHUNK){ + // Free segment of asked size or larger is found + + // Remove the found segment from the freeSegment-list + removeFromFreeSegmentList(segmSize, segm); + + // Set all chunks to allocated (not free) and set the allocation time + // for the segment we are about to allocate + for (int i = segm; i <= segm+nChunksToAllocate; i++) { + chunk[i].setFree(false); + chunk[i].setAllocationTimeStamp(currentTime); + } + + // Before returning the segment, check if it is larger than the segment asked for + if (nChunksAskedFor < nChunksToAllocate) + release(nChunksAskedFor, nChunksToAllocate - nChunksAskedFor - 1); + + Segment segment; + segment.segmentAddress = startOfMemoryBlock+(segm * 256); + segment.segmentSize = 256 * nChunksAskedFor; + segment.releaseId = segm; + + printf("\nSegment: segment address = %d, segment size = %d, release Id = %d", + segment.segmentAddress, segment.segmentSize, segment.releaseId); + + return true; + } + printf("\nNo segments of asked size or larger are found"); + return false; +} + +void BuddyMemory::removeFromFreeSegmentList(int sz, int index) { + // Remove the segment from the freeSegment list + + printf("\nRemoving segment from list..."); + if (index != UNDEFINED_CHUNK) { + Chunk256 prevChunk; + Chunk256 nextChunk; + int prevChunkIndex = chunk[index].prevSegmentOfSameSize; + int nextChunkIndex = chunk[index].nextSegmentOfSameSize; + + if (prevChunkIndex == END_OF_CHUNK_LIST) { + if (nextChunkIndex == END_OF_CHUNK_LIST) + // We are about to remove the only element in the list + freeSegment[sz] = UNDEFINED_CHUNK; + else { + // We are about to remove the first element in the list + nextChunk = chunk[nextChunkIndex]; + nextChunk.prevSegmentOfSameSize = END_OF_CHUNK_LIST; + freeSegment[sz] = nextChunkIndex; + } + } else { + if (nextChunkIndex == END_OF_CHUNK_LIST) { + // We are about to remove the last element in the list + prevChunk = chunk[prevChunkIndex]; + prevChunk.nextSegmentOfSameSize = END_OF_CHUNK_LIST; + } else { + // We are about to remove an element in the middle of the list + prevChunk = chunk[prevChunkIndex]; + nextChunk = chunk[nextChunkIndex]; + prevChunk.nextSegmentOfSameSize = nextChunkIndex; + nextChunk.prevSegmentOfSameSize = prevChunkIndex; + } + } + } + for (int i=0; i= 0; i--) { + if (!chunk[i].getFree()) + break; + else { + startChunk = i; + nChunksToRelease++; + // Look at the next-pointer. If it is valid, we have a + // chunk that is the start of a free segment. Remove it + // from the freeSegment-list. + if (chunk[i].nextSegmentOfSameSize != UNDEFINED_CHUNK) + removeFromFreeSegmentList(size, i); + } + } + + // Look at the chunks after the segment we are about to release + for (int i = endChunk+1; i <= totalNoOfChunks; i++) { + if (!chunk[i].getFree()) + break; + else { + endChunk = i; + nChunksToRelease++; + // Look at the next-pointer. If it is valid, we have a + // chunk that is the start of a free segment. Remove it + // from the free segment list + if (chunk[i].nextSegmentOfSameSize != UNDEFINED_CHUNK) + removeFromFreeSegmentList(size, i); + } + } + + // We have the start and end indexes and total no of free chunks. + // Separate the chunks into segments that can be added to the + // freeSegments-list. + int restChunk = 0; + int segmSize; + + printf("\n%d chunks to release (finally)", nChunksToRelease); + + segmSize = logTwoPlus(nChunksToRelease) - 1; + if (segmSize > sz_MAX) { + segmSize = sz_MAX; + } + + nChunksToRelease = pow(2,segmSize); + addToFreeSegmentList(nChunksToRelease*256, startChunk); +} + +void BuddyMemory::addToFreeSegmentList(int sz, int index) { + // Add a segment to the freeSegment list + + printf("\nAsked to add segment of size %d", sz); + + // Get an index in freeSegment list corresponding to sz size + int segmSize = logTwoPlus(sz) - 1; + if (sz - pow(2,segmSize) >= 256) + segmSize ++; + sz = segmSize - 8; + + int nextSegm = freeSegment[sz]; + + printf("\nAdding a segment of size %f", pow(2,(8 + sz))); + + freeSegment[sz] = index; + if (nextSegm == UNDEFINED_CHUNK) { + // We are about to add a segment to an empty list + chunk[index].prevSegmentOfSameSize = END_OF_CHUNK_LIST; + chunk[index].nextSegmentOfSameSize = END_OF_CHUNK_LIST; + } + else { + // Add the segment first in the list + chunk[index].prevSegmentOfSameSize = END_OF_CHUNK_LIST; + chunk[index].nextSegmentOfSameSize = nextSegm; + chunk[nextSegm].prevSegmentOfSameSize = index; + } + + for (int i=0; i> 8); + arg = arg | (arg >> 4); + arg = arg | (arg >> 2); + arg = arg | (arg >> 1); + resValue = (arg & 0x5555) + ((arg >> 1) & 0x5555); + resValue = (resValue & 0x3333) + ((resValue >> 2) & 0x3333); + resValue = resValue + (resValue >> 4); + resValue = (resValue & 0xf) + ((resValue >> 8) & 0xf); + + return resValue; +} + +bool BuddyMemory::memoryAvailable() { + // Return true if there is at least 8 kB memory available + for (int i = sz_8192; i < sz_MAX; i++) + if (freeSegment[i] != UNDEFINED_CHUNK) + return true; + return false; +} + + +void BuddyMemory::refreshTime(Uint32 time) { + if (time - currentTime > 1000) { + // Update current time + currentTime = time; + // Go through the chunk-list every second and release + // any chunks that have been allocated for too long + for (int i=0; i ALLOCATION_TIMEOUT)) { + release(i, 256); + printf("\nChunks hve been allocated for too long"); + } + } + } +} diff --git a/ndb/src/common/transporter/buddy.hpp b/ndb/src/common/transporter/buddy.hpp new file mode 100644 index 00000000000..7272ac884ec --- /dev/null +++ b/ndb/src/common/transporter/buddy.hpp @@ -0,0 +1,173 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef BUDDY_H +#define BUDDY_H + +#include +#include + +typedef unsigned int Uint32; +typedef unsigned short Uint16; +typedef unsigned long long Uint64; + +// +const int UNDEFINED_CHUNK = -2; // XXX Set to hex + +// +const int END_OF_CHUNK_LIST = -1; // XXX Set to hex + +// A timeout (no of seconds) for the memory segments in the TransporterRegistry +// memory pool. If a segment has been occupied (free=false) for a longer period +// than this timeout, it will be released. +const int ALLOCATION_TIMEOUT = 10000; + +// Free segments should always be as large as possible +// and are only allowed to be in any of these sizes +enum FreeSegmentSize { + sz_256 = 0, + sz_512 = 1, + sz_1024 = 2, + sz_2048 = 3, + sz_4096 = 4, + sz_8192 = 5, + sz_16384 = 6, + sz_32768 = 7, + sz_65536 = 8, + sz_131072 = 9, + sz_GET_MAX = 5, + sz_MAX = 9 +}; + +struct Segment; + +class BuddyMemory { +public: + + // Return true if there is at least 8 kB memory available + bool memoryAvailable(); + + // + bool allocate(int nChunksToAllocate); + + // Remove the segment from the freeSegment list + void removeFromFreeSegmentList(int sz, int index); + + // Release the segment of size + void release(int releaseId, int size); + + // Add a segment to the freeSegment list + void addToFreeSegmentList(int sz, int index); + + bool getSegment(Uint32 size, Segment * dst); + + void refreshTime(Uint32 time); + + //Calculate log2(arg) + 1 + Uint32 logTwoPlus(Uint32 arg); + + // The current time + Uint32 currentTime; + + // Pointer to the first free segment of size FreeSegmentSize + Uint32 freeSegment[sz_MAX]; + + // Start address of the memory block allocated + Uint32* startOfMemoryBlock; + + // Total number of 256 byte chunks. + Uint32 totalNoOfChunks; + + // Array of 256-byte chunks + struct Chunk256* chunk; +}; + +struct Segment { + Uint32 segmentSize; // Size of the segment in no of words + Uint16 index; // Index in the array of SegmentListElements + Uint16 releaseId; // Unique no used when releasing the segment + // Undefined if Long_signal.deallocIndicator==0 + union { + Uint32* segmentAddress; // Address to the memory segment + Uint64 _padding_NOT_TO_BE_USED_; + }; +}; + +struct Chunk256 { + Uint32 allocationTimeStamp; // Bit 0 represents if the segment is free or not + // Bit 1-31 is the allocation time for the segment + // Bit 1-31 are undefined if the segment is free + Uint32 nextSegmentOfSameSize; // Undefined if allocated. + // The first chunk in a free segment has a valid + // next-pointer. In the rest of the chunks + // belonging to the segment it is UNDEFINED_CHUNK. + Uint32 prevSegmentOfSameSize; // Undefined if allocated + // The first chunk in a free segment has a valid + // prev-pointer. In the rest of the chunks + // belonging to the segment it is UNDEFINED_CHUNK. + + void setFree(bool free); + + bool getFree(); + + void setAllocationTimeStamp(Uint32 cTime); + + Uint32 getAllocationTimeStamp(); +}; + +// inline void Chunk256::setFree(bool free){ +// // Bit 0 of allocationTimeStamp represents if the segment is free or not +// allocationTimeStamp = 0x0; + +// printf("\nSet free segment"); +// Uint32 offMask = 0x0; // A mask to set the 0 bit to 0 +// if(free) +// // Set this bit to 0, if segment should be free +// allocationTimeStamp = allocationTimeStamp & offMask; +// } + +// inline bool Chunk256::getFree(){ +// // Get free segment + +// allocationTimeStamp = 0x0; +// Uint32 offMask = 0x0; + +// printf("\nGet free segment"); +// return ((allocationTimeStamp | offMask) == offMask ? true : false); +// } + +// inline void Chunk256::setAllocationTimeStamp(Uint32 cTime){ +// // Bits 1-31 of allocationTimeStamp represent the allocation time for segment + +// Uint32 onMask = 0x80000000; // A mask to set the 0 bit to 1 +// allocationTimeStamp = 0x0; + +// printf("\nSet allocation time"); + +// allocationTimeStamp = onMask | cTime; +// } + +// inline Uint32 Chunk256::getAllocationTimeStamp(){ + +// Uint32 onMask = 0x80000000; // A mask to set the 0 bit to 1 +// allocationTimeStamp = 0x0; + +// printf("\nGet allocation time"); +// allocationTimeStamp = allocationTimeStamp ^ onMask; +// return allocationTimeStamp; +// }; + +#endif diff --git a/ndb/src/common/transporter/failoverSCI/Makefile b/ndb/src/common/transporter/failoverSCI/Makefile new file mode 100644 index 00000000000..1e3d5f4a4b7 --- /dev/null +++ b/ndb/src/common/transporter/failoverSCI/Makefile @@ -0,0 +1,18 @@ +include .defs.mk + +TYPE := ndbapi + +BIN_TARGET := failoverSCI +BIN_TARGET_LIBS := sisci +BIN_TARGET_ARCHIVES := portlib + +CCFLAGS_LOC += -I.. + +SOURCES = failoverSCI.cpp + +include $(NDB_TOP)/Epilogue.mk + + + + + diff --git a/ndb/src/common/transporter/failoverSCI/failoverSCI.cpp b/ndb/src/common/transporter/failoverSCI/failoverSCI.cpp new file mode 100644 index 00000000000..03ce7ea6df3 --- /dev/null +++ b/ndb/src/common/transporter/failoverSCI/failoverSCI.cpp @@ -0,0 +1,866 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include "sisci_types.h" +#include "sisci_api.h" +#include "sisci_error.h" +//#include "sisci_demolib.h" +#include +#include +#include +#include "NdbSleep.h" +#define NO_CALLBACK NULL +#define NO_FLAGS 0 +#define DATA_TRANSFER_READY 8 + +sci_error_t error; +sci_desc_t sdOne; +sci_desc_t sdTwo; +sci_local_segment_t localSegmentOne; +sci_local_segment_t localSegmentTwo; +sci_remote_segment_t remoteSegmentOne; +sci_remote_segment_t remoteSegmentTwo; +sci_map_t localMapOne; +sci_map_t localMapTwo; +sci_map_t remoteMapOne; +sci_map_t remoteMapTwo; +unsigned int localAdapterNo = 0; +unsigned int standbyAdapterNo = 1; +unsigned int localNodeId1; +unsigned int localNodeId2; +unsigned int remoteNodeId1 = 0; +unsigned int remoteNodeId2 = 0; +unsigned int localSegmentId; +unsigned int remoteSegmentId1; +unsigned int remoteSegmentId2; +unsigned int segmentSize = 8192; +unsigned int offset = 0; +unsigned int client = 0; +unsigned int server = 0; +unsigned int *localbufferPtr; +static int data; +static int interruptConnected=0; + +/*********************************************************************************/ +/* U S A G E */ +/* */ +/*********************************************************************************/ + +void Usage() +{ + printf("Usage of shmem\n"); + printf("shmem -rn -client/server [ -adapterno -size ] \n\n"); + printf(" -rn : Remote node-id\n"); + printf(" -client : The local node is client\n"); + printf(" -server : The local node is server\n"); + printf(" -adapterno : Local adapter number (default %d)\n", localAdapterNo); + printf(" -size : Segment block size (default %d)\n", segmentSize); + printf(" -help : This helpscreen\n"); + + printf("\n"); +} + + +/*********************************************************************************/ +/* P R I N T P A R A M E T E R S */ +/* */ +/*********************************************************************************/ +void PrintParameters(void) +{ + + printf("Test parameters for %s \n",(client) ? "client" : "server" ); + printf("----------------------------\n\n"); + printf("Local node-id1 : %d\n",localNodeId1); + printf("Local node-id2 : %d\n",localNodeId2); + // printf("Remote node-id : %d\n",remoteNodeId); + printf("Local adapter no. : %d\n",localAdapterNo); + printf("Segment size : %d\n",segmentSize); + printf("----------------------------\n\n"); + +} + + +/*********************************************************************************/ +/* F I L L S E G M E N T W I T H D A T A */ +/* */ +/*********************************************************************************/ + +sci_error_t GetLocalNodeId(Uint32 localAdapterNo, Uint32* localNodeId) +{ + sci_query_adapter_t queryAdapter; + sci_error_t error; + unsigned int _localNodeId; + + queryAdapter.subcommand = SCI_Q_ADAPTER_NODEID; + queryAdapter.localAdapterNo = localAdapterNo; + queryAdapter.data = &_localNodeId; + + SCIQuery(SCI_Q_ADAPTER,&queryAdapter,NO_FLAGS,&error); + + *localNodeId=_localNodeId; + + return error; +} + + + + + + +sci_error_t SendInterrupt(sci_desc_t sd, + Uint32 localAdapterNo, + Uint32 localSciNodeId, + Uint32 remoteSciNodeId, + Uint32 interruptNo){ + + sci_error_t error; + sci_remote_interrupt_t remoteInterrupt; + Uint32 timeOut = SCI_INFINITE_TIMEOUT; + + // Now connect to the other sides interrupt flag + do { + SCIConnectInterrupt(sd, &remoteInterrupt, remoteSciNodeId, localAdapterNo, + interruptNo, timeOut, NO_FLAGS, &error); + } while (error != SCI_ERR_OK); + + if (error != SCI_ERR_OK) { + fprintf(stderr, "SCIConnectInterrupt failed - Error code 0x%x\n", error); + return error; + } + + // Trigger interrupt + printf("\nNode %u sent interrupt (0x%x) to node %d\n",localSciNodeId, interruptNo, remoteSciNodeId); + SCITriggerInterrupt(remoteInterrupt, NO_FLAGS, &error); + if (error != SCI_ERR_OK) { + fprintf(stderr, "SCITriggerInterrupt failed - Error code 0x%x\n", error); + return error; + } + + + // Disconnect and remove interrupts + SCIDisconnectInterrupt(remoteInterrupt, NO_FLAGS, &error); + if (error != SCI_ERR_OK) { + fprintf(stderr, "SCIDisconnectInterrupt failed - Error code 0x%x\n", error); + return error; + } + + return error; +} + + +sci_error_t ReceiveInterrupt(sci_desc_t sd, + Uint32 localAdapterNo, + Uint32 localSciNodeId, + Uint32 interruptNo, + Uint32 timeout) { + + sci_error_t error; + sci_local_interrupt_t localInterrupt; + Uint32 timeOut = SCI_INFINITE_TIMEOUT; + + // Create an interrupt + SCICreateInterrupt(sd, &localInterrupt, localAdapterNo, + &interruptNo, 0, NULL, SCI_FLAG_FIXED_INTNO, &error); + if (error != SCI_ERR_OK) { + fprintf(stderr, "SCICreateInterrupt failed - Error code 0x%x\n", error); + return error; + } + + + // Wait for an interrupt + SCIWaitForInterrupt(localInterrupt, timeOut, NO_FLAGS, &error); + + printf("\nNode %u received interrupt (0x%x)\n", localSciNodeId, interruptNo); + + // Remove interrupt + + SCIRemoveInterrupt(localInterrupt, NO_FLAGS, &error); + if (error != SCI_ERR_OK) { + fprintf(stderr, "SCIRemoveInterrupt failed - Error code 0x%x\n", error); + return error; + } + return error; +} + + +sci_error_t FillSegmentWithData(unsigned int segmentSize, int reverse) +{ + unsigned int i; + unsigned int nostores; + + + nostores = (segmentSize) / sizeof(unsigned int); + + /* Allocate buffer */ + + localbufferPtr = (unsigned int*)malloc( segmentSize ); + if ( localbufferPtr == NULL ) { + /* + * Unable to create local buffer - Insufficient memory available + */ + return SCI_ERR_NOSPC; + } + if(reverse) { + /* Fill in the data into a local buffer */ + printf("Filling forward order \n"); + for (i=0;i\n"); + // exit(-1); + //} + + if (server == 0 && client == 0) { + fprintf(stderr,"You must specify a client node or a server node\n"); + exit(-1); + } + + if (server == 1 && client == 1) { + fprintf(stderr,"Both server node and client node is selected.\n"); + fprintf(stderr,"You must specify either a client or a server node\n"); + exit(-1); + } + + + /* Initialize the SISCI library */ + SCIInitialize(NO_FLAGS, &error); + if (error != SCI_ERR_OK) { + fprintf(stderr,"SCIInitialize failed - Error code: 0x%x\n",error); + exit(error); + } + + + /* Open a file descriptor */ + SCIOpen(&sdOne,NO_FLAGS,&error); + if (error != SCI_ERR_OK) { + if (error == SCI_ERR_INCONSISTENT_VERSIONS) { + fprintf(stderr,"Version mismatch between SISCI user library and SISCI driver\n"); + } + fprintf(stderr,"SCIOpen failed - Error code 0x%x\n",error); + exit(error); + } + + /* Open a file descriptor */ + SCIOpen(&sdTwo,NO_FLAGS,&error); + if (error != SCI_ERR_OK) { + if (error == SCI_ERR_INCONSISTENT_VERSIONS) { + fprintf(stderr,"Version mismatch between SISCI user library and SISCI driver\n"); + } + fprintf(stderr,"SCIOpen failed - Error code 0x%x\n",error); + exit(error); + } + + + /* Get local node-id */ + error = GetLocalNodeId(localAdapterNo, &localNodeId1); + error = GetLocalNodeId(standbyAdapterNo, &localNodeId2); + if (error != SCI_ERR_OK) { + fprintf(stderr,"Could not find the local adapter %d\n", localAdapterNo); + SCIClose(sdOne,NO_FLAGS,&error); + SCIClose(sdTwo,NO_FLAGS,&error); + exit(-1); + } + + + /* Print parameters */ + PrintParameters(); + + if (client) { + remoteNodeId1=324; + remoteNodeId2=328; + ShmemClientNode(); + } else { + remoteNodeId1=452; + remoteNodeId2=456; + ShmemServerNode(); + } + + /* Close the file descriptor */ + SCIClose(sdOne,NO_FLAGS,&error); + SCIClose(sdTwo,NO_FLAGS,&error); + if (error != SCI_ERR_OK) { + fprintf(stderr,"SCIClose failed - Error code: 0x%x\n",error); + } + + + /* Free allocated resources */ + SCITerminate(); + + return SCI_ERR_OK; +} + + + + + + + + + + + + + + + + + diff --git a/ndb/src/common/transporter/perftest/Makefile b/ndb/src/common/transporter/perftest/Makefile new file mode 100644 index 00000000000..01869e1acf9 --- /dev/null +++ b/ndb/src/common/transporter/perftest/Makefile @@ -0,0 +1,15 @@ +include .defs.mk + +TYPE := ndbapi + +BIN_TARGET := perfTransporterTest +BIN_TARGET_ARCHIVES := transporter portlib general + +SOURCES = perfTransporterTest.cpp + +include $(NDB_TOP)/Epilogue.mk + + + + + diff --git a/ndb/src/common/transporter/perftest/perfTransporterTest.cpp b/ndb/src/common/transporter/perftest/perfTransporterTest.cpp new file mode 100644 index 00000000000..6d7f7083a48 --- /dev/null +++ b/ndb/src/common/transporter/perftest/perfTransporterTest.cpp @@ -0,0 +1,774 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "TransporterRegistry.hpp" +#include "TransporterDefinitions.hpp" +#include "TransporterCallback.hpp" +#include + +#include +#include +#include +#include +#include +#include +#include + +int basePortTCP = 17000; + +SCI_TransporterConfiguration sciTemplate = { + 2000, + // Packet size + 2000000, // Buffer size + 2, // number of adapters + 1, // remote node id SCI + 2, // Remote node Id SCI + 0, // local ndb node id (server) + 0, // remote ndb node id (client) + 0, // byteOrder; + false, // compression; + true, // checksum; + true // signalId; +}; + + +SHM_TransporterConfiguration shmTemplate = { + 0, //remoteNodeId + 0, //localNodeId; + false, //compression + true, //checksum; + true, //signalId; + 0, //byteOrder; + 123, //shmKey; + 25000000 //shmSize; +}; + + +TCP_TransporterConfiguration tcpTemplate = { + 17000, // port; + "", // remoteHostName; + "", // localhostname + 2, // remoteNodeId; + 1, // localNodeId; + 25000000, // sendBufferSize - Size of SendBuffer of priority B + 5000000, // maxReceiveSize - Maximum no of bytes to receive + 0, // byteOrder; + false, // compression; + true, // checksum; + true // signalId; +}; + +OSE_TransporterConfiguration oseTemplate = { + "", // remoteHostName; + "", // localHostName; + 0, // remoteNodeId; + 0, // localNodeId; + false, // compression; + true, // checksum; + true, // signalId; + 0, // byteOrder; + + 2000, // prioASignalSize; + 2000, // prioBSignalSize; + 10 // Recv buf size +}; + +TransporterRegistry *tReg = 0; + +#ifndef OSE_DELTA +#include +#endif + +extern "C" +void +signalHandler(int signo){ +#ifndef OSE_DELTA + ::signal(13, signalHandler); +#endif + char buf[255]; + sprintf(buf,"Signal: %d\n", signo); + ndbout << buf << endl; +} + +void +usage(const char * progName){ + ndbout << "Usage: " << progName << " localNodeId localHostName" + << " remoteHostName" + << " [] [] []" << endl; + ndbout << " type = shm tcp ose sci" << endl; + ndbout << " localNodeId - {1,2}" << endl; +} + +typedef void (* CreateTransporterFunc)(void * conf, + NodeId localNodeId, + NodeId remoteNodeId, + const char * localHostName, + const char * remoteHostName, + int sendBuf, + int recvBuf); + +void +createOSETransporter(void*, NodeId, NodeId, const char*, const char*, int, int); +void +createTCPTransporter(void*, NodeId, NodeId, const char*, const char*, int, int); +void +createSHMTransporter(void*, NodeId, NodeId, const char*, const char*, int, int); +void +createSCITransporter(void*, NodeId, NodeId, const char*, const char*, int, int); + +struct TestPhase { + int signalSize; + int noOfSignals; + int noOfSignalSent; + int noOfSignalReceived; + NDB_TICKS startTime; + NDB_TICKS stopTime; + NDB_TICKS accTime; + int loopCount; + Uint64 sendLenBytes, sendCount; + Uint64 recvLenBytes, recvCount; +}; + +TestPhase testSpec[] = { + { 1, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals of size 1 word + ,{ 1, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals of size 1 word + ,{ 1, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals of size 1 word + ,{ 1, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1 word + + ,{ 8, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals of size 1 word + ,{ 8, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals of size 1 word + ,{ 8, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals of size 1 word + ,{ 8, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1 word + + ,{ 16, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals of size 1 word + ,{ 16, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals of size 1 word + ,{ 16, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals of size 1 word + ,{ 16, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1 word + + ,{ 24, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals of size 1 word + ,{ 24, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals of size 1 word + ,{ 24, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals of size 1 word + ,{ 24, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1 word + + ,{ 0, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals of random size + ,{ 0, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals of random size + ,{ 0, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals of random size + ,{ 0, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of random size + + ,{ 100, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals + ,{ 100, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals + ,{ 100, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals + ,{ 100, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals + + ,{ 500, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals + ,{ 500, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals + ,{ 500, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals + ,{ 500, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals + + ,{ 1000, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals + ,{ 1000, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals + ,{ 1000, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals + ,{ 1000, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals +}; + +const int noOfTests = sizeof(testSpec)/sizeof(TestPhase); + +Uint32 StaticBuffer[1000]; + +SendStatus +sendSignalTo(NodeId nodeId, int signalSize, Uint32 count){ + if(signalSize == 0) + signalSize = (rand() % 25) + 1; + + SignalHeader sh; + sh.theLength = (signalSize > 25 ? 25 : signalSize); + sh.theVerId_signalNumber = count; + sh.theReceiversBlockNumber = rand(); + sh.theSendersBlockRef = rand(); + sh.theSendersSignalId = rand(); + sh.theSignalId = rand(); + sh.theTrace = rand(); + + Uint32 theData[25]; + for(int i = 0; i<25; i++) + theData[i] = (i+1) * (Uint32)(&theData[i]); + + theData[0] = count; + LinearSectionPtr ptr[3]; + + if(signalSize <= 25){ + sh.m_noOfSections = 0; + } else { + sh.m_noOfSections = 1; + ptr[0].sz = signalSize - 25; + ptr[0].p = &StaticBuffer[0]; + } + + return tReg->prepareSend(&sh, 1, theData, nodeId, ptr); +} + +void +reportHeader(){ + ndbout << "#Sigs\tSz\tTime\tSig/sec\tBps\tBps-tot\t" + << "s len\tr len" << endl; +} + +void +print(char * dst, int i){ + if(i > 1000000){ + const int d = i / 1000000; + const int r = (i - (d * 1000000)) / 100000; + if(d < 100) + sprintf(dst, "%d.%dM", d, r); + else + sprintf(dst, "%dM", d); + } else if(i > 1000){ + const int d = i / 1000; + const int r = (i - (d * 1000)) / 100; + if(d < 100) + sprintf(dst, "%d.%dk", d, r); + else + sprintf(dst, "%dk", d); + } else { + sprintf(dst, "%d", i); + } +} + +void +printReport(TestPhase & p){ + if(p.accTime > 0) { + Uint32 secs = (p.accTime/p.loopCount)/1000; + Uint32 mill = (p.accTime/p.loopCount)%1000; + char st[255]; + if(secs > 0){ + sprintf(st, "%d.%.2ds", secs, (mill/10)); + } else { + sprintf(st, "%dms", mill); + } + + Uint32 sps = (1000*p.noOfSignals*p.loopCount)/p.accTime; + Uint32 dps = ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*p.signalSize); + Uint32 bps = ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*(p.signalSize+3)); + if(p.signalSize == 0){ + dps = ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*(13)); + bps = ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*(13+3)); + } + char ssps[255]; + char sbps[255]; + char sdps[255]; + + print(ssps, sps); + print(sbps, bps); + print(sdps, dps); + + + char buf[255]; + if(p.signalSize != 0){ + snprintf(buf, 255, + "%d\t%d\t%s\t%s\t%s\t%s\t%d\t%d", + p.noOfSignals, + 4*p.signalSize, + st, + ssps, + sdps, + sbps, + (int)(p.sendLenBytes / (p.sendCount == 0 ? 1 : p.sendCount)), + (int)(p.recvLenBytes / (p.recvCount == 0 ? 1 : p.recvCount))); + } else { + snprintf(buf, 255, + "%d\trand\t%s\t%s\t%s\t%s\t%d\t%d", + p.noOfSignals, + st, + ssps, + sdps, + sbps, + (int)(p.sendLenBytes / (p.sendCount == 0 ? 1 : p.sendCount)), + (int)(p.recvLenBytes / (p.recvCount == 0 ? 1 : p.recvCount))); + + } + ndbout << buf << endl; + } +} + +int loopCount = 1; +int sendBufSz = -1; +int recvBufSz = -1; + +bool isClient = false; +bool isConnected = false; +bool isStarted = false; +int currentPhase = 0; +TestPhase allPhases[noOfTests]; +Uint32 signalToEcho; +Uint32 signalsEchoed; +NDB_TICKS startTime, stopTime; + +void +client(NodeId remoteNodeId){ + isClient = true; + + currentPhase = 0; + memcpy(allPhases, testSpec, sizeof(testSpec)); + + int counter = 0; + int sigCounter = 0; + + while(true){ + TestPhase * current = &allPhases[currentPhase]; + if(current->noOfSignals == current->noOfSignalSent && + current->noOfSignals == current->noOfSignalReceived){ + + /** + * Test phase done + */ + current->stopTime = NdbTick_CurrentMillisecond(); + current->accTime += (current->stopTime - current->startTime); + + NdbSleep_MilliSleep(500 / loopCount); + + current->startTime = NdbTick_CurrentMillisecond(); + + current->noOfSignalSent = 0; + current->noOfSignalReceived = 0; + + current->loopCount ++; + if(current->loopCount == loopCount){ + + printReport(allPhases[currentPhase]); + + currentPhase ++; + if(currentPhase == noOfTests){ + /** + * Now we are done + */ + break; + } + NdbSleep_MilliSleep(500); + current = &allPhases[currentPhase]; + current->startTime = NdbTick_CurrentMillisecond(); + } + } + + int signalsLeft = current->noOfSignals - current->noOfSignalSent; + if(signalsLeft > 0){ + for(; signalsLeft > 0; signalsLeft--){ + if(sendSignalTo(remoteNodeId,current->signalSize,sigCounter)== SEND_OK){ + current->noOfSignalSent++; + sigCounter++; + } else { + ndbout << "Failed to send: " << sigCounter << endl; + tReg->external_IO(10); + break; + } + } + } + if(counter % 10 == 0) + tReg->checkConnections(); + tReg->external_IO(0); + counter++; + } +} + +void +server(){ + isClient = false; + + signalToEcho = 0; + signalsEchoed = 0; + for(int i = 0; i signalsEchoed){ + tReg->checkConnections(); + for(int i = 0; i<10; i++) + tReg->external_IO(10); + } +} + +int +main(int argc, const char **argv){ + + const char * progName = argv[0]; + + loopCount = 100; + sendBufSz = -1; + recvBufSz = -1; + + isClient = false; + isConnected = false; + isStarted = false; + currentPhase = 0; + + signalHandler(0); + + if(argc < 5){ + usage(progName); + return 0; + } + + const char * type = argv[1]; + const NodeId localNodeId = atoi(argv[2]); + const char * localHostName = argv[3]; + const char * remoteHost1 = argv[4]; + + if(argc >= 6) + loopCount = atoi(argv[5]); + if(argc >= 7) + sendBufSz = atoi(argv[6]); + if(argc >= 8) + recvBufSz = atoi(argv[7]); + + if(localNodeId < 1 || localNodeId > 2){ + ndbout << "localNodeId = " << localNodeId << endl << endl; + usage(progName); + return 0; + } + + if(localNodeId == 1) + ndbout << "-- ECHO CLIENT --" << endl; + else + ndbout << "-- ECHO SERVER --" << endl; + + ndbout << "localNodeId: " << localNodeId << endl; + ndbout << "localHostName: " << localHostName << endl; + ndbout << "remoteHost1 (node " << (localNodeId == 1?2:1) << "): " + << remoteHost1 << endl; + ndbout << "Loop count: " << loopCount << endl; + ndbout << "-----------------" << endl; + + void * confTemplate = 0; + CreateTransporterFunc func = 0; + if(strcasecmp(type, "tcp") == 0){ + func = createTCPTransporter; + confTemplate = &tcpTemplate; + } else if(strcasecmp(type, "ose") == 0){ + func = createOSETransporter; + confTemplate = &oseTemplate; + } else if(strcasecmp(type, "sci") == 0){ + func = createSCITransporter; + confTemplate = &sciTemplate; + } else if(strcasecmp(type, "shm") == 0){ + func = createSHMTransporter; + confTemplate = &shmTemplate; + } else { + ndbout << "Unsupported transporter type" << endl; + return 0; + } + + ndbout << "Creating transporter registry" << endl; + tReg = new TransporterRegistry; + tReg->init(localNodeId); + + switch(localNodeId){ + case 1: + (* func)(confTemplate, 1, 2, localHostName, remoteHost1, + sendBufSz, recvBufSz); + break; + case 2: + (* func)(confTemplate, 2, 1, localHostName, remoteHost1, + sendBufSz, recvBufSz); + break; + } + + ndbout << "Doing startSending/startReceiving" << endl; + tReg->startSending(); + tReg->startReceiving(); + + ndbout << "Connecting" << endl; + tReg->setPerformState(PerformConnect); + tReg->checkConnections(); + + if(localNodeId == 1) + client(2); + else + server(); + + isStarted = false; + + ndbout << "Sleep 3 secs" << endl; + NdbSleep_SecSleep(3); + + ndbout << "Doing setPerformState(Disconnect)" << endl; + tReg->setPerformState(PerformDisconnect); + + ndbout << "Doing checkConnections()" << endl; + tReg->checkConnections(); + + ndbout << "Deleting transporter registry" << endl; + delete tReg; tReg = 0; + + return 0; +} + +void +execute(void* callbackObj, SignalHeader * const header, Uint8 prio, + Uint32 * const theData, + LinearSectionPtr ptr[3]){ + const NodeId nodeId = refToNode(header->theSendersBlockRef); + + if(isClient){ + allPhases[currentPhase].noOfSignalReceived++; + } else { + int sleepTime = 10; + if(theData[0] != signalsEchoed){ + ndbout << "Missing signal theData[0] = " << theData[0] + << " signalsEchoed = " << signalsEchoed << endl; + ndbout << (* header) << endl; + abort(); + } + while(tReg->prepareSend(header, prio, theData, nodeId, ptr) != SEND_OK){ + ndbout << "Failed to echo " << theData[0] << endl; + NdbSleep_MilliSleep(sleepTime); + // sleepTime += 10; + } + signalsEchoed++; + } +} + +void +copy(Uint32 * & insertPtr, + class SectionSegmentPool & thePool, const SegmentedSectionPtr & _ptr){ + abort(); +} + +void +reportError(void* callbackObj, NodeId nodeId, TransporterError errorCode){ + char buf[255]; + sprintf(buf, "reportError (%d, %x) in perfTest", nodeId, errorCode); + ndbout << buf << endl; + if(errorCode & 0x8000 && errorCode != 0x8014){ + abort(); //tReg->setPerformState(nodeId, PerformDisconnect); + } +} + +/** + * Report average send theLength in bytes (4096 last sends) + */ +void +reportSendLen(void* callbackObj, NodeId nodeId, Uint32 count, Uint64 bytes){ + allPhases[currentPhase].sendCount += count; + allPhases[currentPhase].sendLenBytes += bytes; + + if(!isClient){ + ndbout << "reportSendLen(" << nodeId << ", " + << (bytes/count) << ")" << endl; + } +} + +/** + * Report average receive theLength in bytes (4096 last receives) + */ +void +reportReceiveLen(void* callbackObj, NodeId nodeId, Uint32 count, Uint64 bytes){ + allPhases[currentPhase].recvCount += count; + allPhases[currentPhase].recvLenBytes += bytes; + + if(!isClient){ + ndbout << "reportReceiveLen(" << nodeId << ", " + << (bytes/count) << ")" << endl; + } +} + +/** + * Report connection established + */ +void +reportConnect(void* callbackObj, NodeId nodeId){ + char buf[255]; + sprintf(buf, "reportConnect(%d)", nodeId); + ndbout << buf << endl; + tReg->setPerformState(nodeId, PerformIO); + + if(!isStarted){ + isStarted = true; + startTime = NdbTick_CurrentMillisecond(); + if(isClient){ + reportHeader(); + allPhases[0].startTime = startTime; + } + } + else{ + // Resend signals that were lost when connection failed + TestPhase * current = &allPhases[currentPhase]; + current->noOfSignalSent = current->noOfSignalReceived; + } +} + +/** + * Report connection broken + */ +void +reportDisconnect(void* callbackObj, NodeId nodeId, Uint32 errNo){ + char buf[255]; + sprintf(buf, "reportDisconnect(%d)", nodeId); + ndbout << buf << endl; + + if(isStarted) + tReg->setPerformState(nodeId, PerformConnect); +} + + +int +checkJobBuffer() { + /** + * Check to see if jobbbuffers are starting to get full + * and if so call doJob + */ + return 0; +} + +void +createOSETransporter(void * _conf, + NodeId localNodeId, + NodeId remoteNodeId, + const char * localHostName, + const char * remoteHostName, + int sendBuf, + int recvBuf){ + + ndbout << "Creating OSE transporter from node " + << localNodeId << "(" << localHostName << ") to " + << remoteNodeId << "(" << remoteHostName << ")..." << endl;; + + OSE_TransporterConfiguration * conf = (OSE_TransporterConfiguration*)_conf; + + if(sendBuf != -1){ + conf->prioBSignalSize = sendBuf; + } + if(recvBuf != -1){ + conf->receiveBufferSize = recvBuf; + } + + ndbout << "\tSendBufferSize: " << conf->prioBSignalSize << endl; + ndbout << "\tReceiveBufferSize: " << conf->receiveBufferSize << endl; + + conf->localNodeId = localNodeId; + conf->localHostName = localHostName; + conf->remoteNodeId = remoteNodeId; + conf->remoteHostName = remoteHostName; + bool res = tReg->createTransporter(conf); + if(res) + ndbout << "... -- Success " << endl; + else + ndbout << "... -- Failure " << endl; +} + + +void +createSCITransporter(void * _conf, + NodeId localNodeId, + NodeId remoteNodeId, + const char * localHostName, + const char * remoteHostName, + int sendbuf, + int recvbuf) { + + + ndbout << "Creating SCI transporter from node " + << localNodeId << "(" << localHostName << ") to " + << remoteNodeId << "(" << remoteHostName << ")..." << endl;; + + + SCI_TransporterConfiguration * conf = (SCI_TransporterConfiguration*)_conf; + + conf->remoteSciNodeId0= (Uint16)atoi(localHostName); + conf->remoteSciNodeId1= (Uint16)atoi(remoteHostName); + + + conf->localNodeId = localNodeId; + conf->remoteNodeId = remoteNodeId; + + bool res = tReg->createTransporter(conf); + if(res) + ndbout << "... -- Success " << endl; + else + ndbout << "... -- Failure " << endl; +} + +void +createSHMTransporter(void * _conf, + NodeId localNodeId, + NodeId remoteNodeId, + const char * localHostName, + const char * remoteHostName, + int sendbuf, + int recvbuf) { + + + ndbout << "Creating SHM transporter from node " + << localNodeId << "(" << localHostName << ") to " + << remoteNodeId << "(" << remoteHostName << ")..." << endl;; + + + SHM_TransporterConfiguration * conf = (SHM_TransporterConfiguration*)_conf; + + + conf->localNodeId = localNodeId; + conf->remoteNodeId = remoteNodeId; + + bool res = tReg->createTransporter(conf); + if(res) + ndbout << "... -- Success " << endl; + else + ndbout << "... -- Failure " << endl; +} + + +void +createTCPTransporter(void * _conf, + NodeId localNodeId, + NodeId remoteNodeId, + const char * localHostName, + const char * remoteHostName, + int sendBuf, + int recvBuf){ + ndbout << "Creating TCP transporter from node " + << localNodeId << "(" << localHostName << ") to " + << remoteNodeId << "(" << remoteHostName << ")..." << endl;; + + TCP_TransporterConfiguration * conf = (TCP_TransporterConfiguration*)_conf; + + int port; + if(localNodeId == 1 && remoteNodeId == 2) port = basePortTCP + 0; + if(localNodeId == 1 && remoteNodeId == 3) port = basePortTCP + 1; + if(localNodeId == 2 && remoteNodeId == 1) port = basePortTCP + 0; + if(localNodeId == 2 && remoteNodeId == 3) port = basePortTCP + 2; + if(localNodeId == 3 && remoteNodeId == 1) port = basePortTCP + 1; + if(localNodeId == 3 && remoteNodeId == 2) port = basePortTCP + 2; + + if(sendBuf != -1){ + conf->sendBufferSize = sendBuf; + } + if(recvBuf != -1){ + conf->maxReceiveSize = recvBuf; + } + + ndbout << "\tSendBufferSize: " << conf->sendBufferSize << endl; + ndbout << "\tReceiveBufferSize: " << conf->maxReceiveSize << endl; + + conf->localNodeId = localNodeId; + conf->localHostName = localHostName; + conf->remoteNodeId = remoteNodeId; + conf->remoteHostName = remoteHostName; + conf->port = port; + bool res = tReg->createTransporter(conf); + if(res) + ndbout << "... -- Success " << endl; + else + ndbout << "... -- Failure " << endl; +} diff --git a/ndb/src/common/transporter/priotest/Makefile b/ndb/src/common/transporter/priotest/Makefile new file mode 100644 index 00000000000..483fc0f1f07 --- /dev/null +++ b/ndb/src/common/transporter/priotest/Makefile @@ -0,0 +1,15 @@ +include .defs.mk + +TYPE := ndbapi + +SOURCES = prioTransporterTest.cpp +ARCHIVE_TARGET := libpriotransportertest.a + +DIRS := prioTCP prioSHM prioSCI + +include $(NDB_TOP)/Epilogue.mk + + + + + diff --git a/ndb/src/common/transporter/priotest/prioOSE/Makefile b/ndb/src/common/transporter/priotest/prioOSE/Makefile new file mode 100644 index 00000000000..4df66fa35e0 --- /dev/null +++ b/ndb/src/common/transporter/priotest/prioOSE/Makefile @@ -0,0 +1,17 @@ +include .defs.mk + +TYPE := ndbapi + +BIN_TARGET := perfOSE +BIN_TARGET_ARCHIVES := perftransportertest transporter portlib + +CCFLAGS_LOC += -I.. + +SOURCES = perfOSE.cpp + +include $(NDB_TOP)/Epilogue.mk + + + + + diff --git a/ndb/src/common/transporter/priotest/prioSCI/Makefile b/ndb/src/common/transporter/priotest/prioSCI/Makefile new file mode 100644 index 00000000000..7d403539bf3 --- /dev/null +++ b/ndb/src/common/transporter/priotest/prioSCI/Makefile @@ -0,0 +1,17 @@ +include .defs.mk + +TYPE := ndbapi +BIN_TARGET := prioSCI +BIN_TARGET_LIBS := sisci +BIN_TARGET_ARCHIVES := priotransportertest transporter portlib general + +CCFLAGS_LOC += -I.. + +SOURCES = prioSCI.cpp + +include $(NDB_TOP)/Epilogue.mk + + + + + diff --git a/ndb/src/common/transporter/priotest/prioSCI/prioSCI.cpp b/ndb/src/common/transporter/priotest/prioSCI/prioSCI.cpp new file mode 100644 index 00000000000..6218b764e09 --- /dev/null +++ b/ndb/src/common/transporter/priotest/prioSCI/prioSCI.cpp @@ -0,0 +1,29 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include + +NDB_COMMAND(prioSCI, "prioSCI", "prioSCI", "Test the SCI Transporter", 65535) +{ + basePortTCP = 17000; + return prioTransporterTest(TestSCI, "prioSCI", argc, argv); +} + + + + diff --git a/ndb/src/common/transporter/priotest/prioSHM/Makefile b/ndb/src/common/transporter/priotest/prioSHM/Makefile new file mode 100644 index 00000000000..a827c6e3f1e --- /dev/null +++ b/ndb/src/common/transporter/priotest/prioSHM/Makefile @@ -0,0 +1,13 @@ +include .defs.mk + +TYPE := ndbapi + +BIN_TARGET := prioSHM +BIN_TARGET_ARCHIVES := priotransportertest transporter portlib general + +CCFLAGS_LOC += -I.. + +SOURCES = prioSHM.cpp + +include $(NDB_TOP)/Epilogue.mk + diff --git a/ndb/src/common/transporter/priotest/prioSHM/prioSHM.cpp b/ndb/src/common/transporter/priotest/prioSHM/prioSHM.cpp new file mode 100644 index 00000000000..4c1701a91e4 --- /dev/null +++ b/ndb/src/common/transporter/priotest/prioSHM/prioSHM.cpp @@ -0,0 +1,26 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include + +NDB_COMMAND(prioSHM, "prioSHM", "prioSHM", "Test the SHM Transporter", 65535) +{ + basePortTCP = 17000; + return prioTransporterTest(TestSHM, "prioSHM", argc, argv); +} + diff --git a/ndb/src/common/transporter/priotest/prioTCP/Makefile b/ndb/src/common/transporter/priotest/prioTCP/Makefile new file mode 100644 index 00000000000..92abf3e7424 --- /dev/null +++ b/ndb/src/common/transporter/priotest/prioTCP/Makefile @@ -0,0 +1,13 @@ +include .defs.mk + +TYPE := ndbapi + +BIN_TARGET := prioTCP +BIN_TARGET_ARCHIVES := priotransportertest transporter portlib general + +CCFLAGS_LOC += -I.. + +SOURCES = prioTCP.cpp + +include $(NDB_TOP)/Epilogue.mk + diff --git a/ndb/src/common/transporter/priotest/prioTCP/prioTCP.cpp b/ndb/src/common/transporter/priotest/prioTCP/prioTCP.cpp new file mode 100644 index 00000000000..f993dd05ac8 --- /dev/null +++ b/ndb/src/common/transporter/priotest/prioTCP/prioTCP.cpp @@ -0,0 +1,26 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include + +NDB_COMMAND(prioTCP, "prioTCP", "prioTCP", "Test the TCP Transporter", 65535) +{ + basePortTCP = 17000; + return prioTransporterTest(TestTCP, "prioTCP", argc, argv); +} + diff --git a/ndb/src/common/transporter/priotest/prioTransporterTest.cpp b/ndb/src/common/transporter/priotest/prioTransporterTest.cpp new file mode 100644 index 00000000000..919cc9d7511 --- /dev/null +++ b/ndb/src/common/transporter/priotest/prioTransporterTest.cpp @@ -0,0 +1,768 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "TransporterRegistry.hpp" +#include "TransporterDefinitions.hpp" +#include "TransporterCallback.hpp" +#include + +#include "prioTransporterTest.hpp" + +#include +#include +#include +#include +#include +#include + +int basePortTCP = 17000; + +SCI_TransporterConfiguration sciTemplate = { + 2000, + // Packet size + 2000000, // Buffer size + 2, // number of adapters + 1, // remote node id SCI + 2, // Remote node Id SCI + 0, // local ndb node id (server) + 0, // remote ndb node id (client) + 0, // byteOrder; + false, // compression; + true, // checksum; + true // signalId; +}; + + +SHM_TransporterConfiguration shmTemplate = { + 100000, // shmSize + 0, // shmKey + 1, // local ndb node id (server) + 2, // remote ndb node id (client) + 0, // byteOrder; + false, // compression; + true, // checksum; + true // signalId; +}; + +TCP_TransporterConfiguration tcpTemplate = { + 17000, // port; + "", // remoteHostName; + "", // localhostname + 2, // remoteNodeId; + 1, // localNodeId; + 2000000, // sendBufferSize - Size of SendBuffer of priority B + 2000, // maxReceiveSize - Maximum no of bytes to receive + 0, // byteOrder; + false, // compression; + true, // checksum; + true // signalId; +}; + +OSE_TransporterConfiguration oseTemplate = { + "", // remoteHostName; + "", // localHostName; + 0, // remoteNodeId; + 0, // localNodeId; + false, // compression; + true, // checksum; + true, // signalId; + 0, // byteOrder; + + 2000, // prioASignalSize; + 2000, // prioBSignalSize; + 10 // Recv buf size +}; + +TransporterRegistry *tReg = 0; + +#ifndef OSE_DELTA +#include +#endif + +extern "C" +void +signalHandler(int signo){ +#ifndef OSE_DELTA + ::signal(13, signalHandler); +#endif + char buf[255]; + sprintf(buf,"Signal: %d\n", signo); + ndbout << buf << endl; +} + +void +usage(const char * progName){ + ndbout << "Usage: " << progName << " localNodeId localHostName" + << " remoteHostName" + << " [] [] []" << endl; + ndbout << " localNodeId - {1,2}" << endl; +} + +typedef void (* CreateTransporterFunc)(void * conf, + NodeId localNodeId, + NodeId remoteNodeId, + const char * localHostName, + const char * remoteHostName, + int sendBuf, + int recvBuf); + +void +createOSETransporter(void * _conf, + NodeId localNodeId, + NodeId remoteNodeId, + const char * localHostName, + const char * remoteHostName, + int sendBuf, + int recvBuf){ + + ndbout << "Creating OSE transporter from node " + << localNodeId << "(" << localHostName << ") to " + << remoteNodeId << "(" << remoteHostName << ")..." << endl;; + + OSE_TransporterConfiguration * conf = (OSE_TransporterConfiguration*)_conf; + + if(sendBuf != -1){ + conf->prioBSignalSize = sendBuf; + } + if(recvBuf != -1){ + conf->receiveBufferSize = recvBuf; + } + + ndbout << "\tSendBufferSize: " << conf->prioBSignalSize << endl; + ndbout << "\tReceiveBufferSize: " << conf->receiveBufferSize << endl; + + conf->localNodeId = localNodeId; + conf->localHostName = localHostName; + conf->remoteNodeId = remoteNodeId; + conf->remoteHostName = remoteHostName; + bool res = tReg->createTransporter(conf); + if(res) + ndbout << "... -- Success " << endl; + else + ndbout << "... -- Failure " << endl; +} + + +void +createSCITransporter(void * _conf, + NodeId localNodeId, + NodeId remoteNodeId, + const char * localHostName, + const char * remoteHostName, + int sendbuf, + int recvbuf) { + + + ndbout << "Creating SCI transporter from node " + << localNodeId << "(" << localHostName << ") to " + << remoteNodeId << "(" << remoteHostName << ")..." << endl;; + + + SCI_TransporterConfiguration * conf = (SCI_TransporterConfiguration*)_conf; + + conf->remoteSciNodeId0= (Uint16)atoi(localHostName); + conf->remoteSciNodeId1= (Uint16)atoi(remoteHostName); + + + conf->localNodeId = localNodeId; + conf->remoteNodeId = remoteNodeId; + + bool res = tReg->createTransporter(conf); + if(res) + ndbout << "... -- Success " << endl; + else + ndbout << "... -- Failure " << endl; +} + +void +createSHMTransporter(void * _conf, + NodeId localNodeId, + NodeId remoteNodeId, + const char * localHostName, + const char * remoteHostName, + int sendbuf, + int recvbuf) { + + + ndbout << "Creating SHM transporter from node " + << localNodeId << "(" << localHostName << ") to " + << remoteNodeId << "(" << remoteHostName << ")..." << endl;; + + + SHM_TransporterConfiguration * conf = (SHM_TransporterConfiguration*)_conf; + + + conf->localNodeId = localNodeId; + conf->remoteNodeId = remoteNodeId; + + bool res = tReg->createTransporter(conf); + if(res) + ndbout << "... -- Success " << endl; + else + ndbout << "... -- Failure " << endl; +} + + +void +createTCPTransporter(void * _conf, + NodeId localNodeId, + NodeId remoteNodeId, + const char * localHostName, + const char * remoteHostName, + int sendBuf, + int recvBuf){ + ndbout << "Creating TCP transporter from node " + << localNodeId << "(" << localHostName << ") to " + << remoteNodeId << "(" << remoteHostName << ")..." << endl;; + + TCP_TransporterConfiguration * conf = (TCP_TransporterConfiguration*)_conf; + + int port; + if(localNodeId == 1 && remoteNodeId == 2) port = basePortTCP + 0; + if(localNodeId == 1 && remoteNodeId == 3) port = basePortTCP + 1; + if(localNodeId == 2 && remoteNodeId == 1) port = basePortTCP + 0; + if(localNodeId == 2 && remoteNodeId == 3) port = basePortTCP + 2; + if(localNodeId == 3 && remoteNodeId == 1) port = basePortTCP + 1; + if(localNodeId == 3 && remoteNodeId == 2) port = basePortTCP + 2; + + if(sendBuf != -1){ + conf->sendBufferSize = sendBuf; + } + if(recvBuf != -1){ + conf->maxReceiveSize = recvBuf; + } + + ndbout << "\tSendBufferSize: " << conf->sendBufferSize << endl; + ndbout << "\tReceiveBufferSize: " << conf->maxReceiveSize << endl; + + conf->localNodeId = localNodeId; + conf->localHostName = localHostName; + conf->remoteNodeId = remoteNodeId; + conf->remoteHostName = remoteHostName; + conf->port = port; + bool res = tReg->createTransporter(conf); + if(res) + ndbout << "... -- Success " << endl; + else + ndbout << "... -- Failure " << endl; +} + +struct TestPhase { + int signalSize; + int noOfSignals; + int noOfSignalSent; + int noOfSignalReceived; + NDB_TICKS startTime; + NDB_TICKS stopTime; + + NDB_TICKS startTimePrioA; + NDB_TICKS stopTimePrioA; + NDB_TICKS totTimePrioA; + int bytesSentBeforePrioA; + NDB_TICKS accTime; + int loopCount; + Uint64 sendLenBytes, sendCount; + Uint64 recvLenBytes, recvCount; +}; + +TestPhase testSpec[] = { + { 1, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals of size 1 word + ,{ 1, 10000, 0,0, 0,0,0,0,0,0,0 } // 100 signals of size 1 word + ,{ 1, 10000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals of size 1 word + ,{ 1, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1 word + + ,{ 8, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals of size 1 word + ,{ 8, 10000, 0,0, 0,0,0,0,0,0,0 } // 100 signals of size 1 word + ,{ 8, 10000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals of size 1 word + ,{ 8, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1 word + + ,{ 16, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals of size 1 word + ,{ 16, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals of size 1 word + ,{ 16, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals of size 1 word + ,{ 16, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1 word + + ,{ 24, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals of size 1 word + ,{ 24, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals of size 1 word + ,{ 24, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals of size 1 word + ,{ 24, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of size 1 word + + ,{ 0, 10, 0,0, 0,0,0,0,0,0,0 } // 10 signals of random size + ,{ 0, 100, 0,0, 0,0,0,0,0,0,0 } // 100 signals of random size + ,{ 0, 1000, 0,0, 0,0,0,0,0,0,0 } // 1000 signals of random size + ,{ 0, 10000, 0,0, 0,0,0,0,0,0,0 } // 10000 signals of random size +}; + +const int noOfTests = sizeof(testSpec)/sizeof(TestPhase); + +SendStatus +sendSignalTo(NodeId nodeId, int signalSize, int prio){ + if(signalSize == 0) + signalSize = (rand() % 25) + 1; + + SignalHeader sh; + sh.theLength = signalSize; + sh.theVerId_signalNumber = rand(); + sh.theReceiversBlockNumber = rand(); + sh.theSendersBlockRef = rand(); + sh.theSendersSignalId = rand(); + sh.theSignalId = rand(); + sh.theTrace = rand(); + + Uint32 theData[25]; + for(int i = 0; iprepareSend(&sh, prio, theData, nodeId); +} + +void +reportHeader(){ + ndbout << "#Sigs\tSz\tPayload\tTime\tSig/sec\tBps\t" + << "s len\tr len\tprioAtime\tbytesb4pA" << endl; +} + +void +printReport(TestPhase & p){ + if(p.accTime > 0) { + Uint32 secs = (p.accTime/p.loopCount)/1000; + Uint32 mill = (p.accTime/p.loopCount)%1000; + char st[255]; + if(secs > 0){ + sprintf(st, "%d.%.2ds", secs, (mill/10)); + } else { + sprintf(st, "%dms", mill); + } + + Uint32 sps = (1000*p.noOfSignals*p.loopCount)/p.accTime; + Uint32 bps = ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*(p.signalSize+3)); + if(p.signalSize == 0) + ((4000*p.noOfSignals)/p.accTime)*(p.loopCount*(13+3)); + + char ssps[255]; + if(sps > 1000000){ + sps /= 1000000; + sprintf(ssps, "%dM", (int)sps); + } else if(sps > 1000){ + sps /= 1000; + sprintf(ssps, "%dk", (int)sps); + } else { + sprintf(ssps, "%d", (int)sps); + } + + char sbps[255]; + if(bps > 1000000){ + bps /= 1000000; + sprintf(sbps, "%dM", bps); + } else if(bps>1000){ + bps /= 1000; + sprintf(sbps, "%dk", bps); + } else { + sprintf(sbps, "%d", bps); + } + + char buf[255]; + if(p.signalSize != 0){ + snprintf(buf, 255, + "%d\t%d\t%d\t%s\t%s\t%s\t%d\t%d\t%d\t%d", + p.noOfSignals, + p.signalSize, + (4*p.signalSize), + st, + ssps, + sbps, + (int)(p.sendLenBytes / (p.sendCount == 0 ? 1 : p.sendCount)), + (int)(p.recvLenBytes / (p.recvCount == 0 ? 1 : p.recvCount)), + (int)(p.totTimePrioA / p.loopCount), + (int)(p.bytesSentBeforePrioA)); + } else { + snprintf(buf, 255, + "%d\trand\t4*rand\t%s\t%s\t%s\t%d\t%d\t%d\t%d", + p.noOfSignals, + st, + ssps, + sbps, + (int)(p.sendLenBytes / (p.sendCount == 0 ? 1 : p.sendCount)), + (int)(p.recvLenBytes / (p.recvCount == 0 ? 1 : p.recvCount)), + (int)(p.totTimePrioA / p.loopCount), + (int)(p.bytesSentBeforePrioA)); + + } + ndbout << buf << endl; + } +} + +int loopCount = 1; +int sendBufSz = -1; +int recvBufSz = -1; + +NDB_TICKS startSec=0; +NDB_TICKS stopSec=0; +Uint32 startMicro=0; +Uint32 stopMicro=0; +int timerStarted; +int timerStopped; + +bool isClient = false; +bool isConnected = false; +bool isStarted = false; +int currentPhase = 0; +TestPhase allPhases[noOfTests]; +Uint32 signalToEcho; +NDB_TICKS startTime, stopTime; + +void +client(NodeId remoteNodeId){ + isClient = true; + + currentPhase = 0; + memcpy(allPhases, testSpec, sizeof(testSpec)); + + int counter = 0; + + while(true){ + TestPhase * current = &allPhases[currentPhase]; + if(current->noOfSignals == current->noOfSignalSent && + current->noOfSignals == current->noOfSignalReceived){ + + /** + * Test phase done + */ + current->stopTime = NdbTick_CurrentMillisecond(); + current->accTime += (current->stopTime - current->startTime); + + NdbSleep_MilliSleep(500 / loopCount); + + current->startTime = NdbTick_CurrentMillisecond(); + + current->noOfSignalSent = 0; + current->noOfSignalReceived = 0; + + current->loopCount ++; + if(current->loopCount == loopCount){ + + printReport(allPhases[currentPhase]); + + currentPhase ++; + if(currentPhase == noOfTests){ + /** + * Now we are done + */ + break; + } + NdbSleep_MilliSleep(500); + current = &allPhases[currentPhase]; + current->startTime = NdbTick_CurrentMillisecond(); + } + } + int signalsLeft = current->noOfSignals - current->noOfSignalSent; + if(signalsLeft > 0){ + for(; signalsLeft > 1; signalsLeft--){ + if(sendSignalTo(remoteNodeId, current->signalSize, 1) == SEND_OK) { + current->noOfSignalSent++; + // ndbout << "sent prio b" << endl; + current->bytesSentBeforePrioA += (current->signalSize << 2); + } + else { + tReg->external_IO(10); + break; + } + } + //prio A + if(signalsLeft==1) { + NDB_TICKS sec = 0; + Uint32 micro=0; + int ret = NdbTick_CurrentMicrosecond(&sec,µ); + if(ret==0) + current->startTimePrioA = micro + sec*1000000; + if(sendSignalTo(remoteNodeId, current->signalSize, 0) == SEND_OK) { + current->noOfSignalSent++; + signalsLeft--; + } + else { + tReg->external_IO(10); + break; + } + } + } + + if(counter % 10 == 0) + tReg->checkConnections(); + tReg->external_IO(0); + counter++; + } +} + +void +server(){ + isClient = false; + + signalToEcho = 0; + for(int i = 0; i 0){ + tReg->checkConnections(); + for(int i = 0; i<10; i++) + tReg->external_IO(10); + } +} + +int +prioTransporterTest(TestType tt, const char * progName, + int argc, const char **argv){ + + loopCount = 100; + sendBufSz = -1; + recvBufSz = -1; + + isClient = false; + isConnected = false; + isStarted = false; + currentPhase = 0; + + signalHandler(0); + + if(argc < 4){ + usage(progName); + return 0; + } + + const NodeId localNodeId = atoi(argv[1]); + const char * localHostName = argv[2]; + const char * remoteHost1 = argv[3]; + + if(argc >= 5) + loopCount = atoi(argv[4]); + if(argc >= 6) + sendBufSz = atoi(argv[5]); + if(argc >= 7) + recvBufSz = atoi(argv[6]); + + if(localNodeId < 1 || localNodeId > 2){ + ndbout << "localNodeId = " << localNodeId << endl << endl; + usage(progName); + return 0; + } + + if(localNodeId == 1) + ndbout << "-- ECHO CLIENT --" << endl; + else + ndbout << "-- ECHO SERVER --" << endl; + + ndbout << "localNodeId: " << localNodeId << endl; + ndbout << "localHostName: " << localHostName << endl; + ndbout << "remoteHost1 (node " << (localNodeId == 1?2:1) << "): " + << remoteHost1 << endl; + ndbout << "Loop count: " << loopCount << endl; + ndbout << "-----------------" << endl; + + void * confTemplate = 0; + CreateTransporterFunc func = 0; + switch(tt){ + case TestTCP: + func = createTCPTransporter; + confTemplate = &tcpTemplate; + break; + case TestOSE: + func = createOSETransporter; + confTemplate = &oseTemplate; + break; + case TestSCI: + func = createSCITransporter; + confTemplate = &sciTemplate; + break; + case TestSHM: + func = createSHMTransporter; + confTemplate = &shmTemplate; + break; + default: + ndbout << "Unsupported transporter type" << endl; + return 0; + } + + ndbout << "Creating transporter registry" << endl; + tReg = new TransporterRegistry; + tReg->init(localNodeId); + + switch(localNodeId){ + case 1: + (* func)(confTemplate, 1, 2, localHostName, remoteHost1, + sendBufSz, recvBufSz); + break; + case 2: + (* func)(confTemplate, 2, 1, localHostName, remoteHost1, + sendBufSz, recvBufSz); + break; + } + + ndbout << "Doing startSending/startReceiving" << endl; + tReg->startSending(); + tReg->startReceiving(); + + ndbout << "Connecting" << endl; + tReg->setPerformState(PerformConnect); + tReg->checkConnections(); + + if(localNodeId == 1) + client(2); + else + server(); + + isStarted = false; + + ndbout << "Sleep 3 secs" << endl; + NdbSleep_SecSleep(3); + + ndbout << "Doing setPerformState(Disconnect)" << endl; + tReg->setPerformState(PerformDisconnect); + + ndbout << "Doing checkConnections()" << endl; + tReg->checkConnections(); + + ndbout << "Deleting transporter registry" << endl; + delete tReg; tReg = 0; + + return 0; +} + +NdbOut & operator <<(NdbOut & out, SignalHeader & sh){ + out << "-- Signal Header --" << endl; + out << "theLength: " << sh.theLength << endl; + out << "gsn: " << sh.theVerId_signalNumber << endl; + out << "recBlockNo: " << sh.theReceiversBlockNumber << endl; + out << "sendBlockRef: " << sh.theSendersBlockRef << endl; + out << "sendersSig: " << sh.theSendersSignalId << endl; + out << "theSignalId: " << sh.theSignalId << endl; + out << "trace: " << (int)sh.theTrace << endl; + return out; +} + +void +execute(SignalHeader * const header, Uint8 prio, Uint32 * const theData){ + const NodeId nodeId = refToNode(header->theSendersBlockRef); + NDB_TICKS sec = 0; + Uint32 micro=0; + int ret = NdbTick_CurrentMicrosecond(&sec,µ); + if(prio == 0 && isClient && ret == 0) { + allPhases[currentPhase].stopTimePrioA = micro + sec*1000000; + allPhases[currentPhase].totTimePrioA += + allPhases[currentPhase].stopTimePrioA - + allPhases[currentPhase].startTimePrioA; + } + if(ret!=0) + allPhases[currentPhase].totTimePrioA = -1; + + if(isClient){ + allPhases[currentPhase].noOfSignalReceived++; + } else { + int sleepTime = 10; + while(tReg->prepareSend(header, prio, theData, nodeId) != SEND_OK){ + ndbout << "Failed to echo" << sleepTime << endl; + NdbSleep_MilliSleep(sleepTime); + // sleepTime += 10; + } + + signalToEcho--; + } +} + +void +reportError(NodeId nodeId, TransporterError errorCode){ + char buf[255]; + sprintf(buf, "reportError (%d, %x) in perfTest", nodeId, errorCode); + ndbout << buf << endl; + if(errorCode & 0x8000){ + tReg->setPerformState(nodeId, PerformDisconnect); + } +} + +/** + * Report average send theLength in bytes (4096 last sends) + */ +void +reportSendLen(NodeId nodeId, Uint32 count, Uint64 bytes){ + allPhases[currentPhase].sendCount += count; + allPhases[currentPhase].sendLenBytes += bytes; + + if(!isClient){ + ndbout << "reportSendLen(" << nodeId << ", " + << (bytes/count) << ")" << endl; + } +} + +/** + * Report average receive theLength in bytes (4096 last receives) + */ +void +reportReceiveLen(NodeId nodeId, Uint32 count, Uint64 bytes){ + allPhases[currentPhase].recvCount += count; + allPhases[currentPhase].recvLenBytes += bytes; + + if(!isClient){ + ndbout << "reportReceiveLen(" << nodeId << ", " + << (bytes/count) << ")" << endl; + } +} + +/** + * Report connection established + */ +void +reportConnect(NodeId nodeId){ + char buf[255]; + sprintf(buf, "reportConnect(%d)", nodeId); + ndbout << buf << endl; + tReg->setPerformState(nodeId, PerformIO); + + if(!isStarted){ + isStarted = true; + startTime = NdbTick_CurrentMillisecond(); + if(isClient){ + reportHeader(); + allPhases[0].startTime = startTime; + } + } + else{ + // Resend signals that were lost when connection failed + TestPhase * current = &allPhases[currentPhase]; + current->noOfSignalSent = current->noOfSignalReceived; + } +} + +/** + * Report connection broken + */ +void +reportDisconnect(NodeId nodeId, Uint32 errNo){ + char buf[255]; + sprintf(buf, "reportDisconnect(%d)", nodeId); + ndbout << buf << endl; + + if(isStarted) + tReg->setPerformState(nodeId, PerformConnect); +} + + +int +checkJobBuffer() { + /** + * Check to see if jobbbuffers are starting to get full + * and if so call doJob + */ + return 0; +} diff --git a/ndb/src/common/transporter/priotest/prioTransporterTest.hpp b/ndb/src/common/transporter/priotest/prioTransporterTest.hpp new file mode 100644 index 00000000000..787a9f46433 --- /dev/null +++ b/ndb/src/common/transporter/priotest/prioTransporterTest.hpp @@ -0,0 +1,35 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef PRIO_TRANSPORTER_TEST_HPP +#define PRIO_TRANSPORTER_TEST_HPP + + +enum TestType { + TestTCP, + TestOSE, + TestSCI, + TestSHM +}; + +extern int basePortTCP; + +int prioTransporterTest(TestType tt, const char * pName, + int argc, const char **argv); + + + +#endif diff --git a/ndb/src/common/util/Base64.cpp b/ndb/src/common/util/Base64.cpp new file mode 100644 index 00000000000..5f4bbc8645a --- /dev/null +++ b/ndb/src/common/util/Base64.cpp @@ -0,0 +1,111 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include + +static char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz" + "0123456789+/"; + +int +base64_encode(UtilBuffer &src, BaseString &dst) { + char *s = (char *)src.get_data(); + int i = 0; + + while(i < src.length()) { + int c; + c = s[i++]; + c <<= 8; + + if(i < src.length()) + c += s[i]; + c <<= 8; + i++; + + if(i < src.length()) + c += s[i]; + i++; + + dst.append(base64_table[(c >> 18) & 0x3f]); + dst.append(base64_table[(c >> 12) & 0x3f]); + + if(i > (src.length() + 1)) + dst.append('='); + else + dst.append(base64_table[(c >> 6) & 0x3f]); + + if(i > src.length()) + dst.append('='); + else + dst.append(base64_table[(c >> 0) & 0x3f]); + } + return 0; +} + +static inline int +pos(char c) { + return strchr(base64_table, c) - base64_table; +} + + +int +base64_decode(BaseString &src, UtilBuffer &dst) { + size_t size; + size = (src.length() * 3) / 4; + size_t i = 0; + const char *s = src.c_str(); + while(i < size) { + int c = 0; + int mark = 0; + c += pos(*s++); + c <<= 6; + i++; + + c += pos(*s++); + c <<= 6; + i++; + + if(*s != '=') + c += pos(*s++); + else { + size--; + mark++; + } + c <<= 6; + i++; + + if(*s != '=') + c += pos(*s++); + else { + size--; + mark++; + } + /* c <<= 6; */ + i++; + + char b[3]; + + + b[0] = (c >> 16) & 0xff; + b[1] = (c >> 8) & 0xff; + b[2] = (c >> 0) & 0xff; + + dst.append((void *)b, 3-mark); + } + return 0; +} diff --git a/ndb/src/common/util/BaseString.cpp b/ndb/src/common/util/BaseString.cpp new file mode 100644 index 00000000000..1b0eaa1b83c --- /dev/null +++ b/ndb/src/common/util/BaseString.cpp @@ -0,0 +1,418 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* -*- c-basic-offset: 4; -*- */ +#include +#include +#include +#include "BaseString.hpp" +#include + +BaseString::BaseString() +{ + m_chr = new char[1]; + m_chr[0] = 0; + m_len = 0; +} + +BaseString::BaseString(const char* s) +{ + const size_t n = strlen(s); + m_chr = new char[n + 1]; + memcpy(m_chr, s, n + 1); + m_len = n; +} + +BaseString::BaseString(const BaseString& str) +{ + const char* const s = str.m_chr; + const size_t n = str.m_len; + char* t = new char[n + 1]; + memcpy(t, s, n + 1); + m_chr = t; + m_len = n; +} + +BaseString::~BaseString() +{ + delete[] m_chr; +} + +BaseString& +BaseString::assign(const char* s) +{ + const size_t n = strlen(s); + char* t = new char[n + 1]; + memcpy(t, s, n + 1); + delete[] m_chr; + m_chr = t; + m_len = n; + return *this; +} + +BaseString& +BaseString::assign(const char* s, size_t n) +{ + char* t = new char[n + 1]; + memcpy(t, s, n); + t[n] = 0; + delete[] m_chr; + m_chr = t; + m_len = n; + return *this; +} + +BaseString& +BaseString::assign(const BaseString& str, size_t n) +{ + if (n > str.m_len) + n = str.m_len; + return assign(str.m_chr, n); +} + +BaseString& +BaseString::append(const char* s) +{ + const size_t n = strlen(s); + char* t = new char[m_len + n + 1]; + memcpy(t, m_chr, m_len); + memcpy(t + m_len, s, n + 1); + delete[] m_chr; + m_chr = t; + m_len += n; + return *this; +} + +BaseString& +BaseString::append(char c) { + return appfmt("%c", c); +} + +BaseString& +BaseString::append(const BaseString& str) +{ + return append(str.m_chr); +} + +BaseString& +BaseString::append(const Vector &vector, + const BaseString &separator) { + for(size_t i=0;i (int)m_len) { + delete[] m_chr; + m_chr = new char[l]; + } + va_start(ap, fmt); + vsnprintf(m_chr, l, fmt, ap); + va_end(ap); + m_len = strlen(m_chr); + return *this; +} + +BaseString& +BaseString::appfmt(const char *fmt, ...) +{ + char buf[1]; + va_list ap; + int l; + + /* Figure out how long the formatted string will be. A small temporary + * buffer is used, because I don't trust all implementations to work + * when called as vsnprintf(NULL, 0, ...). + */ + va_start(ap, fmt); + l = vsnprintf(buf, sizeof(buf), fmt, ap) + 1; + va_end(ap); + char *tmp = new char[l]; + va_start(ap, fmt); + vsnprintf(tmp, l, fmt, ap); + va_end(ap); + append(tmp); + delete[] tmp; + return *this; +} + +BaseString& +BaseString::operator=(const BaseString& str) +{ + if (this != &str) { + this->assign(str); + } + return *this; +} + +int +BaseString::split(Vector &v, + const BaseString &separator, + int maxSize) const { + char *str = strdup(m_chr); + int i, start, len, num = 0; + len = strlen(str); + for(start = i = 0; + (i <= len) && ( (maxSize<0) || ((int)v.size()<=maxSize-1) ); + i++) { + if(strchr(separator.c_str(), str[i]) || i == len) { + if(maxSize < 0 || (int)v.size() < maxSize-1) + str[i] = '\0'; + v.push_back(BaseString(str+start)); + num++; + start = i+1; + } + } + free(str); + + return num; +} + +ssize_t +BaseString::indexOf(char c) { + char *p; + p = strchr(m_chr, c); + if(p == NULL) + return -1; + return (ssize_t)(p-m_chr); +} + +ssize_t +BaseString::lastIndexOf(char c) { + char *p; + p = strrchr(m_chr, c); + if(p == NULL) + return -1; + return (ssize_t)(p-m_chr); +} + +BaseString +BaseString::substr(ssize_t start, ssize_t stop) { + if(stop < 0) + stop = length(); + ssize_t len = stop-start; + if(len <= 0) + return BaseString(""); + BaseString s; + s.assign(m_chr+start, len); + return s; +} + +static bool +iswhite(char c) { + switch(c) { + case ' ': + case '\t': + return true; + default: + return false; + } + /* NOTREACHED */ +} + +char ** +BaseString::argify(const char *argv0, const char *src) { + Vector vargv; + + if(argv0 != NULL) + vargv.push_back(strdup(argv0)); + + char *tmp = new char[strlen(src)+1]; + char *dst = tmp; + const char *end = src + strlen(src); + /* Copy characters from src to destination, while compacting them + * so that all whitespace is compacted and replaced by a NUL-byte. + * At the same time, add pointers to strings in the vargv vector. + * When whitespace is detected, the characters '"' and '\' are honored, + * to make it possible to give arguments containing whitespace. + * The semantics of '"' and '\' match that of most Unix shells. + */ + while(src < end && *src) { + /* Skip initial whitespace */ + while(src < end && *src && iswhite(*src)) + src++; + + char *begin = dst; + while(src < end && *src) { + /* Handle '"' quotation */ + if(*src == '"') { + src++; + while(src < end && *src && *src != '"') { + if(*src == '\\') + src++; + *dst++ = *src++; + } + src++; + if(src >= end) + goto end; + } + + /* Handle '\' */ + if(*src == '\\') + src++; + else if(iswhite(*src)) + break; + + /* Actually copy characters */ + *dst++ = *src++; + } + + /* Make sure the string is properly terminated */ + *dst++ = '\0'; + src++; + + vargv.push_back(strdup(begin)); + } + end: + + delete[] tmp; + vargv.push_back(NULL); + + /* Convert the C++ Vector into a C-vector of strings, suitable for + * calling execv(). + */ + char **argv = (char **)malloc(sizeof(*argv) * (vargv.size())); + if(argv == NULL) + return NULL; + + for(size_t i = 0; i < vargv.size(); i++){ + argv[i] = vargv[i]; + } + + return argv; +} + +BaseString& +BaseString::trim(const char * delim){ + trim(m_chr, delim); + m_len = strlen(m_chr); + return * this; +} + +char* +BaseString::trim(char * str, const char * delim){ + int len = strlen(str) - 1; + for(; len > 0 && strchr(delim, str[len]); len--); + + int pos = 0; + for(; pos <= len && strchr(delim, str[pos]); pos++); + + if(pos > len){ + str[0] = 0; + return 0; + } else { + memmove(str, &str[pos], len - pos + 1); + str[len-pos+1] = 0; + } + + return str; +} + + +#ifdef TEST_BASE_STRING +#include + +/* +g++ -g -Wall -o tbs -DTEST_BASE_STRING -I$NDB_TOP/include/util \ + -I$NDB_TOP/include/portlib BaseString.cpp +valgrind ./tbs +*/ + +int main() +{ + BaseString s("abc"); + BaseString t(s); + s.assign("def"); + t.append("123"); + assert(s == "def"); + assert(t == "abc123"); + s.assign(""); + t.assign(""); + for (unsigned i = 0; i < 1000; i++) { + s.append("xyz"); + t.assign(s); + assert(strlen(t.c_str()) % 3 == 0); + } + + { + BaseString s(":123:abc:;:foo:"); + Vector v; + assert(s.split(v, ":;") == 7); + + assert(v[0] == ""); + assert(v[1] == "123"); + assert(v[2] == "abc"); + assert(v[3] == ""); + assert(v[4] == ""); + assert(v[5] == "foo"); + assert(v[6] == ""); + } + + { + BaseString s(":123:abc:foo:bar"); + Vector v; + assert(s.split(v, ":;", 4) == 4); + + assert(v[0] == ""); + assert(v[1] == "123"); + assert(v[2] == "abc"); + assert(v[3] == "foo:bar"); + + BaseString n; + n.append(v, "()"); + assert(n == "()123()abc()foo:bar"); + n = ""; + n.append(v); + assert(n == " 123 abc foo:bar"); + } + + { + assert(BaseString("hamburger").substr(4,2) == ""); + assert(BaseString("hamburger").substr(3) == "burger"); + assert(BaseString("hamburger").substr(4,8) == "urge"); + assert(BaseString("smiles").substr(1,5) == "mile"); + assert(BaseString("012345").indexOf('2') == 2); + assert(BaseString("hej").indexOf('X') == -1); + } + + { + assert(BaseString(" 1").trim(" ") == "1"); + assert(BaseString("1 ").trim(" ") == "1"); + assert(BaseString(" 1 ").trim(" ") == "1"); + assert(BaseString("abc\t\n\r kalleabc\t\r\n").trim("abc\t\r\n ") == "kalle"); + assert(BaseString(" ").trim(" ") == ""); + } + return 0; +} + +#endif diff --git a/ndb/src/common/util/File.cpp b/ndb/src/common/util/File.cpp new file mode 100644 index 00000000000..ad72b41835d --- /dev/null +++ b/ndb/src/common/util/File.cpp @@ -0,0 +1,207 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +#include +#include +#include + +#if defined NDB_OSE || defined NDB_SOFTOSE +#include +#endif + +#include + +// +// PUBLIC +// + +bool +File::exists(const char* aFileName) +{ + bool rc = true; + + struct stat stmp; + if (::stat(aFileName, &stmp) != 0) + { + rc = false; + } + + /* + File f; + if (!f.open(aFileName, "r")) + { + rc = (errno == ENOENT ? false : true); + } + else + { + f.close(); + } + */ + return rc; +} + +long +File::size(FILE* f) +{ + long cur_pos = 0, length = 0; + + cur_pos = ::ftell(f); + ::fseek(f, 0, SEEK_END); + length = ::ftell(f); + ::fseek(f, cur_pos, SEEK_SET); // restore original position + + return length; +} + +bool +File::rename(const char* currFileName, const char* newFileName) +{ + return ::rename(currFileName, newFileName) == 0 ? true : false; +} +bool +File::remove(const char* aFileName) +{ + return ::remove(aFileName) == 0 ? true : false; +} + +File::File() : + m_file(NULL), + m_fileMode("r") +{ +} + +File::File(const char* aFileName, const char* mode) : + m_file(NULL), + m_fileMode(mode) +{ + ::snprintf(m_fileName, MAX_FILE_NAME_SIZE, aFileName); +} + +bool +File::open() +{ + return open(m_fileName, m_fileMode); +} + +bool +File::open(const char* aFileName, const char* mode) +{ + if(m_fileName != aFileName){ + /** + * Only copy if it's not the same string + */ + ::snprintf(m_fileName, MAX_FILE_NAME_SIZE, aFileName); + } + m_fileMode = mode; + bool rc = true; + if ((m_file = ::fopen(m_fileName, m_fileMode))== NULL) + { + rc = false; + } + + return rc; +} +File::~File() +{ + close(); +} + +bool +File::remove() +{ + // Close the file first! + close(); + return File::remove(m_fileName); +} + +bool +File::close() +{ + bool rc = true; + if (m_file != NULL) + { + ::fflush(m_file); + rc = (::fclose(m_file) == 0 ? true : false); + m_file = NULL; // Try again? + } + + return rc; +} + +int +File::read(void* buf, size_t itemSize, size_t nitems) const +{ + return ::fread(buf, itemSize, nitems, m_file); +} + +int +File::readChar(char* buf, long start, long length) const +{ + return ::fread((void*)&buf[start], 1, length, m_file); +} + +int +File::readChar(char* buf) +{ + return readChar(buf, 0, strlen(buf)); +} + +int +File::write(const void* buf, size_t size, size_t nitems) +{ + return ::fwrite(buf, size, nitems, m_file); +} + +int +File::writeChar(const char* buf, long start, long length) +{ + return ::fwrite((const void*)&buf[start], sizeof(char), length, m_file); +} + +int +File::writeChar(const char* buf) +{ + return writeChar(buf, 0, ::strlen(buf)); +} + +long +File::size() const +{ + return File::size(m_file); +} + +const char* +File::getName() const +{ + return m_fileName; +} + +int +File::flush() const +{ +#if defined NDB_OSE || defined NDB_SOFTOSE + ::fflush(m_file); + return ::fsync(::fileno(m_file)); +#else + return 0; +#endif +} + +// +// PRIVATE +// diff --git a/ndb/src/common/util/InputStream.cpp b/ndb/src/common/util/InputStream.cpp new file mode 100644 index 00000000000..c52b594225d --- /dev/null +++ b/ndb/src/common/util/InputStream.cpp @@ -0,0 +1,61 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "InputStream.hpp" +#include +#include +#include + +FileInputStream Stdin(stdin); + +FileInputStream::FileInputStream(FILE * file) + : f(file) { +} + +char* +FileInputStream::gets(char * buf, int bufLen){ + if(!feof(f)){ + return fgets(buf, bufLen, f); + } + return 0; +} + +SocketInputStream::SocketInputStream(NDB_SOCKET_TYPE socket, + unsigned readTimeout) + : m_socket(socket) { + m_timeout = readTimeout; +} + +char* +SocketInputStream::gets(char * buf, int bufLen) { + buf[0] = 77; + assert(bufLen >= 2); + int res = readln_socket(m_socket, m_timeout, buf, bufLen - 1); + if(res == -1) + return 0; + if(res == 0 && buf[0] == 77){ // select return 0 + buf[0] = 0; + } else if(res == 0 && buf[0] == 0){ // only newline + buf[0] = '\n'; + buf[1] = 0; + } else { + int len = strlen(buf); + buf[len + 1] = '\0'; + buf[len] = '\n'; + } + return buf; +} diff --git a/ndb/src/common/util/Makefile b/ndb/src/common/util/Makefile new file mode 100644 index 00000000000..e400bb12d29 --- /dev/null +++ b/ndb/src/common/util/Makefile @@ -0,0 +1,36 @@ +include .defs.mk + +TYPE := util + +PIC_ARCHIVE := Y +ARCHIVE_TARGET := general + +SOURCES = File.cpp md5_hash.cpp Properties.cpp socket_io.cpp \ + SimpleProperties.cpp Parser.cpp InputStream.cpp SocketServer.cpp \ + OutputStream.cpp NdbOut.cpp BaseString.cpp Base64.cpp \ + NdbSqlUtil.cpp + +SOURCES.c = uucode.c random.c getarg.c version.c + +ifeq ($(NDB_OS), OSE) + SOURCES += NdbErrHnd.cpp +endif +ifeq ($(NDB_OS), OSE) + SOURCES += NdbErrHnd.cpp +endif +ifdef NDB_STRDUP + SOURCES.c += strdup.c +endif +ifdef NDB_STRLCAT + SOURCES.c += strlcat.c +endif +ifdef NDB_STRLCPY + SOURCES.c += strlcpy.c +endif + +DIRS := testSimpleProperties + +include $(NDB_TOP)/Epilogue.mk + +testNdbSqlUtil: NdbSqlUtil.cpp + $(CC) -o $@ NdbSqlUtil.cpp $(CCFLAGS) -DNDB_SQL_UTIL_TEST -L$(NDB_TOP)/lib -lportlib -lgeneral diff --git a/ndb/src/common/util/NdbErrHnd.cpp b/ndb/src/common/util/NdbErrHnd.cpp new file mode 100644 index 00000000000..53df5d702ca --- /dev/null +++ b/ndb/src/common/util/NdbErrHnd.cpp @@ -0,0 +1,493 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#if defined NDB_OSE || defined NDB_SOFTOSE + +#include +#include +#include + +#include "ose.h" +#include "ose_err.h" +#include "osetypes.h" + + +#define BUFSIZE 100 + +typedef struct { + char header1[BUFSIZE]; + char header2[BUFSIZE]; + char error_code_line[BUFSIZE]; + char subcode_line[BUFSIZE]; + char product_line[BUFSIZE]; + char header_file_line[BUFSIZE]; + char extra_line[BUFSIZE]; + char user_called_line[BUFSIZE]; + char current_process_id_line[BUFSIZE]; + char current_process_name_line[BUFSIZE]; + char file_line[BUFSIZE]; + char line_line[BUFSIZE]; + char err_hnd_file[BUFSIZE]; +} Error_message; + +char assert_line[BUFSIZE]; +char unknown_signal_line[BUFSIZE]; +char signal_number_line[BUFSIZE]; +char sender_line[BUFSIZE]; +char receiver_line[BUFSIZE]; + +extern "C" OSBOOLEAN ndb_err_hnd(bool user_called, + Uint32 error_code, + Uint32 extra) +{ + static Error_message error_message; + bool error_handled; + Uint32 subcode; + + char* subcode_mnemonic; + char* product_name; + char* file_name; + + /*The subcode (bit 16 - 30) is extracted from error_code */ + subcode = (error_code & 0x7fff0000) >> 16; + + if (user_called) { + switch (subcode) { + case 0x0050 : + subcode_mnemonic= "OSE_PRH_PLS"; + product_name= "Program Loader"; + file_name = "prherr.h"; + break; + case 0x0051 : + subcode_mnemonic = "OSE_PRH_START_PRH"; + product_name= "start_prh"; + file_name= " start_prh.c"; + break; + case 0x0052 : + subcode_mnemonic= "OSE_PRH_ASF"; + product_name= "Archive Server"; + file_name = "prherr.h"; + break; + case 0x0058 : + case 0x4058 : + case 0x3fff : + case 0x8058 : + subcode_mnemonic= "OSE_MMS_EBASE"; + product_name= "MMS"; + file_name= "mms_err.h"; + break; + /*Link Handler G3***************************************/ + case 0x0060 : + case 0x8060 : + subcode_mnemonic= "OSE_GLH_EBASE"; + product_name= "General Link Handler"; + file_name= "glherr.h"; + break; + case 0x0064 : + case 0x8064 : + subcode_mnemonic= "OSE_GPL_EBASE"; + product_name= "General Protocol Link Handler"; + file_name= "gplerr.h"; + break; + case 0x0066 : + case 0x8066 : + subcode_mnemonic= "OSE_UDPPDR_EBASE"; + product_name= "UDP driver for GPL"; + file_name= "udppdrerr.h"; + break; + case 0x0067 : + case 0x8067 : + subcode_mnemonic= "OSE_SERPDR_EBASE"; + product_name= "Serial driver for GPL"; + file_name= "serpdrerr.h"; + break; + case 0x0068 : + case 0x8068 : + subcode_mnemonic= "OSE_ETHPDR_EBASE"; + product_name= "Ethernet driver for GPL"; + file_name= "ethpdrerr.h"; + break; + /*Link handler G4***************************************/ + case 0x0061 : + subcode_mnemonic= "OSE_OTL_EBASE"; + product_name= "OSE Transport Layer"; + file_name= "otlerr.h"; + break; + case 0x0062 : + subcode_mnemonic= "OSE_LALUDP_EBASE"; + product_name= "Link Adaption Layer for UDP"; + file_name= "header file unknown"; + break; + /*Internet Utilities************************************/ + case 0x0069 : + subcode_mnemonic= "OSE_TFTPD"; + product_name= "TFTP server"; + file_name= "inetutilerr.h"; + break; + case 0x006a : + subcode_mnemonic= "OSE_TELUDPD"; + product_name= "TELNET/UDP server"; + file_name= "inetutilerr.h"; + break; + case 0x006b : + subcode_mnemonic= "OSE_FTPD"; + product_name= "FTP server"; + file_name= "inetutilerr.h"; + break; + case 0x006c : + subcode_mnemonic= "OSE_TELNETD"; + product_name= "TELNET server"; + file_name= "inetutilerr.h"; + break; + case 0x006d : + subcode_mnemonic= "OSE_SURFER"; + product_name= "OSE System Surfer"; + file_name= "inetutilerr.h"; + break; + case 0x006e : + subcode_mnemonic= "OSE_BOOTP"; + product_name= "BOOTP client"; + file_name= "inetutilerr.h"; + break; + case 0x006f : + switch((error_code & 0x0000f000)){ + case 0x00000000 : + subcode_mnemonic= "OSE_RES"; + product_name= "DNS resolver"; + file_name= "inetutilerr.h"; + break; + case 0x00001000 : + subcode_mnemonic= "OSE_DHCPC"; + product_name= "DHCP client"; + file_name= "inetutilerr.h"; + break; + case 0x00002000 : + subcode_mnemonic= "OSE_FTP"; + product_name= "FTP client"; + file_name= "inetutilerr.h"; + break; + default : + subcode_mnemonic= "Unknown error"; + product_name= "unknown product"; + file_name = "header file unknown"; + break; + } + break; + case 0x00c2 : + subcode_mnemonic= "OSE_DNS"; + product_name= "DNS server"; + file_name= "dns_err.h"; + break; + /*INET**************************/ + case 0x0070 : + subcode_mnemonic= "INET_ERRBASE"; + product_name= "Internet Protocols (INET)"; + file_name= "ineterr.h"; + break; + case 0x0071 : + subcode_mnemonic= "WEBS_ERRBASE"; + product_name= "Web Server (WEBS)"; + file_name= "webserr.h"; + break; + case 0x0072 : + subcode_mnemonic= "SNMP"; + product_name= "SNMP"; + file_name= "header file unknown"; + break; + case 0x0073 : + subcode_mnemonic= "STP_BRIDGE"; + product_name= "STP bridge"; + file_name= "header file unknown"; + break; + case 0x0200 : + case 0x0201 : + case 0x0202 : + case 0x0203 : + case 0x0204 : + case 0x0205 : + case 0x0206 : + case 0x0207 : + case 0x0208 : + case 0x0209 : + case 0x020a : + case 0x020b : + case 0x020c : + case 0x020d : + case 0x020e : + case 0x020f : + subcode_mnemonic = "INETINIT_ERR_BASE"; + product_name = "INET"; + file_name = "startinet.c"; + break; + /*Miscellanous******************************************/ + case 0x0082 : + subcode_mnemonic= "OSE_HEAP_EBASE"; + product_name= "Heap Manager"; + file_name= "heap_err.h"; + break; + case 0x0088 : + subcode_mnemonic= "OSE_BSP"; + product_name= "Board Support Package"; + file_name= "bsperr.h"; + break; + case 0x008a : + subcode_mnemonic= "OSE_TOSV_EBASE"; + product_name= "Time Out Server"; + file_name= "tosverr.h"; + break; + case 0x008b : + subcode_mnemonic= "OSE_RTC_EBASE"; + product_name= "Real Time Clock"; + file_name= "rtcerr.h"; + break; + case 0x008d : + case 0x808d : + subcode_mnemonic= "OSENS_ERR_BASE"; + product_name= "Name Server"; + file_name= "osens_err.h"; + break; + case 0x008e : + subcode_mnemonic= "PMD_ERR_BASE"; + product_name= "Post Mortem Dump"; + file_name= "pmderr.h"; + break; + /*Embedded File System***********************************/ + case 0x0090 : + subcode_mnemonic= "OSE_EFS_COMMON"; + product_name= "EFS common"; + file_name= "efs_err.h"; + break; + case 0x0091 : + subcode_mnemonic= "OSE_EFS_FLIB"; + product_name= "EFS function library"; + file_name= "efs_err.h"; + break; + case 0x0092 : + subcode_mnemonic= "OSE_EFS_SERDD"; + product_name= "EFS serdd"; + file_name= "efs_err.h"; + break; + case 0x0093 : + subcode_mnemonic= "OSE_EFS_SHELL"; + product_name= "OSE shell"; + file_name= "efs_err.h"; + break; + case 0x0094 : + subcode_mnemonic= "OSE_EFS_STARTEFS"; + product_name= "EFS startefs.c"; + file_name= "efs_err.h"; + break; + /*Debugger related***************************************/ + case 0x00a0 : + subcode_mnemonic= "DBGSERVER_ERR_BASE"; + product_name= "Debug server for Illuminator"; + file_name= "degservererr.h"; + break; + case 0x00b2 : + subcode_mnemonic= "OSE_MDM"; + product_name= "Multi INDRT monitor"; + file_name= "header file unknown"; + break; + /*Miscellanous*******************************************/ + case 0x00c0 : + subcode_mnemonic= "OSE_POTS_EBASE"; + product_name= "POTS tutorial example"; + file_name= "pots_err.h"; + break; + case 0x00c1 : + subcode_mnemonic= "OSE_PTH_ECODE_BASE"; + product_name= "Pthreads"; + file_name= "pthread_err.h"; + break; + case 0x00c3 : + subcode_mnemonic= "OSE_NTP_EBASE"; + product_name= "OSE NTP/SNTP"; + file_name= "ntp_err.h"; + break; + case 0x00c4 : + subcode_mnemonic= "TRILLIUM_BASE"; + product_name= "Trillium OSE port"; + file_name= "sk_ss.c"; + break; + case 0x00c5 : + subcode_mnemonic= "OSE_OSECPP_EBASE"; + product_name= "C++ Support with libosecpp.a"; + file_name= "cpp_err.h"; + break; + case 0x00c6 : + subcode_mnemonic= "OSE_RIP_ERR_BASE"; + product_name= "OSE RIP"; + file_name= "oserip.h"; + break; + /*Unknown error_code*************************************/ + default : + subcode_mnemonic= "Unknown error"; + product_name= "unknown product"; + file_name = "header file unknown"; + break; + } + } else { + /* user_called = 0, i.e. reported by the kernel */ + subcode_mnemonic= "OSE_KRN"; + product_name= "Kernel"; + file_name = "ose_err.h"; + } + + snprintf (error_message.header1, + BUFSIZE, + "This is the OSE Example System Error handler\r\n"); + + snprintf (error_message.err_hnd_file, + BUFSIZE, + "located in: " __FILE__ "\r\n"); + + snprintf (error_message.header2, + BUFSIZE, + "An Error has been reported:\r\n"); + + if (user_called == (OSBOOLEAN) 0 ) { + snprintf(error_message.user_called_line, + BUFSIZE, + "user_called: 0x%x (Error detected by the kernel)\r\n", + user_called); + } + else { + snprintf(error_message.user_called_line, + BUFSIZE, + "user_called: 0x%x (Error detected by an application)\r\n", + user_called); + } + + snprintf (error_message.error_code_line, + BUFSIZE, + "error code: 0x%08x\r\n", + error_code); + + snprintf (error_message.subcode_line, + BUFSIZE, + " subcode: %s (0x%08x)\r\n", + subcode_mnemonic, + ( subcode << 16)); + + snprintf (error_message.product_line, + BUFSIZE, + " product: %s\r\n", + product_name); + + snprintf (error_message.header_file_line, + BUFSIZE, + " header file: %s\r\n", + file_name); + + snprintf (error_message.extra_line, + BUFSIZE, + "extra: 0x%08x\r\n", + extra); + + if (error_code != OSE_ENO_KERN_SPACE || user_called){ + struct OS_pcb *pcb = get_pcb(current_process()); + const char *process_name = &pcb->strings[pcb->name]; + + snprintf(error_message.current_process_id_line, + BUFSIZE, + "Current Process: 0x%08x\r\n", + current_process()); + + snprintf(error_message.current_process_name_line, + BUFSIZE, + "Process Name: %s\r\n", + process_name); + + snprintf(error_message.file_line, + BUFSIZE, + "File: %s\r\n", + &pcb->strings[pcb->file]); + + snprintf(error_message.line_line, + BUFSIZE, + "Line: %d\r\n", + pcb->line); + + free_buf((union SIGNAL **)&pcb); + } + + if ( !(((error_code & OSE_EFATAL_MASK) != 0) && (user_called == 0))){ + /* If the error is reported by the kernel and the fatal flag is set, + * dbgprintf can't be trusted */ + ndbout << error_message.header1; + ndbout << error_message.err_hnd_file; + ndbout << error_message.header2; + ndbout << error_message.user_called_line; + ndbout << error_message.error_code_line; + ndbout << error_message.subcode_line; + ndbout << error_message.product_line; + ndbout << error_message.header_file_line; + ndbout << error_message.extra_line; + ndbout << error_message.current_process_id_line; + ndbout << error_message.current_process_name_line; + ndbout << error_message.file_line; + ndbout << error_message.line_line; + ndbout << endl; + } + + if(user_called){ + switch (error_code) { + /* Check for assertion failure (see oseassert.h and assert.c). */ + case (OSERRCODE) 0xffffffff: + { + if(extra != 0){ + char *expr = ((char **)extra)[0]; + char *file = ((char **)extra)[1]; + unsigned line = ((unsigned *)extra)[2]; + snprintf(assert_line, BUFSIZE, "Assertion Failed: %s:%u: %s\r\n", file, line, expr); + ndbout << assert_line; + } + } + /* Check for unknown signal */ + case (OSERRCODE) 0xfffffffe: + { + union SIGNAL *sig = (union SIGNAL *)extra; + SIGSELECT signo = *(SIGSELECT*)sig; + PROCESS rcv_ = current_process(); + PROCESS snd_ = sender(&sig); + struct OS_pcb *rcv = get_pcb(rcv_); + const char *rcv_name = &rcv->strings[rcv->name]; + struct OS_pcb *snd = get_pcb(snd_); + const char *snd_name = &snd->strings[snd->name]; + snprintf(unknown_signal_line, BUFSIZE, + "Unknown Signal Received\r\n"); + snprintf(unknown_signal_line, BUFSIZE, + "Signal Number: 0x%08lx\r\n", signo); + snprintf(unknown_signal_line, BUFSIZE, + "Sending Process: 0x%08lx (%s))\r\n", snd_, snd_name); + snprintf(unknown_signal_line, BUFSIZE, + "Receiving Process: 0x%08lx (%s))\r\n", rcv_, rcv_name); + free_buf((union SIGNAL **)&rcv); + free_buf((union SIGNAL **)&snd); } + ndbout << unknown_signal_line; + ndbout << signal_number_line; + ndbout << sender_line; + ndbout << receiver_line; + } /* switch */ + } /* if */ + + /* Zero means the error has not been fixed by the error handler. */ + error_handled = 0; + return error_handled; +} + +#endif diff --git a/ndb/src/common/util/NdbOut.cpp b/ndb/src/common/util/NdbOut.cpp new file mode 100644 index 00000000000..2624bfa04bd --- /dev/null +++ b/ndb/src/common/util/NdbOut.cpp @@ -0,0 +1,175 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "NdbOut.hpp" +#include +#include +#include +#include +#include + +static FileOutputStream ndbouts_fileoutputstream(stdout); +NdbOut ndbout(ndbouts_fileoutputstream); + +static const char * fms[] = { + "%d", "0x%02x", // Int8 + "%u", "0x%02x", // Uint8 + "%d", "0x%04x", // Int16 + "%u", "0x%04x", // Uint16 + "%d", "0x%08x", // Int32 + "%u", "0x%08x", // Uint32 + "%lld", "0x%016llx", // Int64 + "%llu", "0x%016llx" // Uint64 + "%llu", "0x%016llx" // UintPtr +}; + +NdbOut& +NdbOut::operator<<(Int8 v) { m_out->print(fms[0+isHex],(int)v); return *this;} +NdbOut& +NdbOut::operator<<(Uint8 v) { m_out->print(fms[2+isHex],(int)v); return *this;} +NdbOut& +NdbOut::operator<<(Int16 v) { m_out->print(fms[4+isHex],(int)v); return *this;} +NdbOut& +NdbOut::operator<<(Uint16 v) { m_out->print(fms[6+isHex],(int)v); return *this;} +NdbOut& +NdbOut::operator<<(Int32 v) { m_out->print(fms[8+isHex], v); return *this;} +NdbOut& +NdbOut::operator<<(Uint32 v) { m_out->print(fms[10+isHex], v); return *this;} +NdbOut& +NdbOut::operator<<(Int64 v) { m_out->print(fms[12+isHex], v); return *this;} +NdbOut& +NdbOut::operator<<(Uint64 v) { m_out->print(fms[14+isHex], v); return *this;} +NdbOut& +NdbOut::operator<<(unsigned long int v) { return *this << (Uint64) v; } + +NdbOut& +NdbOut::operator<<(const char* val){ m_out->print("%s", val); return * this; } +NdbOut& +NdbOut::operator<<(const void* val){ m_out->print("%p", val); return * this; } +NdbOut& +NdbOut::operator<<(BaseString &val){ return *this << val.c_str(); } + +NdbOut& +NdbOut::operator<<(float val){ m_out->print("%f", (double)val); return * this;} +NdbOut& +NdbOut::operator<<(double val){ m_out->print("%f", val); return * this; } + +NdbOut& NdbOut::endline() +{ + isHex = 0; // Reset hex to normal, if user forgot this + m_out->println(""); + m_out->flush(); + return *this; +} + +NdbOut& NdbOut::flushline() +{ + m_out->flush(); + return *this; +} + +NdbOut& NdbOut::setHexFormat(int _format) +{ + isHex = (_format == 0 ? 0 : 1); + return *this; +} + +NdbOut::NdbOut(OutputStream & out) + : m_out(& out) +{ + isHex = 0; +} + +NdbOut::~NdbOut() +{ +} + +void +NdbOut::print(const char * fmt, ...){ + va_list ap; + char buf[1000]; + + va_start(ap, fmt); + if (fmt != 0) + vsnprintf(buf, sizeof(buf)-1, fmt, ap); + ndbout << buf; + va_end(ap); +} + +void +NdbOut::println(const char * fmt, ...){ + va_list ap; + char buf[1000]; + + va_start(ap, fmt); + if (fmt != 0) + vsnprintf(buf, sizeof(buf)-1, fmt, ap); + ndbout << buf << endl; + va_end(ap); +} + +extern "C" +void +ndbout_c(const char * fmt, ...){ + va_list ap; + char buf[1000]; + + va_start(ap, fmt); + if (fmt != 0) + vsnprintf(buf, sizeof(buf)-1, fmt, ap); + ndbout << buf << endl; + va_end(ap); +} + +FilteredNdbOut::FilteredNdbOut(OutputStream & out, + int threshold, int level) + : NdbOut(out) { + m_level = level; + m_threshold = threshold; + m_org = &out; + m_null = new NullOutputStream(); + setLevel(level); +} + +FilteredNdbOut::~FilteredNdbOut(){ + delete m_null; +} + +void +FilteredNdbOut::setLevel(int i){ + m_level = i; + if(m_level >= m_threshold){ + m_out = m_org; + } else { + m_out = m_null; + } +} + +void +FilteredNdbOut::setThreshold(int i){ + m_threshold = i; + setLevel(m_level); +} + +int +FilteredNdbOut::getLevel() const { + return m_level; +} +int +FilteredNdbOut::getThreshold() const { + return m_threshold; +} + diff --git a/ndb/src/common/util/NdbSqlUtil.cpp b/ndb/src/common/util/NdbSqlUtil.cpp new file mode 100644 index 00000000000..dba7012cc0f --- /dev/null +++ b/ndb/src/common/util/NdbSqlUtil.cpp @@ -0,0 +1,351 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include + +int +NdbSqlUtil::char_compare(const char* s1, unsigned n1, + const char* s2, unsigned n2, bool padded) +{ + int c1 = 0; + int c2 = 0; + unsigned i = 0; + while (i < n1 || i < n2) { + c1 = i < n1 ? s1[i] : padded ? 0x20 : 0; + c2 = i < n2 ? s2[i] : padded ? 0x20 : 0; + if (c1 != c2) + break; + i++; + } + return c1 - c2; +} + +bool +NdbSqlUtil::char_like(const char* s1, unsigned n1, + const char* s2, unsigned n2, bool padded) +{ + int c1 = 0; + int c2 = 0; + unsigned i1 = 0; + unsigned i2 = 0; + while (i1 < n1 || i2 < n2) { + c1 = i1 < n1 ? s1[i1] : padded ? 0x20 : 0; + c2 = i2 < n2 ? s2[i2] : padded ? 0x20 : 0; + if (c2 == '%') { + while (i2 + 1 < n2 && s2[i2 + 1] == '%') { + i2++; + } + unsigned m = 0; + while (m <= n1 - i1) { + if (char_like(s1 + i1 + m, n1 -i1 - m, + s2 + i2 + 1, n2 - i2 - 1, padded)) + return true; + m++; + } + return false; + } + if (c2 == '_') { + if (c1 == 0) + return false; + } else { + if (c1 != c2) + return false; + } + i1++; + i2++; + } + return i1 == n2 && i2 == n2; +} + +/** + * Data types. + */ + +const NdbSqlUtil::Type +NdbSqlUtil::m_typeList[] = { + { + Type::Undefined, + NULL + }, + { + Type::Tinyint, + cmpTinyint + }, + { + Type::Tinyunsigned, + cmpTinyunsigned + }, + { + Type::Smallint, + cmpSmallint + }, + { + Type::Smallunsigned, + cmpSmallunsigned + }, + { + Type::Mediumint, + NULL // cmpMediumint + }, + { + Type::Mediumunsigned, + NULL // cmpMediumunsigned + }, + { + Type::Int, + cmpInt + }, + { + Type::Unsigned, + cmpUnsigned + }, + { + Type::Bigint, + cmpBigint + }, + { + Type::Bigunsigned, + cmpBigunsigned + }, + { + Type::Float, + cmpFloat + }, + { + Type::Double, + cmpDouble + }, + { + Type::Decimal, + NULL // cmpDecimal + }, + { + Type::Char, + cmpChar + }, + { + Type::Varchar, + cmpVarchar + }, + { + Type::Binary, + NULL // cmpBinary + }, + { + Type::Varbinary, + NULL // cmpVarbinary + }, + { + Type::Datetime, + cmpDatetime + }, + { + Type::Timespec, + NULL // cmpTimespec + } +}; + +const NdbSqlUtil::Type& +NdbSqlUtil::type(Uint32 typeId) +{ + if (typeId < sizeof(m_typeList) / sizeof(m_typeList[0]) && + m_typeList[typeId].m_typeId != Type::Undefined) { + return m_typeList[typeId]; + } + return m_typeList[Type::Undefined]; +} + +// compare + +int +NdbSqlUtil::cmpTinyint(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Tinyint, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpTinyunsigned(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Tinyunsigned, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpSmallint(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Smallint, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpSmallunsigned(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Smallunsigned, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpMediumint(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Mediumint, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpMediumunsigned(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Mediumunsigned, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpInt(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Int, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpUnsigned(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Unsigned, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpBigint(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Bigint, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpBigunsigned(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Bigunsigned, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpFloat(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Float, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpDouble(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Double, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpDecimal(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Decimal, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpChar(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Char, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpVarchar(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Varchar, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpBinary(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Binary, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpVarbinary(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Varbinary, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpDatetime(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Datetime, p1, p2, full, size); +} + +int +NdbSqlUtil::cmpTimespec(const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size) +{ + return cmp(Type::Timespec, p1, p2, full, size); +} + +#ifdef NDB_SQL_UTIL_TEST + +#include +#include +#include + +struct Testcase { + int op; // 1=compare 2=like + int res; + const char* s1; + const char* s2; + int pad; +}; +const Testcase testcase[] = { + { 2, 1, "abc", "abc", 0 }, + { 2, 1, "abc", "abc%", 0 }, + { 2, 1, "abcdef", "abc%", 0 }, + { 2, 1, "abcdefabcdefabcdef", "abc%", 0 }, + { 2, 1, "abcdefabcdefabcdef", "abc%f", 0 }, + { 2, 0, "abcdefabcdefabcdef", "abc%z", 0 }, + { 2, 1, "abcdefabcdefabcdef", "%f", 0 }, + { 2, 1, "abcdef", "a%b%c%d%e%f", 0 }, + { 0, 0, 0, 0 } +}; + +int +main(int argc, char** argv) +{ + unsigned count = argc > 1 ? atoi(argv[1]) : 1000000; + ndbout_c("count = %u", count); + assert(count != 0); + for (const Testcase* t = testcase; t->s1 != 0; t++) { + ndbout_c("%d = '%s' %s '%s' pad=%d", + t->res, t->s1, t->op == 1 ? "comp" : "like", t->s2); + NDB_TICKS x1 = NdbTick_CurrentMillisecond(); + unsigned n1 = strlen(t->s1); + unsigned n2 = strlen(t->s2); + for (unsigned i = 0; i < count; i++) { + if (t->op == 1) { + int res = NdbSqlUtil::char_compare(t->s1, n1, t->s2, n2, t->pad); + assert(res == t->res); + continue; + } + if (t->op == 2) { + int res = NdbSqlUtil::char_like(t->s1, n1, t->s2, n2, t->pad); + assert(res == t->res); + continue; + } + assert(false); + } + NDB_TICKS x2 = NdbTick_CurrentMillisecond(); + if (x2 < x1) + x2 = x1; + double usec = 1000000.0 * double(x2 - x1) / double(count); + ndbout_c("time %.0f usec per call", usec); + } + // quick check + for (unsigned i = 0; i < sizeof(m_typeList) / sizeof(m_typeList[0]); i++) { + const NdbSqlUtil::Type& t = m_typeList[i]; + assert(t.m_typeId == i); + } + return 0; +} + +#endif diff --git a/ndb/src/common/util/OutputStream.cpp b/ndb/src/common/util/OutputStream.cpp new file mode 100644 index 00000000000..1143fe00fd1 --- /dev/null +++ b/ndb/src/common/util/OutputStream.cpp @@ -0,0 +1,98 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include + +FileOutputStream::FileOutputStream(FILE * file){ + f = file; +} + +int +FileOutputStream::print(const char * fmt, ...){ + va_list ap; + va_start(ap, fmt); + const int ret = vfprintf(f, fmt, ap); + va_end(ap); + return ret; +} + +int +FileOutputStream::println(const char * fmt, ...){ + va_list ap; + va_start(ap, fmt); + const int ret = vfprintf(f, fmt, ap); + va_end(ap); + return ret + fprintf(f, "\n"); +} + +SocketOutputStream::SocketOutputStream(NDB_SOCKET_TYPE socket, + unsigned timeout){ + m_socket = socket; + m_timeout = timeout; +} + +int +SocketOutputStream::print(const char * fmt, ...){ + va_list ap; + va_start(ap, fmt); + const int ret = vprint_socket(m_socket, m_timeout, fmt, ap); + va_end(ap); + return ret; +} +int +SocketOutputStream::println(const char * fmt, ...){ + va_list ap; + va_start(ap, fmt); + const int ret = vprintln_socket(m_socket, m_timeout, fmt, ap); + va_end(ap); + return ret; +} + +#ifdef NDB_SOFTOSE +#include +int +SoftOseOutputStream::print(const char * fmt, ...){ + va_list ap; + char buf[1000]; + + va_start(ap, fmt); + if (fmt != 0) + vsnprintf(buf, sizeof(buf)-1, fmt, ap); + else + buf[0] = 0; + va_end(ap); + dbgprintf(buf); +} + +int +SoftOseOutputStream::println(const char * fmt, ...){ + va_list ap; + char buf[1000]; + + va_start(ap, fmt); + if (fmt != 0) + vsnprintf(buf, sizeof(buf)-1, fmt, ap); + else + buf[0] = 0; + va_end(ap); + + strcat(buf, "\n\r"); + dbgprintf(buf); +} +#endif diff --git a/ndb/src/common/util/Parser.cpp b/ndb/src/common/util/Parser.cpp new file mode 100644 index 00000000000..d5c23fe14c1 --- /dev/null +++ b/ndb/src/common/util/Parser.cpp @@ -0,0 +1,349 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include "Parser.hpp" +#include +#include +#include +#include +#include +#include + +#define DEBUG(x) ndbout << x << endl; + +static void trim(char * str); + +class ParseInputStream : public InputStream { +public: + ParseInputStream(InputStream & in, bool trim = true, char eofComment = '#'); + + char* gets(char * buf, int bufLen); + void push_back(const char *); +private: + InputStream & in; + char * buffer; +}; + +ParseInputStream::ParseInputStream(InputStream & _in, + bool /* unused */, + char /* unused */) + : in(_in){ + buffer = 0; +} + +char* +ParseInputStream::gets(char * buf, int bufLen){ + if(buffer != 0){ + strncpy(buf, buffer, bufLen); + free(buffer); + buffer = 0; + return buf; + } + char *t = in.gets(buf, bufLen); + return t; +} + +void +ParseInputStream::push_back(const char * str){ + if(buffer != 0) + abort(); + buffer = strdup(str); +} + +ParserImpl::ParserImpl(const DummyRow * rows, InputStream & in, + bool b_cmd, bool b_empty, bool b_iarg) + : m_rows(rows), input(* new ParseInputStream(in)) +{ + m_breakOnCmd = b_cmd; + m_breakOnEmpty = b_empty; + m_breakOnInvalidArg = b_iarg; +} + +ParserImpl::~ParserImpl(){ + delete & input; +} + +static +bool +Empty(const char * str){ + if(str == 0) + return true; + const int len = strlen(str); + if(len == 0) + return false; + for(int i = 0; im_insensitive = value; + if(value) + impl->compare = strcasecmp; + else + impl->compare = strcmp; +} + +bool +Properties::getCaseInsensitiveNames() const { + return impl->m_insensitive; +} diff --git a/ndb/src/common/util/SimpleProperties.cpp b/ndb/src/common/util/SimpleProperties.cpp new file mode 100644 index 00000000000..a118478ba6c --- /dev/null +++ b/ndb/src/common/util/SimpleProperties.cpp @@ -0,0 +1,509 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include +#include +#include + +bool +SimpleProperties::Writer::first(){ + return reset(); +} + +bool +SimpleProperties::Writer::add(Uint16 key, Uint32 value){ + Uint32 head = Uint32Value; + head <<= 16; + head += key; + if(!putWord(htonl(head))) + return false; + + return putWord(htonl(value)); +} + +bool +SimpleProperties::Writer::add(Uint16 key, const char * value){ + Uint32 head = StringValue; + head <<= 16; + head += key; + if(!putWord(htonl(head))) + return false; + Uint32 strLen = strlen(value) + 1; // Including NULL-byte + if(!putWord(htonl(strLen))) + return false; + + const Uint32 valLen = (strLen + 3) / 4; + return putWords((Uint32*)value, valLen); +} + +bool +SimpleProperties::Writer::add(Uint16 key, const void* value, int len){ + Uint32 head = BinaryValue; + head <<= 16; + head += key; + if(!putWord(htonl(head))) + return false; + if(!putWord(htonl(len))) + return false; + + const Uint32 valLen = (len + 3) / 4; + return putWords((Uint32*)value, valLen); +} + +SimpleProperties::Reader::Reader(){ + m_itemLen = 0; +} + +bool +SimpleProperties::Reader::first(){ + reset(); + m_itemLen = 0; + return readValue(); +} + +bool +SimpleProperties::Reader::next(){ + return readValue(); +} + +bool +SimpleProperties::Reader::valid() const { + return m_type != InvalidValue; +} + +Uint16 +SimpleProperties::Reader::getKey() const{ + return m_key; +} + +Uint16 +SimpleProperties::Reader::getValueLen() const { + switch(m_type){ + case Uint32Value: + return 4; + case StringValue: + case BinaryValue: + return m_strLen; + case InvalidValue: + return 0; + } + return 0; +} + +SimpleProperties::ValueType +SimpleProperties::Reader::getValueType() const { + return m_type; +} + +Uint32 +SimpleProperties::Reader::getUint32() const { + return m_ui32_value; +} + +char * +SimpleProperties::Reader::getString(char * dst) const { + if(peekWords((Uint32*)dst, m_itemLen)) + return dst; + return 0; +} + +bool +SimpleProperties::Reader::readValue(){ + if(!step(m_itemLen)){ + m_type = InvalidValue; + return false; + } + + Uint32 tmp; + if(!getWord(&tmp)){ + m_type = InvalidValue; + return false; + } + + tmp = ntohl(tmp); + m_key = tmp & 0xFFFF; + m_type = (SimpleProperties::ValueType)(tmp >> 16); + switch(m_type){ + case Uint32Value: + m_itemLen = 1; + if(!peekWord(&m_ui32_value)) + return false; + m_ui32_value = ntohl(m_ui32_value); + return true; + case StringValue: + case BinaryValue: + if(!getWord(&tmp)) + return false; + m_strLen = ntohl(tmp); + m_itemLen = (m_strLen + 3)/4; + return true; + default: + m_itemLen = 0; + m_type = InvalidValue; + return false; + } +} + +SimpleProperties::UnpackStatus +SimpleProperties::unpack(Reader & it, void * dst, + const SP2StructMapping _map[], Uint32 mapSz, + bool ignoreMinMax, + bool ignoreUnknownKeys){ + do { + if(!it.valid()) + break; + + bool found = false; + Uint16 key = it.getKey(); + for(Uint32 i = 0; i _map[i].maxValue) + return ValueTooHigh; + } + * ((Uint32 *)_dst) = val; + break; + } + case BinaryValue: + case StringValue:{ + unsigned len = it.getValueLen(); + if(len < _map[i].minValue) + return ValueTooLow; + if(len > _map[i].maxValue) + return ValueTooHigh; + it.getString(_dst); + break; + } + default: + abort(); + } + break; + } + } + if(!found && !ignoreUnknownKeys) + return UnknownKey; + } while(it.next()); + + return Eof; +} + +SimpleProperties::UnpackStatus +SimpleProperties::pack(Writer & it, const void * __src, + const SP2StructMapping _map[], Uint32 mapSz, + bool ignoreMinMax){ + + const char * _src = (const char *)__src; + + for(Uint32 i = 0; i _map[i].maxValue) + return ValueTooHigh; + } + ok = it.add(_map[i].Key, val); + } + break; + case SimpleProperties::BinaryValue:{ + const char * src_len = _src + _map[i].Length_Offset; + Uint32 len = *((Uint32*)src_len); + if(!ignoreMinMax){ + if(len == _map[i].maxValue) + return ValueTooHigh; + } + ok = it.add(_map[i].Key, src, len); + break; + } + case SimpleProperties::StringValue: + if(!ignoreMinMax){ + size_t len = strlen(src); + if(len == _map[i].maxValue) + return ValueTooHigh; + } + ok = it.add(_map[i].Key, src); + break; + } + if(!ok) + return OutOfMemory; + } + + return Eof; +} + +void +SimpleProperties::Reader::printAll(NdbOut& ndbout){ + char tmp[1024]; + for(first(); valid(); next()){ + switch(getValueType()){ + case SimpleProperties::Uint32Value: + ndbout << "Key: " << getKey() + << " value(" << getValueLen() << ") : " + << getUint32() << endl; + break; + case SimpleProperties::BinaryValue: + case SimpleProperties::StringValue: + if(getValueLen() < 1024){ + getString(tmp); + ndbout << "Key: " << getKey() + << " value(" << getValueLen() << ") : " + << "\"" << tmp << "\"" << endl; + } else { + ndbout << "Key: " << getKey() + << " value(" << getValueLen() << ") : " + << "\"" << "" << "\"" << endl; + + } + break; + default: + ndbout << "Unknown type for key: " << getKey() + << " type: " << getValueType() << endl; + } + } +} + +SimplePropertiesLinearReader::SimplePropertiesLinearReader +(const Uint32 * src, Uint32 len){ + m_src = src; + m_len = len; + m_pos = 0; + first(); +} + +void +SimplePropertiesLinearReader::reset() { + m_pos = 0; +} + +bool +SimplePropertiesLinearReader::step(Uint32 len){ + m_pos += len; + return m_pos < m_len; +} + +bool +SimplePropertiesLinearReader::getWord(Uint32 * dst) { + if(m_pos 0;} + +bool +LinearWriter::putWord(Uint32 val){ + if(m_pos < m_len){ + m_src[m_pos++] = val; + return true; + } + return false; +} + +bool +LinearWriter::putWords(const Uint32 * src, Uint32 len){ + if(m_pos + len <= m_len){ + memcpy(&m_src[m_pos], src, 4 * len); + m_pos += len; + return true; + } + return false; +} + +Uint32 +LinearWriter::getWordsUsed() const { return m_pos;} + +UtilBufferWriter::UtilBufferWriter(UtilBuffer & b) + : m_buf(b) +{ + reset(); +} + +bool UtilBufferWriter::reset() { m_buf.clear(); return true;} + +bool +UtilBufferWriter::putWord(Uint32 val){ + return (m_buf.append(&val, 4) == 0); +} + +bool +UtilBufferWriter::putWords(const Uint32 * src, Uint32 len){ + return (m_buf.append(src, 4 * len) == 0); +} + +Uint32 +UtilBufferWriter::getWordsUsed() const { return m_buf.length() / 4;} + +#if 0 +LinearPagesReader::LinearPagesReader(const Uint32 * base, + Uint32 pageSize, + Uint32 headerSize, + Uint32 noOfPages, + Uint32 len){ + m_base = base; + m_pageSz = pageSize; + m_noOfPages = noOfPages; + m_pageHeaderSz = headerSize; + m_len = len; + reset(); +} + +void +LinearPagesReader::reset() { m_pos = 0;} + +bool +LinearPagesReader::step(Uint32 len){ + m_pos += len; + return m_pos < m_len; +} + +bool +LinearPagesReader::getWord(Uint32 * dst) { + if(m_pos +#include +#include +#include +#include + +#include +#include + +#define DEBUG(x) ndbout << x << endl; + +SocketServer::SocketServer(int maxSessions) : + m_sessions(10), + m_services(5) +{ + m_thread = 0; + m_stopThread = false; + m_maxSessions = maxSessions; +} + +SocketServer::~SocketServer() { + for(unsigned i = 0; i s ? maxSock : s); + } + struct timeval timeout; + timeout.tv_sec = 1; + timeout.tv_usec = 0; + + if(select(maxSock + 1, &readSet, 0, &exceptionSet, &timeout) > 0){ + for (unsigned i = 0; i < m_services.size(); i++){ + ServiceInstance & si = m_services[i]; + + if(FD_ISSET(si.m_socket, &readSet)){ + + NDB_SOCKET_TYPE childSock = accept(si.m_socket, 0, 0); + if(childSock == NDB_INVALID_SOCKET){ + continue; + } + + SessionInstance s; + s.m_service = si.m_service; + s.m_session = si.m_service->newSession(childSock); + if(s.m_session != 0){ + m_sessions.push_back(s); + startSession(m_sessions.back()); + } + + continue; + } + + if(FD_ISSET(si.m_socket, &exceptionSet)){ + DEBUG("socket in the exceptionSet"); + continue; + } + } + } + m_services.unlock(); +} + +extern "C" +void* +socketServerThread_C(void* _ss){ + SocketServer * ss = (SocketServer *)_ss; + + ss->doRun(); + + NdbThread_Exit(0); + return 0; +} + +void +SocketServer::startServer(){ + m_threadLock.lock(); + if(m_thread == 0 && m_stopThread == false){ + m_thread = NdbThread_Create(socketServerThread_C, + (void**)this, + 32768, + "NdbSockServ", + NDB_THREAD_PRIO_LOW); + } + m_threadLock.unlock(); +} + +void +SocketServer::stopServer(){ + m_threadLock.lock(); + if(m_thread != 0){ + m_stopThread = true; + + void * res; + NdbThread_WaitFor(m_thread, &res); + NdbThread_Destroy(&m_thread); + m_thread = 0; + } + m_threadLock.unlock(); +} + +void +SocketServer::doRun(){ + + while(!m_stopThread){ + checkSessions(); + if(m_sessions.size() < m_maxSessions){ + doAccept(); + } else { + NdbSleep_MilliSleep(200); + } + } +} + +void +SocketServer::startSession(SessionInstance & si){ + si.m_thread = NdbThread_Create(sessionThread_C, + (void**)si.m_session, + 32768, + "NdbSock_Session", + NDB_THREAD_PRIO_LOW); +} + +static +bool +transfer(NDB_SOCKET_TYPE sock){ +#if defined NDB_OSE || defined NDB_SOFTOSE + const PROCESS p = current_process(); + const size_t ps = sizeof(PROCESS); + int res = setsockopt(sock, SOL_SOCKET, SO_OSEOWNER, &p, ps); + if(res != 0){ + ndbout << "Failed to transfer ownership of socket" << endl; + return false; + } +#endif + return true; +} + +void +SocketServer::checkSessions(){ + for(int i = m_sessions.size() - 1; i >= 0; i--){ + if(m_sessions[i].m_session->m_stopped){ + if(m_sessions[i].m_thread != 0){ + void* ret; + NdbThread_WaitFor(m_sessions[i].m_thread, &ret); + NdbThread_Destroy(&m_sessions[i].m_thread); + } + m_sessions[i].m_session->stopSession(); + delete m_sessions[i].m_session; + m_sessions.erase(i); + } + } +} + +void +SocketServer::stopSessions(bool wait){ + for(int i = m_sessions.size() - 1; i>=0; i--) + m_sessions[i].m_session->m_stop = true; + + for(int i = m_services.size() - 1; i>=0; i--) + m_services[i].m_service->stopSessions(); + + if(wait){ + while(m_sessions.size() > 0){ + checkSessions(); + NdbSleep_MilliSleep(100); + } + } +} + +/***** Session code ******/ + +extern "C" +void* +sessionThread_C(void* _sc){ + SocketServer::Session * si = (SocketServer::Session *)_sc; + + if(!transfer(si->m_socket)){ + si->m_stopped = true; + NdbThread_Exit(0); + return 0; + } + + if(!si->m_stop){ + si->m_stopped = false; + si->runSession(); + } else { + NDB_CLOSE_SOCKET(si->m_socket); + } + + si->m_stopped = true; + NdbThread_Exit(0); + return 0; +} diff --git a/ndb/src/common/util/filetest/FileUnitTest.cpp b/ndb/src/common/util/filetest/FileUnitTest.cpp new file mode 100644 index 00000000000..ebcca26d3d2 --- /dev/null +++ b/ndb/src/common/util/filetest/FileUnitTest.cpp @@ -0,0 +1,238 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "FileUnitTest.hpp" +#include + +#include +#include + +typedef bool (*TESTFUNC)(const char*); + +typedef const char TESTNAME; +typedef struct +{ + const char* name; + TESTFUNC test; +}Tests; + +static Tests testCases[] = { {"Create/Write", &FileUnitTest::testWrite}, + {"Read", &FileUnitTest::testRead}, + {"Exists", &FileUnitTest::testExists}, + {"File Size", &FileUnitTest::testSize}, + {"Rename", &FileUnitTest::testRename}, + {"Remove", &FileUnitTest::testRemove} }; + +static int testFailed = 0; + +int main(int argc, char* argv[]) +{ + if (argc < 2) + { + ndbout << "Usage: filetest " << endl; + return 0; + } + const char* fileName = argv[1]; + + int testCount = (sizeof(testCases) / sizeof(Tests)); + ndbout << "Starting " << testCount << " tests..." << endl; + for (int i = 0; i < testCount; i++) + { + ndbout << "-- " << " Test " << i + 1 + << " [" << testCases[i].name << "] --" << endl; + if (testCases[i].test(fileName)) + { + ndbout << "-- Passed --" << endl; + } + else + { + ndbout << "-- Failed -- " << endl; + } + + } + ndbout << endl << "-- " << testCount - testFailed << " passed, " + << testFailed << " failed --" << endl; + return 0; +} + + +bool +FileUnitTest::testWrite(const char* aFileName) +{ + bool rc = true; + File f; + if (f.open(aFileName, "w")) + { + f.writeChar("ABABABABABAB ABBABAB ABBABA ABAB JKH KJHA JHHAHAH..."); + f.writeChar("12129791242 1298371923 912738912 378129837128371128132...\n"); + f.close(); + } + else + { + error("testWrite failed: "); + rc = false; + } + return rc; +} + +bool +FileUnitTest::testRead(const char* aFileName) +{ + bool rc = true; + // Read file + File f; + if (f.open(aFileName, "r")) + { + long size = f.size(); + ndbout << "File size = " << size << endl; + ndbout << "Allocating buf of " << size << " bytes" << endl; + char* buf = new char[size]; + buf[size - 1] = '\0'; + int r = 0; + while ((r = f.readChar(buf, r, size)) > 0) + { + ndbout << "Read(" << r << "):" << buf << endl; + } + f.close(); + delete buf; + } + else + { + error("readTest failed: "); + rc = false; + } + return rc; +} + +bool +FileUnitTest::testExists(const char* aFileName) +{ + bool rc = true; + if (File::exists(aFileName)) + { + if (File::exists("ThisFileShouldnotbe.txt")) + { + rc = false; + error("testExists failed, the file should NOT be found."); + } + } + else + { + rc = false; + error("testExists failed, the file should exist."); + } + + return rc; +} + + +bool +FileUnitTest::testSize(const char* aFileName) +{ + bool rc = true; + File f; + if (f.open(aFileName, "r")) + { + long size = f.size(); + if (size <= 0) + { + rc = false; + error("testSize failed, size is <= 0"); + } + ndbout << "File size = " << size << endl; + } + else + { + rc = false; + error("testSize failed, could no open file."); + } + f.close(); + return rc; +} + +bool +FileUnitTest::testRename(const char* aFileName) +{ + bool rc = true; + if (File::rename(aFileName, "filetest_new.txt")) + { + if (!File::exists("filetest_new.txt")) + { + rc = false; + error("testRename failed, new file does not exists."); + } + else + { + ndbout << "Renamed " << aFileName << " to filetest_new.txt" << endl; + } + } + else + { + rc = false; + error("testRename failed, unable to rename file."); + } + + return rc; +} + +bool +FileUnitTest::testRemove(const char* aFileName) +{ + bool rc = true; + File f; + if (f.open("filetest_new.txt", "r")) + { + if (!f.remove()) + { + rc = false; + error("testRemove failed, could not remove file."); + } + else + { + if (File::exists("filetest_new")) + { + rc = false; + error("testRemove failed, file was not removed, it still exists."); + } + } + } // (f.open("filetest_new", "r")) + else + { + rc = false; + error("testRemove failed, could not read the file."); + } + + return rc; +} + +void +FileUnitTest::error(const char* msg) +{ + testFailed++; + ndbout << "Test failed: " << msg << endl; + perror("Errno msg"); +} + + +FileUnitTest::FileUnitTest() +{ + +} + +FileUnitTest::~FileUnitTest() +{ + +} diff --git a/ndb/src/common/util/filetest/FileUnitTest.hpp b/ndb/src/common/util/filetest/FileUnitTest.hpp new file mode 100644 index 00000000000..a589615e9b2 --- /dev/null +++ b/ndb/src/common/util/filetest/FileUnitTest.hpp @@ -0,0 +1,41 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef FILEUNITTEST_H +#define FILEUNITTEST_H + +/** + * Unit test of File. + * + * @version #@ $Id: FileUnitTest.hpp,v 1.1 2002/03/13 18:09:03 eyualex Exp $ + */ +class FileUnitTest +{ +public: + static bool testWrite(const char* aFileName); + static bool testRead(const char* aFileName); + static bool testExists(const char* aFileName); + static bool testSize(const char* aFileName); + static bool testRename(const char* aFileName); + static bool testRemove(const char* aFileName); + + static void error(const char* msg); +private: + FileUnitTest(); + ~FileUnitTest(); + +}; +#endif diff --git a/ndb/src/common/util/filetest/Makefile b/ndb/src/common/util/filetest/Makefile new file mode 100644 index 00000000000..fe1842921f9 --- /dev/null +++ b/ndb/src/common/util/filetest/Makefile @@ -0,0 +1,14 @@ +include .defs.mk + +TYPE := + +BIN_TARGET := filetest +BIN_TARGET_ARCHIVES := portlib general + +SOURCES := FileUnitTest.cpp + +CCFLAGS_LOC += -I$(NDB_TOP)/include/logger -I$(NDB_TOP)/include/portlib + +include $(NDB_TOP)/Epilogue.mk + + diff --git a/ndb/src/common/util/getarg.3 b/ndb/src/common/util/getarg.3 new file mode 100644 index 00000000000..43aae5d7b31 --- /dev/null +++ b/ndb/src/common/util/getarg.3 @@ -0,0 +1,315 @@ +.\" Copyright (c) 1999 Kungliga Tekniska Högskolan +.\" $KTH: getarg.3,v 1.1.4.1 2001/07/26 19:54:45 lha Exp $ +.Dd September 24, 1999 +.Dt GETARG 3 +.Os ROKEN +.Sh NAME +.Nm getarg , +.Nm arg_printusage +.Nd collect command line options +.Sh SYNOPSIS +.Fd #include + +.Ft int +.Fn getarg "struct getargs *args" "size_t num_args" "int argc" "char **argv" "int *optind" + +.Ft void +.Fn arg_printusage "struct getargs *args" "size_t num_args" "const char *progname" "const char *extra_string" + +.Sh DESCRIPTION +.Fn getarg +collects any command line options given to a program in an easily used way. +.Fn arg_printusage +pretty-prints the available options, with a short help text. +.Pp +.Fa args +is the option specification to use, and it's an array of +.Fa struct getargs +elements. +.Fa num_args +is the size of +.Fa args +(in elements). +.Fa argc +and +.Fa argv +are the argument count and argument vector to extract option from. +.Fa optind +is a pointer to an integer where the index to the last processed +argument is stored, it must be initialised to the first index (minus +one) to process (normally 0) before the first call. +.Pp +.Fa arg_printusage +take the same +.Fa args +and +.Fa num_args +as getarg; +.Fa progname is the name of the program (to be used in the help text), and +.Fa extra_string +is a string to print after the actual options to indicate more +arguments. The usefulness of this function is realised only be people +who has used programs that has help strings that doesn't match what +the code does. +.Pp +The +.Fa getargs +struct has the following elements. + +.Bd -literal +struct getargs{ + const char *long_name; + char short_name; + enum { arg_integer, + arg_string, + arg_flag, + arg_negative_flag, + arg_strings, + arg_double, + arg_collect + } type; + void *value; + const char *help; + const char *arg_help; +}; +.Ed +.Pp +.Fa long_name +is the long name of the option, it can be +.Dv NULL , +if you don't want a long name. +.Fa short_name +is the characted to use as short option, it can be zero. If the option +has a value the +.Fa value +field gets filled in with that value interpreted as specified by the +.Fa type +field. +.Fa help +is a longer help string for the option as a whole, if it's +.Dv NULL +the help text for the option is omitted (but it's still displayed in +the synopsis). +.Fa arg_help +is a description of the argument, if +.Dv NULL +a default value will be used, depending on the type of the option: +.Pp +.Bl -hang -width arg_negative_flag +.It arg_integer +the argument is a signed integer, and +.Fa value +should point to an +.Fa int . +.It Fa arg_string +the argument is a string, and +.Fa value +should point to a +.Fa char* . +.It Fa arg_flag +the argument is a flag, and +.Fa value +should point to a +.Fa int . +It gets filled in with either zero or one, depending on how the option +is given, the normal case beeing one. Note that if the option isn't +given, the value isn't altered, so it should be initialised to some +useful default. +.It Fa arg_negative_flag +this is the same as +.Fa arg_flag +but it reverses the meaning of the flag (a given short option clears +the flag), and the synopsis of a long option is negated. +.It Fa arg_strings +the argument can be given multiple times, and the values are collected +in an array; +.Fa value +should be a pointer to a +.Fa struct getarg_strings +structure, which holds a length and a string pointer. +.It Fa arg_double +argument is a double precision floating point value, and +.Fa value +should point to a +.Fa double . +.It Fa arg_collect +allows more fine-grained control of the option parsing process. +.Fa value +should be a pointer to a +.Fa getarg_collect_info +structure: +.Bd -literal +typedef int (*getarg_collect_func)(int short_opt, + int argc, + char **argv, + int *optind, + int *optarg, + void *data); + +typedef struct getarg_collect_info { + getarg_collect_func func; + void *data; +} getarg_collect_info; +.Ed +.Pp +With the +.Fa func +member set to a function to call, and +.Fa data +to some application specific data. The parameters to the collect function are: +.Bl -inset +.It Fa short_flag +non-zero if this call is via a short option flag, zero otherwise +.It Fa argc , argv +the whole argument list +.It Fa optind +pointer to the index in argv where the flag is +.It Fa optarg +pointer to the index in argv[*optind] where the flag name starts +.It Fa data +application specific data +.El +.Pp +You can modify +.Fa *optind , +and +.Fa *optarg , +but to do this correct you (more or less) have to know about the inner +workings of getarg. + +You can skip parts of arguments by increasing +.Fa *optarg +(you could +implement the +.Fl z Ns Ar 3 +set of flags from +.Nm gzip +with this), or whole argument strings by increasing +.Fa *optind +(let's say you want a flag +.Fl c Ar x y z +to specify a coordinate); if you also have to set +.Fa *optarg +to a sane value. +.Pp +The collect function should return one of +.Dv ARG_ERR_NO_MATCH , ARG_ERR_BAD_ARG , ARG_ERR_NO_ARG +on error, zero otherwise. +.Pp +For your convenience there is a function, +.Fn getarg_optarg , +that returns the traditional argument string, and you pass it all +arguments, sans data, that where given to the collection function. +.Pp +Don't use this more this unless you absolutely have to. +.El +.Pp +Option parsing is similar to what +.Xr getopt +uses. Short options without arguments can be compressed +.Pf ( Fl xyz +is the same as +.Fl x y z ) , +and short +options with arguments take these as either the rest of the +argv-string or as the next option +.Pf ( Fl o Ns Ar foo , +or +.Fl o Ar foo ) . +.Pp +Long option names are prefixed with -- (double dash), and the value +with a = (equal), +.Fl -foo= Ns Ar bar . +Long option flags can either be specified as they are +.Pf ( Fl -help ) , +or with an (boolean parsable) option +.Pf ( Fl -help= Ns Ar yes , +.Fl -help= Ns Ar true , +or similar), or they can also be negated +.Pf ( Fl -no-help +is the same as +.Fl -help= Ns no ) , +and if you're really confused you can do it multiple times +.Pf ( Fl -no-no-help= Ns Ar false , +or even +.Fl -no-no-help= Ns Ar maybe ) . +.Sh EXAMPLE +.Bd -literal +#include +#include +#include + +char *source = "Ouagadougou"; +char *destination; +int weight; +int include_catalog = 1; +int help_flag; + +struct getargs args[] = { + { "source", 's', arg_string, &source, + "source of shippment", "city" }, + { "destination", 'd', arg_string, &destination, + "destination of shippment", "city" }, + { "weight", 'w', arg_integer, &weight, + "weight of shippment", "tons" }, + { "catalog", 'c', arg_negative_flag, &include_catalog, + "include product catalog" }, + { "help", 'h', arg_flag, &help_flag } +}; + +int num_args = sizeof(args) / sizeof(args[0]); /* number of elements in args */ + +const char *progname = "ship++"; + +int +main(int argc, char **argv) +{ + int optind = 0; + if (getarg(args, num_args, argc, argv, &optind)) { + arg_printusage(args, num_args, progname, "stuff..."); + exit (1); + } + if (help_flag) { + arg_printusage(args, num_args, progname, "stuff..."); + exit (0); + } + if (destination == NULL) { + fprintf(stderr, "%s: must specify destination\n", progname); + exit(1); + } + if (strcmp(source, destination) == 0) { + fprintf(stderr, "%s: destination must be different from source\n"); + exit(1); + } + /* include more stuff here ... */ + exit(2); +} +.Ed +.Pp +The output help output from this program looks like this: +.Bd -literal +$ ship++ --help +Usage: ship++ [--source=city] [-s city] [--destination=city] [-d city] + [--weight=tons] [-w tons] [--no-catalog] [-c] [--help] [-h] stuff... +-s city, --source=city source of shippment +-d city, --destination=city destination of shippment +-w tons, --weight=tons weight of shippment +-c, --no-catalog include product catalog +.Ed + +.Sh BUGS +It should be more flexible, so it would be possible to use other more +complicated option syntaxes, such as what +.Xr ps 1 , +and +.Xr tar 1 , +uses, or the AFS model where you can skip the flag names as long as +the options come in the correct order. +.Pp +Options with multiple arguments should be handled better. +.Pp +Should be integreated with SL. +.Pp +It's very confusing that the struct you pass in is called getargS. +.Sh SEE ALSO +.Xr getopt 3 diff --git a/ndb/src/common/util/getarg.3.ps b/ndb/src/common/util/getarg.3.ps new file mode 100644 index 00000000000..146fb8e4961 --- /dev/null +++ b/ndb/src/common/util/getarg.3.ps @@ -0,0 +1,458 @@ +%!PS-Adobe-3.0 +%%Creator: groff version 1.15 +%%CreationDate: Thu Nov 7 12:53:13 2002 +%%DocumentNeededResources: font Times-Roman +%%+ font Times-Bold +%%+ font Courier-Bold +%%+ font Courier-Oblique +%%+ font Symbol +%%+ font Courier +%%DocumentSuppliedResources: procset grops 1.15 0 +%%Pages: 4 +%%PageOrder: Ascend +%%Orientation: Portrait +%%EndComments +%%BeginProlog +%%BeginResource: procset grops 1.15 0 +/setpacking where{ +pop +currentpacking +true setpacking +}if +/grops 120 dict dup begin +/SC 32 def +/A/show load def +/B{0 SC 3 -1 roll widthshow}bind def +/C{0 exch ashow}bind def +/D{0 exch 0 SC 5 2 roll awidthshow}bind def +/E{0 rmoveto show}bind def +/F{0 rmoveto 0 SC 3 -1 roll widthshow}bind def +/G{0 rmoveto 0 exch ashow}bind def +/H{0 rmoveto 0 exch 0 SC 5 2 roll awidthshow}bind def +/I{0 exch rmoveto show}bind def +/J{0 exch rmoveto 0 SC 3 -1 roll widthshow}bind def +/K{0 exch rmoveto 0 exch ashow}bind def +/L{0 exch rmoveto 0 exch 0 SC 5 2 roll awidthshow}bind def +/M{rmoveto show}bind def +/N{rmoveto 0 SC 3 -1 roll widthshow}bind def +/O{rmoveto 0 exch ashow}bind def +/P{rmoveto 0 exch 0 SC 5 2 roll awidthshow}bind def +/Q{moveto show}bind def +/R{moveto 0 SC 3 -1 roll widthshow}bind def +/S{moveto 0 exch ashow}bind def +/T{moveto 0 exch 0 SC 5 2 roll awidthshow}bind def +/SF{ +findfont exch +[exch dup 0 exch 0 exch neg 0 0]makefont +dup setfont +[exch/setfont cvx]cvx bind def +}bind def +/MF{ +findfont +[5 2 roll +0 3 1 roll +neg 0 0]makefont +dup setfont +[exch/setfont cvx]cvx bind def +}bind def +/level0 0 def +/RES 0 def +/PL 0 def +/LS 0 def +/MANUAL{ +statusdict begin/manualfeed true store end +}bind def +/PLG{ +gsave newpath clippath pathbbox grestore +exch pop add exch pop +}bind def +/BP{ +/level0 save def +1 setlinecap +1 setlinejoin +72 RES div dup scale +LS{ +90 rotate +}{ +0 PL translate +}ifelse +1 -1 scale +}bind def +/EP{ +level0 restore +showpage +}bind def +/DA{ +newpath arcn stroke +}bind def +/SN{ +transform +.25 sub exch .25 sub exch +round .25 add exch round .25 add exch +itransform +}bind def +/DL{ +SN +moveto +SN +lineto stroke +}bind def +/DC{ +newpath 0 360 arc closepath +}bind def +/TM matrix def +/DE{ +TM currentmatrix pop +translate scale newpath 0 0 .5 0 360 arc closepath +TM setmatrix +}bind def +/RC/rcurveto load def +/RL/rlineto load def +/ST/stroke load def +/MT/moveto load def +/CL/closepath load def +/FL{ +currentgray exch setgray fill setgray +}bind def +/BL/fill load def +/LW/setlinewidth load def +/RE{ +findfont +dup maxlength 1 index/FontName known not{1 add}if dict begin +{ +1 index/FID ne{def}{pop pop}ifelse +}forall +/Encoding exch def +dup/FontName exch def +currentdict end definefont pop +}bind def +/DEFS 0 def +/EBEGIN{ +moveto +DEFS begin +}bind def +/EEND/end load def +/CNT 0 def +/level1 0 def +/PBEGIN{ +/level1 save def +translate +div 3 1 roll div exch scale +neg exch neg exch translate +0 setgray +0 setlinecap +1 setlinewidth +0 setlinejoin +10 setmiterlimit +[]0 setdash +/setstrokeadjust where{ +pop +false setstrokeadjust +}if +/setoverprint where{ +pop +false setoverprint +}if +newpath +/CNT countdictstack def +userdict begin +/showpage{}def +}bind def +/PEND{ +clear +countdictstack CNT sub{end}repeat +level1 restore +}bind def +end def +/setpacking where{ +pop +setpacking +}if +%%EndResource +%%IncludeResource: font Times-Roman +%%IncludeResource: font Times-Bold +%%IncludeResource: font Courier-Bold +%%IncludeResource: font Courier-Oblique +%%IncludeResource: font Symbol +%%IncludeResource: font Courier +grops begin/DEFS 1 dict def DEFS begin/u{.001 mul}bind def end/RES 72 +def/PL 792 def/LS false def/ENC0[/asciicircum/asciitilde/Scaron/Zcaron +/scaron/zcaron/Ydieresis/trademark/quotesingle/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/space/exclam/quotedbl/numbersign/dollar/percent +/ampersand/quoteright/parenleft/parenright/asterisk/plus/comma/hyphen +/period/slash/zero/one/two/three/four/five/six/seven/eight/nine/colon +/semicolon/less/equal/greater/question/at/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/bracketleft/backslash/bracketright/circumflex +/underscore/quoteleft/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/braceleft/bar/braceright/tilde/.notdef/quotesinglbase/guillemotleft +/guillemotright/bullet/florin/fraction/perthousand/dagger/daggerdbl +/endash/emdash/ff/fi/fl/ffi/ffl/dotlessi/dotlessj/grave/hungarumlaut +/dotaccent/breve/caron/ring/ogonek/quotedblleft/quotedblright/oe/lslash +/quotedblbase/OE/Lslash/.notdef/exclamdown/cent/sterling/currency/yen +/brokenbar/section/dieresis/copyright/ordfeminine/guilsinglleft +/logicalnot/minus/registered/macron/degree/plusminus/twosuperior +/threesuperior/acute/mu/paragraph/periodcentered/cedilla/onesuperior +/ordmasculine/guilsinglright/onequarter/onehalf/threequarters +/questiondown/Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE +/Ccedilla/Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex +/Idieresis/Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis +/multiply/Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute/Thorn +/germandbls/agrave/aacute/acircumflex/atilde/adieresis/aring/ae/ccedilla +/egrave/eacute/ecircumflex/edieresis/igrave/iacute/icircumflex/idieresis +/eth/ntilde/ograve/oacute/ocircumflex/otilde/odieresis/divide/oslash +/ugrave/uacute/ucircumflex/udieresis/yacute/thorn/ydieresis]def +/Courier@0 ENC0/Courier RE/Courier-Oblique@0 ENC0/Courier-Oblique RE +/Courier-Bold@0 ENC0/Courier-Bold RE/Times-Bold@0 ENC0/Times-Bold RE +/Times-Roman@0 ENC0/Times-Roman RE +%%EndProlog +%%Page: 1 1 +%%BeginPageSetup +BP +%%EndPageSetup +/F0 10/Times-Roman@0 SF(GET)72 48 Q -.834(ARG \( 3 \))-.93 F +(OpenBSD Programmer')111.062 E 2.5(sM)-.55 G 108.562(anual GET)-2.5 F +-.834(ARG \( 3 \))-.93 F/F1 10/Times-Bold@0 SF -.2(NA)72 108 S(ME).2 E +/F2 10/Courier-Bold@0 SF(getarg)102 120 Q F0(,)A F2(arg_printusage)2.5 E +F0 2.52.5 G(ollect command line options)-2.5 E F1(SYNOPSIS)72 144 +Q F2(#include )102 156 Q/F3 10/Courier-Oblique@0 SF(int)102 +186 Q F2(getarg)102 198 Q F0(\()A F3(struct getargs)A/F4 10/Symbol SF(*) +6 E F3(args)A F0(,)1.666 E F3(size_t num_args)4.166 E F0(,)1.666 E F3 +(int argc)4.166 E F0(,)1.666 E F3(char)4.166 E F4(**)6 E F3(argv)A F0(,) +1.666 E F3(int)151.666 210 Q F4(*)6 E F3(optind)A F0(\);)A F3(void)102 +240 Q F2(arg_printusage)102 252 Q F0(\()A F3(struct getargs)A F4(*)6 E +F3(args)A F0(,)1.666 E F3(size_t num_args)4.166 E F0(,)1.666 E F3 +(const char)4.166 E F4(*)6 E F3(progname)A F0(,)1.666 E F3(const char) +151.666 264 Q F4(*)6 E F3(extra_string)A F0(\);)A F1(DESCRIPTION)72 300 +Q F2(getarg)102 312 Q F0 2.721 1.666(\(\) c)D 6.053(ollects an)-1.666 F +8.553(yc)-.15 G 6.053(ommand line options gi)-8.553 F -.15(ve)-.25 G +8.552(nt).15 G 8.552(oap)-8.552 G 6.052(rogram in an easily used w) +-8.552 F(ay)-.1 E(.)-.65 E F2(arg_printusage)102 324 Q F0 -3.332 1.666 +(\(\) p)D(retty-prints the a)-1.666 E -.25(va)-.2 G +(ilable options, with a short help te).25 E(xt.)-.15 E F3(args)102 342 Q +F0 .855(is the option speci\214cation to use, and it')3.355 F 3.356(sa) +-.55 G 3.356(na)-3.356 G .856(rray of)-3.356 F F3 .856(struct getargs) +3.356 F F0(elements.)3.356 E F3(num_args)5.856 E F0(is)3.356 E .344 +(the size of)102 354 R F3(args)2.844 E F0 .344(\(in elements\).)2.844 F +F3(argc)5.344 E F0(and)2.844 E F3(argv)2.844 E F0 .344(are the ar)2.844 +F .344(gument count and ar)-.18 F .344(gument v)-.18 F .344(ector to e) +-.15 F .343(xtract op-)-.15 F 1.127(tion from.)102 366 R F3(optind)6.127 +E F0 1.127(is a pointer to an inte)3.627 F 1.127(ger where the inde)-.15 +F 3.627(xt)-.15 G 3.628(ot)-3.627 G 1.128(he last processed ar)-3.628 F +1.128(gument is stored, it)-.18 F +(must be initialised to the \214rst inde)102 378 Q 2.5(x\()-.15 G +(minus one\) to process \(normally 0\) before the \214rst call.)-2.5 E +F3(arg_printusage)102 396 Q F0(tak)4.178 E 4.178(et)-.1 G 1.678(he same) +-4.178 F F3(args)4.178 E F0(and)4.178 E F3(num_args)4.178 E F0 1.678 +(as getar)4.178 F(g;)-.18 E F3 1.677(progname is the name of)4.178 F +6.381(the program \(to be)102 408 R F0(progname0)12.381 E F3(0)12.381 E +F0(progname1)A F3(1)12.381 E F0(progname2)A F3(2)12.382 E F0(progname3)A +F3(3)12.382 E F0(progname4)A F3(4)102 420 Q F0(progname5)A F3 +(extra_string)3.404 E F0 .904 +(is a string to print after the actual options to indicate more ar)3.404 +F .904(guments. The)-.18 F .025(usefulness of this function is realised\ + only be people who has used programs that has help strings that doesn') +102 432 R(t)-.18 E(match what the code does.)102 444 Q(The)102 462 Q F3 +(getargs)2.5 E F0(struct has the follo)2.5 E(wing elements.)-.25 E/F5 10 +/Courier@0 SF(struct getargs{)102 504 Q(const char)126 516 Q F4(*)6 E F5 +(long_name;)A(char short_name;)126 528 Q(enum { arg_integer,)126 540 Q +(arg_string,)165 552 Q(arg_flag,)165 564 Q(arg_negative_flag,)165 576 Q +(arg_strings,)165 588 Q(arg_double,)165 600 Q(arg_collect)168 612 Q 6 +(}t)126 624 S(ype;)-6 E(void)126 636 Q F4(*)6 E F5(value;)A(const char) +126 648 Q F4(*)6 E F5(help;)A(const char)126 660 Q F4(*)6 E F5 +(arg_help;)A(};)102 672 Q F3(long_name)102 690 Q F0 .207 +(is the long name of the option, it can be)2.707 F F5(NULL)2.706 E F0 +2.706(,i)C 2.706(fy)-2.706 G .206(ou don')-2.706 F 2.706(tw)-.18 G .206 +(ant a long name.)-2.806 F F3(short_name)5.206 E F0 .397(is the charact\ +ed to use as short option, it can be zero. If the option has a v)102 702 +R .398(alue the)-.25 F F3(value)2.898 E F0 .398 +(\214eld gets \214lled in)2.898 F -.4(RO)77 750 S 152.325(KEN September) +.4 F(24, 1999)2.5 E(1)188.865 E EP +%%Page: 2 2 +%%BeginPageSetup +BP +%%EndPageSetup +/F0 10/Times-Roman@0 SF(GET)72 48 Q -.834(ARG \( 3 \))-.93 F +(OpenBSD Programmer')111.062 E 2.5(sM)-.55 G 108.562(anual GET)-2.5 F +-.834(ARG \( 3 \))-.93 F .737(with that v)102 96 R .737 +(alue interpreted as speci\214ed by the)-.25 F/F1 10/Courier-Oblique@0 +SF(type)3.237 E F0(\214eld.)3.237 E F1(help)5.737 E F0 .737 +(is a longer help string for the option as a)3.237 F 2.833 +(whole, if it')102 108 R(s)-.55 E/F2 10/Courier@0 SF(NULL)5.333 E F0 +2.833(the help te)5.333 F 2.833(xt for the option is omitted \(b)-.15 F +2.834(ut it')-.2 F 5.334(ss)-.55 G 2.834 +(till displayed in the synopsis\).)-5.334 F F1(arg_help)102 120 Q F0 +.391(is a description of the ar)2.891 F .391(gument, if)-.18 F F2(NULL) +2.891 E F0 2.891(ad)2.891 G(ef)-2.891 E .39(ault v)-.1 F .39 +(alue will be used, depending on the type of)-.25 F(the option:)102 132 +Q(ar)102 150 Q(g_inte)-.18 E 59.29(ger the)-.15 F(ar)2.5 E +(gument is a signed inte)-.18 E(ger)-.15 E 2.5(,a)-.4 G(nd)-2.5 E F1 +(value)2.5 E F0(should point to an)2.5 E F1(int)2.5 E F0(.)A F1 +(arg_string)102 168 Q F0(the ar)47 E(gument is a string, and)-.18 E F1 +(value)2.5 E F0(should point to a)2.5 E F1(char)2.5 E/F3 10/Symbol SF(*) +A F0(.)A F1(arg_flag)102 186 Q F0 .4(the ar)59 F .4 +(gument is a \215ag, and)-.18 F F1(value)2.9 E F0 .4(should point to a) +2.9 F F1(int)2.9 E F0 2.9(.I)C 2.9(tg)-2.9 G .4 +(ets \214lled in with ei-)-2.9 F 1.154 +(ther zero or one, depending on ho)209 198 R 3.654(wt)-.25 G 1.153 +(he option is gi)-3.654 F -.15(ve)-.25 G 1.153 +(n, the normal case beeing).15 F .526(one. Note that if the option isn') +209 210 R 3.026(tg)-.18 G -2.15 -.25(iv e)-3.026 H .526(n, the v).25 F +.526(alue isn')-.25 F 3.026(ta)-.18 G .527(ltered, so it should be ini-) +-3.026 F(tialised to some useful def)209 222 Q(ault.)-.1 E F1 +(arg_negative_flag)102 240 Q F0 .058(this is the same as)2.558 F F1 +(arg_flag)2.558 E F0 -.2(bu)2.558 G 2.558(ti).2 G 2.558(tr)-2.558 G +-2.15 -.25(ev e)-2.558 H .057(rses the meaning of the \215ag \(a gi).25 +F -.15(ve)-.25 G 2.557(ns).15 G(hort)-2.557 E +(option clears the \215ag\), and the synopsis of a long option is ne)209 +252 Q -.05(ga)-.15 G(ted.).05 E F1(arg_strings)102 270 Q F0 .195(the ar) +41 F .195(gument can be gi)-.18 F -.15(ve)-.25 G 2.695(nm).15 G .195 +(ultiple times, and the v)-2.695 F .195 +(alues are collected in an array;)-.25 F F1(value)209 282 Q F0 .947 +(should be a pointer to a)3.447 F F1 .947(struct getarg_strings)3.447 F +F0 .947(structure, which)3.447 F(holds a length and a string pointer)209 +294 Q(.)-.55 E F1(arg_double)102 312 Q F0(ar)47 E .538 +(gument is a double precision \215oating point v)-.18 F .539(alue, and) +-.25 F F1(value)3.039 E F0 .539(should point to a)3.039 F F1(double)209 +324 Q F0(.)A F1(arg_collect)102 342 Q F0(allo)41 E .345 +(ws more \214ne-grained control of the option parsing process.)-.25 F F1 +(value)5.344 E F0 .344(should be)2.844 F 2.5(ap)209 354 S(ointer to a) +-2.5 E F1(getarg_collect_info)2.5 E F0(structure:)2.5 E F2 +(typedef int \()209 372 Q F3(*)A F2 +(getarg_collect_func\)\(int short_opt,)A(int argc,)407 384 Q(char)407 +396 Q F3(**)6 E F2(argv,)A(int)407 408 Q F3(*)6 E F2(optind,)A(int)407 +420 Q F3(*)6 E F2(optarg,)A(void)407 432 Q F3(*)6 E F2(data\);)A +(typedef struct getarg_collect_info {)209 456 Q +(getarg_collect_func func;)233 468 Q(void)233 480 Q F3(*)6 E F2(data;)A +6(}g)209 492 S(etarg_collect_info;)-6 E F0 -.4(Wi)209 510 S 1.018 +(th the).4 F F1(func)3.518 E F0 1.019 +(member set to a function to call, and)3.518 F F1(data)3.519 E F0 1.019 +(to some application)3.519 F +(speci\214c data. The parameters to the collect function are:)209 522 Q +F1(short_flag)209 540 Q F0 +(non-zero if this call is via a short option \215ag, zero otherwise)2.5 +E F1(argc)209 558 Q F0(,)A F1(argv)6 E F0(the whole ar)2.5 E +(gument list)-.18 E F1(optind)209 576 Q F0(pointer to the inde)2.5 E 2.5 +(xi)-.15 G 2.5(na)-2.5 G -.18(rg)-2.5 G 2.5(vw).18 G(here the \215ag is) +-2.5 E F1(optarg)209 594 Q F0(pointer to the inde)2.5 E 2.5(xi)-.15 G +2.5(na)-2.5 G -.18(rg)-2.5 G(v[).18 E F3(*)A F0 +(optind] where the \215ag name starts)A F1(data)209 612 Q F0 +(application speci\214c data)2.5 E -1.1(Yo)209 630 S 3.915(uc)1.1 G +1.415(an modify)-3.915 F F3(*)3.915 E F1(optind)A F0 3.915(,a)C(nd) +-3.915 E F3(*)3.915 E F1(optarg)A F0 3.915(,b)C 1.414 +(ut to do this correct you \(more or)-4.115 F(less\) ha)209 642 Q .3 +-.15(ve t)-.2 H 2.5(ok).15 G(no)-2.5 E 2.5(wa)-.25 G(bout the inner w) +-2.5 E(orkings of getar)-.1 E(g.)-.18 E -1.1(Yo)209 666 S 3.604(uc)1.1 G +1.104(an skip parts of ar)-3.604 F 1.105(guments by increasing)-.18 F F3 +(*)3.605 E F1(optarg)A F0 1.105(\(you could implement)3.605 F(the)209 +678 Q/F4 10/Courier-Bold@0 SF4.567 E F1(3)A F0 .401 +(set of \215ags from)2.901 F F4(gzip)2.9 E F0 .4 +(with this\), or whole ar)2.9 F .4(gument strings by increas-)-.18 F +(ing)209 690 Q F3(*)3.275 E F1(optind)A F0(\(let')3.275 E 3.276(ss)-.55 +G .776(ay you w)-3.276 F .776(ant a \215ag)-.1 F F44.942 E F1 +6.776(xyz)6.776 G F0 .776(to specify a coordinate\); if)-3.5 F +(you also ha)209 702 Q .3 -.15(ve t)-.2 H 2.5(os).15 G(et)-2.5 E F3(*) +2.5 E F1(optarg)A F0(to a sane v)2.5 E(alue.)-.25 E -.4(RO)77 750 S +152.325(KEN September).4 F(24, 1999)2.5 E(2)188.865 E EP +%%Page: 3 3 +%%BeginPageSetup +BP +%%EndPageSetup +/F0 10/Times-Roman@0 SF(GET)72 48 Q -.834(ARG \( 3 \))-.93 F +(OpenBSD Programmer')111.062 E 2.5(sM)-.55 G 108.562(anual GET)-2.5 F +-.834(ARG \( 3 \))-.93 F 9.449 +(The collect function should return one of)209 96 R/F1 10/Courier@0 SF +(ARG_ERR_NO_MATCH)11.948 E F0(,)A F1(ARG_ERR_BAD_ARG)209 108 Q F0(,)A F1 +(ARG_ERR_NO_ARG)6 E F0(on error)2.5 E 2.5(,z)-.4 G(ero otherwise.)-2.5 E +-.15(Fo)209 126 S 4.042(ry).15 G 1.542(our con)-4.042 F -.15(ve)-.4 G +1.542(nience there is a function,).15 F/F2 10/Courier-Bold@0 SF +(getarg_optarg)4.042 E F0 1.542(\(\), that returns the)B 1.251 +(traditional ar)209 138 R 1.251(gument string, and you pass it all ar) +-.18 F 1.251(guments, sans data, that where)-.18 F(gi)209 150 Q -.15(ve) +-.25 G 2.5(nt).15 G 2.5(ot)-2.5 G(he collection function.)-2.5 E(Don') +209 168 Q 2.5(tu)-.18 G(se this more this unless you absolutely ha)-2.5 +E .3 -.15(ve t)-.2 H(o.).15 E .213(Option parsing is similar to what)102 +186 R F1(getopt)2.713 E F0 .214(uses. Short options without ar)2.714 F +.214(guments can be compressed \()-.18 F F2(\255xyz)1.666 E F0 .207 +(is the same as)102 198 R F2 1.8734.373 F F0 .207 +(\), and short options with ar)B .207(guments tak)-.18 F 2.706(et)-.1 G +.206(hese as either the rest of the ar)-2.706 F(gv-string)-.18 E +(or as the ne)102 210 Q(xt option \()-.15 E F21.666 E/F3 10 +/Courier-Oblique@0 SF(foo)A F0 2.5(,o)C(r)-2.5 E F24.166 E F3(foo) +6 E F0(\).)A .78(Long option names are pre\214x)102 228 R .781 +(ed with -- \(double dash\), and the v)-.15 F .781 +(alue with a = \(equal\),)-.25 F F2(\255-foo=)4.947 E F3(bar)A F0 3.281 +(.L)C(ong)-3.281 E 3.815 +(option \215ags can either be speci\214ed as the)102 240 R 6.315(ya)-.15 +G 3.815(re \()-6.315 F F2(\255-help)1.666 E F0 3.815 +(\), or with an \(boolean parsable\) option)B(\()102 252 Q F2 +(\255-help=)1.666 E F3(yes)A F0(,)A F2(\255-help=)5.659 E F3(true)A F0 +3.993(,o)C 3.993(rs)-3.993 G 1.493(imilar\), or the)-3.993 F 3.993(yc) +-.15 G 1.493(an also be ne)-3.993 F -.05(ga)-.15 G 1.493(ted \().05 F F2 +(\255-no-help)1.666 E F0 1.493(is the same as)3.993 F F2(\255-help=) +103.666 264 Q F0 1.363(no\), and if you')B 1.362 +(re really confused you can do it multiple times \()-.5 F F2 +(\255-no-no-help=)1.666 E F3(false)A F0 3.862(,o)C(r)-3.862 E -2.15 -.25 +(ev e)102 276 T(n).25 E F2(\255-no-no-help=)4.166 E F3(maybe)A F0(\).)A +/F4 10/Times-Bold@0 SF(EXAMPLE)72 300 Q F1(#include )102 330 Q +(#include )102 342 Q(#include )102 354 Q(char)102 +378 Q/F5 10/Symbol SF(*)6 E F1(source = "Ouagadougou";)A(char)102 390 Q +F5(*)6 E F1(destination;)A(int weight;)102 402 Q +(int include_catalog = 1;)102 414 Q(int help_flag;)102 426 Q +(struct getargs args[] = {)102 450 Q 6({")126 462 S 30(source", 's',)-6 +F 6(arg_string, &source,)6 F("source of shippment", "city" },)138 474 Q +6({")126 486 S(destination", 'd', arg_string,)-6 E(&destination,)12 E +("destination of shippment", "city" },)138 498 Q 6({")126 510 S 30 +(weight", 'w',)-6 F(arg_integer, &weight,)6 E +("weight of shippment", "tons" },)138 522 Q 6({")126 534 S 24 +(catalog", 'c',)-6 F(arg_negative_flag, &include_catalog,)6 E +("include product catalog" },)138 546 Q 6({")126 558 S 42(help", 'h',)-6 +F(arg_flag, &help_flag })6 E(};)102 570 Q +(int num_args = sizeof\(args\) / sizeof\(args[0]\); /)102 594 Q F5(*)A +F1(number of elements in args)6 E F5(*)6 E F1(/)A(const char)102 618 Q +F5(*)6 E F1(progname = "ship++";)A(int)102 642 Q(main\(int argc, char) +102 654 Q F5(**)6 E F1(argv\))A({)102 666 Q(int optind = 0;)126 678 Q +(if \(getarg\(args, num_args, argc, argv, &optind\)\) {)126 690 Q +(arg_printusage\(args, num_args, progname, "stuff..."\);)147 702 Q F0 +-.4(RO)77 750 S 152.325(KEN September).4 F(24, 1999)2.5 E(3)188.865 E EP +%%Page: 4 4 +%%BeginPageSetup +BP +%%EndPageSetup +/F0 10/Times-Roman@0 SF(GET)72 48 Q -.834(ARG \( 3 \))-.93 F +(OpenBSD Programmer')111.062 E 2.5(sM)-.55 G 108.562(anual GET)-2.5 F +-.834(ARG \( 3 \))-.93 F/F1 10/Courier@0 SF(exit \(1\);)147 96 Q(})126 +108 Q(if \(help_flag\) {)126 120 Q +(arg_printusage\(args, num_args, progname, "stuff..."\);)147 132 Q +(exit \(0\);)147 144 Q(})126 156 Q(if \(destination == NULL\) {)126 168 +Q(fprintf\(stderr, "%s: must specify destination0, progname\);)147 180 Q +(exit\(1\);)147 192 Q(})126 204 Q +(if \(strcmp\(source, destination\) == 0\) {)126 216 Q +(fprintf\(stderr, "%s: destination must be different from source0\);)147 +228 Q(exit\(1\);)147 240 Q(})126 252 Q(/)126 264 Q/F2 10/Symbol SF(*)A +F1(include more stuff here ...)6 E F2(*)6 E F1(/)A(exit\(2\);)126 276 Q +(})102 288 Q F0(The output help output from this program looks lik)102 +306 Q 2.5(et)-.1 G(his:)-2.5 E F1 6($s)102 324 S(hip++ --help)-6 E +(Usage: ship++ [--source=city] [-s city] [--destination=city] [-d city]) +102 336 Q +([--weight=tons] [-w tons] [--no-catalog] [-c] [--help] [-h] stuff...) +120 348 Q(-s city, --source=city)102 360 Q(source of shippment)36 E +(-d city, --destination=city destination of shippment)102 372 Q +(-w tons, --weight=tons)102 384 Q(weight of shippment)36 E +(-c, --no-catalog)102 396 Q(include product catalog)72 E/F3 10 +/Times-Bold@0 SF -.1(BU)72 432 S(GS).1 E F0 .9(It should be more \215e) +102 444 R .9(xible, so it w)-.15 F .901 +(ould be possible to use other more complicated option syntax)-.1 F .901 +(es, such as)-.15 F(what)102 456 Q F1(ps)3.167 E F0 .667(\(1\), and)B F1 +(tar)3.167 E F0 .666(\(1\), uses, or the AFS model where you can skip t\ +he \215ag names as long as the options)B(come in the correct order)102 +468 Q(.)-.55 E(Options with multiple ar)102 486 Q +(guments should be handled better)-.18 E(.)-.55 E(Should be inte)102 504 +Q(greated with SL.)-.15 E(It')102 522 Q 2.5(sv)-.55 G +(ery confusing that the struct you pass in is called getar)-2.65 E(gS.) +-.18 E F3 1.666(SEE ALSO)72 546 R F1(getopt)102 558 Q F0(\(3\))A -.4(RO) +77 750 S 152.325(KEN September).4 F(24, 1999)2.5 E(4)188.865 E EP +%%Trailer +end +%%EOF diff --git a/ndb/src/common/util/getarg.c b/ndb/src/common/util/getarg.c new file mode 100644 index 00000000000..5f792437a65 --- /dev/null +++ b/ndb/src/common/util/getarg.c @@ -0,0 +1,599 @@ +/* -*- c-basic-offset: 4; -*- */ +/* + * Copyright (c) 1997 - 2000 Kungliga Tekniska Högskolan + * (Royal Institute of Technology, Stockholm, Sweden). + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include + +#ifdef HAVE_CONFIG_H +#include +RCSID("$KTH: getarg.c,v 1.23 2000/09/01 21:25:54 lha Exp $"); +#endif + +#include +#include +#include +#include +#include +#include "getarg.h" + +#define ISFLAG(X) ((X).type == arg_flag || (X).type == arg_negative_flag) + +#ifndef HAVE_STRLCPY +extern size_t strlcpy (char *dst, const char *src, size_t dst_sz); +#endif /* !HAVE_STRLCPY */ + +#ifndef HAVE_STRLCAT +extern size_t strlcat (char *dst, const char *src, size_t dst_sz); +#endif /* !HAVE_STRLCAT */ + +#ifndef max +#define max(a, b) (a) > (b) ? (a) : (b) +#endif + +#ifdef HAVE___PROGNAME +extern char *__progname; +#endif + +#ifndef TRUE +#define TRUE 1 +#endif + +#ifndef FALSE +#define FALSE 0 +#endif + +char * +strupr(char *str) +{ + char *s; + + for(s = str; *s; s++) + *s = toupper(*s); + return str; +} + +static size_t +print_arg (char *string, size_t len, int mdoc, int longp, struct getargs *arg) +{ + const char *s; + + *string = '\0'; + + if (ISFLAG(*arg) || (!longp && arg->type == arg_counter)) + return 0; + + if(mdoc){ + if(longp) + strlcat(string, "= Ns", len); + strlcat(string, " Ar ", len); + }else + if (longp) + strlcat (string, "=", len); + else + strlcat (string, " ", len); + + if (arg->arg_help) + s = arg->arg_help; + else if (arg->type == arg_integer || arg->type == arg_counter) + s = "integer"; + else if (arg->type == arg_string) + s = "string"; + else if (arg->type == arg_double) + s = "float"; + else + s = ""; + + strlcat(string, s, len); + return 1 + strlen(s); +} + +#ifdef GETARGMANDOC +static void +mandoc_template(struct getargs *args, + size_t num_args, + const char *progname, + const char *extra_string) +{ + size_t i; + char timestr[64], cmd[64]; + char buf[128]; + const char *p; + time_t t; + + printf(".\\\" Things to fix:\n"); + printf(".\\\" * correct section, and operating system\n"); + printf(".\\\" * remove Op from mandatory flags\n"); + printf(".\\\" * use better macros for arguments (like .Pa for files)\n"); + printf(".\\\"\n"); + t = time(NULL); + strftime(timestr, sizeof(timestr), "%B %e, %Y", localtime(&t)); + printf(".Dd %s\n", timestr); + p = strrchr(progname, '/'); + if(p) p++; else p = progname; + strlcpy(cmd, p, sizeof(cmd)); + strupr(cmd); + + printf(".Dt %s SECTION\n", cmd); + printf(".Os OPERATING_SYSTEM\n"); + printf(".Sh NAME\n"); + printf(".Nm %s\n", p); + printf(".Nd\n"); + printf("in search of a description\n"); + printf(".Sh SYNOPSIS\n"); + printf(".Nm\n"); + for(i = 0; i < num_args; i++){ + /* we seem to hit a limit on number of arguments if doing + short and long flags with arguments -- split on two lines */ + if(ISFLAG(args[i]) || + args[i].short_name == 0 || args[i].long_name == NULL) { + printf(".Op "); + + if(args[i].short_name) { + print_arg(buf, sizeof(buf), 1, 0, args + i); + printf("Fl %c%s", args[i].short_name, buf); + if(args[i].long_name) + printf(" | "); + } + if(args[i].long_name) { + print_arg(buf, sizeof(buf), 1, 1, args + i); + printf("Fl -%s%s%s", + args[i].type == arg_negative_flag ? "no-" : "", + args[i].long_name, buf); + } + printf("\n"); + } else { + print_arg(buf, sizeof(buf), 1, 0, args + i); + printf(".Oo Fl %c%s \\*(Ba Xo\n", args[i].short_name, buf); + print_arg(buf, sizeof(buf), 1, 1, args + i); + printf(".Fl -%s%s Oc\n.Xc\n", args[i].long_name, buf); + } + /* + if(args[i].type == arg_strings) + fprintf (stderr, "..."); + */ + } + if (extra_string && *extra_string) + printf (".Ar %s\n", extra_string); + printf(".Sh DESCRIPTION\n"); + printf("Supported options:\n"); + printf(".Bl -tag -width Ds\n"); + for(i = 0; i < num_args; i++){ + printf(".It Xo\n"); + if(args[i].short_name){ + printf(".Fl %c", args[i].short_name); + print_arg(buf, sizeof(buf), 1, 0, args + i); + printf("%s", buf); + if(args[i].long_name) + printf(" Ns ,"); + printf("\n"); + } + if(args[i].long_name){ + printf(".Fl -%s%s", + args[i].type == arg_negative_flag ? "no-" : "", + args[i].long_name); + print_arg(buf, sizeof(buf), 1, 1, args + i); + printf("%s\n", buf); + } + printf(".Xc\n"); + if(args[i].help) + printf("%s\n", args[i].help); + /* + if(args[i].type == arg_strings) + fprintf (stderr, "..."); + */ + } + printf(".El\n"); + printf(".\\\".Sh ENVIRONMENT\n"); + printf(".\\\".Sh FILES\n"); + printf(".\\\".Sh EXAMPLES\n"); + printf(".\\\".Sh DIAGNOSTICS\n"); + printf(".\\\".Sh SEE ALSO\n"); + printf(".\\\".Sh STANDARDS\n"); + printf(".\\\".Sh HISTORY\n"); + printf(".\\\".Sh AUTHORS\n"); + printf(".\\\".Sh BUGS\n"); +} +#endif /* GETARGMANDOC */ + +static int +check_column(FILE *f, int col, int len, int columns) +{ + if(col + len > columns) { + fprintf(f, "\n"); + col = fprintf(f, " "); + } + return col; +} + +void +arg_printusage (struct getargs *args, + size_t num_args, + const char *progname, + const char *extra_string) +{ + unsigned int i; + size_t max_len = 0; + char buf[128]; + int col = 0, columns; + +#ifdef HAVE___PROGNAME + if (progname == NULL) + progname = __progname; +#endif + if (progname == NULL) + progname = ""; + +#ifdef GETARGMANDOC + if(getenv("GETARGMANDOC")){ + mandoc_template(args, num_args, progname, extra_string); + return; + } +#endif + + columns = 80; /* Always assume that the window is 80 chars wide */ + col = 0; + col += fprintf (stderr, "Usage: %s", progname); + for (i = 0; i < num_args; ++i) { + size_t len = 0; + + if (args[i].long_name) { + buf[0] = '\0'; + strlcat(buf, "[--", sizeof(buf)); + len += 2; + if(args[i].type == arg_negative_flag) { + strlcat(buf, "no-", sizeof(buf)); + len += 3; + } + strlcat(buf, args[i].long_name, sizeof(buf)); + len += strlen(args[i].long_name); + len += print_arg(buf + strlen(buf), sizeof(buf) - strlen(buf), + 0, 1, &args[i]); + strlcat(buf, "]", sizeof(buf)); + if(args[i].type == arg_strings) + strlcat(buf, "...", sizeof(buf)); + col = check_column(stderr, col, strlen(buf) + 1, columns); + col += fprintf(stderr, " %s", buf); + } + if (args[i].short_name) { + snprintf(buf, sizeof(buf), "[-%c", args[i].short_name); + len += 2; + len += print_arg(buf + strlen(buf), sizeof(buf) - strlen(buf), + 0, 0, &args[i]); + strlcat(buf, "]", sizeof(buf)); + if(args[i].type == arg_strings) + strlcat(buf, "...", sizeof(buf)); + col = check_column(stderr, col, strlen(buf) + 1, columns); + col += fprintf(stderr, " %s", buf); + } + if (args[i].long_name && args[i].short_name) + len += 2; /* ", " */ + max_len = max(max_len, len); + } + if (extra_string) { + col = check_column(stderr, col, strlen(extra_string) + 1, columns); + fprintf (stderr, " %s\n", extra_string); + } else + fprintf (stderr, "\n"); + for (i = 0; i < num_args; ++i) { + if (args[i].help) { + size_t count = 0; + + if (args[i].short_name) { + count += fprintf (stderr, "-%c", args[i].short_name); + print_arg (buf, sizeof(buf), 0, 0, &args[i]); + count += fprintf(stderr, "%s", buf); + } + if (args[i].short_name && args[i].long_name) + count += fprintf (stderr, ", "); + if (args[i].long_name) { + count += fprintf (stderr, "--"); + if (args[i].type == arg_negative_flag) + count += fprintf (stderr, "no-"); + count += fprintf (stderr, "%s", args[i].long_name); + print_arg (buf, sizeof(buf), 0, 1, &args[i]); + count += fprintf(stderr, "%s", buf); + } + while(count++ <= max_len) + putc (' ', stderr); + fprintf (stderr, "%s\n", args[i].help); + } + } +} + +static void +add_string(getarg_strings *s, char *value) +{ + s->strings = realloc(s->strings, (s->num_strings + 1) * sizeof(*s->strings)); + s->strings[s->num_strings] = value; + s->num_strings++; +} + +static int +arg_match_long(struct getargs *args, size_t num_args, + char *argv, int argc, const char **rargv, int *optind) +{ + unsigned int i; + const char *optarg = NULL; + int negate = 0; + int partial_match = 0; + struct getargs *partial = NULL; + struct getargs *current = NULL; + int argv_len; + char *p; + + argv_len = strlen(argv); + p = strchr (argv, '='); + if (p != NULL) + argv_len = p - argv; + + for (i = 0; i < num_args; ++i) { + if(args[i].long_name) { + int len = strlen(args[i].long_name); + char *p = argv; + int p_len = argv_len; + negate = 0; + + for (;;) { + if (strncmp (args[i].long_name, p, p_len) == 0) { + if(p_len == len) + current = &args[i]; + else { + ++partial_match; + partial = &args[i]; + } + optarg = p + p_len; + } else if (ISFLAG(args[i]) && strncmp (p, "no-", 3) == 0) { + negate = !negate; + p += 3; + p_len -= 3; + continue; + } + break; + } + if (current) + break; + } + } + if (current == NULL) { + if (partial_match == 1) + current = partial; + else + return ARG_ERR_NO_MATCH; + } + + if(*optarg == '\0' + && !ISFLAG(*current) + && current->type != arg_collect + && current->type != arg_counter) + return ARG_ERR_NO_MATCH; + switch(current->type){ + case arg_integer: + { + int tmp; + if(sscanf(optarg + 1, "%d", &tmp) != 1) + return ARG_ERR_BAD_ARG; + *(int*)current->value = tmp; + return 0; + } + case arg_string: + { + *(char**)current->value = optarg + 1; + return 0; + } + case arg_strings: + { + add_string((getarg_strings*)current->value, optarg + 1); + return 0; + } + case arg_flag: + case arg_negative_flag: + { + int *flag = current->value; + if(*optarg == '\0' || + strcmp(optarg + 1, "yes") == 0 || + strcmp(optarg + 1, "true") == 0){ + *flag = !negate; + return 0; + } else if (*optarg && strcmp(optarg + 1, "maybe") == 0) { + *flag = rand() & 1; + } else { + *flag = negate; + return 0; + } + return ARG_ERR_BAD_ARG; + } + case arg_counter : + { + int val; + + if (*optarg == '\0') + val = 1; + else { + char *endstr; + + val = strtol (optarg, &endstr, 0); + if (endstr == optarg) + return ARG_ERR_BAD_ARG; + } + *(int *)current->value += val; + return 0; + } + case arg_double: + { + double tmp; + if(sscanf(optarg + 1, "%lf", &tmp) != 1) + return ARG_ERR_BAD_ARG; + *(double*)current->value = tmp; + return 0; + } + case arg_collect:{ + struct getarg_collect_info *c = current->value; + int o = argv - rargv[*optind]; + return (*c->func)(FALSE, argc, rargv, optind, &o, c->data); + } + + default: + abort (); + } +} + +static int +arg_match_short (struct getargs *args, size_t num_args, + char *argv, int argc, const char **rargv, int *optind) +{ + int j, k; + + for(j = 1; j > 0 && j < (int)strlen(rargv[*optind]); j++) { + for(k = 0; k < (int)num_args; k++) { + char *optarg; + + if(args[k].short_name == 0) + continue; + if(argv[j] == args[k].short_name) { + if(args[k].type == arg_flag) { + *(int*)args[k].value = 1; + break; + } + if(args[k].type == arg_negative_flag) { + *(int*)args[k].value = 0; + break; + } + if(args[k].type == arg_counter) { + ++*(int *)args[k].value; + break; + } + if(args[k].type == arg_collect) { + struct getarg_collect_info *c = args[k].value; + + if((*c->func)(TRUE, argc, rargv, optind, &j, c->data)) + return ARG_ERR_BAD_ARG; + break; + } + + if(argv[j + 1]) + optarg = &argv[j + 1]; + else { + ++*optind; + optarg = rargv[*optind]; + } + if(optarg == NULL) { + --*optind; + return ARG_ERR_NO_ARG; + } + if(args[k].type == arg_integer) { + int tmp; + if(sscanf(optarg, "%d", &tmp) != 1) + return ARG_ERR_BAD_ARG; + *(int*)args[k].value = tmp; + return 0; + } else if(args[k].type == arg_string) { + *(char**)args[k].value = optarg; + return 0; + } else if(args[k].type == arg_strings) { + add_string((getarg_strings*)args[k].value, optarg); + return 0; + } else if(args[k].type == arg_double) { + double tmp; + if(sscanf(optarg, "%lf", &tmp) != 1) + return ARG_ERR_BAD_ARG; + *(double*)args[k].value = tmp; + return 0; + } + return ARG_ERR_BAD_ARG; + } + } + if (k == (int)num_args) + return ARG_ERR_NO_MATCH; + } + return 0; +} + +int +getarg(struct getargs *args, size_t num_args, + int argc, const char **argv, int *optind) +{ + int i; + int ret = 0; + + srand (time(NULL)); + (*optind)++; + for(i = *optind; i < argc; i++) { + if(argv[i][0] != '-') + break; + if(argv[i][1] == '-'){ + if(argv[i][2] == 0){ + i++; + break; + } + ret = arg_match_long (args, num_args, argv[i] + 2, + argc, argv, &i); + } else { + ret = arg_match_short (args, num_args, argv[i], + argc, argv, &i); + } + if(ret) + break; + } + *optind = i; + return ret; +} + + +#if TEST +int foo_flag = 2; +int flag1 = 0; +int flag2 = 0; +int bar_int; +char *baz_string; + +struct getargs args[] = { + { NULL, '1', arg_flag, &flag1, "one", NULL }, + { NULL, '2', arg_flag, &flag2, "two", NULL }, + { "foo", 'f', arg_negative_flag, &foo_flag, "foo", NULL }, + { "bar", 'b', arg_integer, &bar_int, "bar", "seconds"}, + { "baz", 'x', arg_string, &baz_string, "baz", "name" }, +}; + +int main(int argc, char **argv) +{ + int optind = 0; + while(getarg(args, 5, argc, argv, &optind)) + printf("Bad arg: %s\n", argv[optind]); + printf("flag1 = %d\n", flag1); + printf("flag2 = %d\n", flag2); + printf("foo_flag = %d\n", foo_flag); + printf("bar_int = %d\n", bar_int); + printf("baz_flag = %s\n", baz_string); + arg_printusage (args, 5, argv[0], "nothing here"); +} +#endif diff --git a/ndb/src/common/util/getarg.cat3 b/ndb/src/common/util/getarg.cat3 new file mode 100644 index 00000000000..31685510537 --- /dev/null +++ b/ndb/src/common/util/getarg.cat3 @@ -0,0 +1,237 @@ +GETARG(3) OpenBSD Programmer's Manual GETARG(3) + +NNAAMMEE + ggeettaarrgg, aarrgg__pprriinnttuussaaggee - collect command line options + +SSYYNNOOPPSSIISS + ##iinncclluuddee <> + + + _i_n_t + ggeettaarrgg(_s_t_r_u_c_t _g_e_t_a_r_g_s _*_a_r_g_s, _s_i_z_e___t _n_u_m___a_r_g_s, _i_n_t _a_r_g_c, _c_h_a_r _*_*_a_r_g_v, + _i_n_t _*_o_p_t_i_n_d); + + + _v_o_i_d + aarrgg__pprriinnttuussaaggee(_s_t_r_u_c_t _g_e_t_a_r_g_s _*_a_r_g_s, _s_i_z_e___t _n_u_m___a_r_g_s, + _c_o_n_s_t _c_h_a_r _*_p_r_o_g_n_a_m_e, _c_o_n_s_t _c_h_a_r _*_e_x_t_r_a___s_t_r_i_n_g); + + +DDEESSCCRRIIPPTTIIOONN + ggeettaarrgg() collects any command line options given to a program in an easi­ + ly used way. aarrgg__pprriinnttuussaaggee() pretty-prints the available options, with + a short help text. + + _a_r_g_s is the option specification to use, and it's an array of _s_t_r_u_c_t + _g_e_t_a_r_g_s elements. _n_u_m___a_r_g_s is the size of _a_r_g_s (in elements). _a_r_g_c and + _a_r_g_v are the argument count and argument vector to extract option from. + _o_p_t_i_n_d is a pointer to an integer where the index to the last processed + argument is stored, it must be initialised to the first index (minus one) + to process (normally 0) before the first call. + + _a_r_g___p_r_i_n_t_u_s_a_g_e take the same _a_r_g_s and _n_u_m___a_r_g_s as getarg; _p_r_o_g_n_a_m_e _i_s _t_h_e + _n_a_m_e _o_f _t_h_e _p_r_o_g_r_a_m _(_t_o _b_e progname0 _0progname1 _1progname2 _2progname3 + _3progname4 _4progname5 _e_x_t_r_a___s_t_r_i_n_g is a string to print after the actual + options to indicate more arguments. The usefulness of this function is + realised only be people who has used programs that has help strings that + doesn't match what the code does. + + The _g_e_t_a_r_g_s struct has the following elements. + + + struct getargs{ + const char *long_name; + char short_name; + enum { arg_integer, + arg_string, + arg_flag, + arg_negative_flag, + arg_strings, + arg_double, + arg_collect + } type; + void *value; + const char *help; + const char *arg_help; + }; + + _l_o_n_g___n_a_m_e is the long name of the option, it can be NULL, if you don't + want a long name. _s_h_o_r_t___n_a_m_e is the characted to use as short option, it + can be zero. If the option has a value the _v_a_l_u_e field gets filled in + with that value interpreted as specified by the _t_y_p_e field. _h_e_l_p is a + longer help string for the option as a whole, if it's NULL the help text + for the option is omitted (but it's still displayed in the synopsis). + _a_r_g___h_e_l_p is a description of the argument, if NULL a default value will + be used, depending on the type of the option: + + + arg_integer the argument is a signed integer, and _v_a_l_u_e should + point to an _i_n_t. + + _a_r_g___s_t_r_i_n_g the argument is a string, and _v_a_l_u_e should point to a + _c_h_a_r_*. + + _a_r_g___f_l_a_g the argument is a flag, and _v_a_l_u_e should point to a + _i_n_t. It gets filled in with either zero or one, de­ + pending on how the option is given, the normal case + beeing one. Note that if the option isn't given, the + value isn't altered, so it should be initialised to + some useful default. + + _a_r_g___n_e_g_a_t_i_v_e___f_l_a_g this is the same as _a_r_g___f_l_a_g but it reverses the mean­ + ing of the flag (a given short option clears the + flag), and the synopsis of a long option is negated. + + _a_r_g___s_t_r_i_n_g_s the argument can be given multiple times, and the val­ + ues are collected in an array; _v_a_l_u_e should be a + pointer to a _s_t_r_u_c_t _g_e_t_a_r_g___s_t_r_i_n_g_s structure, which + holds a length and a string pointer. + + _a_r_g___d_o_u_b_l_e argument is a double precision floating point value, + and _v_a_l_u_e should point to a _d_o_u_b_l_e. + + _a_r_g___c_o_l_l_e_c_t allows more fine-grained control of the option parsing + process. _v_a_l_u_e should be a pointer to a + _g_e_t_a_r_g___c_o_l_l_e_c_t___i_n_f_o structure: + + typedef int (*getarg_collect_func)(int short_opt, + int argc, + char **argv, + int *optind, + int *optarg, + void *data); + + typedef struct getarg_collect_info { + getarg_collect_func func; + void *data; + } getarg_collect_info; + + With the _f_u_n_c member set to a function to call, and + _d_a_t_a to some application specific data. The parameters + to the collect function are: + + _s_h_o_r_t___f_l_a_g non-zero if this call is via a short option + flag, zero otherwise + + _a_r_g_c, _a_r_g_v the whole argument list + + _o_p_t_i_n_d pointer to the index in argv where the flag is + + _o_p_t_a_r_g pointer to the index in argv[*optind] where the + flag name starts + + _d_a_t_a application specific data + + You can modify _*_o_p_t_i_n_d, and _*_o_p_t_a_r_g, but to do this + correct you (more or less) have to know about the in­ + ner workings of getarg. + + You can skip parts of arguments by increasing _*_o_p_t_a_r_g + (you could implement the --zz_3 set of flags from ggzziipp + with this), or whole argument strings by increasing + _*_o_p_t_i_n_d (let's say you want a flag --cc _x _y _z to specify + a coordinate); if you also have to set _*_o_p_t_a_r_g to a + sane value. + + The collect function should return one of + ARG_ERR_NO_MATCH, ARG_ERR_BAD_ARG, ARG_ERR_NO_ARG on + error, zero otherwise. + + For your convenience there is a function, + ggeettaarrgg__ooppttaarrgg(), that returns the traditional argument + string, and you pass it all arguments, sans data, that + where given to the collection function. + + Don't use this more this unless you absolutely have + to. + + Option parsing is similar to what getopt uses. Short options without ar­ + guments can be compressed (--xxyyzz is the same as --xx --yy --zz), and short op­ + tions with arguments take these as either the rest of the argv-string or + as the next option (--oo_f_o_o, or --oo _f_o_o). + + Long option names are prefixed with -- (double dash), and the value with + a = (equal), ----ffoooo==_b_a_r. Long option flags can either be specified as they + are (----hheellpp), or with an (boolean parsable) option (----hheellpp==_y_e_s, + ----hheellpp==_t_r_u_e, or similar), or they can also be negated (----nnoo--hheellpp is the + same as ----hheellpp==no), and if you're really confused you can do it multiple + times (----nnoo--nnoo--hheellpp==_f_a_l_s_e, or even ----nnoo--nnoo--hheellpp==_m_a_y_b_e). + +EEXXAAMMPPLLEE + #include + #include + #include + + char *source = "Ouagadougou"; + char *destination; + int weight; + int include_catalog = 1; + int help_flag; + + struct getargs args[] = { + { "source", 's', arg_string, &source, + "source of shippment", "city" }, + { "destination", 'd', arg_string, &destination, + "destination of shippment", "city" }, + { "weight", 'w', arg_integer, &weight, + "weight of shippment", "tons" }, + { "catalog", 'c', arg_negative_flag, &include_catalog, + "include product catalog" }, + { "help", 'h', arg_flag, &help_flag } + }; + + int num_args = sizeof(args) / sizeof(args[0]); /* number of elements in args */ + + const char *progname = "ship++"; + + int + main(int argc, char **argv) + { + int optind = 0; + if (getarg(args, num_args, argc, argv, &optind)) { + arg_printusage(args, num_args, progname, "stuff..."); + exit (1); + } + if (help_flag) { + arg_printusage(args, num_args, progname, "stuff..."); + exit (0); + } + if (destination == NULL) { + fprintf(stderr, "%s: must specify destination0, progname); + exit(1); + } + if (strcmp(source, destination) == 0) { + fprintf(stderr, "%s: destination must be different from source0); + exit(1); + } + /* include more stuff here ... */ + exit(2); + } + + The output help output from this program looks like this: + + $ ship++ --help + Usage: ship++ [--source=city] [-s city] [--destination=city] [-d city] + [--weight=tons] [-w tons] [--no-catalog] [-c] [--help] [-h] stuff... + -s city, --source=city source of shippment + -d city, --destination=city destination of shippment + -w tons, --weight=tons weight of shippment + -c, --no-catalog include product catalog + + +BBUUGGSS + It should be more flexible, so it would be possible to use other more + complicated option syntaxes, such as what ps(1), and tar(1), uses, or the + AFS model where you can skip the flag names as long as the options come + in the correct order. + + Options with multiple arguments should be handled better. + + Should be integreated with SL. + + It's very confusing that the struct you pass in is called getargS. + +SSEEEE AALLSSOO + getopt(3) + + ROKEN September 24, 1999 4 diff --git a/ndb/src/common/util/md5_hash.cpp b/ndb/src/common/util/md5_hash.cpp new file mode 100644 index 00000000000..5e28edcf8fa --- /dev/null +++ b/ndb/src/common/util/md5_hash.cpp @@ -0,0 +1,235 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + +#include "md5_hash.hpp" + +#ifdef WORDS_BIGENDIAN +#define HIGHFIRST 1 +#endif + +/* + * This code implements the MD5 message-digest algorithm. + * The algorithm is due to Ron Rivest. This code was + * written by Colin Plumb in 1993, no copyright is claimed. + * This code is in the public domain; do with it what you wish. + * + * Equivalent code is available from RSA Data Security, Inc. + * This code has been tested against that, and is equivalent, + * except that you don't need to include two pages of legalese + * with every copy. + * + * The code has been modified by Mikael Ronstroem to handle + * calculating a hash value of a key that is always a multiple + * of 4 bytes long. Word 0 of the calculated 4-word hash value + * is returned as the hash value. + */ + +#ifndef HIGHFIRST +#define byteReverse(buf, len) /* Nothing */ +#else +void byteReverse(unsigned char *buf, unsigned longs); +/* + * Note: this code is harmless on little-endian machines. + */ +void byteReverse(unsigned char *buf, unsigned longs) +{ + uint32 t; + do { + t = (Uint32) ((unsigned) buf[3] << 8 | buf[2]) << 16 | + ((unsigned) buf[1] << 8 | buf[0]); + *(Uint32 *) buf = t; + buf += 4; + } while (--longs); +} +#endif + +/* The four core functions - F1 is optimized somewhat */ + +/* #define F1(x, y, z) (x & y | ~x & z) */ +#define F1(x, y, z) (z ^ (x & (y ^ z))) +#define F2(x, y, z) F1(z, x, y) +#define F3(x, y, z) (x ^ y ^ z) +#define F4(x, y, z) (y ^ (x | ~z)) + +/* This is the central step in the MD5 algorithm. */ +#define MD5STEP(f, w, x, y, z, data, s) \ + ( w += f(x, y, z) + data, w = w<>(32-s), w += x ) + +/* + * The core of the MD5 algorithm, this alters an existing MD5 hash to + * reflect the addition of 16 longwords of new data. MD5Update blocks + * the data and converts bytes into longwords for this routine. + */ +void MD5Transform(Uint32 buf[4], Uint32 const in[16]) +{ + register Uint32 a, b, c, d; + + a = buf[0]; + b = buf[1]; + c = buf[2]; + d = buf[3]; + + MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7); + MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12); + MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17); + MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22); + MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7); + MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12); + MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17); + MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22); + MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7); + MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12); + MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17); + MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22); + MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7); + MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12); + MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17); + MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22); + + MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5); + MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9); + MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14); + MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20); + MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5); + MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9); + MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14); + MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20); + MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5); + MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9); + MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14); + MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20); + MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5); + MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9); + MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14); + MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20); + + MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4); + MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11); + MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16); + MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23); + MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4); + MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11); + MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16); + MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23); + MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4); + MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11); + MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16); + MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23); + MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4); + MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11); + MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16); + MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23); + + MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6); + MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10); + MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15); + MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21); + MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6); + MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10); + MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15); + MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21); + MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6); + MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10); + MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15); + MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21); + MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6); + MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10); + MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15); + MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21); + + buf[0] += a; + buf[1] += b; + buf[2] += c; + buf[3] += d; +} + +/* + * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious + * initialization constants. + */ +Uint32 md5_hash(const Uint64* keybuf, Uint32 no_of_32_words) +{ +/* + * This is the external interface of the module + * It is assumed that keybuf is placed on 8 byte + * alignment. + */ + Uint32 i; + Uint32 buf[4]; + Uint64 transform64_buf[8]; + Uint32* transform32_buf; + Uint32 len = no_of_32_words << 2; + const Uint64* key64buf = (const Uint64*)keybuf; + const Uint32* key32buf = (const Uint32*)keybuf; + + transform32_buf = (Uint32*)&transform64_buf[0]; + buf[0] = 0x67452301; + buf[1] = 0xefcdab89; + buf[2] = 0x98badcfe; + buf[3] = 0x10325476; + + while (no_of_32_words >= 16) { + transform64_buf[0] = key64buf[0]; + transform64_buf[1] = key64buf[1]; + transform64_buf[2] = key64buf[2]; + transform64_buf[3] = key64buf[3]; + transform64_buf[4] = key64buf[4]; + transform64_buf[5] = key64buf[5]; + transform64_buf[6] = key64buf[6]; + transform64_buf[7] = key64buf[7]; + no_of_32_words -= 16; + key64buf += 8; + byteReverse((unsigned char *)transform32_buf, 16); + MD5Transform(buf, transform32_buf); + } + + key32buf = (const Uint32*)key64buf; + transform64_buf[0] = 0; + transform64_buf[1] = 0; + transform64_buf[2] = 0; + transform64_buf[3] = 0; + transform64_buf[4] = 0; + transform64_buf[5] = 0; + transform64_buf[6] = 0; + transform64_buf[7] = (Uint64)len; + + for (i = 0; i < no_of_32_words; i++) + transform32_buf[i] = key32buf[i]; + transform32_buf[no_of_32_words] = 0x80000000; + + if (no_of_32_words < 14) { + byteReverse((unsigned char *)transform32_buf, 16); + MD5Transform(buf, transform32_buf); + } else { + if (no_of_32_words == 14) + transform32_buf[15] = 0; + MD5Transform(buf, transform32_buf); + transform64_buf[0] = 0; + transform64_buf[1] = 0; + transform64_buf[2] = 0; + transform64_buf[3] = 0; + transform64_buf[4] = 0; + transform64_buf[5] = 0; + transform64_buf[6] = 0; + transform64_buf[7] = (Uint64)len; + byteReverse((unsigned char *)transform32_buf, 16); + MD5Transform(buf, transform32_buf); + } + return buf[0]; +} + diff --git a/ndb/src/common/util/random.c b/ndb/src/common/util/random.c new file mode 100644 index 00000000000..91da19572e2 --- /dev/null +++ b/ndb/src/common/util/random.c @@ -0,0 +1,292 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/*************************************************************** +* I N C L U D E D F I L E S * +***************************************************************/ + +#include +#include +#include +#include + +#ifndef NDB_WIN32 +#include +#endif + +#include +#include + +#include + +/*************************************************************** +* L O C A L C O N S T A N T S * +***************************************************************/ + +/*************************************************************** +* L O C A L D A T A S T R U C T U R E S * +***************************************************************/ + +typedef struct { + unsigned short int x[3]; /* Current state. */ + unsigned short int a[3]; /* Factor in congruential formula. */ + unsigned short int c; /* Additive const. in congruential formula. */ + int init; /* Flag for initializing. */ +}DRand48Data; + +/*************************************************************** +* L O C A L F U N C T I O N S * +***************************************************************/ + +static void shuffleSequence(RandomSequence *seq); + +/*************************************************************** +* L O C A L D A T A * +***************************************************************/ + +static DRand48Data dRand48Data; + +/*************************************************************** +* P U B L I C D A T A * +***************************************************************/ + + +/*************************************************************** +**************************************************************** +* L O C A L F U N C T I O N S C O D E S E C T I O N * +**************************************************************** +***************************************************************/ + +static void localRandom48Init(long int seedval, DRand48Data *buffer) +{ + /* The standards say we only have 32 bits. */ + if (sizeof (long int) > 4) + seedval &= 0xffffffffl; + +#if USHRT_MAX == 0xffffU + buffer->x[2] = seedval >> 16; + buffer->x[1] = seedval & 0xffffl; + buffer->x[0] = 0x330e; + + buffer->a[2] = 0x5; + buffer->a[1] = 0xdeec; + buffer->a[0] = 0xe66d; +#else + buffer->x[2] = seedval; + buffer->x[1] = 0x330e0000UL; + buffer->x[0] = 0; + + buffer->a[2] = 0x5deecUL; + buffer->a[1] = 0xe66d0000UL; + buffer->a[0] = 0; +#endif + + buffer->c = 0xb; + buffer->init = 1; +} + +static void localRandom48(DRand48Data *buffer, long int *result) +{ + Uint64 X; + Uint64 a; + Uint64 loc_result; + + /*--------------------------------------*/ + /* Initialize buffer, if not yet done. */ + /*--------------------------------------*/ + if (!buffer->init) { +#if (USHRT_MAX == 0xffffU) + buffer->a[2] = 0x5; + buffer->a[1] = 0xdeec; + buffer->a[0] = 0xe66d; +#else + buffer->a[2] = 0x5deecUL; + buffer->a[1] = 0xe66d0000UL; + buffer->a[0] = 0; +#endif + buffer->c = 0xb; + buffer->init = 1; + } + + /* Do the real work. We choose a data type which contains at least + 48 bits. Because we compute the modulus it does not care how + many bits really are computed. */ + + if (sizeof (unsigned short int) == 2) { + X = (Uint64)buffer->x[2] << 32 | + (Uint64)buffer->x[1] << 16 | + buffer->x[0]; + a = ((Uint64)buffer->a[2] << 32 | + (Uint64)buffer->a[1] << 16 | + buffer->a[0]); + + loc_result = X * a + buffer->c; + + buffer->x[0] = loc_result & 0xffff; + buffer->x[1] = (loc_result >> 16) & 0xffff; + buffer->x[2] = (loc_result >> 32) & 0xffff; + } + else { + X = (Uint64)buffer->x[2] << 16 | + buffer->x[1] >> 16; + a = (Uint64)buffer->a[2] << 16 | + buffer->a[1] >> 16; + + loc_result = X * a + buffer->c; + + buffer->x[0] = loc_result >> 16 & 0xffffffffl; + buffer->x[1] = loc_result << 16 & 0xffff0000l; + } + + /*--------------------*/ + /* Store the result. */ + /*--------------------*/ + if (sizeof (unsigned short int) == 2) + *result = buffer->x[2] << 15 | buffer->x[1] >> 1; + else + *result = buffer->x[2] >> 1; +} + +static void shuffleSequence(RandomSequence *seq) +{ + int i; + int j; + unsigned int tmp; + + if( !seq ) return; + + for(i = 0; i < seq->length; i++ ) { + j = myRandom48(seq->length); + if( i != j ) { + tmp = seq->values[i]; + seq->values[i] = seq->values[j]; + seq->values[j] = tmp; + } + } +} + + +/*************************************************************** +**************************************************************** +* P U B L I C F U N C T I O N S C O D E S E C T I O N * +**************************************************************** +***************************************************************/ + + +double getTps(unsigned int count, double timeValue) +{ + double f; + + if( timeValue != 0.0 ) + f = count / timeValue; + else + f = 0.0; + + return(f); +} + +/*----------------------------*/ +/* Random Sequences Functions */ +/*----------------------------*/ +int initSequence(RandomSequence *seq, SequenceValues *inputValues) +{ + unsigned int i; + unsigned int j; + unsigned int totalLength; + unsigned int index; + + if( !seq || !inputValues ) return(-1); + + /*------------------------------------*/ + /* Find the total length of the array */ + /*------------------------------------*/ + totalLength = 0; + + for(i = 0; inputValues[i].length != 0; i++) + totalLength += inputValues[i].length; + + if( totalLength == 0 ) return(-1); + + seq->length = totalLength; + seq->values = calloc(totalLength, sizeof(unsigned int)); + + if( seq->values == 0 ) return(-1); + + /*----------------------*/ + /* set the array values */ + /*----------------------*/ + index = 0; + + for(i = 0; inputValues[i].length != 0; i++) { + for(j = 0; j < inputValues[i].length; j++ ) { + seq->values[index] = inputValues[i].value; + index++; + } + } + + shuffleSequence(seq); + + seq->currentIndex = 0; + + return(0); +} + +unsigned int getNextRandom(RandomSequence *seq) +{ + unsigned int nextValue; + + nextValue = seq->values[seq->currentIndex]; + + seq->currentIndex++; + + if(seq->currentIndex == seq->length){ + seq->currentIndex = 0; + shuffleSequence(seq); + } + + return nextValue; +} + +void printSequence(RandomSequence *seq, unsigned int numPerRow) +{ + int i; + + if( !seq ) return; + + for(i = 0; ilength; i++) { + ndbout_c("%d ", seq->values[i]); + + if((i+1) % numPerRow == 0) + ndbout_c(""); + } + + if(i % numPerRow != 0) + ndbout_c(""); +} + +void myRandom48Init(long int seedval) +{ + localRandom48Init(seedval, &dRand48Data); +} + +long int myRandom48(unsigned int maxValue) +{ + long int result; + + localRandom48(&dRand48Data, &result); + + return(result % maxValue); +} diff --git a/ndb/src/common/util/socket_io.cpp b/ndb/src/common/util/socket_io.cpp new file mode 100644 index 00000000000..878a9059512 --- /dev/null +++ b/ndb/src/common/util/socket_io.cpp @@ -0,0 +1,284 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include +#include +#include + +extern "C" +int +read_socket(NDB_SOCKET_TYPE socket, int timeout_millis, + char * buf, int buflen){ + if(buflen < 1) + return 0; + + fd_set readset; + FD_ZERO(&readset); + FD_SET(socket, &readset); + + struct timeval timeout; + timeout.tv_sec = (timeout_millis / 1000); + timeout.tv_usec = (timeout_millis % 1000) * 1000; + + const int selectRes = select(socket + 1, &readset, 0, 0, &timeout); + if(selectRes == 0) + return 0; + + if(selectRes == -1){ + return -1; + } + + return recv(socket, &buf[0], buflen, 0); +} + +extern "C" +int +readln_socket(NDB_SOCKET_TYPE socket, int timeout_millis, + char * buf, int buflen){ + if(buflen <= 1) + return 0; + + fd_set readset; + FD_ZERO(&readset); + FD_SET(socket, &readset); + + struct timeval timeout; + timeout.tv_sec = (timeout_millis / 1000); + timeout.tv_usec = (timeout_millis % 1000) * 1000; + + const int selectRes = select(socket + 1, &readset, 0, 0, &timeout); + if(selectRes == 0) + return 0; + + if(selectRes == -1){ + return -1; + } + + int pos = 0; buf[pos] = 0; + while(true){ + const int t = recv(socket, &buf[pos], 1, 0); + if(t != 1){ + return -1; + } + if(buf[pos] == '\n'){ + buf[pos] = 0; + + if(pos > 0 && buf[pos-1] == '\r'){ + pos--; + buf[pos] = 0; + } + + return pos; + } + pos++; + if(pos == (buflen - 1)){ + buf[pos] = 0; + return buflen; + } + + FD_ZERO(&readset); + FD_SET(socket, &readset); + timeout.tv_sec = 1; + timeout.tv_usec = 0; // 1 s + const int selectRes = select(socket + 1, &readset, 0, 0, &timeout); + if(selectRes != 1){ + return -1; + } + } +} + +extern "C" +int +write_socket(NDB_SOCKET_TYPE socket, int timeout_millis, + const char buf[], int len){ + fd_set writeset; + FD_ZERO(&writeset); + FD_SET(socket, &writeset); + struct timeval timeout; + timeout.tv_sec = (timeout_millis / 1000); + timeout.tv_usec = (timeout_millis % 1000) * 1000; + + const int selectRes = select(socket + 1, 0, &writeset, 0, &timeout); + if(selectRes != 1){ + return -1; + } + + const char * tmp = &buf[0]; + while(len > 0){ + const int w = send(socket, tmp, len, 0); + if(w == -1){ + return -1; + } + len -= w; + tmp += w; + + if(len == 0) + break; + + FD_ZERO(&writeset); + FD_SET(socket, &writeset); + timeout.tv_sec = 1; + timeout.tv_usec = 0; + const int selectRes = select(socket + 1, 0, &writeset, 0, &timeout); + if(selectRes != 1){ + return -1; + } + } + + return 0; +} + +extern "C" +int +print_socket(NDB_SOCKET_TYPE socket, int timeout_millis, + const char * fmt, ...){ + va_list ap; + va_start(ap, fmt); + int ret = vprint_socket(socket, timeout_millis, fmt, ap); + va_end(ap); + + return ret; +} + +extern "C" +int +println_socket(NDB_SOCKET_TYPE socket, int timeout_millis, + const char * fmt, ...){ + va_list ap; + va_start(ap, fmt); + int ret = vprintln_socket(socket, timeout_millis, fmt, ap); + va_end(ap); + return ret; +} + +extern "C" +int +vprint_socket(NDB_SOCKET_TYPE socket, int timeout_millis, + const char * fmt, va_list ap){ + char buf[1000]; + char *buf2 = buf; + size_t size = sizeof(buf); + + if (fmt != 0) { + size = vsnprintf(buf, sizeof(buf), fmt, ap); + /* Check if the output was truncated */ + if(size >= sizeof(buf)) { + buf2 = (char *)malloc(size+1); + if(buf2 == NULL) + return -1; + vsnprintf(buf2, size, fmt, ap); + } else + size = sizeof(buf); + } else + buf[0] = 0; + + int ret = write_socket(socket, timeout_millis, buf2, strlen(buf2)); + if(buf2 != buf) + free(buf2); + return ret; +} + +extern "C" +int +vprintln_socket(NDB_SOCKET_TYPE socket, int timeout_millis, + const char * fmt, va_list ap){ + char buf[1000]; + char *buf2 = buf; + size_t size = sizeof(buf); + + if (fmt != 0) { + size = vsnprintf(buf, sizeof(buf)-1, fmt, ap); + /* Check if the output was truncated */ + if(size >= sizeof(buf)) { + buf2 = (char *)malloc(size+2); + if(buf2 == NULL) + return -1; + vsnprintf(buf2, size, fmt, ap); + } else + size = sizeof(buf); + } else + buf[0] = 0; + strlcat(buf2, "\n", size+2); + + int ret = write_socket(socket, timeout_millis, buf2, strlen(buf2)); + if(buf2 != buf) + free(buf2); + return ret; +} + +#ifdef NDB_WIN32 + +class INIT_WINSOCK2 +{ +public: + INIT_WINSOCK2(void); + ~INIT_WINSOCK2(void); + +private: + bool m_bAcceptable; +}; + +INIT_WINSOCK2 g_init_winsock2; + +INIT_WINSOCK2::INIT_WINSOCK2(void) +: m_bAcceptable(false) +{ + WORD wVersionRequested; + WSADATA wsaData; + int err; + + wVersionRequested = MAKEWORD( 2, 2 ); + + err = WSAStartup( wVersionRequested, &wsaData ); + if ( err != 0 ) { + /* Tell the user that we could not find a usable */ + /* WinSock DLL. */ + m_bAcceptable = false; + } + + /* Confirm that the WinSock DLL supports 2.2.*/ + /* Note that if the DLL supports versions greater */ + /* than 2.2 in addition to 2.2, it will still return */ + /* 2.2 in wVersion since that is the version we */ + /* requested. */ + + if ( LOBYTE( wsaData.wVersion ) != 2 || + HIBYTE( wsaData.wVersion ) != 2 ) { + /* Tell the user that we could not find a usable */ + /* WinSock DLL. */ + WSACleanup( ); + m_bAcceptable = false; + } + + /* The WinSock DLL is acceptable. Proceed. */ + m_bAcceptable = true; +} + +INIT_WINSOCK2::~INIT_WINSOCK2(void) +{ + if(m_bAcceptable) + { + m_bAcceptable = false; + WSACleanup(); + } +} + +#endif + diff --git a/ndb/src/common/util/strdup.c b/ndb/src/common/util/strdup.c new file mode 100644 index 00000000000..5291be86b0f --- /dev/null +++ b/ndb/src/common/util/strdup.c @@ -0,0 +1,28 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include + +#ifndef HAVE_STRDUP +char * +strdup(const char *s){ + void *p2; + p2 = malloc(strlen(s)+1); + strcpy(p2, s); + return p2; +} +#endif diff --git a/ndb/src/common/util/strlcat.c b/ndb/src/common/util/strlcat.c new file mode 100644 index 00000000000..ccff15da27f --- /dev/null +++ b/ndb/src/common/util/strlcat.c @@ -0,0 +1,52 @@ +/* + * Copyright (c) 1995 - 1999 Kungliga Tekniska Högskolan + * (Royal Institute of Technology, Stockholm, Sweden). + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include + +/* RCSID("$KTH: strlcat.c,v 1.1 2000/08/16 01:23:47 lha Exp $"); */ + +//#include + +#ifndef HAVE_STRLCAT +size_t +strlcat (char *dst, const char *src, size_t dst_sz) +{ + size_t len = strlen(dst); + + return len + strlcpy (dst + len, src, dst_sz - len); +} +#endif diff --git a/ndb/src/common/util/strlcpy.c b/ndb/src/common/util/strlcpy.c new file mode 100644 index 00000000000..9a3048081ca --- /dev/null +++ b/ndb/src/common/util/strlcpy.c @@ -0,0 +1,65 @@ +/* + * Copyright (c) 1995 - 1999 Kungliga Tekniska Högskolan + * (Royal Institute of Technology, Stockholm, Sweden). + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include + +/* RCSID("$KTH: strlcpy.c,v 1.1 2000/08/16 01:23:48 lha Exp $"); */ + +#ifndef HAVE_STRLCPY + +#ifdef NDB_WIN32 +#include +#endif + +size_t +strlcpy (char *dst, const char *src, size_t dst_sz) +{ + size_t n; + char *p; + + for (p = dst, n = 0; + n + 1 < dst_sz && *src != '\0'; + ++p, ++src, ++n) + *p = *src; + *p = '\0'; + if (*src == '\0') + return n; + else + return n + strlen (src); +} + +#endif diff --git a/ndb/src/common/util/testProperties/Makefile b/ndb/src/common/util/testProperties/Makefile new file mode 100644 index 00000000000..00b4465b69d --- /dev/null +++ b/ndb/src/common/util/testProperties/Makefile @@ -0,0 +1,12 @@ +include .defs.mk + +TYPE := + +BIN_TARGET := keso +BIN_TARGET_ARCHIVES := portlib general + +SOURCES := testProperties.cpp + +CCFLAGS_LOC += -I$(call fixpath,$(NDB_TOP)/include/util) + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/common/util/testProperties/testProperties.cpp b/ndb/src/common/util/testProperties/testProperties.cpp new file mode 100644 index 00000000000..4a2999b89c1 --- /dev/null +++ b/ndb/src/common/util/testProperties/testProperties.cpp @@ -0,0 +1,203 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Properties.hpp" +#include +#include +#include + +#include "uucode.h" + +bool +writeToFile(const Properties & p, const char * fname, bool uu = true){ + Uint32 sz = p.getPackedSize(); + char * buffer = (char*)malloc(sz); + + FILE * f = fopen(fname, "wb"); + bool res = p.pack((Uint32*)buffer); + if(res != true){ + ndbout << "Error packing" << endl; + ndbout << "p.getPropertiesErrno() = " << p.getPropertiesErrno() << endl; + ndbout << "p.getOSErrno() = " << p.getOSErrno() << endl; + } + if(uu) + uuencode(buffer, sz, f); + else { + fwrite(buffer, 1, sz, f); + } + + fclose(f); + free(buffer); + return res; +} + +bool +readFromFile(Properties & p, const char *fname, bool uu = true){ + Uint32 sz = 30000; + char * buffer = (char*)malloc(sz); + FILE * f = fopen(fname, "rb"); + if(uu) + uudecode(f, buffer, sz); + else + fread(buffer, 1, sz, f); + fclose(f); + bool res = p.unpack((Uint32*)buffer, sz); + if(res != true){ + ndbout << "Error unpacking" << endl; + ndbout << "p.getPropertiesErrno() = " << p.getPropertiesErrno() << endl; + ndbout << "p.getOSErrno() = " << p.getOSErrno() << endl; + } + free(buffer); + return res; +} + +Property defs[] = { + Property("Rolf", 123) + ,Property("Keso", "Kent") +}; + + +void putALot(Properties & tmp){ + int i = 123; + tmp.put("LockPagesInMainMemory", i++); + tmp.put("SleepWhenIdle", i++); + tmp.put("NoOfSignalsToExecuteBetweenCommunicationInterfacePoll", i++); + tmp.put("TimeBetweenWatchDogCheck", i++); + tmp.put("StopOnError", i++); + + tmp.put("MaxNoOfConcurrentOperations", i++); + tmp.put("MaxNoOfConcurrentTransactions", i++); + tmp.put("MemorySpaceIndexes", i++); + tmp.put("MemorySpaceTuples", i++); + tmp.put("MemoryDiskPages", i++); + tmp.put("NoOfFreeDiskClusters", i++); + tmp.put("NoOfDiskClusters", i++); + + tmp.put("TimeToWaitAlive", i++); + tmp.put("HeartbeatIntervalDbDb", i++); + tmp.put("HeartbeatIntervalDbApi", i++); + tmp.put("TimeBetweenInactiveTransactionAbortCheck", i++); + + tmp.put("TimeBetweenLocalCheckpoints", i++); + tmp.put("TimeBetweenGlobalCheckpoints", i++); + tmp.put("NoOfFragmentLogFiles", i++); + tmp.put("NoOfConcurrentCheckpointsDuringRestart", i++); + tmp.put("TransactionInactiveTimeBeforeAbort", i++); + tmp.put("NoOfConcurrentProcessesHandleTakeover", i++); + + tmp.put("NoOfConcurrentCheckpointsAfterRestart", i++); + + tmp.put("NoOfDiskPagesToDiskDuringRestartTUP", i++); + tmp.put("NoOfDiskPagesToDiskAfterRestartTUP", i++); + tmp.put("NoOfDiskPagesToDiskDuringRestartACC", i++); + tmp.put("NoOfDiskPagesToDiskAfterRestartACC", i++); + + tmp.put("NoOfDiskClustersPerDiskFile", i++); + tmp.put("NoOfDiskFiles", i++); + + // Always found + tmp.put("NoOfReplicas", 33); + tmp.put("MaxNoOfAttributes", 34); + tmp.put("MaxNoOfTables", 35); +} + +int +main(void){ + Properties p; + + p.put("Kalle", 1); + p.put("Ank1", "anka"); + p.put("Ank2", "anka"); + p.put("Ank3", "anka"); + p.put("Ank4", "anka"); + putALot(p); + + //p.put(defs, 2); + Properties tmp; + tmp.put("Type", "TCP"); + tmp.put("OwnNodeId", 1); + tmp.put("RemoteNodeId", 2); + tmp.put("OwnHostName", "local"); + tmp.put("RemoteHostName", "remote"); + + tmp.put("SendSignalId", 1); + tmp.put("Compression", (Uint32)false); + tmp.put("Checksum", 1); + + tmp.put("SendBufferSize", 2000); + tmp.put("MaxReceiveSize", 1000); + + tmp.put("PortNumber", 1233); + putALot(tmp); + + p.put("Connection", 1, &tmp); + + p.put("NoOfConnections", 2); + p.put("NoOfConnection2", 2); + + p.put("kalle", 3); + p.put("anka", "kalle"); + + Properties p2; + p2.put("kalle", "anka"); + + p.put("prop", &p2); + + p.put("Connection", 2, &tmp); + + p.put("Connection", 3, &tmp); + + p.put("Connection", 4, &tmp); + /* + */ + + Uint32 a = 99; + const char * b; + const Properties * p3; + Properties * p4; + + bool bb = p.get("kalle", &a); + bool cc = p.get("anka", &b); + bool dd = p.get("prop", &p3); + if(p.getCopy("prop", &p4)) + delete p4; + + p2.put("p2", &p2); + + p.put("prop2", &p2); + /* */ + + p.print(stdout, "testing 1: "); + + writeToFile(p, "A_1"); + writeToFile(p, "B_1", false); + + Properties r1; + readFromFile(r1, "A_1"); + writeToFile(r1, "A_3"); + + //r1.print(stdout, "testing 2: "); + Properties r2; + readFromFile(r2, "A_1"); + writeToFile(r2, "A_4"); + + Properties r3; + readFromFile(r3, "B_1", false); + writeToFile(r3, "A_5"); + r3.print(stdout, "testing 3: "); + + return 0; +} diff --git a/ndb/src/common/util/testSimpleProperties/Makefile b/ndb/src/common/util/testSimpleProperties/Makefile new file mode 100644 index 00000000000..89d33fa8dd8 --- /dev/null +++ b/ndb/src/common/util/testSimpleProperties/Makefile @@ -0,0 +1,12 @@ +include .defs.mk + +TYPE := util + +BIN_TARGET := sp_test +BIN_TARGET_ARCHIVES := portlib general + +SOURCES := sp_test.cpp + +CCFLAGS_LOC += -I$(call fixpath,$(NDB_TOP)/include/util) + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/common/util/testSimpleProperties/sp_test.cpp b/ndb/src/common/util/testSimpleProperties/sp_test.cpp new file mode 100644 index 00000000000..d6dbe2a1502 --- /dev/null +++ b/ndb/src/common/util/testSimpleProperties/sp_test.cpp @@ -0,0 +1,95 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "SimpleProperties.hpp" +#include +#include +#include + +Uint32 page[8192]; + +int writer(); +int reader(Uint32 *, Uint32 len); +int unpack(Uint32 *, Uint32 len); + +int main(){ + int len = writer(); + reader(page, len); + unpack(page, len); + + return 0; +} + +int +writer(){ + LinearWriter w(&page[0], 8192); + + w.first(); + w.add(1, 2); + w.add(7, 3); + w.add(3, "jonas"); + w.add(5, "0123456789"); + w.add(7, 4); + w.add(3, "e cool"); + w.add(5, "9876543210"); + + ndbout_c("WordsUsed = %d", w.getWordsUsed()); + + return w.getWordsUsed(); +} + +int +reader(Uint32 * pages, Uint32 len){ + SimplePropertiesLinearReader it(pages, len); + + it.printAll(ndbout); + return 0; +} + +struct Test { + Uint32 val1; + Uint32 val7; + char val3[100]; + Test() : val1(0xFFFFFFFF), val7(0xFFFFFFFF) { sprintf(val3, "bad");} +}; + +static const +SimpleProperties::SP2StructMapping +test_map [] = { + { 1, offsetof(Test, val1), SimpleProperties::Uint32Value, 0, ~0 }, + { 7, offsetof(Test, val7), SimpleProperties::Uint32Value, 0, ~0 }, + { 3, offsetof(Test, val3), SimpleProperties::StringValue, 0, sizeof(100) }, + { 5, 0, SimpleProperties::InvalidValue, 0, 0 } +}; + +static unsigned +test_map_sz = sizeof(test_map)/sizeof(test_map[0]); + +int +unpack(Uint32 * pages, Uint32 len){ + Test test; + SimplePropertiesLinearReader it(pages, len); + SimpleProperties::UnpackStatus status; + while((status = SimpleProperties::unpack(it, &test, test_map, test_map_sz, + true, false)) == SimpleProperties::Break){ + ndbout << "test.val1 = " << test.val1 << endl; + ndbout << "test.val7 = " << test.val7 << endl; + ndbout << "test.val3 = " << test.val3 << endl; + it.next(); + } + assert(status == SimpleProperties::Eof); + return 0; +} diff --git a/ndb/src/common/util/uucode.c b/ndb/src/common/util/uucode.c new file mode 100644 index 00000000000..f862d982204 --- /dev/null +++ b/ndb/src/common/util/uucode.c @@ -0,0 +1,235 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include + +/* ENC is the basic 1 character encoding function to make a char printing */ +/* DEC is single character decode */ +#define ENC(c) ((c) ? ((c) & 077) + ' ': '`') +#define DEC(c) (((c) - ' ') & 077) + +/* + * copy from in to out, encoding as you go along. + */ +void +uuencode(const char * data, int dataLen, FILE * out) +{ + int ch, n; + const char *p = data; + + fprintf(out, "begin\n"); + + while (dataLen > 0){ + n = dataLen > 45 ? 45 : dataLen; + dataLen -= n; + ch = ENC(n); + if (putc(ch, out) == EOF) + break; + for (; n > 0; n -= 3, p += 3) { + char p_0 = * p; + char p_1 = 0; + char p_2 = 0; + + if(n >= 2){ + p_1 = p[1]; + } + if(n >= 3){ + p_2 = p[2]; + } + + ch = p_0 >> 2; + ch = ENC(ch); + if (putc(ch, out) == EOF) + break; + ch = ((p_0 << 4) & 060) | ((p_1 >> 4) & 017); + ch = ENC(ch); + if (putc(ch, out) == EOF) + break; + ch = ((p_1 << 2) & 074) | ((p_2 >> 6) & 03); + ch = ENC(ch); + if (putc(ch, out) == EOF) + break; + ch = p_2 & 077; + ch = ENC(ch); + if (putc(ch, out) == EOF) + break; + } + if (putc('\n', out) == EOF) + break; + } + ch = ENC('\0'); + putc(ch, out); + putc('\n', out); + fprintf(out, "end\n"); +} + +int +uudecode(FILE * input, char * outBuf, int bufLen){ + int n; + char ch, *p, returnCode; + char buf[255]; + + returnCode = 0; + /* search for header line */ + do { + if (!fgets(buf, sizeof(buf), input)) { + return 1; + } + } while (strncmp(buf, "begin", 5)); + + /* for each input line */ + for (;;) { + if (!fgets(p = buf, sizeof(buf), input)) { + return 1; + } + /* + * `n' is used to avoid writing out all the characters + * at the end of the file. + */ + if ((n = DEC(*p)) <= 0) + break; + if(n >= bufLen){ + returnCode = 1; + break; + } + for (++p; n > 0; p += 4, n -= 3) + if (n >= 3) { + ch = DEC(p[0]) << 2 | DEC(p[1]) >> 4; + * outBuf = ch; outBuf++; bufLen--; + ch = DEC(p[1]) << 4 | DEC(p[2]) >> 2; + * outBuf = ch; outBuf++; bufLen--; + ch = DEC(p[2]) << 6 | DEC(p[3]); + * outBuf = ch; outBuf++; bufLen--; + } else { + if (n >= 1) { + ch = DEC(p[0]) << 2 | DEC(p[1]) >> 4; + * outBuf = ch; outBuf++; bufLen--; + } + if (n >= 2) { + ch = DEC(p[1]) << 4 | DEC(p[2]) >> 2; + * outBuf = ch; outBuf++; bufLen--; + } + if (n >= 3) { + ch = DEC(p[2]) << 6 | DEC(p[3]); + * outBuf = ch; outBuf++; bufLen--; + } + } + } + if (!fgets(buf, sizeof(buf), input) || strcmp(buf, "end\n")) { + return 1; + } + return returnCode; +} + +int +uuencode_mem(char * dst, const char * data, int dataLen) +{ + int sz = 0; + + int ch, n; + const char *p = data; + + while (dataLen > 0){ + n = dataLen > 45 ? 45 : dataLen; + dataLen -= n; + ch = ENC(n); + * dst = ch; dst++; sz++; + for (; n > 0; n -= 3, p += 3) { + char p_0 = * p; + char p_1 = 0; + char p_2 = 0; + + if(n >= 2){ + p_1 = p[1]; + } + if(n >= 3){ + p_2 = p[2]; + } + + ch = p_0 >> 2; + ch = ENC(ch); + * dst = ch; dst++; sz++; + + ch = ((p_0 << 4) & 060) | ((p_1 >> 4) & 017); + ch = ENC(ch); + * dst = ch; dst++; sz++; + + ch = ((p_1 << 2) & 074) | ((p_2 >> 6) & 03); + ch = ENC(ch); + * dst = ch; dst++; sz++; + + ch = p_2 & 077; + ch = ENC(ch); + * dst = ch; dst++; sz++; + } + + * dst = '\n'; dst++; sz++; + } + ch = ENC('\0'); + * dst = ch; dst++; sz++; + + * dst = '\n'; dst++; sz++; + * dst = 0; dst++; sz++; + + return sz; +} + +int +uudecode_mem(char * outBuf, int bufLen, const char * src){ + int n; + char ch; + int sz = 0; + const char * p = src; + + /* + * `n' is used to avoid writing out all the characters + * at the end of the file. + */ + if ((n = DEC(*p)) <= 0) + return 0; + if(n >= bufLen){ + return -1; + } + for (++p; n > 0; p += 4, n -= 3){ + if (n >= 3) { + ch = DEC(p[0]) << 2 | DEC(p[1]) >> 4; + * outBuf = ch; outBuf++; bufLen--; sz++; + ch = DEC(p[1]) << 4 | DEC(p[2]) >> 2; + * outBuf = ch; outBuf++; bufLen--; sz++; + ch = DEC(p[2]) << 6 | DEC(p[3]); + * outBuf = ch; outBuf++; bufLen--; sz++; + } else { + if (n >= 1) { + ch = DEC(p[0]) << 2 | DEC(p[1]) >> 4; + * outBuf = ch; outBuf++; bufLen--; sz++; + } + if (n >= 2) { + ch = DEC(p[1]) << 4 | DEC(p[2]) >> 2; + * outBuf = ch; outBuf++; bufLen--; sz++; + } + if (n >= 3) { + ch = DEC(p[2]) << 6 | DEC(p[3]); + * outBuf = ch; outBuf++; bufLen--; sz++; + } + } + } + return sz; +} + + + diff --git a/ndb/src/common/util/version.c b/ndb/src/common/util/version.c new file mode 100644 index 00000000000..d220a06850a --- /dev/null +++ b/ndb/src/common/util/version.c @@ -0,0 +1,224 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include + +Uint32 getMajor(Uint32 version) { + return (version >> 16) & 0xFF; +} + +Uint32 getMinor(Uint32 version) { + return (version >> 8) & 0xFF; +} + +Uint32 getBuild(Uint32 version) { + return (version >> 0) & 0xFF; +} + +Uint32 makeVersion(Uint32 major, Uint32 minor, Uint32 build) { + return MAKE_VERSION(major, minor, build); + +} + +char * getVersionString(Uint32 version, char * status) { + char buff[100]; + snprintf(buff, sizeof(buff), + "Version %d.%d.%d (%s)", + getMajor(version), + getMinor(version), + getBuild(version), + status); + + return strdup(buff); +} + +typedef enum { + UG_Null, + UG_Range, + UG_Exact +} UG_MatchType; + +struct NdbUpGradeCompatible { + Uint32 ownVersion; + Uint32 otherVersion; + UG_MatchType matchType; +}; + +//#define TEST_VERSION + +#ifndef TEST_VERSION +struct NdbUpGradeCompatible ndbCompatibleTable_full[] = { + { NDB_VERSION_D , MAKE_VERSION(NDB_VERSION_MAJOR,NDB_VERSION_MINOR,2), UG_Range }, + { 0, 0, UG_Null } +}; + +struct NdbUpGradeCompatible ndbCompatibleTable_upgrade[] = { + { 0, 0, UG_Null } +}; + +void ndbSetOwnVersion() {} + +#else // testing purposes + +struct NdbUpGradeCompatible ndbCompatibleTable_full[] = { + { MAKE_VERSION(4,1,5), MAKE_VERSION(4,1,0), UG_Range }, + { MAKE_VERSION(3,6,9), MAKE_VERSION(3,6,1), UG_Range }, + { MAKE_VERSION(3,6,2), MAKE_VERSION(3,6,1), UG_Range }, + { MAKE_VERSION(3,5,7), MAKE_VERSION(3,5,0), UG_Range }, + { MAKE_VERSION(3,5,1), MAKE_VERSION(3,5,0), UG_Range }, + { NDB_VERSION_D , MAKE_VERSION(NDB_VERSION_MAJOR,NDB_VERSION_MINOR,2), UG_Range }, + { 0, 0, UG_Null } +}; + +struct NdbUpGradeCompatible ndbCompatibleTable_upgrade[] = { + { MAKE_VERSION(4,1,5), MAKE_VERSION(3,6,9), UG_Exact }, + { MAKE_VERSION(3,6,2), MAKE_VERSION(3,5,7), UG_Exact }, + { MAKE_VERSION(3,5,1), NDB_VERSION_D , UG_Exact }, + { 0, 0, UG_Null } +}; + + +Uint32 ndbOwnVersionTesting = 0; +void +ndbSetOwnVersion() { + char buf[256]; + if (NdbEnv_GetEnv("NDB_SETVERSION", buf, sizeof(buf))) { + Uint32 _v1,_v2,_v3; + if (sscanf(buf, "%u.%u.%u", &_v1, &_v2, &_v3) == 3) { + ndbOwnVersionTesting = MAKE_VERSION(_v1,_v2,_v3); + ndbout_c("Testing: Version set to 0x%x", ndbOwnVersionTesting); + } + } +} + +#endif + +void ndbPrintVersion() +{ + printf("Version: %u.%u.%u\n", + getMajor(ndbGetOwnVersion()), + getMinor(ndbGetOwnVersion()), + getBuild(ndbGetOwnVersion())); +} + +Uint32 +ndbGetOwnVersion() +{ +#ifndef TEST_VERSION + return NDB_VERSION_D; +#else // testing purposes + if (ndbOwnVersionTesting == 0) + return NDB_VERSION_D; + else + return ndbOwnVersionTesting; +#endif +} + +int +ndbSearchUpgradeCompatibleTable(Uint32 ownVersion, Uint32 otherVersion, + struct NdbUpGradeCompatible table[]) +{ + int i; + for (i = 0; table[i].ownVersion != 0 && table[i].otherVersion != 0; i++) { + if (table[i].ownVersion == ownVersion || + table[i].ownVersion == ~0) { + switch (table[i].matchType) { + case UG_Range: + if (otherVersion >= table[i].otherVersion){ + return 1; + } + break; + case UG_Exact: + if (otherVersion == table[i].otherVersion){ + return 1; + } + break; + default: + break; + } + } + } + return 0; +} + +int +ndbCompatible(Uint32 ownVersion, Uint32 otherVersion, struct NdbUpGradeCompatible table[]) +{ + if (otherVersion >= ownVersion) { + return 1; + } + return ndbSearchUpgradeCompatibleTable(ownVersion, otherVersion, table); +} + +int +ndbCompatible_full(Uint32 ownVersion, Uint32 otherVersion) +{ + return ndbCompatible(ownVersion, otherVersion, ndbCompatibleTable_full); +} + +int +ndbCompatible_upgrade(Uint32 ownVersion, Uint32 otherVersion) +{ + if (ndbCompatible_full(ownVersion, otherVersion)) + return 1; + return ndbCompatible(ownVersion, otherVersion, ndbCompatibleTable_upgrade); +} + +int +ndbCompatible_mgmt_ndb(Uint32 ownVersion, Uint32 otherVersion) +{ + return ndbCompatible_upgrade(ownVersion, otherVersion); +} + +int +ndbCompatible_mgmt_api(Uint32 ownVersion, Uint32 otherVersion) +{ + return ndbCompatible_upgrade(ownVersion, otherVersion); +} + +int +ndbCompatible_ndb_mgmt(Uint32 ownVersion, Uint32 otherVersion) +{ + return ndbCompatible_full(ownVersion, otherVersion); +} + +int +ndbCompatible_api_mgmt(Uint32 ownVersion, Uint32 otherVersion) +{ + return ndbCompatible_full(ownVersion, otherVersion); +} + +int +ndbCompatible_api_ndb(Uint32 ownVersion, Uint32 otherVersion) +{ + return ndbCompatible_full(ownVersion, otherVersion); +} + +int +ndbCompatible_ndb_api(Uint32 ownVersion, Uint32 otherVersion) +{ + return ndbCompatible_upgrade(ownVersion, otherVersion); +} + +int +ndbCompatible_ndb_ndb(Uint32 ownVersion, Uint32 otherVersion) +{ + return ndbCompatible_upgrade(ownVersion, otherVersion); +} diff --git a/ndb/src/cw/Makefile b/ndb/src/cw/Makefile new file mode 100644 index 00000000000..e710c1e244d --- /dev/null +++ b/ndb/src/cw/Makefile @@ -0,0 +1,6 @@ +include .defs.mk + +DIRS := cpcd + +include $(NDB_TOP)/Epilogue.mk + diff --git a/ndb/src/cw/cpcc-win32/C++/CPC_GUI.cpp b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.cpp new file mode 100644 index 00000000000..59ee3e90451 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.cpp @@ -0,0 +1,215 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "stdafx.h" + +HINSTANCE hInst ; +TCHAR szTitle[MAX_LOADSTRING] ; +TCHAR szWindowClass[MAX_LOADSTRING] ; + +static CNdbControls controls ; + +int APIENTRY WinMain(HINSTANCE hInstance, + HINSTANCE hPrevInstance, + LPSTR lpCmdLine, + int nCmdShow){ + MSG msg; + HACCEL hAccelTable; + + LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING) ; + LoadString(hInstance, IDC_CPC_GUI, szWindowClass, MAX_LOADSTRING) ; + NdbRegisterClass(hInstance); + + if (!InitInstance (hInstance, nCmdShow)) { + return FALSE; + } + + hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_CPC_GUI); + + while (GetMessage(&msg, NULL, 0, 0)){ + + if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)){ + + TranslateMessage(&msg); + DispatchMessage(&msg); + + } + + } + + return msg.wParam; +} + + +ATOM NdbRegisterClass(HINSTANCE hInstance){ + WNDCLASSEX wcex; + + wcex.cbSize = sizeof(WNDCLASSEX); + + wcex.style = CS_HREDRAW | CS_VREDRAW ; + wcex.lpfnWndProc = (WNDPROC)WndProc; + wcex.cbClsExtra = 0; + wcex.cbWndExtra = 0; + wcex.hInstance = hInstance; + wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_CPC_GUI); + wcex.hCursor = LoadCursor(NULL, IDC_ARROW); + wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW); + wcex.lpszMenuName = (LPCSTR)IDC_CPC_GUI; + wcex.lpszClassName = szWindowClass; + wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL); + + return RegisterClassEx(&wcex); +} + + +BOOL InitInstance(HINSTANCE hInstance, int nCmdShow){ + + HWND hWnd; + + hInst = hInstance; + + hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW, + CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL); + + InitCommonControls(); + + if (!hWnd) return FALSE ; + + ShowWindow(hWnd, nCmdShow) ; + UpdateWindow(hWnd) ; + + return TRUE; +} + +LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam){ + + int wmId, wmEvent; + PAINTSTRUCT ps; + HDC hdc; + int c = 0 ; + + switch (message) + { + + case WM_CREATE: + _assert(controls.Create(hInst, hWnd)) ; + return 0 ; + + case WM_COMMAND: + wmId = LOWORD(wParam); + wmEvent = HIWORD(wParam); + + switch (wmId){ + case IDM_ABOUT: + DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About); + break; + case IDM_EXIT: + DestroyWindow(hWnd); + break; + default: + return DefWindowProc(hWnd, message, wParam, lParam); + } + break; + + case WM_NOTIFY: + switch (((LPNMHDR) lParam)->code) { + case TTN_GETDISPINFO: { + + LPTOOLTIPTEXT lpttt; + lpttt = (LPTOOLTIPTEXT) lParam; + lpttt->hinst = hInst; + + int idButton = lpttt->hdr.idFrom; + + switch (idButton){ + case IDM_NEW: + lpttt->lpszText = MAKEINTRESOURCE(IDS_TIP_NEW); + break; + case IDM_DELETE: + lpttt->lpszText = MAKEINTRESOURCE(IDS_TIP_DELETE); + break; + case IDM_PROPS: + lpttt->lpszText = MAKEINTRESOURCE(IDS_TIP_PROPS); + break; + } + break; + } + case TVN_SELCHANGED: { + LPNMTREEVIEW pnmtv ; + + pnmtv = (LPNMTREEVIEW) lParam ; + controls.ToggleListViews(pnmtv) ; + + break ; + } + + case NM_RCLICK: { + LPNMHDR lpnmh ; + lpnmh = (LPNMHDR) lParam ; + switch(lpnmh->idFrom){ + case ID_TREEVIEW: + break; + default: + break ; + } + } + + default: + break; + } + + + case WM_PAINT: + hdc = BeginPaint(hWnd, &ps) ; + EndPaint(hWnd, &ps); + break; + + case WM_SIZE: + controls.Resize() ; + return 0 ; + + case WM_DESTROY: + PostQuitMessage(0); + break; + + default: + return DefWindowProc(hWnd, message, wParam, lParam); + } + return 0; +} + + +LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam){ + + switch (message){ + + case WM_INITDIALOG: + return TRUE; + + case WM_COMMAND: + if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL){ + EndDialog(hDlg, LOWORD(wParam)); + return TRUE; + } + break; + } + return FALSE; +} + + + + + diff --git a/ndb/src/cw/cpcc-win32/C++/CPC_GUI.dsp b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.dsp new file mode 100644 index 00000000000..91007b0a47e --- /dev/null +++ b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.dsp @@ -0,0 +1,216 @@ +# Microsoft Developer Studio Project File - Name="CPC_GUI" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Application" 0x0101 + +CFG=CPC_GUI - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "CPC_GUI.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "CPC_GUI.mak" CFG="CPC_GUI - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "CPC_GUI - Win32 Release" (based on "Win32 (x86) Application") +!MESSAGE "CPC_GUI - Win32 Debug" (based on "Win32 (x86) Application") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +MTL=midl.exe +RSC=rc.exe + +!IF "$(CFG)" == "CPC_GUI - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"stdafx.h" /FD /c +# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"stdafx.h" /FD /c +# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32 +# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32 +# ADD BASE RSC /l 0x409 /d "NDEBUG" +# ADD RSC /l 0x409 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib mfc42.lib /nologo /subsystem:windows /machine:I386 + +!ELSEIF "$(CFG)" == "CPC_GUI - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Debug" +# PROP Intermediate_Dir "Debug" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c +# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /FR /Yu"stdafx.h" /FD /GZ /c +# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32 +# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32 +# ADD BASE RSC /l 0x409 /d "_DEBUG" +# ADD RSC /l 0x409 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib comdlg32.lib advapi32.lib shell32.lib comctl32.lib mfc42d.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept + +!ENDIF + +# Begin Target + +# Name "CPC_GUI - Win32 Release" +# Name "CPC_GUI - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Source File + +SOURCE=.\CPC_GUI.cpp +# End Source File +# Begin Source File + +SOURCE=.\CPC_GUI.rc +# End Source File +# Begin Source File + +SOURCE=.\NdbControls.cpp +# End Source File +# Begin Source File + +SOURCE=.\StdAfx.cpp +# ADD CPP /Yc"stdafx.h" +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Source File + +SOURCE=.\CPC_GUI.h +# End Source File +# Begin Source File + +SOURCE=.\NdbControls.h +# End Source File +# Begin Source File + +SOURCE=.\resource.h +# End Source File +# Begin Source File + +SOURCE=.\StdAfx.h +# End Source File +# End Group +# Begin Group "Resource Files" + +# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" +# Begin Source File + +SOURCE=.\bitmap1.bmp +# End Source File +# Begin Source File + +SOURCE=.\bmp00001.bmp +# End Source File +# Begin Source File + +SOURCE=.\C.bmp +# End Source File +# Begin Source File + +SOURCE=.\Closed.BMP +# End Source File +# Begin Source File + +SOURCE=.\Closed.ICO +# End Source File +# Begin Source File + +SOURCE=.\Closed24.bmp +# End Source File +# Begin Source File + +SOURCE=.\Computer24.BMP +# End Source File +# Begin Source File + +SOURCE=.\CPC_GUI.ico +# End Source File +# Begin Source File + +SOURCE=.\Db.bmp +# End Source File +# Begin Source File + +SOURCE=.\icon1.ico +# End Source File +# Begin Source File + +SOURCE=.\O.bmp +# End Source File +# Begin Source File + +SOURCE=.\Open.BMP +# End Source File +# Begin Source File + +SOURCE=.\Open.ICO +# End Source File +# Begin Source File + +SOURCE=.\Open24.bmp +# End Source File +# Begin Source File + +SOURCE=.\small.ico +# End Source File +# Begin Source File + +SOURCE=.\toolbar.bmp +# End Source File +# Begin Source File + +SOURCE=.\toolbar1.bmp +# End Source File +# Begin Source File + +SOURCE=.\Tower2.ICO +# End Source File +# Begin Source File + +SOURCE=.\TowerIC1.BMP +# End Source File +# End Group +# Begin Source File + +SOURCE=.\ReadMe.txt +# End Source File +# End Target +# End Project diff --git a/ndb/src/cw/cpcc-win32/C++/CPC_GUI.dsw b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.dsw new file mode 100644 index 00000000000..1f163a31662 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.dsw @@ -0,0 +1,29 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00 +# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! + +############################################################################### + +Project: "CPC_GUI"=.\CPC_GUI.dsp - Package Owner=<4> + +Package=<5> +{{{ +}}} + +Package=<4> +{{{ +}}} + +############################################################################### + +Global: + +Package=<5> +{{{ +}}} + +Package=<3> +{{{ +}}} + +############################################################################### + diff --git a/ndb/src/cw/cpcc-win32/C++/CPC_GUI.h b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.h new file mode 100644 index 00000000000..cf7670948a7 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.h @@ -0,0 +1,40 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#if !defined(AFX_CPC_GUI_H__EA01C861_C56D_48F1_856F_4935E20620B1__INCLUDED_) +#define AFX_CPC_GUI_H__EA01C861_C56D_48F1_856F_4935E20620B1__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + + +#define MAX_LOADSTRING 100 + + + +#define TV_ROOT_ITEMS 2 + + +// Global Variables + +ATOM NdbRegisterClass(HINSTANCE) ; +BOOL InitInstance(HINSTANCE, int) ; +LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM) ; +LRESULT CALLBACK About(HWND, UINT, WPARAM, LPARAM); + +#endif // !defined(AFX_CPC_GUI_H__EA01C861_C56D_48F1_856F_4935E20620B1__INCLUDED_) diff --git a/ndb/src/cw/cpcc-win32/C++/CPC_GUI.ico b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.ico new file mode 100644 index 00000000000..386883523bc Binary files /dev/null and b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.ico differ diff --git a/ndb/src/cw/cpcc-win32/C++/CPC_GUI.rc b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.rc new file mode 100644 index 00000000000..41d75b2b282 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.rc @@ -0,0 +1,193 @@ +//Microsoft Developer Studio generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#define APSTUDIO_HIDDEN_SYMBOLS +#include "windows.h" +#undef APSTUDIO_HIDDEN_SYMBOLS +#include "resource.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDI_CPC_GUI ICON DISCARDABLE "CPC_GUI.ICO" +IDI_SMALL ICON DISCARDABLE "SMALL.ICO" + +///////////////////////////////////////////////////////////////////////////// +// +// Menu +// + +IDM_CPC_GUI MENU DISCARDABLE +BEGIN + POPUP "&File" + BEGIN + MENUITEM "E&xit", IDM_EXIT + END + POPUP "&Actions" + BEGIN + MENUITEM "&Insert...", ID_ACTIONS_INSERT + MENUITEM "&Delete", ID_ACTIONS_DELETE + MENUITEM "&Properties", ID_ACTIONS_PROPERTIES + END + POPUP "&Help" + BEGIN + MENUITEM "&About ...", IDM_ABOUT + END +END + +IDM_TREEVIEW MENU DISCARDABLE +BEGIN + MENUITEM "&Insert", ID_TREEVIEW1 + MENUITEM "&Delete", ID_DELETE + MENUITEM "&Properties", ID_PROPERTIES +END + + +///////////////////////////////////////////////////////////////////////////// +// +// Accelerator +// + +IDC_CPC_GUI ACCELERATORS MOVEABLE PURE +BEGIN + "?", IDM_ABOUT, ASCII, ALT + "/", IDM_ABOUT, ASCII, ALT +END + + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_ABOUTBOX DIALOG DISCARDABLE 22, 17, 230, 75 +STYLE DS_MODALFRAME | WS_CAPTION | WS_SYSMENU +CAPTION "About" +FONT 8, "MS Sans Serif" +BEGIN + LTEXT "NDB Cluster Process Control Applet v1.0",IDC_STATIC,7,8, + 213,8,SS_NOPREFIX + LTEXT "Copyright (C) 2003 MySQL AB", + IDC_STATIC,7,20,213,20 + DEFPUSHBUTTON "OK",IDOK,185,55,41,16,WS_GROUP +END + + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +2 TEXTINCLUDE MOVEABLE PURE +BEGIN + "#define APSTUDIO_HIDDEN_SYMBOLS\r\n" + "#include ""windows.h""\r\n" + "#undef APSTUDIO_HIDDEN_SYMBOLS\r\n" + "#include ""resource.h""\r\n" + "\0" +END + +3 TEXTINCLUDE MOVEABLE PURE +BEGIN + "\r\n" + "\0" +END + +1 TEXTINCLUDE MOVEABLE PURE +BEGIN + "resource.h\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Bitmap +// + +IDR_TOOLBAR BITMAP MOVEABLE PURE "toolbar.bmp" +IDB_TOOLBAR BITMAP MOVEABLE PURE "bitmap1.bmp" +IDB_COMPUTER BITMAP MOVEABLE PURE "TowerIC1.BMP" +IDB_OPEN BITMAP MOVEABLE PURE "Open.BMP" +IDB_CLOSED BITMAP MOVEABLE PURE "Closed.BMP" +IDB_DATABASE BITMAP MOVEABLE PURE "DB.bmp" + +///////////////////////////////////////////////////////////////////////////// +// +// Toolbar +// + +IDR_TOOLBAR TOOLBAR MOVEABLE PURE 18, 18 +BEGIN + BUTTON ID_BUTTON32773 + BUTTON ID_BUTTON32783 + BUTTON ID_BUTTON32784 +END + + +///////////////////////////////////////////////////////////////////////////// +// +// String Table +// + +STRINGTABLE DISCARDABLE +BEGIN + IDS_APP_TITLE "NDB Cluster Process Control Applet" + IDS_TV_ROOT_COMPUTERS "Computers" + IDS_TV_ROOT_DATABASES "Databases" + IDS_LV_COMPUTER_HEADER_1 "Computer" + IDS_LV_COMPUTER_HEADER_2 "Hostname" + IDS_LV_PROCESS_HEADER_1 "Process" + IDC_CPC_GUI "CPC_GUI" + IDS_TIP_NEW "Add new computer or database" + IDS_TIP_DELETE "Delete selected computer or database" +END + +STRINGTABLE DISCARDABLE +BEGIN + IDS_TIP_PROPS "Display properties for selected computer or database" + IDS_LV_PROCESS_HEADER_2 "Name" + IDS_LV_PROCESS_HEADER_3 "Owner" + IDS_LV_PROCESS_HEADER_4 "Status" + IDS_LV_COMPUTER_HEADER_3 "Status" +END + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/ndb/src/cw/cpcc-win32/C++/CPC_GUI.sln b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.sln new file mode 100644 index 00000000000..86b574d851d --- /dev/null +++ b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.sln @@ -0,0 +1,21 @@ +Microsoft Visual Studio Solution File, Format Version 7.00 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CPC_GUI", "CPC_GUI.vcproj", "{F5FADD9D-4353-4A73-88DC-474A4D17B485}" +EndProject +Global + GlobalSection(SolutionConfiguration) = preSolution + ConfigName.0 = Debug + ConfigName.1 = Release + EndGlobalSection + GlobalSection(ProjectDependencies) = postSolution + EndGlobalSection + GlobalSection(ProjectConfiguration) = postSolution + {F5FADD9D-4353-4A73-88DC-474A4D17B485}.Debug.ActiveCfg = Debug|Win32 + {F5FADD9D-4353-4A73-88DC-474A4D17B485}.Debug.Build.0 = Debug|Win32 + {F5FADD9D-4353-4A73-88DC-474A4D17B485}.Release.ActiveCfg = Release|Win32 + {F5FADD9D-4353-4A73-88DC-474A4D17B485}.Release.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + EndGlobalSection + GlobalSection(ExtensibilityAddIns) = postSolution + EndGlobalSection +EndGlobal diff --git a/ndb/src/cw/cpcc-win32/C++/CPC_GUI.suo b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.suo new file mode 100644 index 00000000000..e7d178f04c3 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.suo differ diff --git a/ndb/src/cw/cpcc-win32/C++/CPC_GUI.vcproj b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.vcproj new file mode 100644 index 00000000000..56f9f3a8511 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/C++/CPC_GUI.vcproj @@ -0,0 +1,240 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/ndb/src/cw/cpcc-win32/C++/Closed.ICO b/ndb/src/cw/cpcc-win32/C++/Closed.ICO new file mode 100644 index 00000000000..044042b42fb Binary files /dev/null and b/ndb/src/cw/cpcc-win32/C++/Closed.ICO differ diff --git a/ndb/src/cw/cpcc-win32/C++/NdbControls.cpp b/ndb/src/cw/cpcc-win32/C++/NdbControls.cpp new file mode 100644 index 00000000000..6bbc9a9859b --- /dev/null +++ b/ndb/src/cw/cpcc-win32/C++/NdbControls.cpp @@ -0,0 +1,436 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "stdafx.h" +#include "NdbControls.h" + + +/** +* CNdbControl implementation +*/ + +BOOL CNdbControl::GetRect(LPRECT lprc) const { + + _ASSERT(this) ; + + return GetClientRect(m_hControl, lprc) ; + +} + +BOOL CNdbControl::Resize(LONG x, LONG y, LONG w, LONG h) const { + + _ASSERT(this) ; + + if(!MoveWindow(m_hControl, x, y, w, h, TRUE)) + return FALSE ; + if(m_bVisible){ + ShowWindow(m_hControl, SW_SHOW) ; + UpdateWindow(m_hControl) ; + } + return TRUE ; + +} + +BOOL CNdbControl::Show(BOOL bShow) { + + _ASSERT(this) ; + + if(bShow){ + ShowWindow(m_hControl, SW_SHOW); + m_bVisible = TRUE ; + }else{ + ShowWindow(m_hControl, SW_HIDE); + m_bVisible = FALSE ; + } + EnableWindow(m_hControl, bShow) ; + UpdateWindow(m_hControl) ; + + return TRUE ; +} + + + +CNdbControl::~CNdbControl(){ + + DestroyWindow(m_hControl) ; + if(m_hMenu) + DestroyMenu(m_hMenu) ; + +} + + +/** +* CNdbListView implementation +*/ + +BOOL CNdbListView::Create(HINSTANCE hInst, HWND hParent, DWORD dwId, NDB_ITEM_TYPE enType, PNDB_LV pstH, DWORD dwWidth) { + + if(!pstH) + return FALSE ; + + LV_COLUMN lvC ; + m_hInstance = hInst ; + m_hParent = hParent ; + m_dwId = dwId ; + m_dwWidth = dwWidth ; + m_dwWidth = 100 ; + m_enType = enType; + char* szLabels[MAX_LV_HEADERS] ; + int count = 0 ; + + m_hControl = CreateWindowEx(WS_EX_OVERLAPPEDWINDOW, WC_LISTVIEW, TEXT(""), + WS_VISIBLE | WS_CHILD | WS_BORDER | LVS_REPORT, + 0, 0, 0, 0, m_hParent, (HMENU)m_dwId, hInst, NULL ); + + if(!m_hControl) + return FALSE ; + + lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM; + lvC.fmt = LVCFMT_LEFT; + + switch(enType){ + case ITEM_COMPR_ROOT: + szLabels[0] = pstH->szComputer ; + szLabels[1] = pstH->szHostname ; + szLabels[2] = pstH->szStatus ; + count = 3 ; + break ; + case ITEM_DB_ROOT: + szLabels[0] = pstH->szDatabase ; + szLabels[1] = pstH->szStatus ; + count = 2 ; + break ; + case ITEM_COMPR: + szLabels[0] = pstH->szProcess ; + szLabels[1] = pstH->szDatabase; + szLabels[2] = pstH->szOwner ; + szLabels[3] = pstH->szStatus ; + count = 4 ; + case ITEM_DB: + szLabels[0] = pstH->szProcess ; + szLabels[1] = pstH->szComputer; + szLabels[2] = pstH->szOwner ; + szLabels[3] = pstH->szStatus ; + count = 4 ; + break ; + NDB_DEFAULT_UNREACHABLE ; + } + + for(int j = 0 ; j < count ; ++j){ + lvC.iSubItem = j ; + lvC.cx = m_dwWidth ; + lvC.pszText = szLabels[j] ; + if(0xFFFFFFFF == ListView_InsertColumn(m_hControl, j, &lvC)) + return FALSE ; + } + + SendMessage(m_hControl, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_FULLROWSELECT, + LVS_EX_FULLROWSELECT ); + + ShowWindow(m_hControl, SW_SHOW) ; + + return TRUE ; + +} + + + +/** +* CNdbToolBar implementation +*/ + + + +/** +* CNdbTreeView implementation +*/ + +BOOL CNdbTreeView::Create(HINSTANCE hInst, HWND hParent, DWORD dwMenuId, DWORD dwId){ + + if(!CreateTreeView(hInst, hParent, dwId)) + return FALSE ; + + m_hMenu = LoadMenu(m_hInstance,MAKEINTRESOURCE(dwMenuId)) ; + if(!m_hMenu) + return FALSE ; + + return TRUE ; +} + + +BOOL CNdbTreeView::CreateTreeView(HINSTANCE hInst, HWND hParent, DWORD dwId){ + + + m_hInstance = hInst ; + m_hParent = hParent ; + m_dwId = dwId ; + HIMAGELIST himl ; + HBITMAP hbmp ; + DWORD dwCount = 0 ; + + m_hControl = CreateWindowEx(WS_EX_OVERLAPPEDWINDOW, WC_TREEVIEW, "Tree View", + WS_VISIBLE | WS_CHILD | WS_BORDER | TVS_HASLINES | + TVS_HASBUTTONS | TVS_LINESATROOT | TVS_SINGLEEXPAND, + 0, 0, 0, 0, m_hParent, (HMENU)m_dwId, m_hInstance, NULL) ; + + if(!m_hControl) + return FALSE ; + + if((himl = ImageList_Create(nX, nY, ILC_MASK | ILC_COLOR8, 4, 0)) == NULL) + return FALSE ; + + hbmp = LoadBitmap(m_hInstance, MAKEINTRESOURCE(IDI_OPEN)); + hbmp = (HBITMAP)LoadImage(m_hInstance, MAKEINTRESOURCE(IDB_OPEN), IMAGE_BITMAP, nX, 0, LR_DEFAULTSIZE); + m_nOpen = ImageList_AddMasked(himl, hbmp, clr); + DeleteObject(hbmp); + hbmp = (HBITMAP)LoadImage(m_hInstance, MAKEINTRESOURCE(IDB_CLOSED), IMAGE_BITMAP, 0, 0, LR_DEFAULTSIZE); + m_nClosed = ImageList_AddMasked(himl, hbmp, clr); + DeleteObject(hbmp); + hbmp = (HBITMAP)LoadImage(m_hInstance, MAKEINTRESOURCE(IDB_COMPUTER),IMAGE_BITMAP, 0, 0, LR_DEFAULTSIZE); + m_nComputer = ImageList_AddMasked(himl, hbmp, clr); + DeleteObject(hbmp); + hbmp = (HBITMAP)LoadImage(m_hInstance, MAKEINTRESOURCE(IDB_DATABASE), IMAGE_BITMAP, 0, 0, LR_DEFAULTSIZE); + m_nDatabase = ImageList_AddMasked(himl, hbmp, clr); + DeleteObject(hbmp); + + if(ImageList_GetImageCount(himl) < 4) + return FALSE ; + + TreeView_SetImageList(m_hControl, himl, TVSIL_NORMAL); + + ShowWindow(m_hControl, SW_SHOW) ; + + return TRUE ; + +} + + + +HTREEITEM CNdbTreeView::AddItem(LPSTR szText, NDB_ITEM_TYPE enType, DWORD dwLVId){ + + TVITEM tvi ; + TVINSERTSTRUCT tvins ; + HTREEITEM hti ; + HTREEITEM hTemp ; + int nImage = m_nClosed ; + + tvi.mask = TVIF_TEXT | TVIF_IMAGE + | TVIF_SELECTEDIMAGE | TVIF_PARAM; + + tvi.pszText = szText; + tvi.cchTextMax = lstrlen(szText); + + switch(enType){ + + case ITEM_COMPR_ROOT: + nImage = m_nClosed ; + if(!m_hPrevRoot) + tvins.hParent = TVI_ROOT; + else + tvins.hInsertAfter = m_hPrevRoot ; + break ; + + case ITEM_DB_ROOT: + if(!m_hPrevRoot) + tvins.hParent = TVI_ROOT; + else + tvins.hInsertAfter = m_hPrevRoot ; + break ; + + case ITEM_COMPR: + nImage = m_nComputer ; + if(!m_hPrevComputersChild || !m_hComputersRoot) + return 0 ; + else + tvins.hInsertAfter = m_hPrevComputersChild ; + tvins.hParent = m_hComputersRoot ; + break ; + + case ITEM_DB: + nImage = m_nDatabase ; + if(!m_hPrevComputersChild || !m_hComputersRoot) + return 0 ; + else + tvins.hInsertAfter = m_hPrevDatabasesChild ; + tvins.hParent = m_hDatabasesRoot ; + break ; + + NDB_DEFAULT_UNREACHABLE ; + + } + + tvi.iImage = nImage ; + tvi.iSelectedImage = nImage ; + tvi.lParam = (LPARAM) dwLVId ; + tvins.item = tvi ; + + hTemp = TreeView_InsertItem(m_hControl, &tvins); + if(!hTemp) + return NULL ; + + switch(enType){ + + case ITEM_COMPR_ROOT: + m_hComputersRoot = hTemp ; + break ; + + case ITEM_DB_ROOT: + m_hDatabasesRoot = hTemp ; + break ; + + case ITEM_COMPR: + m_hPrevComputersChild = hTemp ; + break ; + + case ITEM_DB: + m_hPrevComputersChild = hTemp ; + break ; + + NDB_DEFAULT_UNREACHABLE ; + + } + + if (ITEM_COMPR_ROOT != enType && ITEM_DB_ROOT != enType) { + + hti = TreeView_GetParent(m_hControl, hTemp); + tvi.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE; + tvi.hItem = hti; + tvi.iImage = m_nClosed; + tvi.iSelectedImage = m_nClosed; + TreeView_SetItem(m_hControl, &tvi); + + } + + return hTemp ; +} + + +BOOL CNdbControls::Create(HINSTANCE hInst, HWND hParent){ + + m_hInstance = hInst ; + m_hParent = hParent ; + m_tb.Create(m_hInstance, m_hParent, ID_TOOLBAR, IDB_TOOLBAR) ; + m_sb.Create(m_hInstance, m_hParent, ID_STATUSBAR) ; + m_tv.Create(m_hInstance, m_hParent, IDM_TREEVIEW, ID_TREEVIEW) ; + _assert(AddView("Computers", ITEM_COMPR_ROOT)) ; + _assert(AddView("Databases", ITEM_DB_ROOT)) ; + + return TRUE ; +} + +BOOL CNdbControls::AddListView(NDB_ITEM_TYPE enType, DWORD dwId){ + + int count ; + CNdbListView* plv ; + PNDB_LV pst ; + + plv = new CNdbListView ; + + if(!plv) + return FALSE ; + + count = m_map_lvc.GetCount() + m_dwFirstId_lv ; + + switch(enType){ + case ITEM_COMPR_ROOT: + pst = &m_stlvcRoot ; + break ; + case ITEM_DB_ROOT: + pst = &m_stlvdRoot ; + break ; + case ITEM_COMPR: + pst = &m_stlvc ; + break ; + case ITEM_DB: + pst = &m_stlvd ; + break ; + NDB_DEFAULT_UNREACHABLE ; + } + + plv->Create(m_hInstance, m_hParent, dwId, enType, pst, LV_HEADER_WIDTH) ; + + m_map_lvc[count] = plv ; + + return TRUE ; +} + +BOOL CNdbControls::AddView(LPSTR szText, NDB_ITEM_TYPE enType){ + + DWORD dwId_lv = m_dwNextId_lv ; + + if(AddListView(enType, dwId_lv) && m_tv.AddItem(szText, enType, dwId_lv)) + m_dwNextId_lv++ ; + else + return FALSE ; + + return TRUE ; +}; + + +VOID CNdbControls::ToggleListViews(LPNMTREEVIEW pnmtv){ + + CNdbListView* plv ; + int count = m_map_lvc.GetCount() + m_dwFirstId_lv ; + + for(int c = FIRST_ID_LV ; c < count; ++c){ + _assert(m_map_lvc.Lookup(c, plv)) ; + if(pnmtv->itemNew.lParam == (c)) + plv->Show(TRUE) ; + else + plv->Show(FALSE) ; + } +} + + + +VOID CNdbControls::Resize(){ + + RECT rc, rcTB, rcSB ; + LONG tw, sw, lx, ly, lw, lh, tvw, tvh ; + CNdbListView* plv ; + int count ; //, id ; + + GetClientRect(m_hParent, &rc) ; + m_tb.GetRect(&rcTB) ; + m_sb.GetRect(&rcSB) ; + + sw = rcSB.bottom ; + tw = rcTB.bottom ; + + m_tb.Resize(0, 0, rc.right, tw) ; + + tvw = rc.right / 4 ; + tvh = rc.bottom - sw - tw - BORDER ; + + m_tv.Resize(0, tw + BORDER, tvw, tvh) ; + + m_sb.Resize(0, tvh, rc.left, sw) ; + + lx = tvw + BORDER - 2 ; + ly = tw + BORDER ; + lw = rc.right - tvw - BORDER + 1 ; + lh = tvh ; + + count = m_map_lvc.GetCount() + FIRST_ID_LV ; + + for(int c = FIRST_ID_LV ; c < count; ++c){ + _assert(m_map_lvc.Lookup(c, plv)) ; + plv->Resize(lx, ly, lw, lh) ; + } + + return ; + +} diff --git a/ndb/src/cw/cpcc-win32/C++/Open.ICO b/ndb/src/cw/cpcc-win32/C++/Open.ICO new file mode 100644 index 00000000000..ab7b05d9df7 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/C++/Open.ICO differ diff --git a/ndb/src/cw/cpcc-win32/C++/StdAfx.cpp b/ndb/src/cw/cpcc-win32/C++/StdAfx.cpp new file mode 100644 index 00000000000..8fcdb4ce158 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/C++/StdAfx.cpp @@ -0,0 +1,24 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +// stdafx.cpp : source file that includes just the standard includes +// CPC_GUI.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +// TODO: reference any additional headers you need in STDAFX.H +// and not in this file diff --git a/ndb/src/cw/cpcc-win32/C++/StdAfx.h b/ndb/src/cw/cpcc-win32/C++/StdAfx.h new file mode 100644 index 00000000000..d84b5811f8d --- /dev/null +++ b/ndb/src/cw/cpcc-win32/C++/StdAfx.h @@ -0,0 +1,72 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__A9DB83DB_A9FD_11D0_BFD1_444553540000__INCLUDED_) +#define AFX_STDAFX_H__A9DB83DB_A9FD_11D0_BFD1_444553540000__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +#ifdef _DEBUG +#define NDB_DEFAULT_UNREACHABLE default: _ASSERT(0); break +#elif _MSC_VER >= 1200 +#define NDB_DEFAULT_UNREACHABLE default: __assume(0); break +#else +#define NDB_DEFAULT_UNREACHABLE default: break +#endif; + + +#ifdef _DEBUG +#define _assert _ASSERT +#else +#define _assert(expr) expr +#endif + + +#include +#include + +// C RunTime Header Files +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Local Header Files +#include "resource.h" +#include "NdbControls.h" +#include "CPC_GUI.h" + + +// TODO: reference additional headers your program requires here + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__A9DB83DB_A9FD_11D0_BFD1_444553540000__INCLUDED_) diff --git a/ndb/src/cw/cpcc-win32/C++/TreeView.cpp b/ndb/src/cw/cpcc-win32/C++/TreeView.cpp new file mode 100644 index 00000000000..db5c62f14bb --- /dev/null +++ b/ndb/src/cw/cpcc-win32/C++/TreeView.cpp @@ -0,0 +1,19 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "StdAfx.h" +#include "resource.h" +#include "CPC_GUI.h" diff --git a/ndb/src/cw/cpcc-win32/C++/TreeView.h b/ndb/src/cw/cpcc-win32/C++/TreeView.h new file mode 100644 index 00000000000..595f9bd6cdc --- /dev/null +++ b/ndb/src/cw/cpcc-win32/C++/TreeView.h @@ -0,0 +1,19 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + + diff --git a/ndb/src/cw/cpcc-win32/C++/bmp00001.bmp b/ndb/src/cw/cpcc-win32/C++/bmp00001.bmp new file mode 100644 index 00000000000..e50af403eda Binary files /dev/null and b/ndb/src/cw/cpcc-win32/C++/bmp00001.bmp differ diff --git a/ndb/src/cw/cpcc-win32/C++/resource.h b/ndb/src/cw/cpcc-win32/C++/resource.h new file mode 100644 index 00000000000..0bec552edf6 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/C++/resource.h @@ -0,0 +1,90 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +//{{NO_DEPENDENCIES}} +// Microsoft Developer Studio generated include file. +// Used by CPC_GUI.rc +// +#define IDC_MYICON 2 +#define IDD_CPC_GUI_DIALOG 102 +#define IDD_ABOUTBOX 103 +#define IDS_APP_TITLE 103 +#define IDM_ABOUT 104 +#define IDS_LV_ROOT_COMPUTERS 104 +#define IDS_TV_ROOT_COMPUTERS 104 +#define IDM_EXIT 105 +#define IDS_LV_ROOT_DATABASES 105 +#define IDS_TV_ROOT_DATABASES 105 +#define IDS_HELLO 106 +#define IDS_LV_COMPUTER_HEADER_1 106 +#define IDI_CPC_GUI 107 +#define IDS_LV_COMPUTER_HEADER_2 107 +#define IDI_SMALL 108 +#define IDS_LV_PROCESS_HEADER_1 108 +#define IDC_CPC_GUI 109 +#define IDM_CPC_GUI 109 +#define IDS_TIP_NEW 110 +#define IDS_TIP_DELETE 111 +#define IDS_TIP_PROPS 112 +#define IDS_LV_PROCESS_HEADER_2 113 +#define IDS_LV_PROCESS_HEADER_3 114 +#define IDS_LV_PROCESS_HEADER_4 115 +#define IDS_LV_COMPUTER_HEADER_3 116 +#define IDR_MAINFRAME 128 +#define ID_TREEVIEW 130 +#define IDM_TREEVIEW 130 +#define IDB_TOOLBAR 137 +#define ID_TOOLBAR 158 +#define IDB_COMPUTER 168 +#define IDB_CLOSED 169 +#define IDB_OPEN 170 +#define IDI_DATABASE 172 +#define IDI_CLOSED 175 +#define IDI_OPEN 176 +#define IDI_COMPUTER 177 +#define IDB_MASK 178 +#define IDB_DATABASE 182 +#define IDM_TV 183 +#define ID_TREEVIEW1 32771 +#define ID_BUTTON32773 32773 +#define IDM_NEW 32774 +#define IDM_DELETE 32775 +#define IDM_PROPS 32776 +#define ID_LIST_C 32777 +#define ID_ACTIONS_INSERT 32778 +#define ID_ACTIONS_DELETE 32779 +#define ID_DELETE 32780 +#define ID_PROPERTIES 32781 +#define ID_ACTIONS_PROPERTIES 32782 +#define ID_BUTTON32783 32783 +#define ID_BUTTON32784 32784 +#define ID_LIST_P 32785 +#define ID_STATUSBAR 32786 +#define ID_LIST_C_ROOT 32787 +#define ID_LIST_D_ROOT 32788 +#define IDM_ADDNEW 32793 +#define IDC_STATIC -1 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 184 +#define _APS_NEXT_COMMAND_VALUE 32796 +#define _APS_NEXT_CONTROL_VALUE 1000 +#define _APS_NEXT_SYMED_VALUE 110 +#endif +#endif diff --git a/ndb/src/cw/cpcc-win32/C++/small.ico b/ndb/src/cw/cpcc-win32/C++/small.ico new file mode 100644 index 00000000000..8f94d9aa828 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/C++/small.ico differ diff --git a/ndb/src/cw/cpcc-win32/C++/toolbar.bmp b/ndb/src/cw/cpcc-win32/C++/toolbar.bmp new file mode 100644 index 00000000000..a1059352c66 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/C++/toolbar.bmp differ diff --git a/ndb/src/cw/cpcc-win32/csharp/App.ico b/ndb/src/cw/cpcc-win32/csharp/App.ico new file mode 100644 index 00000000000..3a5525fd794 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/csharp/App.ico differ diff --git a/ndb/src/cw/cpcc-win32/csharp/AssemblyInfo.cs b/ndb/src/cw/cpcc-win32/csharp/AssemblyInfo.cs new file mode 100644 index 00000000000..9f89a3282c5 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/AssemblyInfo.cs @@ -0,0 +1,58 @@ +using System.Reflection; +using System.Runtime.CompilerServices; + +// +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +// +[assembly: AssemblyTitle("")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("")] +[assembly: AssemblyCopyright("")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Revision and Build Numbers +// by using the '*' as shown below: + +[assembly: AssemblyVersion("1.0.*")] + +// +// In order to sign your assembly you must specify a key to use. Refer to the +// Microsoft .NET Framework documentation for more information on assembly signing. +// +// Use the attributes below to control which key is used for signing. +// +// Notes: +// (*) If no key is specified, the assembly is not signed. +// (*) KeyName refers to a key that has been installed in the Crypto Service +// Provider (CSP) on your machine. KeyFile refers to a file which contains +// a key. +// (*) If the KeyFile and the KeyName values are both specified, the +// following processing occurs: +// (1) If the KeyName can be found in the CSP, that key is used. +// (2) If the KeyName does not exist and the KeyFile does exist, the key +// in the KeyFile is installed into the CSP and used. +// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility. +// When specifying the KeyFile, the location of the KeyFile should be +// relative to the project output directory which is +// %Project Directory%\obj\. For example, if your KeyFile is +// located in the project directory, you would specify the AssemblyKeyFile +// attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")] +// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework +// documentation for more information on this. +// +[assembly: AssemblyDelaySign(false)] +[assembly: AssemblyKeyFile("")] +[assembly: AssemblyKeyName("")] diff --git a/ndb/src/cw/cpcc-win32/csharp/CPC_Form.cs b/ndb/src/cw/cpcc-win32/csharp/CPC_Form.cs new file mode 100644 index 00000000000..ea1798c8c67 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/CPC_Form.cs @@ -0,0 +1,1400 @@ +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using System.Windows.Forms; +using System.Data; +using System.Threading; + +namespace NDB_CPC +{ + /// + /// Summary description for Form1. + /// + public class CPC : System.Windows.Forms.Form + { + private System.Windows.Forms.TreeView tvComputerCluster; + private System.Windows.Forms.ContextMenu ctxTreeViewMenu; + private System.Windows.Forms.ColumnHeader chComputer; + private System.Windows.Forms.ColumnHeader chProcessName; + private System.Windows.Forms.ContextMenu ctxListViewMenu; + private System.Windows.Forms.MenuItem mainMenuItem; + private System.Windows.Forms.ColumnHeader chProcesses; + private System.Windows.Forms.MainMenu mainMenu; + private System.Windows.Forms.Panel panel1; + private System.Windows.Forms.MenuItem menuItem7; + private System.Windows.Forms.MenuItem menuItem10; + private System.Windows.Forms.MenuItem mainMenuFile; + private System.Windows.Forms.MenuItem mainMenuComputer; + private System.Windows.Forms.MenuItem subMenuComputerAdd; + private System.Windows.Forms.MenuItem subMenuComputerRemove; + private System.Windows.Forms.MenuItem subMenuComputerDisconnect; + private System.Windows.Forms.MenuItem subMenuComputerProperties; + private System.ComponentModel.IContainer components; + + private System.Windows.Forms.MenuItem menuItem3; + private System.Windows.Forms.MenuItem computerMenuAdd; + private System.Windows.Forms.MenuItem computerMenuRemove; + private System.Windows.Forms.MenuItem menuItem5; + private System.Windows.Forms.MenuItem computerMenuDisconnect; + private System.Windows.Forms.MenuItem computerMenuConnect; + private System.Windows.Forms.MenuItem computerMenuProperties; + private System.Windows.Forms.MenuItem menuItem11; + private System.Windows.Forms.MenuItem tvCtxMenuComputerAdd; + private System.Windows.Forms.MenuItem tvCtxMenuComputerRemove; + private System.Windows.Forms.MenuItem tvCtxMenuComputerConnect; + private System.Windows.Forms.MenuItem tvCtxMenuComputerDisconnect; + private System.Windows.Forms.MenuItem tvCtxMenuComputerDefine; + private System.Windows.Forms.MenuItem tvCtxMenuDatabaseNew; + private System.Windows.Forms.MenuItem menuItem1; + private System.Windows.Forms.MenuItem menuItem2; + private System.Windows.Forms.MenuItem mainMenuDatabase; + private System.Windows.Forms.MenuItem subMenuDatabaseCreate; + private System.Windows.Forms.MenuItem menuItem8; + private System.Windows.Forms.MenuItem tvCtxMenuProperties; + private System.Windows.Forms.ImageList imageTV; + + private ComputerMgmt computerMgmt; + private System.Windows.Forms.MenuItem computerMenuRefresh; + private System.Windows.Forms.ListView listView; + private System.Windows.Forms.ColumnHeader chComputerIP; + private System.Windows.Forms.ColumnHeader chDatabase; + private System.Windows.Forms.ColumnHeader chName; + private System.Windows.Forms.ColumnHeader chOwner; + private System.Windows.Forms.ColumnHeader chStatus; + private System.Windows.Forms.Splitter splitter2; + private System.Windows.Forms.Splitter splitterVertical; + private System.Windows.Forms.Splitter splitterHorizont; + private Thread guiThread; + private float resizeWidthRatio; + private System.Windows.Forms.MenuItem menuItem6; + private System.Windows.Forms.MenuItem menuGetStatus; + private System.Windows.Forms.MenuItem menuStartProcess; + private System.Windows.Forms.MenuItem menuRestartProcess; + private System.Windows.Forms.MenuItem menuStopProcess; + private System.Windows.Forms.MenuItem menuRemoveProcess; + private System.Windows.Forms.MenuItem menuRefresh; + private System.Windows.Forms.OpenFileDialog openHostFileDialog; + private System.Windows.Forms.SaveFileDialog saveHostFileDialog; + private float resizeHeightRatio; + private System.Windows.Forms.TextBox mgmConsole; + int i; + public CPC() + { + // + // Required for Windows Form Designer support + // + InitializeComponent(); + + // TODO: Add any constructor code after InitializeComponent call + // + computerMgmt = new ComputerMgmt(); + guiThread = new Thread(new ThreadStart(updateGuiThread)); + + // guiThread.Start(); + } + + /// + /// Clean up any resources being used. + /// + protected override void Dispose( bool disposing ) + { + if( disposing ) + { + if (components != null) + { + components.Dispose(); + } + } + //guiThread.Abort(); + base.Dispose( disposing ); + } + + #region Windows Form Designer generated code + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.Resources.ResourceManager resources = new System.Resources.ResourceManager(typeof(CPC)); + this.tvComputerCluster = new System.Windows.Forms.TreeView(); + this.ctxTreeViewMenu = new System.Windows.Forms.ContextMenu(); + this.tvCtxMenuComputerAdd = new System.Windows.Forms.MenuItem(); + this.tvCtxMenuComputerRemove = new System.Windows.Forms.MenuItem(); + this.menuGetStatus = new System.Windows.Forms.MenuItem(); + this.menuItem6 = new System.Windows.Forms.MenuItem(); + this.tvCtxMenuComputerConnect = new System.Windows.Forms.MenuItem(); + this.tvCtxMenuComputerDisconnect = new System.Windows.Forms.MenuItem(); + this.tvCtxMenuDatabaseNew = new System.Windows.Forms.MenuItem(); + this.tvCtxMenuComputerDefine = new System.Windows.Forms.MenuItem(); + this.menuItem8 = new System.Windows.Forms.MenuItem(); + this.tvCtxMenuProperties = new System.Windows.Forms.MenuItem(); + this.imageTV = new System.Windows.Forms.ImageList(this.components); + this.ctxListViewMenu = new System.Windows.Forms.ContextMenu(); + this.menuStartProcess = new System.Windows.Forms.MenuItem(); + this.menuRestartProcess = new System.Windows.Forms.MenuItem(); + this.menuStopProcess = new System.Windows.Forms.MenuItem(); + this.menuRemoveProcess = new System.Windows.Forms.MenuItem(); + this.menuRefresh = new System.Windows.Forms.MenuItem(); + this.computerMenuAdd = new System.Windows.Forms.MenuItem(); + this.menuItem3 = new System.Windows.Forms.MenuItem(); + this.computerMenuRemove = new System.Windows.Forms.MenuItem(); + this.menuItem5 = new System.Windows.Forms.MenuItem(); + this.computerMenuDisconnect = new System.Windows.Forms.MenuItem(); + this.computerMenuConnect = new System.Windows.Forms.MenuItem(); + this.menuItem11 = new System.Windows.Forms.MenuItem(); + this.computerMenuProperties = new System.Windows.Forms.MenuItem(); + this.computerMenuRefresh = new System.Windows.Forms.MenuItem(); + this.chComputer = new System.Windows.Forms.ColumnHeader(); + this.chProcessName = new System.Windows.Forms.ColumnHeader(); + this.mainMenuItem = new System.Windows.Forms.MenuItem(); + this.chProcesses = new System.Windows.Forms.ColumnHeader(); + this.mainMenu = new System.Windows.Forms.MainMenu(); + this.mainMenuFile = new System.Windows.Forms.MenuItem(); + this.menuItem2 = new System.Windows.Forms.MenuItem(); + this.menuItem1 = new System.Windows.Forms.MenuItem(); + this.mainMenuComputer = new System.Windows.Forms.MenuItem(); + this.subMenuComputerAdd = new System.Windows.Forms.MenuItem(); + this.menuItem7 = new System.Windows.Forms.MenuItem(); + this.subMenuComputerDisconnect = new System.Windows.Forms.MenuItem(); + this.subMenuComputerRemove = new System.Windows.Forms.MenuItem(); + this.menuItem10 = new System.Windows.Forms.MenuItem(); + this.subMenuComputerProperties = new System.Windows.Forms.MenuItem(); + this.mainMenuDatabase = new System.Windows.Forms.MenuItem(); + this.subMenuDatabaseCreate = new System.Windows.Forms.MenuItem(); + this.panel1 = new System.Windows.Forms.Panel(); + this.mgmConsole = new System.Windows.Forms.TextBox(); + this.splitterHorizont = new System.Windows.Forms.Splitter(); + this.splitter2 = new System.Windows.Forms.Splitter(); + this.listView = new System.Windows.Forms.ListView(); + this.chComputerIP = new System.Windows.Forms.ColumnHeader(); + this.chStatus = new System.Windows.Forms.ColumnHeader(); + this.chDatabase = new System.Windows.Forms.ColumnHeader(); + this.chName = new System.Windows.Forms.ColumnHeader(); + this.chOwner = new System.Windows.Forms.ColumnHeader(); + this.splitterVertical = new System.Windows.Forms.Splitter(); + this.openHostFileDialog = new System.Windows.Forms.OpenFileDialog(); + this.saveHostFileDialog = new System.Windows.Forms.SaveFileDialog(); + this.panel1.SuspendLayout(); + this.SuspendLayout(); + // + // tvComputerCluster + // + this.tvComputerCluster.CausesValidation = false; + this.tvComputerCluster.ContextMenu = this.ctxTreeViewMenu; + this.tvComputerCluster.Dock = System.Windows.Forms.DockStyle.Left; + this.tvComputerCluster.ImageList = this.imageTV; + this.tvComputerCluster.Name = "tvComputerCluster"; + this.tvComputerCluster.Nodes.AddRange(new System.Windows.Forms.TreeNode[] { + new System.Windows.Forms.TreeNode("Computer", 0, 0), + new System.Windows.Forms.TreeNode("Database", 5, 5)}); + this.tvComputerCluster.Size = new System.Drawing.Size(104, 333); + this.tvComputerCluster.TabIndex = 5; + this.tvComputerCluster.MouseDown += new System.Windows.Forms.MouseEventHandler(this.tvComputerCluster_MouseDown); + this.tvComputerCluster.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.tvComputerCluster_AfterSelect); + this.tvComputerCluster.BeforeCollapse += new System.Windows.Forms.TreeViewCancelEventHandler(this.tvComputerCluster_BeforeCollapse); + this.tvComputerCluster.BeforeExpand += new System.Windows.Forms.TreeViewCancelEventHandler(this.tvComputerCluster_BeforeExpand); + // + // ctxTreeViewMenu + // + this.ctxTreeViewMenu.MenuItems.AddRange(new System.Windows.Forms.MenuItem[] { + this.tvCtxMenuComputerAdd, + this.tvCtxMenuComputerRemove, + this.menuGetStatus, + this.menuItem6, + this.tvCtxMenuComputerConnect, + this.tvCtxMenuComputerDisconnect, + this.tvCtxMenuDatabaseNew, + this.tvCtxMenuComputerDefine, + this.menuItem8, + this.tvCtxMenuProperties}); + this.ctxTreeViewMenu.Popup += new System.EventHandler(this.ctxTreeViewMenu_Popup); + // + // tvCtxMenuComputerAdd + // + this.tvCtxMenuComputerAdd.Index = 0; + this.tvCtxMenuComputerAdd.Text = "Add computer"; + this.tvCtxMenuComputerAdd.Click += new System.EventHandler(this.computerMenuAdd_Click); + // + // tvCtxMenuComputerRemove + // + this.tvCtxMenuComputerRemove.Index = 1; + this.tvCtxMenuComputerRemove.Text = "Remove computer"; + this.tvCtxMenuComputerRemove.Click += new System.EventHandler(this.computerMenuRemove_Click); + // + // menuGetStatus + // + this.menuGetStatus.Index = 2; + this.menuGetStatus.Text = "Get Status"; + this.menuGetStatus.Click += new System.EventHandler(this.menuGetStatus_Click); + // + // menuItem6 + // + this.menuItem6.Index = 3; + this.menuItem6.Text = "-"; + // + // tvCtxMenuComputerConnect + // + this.tvCtxMenuComputerConnect.Index = 4; + this.tvCtxMenuComputerConnect.Text = "Connect"; + // + // tvCtxMenuComputerDisconnect + // + this.tvCtxMenuComputerDisconnect.Index = 5; + this.tvCtxMenuComputerDisconnect.Text = "Disconnect"; + // + // tvCtxMenuDatabaseNew + // + this.tvCtxMenuDatabaseNew.Index = 6; + this.tvCtxMenuDatabaseNew.Text = "Create database..."; + this.tvCtxMenuDatabaseNew.Click += new System.EventHandler(this.subMenuDatabaseCreate_Click); + // + // tvCtxMenuComputerDefine + // + this.tvCtxMenuComputerDefine.Index = 7; + this.tvCtxMenuComputerDefine.Text = "Define process..."; + this.tvCtxMenuComputerDefine.Click += new System.EventHandler(this.tvCtxMenuComputerDefine_Click); + // + // menuItem8 + // + this.menuItem8.Index = 8; + this.menuItem8.Text = "-"; + // + // tvCtxMenuProperties + // + this.tvCtxMenuProperties.Index = 9; + this.tvCtxMenuProperties.Text = "Properties"; + // + // imageTV + // + this.imageTV.ColorDepth = System.Windows.Forms.ColorDepth.Depth8Bit; + this.imageTV.ImageSize = new System.Drawing.Size(16, 16); + this.imageTV.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageTV.ImageStream"))); + this.imageTV.TransparentColor = System.Drawing.Color.Transparent; + // + // ctxListViewMenu + // + this.ctxListViewMenu.MenuItems.AddRange(new System.Windows.Forms.MenuItem[] { + this.menuStartProcess, + this.menuRestartProcess, + this.menuStopProcess, + this.menuRemoveProcess, + this.menuRefresh}); + this.ctxListViewMenu.Popup += new System.EventHandler(this.ctxListViewMenu_Popup); + // + // menuStartProcess + // + this.menuStartProcess.Index = 0; + this.menuStartProcess.Text = "Start process"; + this.menuStartProcess.Click += new System.EventHandler(this.startProcess); + // + // menuRestartProcess + // + this.menuRestartProcess.Index = 1; + this.menuRestartProcess.Text = "Restart process"; + this.menuRestartProcess.Click += new System.EventHandler(this.restartProcess); + // + // menuStopProcess + // + this.menuStopProcess.Index = 2; + this.menuStopProcess.Text = "Stop process"; + this.menuStopProcess.Click += new System.EventHandler(this.stopProcess); + // + // menuRemoveProcess + // + this.menuRemoveProcess.Index = 3; + this.menuRemoveProcess.Text = "Remove process"; + this.menuRemoveProcess.Click += new System.EventHandler(this.removeProcess); + // + // menuRefresh + // + this.menuRefresh.Index = 4; + this.menuRefresh.Text = "Refresh"; + this.menuRefresh.Click += new System.EventHandler(this.menuRefresh_Click); + // + // computerMenuAdd + // + this.computerMenuAdd.Index = -1; + this.computerMenuAdd.Text = "Add"; + this.computerMenuAdd.Click += new System.EventHandler(this.computerMenuAdd_Click); + // + // menuItem3 + // + this.menuItem3.Index = -1; + this.menuItem3.Text = "-"; + // + // computerMenuRemove + // + this.computerMenuRemove.Index = -1; + this.computerMenuRemove.Text = "Remove"; + this.computerMenuRemove.Click += new System.EventHandler(this.computerMenuRemove_Click); + // + // menuItem5 + // + this.menuItem5.Index = -1; + this.menuItem5.Text = "-"; + // + // computerMenuDisconnect + // + this.computerMenuDisconnect.Index = -1; + this.computerMenuDisconnect.Text = "Disconnect"; + // + // computerMenuConnect + // + this.computerMenuConnect.Index = -1; + this.computerMenuConnect.Text = "Connect"; + // + // menuItem11 + // + this.menuItem11.Index = -1; + this.menuItem11.Text = "-"; + // + // computerMenuProperties + // + this.computerMenuProperties.Index = -1; + this.computerMenuProperties.Text = "Properties"; + // + // computerMenuRefresh + // + this.computerMenuRefresh.Index = -1; + this.computerMenuRefresh.Text = "Refresh"; + this.computerMenuRefresh.Click += new System.EventHandler(this.computerMenuRefresh_Click); + // + // chComputer + // + this.chComputer.Text = "Computer"; + // + // chProcessName + // + this.chProcessName.Text = "Name"; + // + // mainMenuItem + // + this.mainMenuItem.Index = -1; + this.mainMenuItem.Text = "File"; + // + // chProcesses + // + this.chProcesses.Text = "Id"; + // + // mainMenu + // + this.mainMenu.MenuItems.AddRange(new System.Windows.Forms.MenuItem[] { + this.mainMenuFile, + this.mainMenuComputer, + this.mainMenuDatabase}); + // + // mainMenuFile + // + this.mainMenuFile.Index = 0; + this.mainMenuFile.MenuItems.AddRange(new System.Windows.Forms.MenuItem[] { + this.menuItem2, + this.menuItem1}); + this.mainMenuFile.Text = "&File"; + // + // menuItem2 + // + this.menuItem2.Index = 0; + this.menuItem2.Text = "&Import..."; + this.menuItem2.Click += new System.EventHandler(this.importHostFile); + // + // menuItem1 + // + this.menuItem1.Index = 1; + this.menuItem1.Text = "&Export..."; + this.menuItem1.Click += new System.EventHandler(this.exportHostFile); + // + // mainMenuComputer + // + this.mainMenuComputer.Index = 1; + this.mainMenuComputer.MenuItems.AddRange(new System.Windows.Forms.MenuItem[] { + this.subMenuComputerAdd, + this.menuItem7, + this.subMenuComputerDisconnect, + this.subMenuComputerRemove, + this.menuItem10, + this.subMenuComputerProperties}); + this.mainMenuComputer.Text = "&Computer"; + // + // subMenuComputerAdd + // + this.subMenuComputerAdd.Index = 0; + this.subMenuComputerAdd.Text = "&Add Computer"; + this.subMenuComputerAdd.Click += new System.EventHandler(this.computerMenuAdd_Click); + // + // menuItem7 + // + this.menuItem7.Index = 1; + this.menuItem7.Text = "-"; + // + // subMenuComputerDisconnect + // + this.subMenuComputerDisconnect.Index = 2; + this.subMenuComputerDisconnect.Text = "&Disconnect"; + // + // subMenuComputerRemove + // + this.subMenuComputerRemove.Index = 3; + this.subMenuComputerRemove.Text = "&Remove Computer"; + this.subMenuComputerRemove.Click += new System.EventHandler(this.computerMenuRemove_Click); + // + // menuItem10 + // + this.menuItem10.Index = 4; + this.menuItem10.Text = "-"; + // + // subMenuComputerProperties + // + this.subMenuComputerProperties.Index = 5; + this.subMenuComputerProperties.Text = "&Properties"; + // + // mainMenuDatabase + // + this.mainMenuDatabase.Index = 2; + this.mainMenuDatabase.MenuItems.AddRange(new System.Windows.Forms.MenuItem[] { + this.subMenuDatabaseCreate}); + this.mainMenuDatabase.Text = "&Database"; + this.mainMenuDatabase.Click += new System.EventHandler(this.subMenuDatabaseCreate_Click); + // + // subMenuDatabaseCreate + // + this.subMenuDatabaseCreate.Index = 0; + this.subMenuDatabaseCreate.Text = "&Create database..."; + this.subMenuDatabaseCreate.Click += new System.EventHandler(this.subMenuDatabaseCreate_Click); + // + // panel1 + // + this.panel1.Controls.AddRange(new System.Windows.Forms.Control[] { + this.mgmConsole, + this.splitterHorizont, + this.splitter2, + this.listView}); + this.panel1.Dock = System.Windows.Forms.DockStyle.Fill; + this.panel1.Location = new System.Drawing.Point(104, 0); + this.panel1.Name = "panel1"; + this.panel1.Size = new System.Drawing.Size(384, 333); + this.panel1.TabIndex = 6; + // + // mgmConsole + // + this.mgmConsole.AccessibleRole = System.Windows.Forms.AccessibleRole.StaticText; + this.mgmConsole.Dock = System.Windows.Forms.DockStyle.Bottom; + this.mgmConsole.Location = new System.Drawing.Point(0, 231); + this.mgmConsole.Multiline = true; + this.mgmConsole.Name = "mgmConsole"; + this.mgmConsole.Size = new System.Drawing.Size(384, 96); + this.mgmConsole.TabIndex = 5; + this.mgmConsole.Text = "textBox1"; + this.mgmConsole.TextChanged += new System.EventHandler(this.mgmConsole_TextChanged); + this.mgmConsole.Enter += new System.EventHandler(this.mgmConsole_Enter); + // + // splitterHorizont + // + this.splitterHorizont.Dock = System.Windows.Forms.DockStyle.Bottom; + this.splitterHorizont.Location = new System.Drawing.Point(0, 327); + this.splitterHorizont.MinExtra = 100; + this.splitterHorizont.MinSize = 100; + this.splitterHorizont.Name = "splitterHorizont"; + this.splitterHorizont.Size = new System.Drawing.Size(384, 3); + this.splitterHorizont.TabIndex = 4; + this.splitterHorizont.TabStop = false; + // + // splitter2 + // + this.splitter2.Dock = System.Windows.Forms.DockStyle.Bottom; + this.splitter2.Location = new System.Drawing.Point(0, 330); + this.splitter2.Name = "splitter2"; + this.splitter2.Size = new System.Drawing.Size(384, 3); + this.splitter2.TabIndex = 2; + this.splitter2.TabStop = false; + // + // listView + // + this.listView.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] { + this.chComputerIP, + this.chStatus, + this.chDatabase, + this.chName, + this.chOwner}); + this.listView.ContextMenu = this.ctxListViewMenu; + this.listView.Dock = System.Windows.Forms.DockStyle.Fill; + this.listView.FullRowSelect = true; + this.listView.Name = "listView"; + this.listView.Size = new System.Drawing.Size(384, 333); + this.listView.TabIndex = 0; + this.listView.View = System.Windows.Forms.View.Details; + this.listView.ColumnClick += new System.Windows.Forms.ColumnClickEventHandler(this.listView_ColumnClick_1); + this.listView.SelectedIndexChanged += new System.EventHandler(this.listView_SelectedIndexChanged); + // + // chComputerIP + // + this.chComputerIP.Text = "IP Adress"; + // + // chStatus + // + this.chStatus.Text = "Status"; + // + // chDatabase + // + this.chDatabase.Text = "Database"; + // + // chName + // + this.chName.Text = "Name"; + // + // chOwner + // + this.chOwner.Text = "Owner"; + // + // splitterVertical + // + this.splitterVertical.Location = new System.Drawing.Point(104, 0); + this.splitterVertical.MinSize = 100; + this.splitterVertical.Name = "splitterVertical"; + this.splitterVertical.Size = new System.Drawing.Size(3, 333); + this.splitterVertical.TabIndex = 7; + this.splitterVertical.TabStop = false; + this.splitterVertical.SplitterMoved += new System.Windows.Forms.SplitterEventHandler(this.splitterVertical_SplitterMoved); + // + // openHostFileDialog + // + this.openHostFileDialog.DefaultExt = "cpc"; + this.openHostFileDialog.Filter = "CPCd configuration files (*.cpc)|*.cpc| All Files (*.*)|*.*"; + this.openHostFileDialog.Title = "Import a CPCd configuration file"; + this.openHostFileDialog.FileOk += new System.ComponentModel.CancelEventHandler(this.openHostFileDialog_FileOk); + // + // saveHostFileDialog + // + this.saveHostFileDialog.Filter = "CPCd configuration files (*.cpc)|*.cpc| All Files (*.*)|*.*"; + this.saveHostFileDialog.Title = "Export a CPCd configuration file"; + this.saveHostFileDialog.FileOk += new System.ComponentModel.CancelEventHandler(this.saveHostFileDialog_FileOk); + // + // CPC + // + this.AutoScaleBaseSize = new System.Drawing.Size(5, 13); + this.ClientSize = new System.Drawing.Size(488, 333); + this.Controls.AddRange(new System.Windows.Forms.Control[] { + this.splitterVertical, + this.panel1, + this.tvComputerCluster}); + this.Menu = this.mainMenu; + this.Name = "CPC"; + this.Text = "CPC"; + this.Resize += new System.EventHandler(this.CPC_Resize); + this.MouseDown += new System.Windows.Forms.MouseEventHandler(this.CPC_MouseDown); + this.Closing += new System.ComponentModel.CancelEventHandler(this.CPC_Closing); + this.Load += new System.EventHandler(this.CPC_Load); + this.Activated += new System.EventHandler(this.CPC_Activated); + this.Paint += new System.Windows.Forms.PaintEventHandler(this.CPC_Paint); + this.panel1.ResumeLayout(false); + this.ResumeLayout(false); + + } + #endregion + + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + Application.Run(new CPC()); + + } + + private void tvComputerCluster_AfterSelect(object sender, System.Windows.Forms.TreeViewEventArgs e) + { + if(e.Node.Text.ToString().Equals("Database")) + { + updateListViews("Database"); + + return; + } + if(e.Node.Text.ToString().Equals("Computer")) + { + //updateListViews(); + + updateListViews("Computer"); + return; + } + if(e.Node.Parent.Text.ToString().Equals("Database")) + { + //updateListViews(); + listView.Columns.Clear(); + listView.Columns.Add(this.chName); + listView.Columns.Add(this.chDatabase); + listView.Columns.Add(this.chStatus); + listView.Columns.Add(this.chOwner); + updateDatabaseView(e.Node.Text.ToString()); + } + + if(e.Node.Parent.Text=="Computer") + { + //updateListViews(); + + Computer c=computerMgmt.getComputer(e.Node.Text.ToString()); + string [] processcols= new string[5]; + ArrayList processes; + processes = c.getProcesses(); + listView.Items.Clear(); + listView.Columns.Clear(); + listView.Columns.Add(this.chComputer); + listView.Columns.Add(this.chDatabase); + listView.Columns.Add(this.chName); + listView.Columns.Add(this.chStatus); + listView.Columns.Add(this.chOwner); + if(processes != null ) + { + + listView.BeginUpdate(); + foreach(Process p in processes) + { + processcols[0]=p.getComputer().getName(); + processcols[1]=p.getDatabase(); + processcols[2]=p.getName(); + processcols[3]=p.getStatusString(); + processcols[4]=p.getOwner(); + ListViewItem lvp= new ListViewItem(processcols); + listView.Items.Add(lvp); + } + + listView.EndUpdate(); + } + + + listView.Show(); + } + + } + + + + private void ctxTreeViewMenu_Popup(object sender, System.EventArgs e) + { + tvCtxMenuComputerAdd.Enabled=true; + tvCtxMenuComputerRemove.Enabled=true; + tvCtxMenuComputerConnect.Enabled=true; + tvCtxMenuComputerDisconnect.Enabled=true; + tvCtxMenuComputerDefine.Enabled=true; + menuGetStatus.Enabled=true; + tvCtxMenuDatabaseNew.Enabled=true; + tvCtxMenuComputerAdd.Visible=true; + tvCtxMenuComputerRemove.Visible=true; + tvCtxMenuComputerConnect.Visible=true; + tvCtxMenuComputerDisconnect.Visible=true; + tvCtxMenuComputerDefine.Visible=true; + tvCtxMenuDatabaseNew.Visible=true; + tvCtxMenuProperties.Visible=true; + menuGetStatus.Visible=true; + + if(tvComputerCluster.SelectedNode.Text.Equals("Computer")) + { + tvCtxMenuComputerAdd.Enabled=true; + tvCtxMenuComputerRemove.Enabled=false; + tvCtxMenuComputerConnect.Enabled=false; + tvCtxMenuComputerDisconnect.Enabled=false; + tvCtxMenuComputerDefine.Enabled=false; + tvCtxMenuDatabaseNew.Visible=false; + menuGetStatus.Visible=false; + return; + } + + if(tvComputerCluster.SelectedNode.Text.Equals("Database")) + { + // ctxTreeViewMenu.MenuItems.Add(menuDatabaseItem1); + tvCtxMenuComputerAdd.Visible=false; + tvCtxMenuComputerRemove.Visible=false; + tvCtxMenuComputerConnect.Visible=false; + tvCtxMenuComputerDisconnect.Visible=false; + tvCtxMenuComputerDefine.Visible=false; + tvCtxMenuDatabaseNew.Visible=true; + tvCtxMenuDatabaseNew.Enabled=true; + menuGetStatus.Visible=false; + menuItem6.Visible=false; + return; + } + if(tvComputerCluster.SelectedNode.Parent.Text.Equals("Computer")) + { + + Computer c= computerMgmt.getComputer(tvComputerCluster.SelectedNode.Text.ToString()); + if(c.getStatus().Equals(Computer.Status.Disconnected)) + { + tvCtxMenuComputerConnect.Enabled=true; + tvCtxMenuComputerDisconnect.Enabled=false; + } + else + { + tvCtxMenuComputerDisconnect.Enabled=true; + tvCtxMenuComputerConnect.Enabled=false; + } + + tvCtxMenuComputerAdd.Enabled=false; + tvCtxMenuComputerRemove.Enabled=true; + menuGetStatus.Visible=false; + + tvCtxMenuComputerDefine.Enabled=true; + tvCtxMenuDatabaseNew.Visible=false; + return; + } + + if(tvComputerCluster.SelectedNode.Parent.Text.Equals("Database")) + { + tvCtxMenuComputerAdd.Enabled=true; + tvCtxMenuComputerRemove.Enabled=false; + tvCtxMenuComputerConnect.Enabled=false; + tvCtxMenuComputerDisconnect.Enabled=false; + tvCtxMenuComputerDefine.Enabled=false; + tvCtxMenuDatabaseNew.Visible=true; + menuGetStatus.Visible=true; + return; + } + + + } + + + private void listView_SelectedIndexChanged(object sender, System.EventArgs e) + { + //MessageBox.Show(listView.SelectedItems[0].Text); + } + + + private void tvComputerCluster_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e) + { /* + TreeNode node = tvComputerCluster.GetNodeAt(e.X,e.Y); + if(node==null) + { + return; + } + tvComputerCluster.SelectedNode=node; +// updateListViews(); + tvComputerCluster.SelectedNode.Expand(); + */ + } + + + private void subMenuComputerRemove_Click(object sender, System.EventArgs e) + { + //ComputerRemoveDialog crd=new ComputerRemoveDialog(computerMgmt); + //crd.Show(); + //updateListViews(); +/* string computer = tvComputerCluster.SelectedNode.Text.ToString(); + if(MessageBox.Show(this,"Are you sure you want to remove: " +computer+ "?","Remove computer",MessageBoxButtons.YesNo)==DialogResult.Yes) + { + computerMgmt.RemoveComputer(computer); + } +*/ + } + + private void subMenuComputerAdd_Click(object sender, System.EventArgs e) + { + ComputerAddDialog cad=new ComputerAddDialog(computerMgmt); + cad.ShowDialog(); + cad.Dispose(); +/// updateListViews(tvComputerCluster.SelectedNode.Text.ToString()); + } + + + + private void updateListViews(string node) + { + if(node.Equals("Computer")) + { + listView.Columns.Clear(); + listView.Items.Clear(); + ArrayList list= computerMgmt.getComputerCollection(); + string [] computercols= new string[2]; + + + listView.BeginUpdate(); + listView.Columns.Add(this.chComputer); + listView.Columns.Add(this.chStatus); + foreach (Computer computer in list) + { + computercols[0]=computer.getName(); + computercols[1]=computer.getStatusString(); + + ListViewItem lvc= new ListViewItem(computercols); + + listView.Items.Add(lvc); + + } + listView.EndUpdate(); + listView.Show(); + } + + if(node.Equals("Database")) + { + + ArrayList databases= computerMgmt.getDatabaseCollection(); + string [] dbcols= new string[3]; + + + listView.BeginUpdate(); + listView.Items.Clear(); + listView.Columns.Clear(); + listView.Columns.Add(this.chDatabase); + listView.Columns.Add(this.chStatus); + listView.Columns.Add(this.chOwner); + foreach (Database db in databases) + { + dbcols[0]=db.getName(); + dbcols[1]=db.getStatusString(); + dbcols[2]=db.getOwner(); + + ListViewItem lvc= new ListViewItem(dbcols); + + listView.Items.Add(lvc); + + } + listView.EndUpdate(); + + listView.Show(); + } + + } + + public void updateDatabaseView(string database) + { + Database d=computerMgmt.getDatabase(database); + string [] processcols= new string[5]; + ArrayList processes = d.getProcesses(); + listView.Items.Clear(); + if(processes != null ) + { + + listView.BeginUpdate(); + listView.Columns.Clear(); + listView.Columns.Add(this.chComputer); + listView.Columns.Add(this.chDatabase); + listView.Columns.Add(this.chName); + listView.Columns.Add(this.chStatus); + listView.Columns.Add(this.chOwner); + + foreach(Process p in processes) + { + processcols[0]=p.getComputer().getName(); + processcols[1]=p.getDatabase(); + processcols[2]=p.getName(); + processcols[3]=p.getStatusString(); + processcols[4]=p.getOwner(); + ListViewItem lvp= new ListViewItem(processcols); + listView.Items.Add(lvp); + } + + listView.EndUpdate(); + } + + listView.Show(); + } + + private void updateTreeViews() + { + //tvComputerCluster.Nodes.Clear(); + ArrayList computers= computerMgmt.getComputerCollection(); + + ArrayList databases= computerMgmt.getDatabaseCollection(); + + tvComputerCluster.BeginUpdate(); + tvComputerCluster.Nodes[0].Nodes.Clear(); + tvComputerCluster.Nodes[1].Nodes.Clear(); + if(computers != null) + { + foreach (Computer computer in computers) + { + tvComputerCluster.Nodes[0].Nodes.Add(new TreeNode(computer.getName().ToString())); + } + } + if(databases != null) + { + foreach (Database db in databases) + { + tvComputerCluster.Nodes[1].Nodes.Add(new TreeNode(db.getName().ToString())); + } + } + + tvComputerCluster.EndUpdate(); + } + + + private void CPC_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e) + { + //updateListViews(); + //updateTreeViews(); + + } + + private void CPC_Paint(object sender, System.Windows.Forms.PaintEventArgs e) + { + if(tvComputerCluster.SelectedNode!=null) + { + if(tvComputerCluster.SelectedNode.Text.ToString().Equals("Computer")) + updateListViews("Computer"); + } + + //updateListViews(); + //updateTreeViews(); + } + + private void CPC_Activated(object sender, System.EventArgs e) + { + updateListViews(tvComputerCluster.SelectedNode.Text.ToString()); + //updateListViews(); + updateTreeViews(); + } + + + private void computerMenuAdd_Click(object sender, System.EventArgs e) + { + ComputerAddDialog cad=new ComputerAddDialog(computerMgmt); + cad.ShowDialog(); + cad.Dispose(); + + } + + private void computerMenuRemove_Click(object sender, System.EventArgs e) + { + + string computer = tvComputerCluster.SelectedNode.Text.ToString(); + if(MessageBox.Show("Are you sure you want to remove: " + computer +"?\n" + "This will remove all processes on the computer!" ,"Remove selected computer",MessageBoxButtons.YesNo, MessageBoxIcon.Question)== DialogResult.Yes) + { + removeComputer(computer); + } + } + + private void removeComputer(string computer) + { + ArrayList processes; + Computer c=computerMgmt.getComputer(computer); + processes = c.getProcesses(); + + /*foreach(Process p in processes) + { + removeProcess(computer,p.getName()); + processes=c.getProcesses(); + } +*/ + if(computerMgmt.RemoveComputer(computer)) + { + tvComputerCluster.SelectedNode=tvComputerCluster.SelectedNode.PrevVisibleNode; + this.updateTreeViews(); + this.updateListViews("Computer"); + + if(tvComputerCluster.SelectedNode!=null) + this.updateListViews(tvComputerCluster.SelectedNode.Text.ToString()); + //updateListViews(); + } + } + + private void listView_ColumnClick(object sender, System.Windows.Forms.ColumnClickEventArgs e) + { + + if(listView.Sorting.Equals(SortOrder.Ascending)) + listView.Sorting=SortOrder.Descending; + else + listView.Sorting=SortOrder.Ascending; + + } + + + private void subMenuDatabaseCreate_Click(object sender, System.EventArgs e) + { + PanelWizard p = new PanelWizard(this.computerMgmt); + p.ShowDialog(); + } + + private void tvCtxMenuComputerDefine_Click(object sender, System.EventArgs e) + { + ProcessDefineDialog pdd = new ProcessDefineDialog(this.computerMgmt, + tvComputerCluster.SelectedNode.Text.ToString()); + pdd.Show(); + } + + private void listView_ItemActivate(object sender, System.EventArgs e) + { + updateDatabaseView(listView.SelectedItems[0].Text.ToString()); + for(int i=0;i0) + selectedItem=listView.FocusedItem.Text.ToString(); + + + if(selectedItem.Equals("")) + { + computerMenuAdd.Enabled=true; + computerMenuRemove.Enabled=false; + computerMenuConnect.Enabled=false; + computerMenuDisconnect.Enabled=false; + return; + } + else + { + computerMenuAdd.Enabled=false; + if(computerMgmt.getStatus(selectedItem).Equals(Computer.Status.Connected)) + { + computerMenuConnect.Enabled=false; + computerMenuRemove.Enabled=true; + } + if(computerMgmt.getStatus(selectedItem).Equals(Computer.Status.Disconnected)) + computerMenuDisconnect.Enabled=false; + } + + + } + + private void startProcess(object sender, System.EventArgs e) + { + if(listView.SelectedItems.Count==0) + return; + + string computer = listView.SelectedItems[0].SubItems[0].Text.ToString(); + string process = listView.SelectedItems[0].SubItems[2].Text.ToString(); + + if(computerMgmt.getComputer(computer).getProcessByName(process).getStatus()==Process.Status.Running) + { + MessageBox.Show(this,"The process is already started!" ,"Process failed to start",MessageBoxButtons.OK); + return; + } + + int status = startProcess(listView.SelectedItems[0].SubItems[0].Text.ToString(),listView.SelectedItems[0].SubItems[2].Text.ToString()); + + + if(status < 0) + MessageBox.Show(this,"Either the link is not OK, or the process is misconfigured! Status : " + status,"Process failed to start",MessageBoxButtons.OK); + else + MessageBox.Show(this,"The process was sucessfully started!","Process started",MessageBoxButtons.OK); + + } + + private int startProcess(string computer, string process) + { + Computer c=computerMgmt.getComputer(computer); + int status = c.startProcess(c.getProcessByName(process)); + return status; + } + + private void listView_ColumnClick_1(object sender, System.Windows.Forms.ColumnClickEventArgs e) + { + // if(listView.Columns[e.Column].Text.Equals("Computer")) + // { + if(listView.Sorting.Equals(SortOrder.Ascending)) + { + listView.Sorting=SortOrder.Descending; + } + else + { + listView.Sorting=SortOrder.Ascending; + } + // } + } + + private void removeProcess(object sender, System.EventArgs e) + { + if(listView.SelectedItems.Count==0) + return; + string process = listView.SelectedItems[0].SubItems[2].Text.ToString(); + string computer = listView.SelectedItems[0].SubItems[0].Text.ToString(); + + if(MessageBox.Show("Are you sure that you want to remove " + process + " permanently?","Remove process",MessageBoxButtons.YesNo) == DialogResult.No) + return; + removeProcess(computer,process); + MessageBox.Show(this,"The process was sucessfully removed!","Remove process",MessageBoxButtons.OK); + } + + private void removeProcess(string computer, string process) + { + + Computer c=computerMgmt.getComputer(computer); + stopProcess(computer,process); + int status = c.undefineProcess(c.getProcessByName(process)); + //if(status < 0) + // MessageBox.Show(this,"The process could not be removed!","Failed to remove process",MessageBoxButtons.OK); + // else + // { + Database db = computerMgmt.getDatabase((c.getProcessByName(process).getDatabase())); + db.removeProcess(process); + c.removeProcess(process,db.getName()); + updateListViews("Database"); + // } + } + + private void stopProcess(object sender, System.EventArgs e) + { + if(listView.SelectedItems.Count==0) + return; + string computer = listView.SelectedItems[0].SubItems[0].Text.ToString(); + string process = listView.SelectedItems[0].SubItems[2].Text.ToString(); + if(computerMgmt.getComputer(computer).getProcessByName(process).getStatus()==Process.Status.Stopped) + { + MessageBox.Show(this,"The process is already stopped!" ,"Process failed to stop",MessageBoxButtons.OK); + return; + } + + if(DialogResult.No==MessageBox.Show(this,"Are you sure you want to stop the " + process + " process?","Stop process!", MessageBoxButtons.YesNo)) + return; + + int status = stopProcess(computer, process); + if(status < 0) + MessageBox.Show(this,"The process could not be stopped. Status: " + status ,"Process failed to stop",MessageBoxButtons.OK); + else + MessageBox.Show(this,"The process was sucessfully stopped!","Process stopped",MessageBoxButtons.OK); + } + + private int stopProcess(string computer, string process) + { + Computer c=computerMgmt.getComputer(computer); + int status = c.stopProcess(c.getProcessByName(process)); + return status; + } + + private void restartProcess(object sender, System.EventArgs e) + { + if(listView.SelectedItems.Count==0) + return; + string computer = listView.SelectedItems[0].SubItems[0].Text.ToString(); + string process = listView.SelectedItems[0].SubItems[2].Text.ToString(); + if(stopProcess(computer, process)<0) + { + MessageBox.Show("Restart process failed!!!", "Restart process"); + return; + } + if(startProcess(computer, process)<0) + { + MessageBox.Show("Restart process failed!!!", "Restart process"); + return; + } + MessageBox.Show("Succesfully restarted the process!","Restart process"); + } + + private void menuRefresh_Click(object sender, System.EventArgs e) + { + //string computer = tvComputerCluster.SelectedNode.Text; + + this.listProcesses(); + } + + private void importHostFile(object sender, System.EventArgs e) + { + openHostFileDialog.ShowDialog(); + } + + private void exportHostFile(object sender, System.EventArgs e) + { + saveHostFileDialog.ShowDialog(); + } + + private void listProcesses() + { + /* add process in computer list*/ + ArrayList computers = computerMgmt.getComputerCollection(); + foreach(Computer c in computers) + { + c.listProcesses(); + ArrayList processes = c.getProcesses(); + if(processes!=null) + { + foreach(Process p in processes) + { + Database db = computerMgmt.getDatabase(p.getDatabase()); + if(db!=null) + { + p.setDefined(true); + db.addProcessCheck(p); + } + } + } + } + updateListViews("Computer"); + updateListViews("Database"); + } + + private void openHostFileDialog_FileOk(object sender, System.ComponentModel.CancelEventArgs e) + { + computerMgmt.importHostFile(openHostFileDialog.FileName); + this.updateTreeViews(); + openHostFileDialog.Dispose(); + listProcesses(); + } + + private void saveHostFileDialog_FileOk(object sender, System.ComponentModel.CancelEventArgs e) + { + computerMgmt.exportHostFile(saveHostFileDialog.FileName); + saveHostFileDialog.Dispose(); + } + + private void mgmConsole_Enter(object sender, System.EventArgs e) + {/* + //telnetclient.telnetClient tc= new telnetclient.telnetClient("10.0.13.1",10000,mgmConsole); + socketcomm.SocketComm sc = new socketcomm.SocketComm("10.0.13.1",10000); + sc.doConnect(); + while(!sc.isConnected()) + { + Thread.Sleep(100); + } + sc.writeMessage("get status\r"); + string line = sc.readLine(); + while(!line.Equals("")) + { + MessageBox.Show(line); + line=sc.readLine(); + } +*/ + } + + private void mgmConsole_TextChanged(object sender, System.EventArgs e) + { + + } + + + + + + + + + + } + +} diff --git a/ndb/src/cw/cpcc-win32/csharp/Computer.cs b/ndb/src/cw/cpcc-win32/csharp/Computer.cs new file mode 100644 index 00000000000..9763fac5622 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/Computer.cs @@ -0,0 +1,256 @@ +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using System.Windows.Forms; +using System.Data; +using System.IO; +using NDB_CPC.socketcomm; +using NDB_CPC.simpleparser; + + +namespace NDB_CPC +{ + /// + /// Summary description for Computer. + /// + public class Computer + { + public enum Status {Disconnected=1,Connected=2, Unknown=3} + private string m_ip; + private int m_cpcdPort; + private string m_name; + private Status m_status; + private ArrayList m_processes; + private SocketComm m_socket; + public Computer(string name, int port) + { + m_name = name; + m_status = Status.Disconnected; + m_processes = new ArrayList(); + m_cpcdPort=port; + m_socket = new SocketComm(m_name,m_cpcdPort); + } + + public Computer(string name, string ip) + { + m_ip = ip; + m_name = name; + m_status = Status.Disconnected; + m_processes = new ArrayList(); + m_cpcdPort=1234; //default port + m_socket = new SocketComm(m_ip,m_cpcdPort); + } + + public void connectToCpcd() + { + m_socket.doConnect(); + } + + private bool sendMessage(string str) + { + return m_socket.writeMessage(str); + + } + + public string getName() {return m_name;} + public string getIp() {return m_ip;} + public ArrayList getProcesses() + { + if(m_processes.Count>0) + return m_processes; + else + return null; + } + public string getStatusString() + { + try + { + if(m_socket.isConnected()) + return "Connected"; + else + return "Disconnected"; + } + catch(Exception e) + { + return "Unknown"; + } + } + + + public bool isConnected() + { + if(m_socket.isConnected()) + return true; + return false; + } + + public Status getStatus() + { + try + { + if(m_socket.isConnected()) + return Status.Connected; + else + return Status.Disconnected; + } + catch(Exception e) + { + return Status.Unknown; + } + } + + public void setStatus(Status status) + { + m_status=status; + } + + public void addProcess(Process process) + { + m_processes.Add(process); + } + + public Process getProcessByName(string name) + { + foreach(Process process in m_processes) + { + if(process.getName().Equals(name)) + return process; + } + return null; + } + + + public bool removeProcess(string name, string database) + { + foreach(Process p in m_processes) + { + if(p.getName().Equals(name) && p.getDatabase().Equals(database)) + { + m_processes.Remove(p); + return true; + } + } + return false; + } + + public void disconnect() + { + m_socket.disconnect(); + } + public Process getProcess(string id) + { + foreach(Process process in m_processes) + { + if(process.getId().Equals(id)) + return process; + } + return null; + } + + public int listProcesses() + { + string list = "list processes\n\n"; + + if(!sendMessage(list)) + return -2; + + SimpleCPCParser.parse(m_processes, this, m_socket); + return 1; + } + + public int defineProcess(Process p) + { + string define = "define process \n"; + define = define + "name:" + p.getName() + "\n"; + define = define + "group:" + p.getDatabase() + "\n"; + define = define + "env:" + "NDB_CONNECTSTRING="+p.getConnectString() ; + if(p.getEnv().Equals("")) + define = define + "\n"; + else + define = define + " " + p.getEnv() + "\n"; + + //if(p.getPath().EndsWith("\\")) + // define = define + "path:" + p.getPath()+ "ndb" + "\n"; + //else + define = define + "path:" + p.getPath() + "\n"; + define = define + "args:" + p.getArgs() + "\n"; + define = define + "type:" + "permanent" + "\n"; + define = define + "cwd:" + p.getCwd() + "\n"; + define = define + "owner:" + "ejohson" + "\n\n"; + + if(!sendMessage(define)) + return -2; + + SimpleCPCParser.parse(p, m_socket); + if(p.isDefined()) + return 1; + else + return -1; + + } + + public int startProcess(Process p) + { + if(!p.isDefined()) + { + this.defineProcess(p); + if(!p.isDefined()) + return -4; //process misconfigured + + } + string start= "start process \n"; + start = start + "id:" + p.getId() + "\n\n"; + if(!sendMessage(start)) + return -2; + SimpleCPCParser.parse(p, m_socket); + if(p.getStatus().Equals(Process.Status.Running)) + return 1; + else + return -1; + } + + public int stopProcess(Process p) + { + if(!p.isDefined()) + { + return -4; //process not defined + } + string stop= "stop process \n"; + stop = stop + "id:" + p.getId() + "\n\n"; + if(!sendMessage(stop)) + return -2; + SimpleCPCParser.parse(p, m_socket); + + if(p.getStatus().Equals(Process.Status.Stopped)) + return 1; + else + return -1; + } + + public int undefineProcess(Process p) + { + if(!p.isDefined()) + { + return -4; //process not defined + } + string undefine= "undefine process \n"; + undefine = undefine + "id:" + p.getId() + "\n\n"; + if(!sendMessage(undefine)) + return -2; + SimpleCPCParser.parse(p, m_socket); + if(!p.isDefined()) + { + return 1; + + } + return -1; + } + + public int getCpcdPort() + { + return this.m_cpcdPort; + } + + } +} diff --git a/ndb/src/cw/cpcc-win32/csharp/ComputerAddDialog.cs b/ndb/src/cw/cpcc-win32/csharp/ComputerAddDialog.cs new file mode 100644 index 00000000000..c01e41f3e60 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/ComputerAddDialog.cs @@ -0,0 +1,242 @@ +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using System.Windows.Forms; + +namespace NDB_CPC +{ + /// + /// Summary description for ComputerAddDialog. + /// + public class ComputerAddDialog : System.Windows.Forms.Form + { + private System.Windows.Forms.Label label1; + private System.Windows.Forms.TextBox textboxComputerName; + private System.Windows.Forms.Button btnAdd; + private System.Windows.Forms.Button btnCancel; + private System.Windows.Forms.Label label2; + /// + /// Required designer variable. + /// + private System.ComponentModel.Container components = null; + private System.Windows.Forms.Label label6; + private System.Windows.Forms.CheckBox checkBoxDefault; + private System.Windows.Forms.TextBox textBoxPort; + + private ComputerMgmt mgmt; + public ComputerAddDialog(ComputerMgmt mgmt) + { + // + // Required for Windows Form Designer support + // + InitializeComponent(); + + // + // TODO: Add any constructor code after InitializeComponent call + // + this.mgmt=mgmt; + } + /// + /// Clean up any resources being used. + /// + protected override void Dispose( bool disposing ) + { + if( disposing ) + { + if(components != null) + { + components.Dispose(); + } + } + base.Dispose( disposing ); + } + + #region Windows Form Designer generated code + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.textboxComputerName = new System.Windows.Forms.TextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.btnAdd = new System.Windows.Forms.Button(); + this.btnCancel = new System.Windows.Forms.Button(); + this.label2 = new System.Windows.Forms.Label(); + this.label6 = new System.Windows.Forms.Label(); + this.textBoxPort = new System.Windows.Forms.TextBox(); + this.checkBoxDefault = new System.Windows.Forms.CheckBox(); + this.SuspendLayout(); + // + // textboxComputerName + // + this.textboxComputerName.Location = new System.Drawing.Point(128, 16); + this.textboxComputerName.Name = "textboxComputerName"; + this.textboxComputerName.Size = new System.Drawing.Size(136, 20); + this.textboxComputerName.TabIndex = 0; + this.textboxComputerName.Text = ""; + // + // label1 + // + this.label1.Location = new System.Drawing.Point(40, 16); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(88, 23); + this.label1.TabIndex = 1; + this.label1.Text = "Computer name:"; + this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleRight; + // + // btnAdd + // + this.btnAdd.Location = new System.Drawing.Point(112, 128); + this.btnAdd.Name = "btnAdd"; + this.btnAdd.Size = new System.Drawing.Size(80, 24); + this.btnAdd.TabIndex = 4; + this.btnAdd.Text = "Add"; + this.btnAdd.Click += new System.EventHandler(this.btnAdd_Click); + // + // btnCancel + // + this.btnCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.btnCancel.Location = new System.Drawing.Point(200, 128); + this.btnCancel.Name = "btnCancel"; + this.btnCancel.Size = new System.Drawing.Size(80, 24); + this.btnCancel.TabIndex = 5; + this.btnCancel.Text = "Cancel"; + this.btnCancel.Click += new System.EventHandler(this.btnCancel_Click); + // + // label2 + // + this.label2.Location = new System.Drawing.Point(128, 40); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(136, 16); + this.label2.TabIndex = 4; + this.label2.Text = "(e.g. Ndb01 or 10.0.1.1)"; + // + // label6 + // + this.label6.Location = new System.Drawing.Point(48, 64); + this.label6.Name = "label6"; + this.label6.Size = new System.Drawing.Size(80, 24); + this.label6.TabIndex = 9; + this.label6.Text = "CPCd port:"; + this.label6.TextAlign = System.Drawing.ContentAlignment.MiddleRight; + // + // textBoxPort + // + this.textBoxPort.Enabled = false; + this.textBoxPort.Location = new System.Drawing.Point(128, 64); + this.textBoxPort.Name = "textBoxPort"; + this.textBoxPort.Size = new System.Drawing.Size(136, 20); + this.textBoxPort.TabIndex = 2; + this.textBoxPort.TabStop = false; + this.textBoxPort.Text = ""; + // + // checkBoxDefault + // + this.checkBoxDefault.Checked = true; + this.checkBoxDefault.CheckState = System.Windows.Forms.CheckState.Checked; + this.checkBoxDefault.Location = new System.Drawing.Point(96, 96); + this.checkBoxDefault.Name = "checkBoxDefault"; + this.checkBoxDefault.Size = new System.Drawing.Size(168, 16); + this.checkBoxDefault.TabIndex = 3; + this.checkBoxDefault.Text = "Use default port (1234)?"; + this.checkBoxDefault.CheckedChanged += new System.EventHandler(this.checkBoxDefault_CheckedChanged); + // + // ComputerAddDialog + // + this.AcceptButton = this.btnAdd; + this.AutoScaleBaseSize = new System.Drawing.Size(5, 13); + this.CancelButton = this.btnCancel; + this.ClientSize = new System.Drawing.Size(298, 159); + this.Controls.AddRange(new System.Windows.Forms.Control[] { + this.checkBoxDefault, + this.label6, + this.textBoxPort, + this.label2, + this.btnCancel, + this.btnAdd, + this.label1, + this.textboxComputerName}); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "ComputerAddDialog"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "Add a computer"; + this.Load += new System.EventHandler(this.ComputerAddDialog_Load); + this.ResumeLayout(false); + + } + #endregion + + private void btnCancel_Click(object sender, System.EventArgs e) + { + this.Close(); + this.Dispose(); + } + + private void btnAdd_Click(object sender, System.EventArgs e) + { + int port; + if(this.textboxComputerName.Text.Equals("")) + { + MessageBox.Show(this,"A computer must have an IP address or a host name","Warning!",MessageBoxButtons.OK); + return; + } + if(this.checkBoxDefault.Checked) + { + port=1234; + } + else + { + if(this.textBoxPort.Text.Equals("")) + { + MessageBox.Show(this,"You must specify a port number!!!","Warning!",MessageBoxButtons.OK); + return; + } + else + { + try + { + port=Convert.ToInt32(this.textBoxPort.Text.ToString()); + + } + catch (Exception exception) + { + MessageBox.Show(this,"Port number must be numeric!!!","Warning!",MessageBoxButtons.OK); + return; + } + } + } + + if(mgmt.getComputer(this.textboxComputerName.Text)==null) + { + mgmt.AddComputer(this.textboxComputerName.Text.ToString(),port);} + else + { + MessageBox.Show("This computer does already exist!", "Add computer"); + return; + } + + this.Dispose(); + } + + private void ComputerAddDialog_Load(object sender, System.EventArgs e) + { + + } + + private void checkBoxDefault_CheckedChanged(object sender, System.EventArgs e) + { + if(checkBoxDefault.Checked) + textBoxPort.Enabled=false; + else + textBoxPort.Enabled=true; + } + + + + + } +} diff --git a/ndb/src/cw/cpcc-win32/csharp/ComputerRemoveDialog.cs b/ndb/src/cw/cpcc-win32/csharp/ComputerRemoveDialog.cs new file mode 100644 index 00000000000..5b4d1b56df7 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/ComputerRemoveDialog.cs @@ -0,0 +1,228 @@ +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using System.Windows.Forms; + +namespace NDB_CPC +{ + /// + /// Summary description for ComputerRemoveDialog. + /// + public class ComputerRemoveDialog : System.Windows.Forms.Form + { + private System.Windows.Forms.Label label1; + private System.Windows.Forms.ComboBox comboComputer; + private System.Windows.Forms.Button btnCancel; + private System.Windows.Forms.Button btnRemove; + /// + /// Required designer variable. + /// + private System.ComponentModel.Container components = null; + private ComputerMgmt mgmt; + + public ComputerRemoveDialog(ComputerMgmt mgmt) + { + // + // Required for Windows Form Designer support + // + InitializeComponent(); + + // + // TODO: Add any constructor code after InitializeComponent call + // + this.mgmt=mgmt; + } + + /// + /// Clean up any resources being used. + /// + protected override void Dispose( bool disposing ) + { + if( disposing ) + { + if(components != null) + { + components.Dispose(); + } + } + base.Dispose( disposing ); + } + + #region Windows Form Designer generated code + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.Resources.ResourceManager resources = new System.Resources.ResourceManager(typeof(ComputerRemoveDialog)); + this.label1 = new System.Windows.Forms.Label(); + this.comboComputer = new System.Windows.Forms.ComboBox(); + this.btnCancel = new System.Windows.Forms.Button(); + this.btnRemove = new System.Windows.Forms.Button(); + this.SuspendLayout(); + // + // label1 + // + this.label1.AccessibleDescription = ((string)(resources.GetObject("label1.AccessibleDescription"))); + this.label1.AccessibleName = ((string)(resources.GetObject("label1.AccessibleName"))); + this.label1.Anchor = ((System.Windows.Forms.AnchorStyles)(resources.GetObject("label1.Anchor"))); + this.label1.AutoSize = ((bool)(resources.GetObject("label1.AutoSize"))); + this.label1.Dock = ((System.Windows.Forms.DockStyle)(resources.GetObject("label1.Dock"))); + this.label1.Enabled = ((bool)(resources.GetObject("label1.Enabled"))); + this.label1.Font = ((System.Drawing.Font)(resources.GetObject("label1.Font"))); + this.label1.Image = ((System.Drawing.Image)(resources.GetObject("label1.Image"))); + this.label1.ImageAlign = ((System.Drawing.ContentAlignment)(resources.GetObject("label1.ImageAlign"))); + this.label1.ImageIndex = ((int)(resources.GetObject("label1.ImageIndex"))); + this.label1.ImeMode = ((System.Windows.Forms.ImeMode)(resources.GetObject("label1.ImeMode"))); + this.label1.Location = ((System.Drawing.Point)(resources.GetObject("label1.Location"))); + this.label1.Name = "label1"; + this.label1.RightToLeft = ((System.Windows.Forms.RightToLeft)(resources.GetObject("label1.RightToLeft"))); + this.label1.Size = ((System.Drawing.Size)(resources.GetObject("label1.Size"))); + this.label1.TabIndex = ((int)(resources.GetObject("label1.TabIndex"))); + this.label1.Text = resources.GetString("label1.Text"); + this.label1.TextAlign = ((System.Drawing.ContentAlignment)(resources.GetObject("label1.TextAlign"))); + this.label1.Visible = ((bool)(resources.GetObject("label1.Visible"))); + // + // comboComputer + // + this.comboComputer.AccessibleDescription = ((string)(resources.GetObject("comboComputer.AccessibleDescription"))); + this.comboComputer.AccessibleName = ((string)(resources.GetObject("comboComputer.AccessibleName"))); + this.comboComputer.Anchor = ((System.Windows.Forms.AnchorStyles)(resources.GetObject("comboComputer.Anchor"))); + this.comboComputer.BackgroundImage = ((System.Drawing.Image)(resources.GetObject("comboComputer.BackgroundImage"))); + this.comboComputer.Dock = ((System.Windows.Forms.DockStyle)(resources.GetObject("comboComputer.Dock"))); + this.comboComputer.Enabled = ((bool)(resources.GetObject("comboComputer.Enabled"))); + this.comboComputer.Font = ((System.Drawing.Font)(resources.GetObject("comboComputer.Font"))); + this.comboComputer.ImeMode = ((System.Windows.Forms.ImeMode)(resources.GetObject("comboComputer.ImeMode"))); + this.comboComputer.IntegralHeight = ((bool)(resources.GetObject("comboComputer.IntegralHeight"))); + this.comboComputer.ItemHeight = ((int)(resources.GetObject("comboComputer.ItemHeight"))); + this.comboComputer.Location = ((System.Drawing.Point)(resources.GetObject("comboComputer.Location"))); + this.comboComputer.MaxDropDownItems = ((int)(resources.GetObject("comboComputer.MaxDropDownItems"))); + this.comboComputer.MaxLength = ((int)(resources.GetObject("comboComputer.MaxLength"))); + this.comboComputer.Name = "comboComputer"; + this.comboComputer.RightToLeft = ((System.Windows.Forms.RightToLeft)(resources.GetObject("comboComputer.RightToLeft"))); + this.comboComputer.Size = ((System.Drawing.Size)(resources.GetObject("comboComputer.Size"))); + this.comboComputer.Sorted = true; + this.comboComputer.TabIndex = ((int)(resources.GetObject("comboComputer.TabIndex"))); + this.comboComputer.Text = resources.GetString("comboComputer.Text"); + this.comboComputer.Visible = ((bool)(resources.GetObject("comboComputer.Visible"))); + this.comboComputer.SelectedIndexChanged += new System.EventHandler(this.comboComputer_SelectedIndexChanged); + // + // btnCancel + // + this.btnCancel.AccessibleDescription = ((string)(resources.GetObject("btnCancel.AccessibleDescription"))); + this.btnCancel.AccessibleName = ((string)(resources.GetObject("btnCancel.AccessibleName"))); + this.btnCancel.Anchor = ((System.Windows.Forms.AnchorStyles)(resources.GetObject("btnCancel.Anchor"))); + this.btnCancel.BackgroundImage = ((System.Drawing.Image)(resources.GetObject("btnCancel.BackgroundImage"))); + this.btnCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.btnCancel.Dock = ((System.Windows.Forms.DockStyle)(resources.GetObject("btnCancel.Dock"))); + this.btnCancel.Enabled = ((bool)(resources.GetObject("btnCancel.Enabled"))); + this.btnCancel.FlatStyle = ((System.Windows.Forms.FlatStyle)(resources.GetObject("btnCancel.FlatStyle"))); + this.btnCancel.Font = ((System.Drawing.Font)(resources.GetObject("btnCancel.Font"))); + this.btnCancel.Image = ((System.Drawing.Image)(resources.GetObject("btnCancel.Image"))); + this.btnCancel.ImageAlign = ((System.Drawing.ContentAlignment)(resources.GetObject("btnCancel.ImageAlign"))); + this.btnCancel.ImageIndex = ((int)(resources.GetObject("btnCancel.ImageIndex"))); + this.btnCancel.ImeMode = ((System.Windows.Forms.ImeMode)(resources.GetObject("btnCancel.ImeMode"))); + this.btnCancel.Location = ((System.Drawing.Point)(resources.GetObject("btnCancel.Location"))); + this.btnCancel.Name = "btnCancel"; + this.btnCancel.RightToLeft = ((System.Windows.Forms.RightToLeft)(resources.GetObject("btnCancel.RightToLeft"))); + this.btnCancel.Size = ((System.Drawing.Size)(resources.GetObject("btnCancel.Size"))); + this.btnCancel.TabIndex = ((int)(resources.GetObject("btnCancel.TabIndex"))); + this.btnCancel.Text = resources.GetString("btnCancel.Text"); + this.btnCancel.TextAlign = ((System.Drawing.ContentAlignment)(resources.GetObject("btnCancel.TextAlign"))); + this.btnCancel.Visible = ((bool)(resources.GetObject("btnCancel.Visible"))); + this.btnCancel.Click += new System.EventHandler(this.btnCancel_Click); + // + // btnRemove + // + this.btnRemove.AccessibleDescription = ((string)(resources.GetObject("btnRemove.AccessibleDescription"))); + this.btnRemove.AccessibleName = ((string)(resources.GetObject("btnRemove.AccessibleName"))); + this.btnRemove.Anchor = ((System.Windows.Forms.AnchorStyles)(resources.GetObject("btnRemove.Anchor"))); + this.btnRemove.BackgroundImage = ((System.Drawing.Image)(resources.GetObject("btnRemove.BackgroundImage"))); + this.btnRemove.Dock = ((System.Windows.Forms.DockStyle)(resources.GetObject("btnRemove.Dock"))); + this.btnRemove.Enabled = ((bool)(resources.GetObject("btnRemove.Enabled"))); + this.btnRemove.FlatStyle = ((System.Windows.Forms.FlatStyle)(resources.GetObject("btnRemove.FlatStyle"))); + this.btnRemove.Font = ((System.Drawing.Font)(resources.GetObject("btnRemove.Font"))); + this.btnRemove.Image = ((System.Drawing.Image)(resources.GetObject("btnRemove.Image"))); + this.btnRemove.ImageAlign = ((System.Drawing.ContentAlignment)(resources.GetObject("btnRemove.ImageAlign"))); + this.btnRemove.ImageIndex = ((int)(resources.GetObject("btnRemove.ImageIndex"))); + this.btnRemove.ImeMode = ((System.Windows.Forms.ImeMode)(resources.GetObject("btnRemove.ImeMode"))); + this.btnRemove.Location = ((System.Drawing.Point)(resources.GetObject("btnRemove.Location"))); + this.btnRemove.Name = "btnRemove"; + this.btnRemove.RightToLeft = ((System.Windows.Forms.RightToLeft)(resources.GetObject("btnRemove.RightToLeft"))); + this.btnRemove.Size = ((System.Drawing.Size)(resources.GetObject("btnRemove.Size"))); + this.btnRemove.TabIndex = ((int)(resources.GetObject("btnRemove.TabIndex"))); + this.btnRemove.Text = resources.GetString("btnRemove.Text"); + this.btnRemove.TextAlign = ((System.Drawing.ContentAlignment)(resources.GetObject("btnRemove.TextAlign"))); + this.btnRemove.Visible = ((bool)(resources.GetObject("btnRemove.Visible"))); + this.btnRemove.Click += new System.EventHandler(this.btnRemove_Click); + // + // ComputerRemoveDialog + // + this.AcceptButton = this.btnRemove; + this.AccessibleDescription = ((string)(resources.GetObject("$this.AccessibleDescription"))); + this.AccessibleName = ((string)(resources.GetObject("$this.AccessibleName"))); + this.Anchor = ((System.Windows.Forms.AnchorStyles)(resources.GetObject("$this.Anchor"))); + this.AutoScaleBaseSize = ((System.Drawing.Size)(resources.GetObject("$this.AutoScaleBaseSize"))); + this.AutoScroll = ((bool)(resources.GetObject("$this.AutoScroll"))); + this.AutoScrollMargin = ((System.Drawing.Size)(resources.GetObject("$this.AutoScrollMargin"))); + this.AutoScrollMinSize = ((System.Drawing.Size)(resources.GetObject("$this.AutoScrollMinSize"))); + this.BackgroundImage = ((System.Drawing.Image)(resources.GetObject("$this.BackgroundImage"))); + this.CancelButton = this.btnCancel; + this.ClientSize = ((System.Drawing.Size)(resources.GetObject("$this.ClientSize"))); + this.Controls.AddRange(new System.Windows.Forms.Control[] { + this.btnRemove, + this.btnCancel, + this.comboComputer, + this.label1}); + this.Dock = ((System.Windows.Forms.DockStyle)(resources.GetObject("$this.Dock"))); + this.Enabled = ((bool)(resources.GetObject("$this.Enabled"))); + this.Font = ((System.Drawing.Font)(resources.GetObject("$this.Font"))); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.ImeMode = ((System.Windows.Forms.ImeMode)(resources.GetObject("$this.ImeMode"))); + this.Location = ((System.Drawing.Point)(resources.GetObject("$this.Location"))); + this.MaximizeBox = false; + this.MaximumSize = ((System.Drawing.Size)(resources.GetObject("$this.MaximumSize"))); + this.MinimizeBox = false; + this.MinimumSize = ((System.Drawing.Size)(resources.GetObject("$this.MinimumSize"))); + this.Name = "ComputerRemoveDialog"; + this.RightToLeft = ((System.Windows.Forms.RightToLeft)(resources.GetObject("$this.RightToLeft"))); + this.StartPosition = ((System.Windows.Forms.FormStartPosition)(resources.GetObject("$this.StartPosition"))); + this.Text = resources.GetString("$this.Text"); + this.Visible = ((bool)(resources.GetObject("$this.Visible"))); + this.Load += new System.EventHandler(this.ComputerRemoveDialog_Load); + this.ResumeLayout(false); + + } + #endregion + + private void btnRemove_Click(object sender, System.EventArgs e) + { + mgmt.RemoveComputer(comboComputer.SelectedItem.ToString()); + this.Dispose(); + } + + private void ComputerRemoveDialog_Load(object sender, System.EventArgs e) + { + ArrayList list = mgmt.getComputerCollection(); + foreach (Computer computer in list) + { + comboComputer.Items.Add(computer.getName()); + } + } + + private void btnCancel_Click(object sender, System.EventArgs e) + { + this.Close(); + this.Dispose(); + } + + private void comboComputer_SelectedIndexChanged(object sender, System.EventArgs e) + { + } + + + } +} diff --git a/ndb/src/cw/cpcc-win32/csharp/DATABASE.ICO b/ndb/src/cw/cpcc-win32/csharp/DATABASE.ICO new file mode 100644 index 00000000000..9689aa88361 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/csharp/DATABASE.ICO differ diff --git a/ndb/src/cw/cpcc-win32/csharp/Database.cs b/ndb/src/cw/cpcc-win32/csharp/Database.cs new file mode 100644 index 00000000000..39b8c160159 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/Database.cs @@ -0,0 +1,162 @@ +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using System.Windows.Forms; +using System.Data; + +namespace NDB_CPC +{ + /// + /// Summary description for Database. + /// + public class Database + { + public enum Status {Disconnected=1,Connected=2, Unknown=3} + private string m_name; + private string m_owner; + private int m_mgmtPort; + private Status m_status; + private ArrayList m_processes; + public Database(string name) + { + m_name=name; + m_processes = new ArrayList(); + } + public Database(string name, string owner) + { + m_name=name; + m_owner=owner; + m_processes = new ArrayList(); + } + public Database() + { + m_processes = new ArrayList(); + } + + public string getName() + { + return m_name; + } + + public void setName(string name) + { + m_name=name; + } + + public void setMgmtPort(int port) + { + m_mgmtPort=port; + } + + public string getOwner() + { + return m_owner; + } + + public void setOwner(string name) + { + m_owner=name; + } + + + public Status getStatus() + { + return m_status; + } + + public string getStatusString() + { + if(m_status.Equals(Status.Connected)) + return "Connected"; + if(m_status.Equals(Status.Disconnected)) + return "Disconnected"; + if(m_status.Equals(Status.Unknown)) + return "Unknown"; + return "Unknown"; + } + public void setStatus(Status status) + { + m_status=status; + } + + public void addProcess(Process process) + { + /*if(check) + { + if(m_processes==null) + return; + if(m_processes.Count>0) + { + foreach (Process p in m_processes) + { + if(process.getId().Equals(p.getId())) + return; + } + } + } + */ + m_processes.Add(process); + } + public void addProcessCheck(Process process) + { + + if(m_processes==null) + return; + if(m_processes.Count>0) + { + foreach (Process p in m_processes) + { + if(process.getId().Equals(p.getId())) + return; + } + } + m_processes.Add(process); + } + + public Process getProcess(string id) + { + foreach(Process process in m_processes) + { + if(process.getId().Equals(id)) + return process; + } + return null; + } + + public Process getProcessByName(string name) + { + foreach(Process process in m_processes) + { + if(process.getName().Equals(name)) + return process; + } + return null; + } + + public void removeProcess( string processName) + { + Process p = this.getProcessByName(processName); + m_processes.Remove(p); + } + + public void removeAllProcesses() + { + Computer c; + foreach(Process p in m_processes) + { + c=p.getComputer(); + if(c.removeProcess(p.getName(),m_name).Equals(false)) + { + + } + } + m_processes.Clear(); + } + + public ArrayList getProcesses() + { + return m_processes; + } + } +} diff --git a/ndb/src/cw/cpcc-win32/csharp/NDB_CPC.csproj b/ndb/src/cw/cpcc-win32/csharp/NDB_CPC.csproj new file mode 100644 index 00000000000..6384eff8329 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/NDB_CPC.csproj @@ -0,0 +1,240 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/ndb/src/cw/cpcc-win32/csharp/NDB_CPC.csproj.user b/ndb/src/cw/cpcc-win32/csharp/NDB_CPC.csproj.user new file mode 100644 index 00000000000..68937906d93 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/NDB_CPC.csproj.user @@ -0,0 +1,48 @@ + + + + + + + + + + + + diff --git a/ndb/src/cw/cpcc-win32/csharp/NDB_CPC.ncb b/ndb/src/cw/cpcc-win32/csharp/NDB_CPC.ncb new file mode 100644 index 00000000000..ed3460476b0 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/csharp/NDB_CPC.ncb differ diff --git a/ndb/src/cw/cpcc-win32/csharp/NDB_CPC.sln b/ndb/src/cw/cpcc-win32/csharp/NDB_CPC.sln new file mode 100644 index 00000000000..ef18b5e94ce --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/NDB_CPC.sln @@ -0,0 +1,21 @@ +Microsoft Visual Studio Solution File, Format Version 7.00 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NDB_CPC", "NDB_CPC.csproj", "{B78F6720-D36C-43DD-B442-F583718D0286}" +EndProject +Global + GlobalSection(SolutionConfiguration) = preSolution + ConfigName.0 = Debug + ConfigName.1 = Release + EndGlobalSection + GlobalSection(ProjectDependencies) = postSolution + EndGlobalSection + GlobalSection(ProjectConfiguration) = postSolution + {B78F6720-D36C-43DD-B442-F583718D0286}.Debug.ActiveCfg = Debug|.NET + {B78F6720-D36C-43DD-B442-F583718D0286}.Debug.Build.0 = Debug|.NET + {B78F6720-D36C-43DD-B442-F583718D0286}.Release.ActiveCfg = Release|.NET + {B78F6720-D36C-43DD-B442-F583718D0286}.Release.Build.0 = Release|.NET + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + EndGlobalSection + GlobalSection(ExtensibilityAddIns) = postSolution + EndGlobalSection +EndGlobal diff --git a/ndb/src/cw/cpcc-win32/csharp/PanelWizard.cs b/ndb/src/cw/cpcc-win32/csharp/PanelWizard.cs new file mode 100644 index 00000000000..f492aa64c60 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/PanelWizard.cs @@ -0,0 +1,1883 @@ +//author:Arun +//date:Nov 13,2002 +//Wizard using panel +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using System.Windows.Forms; + +namespace NDB_CPC +{ + /// + /// Summary description for MDXQueryBuilderWizard. + /// + public class PanelWizard : System.Windows.Forms.Form + { + private System.Windows.Forms.Button btnCancel; + private System.Windows.Forms.Button btnback; + private System.Windows.Forms.Button btnNext; + private System.Windows.Forms.Button btnFinish; + + //---enabling and disabling the buttons + private bool cancelEnabled; + private bool backEnabled; + private bool nextEnabled; + private bool finishEnabled; + //-------- + //--set the next and back panel + private Panel nextPanel; + private Panel backPanel; + private Panel presentPanel; + // + private Panel[] arrayPanel; + private System.Windows.Forms.Panel panel1; + private System.Windows.Forms.Panel panel2; + private System.Windows.Forms.Panel panel3; + private System.Windows.Forms.RadioButton radioBtnYes; + private System.Windows.Forms.RadioButton radioBtnNo; + private System.Windows.Forms.ListBox listBoxComputers; + private System.Windows.Forms.Label label5; + private System.Windows.Forms.Label label1; + private System.ComponentModel.IContainer components; + private System.Windows.Forms.Button buttonComputerAdd; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Label label6; + private System.Windows.Forms.Label label7; + private System.Windows.Forms.ComboBox comboNDB; + private System.Windows.Forms.ComboBox comboAPI; + private System.Windows.Forms.Label label8; + private System.Windows.Forms.ComboBox comboMGM; + private System.Windows.Forms.Button btnTransferNodeToComp; + private System.Windows.Forms.TreeView tvComputer; + private System.Windows.Forms.ListView lvNode; + private System.Windows.Forms.Button btnTransferCompToNode; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.Label label9; + private System.Windows.Forms.Label label10; + private int m_nMGM; + private ComputerMgmt mgmt; + private int m_nNDB; + private int m_nAPI; + private Database m_db; + private System.Windows.Forms.Label label11; + private System.Windows.Forms.TextBox textDbName; + private System.Windows.Forms.Label label31; + private System.Windows.Forms.Label label32; + private System.Windows.Forms.Label label33; + private System.Windows.Forms.Label label18; + private System.Windows.Forms.Label labelTitle; + private System.Windows.Forms.Label labelCwd; + private System.Windows.Forms.Label labelArgs; + private System.Windows.Forms.Label labelOther; + private System.Windows.Forms.Label labelPath; + private int m_noOfConfiguredNodes; + private int m_noOfConfiguredMgmt; + private int m_noOfConfiguredNdb; + private string m_mgmHost; + private string m_mgmPort; + private System.Windows.Forms.TextBox textCwd; + private System.Windows.Forms.TextBox textArgs; + private System.Windows.Forms.TextBox textOther; + private System.Windows.Forms.TextBox textPath; + private System.Windows.Forms.TextBox textComputer; + private System.Windows.Forms.TextBox textDatabase; + private System.Windows.Forms.TextBox textName; + private int m_noOfConfiguredApi; + private bool m_bMgmt; + private System.Windows.Forms.Button buttonSave; + private System.Windows.Forms.CheckBox checkBoxReuse; + private System.Windows.Forms.Label label4; + private System.Windows.Forms.Panel panel4; + private System.Windows.Forms.CheckBox checkBoxLater; + private System.Windows.Forms.RadioButton radioYes; + private System.Windows.Forms.RadioButton radioNo; + private System.Windows.Forms.Panel panel6; + private System.Windows.Forms.Panel panel5; + private System.Windows.Forms.RadioButton radioStartNo; + private System.Windows.Forms.RadioButton radioStartYes; + private System.Windows.Forms.ImageList imageListComp; + private System.Windows.Forms.Label label12; + private System.Windows.Forms.TextBox textOwner; + private System.Windows.Forms.Label label13; + private System.Windows.Forms.TextBox textEnv; + private bool m_bNdb; + public PanelWizard(ComputerMgmt comp) + { + mgmt=comp; + m_noOfConfiguredNodes=0; + m_noOfConfiguredMgmt=0; + m_noOfConfiguredNdb=0; + m_noOfConfiguredApi=0; + Size panelSize= new Size(350,300); + Size s= new Size(355,360); + Point cancel= new Point(8,310); + Point back= new Point(96,310); + Point next = new Point(184,310); + Point finish= new Point(272,310); + InitializeComponent(); + this.Size=s; + this.btnCancel.Location=cancel; + + this.btnback.Location=back; + this.btnNext.Location=next; + this.btnFinish.Location=finish; + + arrayPanel=new Panel[]{panel1,panel2,panel3,panel4,panel5,panel6};//,panel5, panel6}; + panel1.Size=panelSize; + + comboNDB.SelectedIndex=0; + comboAPI.SelectedIndex=0; + comboMGM.SelectedIndex=0; + m_bMgmt=false; + m_bNdb=false; + + m_db = new Database(); + if(listBoxComputers.Items.Count.Equals(0)) + btnNext.Enabled=false; + } + + /// + /// Clean up any resources being used. + /// + protected override void Dispose( bool disposing ) + { + if( disposing ) + { + if(components != null) + { + components.Dispose(); + } + } + base.Dispose( disposing ); + } + + #region Windows Form Designer generated code + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.Resources.ResourceManager resources = new System.Resources.ResourceManager(typeof(PanelWizard)); + this.panel1 = new System.Windows.Forms.Panel(); + this.buttonComputerAdd = new System.Windows.Forms.Button(); + this.label1 = new System.Windows.Forms.Label(); + this.label5 = new System.Windows.Forms.Label(); + this.listBoxComputers = new System.Windows.Forms.ListBox(); + this.radioBtnNo = new System.Windows.Forms.RadioButton(); + this.radioBtnYes = new System.Windows.Forms.RadioButton(); + this.panel2 = new System.Windows.Forms.Panel(); + this.label12 = new System.Windows.Forms.Label(); + this.textOwner = new System.Windows.Forms.TextBox(); + this.label11 = new System.Windows.Forms.Label(); + this.textDbName = new System.Windows.Forms.TextBox(); + this.label8 = new System.Windows.Forms.Label(); + this.label7 = new System.Windows.Forms.Label(); + this.label6 = new System.Windows.Forms.Label(); + this.comboMGM = new System.Windows.Forms.ComboBox(); + this.comboAPI = new System.Windows.Forms.ComboBox(); + this.comboNDB = new System.Windows.Forms.ComboBox(); + this.label2 = new System.Windows.Forms.Label(); + this.panel3 = new System.Windows.Forms.Panel(); + this.checkBoxLater = new System.Windows.Forms.CheckBox(); + this.label10 = new System.Windows.Forms.Label(); + this.label9 = new System.Windows.Forms.Label(); + this.label3 = new System.Windows.Forms.Label(); + this.btnTransferCompToNode = new System.Windows.Forms.Button(); + this.btnTransferNodeToComp = new System.Windows.Forms.Button(); + this.lvNode = new System.Windows.Forms.ListView(); + this.tvComputer = new System.Windows.Forms.TreeView(); + this.imageListComp = new System.Windows.Forms.ImageList(this.components); + this.panel6 = new System.Windows.Forms.Panel(); + this.radioStartNo = new System.Windows.Forms.RadioButton(); + this.radioStartYes = new System.Windows.Forms.RadioButton(); + this.label18 = new System.Windows.Forms.Label(); + this.btnCancel = new System.Windows.Forms.Button(); + this.btnback = new System.Windows.Forms.Button(); + this.btnNext = new System.Windows.Forms.Button(); + this.btnFinish = new System.Windows.Forms.Button(); + this.panel4 = new System.Windows.Forms.Panel(); + this.textEnv = new System.Windows.Forms.TextBox(); + this.label13 = new System.Windows.Forms.Label(); + this.checkBoxReuse = new System.Windows.Forms.CheckBox(); + this.buttonSave = new System.Windows.Forms.Button(); + this.labelTitle = new System.Windows.Forms.Label(); + this.textComputer = new System.Windows.Forms.TextBox(); + this.textCwd = new System.Windows.Forms.TextBox(); + this.textArgs = new System.Windows.Forms.TextBox(); + this.textOther = new System.Windows.Forms.TextBox(); + this.textPath = new System.Windows.Forms.TextBox(); + this.textDatabase = new System.Windows.Forms.TextBox(); + this.textName = new System.Windows.Forms.TextBox(); + this.labelCwd = new System.Windows.Forms.Label(); + this.labelArgs = new System.Windows.Forms.Label(); + this.labelOther = new System.Windows.Forms.Label(); + this.labelPath = new System.Windows.Forms.Label(); + this.label31 = new System.Windows.Forms.Label(); + this.label32 = new System.Windows.Forms.Label(); + this.label33 = new System.Windows.Forms.Label(); + this.panel5 = new System.Windows.Forms.Panel(); + this.radioNo = new System.Windows.Forms.RadioButton(); + this.radioYes = new System.Windows.Forms.RadioButton(); + this.label4 = new System.Windows.Forms.Label(); + this.panel1.SuspendLayout(); + this.panel2.SuspendLayout(); + this.panel3.SuspendLayout(); + this.panel6.SuspendLayout(); + this.panel4.SuspendLayout(); + this.panel5.SuspendLayout(); + this.SuspendLayout(); + // + // panel1 + // + this.panel1.Controls.AddRange(new System.Windows.Forms.Control[] { + this.buttonComputerAdd, + this.label1, + this.label5, + this.listBoxComputers, + this.radioBtnNo, + this.radioBtnYes}); + this.panel1.Name = "panel1"; + this.panel1.Size = new System.Drawing.Size(344, 312); + this.panel1.TabIndex = 0; + this.panel1.Paint += new System.Windows.Forms.PaintEventHandler(this.panel1_Paint); + // + // buttonComputerAdd + // + this.buttonComputerAdd.Enabled = false; + this.buttonComputerAdd.Location = new System.Drawing.Point(192, 232); + this.buttonComputerAdd.Name = "buttonComputerAdd"; + this.buttonComputerAdd.Size = new System.Drawing.Size(96, 24); + this.buttonComputerAdd.TabIndex = 3; + this.buttonComputerAdd.Text = "Add computer..."; + this.buttonComputerAdd.Click += new System.EventHandler(this.buttonComputerAdd_Click); + // + // label1 + // + this.label1.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((System.Byte)(0))); + this.label1.Location = new System.Drawing.Point(80, 8); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(200, 23); + this.label1.TabIndex = 5; + this.label1.Text = "Configure computers"; + this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // + // label5 + // + this.label5.Location = new System.Drawing.Point(24, 40); + this.label5.Name = "label5"; + this.label5.Size = new System.Drawing.Size(128, 23); + this.label5.TabIndex = 4; + this.label5.Text = "Available computers:"; + this.label5.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // + // listBoxComputers + // + this.listBoxComputers.Location = new System.Drawing.Point(24, 64); + this.listBoxComputers.Name = "listBoxComputers"; + this.listBoxComputers.Size = new System.Drawing.Size(128, 212); + this.listBoxComputers.TabIndex = 3; + this.listBoxComputers.SelectedIndexChanged += new System.EventHandler(this.listBoxComputers_SelectedIndexChanged); + // + // radioBtnNo + // + this.radioBtnNo.AutoCheck = false; + this.radioBtnNo.Location = new System.Drawing.Point(168, 168); + this.radioBtnNo.Name = "radioBtnNo"; + this.radioBtnNo.Size = new System.Drawing.Size(152, 64); + this.radioBtnNo.TabIndex = 2; + this.radioBtnNo.Text = "No, I have to add more computers in order to deploy NDB Cluster. "; + this.radioBtnNo.Click += new System.EventHandler(this.radioBtnNo_Click); + // + // radioBtnYes + // + this.radioBtnYes.AutoCheck = false; + this.radioBtnYes.Location = new System.Drawing.Point(168, 72); + this.radioBtnYes.Name = "radioBtnYes"; + this.radioBtnYes.Size = new System.Drawing.Size(152, 80); + this.radioBtnYes.TabIndex = 1; + this.radioBtnYes.Text = "Yes, all the computers that I need to deploy NDB Cluster exists in the list \"Avai" + + "lable computers\""; + this.radioBtnYes.Click += new System.EventHandler(this.radioBtnYes_Click); + // + // panel2 + // + this.panel2.Controls.AddRange(new System.Windows.Forms.Control[] { + this.label12, + this.textOwner, + this.label11, + this.textDbName, + this.label8, + this.label7, + this.label6, + this.comboMGM, + this.comboAPI, + this.comboNDB, + this.label2}); + this.panel2.Location = new System.Drawing.Point(0, 320); + this.panel2.Name = "panel2"; + this.panel2.Size = new System.Drawing.Size(344, 312); + this.panel2.TabIndex = 1; + this.panel2.Validating += new System.ComponentModel.CancelEventHandler(this.panel2_Validating); + this.panel2.Paint += new System.Windows.Forms.PaintEventHandler(this.panel2_Paint); + // + // label12 + // + this.label12.Location = new System.Drawing.Point(72, 216); + this.label12.Name = "label12"; + this.label12.Size = new System.Drawing.Size(112, 24); + this.label12.TabIndex = 16; + this.label12.Text = "Database owner:"; + this.label12.TextAlign = System.Drawing.ContentAlignment.MiddleRight; + // + // textOwner + // + this.textOwner.Location = new System.Drawing.Point(192, 216); + this.textOwner.Name = "textOwner"; + this.textOwner.TabIndex = 5; + this.textOwner.Text = ""; + this.textOwner.TextChanged += new System.EventHandler(this.textOwner_TextChanged); + // + // label11 + // + this.label11.Location = new System.Drawing.Point(72, 184); + this.label11.Name = "label11"; + this.label11.Size = new System.Drawing.Size(112, 24); + this.label11.TabIndex = 14; + this.label11.Text = "Database name:"; + this.label11.TextAlign = System.Drawing.ContentAlignment.MiddleRight; + this.label11.Click += new System.EventHandler(this.label11_Click); + // + // textDbName + // + this.textDbName.Location = new System.Drawing.Point(192, 184); + this.textDbName.Name = "textDbName"; + this.textDbName.TabIndex = 4; + this.textDbName.Text = ""; + + this.textDbName.TextChanged += new System.EventHandler(this.textDbName_TextChanged); + // + // label8 + // + this.label8.Location = new System.Drawing.Point(16, 120); + this.label8.Name = "label8"; + this.label8.Size = new System.Drawing.Size(176, 24); + this.label8.TabIndex = 12; + this.label8.Text = "Number of management servers:"; + this.label8.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // label7 + // + this.label7.Location = new System.Drawing.Point(16, 88); + this.label7.Name = "label7"; + this.label7.Size = new System.Drawing.Size(120, 24); + this.label7.TabIndex = 11; + this.label7.Text = "Number of API nodes:"; + this.label7.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // label6 + // + this.label6.Location = new System.Drawing.Point(16, 56); + this.label6.Name = "label6"; + this.label6.Size = new System.Drawing.Size(144, 24); + this.label6.TabIndex = 10; + this.label6.Text = "Number of database nodes:"; + this.label6.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // comboMGM + // + this.comboMGM.DisplayMember = "0"; + this.comboMGM.Items.AddRange(new object[] { + "1"}); + this.comboMGM.Location = new System.Drawing.Point(192, 120); + this.comboMGM.Name = "comboMGM"; + this.comboMGM.Size = new System.Drawing.Size(104, 21); + this.comboMGM.TabIndex = 3; + this.comboMGM.Text = "comboBox3"; + // + // comboAPI + // + this.comboAPI.DisplayMember = "0"; + this.comboAPI.Items.AddRange(new object[] { + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "9", + "10"}); + this.comboAPI.Location = new System.Drawing.Point(192, 88); + this.comboAPI.Name = "comboAPI"; + this.comboAPI.Size = new System.Drawing.Size(104, 21); + this.comboAPI.TabIndex = 2; + this.comboAPI.Text = "comboBox2"; + // + // comboNDB + // + this.comboNDB.DisplayMember = "0"; + this.comboNDB.Items.AddRange(new object[] { + "1", + "2", + "4", + "8"}); + this.comboNDB.Location = new System.Drawing.Point(192, 56); + this.comboNDB.Name = "comboNDB"; + this.comboNDB.Size = new System.Drawing.Size(104, 21); + this.comboNDB.TabIndex = 1; + this.comboNDB.Text = "comboBox1"; + // + // label2 + // + this.label2.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((System.Byte)(0))); + this.label2.Location = new System.Drawing.Point(80, 8); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(208, 23); + this.label2.TabIndex = 6; + this.label2.Text = "Setup NDB Cluster nodes"; + this.label2.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // + // panel3 + // + this.panel3.Controls.AddRange(new System.Windows.Forms.Control[] { + this.checkBoxLater, + this.label10, + this.label9, + this.label3, + this.btnTransferCompToNode, + this.btnTransferNodeToComp, + this.lvNode, + this.tvComputer}); + this.panel3.Location = new System.Drawing.Point(360, 8); + this.panel3.Name = "panel3"; + this.panel3.Size = new System.Drawing.Size(320, 312); + this.panel3.TabIndex = 2; + // + // checkBoxLater + // + this.checkBoxLater.Location = new System.Drawing.Point(40, 256); + this.checkBoxLater.Name = "checkBoxLater"; + this.checkBoxLater.Size = new System.Drawing.Size(240, 16); + this.checkBoxLater.TabIndex = 9; + this.checkBoxLater.Text = "I will configure these nodes manually, later."; + // + // label10 + // + this.label10.Location = new System.Drawing.Point(16, 40); + this.label10.Name = "label10"; + this.label10.Size = new System.Drawing.Size(104, 16); + this.label10.TabIndex = 8; + this.label10.Text = "NDB Cluster nodes:"; + this.label10.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // label9 + // + this.label9.Location = new System.Drawing.Point(192, 40); + this.label9.Name = "label9"; + this.label9.Size = new System.Drawing.Size(100, 16); + this.label9.TabIndex = 7; + this.label9.Text = "Computers:"; + this.label9.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // label3 + // + this.label3.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((System.Byte)(0))); + this.label3.Location = new System.Drawing.Point(40, 8); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(280, 23); + this.label3.TabIndex = 6; + this.label3.Text = "Assign NDB nodes to computers"; + this.label3.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // + // btnTransferCompToNode + // + this.btnTransferCompToNode.Location = new System.Drawing.Point(144, 160); + this.btnTransferCompToNode.Name = "btnTransferCompToNode"; + this.btnTransferCompToNode.Size = new System.Drawing.Size(40, 24); + this.btnTransferCompToNode.TabIndex = 4; + this.btnTransferCompToNode.Text = "<---"; + // + // btnTransferNodeToComp + // + this.btnTransferNodeToComp.Location = new System.Drawing.Point(144, 128); + this.btnTransferNodeToComp.Name = "btnTransferNodeToComp"; + this.btnTransferNodeToComp.Size = new System.Drawing.Size(40, 24); + this.btnTransferNodeToComp.TabIndex = 3; + this.btnTransferNodeToComp.Text = "--->"; + this.btnTransferNodeToComp.Click += new System.EventHandler(this.btnTransferNodeToComp_Click); + // + // lvNode + // + this.lvNode.HideSelection = false; + this.lvNode.Location = new System.Drawing.Point(16, 56); + this.lvNode.Name = "lvNode"; + this.lvNode.Size = new System.Drawing.Size(112, 192); + this.lvNode.TabIndex = 2; + this.lvNode.View = System.Windows.Forms.View.List; + this.lvNode.SelectedIndexChanged += new System.EventHandler(this.lvNode_SelectedIndexChanged); + // + // tvComputer + // + this.tvComputer.HideSelection = false; + this.tvComputer.ImageList = this.imageListComp; + this.tvComputer.Location = new System.Drawing.Point(192, 56); + this.tvComputer.Name = "tvComputer"; + this.tvComputer.Size = new System.Drawing.Size(120, 192); + this.tvComputer.TabIndex = 1; + this.tvComputer.MouseDown += new System.Windows.Forms.MouseEventHandler(this.tvComputer_MouseDown); + this.tvComputer.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.tvComputer_AfterSelect); + this.tvComputer.MouseLeave += new System.EventHandler(this.tvComputer_MouseLeave); + this.tvComputer.DragDrop += new System.Windows.Forms.DragEventHandler(this.tvComputer_DragDrop); + // + // imageListComp + // + this.imageListComp.ColorDepth = System.Windows.Forms.ColorDepth.Depth8Bit; + this.imageListComp.ImageSize = new System.Drawing.Size(16, 16); + this.imageListComp.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageListComp.ImageStream"))); + this.imageListComp.TransparentColor = System.Drawing.Color.Transparent; + // + // panel6 + // + this.panel6.Controls.AddRange(new System.Windows.Forms.Control[] { + this.radioStartNo, + this.radioStartYes, + this.label18}); + this.panel6.Location = new System.Drawing.Point(344, 336); + this.panel6.Name = "panel6"; + this.panel6.Size = new System.Drawing.Size(344, 312); + this.panel6.TabIndex = 3; + this.panel6.Paint += new System.Windows.Forms.PaintEventHandler(this.panel4_Paint); + // + // radioStartNo + // + this.radioStartNo.Location = new System.Drawing.Point(40, 144); + this.radioStartNo.Name = "radioStartNo"; + this.radioStartNo.Size = new System.Drawing.Size(272, 48); + this.radioStartNo.TabIndex = 81; + this.radioStartNo.Text = "Manually start NDB Cluster. The Magician will exit and you must start NDB Cluster" + + " manually."; + this.radioStartNo.CheckedChanged += new System.EventHandler(this.radioStartNo_CheckedChanged); + // + // radioStartYes + // + this.radioStartYes.Location = new System.Drawing.Point(40, 40); + this.radioStartYes.Name = "radioStartYes"; + this.radioStartYes.Size = new System.Drawing.Size(272, 88); + this.radioStartYes.TabIndex = 80; + this.radioStartYes.Text = "Start NDB Cluster now. The Magician will start NDB Cluster and exit. MAKE SURE YO" + + "U HAVE STARTED THE MGMTSRVR WITH THE CORRECT CONFIGURATION FILE!!!"; + this.radioStartYes.CheckedChanged += new System.EventHandler(this.radioStartYes_CheckedChanged); + // + // label18 + // + this.label18.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((System.Byte)(0))); + this.label18.Location = new System.Drawing.Point(56, 8); + this.label18.Name = "label18"; + this.label18.Size = new System.Drawing.Size(224, 24); + this.label18.TabIndex = 79; + this.label18.Text = "Start NDB Cluster and finish"; + // + // btnCancel + // + this.btnCancel.Location = new System.Drawing.Point(8, 656); + this.btnCancel.Name = "btnCancel"; + this.btnCancel.Size = new System.Drawing.Size(70, 23); + this.btnCancel.TabIndex = 10; + this.btnCancel.Text = "Cancel"; + this.btnCancel.Click += new System.EventHandler(this.btnCancel_Click); + // + // btnback + // + this.btnback.Location = new System.Drawing.Point(96, 656); + this.btnback.Name = "btnback"; + this.btnback.Size = new System.Drawing.Size(70, 23); + this.btnback.TabIndex = 11; + this.btnback.Text = "< Back"; + this.btnback.Click += new System.EventHandler(this.btnback_Click); + // + // btnNext + // + this.btnNext.Location = new System.Drawing.Point(184, 656); + this.btnNext.Name = "btnNext"; + this.btnNext.Size = new System.Drawing.Size(70, 23); + this.btnNext.TabIndex = 12; + this.btnNext.Text = "Next >"; + this.btnNext.Click += new System.EventHandler(this.btnNext_Click); + // + // btnFinish + // + this.btnFinish.Location = new System.Drawing.Point(272, 656); + this.btnFinish.Name = "btnFinish"; + this.btnFinish.Size = new System.Drawing.Size(70, 23); + this.btnFinish.TabIndex = 13; + this.btnFinish.Text = "Finish"; + this.btnFinish.Click += new System.EventHandler(this.btnFinish_Click); + // + // panel4 + // + this.panel4.Controls.AddRange(new System.Windows.Forms.Control[] { + this.textEnv, + this.label13, + this.checkBoxReuse, + this.buttonSave, + this.labelTitle, + this.textComputer, + this.textCwd, + this.textArgs, + this.textOther, + this.textPath, + this.textDatabase, + this.textName, + this.labelCwd, + this.labelArgs, + this.labelOther, + this.labelPath, + this.label31, + this.label32, + this.label33}); + this.panel4.Location = new System.Drawing.Point(672, 8); + this.panel4.Name = "panel4"; + this.panel4.Size = new System.Drawing.Size(344, 312); + this.panel4.TabIndex = 62; + this.panel4.Paint += new System.Windows.Forms.PaintEventHandler(this.panel5_Paint); + // + // textEnv + // + this.textEnv.Location = new System.Drawing.Point(136, 136); + this.textEnv.Name = "textEnv"; + this.textEnv.Size = new System.Drawing.Size(184, 20); + this.textEnv.TabIndex = 2; + this.textEnv.TabStop = false; + this.textEnv.Text = ""; + // + // label13 + // + this.label13.Location = new System.Drawing.Point(8, 136); + this.label13.Name = "label13"; + this.label13.Size = new System.Drawing.Size(136, 24); + this.label13.TabIndex = 81; + this.label13.Text = "Environment variables:"; + // + // checkBoxReuse + // + this.checkBoxReuse.Location = new System.Drawing.Point(88, 232); + this.checkBoxReuse.Name = "checkBoxReuse"; + this.checkBoxReuse.Size = new System.Drawing.Size(240, 32); + this.checkBoxReuse.TabIndex = 5; + this.checkBoxReuse.TabStop = false; + this.checkBoxReuse.Text = "Use the same configuration for ALL NDB nodes?"; + // + // buttonSave + // + this.buttonSave.Location = new System.Drawing.Point(184, 264); + this.buttonSave.Name = "buttonSave"; + this.buttonSave.Size = new System.Drawing.Size(88, 24); + this.buttonSave.TabIndex = 6; + this.buttonSave.Text = "Save"; + this.buttonSave.Click += new System.EventHandler(this.buttonSave_Click); + // + // labelTitle + // + this.labelTitle.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((System.Byte)(0))); + this.labelTitle.Location = new System.Drawing.Point(80, 16); + this.labelTitle.Name = "labelTitle"; + this.labelTitle.Size = new System.Drawing.Size(192, 23); + this.labelTitle.TabIndex = 79; + this.labelTitle.Text = "Mgmtsrvr configuration"; + // + // textComputer + // + this.textComputer.Location = new System.Drawing.Point(136, 40); + this.textComputer.Name = "textComputer"; + this.textComputer.ReadOnly = true; + this.textComputer.Size = new System.Drawing.Size(184, 20); + this.textComputer.TabIndex = 77; + this.textComputer.TabStop = false; + this.textComputer.Text = ""; + // + // textCwd + // + this.textCwd.Location = new System.Drawing.Point(136, 208); + this.textCwd.Name = "textCwd"; + this.textCwd.Size = new System.Drawing.Size(184, 20); + this.textCwd.TabIndex = 5; + this.textCwd.TabStop = false; + this.textCwd.Text = ""; + // + // textArgs + // + this.textArgs.Location = new System.Drawing.Point(136, 184); + this.textArgs.Name = "textArgs"; + this.textArgs.Size = new System.Drawing.Size(184, 20); + this.textArgs.TabIndex = 4; + this.textArgs.TabStop = false; + this.textArgs.Text = ""; + // + // textOther + // + this.textOther.Location = new System.Drawing.Point(136, 160); + this.textOther.Name = "textOther"; + this.textOther.Size = new System.Drawing.Size(184, 20); + this.textOther.TabIndex = 3; + this.textOther.TabStop = false; + this.textOther.Text = ""; + // + // textPath + // + this.textPath.Location = new System.Drawing.Point(136, 112); + this.textPath.Name = "textPath"; + this.textPath.Size = new System.Drawing.Size(184, 20); + this.textPath.TabIndex = 1; + this.textPath.TabStop = false; + this.textPath.Text = ""; + this.textPath.TextChanged += new System.EventHandler(this.textPath_TextChanged); + // + // textDatabase + // + this.textDatabase.Location = new System.Drawing.Point(136, 88); + this.textDatabase.Name = "textDatabase"; + this.textDatabase.ReadOnly = true; + this.textDatabase.Size = new System.Drawing.Size(184, 20); + this.textDatabase.TabIndex = 62; + this.textDatabase.TabStop = false; + this.textDatabase.Text = ""; + // + // textName + // + this.textName.Location = new System.Drawing.Point(136, 64); + this.textName.Name = "textName"; + this.textName.ReadOnly = true; + this.textName.Size = new System.Drawing.Size(184, 20); + this.textName.TabIndex = 60; + this.textName.TabStop = false; + this.textName.Text = ""; + // + // labelCwd + // + this.labelCwd.Location = new System.Drawing.Point(8, 208); + this.labelCwd.Name = "labelCwd"; + this.labelCwd.Size = new System.Drawing.Size(112, 24); + this.labelCwd.TabIndex = 72; + this.labelCwd.Text = "Current working dir.:"; + // + // labelArgs + // + this.labelArgs.Location = new System.Drawing.Point(8, 184); + this.labelArgs.Name = "labelArgs"; + this.labelArgs.Size = new System.Drawing.Size(128, 24); + this.labelArgs.TabIndex = 70; + this.labelArgs.Text = "Arguments to mgmtsrvr:"; + // + // labelOther + // + this.labelOther.Location = new System.Drawing.Point(8, 160); + this.labelOther.Name = "labelOther"; + this.labelOther.Size = new System.Drawing.Size(136, 24); + this.labelOther.TabIndex = 69; + this.labelOther.Text = "Mgmtsrvr port:"; + // + // labelPath + // + this.labelPath.Location = new System.Drawing.Point(8, 112); + this.labelPath.Name = "labelPath"; + this.labelPath.Size = new System.Drawing.Size(128, 24); + this.labelPath.TabIndex = 67; + this.labelPath.Text = "Path to mgmtsrvr binary:"; + // + // label31 + // + this.label31.Location = new System.Drawing.Point(8, 88); + this.label31.Name = "label31"; + this.label31.Size = new System.Drawing.Size(88, 24); + this.label31.TabIndex = 65; + this.label31.Text = "Database:"; + // + // label32 + // + this.label32.Location = new System.Drawing.Point(8, 64); + this.label32.Name = "label32"; + this.label32.Size = new System.Drawing.Size(88, 24); + this.label32.TabIndex = 63; + this.label32.Text = "Process name:"; + // + // label33 + // + this.label33.Location = new System.Drawing.Point(8, 40); + this.label33.Name = "label33"; + this.label33.Size = new System.Drawing.Size(64, 24); + this.label33.TabIndex = 61; + this.label33.Text = "Computer:"; + // + // panel5 + // + this.panel5.Controls.AddRange(new System.Windows.Forms.Control[] { + this.radioNo, + this.radioYes, + this.label4}); + this.panel5.Location = new System.Drawing.Point(672, 328); + this.panel5.Name = "panel5"; + this.panel5.Size = new System.Drawing.Size(344, 312); + this.panel5.TabIndex = 63; + // + // radioNo + // + this.radioNo.Location = new System.Drawing.Point(72, 160); + this.radioNo.Name = "radioNo"; + this.radioNo.Size = new System.Drawing.Size(240, 48); + this.radioNo.TabIndex = 1; + this.radioNo.Text = "I already have a configuration file that I want to use for this configuration."; + this.radioNo.CheckedChanged += new System.EventHandler(this.radioNo_CheckedChanged); + // + // radioYes + // + this.radioYes.Checked = true; + this.radioYes.Location = new System.Drawing.Point(72, 56); + this.radioYes.Name = "radioYes"; + this.radioYes.Size = new System.Drawing.Size(240, 88); + this.radioYes.TabIndex = 0; + this.radioYes.TabStop = true; + this.radioYes.Text = "Generate a configuration file template (initconfig.txt) for the mgmtsrvr based on" + + " the specified configuration? Notepad will be started with a template that you m" + + "ust complete and save in the cwd of the mgmtsrvr."; + this.radioYes.CheckedChanged += new System.EventHandler(this.radioYes_CheckedChanged); + // + // label4 + // + this.label4.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((System.Byte)(0))); + this.label4.Location = new System.Drawing.Point(88, 8); + this.label4.Name = "label4"; + this.label4.Size = new System.Drawing.Size(192, 40); + this.label4.TabIndex = 79; + this.label4.Text = "Tying up the configuration"; + this.label4.TextAlign = System.Drawing.ContentAlignment.TopCenter; + // + // PanelWizard + // + this.AutoScaleBaseSize = new System.Drawing.Size(5, 13); + this.ClientSize = new System.Drawing.Size(1030, 755); + this.Controls.AddRange(new System.Windows.Forms.Control[] { + this.panel5, + this.panel4, + this.panel1, + this.btnFinish, + this.btnNext, + this.btnback, + this.btnCancel, + this.panel6, + this.panel3, + this.panel2}); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "PanelWizard"; + this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide; + this.Text = "Create Database Magician"; + this.Load += new System.EventHandler(this.MDXQueryBuilderWizard_Load); + this.Activated += new System.EventHandler(this.PanelWizard_Activated); + this.panel1.ResumeLayout(false); + this.panel2.ResumeLayout(false); + this.panel3.ResumeLayout(false); + this.panel6.ResumeLayout(false); + this.panel4.ResumeLayout(false); + this.panel5.ResumeLayout(false); + this.ResumeLayout(false); + + } + #endregion + + private void MDXQueryBuilderWizard_Load(object sender, System.EventArgs e) + { + + foreach(Control ct in this.Controls) + { + if(ct.GetType().Name=="Panel") + { + ct.Left=0; + ct.Top=0; + ct.Visible=false; + } + + } + presentPanel=arrayPanel[0]; + //--set the properties + setBtnPanProperty(getPosition(presentPanel)); + //------ + refreshLook(); + } + + //-set the buttons and panel + private void refreshLook() + { + if(cancelEnabled) + btnCancel.Enabled=true; + else + btnCancel.Enabled=false; + + if(backEnabled) + btnback.Enabled=true; + else + btnback.Enabled=false; + + if(nextEnabled) + btnNext.Enabled=true; + else + btnNext.Enabled=false; + + if(finishEnabled) + btnFinish.Enabled=true; + else + btnFinish.Enabled=false; + + if(presentPanel!=null) + { + presentPanel.Show(); + presentPanel.BringToFront(); + } + } + //-------- + private int getPosition(Panel p) + { + int result=-1; + for(int i=0;i 0) + { + btnNext.Enabled=true; + } + this.listBoxComputers.EndUpdate(); + this.listBoxComputers.Refresh(); + } + + + private void tvComputer_AfterSelect(object sender, System.Windows.Forms.TreeViewEventArgs e) + { + tvComputer.SelectedNode.Expand(); + + } + + private void tvComputer_DragDrop(object sender, System.Windows.Forms.DragEventArgs e) + { + + } + + private void tvComputer_MouseLeave(object sender, System.EventArgs e) + { + + } + + private void tvComputer_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e) + { + TreeNode prevNode = tvComputer.SelectedNode; + if(prevNode!=null) + { + prevNode.BackColor=Color.White; + } + TreeNode node = tvComputer.GetNodeAt(e.X,e.Y); + if(node==null) + { + return; + } + + tvComputer.SelectedNode=node; + tvComputer.SelectedNode.BackColor=Color.LightGray; + + } + + private void btnTransferNodeToComp_Click(object sender, System.EventArgs e) + { + + if(tvComputer.SelectedNode==null) + return; + if(lvNode.SelectedItems.Equals(null)) + return; + int itemCount=lvNode.SelectedItems.Count; + lvNode.BeginUpdate(); + tvComputer.BeginUpdate(); + for(int i=0;i < itemCount;i++) + { + tvComputer.SelectedNode.Nodes.Add(lvNode.SelectedItems[i].Text.ToString()); + } + + for(int i=0;i < itemCount;i++) + { + lvNode.Items.RemoveAt(lvNode.SelectedIndices[0]); + + } + if(lvNode.Items.Count.Equals(0)) + btnNext.Enabled=true; + else + btnNext.Enabled=false; + tvComputer.SelectedNode.Expand(); + lvNode.EndUpdate(); + tvComputer.EndUpdate(); + } + + private void lvNode_SelectedIndexChanged(object sender, System.EventArgs e) + { + } + + private void prepareNodeAssignmentPanel() + { + ArrayList computers = mgmt.getComputerCollection(); + m_nNDB=Convert.ToInt32(comboNDB.SelectedItem.ToString()); + m_nAPI=Convert.ToInt32(comboAPI.SelectedItem.ToString()); + m_nMGM=Convert.ToInt32(comboMGM.SelectedItem.ToString()); + + lvNode.Items.Clear(); + tvComputer.Nodes.Clear(); + for (int i=1;i<=m_nMGM;i++) + lvNode.Items.Add("mgm."+i); + + for (int i=m_nMGM+1;i<=(m_nNDB+m_nMGM);i++) + lvNode.Items.Add("ndb."+i); + + for (int i=m_nMGM+m_nNDB+1;i<=(m_nNDB+m_nMGM+m_nAPI);i++) + lvNode.Items.Add("api."+i); + + foreach(Computer c in computers) + { + if(c.getStatus() == Computer.Status.Connected) + tvComputer.Nodes.Add(c.getName()); + } + + } + private void prepareNodeConfigurationPanel() + { + Computer c; + for(int i=0;i0 && textDbName.TextLength > 0) + nextEnabled=true; + else + nextEnabled=false; + + refreshLook(); + + } + + private void checkBoxLater_CheckedChanged(object sender, System.EventArgs e) + { + if(checkBoxLater.Checked.Equals(true)) + { + this.finishEnabled=true; + this.nextEnabled=false; + } + else + { + this.finishEnabled=false; + this.nextEnabled=true; + } + this.refreshLook(); + } + + private void btnFinish_Click(object sender, System.EventArgs e) + { + mgmt.AddDatabase(this.m_db); + + if(radioStartYes.Checked==true) + startDatabase(); + this.Dispose(); + } + + private void panel4_Paint(object sender, System.Windows.Forms.PaintEventArgs e) + { + + // Point location= new Point(8,40); + // Size s= new Size(panel4.Size.Width-8,panel4.Size.Height-120); + // lvConfig.Location=location; + // lvConfig.Size=s; + + + } + + private void configureMgmt() + { + //clear old + textOther.Text=""; + textArgs.Text=""; + textCwd.Text=""; + textPath.Text=""; + + textPath.Clear(); + textEnv.Clear(); + textOther.Clear(); + textCwd.Clear(); + textArgs.Clear(); + + textPath.ClearUndo(); + textEnv.ClearUndo(); + textOther.ClearUndo(); + textCwd.ClearUndo(); + textArgs.ClearUndo(); + + + textOther.Enabled=true; + textArgs.Enabled=true; + textCwd.Enabled=true; + textPath.Enabled=true; + + textPath.TabStop=true; + textOther.TabStop=true; + textArgs.TabStop=true; + textCwd.TabStop=true; + textEnv.TabStop=true; + + labelTitle.Text="Mgmtsrvr configuration"; + labelPath.Text="Path to mgmtsrvr binary:"; + labelArgs.Text="Arguments to mgmtsrvr:"; + labelOther.Text="Mgmtsrvr port (-p X):"; + + //get new + String process="mgm." + Convert.ToString(m_noOfConfiguredMgmt+1); + Process mgmt=m_db.getProcessByName(process); + textComputer.Text=mgmt.getComputer().getName(); + textName.Text=mgmt.getName().ToString(); + textDatabase.Text=mgmt.getDatabase().ToString(); + m_mgmHost=mgmt.getComputer().getName(); + textPath.Focus(); + } + private void configureApi() + { + checkBoxReuse.Text="Use the same configuration for ALL API nodes?"; + if(m_nAPI > 1) + { + checkBoxReuse.Visible=true; + checkBoxReuse.Enabled=true; + + } + else + { + checkBoxReuse.Enabled=false; + checkBoxReuse.Visible=true; + } + + // clear previous and get a new api + + textOther.Text=""; + textArgs.Text=""; + //textCwd.Text=""; + //textPath.Text=""; + //get new api + textOther.Enabled=false; + textArgs.Enabled=true; + labelTitle.Text="API node configuration"; + labelPath.Text="Path to api binary:"; + labelArgs.Text="Arguments to api:"; + labelOther.Text="NDB_CONNECTSTRING"; + String process="api." + Convert.ToString(m_noOfConfiguredApi+m_nMGM+m_nNDB+1); + Process api=m_db.getProcessByName(process); + textComputer.Text=api.getComputer().getName(); + textName.Text=api.getName().ToString(); + textOther.Text="nodeid=" + Convert.ToString(m_noOfConfiguredApi+m_nMGM+m_nNDB+1) + ";host="+this.m_mgmHost + ":" + this.m_mgmPort; + textDatabase.Text=api.getDatabase().ToString(); + textPath.Focus(); + } + + private void configureNdb() + { + + + checkBoxReuse.Text="Use the same configuration for ALL NDB nodes?"; + + + if(this.m_nNDB > 1) + { + checkBoxReuse.Visible=true; + checkBoxReuse.Enabled=true; + + } + else + { + checkBoxReuse.Enabled=false; + checkBoxReuse.Visible=true; + } + + + + labelPath.Text="Path to ndb binary:"; + labelArgs.Text="Arguments to ndb:"; + + // clear previous and get a new ndb + + labelOther.Text="NDB_CONNECTSTRING"; + textArgs.Text="-i"; + textOther.Enabled=false; + textArgs.Enabled=false; + + textPath.TabStop=true; + textEnv.TabStop=true; + textOther.TabStop=false; + textArgs.TabStop=false; + textCwd.TabStop=true; + + //textCwd.Text=""; + //textPath.Text=""; + //get new + + String process="ndb." + Convert.ToString(m_noOfConfiguredNdb+m_nMGM+1); + textOther.Text="nodeid=" + Convert.ToString(m_noOfConfiguredNdb+m_nMGM+1) + ";host="+this.m_mgmHost + ":" + this.m_mgmPort; + Process ndb=m_db.getProcessByName(process); + textComputer.Text=ndb.getComputer().getName(); + textName.Text=ndb.getName().ToString(); + textDatabase.Text=ndb.getDatabase().ToString(); + textPath.Focus(); + } + + + public void saveMgm() + { + String process="mgm." + Convert.ToString(m_noOfConfiguredMgmt+1); + Process mgmt=m_db.getProcessByName(process); + mgmt.setOther(textOther.Text.ToString()); + mgmt.setEnv(textEnv.Text.ToString()); + m_mgmPort = textOther.Text.ToString(); + try + { + m_db.setMgmtPort(Convert.ToInt32(m_mgmPort)); + } + catch(Exception e) + { + MessageBox.Show("Port number must be numeric!!!", "Error",MessageBoxButtons.OK); + this.configureMgmt(); + return; + } + mgmt.setPath(textPath.Text.ToString()); + mgmt.setCwd(textCwd.Text.ToString()); + mgmt.setProcessType("permanent"); + mgmt.setArgs("-i initconfig.txt"); + mgmt.setConnectString("nodeid=" + Convert.ToString(m_noOfConfiguredMgmt+1)+";host="+m_mgmHost+":" + m_mgmPort); + this.m_noOfConfiguredMgmt++; + } + + public void saveApi() + { + if(checkBoxReuse.Checked) + { + for(;m_noOfConfiguredApi 0 && textOwner.TextLength > 0) + nextEnabled=true; + else + nextEnabled=false; + + refreshLook(); + } + + private void panel2_Paint(object sender, System.Windows.Forms.PaintEventArgs e) + { + textOwner.Text=System.Environment.UserName; + this.Validate(); + if(textDbName.TextLength > 0 && textOwner.TextLength>0) + { + nextEnabled=true; + } + else + { + nextEnabled=false; + } + refreshLook(); + } + + private void textPath_TextChanged(object sender, System.EventArgs e) + { + try + { + + } + catch (Exception exc) + { + MessageBox.Show(exc.ToString()); + } + } + + private void panel2_Validating(object sender, System.ComponentModel.CancelEventArgs e) + { + if(textOwner.TextLength>0 && textDbName.TextLength > 0) + nextEnabled=true; + else + nextEnabled=false; + } + + + + + + + } +} diff --git a/ndb/src/cw/cpcc-win32/csharp/Process.cs b/ndb/src/cw/cpcc-win32/csharp/Process.cs new file mode 100644 index 00000000000..c1ee1b2fe9e --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/Process.cs @@ -0,0 +1,144 @@ +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using System.Windows.Forms; +using System.Data; + +namespace NDB_CPC +{ + /// + /// Summary description for Process. + /// + public class Process + { + public enum Status {Running, Stopped, Unknown} + private string m_id; + protected string m_name; + private Status m_status; + private Computer m_computer; + private string m_owner; + private string m_cwd; + private string m_type; + private string m_path; + private string m_other; + private string m_args; + private string m_env; + private string m_database; + private string m_connectString; + private bool m_defined; + public Process( string name, + string owner, string database, + Computer computer) + { + m_name=name; + m_owner=owner; + m_computer=computer; + m_status=Status.Unknown; + m_database=database; + m_defined=false; + m_path=""; + m_cwd=""; + m_args=""; + m_other=""; + } + public Process() + { + + } + public Process(string id) + { + m_id=id; + } + + public Process( string name, + string database, + Computer computer) + { + m_name=name; + m_computer=computer; + m_status=Status.Unknown; + m_database=database; + m_defined=false; + } + + public Process( string name, + Computer computer) + { + m_name=name; + m_computer=computer; + m_status=Status.Unknown; + m_defined=false; + } + + + public string getStatusString() + { + if(m_status.Equals(Status.Running)) + return "Running"; + if(m_status.Equals(Status.Stopped)) + return "Stopped"; + return "Unknown"; + } + + public Computer getComputer() {return m_computer;} + public string getName() {return m_name;} + public string getDatabase() {return m_database;} + public string getOwner() {return m_owner;} + public string getId() {return m_id;} + public void setId(string id) {m_id=id;} + + public void setCwd(string cwd) {m_cwd=cwd;} + public void setPath(string path) {m_path=path;} + public void setArgs(string args) {m_args=args;} + public void setOther(string other) {m_other=other;} + public void setEnv(string env) {m_env=env;} + public void setName(string name) {m_name=name;} + public void setOwner(string owner) {m_owner=owner;} + public void setDatabase(string db) {m_database=db;} + public void setComputer(Computer c) {m_computer=c;} + + + public string getCwd() {return m_cwd;} + public string getPath() {return m_path;} + public string getArgs() {return m_args;} + public string getOther() {return m_other;} + public string getEnv() {return m_env;} + + public bool isDefined() {return m_defined;} + public void setDefined(bool defined) + { + m_defined=defined; + } + + public Status getStatus() + { + return m_status; + } + + public void setConnectString(string cs) + { + m_connectString=cs; + } + + public string getConnectString() + { + return m_connectString; + } + public void setStatus(Status status) + { + m_status=status; + } + + + public void setProcessType(string type) + { + m_type=type; + } + public string getProcessType() + { + return m_type; + } + + } +} diff --git a/ndb/src/cw/cpcc-win32/csharp/ProcessDefineDialog.cs b/ndb/src/cw/cpcc-win32/csharp/ProcessDefineDialog.cs new file mode 100644 index 00000000000..581b8383e7c --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/ProcessDefineDialog.cs @@ -0,0 +1,435 @@ +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using System.Windows.Forms; + +namespace NDB_CPC +{ + /// + /// Summary description for ProcessDefineDialog. + /// + public class ProcessDefineDialog : System.Windows.Forms.Form + { + private System.Windows.Forms.ComboBox comboComputer; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.Label label4; + private System.Windows.Forms.Label label5; + private System.Windows.Forms.Label label6; + private System.Windows.Forms.Label label7; + private System.Windows.Forms.Label label8; + private System.Windows.Forms.Label label9; + private System.Windows.Forms.TextBox textProcessName; + private System.Windows.Forms.TextBox textProcessGroup; + private System.Windows.Forms.TextBox textProcessEnv; + private System.Windows.Forms.TextBox textProcessPath; + private System.Windows.Forms.TextBox textProcessArgs; + private System.Windows.Forms.TextBox textProcessCWD; + private System.Windows.Forms.TextBox textProcessOwner; + private System.Windows.Forms.ComboBox comboType; + private System.Windows.Forms.Label label10; + private System.Windows.Forms.Label label11; + private System.Windows.Forms.Label label12; + private System.Windows.Forms.Label label13; + private System.Windows.Forms.Label label15; + private System.Windows.Forms.Label label16; + private System.Windows.Forms.Label label14; + private System.Windows.Forms.Label label17; + private System.Windows.Forms.Label label18; + private System.Windows.Forms.Button btnAdd; + private System.Windows.Forms.Button btnCancel; + /// + /// Required designer variable. + /// + private System.ComponentModel.Container components = null; + private ComputerMgmt c_mgmt; + private string m_selComputer; + public ProcessDefineDialog(ComputerMgmt mgmt, string computer) + { + + // Required for Windows Form Designer support + // + InitializeComponent(); + + // + // TODO: Add any constructor code after InitializeComponent call + // + m_selComputer =computer; //the selected computer in the TreeView + c_mgmt=mgmt; + } + + /// + /// Clean up any resources being used. + /// + protected override void Dispose( bool disposing ) + { + if( disposing ) + { + if(components != null) + { + components.Dispose(); + } + } + base.Dispose( disposing ); + } + + #region Windows Form Designer generated code + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.comboComputer = new System.Windows.Forms.ComboBox(); + this.label1 = new System.Windows.Forms.Label(); + this.label2 = new System.Windows.Forms.Label(); + this.label3 = new System.Windows.Forms.Label(); + this.label4 = new System.Windows.Forms.Label(); + this.label5 = new System.Windows.Forms.Label(); + this.label6 = new System.Windows.Forms.Label(); + this.label7 = new System.Windows.Forms.Label(); + this.label8 = new System.Windows.Forms.Label(); + this.label9 = new System.Windows.Forms.Label(); + this.textProcessName = new System.Windows.Forms.TextBox(); + this.textProcessGroup = new System.Windows.Forms.TextBox(); + this.textProcessEnv = new System.Windows.Forms.TextBox(); + this.textProcessPath = new System.Windows.Forms.TextBox(); + this.textProcessArgs = new System.Windows.Forms.TextBox(); + this.textProcessCWD = new System.Windows.Forms.TextBox(); + this.textProcessOwner = new System.Windows.Forms.TextBox(); + this.comboType = new System.Windows.Forms.ComboBox(); + this.label10 = new System.Windows.Forms.Label(); + this.label11 = new System.Windows.Forms.Label(); + this.label12 = new System.Windows.Forms.Label(); + this.label13 = new System.Windows.Forms.Label(); + this.label15 = new System.Windows.Forms.Label(); + this.label16 = new System.Windows.Forms.Label(); + this.label14 = new System.Windows.Forms.Label(); + this.label17 = new System.Windows.Forms.Label(); + this.label18 = new System.Windows.Forms.Label(); + this.btnAdd = new System.Windows.Forms.Button(); + this.btnCancel = new System.Windows.Forms.Button(); + this.SuspendLayout(); + // + // comboComputer + // + this.comboComputer.ItemHeight = 13; + this.comboComputer.Location = new System.Drawing.Point(152, 24); + this.comboComputer.Name = "comboComputer"; + this.comboComputer.Size = new System.Drawing.Size(112, 21); + this.comboComputer.TabIndex = 0; + // + // label1 + // + this.label1.Location = new System.Drawing.Point(24, 24); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(64, 24); + this.label1.TabIndex = 1; + this.label1.Text = "Computer:"; + // + // label2 + // + this.label2.Location = new System.Drawing.Point(24, 48); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(88, 24); + this.label2.TabIndex = 2; + this.label2.Text = "Process name:"; + // + // label3 + // + this.label3.Location = new System.Drawing.Point(24, 72); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(88, 24); + this.label3.TabIndex = 3; + this.label3.Text = "Group:"; + // + // label4 + // + this.label4.Location = new System.Drawing.Point(24, 96); + this.label4.Name = "label4"; + this.label4.Size = new System.Drawing.Size(88, 24); + this.label4.TabIndex = 4; + this.label4.Text = "Env. variables:"; + // + // label5 + // + this.label5.Location = new System.Drawing.Point(24, 120); + this.label5.Name = "label5"; + this.label5.Size = new System.Drawing.Size(88, 24); + this.label5.TabIndex = 5; + this.label5.Text = "Path to binary:"; + // + // label6 + // + this.label6.Location = new System.Drawing.Point(24, 144); + this.label6.Name = "label6"; + this.label6.Size = new System.Drawing.Size(112, 24); + this.label6.TabIndex = 6; + this.label6.Text = "Arguments to binary:"; + // + // label7 + // + this.label7.Location = new System.Drawing.Point(24, 168); + this.label7.Name = "label7"; + this.label7.Size = new System.Drawing.Size(112, 24); + this.label7.TabIndex = 7; + this.label7.Text = "Type of process:"; + // + // label8 + // + this.label8.Location = new System.Drawing.Point(24, 192); + this.label8.Name = "label8"; + this.label8.Size = new System.Drawing.Size(112, 24); + this.label8.TabIndex = 8; + this.label8.Text = "Current working dir.:"; + // + // label9 + // + this.label9.Location = new System.Drawing.Point(24, 216); + this.label9.Name = "label9"; + this.label9.Size = new System.Drawing.Size(112, 24); + this.label9.TabIndex = 9; + this.label9.Text = "Owner:"; + // + // textProcessName + // + this.textProcessName.Location = new System.Drawing.Point(152, 48); + this.textProcessName.Name = "textProcessName"; + this.textProcessName.Size = new System.Drawing.Size(112, 20); + this.textProcessName.TabIndex = 1; + this.textProcessName.Text = ""; + // + // textProcessGroup + // + this.textProcessGroup.Location = new System.Drawing.Point(152, 72); + this.textProcessGroup.Name = "textProcessGroup"; + this.textProcessGroup.Size = new System.Drawing.Size(112, 20); + this.textProcessGroup.TabIndex = 2; + this.textProcessGroup.Text = ""; + // + // textProcessEnv + // + this.textProcessEnv.Location = new System.Drawing.Point(152, 96); + this.textProcessEnv.Name = "textProcessEnv"; + this.textProcessEnv.Size = new System.Drawing.Size(112, 20); + this.textProcessEnv.TabIndex = 3; + this.textProcessEnv.Text = ""; + // + // textProcessPath + // + this.textProcessPath.Location = new System.Drawing.Point(152, 120); + this.textProcessPath.Name = "textProcessPath"; + this.textProcessPath.Size = new System.Drawing.Size(112, 20); + this.textProcessPath.TabIndex = 4; + this.textProcessPath.Text = ""; + // + // textProcessArgs + // + this.textProcessArgs.Location = new System.Drawing.Point(152, 144); + this.textProcessArgs.Name = "textProcessArgs"; + this.textProcessArgs.Size = new System.Drawing.Size(112, 20); + this.textProcessArgs.TabIndex = 5; + this.textProcessArgs.Text = ""; + // + // textProcessCWD + // + this.textProcessCWD.Location = new System.Drawing.Point(152, 192); + this.textProcessCWD.Name = "textProcessCWD"; + this.textProcessCWD.Size = new System.Drawing.Size(112, 20); + this.textProcessCWD.TabIndex = 7; + this.textProcessCWD.Text = ""; + // + // textProcessOwner + // + this.textProcessOwner.Location = new System.Drawing.Point(152, 216); + this.textProcessOwner.Name = "textProcessOwner"; + this.textProcessOwner.Size = new System.Drawing.Size(112, 20); + this.textProcessOwner.TabIndex = 8; + this.textProcessOwner.Text = ""; + // + // comboType + // + this.comboType.ItemHeight = 13; + this.comboType.Items.AddRange(new object[] { + "Permanent", + "Interactive"}); + this.comboType.Location = new System.Drawing.Point(152, 168); + this.comboType.Name = "comboType"; + this.comboType.Size = new System.Drawing.Size(112, 21); + this.comboType.TabIndex = 6; + // + // label10 + // + this.label10.Location = new System.Drawing.Point(272, 32); + this.label10.Name = "label10"; + this.label10.Size = new System.Drawing.Size(88, 16); + this.label10.TabIndex = 19; + this.label10.Text = "(Mandatory)"; + // + // label11 + // + this.label11.Location = new System.Drawing.Point(272, 56); + this.label11.Name = "label11"; + this.label11.Size = new System.Drawing.Size(88, 16); + this.label11.TabIndex = 20; + this.label11.Text = "(Mandatory)"; + // + // label12 + // + this.label12.Location = new System.Drawing.Point(272, 80); + this.label12.Name = "label12"; + this.label12.Size = new System.Drawing.Size(88, 16); + this.label12.TabIndex = 21; + this.label12.Text = "(Mandatory)"; + // + // label13 + // + this.label13.Location = new System.Drawing.Point(272, 127); + this.label13.Name = "label13"; + this.label13.Size = new System.Drawing.Size(88, 16); + this.label13.TabIndex = 22; + this.label13.Text = "(Mandatory)"; + // + // label15 + // + this.label15.Location = new System.Drawing.Point(272, 176); + this.label15.Name = "label15"; + this.label15.Size = new System.Drawing.Size(88, 16); + this.label15.TabIndex = 24; + this.label15.Text = "(Mandatory)"; + // + // label16 + // + this.label16.Location = new System.Drawing.Point(272, 200); + this.label16.Name = "label16"; + this.label16.Size = new System.Drawing.Size(88, 16); + this.label16.TabIndex = 25; + this.label16.Text = "(Mandatory)"; + // + // label14 + // + this.label14.Location = new System.Drawing.Point(272, 224); + this.label14.Name = "label14"; + this.label14.Size = new System.Drawing.Size(88, 16); + this.label14.TabIndex = 26; + this.label14.Text = "(Mandatory)"; + // + // label17 + // + this.label17.Location = new System.Drawing.Point(272, 104); + this.label17.Name = "label17"; + this.label17.Size = new System.Drawing.Size(88, 16); + this.label17.TabIndex = 27; + this.label17.Text = "(Optional)"; + // + // label18 + // + this.label18.Location = new System.Drawing.Point(272, 152); + this.label18.Name = "label18"; + this.label18.Size = new System.Drawing.Size(88, 16); + this.label18.TabIndex = 28; + this.label18.Text = "(Optional)"; + // + // btnAdd + // + this.btnAdd.Location = new System.Drawing.Point(288, 248); + this.btnAdd.Name = "btnAdd"; + this.btnAdd.TabIndex = 9; + this.btnAdd.Text = "Define..."; + this.btnAdd.Click += new System.EventHandler(this.btnAdd_Click); + // + // btnCancel + // + this.btnCancel.Location = new System.Drawing.Point(152, 248); + this.btnCancel.Name = "btnCancel"; + this.btnCancel.TabIndex = 10; + this.btnCancel.Text = "Cancel"; + this.btnCancel.Click += new System.EventHandler(this.btnCancel_Click); + // + // ProcessDefineDialog + // + this.AutoScaleBaseSize = new System.Drawing.Size(5, 13); + this.ClientSize = new System.Drawing.Size(370, 279); + this.Controls.AddRange(new System.Windows.Forms.Control[] { + this.btnCancel, + this.btnAdd, + this.label18, + this.label17, + this.label14, + this.label16, + this.label15, + this.label13, + this.label12, + this.label11, + this.label10, + this.comboType, + this.textProcessOwner, + this.textProcessCWD, + this.textProcessArgs, + this.textProcessPath, + this.textProcessEnv, + this.textProcessGroup, + this.textProcessName, + this.label9, + this.label8, + this.label7, + this.label6, + this.label5, + this.label4, + this.label3, + this.label2, + this.label1, + this.comboComputer}); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "ProcessDefineDialog"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "Define Process"; + this.Load += new System.EventHandler(this.ProcessDefineDialog_Load); + this.ResumeLayout(false); + + } + #endregion + + private void btnCancel_Click(object sender, System.EventArgs e) + { + this.Dispose(); + this.Close(); + } + + private void btnAdd_Click(object sender, System.EventArgs e) + { + //TODO: ERROR CHECK + + Computer c; + c=c_mgmt.getComputer(this.m_selComputer); + + c.addProcess(new Process(this.textProcessName.Text.ToString(), + this.textProcessOwner.Text.ToString(), + this.textProcessGroup.Text.ToString(), + c)); + this.Close(); + this.Dispose(); + } + + private void ProcessDefineDialog_Load(object sender, System.EventArgs e) + { + comboType.SelectedIndex=0; + ArrayList list = c_mgmt.getComputerCollection(); + int i=0, selIndex=0; + foreach(Computer computer in list) + { + this.comboComputer.Items.Add(computer.getName()); + if(computer.getName().Equals(m_selComputer)) + selIndex=i; + i++; + } + comboComputer.SelectedIndex=selIndex; + } + + + } +} diff --git a/ndb/src/cw/cpcc-win32/csharp/fileaccess/FileMgmt.cs b/ndb/src/cw/cpcc-win32/csharp/fileaccess/FileMgmt.cs new file mode 100644 index 00000000000..b3a2361bcb0 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/fileaccess/FileMgmt.cs @@ -0,0 +1,41 @@ +using System; +using System.Text; +using System.Collections.Specialized; +using System.IO; +using System.Windows.Forms; +namespace NDB_CPC.fileaccess +{ + /// + /// Summary description for FileMgmt. + /// + public class FileMgmt + { + public FileMgmt() + { + } + + public StringCollection importHostFile(string filename) + { + StringCollection sc = new StringCollection(); + StreamReader SR = new StreamReader(filename); + string line =""; + line = SR.ReadLine(); + while(!line.Equals("")) + { + sc.Add(line); + line = SR.ReadLine(); + } + return sc; + } + + public void exportHostFile(string filename, string content) + { + StreamWriter SW = new StreamWriter(filename,false); + SW.Write(content); + SW.WriteLine(""); + SW.WriteLine(""); + SW.Close(); + } + + } +} diff --git a/ndb/src/cw/cpcc-win32/csharp/simpleparser/SimpleCPCParser.cs b/ndb/src/cw/cpcc-win32/csharp/simpleparser/SimpleCPCParser.cs new file mode 100644 index 00000000000..b8ff2844af9 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/simpleparser/SimpleCPCParser.cs @@ -0,0 +1,360 @@ +using System; +using System.Collections; +using System.IO; +using System.Windows.Forms; +using NDB_CPC; +using NDB_CPC.socketcomm; + +namespace NDB_CPC.simpleparser +{ + /// + /// Summary description for SimpleCPCParser. + /// + public class SimpleCPCParser + { + public SimpleCPCParser() + { + // + // TODO: Add constructor logic here + // + } + + public static void parse(Process p, SocketComm comm) + { + + string line=comm.readLine();//reader.ReadLine(); + while(line.Equals("")) + { + line=comm.readLine(); + } + if(line.Equals("define process")) + { + defineProcess(p, comm); + line=""; + return; + } + if(line.Equals("start process")) + { + startProcess(p,comm); + line=""; + return; + } + if(line.Equals("stop process")) + { + stopProcess(p,comm); + line=""; + return; + } + if(line.Equals("undefine process")) + { + undefineProcess(p,comm); + line=""; + return; + } + + } + + public static void parse(ArrayList processes, Computer c, SocketComm comm) + { + + string line=comm.readLine();//reader.ReadLine(); + while(line.Equals("")) + { + line=comm.readLine(); + } + + if(line.Equals("start processes")) + { + listProcesses(processes, c, comm); + line=""; + return; + } + + } + + private static void defineProcess(Process p, SocketComm comm) + { + string line=comm.readLine();//reader.ReadLine(); + while(!line.Equals("")) + { + if(line.StartsWith("status:")) + { + line=line.Remove(0,7); + line=line.Trim(); + if(line.Equals("1")) + { + p.setDefined(true); + p.setStatus(Process.Status.Stopped); + } + else + p.setDefined(false); + } + if(line.StartsWith("id:")) + { + line=line.Remove(0,3); + line=line.Trim(); + p.setId(line); + } + line=comm.readLine(); + } + } + + + private static void startProcess(Process p, SocketComm comm) + { + string line=comm.readLine();//reader.ReadLine(); + while(!line.Equals("")) + { + if(line.StartsWith("status:")) + { + line=line.Remove(0,7); + line=line.Trim(); + if(line.Equals("1")) + p.setStatus(NDB_CPC.Process.Status.Running); + else + p.setStatus(NDB_CPC.Process.Status.Unknown); + + } + if(line.StartsWith("id:")) + { + line=line.Remove(0,3); + line=line.Trim(); + if(p.getId().Equals(line)) + { + ; + } + else + { + //damn something is wrong + p.setStatus(NDB_CPC.Process.Status.Unknown); + } + + } + line=comm.readLine(); + } + } + private static void undefineProcess(Process p, SocketComm comm) + { + string line=comm.readLine();//reader.ReadLine(); + while(!line.Equals("")) + { + if(line.StartsWith("status:")) + { + + line=line.Remove(0,7); + line=line.Trim(); + if(line.Equals("1")) + p.setDefined(false); + else + p.setDefined(true); + + } + if(line.StartsWith("id:")) + { + line=line.Remove(0,3); + line=line.Trim(); + } + line=comm.readLine(); + } + } + + private static void stopProcess(Process p, SocketComm comm) + { + string line=comm.readLine();//reader.ReadLine(); + while(!line.Equals("")) + { + if(line.StartsWith("status:")) + { + line=line.Remove(0,7); + line=line.Trim(); + if(line.Equals("1")) + p.setStatus(NDB_CPC.Process.Status.Stopped); + else + p.setStatus(NDB_CPC.Process.Status.Unknown); + + } + if(line.StartsWith("id:")) + { + line=line.Remove(0,3); + line=line.Trim(); + if(p.getId().Equals(line)) + { + ; + } + else + { + //damn something is wrong + p.setStatus(NDB_CPC.Process.Status.Unknown); + } + + } + line=comm.readLine(); + } + } + private static void listProcesses(ArrayList processes, Computer c, SocketComm comm) + { + bool processExist = false; + + string line=comm.readLine();//reader.ReadLine(); + while(!line.Equals("end processes")) + { + if(line.Equals("process")) + { + line=comm.readLine(); + Process p = new Process(); + + while(!line.Equals("")) + { + if(line.StartsWith("id:")) + { + string pid; + line=line.Remove(0,3); + pid=line.Trim(); + /*check if process already exist*/ + processExist=findProcess(processes,pid); + if(!processExist) + { + p.setId(pid); + } + } + + if(line.StartsWith("name:")) + { + + line=line.Remove(0,5); + line=line.Trim(); + /*check if process already exist*/ + if(!processExist) + { + p.setName(line); + } + } + + if(line.StartsWith("path:")) + { + + line=line.Remove(0,5); + line=line.Trim(); + /*check if process already exist*/ + if(!processExist) + { + p.setPath(line); + } + } + + if(line.StartsWith("args:")) + { + + line=line.Remove(0,5); + line=line.Trim(); + /*check if process already exist*/ + if(!processExist) + { + p.setArgs(line); + } + } + + if(line.StartsWith("type:")) + { + + line=line.Remove(0,5); + line=line.Trim(); + /*check if process already exist*/ + if(!processExist) + { + + } + } + + if(line.StartsWith("cwd:")) + { + + line=line.Remove(0,4); + line=line.Trim(); + /*check if process already exist*/ + if(!processExist) + { + p.setCwd(line); + } + } + + if(line.StartsWith("env:")) + { + + line=line.Remove(0,4); + line=line.Trim(); + /*check if process already exist*/ + if(!processExist) + { + p.setEnv(line); + } + } + + if(line.StartsWith("owner:")) + { + + line=line.Remove(0,6); + line=line.Trim(); + /*check if process already exist*/ + if(!processExist) + { + p.setOwner(line); + } + } + if(line.StartsWith("group:")) + { + + line=line.Remove(0,6); + line=line.Trim(); + /*check if process already exist*/ + if(!processExist) + { + p.setDatabase(line); + } + } + + if(line.StartsWith("status:")) + { + + line=line.Remove(0,7); + line=line.Trim(); + /*check if process already exist*/ + //if(!processExist) + //{ + if(line.Equals("0")) + p.setStatus(Process.Status.Stopped); + if(line.Equals("1")) + p.setStatus(Process.Status.Running); + if(line.Equals("2")) + p.setStatus(Process.Status.Unknown); + //} + } + + + line=comm.readLine(); + } + if(!processExist) + { + p.setComputer(c); + p.setDefined(true); + processes.Add(p); + } + processExist=false; + } + line=comm.readLine(); + + } + } + + private static bool findProcess(ArrayList processes, string pid) + { + foreach (Process p in processes) + { + if(p.getId().Equals(pid)) + return true; + } + return false; + + } + } +} diff --git a/ndb/src/cw/cpcc-win32/csharp/socketcomm/SocketComm.cs b/ndb/src/cw/cpcc-win32/csharp/socketcomm/SocketComm.cs new file mode 100644 index 00000000000..2cef5d34f17 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/socketcomm/SocketComm.cs @@ -0,0 +1,207 @@ +using System; +using System.Net; +using System.Net.Sockets; +using System.Text; +using System.Windows.Forms; +using System.Threading; +using System.IO; + +namespace NDB_CPC.socketcomm +{ + /// + /// Summary description for SocketComm. + /// + public class SocketComm + { + private myTcpClient sender; + private StreamWriter writer; + private StreamReader reader; + private string m_host; + private int m_port; + private bool m_connected; + private bool m_connecting; + private Thread connectThread; + public SocketComm(string host, int port) + { + + m_host=host; + m_port=port; + m_connected=false; + m_connecting=false; + } + + + + public bool isConnected() + { + return m_connected; + } + + public void doConnect() + { + if(!m_connecting && !m_connected) + { + connectThread= new Thread(new ThreadStart(connect)); + connectThread.Start(); + } + + } + + private void connect() + { + m_connecting=true; + while(true) + { + if(!m_connected) + { + try + { + // Establish the remote endpoint for the socket. + // The name of the + // remote device is "host.contoso.com". + + // Create a TCP/IP socket. + sender = new myTcpClient(); + // Connect the socket to the remote endpoint. Catch any errors. + try + { + /* + IPAddress ipAddress = Dns.Resolve(host).AddressList[0]; + IPEndPoint ipLocalEndPoint = new IPEndPoint(ipAddress, 11000); +*/ + + + sender.Connect(m_host,m_port);; + + writer = new StreamWriter(sender.GetStream(), Encoding.ASCII); + reader = new StreamReader(sender.GetStream(), Encoding.ASCII); + m_connected=true; + m_connecting=false; + // break; + Console.WriteLine("Socket connected to {0}", + sender.ToString()); + + } + catch (ArgumentNullException ane) + { + Console.WriteLine("ArgumentNullException : {0}",ane.ToString()); + m_connected=false; + } + catch (SocketException se) + { + Console.WriteLine("SocketException : {0}",se.ToString()); + m_connected=false; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected exception : {0}", e.ToString()); + m_connected=false; + } + + } + + Thread.Sleep(200); + } + } + + public bool disconnect() + { + try + { + this.m_connected=false; + this.m_connecting=false; + sender.GetUnderlyingSocket().Shutdown(SocketShutdown.Both); + sender.GetUnderlyingSocket().Close(); + writer.Close(); + reader.Close(); + sender.Close(); + + } + catch (ArgumentNullException ane) + { + Console.WriteLine("ArgumentNullException : {0}",ane.ToString()); + connectThread.Abort(); + return false; + } + catch (SocketException se) + { + Console.WriteLine("SocketException : {0}",se.ToString()); + connectThread.Abort(); + return false; + } + catch (Exception e) + { + Console.WriteLine("Unexpected exception : {0}", e.ToString()); + connectThread.Abort(); + return false; + } + connectThread.Abort(); + return true; + } + + public bool writeMessage(string message) + { + int attempts=0; + while (attempts < 10) + { + try + { + writer.WriteLine(message); + writer.Flush(); + message=""; + return true; + } + catch(IOException e) + { + this.disconnect(); + this.doConnect(); + Thread.Sleep(200); + attempts++; + } + catch(System.NullReferenceException) + { + this.disconnect(); + this.doConnect(); + + Thread.Sleep(200); + attempts++; + } + } + return false; + } + + public string readLine() + { + int attempts=0; + string line=""; + while (attempts < 10){ + try + { + line = reader.ReadLine(); + if(line==null) + line=""; + return line; + } + catch(IOException e) + { + this.disconnect(); + this.doConnect(); + Thread.Sleep(400); + attempts++; + } + catch(System.NullReferenceException) + { + this.disconnect(); + this.doConnect(); + Thread.Sleep(400); + attempts++; + } + } + return ""; + + } + + } +} + diff --git a/ndb/src/cw/cpcc-win32/csharp/socketcomm/myTcpClient.cs b/ndb/src/cw/cpcc-win32/csharp/socketcomm/myTcpClient.cs new file mode 100644 index 00000000000..9c0d82a0b27 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/socketcomm/myTcpClient.cs @@ -0,0 +1,26 @@ +using System; +using System.Net; +using System.Net.Sockets; +using System.Text; +using System.Threading; +using System.IO; + + +namespace NDB_CPC.socketcomm +{ + public class myTcpClient : TcpClient + { + private Socket s; + public myTcpClient(): base() + { + if(this.Active) + { + s = this.Client; + } + } + public Socket GetUnderlyingSocket() + { + return s; + } + } +} diff --git a/ndb/src/cw/cpcc-win32/csharp/startDatabaseDlg.cs b/ndb/src/cw/cpcc-win32/csharp/startDatabaseDlg.cs new file mode 100644 index 00000000000..cecfcaeb0f3 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/startDatabaseDlg.cs @@ -0,0 +1,251 @@ +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using System.Windows.Forms; +using NDB_CPC.simpleparser; + +namespace NDB_CPC +{ + /// + /// Summary description for startDatabase. + /// + public class startDatabaseDlg : System.Windows.Forms.Form + { + private System.Windows.Forms.TextBox textAction; + private System.Windows.Forms.Label label1; + /// + /// Required designer variable. + /// + private System.ComponentModel.Container components = null; + private System.Windows.Forms.ProgressBar progressBar; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Button buttonGo; + private Database m_db; + public startDatabaseDlg(Database db) + { + + // + // Required for Windows Form Designer support + // + InitializeComponent(); + + // + // TODO: Add any constructor code after InitializeComponent call + // + m_db=db; + } + + /// + /// Clean up any resources being used. + /// + protected override void Dispose( bool disposing ) + { + if( disposing ) + { + if(components != null) + { + components.Dispose(); + } + } + base.Dispose( disposing ); + } + + #region Windows Form Designer generated code + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.textAction = new System.Windows.Forms.TextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.progressBar = new System.Windows.Forms.ProgressBar(); + this.label2 = new System.Windows.Forms.Label(); + this.buttonGo = new System.Windows.Forms.Button(); + this.SuspendLayout(); + // + // textAction + // + this.textAction.Location = new System.Drawing.Point(104, 40); + this.textAction.Name = "textAction"; + this.textAction.ReadOnly = true; + this.textAction.Size = new System.Drawing.Size(256, 20); + this.textAction.TabIndex = 0; + this.textAction.Text = ""; + // + // label1 + // + this.label1.Location = new System.Drawing.Point(8, 40); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(96, 16); + this.label1.TabIndex = 1; + this.label1.Text = "Current activity:"; + this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleRight; + // + // progressBar + // + this.progressBar.Location = new System.Drawing.Point(104, 88); + this.progressBar.Name = "progressBar"; + this.progressBar.Size = new System.Drawing.Size(152, 16); + this.progressBar.TabIndex = 2; + // + // label2 + // + this.label2.Location = new System.Drawing.Point(8, 88); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(96, 16); + this.label2.TabIndex = 3; + this.label2.Text = "Activity progress:"; + this.label2.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // + // buttonGo + // + this.buttonGo.Location = new System.Drawing.Point(152, 136); + this.buttonGo.Name = "buttonGo"; + this.buttonGo.Size = new System.Drawing.Size(96, 24); + this.buttonGo.TabIndex = 4; + this.buttonGo.Text = "Go!"; + this.buttonGo.Click += new System.EventHandler(this.buttonGo_Click); + // + // startDatabaseDlg + // + this.AutoScaleBaseSize = new System.Drawing.Size(5, 13); + this.ClientSize = new System.Drawing.Size(378, 167); + this.Controls.AddRange(new System.Windows.Forms.Control[] { + this.buttonGo, + this.label2, + this.progressBar, + this.label1, + this.textAction}); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "startDatabaseDlg"; + this.Text = "Starting database"; + this.Load += new System.EventHandler(this.startDatabase_Load); + this.Paint += new System.Windows.Forms.PaintEventHandler(this.startDatabase_Paint); + this.ResumeLayout(false); + + } + #endregion + + private void startDatabase_Load(object sender, System.EventArgs e) + { + + } + + private void startDatabase_Paint(object sender, System.Windows.Forms.PaintEventArgs e) + { + + + + } + private void defineProcesses() + { + ArrayList processes = m_db.getProcesses(); + progressBar.Maximum = processes.Count; + progressBar.Minimum = 0; + + int retry=0; + //sc.connect("130.100.232.7"); + foreach (Process p in processes) + { + Computer comp; + retry=0; + //if(p.getName().StartsWith("ndb") || p.getName().StartsWith("mgm")) + //{ + textAction.Text="Defining process " + p.getName(); + textAction.Refresh(); + comp=p.getComputer(); + while(retry<10) + { + if(!comp.isConnected()) + { + comp.connectToCpcd(); + + } + else + { + if(comp.defineProcess(p)<0) + { + ; + } + else + break; + } + if(retry==9) + { + if(MessageBox.Show(this,"Failed to define process. Try again?","Warning!!!",MessageBoxButtons.YesNo)==DialogResult.Yes) + retry=0; + } + retry++; + //comp.undefineProcess(p); + } + //} + progressBar.PerformStep(); + } + } + + private void startProcesses() + { + + ArrayList processes = m_db.getProcesses(); + progressBar.Maximum = processes.Count; + progressBar.Minimum = 0; + string start = "start process \n"; + + int retry=0; + //sc.connect("130.100.232.7"); + foreach (Process p in processes) + { + Computer comp; + if((p.getName().StartsWith("ndb")) || (p.getName().StartsWith("mgm"))) + { + textAction.Text="Starting process " + p.getName(); + textAction.Refresh(); + start = start + "id:" + p.getId() + "\n\n"; + comp=p.getComputer(); + while(retry<10) + { + if(!comp.isConnected()) + { + comp.connectToCpcd(); + } + else + { + if(comp.startProcess(p)<0) + { + ; + } + else + break; + } + if(retry==9) + { + if(MessageBox.Show(this,"Failed to start process. Retry again?","Warning!!!",MessageBoxButtons.YesNo)==DialogResult.Yes) + retry=0; + } + + retry++; + } + } + progressBar.PerformStep(); + + } + + } + + private void buttonGo_Click(object sender, System.EventArgs e) + { + buttonGo.Enabled=false; + progressBar.Step=1; + defineProcesses(); + progressBar.Value=0; + startProcesses(); + + } + + + } +} diff --git a/ndb/src/cw/cpcc-win32/csharp/telnetclient/telnetClient.cs b/ndb/src/cw/cpcc-win32/csharp/telnetclient/telnetClient.cs new file mode 100644 index 00000000000..a7966947e1f --- /dev/null +++ b/ndb/src/cw/cpcc-win32/csharp/telnetclient/telnetClient.cs @@ -0,0 +1,408 @@ +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using System.Windows.Forms; +using System.Data; +using System.Net; +using System.Net.Sockets; +using System.Text; +using System.IO; +using System.Threading ; + +namespace NDB_CPC.telnetclient +{ + /// + /// Summary description for telnetClient. + /// + public class telnetClient + { + Char IAC = Convert.ToChar(255); + Char DO = Convert.ToChar(253); + Char DONT = Convert.ToChar(254); + Char WILL = Convert.ToChar(251); + Char WONT = Convert.ToChar(252); + Char SB = Convert.ToChar(250); + Char SE = Convert.ToChar(240); + const Char IS = '0'; + const Char SEND = '1'; + const Char INFO = '2'; + const Char VAR = '0'; + const Char VALUE = '1'; + const Char ESC = '2'; + const Char USERVAR = '3'; + string m_strResp; + + private ArrayList m_ListOptions = new ArrayList(); + private IPEndPoint iep ; + private AsyncCallback callbackProc ; + private string address ; + private int port ; + private Socket s ; + private TextBox textBox1; + Byte[] m_byBuff = new Byte[32767]; + + + public telnetClient(string ip, int p, TextBox tb) + { + + address = ip; + port = p; + textBox1=tb; + IPHostEntry IPHost = Dns.Resolve(address); + string []aliases = IPHost.Aliases; + IPAddress[] addr = IPHost.AddressList; + + try + { + // Create New Socket + s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); + // Create New EndPoint + iep = new IPEndPoint(addr[0],port); + // This is a non blocking IO + s.Blocking = false ; + // Assign Callback function to read from Asyncronous Socket + callbackProc = new AsyncCallback(ConnectCallback); + // Begin Asyncronous Connection + s.BeginConnect(iep , callbackProc, s ) ; + + } + catch(Exception eeeee ) + { + MessageBox.Show(eeeee.Message , "Application Error!!!" , MessageBoxButtons.OK , MessageBoxIcon.Stop ); + Application.Exit(); + } + } + + public void ConnectCallback( IAsyncResult ar ) + { + try + { + // Get The connection socket from the callback + Socket sock1 = (Socket)ar.AsyncState; + if ( sock1.Connected ) + { + // Define a new Callback to read the data + AsyncCallback recieveData = new AsyncCallback( OnRecievedData ); + // Begin reading data asyncronously + sock1.BeginReceive( m_byBuff, 0, m_byBuff.Length, SocketFlags.None, recieveData , sock1 ); + } + } + catch( Exception ex ) + { + MessageBox.Show(ex.Message, "Setup Recieve callbackProc failed!" ); + } + } + + + public void OnRecievedData( IAsyncResult ar ) + { + // Get The connection socket from the callback + Socket sock = (Socket)ar.AsyncState; + // Get The data , if any + int nBytesRec = sock.EndReceive( ar ); + if( nBytesRec > 0 ) + { + string sRecieved = Encoding.ASCII.GetString( m_byBuff, 0, nBytesRec ); + string m_strLine=""; + for ( int i=0; i < nBytesRec;i++) + { + Char ch = Convert.ToChar(m_byBuff[i]); + switch( ch ) + { + case '\r': + m_strLine += Convert.ToString("\r\n"); + break; + case '\n': + break; + default: + m_strLine += Convert.ToString(ch); + break; + } + } + try + { + int strLinelen = m_strLine.Length ; + if ( strLinelen == 0 ) + { + m_strLine = Convert.ToString("\r\n"); + } + + Byte[] mToProcess = new Byte[strLinelen]; + for ( int i=0; i < strLinelen ; i++) + mToProcess[i] = Convert.ToByte(m_strLine[i]); + // Process the incoming data + string mOutText = ProcessOptions(mToProcess); + if ( mOutText != "" ) + textBox1.AppendText(mOutText); + + // Respond to any incoming commands + RespondToOptions(); + } + catch( Exception ex ) + { + Object x = this ; + MessageBox.Show(ex.Message , "Information!" ); + } + } + else + { + // If no data was recieved then the connection is probably dead + Console.WriteLine( "Disconnected", sock.RemoteEndPoint ); + sock.Shutdown( SocketShutdown.Both ); + sock.Close(); + Application.Exit(); + } + } + + private string ProcessOptions(byte[] m_strLineToProcess) + { + string m_DISPLAYTEXT =""; + string m_strTemp ="" ; + string m_strOption =""; + string m_strNormalText =""; + bool bScanDone =false; + int ndx =0; + int ldx =0; + char ch ; + try + { + for ( int i=0; i < m_strLineToProcess.Length ; i++) + { + Char ss = Convert.ToChar(m_strLineToProcess[i]); + m_strTemp = m_strTemp + Convert.ToString(ss); + } + + while(bScanDone != true ) + { + int lensmk = m_strTemp.Length; + ndx = m_strTemp.IndexOf(Convert.ToString(IAC)); + if ( ndx > lensmk ) + ndx = m_strTemp.Length; + + if(ndx != -1) + { + m_DISPLAYTEXT+= m_strTemp.Substring(0,ndx); + ch = m_strTemp[ndx + 1]; + if ( ch == DO || ch == DONT || ch == WILL || ch == WONT ) + { + m_strOption = m_strTemp.Substring(ndx, 3); + string txt = m_strTemp.Substring(ndx + 3); + m_DISPLAYTEXT+= m_strTemp.Substring(0,ndx); + m_ListOptions.Add(m_strOption); + m_strTemp = txt ; + } + else + if ( ch == IAC) + { + m_DISPLAYTEXT= m_strTemp.Substring(0,ndx); + m_strTemp = m_strTemp.Substring(ndx + 1); + } + else + if ( ch == SB ) + { + m_DISPLAYTEXT= m_strTemp.Substring(0,ndx); + ldx = m_strTemp.IndexOf(Convert.ToString(SE)); + m_strOption = m_strTemp.Substring(ndx, ldx); + m_ListOptions.Add(m_strOption); + m_strTemp = m_strTemp.Substring(ldx); + } + } + else + { + m_DISPLAYTEXT = m_DISPLAYTEXT + m_strTemp; + bScanDone = true ; + } + } + m_strNormalText = m_DISPLAYTEXT; + } + catch(Exception eP) + { + MessageBox.Show(eP.Message , "Application Error!!!" , MessageBoxButtons.OK , MessageBoxIcon.Stop ); + Application.Exit(); + } + return m_strNormalText ; + } + + void DispatchMessage(string strText) + { + try + { + Byte[] smk = new Byte[strText.Length]; + for ( int i=0; i < strText.Length ; i++) + { + Byte ss = Convert.ToByte(strText[i]); + smk[i] = ss ; + } + + IAsyncResult ar2 = s.BeginSend(smk , 0 , smk.Length , SocketFlags.None , callbackProc , s ); + s.EndSend(ar2); + } + catch(Exception ers) + { + MessageBox.Show("ERROR IN RESPOND OPTIONS"); + } + } + + void RespondToOptions() + { + try + { + string strOption; + for ( int i=0; i < m_ListOptions.Count; i++) + { + strOption = (string)m_ListOptions[i]; + ArrangeReply(strOption); + } + DispatchMessage(m_strResp); + m_strResp =""; + m_ListOptions.Clear(); + } + catch(Exception ers) + { + MessageBox.Show("ERROR IN RESPOND OPTIONS"); + } + } + void ArrangeReply(string strOption) + { + try + { + + Char Verb; + Char Option; + Char Modifier; + Char ch; + bool bDefined = false; + + if(strOption.Length < 3) return; + + Verb = strOption[1]; + Option = strOption[2]; + + if ( Option == 1 || Option == 3 ) + { + // case 1: // Echo + // case 3: // Suppress Go-Ahead + bDefined = true; + // break; + } + + m_strResp += IAC; + + if(bDefined == true ) + { + if ( Verb == DO ) + { + // case DO: + ch = WILL; + m_strResp += ch; + m_strResp += Option; + // break; + } + if ( Verb == DONT ) + { + ch = WONT; + m_strResp += ch; + m_strResp += Option; + // break; + } + if ( Verb == WILL ) + { + ch = DO; + m_strResp += ch; + m_strResp += Option; + //break; + } + if ( Verb == WONT) + { + ch = DONT; + m_strResp += ch; + m_strResp += Option; + // break; + } + if ( Verb == SB) + { + Modifier = strOption[3]; + if(Modifier == SEND) + { + ch = SB; + m_strResp += ch; + m_strResp += Option; + m_strResp += IS; + m_strResp += IAC; + m_strResp += SE; + } + // break; + } + } + else + { + // switch(Verb) + // { + if ( Verb == DO ) + { + ch = WONT; + m_strResp += ch; + m_strResp += Option; + // break; + } + if ( Verb == DONT) + { + ch = WONT; + m_strResp += ch; + m_strResp += Option; + // break; + } + if ( Verb == WILL) + { + ch = DONT; + m_strResp += ch; + m_strResp += Option; + // break; + } + if ( Verb == WONT) + { + ch = DONT; + m_strResp += ch; + m_strResp += Option; + // break; + } + } + } + catch(Exception eeeee ) + { + MessageBox.Show(eeeee.Message , "Application Error!!!" , MessageBoxButtons.OK , MessageBoxIcon.Stop ); + Application.Exit(); + } + + } + + private void textBox1_KeyPress_1(object sender, System.Windows.Forms.KeyPressEventArgs e) + { + if ( e.KeyChar == 13 ) + { + DispatchMessage("\r\n"); + } + else + if ( e.KeyChar == 8 ) + { + try + { +// string mtmp = textBox1.Text.Substring(0,textBox1.Text.Length-1); +// textBox1.Text = "" ; + } + catch(Exception ebs) + { + MessageBox.Show("ERROR IN BACKSPACE"); + } + } + else + { + string str = e.KeyChar.ToString(); + DispatchMessage(str); + } + } + + + } +} diff --git a/ndb/src/cw/cpcc-win32/vb6/Computer.cls b/ndb/src/cw/cpcc-win32/vb6/Computer.cls new file mode 100644 index 00000000000..5b42dfeadb6 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/Computer.cls @@ -0,0 +1,20 @@ +VERSION 1.0 CLASS +BEGIN + MultiUse = -1 'True + Persistable = 0 'NotPersistable + DataBindingBehavior = 0 'vbNone + DataSourceBehavior = 0 'vbNone + MTSTransactionMode = 0 'NotAnMTSObject +END +Attribute VB_Name = "Computer" +Attribute VB_GlobalNameSpace = False +Attribute VB_Creatable = True +Attribute VB_PredeclaredId = False +Attribute VB_Exposed = False +Attribute VB_Ext_KEY = "SavedWithClassBuilder6" ,"Yes" +Attribute VB_Ext_KEY = "Top_Level" ,"Yes" +Public m_ip As String +Public m_name As String +Public m_status As String +Public m_processes As Collection + diff --git a/ndb/src/cw/cpcc-win32/vb6/Database.cls b/ndb/src/cw/cpcc-win32/vb6/Database.cls new file mode 100644 index 00000000000..dfb1195d910 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/Database.cls @@ -0,0 +1,18 @@ +VERSION 1.0 CLASS +BEGIN + MultiUse = -1 'True + Persistable = 0 'NotPersistable + DataBindingBehavior = 0 'vbNone + DataSourceBehavior = 0 'vbNone + MTSTransactionMode = 0 'NotAnMTSObject +END +Attribute VB_Name = "Database_" +Attribute VB_GlobalNameSpace = False +Attribute VB_Creatable = True +Attribute VB_PredeclaredId = False +Attribute VB_Exposed = False +Attribute VB_Ext_KEY = "SavedWithClassBuilder6" ,"Yes" +Attribute VB_Ext_KEY = "Top_Level" ,"Yes" +Public m_name As String +Public m_processes As Collection +Public m_status As String diff --git a/ndb/src/cw/cpcc-win32/vb6/Icon 110.ico b/ndb/src/cw/cpcc-win32/vb6/Icon 110.ico new file mode 100644 index 00000000000..34b85992394 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/Icon 110.ico differ diff --git a/ndb/src/cw/cpcc-win32/vb6/Icon 231.ico b/ndb/src/cw/cpcc-win32/vb6/Icon 231.ico new file mode 100644 index 00000000000..fe30ff5d1e6 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/Icon 231.ico differ diff --git a/ndb/src/cw/cpcc-win32/vb6/Icon 237.ico b/ndb/src/cw/cpcc-win32/vb6/Icon 237.ico new file mode 100644 index 00000000000..af0a1294f9e Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/Icon 237.ico differ diff --git a/ndb/src/cw/cpcc-win32/vb6/Icon 241.ico b/ndb/src/cw/cpcc-win32/vb6/Icon 241.ico new file mode 100644 index 00000000000..e8caf6e9a73 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/Icon 241.ico differ diff --git a/ndb/src/cw/cpcc-win32/vb6/Icon 242.ico b/ndb/src/cw/cpcc-win32/vb6/Icon 242.ico new file mode 100644 index 00000000000..2deff5472bc Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/Icon 242.ico differ diff --git a/ndb/src/cw/cpcc-win32/vb6/Icon 270.ico b/ndb/src/cw/cpcc-win32/vb6/Icon 270.ico new file mode 100644 index 00000000000..9cab239de23 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/Icon 270.ico differ diff --git a/ndb/src/cw/cpcc-win32/vb6/Icon 271.ico b/ndb/src/cw/cpcc-win32/vb6/Icon 271.ico new file mode 100644 index 00000000000..f05c95f74fe Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/Icon 271.ico differ diff --git a/ndb/src/cw/cpcc-win32/vb6/Icon 273.ico b/ndb/src/cw/cpcc-win32/vb6/Icon 273.ico new file mode 100644 index 00000000000..800606eda0c Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/Icon 273.ico differ diff --git a/ndb/src/cw/cpcc-win32/vb6/Icon 31.ico b/ndb/src/cw/cpcc-win32/vb6/Icon 31.ico new file mode 100644 index 00000000000..a2404977771 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/Icon 31.ico differ diff --git a/ndb/src/cw/cpcc-win32/vb6/Icon 337.ico b/ndb/src/cw/cpcc-win32/vb6/Icon 337.ico new file mode 100644 index 00000000000..9dadb12cfbe Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/Icon 337.ico differ diff --git a/ndb/src/cw/cpcc-win32/vb6/Icon 338.ico b/ndb/src/cw/cpcc-win32/vb6/Icon 338.ico new file mode 100644 index 00000000000..a13c80c81b4 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/Icon 338.ico differ diff --git a/ndb/src/cw/cpcc-win32/vb6/Icon 339.ico b/ndb/src/cw/cpcc-win32/vb6/Icon 339.ico new file mode 100644 index 00000000000..5eb4c06815d Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/Icon 339.ico differ diff --git a/ndb/src/cw/cpcc-win32/vb6/MSSCCPRJ.SCC b/ndb/src/cw/cpcc-win32/vb6/MSSCCPRJ.SCC new file mode 100644 index 00000000000..3100640f8bd --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/MSSCCPRJ.SCC @@ -0,0 +1,5 @@ +[SCC] +SCC=This is a source code control file +[NdbCPC.vbp] +SCC_Project_Name=this project is not under source code control +SCC_Aux_Path= diff --git a/ndb/src/cw/cpcc-win32/vb6/Module1.bas b/ndb/src/cw/cpcc-win32/vb6/Module1.bas new file mode 100644 index 00000000000..ae8ed444a41 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/Module1.bas @@ -0,0 +1,233 @@ +Attribute VB_Name = "Module1" +Option Explicit +Public fMainForm As frmMain +Public g_computers As New Collection +Public g_databases As New Collection + +Sub Main() + If False Then + Dim fLogin As New frmLogin + fLogin.Show vbModal + If Not fLogin.OK Then + 'Login Failed so exit app + End + End If + Unload fLogin + + frmSplash.Show + frmSplash.Refresh + End If + + init + + Set fMainForm = New frmMain + Load fMainForm + Unload frmSplash + + fMainForm.Show +End Sub + +Private Sub init() + Dim c As Computer + Dim p As Process + + ' --- + ' One node configuration + ' + Set c = New Computer + With c + .m_ip = "130.100.232.31" + .m_name = "ndb-client31" + .m_status = "Connected" + Set .m_processes = New Collection + End With + addComputer c + + Set p = New Process + With p + .m_id = "1" + .m_name = "mgm-1" + .m_database = "elathal" + .m_status = "Running" + .m_owner = "elathal" + Set .m_computer = c + End With + addProcess c, p + + Set p = New Process + With p + .m_id = "2" + .m_name = "ndb-2" + .m_database = "elathal" + .m_status = "Running" + .m_owner = "elathal" + Set .m_computer = c + End With + addProcess c, p + + Set p = New Process + With p + .m_id = "3" + .m_name = "api-3" + .m_database = "elathal" + .m_status = "Running" + .m_owner = "elathal" + Set .m_computer = c + End With + addProcess c, p + + ' --- + ' Two node configuration + ' + Set p = New Process + With p + .m_id = "4" + .m_name = "mgm-1" + .m_database = "ejonore-2-node" + .m_status = "Running" + .m_owner = "ejonore" + Set .m_computer = c + End With + addProcess c, p + + Set c = New Computer + With c + .m_ip = "10.0.1.1" + .m_name = "cluster-1" + .m_status = "Connected" + Set .m_processes = New Collection + End With + addComputer c + + Set p = New Process + With p + .m_id = "1" + .m_name = "ndb-2" + .m_database = "ejonore-2-node" + .m_status = "Running" + .m_owner = "ejonore" + Set .m_computer = c + End With + addProcess c, p + + Set c = New Computer + With c + .m_ip = "10.0.2.1" + .m_name = "cluster-2" + .m_status = "Connected" + Set .m_processes = New Collection + End With + addComputer c + + Set p = New Process + With p + .m_id = "1" + .m_name = "ndb-3" + .m_database = "ejonore-2-node" + .m_status = "Running" + .m_owner = "ejonore" + Set .m_computer = c + End With + addProcess c, p + + Set c = New Computer + With c + .m_ip = "10.0.3.1" + .m_name = "cluster-3" + .m_status = "Connected" + Set .m_processes = New Collection + End With + addComputer c + + Set p = New Process + With p + .m_id = "1" + .m_name = "api-4" + .m_database = "ejonore-2-node" + .m_status = "Running" + .m_owner = "ejonore" + Set .m_computer = c + End With + addProcess c, p + + Set c = New Computer + With c + .m_ip = "10.0.4.1" + .m_name = "cluster-4" + .m_status = "Connected" + Set .m_processes = New Collection + End With + addComputer c + + Set p = New Process + With p + .m_id = "1" + .m_name = "api-5" + .m_database = "ejonore-2-node" + .m_status = "Running" + .m_owner = "ejonore" + Set .m_computer = c + End With + addProcess c, p + + Set c = New Computer + With c + .m_ip = "130.100.232.5" + .m_name = "ndbs05" + .m_status = "Not connected" + Set .m_processes = New Collection + End With + addComputer c + + Set c = New Computer + With c + .m_ip = "130.100.232.7" + .m_name = "ndb-srv7" + .m_status = "No contact" + Set .m_processes = New Collection + End With + addComputer c + +End Sub + +Public Sub addComputer(ByRef c As Computer) + g_computers.Add c, "_" & c.m_name +End Sub + +Private Sub addProcess(ByRef c As Computer, ByRef p As Process) + c.m_processes.Add p, "_" & p.m_id + + Dim cl As Database_ + If Not Exists(g_databases, "_" & p.m_database) Then + Set cl = New Database_ + With cl + .m_name = p.m_database + .m_status = "Unknown" + Set .m_processes = New Collection + End With + g_databases.Add cl, "_" & p.m_database + Else + Set cl = g_databases("_" & p.m_database) + End If + cl.m_processes.Add p, "_" & p.m_computer.m_name & "_" & p.m_id +End Sub + +Public Function Exists(ByRef c As Collection, ByVal k As String) As Boolean + Dim r As Boolean + Dim o As Object + + r = True + + On Error GoTo NotFound + Set o = c.Item(k) + GoTo Continue +NotFound: + If Err.Number <> 5 Then + Err.Raise Err.Number, Err.Source, Err.Description + End If + + r = False +Continue: + Exists = r +End Function + diff --git a/ndb/src/cw/cpcc-win32/vb6/NdbCPC.vbp b/ndb/src/cw/cpcc-win32/vb6/NdbCPC.vbp new file mode 100644 index 00000000000..dc8f3780a74 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/NdbCPC.vbp @@ -0,0 +1,49 @@ +Type=Exe +Object={831FDD16-0C5C-11D2-A9FC-0000F8754DA1}#2.0#0; mscomctl.ocx +Module=Module1; Module1.bas +Form=frmMain.frm +Form=frmSplash.frm +Form=frmLogin.frm +Form=frmOptions.frm +Form=frmAbout.frm +Class=Computer; Computer.cls +Class=Process; Process.cls +Class=Database_; Database.cls +Form=frmNewComputer.frm +Form=frmNewDatabase3.frm +Form=frmNewDatabase1.frm +Form=frmNewDatabase2.frm +IconForm="frmAbout" +Startup="Sub Main" +HelpFile="" +Title="NdbCPC" +ExeName32="NdbCPC.exe" +Command32="" +Name="NdbCPC" +HelpContextID="0" +CompatibleMode="0" +MajorVer=1 +MinorVer=0 +RevisionVer=0 +AutoIncrementVer=0 +ServerSupportFiles=0 +VersionCompanyName="ctp" +CompilationType=0 +OptimizationType=0 +FavorPentiumPro(tm)=0 +CodeViewDebugInfo=0 +NoAliasing=0 +BoundsCheck=0 +OverflowCheck=0 +FlPointCheck=0 +FDIVCheck=0 +UnroundedFP=0 +StartMode=0 +Unattended=0 +Retained=0 +ThreadPerObject=0 +MaxNumberOfThreads=1 +DebugStartupOption=0 + +[MS Transaction Server] +AutoRefresh=1 diff --git a/ndb/src/cw/cpcc-win32/vb6/NdbCPC.vbw b/ndb/src/cw/cpcc-win32/vb6/NdbCPC.vbw new file mode 100644 index 00000000000..825abbc923a --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/NdbCPC.vbw @@ -0,0 +1,13 @@ +Module1 = 44, 44, 577, 492, +frmMain = 44, 44, 577, 492, , 66, 66, 599, 514, C +frmSplash = 132, 132, 670, 576, C, 88, 88, 621, 536, C +frmLogin = 0, 0, 538, 444, C, 110, 110, 643, 558, C +frmOptions = 176, 176, 714, 620, C, 132, 132, 665, 580, C +frmAbout = 132, 132, 759, 511, C, 154, 154, 687, 602, C +Computer = 110, 110, 648, 554, +Process = 132, 132, 670, 576, C +Database_ = 88, 88, 626, 532, C +frmNewComputer = 44, 44, 582, 488, , 22, 22, 390, 218, C +frmNewDatabase3 = 0, 0, 506, 444, , 0, 0, 506, 444, C +frmNewDatabase1 = 132, 132, 638, 550, , 154, 154, 660, 572, C +frmNewDatabase2 = 198, 198, 704, 616, , 176, 176, 682, 594, C diff --git a/ndb/src/cw/cpcc-win32/vb6/Process.cls b/ndb/src/cw/cpcc-win32/vb6/Process.cls new file mode 100644 index 00000000000..fcb4c2cbb2c --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/Process.cls @@ -0,0 +1,22 @@ +VERSION 1.0 CLASS +BEGIN + MultiUse = -1 'True + Persistable = 0 'NotPersistable + DataBindingBehavior = 0 'vbNone + DataSourceBehavior = 0 'vbNone + MTSTransactionMode = 0 'NotAnMTSObject +END +Attribute VB_Name = "Process" +Attribute VB_GlobalNameSpace = False +Attribute VB_Creatable = True +Attribute VB_PredeclaredId = False +Attribute VB_Exposed = False +Attribute VB_Ext_KEY = "SavedWithClassBuilder6" ,"Yes" +Attribute VB_Ext_KEY = "Top_Level" ,"Yes" +Public m_computer As Computer +Public m_id As String +Public m_name As String +Public m_database As String +Public m_status As String +Public m_owner As String + diff --git a/ndb/src/cw/cpcc-win32/vb6/closed folder.ico b/ndb/src/cw/cpcc-win32/vb6/closed folder.ico new file mode 100644 index 00000000000..fe82350d376 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/closed folder.ico differ diff --git a/ndb/src/cw/cpcc-win32/vb6/computer.ico b/ndb/src/cw/cpcc-win32/vb6/computer.ico new file mode 100644 index 00000000000..d73302d1cd5 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/computer.ico differ diff --git a/ndb/src/cw/cpcc-win32/vb6/frmAbout.frm b/ndb/src/cw/cpcc-win32/vb6/frmAbout.frm new file mode 100644 index 00000000000..b842d20de21 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/frmAbout.frm @@ -0,0 +1,245 @@ +VERSION 5.00 +Begin VB.Form frmAbout + BorderStyle = 3 'Fixed Dialog + Caption = "About NdbCPC" + ClientHeight = 3630 + ClientLeft = 45 + ClientTop = 330 + ClientWidth = 5865 + ClipControls = 0 'False + LinkTopic = "Form1" + MaxButton = 0 'False + MinButton = 0 'False + ScaleHeight = 3630 + ScaleWidth = 5865 + ShowInTaskbar = 0 'False + StartUpPosition = 1 'CenterOwner + Tag = "About NdbCPC" + Begin VB.PictureBox picIcon + AutoSize = -1 'True + BackColor = &H00C0C0C0& + ClipControls = 0 'False + Height = 540 + Left = 240 + Picture = "frmAbout.frx":0000 + ScaleHeight = 480 + ScaleMode = 0 'User + ScaleWidth = 480 + TabIndex = 2 + TabStop = 0 'False + Top = 240 + Width = 540 + End + Begin VB.CommandButton cmdOK + Cancel = -1 'True + Caption = "OK" + Default = -1 'True + Height = 345 + Left = 4245 + TabIndex = 0 + Tag = "OK" + Top = 2625 + Width = 1467 + End + Begin VB.CommandButton cmdSysInfo + Caption = "&System Info..." + Height = 345 + Left = 4260 + TabIndex = 1 + Tag = "&System Info..." + Top = 3075 + Width = 1452 + End + Begin VB.Label lblDescription + Caption = "App Description" + ForeColor = &H00000000& + Height = 1170 + Left = 1050 + TabIndex = 6 + Tag = "App Description" + Top = 1125 + Width = 4092 + End + Begin VB.Label lblTitle + Caption = "Application Title" + ForeColor = &H00000000& + Height = 480 + Left = 1050 + TabIndex = 5 + Tag = "Application Title" + Top = 240 + Width = 4092 + End + Begin VB.Line Line1 + BorderColor = &H00808080& + BorderStyle = 6 'Inside Solid + Index = 1 + X1 = 225 + X2 = 5657 + Y1 = 2430 + Y2 = 2430 + End + Begin VB.Line Line1 + BorderColor = &H00FFFFFF& + BorderWidth = 2 + Index = 0 + X1 = 240 + X2 = 5657 + Y1 = 2445 + Y2 = 2445 + End + Begin VB.Label lblVersion + Caption = "Version" + Height = 225 + Left = 1050 + TabIndex = 4 + Tag = "Version" + Top = 780 + Width = 4092 + End + Begin VB.Label lblDisclaimer + Caption = "Warning: ..." + ForeColor = &H00000000& + Height = 825 + Left = 255 + TabIndex = 3 + Tag = "Warning: ..." + Top = 2625 + Width = 3870 + End +End +Attribute VB_Name = "frmAbout" +Attribute VB_GlobalNameSpace = False +Attribute VB_Creatable = False +Attribute VB_PredeclaredId = True +Attribute VB_Exposed = False +' Reg Key Security Options... +Const KEY_ALL_ACCESS = &H2003F + + +' Reg Key ROOT Types... +Const HKEY_LOCAL_MACHINE = &H80000002 +Const ERROR_SUCCESS = 0 +Const REG_SZ = 1 ' Unicode nul terminated string +Const REG_DWORD = 4 ' 32-bit number + + +Const gREGKEYSYSINFOLOC = "SOFTWARE\Microsoft\Shared Tools Location" +Const gREGVALSYSINFOLOC = "MSINFO" +Const gREGKEYSYSINFO = "SOFTWARE\Microsoft\Shared Tools\MSINFO" +Const gREGVALSYSINFO = "PATH" + + +Private Declare Function RegOpenKeyEx Lib "advapi32" Alias "RegOpenKeyExA" (ByVal hKey As Long, ByVal lpSubKey As String, ByVal ulOptions As Long, ByVal samDesired As Long, ByRef phkResult As Long) As Long +Private Declare Function RegQueryValueEx Lib "advapi32" Alias "RegQueryValueExA" (ByVal hKey As Long, ByVal lpValueName As String, ByVal lpReserved As Long, ByRef lpType As Long, ByVal lpData As String, ByRef lpcbData As Long) As Long +Private Declare Function RegCloseKey Lib "advapi32" (ByVal hKey As Long) As Long + +Private Sub Form_Load() + lblVersion.Caption = "Version " & App.Major & "." & App.Minor & "." & App.Revision + lblTitle.Caption = App.Title +End Sub + + + +Private Sub cmdSysInfo_Click() + Call StartSysInfo +End Sub + + +Private Sub cmdOK_Click() + Unload Me +End Sub + + +Public Sub StartSysInfo() + On Error GoTo SysInfoErr + + + Dim rc As Long + Dim SysInfoPath As String + + + ' Try To Get System Info Program Path\Name From Registry... + If GetKeyValue(HKEY_LOCAL_MACHINE, gREGKEYSYSINFO, gREGVALSYSINFO, SysInfoPath) Then + ' Try To Get System Info Program Path Only From Registry... + ElseIf GetKeyValue(HKEY_LOCAL_MACHINE, gREGKEYSYSINFOLOC, gREGVALSYSINFOLOC, SysInfoPath) Then + ' Validate Existance Of Known 32 Bit File Version + If (Dir(SysInfoPath & "\MSINFO32.EXE") <> "") Then + SysInfoPath = SysInfoPath & "\MSINFO32.EXE" + + + ' Error - File Can Not Be Found... + Else + GoTo SysInfoErr + End If + ' Error - Registry Entry Can Not Be Found... + Else + GoTo SysInfoErr + End If + + + Call Shell(SysInfoPath, vbNormalFocus) + + + Exit Sub +SysInfoErr: + MsgBox "System Information Is Unavailable At This Time", vbOKOnly +End Sub + + +Public Function GetKeyValue(KeyRoot As Long, KeyName As String, SubKeyRef As String, ByRef KeyVal As String) As Boolean + Dim i As Long ' Loop Counter + Dim rc As Long ' Return Code + Dim hKey As Long ' Handle To An Open Registry Key + Dim hDepth As Long ' + Dim KeyValType As Long ' Data Type Of A Registry Key + Dim tmpVal As String ' Tempory Storage For A Registry Key Value + Dim KeyValSize As Long ' Size Of Registry Key Variable + '------------------------------------------------------------ + ' Open RegKey Under KeyRoot {HKEY_LOCAL_MACHINE...} + '------------------------------------------------------------ + rc = RegOpenKeyEx(KeyRoot, KeyName, 0, KEY_ALL_ACCESS, hKey) ' Open Registry Key + + + If (rc <> ERROR_SUCCESS) Then GoTo GetKeyError ' Handle Error... + + + tmpVal = String$(1024, 0) ' Allocate Variable Space + KeyValSize = 1024 ' Mark Variable Size + + + '------------------------------------------------------------ + ' Retrieve Registry Key Value... + '------------------------------------------------------------ + rc = RegQueryValueEx(hKey, SubKeyRef, 0, KeyValType, tmpVal, KeyValSize) ' Get/Create Key Value + + + If (rc <> ERROR_SUCCESS) Then GoTo GetKeyError ' Handle Errors + + + tmpVal = VBA.Left(tmpVal, InStr(tmpVal, VBA.Chr(0)) - 1) + '------------------------------------------------------------ + ' Determine Key Value Type For Conversion... + '------------------------------------------------------------ + Select Case KeyValType ' Search Data Types... + Case REG_SZ ' String Registry Key Data Type + KeyVal = tmpVal ' Copy String Value + Case REG_DWORD ' Double Word Registry Key Data Type + For i = Len(tmpVal) To 1 Step -1 ' Convert Each Bit + KeyVal = KeyVal + Hex(Asc(Mid(tmpVal, i, 1))) ' Build Value Char. By Char. + Next + KeyVal = Format$("&h" + KeyVal) ' Convert Double Word To String + End Select + + + GetKeyValue = True ' Return Success + rc = RegCloseKey(hKey) ' Close Registry Key + Exit Function ' Exit + + +GetKeyError: ' Cleanup After An Error Has Occured... + KeyVal = "" ' Set Return Val To Empty String + GetKeyValue = False ' Return Failure + rc = RegCloseKey(hKey) ' Close Registry Key +End Function + diff --git a/ndb/src/cw/cpcc-win32/vb6/frmLogin.frm b/ndb/src/cw/cpcc-win32/vb6/frmLogin.frm new file mode 100644 index 00000000000..d4d663c93c2 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/frmLogin.frm @@ -0,0 +1,119 @@ +VERSION 5.00 +Begin VB.Form frmLogin + BorderStyle = 3 'Fixed Dialog + Caption = "Login" + ClientHeight = 1590 + ClientLeft = 45 + ClientTop = 330 + ClientWidth = 3750 + LinkTopic = "Form1" + MaxButton = 0 'False + MinButton = 0 'False + ScaleHeight = 1590 + ScaleWidth = 3750 + ShowInTaskbar = 0 'False + StartUpPosition = 2 'CenterScreen + Tag = "Login" + Begin VB.CommandButton cmdCancel + Cancel = -1 'True + Caption = "Cancel" + Height = 360 + Left = 2100 + TabIndex = 5 + Tag = "Cancel" + Top = 1020 + Width = 1140 + End + Begin VB.CommandButton cmdOK + Caption = "OK" + Default = -1 'True + Height = 360 + Left = 495 + TabIndex = 4 + Tag = "OK" + Top = 1020 + Width = 1140 + End + Begin VB.TextBox txtPassword + Height = 285 + IMEMode = 3 'DISABLE + Left = 1305 + PasswordChar = "*" + TabIndex = 1 + Top = 525 + Width = 2325 + End + Begin VB.TextBox txtUserName + Height = 285 + Left = 1305 + TabIndex = 3 + Top = 135 + Width = 2325 + End + Begin VB.Label lblLabels + Caption = "&Password:" + Height = 248 + Index = 1 + Left = 105 + TabIndex = 0 + Tag = "&Password:" + Top = 540 + Width = 1080 + End + Begin VB.Label lblLabels + Caption = "&User Name:" + Height = 248 + Index = 0 + Left = 105 + TabIndex = 2 + Tag = "&User Name:" + Top = 150 + Width = 1080 + End +End +Attribute VB_Name = "frmLogin" +Attribute VB_GlobalNameSpace = False +Attribute VB_Creatable = False +Attribute VB_PredeclaredId = True +Attribute VB_Exposed = False +Private Declare Function GetUserName Lib "advapi32.dll" Alias "GetUserNameA" (ByVal lpbuffer As String, nSize As Long) As Long + + +Public OK As Boolean +Private Sub Form_Load() + Dim sBuffer As String + Dim lSize As Long + + + sBuffer = Space$(255) + lSize = Len(sBuffer) + Call GetUserName(sBuffer, lSize) + If lSize > 0 Then + txtUserName.Text = Left$(sBuffer, lSize) + Else + txtUserName.Text = vbNullString + End If +End Sub + + + +Private Sub cmdCancel_Click() + OK = False + Me.Hide +End Sub + + +Private Sub cmdOK_Click() + 'ToDo: create test for correct password + 'check for correct password + If txtPassword.Text = "" Then + OK = True + Me.Hide + Else + MsgBox "Invalid Password, try again!", , "Login" + txtPassword.SetFocus + txtPassword.SelStart = 0 + txtPassword.SelLength = Len(txtPassword.Text) + End If +End Sub + diff --git a/ndb/src/cw/cpcc-win32/vb6/frmMain.frm b/ndb/src/cw/cpcc-win32/vb6/frmMain.frm new file mode 100644 index 00000000000..a4bf5b58941 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/frmMain.frm @@ -0,0 +1,1207 @@ +VERSION 5.00 +Object = "{831FDD16-0C5C-11D2-A9FC-0000F8754DA1}#2.0#0"; "mscomctl.ocx" +Begin VB.Form frmMain + Caption = "NdbCPC" + ClientHeight = 5955 + ClientLeft = 2115 + ClientTop = 2250 + ClientWidth = 8880 + LinkTopic = "Form1" + ScaleHeight = 5955 + ScaleWidth = 8880 + Begin MSComctlLib.ImageList ImageList1 + Left = 6840 + Top = 3120 + _ExtentX = 1005 + _ExtentY = 1005 + BackColor = 16777215 + ImageWidth = 16 + ImageHeight = 16 + MaskColor = 12632256 + _Version = 393216 + BeginProperty Images {2C247F25-8591-11D1-B16A-00C0F0283628} + NumListImages = 11 + BeginProperty ListImage1 {2C247F27-8591-11D1-B16A-00C0F0283628} + Picture = "frmMain.frx":0000 + Key = "close" + EndProperty + BeginProperty ListImage2 {2C247F27-8591-11D1-B16A-00C0F0283628} + Picture = "frmMain.frx":27B4 + Key = "open" + EndProperty + BeginProperty ListImage3 {2C247F27-8591-11D1-B16A-00C0F0283628} + Picture = "frmMain.frx":4F68 + Key = "computer_unknown" + EndProperty + BeginProperty ListImage4 {2C247F27-8591-11D1-B16A-00C0F0283628} + Picture = "frmMain.frx":5284 + Key = "computer_stopped" + EndProperty + BeginProperty ListImage5 {2C247F27-8591-11D1-B16A-00C0F0283628} + Picture = "frmMain.frx":55A0 + Key = "computer_started" + EndProperty + BeginProperty ListImage6 {2C247F27-8591-11D1-B16A-00C0F0283628} + Picture = "frmMain.frx":58BC + Key = "" + EndProperty + BeginProperty ListImage7 {2C247F27-8591-11D1-B16A-00C0F0283628} + Picture = "frmMain.frx":5BD8 + Key = "" + EndProperty + BeginProperty ListImage8 {2C247F27-8591-11D1-B16A-00C0F0283628} + Picture = "frmMain.frx":5EF4 + Key = "" + EndProperty + BeginProperty ListImage9 {2C247F27-8591-11D1-B16A-00C0F0283628} + Picture = "frmMain.frx":6210 + Key = "db" + EndProperty + BeginProperty ListImage10 {2C247F27-8591-11D1-B16A-00C0F0283628} + Picture = "frmMain.frx":652A + Key = "computer" + EndProperty + BeginProperty ListImage11 {2C247F27-8591-11D1-B16A-00C0F0283628} + Picture = "frmMain.frx":6844 + Key = "properties" + EndProperty + EndProperty + End + Begin VB.PictureBox picSplitter + BackColor = &H00808080& + BorderStyle = 0 'None + FillColor = &H00808080& + Height = 4800 + Left = 5400 + ScaleHeight = 2090.126 + ScaleMode = 0 'User + ScaleWidth = 780 + TabIndex = 6 + Top = 705 + Width = 72 + Visible = 0 'False + End + Begin MSComctlLib.TreeView tvTreeView + Height = 4800 + Left = 0 + TabIndex = 5 + Top = 705 + Width = 2016 + _ExtentX = 3545 + _ExtentY = 8467 + _Version = 393217 + HideSelection = 0 'False + Indentation = 0 + LineStyle = 1 + Sorted = -1 'True + Style = 7 + FullRowSelect = -1 'True + ImageList = "ImageList1" + Appearance = 1 + End + Begin VB.PictureBox picTitles + Align = 1 'Align Top + Appearance = 0 'Flat + BorderStyle = 0 'None + ForeColor = &H80000008& + Height = 300 + Left = 0 + ScaleHeight = 300 + ScaleWidth = 8880 + TabIndex = 2 + TabStop = 0 'False + Top = 420 + Width = 8880 + Begin VB.Label lblTitle + BorderStyle = 1 'Fixed Single + Caption = " ListView:" + Height = 270 + Index = 1 + Left = 2078 + TabIndex = 4 + Tag = " ListView:" + Top = 12 + Width = 3216 + End + Begin VB.Label lblTitle + BorderStyle = 1 'Fixed Single + Caption = " TreeView:" + Height = 270 + Index = 0 + Left = 0 + TabIndex = 3 + Tag = " TreeView:" + Top = 12 + Width = 2016 + End + End + Begin MSComctlLib.Toolbar tbToolBar + Align = 1 'Align Top + Height = 420 + Left = 0 + TabIndex = 1 + Top = 0 + Width = 8880 + _ExtentX = 15663 + _ExtentY = 741 + ButtonWidth = 609 + ButtonHeight = 582 + Appearance = 1 + ImageList = "ImageList1" + _Version = 393216 + BeginProperty Buttons {66833FE8-8583-11D1-B16A-00C0F0283628} + NumButtons = 5 + BeginProperty Button1 {66833FEA-8583-11D1-B16A-00C0F0283628} + Style = 3 + EndProperty + BeginProperty Button2 {66833FEA-8583-11D1-B16A-00C0F0283628} + Key = "Add computer" + Object.ToolTipText = "Add computer" + ImageKey = "computer" + EndProperty + BeginProperty Button3 {66833FEA-8583-11D1-B16A-00C0F0283628} + Key = "New database" + Object.ToolTipText = "New database" + ImageKey = "db" + EndProperty + BeginProperty Button4 {66833FEA-8583-11D1-B16A-00C0F0283628} + Style = 3 + EndProperty + BeginProperty Button5 {66833FEA-8583-11D1-B16A-00C0F0283628} + Key = "Properties" + Object.ToolTipText = "Properties" + ImageKey = "properties" + EndProperty + EndProperty + End + Begin MSComctlLib.StatusBar sbStatusBar + Align = 2 'Align Bottom + Height = 270 + Left = 0 + TabIndex = 0 + Top = 5685 + Width = 8880 + _ExtentX = 15663 + _ExtentY = 476 + _Version = 393216 + BeginProperty Panels {8E3867A5-8586-11D1-B16A-00C0F0283628} + NumPanels = 3 + BeginProperty Panel1 {8E3867AB-8586-11D1-B16A-00C0F0283628} + AutoSize = 1 + Object.Width = 10028 + Text = "Status" + TextSave = "Status" + EndProperty + BeginProperty Panel2 {8E3867AB-8586-11D1-B16A-00C0F0283628} + Style = 6 + AutoSize = 2 + TextSave = "2002-10-15" + EndProperty + BeginProperty Panel3 {8E3867AB-8586-11D1-B16A-00C0F0283628} + Style = 5 + AutoSize = 2 + TextSave = "09:44" + EndProperty + EndProperty + End + Begin MSComctlLib.ListView lvProcesses + Height = 4815 + Left = 2040 + TabIndex = 8 + Top = 720 + Width = 3255 + _ExtentX = 5741 + _ExtentY = 8493 + Sorted = -1 'True + MultiSelect = -1 'True + LabelWrap = -1 'True + HideSelection = 0 'False + AllowReorder = -1 'True + FullRowSelect = -1 'True + _Version = 393217 + ForeColor = -2147483640 + BackColor = -2147483643 + BorderStyle = 1 + Appearance = 1 + NumItems = 6 + BeginProperty ColumnHeader(1) {BDD1F052-858B-11D1-B16A-00C0F0283628} + Key = "Id" + Text = "Id" + Object.Width = 2540 + EndProperty + BeginProperty ColumnHeader(2) {BDD1F052-858B-11D1-B16A-00C0F0283628} + SubItemIndex = 1 + Key = "Computer" + Text = "Computer" + Object.Width = 2540 + EndProperty + BeginProperty ColumnHeader(3) {BDD1F052-858B-11D1-B16A-00C0F0283628} + SubItemIndex = 2 + Key = "Database" + Text = "Database" + Object.Width = 2540 + EndProperty + BeginProperty ColumnHeader(4) {BDD1F052-858B-11D1-B16A-00C0F0283628} + SubItemIndex = 3 + Key = "Name" + Text = "Name" + Object.Width = 2540 + EndProperty + BeginProperty ColumnHeader(5) {BDD1F052-858B-11D1-B16A-00C0F0283628} + SubItemIndex = 4 + Key = "Status" + Text = "Status" + Object.Width = 2540 + EndProperty + BeginProperty ColumnHeader(6) {BDD1F052-858B-11D1-B16A-00C0F0283628} + SubItemIndex = 5 + Key = "Owner" + Text = "Owner" + Object.Width = 2540 + EndProperty + End + Begin MSComctlLib.ListView lvComputers + Height = 4815 + Left = 2040 + TabIndex = 7 + Top = 720 + Width = 3255 + _ExtentX = 5741 + _ExtentY = 8493 + Sorted = -1 'True + MultiSelect = -1 'True + LabelWrap = -1 'True + HideSelection = -1 'True + AllowReorder = -1 'True + FullRowSelect = -1 'True + _Version = 393217 + Icons = "ImageList1" + SmallIcons = "ImageList1" + ForeColor = -2147483640 + BackColor = -2147483643 + BorderStyle = 1 + Appearance = 1 + NumItems = 2 + BeginProperty ColumnHeader(1) {BDD1F052-858B-11D1-B16A-00C0F0283628} + Text = "Computer" + Object.Width = 2540 + EndProperty + BeginProperty ColumnHeader(2) {BDD1F052-858B-11D1-B16A-00C0F0283628} + SubItemIndex = 1 + Text = "Status" + Object.Width = 2540 + EndProperty + End + Begin MSComctlLib.ListView lvDatabases + Height = 4815 + Left = 2040 + TabIndex = 9 + Top = 720 + Width = 3255 + _ExtentX = 5741 + _ExtentY = 8493 + View = 3 + Sorted = -1 'True + MultiSelect = -1 'True + LabelWrap = -1 'True + HideSelection = -1 'True + AllowReorder = -1 'True + FullRowSelect = -1 'True + _Version = 393217 + Icons = "ImageList1" + SmallIcons = "ImageList1" + ForeColor = -2147483640 + BackColor = -2147483643 + BorderStyle = 1 + Appearance = 1 + NumItems = 2 + BeginProperty ColumnHeader(1) {BDD1F052-858B-11D1-B16A-00C0F0283628} + Key = "Database" + Text = "Database" + Object.Width = 2540 + EndProperty + BeginProperty ColumnHeader(2) {BDD1F052-858B-11D1-B16A-00C0F0283628} + SubItemIndex = 1 + Key = "Status" + Text = "Status" + Object.Width = 2540 + EndProperty + End + Begin VB.Image imgSplitter + Height = 4788 + Left = 1965 + MousePointer = 9 'Size W E + Top = 705 + Width = 150 + End + Begin VB.Menu mnuFile + Caption = "&File" + Begin VB.Menu mnuFileOpen + Caption = "&Open..." + End + Begin VB.Menu mnuFileFind + Caption = "&Find" + End + Begin VB.Menu mnuFileBar0 + Caption = "-" + End + Begin VB.Menu mnuFileSendTo + Caption = "Sen&d to" + End + Begin VB.Menu mnuFileBar1 + Caption = "-" + End + Begin VB.Menu mnuFileNew + Caption = "&New" + Shortcut = ^N + End + Begin VB.Menu mnuFileBar2 + Caption = "-" + End + Begin VB.Menu mnuFileDelete + Caption = "&Delete" + End + Begin VB.Menu mnuFileRename + Caption = "Rena&me" + End + Begin VB.Menu mnuFileProperties + Caption = "Propert&ies" + End + Begin VB.Menu mnuFileBar3 + Caption = "-" + End + Begin VB.Menu mnuFileMRU + Caption = "" + Index = 1 + Visible = 0 'False + End + Begin VB.Menu mnuFileMRU + Caption = "" + Index = 2 + Visible = 0 'False + End + Begin VB.Menu mnuFileMRU + Caption = "" + Index = 3 + Visible = 0 'False + End + Begin VB.Menu mnuFileBar4 + Caption = "-" + Visible = 0 'False + End + Begin VB.Menu mnuFileBar5 + Caption = "-" + End + Begin VB.Menu mnuFileClose + Caption = "&Close" + End + End + Begin VB.Menu mnuEdit + Caption = "&Edit" + Begin VB.Menu mnuEditUndo + Caption = "&Undo" + End + Begin VB.Menu mnuEditBar0 + Caption = "-" + End + Begin VB.Menu mnuEditCut + Caption = "Cu&t" + Shortcut = ^X + End + Begin VB.Menu mnuEditCopy + Caption = "&Copy" + Shortcut = ^C + End + Begin VB.Menu mnuEditPaste + Caption = "&Paste" + Shortcut = ^V + End + Begin VB.Menu mnuEditPasteSpecial + Caption = "Paste &Special..." + End + Begin VB.Menu mnuEditBar1 + Caption = "-" + End + Begin VB.Menu mnuEditSelectAll + Caption = "Select &All" + Shortcut = ^A + End + Begin VB.Menu mnuEditInvertSelection + Caption = "&Invert Selection" + End + End + Begin VB.Menu mnuView + Caption = "&View" + Begin VB.Menu mnuViewToolbar + Caption = "&Toolbar" + Checked = -1 'True + End + Begin VB.Menu mnuViewStatusBar + Caption = "Status &Bar" + Checked = -1 'True + End + Begin VB.Menu mnuViewBar0 + Caption = "-" + End + Begin VB.Menu mnuListViewMode + Caption = "Lar&ge Icons" + Index = 0 + End + Begin VB.Menu mnuListViewMode + Caption = "S&mall Icons" + Index = 1 + End + Begin VB.Menu mnuListViewMode + Caption = "&List" + Index = 2 + End + Begin VB.Menu mnuListViewMode + Caption = "&Details" + Index = 3 + End + Begin VB.Menu mnuViewBar1 + Caption = "-" + End + Begin VB.Menu mnuViewArrangeIcons + Caption = "Arrange &Icons" + End + Begin VB.Menu mnuViewBar2 + Caption = "-" + End + Begin VB.Menu mnuViewRefresh + Caption = "&Refresh" + End + Begin VB.Menu mnuViewOptions + Caption = "&Options..." + End + Begin VB.Menu mnuViewWebBrowser + Caption = "&Web Browser" + End + End + Begin VB.Menu mnuHelp + Caption = "&Help" + Begin VB.Menu mnuHelpContents + Caption = "&Contents" + End + Begin VB.Menu mnuHelpSearchForHelpOn + Caption = "&Search For Help On..." + End + Begin VB.Menu mnuHelpBar0 + Caption = "-" + End + Begin VB.Menu mnuHelpAbout + Caption = "&About " + End + End + Begin VB.Menu mnuPopComputers + Caption = "" + Visible = 0 'False + Begin VB.Menu mnuPopAddComputer + Caption = "Add computer" + End + Begin VB.Menu mnuPop__ + Caption = "-" + End + Begin VB.Menu mnuPopSortComputers + Caption = "Sorted" + End + End + Begin VB.Menu mnuPopDatabases + Caption = "" + Visible = 0 'False + Begin VB.Menu mnuPopNewDatabase + Caption = "New database" + End + Begin VB.Menu mnuPopSortDatabases0 + Caption = "-" + End + Begin VB.Menu mnuPopSortDatabases + Caption = "Sorted" + End + End + Begin VB.Menu mnuPopComputer + Caption = "" + Visible = 0 'False + Begin VB.Menu mnuPopComputerName + Caption = "ComputerName" + Enabled = 0 'False + End + Begin VB.Menu mnuPopComputer0 + Caption = "-" + End + Begin VB.Menu mnuPopConnectComputer + Caption = "Connect" + End + Begin VB.Menu mnuPopDisconnectComputer + Caption = "Disconnect" + End + Begin VB.Menu mnuPopRemoveComputer + Caption = "Remove" + End + Begin VB.Menu mnuComputer1 + Caption = "-" + End + Begin VB.Menu mnuPopComputerProperties + Caption = "Properties" + End + End +End +Attribute VB_Name = "frmMain" +Attribute VB_GlobalNameSpace = False +Attribute VB_Creatable = False +Attribute VB_PredeclaredId = True +Attribute VB_Exposed = False +Option Explicit +Private Declare Function OSWinHelp% Lib "user32" Alias "WinHelpA" (ByVal hwnd&, ByVal HelpFile$, ByVal wCommand%, dwData As Any) + +Dim mbMoving As Boolean +Const sglSplitLimit = 500 +Dim m_currentNode As MSComctlLib.Node +Dim m_currentList As ListView + +Dim m_currentView As Integer +Dim m_computerWidth As Integer +Dim m_databaseWidth As Integer + +Dim m_currentComputer As Computer +Dim m_currentDatabase As Database_ + +Private Sub Form_Load() + tvTreeView.Nodes.Clear + lvComputers.ListItems.Clear + lvProcesses.ListItems.Clear + lvDatabases.ListItems.Clear + + Me.Left = GetSetting(App.Title, "Settings", "MainLeft", 1000) + Me.Top = GetSetting(App.Title, "Settings", "MainTop", 1000) + Me.Width = GetSetting(App.Title, "Settings", "MainWidth", 6500) + Me.Height = GetSetting(App.Title, "Settings", "MainHeight", 6500) + + tvTreeView.Nodes.Add , tvwChild, "Computers", "Computers", 1, 2 + Dim c As Computer + For Each c In g_computers + addComputer c + Next + + Set m_currentNode = tvTreeView.Nodes("Computers") + Set m_currentList = lvComputers + + tvTreeView.Nodes.Add , tvwChild, "Databases", "Databases", 1, 2 + Dim d As Database_ + For Each d In g_databases + AddDatabase d + Next + + lvComputers.Visible = True + lvProcesses.Visible = False + lvDatabases.Visible = False + lvComputers.View = lvwReport + lvProcesses.View = lvwReport + lvDatabases.View = lvwReport + m_computerWidth = lvProcesses.ColumnHeaders("Computer").Width + m_databaseWidth = lvProcesses.ColumnHeaders("Database").Width + lvProcesses.ColumnHeaders("Id").Width = 0 +End Sub + +Private Sub setComputer(ByVal f_ip As String) + Dim c As Computer + Set c = g_computers(f_ip) + If c Is Nothing Then + MsgBox "Unknown computer: " & f_ip + Exit Sub + End If + + Set m_currentComputer = c + + lblTitle(1).Caption = "Processes defined on computer: " & c.m_name + setProcesses c.m_processes + + If lvProcesses.ColumnHeaders("Computer").Width <> 0 Then + m_computerWidth = lvProcesses.ColumnHeaders("Computer").Width + lvProcesses.ColumnHeaders("Computer").Width = 0 + End If + + If lvProcesses.ColumnHeaders("Database").Width = 0 Then + lvProcesses.ColumnHeaders("Database").Width = m_databaseWidth + End If +End Sub + +Private Sub setDatabase(ByVal f_name As String) + Dim c As Database_ + Set c = g_databases(f_name) + If c Is Nothing Then + MsgBox "Unknown database: " & f_name + Exit Sub + End If + + Set m_currentDatabase = c + + lblTitle(1).Caption = "Processes defined for database: " & c.m_name + setProcesses c.m_processes + + If lvProcesses.ColumnHeaders("Database").Width <> 0 Then + m_databaseWidth = lvProcesses.ColumnHeaders("Database").Width + lvProcesses.ColumnHeaders("Database").Width = 0 + End If + + If lvProcesses.ColumnHeaders("Computer").Width = 0 Then + lvProcesses.ColumnHeaders("Computer").Width = m_computerWidth + End If + +End Sub + +Private Sub setProcesses(ByRef c As Collection) + lvProcesses.ListItems.Clear + Dim p As Process + For Each p In c + Dim li As ListItem + Set li = lvProcesses.ListItems.Add(, "_" & p.m_computer.m_name & "_" & p.m_id, p.m_id) + li.SubItems(1) = p.m_computer.m_name + li.SubItems(2) = p.m_database + li.SubItems(3) = p.m_name + li.SubItems(4) = p.m_status + li.SubItems(5) = p.m_owner + Next +End Sub + +Public Sub addComputer(ByRef c As Computer) + Dim icon As Integer + Select Case c.m_status + Case "No contact" + icon = 4 + Case "Connected" + icon = 5 + Case Else + icon = 3 + End Select + + Dim li As ListItem + Set li = lvComputers.ListItems.Add(, "_" & c.m_name, c.m_name, icon, icon) + li.SubItems(1) = c.m_status + + tvTreeView.Nodes.Add "Computers", tvwChild, "_" & c.m_name, c.m_name, icon, icon +End Sub + +Public Sub removeComputer(ByRef name As String) + lvComputers.ListItems.Remove "_" & name + tvTreeView.Nodes.Remove "_" & name + + ' + ' Check if should remove database + Dim c As Computer + Set c = g_computers("_" & name) + Dim db As Database_ + Dim dbs As New Collection + Dim p As Process + For Each p In c.m_processes + Set db = g_databases("_" & p.m_database) + db.m_processes.Remove "_" & p.m_computer.m_name & "_" & p.m_id + If Not Exists(dbs, p.m_database) Then dbs.Add db, p.m_database + Next + + For Each db In dbs + If db.m_processes.Count = 0 Then + g_databases.Remove "_" & db.m_name + tvTreeView.Nodes.Remove "_" & db.m_name + End If + Next + + g_computers.Remove "_" & name + + ' + ' Check if should remove database + + Dim n As MSComctlLib.Node + Set n = tvTreeView.SelectedItem + selectNode n +End Sub + +Private Sub AddDatabase(ByRef c As Database_) + Dim li As ListItem + Set li = lvDatabases.ListItems.Add(, "_" & c.m_name, c.m_name, 9, 9) + li.SubItems(1) = c.m_status + tvTreeView.Nodes.Add "Databases", tvwChild, "_" & c.m_name, c.m_name, 9, 9 +End Sub + +Private Sub Form_Unload(Cancel As Integer) + Dim i As Integer + + + 'close all sub forms + For i = Forms.Count - 1 To 1 Step -1 + Unload Forms(i) + Next + If Me.WindowState <> vbMinimized Then + SaveSetting App.Title, "Settings", "MainLeft", Me.Left + SaveSetting App.Title, "Settings", "MainTop", Me.Top + SaveSetting App.Title, "Settings", "MainWidth", Me.Width + SaveSetting App.Title, "Settings", "MainHeight", Me.Height + End If +End Sub + +Private Sub Form_Resize() + On Error Resume Next + If Me.Width < 3000 Then Me.Width = 3000 + SizeControls imgSplitter.Left +End Sub + +Private Sub imgSplitter_MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single) + With imgSplitter + picSplitter.Move .Left, .Top, .Width \ 2, .Height - 20 + End With + picSplitter.Visible = True + mbMoving = True +End Sub + +Private Sub imgSplitter_MouseMove(Button As Integer, Shift As Integer, X As Single, Y As Single) + Dim sglPos As Single + + + If mbMoving Then + sglPos = X + imgSplitter.Left + If sglPos < sglSplitLimit Then + picSplitter.Left = sglSplitLimit + ElseIf sglPos > Me.Width - sglSplitLimit Then + picSplitter.Left = Me.Width - sglSplitLimit + Else + picSplitter.Left = sglPos + End If + End If +End Sub + + +Private Sub imgSplitter_MouseUp(Button As Integer, Shift As Integer, X As Single, Y As Single) + SizeControls picSplitter.Left + picSplitter.Visible = False + mbMoving = False +End Sub + + +Private Sub TreeView1_DragDrop(Source As Control, X As Single, Y As Single) + If Source = imgSplitter Then + SizeControls X + End If +End Sub + + +Sub SizeControls(X As Single) + On Error Resume Next + + 'set the width + If X < 1500 Then X = 1500 + If X > (Me.Width - 1500) Then X = Me.Width - 1500 + tvTreeView.Width = X + imgSplitter.Left = X + + Dim t_left, t_width As Integer + t_left = X + 40 + t_width = Me.Width - (tvTreeView.Width + 140) + + lblTitle(0).Width = tvTreeView.Width + lblTitle(1).Left = t_left + 20 + lblTitle(1).Width = t_width - 40 + + + 'set the top + If tbToolBar.Visible Then + tvTreeView.Top = tbToolBar.Height + picTitles.Height + Else + tvTreeView.Top = picTitles.Height + End If + + + 'set the height + If sbStatusBar.Visible Then + tvTreeView.Height = Me.ScaleHeight - (picTitles.Top + picTitles.Height + sbStatusBar.Height) + Else + tvTreeView.Height = Me.ScaleHeight - (picTitles.Top + picTitles.Height) + End If + + + imgSplitter.Top = tvTreeView.Top + imgSplitter.Height = tvTreeView.Height + + setListDimensions t_left, t_width, tvTreeView.Top, tvTreeView.Height +End Sub + +Private Sub setListView(ByVal f_View As Integer) + lvComputers.View = f_View + lvProcesses.View = f_View +End Sub + +Private Sub setListDimensions(ByVal f_Left As Integer, ByVal f_Width As Integer, ByVal f_Top As Integer, ByVal f_Height As Integer) + With lvComputers + .Left = f_Left + .Width = f_Width + .Top = f_Top + .Height = f_Height + End With + With lvProcesses + .Left = f_Left + .Width = f_Width + .Top = f_Top + .Height = f_Height + End With + With lvDatabases + .Left = f_Left + .Width = f_Width + .Top = f_Top + .Height = f_Height + End With +End Sub + +Private Sub tbToolBar_ButtonClick(ByVal Button As MSComctlLib.Button) + On Error Resume Next + Select Case Button.Key + Case "New database" + 'ToDo: Add 'Back' button code. + mnuPopNewDatabase_Click + Case "Add computer" + 'ToDo: Add 'Forward' button code. + frmNewComputer.Show vbModal, Me + Dim c As Computer + For Each c In frmNewComputer.m_hosts + addComputer c + g_computers.Add c, "_" & c.m_name + Next + Case "Properties" + mnuFileProperties_Click + End Select +End Sub + +Private Sub mnuHelpAbout_Click() + frmAbout.Show vbModal, Me +End Sub + +Private Sub mnuHelpSearchForHelpOn_Click() + Dim nRet As Integer + + + 'if there is no helpfile for this project display a message to the user + 'you can set the HelpFile for your application in the + 'Project Properties dialog + If Len(App.HelpFile) = 0 Then + MsgBox "Unable to display Help Contents. There is no Help associated with this project.", vbInformation, Me.Caption + Else + On Error Resume Next + nRet = OSWinHelp(Me.hwnd, App.HelpFile, 261, 0) + If Err Then + MsgBox Err.Description + End If + End If + +End Sub + +Private Sub mnuHelpContents_Click() + Dim nRet As Integer + + + 'if there is no helpfile for this project display a message to the user + 'you can set the HelpFile for your application in the + 'Project Properties dialog + If Len(App.HelpFile) = 0 Then + MsgBox "Unable to display Help Contents. There is no Help associated with this project.", vbInformation, Me.Caption + Else + On Error Resume Next + nRet = OSWinHelp(Me.hwnd, App.HelpFile, 3, 0) + If Err Then + MsgBox Err.Description + End If + End If + +End Sub + + +Private Sub mnuViewWebBrowser_Click() + 'ToDo: Add 'mnuViewWebBrowser_Click' code. + MsgBox "Add 'mnuViewWebBrowser_Click' code." +End Sub + +Private Sub mnuViewOptions_Click() + frmOptions.Show vbModal, Me +End Sub + +Private Sub mnuViewRefresh_Click() + 'ToDo: Add 'mnuViewRefresh_Click' code. + MsgBox "Add 'mnuViewRefresh_Click' code." +End Sub + + +Private Sub mnuViewStatusBar_Click() + mnuViewStatusBar.Checked = Not mnuViewStatusBar.Checked + sbStatusBar.Visible = mnuViewStatusBar.Checked + SizeControls imgSplitter.Left +End Sub + +Private Sub mnuViewToolbar_Click() + mnuViewToolbar.Checked = Not mnuViewToolbar.Checked + tbToolBar.Visible = mnuViewToolbar.Checked + SizeControls imgSplitter.Left +End Sub + +Private Sub mnuEditInvertSelection_Click() + 'ToDo: Add 'mnuEditInvertSelection_Click' code. + MsgBox "Add 'mnuEditInvertSelection_Click' code." +End Sub + +Private Sub mnuEditSelectAll_Click() + 'ToDo: Add 'mnuEditSelectAll_Click' code. + MsgBox "Add 'mnuEditSelectAll_Click' code." +End Sub + +Private Sub mnuEditPasteSpecial_Click() + 'ToDo: Add 'mnuEditPasteSpecial_Click' code. + MsgBox "Add 'mnuEditPasteSpecial_Click' code." +End Sub + +Private Sub mnuEditPaste_Click() + 'ToDo: Add 'mnuEditPaste_Click' code. + MsgBox "Add 'mnuEditPaste_Click' code." +End Sub + +Private Sub mnuEditCopy_Click() + 'ToDo: Add 'mnuEditCopy_Click' code. + MsgBox "Add 'mnuEditCopy_Click' code." +End Sub + +Private Sub mnuEditCut_Click() + 'ToDo: Add 'mnuEditCut_Click' code. + MsgBox "Add 'mnuEditCut_Click' code." +End Sub + +Private Sub mnuEditUndo_Click() + 'ToDo: Add 'mnuEditUndo_Click' code. + MsgBox "Add 'mnuEditUndo_Click' code." +End Sub + +Private Sub mnuFileClose_Click() + 'unload the form + Unload Me + +End Sub + +Private Sub mnuFileProperties_Click() + 'ToDo: Add 'mnuFileProperties_Click' code. + MsgBox "Add 'mnuFileProperties_Click' code." +End Sub + +Private Sub mnuFileRename_Click() + 'ToDo: Add 'mnuFileRename_Click' code. + MsgBox "Add 'mnuFileRename_Click' code." +End Sub + +Private Sub mnuFileDelete_Click() + 'ToDo: Add 'mnuFileDelete_Click' code. + MsgBox "Add 'mnuFileDelete_Click' code." +End Sub + +Private Sub mnuFileNew_Click() + 'ToDo: Add 'mnuFileNew_Click' code. + MsgBox "Add 'mnuFileNew_Click' code." +End Sub + +Private Sub mnuFileSendTo_Click() + 'ToDo: Add 'mnuFileSendTo_Click' code. + MsgBox "Add 'mnuFileSendTo_Click' code." +End Sub + +Private Sub mnuFileFind_Click() + 'ToDo: Add 'mnuFileFind_Click' code. + MsgBox "Add 'mnuFileFind_Click' code." +End Sub + +Private Sub mnuFileOpen_Click() + Dim sFile As String +End Sub + +Private Sub mnuPopComputerProperties_Click() + mnuFileProperties_Click +End Sub + +Private Sub mnuPopNewDatabase_Click() + frmNewDatabase1.Show vbModal, Me + frmNewDatabase2.Show vbModal, Me + frmNewDatabase3.Show vbModal, Me +End Sub + +Private Sub mnuPopAddComputer_Click() + frmNewComputer.Show vbModal, Me + Dim c As Computer + For Each c In frmNewComputer.m_hosts + addComputer c + g_computers.Add c, "_" & c.m_name + Next +End Sub + +Private Sub mnuPopSortComputers_Click() + If m_currentNode.Sorted = True Then + mnuPopSortComputers.Checked = False + m_currentNode.Sorted = False + Else + mnuPopSortComputers.Checked = True + m_currentNode.Sorted = True + End If +End Sub + +Private Sub mnuPopRemoveComputer_Click() + Dim res As VbMsgBoxResult + Dim str As String + str = "Remove computer " & m_currentComputer.m_name + res = MsgBox(str, vbOKCancel, str) + If res = vbOK Then + removeComputer (m_currentComputer.m_name) + End If +End Sub + +Private Sub mnuPopSortDatabases_Click() + If m_currentNode.Sorted = True Then + mnuPopSortDatabases.Checked = False + m_currentNode.Sorted = False + Else + mnuPopSortDatabases.Checked = True + m_currentNode.Sorted = True + End If +End Sub + +Private Sub tvTreeView_BeforeLabelEdit(Cancel As Integer) + Cancel = True +End Sub + +Private Sub tvTreeView_Collapse(ByVal Node As MSComctlLib.Node) + 'MsgBox "tvTreeView_Collapse" +End Sub + +Private Sub tvTreeView_Expand(ByVal Node As MSComctlLib.Node) + 'MsgBox "tvTreeView_Expand" +End Sub + +Private Sub tvTreeView_NodeClick(ByVal Node As MSComctlLib.Node) + selectNode Node +End Sub + +Private Sub tvTreeView_MouseUp(Button As Integer, Shift As Integer, X As Single, Y As Single) + 'MsgBox "tvTreeView_MouseUp Button: " & Button & " Shift: " & Shift + Dim Node As MSComctlLib.Node + Dim place As Integer + + Set Node = tvTreeView.HitTest(X, Y) + place = selectNode(Node) + If Button = vbRightButton Then + ShowPopup place + End If +End Sub + +Private Function selectNode(ByRef n As MSComctlLib.Node) As Integer + Dim list As ListView + Dim place As Integer + + If n Is Nothing Then + If Not m_currentNode Is Nothing Then + place = 1 + m_currentNode.Selected = False + Else + place = 2 + End If + Else + n.Selected = True + If n.Text = "Computers" Then + place = 3 + Set list = lvComputers + lblTitle(1).Caption = "Computers" + ElseIf n.Text = "Databases" Then + place = 4 + Set list = lvDatabases + lblTitle(1).Caption = "Databases" + ElseIf n.Parent.Text = "Computers" Then + place = 5 + Set list = lvProcesses + setComputer (n.Key) + ElseIf n.Parent.Text = "Databases" Then + place = 6 + Set list = lvProcesses + setDatabase (n.Key) + End If + + If m_currentList.hwnd <> list.hwnd Then + m_currentList.Visible = False + list.Visible = True + Set m_currentList = list + End If + End If + Set m_currentNode = n + selectNode = place +End Function + +Private Sub lvComputers_MouseUp(Button As Integer, Shift As Integer, X As Single, Y As Single) + Dim li As ListItem + Set li = lvComputers.HitTest(X, Y) + If Button = vbRightButton And Not li Is Nothing Then + Dim c As Computer + Set m_currentComputer = g_computers(li.Key) + ShowPopup 5 + End If +End Sub + +Private Sub ShowPopup(ByVal place As Integer) + Select Case place + Case 3 + PopupMenu mnuPopComputers + Case 4 + PopupMenu mnuPopDatabases + Case 5 + mnuPopComputerName.Caption = m_currentComputer.m_name & ": " & m_currentComputer.m_status + Select Case m_currentComputer.m_status + Case "Connected" + mnuPopConnectComputer.Enabled = False + mnuPopDisconnectComputer.Enabled = True + Case "Connecting" + mnuPopConnectComputer.Enabled = False + mnuPopDisconnectComputer.Enabled = True + Case "Not connected" + mnuPopConnectComputer.Enabled = True + mnuPopDisconnectComputer.Enabled = False + Case "No contact" + mnuPopConnectComputer.Enabled = True + mnuPopDisconnectComputer.Enabled = False + Case Else + mnuPopConnectComputer.Enabled = False + mnuPopDisconnectComputer.Enabled = False + End Select + + PopupMenu mnuPopComputer, , , , mnuPopComputerName + End Select +End Sub + +Private Sub lvComputers_BeforeLabelEdit(Cancel As Integer) + Cancel = True +End Sub + +Private Sub lvProcesses_BeforeLabelEdit(Cancel As Integer) + Cancel = True +End Sub + +Private Sub lvDatabases_BeforeLabelEdit(Cancel As Integer) + Cancel = True +End Sub + +Private Sub ColumnClick(ByRef list As ListView, i As Integer) + i = i - 1 + If list.SortKey = i Then + list.SortOrder = 1 - list.SortOrder + Else + list.SortKey = i + End If +End Sub + +Private Sub lvComputers_ColumnClick(ByVal ColumnHeader As MSComctlLib.ColumnHeader) + ColumnClick lvComputers, ColumnHeader.Index +End Sub + +Private Sub lvProcesses_ColumnClick(ByVal ColumnHeader As MSComctlLib.ColumnHeader) + ColumnClick lvProcesses, ColumnHeader.Index +End Sub + +Private Sub lvDatabases_ColumnClick(ByVal ColumnHeader As MSComctlLib.ColumnHeader) + ColumnClick lvDatabases, ColumnHeader.Index +End Sub + diff --git a/ndb/src/cw/cpcc-win32/vb6/frmNewComputer.frm b/ndb/src/cw/cpcc-win32/vb6/frmNewComputer.frm new file mode 100644 index 00000000000..eae5802493c --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/frmNewComputer.frm @@ -0,0 +1,124 @@ +VERSION 5.00 +Begin VB.Form frmNewComputer + Caption = "Add computer" + ClientHeight = 1545 + ClientLeft = 60 + ClientTop = 345 + ClientWidth = 4605 + LinkTopic = "Form1" + ScaleHeight = 1545 + ScaleWidth = 4605 + StartUpPosition = 3 'Windows Default + Begin VB.CommandButton Command3 + Caption = "Apply" + Default = -1 'True + Height = 360 + Left = 3240 + TabIndex = 4 + Tag = "OK" + Top = 840 + Width = 1140 + End + Begin VB.CommandButton Command2 + Caption = "Cancel" + Height = 360 + Left = 1920 + TabIndex = 3 + Tag = "OK" + Top = 840 + Width = 1140 + End + Begin VB.CommandButton Command1 + Caption = "OK" + Height = 360 + Left = 600 + TabIndex = 2 + Tag = "OK" + Top = 840 + Width = 1140 + End + Begin VB.TextBox Text1 + Height = 285 + Left = 1440 + TabIndex = 1 + Top = 240 + Width = 2925 + End + Begin VB.Label lblLabels + Caption = "Computer name:" + Height = 255 + Index = 1 + Left = 120 + TabIndex = 0 + Tag = "&User Name:" + Top = 240 + Width = 1440 + End +End +Attribute VB_Name = "frmNewComputer" +Attribute VB_GlobalNameSpace = False +Attribute VB_Creatable = False +Attribute VB_PredeclaredId = True +Attribute VB_Exposed = False +Public m_hosts As New Collection + +Private Sub Form_Load() + If m_hosts.Count > 0 Then + For i = m_hosts.Count To 1 Step -1 + m_hosts.Remove i + Next + End If +End Sub + +Private Sub Command1_Click() + If Text1.Text = "" Then + MsgBox "Invalid hostname" + Exit Sub + End If + + If Exists(g_computers, "_" & Text1.Text) Then + MsgBox Text1.Text & " already exists" + Exit Sub + End If + + Dim c As New Computer + With c + .m_ip = "" + .m_name = Text1.Text + .m_status = "Not connected" + Set .m_processes = New Collection + End With + + m_hosts.Add c + + Unload Me +End Sub + +Private Sub Command2_Click() + Unload Me +End Sub + +Private Sub Command3_Click() + If Text1.Text = "" Then + MsgBox "Invalid hostname" + Exit Sub + End If + + If Exists(g_computers, "_" & Text1.Text) Then + MsgBox Text1.Text & " already exists" + Exit Sub + End If + + Dim c As New Computer + With c + .m_ip = "" + .m_name = Text1.Text + .m_status = "Not connected" + Set .m_processes = New Collection + End With + + m_hosts.Add c + + Text1.Text = "" +End Sub + diff --git a/ndb/src/cw/cpcc-win32/vb6/frmNewComputer.frx b/ndb/src/cw/cpcc-win32/vb6/frmNewComputer.frx new file mode 100644 index 00000000000..593f4708db8 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/frmNewComputer.frx differ diff --git a/ndb/src/cw/cpcc-win32/vb6/frmNewDatabase.frx b/ndb/src/cw/cpcc-win32/vb6/frmNewDatabase.frx new file mode 100644 index 00000000000..b20c2b651ae Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/frmNewDatabase.frx differ diff --git a/ndb/src/cw/cpcc-win32/vb6/frmNewDatabase1.frm b/ndb/src/cw/cpcc-win32/vb6/frmNewDatabase1.frm new file mode 100644 index 00000000000..3fa1fd4c4e8 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/frmNewDatabase1.frm @@ -0,0 +1,187 @@ +VERSION 5.00 +Begin VB.Form frmNewDatabase1 + BorderStyle = 5 'Sizable ToolWindow + Caption = "Nodes" + ClientHeight = 3000 + ClientLeft = 2850 + ClientTop = 3450 + ClientWidth = 6240 + LinkTopic = "Form1" + MaxButton = 0 'False + MinButton = 0 'False + ScaleHeight = 3281.25 + ScaleMode = 0 'User + ScaleWidth = 6359.712 + ShowInTaskbar = 0 'False + StartUpPosition = 2 'CenterScreen + Begin VB.TextBox textApiNodes + Height = 285 + Left = 2760 + TabIndex = 12 + Text = "4" + Top = 1665 + Width = 375 + End + Begin VB.VScrollBar VScroll1 + Height = 255 + Left = 3240 + TabIndex = 11 + Top = 1680 + Width = 135 + End + Begin VB.OptionButton Option4 + Alignment = 1 'Right Justify + Caption = "1" + Height = 375 + Left = 2760 + TabIndex = 10 + Top = 1020 + Width = 375 + End + Begin VB.OptionButton Option3 + Alignment = 1 'Right Justify + Caption = "4" + Height = 375 + Left = 3960 + TabIndex = 9 + Top = 360 + Width = 375 + End + Begin VB.OptionButton Option2 + Alignment = 1 'Right Justify + Caption = "2" + Height = 375 + Left = 3360 + TabIndex = 8 + Top = 360 + Width = 375 + End + Begin VB.OptionButton Option1 + Alignment = 1 'Right Justify + Caption = "1" + Height = 375 + Left = 2760 + TabIndex = 7 + Top = 360 + Value = -1 'True + Width = 375 + End + Begin VB.CommandButton cmdCancel + Cancel = -1 'True + Caption = "Cancel" + Height = 305 + Left = 1320 + TabIndex = 3 + Top = 2400 + Width = 1140 + End + Begin VB.CommandButton cmdFinish + Caption = "Finish" + Enabled = 0 'False + Height = 305 + Left = 5040 + TabIndex = 2 + Top = 2400 + Width = 1140 + End + Begin VB.CommandButton cmdBack + Caption = "Back" + Default = -1 'True + Enabled = 0 'False + Height = 305 + Left = 2640 + TabIndex = 0 + Top = 2400 + Width = 1140 + End + Begin VB.CommandButton cmdNext + Caption = "Next" + Height = 305 + Left = 3720 + TabIndex = 1 + Top = 2400 + Width = 1140 + End + Begin VB.Label Label3 + Caption = "No of api nodes" + Height = 255 + Left = 240 + TabIndex = 6 + Top = 1680 + Width = 2415 + End + Begin VB.Label Label2 + Caption = "No of management nodes" + Height = 255 + Left = 240 + TabIndex = 5 + Top = 1080 + Width = 2415 + End + Begin VB.Label Label1 + Caption = "No of database nodes" + Height = 255 + Left = 240 + TabIndex = 4 + Top = 420 + Width = 2415 + End + Begin VB.Line Line1 + BorderColor = &H80000003& + X1 = 122.302 + X2 = 6237.41 + Y1 = 2493.75 + Y2 = 2493.75 + End +End +Attribute VB_Name = "frmNewDatabase1" +Attribute VB_GlobalNameSpace = False +Attribute VB_Creatable = False +Attribute VB_PredeclaredId = True +Attribute VB_Exposed = False +Option Explicit + +Private Sub Form_Resize() + If Me.Width < 6375 Then Me.Width = 6375 + cmdCancel.Left = Me.ScaleWidth - 5136 + 400 + cmdBack.Left = Me.ScaleWidth - 3897 + 400 + cmdNext.Left = Me.ScaleWidth - 2883 + 400 + cmdFinish.Left = Me.ScaleWidth - 1643 + 400 + Line1.X2 = Me.ScaleWidth - 480 + 400 + + cmdCancel.Top = Me.ScaleHeight - 375 + cmdBack.Top = Me.ScaleHeight - 375 + cmdNext.Top = Me.ScaleHeight - 375 + cmdFinish.Top = Me.ScaleHeight - 375 + Line1.Y1 = Me.ScaleHeight - 475 + Line1.Y2 = Me.ScaleHeight - 475 +End Sub + +Private Sub cmdCancel_Click() + 'set the global var to false + 'to denote a failed login + Unload Me +End Sub + +Private Sub Option1_Click() + Option2.Value = False + Option3.Value = False +End Sub + +Private Sub Option2_Click() + Option1.Value = False + Option3.Value = False +End Sub + +Private Sub Option3_Click() + Option1.Value = False + Option2.Value = False +End Sub + +Private Sub Option4_Click() + Option4.Value = True +End Sub + +Private Sub textApiNodes_Validate(Cancel As Boolean) + 'If Not isnumber(textApiNodes.Text) Then Cancel = False +End Sub diff --git a/ndb/src/cw/cpcc-win32/vb6/frmNewDatabase2.frm b/ndb/src/cw/cpcc-win32/vb6/frmNewDatabase2.frm new file mode 100644 index 00000000000..49806a695ea --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/frmNewDatabase2.frm @@ -0,0 +1,136 @@ +VERSION 5.00 +Begin VB.Form frmNewDatabase2 + BorderStyle = 5 'Sizable ToolWindow + Caption = "Computers" + ClientHeight = 2895 + ClientLeft = 2850 + ClientTop = 3450 + ClientWidth = 6240 + LinkTopic = "Form1" + MaxButton = 0 'False + MinButton = 0 'False + ScaleHeight = 3166.406 + ScaleMode = 0 'User + ScaleWidth = 6359.712 + ShowInTaskbar = 0 'False + StartUpPosition = 2 'CenterScreen + Begin VB.ComboBox Combo1 + Height = 315 + Left = 2400 + TabIndex = 7 + Text = "Combo1" + Top = 360 + Width = 1455 + End + Begin VB.VScrollBar VScroll2 + Height = 255 + Left = 4560 + TabIndex = 6 + Top = 375 + Width = 135 + End + Begin VB.TextBox Text1 + Height = 285 + Left = 4080 + TabIndex = 5 + Text = "4" + Top = 360 + Width = 375 + End + Begin VB.CommandButton cmdCancel + Cancel = -1 'True + Caption = "Cancel" + Height = 305 + Left = 1320 + TabIndex = 3 + Top = 2400 + Width = 1140 + End + Begin VB.CommandButton cmdFinish + Caption = "Finish" + Enabled = 0 'False + Height = 305 + Left = 5040 + TabIndex = 2 + Top = 2400 + Width = 1140 + End + Begin VB.CommandButton cmdBack + Caption = "Back" + Default = -1 'True + Enabled = 0 'False + Height = 305 + Left = 2640 + TabIndex = 0 + Top = 2400 + Width = 1140 + End + Begin VB.CommandButton cmdNext + Caption = "Next" + Height = 305 + Left = 3720 + TabIndex = 1 + Top = 2400 + Width = 1140 + End + Begin VB.Label Label5 + Caption = "Computer" + Height = 255 + Left = 2400 + TabIndex = 9 + Top = 0 + Width = 975 + End + Begin VB.Label Label4 + Caption = "Node id" + Height = 255 + Left = 4080 + TabIndex = 8 + Top = 120 + Width = 615 + End + Begin VB.Label Label1 + Caption = "Database node 1" + Height = 255 + Left = 240 + TabIndex = 4 + Top = 420 + Width = 2415 + End + Begin VB.Line Line1 + BorderColor = &H80000003& + X1 = 122.302 + X2 = 6237.41 + Y1 = 2493.75 + Y2 = 2493.75 + End +End +Attribute VB_Name = "frmNewDatabase2" +Attribute VB_GlobalNameSpace = False +Attribute VB_Creatable = False +Attribute VB_PredeclaredId = True +Attribute VB_Exposed = False +Option Explicit + +Private Sub Form_Resize() + If Me.Width < 6375 Then Me.Width = 6375 + cmdCancel.Left = Me.ScaleWidth - 5136 + 400 + cmdBack.Left = Me.ScaleWidth - 3897 + 400 + cmdNext.Left = Me.ScaleWidth - 2883 + 400 + cmdFinish.Left = Me.ScaleWidth - 1643 + 400 + Line1.X2 = Me.ScaleWidth - 480 + 400 + + cmdCancel.Top = Me.ScaleHeight - 375 + cmdBack.Top = Me.ScaleHeight - 375 + cmdNext.Top = Me.ScaleHeight - 375 + cmdFinish.Top = Me.ScaleHeight - 375 + Line1.Y1 = Me.ScaleHeight - 475 + Line1.Y2 = Me.ScaleHeight - 475 +End Sub + +Private Sub cmdCancel_Click() + 'set the global var to false + 'to denote a failed login + Unload Me +End Sub + diff --git a/ndb/src/cw/cpcc-win32/vb6/frmNewDatabase2.log b/ndb/src/cw/cpcc-win32/vb6/frmNewDatabase2.log new file mode 100644 index 00000000000..808b21866e5 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/frmNewDatabase2.log @@ -0,0 +1 @@ +Line 2: The Form or MDIForm name frmNewDatabase1 is already in use; cannot load this form. diff --git a/ndb/src/cw/cpcc-win32/vb6/frmNewDatabase3.frm b/ndb/src/cw/cpcc-win32/vb6/frmNewDatabase3.frm new file mode 100644 index 00000000000..ba050a58a09 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/frmNewDatabase3.frm @@ -0,0 +1,88 @@ +VERSION 5.00 +Begin VB.Form frmNewDatabase3 + BorderStyle = 5 'Sizable ToolWindow + Caption = "Database configuration" + ClientHeight = 3000 + ClientLeft = 2850 + ClientTop = 3450 + ClientWidth = 6240 + LinkTopic = "Form1" + MaxButton = 0 'False + MinButton = 0 'False + ScaleHeight = 3281.25 + ScaleMode = 0 'User + ScaleWidth = 6359.712 + ShowInTaskbar = 0 'False + StartUpPosition = 2 'CenterScreen + Begin VB.CommandButton cmdCancel + Cancel = -1 'True + Caption = "Cancel" + Height = 305 + Left = 1320 + TabIndex = 3 + Top = 2400 + Width = 1140 + End + Begin VB.CommandButton cmdFinish + Caption = "Finish" + Enabled = 0 'False + Height = 305 + Left = 5040 + TabIndex = 2 + Top = 2400 + Width = 1140 + End + Begin VB.CommandButton cmdBack + Caption = "Back" + Default = -1 'True + Enabled = 0 'False + Height = 305 + Left = 2640 + TabIndex = 0 + Top = 2400 + Width = 1140 + End + Begin VB.CommandButton cmdNext + Caption = "Next" + Height = 305 + Left = 3720 + TabIndex = 1 + Top = 2400 + Width = 1140 + End + Begin VB.Line Line1 + BorderColor = &H80000003& + X1 = 122.302 + X2 = 6237.41 + Y1 = 2493.75 + Y2 = 2493.75 + End +End +Attribute VB_Name = "frmNewDatabase3" +Attribute VB_GlobalNameSpace = False +Attribute VB_Creatable = False +Attribute VB_PredeclaredId = True +Attribute VB_Exposed = False +Option Explicit + +Private Sub Form_Resize() + If Me.Width < 6375 Then Me.Width = 6375 + cmdCancel.Left = Me.ScaleWidth - 5136 + 400 + cmdBack.Left = Me.ScaleWidth - 3897 + 400 + cmdNext.Left = Me.ScaleWidth - 2883 + 400 + cmdFinish.Left = Me.ScaleWidth - 1643 + 400 + Line1.X2 = Me.ScaleWidth - 480 + 400 + + cmdCancel.Top = Me.ScaleHeight - 375 + cmdBack.Top = Me.ScaleHeight - 375 + cmdNext.Top = Me.ScaleHeight - 375 + cmdFinish.Top = Me.ScaleHeight - 375 + Line1.Y1 = Me.ScaleHeight - 475 + Line1.Y2 = Me.ScaleHeight - 475 +End Sub + +Private Sub cmdCancel_Click() + 'set the global var to false + 'to denote a failed login + Unload Me +End Sub diff --git a/ndb/src/cw/cpcc-win32/vb6/frmOptions.frm b/ndb/src/cw/cpcc-win32/vb6/frmOptions.frm new file mode 100644 index 00000000000..e526a35b3ec --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/frmOptions.frm @@ -0,0 +1,231 @@ +VERSION 5.00 +Object = "{831FDD16-0C5C-11D2-A9FC-0000F8754DA1}#2.0#0"; "mscomctl.ocx" +Begin VB.Form frmOptions + BorderStyle = 3 'Fixed Dialog + Caption = "Options" + ClientHeight = 5040 + ClientLeft = 6600 + ClientTop = 4575 + ClientWidth = 6150 + KeyPreview = -1 'True + LinkTopic = "Form1" + MaxButton = 0 'False + MinButton = 0 'False + ScaleHeight = 5040 + ScaleWidth = 6150 + ShowInTaskbar = 0 'False + Tag = "Options" + Begin VB.CommandButton cmdOK + Caption = "OK" + Height = 375 + Left = 2490 + TabIndex = 1 + Tag = "OK" + Top = 4455 + Width = 1095 + End + Begin VB.CommandButton cmdCancel + Cancel = -1 'True + Caption = "Cancel" + Height = 375 + Left = 3720 + TabIndex = 3 + Tag = "Cancel" + Top = 4455 + Width = 1095 + End + Begin VB.CommandButton cmdApply + Caption = "&Apply" + Height = 375 + Left = 4920 + TabIndex = 5 + Tag = "&Apply" + Top = 4455 + Width = 1095 + End + Begin VB.PictureBox picOptions + BorderStyle = 0 'None + Height = 3780 + Index = 3 + Left = -20000 + ScaleHeight = 3840.968 + ScaleMode = 0 'User + ScaleWidth = 5745.64 + TabIndex = 7 + TabStop = 0 'False + Top = 480 + Width = 5685 + Begin VB.Frame fraSample4 + Caption = "Sample 4" + Height = 2022 + Left = 505 + TabIndex = 11 + Tag = "Sample 4" + Top = 502 + Width = 2033 + End + End + Begin VB.PictureBox picOptions + BorderStyle = 0 'None + Height = 3780 + Index = 2 + Left = -20000 + ScaleHeight = 3840.968 + ScaleMode = 0 'User + ScaleWidth = 5745.64 + TabIndex = 9 + TabStop = 0 'False + Top = 480 + Width = 5685 + Begin VB.Frame fraSample3 + Caption = "Sample 3" + Height = 2022 + Left = 406 + TabIndex = 10 + Tag = "Sample 3" + Top = 403 + Width = 2033 + End + End + Begin VB.PictureBox picOptions + BorderStyle = 0 'None + Height = 3780 + Index = 1 + Left = -20000 + ScaleHeight = 3840.968 + ScaleMode = 0 'User + ScaleWidth = 5745.64 + TabIndex = 6 + TabStop = 0 'False + Top = 480 + Width = 5685 + Begin VB.Frame fraSample2 + Caption = "Sample 2" + Height = 2022 + Left = 307 + TabIndex = 8 + Tag = "Sample 2" + Top = 305 + Width = 2033 + End + End + Begin VB.PictureBox picOptions + BorderStyle = 0 'None + Height = 3780 + Index = 0 + Left = 210 + ScaleHeight = 3840.968 + ScaleMode = 0 'User + ScaleWidth = 5745.64 + TabIndex = 2 + TabStop = 0 'False + Top = 480 + Width = 5685 + Begin VB.Frame fraSample1 + Caption = "Sample 1" + Height = 2022 + Left = 208 + TabIndex = 4 + Tag = "Sample 1" + Top = 207 + Width = 2033 + End + End + Begin MSComctlLib.TabStrip tbsOptions + Height = 4245 + Left = 105 + TabIndex = 0 + Top = 120 + Width = 5895 + _ExtentX = 10398 + _ExtentY = 7488 + _Version = 393216 + BeginProperty Tabs {1EFB6598-857C-11D1-B16A-00C0F0283628} + NumTabs = 4 + BeginProperty Tab1 {1EFB659A-857C-11D1-B16A-00C0F0283628} + Caption = "Group 1" + ImageVarType = 2 + EndProperty + BeginProperty Tab2 {1EFB659A-857C-11D1-B16A-00C0F0283628} + Caption = "Group 2" + ImageVarType = 2 + EndProperty + BeginProperty Tab3 {1EFB659A-857C-11D1-B16A-00C0F0283628} + Caption = "Group 3" + ImageVarType = 2 + EndProperty + BeginProperty Tab4 {1EFB659A-857C-11D1-B16A-00C0F0283628} + Caption = "Group 4" + ImageVarType = 2 + EndProperty + EndProperty + End +End +Attribute VB_Name = "frmOptions" +Attribute VB_GlobalNameSpace = False +Attribute VB_Creatable = False +Attribute VB_PredeclaredId = True +Attribute VB_Exposed = False +Private Sub cmdApply_Click() + 'ToDo: Add 'cmdApply_Click' code. + MsgBox "Apply Code goes here to set options w/o closing dialog!" +End Sub + + +Private Sub cmdCancel_Click() + Unload Me +End Sub + + +Private Sub cmdOK_Click() + 'ToDo: Add 'cmdOK_Click' code. + MsgBox "Code goes here to set options and close dialog!" + Unload Me +End Sub + + +Private Sub Form_KeyDown(KeyCode As Integer, Shift As Integer) + Dim i As Integer + i = tbsOptions.SelectedItem.Index + 'handle ctrl+tab to move to the next tab + If (Shift And 3) = 2 And KeyCode = vbKeyTab Then + If i = tbsOptions.Tabs.Count Then + 'last tab so we need to wrap to tab 1 + Set tbsOptions.SelectedItem = tbsOptions.Tabs(1) + Else + 'increment the tab + Set tbsOptions.SelectedItem = tbsOptions.Tabs(i + 1) + End If + ElseIf (Shift And 3) = 3 And KeyCode = vbKeyTab Then + If i = 1 Then + 'last tab so we need to wrap to tab 1 + Set tbsOptions.SelectedItem = tbsOptions.Tabs(tbsOptions.Tabs.Count) + Else + 'increment the tab + Set tbsOptions.SelectedItem = tbsOptions.Tabs(i - 1) + End If + End If +End Sub + + + + +Private Sub tbsOptions_Click() + + + Dim i As Integer + 'show and enable the selected tab's controls + 'and hide and disable all others + For i = 0 To tbsOptions.Tabs.Count - 1 + If i = tbsOptions.SelectedItem.Index - 1 Then + picOptions(i).Left = 210 + picOptions(i).Enabled = True + Else + picOptions(i).Left = -20000 + picOptions(i).Enabled = False + End If + Next + + +End Sub + diff --git a/ndb/src/cw/cpcc-win32/vb6/frmSplash.frm b/ndb/src/cw/cpcc-win32/vb6/frmSplash.frm new file mode 100644 index 00000000000..56ccbd79876 --- /dev/null +++ b/ndb/src/cw/cpcc-win32/vb6/frmSplash.frm @@ -0,0 +1,159 @@ +VERSION 5.00 +Begin VB.Form frmSplash + BorderStyle = 3 'Fixed Dialog + ClientHeight = 4710 + ClientLeft = 45 + ClientTop = 45 + ClientWidth = 7455 + ControlBox = 0 'False + LinkTopic = "Form1" + MaxButton = 0 'False + MinButton = 0 'False + ScaleHeight = 4710 + ScaleWidth = 7455 + ShowInTaskbar = 0 'False + StartUpPosition = 2 'CenterScreen + Visible = 0 'False + Begin VB.Frame fraMainFrame + Height = 4590 + Left = 45 + TabIndex = 0 + Top = -15 + Width = 7380 + Begin VB.PictureBox picLogo + Height = 2385 + Left = 510 + Picture = "frmSplash.frx":0000 + ScaleHeight = 2325 + ScaleWidth = 1755 + TabIndex = 2 + Top = 855 + Width = 1815 + End + Begin VB.Label lblLicenseTo + Alignment = 1 'Right Justify + Caption = "LicenseTo" + Height = 255 + Left = 270 + TabIndex = 1 + Tag = "LicenseTo" + Top = 300 + Width = 6855 + End + Begin VB.Label lblProductName + AutoSize = -1 'True + Caption = "Product" + BeginProperty Font + Name = "MS Sans Serif" + Size = 29.25 + Charset = 0 + Weight = 700 + Underline = 0 'False + Italic = 0 'False + Strikethrough = 0 'False + EndProperty + Height = 720 + Left = 2670 + TabIndex = 9 + Tag = "Product" + Top = 1200 + Width = 2190 + End + Begin VB.Label lblCompanyProduct + AutoSize = -1 'True + Caption = "CompanyProduct" + BeginProperty Font + Name = "MS Sans Serif" + Size = 18 + Charset = 0 + Weight = 700 + Underline = 0 'False + Italic = 0 'False + Strikethrough = 0 'False + EndProperty + Height = 435 + Left = 2505 + TabIndex = 8 + Tag = "CompanyProduct" + Top = 765 + Width = 3000 + End + Begin VB.Label lblPlatform + Alignment = 1 'Right Justify + AutoSize = -1 'True + Caption = "Platform" + BeginProperty Font + Name = "MS Sans Serif" + Size = 13.5 + Charset = 0 + Weight = 700 + Underline = 0 'False + Italic = 0 'False + Strikethrough = 0 'False + EndProperty + Height = 360 + Left = 5865 + TabIndex = 7 + Tag = "Platform" + Top = 2400 + Width = 1140 + End + Begin VB.Label lblVersion + Alignment = 1 'Right Justify + AutoSize = -1 'True + Caption = "Version" + BeginProperty Font + Name = "MS Sans Serif" + Size = 12 + Charset = 0 + Weight = 700 + Underline = 0 'False + Italic = 0 'False + Strikethrough = 0 'False + EndProperty + Height = 300 + Left = 6075 + TabIndex = 6 + Tag = "Version" + Top = 2760 + Width = 930 + End + Begin VB.Label lblWarning + Caption = "Warning" + Height = 195 + Left = 300 + TabIndex = 3 + Tag = "Warning" + Top = 3720 + Width = 6855 + End + Begin VB.Label lblCompany + Caption = "Company" + Height = 255 + Left = 4710 + TabIndex = 5 + Tag = "Company" + Top = 3330 + Width = 2415 + End + Begin VB.Label lblCopyright + Caption = "Copyright" + Height = 255 + Left = 4710 + TabIndex = 4 + Tag = "Copyright" + Top = 3120 + Width = 2415 + End + End +End +Attribute VB_Name = "frmSplash" +Attribute VB_GlobalNameSpace = False +Attribute VB_Creatable = False +Attribute VB_PredeclaredId = True +Attribute VB_Exposed = False +Private Sub Form_Load() + lblVersion.Caption = "Version " & App.Major & "." & App.Minor & "." & App.Revision + lblProductName.Caption = App.Title +End Sub + diff --git a/ndb/src/cw/cpcc-win32/vb6/frmSplash.frx b/ndb/src/cw/cpcc-win32/vb6/frmSplash.frx new file mode 100644 index 00000000000..fee0c5c59de Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/frmSplash.frx differ diff --git a/ndb/src/cw/cpcc-win32/vb6/networking.ico b/ndb/src/cw/cpcc-win32/vb6/networking.ico new file mode 100644 index 00000000000..6bbf8022fc6 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/networking.ico differ diff --git a/ndb/src/cw/cpcc-win32/vb6/open folder.ico b/ndb/src/cw/cpcc-win32/vb6/open folder.ico new file mode 100644 index 00000000000..7bb32cc83d3 Binary files /dev/null and b/ndb/src/cw/cpcc-win32/vb6/open folder.ico differ diff --git a/ndb/src/cw/cpcd/APIService.cpp b/ndb/src/cw/cpcd/APIService.cpp new file mode 100644 index 00000000000..9cf17addcc2 --- /dev/null +++ b/ndb/src/cw/cpcd/APIService.cpp @@ -0,0 +1,385 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include +#include + +#include "APIService.hpp" +#include "CPCD.hpp" +#include +#include +#include + +/** + const char * name; + const char * realName; + const Type type; + const ArgType argType; + const ArgRequired argRequired; + const ArgMinMax argMinMax; + const int minVal; + const int maxVal; + void (T::* function)(const class Properties & args); + const char * description; +*/ + +#define CPCD_CMD(name, fun, desc) \ + { name, \ + 0, \ + ParserRow::Cmd, \ + ParserRow::String, \ + ParserRow::Optional, \ + ParserRow::IgnoreMinMax, \ + 0, 0, \ + fun, \ + desc } + +#define CPCD_ARG(name, type, opt, desc) \ + { name, \ + 0, \ + ParserRow::Arg, \ + ParserRow::type, \ + ParserRow::opt, \ + ParserRow::IgnoreMinMax, \ + 0, 0, \ + 0, \ + desc } + +#define CPCD_ARG2(name, type, opt, min, max, desc) \ + { name, \ + 0, \ + ParserRow::Arg, \ + ParserRow::type, \ + ParserRow::opt, \ + ParserRow::IgnoreMinMax, \ + min, max, \ + 0, \ + desc } + +#define CPCD_END() \ + { 0, \ + 0, \ + ParserRow::Arg, \ + ParserRow::Int, \ + ParserRow::Optional, \ + ParserRow::IgnoreMinMax, \ + 0, 0, \ + 0, \ + 0 } + +#define CPCD_CMD_ALIAS(name, realName, fun) \ + { name, \ + realName, \ + ParserRow::CmdAlias, \ + ParserRow::Int, \ + ParserRow::Optional, \ + ParserRow::IgnoreMinMax, \ + 0, 0, \ + 0, \ + 0 } + +#define CPCD_ARG_ALIAS(name, realName, fun) \ + { name, \ + realName, \ + ParserRow::ArgAlias, \ + ParserRow::Int, \ + ParserRow::Optional, \ + ParserRow::IgnoreMinMax, \ + 0, 0, \ + 0, \ + 0 } + +const +ParserRow commands[] = +{ + CPCD_CMD("define process" , &CPCDAPISession::defineProcess, ""), + CPCD_ARG("id", Int, Optional, "Id of process."), + CPCD_ARG("name", String, Mandatory, "Name of process"), + CPCD_ARG("group", String, Mandatory, "Group of process"), + CPCD_ARG("env", String, Optional, "Environment variables for process"), + CPCD_ARG("path", String, Mandatory, "Path to binary"), + CPCD_ARG("args", String, Optional, "Arguments to process"), + CPCD_ARG("type", String, Mandatory, "Type of process"), + CPCD_ARG("cwd", String, Mandatory, "Working directory of process"), + CPCD_ARG("owner", String, Mandatory, "Owner of process"), + CPCD_ARG("runas", String, Optional, "Run as user"), + CPCD_ARG("stdout", String, Optional, "Redirection of stdout"), + CPCD_ARG("stderr", String, Optional, "Redirection of stderr"), + CPCD_ARG("stdin", String, Optional, "Redirection of stderr"), + CPCD_ARG("ulimit", String, Optional, "ulimit"), + + CPCD_CMD("undefine process", &CPCDAPISession::undefineProcess, ""), + CPCD_CMD_ALIAS("undef", "undefine process", 0), + CPCD_ARG("id", Int, Mandatory, "Id of process"), + CPCD_ARG_ALIAS("i", "id", 0), + + CPCD_CMD("start process", &CPCDAPISession::startProcess, ""), + CPCD_ARG("id", Int, Mandatory, "Id of process"), + + CPCD_CMD("stop process", &CPCDAPISession::stopProcess, ""), + CPCD_ARG("id", Int, Mandatory, "Id of process"), + + CPCD_CMD("list processes", &CPCDAPISession::listProcesses, ""), + + CPCD_END() +}; +CPCDAPISession::CPCDAPISession(NDB_SOCKET_TYPE sock, + CPCD & cpcd) + : SocketServer::Session(sock) + , m_cpcd(cpcd) +{ + m_input = new SocketInputStream(sock); + m_output = new SocketOutputStream(sock); + m_parser = new Parser(commands, *m_input, true, true, true); +} + +CPCDAPISession::CPCDAPISession(FILE * f, CPCD & cpcd) + : SocketServer::Session(1) + , m_cpcd(cpcd) +{ + m_input = new FileInputStream(f); + m_parser = new Parser(commands, *m_input, true, true, true); +} + +CPCDAPISession::~CPCDAPISession() { + delete m_input; + delete m_parser; +} + +void +CPCDAPISession::runSession(){ + Parser_t::Context ctx; + while(!m_stop){ + m_parser->run(ctx, * this); + if(ctx.m_currentToken == 0) + break; + + switch(ctx.m_status){ + case Parser_t::Ok: + for(size_t i = 0; i %s", + ctx.m_aliasUsed[i]->name, ctx.m_aliasUsed[i]->realName); + break; + case Parser_t::NoLine: + case Parser_t::EmptyLine: + break; + default: + break; + } + } + NDB_CLOSE_SOCKET(m_socket); +} + +void +CPCDAPISession::stopSession(){ + CPCD::RequestStatus rs; + for(size_t i = 0; irun(ctx, * this); + if(ctx.m_currentToken == 0) + break; + + switch(ctx.m_status){ + case Parser_t::Ok: + for(size_t i = 0; i %s", + ctx.m_aliasUsed[i]->name, ctx.m_aliasUsed[i]->realName); + break; + case Parser_t::NoLine: + case Parser_t::EmptyLine: + break; + default: + break; + } + } +} + +static const int g_TimeOut = 1000; + +void +CPCDAPISession::defineProcess(Parser_t::Context & /* unused */, + const class Properties & args){ + + CPCD::Process * p = new CPCD::Process(args, &m_cpcd); + + CPCD::RequestStatus rs; + + bool ret = m_cpcd.defineProcess(&rs, p); + if(!m_cpcd.loadingProcessList) { + m_output->println("define process"); + m_output->println("status: %d", rs.getStatus()); + if(ret == true){ + m_output->println("id: %d", p->m_id); + if(p->m_processType == TEMPORARY){ + m_temporaryProcesses.push_back(p->m_id); + } + } else { + m_output->println("errormessage: %s", rs.getErrMsg()); + } + m_output->println(""); + } +} + +void +CPCDAPISession::undefineProcess(Parser_t::Context & /* unused */, + const class Properties & args){ + Uint32 id; + CPCD::RequestStatus rs; + + args.get("id", &id); + bool ret = m_cpcd.undefineProcess(&rs, id); + + m_output->println("undefine process"); + m_output->println("id: %d", id); + m_output->println("status: %d", rs.getStatus()); + if(!ret) + m_output->println("errormessage: %s", rs.getErrMsg()); + + m_output->println(""); +} + +void +CPCDAPISession::startProcess(Parser_t::Context & /* unused */, + const class Properties & args){ + Uint32 id; + CPCD::RequestStatus rs; + + args.get("id", &id); + const int ret = m_cpcd.startProcess(&rs, id); + + if(!m_cpcd.loadingProcessList) { + m_output->println("start process"); + m_output->println("id: %d", id); + m_output->println("status: %d", rs.getStatus()); + if(!ret) + m_output->println("errormessage: %s", rs.getErrMsg()); + m_output->println(""); + } +} + +void +CPCDAPISession::stopProcess(Parser_t::Context & /* unused */, + const class Properties & args){ + Uint32 id; + CPCD::RequestStatus rs; + + args.get("id", &id); + int ret = m_cpcd.stopProcess(&rs, id); + + m_output->println("stop process"); + m_output->println("id: %d", id); + m_output->println("status: %d", rs.getStatus()); + if(!ret) + m_output->println("errormessage: %s", rs.getErrMsg()); + + m_output->println(""); +} + +static const char * +propToString(Properties *prop, const char *key) { + static char buf[32]; + const char *retval = NULL; + PropertiesType pt; + + prop->getTypeOf(key, &pt); + switch(pt) { + case PropertiesType_Uint32: + Uint32 val; + prop->get(key, &val); + snprintf(buf, sizeof buf, "%d", val); + retval = buf; + break; + case PropertiesType_char: + const char *str; + prop->get(key, &str); + retval = str; + break; + default: + snprintf(buf, sizeof buf, "(unknown)"); + retval = buf; + } + return retval; +} + +void +CPCDAPISession::printProperty(Properties *prop, const char *key) { + m_output->println("%s: %s", key, propToString(prop, key)); +} + +void +CPCDAPISession::listProcesses(Parser_t::Context & /* unused */, + const class Properties & /* unused */){ + m_cpcd.m_processes.lock(); + MutexVector *proclist = m_cpcd.getProcessList(); + + m_output->println("start processes"); + m_output->println(""); + + + for(size_t i = 0; i < proclist->size(); i++) { + CPCD::Process *p = (*proclist)[i]; + + m_output->println("process"); + + m_output->println("id: %d", p->m_id); + m_output->println("name: %s", p->m_name.c_str()); + m_output->println("path: %s", p->m_path.c_str()); + m_output->println("args: %s", p->m_args.c_str()); + m_output->println("type: %s", p->m_type.c_str()); + m_output->println("cwd: %s", p->m_cwd.c_str()); + m_output->println("env: %s", p->m_env.c_str()); + m_output->println("owner: %s", p->m_owner.c_str()); + m_output->println("group: %s", p->m_group.c_str()); + m_output->println("runas: %s", p->m_runas.c_str()); + m_output->println("stdin: %s", p->m_stdin.c_str()); + m_output->println("stdout: %s", p->m_stdout.c_str()); + m_output->println("stderr: %s", p->m_stderr.c_str()); + m_output->println("ulimit: %s", p->m_ulimit.c_str()); + switch(p->m_status){ + case STOPPED: + m_output->println("status: stopped"); + break; + case STARTING: + m_output->println("status: starting"); + break; + case RUNNING: + m_output->println("status: running"); + break; + case STOPPING: + m_output->println("status: stopping"); + break; + } + + m_output->println(""); + + } + + m_output->println("end processes"); + m_output->println(""); + + m_cpcd.m_processes.unlock(); +} diff --git a/ndb/src/cw/cpcd/APIService.hpp b/ndb/src/cw/cpcd/APIService.hpp new file mode 100644 index 00000000000..ef988785f89 --- /dev/null +++ b/ndb/src/cw/cpcd/APIService.hpp @@ -0,0 +1,64 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CPCD_API_HPP +#define CPCD_API_HPP + +#include +#include +#include + +class CPCD; + +class CPCDAPISession : public SocketServer::Session { + typedef Parser Parser_t; + + class CPCD & m_cpcd; + InputStream *m_input; + OutputStream *m_output; + Parser_t *m_parser; + + Vector m_temporaryProcesses; + + void printProperty(Properties *prop, const char *key); +public: + CPCDAPISession(NDB_SOCKET_TYPE, class CPCD &); + CPCDAPISession(FILE * f, CPCD & cpcd); + ~CPCDAPISession(); + + virtual void runSession(); + virtual void stopSession(); + void loadFile(); + + void defineProcess(Parser_t::Context & ctx, const class Properties & args); + void undefineProcess(Parser_t::Context & ctx, const class Properties & args); + void startProcess(Parser_t::Context & ctx, const class Properties & args); + void stopProcess(Parser_t::Context & ctx, const class Properties & args); + void showProcess(Parser_t::Context & ctx, const class Properties & args); + void listProcesses(Parser_t::Context & ctx, const class Properties & args); +}; + +class CPCDAPIService : public SocketServer::Service { + class CPCD & m_cpcd; +public: + CPCDAPIService(class CPCD & cpcd) : m_cpcd(cpcd) {} + + CPCDAPISession * newSession(NDB_SOCKET_TYPE theSock){ + return new CPCDAPISession(theSock, m_cpcd); + } +}; + +#endif diff --git a/ndb/src/cw/cpcd/CPCD.cpp b/ndb/src/cw/cpcd/CPCD.cpp new file mode 100644 index 00000000000..8864ccf6e4e --- /dev/null +++ b/ndb/src/cw/cpcd/CPCD.cpp @@ -0,0 +1,435 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include +#include +#include + +#include "APIService.hpp" +#include "CPCD.hpp" +#include + +#include "common.hpp" + +extern const ParserRow commands[]; + + +CPCD::CPCD() { + loadingProcessList = false; + m_processes.clear(); + m_monitor = NULL; + m_monitor = new Monitor(this); + m_procfile = "ndb_cpcd.db"; +} + +CPCD::~CPCD() { + if(m_monitor != NULL) { + delete m_monitor; + m_monitor = NULL; + } +} + +int +CPCD::findUniqueId() { + int id; + bool ok = false; + m_processes.lock(); + + while(!ok) { + ok = true; + id = random() % 8192; /* Don't want so big numbers */ + + if(id == 0) + ok = false; + + for(size_t i = 0; im_id == id) + ok = false; + } + } + m_processes.unlock(); + return id; +} + +bool +CPCD::defineProcess(RequestStatus * rs, Process * arg){ + if(arg->m_id == -1) + arg->m_id = findUniqueId(); + + Guard tmp(m_processes); + + for(size_t i = 0; im_name.c_str(), proc->m_name.c_str()) == 0) && + (strcmp(arg->m_group.c_str(), proc->m_group.c_str()) == 0)) { + /* Identical names in the same group */ + rs->err(AlreadyExists, "Name already exists"); + return false; + } + + if(arg->m_id == proc->m_id) { + /* Identical ID numbers */ + rs->err(AlreadyExists, "Id already exists"); + return false; + } + } + + m_processes.push_back(arg, false); + + notifyChanges(); + report(arg->m_id, CPCEvent::ET_PROC_USER_DEFINE); + + return true; +} + +bool +CPCD::undefineProcess(CPCD::RequestStatus *rs, int id) { + + Guard tmp(m_processes); + + Process * proc = 0; + size_t i; + for(i = 0; i < m_processes.size(); i++) { + if(m_processes[i]->m_id == id) { + proc = m_processes[i]; + break; + } + } + + if(proc == 0){ + rs->err(NotExists, "No such process"); + return false; + } + + switch(proc->m_status){ + case RUNNING: + case STOPPED: + case STOPPING: + case STARTING: + proc->stop(); + m_processes.erase(i, false /* Already locked */); + } + + + notifyChanges(); + + report(id, CPCEvent::ET_PROC_USER_UNDEFINE); + + return true; +} + +bool +CPCD::startProcess(CPCD::RequestStatus *rs, int id) { + + Process * proc = 0; + { + + Guard tmp(m_processes); + + for(size_t i = 0; i < m_processes.size(); i++) { + if(m_processes[i]->m_id == id) { + proc = m_processes[i]; + break; + } + } + + if(proc == 0){ + rs->err(NotExists, "No such process"); + return false; + } + + switch(proc->m_status){ + case STOPPED: + proc->m_status = STARTING; + if(proc->start() != 0){ + rs->err(Error, "Failed to start"); + return false; + } + break; + case STARTING: + rs->err(Error, "Already starting"); + return false; + case RUNNING: + rs->err(Error, "Already started"); + return false; + case STOPPING: + rs->err(Error, "Currently stopping"); + return false; + } + + notifyChanges(); + } + report(id, CPCEvent::ET_PROC_USER_START); + + return true; +} + +bool +CPCD::stopProcess(CPCD::RequestStatus *rs, int id) { + + Guard tmp(m_processes); + + Process * proc = 0; + for(size_t i = 0; i < m_processes.size(); i++) { + if(m_processes[i]->m_id == id) { + proc = m_processes[i]; + break; + } + } + + if(proc == 0){ + rs->err(NotExists, "No such process"); + return false; + } + + switch(proc->m_status){ + case STARTING: + case RUNNING: + proc->stop(); + break; + case STOPPED: + rs->err(AlreadyStopped, "Already stopped"); + return false; + break; + case STOPPING: + rs->err(Error, "Already stopping"); + return false; + } + + notifyChanges(); + + report(id, CPCEvent::ET_PROC_USER_START); + + return true; +} + +bool +CPCD::notifyChanges() { + bool ret = true; + if(!loadingProcessList) + ret = saveProcessList(); + + m_monitor->signal(); + + return ret; +} + +/* Must be called with m_processlist locked */ +bool +CPCD::saveProcessList(){ + char newfile[PATH_MAX+4]; + char oldfile[PATH_MAX+4]; + char curfile[PATH_MAX]; + FILE *f; + + /* Create the filenames that we will use later */ + snprintf(newfile, sizeof(newfile), "%s.new", m_procfile.c_str()); + snprintf(oldfile, sizeof(oldfile), "%s.old", m_procfile.c_str()); + snprintf(curfile, sizeof(curfile), "%s", m_procfile.c_str()); + + f = fopen(newfile, "w"); + + if(f == NULL) { + /* XXX What should be done here? */ + logger.critical("Cannot open `%s': %s\n", newfile, strerror(errno)); + return false; + } + + for(size_t i = 0; iprint(f); + fprintf(f, "\n"); + + if(m_processes[i]->m_processType == TEMPORARY){ + /** + * Interactive process should never be "restarted" on cpcd restart + */ + continue; + } + + if(m_processes[i]->m_status == RUNNING || + m_processes[i]->m_status == STARTING){ + fprintf(f, "start process\nid: %d\n\n", m_processes[i]->m_id); + } + } + + fclose(f); + f = NULL; + + /* This will probably only work on reasonably Unix-like systems. You have + * been warned... + * + * The motivation behind all this link()ing is that the daemon might + * crash right in the middle of updating the configuration file, and in + * that case we want to be sure that the old file is around until we are + * guaranteed that there is always at least one copy of either the old or + * the new configuration file left. + */ + + /* Remove an old config file if it exists */ + unlink(oldfile); + + if(link(curfile, oldfile) != 0) /* make a backup of the running config */ + logger.error("Cannot rename '%s' -> '%s'", curfile, oldfile); + else { + if(unlink(curfile) != 0) { /* remove the running config file */ + logger.critical("Cannot remove file '%s'", curfile); + return false; + } + } + + if(link(newfile, curfile) != 0) { /* put the new config file in place */ + printf("-->%d\n", __LINE__); + + logger.critical("Cannot rename '%s' -> '%s': %s", + curfile, newfile, strerror(errno)); + return false; + } + + /* XXX Ideally we would fsync() the directory here, but I'm not sure if + * that actually works. + */ + + unlink(newfile); /* remove the temporary file */ + unlink(oldfile); /* remove the old file */ + + logger.info("Process list saved as '%s'", curfile); + + return true; +} + +bool +CPCD::loadProcessList(){ + BaseString secondfile; + FILE *f; + + loadingProcessList = true; + + secondfile.assfmt("%s.new", m_procfile.c_str()); + + /* Try to open the config file */ + f = fopen(m_procfile.c_str(), "r"); + + /* If it did not exist, try to open the backup. See the saveProcessList() + * method for an explanation why it is done this way. + */ + if(f == NULL) { + f = fopen(secondfile.c_str(), "r"); + + if(f == NULL) { + /* XXX What to do here? */ + logger.info("Configuration file `%s' not found", + m_procfile.c_str()); + logger.info("Starting with empty configuration"); + loadingProcessList = false; + return false; + } else { + logger.info("Configuration file `%s' missing", + m_procfile.c_str()); + logger.info("Backup configuration file `%s' is used", + secondfile.c_str()); + /* XXX Maybe we should just rename the backup file to the official + * name, and be done with it? + */ + } + } + + CPCDAPISession sess(f, *this); + sess.loadFile(); + loadingProcessList = false; + + Vector temporary; + for(size_t i = 0; ireadPid(); + if(proc->m_processType == TEMPORARY){ + temporary.push_back(proc->m_id); + } + } + + for(size_t i = 0; isignal(); + return true; +} + +MutexVector * +CPCD::getProcessList() { + return &m_processes; +} + +void +CPCD::RequestStatus::err(enum RequestStatusCode status, char *msg) { + m_status = status; + snprintf(m_errorstring, sizeof(m_errorstring), "%s", msg); +} + +#if 0 +void +CPCD::sigchild(int pid){ + m_processes.lock(); + for(size_t i = 0; i +#include +#include +#include +#include +#include + +/* XXX Need to figure out how to do this for non-Unix systems */ +#define CPCD_DEFAULT_WORK_DIR "/var/run/ndb_cpcd" +#define CPCD_DEFAULT_PROC_FILE "ndb_cpcd.conf" +#define CPCD_DEFAULT_TCP_PORT 1234 +#define CPCD_DEFAULT_POLLING_INTERVAL 5 /* seconds */ +#define CPCD_DEFAULT_CONFIG_FILE "/etc/ndb_cpcd.conf" + +enum ProcessStatus { + STOPPED = 0, + STARTING = 1, + RUNNING = 2, + STOPPING = 3 +}; + +enum ProcessType { + PERMANENT = 0, + TEMPORARY = 1 +}; + +struct CPCEvent { + enum EventType { + ET_USER_CONNECT, + ET_USER_DISCONNECT, + + ET_PROC_USER_DEFINE, // Defined proc + ET_PROC_USER_UNDEFINE, // Undefined proc + ET_PROC_USER_START, // Proc ordered to start + ET_PROC_USER_STOP, // Proc ordered to stop + ET_PROC_STATE_RUNNING, // exec returned(?) ok + ET_PROC_STATE_STOPPED // detected that proc is ! running + }; + + int m_proc; + time_t m_time; + EventType m_type; +}; + +struct EventSubscriber { + virtual void report(const CPCEvent &) = 0; +}; + +/** + * @brief Error codes for CPCD requests + */ +enum RequestStatusCode { + OK = 0, ///< Everything OK + Error = 1, ///< Generic error + AlreadyExists = 2, ///< Entry already exists in list + NotExists = 3, ///< Entry does not exist in list + AlreadyStopped = 4 +}; + +/** + * @class CPCD + * @brief Manages processes, letting them be controlled with a TCP connection. + * + * The class implementing the Cluster Process Control Daemon + */ +class CPCD { +public: + /** @brief Describes the status of a client request */ + class RequestStatus { + public: + /** @brief Constructs an empty RequestStatus */ + RequestStatus() { m_status = OK; m_errorstring[0] = '\0'; }; + + /** @brief Sets an errorcode and a printable message */ + void err(enum RequestStatusCode, char *); + + /** @brief Returns the error message */ + char *getErrMsg() { return m_errorstring; }; + + /** @brief Returns the error code */ + enum RequestStatusCode getStatus() { return m_status; }; + private: + enum RequestStatusCode m_status; + char m_errorstring[256]; + }; + /** + * @brief Manages a process + */ + class Process { + int m_pid; + public: + /** + * @brief Constructs and empty Process + */ + Process(const Properties & props, class CPCD *cpcd); + /** + * @brief Monitors the process + * + * The process is started or stopped as needed. + */ + void monitor(); + + /** + * @brief Checks if the process is running or not + * + * @return + * - true if the process is running, + * - false if the process is not running + */ + bool isRunning(); + + /** @brief Starts the process */ + int start(); + + /** @brief Stops the process */ + void stop(); + + /** + * @brief Reads the pid from stable storage + * + * @return The pid number + */ + int readPid(); + + /** + * @brief Writes the pid from stable storage + * + * @return + * - 0 if successful + - -1 and sets errno if an error occured + */ + int writePid(int pid); + + /** + * @brief Prints a textual description of the process on a file + */ + void print(FILE *); + + /** Id number of the Process. + * + * @note This is not the same as a pid. This number is used in the + * protocol, and will not be changed if a processes is restarted. + */ + int m_id; + + /** @brief The name shown to the user */ + BaseString m_name; + + /** @brief Used to group a number of processes */ + BaseString m_group; + + /** @brief Environment variables + * + * Environmentvariables to add for the process. + * + * @note + * - The environment cpcd started with is preserved + * - There is no way to delete variables + */ + BaseString m_env; + + /** @brief Path to the binary to run */ + BaseString m_path; + + /** @brief Arguments to the process. + * + * @note + * - This includes argv[0]. + * - If no argv[0] is given, argv[0] will be set to m_path. + */ + BaseString m_args; + + /** + * @brief Type of process + * + * Either set to "interactive" or "permanent". + */ + BaseString m_type; + ProcessType m_processType; + + /** + * @brief Working directory + * + * Working directory the process will start in. + */ + BaseString m_cwd; + + /** + * @brief Owner of the process. + * + * @note This will not affect the process' uid or gid; + * it is only used for managemental purposes. + * @see m_runas + */ + BaseString m_owner; + + /** + * @bried Run as + * @note This affects uid + * @see m_owner + */ + BaseString m_runas; + + /** + * @brief redirection for stdin + */ + BaseString m_stdin; + + /** + * @brief redirection for stdout + */ + BaseString m_stdout; + + /** + * @brief redirection for stderr + */ + BaseString m_stderr; + + /** @brief Status of the process */ + enum ProcessStatus m_status; + + /** + * @brief ulimits for process + * @desc Format c:unlimited d:0 ... + */ + BaseString m_ulimit; + private: + class CPCD *m_cpcd; + void do_exec(); + }; + + /** + * @brief Starts and stops processes as needed + * + * At a specified interval (default 5 seconds) calls the monitor function + * of all the processes in the CPCDs list, causing the to start or + * stop, depending on the configuration. + */ + class Monitor { + public: + /** Creates a new CPCD::Monitor object, connected to the specified + * CPCD. + * A new thread will be created, which will poll the processes of + * the CPCD at the specifed interval. + */ + Monitor(CPCD *cpcd, int poll = CPCD_DEFAULT_POLLING_INTERVAL); + + /** Stops the monitor, but does not stop the processes */ + ~Monitor(); + + /** Runs the monitor thread. */ + void run(); + + /** Signals configuration changes to the monitor thread, causing it to + * do the check without waiting for the timeout */ + void signal(); + private: + class CPCD *m_cpcd; + struct NdbThread *m_monitorThread; + bool m_monitorThreadQuitFlag; + struct NdbCondition *m_changeCondition; + NdbMutex *m_changeMutex; + int m_pollingInterval; /* seconds */ + }; + + /** @brief Constructs a CPCD object */ + CPCD(); + + /** + * @brief Destroys a CPCD object, + * but does not stop the processes it manages + */ + ~CPCD(); + + /** Adds a Process to the CPCDs list of managed Processes. + * + * @note The process will not be started until it is explicitly + * marked as running with CPCD::startProcess(). + * + * @return + * - true if the addition was successful, + * - false if not + * - RequestStatus will be filled in with a suitable error + * if an error occured. + */ + bool defineProcess(RequestStatus *rs, Process * arg); + + /** Removes a Process from the CPCD. + * + * @note A Process that is running cannot be removed. + * + * @return + * - true if the removal was successful, + * - false if not + * - The RequestStatus will be filled in with a suitable error + * if an error occured. + */ + bool undefineProcess(RequestStatus *rs, int id); + + /** Marks a Process for starting. + * + * @note The fact that a process has started does not mean it will actually + * start properly. This command only makes sure the CPCD will + * try to start it. + * + * @return + * - true if the marking was successful + * - false if not + * - RequestStatus will be filled in with a suitable error + * if an error occured. + */ + bool startProcess(RequestStatus *rs, int id); + + /** Marks a Process for stopping. + * + * @return + * - true if the marking was successful + * - false if not + * - The RequestStatus will be filled in with a suitable error + * if an error occured. + */ + bool stopProcess(RequestStatus *rs, int id); + + /** Generates a list of processes, and sends them to the CPCD client */ + bool listProcesses(RequestStatus *rs, MutexVector &); + + /** Set to true while the CPCD is reading the configuration file */ + bool loadingProcessList; + + /** Saves the list of Processes and their status to the configuration file. + * Called whenever the configuration is changed. + */ + bool saveProcessList(); + + /** Loads the list of Processes and their status from the configuration + * file. + * @note This function should only be called when the CPCD is starting, + * calling it at other times will cause unspecified behaviour. + */ + bool loadProcessList(); + + /** Returns the list of processes */ + MutexVector *getProcessList(); + + /** The list of processes. Should not be used directly */ + MutexVector m_processes; + + /** Register event subscriber */ + void do_register(EventSubscriber * sub); + EventSubscriber* do_unregister(EventSubscriber * sub); + +private: + friend class Process; + bool notifyChanges(); + int findUniqueId(); + BaseString m_procfile; + Monitor *m_monitor; + + void report(int id, CPCEvent::EventType); + MutexVector m_subscribers; +}; + +#endif diff --git a/ndb/src/cw/cpcd/Makefile b/ndb/src/cw/cpcd/Makefile new file mode 100644 index 00000000000..f214fb087d2 --- /dev/null +++ b/ndb/src/cw/cpcd/Makefile @@ -0,0 +1,11 @@ +include .defs.mk + +TYPE := util +BIN_TARGET := ndb_cpcd + +# Source files of non-templated classes (.cpp files) +SOURCES = main.cpp CPCD.cpp Process.cpp APIService.cpp Monitor.cpp common.cpp + +BIN_TARGET_LIBS += logger + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/cw/cpcd/Monitor.cpp b/ndb/src/cw/cpcd/Monitor.cpp new file mode 100644 index 00000000000..a96f3509ee8 --- /dev/null +++ b/ndb/src/cw/cpcd/Monitor.cpp @@ -0,0 +1,76 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include + +#include "CPCD.hpp" +#include "common.hpp" + +static void * +monitor_thread_create_wrapper(void * arg) { + CPCD::Monitor *mon = (CPCD::Monitor *)arg; + mon->run(); + return NULL; +} + +CPCD::Monitor::Monitor(CPCD *cpcd, int poll) { + m_cpcd = cpcd; + m_pollingInterval = poll; + m_changeCondition = NdbCondition_Create(); + m_changeMutex = NdbMutex_Create(); + m_monitorThread = NdbThread_Create(monitor_thread_create_wrapper, + (NDB_THREAD_ARG*) this, + 32768, + "ndb_cpcd_monitor", + NDB_THREAD_PRIO_MEAN); + m_monitorThreadQuitFlag = false; +} + +CPCD::Monitor::~Monitor() { + NdbThread_Destroy(&m_monitorThread); + NdbCondition_Destroy(m_changeCondition); + NdbMutex_Destroy(m_changeMutex); +} + +void +CPCD::Monitor::run() { + while(1) { + NdbMutex_Lock(m_changeMutex); + NdbCondition_WaitTimeout(m_changeCondition, + m_changeMutex, + m_pollingInterval * 1000); + + MutexVector &proc = *m_cpcd->getProcessList(); + + proc.lock(); + + for(size_t i = 0; i < proc.size(); i++) { + proc[i]->monitor(); + } + + proc.unlock(); + + NdbMutex_Unlock(m_changeMutex); + } +} + +void +CPCD::Monitor::signal() { + NdbCondition_Signal(m_changeCondition); +} diff --git a/ndb/src/cw/cpcd/Process.cpp b/ndb/src/cw/cpcd/Process.cpp new file mode 100644 index 00000000000..01a63a5c653 --- /dev/null +++ b/ndb/src/cw/cpcd/Process.cpp @@ -0,0 +1,482 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include + +#include +#include + +#include +#include +#include + +#include "common.hpp" +#include "CPCD.hpp" + +#include +#include +#include +#include +#include + +void +CPCD::Process::print(FILE * f){ + fprintf(f, "define process\n"); + fprintf(f, "id: %d\n", m_id); + fprintf(f, "name: %s\n", m_name.c_str() ? m_name.c_str() : ""); + fprintf(f, "group: %s\n", m_group.c_str() ? m_group.c_str() : ""); + fprintf(f, "env: %s\n", m_env.c_str() ? m_env.c_str() : ""); + fprintf(f, "path: %s\n", m_path.c_str() ? m_path.c_str() : ""); + fprintf(f, "args: %s\n", m_args.c_str() ? m_args.c_str() : ""); + fprintf(f, "type: %s\n", m_type.c_str() ? m_type.c_str() : ""); + fprintf(f, "cwd: %s\n", m_cwd.c_str() ? m_cwd.c_str() : ""); + fprintf(f, "owner: %s\n", m_owner.c_str() ? m_owner.c_str() : ""); + fprintf(f, "runas: %s\n", m_runas.c_str() ? m_runas.c_str() : ""); + fprintf(f, "stdin: %s\n", m_stdin.c_str() ? m_stdin.c_str() : ""); + fprintf(f, "stdout: %s\n", m_stdout.c_str() ? m_stdout.c_str() : ""); + fprintf(f, "stderr: %s\n", m_stderr.c_str() ? m_stderr.c_str() : ""); + fprintf(f, "ulimit: %s\n", m_ulimit.c_str() ? m_ulimit.c_str() : ""); +} + +CPCD::Process::Process(const Properties & props, class CPCD *cpcd) { + m_id = -1; + m_pid = -1; + props.get("id", (Uint32 *) &m_id); + props.get("name", m_name); + props.get("group", m_group); + props.get("env", m_env); + props.get("path", m_path); + props.get("args", m_args); + props.get("cwd", m_cwd); + props.get("owner", m_owner); + props.get("type", m_type); + props.get("runas", m_runas); + + props.get("stdin", m_stdin); + props.get("stdout", m_stdout); + props.get("stderr", m_stderr); + props.get("ulimit", m_ulimit); + m_status = STOPPED; + + if(strcasecmp(m_type.c_str(), "temporary") == 0){ + m_processType = TEMPORARY; + } else { + m_processType = PERMANENT; + } + + m_cpcd = cpcd; +} + +void +CPCD::Process::monitor() { + switch(m_status) { + case STARTING: + break; + case RUNNING: + if(!isRunning()){ + m_cpcd->report(m_id, CPCEvent::ET_PROC_STATE_STOPPED); + if(m_processType == TEMPORARY){ + m_status = STOPPED; + } else { + start(); + } + } + break; + case STOPPED: + assert(!isRunning()); + break; + case STOPPING: + break; + } +} + +bool +CPCD::Process::isRunning() { + + if(m_pid <= 1){ + logger.critical("isRunning(%d) invalid pid: %d", m_id, m_pid); + return false; + } + /* Check if there actually exists a process with such a pid */ + errno = 0; + int s = kill((pid_t) m_pid, 0); /* Sending "signal" 0 to a process only + * checkes if the process actually exists */ + if(s != 0) { + switch(errno) { + case EPERM: + logger.critical("Not enough privileges to control pid %d\n", m_pid); + break; + case ESRCH: + /* The pid in the file does not exist, which probably means that it + has died, or the file contains garbage for some other reason */ + break; + default: + logger.critical("Cannot not control pid %d: %s\n", m_pid, strerror(errno)); + break; + } + return false; + } + + return true; +} + +int +CPCD::Process::readPid() { + if(m_pid != -1){ + logger.critical("Reading pid while != -1(%d)", m_pid); + return m_pid; + } + + char filename[PATH_MAX*2+1]; + char buf[1024]; + FILE *f; + + memset(buf, 0, sizeof(buf)); + + snprintf(filename, sizeof(filename), "%d", m_id); + + f = fopen(filename, "r"); + + if(f == NULL){ + logger.debug("readPid - %s not found", filename); + return -1; /* File didn't exist */ + } + + errno = 0; + size_t r = fread(buf, 1, sizeof(buf), f); + fclose(f); + if(r > 0) + m_pid = strtol(buf, (char **)NULL, 0); + + if(errno == 0){ + return m_pid; + } + + return -1; +} + +int +CPCD::Process::writePid(int pid) { + char tmpfilename[PATH_MAX+1+4+8]; + char filename[PATH_MAX*2+1]; + FILE *f; + + snprintf(tmpfilename, sizeof(tmpfilename), "tmp.XXXXXX"); + snprintf(filename, sizeof(filename), "%d", m_id); + + int fd = mkstemp(tmpfilename); + if(fd < 0) { + logger.error("Cannot open `%s': %s\n", tmpfilename, strerror(errno)); + return -1; /* Couldn't open file */ + } + + f = fdopen(fd, "w"); + + if(f == NULL) { + logger.error("Cannot open `%s': %s\n", tmpfilename, strerror(errno)); + return -1; /* Couldn't open file */ + } + + fprintf(f, "%d", pid); + fclose(f); + + if(rename(tmpfilename, filename) == -1){ + logger.error("Unable to rename from %s to %s", tmpfilename, filename); + return -1; + } + return 0; +} + +static void +setup_environment(const char *env) { + char **p; + p = BaseString::argify("", env); + for(int i = 0; p[i] != NULL; i++){ + /*int res = */ putenv(p[i]); + } +} + +static +int +set_ulimit(const BaseString & pair){ + errno = 0; + do { + Vector list; + pair.split(list, ":"); + if(list.size() != 2){ + break; + } + + int resource = 0; + rlim_t value = RLIM_INFINITY; + if(!(list[1].trim() == "unlimited")){ + value = atoi(list[1].c_str()); + } + if(list[0].trim() == "c"){ + resource = RLIMIT_CORE; + } else if(list[0] == "d"){ + resource = RLIMIT_DATA; + } else if(list[0] == "f"){ + resource = RLIMIT_FSIZE; + } else if(list[0] == "n"){ + resource = RLIMIT_NOFILE; + } else if(list[0] == "s"){ + resource = RLIMIT_STACK; + } else if(list[0] == "t"){ + resource = RLIMIT_CPU; + } else { + errno = EINVAL; + break; + } + struct rlimit rlp; + if(getrlimit(resource, &rlp) != 0){ + break; + } + + rlp.rlim_cur = value; + if(setrlimit(resource, &rlp) != 0){ + break; + } + return 0; + } while(false); + logger.error("Unable to process ulimit: %s(%s)", + pair.c_str(), strerror(errno)); + return -1; +} + +void +CPCD::Process::do_exec() { + + setup_environment(m_env.c_str()); + + char **argv = BaseString::argify(m_path.c_str(), m_args.c_str()); + + if(strlen(m_cwd.c_str()) > 0) { + int err = chdir(m_cwd.c_str()); + if(err == -1) { + BaseString err; + logger.error("%s: %s\n", m_cwd.c_str(), strerror(errno)); + _exit(1); + } + } + + Vector ulimit; + m_ulimit.split(ulimit); + for(size_t i = 0; i 0 && set_ulimit(ulimit[i]) != 0){ + _exit(1); + } + } + + int fd = open("/dev/null", O_RDWR, 0); + if(fd == -1) { + logger.error("Cannot open `/dev/null': %s\n", strerror(errno)); + _exit(1); + } + + BaseString * redirects[] = { &m_stdin, &m_stdout, &m_stderr }; + int fds[3]; + for(int i = 0; i<3; i++){ + if(redirects[i]->empty()){ +#ifndef DEBUG + dup2(fd, i); +#endif + continue; + } + + if((* redirects[i]) == "2>&1" && i == 2){ + dup2(fds[1], 2); + continue; + } + + /** + * Make file + */ + int flags = 0; + int mode = S_IRUSR | S_IWUSR ; + if(i == 0){ + flags |= O_RDONLY; + } else { + flags |= O_WRONLY | O_CREAT | O_APPEND; + } + int f = fds[i]= open(redirects[i]->c_str(), flags, mode); + if(f == -1){ + logger.error("Cannot redirect %d to/from '%s' : %s\n", i, + redirects[i]->c_str(), strerror(errno)); + _exit(1); + } + dup2(f, i); + } + + /* Close all filedescriptors */ + for(int i = STDERR_FILENO+1; i < getdtablesize(); i++) + close(i); + + execv(m_path.c_str(), argv); + /* XXX If we reach this point, an error has occurred, but it's kind of hard + * to report it, because we've closed all files... So we should probably + * create a new logger here */ + logger.error("Exec failed: %s\n", strerror(errno)); + /* NOTREACHED */ +} + +int +CPCD::Process::start() { + /* We need to fork() twice, so that the second child (grandchild?) can + * become a daemon. The original child then writes the pid file, + * so that the monitor knows the pid of the new process, and then + * exit()s. That way, the monitor process can pickup the pid, and + * the running process is a daemon. + * + * This is a bit tricky but has the following advantages: + * - the cpcd can die, and "reconnect" to the monitored clients + * without restarting them. + * - the cpcd does not have to wait() for the childs. init(1) will + * take care of that. + */ + logger.info("Starting %d: %s", m_id, m_name.c_str()); + m_status = STARTING; + + int pid = -1; + switch(m_processType){ + case TEMPORARY:{ + /** + * Simple fork + * don't ignore child + */ + switch(pid = fork()) { + case 0: /* Child */ + + if(runas(m_runas.c_str()) == 0){ + writePid(getpid()); + do_exec(); + } + _exit(1); + break; + case -1: /* Error */ + logger.error("Cannot fork: %s\n", strerror(errno)); + m_status = STOPPED; + return -1; + break; + default: /* Parent */ + logger.debug("Started temporary %d : pid=%d", m_id, pid); + m_cpcd->report(m_id, CPCEvent::ET_PROC_STATE_RUNNING); + break; + } + break; + } + case PERMANENT:{ + /** + * PERMANENT + */ + switch(fork()) { + case 0: /* Child */ + if(runas(m_runas.c_str()) != 0){ + writePid(-1); + _exit(1); + } + signal(SIGCHLD, SIG_IGN); + pid_t pid; + switch(pid = fork()) { + case 0: /* Child */ + writePid(getpid()); + setsid(); + do_exec(); + _exit(1); + /* NOTREACHED */ + break; + case -1: /* Error */ + logger.error("Cannot fork: %s\n", strerror(errno)); + writePid(-1); + _exit(1); + break; + default: /* Parent */ + logger.debug("Started permanent %d : pid=%d", m_id, pid); + _exit(0); + break; + } + break; + case -1: /* Error */ + logger.error("Cannot fork: %s\n", strerror(errno)); + m_status = STOPPED; + return -1; + break; + default: /* Parent */ + m_cpcd->report(m_id, CPCEvent::ET_PROC_STATE_RUNNING); + break; + } + break; + } + default: + logger.critical("Unknown process type"); + return -1; + } + + while(readPid() < 0){ + sched_yield(); + } + + if(pid != -1 && pid != m_pid){ + logger.error("pid and m_pid don't match: %d %d", pid, m_pid); + } + + if(isRunning()){ + m_status = RUNNING; + return 0; + } + m_status = STOPPED; + return -1; +} + +void +CPCD::Process::stop() { + + char filename[PATH_MAX*2+1]; + snprintf(filename, sizeof(filename), "%d", m_id); + unlink(filename); + + if(m_pid <= 1){ + logger.critical("Stopping process with bogus pid: %d", m_pid); + return; + } + m_status = STOPPING; + + int ret = kill((pid_t)m_pid, SIGTERM); + switch(ret) { + case 0: + logger.debug("Sent SIGTERM to pid %d", (int)m_pid); + break; + default: + logger.debug("kill pid: %d : %s", (int)m_pid, strerror(errno)); + break; + } + + if(isRunning()){ + ret = kill((pid_t)m_pid, SIGKILL); + switch(ret) { + case 0: + logger.debug("Sent SIGKILL to pid %d", (int)m_pid); + break; + default: + logger.debug("kill pid: %d : %s\n", (int)m_pid, strerror(errno)); + break; + } + } + + m_pid = -1; + m_status = STOPPED; +} diff --git a/ndb/src/cw/cpcd/common.cpp b/ndb/src/cw/cpcd/common.cpp new file mode 100644 index 00000000000..731866b22fd --- /dev/null +++ b/ndb/src/cw/cpcd/common.cpp @@ -0,0 +1,158 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "common.hpp" +#include +#include +#include +#include + +#include +#include + +int debug = 0; + +Logger logger; + +int +runas(const char * user){ + if(user == 0 || strlen(user) == 0){ + return 0; + } + struct passwd * pw = getpwnam(user); + if(pw == 0){ + logger.error("Can't find user to %s", user); + return -1; + } + uid_t uid = pw->pw_uid; + gid_t gid = pw->pw_gid; + int res = setgid(gid); + if(res != 0){ + logger.error("Can't change group to %s(%d)", user, gid); + return res; + } + + res = setuid(uid); + if(res != 0){ + logger.error("Can't change user to %s(%d)", user, uid); + } + return res; +} + +int +insert(const char * pair, Properties & p){ + BaseString tmp(pair); + + tmp.trim(" \t\n\r"); + + Vector split; + tmp.split(split, ":=", 2); + + if(split.size() != 2) + return -1; + + p.put(split[0].trim().c_str(), split[1].trim().c_str()); + + return 0; +} + +int +insert_file(FILE * f, class Properties& p, bool break_on_empty){ + if(f == 0) + return -1; + + while(!feof(f)){ + char buf[1024]; + fgets(buf, 1024, f); + BaseString tmp = buf; + + if(tmp.length() > 0 && tmp.c_str()[0] == '#') + continue; + + if(insert(tmp.c_str(), p) != 0 && break_on_empty) + break; + } + + return 0; +} + +int +insert_file(const char * filename, class Properties& p){ + FILE * f = fopen(filename, "r"); + int res = insert_file(f, p); + if(f) fclose(f); + return res; +} + +int +parse_config_file(struct getargs args[], int num_arg, const Properties& p){ + Properties::Iterator it(&p); + for(const char * name = it.first(); name != 0; name = it.next()){ + bool found = false; + for(int i = 0; i +#include +#include + +extern int debug; + +extern Logger logger; + +int runas(const char * user); +int insert(const char * pair, class Properties & p); + +int insert_file(const char * filename, class Properties&); +int insert_file(FILE *, class Properties&, bool break_on_empty = false); +int parse_config_file(struct getargs args[], int num_arg, const Properties& p); + +#endif /* ! __CPCD_COMMON_HPP_INCLUDED__ */ diff --git a/ndb/src/cw/cpcd/main.cpp b/ndb/src/cw/cpcd/main.cpp new file mode 100644 index 00000000000..8dd4f2b4608 --- /dev/null +++ b/ndb/src/cw/cpcd/main.cpp @@ -0,0 +1,178 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include /* Needed for mkdir(2) */ +#include /* Needed for mkdir(2) */ +#include +#include + +#include "CPCD.hpp" +#include "APIService.hpp" +#include +#include +#include +#include +#include +#include +#include + +#include "common.hpp" + +static char *work_dir = CPCD_DEFAULT_WORK_DIR; +static int port = CPCD_DEFAULT_TCP_PORT; +static int use_syslog = 0; +static char *logfile = NULL; +static char *config_file = CPCD_DEFAULT_CONFIG_FILE; +static char *user = 0; + +static struct getargs args[] = { + { "work-dir", 'w', arg_string, &work_dir, + "Work directory", "directory" }, + { "port", 'p', arg_integer, &port, + "TCP port to listen on", "port" }, + { "syslog", 'S', arg_flag, &use_syslog, + "Log events to syslog", NULL}, + { "logfile", 'L', arg_string, &logfile, + "File to log events to", "file"}, + { "debug", 'D', arg_flag, &debug, + "Enable debug mode", NULL}, + { "config", 'c', arg_string, &config_file, "Config file", NULL }, + { "user", 'u', arg_string, &user, "Run as user", NULL } +}; + +static const int num_args = sizeof(args) / sizeof(args[0]); + +static CPCD * g_cpcd = 0; +#if 0 +extern "C" static void sig_child(int signo, siginfo_t*, void*); +#endif + +const char *progname = "ndb_cpcd"; + +NDB_MAIN(ndb_cpcd){ + int optind = 0; + + if(getarg(args, num_args, argc, argv, &optind)) { + arg_printusage(args, num_args, progname, ""); + exit(1); + } + + Properties p; + insert_file(config_file, p); + if(parse_config_file(args, num_args, p)){ + ndbout_c("Invalid config file: %s", config_file); + exit(1); + } + + if(getarg(args, num_args, argc, argv, &optind)) { + arg_printusage(args, num_args, progname, ""); + exit(1); + } + + logger.setCategory(progname); + logger.enable(Logger::LL_ALL); + + if(debug) + logger.createConsoleHandler(); + + if(user && runas(user) != 0){ + logger.critical("Unable to change user: %s", user); + _exit(1); + } + + if(logfile != NULL){ + BaseString tmp; + if(logfile[0] != '/') + tmp.append(work_dir); + tmp.append(logfile); + logger.addHandler(new FileLogHandler(tmp.c_str())); + } + + if(use_syslog) + logger.addHandler(new SysLogHandler()); + + logger.info("Starting"); + + CPCD cpcd; + g_cpcd = &cpcd; + + /* XXX This will probably not work on !unix */ + int err = mkdir(work_dir, S_IRWXU | S_IRGRP | S_IROTH); + if(err != 0) { + switch(errno) { + case EEXIST: + break; + default: + fprintf(stderr, "Cannot mkdir %s: %s\n", work_dir, strerror(errno)); + exit(1); + } + } + + if(strlen(work_dir) > 0){ + logger.debug("Changing dir to '%s'", work_dir); + if((err = chdir(work_dir)) != 0){ + fprintf(stderr, "Cannot chdir %s: %s\n", work_dir, strerror(errno)); + exit(1); + } + } + + cpcd.loadProcessList(); + + SocketServer * ss = new SocketServer(); + CPCDAPIService * serv = new CPCDAPIService(cpcd); + if(!ss->setup(serv, port)){ + logger.critical("Cannot setup server: %s", strerror(errno)); + sleep(1); + delete ss; + delete serv; + return 1; + } + + ss->startServer(); + + { + signal(SIGPIPE, SIG_IGN); + signal(SIGCHLD, SIG_IGN); +#if 0 + struct sigaction act; + act.sa_handler = 0; + act.sa_sigaction = sig_child; + sigemptyset(&act.sa_mask); + act.sa_flags = SA_SIGINFO; + sigaction(SIGCHLD, &act, 0); +#endif + } + + logger.debug("Start completed"); + while(true) NdbSleep_MilliSleep(1000); + + delete ss; + return 0; +} + +#if 0 +extern "C" +void +sig_child(int signo, siginfo_t* info, void*){ + printf("signo: %d si_signo: %d si_errno: %d si_code: %d si_pid: %d\n", + signo, + info->si_signo, + info->si_errno, + info->si_code, + info->si_pid); + +} +#endif diff --git a/ndb/src/cw/test/socketclient/Makefile b/ndb/src/cw/test/socketclient/Makefile new file mode 100644 index 00000000000..04f11f031e5 --- /dev/null +++ b/ndb/src/cw/test/socketclient/Makefile @@ -0,0 +1,24 @@ +include .defs.mk + +TYPE := + +BIN_TARGET := socketclient + + + +CCFLAGS_LOC += -I../../util/ -I../../cpcd/ + +LIBS_LOC += -L$(NDB_TOP)/lib/ -L$(EXTERNAL_LIB_DIR)/sci + +LIBS_SPEC += -lsocketclient + + +SOURCES = socketClientTest.cpp + + +include $(NDB_TOP)/Epilogue.mk + + + + + diff --git a/ndb/src/cw/test/socketclient/socketClientTest.cpp b/ndb/src/cw/test/socketclient/socketClientTest.cpp new file mode 100644 index 00000000000..a4a0ed1e933 --- /dev/null +++ b/ndb/src/cw/test/socketclient/socketClientTest.cpp @@ -0,0 +1,65 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include "SocketService.hpp" +#include "SocketRegistry.hpp" +#include "SocketClient.hpp" +#include "ClientInterface.hpp" + +#include + +#include + +NDB_MAIN(socketclient) { + + + if(argc<3) { + printf("wrong args: socketclient \n"); + return 0; + } + const char * remotehost = argv[1]; + const int port = atoi(argv[2]); + + + ClientInterface * ci = new ClientInterface(2); + ci->connectCPCDdaemon(remotehost,port); + + /*ci->listProcesses(remotehost); + + ci->startProcess(remotehost, "1247"); + + ci->stopProcess(remotehost, "1247");*/ + + ci->defineProcess(remotehost, "ndb", "ndb-cluster1", "envirnm", "/ndb/bin", + "-i", "permanent", "/ndb/ndb.2", "team"); + + ci->startProcess(remotehost, "1247"); + + ci->listProcesses(remotehost); + + //ci->undefineProcess(remotehost, "1247"); + + ci->disconnectCPCDdaemon(remotehost); +} diff --git a/ndb/src/cw/util/ClientInterface.cpp b/ndb/src/cw/util/ClientInterface.cpp new file mode 100644 index 00000000000..627b622f1dd --- /dev/null +++ b/ndb/src/cw/util/ClientInterface.cpp @@ -0,0 +1,185 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "ClientInterface.hpp" + + + +ClientInterface::ClientInterface(Uint32 maxNoOfCPCD) { + sr = new SocketRegistry(maxNoOfCPCD); + ss = new SocketService(); +} + + +ClientInterface::~ClientInterface() { + delete sr; + delete ss; + +} + + +void ClientInterface::connectCPCDdaemon(const char * remotehost, Uint16 port) +{ + sr->createSocketClient(remotehost, port); +} + +void ClientInterface::disconnectCPCDdaemon(const char * remotehost) +{ + sr->removeSocketClient(remotehost); +} + +void ClientInterface::removeCPCDdaemon(const char * remotehost) +{ + sr->removeSocketClient(remotehost); +} + +void ClientInterface::startProcess(const char * remotehost, char * id) { + char buf[255] = "start process "; + char str[80]; + char line[10]; + + strcpy(line, id); + strcpy(str, "id:"); + strcat(str, line); + strcat(str, "\n\n"); + strcat(buf, str); + printf("Request: %s\n", buf); + + sr->performSend(buf,255,remotehost); + sr->syncPerformReceive(remotehost, *ss, 0); + ss->getPropertyObject(); +} + +void ClientInterface::stopProcess(const char * remotehost, char * id) { + char buf[255] = "stop process "; + char str[80]; + char line[10]; + + strcpy(line, id); + strcpy(str, "id:"); + strcat(str, line); + strcat(str, "\n\n"); + strcat(buf, str); + printf("Request: %s\n", buf); + + sr->performSend(buf,255,remotehost); + sr->syncPerformReceive(remotehost, *ss, 0); + ss->getPropertyObject(); +} + +void ClientInterface::defineProcess(const char * remotehost, char * name, + char * group, char * env, char * path, + char * args, char * type, char * cwd, char * owner){ + char buf[255] = "define process "; + char str[80]; + char line[10]; + + strcpy(line, name); + strcpy(str, "name:"); + strcat(str, line); + strcat(buf, str); + strcat(buf, " \n"); + + strcpy(line, group); + strcpy(str, "group:"); + strcat(str, line); + strcat(buf, str); + strcat(buf, " \n"); + + strcpy(line, env); + strcpy(str, "env:"); + strcat(str, line); + strcat(buf, str); + strcat(buf, " \n"); + + strcpy(line, path); + strcpy(str, "path:"); + strcat(str, line); + strcat(buf, str); + strcat(buf, " \n"); + + strcpy(line, args); + strcpy(str, "args:"); + strcat(str, line); + strcat(buf, str); + strcat(buf, " \n"); + + strcpy(line, type); + strcpy(str, "type:"); + strcat(str, line); + strcat(buf, str); + strcat(buf, " \n"); + + strcpy(line, cwd); + strcpy(str, "cwd:"); + strcat(str, line); + strcat(buf, str); + strcat(buf, " \n"); + + strcpy(line, owner); + strcpy(str, "owner:"); + strcat(str, line); + strcat(buf, str); + strcat(buf, "\n\n"); + + printf("Request: %s\n", buf); + + sr->performSend(buf,255,remotehost); + sr->syncPerformReceive(remotehost, *ss, 0); + ss->getPropertyObject(); +} + +void ClientInterface::undefineProcess(const char * remotehost, char * id){ + char buf[255] = "undefine process "; + char str[80]; + char line[10]; + + strcpy(line, id); + strcpy(str, "id:"); + strcat(str, line); + strcat(str, "\n\n"); + strcat(buf, str); + printf("Request: %s\n", buf); + + sr->performSend(buf,255,remotehost); + sr->syncPerformReceive(remotehost, *ss, 0); + ss->getPropertyObject(); +} + +void ClientInterface::listProcesses(const char * remotehost) { + char buf[255]="list processes\n\n"; + printf("Request: %s\n", buf); + sr->performSend(buf,255,remotehost); + sr->syncPerformReceive(remotehost, *ss, 0); + ss->getPropertyObject(); +} + +void ClientInterface::showProcess(const char * remotehost, char * id) { + char buf[255] = "show process "; + char str[80]; + char line[10]; + + strcpy(line, id); + strcpy(str, "id:"); + strcat(str, line); + strcat(str, "\n\n"); + strcat(buf, str); + printf("Request: %s\n", buf); + + sr->performSend(buf,255,remotehost); + sr->syncPerformReceive(remotehost, *ss, 0); + ss->getPropertyObject(); +} diff --git a/ndb/src/cw/util/ClientInterface.hpp b/ndb/src/cw/util/ClientInterface.hpp new file mode 100644 index 00000000000..764705afacd --- /dev/null +++ b/ndb/src/cw/util/ClientInterface.hpp @@ -0,0 +1,51 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef CLIENT_IF_HPP +#define CLIENT_IF_HPP +#include +#include +#include +#include +#include +#include "SocketRegistry.hpp" +#include "SocketService.hpp" +#include "string.h" +#include +#include + +class ClientInterface { +private: + SocketService * ss; + SocketRegistry * sr; + +public: + ClientInterface(Uint32 maxNoOfCPC); + ~ClientInterface(); + void startProcess(const char * remotehost, char * id); + void stopProcess(const char * remotehost, char * id); + void defineProcess(const char * remotehost, char * name, char * group, + char * env, char * path, char * args, char * type, + char * cwd, char * owner); + void undefineProcess(const char * remotehost, char * id); + void listProcesses(const char * remotehost); + void showProcess(const char * remotehost, char * id); + void connectCPCDdaemon(const char * remotehost, Uint16 port); + void disconnectCPCDdaemon(const char * remotehost); + void removeCPCDdaemon(const char * remotehost); + +}; +#endif diff --git a/ndb/src/cw/util/Makefile b/ndb/src/cw/util/Makefile new file mode 100644 index 00000000000..f5ab16721be --- /dev/null +++ b/ndb/src/cw/util/Makefile @@ -0,0 +1,10 @@ +include .defs.mk +TYPE := ndbapi + +PIC_ARCHIVE := Y +ARCHIVE_TARGET := socketclient + +# Source files of non-templated classes (.cpp files) +SOURCES = ClientInterface.cpp SocketService.cpp SocketClient.cpp + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/cw/util/SocketRegistry.cpp b/ndb/src/cw/util/SocketRegistry.cpp new file mode 100644 index 00000000000..1dbb402f7c9 --- /dev/null +++ b/ndb/src/cw/util/SocketRegistry.cpp @@ -0,0 +1,213 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "SocketRegistry.hpp" +#include + +template +SocketRegistry::SocketRegistry(Uint32 maxSocketClients) { + +} + + +template +SocketRegistry::~SocketRegistry() { + delete [] m_socketClients; +} + +template +bool +SocketRegistry::createSocketClient(const char * host, Uint16 port) { + + if(port == 0) + return false; + if(host==NULL) + return false; + + SocketClient * socketClient = new SocketClient(host, port); + + if(socketClient->openSocket() < 0 || socketClient == NULL) { + ndbout << "could not connect" << endl; + delete socketClient; + return false; + } + else { + m_socketClients[m_nSocketClients] = socketClient; + m_nSocketClients++; + } + return true; +} + +template +int +SocketRegistry::pollSocketClients(Uint32 timeOutMillis) { + + + + // Return directly if there are no TCP transporters configured + if (m_nSocketClients == 0){ + tcpReadSelectReply = 0; + return 0; + } + struct timeval timeout; + timeout.tv_sec = timeOutMillis / 1000; + timeout.tv_usec = (timeOutMillis % 1000) * 1000; + + + NDB_SOCKET_TYPE maxSocketValue = 0; + + // Needed for TCP/IP connections + // The read- and writeset are used by select + + FD_ZERO(&tcpReadset); + + // Prepare for sending and receiving + for (Uint32 i = 0; i < m_nSocketClients; i++) { + SocketClient * t = m_socketClients[i]; + + // If the socketclient is connected + if (t->isConnected()) { + + const NDB_SOCKET_TYPE socket = t->getSocket(); + // Find the highest socket value. It will be used by select + if (socket > maxSocketValue) + maxSocketValue = socket; + + // Put the connected transporters in the socket read-set + FD_SET(socket, &tcpReadset); + } + } + + // The highest socket value plus one + maxSocketValue++; + + tcpReadSelectReply = select(maxSocketValue, &tcpReadset, 0, 0, &timeout); +#ifdef NDB_WIN32 + if(tcpReadSelectReply == SOCKET_ERROR) + { + NdbSleep_MilliSleep(timeOutMillis); + } +#endif + + return tcpReadSelectReply; + +} + +template +bool +SocketRegistry::performSend(const char * buf, + Uint32 len, + const char * remotehost) +{ + SocketClient * socketClient; + for(Uint32 i=0; i < m_nSocketClients; i++) { + socketClient = m_socketClients[i]; + if(strcmp(socketClient->gethostname(), remotehost)==0) { + if(socketClient->isConnected()) { + if(socketClient->writeSocket(buf, len)>0) + return true; + else + return false; + } + } + } + return false; +} + +template +int +SocketRegistry::performReceive(T & t) { + char buf[255] ; //temp. just for testing. must fix better + + if(tcpReadSelectReply > 0){ + for (Uint32 i=0; igetSocket(); + if(sc->isConnected() && FD_ISSET(socket, &tcpReadset)) { + t->runSession(socket,t); + } + } + return 1; + } + return 0; + +} + + + +template +inline +int +SocketRegistry::syncPerformReceive(char * host, + T & t, + Uint32 timeOutMillis) { + char buf[255] ; //temp. just for testing. must fix better + struct timeval timeout; + timeout.tv_sec = timeOutMillis / 1000; + timeout.tv_usec = (timeOutMillis % 1000) * 1000; + int reply; + SocketClient * sc; + for(Uint32 i=0; i < m_nSocketClients; i++) { + sc = m_socketClients[i]; + if(strcmp(sc->gethostname(), remotehost)==0) { + if(sc->isConnected()) { + FD_ZERO(&tcpReadset); + reply = select(sc->getSocket(), &tcpReadset, 0, 0, &timeout); + if(reply > 0) { + return t->runSession(sc->getSocket(), t); + } + } + + } + } + return 0; +} + + + +template +bool +SocketRegistry::reconnect(const char * host){ + for(Uint32 i=0; i < m_nSocketClients; i++) { + SocketClient * socketClient = m_socketClients[i]; + if(strcmp(socketClient->gethostname(), host)==0) { + if(!socketClient->isConnected()) { + if(socketClient->openSocket() > 0) + return true; + else return false; + } + } + } + return false; +} + +template +bool +SocketRegistry::removeSocketClient(const char * host){ + for(Uint32 i=0; i < m_nSocketClients; i++) { + SocketClient * socketClient = m_socketClients[i]; + if(strcmp(socketClient->gethostname(), host)==0) { + if(!socketClient->isConnected()) { + if(socketClient->closeSocket() > 0) { + delete socketClient; + return true; + } + else return false; + } + } + } + return false; +} diff --git a/ndb/src/cw/util/SocketRegistry.hpp b/ndb/src/cw/util/SocketRegistry.hpp new file mode 100644 index 00000000000..2b079156967 --- /dev/null +++ b/ndb/src/cw/util/SocketRegistry.hpp @@ -0,0 +1,290 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SocketClientRegistry_H +#define SocketClientRegistry_H + +#include +#include + +#include "SocketClient.hpp" + +template +class SocketRegistry { + +public: + SocketRegistry(Uint32 maxSocketClients); + ~SocketRegistry(); + /** + * creates and adds a SocketClient to m_socketClients[] + * @param host - host name + * @param port - port to connect to + */ + bool createSocketClient(const char * host, const Uint16 port); + + /** + * performReceive reads from sockets should do more stuff + */ + int performReceive(T &); + + + /** + * performReceive reads from sockets should do more stuff + */ + int syncPerformReceive(const char* ,T &, Uint32); + + + /** + * performSend sends a command to a host + */ + bool performSend(const char * buf, Uint32 len, const char * remotehost); + + /** + * pollSocketClients performs a select (for a max. of timeoutmillis) or + * until there is data to be read from any SocketClient + * @param timeOutMillis - select timeout + */ + int pollSocketClients(Uint32 timeOutMillis); + + /** + * reconnect tries to reconnect to a cpcd given its hostname + * @param host - name of host to reconnect to. + */ + bool reconnect(const char * host); + + + /** + * removeSocketClient + * @param host - name of host for which to remove the SocketConnection + */ + bool removeSocketClient(const char * host); + +private: + SocketClient** m_socketClients; + Uint32 m_maxSocketClients; + Uint32 m_nSocketClients; + int tcpReadSelectReply; + fd_set tcpReadset; + + +}; + + +template +inline +SocketRegistry::SocketRegistry(Uint32 maxSocketClients) { + m_maxSocketClients = maxSocketClients; + m_socketClients = new SocketClient * [m_maxSocketClients]; + m_nSocketClients = 0; +} + + +template +inline +SocketRegistry::~SocketRegistry() { + delete [] m_socketClients; +} + +template +inline +bool +SocketRegistry::createSocketClient(const char * host, Uint16 port) { + + if(port == 0) + return false; + if(host==NULL) + return false; + + SocketClient * socketClient = new SocketClient(host, port); + + if(socketClient->openSocket() < 0 || socketClient == NULL) { + ndbout << "could not connect" << endl; + delete socketClient; + return false; + } + else { + m_socketClients[m_nSocketClients] = socketClient; + m_nSocketClients++; + } + return true; +} + +template +inline +int +SocketRegistry::pollSocketClients(Uint32 timeOutMillis) { + + + + // Return directly if there are no TCP transporters configured + if (m_nSocketClients == 0){ + tcpReadSelectReply = 0; + return 0; + } + struct timeval timeout; + timeout.tv_sec = timeOutMillis / 1000; + timeout.tv_usec = (timeOutMillis % 1000) * 1000; + + + NDB_SOCKET_TYPE maxSocketValue = 0; + + // Needed for TCP/IP connections + // The read- and writeset are used by select + + FD_ZERO(&tcpReadset); + + // Prepare for sending and receiving + for (Uint32 i = 0; i < m_nSocketClients; i++) { + SocketClient * t = m_socketClients[i]; + + // If the socketclient is connected + if (t->isConnected()) { + + const NDB_SOCKET_TYPE socket = t->getSocket(); + // Find the highest socket value. It will be used by select + if (socket > maxSocketValue) + maxSocketValue = socket; + + // Put the connected transporters in the socket read-set + FD_SET(socket, &tcpReadset); + } + } + + // The highest socket value plus one + maxSocketValue++; + + tcpReadSelectReply = select(maxSocketValue, &tcpReadset, 0, 0, &timeout); +#ifdef NDB_WIN32 + if(tcpReadSelectReply == SOCKET_ERROR) + { + NdbSleep_MilliSleep(timeOutMillis); + } +#endif + + return tcpReadSelectReply; + +} + +template +inline +bool +SocketRegistry::performSend(const char * buf, Uint32 len, const char * remotehost) +{ + SocketClient * socketClient; + for(Uint32 i=0; i < m_nSocketClients; i++) { + socketClient = m_socketClients[i]; + if(strcmp(socketClient->gethostname(), remotehost)==0) { + if(socketClient->isConnected()) { + if(socketClient->writeSocket(buf, len)>0) + return true; + else + return false; + } + } + } + return false; +} + +template +inline +int +SocketRegistry::performReceive(T & t) { + char buf[255] ; //temp. just for testing. must fix better + + if(tcpReadSelectReply > 0){ + for (Uint32 i=0; igetSocket(); + if(sc->isConnected() && FD_ISSET(socket, &tcpReadset)) { + t->runSession(socket,t); + } + } + return 1; + } + return 0; + +} + + + +template +inline +int +SocketRegistry::syncPerformReceive(const char * remotehost, + T & t, + Uint32 timeOutMillis) { + char buf[255] ; //temp. just for testing. must fix better + struct timeval timeout; + timeout.tv_sec = timeOutMillis / 1000; + timeout.tv_usec = (timeOutMillis % 1000) * 1000; + int reply; + SocketClient * sc; + for(Uint32 i=0; i < m_nSocketClients; i++) { + sc = m_socketClients[i]; + if(strcmp(sc->gethostname(), remotehost)==0) { + if(sc->isConnected()) { + /*FD_ZERO(&tcpReadset); + reply = select(sc->getSocket()+1, 0, 0, 0, &timeout); + reply=1; + if(reply > 0) {*/ + t.runSession(sc->getSocket(), t); + //} + } + + } + } +} + + + +template +inline +bool +SocketRegistry::reconnect(const char * host){ + for(Uint32 i=0; i < m_nSocketClients; i++) { + SocketClient * socketClient = m_socketClients[i]; + if(strcmp(socketClient->gethostname(), host)==0) { + if(!socketClient->isConnected()) { + if(socketClient->openSocket() > 0) + return true; + else return false; + } + } + } + return false; +} + +template +inline +bool +SocketRegistry::removeSocketClient(const char * host){ + for(Uint32 i=0; i < m_nSocketClients; i++) { + SocketClient * socketClient = m_socketClients[i]; + if(strcmp(socketClient->gethostname(), host)==0) { + if(!socketClient->isConnected()) { + if(socketClient->closeSocket() > 0) { + delete socketClient; + return true; + } + else return false; + } + } + } + return false; +} + + +#endif // Define of SocketRegistry diff --git a/ndb/src/cw/util/SocketService.cpp b/ndb/src/cw/util/SocketService.cpp new file mode 100644 index 00000000000..b993ec8c2c1 --- /dev/null +++ b/ndb/src/cw/util/SocketService.cpp @@ -0,0 +1,60 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include +#include "SocketService.hpp" + +SocketService::SocketService() { + +} + +SocketService::~SocketService() { + +} + +int +SocketService::runSession(NDB_SOCKET_TYPE socket, SocketService & ss){ + InputStream *m_input = new SocketInputStream(socket); + char buf[255]; + + m_input->gets(buf,255); + ndbout_c("SocketService:received: %s\n", buf); + ndbout_c("This should now be parsed\n"); + ndbout_c("and put in a property object.\n"); + ndbout_c("The propery is then accessible from the ClientInterface.\n"); + ndbout_c("by getPropertyObject.\n"); + ndbout_c("At least this is the idea."); + /*Parser_t *m_parser = + new Parser(commands, *m_input, true, true, true); + */ + /** to do + * add a proprty object to which the parser will put its result. + */ + + return 1 ; //succesful + //return 0; //unsuccesful + +} + +void +SocketService::getPropertyObject() { + ndbout << "get property object. return to front end or something" << endl; +} + + diff --git a/ndb/src/cw/util/SocketService.hpp b/ndb/src/cw/util/SocketService.hpp new file mode 100644 index 00000000000..7a0c3a2fd91 --- /dev/null +++ b/ndb/src/cw/util/SocketService.hpp @@ -0,0 +1,46 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SOCKET_SERVICE_HPP +#define SOCKET_SERVICE_HPP +#include +#include +#include +#include +#include +#include "SocketRegistry.hpp" + + + + +class SocketService { + friend class SocketRegistry; +private: + typedef Parser Parser_t; + int runSession(NDB_SOCKET_TYPE socket, SocketService &); +public: + void getPropertyObject(); + SocketService(); + ~SocketService(); + +}; + + + + + + +#endif diff --git a/ndb/src/external/LINUX.x86/sci/include/list.h b/ndb/src/external/LINUX.x86/sci/include/list.h new file mode 100644 index 00000000000..81c467a461b --- /dev/null +++ b/ndb/src/external/LINUX.x86/sci/include/list.h @@ -0,0 +1,56 @@ +/* $Id: list.h,v 1.1 2002/12/13 12:17:20 hin Exp $ */ + +/******************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + + + +#ifndef _LIST_H +#define _LIST_H +#include "sci_types.h" + + +typedef struct ListElement *ListElement_t; +typedef struct List *List_t; + +struct ListElement { + void *element; + u_vkaddr_t key; + ListElement_t prev,next; +}; + +void *Get_Element(ListElement_t el); +void Set_Element(ListElement_t el,void *elptr,u_vkaddr_t key); +void Create_Element(ListElement_t *el); +void Destroy_Element(ListElement_t *el); +void Create_List(List_t *list); +void Destroy_List(List_t *list); +void Add_Element(List_t list,ListElement_t el); +void Remove_Element(List_t list,ListElement_t el); +ListElement_t Find_Element(List_t list,u_vkaddr_t key); +scibool List_Empty(List_t); +scibool List_Elements(List_t); +ListElement_t First_Element(List_t list); +ListElement_t Last_Element(List_t list); +ListElement_t Next_Element(ListElement_t el); + +#endif /* _LIST_H */ diff --git a/ndb/src/external/LINUX.x86/sci/include/os/inttypes.h b/ndb/src/external/LINUX.x86/sci/include/os/inttypes.h new file mode 100644 index 00000000000..b9e5a6cb19f --- /dev/null +++ b/ndb/src/external/LINUX.x86/sci/include/os/inttypes.h @@ -0,0 +1,53 @@ +/* $Id: inttypes.h,v 1.1 2002/12/13 12:17:21 hin Exp $ */ + +/******************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + + +#ifndef _SCI_OS_INTTYPES_H_ +#define _SCI_OS_INTTYPES_H_ + +/* + * -------------------------------------------------------------------------------------- + * Basic types of various sizes. + * -------------------------------------------------------------------------------------- + */ +typedef unsigned char unsigned8; +typedef unsigned short unsigned16; +typedef unsigned int unsigned32; +typedef unsigned long long unsigned64; + +typedef signed char signed8; +typedef signed short signed16; +typedef signed int signed32; +typedef signed long long signed64; + + +#ifdef CPU_WORD_IS_64_BIT +typedef unsigned64 uptr_t; +typedef signed64 iptr_t; +#else +typedef unsigned32 uptr_t; +typedef signed32 iptr_t; +#endif + +#endif /* _SCI_OS_INTTYPES_H_ */ diff --git a/ndb/src/external/LINUX.x86/sci/include/rmlib.h b/ndb/src/external/LINUX.x86/sci/include/rmlib.h new file mode 100644 index 00000000000..9d2722e9798 --- /dev/null +++ b/ndb/src/external/LINUX.x86/sci/include/rmlib.h @@ -0,0 +1,212 @@ +/* $Id: rmlib.h,v 1.1 2002/12/13 12:17:20 hin Exp $ */ + +/********************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU Lesser General Public License as published by * + * the Free Software Foundation; either version 2.1 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU Lesser General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *********************************************************************************/ + +/********************************************************************************/ +/* This header file contains the declarations of the SCI Reflective Memory */ +/* library rmlib. The implementation of the library functions is in rmlib.c. */ +/* The library contains all the functions that operate on the reflective */ +/* memory. */ +/* */ +/* NB! */ +/* */ +/* DOLPHIN'S SCI REFLECTIVE MEMORY FILES ARE UNDER DEVELOPMENT AND MAY CHANGE. */ +/* PLEASE CONTACT DOLPHIN FOR FURTHER INFORMATION. */ +/* */ +/* */ +/********************************************************************************/ + +#include "sisci_error.h" +#include "sisci_api.h" +#include "sisci_demolib.h" +#include "sisci_types.h" + +unsigned int seqerr, syncseqerr; + +#ifndef _RMLIB_H +#define _RMLIB_H + + +#if defined(_REENTRANT) + +#define _RMLIB_EXPAND_NAME(name) _RMLIB_MT_ ## name + +#else + +#define _RMLIB_EXPAND_NAME(name) _RMLIB_ST_ ## name + +#endif + +#ifdef __sparc +#define CACHE_SIZE 2097152 +#else +#define CACHE_SIZE 8192 +#endif + +/*********************************************************************************/ +/* FLAG VALUES */ +/*********************************************************************************/ + +#define REFLECT_ERRCHECK 0x2 + +struct ReflectiveMemorySpace { + unsigned int localAdapterNo; + unsigned int localNodeId; + unsigned int remoteNodeId; + sci_desc_t sd; + sci_desc_t syncsd; + sci_map_t localMap; + sci_map_t remoteMap; + unsigned int localSegmentId; + unsigned int remoteSegmentId; + unsigned int syncSegmentId; + unsigned int sync_rSegmentId; + unsigned int segmentSize; + unsigned int *localMapAddr; + volatile unsigned int *remoteMapAddr; + sci_local_segment_t localSegment; + sci_remote_segment_t remoteSegment; + sci_local_segment_t syncSegment; + sci_remote_segment_t sync_rSegment; + sci_map_t syncMap; + sci_map_t sync_rMap; + sci_sequence_t syncsequence; + sci_sequence_t sequence; + unsigned int protection; + unsigned int retry_value; + sci_sequence_status_t sequenceStatus, syncsequenceStatus; + volatile unsigned int *syncMapAddr; + volatile unsigned int *sync_rMapAddr; +}; + +/*********************************************************************************/ +/* P R I N T R E F L E C T I V E M E M O R Y S P A C E */ +/* */ +/*********************************************************************************/ +#define ReflectPrintParameters _RMLIB_EXPAND_NAME(ReflectPrintParameters) +void ReflectPrintParameters(FILE *stream, struct ReflectiveMemorySpace RM_space); + +/*********************************************************************************/ +/* R E F L E C T D M A S E T U P */ +/* */ +/*********************************************************************************/ +#define ReflectDmaSetup _RMLIB_EXPAND_NAME(ReflectDmaSetup) +sci_error_t ReflectDmaSetup(struct ReflectiveMemorySpace RM_space, sci_dma_queue_t *dmaQueue); + +/*********************************************************************************/ +/* R E F L E C T D M A R E M O V E */ +/* */ +/*********************************************************************************/ +#define ReflectDmaRemove _RMLIB_EXPAND_NAME(ReflectDmaRemove) +sci_error_t ReflectDmaRemove(sci_dma_queue_t dmaQueue); + +/*********************************************************************************/ +/* R E F L E C T D M A R U N */ +/* */ +/*********************************************************************************/ +#define ReflectDmaRun _RMLIB_EXPAND_NAME(ReflectDmaRun) +sci_error_t ReflectDmaRun(struct ReflectiveMemorySpace RM_space, + unsigned int* privateSrc, + unsigned int size, + unsigned int offset, + sci_dma_queue_t dmaQueue); +/*********************************************************************************/ +/* C L O S E R E F L E C T I V E M E M O R Y S P A C E */ +/* */ +/*********************************************************************************/ +#define ReflectClose _RMLIB_EXPAND_NAME(ReflectClose) +sci_error_t ReflectClose(struct ReflectiveMemorySpace RM_space, unsigned int segment_no); + +/*********************************************************************************/ +/* O P E N R E F L E C T I V E M E M O R Y S P A C E */ +/* */ +/*********************************************************************************/ +#define ReflectOpen _RMLIB_EXPAND_NAME(ReflectOpen) +sci_error_t ReflectOpen(struct ReflectiveMemorySpace *RM_space, + unsigned int size, + unsigned int segment_no, + unsigned int localAdapterNo, + unsigned int remoteNodeId, + unsigned int protection, + unsigned int retry_value); + +/*********************************************************************************/ +/* R E F L E C T G E T A C C E S S */ +/* */ +/*********************************************************************************/ +#define ReflectGetAccess _RMLIB_EXPAND_NAME(ReflectGetAccess) +sci_error_t ReflectGetAccess(struct ReflectiveMemorySpace *RM_space); + +/*********************************************************************************/ +/* R E F L E C T R E L E A S E A C C E S S */ +/* */ +/*********************************************************************************/ +#define ReflectReleaseAccess _RMLIB_EXPAND_NAME(ReflectReleaseAccess) +sci_error_t ReflectReleaseAccess(struct ReflectiveMemorySpace *RM_space); + +/*********************************************************************************/ +/* R E F L E C T D M A */ +/* */ +/*********************************************************************************/ +#define ReflectDma _RMLIB_EXPAND_NAME(ReflectDma) +sci_error_t ReflectDma(struct ReflectiveMemorySpace RM_space, + unsigned int* privateSrc, + unsigned int size, + unsigned int offset); + +/*********************************************************************************/ +/* R E F L E C T M E M C O P Y */ +/* */ +/*********************************************************************************/ +#define ReflectMemCopy _RMLIB_EXPAND_NAME(ReflectMemCopy) +sci_error_t ReflectMemCopy(struct ReflectiveMemorySpace RM_space, + unsigned int* privateSrc, + unsigned int size, + unsigned int offset, + unsigned int flags); + +/*********************************************************************************/ +/* R E F L E C T S E T */ +/* */ +/*********************************************************************************/ +#define ReflectSet _RMLIB_EXPAND_NAME(ReflectSet) +sci_error_t ReflectSet(struct ReflectiveMemorySpace RM_space, + unsigned int value, + unsigned int size, + unsigned int offset, + unsigned int flags + ); + +/*********************************************************************************/ +/* R E F L E C T P R I N T */ +/* */ +/*********************************************************************************/ +#define ReflectPrint _RMLIB_EXPAND_NAME(ReflectPrint) +sci_error_t ReflectPrint(FILE *stream, + struct ReflectiveMemorySpace RM_space, + unsigned int size, + unsigned int offset + ); + + +#endif diff --git a/ndb/src/external/LINUX.x86/sci/include/sci_errno.h b/ndb/src/external/LINUX.x86/sci/include/sci_errno.h new file mode 100644 index 00000000000..03f3256a86f --- /dev/null +++ b/ndb/src/external/LINUX.x86/sci/include/sci_errno.h @@ -0,0 +1,216 @@ +/* $Id: sci_errno.h,v 1.1 2002/12/13 12:17:20 hin Exp $ */ + +/******************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + + + +#ifndef _SCI_ERRNO_H_ +#define _SCI_ERRNO_H_ + + +/* + * SCI Error return values always have 30 bit set + * Remote errors should have bit 0 set + */ +#define SCI_ERR_MASK 0x40000000 +#define ESCI_REMOTE_MASK 0x01000000 + +#define SCI_ERR(u) ((unsigned32)(u)&0x7FFFFFFF ) +#define _SCI_ERROR(x) ((x) | SCI_ERR_MASK) +#define _SCI_REMOTE_ERROR(x) ( _SCI_ERROR(x) | ESCI_REMOTE_MASK ) + +/* + * Error codes + */ +typedef enum { + ESCI_OK = 0x000, + ESCI_STILL_EXPORTED = _SCI_ERROR(0x800), + + ESCI_BUS_ERR = _SCI_ERROR(0x900), + ESCI_PEND_SCIERR = _SCI_ERROR(0x901), + ESCI_SCI_ERR = _SCI_ERROR(0x902), + + /* + * Specific SCI error responses: + */ + ESCI_SCI_ERR_DATA = _SCI_ERROR(0x9021), + ESCI_SCI_ERR_TYPE = _SCI_ERROR(0x9022), + ESCI_SCI_ERR_ADDR = _SCI_ERROR(0x9023), + + ESCI_LINK_TIMEOUT = _SCI_ERROR(0x903), + ESCI_EXDEV_TIMEOUT = _SCI_ERROR(0x904), + ESCI_REMOTE_ERR = _SCI_ERROR(0x905), + ESCI_MBX_BUSY = _SCI_ERROR(0x906), + ESCI_DMAERR = _SCI_ERROR(0x907), + ESCI_DMA_DISABLED = _SCI_ERROR(0x908), + ESCI_SW_MBX_SEND_FAILED = _SCI_ERROR(0x909), + ESCI_HW_MBX_SEND_FAILED = _SCI_ERROR(0x90A), + ESCI_HAS_NO_SESSION = _SCI_ERROR(0xA00), + ESCI_CONNREFUSED_SESSION = _SCI_ERROR(0xA01), + ESCI_SESSION_NOT_ESTABLISHED = _SCI_ERROR(0xA11), + ESCI_REMOTE_NO_VALID_SESSION = _SCI_ERROR(0xA02), + ESCI_SESSION_DISABLED = _SCI_ERROR(0xA03), + ESCI_NODE_CLOSED = _SCI_ERROR(0xA04), + ESCI_NODE_DISABLED = _SCI_ERROR(0xA05), + + ESCI_LOCAL_MASTER_ERR = _SCI_ERROR(0xA06), + ESCI_REMOTE_MASTER_ERR = _SCI_REMOTE_ERROR(0xA06), + + ESCI_ILLEGAL_CMD_RECEIVED = _SCI_ERROR(0xA08), + ESCI_ILLEGAL_CMD_SENT = _SCI_ERROR(0xA09), + + /* used above: ESCI_SESSION_NOT_ESTABLISHED = _SCI_ERROR(0xA11), */ + + /* + * Remote error codes + */ + ESCI_CONNREFUSED = _SCI_ERROR(0xB00), + ESCI_NODE_NOT_RESPONDING = _SCI_ERROR(0xB01), + ESCI_ISCONN = _SCI_ERROR(0xB02), + ESCI_HOSTUNREACH = _SCI_ERROR(0xB03), + ESCI_NO_SUCH_USER_ID = _SCI_ERROR(0xB04), + ESCI_REMOTE_NO_SUCH_USER_ID = _SCI_REMOTE_ERROR(0xB04), /* ESCI_NO_SUCH_USER_ID */ + ESCI_NO_SUCH_KEY = _SCI_ERROR(0xB04), /* ESCI_NO_SUCH_USER_ID */ + ESCI_REMOTE_NO_SUCH_KEY = _SCI_REMOTE_ERROR(0xB04), /* ESCI_REMOTE_NO_SUCH_USER_ID */ + ESCI_NODE_ERR = _SCI_ERROR(0xB06), + ESCI_REMOTE_NODE_ERR = _SCI_REMOTE_ERROR(0xB06), /* ESCI_NODE_ERR */ + ESCI_NOSPC = _SCI_ERROR(0xB08), + ESCI_REMOTE_NOSPC = _SCI_REMOTE_ERROR(0xB08), /* ESCI_NOSPC */ + ESCI_NODMASPC = _SCI_ERROR(0xB0A), + ESCI_REMOTE_NODMASPC = _SCI_REMOTE_ERROR(0xB0A), /* ESCI_NODMASPC */ + ESCI_NOTMAP = _SCI_ERROR(0xC00), + ESCI_ISMAP = _SCI_ERROR(0xC01), + ESCI_NOT_INITIALIZED = _SCI_ERROR(0xD00), + ESCI_REMOTE_NOT_INITIALIZED = _SCI_REMOTE_ERROR(ESCI_NOT_INITIALIZED), + /* + * ??? + */ + ESCI_PARAM_ERR = _SCI_ERROR(0xD01), + ESCI_NO_FREE_VC = _SCI_ERROR(0xD02), + ESCI_REMOTE_NO_FREE_VC = _SCI_REMOTE_ERROR(0xD02), /* ESCI_NO_FREE_VC */ + + /* + * Adapter state related error codes: + */ + ESCI_SUSPENDED = _SCI_ERROR(0xD03), + ESCI_NOT_SUSPENDED = _SCI_ERROR(0xD04), + ESCI_NOT_READY = _SCI_ERROR(0xD05), + ESCI_NOT_CONFIGURED = _SCI_ERROR(0xD06), + ESCI_INVALID_ADAPTERID = _SCI_ERROR(0xD07), /* if an adapter-id is out of range */ + ESCI_NONEXIST_ADAPTERID = _SCI_ERROR(0xD08), /* if adapter-id is valid but no adapter matches */ + ESCI_ADAPTERID_INUSE = _SCI_ERROR(0xD09), + + ESCI_INVALID_INSTANCE = _SCI_ERROR(0xD0A), + ESCI_NONEXIST_INSTANCE = _SCI_ERROR(0xD0B), + + ESCI_ADAPTER_INIT_FAILURE = _SCI_ERROR(0xD0C), + + ESCI_PAUSED = _SCI_ERROR(0xD0D), + ESCI_NOT_PAUSED = _SCI_ERROR(0xD0E), + ESCI_ADAPTER_NEED_RESET = _SCI_ERROR(0xD0F), + + ESCI_NONEXIST_SERIAL_NUMBER = _SCI_ERROR(0xD10), + ESCI_NOT_AVAILABLE = _SCI_ERROR(0xD11), + + ESCI_EACCESS = _SCI_ERROR(0xD12), + + /* + * Local error codes + */ + ESCI_NO_LOCAL_ACCESS = _SCI_ERROR(0xE00), + ESCI_LRESOURCE_BUSY = _SCI_ERROR(0xE01), + ESCI_LRESOURCE_EXIST = _SCI_ERROR(0xE02), + ESCI_NO_LRESOURCE = _SCI_ERROR(0xE03), + ESCI_NOTCONN = _SCI_ERROR(0xE04), + ESCI_LOCAL_ERR = _SCI_ERROR(0xE05), + ESCI_NOVAL_NODEID = _SCI_ERROR(0xE06), + ESCI_NOT_SUPPORTED = _SCI_ERROR(0xE07), + ESCI_TIMEOUT = _SCI_ERROR(0xE08), + ESCI_NO_LOCAL_LC_ACCESS = _SCI_ERROR(0xE0A), + ESCI_INVALID_ATT = _SCI_ERROR(0xE0B), + ESCI_BAD_CHECKSUM = _SCI_ERROR(0xE0C), + ESCI_INTERRUPT_FLAG_DISABLED = _SCI_ERROR(0xE0D), + ESCI_COND_INT_RACE_PROBLEM = _SCI_ERROR(0xE0E), + ESCI_OVERFLOW = _SCI_ERROR(0xE0F), + ESCI_BLINK_PARITY_ERROR = _SCI_ERROR(0xE10), + ESCI_FIRMWARE_VERSION_MISMATCH = _SCI_ERROR(0xE11), + + /* + * Link error codes + */ + ESCI_NO_LINK_ACCESS = _SCI_ERROR(0xF00), + ESCI_NO_REMOTE_LINK_ACCESS = _SCI_REMOTE_ERROR(0xF00), /* ESCI_NO_LINK_ACCESS */ + + ESCI_NO_SUCH_NODE = _SCI_ERROR(0xF02), + ESCI_USR_ACCESS_DISABLED = _SCI_ERROR(0xF03), + ESCI_HW_AVOID_DEADLOCK = _SCI_ERROR(0xF04), + ESCI_POTENTIAL_ERROR = _SCI_ERROR(0xF05), + + ESCI_FENCED = _SCI_ERROR(0xF06), + ESCI_SWITCH_HW_FAILURE = _SCI_ERROR(0xF07), + ESCI_SWITCH_WRONG_BLINK_ID = _SCI_ERROR(0xF08), + ESCI_SWITCH_WRONG_PORT_NUMB = _SCI_ERROR(0xF09), + ESCI_SWITCH_WRONG_INIT_TYPE = _SCI_ERROR(0xF0A), /* It is determined that the swith initialization + * do not match the local adapter initialization + */ + ESCI_SWITCH_WRONG_SWITCH_NUMB = _SCI_ERROR(0xF0B), /* It is determined that we are operationg on the + * wrong switch port + */ + ESCI_SWITCH_NOT_CONNECTED = _SCI_ERROR(0xF0C), + ESCI_SWITCH_NOT_RECOGNIZED = _SCI_ERROR(0xF0D), + ESCI_SWITCH_INIT_IN_PROGRESS = _SCI_ERROR(0xF0E), /* Switch TINI initialization in progress */ + + + ESCI_NO_BACKBONE_LINK_ACCESS = _SCI_ERROR(0xF20), + ESCI_BACKBONE_FENCED = _SCI_ERROR(0xF21), + ESCI_NO_BACKBONE_ACCESS = _SCI_ERROR(0xF22), + ESCI_BACKBONE_CABLE_PROBLEM = _SCI_ERROR(0xF23), + ESCI_BACKBONE_BLINK_PROBLEM = _SCI_ERROR(0xF24), + ESCI_BACKBONE_HWINIT_PROBLEM = _SCI_ERROR(0xF25), + ESCI_BACKBONE_ID_PROBLEM = _SCI_ERROR(0xF26), + ESCI_BACKBONE_STATE_PROBLEM = _SCI_ERROR(0xF27), + ESCI_BACKBONE_REQ_LINK_PROBLEM = _SCI_ERROR(0xF28), + ESCI_BACKBONE_UNFENCING = _SCI_ERROR(0xF29), /* Unfencing in progress */ + + /* + * added for pci port + */ + ESCI_AGAIN = _SCI_ERROR(0xF15), + ESCI_ORANGE = _SCI_ERROR(0xF16), /* Out of range */ + ESCI_NOSYS = _SCI_ERROR(0xF17), /* Used instead of ENOSYS. Means function not implemented */ + ESCI_REMOTE_NOSYS = _SCI_REMOTE_ERROR(ESCI_NOSYS), + ESCI_INTR = _SCI_ERROR(0xF18), /* Used instead of EINTR from sys/errno.h */ + ESCI_IO = _SCI_ERROR(0xF19), /* Used instead of EIO from sys/errno.h */ + ESCI_FAULT = _SCI_ERROR(0xF1A), /* Used instead of EFAULT from sys/errno.h */ + ESCI_BUSY = _SCI_ERROR(0xF1B), /* Used instead of EBUST from sys/errno.h */ + ESCI_INVAL = _SCI_ERROR(0xF1C), /* Used instead of EINVAL from sys/errno.h */ + ESCI_NXIO = _SCI_ERROR(0xF1D), /* Used instead of ENXIO from sys/errno.h */ + ESCI_EXIST = _SCI_ERROR(0xF1E) /* Used instead of EEXIST from sys/errno.h */ + +} scierror_t; + +#endif /* _SCI_ERRNO_H_ */ + + + + diff --git a/ndb/src/external/LINUX.x86/sci/include/sci_types.h b/ndb/src/external/LINUX.x86/sci/include/sci_types.h new file mode 100644 index 00000000000..740b3a45cfd --- /dev/null +++ b/ndb/src/external/LINUX.x86/sci/include/sci_types.h @@ -0,0 +1,300 @@ +/* $Id: sci_types.h,v 1.1 2002/12/13 12:17:21 hin Exp $ */ + +/******************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + + +#ifndef _SCI_TYPES_H_ +#define _SCI_TYPES_H_ + +/* + * Remains for the time being for backward compatibility .... + */ + +/* #define UNIQUE(type) struct { type x; } * */ +#ifndef UNIQUE +#define UNIQUE(type) type +#endif +#include "os/inttypes.h" + +#if defined(WIN32) +#if defined(_KERNEL) +#include +#else +#include +#endif /* _KERNEL */ +#else +#if defined(Linux) +#if defined(__KERNEL__) +#include +#else +#include +#endif +#else +#include +#endif +#ifdef SUNOS5 +#include +#include +#endif +#ifdef OS_IS_TRU64 +#include +#endif +#ifdef OS_IS_HP_UX11 +#if defined(_KERNEL) +#include <../wsio/wsio.h> +#else +#include +#endif +#endif +#endif + +/* See comments about "UNCONFIGURED_ADAPTERS" in config.h */ +#define UNCONFIGURED_ADAPTERS 100 + +#ifndef FALSE +#define FALSE 0 +#endif + +#ifndef TRUE +#define TRUE 1 +#endif + +#ifndef NULL +#define NULL 0 +#endif + +#ifndef IN +#define IN +#endif + +#ifndef NOT +#define NOT ! +#endif + +/* + * -------------------------------------------------------------------------------------- + * Basic types of various sizes. + * -------------------------------------------------------------------------------------- + */ + +typedef signed32 scibool; +#ifndef OS_IS_VXWORKS +typedef signed32 BOOL; +#else +/* VXWORKS has already defined BOOL */ +#endif +typedef unsigned32 node_t; /* This is the logical nodeid */ +typedef unsigned32 sciNodeId_t; /* This is the physical 16 bit SCI nodeid */ + +/* + * -------------------------------------------------------------------------------------- + * Various register types. + * -------------------------------------------------------------------------------------- + */ +typedef volatile unsigned32 register32; + + +/* +Temporary for Windows NT, until we use only the above types. +*/ + +#ifdef WIN32 + +typedef unsigned char u_char; +typedef unsigned short u_short; +typedef unsigned long u_long; +typedef unsigned int u_int; +typedef char * caddr_t; + +typedef long off_t; +typedef unsigned int size_t; + +#endif +#ifdef OS_IS_VXWORKS +#include +#endif + +/* + * -------------------------------------------------------------------------------------- + * Various address types. + * + * We are using a struct * instead of unsigned long (int) inorder to enforce strong + * type checking + * + * -------------------------------------------------------------------------------------- + */ +typedef UNIQUE(void *) vkaddr_t; /* Virtual kernel address */ +typedef UNIQUE(uptr_t) vuaddr_t; /* Virtual user address */ + +typedef UNIQUE(unsigned32) remaddr_t; /* Remote IO address (physical address on PCs) */ +typedef UNIQUE(unsigned32) sciofs_lo_t; /* Lower 32 bits of an SCI offset. */ +typedef UNIQUE(unsigned32) sciofs_hi_t; /* The upper 16 bits of an SCI offset. */ + +typedef UNIQUE(unsigned32) ioaddr_t; /* Local IO address (physical address on PCs) */ +typedef unsigned32 u_ioaddr_t; +typedef unsigned32 iooffset_t; +typedef unsigned32 iosize_t; + +typedef uptr_t vkoffset_t; +typedef uptr_t u_vkaddr_t; +typedef uptr_t u_vuaddr_t; +typedef unsigned32 u_sciofs_lo_t; +typedef unsigned32 u_sciofs_hi_t; +typedef unsigned32 u_remaddr_t; +typedef unsigned32 attOffset_t; /* Address displacement from start of ATT entry */ + +typedef unsigned32 adapterNo_t; + +typedef enum { + NO_NODE = 0, + AD_MEM_NODE = 1, + AD_ALT_NODE = 2, + AD_MBX_NODE = 3, + AD_LC_NODE = 4, + AD_LC_PORT_0 = 5, + AD_LC_PORT_1 = 6, + AD_LC_PORT_2 = 7, + PHYS_NODE = 8 +} node_type_t; + + +/* + * Currently we don't support more than 32 bit sizes. + */ +#define SIZEOF(x) ((unsigned32)sizeof(x)) + +#if defined(_KERNEL) + +/* + * -------------------------------------------------------------------------------------- + * Some small macros intended to ease the transition to more strongly typed address + * types. The intention is that they in the long run shall be removed ... + * -------------------------------------------------------------------------------------- + */ +#define P2SIZE_T(x) ((size_t)((uptr_t)(x))) /* Pointer to size_t */ +#define P2U32(x) ((unsigned32)((uptr_t)(x))) /* Pointer to Unsigned 32-bit int */ +#ifdef WIN32 +#define PHADDR(x) ((ioaddr_t)(x)) +#define HASV(x) (x) +#endif +#if 0 +static vkaddr_t VKPTR (void * ptr) { return (vkaddr_t)ptr; } +static vkaddr_t VKADDR(volatile void * ptr) { return (vkaddr_t)ptr; } +#else +#define VKPTR(ptr) (vkaddr_t)ptr +#define VKADDR(ptr) (vkaddr_t)ptr +#endif + +#ifdef KLOG +#define KLOG_LOG(n,m,v) ts_log((n),(m),(v)) +#else +#define KLOG_LOG(n,m,v) +#endif /* KLOG */ + + +/* + * -------------------------------------------------------------------------------------- + * + * M E M A R E A T + * + * Memory area descriptor. + * + * paddr -- Physical address (aligned) of memory area + * ual_vaddr -- (Kernel )Virtual address of the unaligned memory area + * vaddr -- (Kernel) Virtual address of memory area + * rsize -- Real (Physical) Size of memory area + * msize -- Mapped (Virtual) Size of memory area (Size of area mapped + * into virtual) memory + * + * -------------------------------------- + * | | <----- msize ----->| | + * |<------|------- rsize ------|------>| + * -------------------------------------- + * /|\ /|\ + * | | + * ual_vaddr vaddr/paddr + * + * -------------------------------------------------------------------------------------- + */ +struct _memarea_ { + ioaddr_t ioaddr; + vkaddr_t vaddr; + vkaddr_t ual_vaddr; + size_t rsize; + size_t msize; + char *id; + unsigned32 cookie; + + +#ifdef SUNOS5 +#ifdef _USE_NEW_SOLARIS_DDI_INTERFACE + ddi_acc_handle_t mem_handle; + ddi_dma_handle_t dma_handle; +#else + ddi_dma_handle_t handle; +#endif +#endif +#ifdef OS_IS_TRU64 + dma_handle_t dma_handle; +#endif + +#if OS_IS_LINUX + unsigned long ph_base_addr; +#endif + +#ifdef OS_IS_HP_UX11 + struct isc_table_type * isc; + wsio_shmem_attr_t type; +#endif +}; + +typedef struct _memarea_ memarea_t; + +#ifdef SCI_MALLOC_DEBUG +struct _maddr_ { + char *id; + size_t size; + struct _maddr_ *next; + struct _maddr_ **prev; + unsigned32 cookie; +}; + +typedef struct _maddr_ maddr_t; + +#define MALLOC_COOKIE 0xc3c3c3c3 + +#else + +typedef struct { void *p; } *maddr_t; + +#endif /* SCI_MALLOC_DEBUG */ + + +typedef struct { + scibool disabled; + unsigned32 disable_cnt; +} disable_info_t; + +#endif /* _KERNEL */ + +#endif /* _SCI_TYPES_H_ */ diff --git a/ndb/src/external/LINUX.x86/sci/include/sisci_api.h b/ndb/src/external/LINUX.x86/sci/include/sisci_api.h new file mode 100644 index 00000000000..38fdf54125f --- /dev/null +++ b/ndb/src/external/LINUX.x86/sci/include/sisci_api.h @@ -0,0 +1,2170 @@ +/* $Id: sisci_api.h,v 1.1 2002/12/13 12:17:21 hin Exp $ */ +/******************************************************************************* + * * + * Copyright (C) 1993 - 2001 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU Lesser General Public License as published by * + * the Free Software Foundation; either version 2.1 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU Lesser General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + +#ifndef _SISCI_API_H +#define _SISCI_API_H + +#include "sisci_types.h" +#include "sisci_error.h" + + +#ifdef WIN32 +#ifdef API_DLL +#define DLL __declspec(dllexport) +#elif CLIENT_DLL +#define DLL __declspec(dllimport) +#endif +#endif /* WIN32 */ + + +#ifndef DLL +#define DLL +#endif + +#if defined(_REENTRANT) +#define _SISCI_EXPANDE_FUNCTION_NAME(name) _SISCI_PUBLIC_FUNC_MT_ ## name +#define _SISCI_EXPANDE_VARIABLE_NAME(name) _SISCI_PUBLIC_VAR_MT_ ## name +#else +#define _SISCI_EXPANDE_FUNCTION_NAME(name) _SISCI_PUBLIC_FUNC_ST_ ## name +#define _SISCI_EXPANDE_VARIABLE_NAME(name) _SISCI_PUBLIC_VAR_ST_ ## name +#endif +#define _SISCI_EXPANDE_CONSTANT_NAME(name) _SISCI_PUBLIC_CONST_ ## name + +#if defined(CPLUSPLUS) || defined(__cplusplus) +extern "C" { +#endif + + +/*********************************************************************************/ +/* FLAG VALUES */ +/*********************************************************************************/ + +#define SCI_FLAG_FIXED_INTNO _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FIXED_INTNO) +extern const unsigned int SCI_FLAG_FIXED_INTNO; + +#define SCI_FLAG_SHARED_INT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_SHARED_INT) +extern const unsigned int SCI_FLAG_SHARED_INT; + +#define SCI_FLAG_FIXED_MAP_ADDR _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FIXED_MAP_ADDR) +extern const unsigned int SCI_FLAG_FIXED_MAP_ADDR; + +#define SCI_FLAG_READONLY_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_READONLY_MAP) +extern const unsigned int SCI_FLAG_READONLY_MAP; + +#define SCI_FLAG_USE_CALLBACK _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_USE_CALLBACK) +extern const unsigned int SCI_FLAG_USE_CALLBACK; + +#define SCI_FLAG_BLOCK_READ _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_BLOCK_READ) +extern const unsigned int SCI_FLAG_BLOCK_READ; + +#define SCI_FLAG_THREAD_SAFE _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_THREAD_SAFE) +extern const unsigned int SCI_FLAG_THREAD_SAFE; + +#define SCI_FLAG_ASYNCHRONOUS_CONNECT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_ASYNCHRONOUS_CONNECT) +extern const unsigned int SCI_FLAG_ASYNCHRONOUS_CONNECT; + +#define SCI_FLAG_EMPTY _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_EMPTY) +extern const unsigned int SCI_FLAG_EMPTY; + +#define SCI_FLAG_PRIVATE _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_PRIVATE) +extern const unsigned int SCI_FLAG_PRIVATE; + +#define SCI_FLAG_FORCE_DISCONNECT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FORCE_DISCONNECT) +extern const unsigned int SCI_FLAG_FORCE_DISCONNECT; + +#define SCI_FLAG_NOTIFY _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_NOTIFY) +extern const unsigned int SCI_FLAG_NOTIFY; + +#define SCI_FLAG_DMA_READ _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_READ) +extern const unsigned int SCI_FLAG_DMA_READ; + +#define SCI_FLAG_DMA_POST _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_POST) +extern const unsigned int SCI_FLAG_DMA_POST; + +#define SCI_FLAG_DMA_WAIT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_WAIT) +extern const unsigned int SCI_FLAG_DMA_WAIT; + +#define SCI_FLAG_DMA_RESET _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_RESET) +extern const unsigned int SCI_FLAG_DMA_RESET; + +#define SCI_FLAG_NO_FLUSH _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_NO_FLUSH) +extern const unsigned int SCI_FLAG_NO_FLUSH; + +#define SCI_FLAG_NO_STORE_BARRIER _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_NO_STORE_BARRIER) +extern const unsigned int SCI_FLAG_NO_STORE_BARRIER; + +#define SCI_FLAG_FAST_BARRIER _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FAST_BARRIER) +extern const unsigned int SCI_FLAG_FAST_BARRIER; + +#define SCI_FLAG_ERROR_CHECK _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_ERROR_CHECK) +extern const unsigned int SCI_FLAG_ERROR_CHECK; + +#define SCI_FLAG_FLUSH_CPU_BUFFERS_ONLY _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FLUSH_CPU_BUFFERS_ONLY) +extern const unsigned int SCI_FLAG_FLUSH_CPU_BUFFERS_ONLY; + +/* the FLUSH_CPU_BUFFERS_ONLY flag is for backwards compabillity only and should never be used */ +#define FLUSH_CPU_BUFFERS_ONLY _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FLUSH_CPU_BUFFERS_ONLY) + +#define SCI_FLAG_LOCK_OPERATION _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_LOCK_OPERATION) +extern const unsigned int SCI_FLAG_LOCK_OPERATION; + +#define SCI_FLAG_READ_PREFETCH_AGGR_HOLD_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_READ_PREFETCH_AGGR_HOLD_MAP) +extern const unsigned int SCI_FLAG_READ_PREFETCH_AGGR_HOLD_MAP; + +#define SCI_FLAG_READ_PREFETCH_NO_HOLD_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_READ_PREFETCH_NO_HOLD_MAP) +extern const unsigned int SCI_FLAG_READ_PREFETCH_NO_HOLD_MAP; + +#define SCI_FLAG_IO_MAP_IOSPACE _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_IO_MAP_IOSPACE) +extern const unsigned int SCI_FLAG_IO_MAP_IOSPACE; + +#define SCI_FLAG_DMOVE_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMOVE_MAP) +extern const unsigned int SCI_FLAG_DMOVE_MAP; + +#define SCI_FLAG_WRITES_DISABLE_GATHER_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_WRITES_DISABLE_GATHER_MAP) +extern const unsigned int SCI_FLAG_WRITES_DISABLE_GATHER_MAP; + +#define SCI_FLAG_DISABLE_128_BYTES_PACKETS _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DISABLE_128_BYTES_PACKETS) +extern const unsigned int SCI_FLAG_DISABLE_128_BYTES_PACKETS; + +#define SCI_FLAG_SHARED_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_SHARED_MAP) +extern const unsigned int SCI_FLAG_SHARED_MAP; + +#define SCI_FLAG_DMA_SOURCE_ONLY _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_SOURCE_ONLY) +extern const unsigned int SCI_FLAG_DMA_SOURCE_ONLY; + +#define SCI_FLAG_CONDITIONAL_INTERRUPT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_CONDITIONAL_INTERRUPT) +extern const unsigned int SCI_FLAG_CONDITIONAL_INTERRUPT; + +#define SCI_FLAG_CONDITIONAL_INTERRUPT_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_CONDITIONAL_INTERRUPT_MAP) +extern const unsigned int SCI_FLAG_CONDITIONAL_INTERRUPT_MAP; + +#define SCI_FLAG_UNCONDITIONAL_DATA_INTERRUPT_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_UNCONDITIONAL_DATA_INTERRUPT_MAP) +extern const unsigned int SCI_FLAG_UNCONDITIONAL_DATA_INTERRUPT_MAP; + +#define SCI_FLAG_NO_MEMORY_LOOPBACK_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_NO_MEMORY_LOOPBACK_MAP) +extern const unsigned int SCI_FLAG_NO_MEMORY_LOOPBACK_MAP; + +#if defined(OS_IS_LYNXOS) || defined(OS_IS_VXWORKS) +#define SCI_FLAG_WRITE_BACK_CACHE_MAP _SISCI_EXPANDE_CONSTANT_NAME(WRITE_BACK_CACHE_MAP) +extern const unsigned int SCI_FLAG_WRITE_BACK_CACHE_MAP; +#endif + +#define SCI_FLAG_DMA_PHDMA _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_PHDMA) +extern const unsigned int SCI_FLAG_DMA_PHDMA; + +/*********************************************************************************/ +/* GENERAL VALUES */ +/*********************************************************************************/ +#define SCI_LOCAL_HOST _SISCI_EXPANDE_CONSTANT_NAME(SCI_LOCAL_HOST) +extern const unsigned int SCI_LOCAL_HOST; + +#define SCI_INFINITE_TIMEOUT _SISCI_EXPANDE_CONSTANT_NAME(SCI_INFINITE_TIMEOUT) +extern const unsigned int SCI_INFINITE_TIMEOUT; + +/*********************************************************************************/ +/* GENERAL ERROR CODES */ +/* */ +/* SCI_ERR_ILLEGAL_FLAG - Illegal flag value. */ +/* SCI_ERR_FLAG_NOT_IMPLEMENTED - Flag legal but flag feature not implemented. */ +/* SCI_ERR_NOT_IMPLEMENTED - Function not implemented. */ +/* SCI_ERR_SYSTEM - A system error. Check errno. */ +/* SCI_ERR_NOSPC - Unable to allocate OS resources. */ +/* SCI_ERR_API_NOSPC - Unable to allocate API resources. */ +/* SCI_ERR_HW_NOSPC - Unable to allocate HW resources (Hardware) */ +/* */ +/*********************************************************************************/ + + +/*********************************************************************************/ +/* GENERAL "ADAPTER" ERROR CODES */ +/* */ +/* SCI_ERR_NO_SUCH_ADAPTERNO - Adapter number is legal but does not exist. */ +/* SCI_ERR_ILLEGAL_ADAPTERNO - Illegal local adapter number (i.e. outside */ +/* legal range). */ +/* */ +/*********************************************************************************/ + + +/*********************************************************************************/ +/* GENERAL "NODEID" ERROR CODES */ +/* */ +/* SCI_ERR_NO_SUCH_NODEID - The remote adapter identified by nodeId does */ +/* not respond, but the intermediate link(s) */ +/* seem(s) to be operational. */ +/* SCI_ERR_ILLEGAL_NODEID - Illegal NodeId. */ +/* */ +/*********************************************************************************/ + + + +/********************************************************************************* + * * + * S C I I N I T I A L I Z E * + * * + * This function initializes the SISCI library. * + * The function must be called before SCIOpen(). * + * * + * Flags: * + * None * + * * + * Specific error codes for this function: * + * * + * None * + * * + *********************************************************************************/ +#define SCIInitialize _SISCI_EXPANDE_FUNCTION_NAME(SCIInitialize) +DLL void SCIInitialize(unsigned int flags, + sci_error_t *error); +#if 0 +unsigned int __Internal_SISCI_version_var; +#endif + +/********************************************************************************* + * * + * S C I T E R M I N A T E * + * * + * This function terminates the SISCI library. * + * The function must be called after SCIClose(). * + * * + * * + *********************************************************************************/ +#define SCITerminate _SISCI_EXPANDE_FUNCTION_NAME(SCITerminate) +DLL void SCITerminate(void); + +/********************************************************************************* + * * + * S C I O P E N * + * * + * * + * Opens a SCI virtual device. * + * Caller must supply a pointer to a variable of type sci_desc_t to be * + * initialized. * + * * + * Flags * + * SCI_FLAG_THREAD_SAFE - Operations on resources associated with this * + * descriptor will be performed in a multithread-safe * + * manner. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_INCONSISTENT_VERSIONS - Inconsistency between the SISCI library * + * and the SISCI driver versions. * + * * + * * + *********************************************************************************/ +#define SCIOpen _SISCI_EXPANDE_FUNCTION_NAME(SCIOpen) +DLL void SCIOpen(sci_desc_t *sd, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I C L O S E * + * * + * This function closes an open SCI virtual device. * + * * + * Flags: * + * None * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_BUSY - All resources are not deallocated. * + * * + *********************************************************************************/ +#define SCIClose _SISCI_EXPANDE_FUNCTION_NAME(SCIClose) +DLL void SCIClose(sci_desc_t sd, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I C O N N E C T S E G M E N T * + * * + * Connects to a remote shared memory segment located at with the * + * identifier . * + * The user may then call SCIMapRemoteSegment() to map shared memory * + * into user space. * + * * + * Flags * + * SCI_FLAG_USE_CALLBACK * + * SCI_FLAG_ASYNCHRONOUS_CONNECT * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_NO_SUCH_SEGMENT - Could not find the remote segment with the * + * given segmentId. * + * SCI_ERR_CONNECTION_REFUSED - Connection attempt refused by remote node. * + * SCI_ERR_TIMEOUT - The function timed out after specified * + * timeout value. * + * SCI_ERR_NO_LINK_ACCESS - It was not possible to communicate via the * + * local adapter. * + * SCI_ERR_NO_REMOTE_LINK_ACCESS - It was not possible to communicate via a * + * remote switch port. * + * * + *********************************************************************************/ +#define SCIConnectSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIConnectSegment) +DLL void SCIConnectSegment(sci_desc_t sd, + sci_remote_segment_t *segment, + unsigned int nodeId, + unsigned int segmentId, + unsigned int localAdapterNo, + sci_cb_remote_segment_t callback, + void *callbackArg, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I D I S C O N N E C T S E G M E N T * + * * + * Disconnects from the give mapped shared memory segment * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_BUSY - The segment is currently mapped or in use. * + * * + *********************************************************************************/ +#define SCIDisconnectSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIDisconnectSegment) +DLL void SCIDisconnectSegment(sci_remote_segment_t segment, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I G E T R E M O T E S E G M E N T S I Z E * + * * + *********************************************************************************/ +#define SCIGetRemoteSegmentSize _SISCI_EXPANDE_FUNCTION_NAME(SCIGetRemoteSegmentSize) +DLL unsigned int SCIGetRemoteSegmentSize(sci_remote_segment_t segment); + + + +/********************************************************************************* + * * + * S C I W A I T F O R R E M O T E S E G M E N T E V E N T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_TIMEOUT - The function timed out after specified * + * timeout value. * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation. * + * SCI_ERR_CANCELLED - The wait operation has been cancelled du * + * to a SCIDisconnectSegment() on the same * + * handle. The handle is invalid when this * + * error is returned. * + * * + *********************************************************************************/ +#define SCIWaitForRemoteSegmentEvent _SISCI_EXPANDE_FUNCTION_NAME(SCIWaitForRemoteSegmentEvent) +DLL sci_segment_cb_reason_t SCIWaitForRemoteSegmentEvent( + sci_remote_segment_t segment, + sci_error_t *status, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I M A P R E M O T E S E G M E N T * + * * + * This function is used to include a shared memory segment in the virtual * + * address space of the application. * + * * + * Flags: * + * * + * SCI_FLAG_SHARED_MAP - The low level physical map may be shared by * + * other applications. * + * * + * SCI_FLAG_FIXED_MAP_ADDR - Map at the suggested virtual address * + * SCI_FLAG_READONLY_MAP - The segment is mapped in read-only mode * + * SCI_FLAG_LOCK_OPERATION - Enable Lock operations (fetch and add) * + * SCI_FLAG_READ_PREFETCH_AGGR_HOLD_MAP * + * - Enable aggressive prefetch with speculative * + * hold. * + * * + * SCI_FLAG_READ_PREFETCH_NO_HOLD_MAP * + * - The PSB66 will prefetch 64 bytes. As soon * + * as the PCI read retry has been accepted, * + * the stream will change state to FREE, even * + * if less than 64 bytes were actually read. * + * * + * SCI_FLAG_IO_MAP_IOSPACE - Enable No Prefetch, no speculative hold. * + * * + * SCI_FLAG_DMOVE_MAP - Enable DMOVE packet type. The stream will be * + * set into FREE state immediately. * + * * + * SCI_FLAG_WRITES_DISABLE_GATHER_MAP * + * - Disable use of gather. * + * * + * SCI_FLAG_DISABLE_128_BYTES_PACKETS * + * - Disable use of 128-Byte packets * + * * + * SCI_FLAG_CONDITIONAL_INTERRUPT_MAP * + * - Write operations through this map will cause * + * an atomic "fetch-and-add-one" operation on * + * remote memory, but in addition an interrupt * + * will be generated if the target memory * + * location contained a "null value" before the * + * add operation was carried out. * + * The conditional interrupt flag must also be * + * specified in the SCIRegisterInterruptFlag() * + * function. * + * * + * SCI_FLAG_UNCONDITIONAL_INTERRUPT_MAP * + * - Write operations through this map will cause * + * an interrupt for the remote adapter * + * "in addition to" updating the corresponding * + * remote memory location with the data being * + * written. * + * The unconditional interrupt flag must also * + * be specified in the * + * SCIRegisterInterruptFlag() function. * + * * + * SCI_FLAG_WRITE_BACK_CACHE_MAP * + * - Enable cacheing of the mapped region. * + * Writes through this map will be written to a * + * write back cache, hence no remote SCI updates* + * until the cache line is flushed. The * + * application is responsible for the cache * + * flush operation. * + * The SCImemCopy() function will handle this * + * correctly by doing cache flushes internally. * + * This feature is architechture dependent and * + * not be available on all plattforms. * + * * + * SCI_FLAG_NO_MEMORY_LOOPBACK_MAP * + * - Forces a map to a remote segment located * + * in the local machine to be mapped using * + * SCI loopback. This is useful i.e. if you * + * want to use a regular map access to be * + * serialized with lock operations. * + * The default behaviour is to access a remte * + * segment located in the local machine as a * + * local MMU operation. * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the offset and size is * + * larger than the segment size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as * + * required by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as * + * required by the implementation. * + * * + *********************************************************************************/ +#define SCIMapRemoteSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIMapRemoteSegment) +DLL volatile void *SCIMapRemoteSegment( + sci_remote_segment_t segment, + sci_map_t *map, + unsigned int offset, + unsigned int size, + void *addr, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I M A P L O C A L S E G M E N T * + * * + * Flags * + * * + * SCI_FLAG_FIXED_MAP_ADDR * + * SCI_FLAG_READONLY_MAP * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the offset and size is * + * larger than the segment size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as * + * required by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as * + * required by the implementation. * + * * + *********************************************************************************/ +#define SCIMapLocalSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIMapLocalSegment) +DLL void *SCIMapLocalSegment(sci_local_segment_t segment, + sci_map_t *map, + unsigned int offset, + unsigned int size, + void *addr, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I U N M A P S E G M E N T * + * * + * This function unmaps pages of shared memory from the callers virtual * + * address space. * + * * + * Flags * + * None. * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_BUSY - The map is currently in use. * + * * + *********************************************************************************/ +#define SCIUnmapSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIUnmapSegment) +DLL void SCIUnmapSegment(sci_map_t map, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I C R E A T E S E G M E N T * + * * + * Make the specified segment available for connections via the specified * + * adapter. If successful, the segment can be accessed from remote nodes * + * via the specified adapter. * + * * + * Flags: * + * * + * SCI_FLAG_USE_CALLBACK - The callback function will be invoked for events * + * on this segment. * + * SCI_FLAG_EMPTY - No memory will be allocated for the segment. * + * SCI_FLAG_PRIVATE - The segment will be private meaning it will never * + * be any connections to it. * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_SEGMENTID_USED - The segment with this segmentId is already used * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * * + *********************************************************************************/ +#define SCICreateSegment _SISCI_EXPANDE_FUNCTION_NAME(SCICreateSegment) +DLL void SCICreateSegment(sci_desc_t sd, + sci_local_segment_t *segment, + unsigned int segmentId, + unsigned int size, + sci_cb_local_segment_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I W A I T F O R L O C A L S E G M E N T E V E N T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_TIMEOUT - The function timed out after specified timeout value. * + * SCI_ERR_CANCELLED - The wait operation has been cancelled du to a * + * SCIRemoveSegment() on the same handle. * + * The handle is invalid when this error is returned. * + * * + *********************************************************************************/ +#define SCIWaitForLocalSegmentEvent _SISCI_EXPANDE_FUNCTION_NAME(SCIWaitForLocalSegmentEvent) +DLL sci_segment_cb_reason_t SCIWaitForLocalSegmentEvent( + sci_local_segment_t segment, + unsigned int *sourcenodeId, + unsigned int *localAdapterNo, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I P R E P A R E S E G M E N T * + * * + * Flags * + * * + * SCI_FLAG_DMA_SOURCE_ONLY - The segment will be used as a source segment * + * for DMA operations. On some system types this * + * will enable the SISCI driver to use performance * + * improving features. * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIPrepareSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIPrepareSegment) +DLL void SCIPrepareSegment(sci_local_segment_t segment, + unsigned int localAdapterNo, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I R E M O V E S E G M E N T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_BUSY - Unable to remove the segment. The segment is currently * + * in use. * + * * + *********************************************************************************/ +#define SCIRemoveSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIRemoveSegment) +DLL void SCIRemoveSegment(sci_local_segment_t segment, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I S E T S E G M E N T A V A I L A B L E * + * * + * Flags * + * None. * + * * + * * + * SCI_ERR_SEGMENT_NOT_PREPARED - The segment has not been prepared for access * + * from this adapter. * + * SCI_ERR_ILLEGAL_OPERATION - The segment is created with the * + * SCI_FLAG_PRIVATE flag specified and * + * therefore has no segmentId. * + * * + *********************************************************************************/ +#define SCISetSegmentAvailable _SISCI_EXPANDE_FUNCTION_NAME(SCISetSegmentAvailable) +DLL void SCISetSegmentAvailable(sci_local_segment_t segment, + unsigned int localAdapterNo, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I S E T S E G M E N T U N A V A I L A B L E * + * * + * Flags * + * * + * SCI_FLAG_FORCE_DISCONNECT * + * SCI_FLAG_NOTIFY * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation. * + * * + *********************************************************************************/ +#define SCISetSegmentUnavailable _SISCI_EXPANDE_FUNCTION_NAME(SCISetSegmentUnavailable) +DLL void SCISetSegmentUnavailable(sci_local_segment_t segment, + unsigned int localAdapterNo, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I C R E A T E M A P S E Q U E N C E * + * * + * Flags: * + * * + * SCI_FLAG_FAST_BARRIER * + * * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCICreateMapSequence _SISCI_EXPANDE_FUNCTION_NAME(SCICreateMapSequence) +DLL void SCICreateMapSequence(sci_map_t map, + sci_sequence_t *sequence, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I R E M O V E S E Q U E N C E * + * * + * Flags: * + * None * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCIRemoveSequence _SISCI_EXPANDE_FUNCTION_NAME(SCIRemoveSequence) +DLL void SCIRemoveSequence(sci_sequence_t sequence, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I S T A R T S E Q U E N C E * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIStartSequence _SISCI_EXPANDE_FUNCTION_NAME(SCIStartSequence) +DLL sci_sequence_status_t SCIStartSequence(sci_sequence_t sequence, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I C H E C K S E Q U E N CE * + * * + * Flags * + * * + * SCI_FLAG_NO_FLUSH * + * SCI_FLAG_NO_STORE_BARRIER * + * * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCICheckSequence _SISCI_EXPANDE_FUNCTION_NAME(SCICheckSequence) +DLL sci_sequence_status_t SCICheckSequence(sci_sequence_t sequence, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I S T O R E B A R R I E R * + * * + * Flags * + * None. * + * * + * * + * * + *********************************************************************************/ +#define SCIStoreBarrier _SISCI_EXPANDE_FUNCTION_NAME(SCIStoreBarrier) +DLL void SCIStoreBarrier(sci_sequence_t sequence, + unsigned int flags); + + + + +/********************************************************************************* + * * + * S C I F L U S H R E A D B U F F E R S * + * * + *********************************************************************************/ +#define SCIFlushReadBuffers _SISCI_EXPANDE_FUNCTION_NAME(SCIFlushReadBuffers) +DLL void SCIFlushReadBuffers(sci_sequence_t sequence); + + + + +/********************************************************************************* + * * + * S C I P R O B E N O D E * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_NO_LINK_ACCESS - It was not possible to communicate via the * + * local adapter. * + * SCI_ERR_NO_REMOTE_LINK_ACCESS - It was not possible to communicate via a * + * remote switch port. * + * * + *********************************************************************************/ +#define SCIProbeNode _SISCI_EXPANDE_FUNCTION_NAME(SCIProbeNode) +DLL int SCIProbeNode(sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int nodeId, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I G E T C S R R E G I S T E R * + * * + * SISCI Priveleged function * + * * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_NO_LINK_ACCESS - It was not possible to communicate via the * + * local adapter. * + * SCI_ERR_NO_REMOTE_LINK_ACCESS - It was not possible to communicate via a * + * remote switch port. * + * * + *********************************************************************************/ +#define SCIGetCSRRegister _SISCI_EXPANDE_FUNCTION_NAME(SCIGetCSRRegister) +DLL unsigned int SCIGetCSRRegister(sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int SCINodeId, + unsigned int CSROffset, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I S E T C S R R E G I S T E R * + * * + * SISCI Priveleged function * + * * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_NO_LINK_ACCESS - It was not possible to communicate via the * + * local adapter. * + * SCI_ERR_NO_REMOTE_LINK_ACCESS - It was not possible to communicate via a * + * remote switch port. * + * * + *********************************************************************************/ +#define SCISetCSRRegister _SISCI_EXPANDE_FUNCTION_NAME(SCISetCSRRegister) +DLL void SCISetCSRRegister(sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int SCINodeId, + unsigned int CSROffset, + unsigned int CSRValue, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I G E T L O C A L C S R * + * * + * SISCI Priveleged function * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIGetLocalCSR _SISCI_EXPANDE_FUNCTION_NAME(SCIGetLocalCSR) +DLL unsigned int SCIGetLocalCSR(sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int CSROffset, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I S E T L O C A L C S R * + * * + * SISCI Priveleged function + * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCISetLocalCSR _SISCI_EXPANDE_FUNCTION_NAME(SCISetLocalCSR) +DLL void SCISetLocalCSR(sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int CSROffset, + unsigned int CSRValue, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I A T T A C H P H Y S I C A L M E M O R Y * + * * + * SISCI Priveleged function * + * * + * Description: * + * * + * This function enables usage of physical devices and memory regions where the * + * Physical PCI bus address ( and mapped CPU address ) are already known. * + * The function will register the physical memory as a SISCI segment which can * + * be connected and mapped as a regular SISCI segment. * + * * + * Requirements: * + * * + * SCICreateSegment() with flag SCI_FLAG_EMPTY must have been called in advance * + * * + * Parameter description: * + * sci_ioaddr_t ioaddress : This is the address on the PCI bus that a PCI bus * + * master has to use to write to the specified memory * + * void * address : This is the (mapped) virtual address that the * + * application has to use to access the device. * + * This means that the device has to be mapped in * + * advance bye the devices own driver. * + * If the device is not to be accessed by the local * + * CPU, the address pointer shold be set to NULL * + * Flags * + * * + * None * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIAttachPhysicalMemory _SISCI_EXPANDE_FUNCTION_NAME(SCIAttachPhysicalMemory) +DLL void SCIAttachPhysicalMemory(sci_ioaddr_t ioaddress, + void *address, + unsigned int busNo, + unsigned int size, + sci_local_segment_t segment, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I Q U E R Y * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_QUERY - Unrecognized command. * + * * + *********************************************************************************/ +#define SCIQuery _SISCI_EXPANDE_FUNCTION_NAME(SCIQuery) +DLL void SCIQuery(unsigned int command, + void *data, + unsigned int flags, + sci_error_t *error); + + +/* MAJOR QUERY COMMANDS */ + +/* This command requires a pointer to a structure of type */ +/* "sci_query_string". The string will be filled in by the query. */ +#define SCI_Q_VENDORID _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_VENDORID) +extern const unsigned int SCI_Q_VENDORID; + + +/* Same as for SCI_VENDOR_ID */ +#define SCI_Q_API _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_API) +extern const unsigned int SCI_Q_API; + + +/* User passes a pointer to an allocated object of the */ +/* "sci_query_adapter" struct. */ +#define SCI_Q_ADAPTER _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER) +extern const unsigned int SCI_Q_ADAPTER; + + +/* User passes a pointer to an allocated object of the */ +/* "sci_query_system" struct. */ +#define SCI_Q_SYSTEM _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SYSTEM) +extern const unsigned int SCI_Q_SYSTEM; + +#define SCI_Q_LOCAL_SEGMENT _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_LOCAL_SEGMENT) +extern const unsigned int SCI_Q_LOCAL_SEGMENT; + +#define SCI_Q_REMOTE_SEGMENT _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_REMOTE_SEGMENT) +extern const unsigned int SCI_Q_REMOTE_SEGMENT; + +#define SCI_Q_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_MAP) +extern const unsigned int SCI_Q_MAP; + +typedef struct { + char *str; /* Pointer to a string of minimum "length" characters */ + unsigned int length; +} sci_query_string_t; + + +typedef struct { + unsigned int localAdapterNo; /* The adapter no. that the query concern. */ + unsigned int portNo; /* The SCI Link port number that the query concern. */ + unsigned int subcommand; /* A subcommand as specified below. */ + void *data; /* A pointer to an unsigned int that will return */ + /* the response to the query. */ +} sci_query_adapter_t; + + +typedef struct { + unsigned int subcommand; /* A subcommand as specified below. */ + void *data; /* A pointer to an unsigned int that will return */ + /* the response to the query. */ +} sci_query_system_t; + +typedef struct { + sci_local_segment_t segment; + unsigned int subcommand; + union { + sci_ioaddr_t ioaddr; + } data; +} sci_query_local_segment_t; + +typedef struct { + sci_remote_segment_t segment; + unsigned int subcommand; + union { + sci_ioaddr_t ioaddr; + } data; +} sci_query_remote_segment_t; + +typedef struct { + sci_map_t map; + unsigned int subcommand; + unsigned int data; +} sci_query_map_t; + +/* Minor query commands (sub-commands) for adapter specific information SCI_ADAPTER */ +#define SCI_Q_ADAPTER_DMA_SIZE_ALIGNMENT _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_DMA_SIZE_ALIGNMENT) +extern const unsigned int SCI_Q_ADAPTER_DMA_SIZE_ALIGNMENT; + +#define SCI_Q_ADAPTER_DMA_OFFSET_ALIGNMENT _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_DMA_OFFSET_ALIGNMENT) +extern const unsigned int SCI_Q_ADAPTER_DMA_OFFSET_ALIGNMENT; + +#define SCI_Q_ADAPTER_DMA_MTU _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_DMA_MTU) +extern const unsigned int SCI_Q_ADAPTER_DMA_MTU; + +#define SCI_Q_ADAPTER_SUGGESTED_MIN_DMA_SIZE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_SUGGESTED_MIN_DMA_SIZE) +extern const unsigned int SCI_Q_ADAPTER_SUGGESTED_MIN_DMA_SIZE; + +#define SCI_Q_ADAPTER_SUGGESTED_MIN_BLOCK_SIZE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_SUGGESTED_MIN_BLOCK_SIZE) +extern const unsigned int SCI_Q_ADAPTER_SUGGESTED_MIN_BLOCK_SIZE; + +#define SCI_Q_ADAPTER_NODEID _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_NODEID) +extern const unsigned int SCI_Q_ADAPTER_NODEID; + +#define SCI_Q_ADAPTER_SERIAL_NUMBER _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_SERIAL_NUMBER) +extern const unsigned int SCI_Q_ADAPTER_SERIAL_NUMBER; + +#define SCI_Q_ADAPTER_CARD_TYPE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_CARD_TYPE) +extern const unsigned int SCI_Q_ADAPTER_CARD_TYPE; + +#define SCI_Q_ADAPTER_NUMBER_OF_STREAMS _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_NUMBER_OF_STREAMS) +extern const unsigned int SCI_Q_ADAPTER_NUMBER_OF_STREAMS; + +#define SCI_Q_ADAPTER_STREAM_BUFFER_SIZE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_STREAM_BUFFER_SIZE) +extern const unsigned int SCI_Q_ADAPTER_STREAM_BUFFER_SIZE; + +#define SCI_Q_ADAPTER_CONFIGURED _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_CONFIGURED) +extern const unsigned int SCI_Q_ADAPTER_CONFIGURED; + +#define SCI_Q_ADAPTER_LINK_OPERATIONAL _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_LINK_OPERATIONAL) +extern const unsigned int SCI_Q_ADAPTER_LINK_OPERATIONAL; + +#define SCI_Q_ADAPTER_HW_LINK_STATUS_IS_OK _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_HW_LINK_STATUS_IS_OK) +extern const unsigned int SCI_Q_ADAPTER_HW_LINK_STATUS_IS_OK; + +#define SCI_Q_ADAPTER_NUMBER _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_NUMBER) +extern const unsigned int SCI_Q_ADAPTER_NUMBER; + +#define SCI_Q_ADAPTER_INSTANCE_NUMBER _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_INSTANCE_NUMBER) +extern const unsigned int SCI_Q_ADAPTER_INSTANCE_NUMBER; + +#define SCI_Q_ADAPTER_FIRMWARE_OK _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_FIRMWARE_OK) +extern const unsigned int SCI_Q_ADAPTER_FIRMWARE_OK; + +#define SCI_Q_ADAPTER_CONNECTED_TO_SWITCH _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_CONNECTED_TO_SWITCH) +extern const unsigned int SCI_Q_ADAPTER_CONNECTED_TO_SWITCH; + +#define SCI_Q_ADAPTER_LOCAL_SWITCH_TYPE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_LOCAL_SWITCH_TYPE) +extern const unsigned int SCI_Q_ADAPTER_LOCAL_SWITCH_TYPE; + +#define SCI_Q_ADAPTER_LOCAL_SWITCH_PORT_NUMBER _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_LOCAL_SWITCH_PORT_NUMBER) +extern const unsigned int SCI_Q_ADAPTER_LOCAL_SWITCH_PORT_NUMBER; + +#define SCI_Q_ADAPTER_CONNECTED_TO_EXPECTED_SWITCH_PORT _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_CONNECTED_TO_EXPECTED_SWITCH_PORT) +extern const unsigned int SCI_Q_ADAPTER_CONNECTED_TO_EXPECTED_SWITCH_PORT; + +#define SCI_Q_ADAPTER_ATT_PAGE_SIZE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_ATT_PAGE_SIZE) +extern const unsigned int SCI_Q_ADAPTER_ATT_PAGE_SIZE; + +#define SCI_Q_ADAPTER_ATT_NUMBER_OF_ENTRIES _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_ATT_NUMBER_OF_ENTRIES) +extern const unsigned int SCI_Q_ADAPTER_ATT_NUMBER_OF_ENTRIES; + +#define SCI_Q_ADAPTER_ATT_AVAILABLE_ENTRIES _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_ATT_AVAILABLE_ENTRIES) +extern const unsigned int SCI_Q_ADAPTER_ATT_AVAILABLE_ENTRIES; + +#define SCI_Q_ADAPTER_PHYS_MEM_NODEID _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SCI_Q_ADAPTER_PHYS_MEM_NODEID) +extern const unsigned int SCI_Q_ADAPTER_PHYS_MEM_NODEID; + +#define SCI_Q_ADAPTER_PHYS_MBX_NODEID _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SCI_Q_ADAPTER_PHYS_MBX_NODEID) +extern const unsigned int SCI_Q_ADAPTER_PHYS_MBX_NODEID; + +#define SCI_Q_ADAPTER_PHYS_LINK_PORT_NODEID _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_PHYS_LINK_PORT_NODEID) +extern const unsigned int SCI_Q_ADAPTER_PHYS_LINK_PORT_NODEID; + +#define SCI_Q_ADAPTER_SCI_LINK_FREQUENCY _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_SCI_LINK_FREQUENCY) +extern const unsigned int SCI_Q_ADAPTER_SCI_LINK_FREQUENCY; + +#define SCI_Q_ADAPTER_B_LINK_FREQUENCY _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_B_LINK_FREQUENCY) +extern const unsigned int SCI_Q_ADAPTER_B_LINK_FREQUENCY; + +#define SCI_Q_ADAPTER_IO_BUS_FREQUENCY _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_IO_BUS_FREQUENCY) +extern const unsigned int SCI_Q_ADAPTER_IO_BUS_FREQUENCY; + +/* Minor query commands (sub-commands) for adapter specific information SCI_SYSTEM */ +#define SCI_Q_SYSTEM_HOSTBRIDGE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SYSTEM_HOSTBRIDGE) +extern const unsigned int SCI_Q_SYSTEM_HOSTBRIDGE; + +#define SCI_Q_SYSTEM_WRITE_POSTING_ENABLED _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SYSTEM_WRITE_POSTING_ENABLED) +extern const unsigned int SCI_Q_SYSTEM_WRITE_POSTING_ENABLED; + +#define SCI_Q_SYSTEM_WRITE_COMBINING_ENABLED _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SYSTEM_WRITE_COMBINING_ENABLED) +extern const unsigned int SCI_Q_SYSTEM_WRITE_COMBINING_ENABLED; + +#define SCI_Q_LOCAL_SEGMENT_IOADDR _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_LOCAL_SEGMENT_IOADDR) +extern const unsigned int SCI_Q_LOCAL_SEGMENT_IOADDR; + +#define SCI_Q_REMOTE_SEGMENT_IOADDR _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_REMOTE_SEGMENT_IOADDR) +extern const unsigned int SCI_Q_REMOTE_SEGMENT_IOADDR; + +#define SCI_Q_MAP_MAPPED_TO_LOCAL_TARGET _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_MAP_MAPPED_TO_LOCAL_TARGET) +extern const unsigned int SCI_Q_MAP_MAPPED_TO_LOCAL_TARGET; + +#define SCI_Q_MAP_QUERY_REMOTE_MAPPED_TO_LOCAL_TARGET _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_MAP_QUERY_REMOTE_MAPPED_TO_LOCAL_TARGET) +extern const unsigned int SCI_Q_MAP_QUERY_REMOTE_MAPPED_TO_LOCAL_TARGET; + +#define HOSTBRIDGE_NOT_AVAILABLE _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_NOT_AVAILABLE) +extern const unsigned int HOSTBRIDGE_NOT_AVAILABLE; + +#define HOSTBRIDGE_UNKNOWN _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_UNKNOWN) +extern const unsigned int HOSTBRIDGE_UNKNOWN; + +#define HOSTBRIDGE_440FX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_440FX) +extern const unsigned int HOSTBRIDGE_440FX; + +#define HOSTBRIDGE_440LX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_440LX) +extern const unsigned int HOSTBRIDGE_440LX; + +#define HOSTBRIDGE_440BX_A _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_440BX_A) +extern const unsigned int HOSTBRIDGE_440BX_A; + +#define HOSTBRIDGE_440BX_B _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_440BX_B) +extern const unsigned int HOSTBRIDGE_440BX_B; + +#define HOSTBRIDGE_440GX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_440GX) +extern const unsigned int HOSTBRIDGE_440GX; + +#define HOSTBRIDGE_450KX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_450KX) +extern const unsigned int HOSTBRIDGE_450KX; + +#define HOSTBRIDGE_430NX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_430NX) +extern const unsigned int HOSTBRIDGE_430NX; + +#define HOSTBRIDGE_450NX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_450NX) +extern const unsigned int HOSTBRIDGE_450NX; + +#define HOSTBRIDGE_450NX_MICO _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_450NX_MICO) +extern const unsigned int HOSTBRIDGE_450NX_MICO; + +#define HOSTBRIDGE_450NX_PXB _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_450NX_PXB) +extern const unsigned int HOSTBRIDGE_450NX_PXB; + +#define HOSTBRIDGE_I810 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I810) +extern const unsigned int HOSTBRIDGE_I810; + +#define HOSTBRIDGE_I810_DC100 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I810_DC100) +extern const unsigned int HOSTBRIDGE_I810_DC100; + +#define HOSTBRIDGE_I810E _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I810E) +extern const unsigned int HOSTBRIDGE_I810E; + +#define HOSTBRIDGE_I815 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I815) +extern const unsigned int HOSTBRIDGE_I815; + +#define HOSTBRIDGE_I840 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I840) +extern const unsigned int HOSTBRIDGE_I840; + +#define HOSTBRIDGE_I850 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I850) +extern const unsigned int HOSTBRIDGE_I850; + +#define HOSTBRIDGE_I860 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I860) +extern const unsigned int HOSTBRIDGE_I860; + +#define HOSTBRIDGE_INTEL_E7500 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_INTEL_E7500) +extern const unsigned int HOSTBRIDGE_INTEL_E7500; + +#define HOSTBRIDGE_VIA_KT133 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_VIA_KT133) +extern const unsigned int HOSTBRIDGE_VIA_KT133; + +#define HOSTBRIDGE_VIA_KX133 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_VIA_KX133) +extern const unsigned int HOSTBRIDGE_VIA_KX133; + +#define HOSTBRIDGE_VIA_APOLLO_PRO_133A _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_VIA_APOLLO_PRO_133A) +extern const unsigned int HOSTBRIDGE_VIA_APOLLO_PRO_133A; + +#define HOSTBRIDGE_VIA_APOLLO_PRO_266 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_VIA_APOLLO_PRO_266) +extern const unsigned int HOSTBRIDGE_VIA_APOLLO_PRO_266; + +#define HOSTBRIDGE_AMD_760_MP _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_AMD_760_MP) +extern const unsigned int HOSTBRIDGE_AMD_760_MP; + +#define HOSTBRIDGE_AMD_HAMMER _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_AMD_HAMMER) +extern const unsigned int HOSTBRIDGE_AMD_HAMMER; + +#define HOSTBRIDGE_SERVERWORKS_HE _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_HE) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_HE; + +#define HOSTBRIDGE_SERVERWORKS_HE_B _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_HE_B) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_HE_B; + +#define HOSTBRIDGE_SERVERWORKS_LE _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_LE) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_LE; + +#define HOSTBRIDGE_SERVERWORKS_GC_HE _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_GC_HE) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_GC_HE; + +#define HOSTBRIDGE_SERVERWORKS_GC_LE _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_GC_LE) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_GC_LE; + +#define HOSTBRIDGE_SERVERWORKS_GC_WS _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_GC_WS) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_GC_WS; + +#define HOSTBRIDGE_SERVERWORKS_GC_SL _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_GC_SL) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_GC_SL; + + +#define HOSTBRIDGE_WRITE_POSTING_DISABLED _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_WRITE_POSTING_DISABLED) +extern const unsigned int HOSTBRIDGE_WRITE_POSTING_DISABLED; + +#define HOSTBRIDGE_WRITE_POSTING_ENABLED _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_WRITE_POSTING_ENABLED) +extern const unsigned int HOSTBRIDGE_WRITE_POSTING_ENABLED; + + + + +/********************************************************************************* + * * + * S C I C R E A T E D M A Q U E U E * + * * + * Flags * + * * + * SCI_FLAG_DMA_PHDMA : Create physical DMA queue. Please note that this is an * + * priveleged operation. * + * * + * * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCICreateDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCICreateDMAQueue) +DLL void SCICreateDMAQueue(sci_desc_t sd, + sci_dma_queue_t *dq, + unsigned int localAdapterNo, + unsigned int maxEntries, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I R E M O V E D M A Q U E U E * + * * + * Flags * + * None. * * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Not allowed in this queue state. * + * * + *********************************************************************************/ +#define SCIRemoveDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCIRemoveDMAQueue) +DLL void SCIRemoveDMAQueue(sci_dma_queue_t dq, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I E N Q U E U E D M A T R A N S F E R * + * * + * Flags: * + * * + * SCI_FLAG_DMA_READ - The DMA will be remote --> local * + * (default is local --> remote) * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the offset and size is larger * + * than the segment size or larger than max * + * DMA size. * + * SCI_ERR_MAX_ENTRIES - The DMA queue is full * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_SEGMENT_NOT_PREPARED - The local segment has not been prepared for * + * access from the adapter associated with the * + * queue. * + * SCI_ERR_SEGMENT_NOT_CONNECTED - The remote segment is not connected through * + * the adapter associated with the queue. * + *********************************************************************************/ +#define SCIEnqueueDMATransfer _SISCI_EXPANDE_FUNCTION_NAME(SCIEnqueueDMATransfer) +DLL sci_dma_queue_state_t SCIEnqueueDMATransfer(sci_dma_queue_t dq, + sci_local_segment_t localSegment, + sci_remote_segment_t remoteSegment, + unsigned int localOffset, + unsigned int remoteOffset, + unsigned int size, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I P O S T D M A Q U E U E * + * * + * Flags: * + * * + * SCI_FLAG_USE_CALLBACK - The end of the transfer will cause the callback * + * function to be invoked. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * * + *********************************************************************************/ +#define SCIPostDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCIPostDMAQueue) +DLL void SCIPostDMAQueue(sci_dma_queue_t dq, + sci_cb_dma_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I A B O R T D M A Q U E U E * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * * + *********************************************************************************/ +#define SCIAbortDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCIAbortDMAQueue) +DLL void SCIAbortDMAQueue(sci_dma_queue_t dq, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I R E S E T D M A Q U E U E * + * * + * Flags * + * None. * * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIResetDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCIResetDMAQueue) +DLL void SCIResetDMAQueue(sci_dma_queue_t dq, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I D M A Q U E U E S T A T E * + * * + *********************************************************************************/ +#define SCIDMAQueueState _SISCI_EXPANDE_FUNCTION_NAME(SCIDMAQueueState) +DLL sci_dma_queue_state_t SCIDMAQueueState(sci_dma_queue_t dq); + + + +/********************************************************************************* + * * + * S C I W A I T F O R D M A Q U E U E * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * SCI_ERR_TIMEOUT - The function timed out after specified * + * timeout value. * + * * + *********************************************************************************/ +#define SCIWaitForDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCIWaitForDMAQueue) +DLL sci_dma_queue_state_t SCIWaitForDMAQueue(sci_dma_queue_t dq, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I P H D M A E N Q U E U E * + * * + * SISCI Priveleged function * + * * + * Flags * + * * + * SCI_FLAG_DMA_READ * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCIphDmaEnqueue _SISCI_EXPANDE_FUNCTION_NAME(SCIphDmaEnqueue) +DLL void SCIphDmaEnqueue(sci_dma_queue_t dmaqueue, + unsigned int size, + sci_ioaddr_t localBusAddr, + unsigned int remote_nodeid, + unsigned int remote_highaddr, + unsigned int remote_lowaddr, + unsigned int flags, + sci_error_t *error); + +/********************************************************************************* + * * + * S C I P H D M A S T A R T * + * * + * Flags * + * * + * SCI_FLAG_DMA_WAIT * + * SCI_FLAG_USE_CALLBACK * + * SCI_FLAG_DMA_RESET * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCIphDmaStart _SISCI_EXPANDE_FUNCTION_NAME(SCIphDmaStart) +DLL sci_dma_queue_state_t SCIphDmaStart(sci_dma_queue_t dmaqueue, + sci_cb_dma_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + +/********************************************************************************* + * * + * S C I C R E A T E I N T E R R U P T * + * * + * Flags * + * * + * SCI_FLAG_USE_CALLBACK * + * SCI_FLAG_FIXED_INTNO * + * SCI_FLAG_SHARED_INT * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_INTNO_USED - This interrupt number is already used. * + * * + *********************************************************************************/ +#define SCICreateInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCICreateInterrupt) +DLL void SCICreateInterrupt(sci_desc_t sd, + sci_local_interrupt_t *interrupt, + unsigned int localAdapterNo, + unsigned int *interruptNo, + sci_cb_interrupt_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I R E M O V E I N T E R R U P T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCIRemoveInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIRemoveInterrupt) +DLL void SCIRemoveInterrupt(sci_local_interrupt_t interrupt, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I W A I T F O R I N T E R R U P T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_TIMEOUT - The function timed out after specified timeout value. * + * SCI_ERR_CANCELLED - The wait was interrupted by a call to * + * SCIRemoveInterrupt. * + * The handle is invalid when this error code is returned.* + * * + *********************************************************************************/ +#define SCIWaitForInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIWaitForInterrupt) +DLL void SCIWaitForInterrupt(sci_local_interrupt_t interrupt, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I C O N N E C T I N T E R R U P T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_NO_SUCH_INTNO - No such interrupt number. * + * SCI_ERR_CONNECTION_REFUSED - Connection attempt refused by remote node. * + * SCI_ERR_TIMEOUT - The function timed out after specified * + * timeout value. * + * * + *********************************************************************************/ +#define SCIConnectInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIConnectInterrupt) +DLL void SCIConnectInterrupt(sci_desc_t sd, + sci_remote_interrupt_t *interrupt, + unsigned int nodeId, + unsigned int localAdapterNo, + unsigned int interruptNo, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I D I S C O N N E C T I N T E R R U P T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIDisconnectInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIDisconnectInterrupt) +DLL void SCIDisconnectInterrupt(sci_remote_interrupt_t interrupt, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I T R I G G E R I N T E R R U P T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCITriggerInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCITriggerInterrupt) +DLL void SCITriggerInterrupt(sci_remote_interrupt_t interrupt, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I R E G I S T E R I N T E R R U P T F L A G * + * * + * * + * This function register an "interrupt flag" that is identified as an unique * + * location within a local segment. If successful, the resulting interrupt * + * handle will have been associated with the specified local segment. * + * * + * It is up to the (remote) client(s) to set up an "interrupt mapping" for the * + * corresponding segment offset using either the * + * * + * - SCI_FLAG_CONDITIONAL_INTERRUPT_MAP * + * * + * or the * + * * + * - SCI_FLAG_UNCONDITIONAL_DATA_INTERRUPT_MAP * + * * + * option to "SCIMapRemoteSegment()". - I.e. after having established a * + * connection to the corresponding segment. A trigger operation can then * + * be implemented using a store operation via the relevant "interrupt map". * + * * + * * + * * + * * + * * + * Flags: * + * * + * SCI_FLAG_CONDITIONAL_INTERRUPT - Triggering is to take place using * + * "conditional interrupts". * + * * + * * + * * + * Specific error codes for this function: * + * None. * + * * + *********************************************************************************/ +#define SCIRegisterInterruptFlag _SISCI_EXPANDE_FUNCTION_NAME(SCIRegisterInterruptFlag) +DLL void SCIRegisterInterruptFlag( + unsigned int localAdapterNo, + sci_local_interrupt_t *interrupt, + sci_local_segment_t segment, + unsigned int offset, + sci_cb_interrupt_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I E N A B L E C O N D I T I O N A L I N T E R R U P T * + * * + * * + * This function make sure that another HW interrupt will take place the next * + * time the corresponding interrupt flag is triggered by a * + * "conditional interrupt" operation. * + * * + * Default semantics: * + * * + * When successful, the client can rely on that the first subsequent trigger * + * operation will cause a HW interrupt and subsequently cause the client * + * handler function to be invoked. * + * * + * If an interrupt was triggered in parallell with the enable operation, then * + * the operation will fail (SCI_ERR_COND_INT_RACE_PROBLEM), and the client can * + * not rely on another trigger operation will lead to handler invocation. * + * Hence, any state checking normally associated with handling the * + * corresponding interrupt should take place before attempting to enable * + * again. * + * * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_COND_INT_RACE_PROBLEM - The enable operation failed because an * + * incomming trigger operation happened * + * concurrently. * + * * + *********************************************************************************/ +#define SCIEnableConditionalInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIEnableConditionalInterrupt) +DLL void SCIEnableConditionalInterrupt( + sci_local_interrupt_t interrupt, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I D I S A B L E C O N D I T I O N A L I N T E R R U P T * + * * + * * + * Prevent subsequent "conditional interrupt"trigger operations for * + * the specified interupt flag from causing HW interrupt and handler * + * invocations. * + * * + * * + * Default semantics: * + * * + * If successful, no subsequent HW interrupts will take place, but handler * + * invocations that have already been scheduled may still take place. * + * * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIDisableConditionalInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIDisableConditionalInterrupt) +DLL void SCIDisableConditionalInterrupt( + sci_local_interrupt_t interrupt, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I G E T C O N D I T I O N A L I N T E R R U P T C O U N T E R * + * * + * * + * Returns a value that indicates the number of times this flag has * + * been trigged since the last time it was enabled or disabled. * + * Calling the SCIEnableConditionalInterrupt / SCIDisableConditionalInterrupt * + * functions will reset the counter value. * + * * + * Default semantics: * + * * + * If successful, the current trig count is returned in the * + * interruptTrigCounter parameter. * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OVERFLOW - The number of trig operations have exceeded the range * + * that can be counted. * + *********************************************************************************/ +#define SCIGetConditionalInterruptTrigCounter _SISCI_EXPANDE_FUNCTION_NAME(SCIGetConditionalInterruptTrigCounter) +DLL void SCIGetConditionalInterruptTrigCounter( + sci_local_interrupt_t interrupt, + unsigned int *interruptTrigCounter, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I T R A N S F E R B L O C K * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the size and offset is larger * + * than the corresponding map size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_TRANSFER_FAILED - The data transfer failed. * + * * + *********************************************************************************/ +#define SCITransferBlock _SISCI_EXPANDE_FUNCTION_NAME(SCITransferBlock) +DLL void SCITransferBlock(sci_map_t sourceMap, + unsigned int sourceOffset, + sci_map_t destinationMap, + unsigned int destinationOffset, + unsigned int size, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I T R A N S F E R B L O C K A S Y N C * + * * + * Flags * + * * + * SCI_FLAG_BLOCK_READ * + * SCI_FLAG_USE_CALLBACK * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the size and offset is larger than * + * the corresponding map size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required by * + * the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_TRANSFER_FAILED - The data transfer failed. * + * * + *********************************************************************************/ +#define SCITransferBlockAsync _SISCI_EXPANDE_FUNCTION_NAME(SCITransferBlockAsync) +DLL void SCITransferBlockAsync(sci_map_t sourceMap, + unsigned int sourceOffset, + sci_map_t destinationMap, + unsigned int destinationOffset, + unsigned int size, + sci_block_transfer_t *block, + sci_cb_block_transfer_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I W A I T F O R B L O C K T R A N S F E R * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * SCI_ERR_TIMEOUT - The function timed out after specified * + * timeout value. * + * * + *********************************************************************************/ +#define SCIWaitForBlockTransfer _SISCI_EXPANDE_FUNCTION_NAME(SCIWaitForBlockTransfer) +DLL void SCIWaitForBlockTransfer(sci_block_transfer_t block, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I A B O R T B L O C K T R A N S F E R * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * * + *********************************************************************************/ +#define SCIAbortBlockTransfer _SISCI_EXPANDE_FUNCTION_NAME(SCIAbortBlockTransfer) +DLL void SCIAbortBlockTransfer(sci_block_transfer_t block, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I M E M C P Y * + * * + * Flags: * + * SCI_FLAG_BLOCK_READ * + * SCI_FLAG_ERROR_CHECK * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the size and offset is larger * + * than the corresponding map size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_TRANSFER_FAILED - The data transfer failed. * + * * + *********************************************************************************/ + +#define SCIMemCpy _SISCI_EXPANDE_FUNCTION_NAME(SCIMemCpy) +DLL void SCIMemCpy(sci_sequence_t sequence, + void *memAddr, + sci_map_t remoteMap, + unsigned int remoteOffset, + unsigned int size, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I M E M C O P Y * + * * + * Flags: * + * SCI_FLAG_BLOCK_READ * + * SCI_FLAG_ERROR_CHECK * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the size and offset is larger * + * than the corresponding map size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_TRANSFER_FAILED - The data transfer failed. * + * * + *********************************************************************************/ + + +#define SCIMemCopy _SISCI_EXPANDE_FUNCTION_NAME(SCIMemCopy) +DLL void SCIMemCopy(void *memAddr, + sci_map_t remoteMap, + unsigned int remoteOffset, + unsigned int size, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I R E G I S T E R S E G M E N T M E M O R Y * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required by * + * the implementation. * + * SCI_ERR_ILLEGAL_ADDRESS - Illegal address. * + * SCI_ERR_OUT_OF_RANGE - Size is larger than the maximum size for the * + * local segment. * + * * + *********************************************************************************/ +#define SCIRegisterSegmentMemory _SISCI_EXPANDE_FUNCTION_NAME(SCIRegisterSegmentMemory) +DLL void SCIRegisterSegmentMemory(void *address, + unsigned int size, + sci_local_segment_t segment, + unsigned int flags, + sci_error_t *error); + + + + + +/********************************************************************************* + * * + * S C I C O N N E C T S C I S P A C E * + * * + * SISCI Priveleged function * + * * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_CONNECTION_REFUSED - Connection attempt refused by remote node. * + * * + *********************************************************************************/ +#define SCIConnectSCISpace _SISCI_EXPANDE_FUNCTION_NAME(SCIConnectSCISpace) +DLL void SCIConnectSCISpace(sci_desc_t sd, + unsigned int localAdapterNo, + sci_remote_segment_t *segment, + sci_address_t address, + unsigned int size, + unsigned int flags, + sci_error_t *error); + + + +/* + * ===================================================================================== + * + * S C I A T T A C H L O C A L S E G M E N T + * Description: + * + * SCIAttachLocalSegment() permits an application to "attach" to an already existing + * local segment, implying that two or more application want + * share the same local segment. The prerequest, is that the + * application which originally created the segment ("owner") has + * preformed a SCIShareSegment() in order to mark the segment + * "shareable". + * + * + * Flags: + * + * SCI_FLAG_USE_CALLBACK - The callback function will be invoked for events + * on this segment. + * + * + * Specific error codes for this function: + * + * SCI_ERR_ACCESS - No such shared segment + * SCI_ERR_NO_SUCH_SEGMENT - No such segment + * Note: Current implenentation will return SCI_ERR_ACCESS for both cases. This will + * change from next release. Application should handle both cases. + * + * ===================================================================================== + */ +#define SCIAttachLocalSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIAttachLocalSegment) + +DLL void +SCIAttachLocalSegment(sci_desc_t sd, + sci_local_segment_t *segment, + unsigned int segmentId, + unsigned int *size, + sci_cb_local_segment_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); +/* + * ===================================================================================== + * + * S C I S H A R E S E G M E N T + * + * Description: + * + * SCIShareSegment() permits other application to "attach" to an already existing + * local segment, implying that two or more application want + * share the same local segment. The prerequest, is that the + * application which originally created the segment ("owner") has + * preformed a SCIShareSegment() in order to mark the segment + * "shareable". + * + * + * Flags: + * none + * + * Specific error codes for this function: + * + * + * + * ===================================================================================== + */ +#define SCIShareSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIShareSegment) + +DLL void +SCIShareSegment(sci_local_segment_t segment, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I F L U S H * + * * + * This function will flush the CPU buffers and the PSB buffers. * + * * + * Flags * + * SCI_FLAG_FLUSH_CPU_BUFFERS_ONLY : * + * Only flush CPU buffers ( Write combining * + * etc buffers). * + * * + *********************************************************************************/ + +#define SCIFlush _SISCI_EXPANDE_FUNCTION_NAME(SCIFlush) +DLL void SCIFlush(sci_sequence_t sequence, + unsigned int flags); + +#if defined(CPLUSPLUS) || defined(__cplusplus) +} +#endif + + +#endif + + + + + + + + + + + diff --git a/ndb/src/external/LINUX.x86/sci/include/sisci_demolib.h b/ndb/src/external/LINUX.x86/sci/include/sisci_demolib.h new file mode 100644 index 00000000000..4284fc5585c --- /dev/null +++ b/ndb/src/external/LINUX.x86/sci/include/sisci_demolib.h @@ -0,0 +1,226 @@ +/* $Id: sisci_demolib.h,v 1.1 2002/12/13 12:17:21 hin Exp $ */ + +/******************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + +#ifndef _SISCI_DEMOLIB_H +#define _SISCI_DEMOLIB_H + + +#if defined(_REENTRANT) + +#define _SISCI_DEMOLIB_EXPAND_NAME(name) _SISCI_DEMOLIB_MT_ ## name + +#else + +#define _SISCI_DEMOLIB_EXPAND_NAME(name) _SISCI_DEMOLIB_ST_ ## name + +#endif + +/*********************************************************************************/ +/* Q U E R Y A D A P T E R */ +/* */ +/*********************************************************************************/ + +#define QueryAdapter _SISCI_DEMOLIB_EXPAND_NAME(QueryAdapter) + +sci_error_t QueryAdapter( + unsigned int subcommand, + unsigned int localAdapterNo, + unsigned int portNo, + unsigned int *data); + + +/*********************************************************************************/ +/* Q U E R Y S Y S T E M */ +/* */ +/*********************************************************************************/ + +#define QuerySystem _SISCI_DEMOLIB_EXPAND_NAME(QuerySystem) + +sci_error_t QuerySystem( + unsigned int subcommand, + unsigned int *data); + + +/*********************************************************************************/ +/* D E T E C T F I R S T A D A P T E R C A R D */ +/* */ +/*********************************************************************************/ + +#define DetectFirstAdapterCard _SISCI_DEMOLIB_EXPAND_NAME(DetectFirstAdapterCard) + +sci_error_t DetectFirstAdapterCard( + unsigned int *localAdapterNo, + unsigned int *localNodeId); + + +/*********************************************************************************/ +/* G E T A D A P T E R T Y P E */ +/* */ +/*********************************************************************************/ + +#define GetAdapterType _SISCI_DEMOLIB_EXPAND_NAME(GetAdapterType) + +sci_error_t GetAdapterType(unsigned int localAdapterNo, + unsigned int *adapterType); + + +/*********************************************************************************/ +/* G E T L O C A L N O D E I D */ +/* */ +/*********************************************************************************/ + +#define GetLocalNodeId _SISCI_DEMOLIB_EXPAND_NAME(GetLocalNodeId) + +sci_error_t GetLocalNodeId( + unsigned int localAdapterNo, + unsigned int *localNodeId); + + +/*********************************************************************************/ +/* G E T A D A P T E R S E R I A L N U M B E R */ +/* */ +/*********************************************************************************/ + +#define GetAdapterSerialNumber _SISCI_DEMOLIB_EXPAND_NAME(GetAdapterSerialNumber) + +sci_error_t GetAdapterSerialNumber( + unsigned int localAdapterNo, + unsigned int *serialNo); + + + +/*********************************************************************************/ +/* G E T H O S T B R I D G E T Y P E */ +/* */ +/*********************************************************************************/ + +#define GetHostbridgeType _SISCI_DEMOLIB_EXPAND_NAME(GetHostbridgeType) + +sci_error_t GetHostbridgeType(unsigned int *hostbridgeType); + + + +/*********************************************************************************/ +/* P R I N T H O S T B R I D G E T Y P E */ +/* */ +/*********************************************************************************/ + +#define PrintHostbridgeType _SISCI_DEMOLIB_EXPAND_NAME(PrintHostbridgeType) + +void PrintHostbridgeType(unsigned int hostbridge); + + + +/*********************************************************************************/ +/* G E T A P I V E R S I O N S T R I N G */ +/* */ +/*********************************************************************************/ + +#define GetAPIVersionString _SISCI_DEMOLIB_EXPAND_NAME(GetAPIVersionString) + +sci_error_t GetAPIVersionString(char str[], unsigned int strLength); + + + +/*********************************************************************************/ +/* G E T A D A P T E R I O B U S F R E Q U E N C Y */ +/* */ +/*********************************************************************************/ + +sci_error_t GetAdapterIoBusFrequency(unsigned int localAdapterNo, + unsigned int *ioBusFrequency); + + + +/*********************************************************************************/ +/* G E T A D A P T E R S C I L I N K F R E Q U E N C Y */ +/* */ +/*********************************************************************************/ + +sci_error_t GetAdapterSciLinkFrequency(unsigned int localAdapterNo, + unsigned int *sciLinkFrequency); + + + +/*********************************************************************************/ +/* G E T A D A P T E R B L I N K F R E Q U E N C Y */ +/* */ +/*********************************************************************************/ + +sci_error_t GetAdapterBlinkFrequency(unsigned int localAdapterNo, + unsigned int *bLinkFrequency); + + +/*********************************************************************************/ +/* S E N D I N T E R R U P T */ +/* */ +/*********************************************************************************/ + +#define SendInterrupt _SISCI_DEMOLIB_EXPAND_NAME(SendInterrupt) + +sci_error_t SendInterrupt( + sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int localNodeId, + unsigned int remoteNodeId, + unsigned int interruptNo); + + +/*********************************************************************************/ +/* R E C E I V E I N T E R R U P T */ +/* */ +/*********************************************************************************/ + +#define ReceiveInterrupt _SISCI_DEMOLIB_EXPAND_NAME(ReceiveInterrupt) + +sci_error_t ReceiveInterrupt( + sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int localNodeId, + unsigned int interruptNo); + + +/*********************************************************************************/ +/* E N D I A N S W A P */ +/* */ +/*********************************************************************************/ + +#define EndianSwap _SISCI_DEMOLIB_EXPAND_NAME(EndianSwap) + +unsigned int EndianSwap (unsigned int value); + + +/*********************************************************************************/ +/* S L E E P M I L L I S E C O N D S */ +/* */ +/*********************************************************************************/ + +#define SleepMilliseconds _SISCI_DEMOLIB_EXPAND_NAME(SleepMilliseconds) + +void SleepMilliseconds(int milliseconds); + + + + +#endif diff --git a/ndb/src/external/LINUX.x86/sci/include/sisci_error.h b/ndb/src/external/LINUX.x86/sci/include/sisci_error.h new file mode 100644 index 00000000000..c53fe8ad5d9 --- /dev/null +++ b/ndb/src/external/LINUX.x86/sci/include/sisci_error.h @@ -0,0 +1,89 @@ +/* $Id: sisci_error.h,v 1.1 2002/12/13 12:17:21 hin Exp $ */ + +/******************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + + + + +#ifndef _SISCI_ERROR_H_ +#define _SISCI_ERROR_H_ + + +/* SCI Error return values always have 30 bit set */ +#define SCI_ERR_MASK 0x40000000 +#define SCI_ERR_REMOTE_MASK 0x01 /* Remote errors should have bit 0 set */ + +#define SCI_ERR(u) ((unsigned32)(u)&0x7FFFFFFF ) + +/* Error codes */ +typedef enum { + SCI_ERR_OK = 0x000, + + + SCI_ERR_BUSY = (0x900 | SCI_ERR_MASK), + SCI_ERR_FLAG_NOT_IMPLEMENTED = (0x901 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_FLAG = (0x902 | SCI_ERR_MASK), + SCI_ERR_NOSPC = (0x904 | SCI_ERR_MASK), + SCI_ERR_API_NOSPC = (0x905 | SCI_ERR_MASK), + SCI_ERR_HW_NOSPC = (0x906 | SCI_ERR_MASK), + SCI_ERR_NOT_IMPLEMENTED = (0x907 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_ADAPTERNO = (0x908 | SCI_ERR_MASK), + SCI_ERR_NO_SUCH_ADAPTERNO = (0x909 | SCI_ERR_MASK), + SCI_ERR_TIMEOUT = (0x90A | SCI_ERR_MASK), + SCI_ERR_OUT_OF_RANGE = (0x90B | SCI_ERR_MASK), + SCI_ERR_NO_SUCH_SEGMENT = (0x90C | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_NODEID = (0x90D | SCI_ERR_MASK), + SCI_ERR_CONNECTION_REFUSED = (0x90E | SCI_ERR_MASK), + SCI_ERR_SEGMENT_NOT_CONNECTED = (0x90F | SCI_ERR_MASK), + SCI_ERR_SIZE_ALIGNMENT = (0x910 | SCI_ERR_MASK), + SCI_ERR_OFFSET_ALIGNMENT = (0x911 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_PARAMETER = (0x912 | SCI_ERR_MASK), + SCI_ERR_MAX_ENTRIES = (0x913 | SCI_ERR_MASK), + SCI_ERR_SEGMENT_NOT_PREPARED = (0x914 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_ADDRESS = (0x915 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_OPERATION = (0x916 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_QUERY = (0x917 | SCI_ERR_MASK), + SCI_ERR_SEGMENTID_USED = (0x918 | SCI_ERR_MASK), + SCI_ERR_SYSTEM = (0x919 | SCI_ERR_MASK), + SCI_ERR_CANCELLED = (0x91A | SCI_ERR_MASK), + SCI_ERR_NOT_CONNECTED = (0x91B | SCI_ERR_MASK), + SCI_ERR_NOT_AVAILABLE = (0x91C | SCI_ERR_MASK), + SCI_ERR_INCONSISTENT_VERSIONS = (0x91D | SCI_ERR_MASK), + SCI_ERR_COND_INT_RACE_PROBLEM = (0x91E | SCI_ERR_MASK), + SCI_ERR_OVERFLOW = (0x91F | SCI_ERR_MASK), + SCI_ERR_NOT_INITIALIZED = (0x920 | SCI_ERR_MASK), + + SCI_ERR_ACCESS = (0x921 | SCI_ERR_MASK), + + SCI_ERR_NO_SUCH_NODEID = (0xA00 | SCI_ERR_MASK), + SCI_ERR_NODE_NOT_RESPONDING = (0xA02 | SCI_ERR_MASK), + SCI_ERR_NO_REMOTE_LINK_ACCESS = (0xA04 | SCI_ERR_MASK), + SCI_ERR_NO_LINK_ACCESS = (0xA05 | SCI_ERR_MASK), + SCI_ERR_TRANSFER_FAILED = (0xA06 | SCI_ERR_MASK) +} sci_error_t; + + +#endif /* _SCI_ERROR_H_ */ + + + diff --git a/ndb/src/external/LINUX.x86/sci/include/sisci_types.h b/ndb/src/external/LINUX.x86/sci/include/sisci_types.h new file mode 100644 index 00000000000..f4125fdec69 --- /dev/null +++ b/ndb/src/external/LINUX.x86/sci/include/sisci_types.h @@ -0,0 +1,133 @@ +/* $Id: sisci_types.h,v 1.1 2002/12/13 12:17:21 hin Exp $ */ + +/******************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + + +#ifndef _SISCI_TYPES_H +#define _SISCI_TYPES_H + +#include "sisci_error.h" + +#ifndef IN +#define IN +#endif + +#ifndef OUT +#define OUT +#endif + +#ifndef IN_OUT +#define IN_OUT +#endif + +/* Opaque data types for descriptors/handles */ +typedef struct sci_desc *sci_desc_t; +typedef struct sci_local_segment *sci_local_segment_t; +typedef struct sci_remote_segment *sci_remote_segment_t; + +typedef struct sci_map *sci_map_t; +typedef struct sci_sequence *sci_sequence_t; +#ifndef KERNEL +typedef struct sci_dma_queue *sci_dma_queue_t; +#endif +typedef struct sci_remote_interrupt *sci_remote_interrupt_t; +typedef struct sci_local_interrupt *sci_local_interrupt_t; +typedef struct sci_block_transfer *sci_block_transfer_t; + +/* + * Constants defining reasons for segment callbacks: + */ + +typedef enum { + SCI_CB_CONNECT = 1, + SCI_CB_DISCONNECT, + SCI_CB_NOT_OPERATIONAL, + SCI_CB_OPERATIONAL, + SCI_CB_LOST +} sci_segment_cb_reason_t; + +#define MAX_CB_REASON SCI_CB_LOST + +/* dma_queue_states is identical to the dma_queue_state_t in genif.h, they must be consistent.*/ +typedef enum { + SCI_DMAQUEUE_IDLE, + SCI_DMAQUEUE_GATHER, + SCI_DMAQUEUE_POSTED, + SCI_DMAQUEUE_DONE, + SCI_DMAQUEUE_ABORTED, + SCI_DMAQUEUE_ERROR +} sci_dma_queue_state_t; + + +typedef enum { + SCI_SEQ_OK, + SCI_SEQ_RETRIABLE, + SCI_SEQ_NOT_RETRIABLE, + SCI_SEQ_PENDING +} sci_sequence_status_t; + + +typedef struct { + unsigned short nodeId; /* SCI Address bit 63 - 48 */ + unsigned short offsHi; /* SCI Address bit 47 - 32 */ + unsigned int offsLo; /* SCI Address bit 31 - 0 */ +} sci_address_t; + + +typedef unsigned int sci_ioaddr_t; + +typedef enum { + SCI_CALLBACK_CANCEL = 1, + SCI_CALLBACK_CONTINUE +} sci_callback_action_t; + +#ifndef KERNEL +typedef sci_callback_action_t (*sci_cb_local_segment_t)(void *arg, + sci_local_segment_t segment, + sci_segment_cb_reason_t reason, + unsigned int nodeId, + unsigned int localAdapterNo, + sci_error_t error); + +typedef sci_callback_action_t (*sci_cb_remote_segment_t)(void *arg, + sci_remote_segment_t segment, + sci_segment_cb_reason_t reason, + sci_error_t status); + + +typedef sci_callback_action_t (*sci_cb_dma_t)(void IN *arg, + sci_dma_queue_t queue, + sci_error_t status); + + +typedef int (*sci_cb_block_transfer_t)(void *arg, + sci_block_transfer_t block, + sci_error_t status); + + +typedef sci_callback_action_t (*sci_cb_interrupt_t)(void *arg, + sci_local_interrupt_t interrupt, + sci_error_t status); + +#endif /* KERNEL */ +#endif diff --git a/ndb/src/external/LINUX.x86/sci/include/sisci_version.h b/ndb/src/external/LINUX.x86/sci/include/sisci_version.h new file mode 100644 index 00000000000..f1807c33aa5 --- /dev/null +++ b/ndb/src/external/LINUX.x86/sci/include/sisci_version.h @@ -0,0 +1,91 @@ +/* $Id: sisci_version.h,v 1.1 2002/12/13 12:17:21 hin Exp $ */ + +/******************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU Lesser General Public License as published by * + * the Free Software Foundation; either version 2.1 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU Lesser General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + + +#ifndef SISCI_VERSION_H +#define SISCI_VERSION_H + + +#define SISCI_API_VER_MAJOR 0x01 +#define SISCI_API_VER_MAJORC "1" + +#define SISCI_API_VER_MINOR 0x010 +#define SISCI_API_VER_MINORC "10" +#define SISCI_API_VER_MICRO 0x005 +#define SISCI_API_VER_MICROC "5" + +#define SISCI_SIGN_VERSION_MASK 0xfffff000 /* used to mask off API_VER_MICRO */ + +#define SISCI_API_VERSION (SISCI_API_VER_MAJOR << 24 | SISCI_API_VER_MINOR << 12 | SISCI_API_VER_MICRO) + +/* the rules are: + * + * Changes in API_VER_MICRO should be binary compatible, New flags, functions added. No changes to user code + * required if new features is not needed. + * + * Changes in API_VER_MINOR requires recompilation of user code. + * + * Changes in the API_VER_MAJOR will most likely require changes to user code. This should not happen very + * often... + * + */ + +#ifndef BUILD_DATE +#define BUILD_DATE __DATE__ +#endif + +#ifndef BUILD_NAME +#define BUILD_NAME "" +#endif + +#define API_VERSION "SISCI API version " SISCI_API_VER_MAJORC "." SISCI_API_VER_MINORC "."SISCI_API_VER_MICROC " ( "BUILD_NAME" "BUILD_DATE" )" + +#endif + + +/* Version info: */ +/* */ +/* 1.5.2 First SISCI version */ +/* 1.5.3 Some bug fixes */ +/* 1.5.4 Some bug fixes */ +/* 1.5.5 No release */ +/* 1.5.6 Lock flag implemented in function SCIConnectSegment */ +/* 1.5.7 Expanded query functionality */ +/* 1.5.8 Updated error checking (sequence) functionality for D320 */ +/* 1.6.0 Updated error checking (sequence) D320 and IRM 1.9 support */ +/* 1.9.0 Ported to Solaris_sparc, Solaris_x86 and Linux. IRM 1.9. */ +/* 1.9.1 Some bug fixes */ +/* 1.9.2 Added more adapter queries */ +/* 1.9.3 Bug fix in SCIMapLocalSegment and SCIMapRemoteSegment */ +/* 1.9.4 NT Release Developers Kit 2.40 */ +/* 1.9.5 Added flush after data transfer in SCIMemCopy() */ +/* 1.9.5 NT Release Developers Kit 2.44 */ +/* 1.10.0: + * New SCIInitialize(), SCITerminate() functions. + * Support for D330 + * + * + */ + + diff --git a/ndb/src/external/LINUX.x86/sci/include/version.h b/ndb/src/external/LINUX.x86/sci/include/version.h new file mode 100644 index 00000000000..a0e1fa6c5cd --- /dev/null +++ b/ndb/src/external/LINUX.x86/sci/include/version.h @@ -0,0 +1,25 @@ +#ifndef _VERSION_H +#define _VERSION_H + + +/* +#define DEMO_VER_MAJOR "1" +#define DEMO_VER_MINOR "5" +#define DEMO_VER_MICRO "0" +*/ + +#ifndef BUILD_DATE +#define BUILD_DATE __DATE__ +#endif + +#ifndef BUILD_NAME +#define BUILD_NAME "" +#endif + +/* +#define DEMO_VERSION "version " DEMO_VER_MAJOR "." DEMO_VER_MINOR "."DEMO_VER_MICRO " ("BUILD_NAME" "BUILD_DATE" )" +*/ +#define DEMO_VERSION " ("BUILD_NAME" "BUILD_DATE" )" + + +#endif diff --git a/ndb/src/external/SOLARIS.SPARC/sci/include/sisci_api.h b/ndb/src/external/SOLARIS.SPARC/sci/include/sisci_api.h new file mode 100644 index 00000000000..d02d3aafe7f --- /dev/null +++ b/ndb/src/external/SOLARIS.SPARC/sci/include/sisci_api.h @@ -0,0 +1,2148 @@ +/* $Id: sisci_api.h,v 1.1 2002/12/13 12:17:22 hin Exp $ */ +/******************************************************************************* + * * + * Copyright (C) 1993 - 2001 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU Lesser General Public License as published by * + * the Free Software Foundation; either version 2.1 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU Lesser General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + +#ifndef _SISCI_API_H +#define _SISCI_API_H + +#include "sisci_types.h" +#include "sisci_error.h" + + +#ifdef WIN32 +#ifdef API_DLL +#define DLL __declspec(dllexport) +#elif CLIENT_DLL +#define DLL __declspec(dllimport) +#endif +#endif /* WIN32 */ + + +#ifndef DLL +#define DLL +#endif + +#if defined(_REENTRANT) +#define _SISCI_EXPANDE_FUNCTION_NAME(name) _SISCI_PUBLIC_FUNC_MT_ ## name +#define _SISCI_EXPANDE_VARIABLE_NAME(name) _SISCI_PUBLIC_VAR_MT_ ## name +#else +#define _SISCI_EXPANDE_FUNCTION_NAME(name) _SISCI_PUBLIC_FUNC_ST_ ## name +#define _SISCI_EXPANDE_VARIABLE_NAME(name) _SISCI_PUBLIC_VAR_ST_ ## name +#endif +#define _SISCI_EXPANDE_CONSTANT_NAME(name) _SISCI_PUBLIC_CONST_ ## name + +#if defined(CPLUSPLUS) || defined(__cplusplus) +extern "C" { +#endif + + +/*********************************************************************************/ +/* FLAG VALUES */ +/*********************************************************************************/ + +#define SCI_FLAG_FIXED_INTNO _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FIXED_INTNO) +extern const unsigned int SCI_FLAG_FIXED_INTNO; + +#define SCI_FLAG_SHARED_INT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_SHARED_INT) +extern const unsigned int SCI_FLAG_SHARED_INT; + +#define SCI_FLAG_FIXED_MAP_ADDR _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FIXED_MAP_ADDR) +extern const unsigned int SCI_FLAG_FIXED_MAP_ADDR; + +#define SCI_FLAG_READONLY_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_READONLY_MAP) +extern const unsigned int SCI_FLAG_READONLY_MAP; + +#define SCI_FLAG_USE_CALLBACK _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_USE_CALLBACK) +extern const unsigned int SCI_FLAG_USE_CALLBACK; + +#define SCI_FLAG_BLOCK_READ _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_BLOCK_READ) +extern const unsigned int SCI_FLAG_BLOCK_READ; + +#define SCI_FLAG_THREAD_SAFE _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_THREAD_SAFE) +extern const unsigned int SCI_FLAG_THREAD_SAFE; + +#define SCI_FLAG_ASYNCHRONOUS_CONNECT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_ASYNCHRONOUS_CONNECT) +extern const unsigned int SCI_FLAG_ASYNCHRONOUS_CONNECT; + +#define SCI_FLAG_EMPTY _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_EMPTY) +extern const unsigned int SCI_FLAG_EMPTY; + +#define SCI_FLAG_PRIVATE _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_PRIVATE) +extern const unsigned int SCI_FLAG_PRIVATE; + +#define SCI_FLAG_FORCE_DISCONNECT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FORCE_DISCONNECT) +extern const unsigned int SCI_FLAG_FORCE_DISCONNECT; + +#define SCI_FLAG_NOTIFY _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_NOTIFY) +extern const unsigned int SCI_FLAG_NOTIFY; + +#define SCI_FLAG_DMA_READ _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_READ) +extern const unsigned int SCI_FLAG_DMA_READ; + +#define SCI_FLAG_DMA_POST _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_POST) +extern const unsigned int SCI_FLAG_DMA_POST; + +#define SCI_FLAG_DMA_WAIT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_WAIT) +extern const unsigned int SCI_FLAG_DMA_WAIT; + +#define SCI_FLAG_DMA_RESET _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_RESET) +extern const unsigned int SCI_FLAG_DMA_RESET; + +#define SCI_FLAG_NO_FLUSH _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_NO_FLUSH) +extern const unsigned int SCI_FLAG_NO_FLUSH; + +#define SCI_FLAG_NO_STORE_BARRIER _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_NO_STORE_BARRIER) +extern const unsigned int SCI_FLAG_NO_STORE_BARRIER; + +#define SCI_FLAG_FAST_BARRIER _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FAST_BARRIER) +extern const unsigned int SCI_FLAG_FAST_BARRIER; + +#define SCI_FLAG_ERROR_CHECK _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_ERROR_CHECK) +extern const unsigned int SCI_FLAG_ERROR_CHECK; + +#define SCI_FLAG_FLUSH_CPU_BUFFERS_ONLY _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FLUSH_CPU_BUFFERS_ONLY) +extern const unsigned int SCI_FLAG_FLUSH_CPU_BUFFERS_ONLY; + +/* the FLUSH_CPU_BUFFERS_ONLY flag is for backwards compabillity only and should never be used */ +#define FLUSH_CPU_BUFFERS_ONLY _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FLUSH_CPU_BUFFERS_ONLY) + +#define SCI_FLAG_LOCK_OPERATION _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_LOCK_OPERATION) +extern const unsigned int SCI_FLAG_LOCK_OPERATION; + +#define SCI_FLAG_READ_PREFETCH_AGGR_HOLD_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_READ_PREFETCH_AGGR_HOLD_MAP) +extern const unsigned int SCI_FLAG_READ_PREFETCH_AGGR_HOLD_MAP; + +#define SCI_FLAG_READ_PREFETCH_NO_HOLD_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_READ_PREFETCH_NO_HOLD_MAP) +extern const unsigned int SCI_FLAG_READ_PREFETCH_NO_HOLD_MAP; + +#define SCI_FLAG_IO_MAP_IOSPACE _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_IO_MAP_IOSPACE) +extern const unsigned int SCI_FLAG_IO_MAP_IOSPACE; + +#define SCI_FLAG_DMOVE_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMOVE_MAP) +extern const unsigned int SCI_FLAG_DMOVE_MAP; + +#define SCI_FLAG_WRITES_DISABLE_GATHER_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_WRITES_DISABLE_GATHER_MAP) +extern const unsigned int SCI_FLAG_WRITES_DISABLE_GATHER_MAP; + +#define SCI_FLAG_DISABLE_128_BYTES_PACKETS _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DISABLE_128_BYTES_PACKETS) +extern const unsigned int SCI_FLAG_DISABLE_128_BYTES_PACKETS; + +#define SCI_FLAG_DMA_SOURCE_ONLY _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_SOURCE_ONLY) +extern const unsigned int SCI_FLAG_DMA_SOURCE_ONLY; + +#define SCI_FLAG_CONDITIONAL_INTERRUPT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_CONDITIONAL_INTERRUPT) +extern const unsigned int SCI_FLAG_CONDITIONAL_INTERRUPT; + +#define SCI_FLAG_CONDITIONAL_INTERRUPT_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_CONDITIONAL_INTERRUPT_MAP) +extern const unsigned int SCI_FLAG_CONDITIONAL_INTERRUPT_MAP; + +#define SCI_FLAG_UNCONDITIONAL_DATA_INTERRUPT_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_UNCONDITIONAL_DATA_INTERRUPT_MAP) +extern const unsigned int SCI_FLAG_UNCONDITIONAL_DATA_INTERRUPT_MAP; + +#define SCI_FLAG_NO_MEMORY_LOOPBACK_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_NO_MEMORY_LOOPBACK_MAP) +extern const unsigned int SCI_FLAG_NO_MEMORY_LOOPBACK_MAP; + +#if defined(OS_IS_LYNXOS) || defined(OS_IS_VXWORKS) +#define SCI_FLAG_WRITE_BACK_CACHE_MAP _SISCI_EXPANDE_CONSTANT_NAME(WRITE_BACK_CACHE_MAP) +extern const unsigned int SCI_FLAG_WRITE_BACK_CACHE_MAP; +#endif + +#define SCI_FLAG_DMA_PHDMA _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_PHDMA) +extern const unsigned int SCI_FLAG_DMA_PHDMA; + +/*********************************************************************************/ +/* GENERAL VALUES */ +/*********************************************************************************/ +#define SCI_LOCAL_HOST _SISCI_EXPANDE_CONSTANT_NAME(SCI_LOCAL_HOST) +extern const unsigned int SCI_LOCAL_HOST; + +#define SCI_INFINITE_TIMEOUT _SISCI_EXPANDE_CONSTANT_NAME(SCI_INFINITE_TIMEOUT) +extern const unsigned int SCI_INFINITE_TIMEOUT; + +/*********************************************************************************/ +/* GENERAL ERROR CODES */ +/* */ +/* SCI_ERR_ILLEGAL_FLAG - Illegal flag value. */ +/* SCI_ERR_FLAG_NOT_IMPLEMENTED - Flag legal but flag feature not implemented. */ +/* SCI_ERR_NOT_IMPLEMENTED - Function not implemented. */ +/* SCI_ERR_SYSTEM - A system error. Check errno. */ +/* SCI_ERR_NOSPC - Unable to allocate OS resources. */ +/* SCI_ERR_API_NOSPC - Unable to allocate API resources. */ +/* SCI_ERR_HW_NOSPC - Unable to allocate HW resources (Hardware) */ +/* */ +/*********************************************************************************/ + + +/*********************************************************************************/ +/* GENERAL "ADAPTER" ERROR CODES */ +/* */ +/* SCI_ERR_NO_SUCH_ADAPTERNO - Adapter number is legal but does not exist. */ +/* SCI_ERR_ILLEGAL_ADAPTERNO - Illegal local adapter number (i.e. outside */ +/* legal range). */ +/* */ +/*********************************************************************************/ + + +/*********************************************************************************/ +/* GENERAL "NODEID" ERROR CODES */ +/* */ +/* SCI_ERR_NO_SUCH_NODEID - The remote adapter identified by nodeId does */ +/* not respond, but the intermediate link(s) */ +/* seem(s) to be operational. */ +/* SCI_ERR_ILLEGAL_NODEID - Illegal NodeId. */ +/* */ +/*********************************************************************************/ + + + +/********************************************************************************* + * * + * S C I I N I T I A L I Z E * + * * + * This function initializes the SISCI library. * + * The function must be called before SCIOpen(). * + * * + * Flags: * + * None * + * * + * Specific error codes for this function: * + * * + * None * + * * + *********************************************************************************/ +#define SCIInitialize _SISCI_EXPANDE_FUNCTION_NAME(SCIInitialize) +DLL void SCIInitialize(unsigned int flags, + sci_error_t *error); +#if 0 +unsigned int __Internal_SISCI_version_var; +#endif + +/********************************************************************************* + * * + * S C I T E R M I N A T E * + * * + * This function terminates the SISCI library. * + * The function must be called after SCIClose(). * + * * + * * + *********************************************************************************/ +#define SCITerminate _SISCI_EXPANDE_FUNCTION_NAME(SCITerminate) +DLL void SCITerminate(void); + +/********************************************************************************* + * * + * S C I O P E N * + * * + * * + * Opens a SCI virtual device. * + * Caller must supply a pointer to a variable of type sci_desc_t to be * + * initialized. * + * * + * Flags * + * SCI_FLAG_THREAD_SAFE - Operations on resources associated with this * + * descriptor will be performed in a multithread-safe * + * manner. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_INCONSISTENT_VERSIONS - Inconsistency between the SISCI library * + * and the SISCI driver versions. * + * * + * * + *********************************************************************************/ +#define SCIOpen _SISCI_EXPANDE_FUNCTION_NAME(SCIOpen) +DLL void SCIOpen(sci_desc_t *sd, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I C L O S E * + * * + * This function closes an open SCI virtual device. * + * * + * Flags: * + * None * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_BUSY - All resources are not deallocated. * + * * + *********************************************************************************/ +#define SCIClose _SISCI_EXPANDE_FUNCTION_NAME(SCIClose) +DLL void SCIClose(sci_desc_t sd, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I C O N N E C T S E G M E N T * + * * + * Connects to a remote shared memory segment located at with the * + * identifier . * + * The user may then call SCIMapRemoteSegment() to map shared memory * + * into user space. * + * * + * Flags * + * SCI_FLAG_USE_CALLBACK * + * SCI_FLAG_ASYNCHRONOUS_CONNECT * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_NO_SUCH_SEGMENT - Could not find the remote segment with the * + * given segmentId. * + * SCI_ERR_CONNECTION_REFUSED - Connection attempt refused by remote node. * + * SCI_ERR_TIMEOUT - The function timed out after specified * + * timeout value. * + * SCI_ERR_NO_LINK_ACCESS - It was not possible to communicate via the * + * local adapter. * + * SCI_ERR_NO_REMOTE_LINK_ACCESS - It was not possible to communicate via a * + * remote switch port. * + * * + *********************************************************************************/ +#define SCIConnectSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIConnectSegment) +DLL void SCIConnectSegment(sci_desc_t sd, + sci_remote_segment_t *segment, + unsigned int nodeId, + unsigned int segmentId, + unsigned int localAdapterNo, + sci_cb_remote_segment_t callback, + void *callbackArg, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I D I S C O N N E C T S E G M E N T * + * * + * Disconnects from the give mapped shared memory segment * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_BUSY - The segment is currently mapped or in use. * + * * + *********************************************************************************/ +#define SCIDisconnectSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIDisconnectSegment) +DLL void SCIDisconnectSegment(sci_remote_segment_t segment, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I G E T R E M O T E S E G M E N T S I Z E * + * * + *********************************************************************************/ +#define SCIGetRemoteSegmentSize _SISCI_EXPANDE_FUNCTION_NAME(SCIGetRemoteSegmentSize) +DLL unsigned int SCIGetRemoteSegmentSize(sci_remote_segment_t segment); + + + +/********************************************************************************* + * * + * S C I W A I T F O R R E M O T E S E G M E N T E V E N T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_TIMEOUT - The function timed out after specified * + * timeout value. * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation. * + * SCI_ERR_CANCELLED - The wait operation has been cancelled du * + * to a SCIDisconnectSegment() on the same * + * handle. The handle is invalid when this * + * error is returned. * + * * + *********************************************************************************/ +#define SCIWaitForRemoteSegmentEvent _SISCI_EXPANDE_FUNCTION_NAME(SCIWaitForRemoteSegmentEvent) +DLL sci_segment_cb_reason_t SCIWaitForRemoteSegmentEvent( + sci_remote_segment_t segment, + sci_error_t *status, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I M A P R E M O T E S E G M E N T * + * * + * This function is used to include a shared memory segment in the virtual * + * address space of the application. * + * * + * Flags: * + * * + * SCI_FLAG_FIXED_MAP_ADDR - Map at the suggested virtual address * + * SCI_FLAG_READONLY_MAP - The segment is mapped in read-only mode * + * SCI_FLAG_LOCK_OPERATION - Enable Lock operations (fetch and add) * + * SCI_FLAG_READ_PREFETCH_AGGR_HOLD_MAP * + * - Enable aggressive prefetch with speculative * + * hold. * + * * + * SCI_FLAG_READ_PREFETCH_NO_HOLD_MAP * + * - The PSB66 will prefetch 64 bytes. As soon * + * as the PCI read retry has been accepted, * + * the stream will change state to FREE, even * + * if less than 64 bytes were actually read. * + * * + * SCI_FLAG_IO_MAP_IOSPACE - Enable No Prefetch, no speculative hold. * + * * + * SCI_FLAG_DMOVE_MAP - Enable DMOVE packet type. The stream will be * + * set into FREE state immediately. * + * * + * SCI_FLAG_WRITES_DISABLE_GATHER_MAP * + * - Disable use of gather. * + * * + * SCI_FLAG_DISABLE_128_BYTES_PACKETS * + * - Disable use of 128-Byte packets * + * * + * SCI_FLAG_CONDITIONAL_INTERRUPT_MAP * + * - Write operations through this map will cause * + * an atomic "fetch-and-add-one" operation on * + * remote memory, but in addition an interrupt * + * will be generated if the target memory * + * location contained a "null value" before the * + * add operation was carried out. * + * The conditional interrupt flag must also be * + * specified in the SCIRegisterInterruptFlag() * + * function. * + * * + * SCI_FLAG_UNCONDITIONAL_INTERRUPT_MAP * + * - Write operations through this map will cause * + * an interrupt for the remote adapter * + * "in addition to" updating the corresponding * + * remote memory location with the data being * + * written. * + * The unconditional interrupt flag must also * + * be specified in the * + * SCIRegisterInterruptFlag() function. * + * * + * SCI_FLAG_WRITE_BACK_CACHE_MAP * + * - Enable cacheing of the mapped region. * + * Writes through this map will be written to a * + * write back cache, hence no remote SCI updates* + * until the cache line is flushed. The * + * application is responsible for the cache * + * flush operation. * + * The SCImemCopy() function will handle this * + * correctly by doing cache flushes internally. * + * This feature is architechture dependent and * + * not be available on all plattforms. * + * * + * SCI_FLAG_NO_MEMORY_LOOPBACK_MAP * + * - Forces a map to a remote segment located * + * in the local machine to be mapped using * + * SCI loopback. This is useful i.e. if you * + * want to use a regular map access to be * + * serialized with lock operations. * + * The default behaviour is to access a remte * + * segment located in the local machine as a * + * local MMU operation. * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the offset and size is * + * larger than the segment size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as * + * required by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as * + * required by the implementation. * + * * + *********************************************************************************/ +#define SCIMapRemoteSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIMapRemoteSegment) +DLL volatile void *SCIMapRemoteSegment( + sci_remote_segment_t segment, + sci_map_t *map, + unsigned int offset, + unsigned int size, + void *addr, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I M A P L O C A L S E G M E N T * + * * + * Flags * + * * + * SCI_FLAG_FIXED_MAP_ADDR * + * SCI_FLAG_READONLY_MAP * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the offset and size is * + * larger than the segment size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as * + * required by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as * + * required by the implementation. * + * * + *********************************************************************************/ +#define SCIMapLocalSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIMapLocalSegment) +DLL void *SCIMapLocalSegment(sci_local_segment_t segment, + sci_map_t *map, + unsigned int offset, + unsigned int size, + void *addr, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I U N M A P S E G M E N T * + * * + * This function unmaps pages of shared memory from the callers virtual * + * address space. * + * * + * Flags * + * None. * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_BUSY - The map is currently in use. * + * * + *********************************************************************************/ +#define SCIUnmapSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIUnmapSegment) +DLL void SCIUnmapSegment(sci_map_t map, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I C R E A T E S E G M E N T * + * * + * Make the specified segment available for connections via the specified * + * adapter. If successful, the segment can be accessed from remote nodes * + * via the specified adapter. * + * * + * Flags: * + * * + * SCI_FLAG_USE_CALLBACK - The callback function will be invoked for events * + * on this segment. * + * SCI_FLAG_EMPTY - No memory will be allocated for the segment. * + * SCI_FLAG_PRIVATE - The segment will be private meaning it will never * + * be any connections to it. * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_SEGMENTID_USED - The segment with this segmentId is already used * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * * + *********************************************************************************/ +#define SCICreateSegment _SISCI_EXPANDE_FUNCTION_NAME(SCICreateSegment) +DLL void SCICreateSegment(sci_desc_t sd, + sci_local_segment_t *segment, + unsigned int segmentId, + unsigned int size, + sci_cb_local_segment_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I W A I T F O R L O C A L S E G M E N T E V E N T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_TIMEOUT - The function timed out after specified timeout value. * + * SCI_ERR_CANCELLED - The wait operation has been cancelled du to a * + * SCIRemoveSegment() on the same handle. * + * The handle is invalid when this error is returned. * + * * + *********************************************************************************/ +#define SCIWaitForLocalSegmentEvent _SISCI_EXPANDE_FUNCTION_NAME(SCIWaitForLocalSegmentEvent) +DLL sci_segment_cb_reason_t SCIWaitForLocalSegmentEvent( + sci_local_segment_t segment, + unsigned int *sourcenodeId, + unsigned int *localAdapterNo, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I P R E P A R E S E G M E N T * + * * + * Flags * + * * + * SCI_FLAG_DMA_SOURCE_ONLY - The segment will be used as a source segment * + * for DMA operations. On some system types this * + * will enable the SISCI driver to use performance * + * improving features. * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIPrepareSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIPrepareSegment) +DLL void SCIPrepareSegment(sci_local_segment_t segment, + unsigned int localAdapterNo, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I R E M O V E S E G M E N T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_BUSY - Unable to remove the segment. The segment is currently * + * in use. * + * * + *********************************************************************************/ +#define SCIRemoveSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIRemoveSegment) +DLL void SCIRemoveSegment(sci_local_segment_t segment, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I S E T S E G M E N T A V A I L A B L E * + * * + * Flags * + * None. * + * * + * * + * SCI_ERR_SEGMENT_NOT_PREPARED - The segment has not been prepared for access * + * from this adapter. * + * SCI_ERR_ILLEGAL_OPERATION - The segment is created with the * + * SCI_FLAG_PRIVATE flag specified and * + * therefore has no segmentId. * + * * + *********************************************************************************/ +#define SCISetSegmentAvailable _SISCI_EXPANDE_FUNCTION_NAME(SCISetSegmentAvailable) +DLL void SCISetSegmentAvailable(sci_local_segment_t segment, + unsigned int localAdapterNo, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I S E T S E G M E N T U N A V A I L A B L E * + * * + * Flags * + * * + * SCI_FLAG_FORCE_DISCONNECT * + * SCI_FLAG_NOTIFY * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation. * + * * + *********************************************************************************/ +#define SCISetSegmentUnavailable _SISCI_EXPANDE_FUNCTION_NAME(SCISetSegmentUnavailable) +DLL void SCISetSegmentUnavailable(sci_local_segment_t segment, + unsigned int localAdapterNo, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I C R E A T E M A P S E Q U E N C E * + * * + * Flags: * + * * + * SCI_FLAG_FAST_BARRIER * + * * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCICreateMapSequence _SISCI_EXPANDE_FUNCTION_NAME(SCICreateMapSequence) +DLL void SCICreateMapSequence(sci_map_t map, + sci_sequence_t *sequence, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I R E M O V E S E Q U E N C E * + * * + * Flags: * + * None * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCIRemoveSequence _SISCI_EXPANDE_FUNCTION_NAME(SCIRemoveSequence) +DLL void SCIRemoveSequence(sci_sequence_t sequence, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I S T A R T S E Q U E N C E * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIStartSequence _SISCI_EXPANDE_FUNCTION_NAME(SCIStartSequence) +DLL sci_sequence_status_t SCIStartSequence(sci_sequence_t sequence, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I C H E C K S E Q U E N CE * + * * + * Flags * + * * + * SCI_FLAG_NO_FLUSH * + * SCI_FLAG_NO_STORE_BARRIER * + * * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCICheckSequence _SISCI_EXPANDE_FUNCTION_NAME(SCICheckSequence) +DLL sci_sequence_status_t SCICheckSequence(sci_sequence_t sequence, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I S T O R E B A R R I E R * + * * + * Flags * + * None. * + * * + * * + * * + *********************************************************************************/ +#define SCIStoreBarrier _SISCI_EXPANDE_FUNCTION_NAME(SCIStoreBarrier) +DLL void SCIStoreBarrier(sci_sequence_t sequence, + unsigned int flags); + + + + +/********************************************************************************* + * * + * S C I F L U S H R E A D B U F F E R S * + * * + *********************************************************************************/ +#define SCIFlushReadBuffers _SISCI_EXPANDE_FUNCTION_NAME(SCIFlushReadBuffers) +DLL void SCIFlushReadBuffers(sci_sequence_t sequence); + + + + +/********************************************************************************* + * * + * S C I P R O B E N O D E * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_NO_LINK_ACCESS - It was not possible to communicate via the * + * local adapter. * + * SCI_ERR_NO_REMOTE_LINK_ACCESS - It was not possible to communicate via a * + * remote switch port. * + * * + *********************************************************************************/ +#define SCIProbeNode _SISCI_EXPANDE_FUNCTION_NAME(SCIProbeNode) +DLL int SCIProbeNode(sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int nodeId, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I G E T C S R R E G I S T E R * + * * + * SISCI Priveleged function * + * * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_NO_LINK_ACCESS - It was not possible to communicate via the * + * local adapter. * + * SCI_ERR_NO_REMOTE_LINK_ACCESS - It was not possible to communicate via a * + * remote switch port. * + * * + *********************************************************************************/ +#define SCIGetCSRRegister _SISCI_EXPANDE_FUNCTION_NAME(SCIGetCSRRegister) +DLL unsigned int SCIGetCSRRegister(sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int SCINodeId, + unsigned int CSROffset, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I S E T C S R R E G I S T E R * + * * + * SISCI Priveleged function * + * * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_NO_LINK_ACCESS - It was not possible to communicate via the * + * local adapter. * + * SCI_ERR_NO_REMOTE_LINK_ACCESS - It was not possible to communicate via a * + * remote switch port. * + * * + *********************************************************************************/ +#define SCISetCSRRegister _SISCI_EXPANDE_FUNCTION_NAME(SCISetCSRRegister) +DLL void SCISetCSRRegister(sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int SCINodeId, + unsigned int CSROffset, + unsigned int CSRValue, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I G E T L O C A L C S R * + * * + * SISCI Priveleged function * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIGetLocalCSR _SISCI_EXPANDE_FUNCTION_NAME(SCIGetLocalCSR) +DLL unsigned int SCIGetLocalCSR(sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int CSROffset, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I S E T L O C A L C S R * + * * + * SISCI Priveleged function + * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCISetLocalCSR _SISCI_EXPANDE_FUNCTION_NAME(SCISetLocalCSR) +DLL void SCISetLocalCSR(sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int CSROffset, + unsigned int CSRValue, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I A T T A C H P H Y S I C A L M E M O R Y * + * * + * SISCI Priveleged function * + * * + * Description: * + * * + * This function enables usage of physical devices and memory regions where the * + * Physical PCI bus address ( and mapped CPU address ) are already known. * + * The function will register the physical memory as a SISCI segment which can * + * be connected and mapped as a regular SISCI segment. * + * * + * Requirements: * + * * + * SCICreateSegment() with flag SCI_FLAG_EMPTY must have been called in advance * + * * + * Parameter description: * + * sci_ioaddr_t ioaddress : This is the address on the PCI bus that a PCI bus * + * master has to use to write to the specified memory * + * void * address : This is the (mapped) virtual address that the * + * application has to use to access the device. * + * This means that the device has to be mapped in * + * advance bye the devices own driver. * + * If the device is not to be accessed by the local * + * CPU, the address pointer shold be set to NULL * + * Flags * + * * + * None * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIAttachPhysicalMemory _SISCI_EXPANDE_FUNCTION_NAME(SCIAttachPhysicalMemory) +DLL void SCIAttachPhysicalMemory(sci_ioaddr_t ioaddress, + void *address, + unsigned int busNo, + unsigned int size, + sci_local_segment_t segment, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I Q U E R Y * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_QUERY - Unrecognized command. * + * * + *********************************************************************************/ +#define SCIQuery _SISCI_EXPANDE_FUNCTION_NAME(SCIQuery) +DLL void SCIQuery(unsigned int command, + void *data, + unsigned int flags, + sci_error_t *error); + + +/* MAJOR QUERY COMMANDS */ + +/* This command requires a pointer to a structure of type */ +/* "sci_query_string". The string will be filled in by the query. */ +#define SCI_Q_VENDORID _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_VENDORID) +extern const unsigned int SCI_Q_VENDORID; + + +/* Same as for SCI_VENDOR_ID */ +#define SCI_Q_API _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_API) +extern const unsigned int SCI_Q_API; + + +/* User passes a pointer to an allocated object of the */ +/* "sci_query_adapter" struct. */ +#define SCI_Q_ADAPTER _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER) +extern const unsigned int SCI_Q_ADAPTER; + + +/* User passes a pointer to an allocated object of the */ +/* "sci_query_system" struct. */ +#define SCI_Q_SYSTEM _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SYSTEM) +extern const unsigned int SCI_Q_SYSTEM; + +#define SCI_Q_LOCAL_SEGMENT _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_LOCAL_SEGMENT) +extern const unsigned int SCI_Q_LOCAL_SEGMENT; + +#define SCI_Q_REMOTE_SEGMENT _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_REMOTE_SEGMENT) +extern const unsigned int SCI_Q_REMOTE_SEGMENT; + +#define SCI_Q_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_MAP) +extern const unsigned int SCI_Q_MAP; + +typedef struct { + char *str; /* Pointer to a string of minimum "length" characters */ + unsigned int length; +} sci_query_string_t; + + +typedef struct { + unsigned int localAdapterNo; /* The adapter no. that the query concern. */ + unsigned int portNo; /* The SCI Link port number that the query concern. */ + unsigned int subcommand; /* A subcommand as specified below. */ + void *data; /* A pointer to an unsigned int that will return */ + /* the response to the query. */ +} sci_query_adapter_t; + + +typedef struct { + unsigned int subcommand; /* A subcommand as specified below. */ + void *data; /* A pointer to an unsigned int that will return */ + /* the response to the query. */ +} sci_query_system_t; + +typedef struct { + sci_local_segment_t segment; + unsigned int subcommand; + union { + sci_ioaddr_t ioaddr; + } data; +} sci_query_local_segment_t; + +typedef struct { + sci_remote_segment_t segment; + unsigned int subcommand; + union { + sci_ioaddr_t ioaddr; + } data; +} sci_query_remote_segment_t; + +typedef struct { + sci_map_t map; + unsigned int subcommand; + unsigned int data; +} sci_query_map_t; + +/* Minor query commands (sub-commands) for adapter specific information SCI_ADAPTER */ +#define SCI_Q_ADAPTER_DMA_SIZE_ALIGNMENT _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_DMA_SIZE_ALIGNMENT) +extern const unsigned int SCI_Q_ADAPTER_DMA_SIZE_ALIGNMENT; + +#define SCI_Q_ADAPTER_DMA_OFFSET_ALIGNMENT _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_DMA_OFFSET_ALIGNMENT) +extern const unsigned int SCI_Q_ADAPTER_DMA_OFFSET_ALIGNMENT; + +#define SCI_Q_ADAPTER_DMA_MTU _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_DMA_MTU) +extern const unsigned int SCI_Q_ADAPTER_DMA_MTU; + +#define SCI_Q_ADAPTER_SUGGESTED_MIN_DMA_SIZE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_SUGGESTED_MIN_DMA_SIZE) +extern const unsigned int SCI_Q_ADAPTER_SUGGESTED_MIN_DMA_SIZE; + +#define SCI_Q_ADAPTER_SUGGESTED_MIN_BLOCK_SIZE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_SUGGESTED_MIN_BLOCK_SIZE) +extern const unsigned int SCI_Q_ADAPTER_SUGGESTED_MIN_BLOCK_SIZE; + +#define SCI_Q_ADAPTER_NODEID _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_NODEID) +extern const unsigned int SCI_Q_ADAPTER_NODEID; + +#define SCI_Q_ADAPTER_SERIAL_NUMBER _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_SERIAL_NUMBER) +extern const unsigned int SCI_Q_ADAPTER_SERIAL_NUMBER; + +#define SCI_Q_ADAPTER_CARD_TYPE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_CARD_TYPE) +extern const unsigned int SCI_Q_ADAPTER_CARD_TYPE; + +#define SCI_Q_ADAPTER_NUMBER_OF_STREAMS _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_NUMBER_OF_STREAMS) +extern const unsigned int SCI_Q_ADAPTER_NUMBER_OF_STREAMS; + +#define SCI_Q_ADAPTER_STREAM_BUFFER_SIZE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_STREAM_BUFFER_SIZE) +extern const unsigned int SCI_Q_ADAPTER_STREAM_BUFFER_SIZE; + +#define SCI_Q_ADAPTER_CONFIGURED _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_CONFIGURED) +extern const unsigned int SCI_Q_ADAPTER_CONFIGURED; + +#define SCI_Q_ADAPTER_LINK_OPERATIONAL _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_LINK_OPERATIONAL) +extern const unsigned int SCI_Q_ADAPTER_LINK_OPERATIONAL; + +#define SCI_Q_ADAPTER_HW_LINK_STATUS_IS_OK _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_HW_LINK_STATUS_IS_OK) +extern const unsigned int SCI_Q_ADAPTER_HW_LINK_STATUS_IS_OK; + +#define SCI_Q_ADAPTER_NUMBER _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_NUMBER) +extern const unsigned int SCI_Q_ADAPTER_NUMBER; + +#define SCI_Q_ADAPTER_INSTANCE_NUMBER _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_INSTANCE_NUMBER) +extern const unsigned int SCI_Q_ADAPTER_INSTANCE_NUMBER; + +#define SCI_Q_ADAPTER_FIRMWARE_OK _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_FIRMWARE_OK) +extern const unsigned int SCI_Q_ADAPTER_FIRMWARE_OK; + +#define SCI_Q_ADAPTER_CONNECTED_TO_SWITCH _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_CONNECTED_TO_SWITCH) +extern const unsigned int SCI_Q_ADAPTER_CONNECTED_TO_SWITCH; + +#define SCI_Q_ADAPTER_LOCAL_SWITCH_TYPE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_LOCAL_SWITCH_TYPE) +extern const unsigned int SCI_Q_ADAPTER_LOCAL_SWITCH_TYPE; + +#define SCI_Q_ADAPTER_LOCAL_SWITCH_PORT_NUMBER _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_LOCAL_SWITCH_PORT_NUMBER) +extern const unsigned int SCI_Q_ADAPTER_LOCAL_SWITCH_PORT_NUMBER; + +#define SCI_Q_ADAPTER_CONNECTED_TO_EXPECTED_SWITCH_PORT _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_CONNECTED_TO_EXPECTED_SWITCH_PORT) +extern const unsigned int SCI_Q_ADAPTER_CONNECTED_TO_EXPECTED_SWITCH_PORT; + +#define SCI_Q_ADAPTER_ATT_PAGE_SIZE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_ATT_PAGE_SIZE) +extern const unsigned int SCI_Q_ADAPTER_ATT_PAGE_SIZE; + +#define SCI_Q_ADAPTER_ATT_NUMBER_OF_ENTRIES _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_ATT_NUMBER_OF_ENTRIES) +extern const unsigned int SCI_Q_ADAPTER_ATT_NUMBER_OF_ENTRIES; + +#define SCI_Q_ADAPTER_ATT_AVAILABLE_ENTRIES _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_ATT_AVAILABLE_ENTRIES) +extern const unsigned int SCI_Q_ADAPTER_ATT_AVAILABLE_ENTRIES; + +#define SCI_Q_ADAPTER_PHYS_MEM_NODEID _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SCI_Q_ADAPTER_PHYS_MEM_NODEID) +extern const unsigned int SCI_Q_ADAPTER_PHYS_MEM_NODEID; + +#define SCI_Q_ADAPTER_PHYS_MBX_NODEID _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SCI_Q_ADAPTER_PHYS_MBX_NODEID) +extern const unsigned int SCI_Q_ADAPTER_PHYS_MBX_NODEID; + +#define SCI_Q_ADAPTER_PHYS_LINK_PORT_NODEID _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_PHYS_LINK_PORT_NODEID) +extern const unsigned int SCI_Q_ADAPTER_PHYS_LINK_PORT_NODEID; + +#define SCI_Q_ADAPTER_SCI_LINK_FREQUENCY _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_SCI_LINK_FREQUENCY) +extern const unsigned int SCI_Q_ADAPTER_SCI_LINK_FREQUENCY; + +#define SCI_Q_ADAPTER_B_LINK_FREQUENCY _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_B_LINK_FREQUENCY) +extern const unsigned int SCI_Q_ADAPTER_B_LINK_FREQUENCY; + +#define SCI_Q_ADAPTER_IO_BUS_FREQUENCY _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_IO_BUS_FREQUENCY) +extern const unsigned int SCI_Q_ADAPTER_IO_BUS_FREQUENCY; + +/* Minor query commands (sub-commands) for adapter specific information SCI_SYSTEM */ +#define SCI_Q_SYSTEM_HOSTBRIDGE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SYSTEM_HOSTBRIDGE) +extern const unsigned int SCI_Q_SYSTEM_HOSTBRIDGE; + +#define SCI_Q_SYSTEM_WRITE_POSTING_ENABLED _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SYSTEM_WRITE_POSTING_ENABLED) +extern const unsigned int SCI_Q_SYSTEM_WRITE_POSTING_ENABLED; + +#define SCI_Q_SYSTEM_WRITE_COMBINING_ENABLED _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SYSTEM_WRITE_COMBINING_ENABLED) +extern const unsigned int SCI_Q_SYSTEM_WRITE_COMBINING_ENABLED; + +#define SCI_Q_LOCAL_SEGMENT_IOADDR _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_LOCAL_SEGMENT_IOADDR) +extern const unsigned int SCI_Q_LOCAL_SEGMENT_IOADDR; + +#define SCI_Q_REMOTE_SEGMENT_IOADDR _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_REMOTE_SEGMENT_IOADDR) +extern const unsigned int SCI_Q_REMOTE_SEGMENT_IOADDR; + +#define SCI_Q_MAP_MAPPED_TO_LOCAL_TARGET _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_MAP_MAPPED_TO_LOCAL_TARGET) +extern const unsigned int SCI_Q_MAP_MAPPED_TO_LOCAL_TARGET; + +#define SCI_Q_MAP_QUERY_REMOTE_MAPPED_TO_LOCAL_TARGET _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_MAP_QUERY_REMOTE_MAPPED_TO_LOCAL_TARGET) +extern const unsigned int SCI_Q_MAP_QUERY_REMOTE_MAPPED_TO_LOCAL_TARGET; + +#define HOSTBRIDGE_NOT_AVAILABLE _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_NOT_AVAILABLE) +extern const unsigned int HOSTBRIDGE_NOT_AVAILABLE; + +#define HOSTBRIDGE_UNKNOWN _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_UNKNOWN) +extern const unsigned int HOSTBRIDGE_UNKNOWN; + +#define HOSTBRIDGE_440FX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_440FX) +extern const unsigned int HOSTBRIDGE_440FX; + +#define HOSTBRIDGE_440LX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_440LX) +extern const unsigned int HOSTBRIDGE_440LX; + +#define HOSTBRIDGE_440BX_A _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_440BX_A) +extern const unsigned int HOSTBRIDGE_440BX_A; + +#define HOSTBRIDGE_440BX_B _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_440BX_B) +extern const unsigned int HOSTBRIDGE_440BX_B; + +#define HOSTBRIDGE_440GX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_440GX) +extern const unsigned int HOSTBRIDGE_440GX; + +#define HOSTBRIDGE_450KX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_450KX) +extern const unsigned int HOSTBRIDGE_450KX; + +#define HOSTBRIDGE_430NX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_430NX) +extern const unsigned int HOSTBRIDGE_430NX; + +#define HOSTBRIDGE_450NX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_450NX) +extern const unsigned int HOSTBRIDGE_450NX; + +#define HOSTBRIDGE_450NX_MICO _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_450NX_MICO) +extern const unsigned int HOSTBRIDGE_450NX_MICO; + +#define HOSTBRIDGE_450NX_PXB _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_450NX_PXB) +extern const unsigned int HOSTBRIDGE_450NX_PXB; + +#define HOSTBRIDGE_I810 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I810) +extern const unsigned int HOSTBRIDGE_I810; + +#define HOSTBRIDGE_I810_DC100 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I810_DC100) +extern const unsigned int HOSTBRIDGE_I810_DC100; + +#define HOSTBRIDGE_I810E _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I810E) +extern const unsigned int HOSTBRIDGE_I810E; + +#define HOSTBRIDGE_I815 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I815) +extern const unsigned int HOSTBRIDGE_I815; + +#define HOSTBRIDGE_I840 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I840) +extern const unsigned int HOSTBRIDGE_I840; + +#define HOSTBRIDGE_I850 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I850) +extern const unsigned int HOSTBRIDGE_I850; + +#define HOSTBRIDGE_I860 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I860) +extern const unsigned int HOSTBRIDGE_I860; + +#define HOSTBRIDGE_VIA_KT133 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_VIA_KT133) +extern const unsigned int HOSTBRIDGE_VIA_KT133; + +#define HOSTBRIDGE_VIA_KX133 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_VIA_KX133) +extern const unsigned int HOSTBRIDGE_VIA_KX133; + +#define HOSTBRIDGE_VIA_APOLLO_PRO_133A _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_VIA_APOLLO_PRO_133A) +extern const unsigned int HOSTBRIDGE_VIA_APOLLO_PRO_133A; + +#define HOSTBRIDGE_VIA_APOLLO_PRO_266 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_VIA_APOLLO_PRO_266) +extern const unsigned int HOSTBRIDGE_VIA_APOLLO_PRO_266; + +#define HOSTBRIDGE_AMD_760_MP _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_AMD_760_MP) +extern const unsigned int HOSTBRIDGE_AMD_760_MP; + +#define HOSTBRIDGE_SERVERWORKS_HE _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_HE) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_HE; + +#define HOSTBRIDGE_SERVERWORKS_HE_B _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_HE_B) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_HE_B; + +#define HOSTBRIDGE_SERVERWORKS_LE _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_LE) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_LE; + + + +#define HOSTBRIDGE_WRITE_POSTING_DISABLED _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_WRITE_POSTING_DISABLED) +extern const unsigned int HOSTBRIDGE_WRITE_POSTING_DISABLED; + +#define HOSTBRIDGE_WRITE_POSTING_ENABLED _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_WRITE_POSTING_ENABLED) +extern const unsigned int HOSTBRIDGE_WRITE_POSTING_ENABLED; + + + + +/********************************************************************************* + * * + * S C I C R E A T E D M A Q U E U E * + * * + * Flags * + * * + * SCI_FLAG_DMA_PHDMA : Create physical DMA queue. Please note that this is an * + * priveleged operation. * + * * + * * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCICreateDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCICreateDMAQueue) +DLL void SCICreateDMAQueue(sci_desc_t sd, + sci_dma_queue_t *dq, + unsigned int localAdapterNo, + unsigned int maxEntries, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I R E M O V E D M A Q U E U E * + * * + * Flags * + * None. * * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Not allowed in this queue state. * + * * + *********************************************************************************/ +#define SCIRemoveDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCIRemoveDMAQueue) +DLL void SCIRemoveDMAQueue(sci_dma_queue_t dq, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I E N Q U E U E D M A T R A N S F E R * + * * + * Flags: * + * * + * SCI_FLAG_DMA_READ - The DMA will be remote --> local * + * (default is local --> remote) * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the offset and size is larger * + * than the segment size or larger than max * + * DMA size. * + * SCI_ERR_MAX_ENTRIES - The DMA queue is full * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_SEGMENT_NOT_PREPARED - The local segment has not been prepared for * + * access from the adapter associated with the * + * queue. * + * SCI_ERR_SEGMENT_NOT_CONNECTED - The remote segment is not connected through * + * the adapter associated with the queue. * + *********************************************************************************/ +#define SCIEnqueueDMATransfer _SISCI_EXPANDE_FUNCTION_NAME(SCIEnqueueDMATransfer) +DLL sci_dma_queue_state_t SCIEnqueueDMATransfer(sci_dma_queue_t dq, + sci_local_segment_t localSegment, + sci_remote_segment_t remoteSegment, + unsigned int localOffset, + unsigned int remoteOffset, + unsigned int size, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I P O S T D M A Q U E U E * + * * + * Flags: * + * * + * SCI_FLAG_USE_CALLBACK - The end of the transfer will cause the callback * + * function to be invoked. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * * + *********************************************************************************/ +#define SCIPostDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCIPostDMAQueue) +DLL void SCIPostDMAQueue(sci_dma_queue_t dq, + sci_cb_dma_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I A B O R T D M A Q U E U E * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * * + *********************************************************************************/ +#define SCIAbortDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCIAbortDMAQueue) +DLL void SCIAbortDMAQueue(sci_dma_queue_t dq, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I R E S E T D M A Q U E U E * + * * + * Flags * + * None. * * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIResetDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCIResetDMAQueue) +DLL void SCIResetDMAQueue(sci_dma_queue_t dq, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I D M A Q U E U E S T A T E * + * * + *********************************************************************************/ +#define SCIDMAQueueState _SISCI_EXPANDE_FUNCTION_NAME(SCIDMAQueueState) +DLL sci_dma_queue_state_t SCIDMAQueueState(sci_dma_queue_t dq); + + + +/********************************************************************************* + * * + * S C I W A I T F O R D M A Q U E U E * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * SCI_ERR_TIMEOUT - The function timed out after specified * + * timeout value. * + * * + *********************************************************************************/ +#define SCIWaitForDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCIWaitForDMAQueue) +DLL sci_dma_queue_state_t SCIWaitForDMAQueue(sci_dma_queue_t dq, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I P H D M A E N Q U E U E * + * * + * SISCI Priveleged function * + * * + * Flags * + * * + * SCI_FLAG_DMA_READ * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCIphDmaEnqueue _SISCI_EXPANDE_FUNCTION_NAME(SCIphDmaEnqueue) +DLL void SCIphDmaEnqueue(sci_dma_queue_t dmaqueue, + unsigned int size, + sci_ioaddr_t localBusAddr, + unsigned int remote_nodeid, + unsigned int remote_highaddr, + unsigned int remote_lowaddr, + unsigned int flags, + sci_error_t *error); + +/********************************************************************************* + * * + * S C I P H D M A S T A R T * + * * + * Flags * + * * + * SCI_FLAG_DMA_WAIT * + * SCI_FLAG_USE_CALLBACK * + * SCI_FLAG_DMA_RESET * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCIphDmaStart _SISCI_EXPANDE_FUNCTION_NAME(SCIphDmaStart) +DLL sci_dma_queue_state_t SCIphDmaStart(sci_dma_queue_t dmaqueue, + sci_cb_dma_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + +/********************************************************************************* + * * + * S C I C R E A T E I N T E R R U P T * + * * + * Flags * + * * + * SCI_FLAG_USE_CALLBACK * + * SCI_FLAG_FIXED_INTNO * + * SCI_FLAG_SHARED_INT * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_INTNO_USED - This interrupt number is already used. * + * * + *********************************************************************************/ +#define SCICreateInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCICreateInterrupt) +DLL void SCICreateInterrupt(sci_desc_t sd, + sci_local_interrupt_t *interrupt, + unsigned int localAdapterNo, + unsigned int *interruptNo, + sci_cb_interrupt_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I R E M O V E I N T E R R U P T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCIRemoveInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIRemoveInterrupt) +DLL void SCIRemoveInterrupt(sci_local_interrupt_t interrupt, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I W A I T F O R I N T E R R U P T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_TIMEOUT - The function timed out after specified timeout value. * + * SCI_ERR_CANCELLED - The wait was interrupted by a call to * + * SCIRemoveInterrupt. * + * The handle is invalid when this error code is returned.* + * * + *********************************************************************************/ +#define SCIWaitForInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIWaitForInterrupt) +DLL void SCIWaitForInterrupt(sci_local_interrupt_t interrupt, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I C O N N E C T I N T E R R U P T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_NO_SUCH_INTNO - No such interrupt number. * + * SCI_ERR_CONNECTION_REFUSED - Connection attempt refused by remote node. * + * SCI_ERR_TIMEOUT - The function timed out after specified * + * timeout value. * + * * + *********************************************************************************/ +#define SCIConnectInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIConnectInterrupt) +DLL void SCIConnectInterrupt(sci_desc_t sd, + sci_remote_interrupt_t *interrupt, + unsigned int nodeId, + unsigned int localAdapterNo, + unsigned int interruptNo, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I D I S C O N N E C T I N T E R R U P T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIDisconnectInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIDisconnectInterrupt) +DLL void SCIDisconnectInterrupt(sci_remote_interrupt_t interrupt, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I T R I G G E R I N T E R R U P T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCITriggerInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCITriggerInterrupt) +DLL void SCITriggerInterrupt(sci_remote_interrupt_t interrupt, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I R E G I S T E R I N T E R R U P T F L A G * + * * + * * + * This function register an "interrupt flag" that is identified as an unique * + * location within a local segment. If successful, the resulting interrupt * + * handle will have been associated with the specified local segment. * + * * + * It is up to the (remote) client(s) to set up an "interrupt mapping" for the * + * corresponding segment offset using either the * + * * + * - SCI_FLAG_CONDITIONAL_INTERRUPT_MAP * + * * + * or the * + * * + * - SCI_FLAG_UNCONDITIONAL_DATA_INTERRUPT_MAP * + * * + * option to "SCIMapRemoteSegment()". - I.e. after having established a * + * connection to the corresponding segment. A trigger operation can then * + * be implemented using a store operation via the relevant "interrupt map". * + * * + * * + * * + * * + * * + * Flags: * + * * + * SCI_FLAG_CONDITIONAL_INTERRUPT - Triggering is to take place using * + * "conditional interrupts". * + * * + * * + * * + * Specific error codes for this function: * + * None. * + * * + *********************************************************************************/ +#define SCIRegisterInterruptFlag _SISCI_EXPANDE_FUNCTION_NAME(SCIRegisterInterruptFlag) +DLL void SCIRegisterInterruptFlag( + unsigned int localAdapterNo, + sci_local_interrupt_t *interrupt, + sci_local_segment_t segment, + unsigned int offset, + sci_cb_interrupt_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I E N A B L E C O N D I T I O N A L I N T E R R U P T * + * * + * * + * This function make sure that another HW interrupt will take place the next * + * time the corresponding interrupt flag is triggered by a * + * "conditional interrupt" operation. * + * * + * Default semantics: * + * * + * When successful, the client can rely on that the first subsequent trigger * + * operation will cause a HW interrupt and subsequently cause the client * + * handler function to be invoked. * + * * + * If an interrupt was triggered in parallell with the enable operation, then * + * the operation will fail (SCI_ERR_COND_INT_RACE_PROBLEM), and the client can * + * not rely on another trigger operation will lead to handler invocation. * + * Hence, any state checking normally associated with handling the * + * corresponding interrupt should take place before attempting to enable * + * again. * + * * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_COND_INT_RACE_PROBLEM - The enable operation failed because an * + * incomming trigger operation happened * + * concurrently. * + * * + *********************************************************************************/ +#define SCIEnableConditionalInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIEnableConditionalInterrupt) +DLL void SCIEnableConditionalInterrupt( + sci_local_interrupt_t interrupt, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I D I S A B L E C O N D I T I O N A L I N T E R R U P T * + * * + * * + * Prevent subsequent "conditional interrupt"trigger operations for * + * the specified interupt flag from causing HW interrupt and handler * + * invocations. * + * * + * * + * Default semantics: * + * * + * If successful, no subsequent HW interrupts will take place, but handler * + * invocations that have already been scheduled may still take place. * + * * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIDisableConditionalInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIDisableConditionalInterrupt) +DLL void SCIDisableConditionalInterrupt( + sci_local_interrupt_t interrupt, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I G E T C O N D I T I O N A L I N T E R R U P T C O U N T E R * + * * + * * + * Returns a value that indicates the number of times this flag has * + * been trigged since the last time it was enabled or disabled. * + * Calling the SCIEnableConditionalInterrupt / SCIDisableConditionalInterrupt * + * functions will reset the counter value. * + * * + * Default semantics: * + * * + * If successful, the current trig count is returned in the * + * interruptTrigCounter parameter. * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OVERFLOW - The number of trig operations have exceeded the range * + * that can be counted. * + *********************************************************************************/ +#define SCIGetConditionalInterruptTrigCounter _SISCI_EXPANDE_FUNCTION_NAME(SCIGetConditionalInterruptTrigCounter) +DLL void SCIGetConditionalInterruptTrigCounter( + sci_local_interrupt_t interrupt, + unsigned int *interruptTrigCounter, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I T R A N S F E R B L O C K * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the size and offset is larger * + * than the corresponding map size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_TRANSFER_FAILED - The data transfer failed. * + * * + *********************************************************************************/ +#define SCITransferBlock _SISCI_EXPANDE_FUNCTION_NAME(SCITransferBlock) +DLL void SCITransferBlock(sci_map_t sourceMap, + unsigned int sourceOffset, + sci_map_t destinationMap, + unsigned int destinationOffset, + unsigned int size, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I T R A N S F E R B L O C K A S Y N C * + * * + * Flags * + * * + * SCI_FLAG_BLOCK_READ * + * SCI_FLAG_USE_CALLBACK * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the size and offset is larger than * + * the corresponding map size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required by * + * the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_TRANSFER_FAILED - The data transfer failed. * + * * + *********************************************************************************/ +#define SCITransferBlockAsync _SISCI_EXPANDE_FUNCTION_NAME(SCITransferBlockAsync) +DLL void SCITransferBlockAsync(sci_map_t sourceMap, + unsigned int sourceOffset, + sci_map_t destinationMap, + unsigned int destinationOffset, + unsigned int size, + sci_block_transfer_t *block, + sci_cb_block_transfer_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I W A I T F O R B L O C K T R A N S F E R * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * SCI_ERR_TIMEOUT - The function timed out after specified * + * timeout value. * + * * + *********************************************************************************/ +#define SCIWaitForBlockTransfer _SISCI_EXPANDE_FUNCTION_NAME(SCIWaitForBlockTransfer) +DLL void SCIWaitForBlockTransfer(sci_block_transfer_t block, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I A B O R T B L O C K T R A N S F E R * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * * + *********************************************************************************/ +#define SCIAbortBlockTransfer _SISCI_EXPANDE_FUNCTION_NAME(SCIAbortBlockTransfer) +DLL void SCIAbortBlockTransfer(sci_block_transfer_t block, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I M E M C P Y * + * * + * Flags: * + * SCI_FLAG_BLOCK_READ * + * SCI_FLAG_ERROR_CHECK * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the size and offset is larger * + * than the corresponding map size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_TRANSFER_FAILED - The data transfer failed. * + * * + *********************************************************************************/ + +#define SCIMemCpy _SISCI_EXPANDE_FUNCTION_NAME(SCIMemCpy) +DLL void SCIMemCpy(sci_sequence_t sequence, + void *memAddr, + sci_map_t remoteMap, + unsigned int remoteOffset, + unsigned int size, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I M E M C O P Y * + * * + * Flags: * + * SCI_FLAG_BLOCK_READ * + * SCI_FLAG_ERROR_CHECK * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the size and offset is larger * + * than the corresponding map size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_TRANSFER_FAILED - The data transfer failed. * + * * + *********************************************************************************/ + + +#define SCIMemCopy _SISCI_EXPANDE_FUNCTION_NAME(SCIMemCopy) +DLL void SCIMemCopy(void *memAddr, + sci_map_t remoteMap, + unsigned int remoteOffset, + unsigned int size, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I R E G I S T E R S E G M E N T M E M O R Y * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required by * + * the implementation. * + * SCI_ERR_ILLEGAL_ADDRESS - Illegal address. * + * SCI_ERR_OUT_OF_RANGE - Size is larger than the maximum size for the * + * local segment. * + * * + *********************************************************************************/ +#define SCIRegisterSegmentMemory _SISCI_EXPANDE_FUNCTION_NAME(SCIRegisterSegmentMemory) +DLL void SCIRegisterSegmentMemory(void *address, + unsigned int size, + sci_local_segment_t segment, + unsigned int flags, + sci_error_t *error); + + + + + +/********************************************************************************* + * * + * S C I C O N N E C T S C I S P A C E * + * * + * SISCI Priveleged function * + * * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_CONNECTION_REFUSED - Connection attempt refused by remote node. * + * * + *********************************************************************************/ +#define SCIConnectSCISpace _SISCI_EXPANDE_FUNCTION_NAME(SCIConnectSCISpace) +DLL void SCIConnectSCISpace(sci_desc_t sd, + unsigned int localAdapterNo, + sci_remote_segment_t *segment, + sci_address_t address, + unsigned int size, + unsigned int flags, + sci_error_t *error); + + + +/* + * ===================================================================================== + * + * S C I A T T A C H L O C A L S E G M E N T + * Description: + * + * SCIAttachLocalSegment() permits an application to "attach" to an already existing + * local segment, implying that two or more application want + * share the same local segment. The prerequest, is that the + * application which originally created the segment ("owner") has + * preformed a SCIShareSegment() in order to mark the segment + * "shareable". + * + * + * Flags: + * + * SCI_FLAG_USE_CALLBACK - The callback function will be invoked for events + * on this segment. + * + * + * Specific error codes for this function: + * + * SCI_ERR_ACCESS - No such shared segment + * SCI_ERR_NO_SUCH_SEGMENT - No such segment + * Note: Current implenentation will return SCI_ERR_ACCESS for both cases. This will + * change from next release. Application should handle both cases. + * + * ===================================================================================== + */ +#define SCIAttachLocalSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIAttachLocalSegment) + +DLL void +SCIAttachLocalSegment(sci_desc_t sd, + sci_local_segment_t *segment, + unsigned int segmentId, + unsigned int *size, + sci_cb_local_segment_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); +/* + * ===================================================================================== + * + * S C I S H A R E S E G M E N T + * + * Description: + * + * SCIShareSegment() permits other application to "attach" to an already existing + * local segment, implying that two or more application want + * share the same local segment. The prerequest, is that the + * application which originally created the segment ("owner") has + * preformed a SCIShareSegment() in order to mark the segment + * "shareable". + * + * + * Flags: + * none + * + * Specific error codes for this function: + * + * + * + * ===================================================================================== + */ +#define SCIShareSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIShareSegment) + +DLL void +SCIShareSegment(sci_local_segment_t segment, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I F L U S H * + * * + * This function will flush the CPU buffers and the PSB buffers. * + * * + * Flags * + * SCI_FLAG_FLUSH_CPU_BUFFERS_ONLY : * + * Only flush CPU buffers ( Write combining * + * etc buffers). * + * * + *********************************************************************************/ + +#define SCIFlush _SISCI_EXPANDE_FUNCTION_NAME(SCIFlush) +DLL void SCIFlush(sci_sequence_t sequence, + unsigned int flags); + +#if defined(CPLUSPLUS) || defined(__cplusplus) +} +#endif + + +#endif + + + + + + + + + + + diff --git a/ndb/src/external/SOLARIS.SPARC/sci/include/sisci_error.h b/ndb/src/external/SOLARIS.SPARC/sci/include/sisci_error.h new file mode 100644 index 00000000000..aab7c136d3a --- /dev/null +++ b/ndb/src/external/SOLARIS.SPARC/sci/include/sisci_error.h @@ -0,0 +1,89 @@ +/* $Id: sisci_error.h,v 1.1 2002/12/13 12:17:22 hin Exp $ */ + +/******************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + + + + +#ifndef _SISCI_ERROR_H_ +#define _SISCI_ERROR_H_ + + +/* SCI Error return values always have 30 bit set */ +#define SCI_ERR_MASK 0x40000000 +#define SCI_ERR_REMOTE_MASK 0x01 /* Remote errors should have bit 0 set */ + +#define SCI_ERR(u) ((unsigned32)(u)&0x7FFFFFFF ) + +/* Error codes */ +typedef enum { + SCI_ERR_OK = 0x000, + + + SCI_ERR_BUSY = (0x900 | SCI_ERR_MASK), + SCI_ERR_FLAG_NOT_IMPLEMENTED = (0x901 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_FLAG = (0x902 | SCI_ERR_MASK), + SCI_ERR_NOSPC = (0x904 | SCI_ERR_MASK), + SCI_ERR_API_NOSPC = (0x905 | SCI_ERR_MASK), + SCI_ERR_HW_NOSPC = (0x906 | SCI_ERR_MASK), + SCI_ERR_NOT_IMPLEMENTED = (0x907 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_ADAPTERNO = (0x908 | SCI_ERR_MASK), + SCI_ERR_NO_SUCH_ADAPTERNO = (0x909 | SCI_ERR_MASK), + SCI_ERR_TIMEOUT = (0x90A | SCI_ERR_MASK), + SCI_ERR_OUT_OF_RANGE = (0x90B | SCI_ERR_MASK), + SCI_ERR_NO_SUCH_SEGMENT = (0x90C | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_NODEID = (0x90D | SCI_ERR_MASK), + SCI_ERR_CONNECTION_REFUSED = (0x90E | SCI_ERR_MASK), + SCI_ERR_SEGMENT_NOT_CONNECTED = (0x90F | SCI_ERR_MASK), + SCI_ERR_SIZE_ALIGNMENT = (0x910 | SCI_ERR_MASK), + SCI_ERR_OFFSET_ALIGNMENT = (0x911 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_PARAMETER = (0x912 | SCI_ERR_MASK), + SCI_ERR_MAX_ENTRIES = (0x913 | SCI_ERR_MASK), + SCI_ERR_SEGMENT_NOT_PREPARED = (0x914 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_ADDRESS = (0x915 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_OPERATION = (0x916 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_QUERY = (0x917 | SCI_ERR_MASK), + SCI_ERR_SEGMENTID_USED = (0x918 | SCI_ERR_MASK), + SCI_ERR_SYSTEM = (0x919 | SCI_ERR_MASK), + SCI_ERR_CANCELLED = (0x91A | SCI_ERR_MASK), + SCI_ERR_NOT_CONNECTED = (0x91B | SCI_ERR_MASK), + SCI_ERR_NOT_AVAILABLE = (0x91C | SCI_ERR_MASK), + SCI_ERR_INCONSISTENT_VERSIONS = (0x91D | SCI_ERR_MASK), + SCI_ERR_COND_INT_RACE_PROBLEM = (0x91E | SCI_ERR_MASK), + SCI_ERR_OVERFLOW = (0x91F | SCI_ERR_MASK), + SCI_ERR_NOT_INITIALIZED = (0x920 | SCI_ERR_MASK), + + SCI_ERR_ACCESS = (0x921 | SCI_ERR_MASK), + + SCI_ERR_NO_SUCH_NODEID = (0xA00 | SCI_ERR_MASK), + SCI_ERR_NODE_NOT_RESPONDING = (0xA02 | SCI_ERR_MASK), + SCI_ERR_NO_REMOTE_LINK_ACCESS = (0xA04 | SCI_ERR_MASK), + SCI_ERR_NO_LINK_ACCESS = (0xA05 | SCI_ERR_MASK), + SCI_ERR_TRANSFER_FAILED = (0xA06 | SCI_ERR_MASK) +} sci_error_t; + + +#endif /* _SCI_ERROR_H_ */ + + + diff --git a/ndb/src/external/SOLARIS.SPARC/sci/include/sisci_types.h b/ndb/src/external/SOLARIS.SPARC/sci/include/sisci_types.h new file mode 100644 index 00000000000..77989ffca59 --- /dev/null +++ b/ndb/src/external/SOLARIS.SPARC/sci/include/sisci_types.h @@ -0,0 +1,133 @@ +/* $Id: sisci_types.h,v 1.1 2002/12/13 12:17:22 hin Exp $ */ + +/******************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + + +#ifndef _SISCI_TYPES_H +#define _SISCI_TYPES_H + +#include "sisci_error.h" + +#ifndef IN +#define IN +#endif + +#ifndef OUT +#define OUT +#endif + +#ifndef IN_OUT +#define IN_OUT +#endif + +/* Opaque data types for descriptors/handles */ +typedef struct sci_desc *sci_desc_t; +typedef struct sci_local_segment *sci_local_segment_t; +typedef struct sci_remote_segment *sci_remote_segment_t; + +typedef struct sci_map *sci_map_t; +typedef struct sci_sequence *sci_sequence_t; +#ifndef KERNEL +typedef struct sci_dma_queue *sci_dma_queue_t; +#endif +typedef struct sci_remote_interrupt *sci_remote_interrupt_t; +typedef struct sci_local_interrupt *sci_local_interrupt_t; +typedef struct sci_block_transfer *sci_block_transfer_t; + +/* + * Constants defining reasons for segment callbacks: + */ + +typedef enum { + SCI_CB_CONNECT = 1, + SCI_CB_DISCONNECT, + SCI_CB_NOT_OPERATIONAL, + SCI_CB_OPERATIONAL, + SCI_CB_LOST +} sci_segment_cb_reason_t; + +#define MAX_CB_REASON SCI_CB_LOST + +/* dma_queue_states is identical to the dma_queue_state_t in genif.h, they must be consistent.*/ +typedef enum { + SCI_DMAQUEUE_IDLE, + SCI_DMAQUEUE_GATHER, + SCI_DMAQUEUE_POSTED, + SCI_DMAQUEUE_DONE, + SCI_DMAQUEUE_ABORTED, + SCI_DMAQUEUE_ERROR +} sci_dma_queue_state_t; + + +typedef enum { + SCI_SEQ_OK, + SCI_SEQ_RETRIABLE, + SCI_SEQ_NOT_RETRIABLE, + SCI_SEQ_PENDING +} sci_sequence_status_t; + + +typedef struct { + unsigned short nodeId; /* SCI Address bit 63 - 48 */ + unsigned short offsHi; /* SCI Address bit 47 - 32 */ + unsigned int offsLo; /* SCI Address bit 31 - 0 */ +} sci_address_t; + + +typedef unsigned int sci_ioaddr_t; + +typedef enum { + SCI_CALLBACK_CANCEL = 1, + SCI_CALLBACK_CONTINUE +} sci_callback_action_t; + +#ifndef KERNEL +typedef sci_callback_action_t (*sci_cb_local_segment_t)(void *arg, + sci_local_segment_t segment, + sci_segment_cb_reason_t reason, + unsigned int nodeId, + unsigned int localAdapterNo, + sci_error_t error); + +typedef sci_callback_action_t (*sci_cb_remote_segment_t)(void *arg, + sci_remote_segment_t segment, + sci_segment_cb_reason_t reason, + sci_error_t status); + + +typedef sci_callback_action_t (*sci_cb_dma_t)(void IN *arg, + sci_dma_queue_t queue, + sci_error_t status); + + +typedef int (*sci_cb_block_transfer_t)(void *arg, + sci_block_transfer_t block, + sci_error_t status); + + +typedef sci_callback_action_t (*sci_cb_interrupt_t)(void *arg, + sci_local_interrupt_t interrupt, + sci_error_t status); + +#endif /* KERNEL */ +#endif diff --git a/ndb/src/external/SOLARIS.SPARC/sci/include/sisci_version.h b/ndb/src/external/SOLARIS.SPARC/sci/include/sisci_version.h new file mode 100644 index 00000000000..c2fccb9ec33 --- /dev/null +++ b/ndb/src/external/SOLARIS.SPARC/sci/include/sisci_version.h @@ -0,0 +1,91 @@ +/* $Id: sisci_version.h,v 1.1 2002/12/13 12:17:22 hin Exp $ */ + +/******************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU Lesser General Public License as published by * + * the Free Software Foundation; either version 2.1 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU Lesser General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + + +#ifndef SISCI_VERSION_H +#define SISCI_VERSION_H + + +#define SISCI_API_VER_MAJOR 1 +#define SISCI_API_VER_MAJORC "1" + +#define SISCI_API_VER_MINOR 10 +#define SISCI_API_VER_MINORC "10" +#define SISCI_API_VER_MICRO 4 +#define SISCI_API_VER_MICROC "4" + +#define SISCI_SIGN_VERSION_MASK 0xfffff000 /* used to mask off API_VER_MICRO */ + +#define SISCI_API_VERSION (SISCI_API_VER_MAJOR << 24 | SISCI_API_VER_MINOR << 12 | SISCI_API_VER_MICRO) + +/* the rules are: + * + * Changes in API_VER_MICRO should be binary compatible, New flags, functions added. No changes to user code + * required if new features is not needed. + * + * Changes in API_VER_MINOR requires recompilation of user code. + * + * Changes in the API_VER_MAJOR will most likely require changes to user code. This should not happen very + * often... + * + */ + +#ifndef BUILD_DATE +#define BUILD_DATE __DATE__ +#endif + +#ifndef BUILD_NAME +#define BUILD_NAME "" +#endif + +#define API_VERSION "SISCI API version " SISCI_API_VER_MAJORC "." SISCI_API_VER_MINORC "."SISCI_API_VER_MICROC " ( "BUILD_NAME" "BUILD_DATE" )" + +#endif + + +/* Version info: */ +/* */ +/* 1.5.2 First SISCI version */ +/* 1.5.3 Some bug fixes */ +/* 1.5.4 Some bug fixes */ +/* 1.5.5 No release */ +/* 1.5.6 Lock flag implemented in function SCIConnectSegment */ +/* 1.5.7 Expanded query functionality */ +/* 1.5.8 Updated error checking (sequence) functionality for D320 */ +/* 1.6.0 Updated error checking (sequence) D320 and IRM 1.9 support */ +/* 1.9.0 Ported to Solaris_sparc, Solaris_x86 and Linux. IRM 1.9. */ +/* 1.9.1 Some bug fixes */ +/* 1.9.2 Added more adapter queries */ +/* 1.9.3 Bug fix in SCIMapLocalSegment and SCIMapRemoteSegment */ +/* 1.9.4 NT Release Developers Kit 2.40 */ +/* 1.9.5 Added flush after data transfer in SCIMemCopy() */ +/* 1.9.5 NT Release Developers Kit 2.44 */ +/* 1.10.0: + * New SCIInitialize(), SCITerminate() functions. + * Support for D330 + * + * + */ + + diff --git a/ndb/src/external/WIN32.x86/sci/include/rmlib.h b/ndb/src/external/WIN32.x86/sci/include/rmlib.h new file mode 100644 index 00000000000..87ba20db99f --- /dev/null +++ b/ndb/src/external/WIN32.x86/sci/include/rmlib.h @@ -0,0 +1,212 @@ +/* $Id: rmlib.h,v 1.1 2002/12/13 12:17:23 hin Exp $ */ + +/********************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU Lesser General Public License as published by * + * the Free Software Foundation; either version 2.1 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU Lesser General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *********************************************************************************/ + +/********************************************************************************/ +/* This header file contains the declarations of the SCI Reflective Memory */ +/* library rmlib. The implementation of the library functions is in rmlib.c. */ +/* The library contains all the functions that operate on the reflective */ +/* memory. */ +/* */ +/* NB! */ +/* */ +/* DOLPHIN'S SCI REFLECTIVE MEMORY FILES ARE UNDER DEVELOPMENT AND MAY CHANGE. */ +/* PLEASE CONTACT DOLPHIN FOR FURTHER INFORMATION. */ +/* */ +/* */ +/********************************************************************************/ + +#include "sisci_error.h" +#include "sisci_api.h" +#include "sisci_demolib.h" +#include "sisci_types.h" + +unsigned int seqerr, syncseqerr; + +#ifndef _RMLIB_H +#define _RMLIB_H + + +#if defined(_REENTRANT) + +#define _RMLIB_EXPAND_NAME(name) _RMLIB_MT_ ## name + +#else + +#define _RMLIB_EXPAND_NAME(name) _RMLIB_ST_ ## name + +#endif + +#ifdef __sparc +#define CACHE_SIZE 2097152 +#else +#define CACHE_SIZE 8192 +#endif + +/*********************************************************************************/ +/* FLAG VALUES */ +/*********************************************************************************/ + +#define REFLECT_ERRCHECK 0x2 + +struct ReflectiveMemorySpace { + unsigned int localAdapterNo; + unsigned int localNodeId; + unsigned int remoteNodeId; + sci_desc_t sd; + sci_desc_t syncsd; + sci_map_t localMap; + sci_map_t remoteMap; + unsigned int localSegmentId; + unsigned int remoteSegmentId; + unsigned int syncSegmentId; + unsigned int sync_rSegmentId; + unsigned int segmentSize; + unsigned int *localMapAddr; + volatile unsigned int *remoteMapAddr; + sci_local_segment_t localSegment; + sci_remote_segment_t remoteSegment; + sci_local_segment_t syncSegment; + sci_remote_segment_t sync_rSegment; + sci_map_t syncMap; + sci_map_t sync_rMap; + sci_sequence_t syncsequence; + sci_sequence_t sequence; + unsigned int protection; + unsigned int retry_value; + sci_sequence_status_t sequenceStatus, syncsequenceStatus; + volatile unsigned int *syncMapAddr; + volatile unsigned int *sync_rMapAddr; +}; + +/*********************************************************************************/ +/* P R I N T R E F L E C T I V E M E M O R Y S P A C E */ +/* */ +/*********************************************************************************/ +#define ReflectPrintParameters _RMLIB_EXPAND_NAME(ReflectPrintParameters) +void ReflectPrintParameters(FILE *stream, struct ReflectiveMemorySpace RM_space); + +/*********************************************************************************/ +/* R E F L E C T D M A S E T U P */ +/* */ +/*********************************************************************************/ +#define ReflectDmaSetup _RMLIB_EXPAND_NAME(ReflectDmaSetup) +sci_error_t ReflectDmaSetup(struct ReflectiveMemorySpace RM_space, sci_dma_queue_t *dmaQueue); + +/*********************************************************************************/ +/* R E F L E C T D M A R E M O V E */ +/* */ +/*********************************************************************************/ +#define ReflectDmaRemove _RMLIB_EXPAND_NAME(ReflectDmaRemove) +sci_error_t ReflectDmaRemove(sci_dma_queue_t dmaQueue); + +/*********************************************************************************/ +/* R E F L E C T D M A R U N */ +/* */ +/*********************************************************************************/ +#define ReflectDmaRun _RMLIB_EXPAND_NAME(ReflectDmaRun) +sci_error_t ReflectDmaRun(struct ReflectiveMemorySpace RM_space, + unsigned int* privateSrc, + unsigned int size, + unsigned int offset, + sci_dma_queue_t dmaQueue); +/*********************************************************************************/ +/* C L O S E R E F L E C T I V E M E M O R Y S P A C E */ +/* */ +/*********************************************************************************/ +#define ReflectClose _RMLIB_EXPAND_NAME(ReflectClose) +sci_error_t ReflectClose(struct ReflectiveMemorySpace RM_space, unsigned int segment_no); + +/*********************************************************************************/ +/* O P E N R E F L E C T I V E M E M O R Y S P A C E */ +/* */ +/*********************************************************************************/ +#define ReflectOpen _RMLIB_EXPAND_NAME(ReflectOpen) +sci_error_t ReflectOpen(struct ReflectiveMemorySpace *RM_space, + unsigned int size, + unsigned int segment_no, + unsigned int localAdapterNo, + unsigned int remoteNodeId, + unsigned int protection, + unsigned int retry_value); + +/*********************************************************************************/ +/* R E F L E C T G E T A C C E S S */ +/* */ +/*********************************************************************************/ +#define ReflectGetAccess _RMLIB_EXPAND_NAME(ReflectGetAccess) +sci_error_t ReflectGetAccess(struct ReflectiveMemorySpace *RM_space); + +/*********************************************************************************/ +/* R E F L E C T R E L E A S E A C C E S S */ +/* */ +/*********************************************************************************/ +#define ReflectReleaseAccess _RMLIB_EXPAND_NAME(ReflectReleaseAccess) +sci_error_t ReflectReleaseAccess(struct ReflectiveMemorySpace *RM_space); + +/*********************************************************************************/ +/* R E F L E C T D M A */ +/* */ +/*********************************************************************************/ +#define ReflectDma _RMLIB_EXPAND_NAME(ReflectDma) +sci_error_t ReflectDma(struct ReflectiveMemorySpace RM_space, + unsigned int* privateSrc, + unsigned int size, + unsigned int offset); + +/*********************************************************************************/ +/* R E F L E C T M E M C O P Y */ +/* */ +/*********************************************************************************/ +#define ReflectMemCopy _RMLIB_EXPAND_NAME(ReflectMemCopy) +sci_error_t ReflectMemCopy(struct ReflectiveMemorySpace RM_space, + unsigned int* privateSrc, + unsigned int size, + unsigned int offset, + unsigned int flags); + +/*********************************************************************************/ +/* R E F L E C T S E T */ +/* */ +/*********************************************************************************/ +#define ReflectSet _RMLIB_EXPAND_NAME(ReflectSet) +sci_error_t ReflectSet(struct ReflectiveMemorySpace RM_space, + unsigned int value, + unsigned int size, + unsigned int offset, + unsigned int flags + ); + +/*********************************************************************************/ +/* R E F L E C T P R I N T */ +/* */ +/*********************************************************************************/ +#define ReflectPrint _RMLIB_EXPAND_NAME(ReflectPrint) +sci_error_t ReflectPrint(FILE *stream, + struct ReflectiveMemorySpace RM_space, + unsigned int size, + unsigned int offset + ); + + +#endif diff --git a/ndb/src/external/WIN32.x86/sci/include/scilib.h b/ndb/src/external/WIN32.x86/sci/include/scilib.h new file mode 100644 index 00000000000..d1501082bab --- /dev/null +++ b/ndb/src/external/WIN32.x86/sci/include/scilib.h @@ -0,0 +1,330 @@ +/* $Id: scilib.h,v 1.1 2002/12/13 12:17:23 hin Exp $ */ + +/******************************************************************************* + * * + * Copyright (C) 2002 * + * Dolphin Interconnect Solutions AS * + * * + *******************************************************************************/ + + +#if defined(_REENTRANT) +#define _SCIL_EXPANDE_FUNCTION_NAME(name) _SCIL_PUBLIC_FUNC_MT_ ## name +#define _SCIL_EXPANDE_VARIABLE_NAME(name) _SCIL_PUBLIC_VAR_MT_ ## name +#else +#define _SCIL_EXPANDE_FUNCTION_NAME(name) _SCIL_PUBLIC_FUNC_ST_ ## name +#define _SCIL_EXPANDE_VARIABLE_NAME(name) _SCIL_PUBLIC_VAR_ST_ ## name +#endif +#define _SCIL_EXPANDE_CONSTANT_NAME(name) _SCIL_PUBLIC_CONST_ ## name + +#include "sisci_api.h" + +#if defined(CPLUSPLUS) || defined(__cplusplus) +extern "C" { +#endif + + +/* + * SISCI segment id pollution: + * =========================== + * The SISCI library uses regular SISCI segmens internally. + * The MSG_QUEUE_LIB_IDENTIFIER_MASK is a mask which is used by the SISCI + * library to identify internal SISCI segments ids, from segments used directly + * by the user. + * + * Future versions of the library may have its own namespace. + * + */ + +#define MSG_QUEUE_LIB_IDENTIFIER_MASK 0x10000000 + + +/*********************************************************************************/ +/* FLAG VALUES */ +/*********************************************************************************/ + +#define SCIL_FLAG_ERROR_CHECK_DATA _SCIL_EXPANDE_CONSTANT_NAME(SCIL_FLAG_ERROR_CHECK_DATA) +extern const unsigned int SCIL_FLAG_ERROR_CHECK_DATA; + +#define SCIL_FLAG_ERROR_CHECK_PROT _SCIL_EXPANDE_CONSTANT_NAME(SCIL_FLAG_ERROR_CHECK_PROT) +extern const unsigned int SCIL_FLAG_ERROR_CHECK_PROT; + +#define SCIL_FLAG_FULL_ERROR_CHECK _SCIL_EXPANDE_CONSTANT_NAME(SCIL_FLAG_FULL_ERROR_CHECK) +extern const unsigned int SCIL_FLAG_FULL_ERROR_CHECK; + + + + + +typedef struct sci_msq_queue *sci_msq_queue_t; + + +/********************************************************************************* + * * + * S C I L C r e a t e M s g Q u e u e * + * * + * Parameters: * + * * + * Creates a message queue. The message queue identifier object will be allocated* + * if the sci_msq_queue_t * msg pointer is NULL. The function will create a * + * remote connection. If this connection times out, the function shoud be * + * repeated until connection is established. SCILRemoveMsgQueue() must be called * + * to remove the connection and deallocate the message queue identifier. * + * * + * sci_msq_queue_t *msq : Message queue identifier * + * The function must be called with a null pointer * + * the first time. * + * unsigned int localAdapterNo: Local Adapter Number * + * unsigned int remoteNodeId : Remote nodeId * + * unsigned int msqId : Message queue number * + * unsigned int maxMsgCount : The maximum count of messages in queue * + * unsigned int maxMsgSize, : The maximum size of each messages in queue * + * unsigned int timeout : Time to wait for successful connection * + * unsigned int flags : Flags. * + * * + * Flags * + * * + * None * + * * + * Specific error codes for this function: * + * * + * None. Normal SISIC error codes. * + * * + *********************************************************************************/ +#define SCILCreateMsgQueue _SCIL_EXPANDE_FUNCTION_NAME(SCILCreateMsgQueue) +DLL sci_error_t SCILCreateMsgQueue(sci_msq_queue_t *msq, + unsigned int localAdapterNo, + unsigned int remoteNodeId, + unsigned int msqId, + unsigned int maxMsgCount, + unsigned int maxMsgSize, + unsigned int timeout, + unsigned int flags); + + +/********************************************************************************* + * * + * S C I L R e c e i v e M s g * + * * + * * + * Receives a message from the queue. * + * * + * Paremeters * + * * + * sci_msq_queue_t msq : message queue identifier * + * void *msg : Location to store received data * + * unsigned int size : Size of message to read * + * unsigned int *sizeLeft: Bytes left in buffer, after current receive. This is * + * just a hint. There may be more. * + * * + * Flags * + * * + * SCIL_FLAG_ERROR_CHECK_PROT: The internal buffer management is done using full* + * error checking. + * * + * Specific error codes for this function: * + * * + * SCI_ERR_EWOULD_BLOCK : There is not enough data in the message buffer * + * to read the specified number of bytes. * + * . * + * SCI_ERR_NOT_CONNECTED : The connection is not established. * + * * + *********************************************************************************/ +#define SCILReceiveMsg _SCIL_EXPANDE_FUNCTION_NAME(SCILReceiveMsg) +DLL sci_error_t SCILReceiveMsg( + sci_msq_queue_t msq, + void *msg, + unsigned int size, + unsigned int *sizeLeft, + unsigned int flags); + + + +/********************************************************************************* + * * + * S C I L S e n d M s g * + * * + * * + * Sends a message to the queue. * + * * + * Paremeters * + * * + * sci_msq_queue_t msq : Message queue identifier * + * void *msg : Send data * + * unsigned int size : Size of message to send * + * unsigned int *sizeFree: Bytes free in buffer, after current send. This is * + * just a hint. There may be more. * + * * + * Flags * + * * + * SCIL_FLAG_ERROR_CHECK_DATA: The data is transmitted using full error checking* + * SCIL_FLAG_ERROR_CHECK_PROT: The internal buffer management is done using full* + * error checking. * + * SCIL_FLSG_FULL_ERROR_CHECK: This flag is an combination of both above. * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_EWOULD_BLOCK : There is not enough data in the message buffer * + * to send the specified number of bytes. * + * . * + * SCI_ERR_NOT_CONNECTED : The connection is not established. * + * * + *********************************************************************************/ +#define SCILSendMsg _SCIL_EXPANDE_FUNCTION_NAME(SCILSendMsg) +DLL sci_error_t SCILSendMsg( + sci_msq_queue_t msq, + void *msg, + unsigned int size, + unsigned int *sizeFree, + unsigned int flags); + + +/********************************************************************************* + * * + * S C I L R e m o v e M s g Q u e ue * + * * + * * + * Removes a message queue. * + * * + * sci_msq_queue_t msq : Message queue identifier * + * * + * Flags * + * * + * None * + * * + * Specific error codes for this function: * + * * + * None * + * * + *********************************************************************************/ +#define SCILRemoveMsgQueue _SCIL_EXPANDE_FUNCTION_NAME(SCILRemoveMsgQueue) +DLL sci_error_t SCILRemoveMsgQueue( + sci_msq_queue_t *msq, + unsigned int flags); + + + +/********************************************************************************* + * * + * S C I L I n i t * + * * + * * + * Initializes the SCI library. This function must be called before any other * + * function in the library. * + * * + * Flags * + * * + * None * + * * + * Specific error codes for this function: * + * * + * None * + * . * + *********************************************************************************/ +#define SCILInit _SCIL_EXPANDE_FUNCTION_NAME(SCILInit) +DLL sci_error_t SCILInit(unsigned int flags); + + + +/********************************************************************************* + * * + * S C I L D e s t r o y * + * * + * * + * Removes internal resources allocated by the SCI Library. No other library * + * function should be called after this function. * + * * + * Flags * + * * + * None * + * * + * Specific error codes for this function: * + * * + * None * + * * + *********************************************************************************/ +#define SCILDestroy _SCIL_EXPANDE_FUNCTION_NAME(SCILDestroy) +DLL sci_error_t SCILDestroy(unsigned int flags); + + + +/********************************************************************************* + * * + * S C I L C o n n e c t M s g Q u e u e * + * * + * * + * Makes a connection to a remote message queue. This must be done before * + * SCILSendMsg() is called. * + * * + * Parameters: * + * * + * sci_msq_queue_t *msq : Message queue identifier * + * unsigned int localAdapterNo: Local Adapter Number * + * unsigned int remoteNodeId : Remote nodeId * + * unsigned int msqId : Message queue number * + * unsigned int maxMsgCount : The maximum count of messages in queue * + * unsigned int maxMsgSize, : The maximum size of each messages in queue * + * unsigned int timeout : Time to wait for successful connection * + * unsigned int flags : Flags. * + * * + * Flags * + * * + * None * + * * + * Specific error codes for this function: * + * * + * None. Normal SISIC error codes. * + * * + *********************************************************************************/ +#define SCILConnectMsgQueue _SCIL_EXPANDE_FUNCTION_NAME(SCILConnectMsgQueue) +DLL sci_error_t SCILConnectMsgQueue(sci_msq_queue_t *msq, + unsigned int localAdapterNo, + unsigned int remoteNodeId, + unsigned int rmsgId, + unsigned int maxMsgCount, + unsigned int maxMsgSize, + unsigned int timeout, + unsigned int flags); + + + + +/********************************************************************************* + * * + * S C I L D i s c o n n e c t M s g Q u e u e * + * * + * * + * Disconnects from a remote message queue. * + * * + * Parameters: * + * * + * sci_msq_queue_t *msq : Message queue identifier * + * * + * Flags * + * * + * None * + * * + * Specific error codes for this function: * + * * + * None * + * * + *********************************************************************************/ +#define SCILDisconnectMsgQueue _SCIL_EXPANDE_FUNCTION_NAME(SCILDisconnectMsgQueue) +DLL sci_error_t SCILDisconnectMsgQueue(sci_msq_queue_t *msq, + unsigned int flags); + + + +#if defined(CPLUSPLUS) || defined(__cplusplus) +} +#endif + + + + + + + + + + diff --git a/ndb/src/external/WIN32.x86/sci/include/sisci_api.h b/ndb/src/external/WIN32.x86/sci/include/sisci_api.h new file mode 100644 index 00000000000..9f4a1ddffb3 --- /dev/null +++ b/ndb/src/external/WIN32.x86/sci/include/sisci_api.h @@ -0,0 +1,2217 @@ +/* $Id: sisci_api.h,v 1.1 2002/12/13 12:17:23 hin Exp $ */ +/******************************************************************************* + * * + * Copyright (C) 1993 - 2001 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU Lesser General Public License as published by * + * the Free Software Foundation; either version 2.1 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU Lesser General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + +#ifndef _SISCI_API_H +#define _SISCI_API_H + +#include "sisci_types.h" +#include "sisci_error.h" + + +#ifdef WIN32 +#ifdef API_DLL +#define DLL __declspec(dllexport) +#elif CLIENT_DLL +#define DLL __declspec(dllimport) +#endif +#endif /* WIN32 */ + + +#ifndef DLL +#define DLL +#endif + +#if defined(_REENTRANT) +#define _SISCI_EXPANDE_FUNCTION_NAME(name) _SISCI_PUBLIC_FUNC_MT_ ## name +#define _SISCI_EXPANDE_VARIABLE_NAME(name) _SISCI_PUBLIC_VAR_MT_ ## name +#else +#define _SISCI_EXPANDE_FUNCTION_NAME(name) _SISCI_PUBLIC_FUNC_ST_ ## name +#define _SISCI_EXPANDE_VARIABLE_NAME(name) _SISCI_PUBLIC_VAR_ST_ ## name +#endif +#define _SISCI_EXPANDE_CONSTANT_NAME(name) _SISCI_PUBLIC_CONST_ ## name + +#if defined(CPLUSPLUS) || defined(__cplusplus) +extern "C" { +#endif + + +/*********************************************************************************/ +/* FLAG VALUES */ +/*********************************************************************************/ + +#define SCI_FLAG_FIXED_INTNO _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FIXED_INTNO) +extern const unsigned int SCI_FLAG_FIXED_INTNO; + +#define SCI_FLAG_SHARED_INT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_SHARED_INT) +extern const unsigned int SCI_FLAG_SHARED_INT; + +#define SCI_FLAG_COUNTING_INT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_COUNTING_INT) +extern const unsigned int SCI_FLAG_COUNTING_INT; + +#define SCI_FLAG_FIXED_MAP_ADDR _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FIXED_MAP_ADDR) +extern const unsigned int SCI_FLAG_FIXED_MAP_ADDR; + +#define SCI_FLAG_READONLY_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_READONLY_MAP) +extern const unsigned int SCI_FLAG_READONLY_MAP; + +#define SCI_FLAG_USE_CALLBACK _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_USE_CALLBACK) +extern const unsigned int SCI_FLAG_USE_CALLBACK; + +#define SCI_FLAG_BLOCK_READ _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_BLOCK_READ) +extern const unsigned int SCI_FLAG_BLOCK_READ; + +#define SCI_FLAG_THREAD_SAFE _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_THREAD_SAFE) +extern const unsigned int SCI_FLAG_THREAD_SAFE; + +#define SCI_FLAG_ASYNCHRONOUS_CONNECT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_ASYNCHRONOUS_CONNECT) +extern const unsigned int SCI_FLAG_ASYNCHRONOUS_CONNECT; + +#define SCI_FLAG_EMPTY _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_EMPTY) +extern const unsigned int SCI_FLAG_EMPTY; + +#define SCI_FLAG_PRIVATE _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_PRIVATE) +extern const unsigned int SCI_FLAG_PRIVATE; + +#define SCI_FLAG_FORCE_DISCONNECT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FORCE_DISCONNECT) +extern const unsigned int SCI_FLAG_FORCE_DISCONNECT; + +#define SCI_FLAG_NOTIFY _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_NOTIFY) +extern const unsigned int SCI_FLAG_NOTIFY; + +#define SCI_FLAG_DMA_READ _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_READ) +extern const unsigned int SCI_FLAG_DMA_READ; + +#define SCI_FLAG_DMA_POST _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_POST) +extern const unsigned int SCI_FLAG_DMA_POST; + +#define SCI_FLAG_DMA_WAIT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_WAIT) +extern const unsigned int SCI_FLAG_DMA_WAIT; + +#define SCI_FLAG_DMA_RESET _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_RESET) +extern const unsigned int SCI_FLAG_DMA_RESET; + +#define SCI_FLAG_NO_FLUSH _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_NO_FLUSH) +extern const unsigned int SCI_FLAG_NO_FLUSH; + +#define SCI_FLAG_NO_STORE_BARRIER _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_NO_STORE_BARRIER) +extern const unsigned int SCI_FLAG_NO_STORE_BARRIER; + +#define SCI_FLAG_FAST_BARRIER _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FAST_BARRIER) +extern const unsigned int SCI_FLAG_FAST_BARRIER; + +#define SCI_FLAG_ERROR_CHECK _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_ERROR_CHECK) +extern const unsigned int SCI_FLAG_ERROR_CHECK; + +#define SCI_FLAG_FLUSH_CPU_BUFFERS_ONLY _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FLUSH_CPU_BUFFERS_ONLY) +extern const unsigned int SCI_FLAG_FLUSH_CPU_BUFFERS_ONLY; + +/* the FLUSH_CPU_BUFFERS_ONLY flag is for backwards compabillity only and should never be used */ +#define FLUSH_CPU_BUFFERS_ONLY _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_FLUSH_CPU_BUFFERS_ONLY) + +#define SCI_FLAG_LOCK_OPERATION _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_LOCK_OPERATION) +extern const unsigned int SCI_FLAG_LOCK_OPERATION; + +#define SCI_FLAG_READ_PREFETCH_AGGR_HOLD_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_READ_PREFETCH_AGGR_HOLD_MAP) +extern const unsigned int SCI_FLAG_READ_PREFETCH_AGGR_HOLD_MAP; + +#define SCI_FLAG_READ_PREFETCH_NO_HOLD_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_READ_PREFETCH_NO_HOLD_MAP) +extern const unsigned int SCI_FLAG_READ_PREFETCH_NO_HOLD_MAP; + +#define SCI_FLAG_IO_MAP_IOSPACE _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_IO_MAP_IOSPACE) +extern const unsigned int SCI_FLAG_IO_MAP_IOSPACE; + +#define SCI_FLAG_DMOVE_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMOVE_MAP) +extern const unsigned int SCI_FLAG_DMOVE_MAP; + +#define SCI_FLAG_WRITES_DISABLE_GATHER_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_WRITES_DISABLE_GATHER_MAP) +extern const unsigned int SCI_FLAG_WRITES_DISABLE_GATHER_MAP; + +#define SCI_FLAG_DISABLE_128_BYTES_PACKETS _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DISABLE_128_BYTES_PACKETS) +extern const unsigned int SCI_FLAG_DISABLE_128_BYTES_PACKETS; + +#define SCI_FLAG_SHARED_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_SHARED_MAP) +extern const unsigned int SCI_FLAG_SHARED_MAP; + +#define SCI_FLAG_DMA_SOURCE_ONLY _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_SOURCE_ONLY) +extern const unsigned int SCI_FLAG_DMA_SOURCE_ONLY; + +#define SCI_FLAG_CONDITIONAL_INTERRUPT _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_CONDITIONAL_INTERRUPT) +extern const unsigned int SCI_FLAG_CONDITIONAL_INTERRUPT; + +#define SCI_FLAG_CONDITIONAL_INTERRUPT_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_CONDITIONAL_INTERRUPT_MAP) +extern const unsigned int SCI_FLAG_CONDITIONAL_INTERRUPT_MAP; + +#define SCI_FLAG_UNCONDITIONAL_DATA_INTERRUPT_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_UNCONDITIONAL_DATA_INTERRUPT_MAP) +extern const unsigned int SCI_FLAG_UNCONDITIONAL_DATA_INTERRUPT_MAP; + +#define SCI_FLAG_NO_MEMORY_LOOPBACK_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_NO_MEMORY_LOOPBACK_MAP) +extern const unsigned int SCI_FLAG_NO_MEMORY_LOOPBACK_MAP; + +#if defined(OS_IS_LYNXOS) || defined(OS_IS_VXWORKS) +#define SCI_FLAG_WRITE_BACK_CACHE_MAP _SISCI_EXPANDE_CONSTANT_NAME(WRITE_BACK_CACHE_MAP) +extern const unsigned int SCI_FLAG_WRITE_BACK_CACHE_MAP; +#endif + +#define SCI_FLAG_DMA_PHDMA _SISCI_EXPANDE_CONSTANT_NAME(SCI_FLAG_DMA_PHDMA) +extern const unsigned int SCI_FLAG_DMA_PHDMA; + +/*********************************************************************************/ +/* GENERAL VALUES */ +/*********************************************************************************/ +#define SCI_LOCAL_HOST _SISCI_EXPANDE_CONSTANT_NAME(SCI_LOCAL_HOST) +extern const unsigned int SCI_LOCAL_HOST; + +#define SCI_INFINITE_TIMEOUT _SISCI_EXPANDE_CONSTANT_NAME(SCI_INFINITE_TIMEOUT) +extern const unsigned int SCI_INFINITE_TIMEOUT; + +/*********************************************************************************/ +/* GENERAL ERROR CODES */ +/* */ +/* SCI_ERR_ILLEGAL_FLAG - Illegal flag value. */ +/* SCI_ERR_FLAG_NOT_IMPLEMENTED - Flag legal but flag feature not implemented. */ +/* SCI_ERR_NOT_IMPLEMENTED - Function not implemented. */ +/* SCI_ERR_SYSTEM - A system error. Check errno. */ +/* SCI_ERR_NOSPC - Unable to allocate OS resources. */ +/* SCI_ERR_API_NOSPC - Unable to allocate API resources. */ +/* SCI_ERR_HW_NOSPC - Unable to allocate HW resources (Hardware) */ +/* */ +/*********************************************************************************/ + + +/*********************************************************************************/ +/* GENERAL "ADAPTER" ERROR CODES */ +/* */ +/* SCI_ERR_NO_SUCH_ADAPTERNO - Adapter number is legal but does not exist. */ +/* SCI_ERR_ILLEGAL_ADAPTERNO - Illegal local adapter number (i.e. outside */ +/* legal range). */ +/* */ +/*********************************************************************************/ + + +/*********************************************************************************/ +/* GENERAL "NODEID" ERROR CODES */ +/* */ +/* SCI_ERR_NO_SUCH_NODEID - The remote adapter identified by nodeId does */ +/* not respond, but the intermediate link(s) */ +/* seem(s) to be operational. */ +/* SCI_ERR_ILLEGAL_NODEID - Illegal NodeId. */ +/* */ +/*********************************************************************************/ + + + +/********************************************************************************* + * * + * S C I I N I T I A L I Z E * + * * + * This function initializes the SISCI library. * + * The function must be called before SCIOpen(). * + * * + * Flags: * + * None * + * * + * Specific error codes for this function: * + * * + * None * + * * + *********************************************************************************/ +#define SCIInitialize _SISCI_EXPANDE_FUNCTION_NAME(SCIInitialize) +DLL void SCIInitialize(unsigned int flags, + sci_error_t *error); +#if 0 +unsigned int __Internal_SISCI_version_var; +#endif + +/********************************************************************************* + * * + * S C I T E R M I N A T E * + * * + * This function terminates the SISCI library. * + * The function must be called after SCIClose(). * + * * + * * + *********************************************************************************/ +#define SCITerminate _SISCI_EXPANDE_FUNCTION_NAME(SCITerminate) +DLL void SCITerminate(void); + +/********************************************************************************* + * * + * S C I O P E N * + * * + * * + * Opens a SCI virtual device. * + * Caller must supply a pointer to a variable of type sci_desc_t to be * + * initialized. * + * * + * Flags * + * SCI_FLAG_THREAD_SAFE - Operations on resources associated with this * + * descriptor will be performed in a multithread-safe * + * manner. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_INCONSISTENT_VERSIONS - Inconsistency between the SISCI library * + * and the SISCI driver versions. * + * * + * * + *********************************************************************************/ +#define SCIOpen _SISCI_EXPANDE_FUNCTION_NAME(SCIOpen) +DLL void SCIOpen(sci_desc_t *sd, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I C L O S E * + * * + * This function closes an open SCI virtual device. * + * * + * Flags: * + * None * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_BUSY - All resources are not deallocated. * + * * + *********************************************************************************/ +#define SCIClose _SISCI_EXPANDE_FUNCTION_NAME(SCIClose) +DLL void SCIClose(sci_desc_t sd, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I C O N N E C T S E G M E N T * + * * + * Connects to a remote shared memory segment located at with the * + * identifier . * + * The user may then call SCIMapRemoteSegment() to map shared memory * + * into user space. * + * * + * Flags * + * SCI_FLAG_USE_CALLBACK * + * SCI_FLAG_ASYNCHRONOUS_CONNECT * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_NO_SUCH_SEGMENT - Could not find the remote segment with the * + * given segmentId. * + * SCI_ERR_CONNECTION_REFUSED - Connection attempt refused by remote node. * + * SCI_ERR_TIMEOUT - The function timed out after specified * + * timeout value. * + * SCI_ERR_NO_LINK_ACCESS - It was not possible to communicate via the * + * local adapter. * + * SCI_ERR_NO_REMOTE_LINK_ACCESS - It was not possible to communicate via a * + * remote switch port. * + * * + *********************************************************************************/ +#define SCIConnectSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIConnectSegment) +DLL void SCIConnectSegment(sci_desc_t sd, + sci_remote_segment_t *segment, + unsigned int nodeId, + unsigned int segmentId, + unsigned int localAdapterNo, + sci_cb_remote_segment_t callback, + void *callbackArg, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I D I S C O N N E C T S E G M E N T * + * * + * Disconnects from the give mapped shared memory segment * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_BUSY - The segment is currently mapped or in use. * + * * + *********************************************************************************/ +#define SCIDisconnectSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIDisconnectSegment) +DLL void SCIDisconnectSegment(sci_remote_segment_t segment, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I G E T R E M O T E S E G M E N T S I Z E * + * * + *********************************************************************************/ +#define SCIGetRemoteSegmentSize _SISCI_EXPANDE_FUNCTION_NAME(SCIGetRemoteSegmentSize) +DLL unsigned int SCIGetRemoteSegmentSize(sci_remote_segment_t segment); + + + +/********************************************************************************* + * * + * S C I W A I T F O R R E M O T E S E G M E N T E V E N T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_TIMEOUT - The function timed out after specified * + * timeout value. * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation. * + * SCI_ERR_CANCELLED - The wait operation has been cancelled du * + * to a SCIDisconnectSegment() on the same * + * handle. The handle is invalid when this * + * error is returned. * + * * + *********************************************************************************/ +#define SCIWaitForRemoteSegmentEvent _SISCI_EXPANDE_FUNCTION_NAME(SCIWaitForRemoteSegmentEvent) +DLL sci_segment_cb_reason_t SCIWaitForRemoteSegmentEvent( + sci_remote_segment_t segment, + sci_error_t *status, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I M A P R E M O T E S E G M E N T * + * * + * This function is used to include a shared memory segment in the virtual * + * address space of the application. * + * * + * Flags: * + * * + * SCI_FLAG_SHARED_MAP - The low level physical map may be shared by * + * other applications. * + * * + * SCI_FLAG_FIXED_MAP_ADDR - Map at the suggested virtual address * + * SCI_FLAG_READONLY_MAP - The segment is mapped in read-only mode * + * SCI_FLAG_LOCK_OPERATION - Enable Lock operations (fetch and add) * + * SCI_FLAG_READ_PREFETCH_AGGR_HOLD_MAP * + * - Enable aggressive prefetch with speculative * + * hold. * + * * + * SCI_FLAG_READ_PREFETCH_NO_HOLD_MAP * + * - The PSB66 will prefetch 64 bytes. As soon * + * as the PCI read retry has been accepted, * + * the stream will change state to FREE, even * + * if less than 64 bytes were actually read. * + * * + * SCI_FLAG_IO_MAP_IOSPACE - Enable No Prefetch, no speculative hold. * + * * + * SCI_FLAG_DMOVE_MAP - Enable DMOVE packet type. The stream will be * + * set into FREE state immediately. * + * * + * SCI_FLAG_WRITES_DISABLE_GATHER_MAP * + * - Disable use of gather. * + * * + * SCI_FLAG_DISABLE_128_BYTES_PACKETS * + * - Disable use of 128-Byte packets * + * * + * SCI_FLAG_CONDITIONAL_INTERRUPT_MAP * + * - Write operations through this map will cause * + * an atomic "fetch-and-add-one" operation on * + * remote memory, but in addition an interrupt * + * will be generated if the target memory * + * location contained a "null value" before the * + * add operation was carried out. * + * The conditional interrupt flag must also be * + * specified in the SCIRegisterInterruptFlag() * + * function. * + * * + * SCI_FLAG_UNCONDITIONAL_INTERRUPT_MAP * + * - Write operations through this map will cause * + * an interrupt for the remote adapter * + * "in addition to" updating the corresponding * + * remote memory location with the data being * + * written. * + * The unconditional interrupt flag must also * + * be specified in the * + * SCIRegisterInterruptFlag() function. * + * * + * SCI_FLAG_WRITE_BACK_CACHE_MAP * + * - Enable cacheing of the mapped region. * + * Writes through this map will be written to a * + * write back cache, hence no remote SCI updates* + * until the cache line is flushed. The * + * application is responsible for the cache * + * flush operation. * + * The SCImemCopy() function will handle this * + * correctly by doing cache flushes internally. * + * This feature is architechture dependent and * + * not be available on all plattforms. * + * * + * SCI_FLAG_NO_MEMORY_LOOPBACK_MAP * + * - Forces a map to a remote segment located * + * in the local machine to be mapped using * + * SCI loopback. This is useful i.e. if you * + * want to use a regular map access to be * + * serialized with lock operations. * + * The default behaviour is to access a remte * + * segment located in the local machine as a * + * local MMU operation. * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the offset and size is * + * larger than the segment size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as * + * required by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as * + * required by the implementation. * + * * + *********************************************************************************/ +#define SCIMapRemoteSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIMapRemoteSegment) +DLL volatile void *SCIMapRemoteSegment( + sci_remote_segment_t segment, + sci_map_t *map, + unsigned int offset, + unsigned int size, + void *addr, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I M A P L O C A L S E G M E N T * + * * + * Flags * + * * + * SCI_FLAG_FIXED_MAP_ADDR * + * SCI_FLAG_READONLY_MAP * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the offset and size is * + * larger than the segment size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as * + * required by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as * + * required by the implementation. * + * * + *********************************************************************************/ +#define SCIMapLocalSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIMapLocalSegment) +DLL void *SCIMapLocalSegment(sci_local_segment_t segment, + sci_map_t *map, + unsigned int offset, + unsigned int size, + void *addr, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I U N M A P S E G M E N T * + * * + * This function unmaps pages of shared memory from the callers virtual * + * address space. * + * * + * Flags * + * None. * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_BUSY - The map is currently in use. * + * * + *********************************************************************************/ +#define SCIUnmapSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIUnmapSegment) +DLL void SCIUnmapSegment(sci_map_t map, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I C R E A T E S E G M E N T * + * * + * Make the specified segment available for connections via the specified * + * adapter. If successful, the segment can be accessed from remote nodes * + * via the specified adapter. * + * * + * Flags: * + * * + * SCI_FLAG_USE_CALLBACK - The callback function will be invoked for events * + * on this segment. * + * SCI_FLAG_EMPTY - No memory will be allocated for the segment. * + * SCI_FLAG_PRIVATE - The segment will be private meaning it will never * + * be any connections to it. * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_SEGMENTID_USED - The segment with this segmentId is already used * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * * + *********************************************************************************/ +#define SCICreateSegment _SISCI_EXPANDE_FUNCTION_NAME(SCICreateSegment) +DLL void SCICreateSegment(sci_desc_t sd, + sci_local_segment_t *segment, + unsigned int segmentId, + unsigned int size, + sci_cb_local_segment_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I W A I T F O R L O C A L S E G M E N T E V E N T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_TIMEOUT - The function timed out after specified timeout value. * + * SCI_ERR_CANCELLED - The wait operation has been cancelled du to a * + * SCIRemoveSegment() on the same handle. * + * The handle is invalid when this error is returned. * + * * + *********************************************************************************/ +#define SCIWaitForLocalSegmentEvent _SISCI_EXPANDE_FUNCTION_NAME(SCIWaitForLocalSegmentEvent) +DLL sci_segment_cb_reason_t SCIWaitForLocalSegmentEvent( + sci_local_segment_t segment, + unsigned int *sourcenodeId, + unsigned int *localAdapterNo, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I P R E P A R E S E G M E N T * + * * + * Flags * + * * + * SCI_FLAG_DMA_SOURCE_ONLY - The segment will be used as a source segment * + * for DMA operations. On some system types this * + * will enable the SISCI driver to use performance * + * improving features. * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIPrepareSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIPrepareSegment) +DLL void SCIPrepareSegment(sci_local_segment_t segment, + unsigned int localAdapterNo, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I R E M O V E S E G M E N T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_BUSY - Unable to remove the segment. The segment is currently * + * in use. * + * * + *********************************************************************************/ +#define SCIRemoveSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIRemoveSegment) +DLL void SCIRemoveSegment(sci_local_segment_t segment, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I S E T S E G M E N T A V A I L A B L E * + * * + * Flags * + * None. * + * * + * * + * SCI_ERR_SEGMENT_NOT_PREPARED - The segment has not been prepared for access * + * from this adapter. * + * SCI_ERR_ILLEGAL_OPERATION - The segment is created with the * + * SCI_FLAG_PRIVATE flag specified and * + * therefore has no segmentId. * + * * + *********************************************************************************/ +#define SCISetSegmentAvailable _SISCI_EXPANDE_FUNCTION_NAME(SCISetSegmentAvailable) +DLL void SCISetSegmentAvailable(sci_local_segment_t segment, + unsigned int localAdapterNo, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I S E T S E G M E N T U N A V A I L A B L E * + * * + * Flags * + * * + * SCI_FLAG_FORCE_DISCONNECT * + * SCI_FLAG_NOTIFY * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation. * + * * + *********************************************************************************/ +#define SCISetSegmentUnavailable _SISCI_EXPANDE_FUNCTION_NAME(SCISetSegmentUnavailable) +DLL void SCISetSegmentUnavailable(sci_local_segment_t segment, + unsigned int localAdapterNo, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I C R E A T E M A P S E Q U E N C E * + * * + * Flags: * + * * + * SCI_FLAG_FAST_BARRIER * + * * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCICreateMapSequence _SISCI_EXPANDE_FUNCTION_NAME(SCICreateMapSequence) +DLL void SCICreateMapSequence(sci_map_t map, + sci_sequence_t *sequence, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I R E M O V E S E Q U E N C E * + * * + * Flags: * + * None * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCIRemoveSequence _SISCI_EXPANDE_FUNCTION_NAME(SCIRemoveSequence) +DLL void SCIRemoveSequence(sci_sequence_t sequence, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I S T A R T S E Q U E N C E * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIStartSequence _SISCI_EXPANDE_FUNCTION_NAME(SCIStartSequence) +DLL sci_sequence_status_t SCIStartSequence(sci_sequence_t sequence, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I C H E C K S E Q U E N CE * + * * + * Flags * + * * + * SCI_FLAG_NO_FLUSH * + * SCI_FLAG_NO_STORE_BARRIER * + * * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCICheckSequence _SISCI_EXPANDE_FUNCTION_NAME(SCICheckSequence) +DLL sci_sequence_status_t SCICheckSequence(sci_sequence_t sequence, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I S T O R E B A R R I E R * + * * + * Flags * + * None. * + * * + * * + * * + *********************************************************************************/ +#define SCIStoreBarrier _SISCI_EXPANDE_FUNCTION_NAME(SCIStoreBarrier) +DLL void SCIStoreBarrier(sci_sequence_t sequence, + unsigned int flags); + + + + +/********************************************************************************* + * * + * S C I F L U S H R E A D B U F F E R S * + * * + *********************************************************************************/ +#define SCIFlushReadBuffers _SISCI_EXPANDE_FUNCTION_NAME(SCIFlushReadBuffers) +DLL void SCIFlushReadBuffers(sci_sequence_t sequence); + + + + +/********************************************************************************* + * * + * S C I P R O B E N O D E * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_NO_LINK_ACCESS - It was not possible to communicate via the * + * local adapter. * + * SCI_ERR_NO_REMOTE_LINK_ACCESS - It was not possible to communicate via a * + * remote switch port. * + * * + *********************************************************************************/ +#define SCIProbeNode _SISCI_EXPANDE_FUNCTION_NAME(SCIProbeNode) +DLL int SCIProbeNode(sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int nodeId, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I G E T C S R R E G I S T E R * + * * + * SISCI Priveleged function * + * * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_NO_LINK_ACCESS - It was not possible to communicate via the * + * local adapter. * + * SCI_ERR_NO_REMOTE_LINK_ACCESS - It was not possible to communicate via a * + * remote switch port. * + * * + *********************************************************************************/ +#define SCIGetCSRRegister _SISCI_EXPANDE_FUNCTION_NAME(SCIGetCSRRegister) +DLL unsigned int SCIGetCSRRegister(sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int SCINodeId, + unsigned int CSROffset, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I S E T C S R R E G I S T E R * + * * + * SISCI Priveleged function * + * * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_NO_LINK_ACCESS - It was not possible to communicate via the * + * local adapter. * + * SCI_ERR_NO_REMOTE_LINK_ACCESS - It was not possible to communicate via a * + * remote switch port. * + * * + *********************************************************************************/ +#define SCISetCSRRegister _SISCI_EXPANDE_FUNCTION_NAME(SCISetCSRRegister) +DLL void SCISetCSRRegister(sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int SCINodeId, + unsigned int CSROffset, + unsigned int CSRValue, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I G E T L O C A L C S R * + * * + * SISCI Priveleged function * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIGetLocalCSR _SISCI_EXPANDE_FUNCTION_NAME(SCIGetLocalCSR) +DLL unsigned int SCIGetLocalCSR(sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int CSROffset, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I S E T L O C A L C S R * + * * + * SISCI Priveleged function + * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCISetLocalCSR _SISCI_EXPANDE_FUNCTION_NAME(SCISetLocalCSR) +DLL void SCISetLocalCSR(sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int CSROffset, + unsigned int CSRValue, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I A T T A C H P H Y S I C A L M E M O R Y * + * * + * SISCI Priveleged function * + * * + * Description: * + * * + * This function enables usage of physical devices and memory regions where the * + * Physical PCI bus address ( and mapped CPU address ) are already known. * + * The function will register the physical memory as a SISCI segment which can * + * be connected and mapped as a regular SISCI segment. * + * * + * Requirements: * + * * + * SCICreateSegment() with flag SCI_FLAG_EMPTY must have been called in advance * + * * + * Parameter description: * + * sci_ioaddr_t ioaddress : This is the address on the PCI bus that a PCI bus * + * master has to use to write to the specified memory * + * void * address : This is the (mapped) virtual address that the * + * application has to use to access the device. * + * This means that the device has to be mapped in * + * advance bye the devices own driver. * + * If the device is not to be accessed by the local * + * CPU, the address pointer shold be set to NULL * + * Flags * + * * + * None * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIAttachPhysicalMemory _SISCI_EXPANDE_FUNCTION_NAME(SCIAttachPhysicalMemory) +DLL void SCIAttachPhysicalMemory(sci_ioaddr_t ioaddress, + void *address, + unsigned int busNo, + unsigned int size, + sci_local_segment_t segment, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I Q U E R Y * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_QUERY - Unrecognized command. * + * * + *********************************************************************************/ +#define SCIQuery _SISCI_EXPANDE_FUNCTION_NAME(SCIQuery) +DLL void SCIQuery(unsigned int command, + void *data, + unsigned int flags, + sci_error_t *error); + + +/* MAJOR QUERY COMMANDS */ + +/* This command requires a pointer to a structure of type */ +/* "sci_query_string". The string will be filled in by the query. */ +#define SCI_Q_VENDORID _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_VENDORID) +extern const unsigned int SCI_Q_VENDORID; + + +/* Same as for SCI_VENDOR_ID */ +#define SCI_Q_API _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_API) +extern const unsigned int SCI_Q_API; + + +/* User passes a pointer to an allocated object of the */ +/* "sci_query_adapter" struct. */ +#define SCI_Q_ADAPTER _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER) +extern const unsigned int SCI_Q_ADAPTER; + + +/* User passes a pointer to an allocated object of the */ +/* "sci_query_system" struct. */ +#define SCI_Q_SYSTEM _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SYSTEM) +extern const unsigned int SCI_Q_SYSTEM; + +#define SCI_Q_LOCAL_SEGMENT _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_LOCAL_SEGMENT) +extern const unsigned int SCI_Q_LOCAL_SEGMENT; + +#define SCI_Q_REMOTE_SEGMENT _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_REMOTE_SEGMENT) +extern const unsigned int SCI_Q_REMOTE_SEGMENT; + +#define SCI_Q_MAP _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_MAP) +extern const unsigned int SCI_Q_MAP; + +typedef char* sci_semaphoreId_t; + +#ifdef WIN32 +struct _semaphoreid { + char *semaphoreName; +}; +#endif /*WIN32*/ + +typedef struct { + char *str; /* Pointer to a string of minimum "length" characters */ + unsigned int length; +} sci_query_string_t; + + +typedef struct { + unsigned int localAdapterNo; /* The adapter no. that the query concern. */ + unsigned int portNo; /* The SCI Link port number that the query concern. */ + unsigned int subcommand; /* A subcommand as specified below. */ + void *data; /* A pointer to an unsigned int that will return */ + /* the response to the query. */ +} sci_query_adapter_t; + + +typedef struct { + unsigned int subcommand; /* A subcommand as specified below. */ + void *data; /* A pointer to an unsigned int that will return */ + /* the response to the query. */ +} sci_query_system_t; + +typedef struct { + sci_local_segment_t segment; + unsigned int subcommand; + union { + sci_ioaddr_t ioaddr; + } data; +} sci_query_local_segment_t; + +typedef struct { + sci_remote_segment_t segment; + unsigned int subcommand; + union { + sci_ioaddr_t ioaddr; + } data; +} sci_query_remote_segment_t; + +typedef struct { + sci_map_t map; + unsigned int subcommand; + unsigned int data; +} sci_query_map_t; + +/* Minor query commands (sub-commands) for adapter specific information SCI_ADAPTER */ +#define SCI_Q_ADAPTER_DMA_SIZE_ALIGNMENT _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_DMA_SIZE_ALIGNMENT) +extern const unsigned int SCI_Q_ADAPTER_DMA_SIZE_ALIGNMENT; + +#define SCI_Q_ADAPTER_DMA_OFFSET_ALIGNMENT _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_DMA_OFFSET_ALIGNMENT) +extern const unsigned int SCI_Q_ADAPTER_DMA_OFFSET_ALIGNMENT; + +#define SCI_Q_ADAPTER_DMA_MTU _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_DMA_MTU) +extern const unsigned int SCI_Q_ADAPTER_DMA_MTU; + +#define SCI_Q_ADAPTER_SUGGESTED_MIN_DMA_SIZE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_SUGGESTED_MIN_DMA_SIZE) +extern const unsigned int SCI_Q_ADAPTER_SUGGESTED_MIN_DMA_SIZE; + +#define SCI_Q_ADAPTER_SUGGESTED_MIN_BLOCK_SIZE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_SUGGESTED_MIN_BLOCK_SIZE) +extern const unsigned int SCI_Q_ADAPTER_SUGGESTED_MIN_BLOCK_SIZE; + +#define SCI_Q_ADAPTER_NODEID _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_NODEID) +extern const unsigned int SCI_Q_ADAPTER_NODEID; + +#define SCI_Q_ADAPTER_SERIAL_NUMBER _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_SERIAL_NUMBER) +extern const unsigned int SCI_Q_ADAPTER_SERIAL_NUMBER; + +#define SCI_Q_ADAPTER_CARD_TYPE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_CARD_TYPE) +extern const unsigned int SCI_Q_ADAPTER_CARD_TYPE; + +#define SCI_Q_ADAPTER_NUMBER_OF_STREAMS _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_NUMBER_OF_STREAMS) +extern const unsigned int SCI_Q_ADAPTER_NUMBER_OF_STREAMS; + +#define SCI_Q_ADAPTER_STREAM_BUFFER_SIZE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_STREAM_BUFFER_SIZE) +extern const unsigned int SCI_Q_ADAPTER_STREAM_BUFFER_SIZE; + +#define SCI_Q_ADAPTER_CONFIGURED _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_CONFIGURED) +extern const unsigned int SCI_Q_ADAPTER_CONFIGURED; + +#define SCI_Q_ADAPTER_LINK_OPERATIONAL _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_LINK_OPERATIONAL) +extern const unsigned int SCI_Q_ADAPTER_LINK_OPERATIONAL; + +#define SCI_Q_ADAPTER_HW_LINK_STATUS_IS_OK _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_HW_LINK_STATUS_IS_OK) +extern const unsigned int SCI_Q_ADAPTER_HW_LINK_STATUS_IS_OK; + +#define SCI_Q_ADAPTER_NUMBER _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_NUMBER) +extern const unsigned int SCI_Q_ADAPTER_NUMBER; + +#define SCI_Q_ADAPTER_INSTANCE_NUMBER _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_INSTANCE_NUMBER) +extern const unsigned int SCI_Q_ADAPTER_INSTANCE_NUMBER; + +#define SCI_Q_ADAPTER_FIRMWARE_OK _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_FIRMWARE_OK) +extern const unsigned int SCI_Q_ADAPTER_FIRMWARE_OK; + +#define SCI_Q_ADAPTER_CONNECTED_TO_SWITCH _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_CONNECTED_TO_SWITCH) +extern const unsigned int SCI_Q_ADAPTER_CONNECTED_TO_SWITCH; + +#define SCI_Q_ADAPTER_LOCAL_SWITCH_TYPE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_LOCAL_SWITCH_TYPE) +extern const unsigned int SCI_Q_ADAPTER_LOCAL_SWITCH_TYPE; + +#define SCI_Q_ADAPTER_LOCAL_SWITCH_PORT_NUMBER _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_LOCAL_SWITCH_PORT_NUMBER) +extern const unsigned int SCI_Q_ADAPTER_LOCAL_SWITCH_PORT_NUMBER; + +#define SCI_Q_ADAPTER_CONNECTED_TO_EXPECTED_SWITCH_PORT _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_CONNECTED_TO_EXPECTED_SWITCH_PORT) +extern const unsigned int SCI_Q_ADAPTER_CONNECTED_TO_EXPECTED_SWITCH_PORT; + +#define SCI_Q_ADAPTER_ATT_PAGE_SIZE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_ATT_PAGE_SIZE) +extern const unsigned int SCI_Q_ADAPTER_ATT_PAGE_SIZE; + +#define SCI_Q_ADAPTER_ATT_NUMBER_OF_ENTRIES _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_ATT_NUMBER_OF_ENTRIES) +extern const unsigned int SCI_Q_ADAPTER_ATT_NUMBER_OF_ENTRIES; + +#define SCI_Q_ADAPTER_ATT_AVAILABLE_ENTRIES _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_ATT_AVAILABLE_ENTRIES) +extern const unsigned int SCI_Q_ADAPTER_ATT_AVAILABLE_ENTRIES; + +#define SCI_Q_ADAPTER_PHYS_MEM_NODEID _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SCI_Q_ADAPTER_PHYS_MEM_NODEID) +extern const unsigned int SCI_Q_ADAPTER_PHYS_MEM_NODEID; + +#define SCI_Q_ADAPTER_PHYS_MBX_NODEID _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SCI_Q_ADAPTER_PHYS_MBX_NODEID) +extern const unsigned int SCI_Q_ADAPTER_PHYS_MBX_NODEID; + +#define SCI_Q_ADAPTER_PHYS_LINK_PORT_NODEID _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_PHYS_LINK_PORT_NODEID) +extern const unsigned int SCI_Q_ADAPTER_PHYS_LINK_PORT_NODEID; + +#define SCI_Q_ADAPTER_SCI_LINK_FREQUENCY _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_SCI_LINK_FREQUENCY) +extern const unsigned int SCI_Q_ADAPTER_SCI_LINK_FREQUENCY; + +#define SCI_Q_ADAPTER_B_LINK_FREQUENCY _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_B_LINK_FREQUENCY) +extern const unsigned int SCI_Q_ADAPTER_B_LINK_FREQUENCY; + +#define SCI_Q_ADAPTER_IO_BUS_FREQUENCY _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_ADAPTER_IO_BUS_FREQUENCY) +extern const unsigned int SCI_Q_ADAPTER_IO_BUS_FREQUENCY; + +/* Minor query commands (sub-commands) for adapter specific information SCI_SYSTEM */ +#define SCI_Q_SYSTEM_HOSTBRIDGE _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SYSTEM_HOSTBRIDGE) +extern const unsigned int SCI_Q_SYSTEM_HOSTBRIDGE; + +#define SCI_Q_SYSTEM_WRITE_POSTING_ENABLED _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SYSTEM_WRITE_POSTING_ENABLED) +extern const unsigned int SCI_Q_SYSTEM_WRITE_POSTING_ENABLED; + +#define SCI_Q_SYSTEM_WRITE_COMBINING_ENABLED _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_SYSTEM_WRITE_COMBINING_ENABLED) +extern const unsigned int SCI_Q_SYSTEM_WRITE_COMBINING_ENABLED; + +#define SCI_Q_LOCAL_SEGMENT_IOADDR _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_LOCAL_SEGMENT_IOADDR) +extern const unsigned int SCI_Q_LOCAL_SEGMENT_IOADDR; + +#define SCI_Q_REMOTE_SEGMENT_IOADDR _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_REMOTE_SEGMENT_IOADDR) +extern const unsigned int SCI_Q_REMOTE_SEGMENT_IOADDR; + +#define SCI_Q_MAP_MAPPED_TO_LOCAL_TARGET _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_MAP_MAPPED_TO_LOCAL_TARGET) +extern const unsigned int SCI_Q_MAP_MAPPED_TO_LOCAL_TARGET; + +#define SCI_Q_MAP_QUERY_REMOTE_MAPPED_TO_LOCAL_TARGET _SISCI_EXPANDE_CONSTANT_NAME(SCI_Q_MAP_QUERY_REMOTE_MAPPED_TO_LOCAL_TARGET) +extern const unsigned int SCI_Q_MAP_QUERY_REMOTE_MAPPED_TO_LOCAL_TARGET; + +#define HOSTBRIDGE_NOT_AVAILABLE _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_NOT_AVAILABLE) +extern const unsigned int HOSTBRIDGE_NOT_AVAILABLE; + +#define HOSTBRIDGE_UNKNOWN _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_UNKNOWN) +extern const unsigned int HOSTBRIDGE_UNKNOWN; + +#define HOSTBRIDGE_440FX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_440FX) +extern const unsigned int HOSTBRIDGE_440FX; + +#define HOSTBRIDGE_440LX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_440LX) +extern const unsigned int HOSTBRIDGE_440LX; + +#define HOSTBRIDGE_440BX_A _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_440BX_A) +extern const unsigned int HOSTBRIDGE_440BX_A; + +#define HOSTBRIDGE_440BX_B _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_440BX_B) +extern const unsigned int HOSTBRIDGE_440BX_B; + +#define HOSTBRIDGE_440GX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_440GX) +extern const unsigned int HOSTBRIDGE_440GX; + +#define HOSTBRIDGE_450KX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_450KX) +extern const unsigned int HOSTBRIDGE_450KX; + +#define HOSTBRIDGE_430NX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_430NX) +extern const unsigned int HOSTBRIDGE_430NX; + +#define HOSTBRIDGE_450NX _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_450NX) +extern const unsigned int HOSTBRIDGE_450NX; + +#define HOSTBRIDGE_450NX_MICO _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_450NX_MICO) +extern const unsigned int HOSTBRIDGE_450NX_MICO; + +#define HOSTBRIDGE_450NX_PXB _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_450NX_PXB) +extern const unsigned int HOSTBRIDGE_450NX_PXB; + +#define HOSTBRIDGE_I810 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I810) +extern const unsigned int HOSTBRIDGE_I810; + +#define HOSTBRIDGE_I810_DC100 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I810_DC100) +extern const unsigned int HOSTBRIDGE_I810_DC100; + +#define HOSTBRIDGE_I810E _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I810E) +extern const unsigned int HOSTBRIDGE_I810E; + +#define HOSTBRIDGE_I815 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I815) +extern const unsigned int HOSTBRIDGE_I815; + +#define HOSTBRIDGE_I840 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I840) +extern const unsigned int HOSTBRIDGE_I840; + +#define HOSTBRIDGE_I850 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I850) +extern const unsigned int HOSTBRIDGE_I850; + +#define HOSTBRIDGE_I860 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_I860) +extern const unsigned int HOSTBRIDGE_I860; + +#define HOSTBRIDGE_INTEL_E7500 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_INTEL_E7500) +extern const unsigned int HOSTBRIDGE_INTEL_E7500; + +#define HOSTBRIDGE_VIA_KT133 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_VIA_KT133) +extern const unsigned int HOSTBRIDGE_VIA_KT133; + +#define HOSTBRIDGE_VIA_KX133 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_VIA_KX133) +extern const unsigned int HOSTBRIDGE_VIA_KX133; + +#define HOSTBRIDGE_VIA_APOLLO_PRO_133A _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_VIA_APOLLO_PRO_133A) +extern const unsigned int HOSTBRIDGE_VIA_APOLLO_PRO_133A; + +#define HOSTBRIDGE_VIA_APOLLO_PRO_266 _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_VIA_APOLLO_PRO_266) +extern const unsigned int HOSTBRIDGE_VIA_APOLLO_PRO_266; + +#define HOSTBRIDGE_AMD_760_MP _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_AMD_760_MP) +extern const unsigned int HOSTBRIDGE_AMD_760_MP; + +#define HOSTBRIDGE_AMD_HAMMER _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_AMD_HAMMER) +extern const unsigned int HOSTBRIDGE_AMD_HAMMER; + +#define HOSTBRIDGE_SERVERWORKS_HE _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_HE) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_HE; + +#define HOSTBRIDGE_SERVERWORKS_HE_B _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_HE_B) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_HE_B; + +#define HOSTBRIDGE_SERVERWORKS_LE _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_LE) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_LE; + +#define HOSTBRIDGE_SERVERWORKS_GC_HE _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_GC_HE) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_GC_HE; + +#define HOSTBRIDGE_SERVERWORKS_GC_LE _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_GC_LE) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_GC_LE; + +#define HOSTBRIDGE_SERVERWORKS_GC_WS _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_GC_WS) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_GC_WS; + +#define HOSTBRIDGE_SERVERWORKS_GC_SL _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_SERVERWORKS_GC_SL) +extern const unsigned int HOSTBRIDGE_SERVERWORKS_GC_SL; + + +#define HOSTBRIDGE_WRITE_POSTING_DISABLED _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_WRITE_POSTING_DISABLED) +extern const unsigned int HOSTBRIDGE_WRITE_POSTING_DISABLED; + +#define HOSTBRIDGE_WRITE_POSTING_ENABLED _SISCI_EXPANDE_CONSTANT_NAME(HOSTBRIDGE_WRITE_POSTING_ENABLED) +extern const unsigned int HOSTBRIDGE_WRITE_POSTING_ENABLED; + + + + +/********************************************************************************* + * * + * S C I C R E A T E D M A Q U E U E * + * * + * Flags * + * * + * SCI_FLAG_DMA_PHDMA : Create physical DMA queue. Please note that this is an * + * priveleged operation. * + * * + * * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCICreateDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCICreateDMAQueue) +DLL void SCICreateDMAQueue(sci_desc_t sd, + sci_dma_queue_t *dq, + unsigned int localAdapterNo, + unsigned int maxEntries, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I R E M O V E D M A Q U E U E * + * * + * Flags * + * None. * * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Not allowed in this queue state. * + * * + *********************************************************************************/ +#define SCIRemoveDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCIRemoveDMAQueue) +DLL void SCIRemoveDMAQueue(sci_dma_queue_t dq, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I E N Q U E U E D M A T R A N S F E R * + * * + * Flags: * + * * + * SCI_FLAG_DMA_READ - The DMA will be remote --> local * + * (default is local --> remote) * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the offset and size is larger * + * than the segment size or larger than max * + * DMA size. * + * SCI_ERR_MAX_ENTRIES - The DMA queue is full * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_SEGMENT_NOT_PREPARED - The local segment has not been prepared for * + * access from the adapter associated with the * + * queue. * + * SCI_ERR_SEGMENT_NOT_CONNECTED - The remote segment is not connected through * + * the adapter associated with the queue. * + *********************************************************************************/ +#define SCIEnqueueDMATransfer _SISCI_EXPANDE_FUNCTION_NAME(SCIEnqueueDMATransfer) +DLL sci_dma_queue_state_t SCIEnqueueDMATransfer(sci_dma_queue_t dq, + sci_local_segment_t localSegment, + sci_remote_segment_t remoteSegment, + unsigned int localOffset, + unsigned int remoteOffset, + unsigned int size, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I P O S T D M A Q U E U E * + * * + * Flags: * + * * + * SCI_FLAG_USE_CALLBACK - The end of the transfer will cause the callback * + * function to be invoked. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * * + *********************************************************************************/ +#define SCIPostDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCIPostDMAQueue) +DLL void SCIPostDMAQueue(sci_dma_queue_t dq, + sci_cb_dma_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I A B O R T D M A Q U E U E * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * * + *********************************************************************************/ +#define SCIAbortDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCIAbortDMAQueue) +DLL void SCIAbortDMAQueue(sci_dma_queue_t dq, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I R E S E T D M A Q U E U E * + * * + * Flags * + * None. * * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIResetDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCIResetDMAQueue) +DLL void SCIResetDMAQueue(sci_dma_queue_t dq, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I D M A Q U E U E S T A T E * + * * + *********************************************************************************/ +#define SCIDMAQueueState _SISCI_EXPANDE_FUNCTION_NAME(SCIDMAQueueState) +DLL sci_dma_queue_state_t SCIDMAQueueState(sci_dma_queue_t dq); + + + +/********************************************************************************* + * * + * S C I W A I T F O R D M A Q U E U E * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * SCI_ERR_TIMEOUT - The function timed out after specified * + * timeout value. * + * * + *********************************************************************************/ +#define SCIWaitForDMAQueue _SISCI_EXPANDE_FUNCTION_NAME(SCIWaitForDMAQueue) +DLL sci_dma_queue_state_t SCIWaitForDMAQueue(sci_dma_queue_t dq, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I P H D M A E N Q U E U E * + * * + * SISCI Priveleged function * + * * + * Flags * + * * + * SCI_FLAG_DMA_READ * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCIphDmaEnqueue _SISCI_EXPANDE_FUNCTION_NAME(SCIphDmaEnqueue) +DLL void SCIphDmaEnqueue(sci_dma_queue_t dmaqueue, + unsigned int size, + sci_ioaddr_t localBusAddr, + unsigned int remote_nodeid, + unsigned int remote_highaddr, + unsigned int remote_lowaddr, + unsigned int flags, + sci_error_t *error); + +/********************************************************************************* + * * + * S C I P H D M A S T A R T * + * * + * Flags * + * * + * SCI_FLAG_DMA_WAIT * + * SCI_FLAG_USE_CALLBACK * + * SCI_FLAG_DMA_RESET * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCIphDmaStart _SISCI_EXPANDE_FUNCTION_NAME(SCIphDmaStart) +DLL sci_dma_queue_state_t SCIphDmaStart(sci_dma_queue_t dmaqueue, + sci_cb_dma_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + +#ifdef WIN32 +/********************************************************************************* + * * + * S C I C R E A T E N A M E D I N T E R R U P T * + * * + * Flags * + * * + * SCI_FLAG_USE_CALLBACK * + * SCI_FLAG_FIXED_INTNO * + * SCI_FLAG_SHARED_INT * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_INTNO_USED - This interrupt number is already used. * + * * + *********************************************************************************/ +#define SCICreateNamedInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCICreateNamedInterrupt) +DLL void SCICreateNamedInterrupt(sci_desc_t sd, + sci_local_interrupt_t *interrupt, + unsigned int localAdapterNo, + unsigned int *interruptNo, + sci_cb_interrupt_t callback, + void *callbackArg, + unsigned int flags, + sci_semaphoreId_t semId, + sci_error_t *error); +#endif /*WIN32*/ + +/********************************************************************************* + * * + * S C I C R E A T E I N T E R R U P T * + * * + * Flags * + * * + * SCI_FLAG_USE_CALLBACK * + * SCI_FLAG_FIXED_INTNO * + * SCI_FLAG_SHARED_INT * + * SCI_FLAG_COUNTING_INT: This flag will enable counting interrupts. This means * + * that the number of trigged interrupts is equal to the * + * number of received interrupts. * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_INTNO_USED - This interrupt number is already used. * + * * + *********************************************************************************/ +#define SCICreateInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCICreateInterrupt) +DLL void SCICreateInterrupt(sci_desc_t sd, + sci_local_interrupt_t *interrupt, + unsigned int localAdapterNo, + unsigned int *interruptNo, + sci_cb_interrupt_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I R E M O V E I N T E R R U P T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + *********************************************************************************/ +#define SCIRemoveInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIRemoveInterrupt) +DLL void SCIRemoveInterrupt(sci_local_interrupt_t interrupt, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I W A I T F O R I N T E R R U P T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_TIMEOUT - The function timed out after specified timeout value. * + * SCI_ERR_CANCELLED - The wait was interrupted by a call to * + * SCIRemoveInterrupt. * + * The handle is invalid when this error code is returned.* + * * + *********************************************************************************/ +#define SCIWaitForInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIWaitForInterrupt) +DLL void SCIWaitForInterrupt(sci_local_interrupt_t interrupt, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I C O N N E C T I N T E R R U P T * + * * + * Flags * + * * + * SCI_FLAG_COUNTING_INT: This flag will enable counting interrupts. This means * + * that the number of trigged interrupts is equal to the * + * number of received interrupts. * + * if SCI_FLAG_COUNTING_INT is not used, the interface * + * guarentees that there always will be an remote * + * interrupt generated after the first and after the last* + * trigger. If interupts is triggered faster than the * + * remote interrupt handler can handle, interrupts may be* + * lost. * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_NO_SUCH_INTNO - No such interrupt number. * + * SCI_ERR_CONNECTION_REFUSED - Connection attempt refused by remote node. * + * SCI_ERR_TIMEOUT - The function timed out after specified * + * timeout value. * + * * + *********************************************************************************/ +#define SCIConnectInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIConnectInterrupt) +DLL void SCIConnectInterrupt(sci_desc_t sd, + sci_remote_interrupt_t *interrupt, + unsigned int nodeId, + unsigned int localAdapterNo, + unsigned int interruptNo, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I D I S C O N N E C T I N T E R R U P T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIDisconnectInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIDisconnectInterrupt) +DLL void SCIDisconnectInterrupt(sci_remote_interrupt_t interrupt, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I T R I G G E R I N T E R R U P T * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCITriggerInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCITriggerInterrupt) +DLL void SCITriggerInterrupt(sci_remote_interrupt_t interrupt, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I R E G I S T E R I N T E R R U P T F L A G * + * * + * * + * This function register an "interrupt flag" that is identified as an unique * + * location within a local segment. If successful, the resulting interrupt * + * handle will have been associated with the specified local segment. * + * * + * It is up to the (remote) client(s) to set up an "interrupt mapping" for the * + * corresponding segment offset using either the * + * * + * - SCI_FLAG_CONDITIONAL_INTERRUPT_MAP * + * * + * or the * + * * + * - SCI_FLAG_UNCONDITIONAL_DATA_INTERRUPT_MAP * + * * + * option to "SCIMapRemoteSegment()". - I.e. after having established a * + * connection to the corresponding segment. A trigger operation can then * + * be implemented using a store operation via the relevant "interrupt map". * + * * + * * + * * + * * + * * + * Flags: * + * * + * SCI_FLAG_CONDITIONAL_INTERRUPT - Triggering is to take place using * + * "conditional interrupts". * + * * + * * + * * + * Specific error codes for this function: * + * None. * + * * + *********************************************************************************/ +#define SCIRegisterInterruptFlag _SISCI_EXPANDE_FUNCTION_NAME(SCIRegisterInterruptFlag) +DLL void SCIRegisterInterruptFlag( + unsigned int localAdapterNo, + sci_local_interrupt_t *interrupt, + sci_local_segment_t segment, + unsigned int offset, + sci_cb_interrupt_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I E N A B L E C O N D I T I O N A L I N T E R R U P T * + * * + * * + * This function make sure that another HW interrupt will take place the next * + * time the corresponding interrupt flag is triggered by a * + * "conditional interrupt" operation. * + * * + * Default semantics: * + * * + * When successful, the client can rely on that the first subsequent trigger * + * operation will cause a HW interrupt and subsequently cause the client * + * handler function to be invoked. * + * * + * If an interrupt was triggered in parallell with the enable operation, then * + * the operation will fail (SCI_ERR_COND_INT_RACE_PROBLEM), and the client can * + * not rely on another trigger operation will lead to handler invocation. * + * Hence, any state checking normally associated with handling the * + * corresponding interrupt should take place before attempting to enable * + * again. * + * * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_COND_INT_RACE_PROBLEM - The enable operation failed because an * + * incomming trigger operation happened * + * concurrently. * + * * + *********************************************************************************/ +#define SCIEnableConditionalInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIEnableConditionalInterrupt) +DLL void SCIEnableConditionalInterrupt( + sci_local_interrupt_t interrupt, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I D I S A B L E C O N D I T I O N A L I N T E R R U P T * + * * + * * + * Prevent subsequent "conditional interrupt"trigger operations for * + * the specified interupt flag from causing HW interrupt and handler * + * invocations. * + * * + * * + * Default semantics: * + * * + * If successful, no subsequent HW interrupts will take place, but handler * + * invocations that have already been scheduled may still take place. * + * * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * * + *********************************************************************************/ +#define SCIDisableConditionalInterrupt _SISCI_EXPANDE_FUNCTION_NAME(SCIDisableConditionalInterrupt) +DLL void SCIDisableConditionalInterrupt( + sci_local_interrupt_t interrupt, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I G E T C O N D I T I O N A L I N T E R R U P T C O U N T E R * + * * + * * + * Returns a value that indicates the number of times this flag has * + * been trigged since the last time it was enabled or disabled. * + * Calling the SCIEnableConditionalInterrupt / SCIDisableConditionalInterrupt * + * functions will reset the counter value. * + * * + * Default semantics: * + * * + * If successful, the current trig count is returned in the * + * interruptTrigCounter parameter. * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OVERFLOW - The number of trig operations have exceeded the range * + * that can be counted. * + *********************************************************************************/ +#define SCIGetConditionalInterruptTrigCounter _SISCI_EXPANDE_FUNCTION_NAME(SCIGetConditionalInterruptTrigCounter) +DLL void SCIGetConditionalInterruptTrigCounter( + sci_local_interrupt_t interrupt, + unsigned int *interruptTrigCounter, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I T R A N S F E R B L O C K * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the size and offset is larger * + * than the corresponding map size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_TRANSFER_FAILED - The data transfer failed. * + * * + *********************************************************************************/ +#define SCITransferBlock _SISCI_EXPANDE_FUNCTION_NAME(SCITransferBlock) +DLL void SCITransferBlock(sci_map_t sourceMap, + unsigned int sourceOffset, + sci_map_t destinationMap, + unsigned int destinationOffset, + unsigned int size, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I T R A N S F E R B L O C K A S Y N C * + * * + * Flags * + * * + * SCI_FLAG_BLOCK_READ * + * SCI_FLAG_USE_CALLBACK * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the size and offset is larger than * + * the corresponding map size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required by * + * the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_TRANSFER_FAILED - The data transfer failed. * + * * + *********************************************************************************/ +#define SCITransferBlockAsync _SISCI_EXPANDE_FUNCTION_NAME(SCITransferBlockAsync) +DLL void SCITransferBlockAsync(sci_map_t sourceMap, + unsigned int sourceOffset, + sci_map_t destinationMap, + unsigned int destinationOffset, + unsigned int size, + sci_block_transfer_t *block, + sci_cb_block_transfer_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I W A I T F O R B L O C K T R A N S F E R * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * SCI_ERR_TIMEOUT - The function timed out after specified * + * timeout value. * + * * + *********************************************************************************/ +#define SCIWaitForBlockTransfer _SISCI_EXPANDE_FUNCTION_NAME(SCIWaitForBlockTransfer) +DLL void SCIWaitForBlockTransfer(sci_block_transfer_t block, + unsigned int timeout, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I A B O R T B L O C K T R A N S F E R * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_ILLEGAL_OPERATION - Illegal operation * + * * + *********************************************************************************/ +#define SCIAbortBlockTransfer _SISCI_EXPANDE_FUNCTION_NAME(SCIAbortBlockTransfer) +DLL void SCIAbortBlockTransfer(sci_block_transfer_t block, + unsigned int flags, + sci_error_t *error); + + + + +/********************************************************************************* + * * + * S C I M E M C P Y * + * * + * Flags: * + * SCI_FLAG_BLOCK_READ * + * SCI_FLAG_ERROR_CHECK * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the size and offset is larger * + * than the corresponding map size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_TRANSFER_FAILED - The data transfer failed. * + * * + *********************************************************************************/ + +#define SCIMemCpy _SISCI_EXPANDE_FUNCTION_NAME(SCIMemCpy) +DLL void SCIMemCpy(sci_sequence_t sequence, + void *memAddr, + sci_map_t remoteMap, + unsigned int remoteOffset, + unsigned int size, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I M E M C O P Y * + * * + * Flags: * + * SCI_FLAG_BLOCK_READ * + * SCI_FLAG_ERROR_CHECK * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_OUT_OF_RANGE - The sum of the size and offset is larger * + * than the corresponding map size. * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_OFFSET_ALIGNMENT - Offset is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_TRANSFER_FAILED - The data transfer failed. * + * * + *********************************************************************************/ + + +#define SCIMemCopy _SISCI_EXPANDE_FUNCTION_NAME(SCIMemCopy) +DLL void SCIMemCopy(void *memAddr, + sci_map_t remoteMap, + unsigned int remoteOffset, + unsigned int size, + unsigned int flags, + sci_error_t *error); + + + +/********************************************************************************* + * * + * S C I R E G I S T E R S E G M E N T M E M O R Y * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required by * + * the implementation. * + * SCI_ERR_ILLEGAL_ADDRESS - Illegal address. * + * SCI_ERR_OUT_OF_RANGE - Size is larger than the maximum size for the * + * local segment. * + * * + *********************************************************************************/ +#define SCIRegisterSegmentMemory _SISCI_EXPANDE_FUNCTION_NAME(SCIRegisterSegmentMemory) +DLL void SCIRegisterSegmentMemory(void *address, + unsigned int size, + sci_local_segment_t segment, + unsigned int flags, + sci_error_t *error); + + + + + +/********************************************************************************* + * * + * S C I C O N N E C T S C I S P A C E * + * * + * SISCI Priveleged function * + * * + * * + * Flags * + * None. * + * * + * * + * Specific error codes for this function: * + * * + * SCI_ERR_SIZE_ALIGNMENT - Size is not correctly aligned as required * + * by the implementation. * + * SCI_ERR_CONNECTION_REFUSED - Connection attempt refused by remote node. * + * * + *********************************************************************************/ +#define SCIConnectSCISpace _SISCI_EXPANDE_FUNCTION_NAME(SCIConnectSCISpace) +DLL void SCIConnectSCISpace(sci_desc_t sd, + unsigned int localAdapterNo, + sci_remote_segment_t *segment, + sci_address_t address, + unsigned int size, + unsigned int flags, + sci_error_t *error); + + + +/* + * ===================================================================================== + * + * S C I A T T A C H L O C A L S E G M E N T + * Description: + * + * SCIAttachLocalSegment() permits an application to "attach" to an already existing + * local segment, implying that two or more application want + * share the same local segment. The prerequest, is that the + * application which originally created the segment ("owner") has + * preformed a SCIShareSegment() in order to mark the segment + * "shareable". + * + * + * Flags: + * + * SCI_FLAG_USE_CALLBACK - The callback function will be invoked for events + * on this segment. + * + * + * Specific error codes for this function: + * + * SCI_ERR_ACCESS - No such shared segment + * SCI_ERR_NO_SUCH_SEGMENT - No such segment + * Note: Current implenentation will return SCI_ERR_ACCESS for both cases. This will + * change from next release. Application should handle both cases. + * + * ===================================================================================== + */ +#define SCIAttachLocalSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIAttachLocalSegment) + +DLL void +SCIAttachLocalSegment(sci_desc_t sd, + sci_local_segment_t *segment, + unsigned int segmentId, + unsigned int *size, + sci_cb_local_segment_t callback, + void *callbackArg, + unsigned int flags, + sci_error_t *error); +/* + * ===================================================================================== + * + * S C I S H A R E S E G M E N T + * + * Description: + * + * SCIShareSegment() permits other application to "attach" to an already existing + * local segment, implying that two or more application want + * share the same local segment. The prerequest, is that the + * application which originally created the segment ("owner") has + * preformed a SCIShareSegment() in order to mark the segment + * "shareable". + * + * + * Flags: + * none + * + * Specific error codes for this function: + * + * + * + * ===================================================================================== + */ +#define SCIShareSegment _SISCI_EXPANDE_FUNCTION_NAME(SCIShareSegment) + +DLL void +SCIShareSegment(sci_local_segment_t segment, + unsigned int flags, + sci_error_t *error); + + +/********************************************************************************* + * * + * S C I F L U S H * + * * + * This function will flush the CPU buffers and the PSB buffers. * + * * + * Flags * + * SCI_FLAG_FLUSH_CPU_BUFFERS_ONLY : * + * Only flush CPU buffers ( Write combining * + * etc buffers). * + * * + *********************************************************************************/ + +#define SCIFlush _SISCI_EXPANDE_FUNCTION_NAME(SCIFlush) +DLL void SCIFlush(sci_sequence_t sequence, + unsigned int flags); + +#if defined(CPLUSPLUS) || defined(__cplusplus) +} +#endif + + +#endif + + + + + + + + + + + diff --git a/ndb/src/external/WIN32.x86/sci/include/sisci_demolib.h b/ndb/src/external/WIN32.x86/sci/include/sisci_demolib.h new file mode 100644 index 00000000000..ce5bb2aec8e --- /dev/null +++ b/ndb/src/external/WIN32.x86/sci/include/sisci_demolib.h @@ -0,0 +1,226 @@ +/* $Id: sisci_demolib.h,v 1.1 2002/12/13 12:17:23 hin Exp $ */ + +/******************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + +#ifndef _SISCI_DEMOLIB_H +#define _SISCI_DEMOLIB_H + + +#if defined(_REENTRANT) + +#define _SISCI_DEMOLIB_EXPAND_NAME(name) _SISCI_DEMOLIB_MT_ ## name + +#else + +#define _SISCI_DEMOLIB_EXPAND_NAME(name) _SISCI_DEMOLIB_ST_ ## name + +#endif + +/*********************************************************************************/ +/* Q U E R Y A D A P T E R */ +/* */ +/*********************************************************************************/ + +#define QueryAdapter _SISCI_DEMOLIB_EXPAND_NAME(QueryAdapter) + +sci_error_t QueryAdapter( + unsigned int subcommand, + unsigned int localAdapterNo, + unsigned int portNo, + unsigned int *data); + + +/*********************************************************************************/ +/* Q U E R Y S Y S T E M */ +/* */ +/*********************************************************************************/ + +#define QuerySystem _SISCI_DEMOLIB_EXPAND_NAME(QuerySystem) + +sci_error_t QuerySystem( + unsigned int subcommand, + unsigned int *data); + + +/*********************************************************************************/ +/* D E T E C T F I R S T A D A P T E R C A R D */ +/* */ +/*********************************************************************************/ + +#define DetectFirstAdapterCard _SISCI_DEMOLIB_EXPAND_NAME(DetectFirstAdapterCard) + +sci_error_t DetectFirstAdapterCard( + unsigned int *localAdapterNo, + unsigned int *localNodeId); + + +/*********************************************************************************/ +/* G E T A D A P T E R T Y P E */ +/* */ +/*********************************************************************************/ + +#define GetAdapterType _SISCI_DEMOLIB_EXPAND_NAME(GetAdapterType) + +sci_error_t GetAdapterType(unsigned int localAdapterNo, + unsigned int *adapterType); + + +/*********************************************************************************/ +/* G E T L O C A L N O D E I D */ +/* */ +/*********************************************************************************/ + +#define GetLocalNodeId _SISCI_DEMOLIB_EXPAND_NAME(GetLocalNodeId) + +sci_error_t GetLocalNodeId( + unsigned int localAdapterNo, + unsigned int *localNodeId); + + +/*********************************************************************************/ +/* G E T A D A P T E R S E R I A L N U M B E R */ +/* */ +/*********************************************************************************/ + +#define GetAdapterSerialNumber _SISCI_DEMOLIB_EXPAND_NAME(GetAdapterSerialNumber) + +sci_error_t GetAdapterSerialNumber( + unsigned int localAdapterNo, + unsigned int *serialNo); + + + +/*********************************************************************************/ +/* G E T H O S T B R I D G E T Y P E */ +/* */ +/*********************************************************************************/ + +#define GetHostbridgeType _SISCI_DEMOLIB_EXPAND_NAME(GetHostbridgeType) + +sci_error_t GetHostbridgeType(unsigned int *hostbridgeType); + + + +/*********************************************************************************/ +/* P R I N T H O S T B R I D G E T Y P E */ +/* */ +/*********************************************************************************/ + +#define PrintHostbridgeType _SISCI_DEMOLIB_EXPAND_NAME(PrintHostbridgeType) + +void PrintHostbridgeType(unsigned int hostbridge); + + + +/*********************************************************************************/ +/* G E T A P I V E R S I O N S T R I N G */ +/* */ +/*********************************************************************************/ + +#define GetAPIVersionString _SISCI_DEMOLIB_EXPAND_NAME(GetAPIVersionString) + +sci_error_t GetAPIVersionString(char str[], unsigned int strLength); + + + +/*********************************************************************************/ +/* G E T A D A P T E R I O B U S F R E Q U E N C Y */ +/* */ +/*********************************************************************************/ + +sci_error_t GetAdapterIoBusFrequency(unsigned int localAdapterNo, + unsigned int *ioBusFrequency); + + + +/*********************************************************************************/ +/* G E T A D A P T E R S C I L I N K F R E Q U E N C Y */ +/* */ +/*********************************************************************************/ + +sci_error_t GetAdapterSciLinkFrequency(unsigned int localAdapterNo, + unsigned int *sciLinkFrequency); + + + +/*********************************************************************************/ +/* G E T A D A P T E R B L I N K F R E Q U E N C Y */ +/* */ +/*********************************************************************************/ + +sci_error_t GetAdapterBlinkFrequency(unsigned int localAdapterNo, + unsigned int *bLinkFrequency); + + +/*********************************************************************************/ +/* S E N D I N T E R R U P T */ +/* */ +/*********************************************************************************/ + +#define SendInterrupt _SISCI_DEMOLIB_EXPAND_NAME(SendInterrupt) + +sci_error_t SendInterrupt( + sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int localNodeId, + unsigned int remoteNodeId, + unsigned int interruptNo); + + +/*********************************************************************************/ +/* R E C E I V E I N T E R R U P T */ +/* */ +/*********************************************************************************/ + +#define ReceiveInterrupt _SISCI_DEMOLIB_EXPAND_NAME(ReceiveInterrupt) + +sci_error_t ReceiveInterrupt( + sci_desc_t sd, + unsigned int localAdapterNo, + unsigned int localNodeId, + unsigned int interruptNo); + + +/*********************************************************************************/ +/* E N D I A N S W A P */ +/* */ +/*********************************************************************************/ + +#define EndianSwap _SISCI_DEMOLIB_EXPAND_NAME(EndianSwap) + +unsigned int EndianSwap (unsigned int value); + + +/*********************************************************************************/ +/* S L E E P M I L L I S E C O N D S */ +/* */ +/*********************************************************************************/ + +#define SleepMilliseconds _SISCI_DEMOLIB_EXPAND_NAME(SleepMilliseconds) + +void SleepMilliseconds(int milliseconds); + + + + +#endif diff --git a/ndb/src/external/WIN32.x86/sci/include/sisci_error.h b/ndb/src/external/WIN32.x86/sci/include/sisci_error.h new file mode 100644 index 00000000000..56fa0d18b3a --- /dev/null +++ b/ndb/src/external/WIN32.x86/sci/include/sisci_error.h @@ -0,0 +1,94 @@ +/* $Id: sisci_error.h,v 1.1 2002/12/13 12:17:23 hin Exp $ */ + +/******************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + + + + +#ifndef _SISCI_ERROR_H_ +#define _SISCI_ERROR_H_ + + +/* SCI Error return values always have 30 bit set */ +#define SCI_ERR_MASK 0x40000000 +#define SCI_ERR_REMOTE_MASK 0x01 /* Remote errors should have bit 0 set */ + +#define SCI_ERR(u) ((unsigned32)(u)&0x7FFFFFFF ) + +/* Error codes */ +typedef enum { + SCI_ERR_OK = 0x000, + + + SCI_ERR_BUSY = (0x900 | SCI_ERR_MASK), + SCI_ERR_FLAG_NOT_IMPLEMENTED = (0x901 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_FLAG = (0x902 | SCI_ERR_MASK), + SCI_ERR_NOSPC = (0x904 | SCI_ERR_MASK), + SCI_ERR_API_NOSPC = (0x905 | SCI_ERR_MASK), + SCI_ERR_HW_NOSPC = (0x906 | SCI_ERR_MASK), + SCI_ERR_NOT_IMPLEMENTED = (0x907 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_ADAPTERNO = (0x908 | SCI_ERR_MASK), + SCI_ERR_NO_SUCH_ADAPTERNO = (0x909 | SCI_ERR_MASK), + SCI_ERR_TIMEOUT = (0x90A | SCI_ERR_MASK), + SCI_ERR_OUT_OF_RANGE = (0x90B | SCI_ERR_MASK), + SCI_ERR_NO_SUCH_SEGMENT = (0x90C | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_NODEID = (0x90D | SCI_ERR_MASK), + SCI_ERR_CONNECTION_REFUSED = (0x90E | SCI_ERR_MASK), + SCI_ERR_SEGMENT_NOT_CONNECTED = (0x90F | SCI_ERR_MASK), + SCI_ERR_SIZE_ALIGNMENT = (0x910 | SCI_ERR_MASK), + SCI_ERR_OFFSET_ALIGNMENT = (0x911 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_PARAMETER = (0x912 | SCI_ERR_MASK), + SCI_ERR_MAX_ENTRIES = (0x913 | SCI_ERR_MASK), + SCI_ERR_SEGMENT_NOT_PREPARED = (0x914 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_ADDRESS = (0x915 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_OPERATION = (0x916 | SCI_ERR_MASK), + SCI_ERR_ILLEGAL_QUERY = (0x917 | SCI_ERR_MASK), + SCI_ERR_SEGMENTID_USED = (0x918 | SCI_ERR_MASK), + SCI_ERR_SYSTEM = (0x919 | SCI_ERR_MASK), + SCI_ERR_CANCELLED = (0x91A | SCI_ERR_MASK), + SCI_ERR_NOT_CONNECTED = (0x91B | SCI_ERR_MASK), + SCI_ERR_NOT_AVAILABLE = (0x91C | SCI_ERR_MASK), + SCI_ERR_INCONSISTENT_VERSIONS = (0x91D | SCI_ERR_MASK), + SCI_ERR_COND_INT_RACE_PROBLEM = (0x91E | SCI_ERR_MASK), + SCI_ERR_OVERFLOW = (0x91F | SCI_ERR_MASK), + SCI_ERR_NOT_INITIALIZED = (0x920 | SCI_ERR_MASK), + + SCI_ERR_ACCESS = (0x921 | SCI_ERR_MASK), + + SCI_ERR_NO_SUCH_NODEID = (0xA00 | SCI_ERR_MASK), + SCI_ERR_NODE_NOT_RESPONDING = (0xA02 | SCI_ERR_MASK), + SCI_ERR_NO_REMOTE_LINK_ACCESS = (0xA04 | SCI_ERR_MASK), + SCI_ERR_NO_LINK_ACCESS = (0xA05 | SCI_ERR_MASK), + SCI_ERR_TRANSFER_FAILED = (0xA06 | SCI_ERR_MASK), + + SCI_ERR_EWOULD_BLOCK = ( 0xB00 | SCI_ERR_MASK), + SCI_ERR_SEMAPHORE_COUNT_EXCEEDED = ( 0xB01 | SCI_ERR_MASK), + SCI_ERR_IRQL_ILLEGAL = ( 0xB02 | SCI_ERR_MASK) + +} sci_error_t; + + +#endif /* _SCI_ERROR_H_ */ + + + diff --git a/ndb/src/external/WIN32.x86/sci/include/sisci_types.h b/ndb/src/external/WIN32.x86/sci/include/sisci_types.h new file mode 100644 index 00000000000..03e7957c3f2 --- /dev/null +++ b/ndb/src/external/WIN32.x86/sci/include/sisci_types.h @@ -0,0 +1,133 @@ +/* $Id: sisci_types.h,v 1.1 2002/12/13 12:17:23 hin Exp $ */ + +/******************************************************************************* + * * + * Copyright (C) 1993 - 2000 * + * Dolphin Interconnect Solutions AS * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, * + * or (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + * * + *******************************************************************************/ + + +#ifndef _SISCI_TYPES_H +#define _SISCI_TYPES_H + +#include "sisci_error.h" + +#ifndef IN +#define IN +#endif + +#ifndef OUT +#define OUT +#endif + +#ifndef IN_OUT +#define IN_OUT +#endif + +/* Opaque data types for descriptors/handles */ +typedef struct sci_desc *sci_desc_t; +typedef struct sci_local_segment *sci_local_segment_t; +typedef struct sci_remote_segment *sci_remote_segment_t; + +typedef struct sci_map *sci_map_t; +typedef struct sci_sequence *sci_sequence_t; +#ifndef KERNEL +typedef struct sci_dma_queue *sci_dma_queue_t; +#endif +typedef struct sci_remote_interrupt *sci_remote_interrupt_t; +typedef struct sci_local_interrupt *sci_local_interrupt_t; +typedef struct sci_block_transfer *sci_block_transfer_t; + +/* + * Constants defining reasons for segment callbacks: + */ + +typedef enum { + SCI_CB_CONNECT = 1, + SCI_CB_DISCONNECT, + SCI_CB_NOT_OPERATIONAL, + SCI_CB_OPERATIONAL, + SCI_CB_LOST +} sci_segment_cb_reason_t; + +#define MAX_CB_REASON SCI_CB_LOST + +/* dma_queue_states is identical to the dma_queue_state_t in genif.h, they must be consistent.*/ +typedef enum { + SCI_DMAQUEUE_IDLE, + SCI_DMAQUEUE_GATHER, + SCI_DMAQUEUE_POSTED, + SCI_DMAQUEUE_DONE, + SCI_DMAQUEUE_ABORTED, + SCI_DMAQUEUE_ERROR +} sci_dma_queue_state_t; + + +typedef enum { + SCI_SEQ_OK, + SCI_SEQ_RETRIABLE, + SCI_SEQ_NOT_RETRIABLE, + SCI_SEQ_PENDING +} sci_sequence_status_t; + + +typedef struct { + unsigned short nodeId; /* SCI Address bit 63 - 48 */ + unsigned short offsHi; /* SCI Address bit 47 - 32 */ + unsigned int offsLo; /* SCI Address bit 31 - 0 */ +} sci_address_t; + + +typedef unsigned int sci_ioaddr_t; + +typedef enum { + SCI_CALLBACK_CANCEL = 1, + SCI_CALLBACK_CONTINUE +} sci_callback_action_t; + +#ifndef KERNEL +typedef sci_callback_action_t (*sci_cb_local_segment_t)(void *arg, + sci_local_segment_t segment, + sci_segment_cb_reason_t reason, + unsigned int nodeId, + unsigned int localAdapterNo, + sci_error_t error); + +typedef sci_callback_action_t (*sci_cb_remote_segment_t)(void *arg, + sci_remote_segment_t segment, + sci_segment_cb_reason_t reason, + sci_error_t status); + + +typedef sci_callback_action_t (*sci_cb_dma_t)(void IN *arg, + sci_dma_queue_t queue, + sci_error_t status); + + +typedef int (*sci_cb_block_transfer_t)(void *arg, + sci_block_transfer_t block, + sci_error_t status); + + +typedef sci_callback_action_t (*sci_cb_interrupt_t)(void *arg, + sci_local_interrupt_t interrupt, + sci_error_t status); + +#endif /* KERNEL */ +#endif diff --git a/ndb/src/external/WIN32.x86/sci/lib/SISCI_LIBRARY_WIN32.TXT b/ndb/src/external/WIN32.x86/sci/lib/SISCI_LIBRARY_WIN32.TXT new file mode 100644 index 00000000000..97fe959bb2c --- /dev/null +++ b/ndb/src/external/WIN32.x86/sci/lib/SISCI_LIBRARY_WIN32.TXT @@ -0,0 +1,77 @@ +SISCI_API LIBRARIES AND LINKING +=============================== + + +/MD, /ML, /MT (Use Run-Time Library) + + + +sisci_api.lib - Single threaded + +sisci_api_md.lib - Multithreaded DLL + +sisci_api_mt.lib - Multithreaded + + + + +With these libraries, you can select either single-threaded or multithreaded run-time routines, +indicate that a multithreaded module is a dynamic-link library (DLL), and select the retail +or debug version of the library. + +Note Having more than one copy of the run-time libraries in a process can cause problems, +because static data in one copy is not shared with the other copy. To ensure that your process +contains only one copy, avoid mixing static and dynamic versions of the run-time libraries. +The linker will prevent you from linking with both static and dynamic versions within one .EXE file, +but you can still end up with two (or more) copies of the run-time libraries. +For example, a dynamic-link library linked with the static (non-DLL) versions of the run-time +libraries can cause problems when used with an .EXE file that was linked with the dynamic (DLL) +version of the run-time libraries. (You should also avoid mixing the debug and non-debug versions +of the libraries in one process.) + + +MD Multithreaded +---------------- + +/MD Multithreaded DLL Defines _MT and _DLL so that both multithread- and DLL-specific versions +of the run-time routines are selected from the standard .H files. This option also causes the +compiler to place the library name MSVCRT.LIB into the .OBJ file. +Applications compiled with this option are statically linked to MSVCRT.LIB. This library provides +a layer of code that allows the linker to resolve external references. The actual working code is +contained in MSVCRT.DLL, which must be available at run time to applications linked with MSVCRT.LIB. + + +/MDd Debug Multithreaded DLL Defines _DEBUG, _MT, and _DLL so that debug multithread- and DLL-specific +versions of the run-time routines are selected from the standard .H files. It also causes the compiler +to place the library name MSVCRTD.LIB into the .OBJ file. + + +ML Single-Threaded +------------------ + + +/ML Single-Threaded Causes the compiler to place the library name LIBC.LIB into the .OBJ file so +that the linker will use LIBC.LIB to resolve external symbols. This is the compiler’s default action. +LIBC.LIB does not provide multithread support. + + +/MLd Debug Single-Threaded Defines _DEBUG and causes the compiler to place the library name LIBCD.LIB +into the .OBJ file so that the linker will use LIBCD.LIB to resolve external symbols. LIBCD.LIB does +not provide multithread support. + + +MT Multithreaded +---------------- + + +/MT Multithreaded Defines _MT so that multithread-specific versions of the run-time routines are +selected from the standard header (.H) files. This option also causes the compiler to place the library +name LIBCMT.LIB into the .OBJ file so that the linker will use LIBCMT.LIB to resolve external symbols. + +Either /MT or /MD (or their debug equivalents /MTd or /MDd) is required to create multithreaded programs. +/MTd Debug Multithreaded Defines _DEBUG and _MT. Defining _MT causes multithread-specific versions of +the run-time routines to be selected from the standard .H files. This option also causes the compiler +to place the library name LIBCMTD.LIB into the .OBJ file so that the linker will use LIBCMTD.LIB to +resolve external symbols. Either /MTd or /MDd (or their non-debug equivalents /MT or MD) is required to +create multithreaded programs. + diff --git a/ndb/src/external/WIN32.x86/sci/lib/scilib.lib b/ndb/src/external/WIN32.x86/sci/lib/scilib.lib new file mode 100644 index 00000000000..572169a2016 Binary files /dev/null and b/ndb/src/external/WIN32.x86/sci/lib/scilib.lib differ diff --git a/ndb/src/external/WIN32.x86/sci/lib/scilib_md.lib b/ndb/src/external/WIN32.x86/sci/lib/scilib_md.lib new file mode 100644 index 00000000000..f18cba61336 Binary files /dev/null and b/ndb/src/external/WIN32.x86/sci/lib/scilib_md.lib differ diff --git a/ndb/src/external/WIN32.x86/sci/lib/scilib_mt.lib b/ndb/src/external/WIN32.x86/sci/lib/scilib_mt.lib new file mode 100644 index 00000000000..3e9982468ea Binary files /dev/null and b/ndb/src/external/WIN32.x86/sci/lib/scilib_mt.lib differ diff --git a/ndb/src/external/WIN32.x86/sci/lib/sisci_api.lib b/ndb/src/external/WIN32.x86/sci/lib/sisci_api.lib new file mode 100644 index 00000000000..3fbff6ec809 Binary files /dev/null and b/ndb/src/external/WIN32.x86/sci/lib/sisci_api.lib differ diff --git a/ndb/src/external/WIN32.x86/sci/lib/sisci_api_md.lib b/ndb/src/external/WIN32.x86/sci/lib/sisci_api_md.lib new file mode 100644 index 00000000000..1d8d42d1d35 Binary files /dev/null and b/ndb/src/external/WIN32.x86/sci/lib/sisci_api_md.lib differ diff --git a/ndb/src/external/WIN32.x86/sci/lib/sisci_api_mt.lib b/ndb/src/external/WIN32.x86/sci/lib/sisci_api_mt.lib new file mode 100644 index 00000000000..017fad7ba31 Binary files /dev/null and b/ndb/src/external/WIN32.x86/sci/lib/sisci_api_mt.lib differ diff --git a/ndb/src/kernel/Makefile b/ndb/src/kernel/Makefile new file mode 100644 index 00000000000..11261c047a6 --- /dev/null +++ b/ndb/src/kernel/Makefile @@ -0,0 +1,5 @@ +include .defs.mk + +DIRS := error blocks vm ndb-main + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/kernel/blocks/ERROR_codes.txt b/ndb/src/kernel/blocks/ERROR_codes.txt new file mode 100644 index 00000000000..595afe9650e --- /dev/null +++ b/ndb/src/kernel/blocks/ERROR_codes.txt @@ -0,0 +1,425 @@ +Next QMGR 1 +Next NDBCNTR 1000 +Next NDBFS 2000 +Next DBACC 3001 +Next DBTUP 4007 +Next DBLQH 5031 +Next DBDICT 6003 +Next DBDIH 7173 +Next DBTC 8035 +Next CMVMI 9000 +Next BACKUP 10022 +Next DBUTIL 11002 +Next DBTUX 12001 +Next SUMA 13001 +Next DBDICT 14003 + +TESTING NODE FAILURE, ARBITRATION +--------------------------------- + +911 - 919: +Crash president when he starts to run in ArbitState 1-9. + +910: Crash new president after node crash + +ERROR CODES FOR TESTING NODE FAILURE, GLOBAL CHECKPOINT HANDLING: +----------------------------------------------------------------- + +7000: +Insert system error in master when global checkpoint is idle. + +7001: +Insert system error in master after receiving GCP_PREPARE from +all nodes in the cluster. + +7002: +Insert system error in master after receiving GCP_NODEFINISH from +all nodes in the cluster. + +7003: +Insert system error in master after receiving GCP_SAVECONF from +all nodes in the cluster. + +7004: +Insert system error in master after completing global checkpoint with +all nodes in the cluster. + +7005: +Insert system error in GCP participant when receiving GCP_PREPARE. + +7006: +Insert system error in GCP participant when receiving GCP_COMMIT. + +7007: +Insert system error in GCP participant when receiving GCP_TCFINISHED. + +7008: +Insert system error in GCP participant when receiving COPY_GCICONF. + +5000: +Insert system error in GCP participant when receiving GCP_SAVEREQ. + +5007: +Delay GCP_SAVEREQ by 10 secs + +ERROR CODES FOR TESTING NODE FAILURE, LOCAL CHECKPOINT HANDLING: +----------------------------------------------------------------- + +7009: +Insert system error in master when local checkpoint is idle. + +7010: +Insert system error in master when local checkpoint is in the +state clcpStatus = CALCULATE_KEEP_GCI. + +7011: +Stop local checkpoint in the state CALCULATE_KEEP_GCI. + +7012: +Restart local checkpoint after stopping in CALCULATE_KEEP_GCI. + +Method: +1) Error 7011 in master, wait until report of stopped. +2) Error xxxx in participant to crash it. +3) Error 7012 in master to start again. + +7013: +Insert system error in master when local checkpoint is in the +state clcpStatus = COPY_GCI before sending COPY_GCIREQ. + +7014: +Insert system error in master when local checkpoint is in the +state clcpStatus = TC_CLOPSIZE before sending TC_CLOPSIZEREQ. + +7015: +Insert system error in master when local checkpoint is in the +state clcpStatus = START_LCP_ROUND before sending START_LCP_ROUND. + +7016: +Insert system error in master when local checkpoint is in the +state clcpStatus = START_LCP_ROUND after receiving LCP_REPORT. + +7017: +Insert system error in master when local checkpoint is in the +state clcpStatus = TAB_COMPLETED. + +7018: +Insert system error in master when local checkpoint is in the +state clcpStatus = TAB_SAVED before sending DIH_LCPCOMPLETE. + +7019: +Insert system error in master when local checkpoint is in the +state clcpStatus = IDLE before sending CONTINUEB(ZCHECK_TC_COUNTER). + +7020: +Insert system error in local checkpoint participant at reception of +COPY_GCIREQ. + +7075: Master +Don't send any LCP_FRAG_ORD(last=true) +And crash when all have "not" been sent + +8000: Crash particpant when receiving TCGETOPSIZEREQ +8001: Crash particpant when receiving TC_CLOPSIZEREQ +5010: Crash any when receiving LCP_FRAGORD + +7021: Crash in master when receiving START_LCP_REQ +7022: Crash in !master when receiving START_LCP_REQ + +7023: Crash in master when sending START_LCP_CONF +7024: Crash in !master when sending START_LCP_CONF + +7025: Crash in master when receiving LCP_FRAG_REP +7016: Crash in !master when receiving LCP_FRAG_REP + +7026: Crash in master when changing state to LCP_TAB_COMPLETED +7017: Crash in !master when changing state to LCP_TAB_COMPLETED + +7027: Crash in master when changing state to LCP_TAB_SAVED +7018: Crash in master when changing state to LCP_TAB_SAVED + +ERROR CODES FOR TESTING NODE FAILURE, FAILURE IN COPY FRAGMENT PROCESS: +----------------------------------------------------------------------- + +5002: +Insert node failure in starting node when receiving a tuple copied from the copy node +as part of copy fragment process. +5003: +Insert node failure when receiving ABORT signal. + +5004: +Insert node failure handling when receiving COMMITREQ. + +5005: +Insert node failure handling when receiving COMPLETEREQ. + +5006: +Insert node failure handling when receiving ABORTREQ. + +These error code can be combined with error codes for testing time-out +handling in DBTC to ensure that node failures are also well handled in +time-out handling. They can also be used to test multiple node failure +handling. + +ERROR CODES FOR TESTING TIME-OUT HANDLING IN DBLQH +------------------------------------------------- +5011: +Delay execution of COMMIT signal 2 seconds to generate time-out. + +5012 (use 5017): +First delay execution of COMMIT signal 2 seconds to generate COMMITREQ. +Delay execution of COMMITREQ signal 2 seconds to generate time-out. + +5013: +Delay execution of COMPLETE signal 2 seconds to generate time-out. + +5014 (use 5018): +First delay execution of COMPLETE signal 2 seconds to generate COMPLETEREQ. +Delay execution of COMPLETEREQ signal 2 seconds to generate time-out. + +5015: +Delay execution of ABORT signal 2 seconds to generate time-out. + +5016: (ABORTREQ only as part of take-over) +Delay execution of ABORTREQ signal 2 seconds to generate time-out. + +5031: lqhKeyRef, ZNO_TC_CONNECT_ERROR +5032: lqhKeyRef, ZTEMPORARY_REDO_LOG_FAILURE +5033: lqhKeyRef, ZTAIL_PROBLEM_IN_LOG_ERROR + +ERROR CODES FOR TESTING TIME-OUT HANDLING IN DBTC +------------------------------------------------- +8040: +Delay execution of ABORTED signal 2 seconds to generate time-out. + +8041: +Delay execution of COMMITTED signal 2 seconds to generate time-out. +8042 (use 8046): +Delay execution of COMMITTED signal 2 seconds to generate COMMITCONF. +Delay execution of COMMITCONF signal 2 seconds to generate time-out. + +8043: +Delay execution of COMPLETED signal 2 seconds to generate time-out. + +8044 (use 8047): +Delay execution of COMPLETED signal 2 seconds to generate COMPLETECONF. +Delay execution of COMPLETECONF signal 2 seconds to generate time-out. + +8045: (ABORTCONF only as part of take-over) +Delay execution of ABORTCONF signal 2 seconds to generate time-out. + +ERROR CODES FOR TESTING TIME-OUT HANDLING IN DBTC +------------------------------------------------- + +8003: Throw away a LQHKEYCONF in state STARTED +8004: Throw away a LQHKEYCONF in state RECEIVING +8005: Throw away a LQHKEYCONF in state REC_COMMITTING +8006: Throw away a LQHKEYCONF in state START_COMMITTING + +8007: Ignore send of LQHKEYREQ in state STARTED +8008: Ignore send of LQHKEYREQ in state START_COMMITTING + +8009: Ignore send of LQHKEYREQ+ATTRINFO in state STARTED +8010: Ignore send of LQHKEYREQ+ATTRINFO in state START_COMMITTING + +8011: Abort at send of CONTINUEB(ZSEND_ATTRINFO) in state STARTED +8012: Abort at send of CONTINUEB(ZSEND_ATTRINFO) in state START_COMMITTING + +8013: Ignore send of CONTINUEB(ZSEND_COMPLETE_LOOP) (should crash eventually) +8014: Ignore send of CONTINUEB(ZSEND_COMMIT_LOOP) (should crash eventually) + +8015: Ignore ATTRINFO signal in DBTC in state REC_COMMITTING +8016: Ignore ATTRINFO signal in DBTC in state RECEIVING + +8017: Return immediately from DIVERIFYCONF (should crash eventually) +8018: Throw away a COMMITTED signal +8019: Throw away a COMPLETED signal + +TESTING TAKE-OVER FUNCTIONALITY IN DBTC +--------------------------------------- + +8002: Crash when sending LQHKEYREQ +8029: Crash when receiving LQHKEYCONF +8030: Crash when receiving COMMITTED +8031: Crash when receiving COMPLETED +8020: Crash when all COMMITTED has arrived +8021: Crash when all COMPLETED has arrived +8022: Crash when all LQHKEYCONF has arrived + +COMBINATION OF TIME-OUT + CRASH +------------------------------- + +8023 (use 8024): Ignore LQHKEYCONF and crash when ABORTED signal arrives by setting 8024 +8025 (use 8026): Ignore COMMITTED and crash when COMMITCONF signal arrives by setting 8026 +8027 (use 8028): Ignore COMPLETED and crash when COMPLETECONF signal arrives by setting 8028 + +ABORT OF TCKEYREQ +----------------- + +8032: No free TC records any more + + +CMVMI +----- +9000 Set RestartOnErrorInsert to restart -n +9999 Crash system immediatly + +Test Crashes in handling node restarts +-------------------------------------- + +7121: Crash after receiving permission to start (START_PERMCONF) in starting + node. +7122: Crash master when receiving request for permission to start (START_PERMREQ). +7123: Crash any non-starting node when receiving information about a starting node + (START_INFOREQ) +7124: Respond negatively on an info request (START_INFOREQ) +7125: Stop an invalidate Node LCP process in the middle to test if START_INFOREQ + stopped by long-running processes are handled in a correct manner. +7126: Allow node restarts for all nodes (used in conjunction with 7025) +7127: Crash when receiving a INCL_NODEREQ message. +7128: Crash master after receiving all INCL_NODECONF from all nodes +7129: Crash master after receiving all INCL_NODECONF from all nodes and releasing + the lock on the dictionary +7130: Crash starting node after receiving START_MECONF +7131: Crash when receiving START_COPYREQ in master node +7132: Crash when receiving START_COPYCONF in starting node + +DICT: +6000 Crash during NR when receiving DICTSTARTREQ +6001 Crash during NR when receiving SCHEMA_INFO +6002 Crash during NR soon after sending GET_TABINFO_REQ + +LQH: +5026 Crash when receiving COPY_ACTIVEREQ +5027 Crash when receiving STAT_RECREQ + +Test Crashes in handling take over +---------------------------------- + +7133: Crash when receiving START_TOREQ +7134: Crash master after receiving all START_TOCONF +7135: Crash master after copying table 0 to starting node +7136: Crash master after completing copy of tables +7137: Crash master after adding a fragment before copying it +7138: Crash when receiving CREATE_FRAGREQ in prepare phase +7139: Crash when receiving CREATE_FRAGREQ in commit phase +7140: Crash master when receiving all CREATE_FRAGCONF in prepare phase +7141: Crash master when receiving all CREATE_FRAGCONF in commit phase +7142: Crash master when receiving COPY_FRAGCONF +7143: Crash master when receiving COPY_ACTIVECONF +7144: Crash when receiving END_TOREQ +7145: Crash master after receiving first END_TOCONF +7146: Crash master after receiving all END_TOCONF +7147: Crash master after receiving first START_TOCONF +7148: Crash master after receiving first CREATE_FRAGCONF +7152: Crash master after receiving first UPDATE_TOCONF +7153: Crash master after receiving all UPDATE_TOCONF +7154: Crash when receiving UPDATE_TOREQ +7155: Crash master when completing writing start take over info +7156: Crash master when completing writing end take over info + +Test failures in various states in take over functionality +---------------------------------------------------------- +7157: Block take over at start take over +7158: Block take over at sending of START_TOREQ +7159: Block take over at selecting next fragment +7160: Block take over at creating new fragment +7161: Block take over at sending of CREATE_FRAGREQ in prepare phase +7162: Block take over at sending of CREATE_FRAGREQ in commit phase +7163: Block take over at sending of UPDATE_TOREQ at end of copy frag +7164: Block take over at sending of END_TOREQ +7169: Block take over at sending of UPDATE_TOREQ at end of copy + +5008: Crash at reception of EMPTY_LCPREQ (at master take over after NF) +5009: Crash at sending of EMPTY_LCPCONF (at master take over after NF) + +Test Crashes in Handling Graceful Shutdown +------------------------------------------ +7065: Crash when receiving STOP_PERMREQ in master +7066: Crash when receiving STOP_PERMREQ in slave +7067: Crash when receiving DIH_SWITCH_REPLICA_REQ +7068: Crash when receiving DIH_SWITCH_REPLICA_CONF + + +Backup Stuff: +------------------------------------------ +10001: Crash on NODE_FAILREP in Backup coordinator +10002: Crash on NODE_FAILREP when coordinatorTakeOver +10003: Crash on PREP_CREATE_TRIG_{CONF/REF} (only coordinator) +10004: Crash on START_BACKUP_{CONF/REF} (only coordinator) +10005: Crash on CREATE_TRIG_{CONF/REF} (only coordinator) +10006: Crash on WAIT_GCP_REF (only coordinator) +10007: Crash on WAIT_GCP_CONF (only coordinator) +10008: Crash on WAIT_GCP_CONF during start of backup (only coordinator) +10009: Crash on WAIT_GCP_CONF during stop of backup (only coordinator) +10010: Crash on BACKUP_FRAGMENT_CONF (only coordinator) +10011: Crash on BACKUP_FRAGMENT_REF (only coordinator) +10012: Crash on DROP_TRIG_{CONF/REF} (only coordinator) +10013: Crash on STOP_BACKUP_{CONF/REF} (only coordinator) +10014: Crash on DEFINE_BACKUP_REQ (participant) +10015: Crash on START_BACKUP_REQ (participant) +10016: Crash on BACKUP_FRAGMENT_REQ (participant) +10017: Crash on SCAN_FRAGCONF (participant) +10018: Crash on FSAPPENDCONF (participant) +10019: Crash on TRIG_ATTRINFO (participant) +10020: Crash on STOP_BACKUP_REQ (participant) +10021: Crash on NODE_FAILREP in participant not becoming coordinator + +10022: Fake no backup records at DEFINE_BACKUP_REQ (participant) +10023: Abort backup by error at reception of UTIL_SEQUENCE_CONF (code 300) +10024: Abort backup by error at reception of DEFINE_BACKUP_CONF (code 301) +10025: Abort backup by error at reception of CREATE_TRIG_CONF last (code 302) +10026: Abort backup by error at reception of START_BACKUP_CONF (code 303) +10027: Abort backup by error at reception of DEFINE_BACKUP_REQ at master (code 304) +10028: Abort backup by error at reception of BACKUP_FRAGMENT_CONF at master (code 305) +10029: Abort backup by error at reception of FSAPPENDCONF in slave (FileOrScanError = 5) +10030: Simulate buffer full from trigger execution => abort backup + +11001: Send UTIL_SEQUENCE_REF (in master) + +5028: Crash when receiving LQHKEYREQ (in non-master) + +Drop Table/Index: +----------------- +4001: Crash on REL_TABMEMREQ in TUP +4002: Crash on DROP_TABFILEREQ in TUP +4003: Fail next trigger create in TUP +8033: Fail next trigger create in TC +8034: Fail next index create in TC + +System Restart: +--------------- + +5020: Force system to read pages form file when executing prepare operation record +3000: Delay writing of datapages in ACC when LCP is started +4000: Delay writing of datapages in TUP when LCP is started +7070: Set TimeBetweenLcp to min value +7071: Set TimeBetweenLcp to max value +7072: Split START_FRAGREQ into several log nodes +7073: Don't include own node in START_FRAGREQ +7074: 7072 + 7073 + +Scan: +------ + +5021: Crash when receiving SCAN_NEXTREQ if sender is own node +5022: Crash when receiving SCAN_NEXTREQ if sender is NOT own node +5023: Drop SCAN_NEXTREQ if sender is own node +5024: Drop SCAN_NEXTREQ if sender is NOT own node +5025: Delay SCAN_NEXTREQ 1 second if sender is NOT own node +5030: Drop all SCAN_NEXTREQ until node is shutdown with SYSTEM_ERROR + because of scan fragment timeout + +Test routing of signals: +----------------------- +4006: Turn on routing of TRANSID_AI signals from TUP +5029: Turn on routing of KEYINFO20 signals from LQH + +Ordered index: +-------------- + +Dbdict: +------- +14000 Crash in participant @ CreateTabReq::Prepare +14001 Crash in participant @ CreateTabReq::Commit +14002 Crash in participant @ CreateTabReq::CreateDrop diff --git a/ndb/src/kernel/blocks/Makefile b/ndb/src/kernel/blocks/Makefile new file mode 100644 index 00000000000..ce554dfc3b8 --- /dev/null +++ b/ndb/src/kernel/blocks/Makefile @@ -0,0 +1,28 @@ +#-------------------------------------------------------------------------- +# +# Name Makefile +# +# +# +# List subdirectories to be travered +include .defs.mk + +DIRS := \ + cmvmi \ + dbacc \ + dbdict \ + dbdih \ + dblqh \ + dbtc \ + dbtup \ + ndbfs \ + ndbcntr \ + qmgr \ + trix \ + backup \ + dbutil \ + suma \ + grep \ + dbtux + +include ${NDB_TOP}/Epilogue.mk diff --git a/ndb/src/kernel/blocks/NodeRestart.new.txt b/ndb/src/kernel/blocks/NodeRestart.new.txt new file mode 100644 index 00000000000..00ab8f0c208 --- /dev/null +++ b/ndb/src/kernel/blocks/NodeRestart.new.txt @@ -0,0 +1,82 @@ + +Master DIH Starting DIH Starting DICT +---------------------- ---------------------- --------------------- + + Check for sysfile + DIH_RESTARTCONF -> + +****************************************************************************** +* NDB_STTOR interal startphase = 1 +****************************************************************************** + + Read schema file + +****************************************************************************** +* NDB_STTOR interal startphase = 2 +****************************************************************************** + + <- START_PERMREQ + +XXX + +START_PERMCONF -> + +****************************************************************************** +* NDB_STTOR interal startphase = 3 +****************************************************************************** + + <- START_MEREQ + +START_RECREQ -> starting LQH + <- START_RECCONF + +For each table + COPY_TABREQ -> starting DIH + +DICTSTARTREQ -> starting DICT + GET_SCHEMA_INFOREQ + (to master DICT) + + ->SCHEMA_INFO + (schema file) + + 1) For each table + If TableStatus OK + ReadTableFile + else + GET_TABINFOREQ + 2) DIADDTABREQ->DIH + + For each local frag + ADD_FRAG_REQ -> local DICT + DI_ADD_TAB_CONF + <- DICTSTARTCONF + +INCL_NODEREQ -> all DIH + +START_MECONF -> starting DIH + (including sysfile) + +****************************************************************************** +* NDB_STTOR interal startphase = 5 +****************************************************************************** + + <- START_COPYREQ + +START_TOREQ -> all DIH + +For each fragment + CREATE_FRAGREQ -> all DIH + + COPY-DATA (LQHKEYREQ++) + + UPDATE_TOREQ -> all DIH + + COPY_ACTIVEREQ -> starting LQH + + CREATE_FRAGREQ -> all DIH + +START_COPYCONF -> + +LOCAL CHECKPOINT + diff --git a/ndb/src/kernel/blocks/NodeRestart.txt b/ndb/src/kernel/blocks/NodeRestart.txt new file mode 100644 index 00000000000..e9f277bb39e --- /dev/null +++ b/ndb/src/kernel/blocks/NodeRestart.txt @@ -0,0 +1,80 @@ + +Master DIH Starting DIH Starting DICT +---------------------- ---------------------- --------------------- + + Check for sysfile + DIH_RESTARTCONF -> + +****************************************************************************** +* NDB_STTOR interal startphase = 1 +****************************************************************************** + + Read schema file + +****************************************************************************** +* NDB_STTOR interal startphase = 2 +****************************************************************************** + + <- START_PERMREQ + +XXX + +START_PERMCONF -> + +****************************************************************************** +* NDB_STTOR interal startphase = 3 +****************************************************************************** + + <- START_MEREQ + +START_RECREQ -> starting LQH + <- START_RECCONF + +DICTSTARTREQ -> starting DICT + GET_SCHEMA_INFOREQ + (to master DICT) + + ->SCHEMA_INFO + (schema file) + + 1) For each table + 1) If TableStatus match + ReadTableFile + else + GET_TABINFOREQ + + <- DICTSTARTCONF + +For each table + COPY_TABREQ -> starting DIH + +INCL_NODEREQ -> all DIH + +START_MECONF -> starting DIH + (including sysfile) + +****************************************************************************** +* NDB_STTOR interal startphase = 5 +****************************************************************************** + + <- START_COPYREQ + +START_TOREQ -> all DIH + +For each fragment + ADD_FRAG_REQ -> local DICT -> LQHFRAGREQ -> starting LQH + + CREATE_FRAGREQ -> all DIH + + COPY-DATA (LQHKEYREQ++) + + UPDATE_TOREQ -> all DIH + + COPY_ACTIVEREQ -> starting LQH + + CREATE_FRAGREQ -> all DIH + +START_COPYCONF -> + +LOCAL CHECKPOINT + diff --git a/ndb/src/kernel/blocks/Start.txt b/ndb/src/kernel/blocks/Start.txt new file mode 100644 index 00000000000..545296d44f1 --- /dev/null +++ b/ndb/src/kernel/blocks/Start.txt @@ -0,0 +1,97 @@ + +--- Start phase 1 - Qmgr ------------------------------------------- + +1) Set timer 1 - TimeToWaitAlive + +2) Send CM_REGREQ to all connected(and connecting) nodes + +3) Wait until - +a) The precident answers CM_REGCONF +b) All nodes has answered and I'm the candidate -> election won +c) 30s has passed and I'm the candidate -> election won +d) TimeToWaitAlive has passed -> Failure to start + +When receiving CM_REGCONF +4) Send CM_NODEINFOREQ to all connected(and connecting) nodes + reported in CM_REGCONF + +5) Wait until - +a) All CM_NODEINFO_CONF has arrived +b) TimeToWaitAlive has passed -> Failure to start + +6) Send CM_ACKADD to president + +7) Wait until - +a) Receive CM_ADD(CommitNew) from president -> I'm in the qmgr cluster +b) TimeToWaitAlive has passed -> Failure to start + +NOTE: +30s is hardcoded in 3c. +TimeToWaitAlive should be atleast X sec greater than 30s. i.e. 30+X sec +to support "partial starts" + +NOTE: +In 3b, a more correct number (instead of all) would be +N-NG+1 where N is #nodes and NG is #node groups = (N/R where R is # replicas) +But Qmgr has no notion about node groups or replicas + +--- Start phase X - Qmgr ------------------------------------------- + +President - When accepting a CM_REGREQ +1) Send CM_REGCONF to starting node +2) Send CM_ADD(Prepare) to all started nodes + starting node +3) Send CM_ADD(AddCommit) to all started nodes +4) Send CM_ADD(CommitNew) to starting node + +Cluster participant - +1) Wait for both CM_NODEINFOREQ from starting and CM_ADD(Prepare) from pres. +2) Send CM_ACKADD(Prepare) +3) Wait for CM_ADD(AddCommit) from president +4) Send CM_ACKADD(AddCommit) + +--- Start phase 2 - NdbCntr ---------------------------------------- + +- Use same TimeToWaitAliveTimer + +1) Check sysfile (DIH_RESTART_REQ) +2) Read nodes (from Qmgr) P = qmgr president + +3) Send CNTR_MASTER_REQ to cntr(P) + including info in DIH_RESTART_REF/CONF + +4) Wait until - +a) Receiving CNTR_MASTER_CONF -> continue +b) Receiving CNTR_MASTER_REF -> P = node specified in REF, goto 3 +c) TimeToWaitAlive has passed -> Failure to start + +4) Run ndb-startphase 1 + +-- +Initial start/System restart NdbCntr (on qmgr president node) + +1) Wait until - +a) Receiving all CNTR_MASTER_REQ (all = those in READ_NODES_CONF) +b) TimeToWaitAlive has passed -> Failure to start + +2) Wait until - +a) Enough nodes (at least 1 in each node group and 1 full node group) + has sent me CNTR_MASTER_REQ +b) TimeToWaitAlive has passed -> Failure to start + +3) Decide what kind of start to perform (initial / system restart) + Decide who should be the master (the one with greatest GCI) + Send CNTR_MASTER_CONF(initial/system restart) to all nodes included in start + +-- +Running NdbCntr + +When receiving CNTR_MASTER_REQ +1) If I'm not master send CNTR_MASTER_REF (including master node id) +2) If I'm master + Coordinate parallell node restarts + send CNTR_MASTER_CONF (node restart) + +NOTE: +2a Specified with a command line/config parameter the system could + start using only one node in each node group (if possible w.r.t LCP/GCP) + diff --git a/ndb/src/kernel/blocks/SystemRestart.new.txt b/ndb/src/kernel/blocks/SystemRestart.new.txt new file mode 100644 index 00000000000..3738de28df8 --- /dev/null +++ b/ndb/src/kernel/blocks/SystemRestart.new.txt @@ -0,0 +1,61 @@ + +DIH DICT CNTR +---------------------- ---------------------- --------------------- + <- DIHRESTARTREQ +Check for sysfile +DIH_RESTARTCONF -> + +NDB_STTORY -> DICT (sp=1) + Read schema file + +****************************************************************************** +* Elect master +****************************************************************************** + +-- Master DIH -- + +Read sysfile + +COPY_GCIREQ -> all DIHs + +DICTSTARTREQ -> local DICT (master) + + master + ====== + For each table (that should be started) + 1) ReadTableFile + 2) DI_ADD_TAB_REQ -> local DIH + +1) ReadTableFile (DIH) +2) COPY_TABREQ -> all DIH (but self) +3) For each local frag + ADD_FRAG_REQ -> local DICT +4) DI_ADD_TAB_CONF + + SCHEMA_INFO -> all DICTs + Info = schema file + + Participant + =========== + 1) For each table + 1) If TableStatus match + ReadTableFile + else + GET_TABINFOREQ + 2) WriteTableFile + 3) Parse Table Data + 4) DI_ADD_TAB_REQ -> local DIH + + <- SCHEMA_INFOCONF + + + <- DICTSTARTCONF + +For each fragment + IF Fragment is logged + START_FRAGREQ -> LQH x + + START_RECREQ -> all LQH + Note does not wait for START_FRAGCONF + +NDB_STARTCONF -> diff --git a/ndb/src/kernel/blocks/SystemRestart.txt b/ndb/src/kernel/blocks/SystemRestart.txt new file mode 100644 index 00000000000..235dfb968fa --- /dev/null +++ b/ndb/src/kernel/blocks/SystemRestart.txt @@ -0,0 +1,61 @@ + +NDBCNTR DIH DICT +---------------------- ---------------------- --------------- +DIH_RESTARTREQ -> DIH + Check for sysfile + <- DIH_RESTARTCONF + +NDB_STTORY -> DICT +sp = 1 + Read schema file + +---- Master + +NDB_STARTREQ -> DIH + Read sysfile + + COPY_GCIREQ -> all DIHs + + DICTSTARTREQ -> local DICT + local + ====== + SCHEMA_INFO -> all DICTs + Info = schema file + + Participant + =========== + 1) For each table + If TableStatus match + ReadTableFile + else + GET_TABINFOREQ + + <- SCHEMA_INFOCONF + + local + ====== + For each table + DIHSTARTTABREQ -> DIH + + <- DICTSTARTCONF + + For each table (STARTED) + Read table description + from disk + + For each fragment + IF Fragment dont have LCP + ADD_FRAGREQ -> local DICT + 1) LQHFRAGREQ -> LQH x + 2) For each attribute + LQHADDATTREQ + IF Fragment is logged + START_FRAGREQ -> LQH x + + START_RECREQ -> all LQH + Note does not wait for START_FRAGCONF + + For each table + COPY_TABREQ -> all DIH (but self) + + <- NDB_STARTCONF diff --git a/ndb/src/kernel/blocks/backup/Backup.cpp b/ndb/src/kernel/blocks/backup/Backup.cpp new file mode 100644 index 00000000000..4342a9d6d94 --- /dev/null +++ b/ndb/src/kernel/blocks/backup/Backup.cpp @@ -0,0 +1,4691 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Backup.hpp" + +#include + +#include +#include + +#include +#include + +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include + +#include + +#include + +static NDB_TICKS startTime; + +static const Uint32 BACKUP_SEQUENCE = 0x1F000000; + +#ifdef VM_TRACE +#define DEBUG_OUT(x) ndbout << x << endl +#else +#define DEBUG_OUT(x) +#endif + +//#define DEBUG_ABORT + +//--------------------------------------------------------- +// Ignore this since a completed abort could have preceded +// this message. +//--------------------------------------------------------- +#define slaveAbortCheck() \ +if ((ptr.p->backupId != backupId) || \ + (ptr.p->slaveState.getState() == ABORTING)) { \ + jam(); \ + return; \ +} + +#define masterAbortCheck() \ +if ((ptr.p->backupId != backupId) || \ + (ptr.p->masterData.state.getState() == ABORTING)) { \ + jam(); \ + return; \ +} + +#define defineSlaveAbortCheck() \ + if (ptr.p->slaveState.getState() == ABORTING) { \ + jam(); \ + closeFiles(signal, ptr); \ + return; \ + } + +static Uint32 g_TypeOfStart = NodeState::ST_ILLEGAL_TYPE; + +void +Backup::execSTTOR(Signal* signal) +{ + jamEntry(); + + const Uint32 startphase = signal->theData[1]; + const Uint32 typeOfStart = signal->theData[7]; + + if (startphase == 3) { + jam(); + g_TypeOfStart = typeOfStart; + signal->theData[0] = reference(); + sendSignal(NDBCNTR_REF, GSN_READ_NODESREQ, signal, 1, JBB); + return; + }//if + + if(startphase == 7 && g_TypeOfStart == NodeState::ST_INITIAL_START && + c_masterNodeId == getOwnNodeId()){ + jam(); + createSequence(signal); + return; + }//if + + sendSTTORRY(signal); + return; +}//Dbdict::execSTTOR() + +void +Backup::execREAD_NODESCONF(Signal* signal) +{ + jamEntry(); + ReadNodesConf * conf = (ReadNodesConf *)signal->getDataPtr(); + + c_aliveNodes.clear(); + + Uint32 count = 0; + for (Uint32 i = 0; iallNodes, i)){ + jam(); + count++; + + NodePtr node; + ndbrequire(c_nodes.seize(node)); + + node.p->nodeId = i; + if(NodeBitmask::get(conf->inactiveNodes, i)) { + jam(); + node.p->alive = 0; + } else { + jam(); + node.p->alive = 1; + c_aliveNodes.set(i); + }//if + }//if + }//for + c_masterNodeId = conf->masterNodeId; + ndbrequire(count == conf->noOfNodes); + sendSTTORRY(signal); +} + +void +Backup::sendSTTORRY(Signal* signal) +{ + signal->theData[0] = 0; + signal->theData[3] = 1; + signal->theData[4] = 3; + signal->theData[5] = 7; + signal->theData[6] = 255; // No more start phases from missra + sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 7, JBB); +} + +void +Backup::createSequence(Signal* signal) +{ + UtilSequenceReq * req = (UtilSequenceReq*)signal->getDataPtrSend(); + + req->senderData = RNIL; + req->sequenceId = BACKUP_SEQUENCE; + req->requestType = UtilSequenceReq::Create; + + sendSignal(DBUTIL_REF, GSN_UTIL_SEQUENCE_REQ, + signal, UtilSequenceReq::SignalLength, JBB); +} + +void +Backup::execCONTINUEB(Signal* signal) +{ + jamEntry(); + const Uint32 Tdata0 = signal->theData[0]; + const Uint32 Tdata1 = signal->theData[1]; + const Uint32 Tdata2 = signal->theData[2]; + + switch(Tdata0) { + case BackupContinueB::START_FILE_THREAD: + case BackupContinueB::BUFFER_UNDERFLOW: + { + jam(); + BackupFilePtr filePtr; + c_backupFilePool.getPtr(filePtr, Tdata1); + checkFile(signal, filePtr); + return; + } + break; + case BackupContinueB::BUFFER_FULL_SCAN: + { + jam(); + BackupFilePtr filePtr; + c_backupFilePool.getPtr(filePtr, Tdata1); + checkScan(signal, filePtr); + return; + } + break; + case BackupContinueB::BUFFER_FULL_FRAG_COMPLETE: + { + jam(); + BackupFilePtr filePtr; + c_backupFilePool.getPtr(filePtr, Tdata1); + fragmentCompleted(signal, filePtr); + return; + } + break; + case BackupContinueB::BUFFER_FULL_META: + { + jam(); + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, Tdata1); + + if (ptr.p->slaveState.getState() == ABORTING) { + jam(); + closeFiles(signal, ptr); + return; + }//if + BackupFilePtr filePtr; + ptr.p->files.getPtr(filePtr, ptr.p->ctlFilePtr); + FsBuffer & buf = filePtr.p->operation.dataBuffer; + + if(buf.getFreeSize() + buf.getMinRead() < buf.getUsableSize()) { + jam(); + TablePtr tabPtr; + c_tablePool.getPtr(tabPtr, Tdata2); + + DEBUG_OUT("Backup - Buffer full - " << buf.getFreeSize() + << " + " << buf.getMinRead() + << " < " << buf.getUsableSize() + << " - tableId = " << tabPtr.p->tableId); + + signal->theData[0] = BackupContinueB::BUFFER_FULL_META; + signal->theData[1] = Tdata1; + signal->theData[2] = Tdata2; + sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 100, 3); + return; + }//if + + TablePtr tabPtr; + c_tablePool.getPtr(tabPtr, Tdata2); + GetTabInfoReq * req = (GetTabInfoReq *)signal->getDataPtrSend(); + req->senderRef = reference(); + req->senderData = ptr.i; + req->requestType = GetTabInfoReq::RequestById | + GetTabInfoReq::LongSignalConf; + req->tableId = tabPtr.p->tableId; + sendSignal(DBDICT_REF, GSN_GET_TABINFOREQ, signal, + GetTabInfoReq::SignalLength, JBB); + return; + } + default: + ndbrequire(0); + }//switch +} + +void +Backup::execDUMP_STATE_ORD(Signal* signal) +{ + jamEntry(); + + if(signal->theData[0] == 20){ + if(signal->length() > 1){ + c_defaults.m_dataBufferSize = (signal->theData[1] * 1024 * 1024); + } + if(signal->length() > 2){ + c_defaults.m_logBufferSize = (signal->theData[2] * 1024 * 1024); + } + if(signal->length() > 3){ + c_defaults.m_minWriteSize = signal->theData[3] * 1024; + } + if(signal->length() > 4){ + c_defaults.m_maxWriteSize = signal->theData[4] * 1024; + } + + infoEvent("Backup: data: %d log: %d min: %d max: %d", + c_defaults.m_dataBufferSize, + c_defaults.m_logBufferSize, + c_defaults.m_minWriteSize, + c_defaults.m_maxWriteSize); + return; + } + if(signal->theData[0] == 21){ + BackupReq * req = (BackupReq*)signal->getDataPtrSend(); + req->senderData = 23; + req->backupDataLen = 0; + sendSignal(BACKUP_REF, GSN_BACKUP_REQ,signal,BackupReq::SignalLength, JBB); + startTime = NdbTick_CurrentMillisecond(); + return; + } + + if(signal->theData[0] == 22){ + const Uint32 seq = signal->theData[1]; + FsRemoveReq * req = (FsRemoveReq *)signal->getDataPtrSend(); + req->userReference = reference(); + req->userPointer = 23; + req->directory = 1; + req->ownDirectory = 1; + FsOpenReq::setVersion(req->fileNumber, 2); + FsOpenReq::setSuffix(req->fileNumber, FsOpenReq::S_CTL); + FsOpenReq::v2_setSequence(req->fileNumber, seq); + FsOpenReq::v2_setNodeId(req->fileNumber, getOwnNodeId()); + sendSignal(NDBFS_REF, GSN_FSREMOVEREQ, signal, + FsRemoveReq::SignalLength, JBA); + return; + } + + if(signal->theData[0] == 23){ + /** + * Print records + */ + BackupRecordPtr ptr; + for(c_backups.first(ptr); ptr.i != RNIL; c_backups.next(ptr)){ + infoEvent("BackupRecord %d: BackupId: %d MasterRef: %x ClientRef: %x", + ptr.i, ptr.p->backupId, ptr.p->masterRef, ptr.p->clientRef); + if(ptr.p->masterRef == reference()){ + infoEvent(" MasterState: %d State: %d", + ptr.p->masterData.state.getState(), + ptr.p->slaveState.getState()); + } else { + infoEvent(" State: %d", ptr.p->slaveState.getState()); + } + BackupFilePtr filePtr; + for(ptr.p->files.first(filePtr); filePtr.i != RNIL; + ptr.p->files.next(filePtr)){ + jam(); + infoEvent(" file %d: type: %d open: %d running: %d done: %d scan: %d", + filePtr.i, filePtr.p->fileType, filePtr.p->fileOpened, + filePtr.p->fileRunning, + filePtr.p->fileDone, filePtr.p->scanRunning); + } + } + } + if(signal->theData[0] == 24){ + /** + * Print size of records etc. + */ + infoEvent("Backup - dump pool sizes"); + infoEvent("BackupPool: %d BackupFilePool: %d TablePool: %d", + c_backupPool.getSize(), c_backupFilePool.getSize(), + c_tablePool.getSize()); + infoEvent("AttrPool: %d TriggerPool: %d FragmentPool: %d", + c_backupPool.getSize(), c_backupFilePool.getSize(), + c_tablePool.getSize()); + infoEvent("PagePool: %d", + c_pagePool.getSize()); + + } +} + +bool +Backup::findTable(const BackupRecordPtr & ptr, + TablePtr & tabPtr, Uint32 tableId) const +{ + for(ptr.p->tables.first(tabPtr); + tabPtr.i != RNIL; + ptr.p->tables.next(tabPtr)) { + jam(); + if(tabPtr.p->tableId == tableId){ + jam(); + return true; + }//if + }//for + tabPtr.i = RNIL; + tabPtr.p = 0; + return false; +} + +static Uint32 xps(Uint32 x, Uint64 ms) +{ + float fx = x; + float fs = ms; + + if(ms == 0 || x == 0) { + jam(); + return 0; + }//if + jam(); + return ((Uint32)(1000.0f * (fx + fs/2.1f))) / ((Uint32)fs); +} + +struct Number { + Number(Uint32 r) { val = r;} + Number & operator=(Uint32 r) { val = r; return * this; } + Uint32 val; +}; + +NdbOut & +operator<< (NdbOut & out, const Number & val){ + char p = 0; + Uint32 loop = 1; + while(val.val > loop){ + loop *= 1000; + p += 3; + } + if(loop != 1){ + p -= 3; + loop /= 1000; + } + + switch(p){ + case 0: + break; + case 3: + p = 'k'; + break; + case 6: + p = 'M'; + break; + case 9: + p = 'G'; + break; + default: + p = 0; + } + char str[2]; + str[0] = p; + str[1] = 0; + Uint32 tmp = (val.val + (loop >> 1)) / loop; +#if 1 + if(p > 0) + out << tmp << str; + else + out << tmp; +#else + out << val.val; +#endif + + return out; +} + +void +Backup::execBACKUP_CONF(Signal* signal) +{ + jamEntry(); + BackupConf * conf = (BackupConf*)signal->getDataPtr(); + + ndbout_c("Backup %d has started", conf->backupId); +} + +void +Backup::execBACKUP_REF(Signal* signal) +{ + jamEntry(); + BackupRef * ref = (BackupRef*)signal->getDataPtr(); + + ndbout_c("Backup (%d) has NOT started %d", ref->senderData, ref->errorCode); +} + +void +Backup::execBACKUP_COMPLETE_REP(Signal* signal) +{ + jamEntry(); + BackupCompleteRep* rep = (BackupCompleteRep*)signal->getDataPtr(); + + startTime = NdbTick_CurrentMillisecond() - startTime; + + ndbout_c("Backup %d has completed", rep->backupId); + const Uint32 bytes = rep->noOfBytes; + const Uint32 records = rep->noOfRecords; + + Number rps = xps(records, startTime); + Number bps = xps(bytes, startTime); + + ndbout << " Data [ " + << Number(records) << " rows " + << Number(bytes) << " bytes " << startTime << " ms ] " + << " => " + << rps << " row/s & " << bps << "b/s" << endl; + + bps = xps(rep->noOfLogBytes, startTime); + rps = xps(rep->noOfLogRecords, startTime); + + ndbout << " Log [ " + << Number(rep->noOfLogRecords) << " log records " + << Number(rep->noOfLogBytes) << " bytes " << startTime << " ms ] " + << " => " + << rps << " records/s & " << bps << "b/s" << endl; + +} + +void +Backup::execBACKUP_ABORT_REP(Signal* signal) +{ + jamEntry(); + BackupAbortRep* rep = (BackupAbortRep*)signal->getDataPtr(); + + ndbout_c("Backup %d has been aborted %d", rep->backupId, rep->reason); +} + +const TriggerEvent::Value triggerEventValues[] = { + TriggerEvent::TE_INSERT, + TriggerEvent::TE_UPDATE, + TriggerEvent::TE_DELETE +}; + +const char* triggerNameFormat[] = { + "NDB$BACKUP_%d_%d_INSERT", + "NDB$BACKUP_%d_%d_UPDATE", + "NDB$BACKUP_%d_%d_DELETE" +}; + +const Backup::State +Backup::validMasterTransitions[] = { + INITIAL, DEFINING, + DEFINING, DEFINED, + DEFINED, STARTED, + STARTED, SCANNING, + SCANNING, STOPPING, + STOPPING, INITIAL, + + DEFINING, ABORTING, + DEFINED, ABORTING, + STARTED, ABORTING, + SCANNING, ABORTING, + STOPPING, ABORTING, + ABORTING, ABORTING, + + DEFINING, INITIAL, + ABORTING, INITIAL, + INITIAL, INITIAL +}; + +const Backup::State +Backup::validSlaveTransitions[] = { + INITIAL, DEFINING, + DEFINING, DEFINED, + DEFINED, STARTED, + STARTED, STARTED, // Several START_BACKUP_REQ is sent + STARTED, SCANNING, + SCANNING, STARTED, + STARTED, STOPPING, + STOPPING, CLEANING, + CLEANING, INITIAL, + + INITIAL, ABORTING, // Node fail + DEFINING, ABORTING, + DEFINED, ABORTING, + STARTED, ABORTING, + SCANNING, ABORTING, + STOPPING, ABORTING, + CLEANING, ABORTING, // Node fail w/ master takeover + ABORTING, ABORTING, // Slave who initiates ABORT should have this transition + + ABORTING, INITIAL, + INITIAL, INITIAL +}; + +const Uint32 +Backup::validSlaveTransitionsCount = +sizeof(Backup::validSlaveTransitions) / sizeof(Backup::State); + +const Uint32 +Backup::validMasterTransitionsCount = +sizeof(Backup::validMasterTransitions) / sizeof(Backup::State); + +void +Backup::CompoundState::setState(State newState){ + bool found = false; + const State currState = state; + for(unsigned i = 0; i & ah, + ArrayPool & fh) + : attributes(ah), fragments(fh) +{ + triggerIds[0] = ILLEGAL_TRIGGER_ID; + triggerIds[1] = ILLEGAL_TRIGGER_ID; + triggerIds[2] = ILLEGAL_TRIGGER_ID; + triggerAllocated[0] = false; + triggerAllocated[1] = false; + triggerAllocated[2] = false; +} + +/***************************************************************************** + * + * Node state handling + * + *****************************************************************************/ +void +Backup::execNODE_FAILREP(Signal* signal) +{ + jamEntry(); + + NodeFailRep * rep = (NodeFailRep*)signal->getDataPtr(); + + bool doStuff = false; + /* + Start by saving important signal data which will be destroyed before the + process is completed. + */ + NodeId new_master_node_id = rep->masterNodeId; + Uint32 theFailedNodes[NodeBitmask::Size]; + for (Uint32 i = 0; i < NodeBitmask::Size; i++) + theFailedNodes[i] = rep->theNodes[i]; + +// NodeId old_master_node_id = getMasterNodeId(); + c_masterNodeId = new_master_node_id; + + NodePtr nodePtr; + for(c_nodes.first(nodePtr); nodePtr.i != RNIL; c_nodes.next(nodePtr)) { + jam(); + if(NodeBitmask::get(theFailedNodes, nodePtr.p->nodeId)){ + if(nodePtr.p->alive){ + jam(); + ndbrequire(c_aliveNodes.get(nodePtr.p->nodeId)); + doStuff = true; + } else { + jam(); + ndbrequire(!c_aliveNodes.get(nodePtr.p->nodeId)); + }//if + nodePtr.p->alive = 0; + c_aliveNodes.clear(nodePtr.p->nodeId); + }//if + }//for + + if(!doStuff){ + jam(); + return; + }//if + +#ifdef DEBUG_ABORT + ndbout_c("****************** Node fail rep ******************"); +#endif + + NodeId newCoordinator = c_masterNodeId; + BackupRecordPtr ptr; + for(c_backups.first(ptr); ptr.i != RNIL; c_backups.next(ptr)) { + jam(); + checkNodeFail(signal, ptr, newCoordinator, theFailedNodes); + } +} + +bool +Backup::verifyNodesAlive(const NdbNodeBitmask& aNodeBitMask) +{ + for (Uint32 i = 0; i < MAX_NDB_NODES; i++) { + jam(); + if(aNodeBitMask.get(i)) { + if(!c_aliveNodes.get(i)){ + jam(); + return false; + }//if + }//if + }//for + return true; +} + +void +Backup::checkNodeFail(Signal* signal, + BackupRecordPtr ptr, + NodeId newCoord, + Uint32 theFailedNodes[NodeBitmask::Size]) +{ + ndbrequire( ptr.p->nodes.get(newCoord)); /* just to make sure newCoord + * is part of the backup + */ + /* Update ptr.p->nodes to be up to date with current alive nodes + */ + NodePtr nodePtr; + bool found = false; + for(c_nodes.first(nodePtr); nodePtr.i != RNIL; c_nodes.next(nodePtr)) { + jam(); + if(NodeBitmask::get(theFailedNodes, nodePtr.p->nodeId)) { + jam(); + if (ptr.p->nodes.get(nodePtr.p->nodeId)) { + jam(); + ptr.p->nodes.clear(nodePtr.p->nodeId); + found = true; + } + }//if + }//for + + if(!found) { + jam(); + return; // failed node is not part of backup process, safe to continue + } + + bool doMasterTakeover = false; + if(NodeBitmask::get(theFailedNodes, refToNode(ptr.p->masterRef))){ + jam(); + doMasterTakeover = true; + }; + + if (newCoord == getOwnNodeId()){ + jam(); + if (doMasterTakeover) { + /** + * I'm new master + */ + CRASH_INSERTION((10002)); +#ifdef DEBUG_ABORT + ndbout_c("**** Master Takeover: Node failed: Master id = %u", + refToNode(ptr.p->masterRef)); +#endif + masterTakeOver(signal, ptr); + return; + }//if + /** + * I'm master for this backup + */ + jam(); + CRASH_INSERTION((10001)); +#ifdef DEBUG_ABORT + ndbout_c("**** Master: Node failed: Master id = %u", + refToNode(ptr.p->masterRef)); +#endif + masterAbort(signal, ptr, false); + return; + }//if + + /** + * If there's a new master, (it's not me) + * but remember who it is + */ + ptr.p->masterRef = calcBackupBlockRef(newCoord); +#ifdef DEBUG_ABORT + ndbout_c("**** Slave: Node failed: Master id = %u", + refToNode(ptr.p->masterRef)); +#endif + /** + * I abort myself as slave if not master + */ + CRASH_INSERTION((10021)); + // slaveAbort(signal, ptr); +} + +void +Backup::masterTakeOver(Signal* signal, BackupRecordPtr ptr) +{ + ptr.p->masterRef = reference(); + ptr.p->masterData.gsn = MAX_GSN + 1; + + switch(ptr.p->slaveState.getState()){ + case INITIAL: + jam(); + ptr.p->masterData.state.forceState(INITIAL); + break; + case ABORTING: + jam(); + case DEFINING: + jam(); + case DEFINED: + jam(); + case STARTED: + jam(); + case SCANNING: + jam(); + ptr.p->masterData.state.forceState(STARTED); + break; + case STOPPING: + jam(); + case CLEANING: + jam(); + ptr.p->masterData.state.forceState(STOPPING); + break; + default: + ndbrequire(false); + } + masterAbort(signal, ptr, false); +} + +void +Backup::execINCL_NODEREQ(Signal* signal) +{ + jamEntry(); + + const Uint32 senderRef = signal->theData[0]; + const Uint32 inclNode = signal->theData[1]; + + NodePtr node; + for(c_nodes.first(node); node.i != RNIL; c_nodes.next(node)) { + jam(); + const Uint32 nodeId = node.p->nodeId; + if(inclNode == nodeId){ + jam(); + + ndbrequire(node.p->alive == 0); + ndbrequire(!c_aliveNodes.get(nodeId)); + + node.p->alive = 1; + c_aliveNodes.set(nodeId); + + break; + }//if + }//for + signal->theData[0] = reference(); + sendSignal(senderRef, GSN_INCL_NODECONF, signal, 1, JBB); +} + +/***************************************************************************** + * + * Master functionallity - Define backup + * + *****************************************************************************/ + +void +Backup::execBACKUP_REQ(Signal* signal) +{ + jamEntry(); + BackupReq * req = (BackupReq*)signal->getDataPtr(); + + const Uint32 senderData = req->senderData; + const BlockReference senderRef = signal->senderBlockRef(); + const Uint32 dataLen32 = req->backupDataLen; // In 32 bit words + + if(getOwnNodeId() != getMasterNodeId()) { + jam(); + sendBackupRef(senderRef, signal, senderData, BackupRef::IAmNotMaster); + return; + }//if + + if(dataLen32 != 0) { + jam(); + sendBackupRef(senderRef, signal, senderData, + BackupRef::BackupDefinitionNotImplemented); + return; + }//if + +#ifdef DEBUG_ABORT + dumpUsedResources(); +#endif + /** + * Seize a backup record + */ + BackupRecordPtr ptr; + c_backups.seize(ptr); + if(ptr.i == RNIL) { + jam(); + sendBackupRef(senderRef, signal, senderData, BackupRef::OutOfBackupRecord); + return; + }//if + + ndbrequire(ptr.p->pages.empty()); + ndbrequire(ptr.p->tables.empty()); + + ptr.p->masterData.state.forceState(INITIAL); + ptr.p->masterData.state.setState(DEFINING); + ptr.p->clientRef = senderRef; + ptr.p->clientData = senderData; + ptr.p->masterRef = reference(); + ptr.p->nodes = c_aliveNodes; + ptr.p->backupId = 0; + ptr.p->backupKey[0] = 0; + ptr.p->backupKey[1] = 0; + ptr.p->backupDataLen = 0; + ptr.p->masterData.dropTrig.tableId = RNIL; + ptr.p->masterData.alterTrig.tableId = RNIL; + + UtilSequenceReq * utilReq = (UtilSequenceReq*)signal->getDataPtrSend(); + + ptr.p->masterData.gsn = GSN_UTIL_SEQUENCE_REQ; + utilReq->senderData = ptr.i; + utilReq->sequenceId = BACKUP_SEQUENCE; + utilReq->requestType = UtilSequenceReq::NextVal; + sendSignal(DBUTIL_REF, GSN_UTIL_SEQUENCE_REQ, + signal, UtilSequenceReq::SignalLength, JBB); +} + +void +Backup::execUTIL_SEQUENCE_REF(Signal* signal) +{ + BackupRecordPtr ptr; + jamEntry(); + UtilSequenceRef * utilRef = (UtilSequenceRef*)signal->getDataPtr(); + ptr.i = utilRef->senderData; + ndbrequire(ptr.i == RNIL); + c_backupPool.getPtr(ptr); + ndbrequire(ptr.p->masterData.gsn == GSN_UTIL_SEQUENCE_REQ); + ptr.p->masterData.gsn = 0; + sendBackupRef(signal, ptr, BackupRef::SequenceFailure); +}//execUTIL_SEQUENCE_REF() + + +void +Backup::sendBackupRef(Signal* signal, BackupRecordPtr ptr, Uint32 errorCode) +{ + jam(); + sendBackupRef(ptr.p->clientRef, signal, ptr.p->clientData, errorCode); + // ptr.p->masterData.state.setState(INITIAL); + cleanupSlaveResources(ptr); +} + +void +Backup::sendBackupRef(BlockReference senderRef, Signal *signal, + Uint32 senderData, Uint32 errorCode) +{ + jam(); + BackupRef* ref = (BackupRef*)signal->getDataPtrSend(); + ref->senderData = senderData; + ref->errorCode = errorCode; + ref->masterRef = numberToRef(BACKUP, getMasterNodeId()); + sendSignal(senderRef, GSN_BACKUP_REF, signal, BackupRef::SignalLength, JBB); +} + +void +Backup::execUTIL_SEQUENCE_CONF(Signal* signal) +{ + jamEntry(); + + UtilSequenceConf * conf = (UtilSequenceConf*)signal->getDataPtr(); + + if(conf->requestType == UtilSequenceReq::Create) { + jam(); + sendSTTORRY(signal); // At startup in NDB + return; + } + + BackupRecordPtr ptr; + ptr.i = conf->senderData; + c_backupPool.getPtr(ptr); + + ndbrequire(ptr.p->masterData.gsn == GSN_UTIL_SEQUENCE_REQ); + ptr.p->masterData.gsn = 0; + if (ptr.p->masterData.state.getState() == ABORTING) { + jam(); + sendBackupRef(signal, ptr, ptr.p->errorCode); + return; + }//if + if (ERROR_INSERTED(10023)) { + ptr.p->masterData.state.setState(ABORTING); + sendBackupRef(signal, ptr, 323); + return; + }//if + ndbrequire(ptr.p->masterData.state.getState() == DEFINING); + + ptr.p->backupId = conf->sequenceValue[0]; + ptr.p->backupKey[0] = (getOwnNodeId() << 16) | (ptr.p->backupId & 0xFFFF); + ptr.p->backupKey[1] = NdbTick_CurrentMillisecond(); + + ptr.p->masterData.gsn = GSN_UTIL_LOCK_REQ; + Mutex mutex(signal, c_mutexMgr, ptr.p->masterData.m_defineBackupMutex); + Callback c = { safe_cast(&Backup::defineBackupMutex_locked), ptr.i }; + ndbrequire(mutex.lock(c)); + + return; +} + +void +Backup::defineBackupMutex_locked(Signal* signal, Uint32 ptrI, Uint32 retVal){ + jamEntry(); + ndbrequire(retVal == 0); + + BackupRecordPtr ptr; + ptr.i = ptrI; + c_backupPool.getPtr(ptr); + + ndbrequire(ptr.p->masterData.gsn == GSN_UTIL_LOCK_REQ); + ptr.p->masterData.gsn = 0; + + ptr.p->masterData.gsn = GSN_UTIL_LOCK_REQ; + Mutex mutex(signal, c_mutexMgr, ptr.p->masterData.m_dictCommitTableMutex); + Callback c = { safe_cast(&Backup::dictCommitTableMutex_locked), ptr.i }; + ndbrequire(mutex.lock(c)); +} + +void +Backup::dictCommitTableMutex_locked(Signal* signal, Uint32 ptrI,Uint32 retVal) +{ + jamEntry(); + ndbrequire(retVal == 0); + + /** + * We now have both the mutexes + */ + BackupRecordPtr ptr; + ptr.i = ptrI; + c_backupPool.getPtr(ptr); + + ndbrequire(ptr.p->masterData.gsn == GSN_UTIL_LOCK_REQ); + ptr.p->masterData.gsn = 0; + + if (ERROR_INSERTED(10031)) { + ptr.p->masterData.state.setState(ABORTING); + ptr.p->setErrorCode(331); + }//if + + if (ptr.p->masterData.state.getState() == ABORTING) { + jam(); + + /** + * Unlock mutexes + */ + jam(); + Mutex mutex1(signal, c_mutexMgr, ptr.p->masterData.m_dictCommitTableMutex); + jam(); + mutex1.unlock(); // ignore response + + jam(); + Mutex mutex2(signal, c_mutexMgr, ptr.p->masterData.m_defineBackupMutex); + jam(); + mutex2.unlock(); // ignore response + + sendBackupRef(signal, ptr, ptr.p->errorCode); + return; + }//if + + ndbrequire(ptr.p->masterData.state.getState() == DEFINING); + + sendDefineBackupReq(signal, ptr); +} + +/***************************************************************************** + * + * Master functionallity - Define backup cont'd (from now on all slaves are in) + * + *****************************************************************************/ + +void +Backup::sendSignalAllWait(BackupRecordPtr ptr, Uint32 gsn, Signal *signal, + Uint32 signalLength, bool executeDirect) +{ + jam(); + ptr.p->masterData.gsn = gsn; + ptr.p->masterData.sendCounter.clearWaitingFor(); + NodePtr node; + for(c_nodes.first(node); node.i != RNIL; c_nodes.next(node)){ + jam(); + const Uint32 nodeId = node.p->nodeId; + if(node.p->alive && ptr.p->nodes.get(nodeId)){ + jam(); + + ptr.p->masterData.sendCounter.setWaitingFor(nodeId); + + const BlockReference ref = numberToRef(BACKUP, nodeId); + if (!executeDirect || ref != reference()) { + sendSignal(ref, gsn, signal, signalLength, JBB); + }//if + }//if + }//for + if (executeDirect) { + EXECUTE_DIRECT(BACKUP, gsn, signal, signalLength); + } +} + +bool +Backup::haveAllSignals(BackupRecordPtr ptr, Uint32 gsn, Uint32 nodeId) +{ + ndbrequire(ptr.p->masterRef == reference()); + ndbrequire(ptr.p->masterData.gsn == gsn); + ndbrequire(!ptr.p->masterData.sendCounter.done()); + ndbrequire(ptr.p->masterData.sendCounter.isWaitingFor(nodeId)); + + ptr.p->masterData.sendCounter.clearWaitingFor(nodeId); + + if (ptr.p->masterData.sendCounter.done()) + ptr.p->masterData.gsn = 0; + + return ptr.p->masterData.sendCounter.done(); +} + +void +Backup::sendDefineBackupReq(Signal *signal, BackupRecordPtr ptr) +{ + /** + * Sending define backup to all participants + */ + DefineBackupReq * req = (DefineBackupReq*)signal->getDataPtrSend(); + req->backupId = ptr.p->backupId; + req->clientRef = ptr.p->clientRef; + req->clientData = ptr.p->clientData; + req->senderRef = reference(); + req->backupPtr = ptr.i; + req->backupKey[0] = ptr.p->backupKey[0]; + req->backupKey[1] = ptr.p->backupKey[1]; + req->nodes = ptr.p->nodes; + req->backupDataLen = ptr.p->backupDataLen; + + ptr.p->masterData.errorCode = 0; + ptr.p->okToCleanMaster = false; // master must wait with cleaning to last + sendSignalAllWait(ptr, GSN_DEFINE_BACKUP_REQ, signal, + DefineBackupReq::SignalLength, + true /* do execute direct on oneself */); + /** + * Now send backup data + */ + const Uint32 len = ptr.p->backupDataLen; + if(len == 0){ + /** + * No data to send + */ + jam(); + return; + }//if + + /** + * Not implemented + */ + ndbrequire(0); +} + +void +Backup::execDEFINE_BACKUP_REF(Signal* signal) +{ + jamEntry(); + + DefineBackupRef* ref = (DefineBackupRef*)signal->getDataPtr(); + + const Uint32 ptrI = ref->backupPtr; + const Uint32 backupId = ref->backupId; + const Uint32 nodeId = refToNode(signal->senderBlockRef()); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + masterAbortCheck(); // macro will do return if ABORTING + + ptr.p->masterData.errorCode = ref->errorCode; + defineBackupReply(signal, ptr, nodeId); +} + +void +Backup::execDEFINE_BACKUP_CONF(Signal* signal) +{ + jamEntry(); + + DefineBackupConf* conf = (DefineBackupConf*)signal->getDataPtr(); + const Uint32 ptrI = conf->backupPtr; + const Uint32 backupId = conf->backupId; + const Uint32 nodeId = refToNode(signal->senderBlockRef()); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + masterAbortCheck(); // macro will do return if ABORTING + + if (ERROR_INSERTED(10024)) { + ptr.p->masterData.errorCode = 324; + }//if + + defineBackupReply(signal, ptr, nodeId); +} + +void +Backup::defineBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId) +{ + if (!haveAllSignals(ptr, GSN_DEFINE_BACKUP_REQ, nodeId)) { + jam(); + return; + } + /** + * Unlock mutexes + */ + jam(); + Mutex mutex1(signal, c_mutexMgr, ptr.p->masterData.m_dictCommitTableMutex); + jam(); + mutex1.unlock(); // ignore response + + jam(); + Mutex mutex2(signal, c_mutexMgr, ptr.p->masterData.m_defineBackupMutex); + jam(); + mutex2.unlock(); // ignore response + + if(ptr.p->errorCode) { + jam(); + ptr.p->masterData.errorCode = ptr.p->errorCode; + } + + if(ptr.p->masterData.errorCode){ + jam(); + ptr.p->setErrorCode(ptr.p->masterData.errorCode); + sendAbortBackupOrd(signal, ptr, AbortBackupOrd::OkToClean); + masterSendAbortBackup(signal, ptr); + return; + } + + /** + * Reply to client + */ + BackupConf * conf = (BackupConf*)signal->getDataPtrSend(); + conf->backupId = ptr.p->backupId; + conf->senderData = ptr.p->clientData; + conf->nodes = ptr.p->nodes; + sendSignal(ptr.p->clientRef, GSN_BACKUP_CONF, signal, + BackupConf::SignalLength, JBB); + + ptr.p->masterData.state.setState(DEFINED); + /** + * Prepare Trig + */ + TablePtr tabPtr; + ndbrequire(ptr.p->tables.first(tabPtr)); + sendCreateTrig(signal, ptr, tabPtr); +} + +/***************************************************************************** + * + * Master functionallity - Prepare triggers + * + *****************************************************************************/ +void +Backup::createAttributeMask(TablePtr tabPtr, + Bitmask & mask) +{ + mask.clear(); + Table & table = * tabPtr.p; + for(Uint32 i = 0; idata.key != 0){ + jam(); + continue; + } + mask.set(i); + } +} + +void +Backup::sendCreateTrig(Signal* signal, + BackupRecordPtr ptr, TablePtr tabPtr) +{ + CreateTrigReq * req =(CreateTrigReq *)signal->getDataPtrSend(); + + ptr.p->errorCode = 0; + ptr.p->masterData.gsn = GSN_CREATE_TRIG_REQ; + ptr.p->masterData.sendCounter = 3; + ptr.p->masterData.createTrig.tableId = tabPtr.p->tableId; + + req->setUserRef(reference()); + req->setConnectionPtr(ptr.i); + req->setRequestType(CreateTrigReq::RT_USER); + + Bitmask attrMask; + createAttributeMask(tabPtr, attrMask); + req->setAttributeMask(attrMask); + req->setTableId(tabPtr.p->tableId); + req->setIndexId(RNIL); // not used + req->setTriggerId(RNIL); // to be created + req->setTriggerType(TriggerType::SUBSCRIPTION); + req->setTriggerActionTime(TriggerActionTime::TA_DETACHED); + req->setMonitorReplicas(true); + req->setMonitorAllAttributes(false); + req->setOnline(false); // leave trigger offline + + char triggerName[MAX_TAB_NAME_SIZE]; + Uint32 nameBuffer[2 + ((MAX_TAB_NAME_SIZE + 3) >> 2)]; // SP string + LinearWriter w(nameBuffer, sizeof(nameBuffer) >> 2); + LinearSectionPtr lsPtr[3]; + + for (int i=0; i < 3; i++) { + req->setTriggerEvent(triggerEventValues[i]); + snprintf(triggerName, sizeof(triggerName), triggerNameFormat[i], + ptr.p->backupId, tabPtr.p->tableId); + w.reset(); + w.add(CreateTrigReq::TriggerNameKey, triggerName); + lsPtr[0].p = nameBuffer; + lsPtr[0].sz = w.getWordsUsed(); + sendSignal(DBDICT_REF, GSN_CREATE_TRIG_REQ, + signal, CreateTrigReq::SignalLength, JBB, lsPtr, 1); + } +} + +void +Backup::execCREATE_TRIG_CONF(Signal* signal) +{ + jamEntry(); + CreateTrigConf * conf = (CreateTrigConf*)signal->getDataPtr(); + + const Uint32 ptrI = conf->getConnectionPtr(); + const Uint32 tableId = conf->getTableId(); + const TriggerEvent::Value type = conf->getTriggerEvent(); + const Uint32 triggerId = conf->getTriggerId(); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + /** + * Verify that I'm waiting for this conf + */ + ndbrequire(ptr.p->masterRef == reference()); + ndbrequire(ptr.p->masterData.gsn == GSN_CREATE_TRIG_REQ); + ndbrequire(ptr.p->masterData.sendCounter.done() == false); + ndbrequire(ptr.p->masterData.createTrig.tableId == tableId); + + TablePtr tabPtr; + ndbrequire(findTable(ptr, tabPtr, tableId)); + ndbrequire(type < 3); // if some decides to change the enums + + ndbrequire(tabPtr.p->triggerIds[type] == ILLEGAL_TRIGGER_ID); + tabPtr.p->triggerIds[type] = triggerId; + + createTrigReply(signal, ptr); +} + +void +Backup::execCREATE_TRIG_REF(Signal* signal) +{ + CreateTrigRef* ref = (CreateTrigRef*)signal->getDataPtr(); + + const Uint32 ptrI = ref->getConnectionPtr(); + const Uint32 tableId = ref->getTableId(); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + /** + * Verify that I'm waiting for this ref + */ + ndbrequire(ptr.p->masterRef == reference()); + ndbrequire(ptr.p->masterData.gsn == GSN_CREATE_TRIG_REQ); + ndbrequire(ptr.p->masterData.sendCounter.done() == false); + ndbrequire(ptr.p->masterData.createTrig.tableId == tableId); + + ptr.p->setErrorCode(ref->getErrorCode()); + + createTrigReply(signal, ptr); +} + +void +Backup::createTrigReply(Signal* signal, BackupRecordPtr ptr) +{ + CRASH_INSERTION(10003); + + /** + * Check finished with table + */ + ptr.p->masterData.sendCounter--; + if(ptr.p->masterData.sendCounter.done() == false){ + jam(); + return; + }//if + + ptr.p->masterData.gsn = 0; + + if(ptr.p->checkError()) { + jam(); + masterAbort(signal, ptr, true); + return; + }//if + + if (ERROR_INSERTED(10025)) { + ptr.p->errorCode = 325; + masterAbort(signal, ptr, true); + return; + }//if + + TablePtr tabPtr; + ndbrequire(findTable(ptr, tabPtr, ptr.p->masterData.createTrig.tableId)); + + /** + * Next table + */ + ptr.p->tables.next(tabPtr); + if(tabPtr.i != RNIL){ + jam(); + sendCreateTrig(signal, ptr, tabPtr); + return; + }//if + + /** + * Finished with all tables, send StartBackupReq + */ + ptr.p->masterData.state.setState(STARTED); + + ptr.p->tables.first(tabPtr); + ptr.p->errorCode = 0; + ptr.p->masterData.startBackup.signalNo = 0; + ptr.p->masterData.startBackup.noOfSignals = + (ptr.p->tables.noOfElements() + StartBackupReq::MaxTableTriggers - 1) / + StartBackupReq::MaxTableTriggers; + sendStartBackup(signal, ptr, tabPtr); +} + +/***************************************************************************** + * + * Master functionallity - Start backup + * + *****************************************************************************/ +void +Backup::sendStartBackup(Signal* signal, BackupRecordPtr ptr, TablePtr tabPtr) +{ + + ptr.p->masterData.startBackup.tablePtr = tabPtr.i; + + StartBackupReq* req = (StartBackupReq*)signal->getDataPtrSend(); + req->backupId = ptr.p->backupId; + req->backupPtr = ptr.i; + req->signalNo = ptr.p->masterData.startBackup.signalNo; + req->noOfSignals = ptr.p->masterData.startBackup.noOfSignals; + Uint32 i; + for(i = 0; itableTriggers[i].tableId = tabPtr.p->tableId; + req->tableTriggers[i].triggerIds[0] = tabPtr.p->triggerIds[0]; + req->tableTriggers[i].triggerIds[1] = tabPtr.p->triggerIds[1]; + req->tableTriggers[i].triggerIds[2] = tabPtr.p->triggerIds[2]; + if(!ptr.p->tables.next(tabPtr)){ + jam(); + i++; + break; + }//if + }//for + req->noOfTableTriggers = i; + + sendSignalAllWait(ptr, GSN_START_BACKUP_REQ, signal, + StartBackupReq::HeaderLength + + (i * StartBackupReq::TableTriggerLength)); +} + +void +Backup::execSTART_BACKUP_REF(Signal* signal) +{ + jamEntry(); + + StartBackupRef* ref = (StartBackupRef*)signal->getDataPtr(); + const Uint32 ptrI = ref->backupPtr; + const Uint32 backupId = ref->backupId; + const Uint32 signalNo = ref->signalNo; + const Uint32 nodeId = refToNode(signal->senderBlockRef()); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + masterAbortCheck(); // macro will do return if ABORTING + + ptr.p->setErrorCode(ref->errorCode); + startBackupReply(signal, ptr, nodeId, signalNo); +} + +void +Backup::execSTART_BACKUP_CONF(Signal* signal) +{ + jamEntry(); + + StartBackupConf* conf = (StartBackupConf*)signal->getDataPtr(); + const Uint32 ptrI = conf->backupPtr; + const Uint32 backupId = conf->backupId; + const Uint32 signalNo = conf->signalNo; + const Uint32 nodeId = refToNode(signal->senderBlockRef()); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + masterAbortCheck(); // macro will do return if ABORTING + + startBackupReply(signal, ptr, nodeId, signalNo); +} + +void +Backup::startBackupReply(Signal* signal, BackupRecordPtr ptr, + Uint32 nodeId, Uint32 signalNo) +{ + + CRASH_INSERTION((10004)); + + ndbrequire(ptr.p->masterData.startBackup.signalNo == signalNo); + if (!haveAllSignals(ptr, GSN_START_BACKUP_REQ, nodeId)) { + jam(); + return; + } + + if(ptr.p->checkError()){ + jam(); + masterAbort(signal, ptr, true); + return; + } + + if (ERROR_INSERTED(10026)) { + ptr.p->errorCode = 326; + masterAbort(signal, ptr, true); + return; + }//if + + TablePtr tabPtr; + c_tablePool.getPtr(tabPtr, ptr.p->masterData.startBackup.tablePtr); + for(Uint32 i = 0; itables.next(tabPtr)) { + jam(); + break; + }//if + }//for + + if(tabPtr.i != RNIL) { + jam(); + ptr.p->masterData.startBackup.signalNo++; + sendStartBackup(signal, ptr, tabPtr); + return; + } + + sendAlterTrig(signal, ptr); +} + +/***************************************************************************** + * + * Master functionallity - Activate triggers + * + *****************************************************************************/ +void +Backup::sendAlterTrig(Signal* signal, BackupRecordPtr ptr) +{ + AlterTrigReq * req =(AlterTrigReq *)signal->getDataPtrSend(); + + ptr.p->errorCode = 0; + ptr.p->masterData.gsn = GSN_ALTER_TRIG_REQ; + ptr.p->masterData.sendCounter = 0; + + req->setUserRef(reference()); + req->setConnectionPtr(ptr.i); + req->setRequestType(AlterTrigReq::RT_USER); + req->setTriggerInfo(0); // not used on ALTER via DICT + req->setOnline(true); + req->setReceiverRef(reference()); + + TablePtr tabPtr; + + if (ptr.p->masterData.alterTrig.tableId == RNIL) { + jam(); + ptr.p->tables.first(tabPtr); + } else { + jam(); + ndbrequire(findTable(ptr, tabPtr, ptr.p->masterData.alterTrig.tableId)); + ptr.p->tables.next(tabPtr); + }//if + if (tabPtr.i != RNIL) { + jam(); + ptr.p->masterData.alterTrig.tableId = tabPtr.p->tableId; + req->setTableId(tabPtr.p->tableId); + + req->setTriggerId(tabPtr.p->triggerIds[0]); + sendSignal(DBDICT_REF, GSN_ALTER_TRIG_REQ, + signal, AlterTrigReq::SignalLength, JBB); + + req->setTriggerId(tabPtr.p->triggerIds[1]); + sendSignal(DBDICT_REF, GSN_ALTER_TRIG_REQ, + signal, AlterTrigReq::SignalLength, JBB); + + req->setTriggerId(tabPtr.p->triggerIds[2]); + sendSignal(DBDICT_REF, GSN_ALTER_TRIG_REQ, + signal, AlterTrigReq::SignalLength, JBB); + + ptr.p->masterData.sendCounter += 3; + return; + }//if + ptr.p->masterData.alterTrig.tableId = RNIL; + /** + * Finished with all tables + */ + ptr.p->masterData.gsn = GSN_WAIT_GCP_REQ; + ptr.p->masterData.waitGCP.startBackup = true; + + WaitGCPReq * waitGCPReq = (WaitGCPReq*)signal->getDataPtrSend(); + waitGCPReq->senderRef = reference(); + waitGCPReq->senderData = ptr.i; + waitGCPReq->requestType = WaitGCPReq::CompleteForceStart; + sendSignal(DBDIH_REF, GSN_WAIT_GCP_REQ, signal, + WaitGCPReq::SignalLength,JBB); +} + +void +Backup::execALTER_TRIG_CONF(Signal* signal) +{ + jamEntry(); + + AlterTrigConf* conf = (AlterTrigConf*)signal->getDataPtr(); + const Uint32 ptrI = conf->getConnectionPtr(); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + alterTrigReply(signal, ptr); +} + +void +Backup::execALTER_TRIG_REF(Signal* signal) +{ + jamEntry(); + + AlterTrigRef* ref = (AlterTrigRef*)signal->getDataPtr(); + const Uint32 ptrI = ref->getConnectionPtr(); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + ptr.p->setErrorCode(ref->getErrorCode()); + + alterTrigReply(signal, ptr); +} + +void +Backup::alterTrigReply(Signal* signal, BackupRecordPtr ptr) +{ + + CRASH_INSERTION((10005)); + + ndbrequire(ptr.p->masterRef == reference()); + ndbrequire(ptr.p->masterData.gsn == GSN_ALTER_TRIG_REQ); + ndbrequire(ptr.p->masterData.sendCounter.done() == false); + + ptr.p->masterData.sendCounter--; + + if(ptr.p->masterData.sendCounter.done() == false){ + jam(); + return; + }//if + + ptr.p->masterData.gsn = 0; + + if(ptr.p->checkError()){ + jam(); + masterAbort(signal, ptr, true); + return; + }//if + + sendAlterTrig(signal, ptr); +} + +void +Backup::execWAIT_GCP_REF(Signal* signal) +{ + jamEntry(); + + CRASH_INSERTION((10006)); + + WaitGCPRef * ref = (WaitGCPRef*)signal->getDataPtr(); + const Uint32 ptrI = ref->senderData; + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + ndbrequire(ptr.p->masterRef == reference()); + ndbrequire(ptr.p->masterData.gsn == GSN_WAIT_GCP_REQ); + + WaitGCPReq * req = (WaitGCPReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + req->senderData = ptr.i; + req->requestType = WaitGCPReq::CompleteForceStart; + sendSignal(DBDIH_REF, GSN_WAIT_GCP_REQ, signal, + WaitGCPReq::SignalLength,JBB); +} + +void +Backup::execWAIT_GCP_CONF(Signal* signal){ + jamEntry(); + + CRASH_INSERTION((10007)); + + WaitGCPConf * conf = (WaitGCPConf*)signal->getDataPtr(); + const Uint32 ptrI = conf->senderData; + const Uint32 gcp = conf->gcp; + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + ndbrequire(ptr.p->masterRef == reference()); + ndbrequire(ptr.p->masterData.gsn == GSN_WAIT_GCP_REQ); + ptr.p->masterData.gsn = 0; + + if(ptr.p->checkError()) { + jam(); + masterAbort(signal, ptr, true); + return; + }//if + + if(ptr.p->masterData.waitGCP.startBackup) { + jam(); + CRASH_INSERTION((10008)); + ptr.p->startGCP = gcp; + ptr.p->masterData.state.setState(SCANNING); + nextFragment(signal, ptr); + } else { + jam(); + CRASH_INSERTION((10009)); + ptr.p->stopGCP = gcp; + ptr.p->masterData.state.setState(STOPPING); + sendDropTrig(signal, ptr); // regular dropping of triggers + }//if +} +/***************************************************************************** + * + * Master functionallity - Backup fragment + * + *****************************************************************************/ +void +Backup::nextFragment(Signal* signal, BackupRecordPtr ptr) +{ + jam(); + + BackupFragmentReq* req = (BackupFragmentReq*)signal->getDataPtrSend(); + req->backupPtr = ptr.i; + req->backupId = ptr.p->backupId; + + NodeBitmask nodes = ptr.p->nodes; + Uint32 idleNodes = nodes.count(); + Uint32 saveIdleNodes = idleNodes; + ndbrequire(idleNodes > 0); + + TablePtr tabPtr; + ptr.p->tables.first(tabPtr); + for(; tabPtr.i != RNIL && idleNodes > 0; ptr.p->tables.next(tabPtr)) { + jam(); + FragmentPtr fragPtr; + Array & frags = tabPtr.p->fragments; + const Uint32 fragCount = frags.getSize(); + + for(Uint32 i = 0; i 0; i++) { + jam(); + tabPtr.p->fragments.getPtr(fragPtr, i); + const Uint32 nodeId = fragPtr.p->node; + if(fragPtr.p->scanning != 0) { + jam(); + ndbrequire(nodes.get(nodeId)); + nodes.clear(nodeId); + idleNodes--; + } else if(fragPtr.p->scanned == 0 && nodes.get(nodeId)){ + jam(); + fragPtr.p->scanning = 1; + nodes.clear(nodeId); + idleNodes--; + + req->tableId = tabPtr.p->tableId; + req->fragmentNo = i; + req->count = 0; + + const BlockReference ref = numberToRef(BACKUP, nodeId); + sendSignal(ref, GSN_BACKUP_FRAGMENT_REQ, signal, + BackupFragmentReq::SignalLength, JBB); + }//if + }//for + }//for + + if(idleNodes != saveIdleNodes){ + jam(); + return; + }//if + + /** + * Finished with all tables + */ + { + ptr.p->masterData.gsn = GSN_WAIT_GCP_REQ; + ptr.p->masterData.waitGCP.startBackup = false; + + WaitGCPReq * req = (WaitGCPReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + req->senderData = ptr.i; + req->requestType = WaitGCPReq::CompleteForceStart; + sendSignal(DBDIH_REF, GSN_WAIT_GCP_REQ, signal, + WaitGCPReq::SignalLength, JBB); + } +} + +void +Backup::execBACKUP_FRAGMENT_CONF(Signal* signal) +{ + jamEntry(); + + CRASH_INSERTION((10010)); + + BackupFragmentConf * conf = (BackupFragmentConf*)signal->getDataPtr(); + const Uint32 ptrI = conf->backupPtr; + const Uint32 backupId = conf->backupId; + const Uint32 tableId = conf->tableId; + const Uint32 fragmentNo = conf->fragmentNo; + const Uint32 nodeId = refToNode(signal->senderBlockRef()); + const Uint32 noOfBytes = conf->noOfBytes; + const Uint32 noOfRecords = conf->noOfRecords; + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + masterAbortCheck(); // macro will do return if ABORTING + + ptr.p->noOfBytes += noOfBytes; + ptr.p->noOfRecords += noOfRecords; + + TablePtr tabPtr; + ndbrequire(findTable(ptr, tabPtr, tableId)); + + FragmentPtr fragPtr; + tabPtr.p->fragments.getPtr(fragPtr, fragmentNo); + + ndbrequire(fragPtr.p->scanned == 0); + ndbrequire(fragPtr.p->scanning == 1); + ndbrequire(fragPtr.p->node == nodeId); + + fragPtr.p->scanned = 1; + fragPtr.p->scanning = 0; + + if(ptr.p->checkError()) { + jam(); + masterAbort(signal, ptr, true); + return; + }//if + if (ERROR_INSERTED(10028)) { + ptr.p->errorCode = 328; + masterAbort(signal, ptr, true); + return; + }//if + nextFragment(signal, ptr); +} + +void +Backup::execBACKUP_FRAGMENT_REF(Signal* signal) +{ + jamEntry(); + + CRASH_INSERTION((10011)); + + BackupFragmentRef * ref = (BackupFragmentRef*)signal->getDataPtr(); + const Uint32 ptrI = ref->backupPtr; + const Uint32 backupId = ref->backupId; + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + masterAbortCheck(); // macro will do return if ABORTING + + ptr.p->setErrorCode(ref->errorCode); + masterAbort(signal, ptr, true); +} + +/***************************************************************************** + * + * Master functionallity - Drop triggers + * + *****************************************************************************/ + +void +Backup::sendDropTrig(Signal* signal, BackupRecordPtr ptr) +{ + TablePtr tabPtr; + if (ptr.p->masterData.dropTrig.tableId == RNIL) { + jam(); + ptr.p->tables.first(tabPtr); + } else { + jam(); + ndbrequire(findTable(ptr, tabPtr, ptr.p->masterData.dropTrig.tableId)); + ptr.p->tables.next(tabPtr); + }//if + if (tabPtr.i != RNIL) { + jam(); + sendDropTrig(signal, ptr, tabPtr); + } else { + jam(); + ptr.p->masterData.dropTrig.tableId = RNIL; + + sendAbortBackupOrd(signal, ptr, AbortBackupOrd::OkToClean); + + if(ptr.p->masterData.state.getState() == STOPPING) { + jam(); + sendStopBackup(signal, ptr); + return; + }//if + ndbrequire(ptr.p->masterData.state.getState() == ABORTING); + masterSendAbortBackup(signal, ptr); + }//if +} + +void +Backup::sendDropTrig(Signal* signal, BackupRecordPtr ptr, TablePtr tabPtr) +{ + jam(); + DropTrigReq * req = (DropTrigReq *)signal->getDataPtrSend(); + + ptr.p->masterData.gsn = GSN_DROP_TRIG_REQ; + ptr.p->masterData.sendCounter = 0; + + req->setConnectionPtr(ptr.i); + req->setUserRef(reference()); // Sending to myself + req->setRequestType(DropTrigReq::RT_USER); + req->setIndexId(RNIL); + req->setTriggerInfo(0); // not used on DROP via DICT + + char triggerName[MAX_TAB_NAME_SIZE]; + Uint32 nameBuffer[2 + ((MAX_TAB_NAME_SIZE + 3) >> 2)]; // SP string + LinearWriter w(nameBuffer, sizeof(nameBuffer) >> 2); + LinearSectionPtr lsPtr[3]; + + ptr.p->masterData.dropTrig.tableId = tabPtr.p->tableId; + req->setTableId(tabPtr.p->tableId); + + for (int i = 0; i < 3; i++) { + Uint32 id = tabPtr.p->triggerIds[i]; + req->setTriggerId(id); + if (id != ILLEGAL_TRIGGER_ID) { + sendSignal(DBDICT_REF, GSN_DROP_TRIG_REQ, + signal, DropTrigReq::SignalLength, JBB); + } else { + snprintf(triggerName, sizeof(triggerName), triggerNameFormat[i], + ptr.p->backupId, tabPtr.p->tableId); + w.reset(); + w.add(CreateTrigReq::TriggerNameKey, triggerName); + lsPtr[0].p = nameBuffer; + lsPtr[0].sz = w.getWordsUsed(); + sendSignal(DBDICT_REF, GSN_DROP_TRIG_REQ, + signal, DropTrigReq::SignalLength, JBB, lsPtr, 1); + } + ptr.p->masterData.sendCounter ++; + } +} + +void +Backup::execDROP_TRIG_REF(Signal* signal) +{ + jamEntry(); + + DropTrigRef* ref = (DropTrigRef*)signal->getDataPtr(); + const Uint32 ptrI = ref->getConnectionPtr(); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + //ndbrequire(ref->getErrorCode() == DropTrigRef::NoSuchTrigger); + dropTrigReply(signal, ptr); +} + +void +Backup::execDROP_TRIG_CONF(Signal* signal) +{ + jamEntry(); + + DropTrigConf* conf = (DropTrigConf*)signal->getDataPtr(); + const Uint32 ptrI = conf->getConnectionPtr(); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + dropTrigReply(signal, ptr); +} + +void +Backup::dropTrigReply(Signal* signal, BackupRecordPtr ptr) +{ + + CRASH_INSERTION((10012)); + + ndbrequire(ptr.p->masterRef == reference()); + ndbrequire(ptr.p->masterData.gsn == GSN_DROP_TRIG_REQ); + ndbrequire(ptr.p->masterData.sendCounter.done() == false); + + ptr.p->masterData.sendCounter--; + if(ptr.p->masterData.sendCounter.done() == false){ + jam(); + return; + }//if + + ptr.p->masterData.gsn = 0; + sendDropTrig(signal, ptr); // recursive next +} + +/***************************************************************************** + * + * Master functionallity - Stop backup + * + *****************************************************************************/ +void +Backup::execSTOP_BACKUP_REF(Signal* signal) +{ + jamEntry(); + ndbrequire(0); +} + +void +Backup::sendStopBackup(Signal* signal, BackupRecordPtr ptr) +{ + jam(); + ptr.p->masterData.gsn = GSN_STOP_BACKUP_REQ; + + StopBackupReq* stop = (StopBackupReq*)signal->getDataPtrSend(); + stop->backupPtr = ptr.i; + stop->backupId = ptr.p->backupId; + stop->startGCP = ptr.p->startGCP; + stop->stopGCP = ptr.p->stopGCP; + + sendSignalAllWait(ptr, GSN_STOP_BACKUP_REQ, signal, + StopBackupReq::SignalLength); +} + +void +Backup::execSTOP_BACKUP_CONF(Signal* signal) +{ + jamEntry(); + + StopBackupConf* conf = (StopBackupConf*)signal->getDataPtr(); + const Uint32 ptrI = conf->backupPtr; + const Uint32 backupId = conf->backupId; + const Uint32 nodeId = refToNode(signal->senderBlockRef()); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + masterAbortCheck(); // macro will do return if ABORTING + + ptr.p->noOfLogBytes += conf->noOfLogBytes; + ptr.p->noOfLogRecords += conf->noOfLogRecords; + + stopBackupReply(signal, ptr, nodeId); +} + +void +Backup::stopBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId) +{ + CRASH_INSERTION((10013)); + + if (!haveAllSignals(ptr, GSN_STOP_BACKUP_REQ, nodeId)) { + jam(); + return; + } + + // ptr.p->masterData.state.setState(INITIAL); + + // send backup complete first to slaves so that they know + sendAbortBackupOrd(signal, ptr, AbortBackupOrd::BackupComplete); + + BackupCompleteRep * rep = (BackupCompleteRep*)signal->getDataPtrSend(); + rep->backupId = ptr.p->backupId; + rep->senderData = ptr.p->clientData; + rep->startGCP = ptr.p->startGCP; + rep->stopGCP = ptr.p->stopGCP; + rep->noOfBytes = ptr.p->noOfBytes; + rep->noOfRecords = ptr.p->noOfRecords; + rep->noOfLogBytes = ptr.p->noOfLogBytes; + rep->noOfLogRecords = ptr.p->noOfLogRecords; + rep->nodes = ptr.p->nodes; + sendSignal(ptr.p->clientRef, GSN_BACKUP_COMPLETE_REP, signal, + BackupCompleteRep::SignalLength, JBB); +} + +/***************************************************************************** + * + * Master functionallity - Abort backup + * + *****************************************************************************/ +void +Backup::masterAbort(Signal* signal, BackupRecordPtr ptr, bool controlledAbort) +{ + if(ptr.p->masterData.state.getState() == ABORTING) { +#ifdef DEBUG_ABORT + ndbout_c("---- Master already aborting"); +#endif + jam(); + return; + } + jam(); +#ifdef DEBUG_ABORT + ndbout_c("************ masterAbort"); +#endif + + sendAbortBackupOrd(signal, ptr, AbortBackupOrd::BackupFailure); + if (!ptr.p->checkError()) + ptr.p->errorCode = AbortBackupOrd::BackupFailureDueToNodeFail; + + const State s = ptr.p->masterData.state.getState(); + + ptr.p->masterData.state.setState(ABORTING); + + ndbrequire(s == INITIAL || + s == STARTED || + s == DEFINING || + s == DEFINED || + s == SCANNING || + s == STOPPING || + s == ABORTING); + if(ptr.p->masterData.gsn == GSN_UTIL_SEQUENCE_REQ) { + jam(); + DEBUG_OUT("masterAbort: gsn = GSN_UTIL_SEQUENCE_REQ"); + //------------------------------------------------------- + // We are waiting for UTIL_SEQUENCE response. We rely on + // this to arrive and check for ABORTING in response. + // No slaves are involved at this point and ABORT simply + // results in BACKUP_REF to client + //------------------------------------------------------- + /** + * Waiting for Sequence Id + * @see execUTIL_SEQUENCE_CONF + */ + return; + }//if + + if(ptr.p->masterData.gsn == GSN_UTIL_LOCK_REQ) { + jam(); + DEBUG_OUT("masterAbort: gsn = GSN_UTIL_LOCK_REQ"); + //------------------------------------------------------- + // We are waiting for UTIL_LOCK response (mutex). We rely on + // this to arrive and check for ABORTING in response. + // No slaves are involved at this point and ABORT simply + // results in BACKUP_REF to client + //------------------------------------------------------- + /** + * Waiting for lock + * @see execUTIL_LOCK_CONF + */ + return; + }//if + + /** + * Unlock mutexes only at master + */ + jam(); + Mutex mutex1(signal, c_mutexMgr, ptr.p->masterData.m_dictCommitTableMutex); + jam(); + mutex1.unlock(); // ignore response + + jam(); + Mutex mutex2(signal, c_mutexMgr, ptr.p->masterData.m_defineBackupMutex); + jam(); + mutex2.unlock(); // ignore response + + if (!controlledAbort) { + jam(); + if (s == DEFINING) { + jam(); +//------------------------------------------------------- +// If we are in the defining phase all work is done by +// slaves. No triggers have been allocated thus slaves +// may free all "Master" resources, let them know... +//------------------------------------------------------- + sendAbortBackupOrd(signal, ptr, AbortBackupOrd::OkToClean); + return; + }//if + if (s == DEFINED) { + jam(); +//------------------------------------------------------- +// DEFINED is the state when triggers are created. We rely +// on that DICT will report create trigger failure in case +// of node failure. Thus no special action is needed here. +// We will check for errorCode != 0 when receiving +// replies on create trigger. +//------------------------------------------------------- + return; + }//if + if(ptr.p->masterData.gsn == GSN_WAIT_GCP_REQ) { + jam(); + DEBUG_OUT("masterAbort: gsn = GSN_WAIT_GCP_REQ"); +//------------------------------------------------------- +// We are waiting for WAIT_GCP response. We rely on +// this to arrive and check for ABORTING in response. +//------------------------------------------------------- + + /** + * Waiting for GCP + * @see execWAIT_GCP_CONF + */ + return; + }//if + + if(ptr.p->masterData.gsn == GSN_ALTER_TRIG_REQ) { + jam(); + DEBUG_OUT("masterAbort: gsn = GSN_ALTER_TRIG_REQ"); +//------------------------------------------------------- +// We are waiting for ALTER_TRIG response. We rely on +// this to arrive and check for ABORTING in response. +//------------------------------------------------------- + + /** + * All triggers haven't been created yet + */ + return; + }//if + + if(ptr.p->masterData.gsn == GSN_DROP_TRIG_REQ) { + jam(); + DEBUG_OUT("masterAbort: gsn = GSN_DROP_TRIG_REQ"); +//------------------------------------------------------- +// We are waiting for DROP_TRIG response. We rely on +// this to arrive and will continue dropping triggers +// until completed. +//------------------------------------------------------- + + /** + * I'm currently dropping the trigger + */ + return; + }//if + }//if + +//------------------------------------------------------- +// If we are waiting for START_BACKUP responses we can +// safely start dropping triggers (state == STARTED). +// We will ignore any START_BACKUP responses after this. +//------------------------------------------------------- + DEBUG_OUT("masterAbort: sendDropTrig"); + sendDropTrig(signal, ptr); // dropping due to error +} + +void +Backup::masterSendAbortBackup(Signal* signal, BackupRecordPtr ptr) +{ + if (ptr.p->masterData.state.getState() != ABORTING) { + sendAbortBackupOrd(signal, ptr, AbortBackupOrd::BackupFailure); + ptr.p->masterData.state.setState(ABORTING); + } + const State s = ptr.p->masterData.state.getAbortState(); + + /** + * First inform to client + */ + if(s == DEFINING) { + jam(); +#ifdef DEBUG_ABORT + ndbout_c("** Abort: sending BACKUP_REF to mgmtsrvr"); +#endif + sendBackupRef(ptr.p->clientRef, signal, ptr.p->clientData, + ptr.p->errorCode); + + } else { + jam(); +#ifdef DEBUG_ABORT + ndbout_c("** Abort: sending BACKUP_ABORT_REP to mgmtsrvr"); +#endif + BackupAbortRep* rep = (BackupAbortRep*)signal->getDataPtrSend(); + rep->backupId = ptr.p->backupId; + rep->senderData = ptr.p->clientData; + rep->reason = ptr.p->errorCode; + sendSignal(ptr.p->clientRef, GSN_BACKUP_ABORT_REP, signal, + BackupAbortRep::SignalLength, JBB); + }//if + + // ptr.p->masterData.state.setState(INITIAL); + + sendAbortBackupOrd(signal, ptr, AbortBackupOrd::BackupFailure); +} + +/***************************************************************************** + * + * Slave functionallity: Define Backup + * + *****************************************************************************/ +void +Backup::defineBackupRef(Signal* signal, BackupRecordPtr ptr, Uint32 errCode) +{ + if (ptr.p->slaveState.getState() == ABORTING) { + jam(); + return; + } + ptr.p->slaveState.setState(ABORTING); + + if (errCode != 0) { + jam(); + ptr.p->setErrorCode(errCode); + }//if + ndbrequire(ptr.p->errorCode != 0); + + DefineBackupRef* ref = (DefineBackupRef*)signal->getDataPtrSend(); + ref->backupId = ptr.p->backupId; + ref->backupPtr = ptr.i; + ref->errorCode = ptr.p->errorCode; + sendSignal(ptr.p->masterRef, GSN_DEFINE_BACKUP_REF, signal, + DefineBackupRef::SignalLength, JBB); + + closeFiles(signal, ptr); +} + +void +Backup::execDEFINE_BACKUP_REQ(Signal* signal) +{ + jamEntry(); + + DefineBackupReq* req = (DefineBackupReq*)signal->getDataPtr(); + + BackupRecordPtr ptr; + const Uint32 ptrI = req->backupPtr; + const Uint32 backupId = req->backupId; + const BlockReference senderRef = req->senderRef; + + if(senderRef == reference()){ + /** + * Signal sent from myself -> record already seized + */ + jam(); + c_backupPool.getPtr(ptr, ptrI); + } else { // from other node + jam(); +#ifdef DEBUG_ABORT + dumpUsedResources(); +#endif + if(!c_backups.seizeId(ptr, ptrI)) { + jam(); + ndbrequire(false); // If master has succeeded slave should succed + }//if + }//if + + CRASH_INSERTION((10014)); + + ptr.p->slaveState.forceState(INITIAL); + ptr.p->slaveState.setState(DEFINING); + ptr.p->errorCode = 0; + ptr.p->clientRef = req->clientRef; + ptr.p->clientData = req->clientData; + ptr.p->masterRef = senderRef; + ptr.p->nodes = req->nodes; + ptr.p->backupId = backupId; + ptr.p->backupKey[0] = req->backupKey[0]; + ptr.p->backupKey[1] = req->backupKey[1]; + ptr.p->backupDataLen = req->backupDataLen; + ptr.p->masterData.dropTrig.tableId = RNIL; + ptr.p->masterData.alterTrig.tableId = RNIL; + ptr.p->noOfBytes = 0; + ptr.p->noOfRecords = 0; + ptr.p->noOfLogBytes = 0; + ptr.p->noOfLogRecords = 0; + ptr.p->currGCP = 0; + + /** + * Allocate files + */ + BackupFilePtr files[3]; + Uint32 noOfPages[] = { + NO_OF_PAGES_META_FILE, + 2, // 32k + 0 // 3M + }; + const Uint32 maxInsert[] = { + 2048, // Temporarily to solve TR515 + //25, // 100 bytes + 2048, // 4k + 16*3000, // Max 16 tuples + }; + Uint32 minWrite[] = { + 8192, + 8192, + 32768 + }; + Uint32 maxWrite[] = { + 8192, + 8192, + 32768 + }; + + minWrite[1] = c_defaults.m_minWriteSize; + maxWrite[1] = c_defaults.m_maxWriteSize; + noOfPages[1] = (c_defaults.m_logBufferSize + sizeof(Page32) - 1) / + sizeof(Page32); + minWrite[2] = c_defaults.m_minWriteSize; + maxWrite[2] = c_defaults.m_maxWriteSize; + noOfPages[2] = (c_defaults.m_dataBufferSize + sizeof(Page32) - 1) / + sizeof(Page32); + + for(Uint32 i = 0; i<3; i++) { + jam(); + if(!ptr.p->files.seize(files[i])) { + jam(); + defineBackupRef(signal, ptr, + DefineBackupRef::FailedToAllocateFileRecord); + return; + }//if + + files[i].p->tableId = RNIL; + files[i].p->backupPtr = ptr.i; + files[i].p->filePointer = RNIL; + files[i].p->fileDone = 0; + files[i].p->fileOpened = 0; + files[i].p->fileRunning = 0; + files[i].p->scanRunning = 0; + files[i].p->errorCode = 0; + + if(files[i].p->pages.seize(noOfPages[i]) == false) { + jam(); + DEBUG_OUT("Failed to seize " << noOfPages[i] << " pages"); + defineBackupRef(signal, ptr, DefineBackupRef::FailedToAllocateBuffers); + return; + }//if + Page32Ptr pagePtr; + files[i].p->pages.getPtr(pagePtr, 0); + + const char * msg = files[i].p-> + operation.dataBuffer.setup((Uint32*)pagePtr.p, + noOfPages[i] * (sizeof(Page32) >> 2), + 128, + minWrite[i] >> 2, + maxWrite[i] >> 2, + maxInsert[i]); + if(msg != 0) { + jam(); + defineBackupRef(signal, ptr, DefineBackupRef::FailedToSetupFsBuffers); + return; + }//if + }//for + files[0].p->fileType = BackupFormat::CTL_FILE; + files[1].p->fileType = BackupFormat::LOG_FILE; + files[2].p->fileType = BackupFormat::DATA_FILE; + + ptr.p->ctlFilePtr = files[0].i; + ptr.p->logFilePtr = files[1].i; + ptr.p->dataFilePtr = files[2].i; + + if (!verifyNodesAlive(ptr.p->nodes)) { + jam(); + defineBackupRef(signal, ptr, DefineBackupRef::Undefined); + // sendBackupRef(signal, ptr, + // ptr.p->errorCode?ptr.p->errorCode:BackupRef::Undefined); + return; + }//if + if (ERROR_INSERTED(10027)) { + jam(); + defineBackupRef(signal, ptr, 327); + // sendBackupRef(signal, ptr, 327); + return; + }//if + + if(ptr.p->backupDataLen == 0) { + jam(); + backupAllData(signal, ptr); + return; + }//if + + /** + * Not implemented + */ + ndbrequire(0); +} + +void +Backup::backupAllData(Signal* signal, BackupRecordPtr ptr) +{ + /** + * Get all tables from dict + */ + ListTablesReq * req = (ListTablesReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + req->senderData = ptr.i; + req->requestData = 0; + sendSignal(DBDICT_REF, GSN_LIST_TABLES_REQ, signal, + ListTablesReq::SignalLength, JBB); +} + +void +Backup::execLIST_TABLES_CONF(Signal* signal) +{ + jamEntry(); + + ListTablesConf* conf = (ListTablesConf*)signal->getDataPtr(); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, conf->senderData); + + const Uint32 len = signal->length() - ListTablesConf::HeaderLength; + for(unsigned int i = 0; itableData[i]); + Uint32 tableType = ListTablesConf::getTableType(conf->tableData[i]); + if (tableType != DictTabInfo::SystemTable && + tableType != DictTabInfo::UserTable) { + jam(); + continue; + }//if + TablePtr tabPtr; + ptr.p->tables.seize(tabPtr); + if(tabPtr.i == RNIL) { + jam(); + defineBackupRef(signal, ptr, DefineBackupRef::FailedToAllocateTables); + return; + }//if + tabPtr.p->tableId = tableId; + tabPtr.p->tableType = tableType; + }//for + + if(len == ListTablesConf::DataLength) { + jam(); + /** + * Not finished... + */ + return; + }//if + + defineSlaveAbortCheck(); + + /** + * All tables fetched + */ + openFiles(signal, ptr); +} + +void +Backup::openFiles(Signal* signal, BackupRecordPtr ptr) +{ + jam(); + + BackupFilePtr filePtr; + + FsOpenReq * req = (FsOpenReq *)signal->getDataPtrSend(); + req->userReference = reference(); + req->fileFlags = + FsOpenReq::OM_WRITEONLY | + FsOpenReq::OM_TRUNCATE | + FsOpenReq::OM_CREATE | + FsOpenReq::OM_APPEND | + FsOpenReq::OM_SYNC; + FsOpenReq::v2_setCount(req->fileNumber, 0xFFFFFFFF); + + /** + * Ctl file + */ + c_backupFilePool.getPtr(filePtr, ptr.p->ctlFilePtr); + ndbrequire(filePtr.p->fileRunning == 0); + filePtr.p->fileRunning = 1; + + req->userPointer = filePtr.i; + FsOpenReq::setVersion(req->fileNumber, 2); + FsOpenReq::setSuffix(req->fileNumber, FsOpenReq::S_CTL); + FsOpenReq::v2_setSequence(req->fileNumber, ptr.p->backupId); + FsOpenReq::v2_setNodeId(req->fileNumber, getOwnNodeId()); + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, FsOpenReq::SignalLength, JBA); + + /** + * Log file + */ + c_backupFilePool.getPtr(filePtr, ptr.p->logFilePtr); + ndbrequire(filePtr.p->fileRunning == 0); + filePtr.p->fileRunning = 1; + + req->userPointer = filePtr.i; + FsOpenReq::setVersion(req->fileNumber, 2); + FsOpenReq::setSuffix(req->fileNumber, FsOpenReq::S_LOG); + FsOpenReq::v2_setSequence(req->fileNumber, ptr.p->backupId); + FsOpenReq::v2_setNodeId(req->fileNumber, getOwnNodeId()); + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, FsOpenReq::SignalLength, JBA); + + /** + * Data file + */ + c_backupFilePool.getPtr(filePtr, ptr.p->dataFilePtr); + ndbrequire(filePtr.p->fileRunning == 0); + filePtr.p->fileRunning = 1; + + req->userPointer = filePtr.i; + FsOpenReq::setVersion(req->fileNumber, 2); + FsOpenReq::setSuffix(req->fileNumber, FsOpenReq::S_DATA); + FsOpenReq::v2_setSequence(req->fileNumber, ptr.p->backupId); + FsOpenReq::v2_setNodeId(req->fileNumber, getOwnNodeId()); + FsOpenReq::v2_setCount(req->fileNumber, 0); + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, FsOpenReq::SignalLength, JBA); +} + +void +Backup::execFSOPENREF(Signal* signal) +{ + jamEntry(); + + FsRef * ref = (FsRef *)signal->getDataPtr(); + + const Uint32 userPtr = ref->userPointer; + + BackupFilePtr filePtr; + c_backupFilePool.getPtr(filePtr, userPtr); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, filePtr.p->backupPtr); + ptr.p->setErrorCode(ref->errorCode); + openFilesReply(signal, ptr, filePtr); +} + +void +Backup::execFSOPENCONF(Signal* signal) +{ + jamEntry(); + + FsConf * conf = (FsConf *)signal->getDataPtr(); + + const Uint32 userPtr = conf->userPointer; + const Uint32 filePointer = conf->filePointer; + + BackupFilePtr filePtr; + c_backupFilePool.getPtr(filePtr, userPtr); + filePtr.p->filePointer = filePointer; + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, filePtr.p->backupPtr); + + ndbrequire(filePtr.p->fileOpened == 0); + filePtr.p->fileOpened = 1; + openFilesReply(signal, ptr, filePtr); +} + +void +Backup::openFilesReply(Signal* signal, + BackupRecordPtr ptr, BackupFilePtr filePtr) +{ + jam(); + + /** + * Mark files as "opened" + */ + ndbrequire(filePtr.p->fileRunning == 1); + filePtr.p->fileRunning = 0; + + /** + * Check if all files have recived open_reply + */ + for(ptr.p->files.first(filePtr); filePtr.i!=RNIL;ptr.p->files.next(filePtr)) + { + jam(); + if(filePtr.p->fileRunning == 1) { + jam(); + return; + }//if + }//for + + defineSlaveAbortCheck(); + + /** + * Did open succeed for all files + */ + if(ptr.p->checkError()) { + jam(); + defineBackupRef(signal, ptr); + return; + }//if + + /** + * Insert file headers + */ + ptr.p->files.getPtr(filePtr, ptr.p->ctlFilePtr); + if(!insertFileHeader(BackupFormat::CTL_FILE, ptr.p, filePtr.p)) { + jam(); + defineBackupRef(signal, ptr, DefineBackupRef::FailedInsertFileHeader); + return; + }//if + + ptr.p->files.getPtr(filePtr, ptr.p->logFilePtr); + if(!insertFileHeader(BackupFormat::LOG_FILE, ptr.p, filePtr.p)) { + jam(); + defineBackupRef(signal, ptr, DefineBackupRef::FailedInsertFileHeader); + return; + }//if + + ptr.p->files.getPtr(filePtr, ptr.p->dataFilePtr); + if(!insertFileHeader(BackupFormat::DATA_FILE, ptr.p, filePtr.p)) { + jam(); + defineBackupRef(signal, ptr, DefineBackupRef::FailedInsertFileHeader); + return; + }//if + + /** + * Start CTL file thread + */ + ptr.p->files.getPtr(filePtr, ptr.p->ctlFilePtr); + filePtr.p->fileRunning = 1; + + signal->theData[0] = BackupContinueB::START_FILE_THREAD; + signal->theData[1] = ptr.p->ctlFilePtr; + sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 100, 2); + + /** + * Insert table list in ctl file + */ + FsBuffer & buf = filePtr.p->operation.dataBuffer; + + const Uint32 sz = + (sizeof(BackupFormat::CtlFile::TableList) >> 2) + + ptr.p->tables.noOfElements() - 1; + + Uint32 * dst; + ndbrequire(sz < buf.getMaxWrite()); + if(!buf.getWritePtr(&dst, sz)) { + jam(); + defineBackupRef(signal, ptr, DefineBackupRef::FailedInsertTableList); + return; + }//if + + BackupFormat::CtlFile::TableList* tl = + (BackupFormat::CtlFile::TableList*)dst; + tl->SectionType = htonl(BackupFormat::TABLE_LIST); + tl->SectionLength = htonl(sz); + + TablePtr tabPtr; + Uint32 count = 0; + for(ptr.p->tables.first(tabPtr); + tabPtr.i != RNIL; + ptr.p->tables.next(tabPtr)){ + jam(); + tl->TableIds[count] = htonl(tabPtr.p->tableId); + count++; + }//for + + buf.updateWritePtr(sz); + + /** + * Start getting table definition data + */ + ndbrequire(ptr.p->tables.first(tabPtr)); + + signal->theData[0] = BackupContinueB::BUFFER_FULL_META; + signal->theData[1] = ptr.i; + signal->theData[2] = tabPtr.i; + sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 100, 3); + return; +} + +bool +Backup::insertFileHeader(BackupFormat::FileType ft, + BackupRecord * ptrP, + BackupFile * filePtrP){ + FsBuffer & buf = filePtrP->operation.dataBuffer; + + const Uint32 sz = sizeof(BackupFormat::FileHeader) >> 2; + + Uint32 * dst; + ndbrequire(sz < buf.getMaxWrite()); + if(!buf.getWritePtr(&dst, sz)) { + jam(); + return false; + }//if + + BackupFormat::FileHeader* header = (BackupFormat::FileHeader*)dst; + ndbrequire(sizeof(header->Magic) == sizeof(BACKUP_MAGIC)); + memcpy(header->Magic, BACKUP_MAGIC, sizeof(BACKUP_MAGIC)); + header->NdbVersion = htonl(NDB_VERSION); + header->SectionType = htonl(BackupFormat::FILE_HEADER); + header->SectionLength = htonl(sz - 3); + header->FileType = htonl(ft); + header->BackupId = htonl(ptrP->backupId); + header->BackupKey_0 = htonl(ptrP->backupKey[0]); + header->BackupKey_1 = htonl(ptrP->backupKey[1]); + header->ByteOrder = 0x12345678; + + buf.updateWritePtr(sz); + return true; +} + +void +Backup::execGET_TABINFOREF(Signal* signal) +{ + GetTabInfoRef * ref = (GetTabInfoRef*)signal->getDataPtr(); + + const Uint32 senderData = ref->senderData; + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, senderData); + + defineSlaveAbortCheck(); + + defineBackupRef(signal, ptr, ref->errorCode); +} + +void +Backup::execGET_TABINFO_CONF(Signal* signal) +{ + jamEntry(); + + if(!assembleFragments(signal)) { + jam(); + return; + }//if + + GetTabInfoConf * const conf = (GetTabInfoConf*)signal->getDataPtr(); + //const Uint32 senderRef = info->senderRef; + const Uint32 len = conf->totalLen; + const Uint32 senderData = conf->senderData; + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, senderData); + + defineSlaveAbortCheck(); + + SegmentedSectionPtr dictTabInfoPtr; + signal->getSection(dictTabInfoPtr, GetTabInfoConf::DICT_TAB_INFO); + ndbrequire(dictTabInfoPtr.sz == len); + + /** + * No of pages needed + */ + const Uint32 noPages = (len + sizeof(Page32) - 1) / sizeof(Page32); + if(ptr.p->pages.getSize() < noPages) { + jam(); + ptr.p->pages.release(); + if(ptr.p->pages.seize(noPages) == false) { + jam(); + ptr.p->setErrorCode(DefineBackupRef::FailedAllocateTableMem); + ndbrequire(false); + releaseSections(signal); + defineBackupRef(signal, ptr); + return; + }//if + }//if + + BackupFilePtr filePtr; + ptr.p->files.getPtr(filePtr, ptr.p->ctlFilePtr); + FsBuffer & buf = filePtr.p->operation.dataBuffer; + { // Write into ctl file + Uint32* dst, dstLen = len + 2; + if(!buf.getWritePtr(&dst, dstLen)) { + jam(); + ndbrequire(false); + ptr.p->setErrorCode(DefineBackupRef::FailedAllocateTableMem); + releaseSections(signal); + defineBackupRef(signal, ptr); + return; + }//if + if(dst != 0) { + jam(); + + BackupFormat::CtlFile::TableDescription * desc = + (BackupFormat::CtlFile::TableDescription*)dst; + desc->SectionType = htonl(BackupFormat::TABLE_DESCRIPTION); + desc->SectionLength = htonl(len + 2); + dst += 2; + + copy(dst, dictTabInfoPtr); + buf.updateWritePtr(dstLen); + }//if + } + + ndbrequire(ptr.p->pages.getSize() >= noPages); + Page32Ptr pagePtr; + ptr.p->pages.getPtr(pagePtr, 0); + copy(&pagePtr.p->data[0], dictTabInfoPtr); + releaseSections(signal); + + if(ptr.p->checkError()) { + jam(); + defineBackupRef(signal, ptr); + return; + }//if + + TablePtr tabPtr = parseTableDescription(signal, ptr, len); + if(tabPtr.i == RNIL) { + jam(); + defineBackupRef(signal, ptr); + return; + }//if + + ptr.p->tables.next(tabPtr); + if(tabPtr.i == RNIL) { + jam(); + + ptr.p->pages.release(); + + ndbrequire(ptr.p->tables.first(tabPtr)); + signal->theData[0] = RNIL; + signal->theData[1] = tabPtr.p->tableId; + signal->theData[2] = ptr.i; + sendSignal(DBDIH_REF, GSN_DI_FCOUNTREQ, signal, 3, JBB); + return; + }//if + + signal->theData[0] = BackupContinueB::BUFFER_FULL_META; + signal->theData[1] = ptr.i; + signal->theData[2] = tabPtr.i; + sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 100, 3); + return; +} + +Backup::TablePtr +Backup::parseTableDescription(Signal* signal, BackupRecordPtr ptr, Uint32 len) +{ + + Page32Ptr pagePtr; + ptr.p->pages.getPtr(pagePtr, 0); + + SimplePropertiesLinearReader it(&pagePtr.p->data[0], len); + + it.first(); + + DictTabInfo::Table tmpTab; tmpTab.init(); + SimpleProperties::UnpackStatus stat; + stat = SimpleProperties::unpack(it, &tmpTab, + DictTabInfo::TableMapping, + DictTabInfo::TableMappingSize, + true, true); + ndbrequire(stat == SimpleProperties::Break); + + TablePtr tabPtr; + ndbrequire(findTable(ptr, tabPtr, tmpTab.TableId)); + + /** + * Initialize table object + */ + tabPtr.p->frag_mask = RNIL; + + tabPtr.p->schemaVersion = tmpTab.TableVersion; + tabPtr.p->noOfAttributes = tmpTab.NoOfAttributes; + tabPtr.p->noOfKeys = tmpTab.NoOfKeyAttr; + tabPtr.p->noOfNull = 0; + tabPtr.p->noOfVariable = 0; // Computed while iterating over attribs + tabPtr.p->sz_FixedKeys = 0; // Computed while iterating over attribs + tabPtr.p->sz_FixedAttributes = 0; // Computed while iterating over attribs + tabPtr.p->variableKeyId = RNIL; // Computed while iterating over attribs + tabPtr.p->triggerIds[0] = ILLEGAL_TRIGGER_ID; + tabPtr.p->triggerIds[1] = ILLEGAL_TRIGGER_ID; + tabPtr.p->triggerIds[2] = ILLEGAL_TRIGGER_ID; + tabPtr.p->triggerAllocated[0] = false; + tabPtr.p->triggerAllocated[1] = false; + tabPtr.p->triggerAllocated[2] = false; + + if(tabPtr.p->attributes.seize(tabPtr.p->noOfAttributes) == false) { + jam(); + ptr.p->setErrorCode(DefineBackupRef::FailedToAllocateAttributeRecord); + tabPtr.i = RNIL; + return tabPtr; + }//if + + const Uint32 count = tabPtr.p->noOfAttributes; + for(Uint32 i = 0; i> 5; + + AttributePtr attrPtr; + tabPtr.p->attributes.getPtr(attrPtr, tmp.AttributeId); + + attrPtr.p->data.nullable = tmp.AttributeNullableFlag; + attrPtr.p->data.fixed = (tmp.AttributeArraySize != 0); + attrPtr.p->data.key = tmp.AttributeKeyFlag; + attrPtr.p->data.sz32 = sz32; + + /** + * Either + * 1) Fixed + * 2) Nullable + * 3) Variable + * 4) Fixed key + * 5) Variable key + */ + if(attrPtr.p->data.key == false) { + jam(); + + if(attrPtr.p->data.fixed == true && attrPtr.p->data.nullable == false) { + jam(); + attrPtr.p->data.offset = tabPtr.p->sz_FixedAttributes; + tabPtr.p->sz_FixedAttributes += sz32; + }//if + + if(attrPtr.p->data.fixed == true && attrPtr.p->data.nullable == true) { + jam(); + attrPtr.p->data.offset = 0; + + attrPtr.p->data.offsetNull = tabPtr.p->noOfNull; + tabPtr.p->noOfNull++; + tabPtr.p->noOfVariable++; + }//if + + if(attrPtr.p->data.fixed == false) { + jam(); + tabPtr.p->noOfVariable++; + ndbrequire(0); + }//if + + } else if(attrPtr.p->data.key == true) { + jam(); + ndbrequire(attrPtr.p->data.nullable == false); + + if(attrPtr.p->data.fixed == true) { // Fixed key + jam(); + tabPtr.p->sz_FixedKeys += sz32; + }//if + + if(attrPtr.p->data.fixed == false) { // Variable key + jam(); + attrPtr.p->data.offset = 0; + tabPtr.p->noOfVariable++; + ndbrequire(tabPtr.p->variableKeyId == RNIL); // Only one variable key + tabPtr.p->variableKeyId = attrPtr.i; + ndbrequire(0); + }//if + }//if + + it.next(); // Move Past EndOfAttribute + }//for + return tabPtr; +} + +void +Backup::execDI_FCOUNTCONF(Signal* signal) +{ + jamEntry(); + + const Uint32 userPtr = signal->theData[0]; + const Uint32 fragCount = signal->theData[1]; + const Uint32 tableId = signal->theData[2]; + const Uint32 senderData = signal->theData[3]; + + ndbrequire(userPtr == RNIL && signal->length() == 5); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, senderData); + + defineSlaveAbortCheck(); + + TablePtr tabPtr; + ndbrequire(findTable(ptr, tabPtr, tableId)); + + ndbrequire(tabPtr.p->fragments.seize(fragCount) != false); + tabPtr.p->frag_mask = calculate_frag_mask(fragCount); + for(Uint32 i = 0; ifragments.getPtr(fragPtr, i); + fragPtr.p->scanned = 0; + fragPtr.p->scanning = 0; + fragPtr.p->tableId = tableId; + fragPtr.p->node = RNIL; + }//for + + /** + * Next table + */ + if(ptr.p->tables.next(tabPtr)) { + jam(); + signal->theData[0] = RNIL; + signal->theData[1] = tabPtr.p->tableId; + signal->theData[2] = ptr.i; + sendSignal(DBDIH_REF, GSN_DI_FCOUNTREQ, signal, 3, JBB); + return; + }//if + + ptr.p->tables.first(tabPtr); + getFragmentInfo(signal, ptr, tabPtr, 0); +} + +void +Backup::getFragmentInfo(Signal* signal, + BackupRecordPtr ptr, TablePtr tabPtr, Uint32 fragNo) +{ + jam(); + + for(; tabPtr.i != RNIL; ptr.p->tables.next(tabPtr)) { + jam(); + const Uint32 fragCount = tabPtr.p->fragments.getSize(); + for(; fragNo < fragCount; fragNo ++) { + jam(); + FragmentPtr fragPtr; + tabPtr.p->fragments.getPtr(fragPtr, fragNo); + + if(fragPtr.p->scanned == 0 && fragPtr.p->scanning == 0) { + jam(); + signal->theData[0] = RNIL; + signal->theData[1] = ptr.i; + signal->theData[2] = tabPtr.p->tableId; + signal->theData[3] = fragNo; + sendSignal(DBDIH_REF, GSN_DIGETPRIMREQ, signal, 4, JBB); + return; + }//if + }//for + fragNo = 0; + }//for + + getFragmentInfoDone(signal, ptr); +} + +void +Backup::execDIGETPRIMCONF(Signal* signal) +{ + jamEntry(); + + const Uint32 userPtr = signal->theData[0]; + const Uint32 senderData = signal->theData[1]; + const Uint32 nodeCount = signal->theData[6]; + const Uint32 tableId = signal->theData[7]; + const Uint32 fragNo = signal->theData[8]; + + ndbrequire(userPtr == RNIL && signal->length() == 9); + ndbrequire(nodeCount > 0 && nodeCount <= MAX_REPLICAS); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, senderData); + + defineSlaveAbortCheck(); + + TablePtr tabPtr; + ndbrequire(findTable(ptr, tabPtr, tableId)); + + FragmentPtr fragPtr; + tabPtr.p->fragments.getPtr(fragPtr, fragNo); + + fragPtr.p->node = signal->theData[2]; + + getFragmentInfo(signal, ptr, tabPtr, fragNo + 1); +} + +void +Backup::getFragmentInfoDone(Signal* signal, BackupRecordPtr ptr) +{ + // Slave must now hold on to master data until + // AbortBackupOrd::OkToClean signal + ptr.p->okToCleanMaster = false; + ptr.p->slaveState.setState(DEFINED); + DefineBackupConf * conf = (DefineBackupConf*)signal->getDataPtr(); + conf->backupPtr = ptr.i; + conf->backupId = ptr.p->backupId; + sendSignal(ptr.p->masterRef, GSN_DEFINE_BACKUP_CONF, signal, + DefineBackupConf::SignalLength, JBB); +} + + +/***************************************************************************** + * + * Slave functionallity: Start backup + * + *****************************************************************************/ +void +Backup::execSTART_BACKUP_REQ(Signal* signal) +{ + jamEntry(); + + CRASH_INSERTION((10015)); + + StartBackupReq* req = (StartBackupReq*)signal->getDataPtr(); + const Uint32 ptrI = req->backupPtr; + const Uint32 backupId = req->backupId; + const Uint32 signalNo = req->signalNo; + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + slaveAbortCheck(); // macro will do return if ABORTING + + ptr.p->slaveState.setState(STARTED); + + for(Uint32 i = 0; inoOfTableTriggers; i++) { + jam(); + TablePtr tabPtr; + ndbrequire(findTable(ptr, tabPtr, req->tableTriggers[i].tableId)); + for(Uint32 j = 0; j<3; j++) { + jam(); + const Uint32 triggerId = req->tableTriggers[i].triggerIds[j]; + tabPtr.p->triggerIds[j] = triggerId; + + TriggerPtr trigPtr; + if(!ptr.p->triggers.seizeId(trigPtr, triggerId)) { + jam(); + StartBackupRef* ref = (StartBackupRef*)signal->getDataPtrSend(); + ref->backupPtr = ptr.i; + ref->backupId = ptr.p->backupId; + ref->signalNo = signalNo; + ref->errorCode = StartBackupRef::FailedToAllocateTriggerRecord; + sendSignal(ptr.p->masterRef, GSN_START_BACKUP_REF, signal, + StartBackupRef::SignalLength, JBB); + return; + }//if + + tabPtr.p->triggerAllocated[i] = true; + trigPtr.p->backupPtr = ptr.i; + trigPtr.p->tableId = tabPtr.p->tableId; + trigPtr.p->tab_ptr_i = tabPtr.i; + trigPtr.p->logEntry = 0; + trigPtr.p->event = j; + trigPtr.p->maxRecordSize = 2048; + trigPtr.p->operation = + &ptr.p->files.getPtr(ptr.p->logFilePtr)->operation; + trigPtr.p->operation->noOfBytes = 0; + trigPtr.p->operation->noOfRecords = 0; + trigPtr.p->errorCode = 0; + }//for + }//for + + /** + * Start file threads... + */ + BackupFilePtr filePtr; + for(ptr.p->files.first(filePtr); + filePtr.i!=RNIL; + ptr.p->files.next(filePtr)){ + jam(); + if(filePtr.p->fileRunning == 0) { + jam(); + filePtr.p->fileRunning = 1; + signal->theData[0] = BackupContinueB::START_FILE_THREAD; + signal->theData[1] = filePtr.i; + sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 100, 2); + }//if + }//for + + StartBackupConf* conf = (StartBackupConf*)signal->getDataPtrSend(); + conf->backupPtr = ptr.i; + conf->backupId = ptr.p->backupId; + conf->signalNo = signalNo; + sendSignal(ptr.p->masterRef, GSN_START_BACKUP_CONF, signal, + StartBackupConf::SignalLength, JBB); +} + +/***************************************************************************** + * + * Slave functionallity: Backup fragment + * + *****************************************************************************/ +void +Backup::execBACKUP_FRAGMENT_REQ(Signal* signal) +{ + jamEntry(); + BackupFragmentReq* req = (BackupFragmentReq*)signal->getDataPtr(); + + CRASH_INSERTION((10016)); + + const Uint32 ptrI = req->backupPtr; + const Uint32 backupId = req->backupId; + const Uint32 tableId = req->tableId; + const Uint32 fragNo = req->fragmentNo; + const Uint32 count = req->count; + + /** + * Get backup record + */ + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + slaveAbortCheck(); // macro will do return if ABORTING + + ptr.p->slaveState.setState(SCANNING); + + /** + * Get file + */ + BackupFilePtr filePtr; + c_backupFilePool.getPtr(filePtr, ptr.p->dataFilePtr); + + ndbrequire(filePtr.p->backupPtr == ptrI); + ndbrequire(filePtr.p->fileOpened == 1); + ndbrequire(filePtr.p->fileRunning == 1); + ndbrequire(filePtr.p->scanRunning == 0); + ndbrequire(filePtr.p->fileDone == 0); + + /** + * Get table + */ + TablePtr tabPtr; + ndbrequire(findTable(ptr, tabPtr, tableId)); + + /** + * Get fragment + */ + FragmentPtr fragPtr; + tabPtr.p->fragments.getPtr(fragPtr, fragNo); + + ndbrequire(fragPtr.p->scanned == 0); + ndbrequire(fragPtr.p->scanning == 0 || + refToNode(ptr.p->masterRef) == getOwnNodeId()); + + /** + * Init operation + */ + if(filePtr.p->tableId != tableId) { + jam(); + filePtr.p->operation.init(tabPtr); + filePtr.p->tableId = tableId; + }//if + + /** + * Check for space in buffer + */ + if(!filePtr.p->operation.newFragment(tableId, fragNo)) { + jam(); + req->count = count + 1; + sendSignalWithDelay(BACKUP_REF, GSN_BACKUP_FRAGMENT_REQ, signal, 50, + signal->length()); + ptr.p->slaveState.setState(STARTED); + return; + }//if + + /** + * Mark things as "in use" + */ + fragPtr.p->scanning = 1; + filePtr.p->fragmentNo = fragNo; + + /** + * Start scan + */ + { + filePtr.p->scanRunning = 1; + + Table & table = * tabPtr.p; + ScanFragReq * req = (ScanFragReq *)signal->getDataPtrSend(); + const Uint32 parallelism = 16; + const Uint32 attrLen = 5 + table.noOfAttributes - table.noOfKeys; + + req->senderData = filePtr.i; + req->resultRef = reference(); + req->schemaVersion = table.schemaVersion; + req->fragmentNo = fragNo; + req->requestInfo = 0; + req->savePointId = 0; + req->tableId = table.tableId; + ScanFragReq::setConcurrency(req->requestInfo, parallelism); + ScanFragReq::setLockMode(req->requestInfo, 0); + ScanFragReq::setHoldLockFlag(req->requestInfo, 0); + ScanFragReq::setKeyinfoFlag(req->requestInfo, 1); + ScanFragReq::setAttrLen(req->requestInfo,attrLen); + req->transId1 = 0; + req->transId2 = (BACKUP << 20) + (getOwnNodeId() << 8); + + for(unsigned int i = 0; iclientOpPtr[i] = filePtr.i; + }//for + sendSignal(DBLQH_REF, GSN_SCAN_FRAGREQ, signal, 25, JBB); + + signal->theData[0] = filePtr.i; + signal->theData[1] = 0; + signal->theData[2] = (BACKUP << 20) + (getOwnNodeId() << 8); + + // Return all + signal->theData[3] = table.noOfAttributes - table.noOfKeys; + signal->theData[4] = 0; + signal->theData[5] = 0; + signal->theData[6] = 0; + signal->theData[7] = 0; + + Uint32 dataPos = 8; + for(Uint32 i = 0; idata.key != 0) { + jam(); + continue; + }//if + + AttributeHeader::init(&signal->theData[dataPos], i, 0); + dataPos++; + if(dataPos == 25) { + jam(); + sendSignal(DBLQH_REF, GSN_ATTRINFO, signal, 25, JBB); + dataPos = 3; + }//if + }//for + if(dataPos != 3) { + jam(); + sendSignal(DBLQH_REF, GSN_ATTRINFO, signal, dataPos, JBB); + }//if + } +} + +void +Backup::execSCAN_HBREP(Signal* signal) +{ + jamEntry(); +} + +void +Backup::execTRANSID_AI(Signal* signal) +{ + jamEntry(); + + const Uint32 filePtrI = signal->theData[0]; + //const Uint32 transId1 = signal->theData[1]; + //const Uint32 transId2 = signal->theData[2]; + const Uint32 dataLen = signal->length() - 3; + + BackupFilePtr filePtr; + c_backupFilePool.getPtr(filePtr, filePtrI); + + OperationRecord & op = filePtr.p->operation; + + TablePtr tabPtr; + c_tablePool.getPtr(tabPtr, op.tablePtr); + + Table & table = * tabPtr.p; + + /** + * Unpack data + */ + op.attrSzTotal += dataLen; + + Uint32 srcSz = dataLen; + const Uint32 * src = &signal->theData[3]; + + Uint32 * dst = op.dst; + Uint32 dstSz = op.attrSzLeft; + + while(srcSz > 0) { + jam(); + + if(dstSz == 0) { + jam(); + + /** + * Finished with one attribute now find next + */ + const AttributeHeader attrHead(* src); + const Uint32 attrId = attrHead.getAttributeId(); + const bool null = attrHead.isNULL(); + const Attribute::Data attr = table.attributes.getPtr(attrId)->data; + + srcSz -= attrHead.getHeaderSize(); + src += attrHead.getHeaderSize(); + + if(null) { + jam(); + ndbrequire(attr.nullable); + op.nullAttribute(attr.offsetNull); + dstSz = 0; + continue; + }//if + + dstSz = attrHead.getDataSize(); + ndbrequire(dstSz == attr.sz32); + if(attr.fixed && ! attr.nullable) { + jam(); + dst = op.newAttrib(attr.offset, dstSz); + } else if (attr.fixed && attr.nullable) { + jam(); + dst = op.newNullable(attrId, dstSz); + } else { + ndbrequire(false); + //dst = op.newVariable(attrId, attrSize); + }//if + }//if + + const Uint32 szCopy = (dstSz > srcSz) ? srcSz : dstSz; + memcpy(dst, src, (szCopy << 2)); + + srcSz -= szCopy; + dstSz -= szCopy; + src += szCopy; + dst += szCopy; + }//while + op.dst = dst; + op.attrSzLeft = dstSz; + + if(op.finished()){ + jam(); + op.newRecord(op.dst); + } +} + +void +Backup::execKEYINFO20(Signal* signal) +{ + jamEntry(); + + const Uint32 filePtrI = signal->theData[0]; + const Uint32 keyLen = signal->theData[1]; + //const Uint32 scanInfo = signal->theData[2]; + //const Uint32 transId1 = signal->theData[3]; + //const Uint32 transId2 = signal->theData[4]; + const Uint32 dataLen = signal->length() - 5; + + BackupFilePtr filePtr; + c_backupFilePool.getPtr(filePtr, filePtrI); + + OperationRecord & op = filePtr.p->operation; + + /** + * Unpack data + */ + ndbrequire(keyLen == dataLen); + const Uint32 * src = &signal->theData[5]; + const Uint32 klFixed = op.getFixedKeySize(); + ndbrequire(keyLen >= klFixed); + + Uint32 * dst = op.newKey(); + memcpy(dst, src, klFixed << 2); + + const Uint32 szLeft = (keyLen - klFixed); + if(szLeft > 0) { + jam(); + src += klFixed; + dst = op.newVariableKey(szLeft); + memcpy(dst, src, (szLeft << 2)); + ndbrequire(0); + }//if + + if(op.finished()){ + jam(); + op.newRecord(op.dst); + } +} + +void +Backup::OperationRecord::init(const TablePtr & ptr) +{ + + tablePtr = ptr.i; + noOfAttributes = (ptr.p->noOfAttributes - ptr.p->noOfKeys) + 1; + variableKeyId = ptr.p->variableKeyId; + + sz_Bitmask = (ptr.p->noOfNull + 31) >> 5; + sz_FixedKeys = ptr.p->sz_FixedKeys; + sz_FixedAttribs = ptr.p->sz_FixedAttributes; + + if(ptr.p->noOfVariable == 0) { + jam(); + maxRecordSize = 1 + sz_Bitmask + sz_FixedKeys + sz_FixedAttribs; + } else { + jam(); + maxRecordSize = + 1 + sz_Bitmask + 2048 /* Max tuple size */ + 2 * ptr.p->noOfVariable; + }//if +} + +bool +Backup::OperationRecord::newFragment(Uint32 tableId, Uint32 fragNo) +{ + Uint32 * tmp; + const Uint32 headSz = (sizeof(BackupFormat::DataFile::FragmentHeader) >> 2); + const Uint32 sz = headSz + 16 * maxRecordSize; + + ndbrequire(sz < dataBuffer.getMaxWrite()); + if(dataBuffer.getWritePtr(&tmp, sz)) { + jam(); + BackupFormat::DataFile::FragmentHeader * head = + (BackupFormat::DataFile::FragmentHeader*)tmp; + + head->SectionType = htonl(BackupFormat::FRAGMENT_HEADER); + head->SectionLength = htonl(headSz); + head->TableId = htonl(tableId); + head->FragmentNo = htonl(fragNo); + head->ChecksumType = htonl(0); + + opNoDone = opNoConf = 0; + memset(attrLen, 0, sizeof(attrLen)); + newRecord(tmp + headSz); + scanStart = tmp; + scanStop = (tmp + headSz); + + noOfRecords = 0; + noOfBytes = 0; + return true; + }//if + return false; +} + +bool +Backup::OperationRecord::fragComplete(Uint32 tableId, Uint32 fragNo) +{ + Uint32 * tmp; + const Uint32 footSz = sizeof(BackupFormat::DataFile::FragmentFooter) >> 2; + + if(dataBuffer.getWritePtr(&tmp, footSz + 1)) { + jam(); + * tmp = 0; // Finish record stream + tmp++; + BackupFormat::DataFile::FragmentFooter * foot = + (BackupFormat::DataFile::FragmentFooter*)tmp; + foot->SectionType = htonl(BackupFormat::FRAGMENT_FOOTER); + foot->SectionLength = htonl(footSz); + foot->TableId = htonl(tableId); + foot->FragmentNo = htonl(fragNo); + foot->NoOfRecords = htonl(noOfRecords); + foot->Checksum = htonl(0); + dataBuffer.updateWritePtr(footSz + 1); + return true; + }//if + return false; +} + +bool +Backup::OperationRecord::newScan() +{ + Uint32 * tmp; + ndbrequire(16 * maxRecordSize < dataBuffer.getMaxWrite()); + if(dataBuffer.getWritePtr(&tmp, 16 * maxRecordSize)) { + jam(); + opNoDone = opNoConf = 0; + memset(attrLen, 0, sizeof(attrLen)); + newRecord(tmp); + scanStart = tmp; + scanStop = tmp; + return true; + }//if + return false; +} + +bool +Backup::OperationRecord::scanConf(Uint32 noOfOps, Uint32 opLen[]) +{ + const Uint32 done = opNoDone-opNoConf; + + ndbrequire(noOfOps == done); + ndbrequire(memcmp(&attrLen[opNoConf], opLen, done << 2) == 0); + opNoConf = opNoDone; + + const Uint32 len = (scanStop - scanStart); + ndbrequire(len < dataBuffer.getMaxWrite()); + dataBuffer.updateWritePtr(len); + noOfBytes += (len << 2); + return true; +} + +void +Backup::execSCAN_FRAGREF(Signal* signal) +{ + jamEntry(); + + ScanFragRef * ref = (ScanFragRef*)signal->getDataPtr(); + + const Uint32 filePtrI = ref->senderData; + BackupFilePtr filePtr; + c_backupFilePool.getPtr(filePtr, filePtrI); + + filePtr.p->errorCode = ref->errorCode; + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, filePtr.p->backupPtr); + + abortFile(signal, ptr, filePtr); +} + +void +Backup::execSCAN_FRAGCONF(Signal* signal) +{ + jamEntry(); + + CRASH_INSERTION((10017)); + + ScanFragConf * conf = (ScanFragConf*)signal->getDataPtr(); + + const Uint32 filePtrI = conf->senderData; + BackupFilePtr filePtr; + c_backupFilePool.getPtr(filePtr, filePtrI); + + OperationRecord & op = filePtr.p->operation; + op.scanConf(conf->completedOps, conf->opReturnDataLen); + + const Uint32 completed = conf->fragmentCompleted; + if(completed != 2) { + jam(); + + checkScan(signal, filePtr); + return; + }//if + + fragmentCompleted(signal, filePtr); +} + +void +Backup::fragmentCompleted(Signal* signal, BackupFilePtr filePtr) +{ + jam(); + + if(filePtr.p->errorCode != 0){ + jam(); + abortFileHook(signal, filePtr, true); // Scan completed + return; + }//if + + OperationRecord & op = filePtr.p->operation; + if(!op.fragComplete(filePtr.p->tableId, filePtr.p->fragmentNo)) { + jam(); + signal->theData[0] = BackupContinueB::BUFFER_FULL_FRAG_COMPLETE; + signal->theData[1] = filePtr.i; + sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 50, 2); + return; + }//if + + filePtr.p->scanRunning = 0; + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, filePtr.p->backupPtr); + + BackupFragmentConf * conf = (BackupFragmentConf*)signal->getDataPtrSend(); + conf->backupId = ptr.p->backupId; + conf->backupPtr = ptr.i; + conf->tableId = filePtr.p->tableId; + conf->fragmentNo = filePtr.p->fragmentNo; + conf->noOfRecords = op.noOfRecords; + conf->noOfBytes = op.noOfBytes; + sendSignal(ptr.p->masterRef, GSN_BACKUP_FRAGMENT_CONF, signal, + BackupFragmentConf::SignalLength, JBB); + + ptr.p->slaveState.setState(STARTED); + return; +} + +void +Backup::checkScan(Signal* signal, BackupFilePtr filePtr) +{ + if(filePtr.p->errorCode != 0){ + jam(); + abortFileHook(signal, filePtr, false); // Scan not completed + return; + }//if + + OperationRecord & op = filePtr.p->operation; + if(op.newScan()) { + jam(); + + ScanFragNextReq * req = (ScanFragNextReq *)signal->getDataPtrSend(); + req->senderData = filePtr.i; + req->closeFlag = 0; + req->transId1 = 0; + req->transId2 = (BACKUP << 20) + (getOwnNodeId() << 8); + sendSignal(DBLQH_REF, GSN_SCAN_NEXTREQ, signal, + ScanFragNextReq::SignalLength, JBB); + return; + }//if + + signal->theData[0] = BackupContinueB::BUFFER_FULL_SCAN; + signal->theData[1] = filePtr.i; + sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 50, 2); +} + +void +Backup::execFSAPPENDREF(Signal* signal) +{ + jamEntry(); + + FsRef * ref = (FsRef *)signal->getDataPtr(); + + const Uint32 filePtrI = ref->userPointer; + const Uint32 errCode = ref->errorCode; + + BackupFilePtr filePtr; + c_backupFilePool.getPtr(filePtr, filePtrI); + + filePtr.p->fileRunning = 0; + filePtr.p->errorCode = errCode; + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, filePtr.p->backupPtr); + + abortFile(signal, ptr, filePtr); +} + +void +Backup::execFSAPPENDCONF(Signal* signal) +{ + jamEntry(); + + CRASH_INSERTION((10018)); + + //FsConf * conf = (FsConf*)signal->getDataPtr(); + const Uint32 filePtrI = signal->theData[0]; //conf->userPointer; + const Uint32 bytes = signal->theData[1]; //conf->bytes; + + BackupFilePtr filePtr; + c_backupFilePool.getPtr(filePtr, filePtrI); + + if (ERROR_INSERTED(10029)) { + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, filePtr.p->backupPtr); + abortFile(signal, ptr, filePtr); + }//if + + OperationRecord & op = filePtr.p->operation; + + op.dataBuffer.updateReadPtr(bytes >> 2); + + checkFile(signal, filePtr); +} + +void +Backup::checkFile(Signal* signal, BackupFilePtr filePtr) +{ + +#ifdef DEBUG_ABORT + // ndbout_c("---- check file filePtr.i = %u", filePtr.i); +#endif + + OperationRecord & op = filePtr.p->operation; + + Uint32 * tmp, sz; bool eof; + if(op.dataBuffer.getReadPtr(&tmp, &sz, &eof)) { + jam(); + + if(filePtr.p->errorCode == 0) { + jam(); + FsAppendReq * req = (FsAppendReq *)signal->getDataPtrSend(); + req->filePointer = filePtr.p->filePointer; + req->userPointer = filePtr.i; + req->userReference = reference(); + req->varIndex = 0; + req->offset = tmp - c_startOfPages; + req->size = sz; + + sendSignal(NDBFS_REF, GSN_FSAPPENDREQ, signal, + FsAppendReq::SignalLength, JBA); + return; + } else { + jam(); + if (filePtr.p->scanRunning == 1) + eof = false; + }//if + }//if + + if(!eof) { + jam(); + signal->theData[0] = BackupContinueB::BUFFER_UNDERFLOW; + signal->theData[1] = filePtr.i; + sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 50, 2); + return; + }//if + + ndbrequire(filePtr.p->fileDone == 1); + + if(sz > 0 && filePtr.p->errorCode == 0) { + jam(); + FsAppendReq * req = (FsAppendReq *)signal->getDataPtrSend(); + req->filePointer = filePtr.p->filePointer; + req->userPointer = filePtr.i; + req->userReference = reference(); + req->varIndex = 0; + req->offset = tmp - c_startOfPages; + req->size = sz; // Avrunda uppot + + sendSignal(NDBFS_REF, GSN_FSAPPENDREQ, signal, + FsAppendReq::SignalLength, JBA); + return; + }//if + + filePtr.p->fileRunning = 0; + + FsCloseReq * req = (FsCloseReq *)signal->getDataPtrSend(); + req->filePointer = filePtr.p->filePointer; + req->userPointer = filePtr.i; + req->userReference = reference(); + req->fileFlag = 0; +#ifdef DEBUG_ABORT + ndbout_c("***** FSCLOSEREQ filePtr.i = %u", filePtr.i); +#endif + sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, FsCloseReq::SignalLength, JBA); +} + +void +Backup::abortFile(Signal* signal, BackupRecordPtr ptr, BackupFilePtr filePtr) +{ + jam(); + + if(ptr.p->slaveState.getState() != ABORTING) { + /** + * Inform master of failure + */ + jam(); + ptr.p->slaveState.setState(ABORTING); + ptr.p->setErrorCode(AbortBackupOrd::FileOrScanError); + sendAbortBackupOrdSlave(signal, ptr, AbortBackupOrd::FileOrScanError); + return; + }//if + + + for(ptr.p->files.first(filePtr); + filePtr.i!=RNIL; + ptr.p->files.next(filePtr)){ + jam(); + filePtr.p->errorCode = 1; + }//for + + closeFiles(signal, ptr); +} + +void +Backup::abortFileHook(Signal* signal, BackupFilePtr filePtr, bool scanComplete) +{ + jam(); + + if(!scanComplete) { + jam(); + + ScanFragNextReq * req = (ScanFragNextReq *)signal->getDataPtrSend(); + req->senderData = filePtr.i; + req->closeFlag = 1; + req->transId1 = 0; + req->transId2 = (BACKUP << 20) + (getOwnNodeId() << 8); + sendSignal(DBLQH_REF, GSN_SCAN_NEXTREQ, signal, + ScanFragNextReq::SignalLength, JBB); + return; + }//if + + filePtr.p->scanRunning = 0; + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, filePtr.p->backupPtr); + + filePtr.i = RNIL; + abortFile(signal, ptr, filePtr); +} + +/**************************************************************************** + * + * Slave functionallity: Perform logging + * + ****************************************************************************/ +Uint32 +Backup::calculate_frag_mask(Uint32 count) +{ + Uint32 mask = 1; + while (mask < count) mask <<= 1; + mask -= 1; + return mask; +} + +void +Backup::execBACKUP_TRIG_REQ(Signal* signal) +{ + /* + TUP asks if this trigger is to be fired on this node. + */ + TriggerPtr trigPtr; + TablePtr tabPtr; + FragmentPtr fragPtr; + Uint32 trigger_id = signal->theData[0]; + Uint32 frag_id = signal->theData[1]; + Uint32 result; + + jamEntry(); + c_triggerPool.getPtr(trigPtr, trigger_id); + c_tablePool.getPtr(tabPtr, trigPtr.p->tab_ptr_i); + frag_id = frag_id & tabPtr.p->frag_mask; + /* + At the moment the fragment identity known by TUP is the + actual fragment id but with possibly an extra bit set. + This is due to that ACC splits the fragment. Thus fragment id 5 can + here be either 5 or 13. Thus masking with 2 ** n - 1 where number of + fragments <= 2 ** n will always provide a correct fragment id. + */ + tabPtr.p->fragments.getPtr(fragPtr, frag_id); + if (fragPtr.p->node != getOwnNodeId()) { + jam(); + result = ZFALSE; + } else { + jam(); + result = ZTRUE; + }//if + signal->theData[0] = result; +} + +void +Backup::execTRIG_ATTRINFO(Signal* signal) { + jamEntry(); + + CRASH_INSERTION((10019)); + + TrigAttrInfo * trg = (TrigAttrInfo*)signal->getDataPtr(); + + TriggerPtr trigPtr; + c_triggerPool.getPtr(trigPtr, trg->getTriggerId()); + ndbrequire(trigPtr.p->event != ILLEGAL_TRIGGER_ID); // Online... + + if(trigPtr.p->errorCode != 0) { + jam(); + return; + }//if + + if(trg->getAttrInfoType() == TrigAttrInfo::BEFORE_VALUES) { + jam(); + /** + * Backup is doing REDO logging and don't need before values + */ + return; + }//if + + BackupFormat::LogFile::LogEntry * logEntry = trigPtr.p->logEntry; + if(logEntry == 0) { + jam(); + Uint32 * dst; + FsBuffer & buf = trigPtr.p->operation->dataBuffer; + ndbrequire(trigPtr.p->maxRecordSize <= buf.getMaxWrite()); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, trigPtr.p->backupPtr); + if(!buf.getWritePtr(&dst, trigPtr.p->maxRecordSize)) { + jam(); + trigPtr.p->errorCode = AbortBackupOrd::LogBufferFull; + sendAbortBackupOrdSlave(signal, ptr, AbortBackupOrd::LogBufferFull); + return; + }//if + if(trigPtr.p->operation->noOfBytes > 123 && ERROR_INSERTED(10030)) { + jam(); + trigPtr.p->errorCode = AbortBackupOrd::LogBufferFull; + sendAbortBackupOrdSlave(signal, ptr, AbortBackupOrd::LogBufferFull); + return; + }//if + + logEntry = (BackupFormat::LogFile::LogEntry *)dst; + trigPtr.p->logEntry = logEntry; + logEntry->Length = 0; + logEntry->TableId = htonl(trigPtr.p->tableId); + logEntry->TriggerEvent = htonl(trigPtr.p->event); + } else { + ndbrequire(logEntry->TableId == htonl(trigPtr.p->tableId)); + ndbrequire(logEntry->TriggerEvent == htonl(trigPtr.p->event)); + }//if + + const Uint32 pos = logEntry->Length; + const Uint32 dataLen = signal->length() - TrigAttrInfo::StaticLength; + memcpy(&logEntry->Data[pos], trg->getData(), dataLen << 2); + + logEntry->Length = pos + dataLen; +} + +void +Backup::execFIRE_TRIG_ORD(Signal* signal) +{ + jamEntry(); + FireTrigOrd* trg = (FireTrigOrd*)signal->getDataPtr(); + + const Uint32 gci = trg->getGCI(); + const Uint32 trI = trg->getTriggerId(); + + TriggerPtr trigPtr; + c_triggerPool.getPtr(trigPtr, trI); + + ndbrequire(trigPtr.p->event != ILLEGAL_TRIGGER_ID); + + if(trigPtr.p->errorCode != 0) { + jam(); + return; + }//if + + ndbrequire(trigPtr.p->logEntry != 0); + Uint32 len = trigPtr.p->logEntry->Length; + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, trigPtr.p->backupPtr); + if(gci != ptr.p->currGCP) { + jam(); + + trigPtr.p->logEntry->TriggerEvent = htonl(trigPtr.p->event | 0x10000); + trigPtr.p->logEntry->Data[len] = htonl(gci); + len ++; + ptr.p->currGCP = gci; + }//if + + len += (sizeof(BackupFormat::LogFile::LogEntry) >> 2) - 2; + trigPtr.p->logEntry->Length = htonl(len); + + ndbrequire(len + 1 <= trigPtr.p->operation->dataBuffer.getMaxWrite()); + trigPtr.p->operation->dataBuffer.updateWritePtr(len + 1); + trigPtr.p->logEntry = 0; + + trigPtr.p->operation->noOfBytes += (len + 1) << 2; + trigPtr.p->operation->noOfRecords += 1; +} + +void +Backup::sendAbortBackupOrdSlave(Signal* signal, BackupRecordPtr ptr, + Uint32 requestType) +{ + jam(); + AbortBackupOrd *ord = (AbortBackupOrd*)signal->getDataPtrSend(); + ord->backupId = ptr.p->backupId; + ord->backupPtr = ptr.i; + ord->requestType = requestType; + ord->senderData= ptr.i; + sendSignal(ptr.p->masterRef, GSN_ABORT_BACKUP_ORD, signal, + AbortBackupOrd::SignalLength, JBB); +} + +void +Backup::sendAbortBackupOrd(Signal* signal, BackupRecordPtr ptr, + Uint32 requestType) +{ + jam(); + AbortBackupOrd *ord = (AbortBackupOrd*)signal->getDataPtrSend(); + ord->backupId = ptr.p->backupId; + ord->backupPtr = ptr.i; + ord->requestType = requestType; + ord->senderData= ptr.i; + NodePtr node; + for(c_nodes.first(node); node.i != RNIL; c_nodes.next(node)) { + jam(); + const Uint32 nodeId = node.p->nodeId; + if(node.p->alive && ptr.p->nodes.get(nodeId)) { + jam(); + sendSignal(numberToRef(BACKUP, nodeId), GSN_ABORT_BACKUP_ORD, signal, + AbortBackupOrd::SignalLength, JBB); + }//if + }//for +} + +/***************************************************************************** + * + * Slave functionallity: Stop backup + * + *****************************************************************************/ +void +Backup::execSTOP_BACKUP_REQ(Signal* signal) +{ + jamEntry(); + StopBackupReq * req = (StopBackupReq*)signal->getDataPtr(); + + CRASH_INSERTION((10020)); + + const Uint32 ptrI = req->backupPtr; + const Uint32 backupId = req->backupId; + const Uint32 startGCP = req->startGCP; + const Uint32 stopGCP = req->stopGCP; + + /** + * At least one GCP must have passed + */ + ndbrequire(stopGCP > startGCP); + + /** + * Get backup record + */ + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + ptr.p->slaveState.setState(STOPPING); + slaveAbortCheck(); // macro will do return if ABORTING + + /** + * Insert footers + */ + { + BackupFilePtr filePtr; + ptr.p->files.getPtr(filePtr, ptr.p->logFilePtr); + Uint32 * dst; + ndbrequire(filePtr.p->operation.dataBuffer.getWritePtr(&dst, 1)); + * dst = 0; + filePtr.p->operation.dataBuffer.updateWritePtr(1); + } + + { + BackupFilePtr filePtr; + ptr.p->files.getPtr(filePtr, ptr.p->ctlFilePtr); + + const Uint32 gcpSz = sizeof(BackupFormat::CtlFile::GCPEntry) >> 2; + + Uint32 * dst; + ndbrequire(filePtr.p->operation.dataBuffer.getWritePtr(&dst, gcpSz)); + + BackupFormat::CtlFile::GCPEntry * gcp = + (BackupFormat::CtlFile::GCPEntry*)dst; + + gcp->SectionType = htonl(BackupFormat::GCP_ENTRY); + gcp->SectionLength = htonl(gcpSz); + gcp->StartGCP = htonl(startGCP); + gcp->StopGCP = htonl(stopGCP - 1); + filePtr.p->operation.dataBuffer.updateWritePtr(gcpSz); + } + + closeFiles(signal, ptr); +} + +void +Backup::closeFiles(Signal* sig, BackupRecordPtr ptr) +{ + if (ptr.p->closingFiles) { + jam(); + return; + } + ptr.p->closingFiles = true; + + /** + * Close all files + */ + BackupFilePtr filePtr; + int openCount = 0; + for(ptr.p->files.first(filePtr); filePtr.i!=RNIL; ptr.p->files.next(filePtr)) + { + if(filePtr.p->fileOpened == 0) { + jam(); + continue; + } + + jam(); + openCount++; + + if(filePtr.p->fileDone == 1){ + jam(); + continue; + }//if + + filePtr.p->fileDone = 1; + + if(filePtr.p->fileRunning == 1){ + jam(); +#ifdef DEBUG_ABORT + ndbout_c("Close files fileRunning == 1, filePtr.i=%u", filePtr.i); +#endif + filePtr.p->operation.dataBuffer.eof(); + } else { + jam(); + + FsCloseReq * req = (FsCloseReq *)sig->getDataPtrSend(); + req->filePointer = filePtr.p->filePointer; + req->userPointer = filePtr.i; + req->userReference = reference(); + req->fileFlag = 0; +#ifdef DEBUG_ABORT + ndbout_c("***** FSCLOSEREQ filePtr.i = %u", filePtr.i); +#endif + sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, sig, + FsCloseReq::SignalLength, JBA); + }//if + }//for + + if(openCount == 0){ + jam(); + closeFilesDone(sig, ptr); + }//if +} + +void +Backup::execFSCLOSEREF(Signal* signal) +{ + jamEntry(); + + FsRef * ref = (FsRef*)signal->getDataPtr(); + const Uint32 filePtrI = ref->userPointer; + + BackupFilePtr filePtr; + c_backupFilePool.getPtr(filePtr, filePtrI); + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, filePtr.p->backupPtr); + + /** + * This should only happen during abort of backup + */ + ndbrequire(ptr.p->slaveState.getState() == ABORTING); + + filePtr.p->fileOpened = 1; + FsConf * conf = (FsConf*)signal->getDataPtr(); + conf->userPointer = filePtrI; + + execFSCLOSECONF(signal); +} + +void +Backup::execFSCLOSECONF(Signal* signal) +{ + jamEntry(); + + FsConf * conf = (FsConf*)signal->getDataPtr(); + const Uint32 filePtrI = conf->userPointer; + + BackupFilePtr filePtr; + c_backupFilePool.getPtr(filePtr, filePtrI); + +#ifdef DEBUG_ABORT + ndbout_c("***** FSCLOSECONF filePtrI = %u", filePtrI); +#endif + + ndbrequire(filePtr.p->fileDone == 1); + ndbrequire(filePtr.p->fileOpened == 1); + ndbrequire(filePtr.p->fileRunning == 0); + ndbrequire(filePtr.p->scanRunning == 0); + + filePtr.p->fileOpened = 0; + + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, filePtr.p->backupPtr); + for(ptr.p->files.first(filePtr); filePtr.i!=RNIL;ptr.p->files.next(filePtr)) + { + jam(); + if(filePtr.p->fileOpened == 1) { + jam(); +#ifdef DEBUG_ABORT + ndbout_c("waiting for more FSCLOSECONF's filePtr.i = %u", filePtr.i); +#endif + return; // we will be getting more FSCLOSECONF's + }//if + }//for + closeFilesDone(signal, ptr); +} + +void +Backup::closeFilesDone(Signal* signal, BackupRecordPtr ptr) +{ + jam(); + + if(ptr.p->slaveState.getState() == STOPPING) { + jam(); + BackupFilePtr filePtr; + ptr.p->files.getPtr(filePtr, ptr.p->logFilePtr); + + StopBackupConf* conf = (StopBackupConf*)signal->getDataPtrSend(); + conf->backupId = ptr.p->backupId; + conf->backupPtr = ptr.i; + conf->noOfLogBytes = filePtr.p->operation.noOfBytes; + conf->noOfLogRecords = filePtr.p->operation.noOfRecords; + sendSignal(ptr.p->masterRef, GSN_STOP_BACKUP_CONF, signal, + StopBackupConf::SignalLength, JBB); + + ptr.p->slaveState.setState(CLEANING); + return; + }//if + + ndbrequire(ptr.p->slaveState.getState() == ABORTING); + removeBackup(signal, ptr); +} + +/***************************************************************************** + * + * Slave functionallity: Abort backup + * + *****************************************************************************/ +void +Backup::removeBackup(Signal* signal, BackupRecordPtr ptr) +{ + jam(); + + FsRemoveReq * req = (FsRemoveReq *)signal->getDataPtrSend(); + req->userReference = reference(); + req->userPointer = ptr.i; + req->directory = 1; + req->ownDirectory = 1; + FsOpenReq::setVersion(req->fileNumber, 2); + FsOpenReq::setSuffix(req->fileNumber, FsOpenReq::S_CTL); + FsOpenReq::v2_setSequence(req->fileNumber, ptr.p->backupId); + FsOpenReq::v2_setNodeId(req->fileNumber, getOwnNodeId()); + sendSignal(NDBFS_REF, GSN_FSREMOVEREQ, signal, + FsRemoveReq::SignalLength, JBA); +} + +void +Backup::execFSREMOVEREF(Signal* signal) +{ + jamEntry(); + ndbrequire(0); +} + +void +Backup::execFSREMOVECONF(Signal* signal){ + jamEntry(); + + FsConf * conf = (FsConf*)signal->getDataPtr(); + const Uint32 ptrI = conf->userPointer; + + /** + * Get backup record + */ + BackupRecordPtr ptr; + c_backupPool.getPtr(ptr, ptrI); + + ndbrequire(ptr.p->slaveState.getState() == ABORTING); + if (ptr.p->masterRef == reference()) { + if (ptr.p->masterData.state.getAbortState() == DEFINING) { + jam(); + sendBackupRef(signal, ptr, ptr.p->errorCode); + return; + } else { + jam(); + }//if + }//if + cleanupSlaveResources(ptr); +} + +/***************************************************************************** + * + * Slave functionallity: Abort backup + * + *****************************************************************************/ +void +Backup::execABORT_BACKUP_ORD(Signal* signal) +{ + jamEntry(); + AbortBackupOrd* ord = (AbortBackupOrd*)signal->getDataPtr(); + + const Uint32 backupId = ord->backupId; + const AbortBackupOrd::RequestType requestType = + (AbortBackupOrd::RequestType)ord->requestType; + const Uint32 senderData = ord->senderData; + +#ifdef DEBUG_ABORT + ndbout_c("******** ABORT_BACKUP_ORD ********* nodeId = %u", + refToNode(signal->getSendersBlockRef())); + ndbout_c("backupId = %u, requestType = %u, senderData = %u, ", + backupId, requestType, senderData); + dumpUsedResources(); +#endif + + BackupRecordPtr ptr; + if(requestType == AbortBackupOrd::ClientAbort) { + if (getOwnNodeId() != getMasterNodeId()) { + jam(); + // forward to master +#ifdef DEBUG_ABORT + ndbout_c("---- Forward to master nodeId = %u", getMasterNodeId()); +#endif + sendSignal(calcBackupBlockRef(getMasterNodeId()), GSN_ABORT_BACKUP_ORD, + signal, AbortBackupOrd::SignalLength, JBB); + return; + } + jam(); + for(c_backups.first(ptr); ptr.i != RNIL; c_backups.next(ptr)) { + jam(); + if(ptr.p->backupId == backupId && ptr.p->clientData == senderData) { + jam(); + break; + }//if + }//for + if(ptr.i == RNIL) { + jam(); + return; + }//if + } else { + if (c_backupPool.findId(senderData)) { + jam(); + c_backupPool.getPtr(ptr, senderData); + } else { // TODO might be abort sent to not master, + // or master aborting too early + jam(); +#ifdef DEBUG_ABORT + ndbout_c("Backup: abort request type=%u on id=%u,%u not found", + requestType, backupId, senderData); +#endif + return; + } + }//if + + const bool isCoordinator = (ptr.p->masterRef == reference()); + + bool ok = false; + switch(requestType){ + + /** + * Requests sent to master + */ + + case AbortBackupOrd::ClientAbort: + jam(); + // fall through + case AbortBackupOrd::LogBufferFull: + jam(); + // fall through + case AbortBackupOrd::FileOrScanError: + jam(); + if(ptr.p->masterData.state.getState() == ABORTING) { +#ifdef DEBUG_ABORT + ndbout_c("---- Already aborting"); +#endif + jam(); + return; + } + ptr.p->setErrorCode(requestType); + ndbrequire(isCoordinator); // Sent from slave to coordinator + masterAbort(signal, ptr, false); + return; + + /** + * Info sent to slave + */ + + case AbortBackupOrd::OkToClean: + jam(); + cleanupMasterResources(ptr); + return; + + /** + * Requests sent to slave + */ + + case AbortBackupOrd::BackupComplete: + jam(); + if (ptr.p->slaveState.getState() == CLEANING) { // TODO what if state is + // not CLEANING? + jam(); + cleanupSlaveResources(ptr); + }//if + return; + break; + case AbortBackupOrd::BackupFailureDueToNodeFail: + jam(); + ok = true; + if (ptr.p->errorCode != 0) + ptr.p->setErrorCode(requestType); + break; + case AbortBackupOrd::BackupFailure: + jam(); + ok = true; + break; + } + ndbrequire(ok); + + /** + * Slave abort + */ + slaveAbort(signal, ptr); +} + +void +Backup::slaveAbort(Signal* signal, BackupRecordPtr ptr) +{ + if(ptr.p->slaveState.getState() == ABORTING) { +#ifdef DEBUG_ABORT + ndbout_c("---- Slave already aborting"); +#endif + jam(); + return; + } +#ifdef DEBUG_ABORT + ndbout_c("************* slaveAbort"); +#endif + + State slaveState = ptr.p->slaveState.getState(); + ptr.p->slaveState.setState(ABORTING); + switch(slaveState) { + case DEFINING: + jam(); + return; +//------------------------------------------ +// Will watch for the abort at various places +// in the defining phase. +//------------------------------------------ + case ABORTING: + jam(); + //Fall through + case DEFINED: + jam(); + //Fall through + case STOPPING: + jam(); + closeFiles(signal, ptr); + return; + case STARTED: + jam(); + //Fall through + case SCANNING: + jam(); + BackupFilePtr filePtr; + filePtr.i = RNIL; + abortFile(signal, ptr, filePtr); + return; + case CLEANING: + jam(); + cleanupSlaveResources(ptr); + return; + case INITIAL: + jam(); + ndbrequire(false); + return; + } +} + +void +Backup::dumpUsedResources() +{ + jam(); + BackupRecordPtr ptr; + + for(c_backups.first(ptr); ptr.i != RNIL; c_backups.next(ptr)) { + ndbout_c("Backup id=%u, slaveState.getState = %u, errorCode=%u", + ptr.p->backupId, + ptr.p->slaveState.getState(), + ptr.p->errorCode); + + TablePtr tabPtr; + for(ptr.p->tables.first(tabPtr); + tabPtr.i != RNIL; + ptr.p->tables.next(tabPtr)) { + jam(); + for(Uint32 j = 0; j<3; j++) { + jam(); + TriggerPtr trigPtr; + if(tabPtr.p->triggerAllocated[j]) { + jam(); + c_triggerPool.getPtr(trigPtr, tabPtr.p->triggerIds[j]); + ndbout_c("Allocated[%u] Triggerid = %u, event = %u", + j, + tabPtr.p->triggerIds[j], + trigPtr.p->event); + }//if + }//for + }//for + + BackupFilePtr filePtr; + for(ptr.p->files.first(filePtr); + filePtr.i != RNIL; + ptr.p->files.next(filePtr)) { + jam(); + ndbout_c("filePtr.i = %u, filePtr.p->fileOpened=%u fileRunning=%u " + "scanRunning=%u", + filePtr.i, + filePtr.p->fileOpened, + filePtr.p->fileRunning, + filePtr.p->scanRunning); + }//for + } +} + +void +Backup::cleanupMasterResources(BackupRecordPtr ptr) +{ +#ifdef DEBUG_ABORT + ndbout_c("******** Cleanup Master Resources *********"); + ndbout_c("backupId = %u, errorCode = %u", ptr.p->backupId, ptr.p->errorCode); +#endif + + TablePtr tabPtr; + for(ptr.p->tables.first(tabPtr); tabPtr.i != RNIL;ptr.p->tables.next(tabPtr)) + { + jam(); + tabPtr.p->attributes.release(); + tabPtr.p->fragments.release(); + for(Uint32 j = 0; j<3; j++) { + jam(); + TriggerPtr trigPtr; + if(tabPtr.p->triggerAllocated[j]) { + jam(); + c_triggerPool.getPtr(trigPtr, tabPtr.p->triggerIds[j]); + trigPtr.p->event = ILLEGAL_TRIGGER_ID; + tabPtr.p->triggerAllocated[j] = false; + }//if + tabPtr.p->triggerIds[j] = ILLEGAL_TRIGGER_ID; + }//for + }//for + ptr.p->tables.release(); + ptr.p->triggers.release(); + ptr.p->okToCleanMaster = true; + + cleanupFinalResources(ptr); +} + +void +Backup::cleanupSlaveResources(BackupRecordPtr ptr) +{ +#ifdef DEBUG_ABORT + ndbout_c("******** Clean Up Slave Resources*********"); + ndbout_c("backupId = %u, errorCode = %u", ptr.p->backupId, ptr.p->errorCode); +#endif + + BackupFilePtr filePtr; + for(ptr.p->files.first(filePtr); + filePtr.i != RNIL; + ptr.p->files.next(filePtr)) { + jam(); + ndbrequire(filePtr.p->fileOpened == 0); + ndbrequire(filePtr.p->fileRunning == 0); + ndbrequire(filePtr.p->scanRunning == 0); + filePtr.p->pages.release(); + }//for + ptr.p->files.release(); + + cleanupFinalResources(ptr); +} + +void +Backup::cleanupFinalResources(BackupRecordPtr ptr) +{ +#ifdef DEBUG_ABORT + ndbout_c("******** Clean Up Final Resources*********"); + ndbout_c("backupId = %u, errorCode = %u", ptr.p->backupId, ptr.p->errorCode); +#endif + + // if (!ptr.p->tables.empty() || !ptr.p->files.empty()) { + if (!ptr.p->okToCleanMaster || !ptr.p->files.empty()) { + jam(); +#ifdef DEBUG_ABORT + ndbout_c("******** Waiting to do final cleanup"); +#endif + return; + } + ptr.p->pages.release(); + ptr.p->masterData.state.setState(INITIAL); + ptr.p->slaveState.setState(INITIAL); + ptr.p->backupId = 0; + + ptr.p->closingFiles = false; + ptr.p->okToCleanMaster = true; + + c_backups.release(ptr); + // ndbrequire(false); +} diff --git a/ndb/src/kernel/blocks/backup/Backup.hpp b/ndb/src/kernel/blocks/backup/Backup.hpp new file mode 100644 index 00000000000..77669e759d3 --- /dev/null +++ b/ndb/src/kernel/blocks/backup/Backup.hpp @@ -0,0 +1,728 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef BACKUP_H +#define BACKUP_H + +#include +#include + +#include "FsBuffer.hpp" +#include "BackupFormat.hpp" + +#include +#include + +#include +#include +#include +#include + +#include + +/** + * Backup - This block manages database backup and restore + */ +class Backup : public SimulatedBlock +{ +public: + Backup(const Configuration & conf); + virtual ~Backup(); + BLOCK_DEFINES(Backup); + +protected: + + void execSTTOR(Signal* signal); + void execDUMP_STATE_ORD(Signal* signal); + void execREAD_NODESCONF(Signal* signal); + void execNODE_FAILREP(Signal* signal); + void execINCL_NODEREQ(Signal* signal); + void execCONTINUEB(Signal* signal); + + /** + * Testing + */ + void execBACKUP_REF(Signal* signal); + void execBACKUP_CONF(Signal* signal); + void execBACKUP_ABORT_REP(Signal* signal); + void execBACKUP_COMPLETE_REP(Signal* signal); + + /** + * Signals sent from master + */ + void execDEFINE_BACKUP_REQ(Signal* signal); + void execBACKUP_DATA(Signal* signal); + void execSTART_BACKUP_REQ(Signal* signal); + void execBACKUP_FRAGMENT_REQ(Signal* signal); + void execSTOP_BACKUP_REQ(Signal* signal); + void execBACKUP_STATUS_REQ(Signal* signal); + void execABORT_BACKUP_ORD(Signal* signal); + + /** + * The actual scan + */ + void execSCAN_HBREP(Signal* signal); + void execTRANSID_AI(Signal* signal); + void execKEYINFO20(Signal* signal); + void execSCAN_FRAGREF(Signal* signal); + void execSCAN_FRAGCONF(Signal* signal); + + /** + * Trigger logging + */ + void execBACKUP_TRIG_REQ(Signal* signal); + void execTRIG_ATTRINFO(Signal* signal); + void execFIRE_TRIG_ORD(Signal* signal); + + /** + * DICT signals + */ + void execLIST_TABLES_CONF(Signal* signal); + void execGET_TABINFOREF(Signal* signal); + void execGET_TABINFO_CONF(Signal* signal); + void execCREATE_TRIG_REF(Signal* signal); + void execCREATE_TRIG_CONF(Signal* signal); + void execALTER_TRIG_REF(Signal* signal); + void execALTER_TRIG_CONF(Signal* signal); + void execDROP_TRIG_REF(Signal* signal); + void execDROP_TRIG_CONF(Signal* signal); + + /** + * DIH signals + */ + void execDI_FCOUNTCONF(Signal* signal); + void execDIGETPRIMCONF(Signal* signal); + + /** + * FS signals + */ + void execFSOPENREF(Signal* signal); + void execFSOPENCONF(Signal* signal); + + void execFSCLOSEREF(Signal* signal); + void execFSCLOSECONF(Signal* signal); + + void execFSAPPENDREF(Signal* signal); + void execFSAPPENDCONF(Signal* signal); + + void execFSREMOVEREF(Signal* signal); + void execFSREMOVECONF(Signal* signal); + + /** + * Master functinallity + */ + void execBACKUP_REQ(Signal* signal); + void execABORT_BACKUP_REQ(Signal* signal); + + void execDEFINE_BACKUP_REF(Signal* signal); + void execDEFINE_BACKUP_CONF(Signal* signal); + + void execSTART_BACKUP_REF(Signal* signal); + void execSTART_BACKUP_CONF(Signal* signal); + + void execBACKUP_FRAGMENT_REF(Signal* signal); + void execBACKUP_FRAGMENT_CONF(Signal* signal); + + void execSTOP_BACKUP_REF(Signal* signal); + void execSTOP_BACKUP_CONF(Signal* signal); + + void execBACKUP_STATUS_CONF(Signal* signal); + + void execUTIL_SEQUENCE_REF(Signal* signal); + void execUTIL_SEQUENCE_CONF(Signal* signal); + + void execWAIT_GCP_REF(Signal* signal); + void execWAIT_GCP_CONF(Signal* signal); + + +private: + void defineBackupMutex_locked(Signal* signal, Uint32 ptrI,Uint32 retVal); + void dictCommitTableMutex_locked(Signal* signal, Uint32 ptrI,Uint32 retVal); + +public: + struct Node { + Uint32 nodeId; + Uint32 alive; + Uint32 nextList; + union { Uint32 prevList; Uint32 nextPool; }; + }; + typedef Ptr NodePtr; + +#define BACKUP_WORDS_PER_PAGE 8191 + struct Page32 { + Uint32 data[BACKUP_WORDS_PER_PAGE]; + Uint32 nextPool; + }; + typedef Ptr Page32Ptr; + + struct Attribute { + struct Data { + Uint8 nullable; + Uint8 fixed; + Uint8 key; + Uint8 unused; + Uint32 sz32; // No of 32 bit words + Uint32 offset; // Relative DataFixedAttributes/DataFixedKeys + Uint32 offsetNull; // In NullBitmask + } data; + Uint32 nextPool; + }; + typedef Ptr AttributePtr; + + struct Fragment { + Uint32 tableId; + Uint32 node; + Uint16 scanned; // 0 = not scanned x = scanned by node x + Uint16 scanning; // 0 = not scanning x = scanning on node x + Uint32 nextPool; + }; + typedef Ptr FragmentPtr; + + struct Table { + Table(ArrayPool &, ArrayPool &); + + Uint32 tableId; + Uint32 schemaVersion; + Uint32 frag_mask; + Uint32 tableType; + Uint32 noOfNull; + Uint32 noOfKeys; + Uint32 noOfAttributes; + Uint32 noOfVariable; + Uint32 sz_FixedKeys; + Uint32 sz_FixedAttributes; + Uint32 variableKeyId; + Uint32 triggerIds[3]; + bool triggerAllocated[3]; + + Array attributes; + Array fragments; + + Uint32 nextList; + union { Uint32 nextPool; Uint32 prevList; }; + }; + typedef Ptr TablePtr; + + struct OperationRecord { + public: + OperationRecord(Backup & b) : backup(b) {} + + /** + * Once per table + */ + void init(const TablePtr & ptr); + inline Uint32 getFixedKeySize() const { return sz_FixedKeys; } + + /** + * Once per fragment + */ + bool newFragment(Uint32 tableId, Uint32 fragNo); + bool fragComplete(Uint32 tableId, Uint32 fragNo); + + /** + * Once per scan frag (next) req/conf + */ + bool newScan(); + bool scanConf(Uint32 noOfOps, Uint32 opLen[]); + + /** + * Per record + */ + void newRecord(Uint32 * base); + bool finished(); + + /** + * Per attribute + */ + Uint32 * newKey(); + void nullAttribute(Uint32 nullOffset); + Uint32 * newNullable(Uint32 attrId, Uint32 sz); + Uint32 * newAttrib(Uint32 offset, Uint32 sz); + Uint32 * newVariable(Uint32 id, Uint32 sz); + Uint32 * newVariableKey(Uint32 sz); + + private: + Uint32* base; + Uint32* dst_Length; + Uint32* dst_Bitmask; + Uint32* dst_FixedKeys; + Uint32* dst_FixedAttribs; + BackupFormat::DataFile::VariableData* dst_VariableData; + + Uint32 noOfAttributes; // No of Attributes + Uint32 variableKeyId; // Id of variable key + Uint32 attrLeft; // No of attributes left + + Uint32 opNoDone; + Uint32 opNoConf; + Uint32 attrLen[16]; + + public: + Uint32* dst; + Uint32 attrSzLeft; // No of words missing for current attribute + Uint32 attrSzTotal; // No of AI words received + Uint32 tablePtr; // Ptr.i to current table + + FsBuffer dataBuffer; + Uint32 noOfRecords; + Uint32 noOfBytes; + Uint32 maxRecordSize; + + private: + Uint32* scanStart; + Uint32* scanStop; + + /** + * sizes of part + */ + Uint32 sz_Bitmask; + Uint32 sz_FixedKeys; + Uint32 sz_FixedAttribs; + + public: + union { Uint32 nextPool; Uint32 nextList; }; + Uint32 prevList; + private: + + Backup & backup; + BlockNumber number() const { return backup.number(); } + void progError(int line, int cause, const char * extra) { + backup.progError(line, cause, extra); + } + }; + friend struct OperationRecord; + + struct TriggerRecord { + TriggerRecord() { event = ~0;} + OperationRecord * operation; + BackupFormat::LogFile::LogEntry * logEntry; + Uint32 maxRecordSize; + Uint32 tableId; + Uint32 tab_ptr_i; + Uint32 event; + Uint32 backupPtr; + Uint32 errorCode; + union { Uint32 nextPool; Uint32 nextList; }; + }; + typedef Ptr TriggerPtr; + + /** + * BackupFile - At least 3 per backup + */ + struct BackupFile { + BackupFile(Backup & backup, ArrayPool & pp) + : operation(backup), pages(pp) {} + + Uint32 backupPtr; // Pointer to backup record + Uint32 tableId; + Uint32 fragmentNo; + Uint32 filePointer; + Uint32 errorCode; + BackupFormat::FileType fileType; + OperationRecord operation; + + Array pages; + Uint32 nextList; + union { Uint32 prevList; Uint32 nextPool; }; + + Uint8 fileOpened; + Uint8 fileRunning; + Uint8 fileDone; + Uint8 scanRunning; + }; + typedef Ptr BackupFilePtr; + + + /** + * State for BackupRecord + */ + enum State { + INITIAL, + DEFINING, // Defining backup content and parameters + DEFINED, // DEFINE_BACKUP_CONF sent in slave, received all in master + STARTED, // Creating triggers + SCANNING, // Scanning fragments + STOPPING, // Closing files + CLEANING, // Cleaning resources + ABORTING // Aborting backup + }; + + static const Uint32 validSlaveTransitionsCount; + static const Uint32 validMasterTransitionsCount; + static const State validSlaveTransitions[]; + static const State validMasterTransitions[]; + + class CompoundState { + public: + CompoundState(Backup & b, + const State valid[], + Uint32 count, Uint32 _id) + : backup(b) + , validTransitions(valid), + noOfValidTransitions(count), id(_id) + { + state = INITIAL; + abortState = state; + } + + void setState(State s); + State getState() const { return state;} + State getAbortState() const { return abortState;} + + void forceState(State s); + + BlockNumber number() const { return backup.number(); } + void progError(int line, int cause, const char * extra) { + backup.progError(line, cause, extra); + } + private: + Backup & backup; + State state; + State abortState; /** + When state == ABORTING, this contains the state + when the abort started + */ + const State * validTransitions; + const Uint32 noOfValidTransitions; + const Uint32 id; + }; + friend class CompoundState; + + /** + * Backup record + * + * One record per backup + */ + struct BackupRecord { + BackupRecord(Backup& b, ArrayPool & pp, + ArrayPool
    & tp, + ArrayPool & bp, + ArrayPool & trp) + : slaveState(b, validSlaveTransitions, validSlaveTransitionsCount,1) + , tables(tp), triggers(trp), files(bp), pages(pp) + , masterData(b, validMasterTransitions, validMasterTransitionsCount) + , backup(b) + { + closingFiles = false; + okToCleanMaster = true; + } + + CompoundState slaveState; + + Uint32 clientRef; + Uint32 clientData; + Uint32 backupId; + Uint32 backupKey[2]; + Uint32 masterRef; + Uint32 errorCode; + NdbNodeBitmask nodes; + + bool okToCleanMaster; + bool closingFiles; + + Uint64 noOfBytes; + Uint64 noOfRecords; + Uint64 noOfLogBytes; + Uint64 noOfLogRecords; + + Uint32 startGCP; + Uint32 currGCP; + Uint32 stopGCP; + SLList
    tables; + SLList triggers; + + SLList files; + Uint32 ctlFilePtr; // Ptr.i to ctl-file + Uint32 logFilePtr; // Ptr.i to log-file + Uint32 dataFilePtr; // Ptr.i to first data-file + + Uint32 backupDataLen; // Used for (un)packing backup request + Array pages; // Used for (un)packing backup request + SimpleProperties props;// Used for (un)packing backup request + + struct MasterData { + MasterData(Backup & b, const State valid[], Uint32 count) + : state(b, valid, count, 0) + { + } + MutexHandle2 m_defineBackupMutex; + MutexHandle2 m_dictCommitTableMutex; + + Uint32 gsn; + CompoundState state; + SignalCounter sendCounter; + Uint32 errorCode; + struct { + Uint32 tableId; + } createTrig; + struct { + Uint32 tableId; + } dropTrig; + struct { + Uint32 tableId; + } alterTrig; + union { + struct { + Uint32 startBackup; + } waitGCP; + struct { + Uint32 signalNo; + Uint32 noOfSignals; + Uint32 tablePtr; + } startBackup; + struct { + Uint32 dummy; + } stopBackup; + }; + } masterData; + + Uint32 nextList; + union { Uint32 prevList; Uint32 nextPool; }; + + void setErrorCode(Uint32 errCode){ + if(errorCode == 0) + errorCode = errCode; + } + + bool checkError() const { + return errorCode != 0; + } + + Backup & backup; + BlockNumber number() const { return backup.number(); } + void progError(int line, int cause, const char * extra) { + backup.progError(line, cause, extra); + } + }; + friend struct BackupRecord; + typedef Ptr BackupRecordPtr; + + struct Config { + Uint32 m_dataBufferSize; + Uint32 m_logBufferSize; + Uint32 m_minWriteSize; + Uint32 m_maxWriteSize; + }; + + /** + * Variables + */ + Uint32 * c_startOfPages; + NodeId c_masterNodeId; + SLList c_nodes; + NdbNodeBitmask c_aliveNodes; + DLList c_backups; + Config c_defaults; + + STATIC_CONST(NO_OF_PAGES_META_FILE = 2); + + /** + * Pools + */ + ArrayPool
    c_tablePool; + ArrayPool c_attributePool; + ArrayPool c_backupPool; + ArrayPool c_backupFilePool; + ArrayPool c_pagePool; + ArrayPool c_fragmentPool; + ArrayPool c_nodePool; + ArrayPool c_triggerPool; + + Uint32 calculate_frag_mask(Uint32); + + void checkFile(Signal*, BackupFilePtr); + void checkScan(Signal*, BackupFilePtr); + void fragmentCompleted(Signal*, BackupFilePtr); + + void backupAllData(Signal* signal, BackupRecordPtr); + + void getFragmentInfo(Signal*, BackupRecordPtr, TablePtr, Uint32 fragNo); + void getFragmentInfoDone(Signal*, BackupRecordPtr); + + void openFiles(Signal* signal, BackupRecordPtr ptr); + void openFilesReply(Signal*, BackupRecordPtr ptr, BackupFilePtr); + void closeFiles(Signal*, BackupRecordPtr ptr); + void closeFilesDone(Signal*, BackupRecordPtr ptr); + + void sendDefineBackupReq(Signal *signal, BackupRecordPtr ptr); + + void defineBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId); + void createTrigReply(Signal* signal, BackupRecordPtr ptr); + void alterTrigReply(Signal* signal, BackupRecordPtr ptr); + void startBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32, Uint32); + void stopBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId); + + void defineBackupRef(Signal*, BackupRecordPtr, Uint32 errCode = 0); + + void nextFragment(Signal*, BackupRecordPtr); + + void sendCreateTrig(Signal*, BackupRecordPtr ptr, TablePtr tabPtr); + void createAttributeMask(TablePtr tab, Bitmask&); + void sendStartBackup(Signal*, BackupRecordPtr, TablePtr); + void sendAlterTrig(Signal*, BackupRecordPtr ptr); + + void sendDropTrig(Signal*, BackupRecordPtr ptr); + void sendDropTrig(Signal* signal, BackupRecordPtr ptr, TablePtr tabPtr); + void dropTrigReply(Signal*, BackupRecordPtr ptr); + + void sendSignalAllWait(BackupRecordPtr ptr, Uint32 gsn, Signal *signal, + Uint32 signalLength, + bool executeDirect = false); + bool haveAllSignals(BackupRecordPtr ptr, Uint32 gsn, Uint32 nodeId); + + void sendStopBackup(Signal*, BackupRecordPtr ptr); + void sendAbortBackupOrd(Signal* signal, BackupRecordPtr ptr, Uint32 errCode); + void sendAbortBackupOrdSlave(Signal* signal, BackupRecordPtr ptr, + Uint32 errCode); + void masterAbort(Signal*, BackupRecordPtr ptr, bool controlledAbort); + void masterSendAbortBackup(Signal*, BackupRecordPtr ptr); + void slaveAbort(Signal*, BackupRecordPtr ptr); + + void abortFile(Signal* signal, BackupRecordPtr ptr, BackupFilePtr filePtr); + void abortFileHook(Signal* signal, BackupFilePtr filePtr, bool scanDone); + + bool verifyNodesAlive(const NdbNodeBitmask& aNodeBitMask); + bool checkAbort(BackupRecordPtr ptr); + void checkNodeFail(Signal* signal, + BackupRecordPtr ptr, + NodeId newCoord, + Uint32 theFailedNodes[NodeBitmask::Size]); + void masterTakeOver(Signal* signal, BackupRecordPtr ptr); + + + NodeId getMasterNodeId() const { return c_masterNodeId; } + bool findTable(const BackupRecordPtr &, TablePtr &, Uint32 tableId) const; + TablePtr parseTableDescription(Signal*, BackupRecordPtr ptr, Uint32 len); + + bool insertFileHeader(BackupFormat::FileType, BackupRecord*, BackupFile*); + void sendBackupRef(Signal* signal, BackupRecordPtr ptr, Uint32 errorCode); + void sendBackupRef(BlockReference ref, Signal *signal, + Uint32 senderData, Uint32 errorCode); + void dumpUsedResources(); + void cleanupMasterResources(BackupRecordPtr ptr); + void cleanupSlaveResources(BackupRecordPtr ptr); + void cleanupFinalResources(BackupRecordPtr ptr); + void removeBackup(Signal*, BackupRecordPtr ptr); + + void sendSTTORRY(Signal*); + void createSequence(Signal* signal); + void createSequenceReply(Signal*, class UtilSequenceConf *); +}; + +inline +void +Backup::OperationRecord::newRecord(Uint32 * p){ + base = p; + dst_Length = p; p += 1; + dst_Bitmask = p; p += sz_Bitmask; + dst_FixedKeys = p; p += sz_FixedKeys; + dst_FixedAttribs = p; p += sz_FixedAttribs; + dst_VariableData = (BackupFormat::DataFile::VariableData*)p; + BitmaskImpl::clear(sz_Bitmask, dst_Bitmask); + attrLeft = noOfAttributes; + attrSzLeft = attrSzTotal = 0; +} + +inline +Uint32 * +Backup::OperationRecord::newAttrib(Uint32 offset, Uint32 sz){ + attrLeft--; + attrSzLeft = sz; + dst = dst_FixedAttribs + offset; + return dst; +} + +inline +Uint32 * +Backup::OperationRecord::newKey(){ + attrLeft --; + attrSzLeft = 0; + return dst_FixedKeys; +} + +inline +void +Backup::OperationRecord::nullAttribute(Uint32 offsetNull){ + attrLeft --; + BitmaskImpl::set(sz_Bitmask, dst_Bitmask, offsetNull); +} + +inline +Uint32 * +Backup::OperationRecord::newNullable(Uint32 id, Uint32 sz){ + attrLeft--; + attrSzLeft = sz; + + dst = &dst_VariableData->Data[0]; + dst_VariableData->Sz = htonl(sz); + dst_VariableData->Id = htonl(id); + + dst_VariableData = (BackupFormat::DataFile::VariableData *)(dst + sz); + + // Clear all bits on newRecord -> dont need to clear this + // BitmaskImpl::clear(sz_Bitmask, dst_Bitmask, offsetNull); + return dst; +} + +inline +Uint32 * +Backup::OperationRecord::newVariable(Uint32 id, Uint32 sz){ + attrLeft--; + attrSzLeft = sz; + + dst = &dst_VariableData->Data[0]; + dst_VariableData->Sz = htonl(sz); + dst_VariableData->Id = htonl(id); + + dst_VariableData = (BackupFormat::DataFile::VariableData *)(dst + sz); + return dst; +} + +inline +Uint32 * +Backup::OperationRecord::newVariableKey(Uint32 sz){ + attrLeft--; + attrSzLeft = 0; + + dst = &dst_VariableData->Data[0]; + dst_VariableData->Sz = htonl(sz); + dst_VariableData->Id = htonl(variableKeyId); + + dst_VariableData = (BackupFormat::DataFile::VariableData *)(dst + sz); + return dst; +} + +inline +bool +Backup::OperationRecord::finished(){ + if(attrLeft != 0 || attrSzLeft != 0){ + return false; + } + + attrLen[opNoDone] = attrSzTotal; + opNoDone++; + + scanStop = dst = (Uint32 *)dst_VariableData; + + const Uint32 len = (dst - base - 1); + * dst_Length = htonl(len); + + noOfRecords++; + + return true; +} + +#endif diff --git a/ndb/src/kernel/blocks/backup/Backup.txt b/ndb/src/kernel/blocks/backup/Backup.txt new file mode 100644 index 00000000000..ee5e02bb549 --- /dev/null +++ b/ndb/src/kernel/blocks/backup/Backup.txt @@ -0,0 +1,343 @@ +-- BACKUP SIGNAL DIAGRAM COMPLEMENT TO BACKUP AMENDMENTS 2003-07-11 -- + +USER MASTER MASTER SLAVE SLAVE +--------------------------------------------------------------------- +BACKUP_REQ +----------------> + UTIL_SEQUENCE + ---------------> + <--------------- + DEFINE_BACKUP + ------------------------------> (Local signals) + LIST_TABLES + ---------------> + <--------------- + FSOPEN + ---------------> + GET_TABINFO + <--------------- + DI_FCOUNT + ---------------> + <--------------- + DI_GETPRIM + ---------------> + <--------------- + <------------------------------- +BACKUP_CONF +<---------------- + CREATE_TRIG + --------------> (If master crashes here -> rouge triggers/memory leak) + <-------------- + START_BACKUP + ------------------------------> + <------------------------------ + ALTER_TRIG + --------------> + <-------------- + WAIT_GCP + --------------> + <-------------- + BACKUP_FRAGMENT + ------------------------------> + SCAN_FRAG + ---------------> + <--------------- + <------------------------------ + WAIT_GCP + --------------> + <-------------- + DROP_TRIG + --------------> + <-------------- + STOP_BACKUP + ------------------------------> + <------------------------------ +BACKUP_COMPLETE_REP +<---------------- + ABORT_BACKUP + ------------------------------> + +---------------------------------------------------------------------------- + +USER BACKUP-MASTER + +1) BACKUP_REQ --> + +2) To all slaves DEFINE_BACKUP_REQ + This signals contains info so that all + slaves can take over as master + Tomas: Except triggerId info... + +3) Wait for conf + +4) <-- BACKUP_CONF + +5) For Each Table + PREP_CREATE_TRIG_REQ + Wait for Conf + +6) To all slaves START_BACKUP_REQ + Include trigger ids + Wait for conf + +7) For Each Table + CREATE_TRIG_REQ + Wait for conf + +8) Wait for GCP + +9) For each table + For each fragment + BACKUP_FRAGMENT_REQ --> + <-- BACKUP_FRAGMENT_CONF + +10) Wait for GCP + +11) To all slaves STOP_BACKUP_REQ + This signal turns off logging + +12) Wait for conf + +13) <-- BACKUP_COMPLETE_REP + +---- + +Slave: Master Died +Wait for master take-over, max 30 sec then abort everything + +Slave: Master TakeOver + +BACKUP_STATUS_REQ --> To all nodes +<-- BACKUP_STATUS_CONF + +BACKUP_STATUS_CONF + BACKUP_DEFINED + BACKUP_STARTED + BACKUP_FRAGMENT + +Master: Slave died + +-- Define Backup Req -- + +1) Get backup definition + Which tables (all) + +2) Open files + Write table list to CTL - file + +3) Get definitions for all tables in backup + +4) Get Fragment info + +5) Define Backup Conf + +-- Define Backup Req -- + +-- Abort Backup Req -- + +1) Report to others + +2) Stop logging +3) Stop file(s) +4) Stop scan + +5) If failure/abort + Remove files + +6) If XXX + Report to user +7) Clean up records/stuff + +-- Abort Backup -- + +Reasons for aborting: + +1a) client abort + +1b) slave failure + +1c) node failure + +Resources to be cleaned up: + +Slave responsability: + +2a) Close and remove files + +2b) Free allocated resources + +Master responsability: + +2c) Drop triggers + +USER MASTER MASTER SLAVE SLAVE +--------------------------------------------------------------------- + BACKUP_ABORT_ORD: + -------------------------(ALL)--> + Set Master State ABORTING Set Slave State ABORTING + Drop Triggers Close and Remove files + CleanupSlaveResources() + + BACKUP_ABORT_ORD:OkToClean + -------------------------(ALL)--> + + + CleanupMasterResources() + +BACKUP_ABORT_REP +<--------------- + + + +State descriptions: + +Master - INITIAL +BACKUP_REQ -> +Master - DEFINING +DEFINE_BACKUP_CONF -> +Master - DEFINED +CREATE_TRIG_CONF -> +Master - STARTED +<---> +Master - SCANNING +WAIT_GCP_CONF -> +Master - STOPPING +(Master - CLEANING) +-------- +Master - ABORTING + + +Slave - INITIAL +DEFINE_BACKUP_REQ -> +Slave - DEFINING + - backupId + - tables +DIGETPRIMCONF -> +Slave - DEFINED +START_BACKUP_REQ -> +Slave - STARTED +Slave - SCANNING +STOP_BACKUP_REQ -> +Slave - STOPPING +FSCLOSECONF -> +Slave - CLEANING +----- +Slave - ABORTING + + + +Testcases: + +2. Master failure at first START_BACKUP_CONF + + error 10004 +start backup + +- Ok + +2. Master failure at first CREATE_TRIG_CONF + + error 10003 +start backup + +- Ok + +2. Master failure at first ALTER_TRIG_CONF + + error 10005 +start backup + +- Ok + +2. Master failure at WAIT_GCP_CONF + + error 10007 +start backup + +- Ok + +2. Master failure at WAIT_GCP_CONF, nextFragment + + error 10008 +start backup + +- Ok + +2. Master failure at WAIT_GCP_CONF, stopping + + error 10009 +start backup + +- Ok + +2. Master failure at BACKUP_FRAGMENT_CONF + + error 10010 +start backup + +- Ok + +2. Master failure at first DROP_TRIG_CONF + + error 10012 +start backup + +- Ok + +1. Master failure at first STOP_BACKUP_CONF + + error 10013 +start backup + +- Ok + +3. Multiple node failiure: + + error 10001 + error 10014 +start backup + +- Ok (note, mgmtsrvr does gets BACKUP_ABORT_REP but expects BACKUP_REF, hangs...) + +4. Multiple node failiure: + + error 10007 + error 10002 +start backup + +- Ok + + + + ndbrequire(!ERROR_INSERTED(10001)); + ndbrequire(!ERROR_INSERTED(10002)); + ndbrequire(!ERROR_INSERTED(10021)); + ndbrequire(!ERROR_INSERTED(10003)); + ndbrequire(!ERROR_INSERTED(10004)); + ndbrequire(!ERROR_INSERTED(10005)); + ndbrequire(!ERROR_INSERTED(10006)); + ndbrequire(!ERROR_INSERTED(10007)); + ndbrequire(!ERROR_INSERTED(10008)); + ndbrequire(!ERROR_INSERTED(10009)); + ndbrequire(!ERROR_INSERTED(10010)); + ndbrequire(!ERROR_INSERTED(10011)); + ndbrequire(!ERROR_INSERTED(10012)); + ndbrequire(!ERROR_INSERTED(10013)); + ndbrequire(!ERROR_INSERTED(10014)); + ndbrequire(!ERROR_INSERTED(10015)); + ndbrequire(!ERROR_INSERTED(10016)); + ndbrequire(!ERROR_INSERTED(10017)); + ndbrequire(!ERROR_INSERTED(10018)); + ndbrequire(!ERROR_INSERTED(10019)); + ndbrequire(!ERROR_INSERTED(10020)); + + if (ERROR_INSERTED(10023)) { + if (ERROR_INSERTED(10023)) { + if (ERROR_INSERTED(10024)) { + if (ERROR_INSERTED(10025)) { + if (ERROR_INSERTED(10026)) { + if (ERROR_INSERTED(10028)) { + if (ERROR_INSERTED(10027)) { + (ERROR_INSERTED(10022))) { + if (ERROR_INSERTED(10029)) { + if(trigPtr.p->operation->noOfBytes > 123 && ERROR_INSERTED(10030)) { diff --git a/ndb/src/kernel/blocks/backup/BackupFormat.hpp b/ndb/src/kernel/blocks/backup/BackupFormat.hpp new file mode 100644 index 00000000000..65dd2ad9053 --- /dev/null +++ b/ndb/src/kernel/blocks/backup/BackupFormat.hpp @@ -0,0 +1,149 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef BACKUP_FORMAT_HPP +#define BACKUP_FORMAT_HPP + +#include + +static const char BACKUP_MAGIC[] = { 'N', 'D', 'B', 'B', 'C', 'K', 'U', 'P' }; + +struct BackupFormat { + + /** + * Section types in file + */ + enum SectionType { + FILE_HEADER = 1, + FRAGMENT_HEADER = 2, + FRAGMENT_FOOTER = 3, + TABLE_LIST = 4, + TABLE_DESCRIPTION = 5, + GCP_ENTRY = 6 + }; + + struct FileHeader { + char Magic[8]; + Uint32 NdbVersion; + + Uint32 SectionType; + Uint32 SectionLength; + Uint32 FileType; + Uint32 BackupId; + Uint32 BackupKey_0; + Uint32 BackupKey_1; + Uint32 ByteOrder; + }; + + /** + * File types + */ + enum FileType { + CTL_FILE = 1, + LOG_FILE = 2, + DATA_FILE = 3 + }; + + /** + * Data file formats + */ + struct DataFile { + + struct FragmentHeader { + Uint32 SectionType; + Uint32 SectionLength; + Uint32 TableId; + Uint32 FragmentNo; + Uint32 ChecksumType; + }; + + struct VariableData { + Uint32 Sz; + Uint32 Id; + Uint32 Data[1]; + }; + + struct Record { + Uint32 Length; + Uint32 NullBitmask[1]; + Uint32 DataFixedKeys[1]; + Uint32 DataFixedAttributes[1]; + VariableData DataVariableAttributes[1]; + }; + + struct FragmentFooter { + Uint32 SectionType; + Uint32 SectionLength; + Uint32 TableId; + Uint32 FragmentNo; + Uint32 NoOfRecords; + Uint32 Checksum; + }; + }; + + /** + * CTL file formats + */ + struct CtlFile { + + /** + * Table list + */ + struct TableList { + Uint32 SectionType; + Uint32 SectionLength; + Uint32 TableIds[1]; // Length = SectionLength - 2 + }; + + /** + * Table description(s) + */ + struct TableDescription { + Uint32 SectionType; + Uint32 SectionLength; + Uint32 DictTabInfo[1]; // Length = SectionLength - 2 + }; + + /** + * GCP Entry + */ + struct GCPEntry { + Uint32 SectionType; + Uint32 SectionLength; + Uint32 StartGCP; + Uint32 StopGCP; + }; + }; + + /** + * LOG file format + */ + struct LogFile { + + /** + * Log Entry + */ + struct LogEntry { + Uint32 Length; + Uint32 TableId; + // If TriggerEvent & 0x10000 == true then GCI is right after data + Uint32 TriggerEvent; + Uint32 Data[1]; // Len = Length - 2 + }; + }; +}; + +#endif diff --git a/ndb/src/kernel/blocks/backup/BackupInit.cpp b/ndb/src/kernel/blocks/backup/BackupInit.cpp new file mode 100644 index 00000000000..1997e560bb9 --- /dev/null +++ b/ndb/src/kernel/blocks/backup/BackupInit.cpp @@ -0,0 +1,215 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +//**************************************************************************** +// +// NAME +// Backup - Database backup / restore +// +//=========================================================================== +#include "Backup.hpp" + +#include +#include +#include + +//extern const unsigned Ndbcntr::g_sysTableCount; + +Backup::Backup(const Configuration & conf) : + SimulatedBlock(BACKUP, conf), + c_nodes(c_nodePool), + c_backups(c_backupPool) +{ + BLOCK_CONSTRUCTOR(Backup); + + c_nodePool.setSize(MAX_NDB_NODES); + c_masterNodeId = getOwnNodeId(); + + const Properties * p = conf.getOwnProperties(); + ndbrequire(p != 0); + + Uint32 noBackups = 0, noTables = 0, noAttribs = 0; + p->get("ParallelBackups", &noBackups); + ndbrequire(p->get("MaxNoOfTables", &noTables)); + ndbrequire(p->get("MaxNoOfAttributes", &noAttribs)); + + // To allow for user tables AND SYSTAB + // See ClusterConfig + //TODO get this infor from NdbCntr + noTables += 2; + + // Considering also TR527, this is a KISS work-around to be able to + // continue testing the real thing + noAttribs += 2 + 1; + + c_backupPool.setSize(noBackups); + c_backupFilePool.setSize(3 * noBackups); + c_tablePool.setSize(noBackups * noTables); + c_attributePool.setSize(noBackups * noAttribs); + c_triggerPool.setSize(noBackups * 3 * noTables); + + // 2 = no of replicas + c_fragmentPool.setSize(noBackups * 2 * NO_OF_FRAG_PER_NODE * noTables); + + Uint32 szMem = 0; + p->get("BackupMemory", &szMem); + Uint32 noPages = (szMem + sizeof(Page32) - 1) / sizeof(Page32); + // We need to allocate an additional of 2 pages. 1 page because of a bug in + // ArrayPool and another one for DICTTAINFO. + c_pagePool.setSize(noPages + NO_OF_PAGES_META_FILE + 2); + + Uint32 szDataBuf = (2 * 1024 * 1024); + Uint32 szLogBuf = (2 * 1024 * 1024); + Uint32 szWrite = 32768; + p->get("BackupDataBufferSize", &szDataBuf); + p->get("BackupLogBufferSize", &szLogBuf); + p->get("BackupWriteSize", &szWrite); + + c_defaults.m_logBufferSize = szLogBuf; + c_defaults.m_dataBufferSize = szDataBuf; + c_defaults.m_minWriteSize = szWrite; + c_defaults.m_maxWriteSize = szWrite; + + { // Init all tables + ArrayList
    tables(c_tablePool); + TablePtr ptr; + while(tables.seize(ptr)){ + new (ptr.p) Table(c_attributePool, c_fragmentPool); + } + tables.release(); + } + + { + ArrayList ops(c_backupFilePool); + BackupFilePtr ptr; + while(ops.seize(ptr)){ + new (ptr.p) BackupFile(* this, c_pagePool); + } + ops.release(); + } + + { + ArrayList recs(c_backupPool); + BackupRecordPtr ptr; + while(recs.seize(ptr)){ + new (ptr.p) BackupRecord(* this, c_pagePool, c_tablePool, + c_backupFilePool, c_triggerPool); + } + recs.release(); + } + + // Initialize BAT for interface to file system + { + Page32Ptr p; + ndbrequire(c_pagePool.seizeId(p, 0)); + c_startOfPages = (Uint32 *)p.p; + c_pagePool.release(p); + + NewVARIABLE* bat = allocateBat(1); + bat[0].WA = c_startOfPages; + bat[0].nrr = c_pagePool.getSize()*sizeof(Page32)/sizeof(Uint32); + } + + // Add received signals + addRecSignal(GSN_STTOR, &Backup::execSTTOR); + addRecSignal(GSN_DUMP_STATE_ORD, &Backup::execDUMP_STATE_ORD); + addRecSignal(GSN_READ_NODESCONF, &Backup::execREAD_NODESCONF); + addRecSignal(GSN_NODE_FAILREP, &Backup::execNODE_FAILREP); + addRecSignal(GSN_INCL_NODEREQ, &Backup::execINCL_NODEREQ); + addRecSignal(GSN_CONTINUEB, &Backup::execCONTINUEB); + + addRecSignal(GSN_SCAN_HBREP, &Backup::execSCAN_HBREP); + addRecSignal(GSN_TRANSID_AI, &Backup::execTRANSID_AI); + addRecSignal(GSN_KEYINFO20, &Backup::execKEYINFO20); + addRecSignal(GSN_SCAN_FRAGREF, &Backup::execSCAN_FRAGREF); + addRecSignal(GSN_SCAN_FRAGCONF, &Backup::execSCAN_FRAGCONF); + + addRecSignal(GSN_BACKUP_TRIG_REQ, &Backup::execBACKUP_TRIG_REQ); + addRecSignal(GSN_TRIG_ATTRINFO, &Backup::execTRIG_ATTRINFO); + addRecSignal(GSN_FIRE_TRIG_ORD, &Backup::execFIRE_TRIG_ORD); + + addRecSignal(GSN_LIST_TABLES_CONF, &Backup::execLIST_TABLES_CONF); + addRecSignal(GSN_GET_TABINFOREF, &Backup::execGET_TABINFOREF); + addRecSignal(GSN_GET_TABINFO_CONF, &Backup::execGET_TABINFO_CONF); + + addRecSignal(GSN_CREATE_TRIG_REF, &Backup::execCREATE_TRIG_REF); + addRecSignal(GSN_CREATE_TRIG_CONF, &Backup::execCREATE_TRIG_CONF); + + addRecSignal(GSN_ALTER_TRIG_REF, &Backup::execALTER_TRIG_REF); + addRecSignal(GSN_ALTER_TRIG_CONF, &Backup::execALTER_TRIG_CONF); + + addRecSignal(GSN_DROP_TRIG_REF, &Backup::execDROP_TRIG_REF); + addRecSignal(GSN_DROP_TRIG_CONF, &Backup::execDROP_TRIG_CONF); + + addRecSignal(GSN_DI_FCOUNTCONF, &Backup::execDI_FCOUNTCONF); + addRecSignal(GSN_DIGETPRIMCONF, &Backup::execDIGETPRIMCONF); + + addRecSignal(GSN_FSOPENREF, &Backup::execFSOPENREF); + addRecSignal(GSN_FSOPENCONF, &Backup::execFSOPENCONF); + + addRecSignal(GSN_FSCLOSEREF, &Backup::execFSCLOSEREF); + addRecSignal(GSN_FSCLOSECONF, &Backup::execFSCLOSECONF); + + addRecSignal(GSN_FSAPPENDREF, &Backup::execFSAPPENDREF); + addRecSignal(GSN_FSAPPENDCONF, &Backup::execFSAPPENDCONF); + + addRecSignal(GSN_FSREMOVEREF, &Backup::execFSREMOVEREF); + addRecSignal(GSN_FSREMOVECONF, &Backup::execFSREMOVECONF); + + /*****/ + addRecSignal(GSN_BACKUP_REQ, &Backup::execBACKUP_REQ); + addRecSignal(GSN_ABORT_BACKUP_ORD, &Backup::execABORT_BACKUP_ORD); + + addRecSignal(GSN_DEFINE_BACKUP_REQ, &Backup::execDEFINE_BACKUP_REQ); + addRecSignal(GSN_DEFINE_BACKUP_REF, &Backup::execDEFINE_BACKUP_REF); + addRecSignal(GSN_DEFINE_BACKUP_CONF, &Backup::execDEFINE_BACKUP_CONF); + + addRecSignal(GSN_START_BACKUP_REQ, &Backup::execSTART_BACKUP_REQ); + addRecSignal(GSN_START_BACKUP_REF, &Backup::execSTART_BACKUP_REF); + addRecSignal(GSN_START_BACKUP_CONF, &Backup::execSTART_BACKUP_CONF); + + addRecSignal(GSN_BACKUP_FRAGMENT_REQ, &Backup::execBACKUP_FRAGMENT_REQ); + //addRecSignal(GSN_BACKUP_FRAGMENT_REF, &Backup::execBACKUP_FRAGMENT_REF); + addRecSignal(GSN_BACKUP_FRAGMENT_CONF, &Backup::execBACKUP_FRAGMENT_CONF); + + addRecSignal(GSN_STOP_BACKUP_REQ, &Backup::execSTOP_BACKUP_REQ); + addRecSignal(GSN_STOP_BACKUP_REF, &Backup::execSTOP_BACKUP_REF); + addRecSignal(GSN_STOP_BACKUP_CONF, &Backup::execSTOP_BACKUP_CONF); + + //addRecSignal(GSN_BACKUP_STATUS_REQ, &Backup::execBACKUP_STATUS_REQ); + //addRecSignal(GSN_BACKUP_STATUS_CONF, &Backup::execBACKUP_STATUS_CONF); + + addRecSignal(GSN_UTIL_SEQUENCE_REF, &Backup::execUTIL_SEQUENCE_REF); + addRecSignal(GSN_UTIL_SEQUENCE_CONF, &Backup::execUTIL_SEQUENCE_CONF); + + addRecSignal(GSN_WAIT_GCP_REF, &Backup::execWAIT_GCP_REF); + addRecSignal(GSN_WAIT_GCP_CONF, &Backup::execWAIT_GCP_CONF); + + /** + * Testing + */ + addRecSignal(GSN_BACKUP_REF, &Backup::execBACKUP_REF); + addRecSignal(GSN_BACKUP_CONF, &Backup::execBACKUP_CONF); + addRecSignal(GSN_BACKUP_ABORT_REP, &Backup::execBACKUP_ABORT_REP); + addRecSignal(GSN_BACKUP_COMPLETE_REP, &Backup::execBACKUP_COMPLETE_REP); +} + +Backup::~Backup() +{ +} + +BLOCK_FUNCTIONS(Backup); + diff --git a/ndb/src/kernel/blocks/backup/FsBuffer.hpp b/ndb/src/kernel/blocks/backup/FsBuffer.hpp new file mode 100644 index 00000000000..4b5d95a19a5 --- /dev/null +++ b/ndb/src/kernel/blocks/backup/FsBuffer.hpp @@ -0,0 +1,346 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef FS_BUFFER_HPP +#define FS_BUFFER_HPP + +#include +#include +#include +#include + +#define DEBUG(x) + +/** + * A circular data buffer to be used together with the FS + * + * One writer - Typically your block + * getWritePtr() + * updateWritePtr() + * + * One reader - Typically "thread" in your block sending stuff to NDBFS + * getReadPtr() + * updateReadPtr() + */ +class FsBuffer { +public: + /** + * Default constructor + */ + FsBuffer(); + + /** + * setup FsBuffer + * + * @param Buffer - Ptr to continuous memory + * @param Size - Buffer size in 32-bit words + * @param BlockSize - Size of block in 32-bit words + * @param MinRead - Min read size in 32-bit words + * Get rounded(down) to nearest multiple of block size. + * @param MaxRead - Max read size in 32-bit words + * Get rounded(down) to nearest multiple of block size. + * @param MaxWrite - Maximum write (into buffer) in 32-bit words + * + * @return NULL if everything is OK + * else A string describing problem + */ + const char * setup(Uint32 * Buffer, + Uint32 Size, + Uint32 BlockSize = 128, // 512 bytes + Uint32 MinRead = 1024, // 4k + Uint32 MaxRead = 1024, // 4k + Uint32 MaxWrite = 1024); // 4k + /* + * @return NULL if everything is OK + * else A string describing problem + */ + const char * valid() const; + + Uint32 getBufferSize() const; + Uint32 getUsableSize() const; + Uint32 * getStart() const; + + /** + * getReadPtr - Get pointer and size of data to send to FS + * + * @param ptr - Where to fetch data + * @param sz - How much data in 32-bit words + * @param eof - Is this the last fetch (only if return false) + * + * @return true - If there is data of size >= minread + * false - If there is can be data be if it is is < minread + * - else eof = true + */ + bool getReadPtr(Uint32 ** ptr, Uint32 * sz, bool * eof); + + /** + * @note: sz must be equal to sz returned by getReadPtr + */ + void updateReadPtr(Uint32 sz); + + /** + * + * @note Must be followed by a updateWritePtr(no of words used) + */ + bool getWritePtr(Uint32 ** ptr, Uint32 sz); + + void updateWritePtr(Uint32 sz); + + /** + * There will be no more writing to this buffer + */ + void eof(); + + /** + * Getters for varibles + */ + Uint32 getMaxWrite() const { return m_maxWrite;} + Uint32 getMinRead() const { return m_minRead;} + + Uint32 getFreeSize() const { return m_free; } + + +private: + + Uint32 m_free; + Uint32 m_readIndex; + Uint32 m_writeIndex; + Uint32 m_eof; + Uint32 * m_start; + Uint32 m_minRead; + Uint32 m_maxRead; + Uint32 m_maxWrite; + Uint32 m_size; + + Uint32 * m_buffer; + Uint32 m_bufSize; + Uint32 m_blockSize; + + void clear(); +}; + +inline +FsBuffer::FsBuffer() +{ + clear(); +} + +inline +void +FsBuffer::clear(){ + m_minRead = m_maxRead = m_maxWrite = m_size = m_bufSize = m_free = 0; + m_buffer = m_start = 0; +} + +static +Uint32 * +align(Uint32 * ptr, Uint32 alignment, bool downwards){ + + const UintPtr a = (UintPtr)ptr; + const UintPtr b = a % alignment; + + if(downwards){ + return (Uint32 *)(a - b); + } else { + return (Uint32 *)(a + (b == 0 ? 0 : (alignment - b))); + } +} + +inline +const char * +FsBuffer::setup(Uint32 * Buffer, + Uint32 Size, + Uint32 Block, + Uint32 MinRead, + Uint32 MaxRead, + Uint32 MaxWrite) +{ + clear(); + m_buffer = Buffer; + m_bufSize = Size; + m_blockSize = Block; + if(Block == 0){ + return valid(); + } + + m_minRead = (MinRead / Block) * Block; + m_maxRead = (MaxRead / Block) * Block; + m_maxWrite = MaxWrite; + + m_start = align(Buffer, Block*4, false); + Uint32 * stop = align(Buffer + Size - MaxWrite, Block*4, true); + if(stop > m_start){ + m_size = stop - m_start; + } else { + m_size = 0; + } + + if(m_minRead == 0) + m_size = 0; + else + m_size = (m_size / m_minRead) * m_minRead; + +#if 0 + ndbout_c("Block = %d MinRead = %d -> %d", Block*4, MinRead*4, m_minRead*4); + ndbout_c("Block = %d MaxRead = %d -> %d", Block*4, MaxRead*4, m_maxRead*4); + + ndbout_c("Buffer = %d -> %d", Buffer, m_start); + ndbout_c("Buffer = %d Size = %d MaxWrite = %d -> %d", + Buffer, Size*4, MaxWrite*4, m_size*4); +#endif + + m_readIndex = m_writeIndex = m_eof = 0; + m_free = m_size; + return valid(); +} + +inline +const char * +FsBuffer::valid() const { + if(m_buffer == 0) return "Null pointer buffer"; + if(m_bufSize == 0) return "Zero size buffer"; + if(m_blockSize == 0) return "Zero block size"; + if(m_minRead < m_blockSize) return "Min read less than block size"; + if(m_maxRead < m_blockSize) return "Max read less than block size"; + if(m_maxRead < m_minRead) return "Max read less than min read"; + if(m_size == 0) return "Zero usable space"; + return 0; +} + +inline +Uint32 +FsBuffer::getBufferSize() const { + return m_bufSize; +} + +inline +Uint32 +FsBuffer::getUsableSize() const { + return m_size; +} + +inline +Uint32 * +FsBuffer::getStart() const { + return m_start; +} + +inline +bool +FsBuffer::getReadPtr(Uint32 ** ptr, Uint32 * sz, bool * _eof){ + + Uint32 * Tp = m_start; + const Uint32 Tr = m_readIndex; + const Uint32 Tm = m_minRead; + const Uint32 Ts = m_size; + const Uint32 Tmw = m_maxRead; + + Uint32 sz1 = m_size - m_free; // Used + + if(sz1 >= Tm){ + if(Tr + sz1 > Ts) + sz1 = (Ts - Tr); + + if(sz1 > Tmw) + * sz = Tmw; + else + * sz = sz1 - (sz1 % Tm); + + * ptr = &Tp[Tr]; + + DEBUG(ndbout_c("getReadPtr() Tr: %d Tw: %d Ts: %d Tm: %d sz1: %d -> %d", + Tr, Tw, Ts, Tm, sz1, * sz)); + + return true; + } + + if(!m_eof){ + * _eof = false; + + DEBUG(ndbout_c("getReadPtr() Tr: %d Tw: %d Ts: %d Tm: %d sz1: %d -> false", + Tr, Tw, Ts, Tm, sz1)); + + return false; + } + + * sz = sz1; + * _eof = true; + * ptr = &Tp[Tr]; + + DEBUG(ndbout_c("getReadPtr() Tr: %d Tw: %d Ts: %d Tm: %d sz1: %d -> %d eof", + Tr, Tw, Ts, Tm, sz1, * sz)); + + return false; +} + +inline +void +FsBuffer::updateReadPtr(Uint32 sz){ + const Uint32 Tr = m_readIndex; + const Uint32 Ts = m_size; + + m_free += sz; + m_readIndex = (Tr + sz) % Ts; +} + +inline +bool +FsBuffer::getWritePtr(Uint32 ** ptr, Uint32 sz){ + assert(sz <= m_maxWrite); + Uint32 * Tp = m_start; + const Uint32 Tw = m_writeIndex; + const Uint32 sz1 = m_free; + + if(sz1 > sz){ // Note at least 1 word of slack + * ptr = &Tp[Tw]; + + DEBUG(ndbout_c("getWritePtr(%d) Tr: %d Tw: %d Ts: %d sz1: %d -> true", + sz, Tr, Tw, Ts, sz1)); + return true; + } + + DEBUG(ndbout_c("getWritePtr(%d) Tr: %d Tw: %d Ts: %d sz1: %d -> false", + sz, Tr, Tw, Ts, sz1)); + + return false; +} + +inline +void +FsBuffer::updateWritePtr(Uint32 sz){ + assert(sz <= m_maxWrite); + Uint32 * Tp = m_start; + const Uint32 Tw = m_writeIndex; + const Uint32 Ts = m_size; + + const Uint32 Tnew = (Tw + sz); + m_free -= sz; + if(Tnew < Ts){ + m_writeIndex = Tnew; + return; + } + + memcpy(Tp, &Tp[Ts], (Tnew - Ts) << 2); + m_writeIndex = Tnew - Ts; +} + +inline +void +FsBuffer::eof(){ + m_eof = 1; +} + +#endif diff --git a/ndb/src/kernel/blocks/backup/Makefile b/ndb/src/kernel/blocks/backup/Makefile new file mode 100644 index 00000000000..989199cbe02 --- /dev/null +++ b/ndb/src/kernel/blocks/backup/Makefile @@ -0,0 +1,18 @@ +include .defs.mk + +TYPE := kernel + +#ifneq ($(MYSQLCLUSTER_TOP),) +DIRS := restore +#endif + +ARCHIVE_TARGET := backup + +SOURCES = Backup.cpp BackupInit.cpp + +include $(NDB_TOP)/Epilogue.mk + +$(NDB_TOP)/bin/readBackupFile: read.o + $(C++) -o $@ read.o \ + $(NDB_TOP)/lib/libportlib.a $(NDB_TOP)/lib/libgeneral.a + diff --git a/ndb/src/kernel/blocks/backup/read.cpp b/ndb/src/kernel/blocks/backup/read.cpp new file mode 100644 index 00000000000..8300c74ab43 --- /dev/null +++ b/ndb/src/kernel/blocks/backup/read.cpp @@ -0,0 +1,479 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include + +#include +#include +#include "BackupFormat.hpp" +#include +#include + +bool readHeader(FILE*, BackupFormat::FileHeader *); +bool readFragHeader(FILE*, BackupFormat::DataFile::FragmentHeader *); +bool readFragFooter(FILE*, BackupFormat::DataFile::FragmentFooter *); +Int32 readRecord(FILE*, Uint32 **); + +NdbOut & operator<<(NdbOut&, const BackupFormat::FileHeader &); +NdbOut & operator<<(NdbOut&, const BackupFormat::DataFile::FragmentHeader &); +NdbOut & operator<<(NdbOut&, const BackupFormat::DataFile::FragmentFooter &); + +bool readTableList(FILE*, BackupFormat::CtlFile::TableList **); +bool readTableDesc(FILE*, BackupFormat::CtlFile::TableDescription **); +bool readGCPEntry(FILE*, BackupFormat::CtlFile::GCPEntry **); + +NdbOut & operator<<(NdbOut&, const BackupFormat::CtlFile::TableList &); +NdbOut & operator<<(NdbOut&, const BackupFormat::CtlFile::TableDescription &); +NdbOut & operator<<(NdbOut&, const BackupFormat::CtlFile::GCPEntry &); + +Int32 readLogEntry(FILE*, Uint32**); + +static Uint32 recNo; +static Uint32 logEntryNo; + +int +main(int argc, const char * argv[]){ + + if(argc <= 1){ + printf("Usage: %s ", argv[0]); + exit(1); + } + FILE * f = fopen(argv[1], "rb"); + if(!f){ + ndbout << "No such file!" << endl; + exit(1); + } + + BackupFormat::FileHeader fileHeader; + if(!readHeader(f, &fileHeader)){ + ndbout << "Invalid file!" << endl; + exit(1); + } + ndbout << fileHeader << endl; + + switch(fileHeader.FileType){ + case BackupFormat::DATA_FILE: + while(!feof(f)){ + BackupFormat::DataFile::FragmentHeader fragHeader; + if(!readFragHeader(f, &fragHeader)) + break; + ndbout << fragHeader << endl; + + Uint32 len, * data; + while((len = readRecord(f, &data)) > 0){ +#if 0 + ndbout << "-> " << hex; + for(Uint32 i = 0; iSectionLength - 2; + for(Uint32 i = 0; i 0){ + LogEntry * logEntry = (LogEntry *) data; + /** + * Log Entry + */ + Uint32 event = ntohl(logEntry->TriggerEvent); + bool gcp = (event & 0x10000) != 0; + event &= 0xFFFF; + if(gcp) + len --; + + ndbout << "LogEntry Table: " << (Uint32)ntohl(logEntry->TableId) + << " Event: " << event + << " Length: " << (len - 2); + + const Uint32 dataLen = len - 2; +#if 0 + Uint32 pos = 0; + while(pos < dataLen){ + AttributeHeader * ah = (AttributeHeader*)&logEntry->Data[pos]; + ndbout_c(" Attribut: %d Size: %d", + ah->getAttributeId(), + ah->getDataSize()); + pos += ah->getDataSize() + 1; + } +#endif + if(gcp) + ndbout << " GCP: " << (Uint32)ntohl(logEntry->Data[dataLen]); + ndbout << endl; + } + break; + } + default: + ndbout << "Unsupported file type for printer: " + << fileHeader.FileType << endl; + break; + } + fclose(f); + return 0; +} + +#define RETURN_FALSE() { ndbout_c("false: %d", __LINE__); abort(); return false; } + +static bool endian = false; + +bool +readHeader(FILE* f, BackupFormat::FileHeader * dst){ + if(fread(dst, 4, 3, f) != 3) + RETURN_FALSE(); + + if(memcmp(dst->Magic, BACKUP_MAGIC, sizeof(BACKUP_MAGIC)) != 0) + RETURN_FALSE(); + + dst->NdbVersion = ntohl(dst->NdbVersion); + if(dst->NdbVersion != 210) + RETURN_FALSE(); + + if(fread(&dst->SectionType, 4, 2, f) != 2) + RETURN_FALSE(); + dst->SectionType = ntohl(dst->SectionType); + dst->SectionLength = ntohl(dst->SectionLength); + + if(dst->SectionType != BackupFormat::FILE_HEADER) + RETURN_FALSE(); + + if(dst->SectionLength != ((sizeof(BackupFormat::FileHeader) - 12) >> 2)) + RETURN_FALSE(); + + if(fread(&dst->FileType, 4, dst->SectionLength - 2, f) != + (dst->SectionLength - 2)) + RETURN_FALSE(); + + dst->FileType = ntohl(dst->FileType); + dst->BackupId = ntohl(dst->BackupId); + dst->BackupKey_0 = ntohl(dst->BackupKey_0); + dst->BackupKey_1 = ntohl(dst->BackupKey_1); + + if(dst->FileType < BackupFormat::CTL_FILE || + dst->FileType > BackupFormat::DATA_FILE) + RETURN_FALSE(); + + if(dst->ByteOrder != 0x12345678) + endian = true; + + return true; +} + +bool +readFragHeader(FILE* f, BackupFormat::DataFile::FragmentHeader * dst){ + if(fread(dst, 1, sizeof(* dst), f) != sizeof(* dst)) + return false; + + dst->SectionType = ntohl(dst->SectionType); + dst->SectionLength = ntohl(dst->SectionLength); + dst->TableId = ntohl(dst->TableId); + dst->FragmentNo = ntohl(dst->FragmentNo); + dst->ChecksumType = ntohl(dst->ChecksumType); + + if(dst->SectionLength != (sizeof(* dst) >> 2)) + RETURN_FALSE(); + + if(dst->SectionType != BackupFormat::FRAGMENT_HEADER) + RETURN_FALSE(); + + recNo = 0; + + return true; +} + +bool +readFragFooter(FILE* f, BackupFormat::DataFile::FragmentFooter * dst){ + if(fread(dst, 1, sizeof(* dst), f) != sizeof(* dst)) + RETURN_FALSE(); + + dst->SectionType = ntohl(dst->SectionType); + dst->SectionLength = ntohl(dst->SectionLength); + dst->TableId = ntohl(dst->TableId); + dst->FragmentNo = ntohl(dst->FragmentNo); + dst->NoOfRecords = ntohl(dst->NoOfRecords); + dst->Checksum = ntohl(dst->Checksum); + + if(dst->SectionLength != (sizeof(* dst) >> 2)) + RETURN_FALSE(); + + if(dst->SectionType != BackupFormat::FRAGMENT_FOOTER) + RETURN_FALSE(); + return true; +} + +static Uint32 buf[8192]; + +Int32 +readRecord(FILE* f, Uint32 **dst){ + Uint32 len; + if(fread(&len, 1, 4, f) != 4) + RETURN_FALSE(); + + len = ntohl(len); + + if(fread(buf, 4, len, f) != len) + return -1; + + if(len > 0) + recNo++; + + * dst = &buf[0]; + + return len; +} + +Int32 +readLogEntry(FILE* f, Uint32 **dst){ + Uint32 len; + if(fread(&len, 1, 4, f) != 4) + RETURN_FALSE(); + + len = ntohl(len); + + if(fread(&buf[1], 4, len, f) != len) + return -1; + + buf[0] = len; + + if(len > 0) + logEntryNo++; + + * dst = &buf[0]; + + return len; +} + + +NdbOut & +operator<<(NdbOut& ndbout, const BackupFormat::FileHeader & hf){ + + char buf[9]; + memcpy(buf, hf.Magic, sizeof(hf.Magic)); + buf[8] = 0; + + ndbout << "-- FileHeader:" << endl; + ndbout << "Magic: " << buf << endl; + ndbout << "NdbVersion: " << hf.NdbVersion << endl; + ndbout << "SectionType: " << hf.SectionType << endl; + ndbout << "SectionLength: " << hf.SectionLength << endl; + ndbout << "FileType: " << hf.FileType << endl; + ndbout << "BackupId: " << hf.BackupId << endl; + ndbout << "BackupKey: [ " << hex << hf.BackupKey_0 + << " "<< hf.BackupKey_1 << " ]" << endl; + ndbout << "ByteOrder: " << hex << hf.ByteOrder << endl; + return ndbout; +} + +NdbOut & operator<<(NdbOut& ndbout, + const BackupFormat::DataFile::FragmentHeader & hf){ + + ndbout << "-- Fragment header:" << endl; + ndbout << "SectionType: " << hf.SectionType << endl; + ndbout << "SectionLength: " << hf.SectionLength << endl; + ndbout << "TableId: " << hf.TableId << endl; + ndbout << "FragmentNo: " << hf.FragmentNo << endl; + ndbout << "ChecksumType: " << hf.ChecksumType << endl; + + return ndbout; +} +NdbOut & operator<<(NdbOut& ndbout, + const BackupFormat::DataFile::FragmentFooter & hf){ + + ndbout << "-- Fragment footer:" << endl; + ndbout << "SectionType: " << hf.SectionType << endl; + ndbout << "SectionLength: " << hf.SectionLength << endl; + ndbout << "TableId: " << hf.TableId << endl; + ndbout << "FragmentNo: " << hf.FragmentNo << endl; + ndbout << "NoOfRecords: " << hf.NoOfRecords << endl; + ndbout << "Checksum: " << hf.Checksum << endl; + + return ndbout; +} + +bool +readTableList(FILE* f, BackupFormat::CtlFile::TableList **ret){ + BackupFormat::CtlFile::TableList * dst = + (BackupFormat::CtlFile::TableList *)&buf[0]; + + if(fread(dst, 4, 2, f) != 2) + RETURN_FALSE(); + + dst->SectionType = ntohl(dst->SectionType); + dst->SectionLength = ntohl(dst->SectionLength); + + if(dst->SectionType != BackupFormat::TABLE_LIST) + RETURN_FALSE(); + + const Uint32 len = dst->SectionLength - 2; + if(fread(&dst->TableIds[0], 4, len, f) != len) + RETURN_FALSE(); + + for(Uint32 i = 0; iTableIds[i] = ntohl(dst->TableIds[i]); + } + + * ret = dst; + + return true; +} + +bool +readTableDesc(FILE* f, BackupFormat::CtlFile::TableDescription **ret){ + BackupFormat::CtlFile::TableDescription * dst = + (BackupFormat::CtlFile::TableDescription *)&buf[0]; + + if(fread(dst, 4, 2, f) != 2) + RETURN_FALSE(); + + dst->SectionType = ntohl(dst->SectionType); + dst->SectionLength = ntohl(dst->SectionLength); + + if(dst->SectionType != BackupFormat::TABLE_DESCRIPTION) + RETURN_FALSE(); + + const Uint32 len = dst->SectionLength - 2; + if(fread(&dst->DictTabInfo[0], 4, len, f) != len) + RETURN_FALSE(); + + * ret = dst; + + return true; +} + +bool +readGCPEntry(FILE* f, BackupFormat::CtlFile::GCPEntry **ret){ + BackupFormat::CtlFile::GCPEntry * dst = + (BackupFormat::CtlFile::GCPEntry *)&buf[0]; + + if(fread(dst, 4, 4, f) != 4) + RETURN_FALSE(); + + dst->SectionType = ntohl(dst->SectionType); + dst->SectionLength = ntohl(dst->SectionLength); + + if(dst->SectionType != BackupFormat::GCP_ENTRY) + RETURN_FALSE(); + + dst->StartGCP = ntohl(dst->StartGCP); + dst->StopGCP = ntohl(dst->StopGCP); + + * ret = dst; + + return true; +} + + +NdbOut & +operator<<(NdbOut& ndbout, const BackupFormat::CtlFile::TableList & hf) { + ndbout << "-- Table List:" << endl; + ndbout << "SectionType: " << hf.SectionType << endl; + ndbout << "SectionLength: " << hf.SectionLength << endl; + for(Uint32 i = 0; i < hf.SectionLength - 2; i++){ + ndbout << hf.TableIds[i] << " "; + if((i + 1) % 16 == 0) + ndbout << endl; + } + return ndbout; +} + +NdbOut & +operator<<(NdbOut& ndbout, const BackupFormat::CtlFile::TableDescription & hf){ + ndbout << "-- Table Description:" << endl; + ndbout << "SectionType: " << hf.SectionType << endl; + ndbout << "SectionLength: " << hf.SectionLength << endl; + + SimplePropertiesLinearReader it(&hf.DictTabInfo[0], hf.SectionLength - 2); + char buf[1024]; + for(it.first(); it.valid(); it.next()){ + switch(it.getValueType()){ + case SimpleProperties::Uint32Value: + ndbout << "Key: " << it.getKey() + << " value(" << it.getValueLen() << ") : " + << it.getUint32() << endl; + break; + case SimpleProperties::StringValue: + if(it.getValueLen() < sizeof(buf)){ + it.getString(buf); + ndbout << "Key: " << it.getKey() + << " value(" << it.getValueLen() << ") : " + << "\"" << buf << "\"" << endl; + } else { + ndbout << "Key: " << it.getKey() + << " value(" << it.getValueLen() << ") : " + << "\"" << "" << "\"" << endl; + + } + break; + default: + ndbout << "Unknown type for key: " << it.getKey() + << " type: " << it.getValueType() << endl; + } + } + + return ndbout; +} + +NdbOut & +operator<<(NdbOut& ndbout, const BackupFormat::CtlFile::GCPEntry & hf) { + ndbout << "-- GCP Entry:" << endl; + ndbout << "SectionType: " << hf.SectionType << endl; + ndbout << "SectionLength: " << hf.SectionLength << endl; + ndbout << "Start GCP: " << hf.StartGCP << endl; + ndbout << "Stop GCP: " << hf.StopGCP << endl; + + return ndbout; +} + diff --git a/ndb/src/kernel/blocks/backup/restore/Makefile b/ndb/src/kernel/blocks/backup/restore/Makefile new file mode 100644 index 00000000000..f99e3e3da0d --- /dev/null +++ b/ndb/src/kernel/blocks/backup/restore/Makefile @@ -0,0 +1,20 @@ +include .defs.mk + +TYPE := ndbapi ndbapiclient + +BIN_TARGET := restore +BIN_TARGET_LIBS := +BIN_TARGET_ARCHIVES := NDB_API general + +CCFLAGS_LOC = -I.. -I$(NDB_TOP)/src/ndbapi + +#ifneq ($(MYSQLCLUSTER_TOP),) +#CCFLAGS_LOC +=-I$(MYSQLCLUSTER_TOP)/include -D USE_MYSQL +#LDFLAGS_LOC += -L$(MYSQLCLUSTER_TOP)/libmysql_r/ -lmysqlclient_r +#endif + +SOURCES = main.cpp Restore.cpp + +include $(NDB_TOP)/Epilogue.mk + + diff --git a/ndb/src/kernel/blocks/backup/restore/Restore.cpp b/ndb/src/kernel/blocks/backup/restore/Restore.cpp new file mode 100644 index 00000000000..f91651d9720 --- /dev/null +++ b/ndb/src/kernel/blocks/backup/restore/Restore.cpp @@ -0,0 +1,1112 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Restore.hpp" +#include "BackupFormat.hpp" +#include +#include +#include +#include + +#include +#include +#include +#include + +// from src/ndbapi +#include + +Uint16 Twiddle16(Uint16 in); // Byte shift 16-bit data +Uint32 Twiddle32(Uint32 in); // Byte shift 32-bit data +Uint64 Twiddle64(Uint64 in); // Byte shift 64-bit data + +bool +BackupFile::Twiddle(AttributeS* attr, Uint32 arraySize){ + + if(m_hostByteOrder) + return true; + + if(arraySize == 0){ + arraySize = attr->Desc->arraySize; + } + + switch(attr->Desc->size){ + case 8: + + return true; + case 16: + for(unsigned i = 0; iData.u_int16_value[i] = Twiddle16(attr->Data.u_int16_value[i]); + } + return true; + case 32: + for(unsigned i = 0; iData.u_int32_value[i] = Twiddle32(attr->Data.u_int32_value[i]); + } + return true; + case 64: + for(unsigned i = 0; iData.u_int64_value[i] = Twiddle64(attr->Data.u_int64_value[i]); + } + return true; + default: + return false; + } // switch + +} // Twiddle + +FilteredNdbOut err(* new FileOutputStream(stderr), 0, 0); +FilteredNdbOut info(* new FileOutputStream(stdout), 1, 1); +FilteredNdbOut debug(* new FileOutputStream(stdout), 2, 0); + +// To decide in what byte order data is +const Uint32 magicByteOrder = 0x12345678; +const Uint32 swappedMagicByteOrder = 0x78563412; + +RestoreMetaData::RestoreMetaData(const char* path, Uint32 nodeId, Uint32 bNo) { + + debug << "RestoreMetaData constructor" << endl; + setCtlFile(nodeId, bNo, path); +} + +RestoreMetaData::~RestoreMetaData(){ + for(int i = 0; igetTableId() == tableId) + return allTables[i]; + return NULL; +} + +Uint32 +RestoreMetaData::getStopGCP() const { + return m_stopGCP; +} + +int +RestoreMetaData::loadContent(const char * catalog, + const char * schema) +{ + +#if NDB_VERSION_MAJOR >= VERSION_3X + if(getMajor(m_fileHeader.NdbVersion) < VERSION_3X) { + if(catalog == NULL) + return -1; + if(schema == NULL) + return -1; + } + + + /** + * if backup is of version 3 or higher, then + * return -2 to indicate for the user that he + * cannot restore tables to a certain catalog/schema + */ + if(getMajor(m_fileHeader.NdbVersion) >= VERSION_3X && + (catalog != NULL || + schema != NULL)) { + return -2; + } +#endif +#if NDB_VERSION_MAJOR < VERSION_3X + if(getMajor(m_fileHeader.NdbVersion) >= VERSION_3X) + { + return -2; + } +#endif + + Uint32 noOfTables = readMetaTableList(); + if(noOfTables == 0) + return -3; + for(Uint32 i = 0; iSectionType = ntohl(dst->SectionType); + dst->SectionLength = ntohl(dst->SectionLength); + + if(dst->SectionType != BackupFormat::GCP_ENTRY){ + err << "readGCPEntry invalid format" << endl; + return false; + } + + dst->StartGCP = ntohl(dst->StartGCP); + dst->StopGCP = ntohl(dst->StopGCP); + + m_startGCP = dst->StartGCP; + m_stopGCP = dst->StopGCP; + return true; +} + + +struct tmpTableS { + Uint32 tableId; + Uint32 schemaVersion; + Uint32 noOfAttributes; +}; // tmpTableS + +static const +SimpleProperties::SP2StructMapping +RestoreTabMap[] = { + // Map the basic stuff to begin with + DTIMAP(tmpTableS, TableId, tableId), + DTIMAP(tmpTableS, TableVersion, schemaVersion), + DTIMAP(tmpTableS, NoOfAttributes, noOfAttributes), + + DTIBREAK(AttributeName) +}; // RestoreTabMap + +static const Uint32 +TabMapSize = sizeof(RestoreTabMap) + / sizeof(SimpleProperties::SP2StructMapping); + +/** + * Use a temporary struct to keep variables in AttributeDesc private + * and DTIMAP requires all Uint32 + */ +struct tmpAttrS { + // Just the basic needed stuff is yet implemented + char name[AttrNameLenC]; + Uint32 attrId; + Uint32 type; + Uint32 nullable; + Uint32 key; + Uint32 size; + Uint32 arraySize; +}; + +static const +SimpleProperties::SP2StructMapping +RestoreAttrMap[] = { + // Map the most basic properties + DTIMAP(tmpAttrS, AttributeId, attrId), + DTIMAP(tmpAttrS, AttributeType, type), + DTIMAP(tmpAttrS, AttributeNullableFlag, nullable), + DTIMAP(tmpAttrS, AttributeKeyFlag, key), + DTIMAP(tmpAttrS, AttributeSize, size), + DTIMAP(tmpAttrS, AttributeArraySize, arraySize), + DTIBREAK(AttributeEnd) +}; // RestoreAttrMap +static const Uint32 +AttrMapSize = sizeof(RestoreAttrMap) + / sizeof(SimpleProperties::SP2StructMapping); + +struct v2xKernel_to_v3xAPIMapping { + Int32 kernelConstant; + Int32 apiConstant; +}; + +enum v2xKernelTypes { + ExtUndefined=0,// Undefined + ExtInt, // 32 bit + ExtUnsigned, // 32 bit + ExtBigint, // 64 bit + ExtBigunsigned,// 64 Bit + ExtFloat, // 32-bit float + ExtDouble, // 64-bit float + ExtDecimal, // Precision, Scale + ExtChar, // Len + ExtVarchar, // Max len + ExtBinary, // Len + ExtVarbinary, // Max len + ExtDatetime, // Precision down to 1 sec (sizeof(Datetime) == 8 bytes ) + ExtTimespec // Precision down to 1 nsec (sizeof(Datetime) == 12 bytes ) +}; + +const +v2xKernel_to_v3xAPIMapping +columnTypeMapping[] = { + { ExtInt, NdbDictionary::Column::Int }, + { ExtUnsigned, NdbDictionary::Column::Unsigned }, + { ExtBigint, NdbDictionary::Column::Bigint }, + { ExtBigunsigned, NdbDictionary::Column::Bigunsigned }, + { ExtFloat, NdbDictionary::Column::Float }, + { ExtDouble, NdbDictionary::Column::Double }, + { ExtDecimal, NdbDictionary::Column::Decimal }, + { ExtChar, NdbDictionary::Column::Char }, + { ExtVarchar, NdbDictionary::Column::Varchar }, + { ExtBinary, NdbDictionary::Column::Binary }, + { ExtVarbinary, NdbDictionary::Column::Varbinary }, + { ExtDatetime, NdbDictionary::Column::Datetime }, + { ExtTimespec, NdbDictionary::Column::Timespec }, + { -1, -1 } +}; + +static +NdbDictionary::Column::Type +convertToV3x(Int32 kernelConstant, const v2xKernel_to_v3xAPIMapping map[], + Int32 def) +{ + int i = 0; + while(map[i].kernelConstant != kernelConstant){ + if(map[i].kernelConstant == -1 && + map[i].apiConstant == -1){ + return (NdbDictionary::Column::Type)def; + } + i++; + } + return (NdbDictionary::Column::Type)map[i].apiConstant; +} + + + +// Parse dictTabInfo buffer and pushback to to vector storage +// Using SimpleProperties (here we don't need ntohl, ref:ejonore) +bool +RestoreMetaData::parseTableDescriptor(const Uint32 * data, + Uint32 len, + const char * catalog, + const char * schema) { + SimplePropertiesLinearReader it(data, len); + SimpleProperties::UnpackStatus spStatus; + + // Parse table name + if (it.getKey() != DictTabInfo::TableName) { + err << "readMetaTableDesc getKey table name error" << endl; + return false; + } // if + + /** + * if backup was taken in v21x then there is no info about catalog, + * and schema. This infomration is concatenated to the tableName. + * + */ + char tableName[MAX_TAB_NAME_SIZE*2]; // * 2 for db and schema.-. + + + char tmpTableName[MAX_TAB_NAME_SIZE]; + it.getString(tmpTableName); +#if NDB_VERSION_MAJOR >= VERSION_3X + /** + * only mess with name in version 3. + */ + /* switch(getMajor(m_fileHeader.NdbVersion)) { + */ + if(getMajor(m_fileHeader.NdbVersion) < VERSION_3X) + { + + if(strcmp(tmpTableName, "SYSTAB_0") == 0 || + strcmp(tmpTableName, "NDB$EVENTS_0") == 0) + { + sprintf(tableName,"sys/def/%s",tmpTableName); + } + else { + if(catalog == NULL && schema == NULL) + { + sprintf(tableName,"%s",tmpTableName); + } + else + { + sprintf(tableName,"%s/%s/%s",catalog,schema,tmpTableName); + } + } + } + else + sprintf(tableName,"%s",tmpTableName); +#elif NDB_VERSION_MAJOR < VERSION_3X + /** + * this is version two! + */ + sprintf(tableName,"%s",tmpTableName); +#endif + if (strlen(tableName) == 0) { + err << "readMetaTableDesc getString table name error" << endl; + return false; + } // if + + TableS * table = new TableS(tableName); + if(table == NULL) { + return false; + } + + table->setBackupVersion(m_fileHeader.NdbVersion); + tmpTableS tmpTable; + spStatus = SimpleProperties::unpack(it, &tmpTable, + RestoreTabMap, TabMapSize, true, true); + if ((spStatus != SimpleProperties::Break) || + it.getKey() != DictTabInfo::AttributeName) { + err << "readMetaTableDesc sp.unpack error" << endl; + delete table; + return false; + } // if + + debug << "Parsed table id " << tmpTable.tableId << endl; + table->setTableId(tmpTable.tableId); + debug << "Parsed table #attr " << tmpTable.noOfAttributes << endl; + debug << "Parsed table schema version not used " << endl; + + for (Uint32 i = 0; i < tmpTable.noOfAttributes; i++) { + if (it.getKey() != DictTabInfo::AttributeName) { + err << "readMetaTableDesc error " << endl; + delete table; + return false; + } // if + + tmpAttrS tmpAttr; + if(it.getValueLen() > AttrNameLenC){ + err << "readMetaTableDesc attribute name too long??" << endl; + delete table; + return false; + } + it.getString(tmpAttr.name); + + spStatus = SimpleProperties::unpack(it, &tmpAttr, RestoreAttrMap, + AttrMapSize, true, true); + if ((spStatus != SimpleProperties::Break) || + (it.getKey() != DictTabInfo::AttributeEnd)) { + err << "readMetaTableDesc sp unpack attribute " << i << " error" + << endl; + delete table; + return false; + } // if + + debug << "Creating attribute " << i << " " << tmpAttr.name << endl; + + bool thisNullable = (bool)(tmpAttr.nullable); // Really not needed (now) + KeyType thisKey = (KeyType)(tmpAttr.key); // These are identical (right now) + // Convert attribute size from enum to Uint32 + // The static consts are really enum taking the value in DictTabInfo + // e.g. 3 is not ...0011 but rather ...0100 + //TODO: rather do a switch if the constants should change + Uint32 thisSize = 1 << tmpAttr.size; + // Convert attribute type to AttrType + AttrType thisType; + switch (tmpAttr.type) { + case 0: // SignedType + thisType = Signed; + break; + case 1: // UnSignedType + thisType = UnSigned; + break; + case 2: // FloatingPointType + thisType = Float; + break; + case 3: // StringType: + debug << "String type detected " << endl; + thisType = String; + break; + default: + // What, default to unsigned? + thisType = UnSigned; + break; + } // switch + /* ndbout_c << " type: " << thisType << " size: " << thisSize <<" arraySize: " + << tmpAttr.arraySize << " nullable: " << thisNullable << " key: " + << thisKey << endl; + */ + table->createAttr(tmpAttr.name, thisType, + thisSize, tmpAttr.arraySize, + thisNullable, thisKey); + if (!it.next()) { + break; + // Check number of created attributes and compare with expected + //ndbout << "readMetaTableDesc expecting more attributes" << endl; + //return false; + } // if + } // for + + debug << "Pushing table " << tableName << endl; + debug << " with " << table->getNoOfAttributes() << " attributes" << endl; + allTables.push_back(table); + +#ifndef restore_old_types + NdbTableImpl* tableImpl = 0; + int ret = NdbDictInterface::parseTableInfo(&tableImpl, data, len); +#if NDB_VERSION_MAJOR >= VERSION_3X + NdbDictionary::Column::Type type; + if(getMajor(m_fileHeader.NdbVersion) < VERSION_3X) { + tableImpl->setName(tableName); + for(Uint32 i = 0 ; i < tableImpl->getNoOfColumns(); i++) { + type = convertToV3x(tableImpl->getColumn(i)->m_extType, + columnTypeMapping, + -1); + if(type == -1) + { + ndbout_c("Restore: Was not able to map external type %d (in v2x) " + " to a proper type in v3x", tableImpl->getColumn(i)->m_extType); + return false; + } + else + { + tableImpl->getColumn(i)->m_type = type; + } + + + + + } + } +#endif + if (ret != 0) { + err << "parseTableInfo " << tableName << " failed" << endl; + return false; + } + if(tableImpl == 0) + return false; + debug << "parseTableInfo " << tableName << " done" << endl; + table->m_dictTable = tableImpl; +#endif + return true; +} + +// Constructor +RestoreDataIterator::RestoreDataIterator(const RestoreMetaData & md) + : m_metaData(md) +{ + debug << "RestoreDataIterator constructor" << endl; + setDataFile(md, 0); +} + +RestoreDataIterator::~RestoreDataIterator(){ +} + +bool +TupleS::prepareRecord(const TableS & tab){ + m_currentTable = &tab; + for(int i = 0; iDesc = tab[i]; + allAttributes.push_back(a); + } + return true; +} + +const TupleS * +RestoreDataIterator::getNextTuple(int & res) { + TupleS * tup = new TupleS(); + if(tup == NULL) { + ndbout_c("Restore: Failed to allocate memory"); + res = -1; + return NULL; + } + if(!tup->prepareRecord(* m_currentTable)) { + res =-1; + return NULL; + } + + + Uint32 dataLength = 0; + // Read record length + if (fread(&dataLength, sizeof(dataLength), 1, m_file) != 1){ + err << "getNextTuple:Error reading length of data part" << endl; + delete tup; + res = -1; + return NULL; + } // if + + // Convert length from network byte order + dataLength = ntohl(dataLength); + const Uint32 dataLenBytes = 4 * dataLength; + + if (dataLength == 0) { + // Zero length for last tuple + // End of this data fragment + debug << "End of fragment" << endl; + res = 0; + delete tup; + return NULL; + } // if + + tup->createDataRecord(dataLenBytes); + // Read tuple data + if (fread(tup->getDataRecord(), 1, dataLenBytes, m_file) != dataLenBytes) { + err << "getNextTuple:Read error: " << endl; + delete tup; + res = -1; + return NULL; + } + + Uint32 * ptr = tup->getDataRecord(); + ptr += m_currentTable->m_nullBitmaskSize; + + for(int i = 0; i < m_currentTable->m_fixedKeys.size(); i++){ + assert(ptr < tup->getDataRecord() + dataLength); + + const Uint32 attrId = m_currentTable->m_fixedKeys[i]->attrId; + AttributeS * attr = tup->allAttributes[attrId]; + + const Uint32 sz = attr->Desc->getSizeInWords(); + + attr->Data.null = false; + attr->Data.void_value = ptr; + + if(!Twiddle(attr)) + { + res = -1; + return NULL; + } + ptr += sz; + } + + for(int i = 0; im_fixedAttribs.size(); i++){ + assert(ptr < tup->getDataRecord() + dataLength); + + const Uint32 attrId = m_currentTable->m_fixedAttribs[i]->attrId; + AttributeS * attr = tup->allAttributes[attrId]; + + const Uint32 sz = attr->Desc->getSizeInWords(); + + attr->Data.null = false; + attr->Data.void_value = ptr; + + if(!Twiddle(attr)) + { + res = -1; + return NULL; + } + + ptr += sz; + } + + for(int i = 0; im_variableAttribs.size(); i++){ + const Uint32 attrId = m_currentTable->m_variableAttribs[i]->attrId; + AttributeS * attr = tup->allAttributes[attrId]; + + if(attr->Desc->nullable){ + const Uint32 ind = attr->Desc->m_nullBitIndex; + if(BitmaskImpl::get(m_currentTable->m_nullBitmaskSize, + tup->getDataRecord(),ind)){ + attr->Data.null = true; + attr->Data.void_value = NULL; + continue; + } + } + + assert(ptr < tup->getDataRecord() + dataLength); + + typedef BackupFormat::DataFile::VariableData VarData; + VarData * data = (VarData *)ptr; + Uint32 sz = ntohl(data->Sz); + Uint32 id = ntohl(data->Id); + assert(id == attrId); + + attr->Data.null = false; + attr->Data.void_value = &data->Data[0]; + + /** + * Compute array size + */ + const Uint32 arraySize = (4 * sz) / (attr->Desc->size / 8); + assert(arraySize >= attr->Desc->arraySize); + if(!Twiddle(attr, attr->Desc->arraySize)) + { + res = -1; + return NULL; + } + + ptr += (sz + 2); + } + + m_count ++; + res = 0; + return tup; +} // RestoreDataIterator::getNextTuple + +BackupFile::BackupFile(){ + m_file = 0; + m_path[0] = 0; + m_fileName[0] = 0; + m_buffer = 0; + m_bufferSize = 0; +} + +BackupFile::~BackupFile(){ + if(m_file != 0) + fclose(m_file); + if(m_buffer != 0) + free(m_buffer); +} + +bool +BackupFile::openFile(){ + if(m_file != NULL){ + fclose(m_file); + m_file = 0; + } + + m_file = fopen(m_fileName, "r"); + return m_file != 0; +} + +Uint32 * +BackupFile::createBuffer(Uint32 bytes){ + if(bytes > m_bufferSize){ + if(m_buffer != 0) + free(m_buffer); + m_bufferSize = m_bufferSize + 2 * bytes; + m_buffer = (Uint32*)malloc(m_bufferSize); + } + return m_buffer; +} + +void +BackupFile::setCtlFile(Uint32 nodeId, Uint32 backupId, const char * path){ + m_nodeId = nodeId; + m_expectedFileHeader.BackupId = backupId; + m_expectedFileHeader.FileType = BackupFormat::CTL_FILE; + + char name[PATH_MAX]; const Uint32 sz = sizeof(name); + snprintf(name, sz, "BACKUP-%d.%d.ctl", backupId, nodeId); + setName(path, name); +} + +void +BackupFile::setDataFile(const BackupFile & bf, Uint32 no){ + m_nodeId = bf.m_nodeId; + m_expectedFileHeader = bf.m_fileHeader; + m_expectedFileHeader.FileType = BackupFormat::DATA_FILE; + + char name[PATH_MAX]; const Uint32 sz = sizeof(name); + snprintf(name, sz, "BACKUP-%d-%d.%d.Data", + m_expectedFileHeader.BackupId, no, m_nodeId); + setName(bf.m_path, name); +} + +void +BackupFile::setLogFile(const BackupFile & bf, Uint32 no){ + m_nodeId = bf.m_nodeId; + m_expectedFileHeader = bf.m_fileHeader; + m_expectedFileHeader.FileType = BackupFormat::LOG_FILE; + + char name[PATH_MAX]; const Uint32 sz = sizeof(name); + snprintf(name, sz, "BACKUP-%d.%d.log", + m_expectedFileHeader.BackupId, m_nodeId); + setName(bf.m_path, name); +} + +void +BackupFile::setName(const char * p, const char * n){ + const Uint32 sz = sizeof(m_path); + if(p != 0 && strlen(p) > 0){ + if(p[strlen(p)-1] == '/'){ + snprintf(m_path, sz, "%s", p); + } else { + snprintf(m_path, sz, "%s%s", p, "/"); + } + } else { + m_path[0] = 0; + } + + snprintf(m_fileName, sizeof(m_fileName), "%s%s", m_path, n); + debug << "Filename = " << m_fileName << endl; +} + +bool +BackupFile::readHeader(){ + if(!openFile()){ + return false; + } + + if(fread(&m_fileHeader, sizeof(m_fileHeader), 1, m_file) != 1){ + err << "readDataFileHeader: Error reading header" << endl; + return false; + } + + // Convert from network to host byte order for platform compatibility + m_fileHeader.NdbVersion = ntohl(m_fileHeader.NdbVersion); + m_fileHeader.SectionType = ntohl(m_fileHeader.SectionType); + m_fileHeader.SectionLength = ntohl(m_fileHeader.SectionLength); + m_fileHeader.FileType = ntohl(m_fileHeader.FileType); + m_fileHeader.BackupId = ntohl(m_fileHeader.BackupId); + m_fileHeader.BackupKey_0 = ntohl(m_fileHeader.BackupKey_0); + m_fileHeader.BackupKey_1 = ntohl(m_fileHeader.BackupKey_1); + + debug << "FileHeader: " << m_fileHeader.Magic << " " << + m_fileHeader.NdbVersion << " " << + m_fileHeader.SectionType << " " << + m_fileHeader.SectionLength << " " << + m_fileHeader.FileType << " " << + m_fileHeader.BackupId << " " << + m_fileHeader.BackupKey_0 << " " << + m_fileHeader.BackupKey_1 << " " << + m_fileHeader.ByteOrder << endl; + + debug << "ByteOrder is " << m_fileHeader.ByteOrder << endl; + debug << "magicByteOrder is " << magicByteOrder << endl; + + if (m_fileHeader.FileType != m_expectedFileHeader.FileType){ + abort(); + } + + // Check for BackupFormat::FileHeader::ByteOrder if swapping is needed + if (m_fileHeader.ByteOrder == magicByteOrder) { + m_hostByteOrder = true; + } else if (m_fileHeader.ByteOrder == swappedMagicByteOrder){ + m_hostByteOrder = false; + } else { + abort(); + } + + return true; +} // BackupFile::readHeader + +bool +BackupFile::validateFooter(){ + return true; +} + +bool +RestoreDataIterator::readFragmentHeader(int & ret) +{ + BackupFormat::DataFile::FragmentHeader Header; + + debug << "RestoreDataIterator::getNextFragment" << endl; + + if (fread(&Header, sizeof(Header), 1, m_file) != 1){ + ret = 0; + return false; + } // if + + Header.SectionType = ntohl(Header.SectionType); + Header.SectionLength = ntohl(Header.SectionLength); + Header.TableId = ntohl(Header.TableId); + Header.FragmentNo = ntohl(Header.FragmentNo); + Header.ChecksumType = ntohl(Header.ChecksumType); + + debug << "FragmentHeader: " << Header.SectionType + << " " << Header.SectionLength + << " " << Header.TableId + << " " << Header.FragmentNo + << " " << Header.ChecksumType << endl; + + m_currentTable = m_metaData.getTable(Header.TableId); + if(m_currentTable == 0){ + ret = -1; + return false; + } + + info << "_____________________________________________________" << endl + << "Restoring data in table: " << m_currentTable->getTableName() + << "(" << Header.TableId << ") fragment " + << Header.FragmentNo << endl; + + m_count = 0; + ret = 0; + return true; +} // RestoreDataIterator::getNextFragment + + +bool +RestoreDataIterator::validateFragmentFooter() { + BackupFormat::DataFile::FragmentFooter footer; + + if (fread(&footer, sizeof(footer), 1, m_file) != 1){ + err << "getFragmentFooter:Error reading fragment footer" << endl; + return false; + } + + // TODO: Handle footer, nothing yet + footer.SectionType = ntohl(footer.SectionType); + footer.SectionLength = ntohl(footer.SectionLength); + footer.TableId = ntohl(footer.TableId); + footer.FragmentNo = ntohl(footer.FragmentNo); + footer.NoOfRecords = ntohl(footer.NoOfRecords); + footer.Checksum = ntohl(footer.Checksum); + + assert(m_count == footer.NoOfRecords); + + return true; +} // RestoreDataIterator::getFragmentFooter + +void TableS::createAttr(const char* name, + const AttrType type, + const unsigned int size, // in bytes + const unsigned int arraySize, + const bool nullable, + const KeyType key) +{ + AttributeDesc desc; + + strncpy(desc.name, name, AttrNameLenC); + desc.type = type; + desc.size = size; + desc.arraySize = arraySize; + desc.nullable = nullable; + desc.key = key; + desc.attrId = allAttributesDesc.size(); + + AttributeDesc * d = new AttributeDesc(desc); + if(d == NULL) { + ndbout_c("Restore: Failed to allocate memory"); + abort(); + } + allAttributesDesc.push_back(d); + + if(desc.key != NoKey /* && not variable */){ + m_fixedKeys.push_back(d); + return; + } + if(!nullable){ + m_fixedAttribs.push_back(d); + return; + } + if(nullable){ + d->m_nullBitIndex = m_noOfNullable; + m_noOfNullable++; + m_nullBitmaskSize = (m_noOfNullable + 31) / 32; + } + m_variableAttribs.push_back(d); +} // TableS::createAttr + +Uint16 Twiddle16(Uint16 in) +{ + Uint16 retVal = 0; + + retVal = ((in & 0xFF00) >> 8) | + ((in & 0x00FF) << 8); + + return(retVal); +} // Twiddle16 + +Uint32 Twiddle32(Uint32 in) +{ + Uint32 retVal = 0; + + retVal = ((in & 0x000000FF) << 24) | + ((in & 0x0000FF00) << 8) | + ((in & 0x00FF0000) >> 8) | + ((in & 0xFF000000) >> 24); + + return(retVal); +} // Twiddle32 + +Uint64 Twiddle64(Uint64 in) +{ + Uint64 retVal = 0; + + retVal = + ((in & (Uint64)0x00000000000000FFLL) << 56) | + ((in & (Uint64)0x000000000000FF00LL) << 40) | + ((in & (Uint64)0x0000000000FF0000LL) << 24) | + ((in & (Uint64)0x00000000FF000000LL) << 8) | + ((in & (Uint64)0x000000FF00000000LL) >> 8) | + ((in & (Uint64)0x0000FF0000000000LL) >> 24) | + ((in & (Uint64)0x00FF000000000000LL) >> 40) | + ((in & (Uint64)0xFF00000000000000LL) >> 56); + + return(retVal); +} // Twiddle64 + + +RestoreLogIterator::RestoreLogIterator(const RestoreMetaData & md) + : m_metaData(md) +{ + debug << "RestoreLog constructor" << endl; + setLogFile(md, 0); + + m_count = 0; +} + +const LogEntry * +RestoreLogIterator::getNextLogEntry(int & res) { + // Read record length + typedef BackupFormat::LogFile::LogEntry LogE; + + Uint32 gcp = 0; + LogE * logE = 0; + Uint32 len = ~0; + const Uint32 stopGCP = m_metaData.getStopGCP(); + do { + + if(createBuffer(4) == 0) { + res = -1; + return NULL; + } + + + if (fread(m_buffer, sizeof(Uint32), 1, m_file) != 1){ + res = -1; + return NULL; + } + + m_buffer[0] = ntohl(m_buffer[0]); + len = m_buffer[0]; + if(len == 0){ + res = 0; + return 0; + } + + if(createBuffer(4 * (len + 1)) == 0){ + res = -1; + return NULL; + } + + if (fread(&m_buffer[1], 4, len, m_file) != len) { + res = -1; + return NULL; + } + + logE = (LogE *)&m_buffer[0]; + logE->TableId = ntohl(logE->TableId); + logE->TriggerEvent = ntohl(logE->TriggerEvent); + + const bool hasGcp = (logE->TriggerEvent & 0x10000) != 0; + logE->TriggerEvent &= 0xFFFF; + + if(hasGcp){ + len--; + gcp = ntohl(logE->Data[len-2]); + } + } while(gcp > stopGCP + 1); + + for(int i=0; iTableId); + switch(logE->TriggerEvent){ + case TriggerEvent::TE_INSERT: + m_logEntry.m_type = LogEntry::LE_INSERT; + break; + case TriggerEvent::TE_UPDATE: + m_logEntry.m_type = LogEntry::LE_UPDATE; + break; + case TriggerEvent::TE_DELETE: + m_logEntry.m_type = LogEntry::LE_DELETE; + break; + default: + res = -1; + return NULL; + } + + const TableS * tab = m_logEntry.m_table; + + AttributeHeader * ah = (AttributeHeader *)&logE->Data[0]; + AttributeHeader *end = (AttributeHeader *)&logE->Data[len - 2]; + AttributeS * attr; + while(ah < end){ + attr = new AttributeS; + if(attr == NULL) { + ndbout_c("Restore: Failed to allocate memory"); + res = -1; + return NULL; + } + attr->Desc = (* tab)[ah->getAttributeId()]; + assert(attr->Desc != 0); + + const Uint32 sz = ah->getDataSize(); + if(sz == 0){ + attr->Data.null = true; + attr->Data.void_value = NULL; + } else { + attr->Data.null = false; + attr->Data.void_value = ah->getDataPtr(); + } + + Twiddle(attr); + m_logEntry.m_values.push_back(attr); + + ah = ah->getNext(); + } + + m_count ++; + res = 0; + return &m_logEntry; +} diff --git a/ndb/src/kernel/blocks/backup/restore/Restore.hpp b/ndb/src/kernel/blocks/backup/restore/Restore.hpp new file mode 100644 index 00000000000..f214bcb1380 --- /dev/null +++ b/ndb/src/kernel/blocks/backup/restore/Restore.hpp @@ -0,0 +1,328 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef RESTORE_H +#define RESTORE_H + +#include +#include +#include +#include + +#include +#include "myVector.hpp" +#include +#include +#include + +#include +#include + +#define VERSION_3X 3 + + +const int FileNameLenC = 256; +const int TableNameLenC = 256; +const int AttrNameLenC = 256; +const Uint32 timeToWaitForNdbC = 10000; +const Uint32 opsDefaultC = 1000; + +// Forward declarations +//class AttributeDesc; +struct AttributeDesc; +struct AttributeData; +struct AttributeS; + +struct AttributeData { + bool null; + Uint32 size; + union { + Int8 * int8_value; + Uint8 * u_int8_value; + + Int16 * int16_value; + Uint16 * u_int16_value; + + Int32 * int32_value; + Uint32 * u_int32_value; + + Int64 * int64_value; + Uint64 * u_int64_value; + + char * string_value; + + void* void_value; + }; +}; + +struct AttributeDesc { + //private: + // TODO (sometimes): use a temporary variable in DTIMAP so we can + // hide AttributeDesc private variables + friend class TupleS; + friend class TableS; + friend class RestoreDataIterator; + friend class RestoreMetaData; + friend struct AttributeS; + char name[AttrNameLenC]; + Uint32 attrId; + AttrType type; + bool nullable; + KeyType key; + Uint32 size; // bits + Uint32 arraySize; + + Uint32 m_nullBitIndex; +public: + + AttributeDesc() { + name[0] = 0; + } + + Uint32 getSizeInWords() const { return (size * arraySize + 31)/ 32;} +}; // AttributeDesc + +struct AttributeS { + const AttributeDesc * Desc; + AttributeData Data; +}; + +class TupleS { +private: + friend class RestoreDataIterator; + + const TableS * m_currentTable; + myVector allAttributes; + Uint32 * dataRecord; + bool prepareRecord(const TableS &); + +public: + TupleS() {dataRecord = NULL;}; + ~TupleS() {if(dataRecord != NULL) delete [] dataRecord;}; + int getNoOfAttributes() const { return allAttributes.size(); }; + const TableS * getTable() const { return m_currentTable;}; + const AttributeS * operator[](int i) const { return allAttributes[i];}; + Uint32 * getDataRecord() { return dataRecord;}; + void createDataRecord(Uint32 bytes) { dataRecord = new Uint32[bytes];}; +}; // class TupleS + +class TableS { + + friend class TupleS; + friend class RestoreMetaData; + friend class RestoreDataIterator; + + Uint32 tableId; + char tableName[TableNameLenC]; + Uint32 schemaVersion; + Uint32 backupVersion; + myVector allAttributesDesc; + myVector m_fixedKeys; + //myVector m_variableKey; + myVector m_fixedAttribs; + myVector m_variableAttribs; + + Uint32 m_noOfNullable; + Uint32 m_nullBitmaskSize; + + int pos; + char create_string[2048]; + /* + char mysqlTableName[1024]; + char mysqlDatabaseName[1024]; + */ + + void createAttr(const char* name, + const AttrType type, + const unsigned int size, // in bits + const unsigned int arraySize, + const bool nullable, + const KeyType key); + +#ifndef restore_old_types +public: + class NdbDictionary::Table* m_dictTable; +#endif +public: + TableS (const char * name){ + snprintf(tableName, sizeof(tableName), name); + m_noOfNullable = m_nullBitmaskSize = 0; + } + + void setTableId (Uint32 id) { + tableId = id; + } + + Uint32 getTableId() const { + return tableId; + } + /* + void setMysqlTableName(char * tableName) { + strpcpy(mysqlTableName, tableName); + } + + char * + void setMysqlDatabaseName(char * databaseName) { + strpcpy(mysqlDatabaseName, databaseName); + } + + table.setMysqlDatabaseName(database); + */ + void setBackupVersion(Uint32 version) { + backupVersion = version; + } + + + Uint32 getBackupVersion() const { + return backupVersion; + } + + const char * getTableName() const { + return m_dictTable->getName(); + } + + int getNoOfAttributes() const { + return allAttributesDesc.size(); + }; + + /** + * Get attribute descriptor + */ + const AttributeDesc * operator[](int attributeId) const { + return allAttributesDesc[attributeId]; + } + + TableS& operator=(TableS& org) ; +}; // TableS; + +class BackupFile { +protected: + FILE * m_file; + char m_path[PATH_MAX]; + char m_fileName[PATH_MAX]; + bool m_hostByteOrder; + BackupFormat::FileHeader m_fileHeader; + BackupFormat::FileHeader m_expectedFileHeader; + + Uint32 m_nodeId; + Uint32 * m_buffer; + Uint32 m_bufferSize; + Uint32 * createBuffer(Uint32 bytes); + + bool openFile(); + void setCtlFile(Uint32 nodeId, Uint32 backupId, const char * path); + void setDataFile(const BackupFile & bf, Uint32 no); + void setLogFile(const BackupFile & bf, Uint32 no); + + void setName(const char * path, const char * name); + + BackupFile(); + ~BackupFile(); +public: + bool readHeader(); + bool validateFooter(); + + const char * getPath() const { return m_path;} + const char * getFilename() const { return m_fileName;} + Uint32 getNodeId() const { return m_nodeId;} + const BackupFormat::FileHeader & getFileHeader() const { return m_fileHeader;} + bool Twiddle(AttributeS * attr, Uint32 arraySize = 0); +}; + +class RestoreMetaData : public BackupFile { + + myVector allTables; + bool readMetaFileHeader(); + bool readMetaTableDesc(const char * catalog, + const char * schema); + + bool readGCPEntry(); + Uint32 readMetaTableList(); + + Uint32 m_startGCP; + Uint32 m_stopGCP; + + bool parseTableDescriptor(const Uint32 * data, Uint32 len, + const char * catalog, + const char * schema); + +public: + + RestoreMetaData(const char * path, Uint32 nodeId, Uint32 bNo); + ~RestoreMetaData(); + + int loadContent(const char * catalog, + const char * schema); + + + + Uint32 getNoOfTables() const { return allTables.size();} + + const TableS * operator[](int i) const { return allTables[i];} + const TableS * getTable(Uint32 tableId) const; + + Uint32 getStopGCP() const; +}; // RestoreMetaData + + +class RestoreDataIterator : public BackupFile { + const RestoreMetaData & m_metaData; + + Uint32 m_count; + TupleS m_tuple; + const TableS* m_currentTable; +public: + + // Constructor + RestoreDataIterator(const RestoreMetaData &); + ~RestoreDataIterator(); + + // Read data file fragment header + bool readFragmentHeader(int & res); + bool validateFragmentFooter(); + + const TupleS *getNextTuple(int & res); +}; + +class LogEntry { +public: + enum EntryType { + LE_INSERT, + LE_DELETE, + LE_UPDATE + }; + EntryType m_type; + const TableS * m_table; + myVector m_values; + + +}; + +class RestoreLogIterator : public BackupFile { +private: + const RestoreMetaData & m_metaData; + + Uint32 m_count; + LogEntry m_logEntry; +public: + RestoreLogIterator(const RestoreMetaData &); + + const LogEntry * getNextLogEntry(int & res); +}; + +#endif + + diff --git a/ndb/src/kernel/blocks/backup/restore/main.cpp b/ndb/src/kernel/blocks/backup/restore/main.cpp new file mode 100644 index 00000000000..52857aa2c42 --- /dev/null +++ b/ndb/src/kernel/blocks/backup/restore/main.cpp @@ -0,0 +1,1689 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include "Restore.hpp" +#include +#include +#include +#include +#ifdef USE_MYSQL +#include +#endif +NdbOut& operator<<(NdbOut& ndbout, const TupleS& tuple); +NdbOut& operator<<(NdbOut& ndbout, const LogEntry& logEntry); +NdbOut& operator<<(NdbOut& ndbout, const RestoreMetaData &); + +extern FilteredNdbOut err; +extern FilteredNdbOut info; +extern FilteredNdbOut debug; + +static const char * delimiter = ";"; // Delimiter in file dump + +static int ga_nodeId = 0; +static int ga_nParallelism = 1; +static int ga_backupId = 0; +static bool ga_dont_ignore_systab_0 = false; +static myVector g_consumers; + +#ifdef USE_MYSQL +/** + * mysql specific stuff: + */ +static const char* ga_user = "root"; +static const char* ga_host = "localhost"; +static const char* ga_socket = "/tmp/mysql.sock"; +static const char* ga_password = ""; +static const char* ga_database = ""; +static int ga_port = 3306; +static bool use_mysql = false; +static MYSQL mysql; +#endif + + +#ifdef NDB_WIN32 +static const char* ga_backupPath = ".\\"; +#else +static const char* ga_backupPath = "./"; +#endif + +typedef struct { + void * ndb; + void * restore; + TupleS * tup; + int transaction; + int retries; +} restore_callback_t; + +static const char* ga_connect_NDB = NULL; +static const char* ga_schema = NULL; +static const char* ga_catalog = NULL; + + + +/** + * print and restore flags + */ +static bool ga_restore = false; +static bool ga_print = false; + + + +class BackupConsumer { +public: + virtual bool init() { return true;} + virtual bool table(const TableS &){return true;} +#ifdef USE_MYSQL + virtual bool table(const TableS &, MYSQL* mysqlp) {return true;}; +#endif + virtual void tuple(const TupleS &){} + virtual void tupleAsynch(const TupleS &, restore_callback_t * callback) {}; + // virtual bool asynchErrorHandler(NdbConnection * trans){return true;}; + virtual void asynchExitHandler(){}; + virtual void endOfTuples(){} + virtual void logEntry(const LogEntry &){} + virtual void endOfLogEntrys(){} +protected: + int create_table_string(const TableS & table, char * ,char *); +}; + +class BackupPrinter : public BackupConsumer +{ + NdbOut & m_ndbout; +public: + BackupPrinter(NdbOut & out = ndbout) : m_ndbout(out) + { + m_print = false; + m_print_log = false; + m_print_data = false; + m_print_meta = false; + } + + virtual bool table(const TableS &); +#ifdef USE_MYSQL + virtual bool table(const TableS &, MYSQL* mysqlp); +#endif + virtual void tuple(const TupleS &); + virtual void logEntry(const LogEntry &); + virtual void endOfTuples() {}; + virtual void endOfLogEntrys(); + virtual void tupleAsynch(const TupleS &, restore_callback_t * callback); + bool m_print; + bool m_print_log; + bool m_print_data; + bool m_print_meta; + Uint32 m_logCount; + Uint32 m_dataCount; + +}; + +class BackupRestore : public BackupConsumer +{ +public: + BackupRestore() + { + m_ndb = 0; + m_logCount = m_dataCount = 0; + m_restore = false; + m_restore_meta = false; + } + + virtual ~BackupRestore(); + + virtual bool init(); + virtual bool table(const TableS &); +#ifdef USE_MYSQL + virtual bool table(const TableS &, MYSQL* mysqlp); +#endif + virtual void tuple(const TupleS &); + virtual void tupleAsynch(const TupleS &, restore_callback_t * callback); + virtual void asynchExitHandler(); + virtual void endOfTuples(); + virtual void logEntry(const LogEntry &); + virtual void endOfLogEntrys(); + void connectToMysql(); + Ndb * m_ndb; + bool m_restore; + bool m_restore_meta; + Uint32 m_logCount; + Uint32 m_dataCount; +}; +bool +readArguments(const int argc, const char** argv) +{ + BackupPrinter* printer = new BackupPrinter(); + if (printer == NULL) + return false; + BackupRestore* restore = new BackupRestore(); + if (restore == NULL) + { + delete printer; + return false; + } + + int _print = 0; + int _print_meta = 0; + int _print_data = 0; + int _print_log = 0; + int _restore_data = 0; + int _restore_meta = 0; + + + struct getargs args[] = + { + { "connect", 'c', arg_string, &ga_connect_NDB, + "NDB Cluster connection", "\"nodeid=;host=\""}, + { "nodeid", 'n', arg_integer, &ga_nodeId, + "Backup files from node", "db node id"}, + { "backupid", 'b',arg_integer, &ga_backupId, "Backup id", "backup id"}, + { "print", '\0', arg_flag, &_print, + "Print data and log to stdout", "print data and log"}, + { "print_data", '\0', arg_flag, &_print_data, + "Print data to stdout", "print data"}, + { "print_meta", '\0', arg_flag, &_print_meta, + "Print meta data to stdout", "print meta data"}, + { "print_log", '\0', arg_flag, &_print_log, + "Print log to stdout", "print log"}, + { "restore_data", 'r', arg_flag, &_restore_data, + "Restore table data/logs into NDB Cluster using NDBAPI", + "Restore table data/log"}, + { "restore_meta", 'm', arg_flag, &_restore_meta, + "Restore meta data into NDB Cluster using NDBAPI", "Restore meta data"}, + { "parallelism", 'p', arg_integer, &ga_nParallelism, + "No of parallel transactions during restore of data." + "(parallelism can be 1 to 1024)", + "Parallelism"}, +#if NDB_VERSION_MAJOR >= VERSION_3X + { "catalog", 'd', arg_string, &ga_catalog, + "Specifies the catalog/database where the data should be restored to. " + "Restores only to backups taken with v.2.x and restored on >v.3.x " + "systems. Note: system tables (if restored) defaults to sys/def/ ", + "catalog"}, + { "schema", 's', arg_string, &ga_schema, + "Specifies the schema where the data should be restored to." + "Restores only to backups taken with v.2.x and restored on >v.3.x " + "systems. Note: system tables (if restored) defaults to sys/def/ ", + "schema"}, +#endif +#ifdef USE_MYSQL + { "use_mysql", '\0', arg_flag, &use_mysql, + "Restore meta data via mysql. Systab will be ignored. Data is restored " + "using NDBAPI.", "use mysql"}, + { "user", '\0', arg_string, &ga_user, "MySQL user", "Default: root"}, + { "password", '\0', arg_string, &ga_password, "MySQL user's password", + "Default: \"\" "}, + { "host", '\0', arg_string, &ga_host, "Hostname of MySQL server", + "Default: localhost"}, + { "socket", '\0', arg_string, &ga_socket, "Path to MySQL server socket file", + "Default: /tmp/mysql.sock"}, + { "port", '\0', arg_integer, &ga_port, "Port number of MySQL server", + "Default: 3306"}, +#endif + { "dont_ignore_systab_0", 'f', arg_flag, &ga_dont_ignore_systab_0, + "Experimental. Do not ignore system table during restore.", + "dont_ignore_systab_0"} + + }; + + int num_args = sizeof(args) / sizeof(args[0]); + int optind = 0; + + if (getarg(args, num_args, argc, argv, &optind) || + ga_nodeId == 0 || + ga_backupId == 0 || + ga_nParallelism < 1 || + ga_nParallelism >1024) + { + + arg_printusage(args, num_args, argv[0], "\n"); + delete printer; + delete restore; + return false; + } + + /** + * Got segmentation fault when using the printer's attributes directly + * in getargs... Do not have the time to found out why... this is faster... + */ + if (_print) + { + ga_print = true; + ga_restore = true; + printer->m_print = true; + } + if (_print_meta) + { + ga_print = true; + printer->m_print_meta = true; + } + if (_print_data) + { + ga_print = true; + printer->m_print_data = true; + } + if (_print_log) + { + ga_print = true; + printer->m_print_log = true; + } + + if (_restore_data) + { + ga_restore = true; + restore->m_restore = true; + } + + if (_restore_meta) + { + // ga_restore = true; + restore->m_restore_meta = true; + } + + { + BackupConsumer * c = printer; + g_consumers.push_back(c); + } + { + BackupConsumer * c = restore; + g_consumers.push_back(c); + } + // Set backup file path + if (argv[optind] != NULL) + { + ga_backupPath = argv[optind]; + } +#ifdef USE_MYSQL + if(use_mysql) { + ga_dont_ignore_systab_0 = false; + ga_database = ""; //not used yet. pethaps later if we want to + // restore meta data in an existing mysql database, + // and not just restore it to the same database + // as when the backup was taken. + // If implementing this, then the + // tupleAsynch must also be changed so that the + // table data is restored to the correct table. + // also, mysql_select_db must be set properly (ie., + // ignored in codw below) + } +#endif + + return true; +} + + +void +clearConsumers() +{ + for(int i = 0; i= VERSION_3X + Ndb::useFullyQualifiedNames(false); +#endif + + /** + * we must always load meta data, even if we will only print it to stdout + */ + RestoreMetaData metaData(ga_backupPath, ga_nodeId, ga_backupId); + if (!metaData.readHeader()) + { + ndbout << "Failed to read " << metaData.getFilename() << endl << endl; + return -1; + } + /** + * check wheater we can restore the backup (right version, and if that + * version needs catalog and schema specified. + */ + int res = metaData.loadContent(ga_catalog, ga_schema); + + if (res == 0) + { + ndbout_c("Restore: Failed to load content"); + return -1; + } + if (res == -1) + { + ndbout_c("Restore: The backup is from a NDB Cluster v.2.x version. " + "To restore this backup on a > 3.x version you must specify " + "catalog and schema."); + return -1; + } + if (res == -2) + { +#ifdef NDB_VERSION + ndbout_c("Restore: The backup is from a NDB Cluster v.3.x version " + "Catalog and schema are invalid parameters since they " + "already exist implicitly."); +#endif +#ifdef NDB_KERNEL_VERSION + ndbout_c("Restore: The backup is from a NDB Cluster v.3.x version " + "It is not possible to restore a 3.x backup on v.2.x. "); +#endif + return -1; + } + + if (res == -3) + { + ndbout_c("Restore: The backup contains no tables " + "Catalog and schema are invalid parameters. "); + return -1; + } + + + if (!metaData.validateFooter()) + { + ndbout_c("Restore: Failed to validate footer."); + return -1; + } + + + for(int i = 0; iinit()) + { + clearConsumers(); + return -11; + } + + } + + for(Uint32 i = 0; igetTableName())) + { + for(int j = 0; jtable(* metaData[i], &mysql)) + { + ndbout_c("Restore: Failed to restore table: %s. " + "Exiting...", + metaData[i]->getTableName()); + return -11; + } + } else +#endif + if (!g_consumers[j]->table(* metaData[i])) + { + ndbout_c("Restore: Failed to restore table: %s. " + "Exiting...", + metaData[i]->getTableName()); + return -11; + } + + } + } + + + + if (ga_restore || ga_print) + { + if (ga_restore) + { + RestoreDataIterator dataIter(metaData); + + // Read data file header + if (!dataIter.readHeader()) + { + ndbout << "Failed to read header of data file. Exiting..." ; + return -11; + } + + + while (dataIter.readFragmentHeader(res)) + { + const TupleS* tuple = 0; + while ((tuple = dataIter.getNextTuple(res)) != NULL) + { + if (checkSysTable(tuple->getTable()->getTableName())) + { + for(int i = 0; itupleAsynch(* tuple, 0); + } + } + } while (tuple != NULL); + + if (res < 0) + { + ndbout_c("Restore: An error occured while restoring data. " + "Exiting..."); + return -1; + } + if (!dataIter.validateFragmentFooter()) { + ndbout_c("Restore: Error validating fragment footer. " + "Exiting..."); + return -1; + } + } // while (dataIter.readFragmentHeader(res)) + + if (res < 0) + { + ndbout_c("Restore: An error occured while restoring data. " + "Exiting..."); + return -1; + } + + + dataIter.validateFooter(); //not implemented + for (int i = 0; iendOfTuples(); + + RestoreLogIterator logIter(metaData); + if (!logIter.readHeader()) + { + ndbout << "Failed to read header of data file. Exiting..."; + return -1; + } + + /** + * I have not touched the part below : -johan 040218 + * except fixing return values. + */ + const LogEntry * logEntry = 0; + while ((logEntry = logIter.getNextLogEntry(res))) + { + if (checkSysTable(logEntry->m_table->getTableName())) + { + for(int i = 0; ilogEntry(* logEntry); + } + } + if (res < 0) + { + ndbout_c("Restore: An restoring the data log" + "Exiting..."); + return -1; + } + logIter.validateFooter(); //not implemented + for (int i = 0; iendOfLogEntrys(); + } + } + clearConsumers(); + return 1; +} // main + +NdbOut & +operator<<(NdbOut& ndbout, const AttributeS& attr){ + const AttributeData & data = attr.Data; + const AttributeDesc & desc = * attr.Desc; + + if (data.null) + { + ndbout << ""; + return ndbout; + } + + if (desc.arraySize > 1) + ndbout << "[ "; + for (Uint32 j = 0; j < desc.arraySize; j++) + { + // Print strings without spaces, + // (but ndbout char does not work as expected, see below) + switch (desc.type) + { + case Signed: + switch (desc.size) + { + case 8: + ndbout << (short)data.int8_value[j]; + break; + case 16: + ndbout << data.int16_value[j]; + break; + case 32: + ndbout << data.int32_value[j]; + break; + case 64: + ndbout << data.int64_value[j]; + break; + case 128: + ndbout << "Signed sz = 128 - this is something wrong??" << endl; + break; + default: + // Unknown, error + break; + } // switch size + break; + case UnSigned: + switch (desc.size) + { + case 8: + ndbout << (short)data.u_int8_value[j]; + break; + case 16: + ndbout << data.u_int16_value[j]; + break; + case 32: + ndbout << data.u_int32_value[j]; + break; + case 64: + ndbout << data.u_int64_value[j]; + break; + case 128: + ndbout << "UnSigned sz = 128 - this is something wrong??" << endl; + break; + default: + // Unknown, error + break; + } // switch size + break; + case (String): + if (desc.size == 8) + { + ndbout << data.string_value; + j = desc.arraySize; + } // if + else + { + ndbout << "String sz != 8 - this is something wrong??" << endl; + } + break; + case (Float): + // Not yet supported to print float + ndbout << "float"; + break; + default: + ndbout << "Not defined Attr Type"; + } // switch AttrType + ndbout << " "; + } // for ArraySize + if (desc.arraySize > 1) + { + ndbout << "]"; + } + return ndbout; +} + +// Print tuple data +NdbOut& +operator<<(NdbOut& ndbout, const TupleS& tuple) +{ + ndbout << tuple.getTable()->getTableName() << "; "; + for (int i = 0; i < tuple.getNoOfAttributes(); i++) + { + const AttributeS * attr = tuple[i]; + debug << i << " " << attr->Desc->name; + + ndbout << (* attr); + + if (i != (tuple.getNoOfAttributes() - 1)) + ndbout << delimiter << " "; + } // for + return ndbout; +} + +// Print tuple data +NdbOut& +operator<<(NdbOut& ndbout, const LogEntry& logE) +{ + switch(logE.m_type) + { + case LogEntry::LE_INSERT: + ndbout << "INSERT " << logE.m_table->getTableName() << " "; + break; + case LogEntry::LE_DELETE: + ndbout << "DELETE " << logE.m_table->getTableName() << " "; + break; + case LogEntry::LE_UPDATE: + ndbout << "UPDATE " << logE.m_table->getTableName() << " "; + break; + default: + ndbout << "Unknown log entry type (not insert, delete or update)" ; + } + + for (int i = 0; i < logE.m_values.size();i++) + { + const AttributeS * attr = logE.m_values[i]; + ndbout << attr->Desc->name << "="; + ndbout << (* attr); + if (i < (logE.m_values.size() - 1)) + ndbout << ", "; + } + return ndbout; +} + + +NdbOut & +operator<<(NdbOut& ndbout, const TableS & table){ + ndbout << endl << "Table: " << table.getTableName() << endl; + for (int j = 0; j < table.getNoOfAttributes(); j++) + { + const AttributeDesc * desc = table[j]; + ndbout << desc->name << ": "; + NdbDictionary::Column::Type type = table.m_dictTable->getColumn(desc->attrId)->getType(); + switch(type){ + case NdbDictionary::Column::Int: + ndbout << "Int "; + break; + case NdbDictionary::Column::Unsigned: + ndbout << "Unsigned "; + break; + case NdbDictionary::Column::Float: + ndbout << "Float "; + break; + case NdbDictionary::Column::Decimal: + ndbout << "Decimal "; + break; + case NdbDictionary::Column::Char: + ndbout << "Char "; + break; + case NdbDictionary::Column::Varchar: + ndbout << "Varchar "; + break; + case NdbDictionary::Column::Binary: + ndbout << "Binary "; + break; + case NdbDictionary::Column::Varbinary: + ndbout << "Varbinary "; + break; + case NdbDictionary::Column::Bigint: + ndbout << "Bigint "; + break; + case NdbDictionary::Column::Bigunsigned: + ndbout << "Bigunsigned "; + break; + case NdbDictionary::Column::Double: + ndbout << "Double "; + break; + case NdbDictionary::Column::Datetime: + ndbout << "Datetime "; + break; + case NdbDictionary::Column::Timespec: + ndbout << "Timespec "; + break; + case NdbDictionary::Column::Undefined: + ndbout << "Undefined "; + break; + default: + ndbout << "Unknown(" << type << ")"; + } + ndbout << " key: " << desc->key; + ndbout << " array: " << desc->arraySize; + ndbout << " size: " << desc->size << endl; + } // for + return ndbout; +} + + +#if 0 +/***************************************** + * + * Callback function for asynchronous transactions + * + * Idea for error handling: Transaction objects have to be stored globally when + * they are prepared. + * In the callback function if the transaction: + * succeeded: delete the object from global storage + * failed but can be retried: execute the object that is in global storage + * failed but fatal: delete the object from global storage + * + ******************************************/ +static void restoreCallback(int result, // Result for transaction + NdbConnection *object, // Transaction object + void *anything) // Not used +{ + static Uint32 counter = 0; + + + debug << "restoreCallback function called " << counter << " time(s)" << endl; + + ++counter; + + if (result == -1) + { + ndbout << " restoreCallback (" << counter; + if ((counter % 10) == 1) + { + ndbout << "st"; + } // if + else if ((counter % 10) == 2) + { + ndbout << "nd"; + } // else if + else if ((counter % 10 ) ==3) + { + ndbout << "rd"; + } // else if + else + { + ndbout << "th"; + } // else + err << " time: error detected " << object->getNdbError() << endl; + } // if + +} // restoreCallback +#endif + + + + +bool +BackupPrinter::table(const TableS & tab) +{ + if (m_print || m_print_meta) + { + m_ndbout << tab; + ndbout_c("Successfully printed table: %s", tab.m_dictTable->getName()); + } + return true; +} + +#ifdef USE_MYSQL +bool +BackupPrinter::table(const TableS & tab, MYSQL * mysql) +{ + if (m_print || m_print_meta) + { + + char tmpTabName[MAX_TAB_NAME_SIZE*2]; + sprintf(tmpTabName, "%s", tab.getTableName()); + char * database = strtok(tmpTabName, "/"); + char * schema = strtok( NULL , "/"); + char * tableName = strtok( NULL , "/"); + + /** + * this means that the user did not specify schema + * and it is a v2x backup + */ + if(database == NULL) + return false; + if(schema == NULL) + return false; + if(tableName==NULL) + tableName = schema; + + char stmtCreateDB[255]; + + sprintf(stmtCreateDB,"CREATE DATABASE %s", database); + ndbout_c("%s", stmtCreateDB); + + + char buf [2048]; + create_table_string(tab, tableName, buf); + ndbout_c("%s", buf); + + ndbout_c("Successfully printed table: %s", tab.m_dictTable->getName()); + } + return true; +} + +#endif + +void +BackupPrinter::tuple(const TupleS & tup) +{ + if (m_print || m_print_data) + m_ndbout << tup << endl; +} + +void +BackupPrinter::logEntry(const LogEntry & logE) +{ + if (m_print || m_print_log) + m_ndbout << logE << endl; + m_logCount++; +} + +bool +BackupRestore::init() +{ + + if (!m_restore && !m_restore_meta) + return true; + + if (ga_connect_NDB != NULL) + { + // Use connection string + Ndb::setConnectString(ga_connect_NDB); + } + + m_ndb = new Ndb("TEST_DB"); + if (m_ndb == NULL) + return false; + + m_ndb->init(1024); + if (m_ndb->waitUntilReady(30) != 0) + { + ndbout << "Failed to connect to ndb!!" << endl; + delete m_ndb; + return false; + } + ndbout << "Connected to ndb!!" << endl; + +#if USE_MYSQL + if(use_mysql) + { + if ( mysql_thread_safe() == 0 ) + { + ndbout << "Not thread safe mysql library..." << endl; + exit(-1); + } + + ndbout << "Connecting to MySQL..." <name << ": "; + pos += sprintf(buf+pos, "%s%s", desc->name," "); + NdbDictionary::Column::Type type = table.m_dictTable->getColumn(desc->attrId)->getType(); + switch(type){ + case NdbDictionary::Column::Int: + pos += sprintf(buf+pos, "%s", "int"); + break; + case NdbDictionary::Column::Unsigned: + pos += sprintf(buf+pos, "%s", "int unsigned"); + break; + case NdbDictionary::Column::Float: + pos += sprintf(buf+pos, "%s", "float"); + break; + case NdbDictionary::Column::Decimal: + pos += sprintf(buf+pos, "%s", "decimal"); + break; + case NdbDictionary::Column::Char: + pos += sprintf(buf+pos, "%s", "char"); + break; + case NdbDictionary::Column::Varchar: + pos += sprintf(buf+pos, "%s", "varchar"); + break; + case NdbDictionary::Column::Binary: + pos += sprintf(buf+pos, "%s", "binary"); + break; + case NdbDictionary::Column::Varbinary: + pos += sprintf(buf+pos, "%s", "varchar binary"); + break; + case NdbDictionary::Column::Bigint: + pos += sprintf(buf+pos, "%s", "bigint"); + break; + case NdbDictionary::Column::Bigunsigned: + pos += sprintf(buf+pos, "%s", "bigint unsigned"); + break; + case NdbDictionary::Column::Double: + pos += sprintf(buf+pos, "%s", "double"); + break; + case NdbDictionary::Column::Datetime: + pos += sprintf(buf+pos, "%s", "datetime"); + break; + case NdbDictionary::Column::Timespec: + pos += sprintf(buf+pos, "%s", "time"); + break; + case NdbDictionary::Column::Undefined: + // pos += sprintf(buf+pos, "%s", "varchar binary"); + return -1; + break; + default: + //pos += sprintf(buf+pos, "%s", "varchar binary"); + return -1; + } + if (desc->arraySize > 1) { + int attrSize = desc->arraySize; + pos += sprintf(buf+pos, "%s%u%s", + "(", + attrSize, + ")"); + } + if (table.m_dictTable->getColumn(desc->attrId)->getPrimaryKey()) { + pos += sprintf(buf+pos, "%s", " not null"); + pos2 += sprintf(buf2+pos2, "%s%s", desc->name, ","); + } + pos += sprintf(buf+pos, "%s", ","); + } // for + pos2--; // remove trailing comma + pos2 += sprintf(buf2+pos2, "%s", ")"); + // pos--; // remove trailing comma + + pos += sprintf(buf+pos, "%s", buf2); + pos += sprintf(buf+pos, "%s", ") type=ndbcluster"); + return 0; +} + + + +bool +BackupRestore::table(const TableS & table){ + if (!m_restore_meta) + { + return true; + } +#ifndef restore_old_types + NdbDictionary::Dictionary* dict = m_ndb->getDictionary(); + if (dict->createTable(*table.m_dictTable) == -1) + { + err << "Create table " << table.getTableName() << " failed: " + << dict->getNdbError() << endl; + return false; + } + info << "Successfully restored table " << table.getTableName()<< endl ; + return true; +#else + NdbSchemaCon * tableTransaction = 0; + NdbSchemaOp * tableOp = 0; + + tableTransaction = m_ndb->startSchemaTransaction(); + if (tableTransaction == NULL) + { + err << table.getTableName() + << " - BackupRestore::table cannot startSchemaTransaction: " + << tableTransaction->getNdbError() << endl; + return false; + } // if + + tableOp = tableTransaction->getNdbSchemaOp(); + if (tableOp == NULL) + { + err << table.getTableName() + << " - BackupRestore::table cannot getNdbSchemaOp: " + << tableTransaction->getNdbError() << endl; + m_ndb->closeSchemaTransaction(tableTransaction); + return false; + } // if + + // TODO: check for errors in table attributes. set aTupleKey + int check = 0; + check = tableOp->createTable(table.getTableName()); + // aTableSize = 8, Not used? + // aTupleKey = TupleKey, go through attributes and check if there is a PK + // and so on.... + if (check == -1) + { + err << table.getTableName() + << " - BackupRestore::table cannot createTable: " + << tableTransaction->getNdbError() << endl; + m_ndb->closeSchemaTransaction(tableTransaction); + return false; + } // if + + // Create attributes from meta data + for (int i = 0; i < table.getNoOfAttributes(); i++) + { + const AttributeDesc* desc = table[i]; + check = tableOp->createAttribute(desc->name, // Attr name + desc->key, // Key type + desc->size, // bits + desc->arraySize, + desc->type, + MMBased, // only supported + desc->nullable + // Rest is don't care for the moment + ); + + if (check == -1) + { + err << table.getTableName() + << " - RestoreDataIterator::createTable cannot createAttribute: " + << tableTransaction->getNdbError() << endl; + m_ndb->closeSchemaTransaction(tableTransaction); + return false; + } // if + } // for + + if (tableTransaction->execute() == -1) + { + err << table.getTableName() + << " - RestoreDataIterator::createTable cannot execute transaction: " + << tableTransaction->getNdbError() << endl; + m_ndb->closeSchemaTransaction(tableTransaction); + return false; + } // if + + m_ndb->closeSchemaTransaction(tableTransaction); + info << "Successfully created table " << table.getTableName() << endl; + return true ; +#endif +} + + + +/* + * callback : This is called when the transaction is polled + * + * (This function must have three arguments: + * - The result of the transaction, + * - The NdbConnection object, and + * - A pointer to an arbitrary object.) + */ + +static void +callback(int result, NdbConnection* trans, void* aObject) +{ + restore_callback_t * cbData = (restore_callback_t *)aObject; + if (result<0) + { + /** + * Error. temporary or permanent? + */ + if (asynchErrorHandler(trans, (Ndb*)cbData->ndb)) + { + ((Ndb*)cbData->ndb)->closeTransaction(asynchTrans[cbData->transaction]); + cbData->retries++; + ((BackupRestore*)cbData)->tupleAsynch( * (TupleS*)(cbData->tup), cbData); + } + else + { + ndbout_c("Restore: Failed to restore data " + "due to a unrecoverable error. Exiting..."); + delete (Ndb*)cbData->ndb; + delete cbData->tup; + delete cbData; + exit(-1); + } + } + else + { + /** + * OK! close transaction + */ + ((Ndb*)cbData->ndb)->closeTransaction(asynchTrans[cbData->transaction]); + delete cbData->tup; + delete cbData; + } +} + +static int nPreparedTransactions = 0; +void +BackupPrinter::tupleAsynch(const TupleS & tup, restore_callback_t * callback) +{ + m_dataCount++; + if (m_print || m_print_data) + m_ndbout << tup << endl; +} + +void BackupRestore::tupleAsynch(const TupleS & tup, restore_callback_t * cbData) +{ + + if (!m_restore) + { + delete &tup; + return; + } + Uint32 retries; + if (cbData!=0) + retries = cbData->retries; + else + retries = 0; + + while (retries < 10) + { + /** + * start transactions + */ + asynchTrans[nPreparedTransactions] = m_ndb->startTransaction(); + if (asynchTrans[nPreparedTransactions] == NULL) + { + if (asynchErrorHandler(asynchTrans[nPreparedTransactions], m_ndb)) + { + retries++; + continue; + } + asynchExitHandler(); + } // if + + const TableS * table = tup.getTable(); + NdbOperation * op = + asynchTrans[nPreparedTransactions]->getNdbOperation(table->getTableName()); + + if (op == NULL) + { + if (asynchErrorHandler(asynchTrans[nPreparedTransactions], m_ndb)) + { + retries++; + continue; + } + asynchExitHandler(); + } // if + + if (op->writeTuple() == -1) + { + if (asynchErrorHandler(asynchTrans[nPreparedTransactions], m_ndb)) + { + retries++; + continue; + } + asynchExitHandler(); + } // if + + Uint32 ret = 0; + for (int i = 0; i < tup.getNoOfAttributes(); i++) + { + const AttributeS * attr = tup[i]; + int size = attr->Desc->size; + int arraySize = attr->Desc->arraySize; + const KeyType key = attr->Desc->key; + char * dataPtr = attr->Data.string_value; + Uint32 length = (size * arraySize) / 8; + if (key == TupleKey) + { +#if NDB_VERSION_MAJOR >= VERSION3X + /** + * Convert VARCHAR from v.2x to v3x representation + */ + if (getMajor(tup.getTable()->getBackupVersion()) < VERSION_3X && + ((tup.getTable()->m_dictTable->getColumn(i)->getType() == + NdbDictionary::Column::Varbinary ) || + (tup.getTable()->m_dictTable->getColumn(i)->getType() == + NdbDictionary::Column::Varchar)) && !attr->Data.null) + { + char * src = dataPtr; + char var_len[2]; + var_len[0]= *(dataPtr+length - 2); + var_len[1]= *(dataPtr+length - 1); + memmove((char*)dataPtr+2, dataPtr, length); + src[0] = var_len[0]; + src[1] = var_len[1]; + dataPtr = src; + } +#endif + ret = op->equal(i, dataPtr, length); + if (ret<0) + { + ndbout_c("Column: %d type %d",i, + tup.getTable()->m_dictTable->getColumn(i)->getType()); + + if (asynchErrorHandler(asynchTrans[nPreparedTransactions],m_ndb)) + { + retries++; + continue; + } + asynchExitHandler(); + } + } + } + + for (int i = 0; i < tup.getNoOfAttributes(); i++) + { + const AttributeS * attr = tup[i]; + int size = attr->Desc->size; + int arraySize = attr->Desc->arraySize; + KeyType key = attr->Desc->key; + char * dataPtr = attr->Data.string_value; + Uint32 length = (size * arraySize) / 8; +#if NDB_VERSION_MAJOR >= VERSION3X + /** + * Convert VARCHAR from v.2x to v3x representation + */ + if (getMajor(tup.getTable()->getBackupVersion()) < VERSION_3X && + ((tup.getTable()->m_dictTable->getColumn(i)->getType() == + NdbDictionary::Column::Varbinary ) || + (tup.getTable()->m_dictTable->getColumn(i)->getType() == + NdbDictionary::Column::Varchar)) && !attr->Data.null) + { + char * src = dataPtr; + char var_len[2]; + var_len[0]= *(dataPtr+length - 2);//length is last 2 bytes + var_len[1]= *(dataPtr+length - 1); + memmove((char*)dataPtr+2, dataPtr, length); + src[0] = var_len[0]; + src[1] = var_len[1]; + dataPtr = src; + } +#endif + + if (key == NoKey && !attr->Data.null) + { + ret = op->setValue(i, dataPtr, length); + } + else if (key == NoKey && attr->Data.null) + { + ret = op->setValue(i, NULL, 0); + } + + if (ret<0) + { + ndbout_c("Column: %d type %d",i, + tup.getTable()->m_dictTable->getColumn(i)->getType()); + + if (asynchErrorHandler(asynchTrans[nPreparedTransactions], m_ndb)) + { + retries++; + continue; + } + + + asynchExitHandler(); + } + } + restore_callback_t * cb; + if (cbData ==0) + { + cb = new restore_callback_t; + cb->retries = 0; + } + else + cb =cbData; + cb->ndb = m_ndb; + cb->restore = this; + cb->tup = (TupleS*)&tup; + cb->transaction = nPreparedTransactions; + + // Prepare transaction (the transaction is NOT yet sent to NDB) + asynchTrans[nPreparedTransactions]->executeAsynchPrepare(Commit, + &callback, + cb); + if (nPreparedTransactions == ga_nParallelism-1) + { + // send-poll all transactions + // close transaction is done in callback + m_ndb->sendPollNdb(3000, ga_nParallelism); + nPreparedTransactions=0; + } + else + nPreparedTransactions++; + m_dataCount++; + return; + } + ndbout_c("Unable to recover from errors. Exiting..."); + asynchExitHandler(); +} + +void BackupRestore::asynchExitHandler() +{ + if (m_ndb != NULL) + delete m_ndb; + exit(-1); +} +/** + * returns true if is recoverable, + * Error handling based on hugo + * false if it is an error that generates an abort. + */ +static +bool asynchErrorHandler(NdbConnection * trans, Ndb* ndb) +{ + + NdbError error = trans->getNdbError(); + ndb->closeTransaction(trans); + switch(error.status) + { + case NdbError::Success: + return false; + // ERROR! + break; + + case NdbError::TemporaryError: + NdbSleep_MilliSleep(10); + return true; + // RETRY + break; + + case NdbError::UnknownResult: + ndbout << error << endl; + return false; + // ERROR! + break; + + default: + case NdbError::PermanentError: + switch (error.code) + { + case 499: + case 250: + NdbSleep_MilliSleep(10); + return true; //temp errors? + default: + break; + } + //ERROR + ndbout << error << endl; + return false; + break; + } + return false; +} + + + +void +BackupRestore::tuple(const TupleS & tup) +{ + if (!m_restore) + return; + while (1) + { + NdbConnection * trans = m_ndb->startTransaction(); + if (trans == NULL) + { + // Deep shit, TODO: handle the error + ndbout << "Cannot start transaction" << endl; + exit(-1); + } // if + + const TableS * table = tup.getTable(); + NdbOperation * op = trans->getNdbOperation(table->getTableName()); + if (op == NULL) + { + ndbout << "Cannot get operation: "; + ndbout << trans->getNdbError() << endl; + exit(-1); + } // if + + // TODO: check return value and handle error + if (op->writeTuple() == -1) + { + ndbout << "writeTuple call failed: "; + ndbout << trans->getNdbError() << endl; + exit(-1); + } // if + + for (int i = 0; i < tup.getNoOfAttributes(); i++) + { + const AttributeS * attr = tup[i]; + int size = attr->Desc->size; + int arraySize = attr->Desc->arraySize; + KeyType key = attr->Desc->key; + const char * dataPtr = attr->Data.string_value; + + const Uint32 length = (size * arraySize) / 8; + if (key == TupleKey) + { + op->equal(i, dataPtr, length); + } + } + + for (int i = 0; i < tup.getNoOfAttributes(); i++) + { + const AttributeS * attr = tup[i]; + int size = attr->Desc->size; + int arraySize = attr->Desc->arraySize; + KeyType key = attr->Desc->key; + const char * dataPtr = attr->Data.string_value; + + const Uint32 length = (size * arraySize) / 8; + if (key == NoKey && !attr->Data.null) + { + op->setValue(i, dataPtr, length); + } + else if (key == NoKey && attr->Data.null) + { + op->setValue(i, NULL, 0); + } + } + int ret = trans->execute(Commit); + if (ret != 0) + { + ndbout << "execute failed: "; + ndbout << trans->getNdbError() << endl; + exit(-1); + } + m_ndb->closeTransaction(trans); + if (ret == 0) + break; + } + m_dataCount++; +} + +void +BackupRestore::endOfTuples() +{ + if (!m_restore) + return; + // Send all transactions to NDB + m_ndb->sendPreparedTransactions(0); + // Poll all transactions + m_ndb->pollNdb(3000, nPreparedTransactions); + // Close all transactions + // for (int i = 0; i < nPreparedTransactions; i++) + // m_ndb->closeTransaction(asynchTrans[i]); + nPreparedTransactions=0; +} + +void +BackupRestore::logEntry(const LogEntry & tup) +{ + if (!m_restore) + return; + + NdbConnection * trans = m_ndb->startTransaction(); + if (trans == NULL) + { + // Deep shit, TODO: handle the error + ndbout << "Cannot start transaction" << endl; + exit(-1); + } // if + + const TableS * table = tup.m_table; + NdbOperation * op = trans->getNdbOperation(table->getTableName()); + if (op == NULL) + { + ndbout << "Cannot get operation: "; + ndbout << trans->getNdbError() << endl; + exit(-1); + } // if + + int check = 0; + switch(tup.m_type) + { + case LogEntry::LE_INSERT: + check = op->insertTuple(); + break; + case LogEntry::LE_UPDATE: + check = op->updateTuple(); + break; + case LogEntry::LE_DELETE: + check = op->deleteTuple(); + break; + default: + ndbout << "Log entry has wrong operation type." + << " Exiting..."; + exit(-1); + } + + for (int i = 0; i < tup.m_values.size(); i++) + { + const AttributeS * attr = tup.m_values[i]; + int size = attr->Desc->size; + int arraySize = attr->Desc->arraySize; + KeyType key = attr->Desc->key; + const char * dataPtr = attr->Data.string_value; + + const Uint32 length = (size / 8) * arraySize; + if (key == TupleKey) + { + op->equal(attr->Desc->attrId, dataPtr, length); + } + else if (key == NoKey) + { + op->setValue(attr->Desc->attrId, dataPtr, length); + } + } + +#if 1 + trans->execute(Commit); +#else + const int ret = trans->execute(Commit); + // Both insert update and delete can fail during log running + // and it's ok + + if (ret != 0) + { + ndbout << "execute failed: "; + ndbout << trans->getNdbError() << endl; + exit(-1); + } +#endif + + m_ndb->closeTransaction(trans); + m_logCount++; +} + +void +BackupRestore::endOfLogEntrys() +{ + if (ga_restore) + { + ndbout << "Restored " << m_dataCount << " tuples and " + << m_logCount << " log entries" << endl; + } +} + +void +BackupPrinter::endOfLogEntrys() +{ + if (m_print || m_print_log) + { + ndbout << "Printed " << m_dataCount << " tuples and " + << m_logCount << " log entries" + << " to stdout." << endl; + } +} + + + + diff --git a/ndb/src/kernel/blocks/backup/restore/myVector.hpp b/ndb/src/kernel/blocks/backup/restore/myVector.hpp new file mode 100644 index 00000000000..c858999d2be --- /dev/null +++ b/ndb/src/kernel/blocks/backup/restore/myVector.hpp @@ -0,0 +1,128 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef MY_VECTOR_HPP +#define MY_VECTOR_HPP + +// Template class for std::vector-like class (hopefully works in OSE) +template +class myVector +{ + + // Note that last element in array is used for end() and is always empty + int sizeIncrement; + int thisSize; + int used; + T *storage; + +public: + + // Assignment of whole vector + myVector & operator=(myVector & org) { + + // Don't copy if they point to the same address + if (!(this == &org)) { + // Check memory space + if (thisSize < org.thisSize) { + // We have to increase memory for destination + T* tmpStorage = new T[org.thisSize]; + delete[] storage; + storage = tmpStorage; + } // if + thisSize = org.thisSize; + sizeIncrement = org.sizeIncrement; + used = org.used; + for (int i = 0; i < thisSize; i++) { + storage[i] = org.storage[i]; + } // for + } // if + return *this; + } // operator= + + // Construct with size s+1 + myVector(int s = 1) : sizeIncrement(5), // sizeIncrement(s), + thisSize(s + 1), + used(0), + storage(new T[s + 1]) { } + + ~myVector() { delete[] storage; } // Destructor: deallocate memory + + T& operator[](int i) { // Return by index + if ((i < 0) || (i >= used)) { + // Index error + ndbout << "vector index out of range" << endl; + abort(); + return storage[used - 1]; + } // if + else { + return storage[i]; + } // else + } // operator[] + + const T& operator[](int i) const { // Return by index + if ((i < 0) || (i >= used)) { + // Index error + ndbout << "vector index out of range" << endl; + abort(); + return storage[used - 1]; + } // if + else { + return storage[i]; + } // else + } // operator[] + + int getSize() const { return used; } + + void push_back (T& item) { + if (used >= thisSize - 1) { + // We have to allocate new storage + int newSize = thisSize + sizeIncrement; + T* tmpStorage = new T[newSize]; + if (tmpStorage == NULL) { + // Memory allocation error! break + ndbout << "PANIC: Memory allocation error in vector" << endl; + return; + } // if + thisSize = newSize; + for (int i = 0; i < used; i++) { + tmpStorage[i] = storage[i]; + } // for + delete[] storage; + storage = tmpStorage; + } // if + + // Now push + storage[used] = item; + used++; + }; // myVector<> push_back() + + // Remove item at back + void pop_back() { + if (used > 0) { + used--; + } // if + } // pop_back() + + int size() const { return used; }; + + bool empty() const { return(used == 0); } + + void clear() { + used = 0; + } +}; + +#endif diff --git a/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp b/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp new file mode 100644 index 00000000000..2735cac0c8e --- /dev/null +++ b/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp @@ -0,0 +1,1531 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Cmvmi.hpp" + +#include +#include +#include +#include +#include +#include + +#include +#include + +#define DEBUG(x) { ndbout << "CMVMI::" << x << endl; } + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + +// Used here only to print event reports on stdout/console. +static EventLogger eventLogger; + +Cmvmi::Cmvmi(const Configuration & conf) : + SimulatedBlock(CMVMI, conf) + ,theConfig((Configuration&)conf) + ,theCConfig(conf.clusterConfiguration()), + subscribers(subscriberPool) +{ + BLOCK_CONSTRUCTOR(Cmvmi); + + // Add received signals + addRecSignal(GSN_CONNECT_REP, &Cmvmi::execCONNECT_REP); + addRecSignal(GSN_DISCONNECT_REP, &Cmvmi::execDISCONNECT_REP); + + addRecSignal(GSN_NDB_TAMPER, &Cmvmi::execNDB_TAMPER, true); + addRecSignal(GSN_SET_LOGLEVELORD, &Cmvmi::execSET_LOGLEVELORD); + addRecSignal(GSN_EVENT_REP, &Cmvmi::execEVENT_REP); + addRecSignal(GSN_STTOR, &Cmvmi::execSTTOR_Local); + addRecSignal(GSN_CM_RUN, &Cmvmi::execCM_RUN); + addRecSignal(GSN_CM_INFOREQ, &Cmvmi::execCM_INFOREQ); + addRecSignal(GSN_CMVMI_CFGREQ, &Cmvmi::execCMVMI_CFGREQ); + addRecSignal(GSN_CLOSE_COMREQ, &Cmvmi::execCLOSE_COMREQ); + addRecSignal(GSN_ENABLE_COMORD, &Cmvmi::execENABLE_COMORD); + addRecSignal(GSN_OPEN_COMREQ, &Cmvmi::execOPEN_COMREQ); + addRecSignal(GSN_SIZEALT_ACK, &Cmvmi::execSIZEALT_ACK); + addRecSignal(GSN_TEST_ORD, &Cmvmi::execTEST_ORD); + + addRecSignal(GSN_STATISTICS_REQ, &Cmvmi::execSTATISTICS_REQ); + addRecSignal(GSN_TAMPER_ORD, &Cmvmi::execTAMPER_ORD); + addRecSignal(GSN_SET_VAR_REQ, &Cmvmi::execSET_VAR_REQ); + addRecSignal(GSN_SET_VAR_CONF, &Cmvmi::execSET_VAR_CONF); + addRecSignal(GSN_SET_VAR_REF, &Cmvmi::execSET_VAR_REF); + addRecSignal(GSN_STOP_ORD, &Cmvmi::execSTOP_ORD); + addRecSignal(GSN_START_ORD, &Cmvmi::execSTART_ORD); + addRecSignal(GSN_EVENT_SUBSCRIBE_REQ, + &Cmvmi::execEVENT_SUBSCRIBE_REQ); + + addRecSignal(GSN_DUMP_STATE_ORD, &Cmvmi::execDUMP_STATE_ORD); + + addRecSignal(GSN_TESTSIG, &Cmvmi::execTESTSIG); + + subscriberPool.setSize(5); + + // Print to stdout/console + eventLogger.createConsoleHandler(); + eventLogger.setCategory("NDB"); + eventLogger.enable(Logger::LL_INFO, Logger::LL_ALERT); // Log INFO to ALERT + + const ClusterConfiguration::ClusterData & clData = + theConfig.clusterConfigurationData() ; + + clogLevel = clData.SizeAltData.logLevel; + + for(Uint32 i= 0; i< clData.SizeAltData.noOfNodes; i++ ){ + jam(); + const Uint32 nodeId = clData.nodeData[i].nodeId; + switch(clData.nodeData[i].nodeType){ + case NodeInfo::DB: + case NodeInfo::API: + case NodeInfo::MGM: + case NodeInfo::REP: + break; + default: + ndbrequire(false); + } + setNodeInfo(nodeId).m_type = clData.nodeData[i].nodeType; + } +} + +Cmvmi::~Cmvmi() +{ +} + + +void Cmvmi::execNDB_TAMPER(Signal* signal) +{ + jamEntry(); + SET_ERROR_INSERT_VALUE(signal->theData[0]); + if(ERROR_INSERTED(9999)){ + CRASH_INSERTION(9999); + } +}//execNDB_TAMPER() + +void Cmvmi::execSET_LOGLEVELORD(Signal* signal) +{ + SetLogLevelOrd * const llOrd = (SetLogLevelOrd *)&signal->theData[0]; + LogLevel::EventCategory category; + Uint32 level; + jamEntry(); + + for(unsigned int i = 0; inoOfEntries; i++){ + category = (LogLevel::EventCategory)llOrd->theCategories[i]; + level = llOrd->theLevels[i]; + + clogLevel.setLogLevel(category, level); + } +}//execSET_LOGLEVELORD() + +void Cmvmi::execEVENT_REP(Signal* signal) +{ + //----------------------------------------------------------------------- + // This message is sent to report any types of events in NDB. + // Based on the log level they will be either ignored or + // reported. Currently they are printed, but they will be + // transferred to the management server for further distribution + // to the graphical management interface. + //----------------------------------------------------------------------- + EventReport * const eventReport = (EventReport *)&signal->theData[0]; + EventReport::EventType eventType = eventReport->getEventType(); + + jamEntry(); + + /** + * If entry is not found + */ + Uint32 threshold = 16; + LogLevel::EventCategory eventCategory = (LogLevel::EventCategory)0; + + for(unsigned int i = 0; i< EventLogger::matrixSize; i++){ + if(EventLogger::matrix[i].eventType == eventType){ + eventCategory = EventLogger::matrix[i].eventCategory; + threshold = EventLogger::matrix[i].threshold; + break; + } + } + + if(threshold > 15){ + // No entry found in matrix (or event that should never be printed) + return; + } + + SubscriberPtr ptr; + for(subscribers.first(ptr); ptr.i != RNIL; subscribers.next(ptr)){ + if(ptr.p->logLevel.getLogLevel(eventCategory) < threshold){ + continue; + } + + sendSignal(ptr.p->blockRef, GSN_EVENT_REP, signal, signal->length(), JBB); + } + + if(clogLevel.getLogLevel(eventCategory) < threshold){ + return; + } + + // Print the event info + eventLogger.log(eventReport->getEventType(), signal->theData); + +}//execEVENT_REP() + +void +Cmvmi::execEVENT_SUBSCRIBE_REQ(Signal * signal){ + EventSubscribeReq * subReq = (EventSubscribeReq *)&signal->theData[0]; + SubscriberPtr ptr; + + jamEntry(); + + /** + * Search for subcription + */ + for(subscribers.first(ptr); ptr.i != RNIL; subscribers.next(ptr)){ + if(ptr.p->blockRef == subReq->blockRef) + break; + } + + if(ptr.i == RNIL){ + /** + * Create a new one + */ + if(subscribers.seize(ptr) == false){ + sendSignal(subReq->blockRef, GSN_EVENT_SUBSCRIBE_REF, signal, 1, JBB); + return; + } + /** + * If it's a new subscription, clear the loglevel + * + * Clear only if noOfEntries is 0, this is needed beacuse we set + * the default loglevels for the MGMT nodes during the inital connect phase. + * See reportConnected(). + */ + if (subReq->noOfEntries == 0){ + ptr.p->logLevel.clear(); + } + + ptr.p->blockRef = subReq->blockRef; + } + + if(subReq->noOfEntries == 0){ + /** + * Cancel subscription + */ + subscribers.release(ptr.i); + } else { + /** + * Update subscription + */ + LogLevel::EventCategory category; + Uint32 level = 0; + for(Uint32 i = 0; inoOfEntries; i++){ + category = (LogLevel::EventCategory)subReq->theCategories[i]; + level = subReq->theLevels[i]; + ptr.p->logLevel.setLogLevel(category, + level); + } + } + + signal->theData[0] = ptr.i; + sendSignal(ptr.p->blockRef, GSN_EVENT_SUBSCRIBE_CONF, signal, 1, JBB); +} + +void +Cmvmi::cancelSubscription(NodeId nodeId){ + + SubscriberPtr ptr; + subscribers.first(ptr); + + while(ptr.i != RNIL){ + Uint32 i = ptr.i; + BlockReference blockRef = ptr.p->blockRef; + + subscribers.next(ptr); + + if(refToNode(blockRef) == nodeId){ + subscribers.release(i); + } + } +} + +void Cmvmi::sendSTTORRY(Signal* signal) +{ + if( theStartPhase == 1 ) { + const ClusterConfiguration::ClusterData & clusterConf = + theConfig.clusterConfigurationData() ; + const int myNodeId = globalData.ownId; + int MyNodeFound = 0; + + jam(); + + CmInit * const cmInit = (CmInit *)&signal->theData[0]; + + cmInit->heartbeatDbDb = clusterConf.ispValues[0][2]; + cmInit->heartbeatDbApi = clusterConf.ispValues[0][3]; + cmInit->arbitTimeout = clusterConf.ispValues[0][5]; + + NodeBitmask::clear(cmInit->allNdbNodes); + for(unsigned int i = 0; i < clusterConf.SizeAltData.noOfNodes; i++ ) { + jam(); + if (clusterConf.nodeData[i].nodeType == NodeInfo::DB){ + jam(); + const NodeId nodeId = clusterConf.nodeData[i].nodeId; + if (nodeId == myNodeId) { + jam(); + MyNodeFound = 1; + }//if + NodeBitmask::set(cmInit->allNdbNodes, nodeId); + }//if + }//for + + if (MyNodeFound == 0) { + ERROR_SET(fatal, ERR_NODE_NOT_IN_CONFIG, "", ""); + }//if + + sendSignal(QMGR_REF, GSN_CM_INIT, signal, CmInit::SignalLength, JBB); + + // these do not fit into CM_INIT + ArbitSignalData* const sd = (ArbitSignalData*)&signal->theData[0]; + for (unsigned rank = 1; rank <= 2; rank++) { + sd->sender = myNodeId; + sd->code = rank; + sd->node = 0; + sd->ticket.clear(); + sd->mask.clear(); + for (int i = 0; i < MAX_NODES; i++) { + if (clusterConf.nodeData[i].arbitRank == rank) + sd->mask.set(clusterConf.nodeData[i].nodeId); + } + sendSignal(QMGR_REF, GSN_ARBIT_CFG, signal, + ArbitSignalData::SignalLength, JBB); + } + } else { + jam(); + signal->theData[0] = theSignalKey; + signal->theData[3] = 1; + signal->theData[4] = 3; + signal->theData[5] = 255; + sendSignal(NDBCNTR_REF, GSN_STTORRY, signal,6, JBB); + } +}//Cmvmi::sendSTTORRY + + +// Received a restart signal. +// Answer it like any other block +// PR0 : StartCase +// DR0 : StartPhase +// DR1 : ? +// DR2 : ? +// DR3 : ? +// DR4 : ? +// DR5 : SignalKey + +void Cmvmi::execSTTOR_Local(Signal* signal) +{ + theStartPhase = signal->theData[1]; + theSignalKey = signal->theData[6]; + + const ClusterConfiguration::ClusterData & clusterConf = + theConfig.clusterConfigurationData(); + jamEntry(); + if (theStartPhase == 1 && clusterConf.SizeAltData.exist == true){ + jam(); + signalCount = 0; + execSIZEALT_ACK(signal); + return; + } else if (theStartPhase == 3) { + jam(); + globalData.activateSendPacked = 1; + sendSTTORRY(signal); + } else { + jam(); + sendSTTORRY(signal); + } +} + +void Cmvmi::execSIZEALT_ACK(Signal* signal) +{ + const ClusterConfiguration::ClusterData & clusterConf = + theConfig.clusterConfigurationData(); + jamEntry(); + + if (signalCount < NDB_SIZEALT_OFF){ + jam(); + BlockNumber blockNo = clusterConf.SizeAltData.blockNo[signalCount]; + signal->theData[0] = CMVMI_REF; + + /** + * This send SizeAlt(s) to blocks + * Definition of data content can be found in SignalData/XXXSizeAltReq.H + */ + const unsigned int noOfWords = 20; + for(unsigned int i = 1; itheData[i] = clusterConf.SizeAltData.varSize[signalCount][i].nrr; + } + + signalCount++; + sendSignal(numberToRef(blockNo, 0), GSN_SIZEALT_REP, signal,21, JBB); + } else { + jam(); + sendSTTORRY(signal); + } +} + +void Cmvmi::execCM_INFOREQ(Signal* signal) +{ + int id = signal->theData[1]; + const BlockReference userRef = signal->theData[0]; + const ClusterConfiguration::ClusterData & clusterConf = + theConfig.clusterConfigurationData(); + const int myNodeId = globalData.ownId; + + jamEntry(); + signal->theData[0] = id; + + for(unsigned int i= 0; i< clusterConf.SizeAltData.noOfNodes; i++ ) { + jam(); + if (clusterConf.nodeData[i].nodeType == NodeInfo::DB){ + NodeId nodeId = clusterConf.nodeData[i].nodeId; + if (nodeId != myNodeId) { + jam(); + globalTransporterRegistry.setPerformState(nodeId, PerformConnect); + } + } + } + + sendSignal(userRef, GSN_CM_INFOCONF, signal, 1, JBB); +} + +void Cmvmi::execCM_RUN(Signal* signal) +{ + jamEntry(); + if (signal->theData[0] == 0) { + jam(); + signal->theData[0] = theSignalKey; + signal->theData[3] = 1; + signal->theData[4] = 3; + signal->theData[5] = 255; + sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 6, JBB); + } else { + globalData.theStartLevel = NodeState::SL_STARTED; + + // Connect to all application nodes. + // Enable communication with all NDB blocks. + + const ClusterConfiguration::ClusterData & clusterConf = + theConfig.clusterConfigurationData(); + jam(); + for(unsigned int i= 0; i< clusterConf.SizeAltData.noOfNodes; i++ ) { + NodeId nodeId = clusterConf.nodeData[i].nodeId; + jam(); + if (clusterConf.nodeData[i].nodeType != NodeInfo::DB && + clusterConf.nodeData[i].nodeType != NodeInfo::MGM){ + + jam(); + globalTransporterRegistry.setPerformState(nodeId, PerformConnect); + globalTransporterRegistry.setIOState(nodeId, HaltIO); + //----------------------------------------------------- + // Report that the connection to the node is opened + //----------------------------------------------------- + signal->theData[0] = EventReport::CommunicationOpened; + signal->theData[1] = clusterConf.nodeData[i].nodeId; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); + //----------------------------------------------------- + } + } + } +} + +void Cmvmi::execCMVMI_CFGREQ(Signal* signal) +{ + const BlockReference userRef = signal->theData[0]; + const ClusterConfiguration::ClusterData & clusterConf = + theConfig.clusterConfigurationData(); + + int theStart_phase = signal->theData[1]; + + jamEntry(); + + CmvmiCfgConf * const cfgConf = (CmvmiCfgConf *)&signal->theData[0]; + + cfgConf->startPhase = theStart_phase; + for(unsigned int i = 0; itheData[i] = clusterConf.ispValues[theStart_phase][i]; + + sendSignal(userRef, GSN_CMVMI_CFGCONF, signal, CmvmiCfgConf::LENGTH,JBB ); +} + +void Cmvmi::execCLOSE_COMREQ(Signal* signal) +{ + // Close communication with the node and halt input/output from + // other blocks than QMGR + + CloseComReqConf * const closeCom = (CloseComReqConf *)&signal->theData[0]; + + const BlockReference userRef = closeCom->xxxBlockRef; + Uint32 failNo = closeCom->failNo; +// Uint32 noOfNodes = closeCom->noOfNodes; + + jamEntry(); + for (unsigned i = 0; i < MAX_NODES; i++){ + if(NodeBitmask::get(closeCom->theNodes, i)){ + + jam(); + + //----------------------------------------------------- + // Report that the connection to the node is closed + //----------------------------------------------------- + signal->theData[0] = EventReport::CommunicationClosed; + signal->theData[1] = i; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); + + globalTransporterRegistry.setIOState(i, HaltIO); + globalTransporterRegistry.setPerformState(i, PerformDisconnect); + + /** + * Cancel possible event subscription + */ + cancelSubscription(i); + } + } + if (failNo != 0) { + jam(); + signal->theData[0] = userRef; + signal->theData[1] = failNo; + sendSignal(QMGR_REF, GSN_CLOSE_COMCONF, signal, 19, JBA); + } +} + +void Cmvmi::execOPEN_COMREQ(Signal* signal) +{ + // Connect to the specifed NDB node, only QMGR allowed communication + // so far with the node + + const BlockReference userRef = signal->theData[0]; + Uint32 tStartingNode = signal->theData[1]; + + jamEntry(); + if (userRef != 0) { + jam(); + signal->theData[0] = signal->theData[1]; + sendSignal(userRef, GSN_OPEN_COMCONF, signal, 2,JBA); + } + globalTransporterRegistry.setPerformState(tStartingNode, PerformConnect); + //----------------------------------------------------- + // Report that the connection to the node is opened + //----------------------------------------------------- + signal->theData[0] = EventReport::CommunicationOpened; + signal->theData[1] = tStartingNode; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); + //----------------------------------------------------- +} + +void Cmvmi::execENABLE_COMORD(Signal* signal) +{ + // Enable communication with all our NDB blocks to this node + + Uint32 tStartingNode = signal->theData[0]; + globalTransporterRegistry.setIOState(tStartingNode, NoHalt); + setNodeInfo(tStartingNode).m_connected = true; + //----------------------------------------------------- + // Report that the version of the node + //----------------------------------------------------- + signal->theData[0] = EventReport::ConnectedApiVersion; + signal->theData[1] = tStartingNode; + signal->theData[2] = getNodeInfo(tStartingNode).m_version; + + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB); + //----------------------------------------------------- + + jamEntry(); +} + +void Cmvmi::execDISCONNECT_REP(Signal *signal) +{ + const DisconnectRep * const rep = (DisconnectRep *)&signal->theData[0]; + const Uint32 hostId = rep->nodeId; + const Uint32 errNo = rep->err; + + jamEntry(); + + setNodeInfo(hostId).m_connected = false; + setNodeInfo(hostId).m_connectCount++; + const NodeInfo::NodeType type = getNodeInfo(hostId).getType(); + ndbrequire(type != NodeInfo::INVALID); + + if (globalTransporterRegistry.performState(hostId) != PerformDisconnect) { + jam(); + + // ------------------------------------------------------------------- + // We do not report the disconnection when disconnection is already ongoing. + // This reporting should be looked into but this secures that we avoid + // crashes due to too quick re-reporting of disconnection. + // ------------------------------------------------------------------- + if(type == NodeInfo::DB || globalData.theStartLevel == NodeState::SL_STARTED){ + jam(); + DisconnectRep * const rep = (DisconnectRep *)&signal->theData[0]; + rep->nodeId = hostId; + rep->err = errNo; + sendSignal(QMGR_REF, GSN_DISCONNECT_REP, signal, + DisconnectRep::SignalLength, JBA); + globalTransporterRegistry.setPerformState(hostId, PerformDisconnect); + } else if(globalData.theStartLevel == NodeState::SL_CMVMI || + globalData.theStartLevel == NodeState::SL_STARTING) { + /** + * Someone disconnected during cmvmi period + */ + if(type == NodeInfo::MGM){ + jam(); + globalTransporterRegistry.setPerformState(hostId, PerformConnect); + } else { + globalTransporterRegistry.setPerformState(hostId, PerformDisconnect); + } + } + } + + signal->theData[0] = EventReport::Disconnected; + signal->theData[1] = hostId; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); +} + +void Cmvmi::execCONNECT_REP(Signal *signal){ + const Uint32 hostId = signal->theData[0]; + + jamEntry(); + + const NodeInfo::NodeType type = (NodeInfo::NodeType)getNodeInfo(hostId).m_type; + ndbrequire(type != NodeInfo::INVALID); + globalData.m_nodeInfo[hostId].m_version = 0; + globalData.m_nodeInfo[hostId].m_signalVersion = 0; + + if(type == NodeInfo::DB || globalData.theStartLevel >= NodeState::SL_STARTED){ + jam(); + + /** + * Inform QMGR that client has connected + */ + + signal->theData[0] = hostId; + sendSignal(QMGR_REF, GSN_CONNECT_REP, signal, 1, JBA); + } else if(globalData.theStartLevel == NodeState::SL_CMVMI || + globalData.theStartLevel == NodeState::SL_STARTING) { + jam(); + /** + * Someone connected before start was finished + */ + if(type == NodeInfo::MGM){ + jam(); + } else { + /** + * Dont allow api nodes to connect + */ + globalTransporterRegistry.setPerformState(hostId, PerformDisconnect); + } + } + + /* Automatically subscribe events for MGM nodes. + */ + if(type == NodeInfo::MGM){ + jam(); + globalTransporterRegistry.setIOState(hostId, NoHalt); + + EventSubscribeReq* dst = (EventSubscribeReq *)&signal->theData[0]; + + for (Uint32 i = 0; i < EventLogger::defEventLogMatrixSize; i++) { + dst->theCategories[i] = EventLogger::defEventLogMatrix[i].eventCategory; + dst->theLevels[i] = EventLogger::defEventLogMatrix[i].threshold; + } + + dst->noOfEntries = EventLogger::defEventLogMatrixSize; + /* The BlockNumber is hardcoded as 1 in MgmtSrvr */ + dst->blockRef = numberToRef(MIN_API_BLOCK_NO, hostId); + + execEVENT_SUBSCRIBE_REQ(signal); + + } + + //------------------------------------------ + // Also report this event to the Event handler + //------------------------------------------ + signal->theData[0] = EventReport::Connected; + signal->theData[1] = hostId; + signal->header.theLength = 2; + + execEVENT_REP(signal); +} + +#ifdef VM_TRACE +void +modifySignalLogger(bool allBlocks, BlockNumber bno, + TestOrd::Command cmd, + TestOrd::SignalLoggerSpecification spec){ + SignalLoggerManager::LogMode logMode; + + /** + * Mapping between SignalLoggerManager::LogMode and + * TestOrd::SignalLoggerSpecification + */ + switch(spec){ + case TestOrd::InputSignals: + logMode = SignalLoggerManager::LogIn; + break; + case TestOrd::OutputSignals: + logMode = SignalLoggerManager::LogOut; + break; + case TestOrd::InputOutputSignals: + logMode = SignalLoggerManager::LogInOut; + break; + default: + return; + break; + } + + switch(cmd){ + case TestOrd::On: + globalSignalLoggers.logOn(allBlocks, bno, logMode); + break; + case TestOrd::Off: + globalSignalLoggers.logOff(allBlocks, bno, logMode); + break; + case TestOrd::Toggle: + globalSignalLoggers.logToggle(allBlocks, bno, logMode); + break; + case TestOrd::KeepUnchanged: + // Do nothing + break; + } + globalSignalLoggers.flushSignalLog(); +} +#endif + +void +Cmvmi::execTEST_ORD(Signal * signal){ + jamEntry(); + +#ifdef VM_TRACE + TestOrd * const testOrd = (TestOrd *)&signal->theData[0]; + + TestOrd::Command cmd; + + { + /** + * Process Trace command + */ + TestOrd::TraceSpecification traceSpec; + + testOrd->getTraceCommand(cmd, traceSpec); + unsigned long traceVal = traceSpec; + unsigned long currentTraceVal = globalSignalLoggers.getTrace(); + switch(cmd){ + case TestOrd::On: + currentTraceVal |= traceVal; + break; + case TestOrd::Off: + currentTraceVal &= (~traceVal); + break; + case TestOrd::Toggle: + currentTraceVal ^= traceVal; + break; + case TestOrd::KeepUnchanged: + // Do nothing + break; + } + globalSignalLoggers.setTrace(currentTraceVal); + } + + { + /** + * Process Log command + */ + TestOrd::SignalLoggerSpecification logSpec; + BlockNumber bno; + unsigned int loggers = testOrd->getNoOfSignalLoggerCommands(); + + if(loggers == (unsigned)~0){ // Apply command to all blocks + testOrd->getSignalLoggerCommand(0, bno, cmd, logSpec); + modifySignalLogger(true, bno, cmd, logSpec); + } else { + for(unsigned int i = 0; igetSignalLoggerCommand(i, bno, cmd, logSpec); + modifySignalLogger(false, bno, cmd, logSpec); + } + } + } + + { + /** + * Process test command + */ + testOrd->getTestCommand(cmd); + switch(cmd){ + case TestOrd::On:{ + SET_GLOBAL_TEST_ON; + } + break; + case TestOrd::Off:{ + SET_GLOBAL_TEST_OFF; + } + break; + case TestOrd::Toggle:{ + TOGGLE_GLOBAL_TEST_FLAG; + } + break; + case TestOrd::KeepUnchanged: + // Do nothing + break; + } + } + +#endif +} + +void Cmvmi::execSTATISTICS_REQ(Signal* signal) +{ + // TODO Note ! This is only a test implementation... + + static int stat1 = 0; + jamEntry(); + + //ndbout << "data 1: " << signal->theData[1]; + + int x = signal->theData[0]; + stat1++; + signal->theData[0] = stat1; + sendSignal(x, GSN_STATISTICS_CONF, signal, 7, JBB); + +}//execSTATISTICS_REQ() + + + +void Cmvmi::execSTOP_ORD(Signal* signal) +{ + jamEntry(); + globalData.theRestartFlag = perform_stop; +}//execSTOP_ORD() + +void +Cmvmi::execSTART_ORD(Signal* signal) { + + StartOrd * const startOrd = (StartOrd *)&signal->theData[0]; + jamEntry(); + + Uint32 tmp = startOrd->restartInfo; + if(StopReq::getPerformRestart(tmp)){ + jam(); + /** + * + */ + NdbRestartType type = NRT_Default; + if(StopReq::getNoStart(tmp) && StopReq::getInitialStart(tmp)) + type = NRT_NoStart_InitialStart; + if(StopReq::getNoStart(tmp) && !StopReq::getInitialStart(tmp)) + type = NRT_NoStart_Restart; + if(!StopReq::getNoStart(tmp) && StopReq::getInitialStart(tmp)) + type = NRT_DoStart_InitialStart; + if(!StopReq::getNoStart(tmp)&&!StopReq::getInitialStart(tmp)) + type = NRT_DoStart_Restart; + NdbShutdown(NST_Restart, type); + } + + if(globalData.theRestartFlag == system_started){ + jam() + /** + * START_ORD received when already started(ignored) + */ + //ndbout << "START_ORD received when already started(ignored)" << endl; + return; + } + + if(globalData.theRestartFlag == perform_stop){ + jam() + /** + * START_ORD received when stopping(ignored) + */ + //ndbout << "START_ORD received when stopping(ignored)" << endl; + return; + } + + if(globalData.theStartLevel == NodeState::SL_NOTHING){ + jam(); + globalData.theStartLevel = NodeState::SL_CMVMI; + /** + * Open connections to management servers + */ + + const ClusterConfiguration::ClusterData & clusterConf = + theConfig.clusterConfigurationData() ; + + for(unsigned int i= 0; i < clusterConf.SizeAltData.noOfNodes; i++ ){ + NodeId nodeId = clusterConf.nodeData[i].nodeId; + + if (clusterConf.nodeData[i].nodeType == NodeInfo::MGM){ + + if(globalTransporterRegistry.performState(nodeId) != PerformIO){ + globalTransporterRegistry.setPerformState(nodeId, PerformConnect); + globalTransporterRegistry.setIOState(nodeId, NoHalt); + } + } + } + return ; + } + + if(globalData.theStartLevel == NodeState::SL_CMVMI){ + jam(); + globalData.theStartLevel = NodeState::SL_STARTING; + globalData.theRestartFlag = system_started; + /** + * StartLevel 1 + * + * Do Restart + */ + + globalScheduler.clear(); + globalTimeQueue.clear(); + + // Disconnect all nodes as part of the system restart. + // We need to ensure that we are starting up + // without any connected nodes. + const ClusterConfiguration::ClusterData & clusterConf = + theConfig.clusterConfigurationData() ; + const int myNodeId = globalData.ownId; + + for(unsigned int i= 0; i < clusterConf.SizeAltData.noOfNodes; i++ ){ + NodeId nodeId = clusterConf.nodeData[i].nodeId; + if (myNodeId != nodeId && + clusterConf.nodeData[i].nodeType != NodeInfo::MGM){ + + globalTransporterRegistry.setPerformState(nodeId, PerformDisconnect); + globalTransporterRegistry.setIOState(nodeId, HaltIO); + } + } + + /** + * Start running startphases + */ + sendSignal(NDBCNTR_REF, GSN_START_ORD, signal, 1, JBA); + return; + } +}//execSTART_ORD() + +void Cmvmi::execTAMPER_ORD(Signal* signal) +{ + jamEntry(); + // TODO We should maybe introduce a CONF and REF signal + // to be able to indicate if we really introduced an error. +#ifdef ERROR_INSERT + TamperOrd* const tamperOrd = (TamperOrd*)&signal->theData[0]; + + signal->theData[1] = tamperOrd->errorNo; + signal->theData[0] = 5; + sendSignal(DBDIH_REF, GSN_DIHNDBTAMPER, signal, 3,JBB); +#endif + +}//execTAMPER_ORD() + + + +void Cmvmi::execSET_VAR_REQ(Signal* signal) +{ + + SetVarReq* const setVarReq = (SetVarReq*)&signal->theData[0]; + ConfigParamId var = setVarReq->variable(); + jamEntry(); + switch (var) { + + // NDBCNTR_REF + + // DBTC + case TransactionDeadlockDetectionTimeout: + case TransactionInactiveTime: + case NoOfConcurrentProcessesHandleTakeover: + sendSignal(DBTC_REF, GSN_SET_VAR_REQ, signal, 3, JBB); + break; + + // DBDIH + case TimeBetweenLocalCheckpoints: + case TimeBetweenGlobalCheckpoints: + sendSignal(DBDIH_REF, GSN_SET_VAR_REQ, signal, 3, JBB); + break; + + // DBLQH + case NoOfConcurrentCheckpointsDuringRestart: + case NoOfConcurrentCheckpointsAfterRestart: + sendSignal(DBLQH_REF, GSN_SET_VAR_REQ, signal, 3, JBB); + break; + + // DBACC + case NoOfDiskPagesToDiskDuringRestartACC: + case NoOfDiskPagesToDiskAfterRestartACC: + sendSignal(DBACC_REF, GSN_SET_VAR_REQ, signal, 3, JBB); + break; + + // DBTUP + case NoOfDiskPagesToDiskDuringRestartTUP: + case NoOfDiskPagesToDiskAfterRestartTUP: + sendSignal(DBTUP_REF, GSN_SET_VAR_REQ, signal, 3, JBB); + break; + + // DBDICT + + // NDBCNTR + case TimeToWaitAlive: + + // QMGR + case HeartbeatIntervalDbDb: // TODO ev till Ndbcnt också + case HeartbeatIntervalDbApi: + case ArbitTimeout: + sendSignal(QMGR_REF, GSN_SET_VAR_REQ, signal, 3, JBB); + break; + + // NDBFS + + // CMVMI + case MaxNoOfSavedMessages: + case LockPagesInMainMemory: + case TimeBetweenWatchDogCheck: + case StopOnError: + handleSET_VAR_REQ(signal); + break; + + + // Not possible to update (this could of course be handled by each block + // instead but I havn't investigated where they belong) + case Id: + case ExecuteOnComputer: + case ShmKey: + case MaxNoOfConcurrentOperations: + case MaxNoOfConcurrentTransactions: + case MemorySpaceIndexes: + case MemorySpaceTuples: + case MemoryDiskPages: + case NoOfFreeDiskClusters: + case NoOfDiskClusters: + case NoOfFragmentLogFiles: + case NoOfDiskClustersPerDiskFile: + case NoOfDiskFiles: + case MaxNoOfSavedEvents: + default: + + int mgmtSrvr = setVarReq->mgmtSrvrBlockRef(); + sendSignal(mgmtSrvr, GSN_SET_VAR_REF, signal, 0, JBB); + } // switch + + +}//execSET_VAR_REQ() + + +void Cmvmi::execSET_VAR_CONF(Signal* signal) +{ + int mgmtSrvr = signal->theData[0]; + sendSignal(mgmtSrvr, GSN_SET_VAR_CONF, signal, 0, JBB); + +}//execSET_VAR_CONF() + + +void Cmvmi::execSET_VAR_REF(Signal* signal) +{ + int mgmtSrvr = signal->theData[0]; + sendSignal(mgmtSrvr, GSN_SET_VAR_REF, signal, 0, JBB); + +}//execSET_VAR_REF() + + +void Cmvmi::handleSET_VAR_REQ(Signal* signal) { + + SetVarReq* const setVarReq = (SetVarReq*)&signal->theData[0]; + ConfigParamId var = setVarReq->variable(); + int val = setVarReq->value(); + + switch (var) { + case MaxNoOfSavedMessages: + theConfig.maxNoOfErrorLogs(val); + sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB); + break; + + case LockPagesInMainMemory: + int result; + if (val == 0) { + result = NdbMem_MemUnlockAll(); + } + else { + result = NdbMem_MemLockAll(); + } + if (result == 0) { + sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB); + } + else { + sendSignal(CMVMI_REF, GSN_SET_VAR_REF, signal, 1, JBB); + } + break; + + case TimeBetweenWatchDogCheck: + theConfig.timeBetweenWatchDogCheck(val); + sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB); + break; + + case StopOnError: + theConfig.stopOnError(val); + sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB); + break; + + default: + sendSignal(CMVMI_REF, GSN_SET_VAR_REF, signal, 1, JBB); + return; + } // switch + +} + +#ifdef VM_TRACE +class RefSignalTest { +public: + enum ErrorCode { + OK = 0, + NF_FakeErrorREF = 7 + }; + Uint32 senderRef; + Uint32 senderData; + Uint32 errorCode; +}; +#endif + +void +Cmvmi::execDUMP_STATE_ORD(Signal* signal) +{ + + sendSignal(QMGR_REF, GSN_DUMP_STATE_ORD, signal, signal->length(), JBB); + sendSignal(NDBCNTR_REF, GSN_DUMP_STATE_ORD, signal, signal->length(), JBB); + sendSignal(DBTC_REF, GSN_DUMP_STATE_ORD, signal, signal->length(), JBB); + sendSignal(DBDIH_REF, GSN_DUMP_STATE_ORD, signal, signal->length(), JBB); + sendSignal(DBDICT_REF, GSN_DUMP_STATE_ORD, signal, signal->length(), JBB); + sendSignal(DBLQH_REF, GSN_DUMP_STATE_ORD, signal, signal->length(), JBB); + sendSignal(DBTUP_REF, GSN_DUMP_STATE_ORD, signal, signal->length(), JBB); + sendSignal(DBACC_REF, GSN_DUMP_STATE_ORD, signal, signal->length(), JBB); + sendSignal(NDBFS_REF, GSN_DUMP_STATE_ORD, signal, signal->length(), JBB); + sendSignal(BACKUP_REF, GSN_DUMP_STATE_ORD, signal, signal->length(), JBB); + sendSignal(DBUTIL_REF, GSN_DUMP_STATE_ORD, signal, signal->length(), JBB); + sendSignal(SUMA_REF, GSN_DUMP_STATE_ORD, signal, signal->length(), JBB); + sendSignal(GREP_REF, GSN_DUMP_STATE_ORD, signal, signal->length(), JBB); + sendSignal(TRIX_REF, GSN_DUMP_STATE_ORD, signal, signal->length(), JBB); + sendSignal(DBTUX_REF, GSN_DUMP_STATE_ORD, signal, signal->length(), JBB); + + /** + * + * Here I can dump CMVMI state if needed + */ + if(signal->theData[0] == 13){ + infoEvent("Cmvmi: signalCount = %d", signalCount); + } + + DumpStateOrd * const & dumpState = (DumpStateOrd *)&signal->theData[0]; + if (dumpState->args[0] == DumpStateOrd::CmvmiDumpConnections){ + const ClusterConfiguration::ClusterData & clusterConf = + theConfig.clusterConfigurationData() ; + + for(unsigned int i= 0; i < clusterConf.SizeAltData.noOfNodes; i++ ){ + NodeId nodeId = clusterConf.nodeData[i].nodeId; + + const char* nodeTypeStr = ""; + switch(clusterConf.nodeData[i].nodeType){ + case NodeInfo::DB: + nodeTypeStr = "DB"; + break; + case NodeInfo::API: + nodeTypeStr = "API"; + break; + case NodeInfo::MGM: + nodeTypeStr = "MGM"; + break; + case NodeInfo::REP: + nodeTypeStr = "REP"; + break; + default: + nodeTypeStr = ""; + } + + const char* actionStr = ""; + switch (globalTransporterRegistry.performState(nodeId)){ + case PerformNothing: + actionStr = "does nothing"; + break; + case PerformIO: + actionStr = "is connected"; + break; + case PerformConnect: + actionStr = "is trying to connect"; + break; + case PerformDisconnect: + actionStr = "is trying to disconnect"; + break; + case RemoveTransporter: + actionStr = "will be removed"; + break; + } + + infoEvent("Connection to %d (%s) %s", + nodeId, + nodeTypeStr, + actionStr); + } + } + + if (dumpState->args[0] == DumpStateOrd::CmvmiDumpLongSignalMemory){ + infoEvent("Cmvmi: g_sectionSegmentPool size: %d free: %d", + g_sectionSegmentPool.getSize(), + g_sectionSegmentPool.getNoOfFree()); + } + + if (dumpState->args[0] == DumpStateOrd::CmvmiSetRestartOnErrorInsert){ + if(signal->getLength() == 1) + theConfig.setRestartOnErrorInsert((int)NRT_NoStart_Restart); + else + theConfig.setRestartOnErrorInsert(signal->theData[1]); + } + + if (dumpState->args[0] == DumpStateOrd::CmvmiTestLongSigWithDelay) { + Uint32 loopCount = dumpState->args[1]; + const unsigned len0 = 11; + const unsigned len1 = 123; + Uint32 sec0[len0]; + Uint32 sec1[len1]; + for (unsigned i = 0; i < len0; i++) + sec0[i] = i; + for (unsigned i = 0; i < len1; i++) + sec1[i] = 16 * i; + Uint32* sig = signal->getDataPtrSend(); + sig[0] = reference(); + sig[1] = 20; // test type + sig[2] = 0; + sig[3] = 0; + sig[4] = loopCount; + sig[5] = len0; + sig[6] = len1; + sig[7] = 0; + LinearSectionPtr ptr[3]; + ptr[0].p = sec0; + ptr[0].sz = len0; + ptr[1].p = sec1; + ptr[1].sz = len1; + sendSignal(reference(), GSN_TESTSIG, signal, 8, JBB, ptr, 2); + } + +#ifdef VM_TRACE +#if 0 + { + SafeCounterManager mgr(* this); mgr.setSize(1); + SafeCounterHandle handle; + + { + SafeCounter tmp(mgr, handle); + tmp.init(CMVMI, GSN_TESTSIG, /* senderData */ 13); + tmp.setWaitingFor(3); + ndbrequire(!tmp.done()); + ndbout_c("Allocted"); + } + ndbrequire(!handle.done()); + { + SafeCounter tmp(mgr, handle); + tmp.clearWaitingFor(3); + ndbrequire(tmp.done()); + ndbout_c("Deallocted"); + } + ndbrequire(handle.done()); + } +#endif +#endif +}//Cmvmi::execDUMP_STATE_ORD() + + +BLOCK_FUNCTIONS(Cmvmi); + +static Uint32 g_print; +static LinearSectionPtr g_test[3]; + +void +Cmvmi::execTESTSIG(Signal* signal){ + /** + * Test of SafeCounter + */ + jamEntry(); + + if(!assembleFragments(signal)){ + jam(); + return; + } + + Uint32 ref = signal->theData[0]; + Uint32 testType = signal->theData[1]; + Uint32 fragmentLength = signal->theData[2]; + g_print = signal->theData[3]; +// Uint32 returnCount = signal->theData[4]; + Uint32 * secSizes = &signal->theData[5]; + + if(g_print){ + SignalLoggerManager::printSignalHeader(stdout, + signal->header, + 0, + getOwnNodeId(), + true); + ndbout_c("-- Fixed section --"); + for(Uint32 i = 0; ilength(); i++){ + fprintf(stdout, "H'0x%.8x ", signal->theData[i]); + if(((i + 1) % 6) == 0) + fprintf(stdout, "\n"); + } + fprintf(stdout, "\n"); + + for(Uint32 i = 0; iheader.m_noOfSections; i++){ + SegmentedSectionPtr ptr; + ndbout_c("-- Section %d --", i); + signal->getSection(ptr, i); + ndbrequire(ptr.p != 0); + print(ptr, stdout); + ndbrequire(ptr.sz == secSizes[i]); + } + } + + /** + * Validate length:s + */ + for(Uint32 i = 0; iheader.m_noOfSections; i++){ + SegmentedSectionPtr ptr; + signal->getSection(ptr, i); + ndbrequire(ptr.p != 0); + ndbrequire(ptr.sz == secSizes[i]); + } + + /** + * Testing send with delay. + */ + if (testType == 20) { + if (signal->theData[4] == 0) { + releaseSections(signal); + return; + } + signal->theData[4]--; + sendSignalWithDelay(reference(), GSN_TESTSIG, signal, 100, 8); + return; + } + + NodeReceiverGroup rg; rg.m_block = CMVMI; + const ClusterConfiguration::ClusterData & clusterConf = + theConfig.clusterConfigurationData() ; + for(unsigned int i = 0; i < clusterConf.SizeAltData.noOfNodes; i++ ){ + NodeId nodeId = clusterConf.nodeData[i].nodeId; + if (clusterConf.nodeData[i].nodeType == NodeInfo::DB){ + rg.m_nodes.set(nodeId); + } + } + + if(signal->getSendersBlockRef() == ref){ + /** + * Signal from API (not via NodeReceiverGroup) + */ + if((testType % 2) == 1){ + signal->theData[4] = 1; + } else { + signal->theData[1] --; + signal->theData[4] = rg.m_nodes.count(); + } + } + + switch(testType){ + case 1: + sendSignal(ref, GSN_TESTSIG, signal, signal->length(), JBB); + break; + case 2: + sendSignal(rg, GSN_TESTSIG, signal, signal->length(), JBB); + break; + case 3: + case 4:{ + LinearSectionPtr ptr[3]; + const Uint32 secs = signal->getNoOfSections(); + for(Uint32 i = 0; igetSection(sptr, i); + ptr[i].sz = sptr.sz; + ptr[i].p = new Uint32[sptr.sz]; + copy(ptr[i].p, sptr); + } + + if(testType == 3){ + sendSignal(ref, GSN_TESTSIG, signal, signal->length(), JBB, ptr, secs); + } else { + sendSignal(rg, GSN_TESTSIG, signal, signal->length(), JBB, ptr, secs); + } + for(Uint32 i = 0; ilength(), + JBB, + fragmentLength); + int count = 1; + while(fragSend.m_status != FragmentSendInfo::SendComplete){ + count++; + if(g_print) + ndbout_c("Sending fragment %d", count); + sendNextSegmentedFragment(signal, fragSend); + } + break; + } + case 7: + case 8:{ + LinearSectionPtr ptr[3]; + const Uint32 secs = signal->getNoOfSections(); + for(Uint32 i = 0; igetSection(sptr, i); + ptr[i].sz = sptr.sz; + ptr[i].p = new Uint32[sptr.sz]; + copy(ptr[i].p, sptr); + } + + NodeReceiverGroup tmp; + if(testType == 7){ + tmp = ref; + } else { + tmp = rg; + } + + FragmentSendInfo fragSend; + sendFirstFragment(fragSend, + tmp, + GSN_TESTSIG, + signal, + signal->length(), + JBB, + ptr, + secs, + fragmentLength); + + int count = 1; + while(fragSend.m_status != FragmentSendInfo::SendComplete){ + count++; + if(g_print) + ndbout_c("Sending fragment %d", count); + sendNextLinearFragment(signal, fragSend); + } + + for(Uint32 i = 0; ilength(), JBB, + m_callBack, + fragmentLength); + } else { + m_callBack.m_callbackData = 10; + sendFragmentedSignal(rg, + GSN_TESTSIG, signal, signal->length(), JBB, + m_callBack, + fragmentLength); + } + break; + } + case 11: + case 12:{ + + const Uint32 secs = signal->getNoOfSections(); + memset(g_test, 0, sizeof(g_test)); + for(Uint32 i = 0; igetSection(sptr, i); + g_test[i].sz = sptr.sz; + g_test[i].p = new Uint32[sptr.sz]; + copy(g_test[i].p, sptr); + } + + + Callback m_callBack; + m_callBack.m_callbackFunction = + safe_cast(&Cmvmi::sendFragmentedComplete); + + if(testType == 11){ + m_callBack.m_callbackData = 11; + sendFragmentedSignal(ref, + GSN_TESTSIG, signal, signal->length(), JBB, + g_test, secs, + m_callBack, + fragmentLength); + } else { + m_callBack.m_callbackData = 12; + sendFragmentedSignal(rg, + GSN_TESTSIG, signal, signal->length(), JBB, + g_test, secs, + m_callBack, + fragmentLength); + } + break; + } + default: + ndbrequire(false); + } + return; +} + +void +Cmvmi::sendFragmentedComplete(Signal* signal, Uint32 data, Uint32 returnCode){ + if(g_print) + ndbout_c("sendFragmentedComplete: %d", data); + if(data == 11 || data == 12){ + for(Uint32 i = 0; i<3; i++){ + if(g_test[i].p != 0) + delete[] g_test[i].p; + } + } +} diff --git a/ndb/src/kernel/blocks/cmvmi/Cmvmi.hpp b/ndb/src/kernel/blocks/cmvmi/Cmvmi.hpp new file mode 100644 index 00000000000..4f42c2efc93 --- /dev/null +++ b/ndb/src/kernel/blocks/cmvmi/Cmvmi.hpp @@ -0,0 +1,131 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef Cmvmi_H_ +#define Cmvmi_H_ + +#include +#include +#include + +#include + +/** + * Cmvmi class + */ +class Cmvmi : public SimulatedBlock { +public: + Cmvmi(const Configuration & conf); + virtual ~Cmvmi(); + +private: + /** + * These methods used to be reportXXX + * + * But they in a nasty way intefere with the execution model + * they been turned in to exec-Method used via prio A signals + */ + void execDISCONNECT_REP(Signal*); + void execCONNECT_REP(Signal*); + +private: + BLOCK_DEFINES(Cmvmi); + + // The signal processing functions + void execNDB_TAMPER(Signal* signal); + void execSET_LOGLEVELORD(Signal* signal); + void execEVENT_REP(Signal* signal); + void execSTTOR_Local(Signal* signal); + void execCM_RUN(Signal* signal); + void execCM_INFOREQ(Signal* signal); + void execCMVMI_CFGREQ(Signal* signal); + void execCLOSE_COMREQ(Signal* signal); + void execENABLE_COMORD(Signal* signal); + void execOPEN_COMREQ(Signal* signal); + void execSIZEALT_ACK(Signal* signal); + void execTEST_ORD(Signal* signal); + + void execSTATISTICS_REQ(Signal* signal); + void execSTOP_ORD(Signal* signal); + void execSTART_ORD(Signal* signal); + void execTAMPER_ORD(Signal* signal); + void execSET_VAR_REQ(Signal* signal); + void execSET_VAR_CONF(Signal* signal); + void execSET_VAR_REF(Signal* signal); + + void execDUMP_STATE_ORD(Signal* signal); + + void execEVENT_SUBSCRIBE_REQ(Signal *); + void cancelSubscription(NodeId nodeId); + + void handleSET_VAR_REQ(Signal* signal); + + void execTESTSIG(Signal* signal); + + int signalCount; + int theSignalKey; + int theStartPhase; + int theNumberOfNodes; + + char theErrorMessage[256]; + void sendSTTORRY(Signal* signal); + + LogLevel clogLevel; + class Configuration & theConfig; + const class ClusterConfiguration & theCConfig; + + /** + * This struct defines the data needed for a EVENT_REP subscriber + */ + struct EventRepSubscriber { + /** + * What log level is the subscriber using + */ + LogLevel logLevel; + + /** + * What block reference does he use + * (Where should the EVENT_REP's be forwarded) + */ + BlockReference blockRef; + + /** + * Next ptr (used in pool/list) + */ + union { Uint32 nextPool; Uint32 nextList; }; + Uint32 prevList; + }; + typedef Ptr SubscriberPtr; + + /** + * Pool of EventRepSubscriber record + */ + ArrayPool subscriberPool; + + /** + * List of current subscribers + */ + ArrayList subscribers; + +private: + // Declared but not defined + Cmvmi(const Cmvmi &obj); + void operator = (const Cmvmi &); + + void sendFragmentedComplete(Signal* signal, Uint32 data, Uint32 returnCode); +}; + +#endif diff --git a/ndb/src/kernel/blocks/cmvmi/Makefile b/ndb/src/kernel/blocks/cmvmi/Makefile new file mode 100644 index 00000000000..d75e5dbf08b --- /dev/null +++ b/ndb/src/kernel/blocks/cmvmi/Makefile @@ -0,0 +1,9 @@ +include .defs.mk + +TYPE := kernel + +ARCHIVE_TARGET := cmvmi + +SOURCES = Cmvmi.cpp + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/kernel/blocks/dbacc/Dbacc.hpp b/ndb/src/kernel/blocks/dbacc/Dbacc.hpp new file mode 100644 index 00000000000..fef41be88c4 --- /dev/null +++ b/ndb/src/kernel/blocks/dbacc/Dbacc.hpp @@ -0,0 +1,1568 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DBACC_H +#define DBACC_H + + + +#include +#include + +#ifdef DBACC_C +// Debug Macros +#define dbgWord32(ptr, ind, val) + +/* +#define dbgWord32(ptr, ind, val) \ +if(debug_jan){ \ +tmp_val = val; \ +switch(ind){ \ +case 1: strcpy(tmp_string, "ZPOS_PAGE_TYPE "); \ +break; \ +case 2: strcpy(tmp_string, "ZPOS_NO_ELEM_IN_PAGE"); \ +break; \ +case 3: strcpy(tmp_string, "ZPOS_CHECKSUM "); \ +break; \ +case 4: strcpy(tmp_string, "ZPOS_OVERFLOWREC "); \ +break; \ +case 5: strcpy(tmp_string, "ZPOS_FREE_AREA_IN_PAGE"); \ +break; \ +case 6: strcpy(tmp_string, "ZPOS_LAST_INDEX "); \ +break; \ +case 7: strcpy(tmp_string, "ZPOS_INSERT_INDEX "); \ +break; \ +case 8: strcpy(tmp_string, "ZPOS_ARRAY_POS "); \ +break; \ +case 9: strcpy(tmp_string, "ZPOS_NEXT_FREE_INDEX"); \ +break; \ +case 10: strcpy(tmp_string, "ZPOS_NEXT_PAGE "); \ +break; \ +case 11: strcpy(tmp_string, "ZPOS_PREV_PAGE "); \ +break; \ +default: sprintf(tmp_string, "%-20d", ind);\ +} \ +ndbout << "Ptr: " << ptr.p->word32 << " \tIndex: " << tmp_string << " \tValue: " << tmp_val << " \tLINE: " << __LINE__ << endl; \ +}\ +*/ + +#define dbgUndoword(ptr, ind, val) + +// Constants +/** ------------------------------------------------------------------------ + * THESE ARE CONSTANTS THAT ARE USED FOR DEFINING THE SIZE OF BUFFERS, THE + * SIZE OF PAGE HEADERS, THE NUMBER OF BUFFERS IN A PAGE AND A NUMBER OF + * OTHER CONSTANTS WHICH ARE CHANGED WHEN THE BUFFER SIZE IS CHANGED. + * ----------------------------------------------------------------------- */ +#define ZHEAD_SIZE 32 +#define ZCON_HEAD_SIZE 2 +#define ZBUF_SIZE 28 +#define ZEMPTYLIST 72 +#define ZUP_LIMIT 14 +#define ZDOWN_LIMIT 12 +#define ZSHIFT_PLUS 5 +#define ZSHIFT_MINUS 2 +#define ZFREE_LIMIT 65 +#define ZNO_CONTAINERS 64 +#define ZELEM_HEAD_SIZE 1 +/* ------------------------------------------------------------------------- */ +/* THESE CONSTANTS DEFINE THE USE OF THE PAGE HEADER IN THE INDEX PAGES. */ +/* ------------------------------------------------------------------------- */ +#define ZPOS_PAGE_ID 0 +#define ZPOS_PAGE_TYPE 1 +#define ZPOS_PAGE_TYPE_BIT 14 +#define ZPOS_EMPTY_LIST 1 +#define ZPOS_ALLOC_CONTAINERS 2 +#define ZPOS_CHECKSUM 3 +#define ZPOS_OVERFLOWREC 4 +#define ZPOS_NO_ELEM_IN_PAGE 2 +#define ZPOS_FREE_AREA_IN_PAGE 5 +#define ZPOS_LAST_INDEX 6 +#define ZPOS_INSERT_INDEX 7 +#define ZPOS_ARRAY_POS 8 +#define ZPOS_NEXT_FREE_INDEX 9 +#define ZPOS_NEXT_PAGE 10 +#define ZPOS_PREV_PAGE 11 +#define ZNORMAL_PAGE_TYPE 0 +#define ZOVERFLOW_PAGE_TYPE 1 +#define ZLONG_PAGE_TYPE 2 +#define ZDEFAULT_LIST 3 +#define ZWORDS_IN_PAGE 2048 +/* --------------------------------------------------------------------------------- */ +/* CONSTANTS FOR THE ZERO PAGES */ +/* --------------------------------------------------------------------------------- */ +#define ZPAGEZERO_PREV_UNDOP 8 +#define ZPAGEZERO_NO_OVER_PAGE 9 +#define ZPAGEZERO_TABID 10 +#define ZPAGEZERO_FRAGID0 11 +#define ZPAGEZERO_FRAGID1 12 +#define ZPAGEZERO_HASH_CHECK 13 +#define ZPAGEZERO_DIRSIZE 14 +#define ZPAGEZERO_EXPCOUNTER 15 +#define ZPAGEZERO_NEXT_UNDO_FILE 16 +#define ZPAGEZERO_SLACK 17 +#define ZPAGEZERO_NO_PAGES 18 +#define ZPAGEZERO_HASHCHECKBIT 19 +#define ZPAGEZERO_K 20 +#define ZPAGEZERO_LHFRAGBITS 21 +#define ZPAGEZERO_LHDIRBITS 22 +#define ZPAGEZERO_LOCALKEYLEN 23 +#define ZPAGEZERO_MAXP 24 +#define ZPAGEZERO_MAXLOADFACTOR 25 +#define ZPAGEZERO_MINLOADFACTOR 26 +#define ZPAGEZERO_MYFID 27 +#define ZPAGEZERO_LAST_OVER_INDEX 28 +#define ZPAGEZERO_P 29 +#define ZPAGEZERO_NO_OF_ELEMENTS 30 +#define ZPAGEZERO_ELEMENT_LENGTH 31 +#define ZPAGEZERO_KEY_LENGTH 32 +#define ZPAGEZERO_NODETYPE 33 +#define ZPAGEZERO_SLACK_CHECK 34 +/* --------------------------------------------------------------------------------- */ +/* CONSTANTS FOR THE LONG KEY PAGES */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +// Maximum number of elements in long key page = (ZWORDS_IN_PAGE - ZHEAD_SIZE) / +// (MinKeySize + IndexSize) = (2048 - 32) / (8 + 1) = 224. MinKeySize is actually 9 +// because 8 is the largest normal key size. +#define ZMAX_NO_OF_LONGKEYS_IN_PAGE 225 +#define ZMAX_LONG_KEY_ARRAY_INDEX 3 +#define ZACTIVE_LONG_KEY_LEN 1 +/* --------------------------------------------------------------------------------- */ +/* CONSTANTS IN ALPHABETICAL ORDER */ +/* --------------------------------------------------------------------------------- */ +#define ZADDFRAG 0 +#define ZCOPY_NEXT 1 +#define ZCOPY_NEXT_COMMIT 2 +#define ZCOPY_COMMIT 3 +#define ZCOPY_REPEAT 4 +#define ZCOPY_ABORT 5 +#define ZCOPY_CLOSE 6 +#define ZDIRARRAY 68 +#define ZDIRRANGESIZE 65 +//#define ZEMPTY_FRAGMENT 0 +#define ZFRAGMENTSIZE 64 +#define ZFIRSTTIME 1 +#define ZFS_CONNECTSIZE 300 +#define ZFS_OPSIZE 100 +#define ZKEYINKEYREQ 4 +#define ZLCP_CONNECTSIZE 30 +#define ZLEFT 1 +#define ZLOCALLOGFILE 2 +#define ZLOCKED 0 +#define ZMAXSCANSIGNALLEN 20 +#define ZMAINKEYLEN 8 +#define ZMAX_UNDO_VERSION 4 +#define ZNO_OF_DISK_VERSION 3 +#define ZNO_OF_OP_PER_SIGNAL 20 +//#define ZNOT_EMPTY_FRAGMENT 1 +#define ZNR_OF_UNDO_PAGE_GROUP 16 +#define ZOP_HEAD_INFO_LN 3 +#define ZOPRECSIZE 740 +#define ZOVERFLOWRECSIZE 5 +#define ZPAGE8_BASE_ADD 1 +#define ZPAGESIZE 128 +#define ZPARALLEL_QUEUE 1 +#define ZPDIRECTORY 1 +#define ZSCAN_MAX_LOCK 4 +#define ZSERIAL_QUEUE 2 +#define ZSPH1 1 +#define ZSPH2 2 +#define ZSPH3 3 +#define ZSPH6 6 +#define ZREADLOCK 0 +#define ZRIGHT 2 +#define ZROOTFRAGMENTSIZE 32 +#define ZSCAN_LOCK_ALL 3 +#define ZSCAN_OP 5 +#define ZSCAN_REC_SIZE 256 +#define ZSR_VERSION_REC_SIZE 16 +#define ZSTAND_BY 2 +#define ZTABLESIZE 16 +#define ZTABMAXINDEX 3 +#define ZUNDEFINED_OP 6 +#define ZUNDOPAGESIZE 64 +#define ZUNDOHEADSIZE 7 +#define ZUNLOCKED 1 +#define ZUNDOPAGE_BASE_ADD 2 +#define ZUNDOPAGEINDEXBITS 13 +#define ZUNDOPAGEINDEX_MASK 0x1fff +#define ZWRITEPAGESIZE 8 +#define ZWRITE_UNDOPAGESIZE 2 +#define ZMIN_UNDO_PAGES_AT_COMMIT 4 +#define ZMIN_UNDO_PAGES_AT_OPERATION 10 +#define ZMIN_UNDO_PAGES_AT_EXPAND 16 + +/* --------------------------------------------------------------------------------- */ +/* CONTINUEB CODES */ +/* --------------------------------------------------------------------------------- */ +#define ZLOAD_BAL_LCP_TIMER 0 +#define ZINITIALISE_RECORDS 1 +#define ZSR_READ_PAGES_ALLOC 2 +#define ZSTART_UNDO 3 +#define ZSEND_SCAN_HBREP 4 +#define ZREL_ROOT_FRAG 5 +#define ZREL_FRAG 6 +#define ZREL_DIR 7 +#define ZREPORT_MEMORY_USAGE 8 + +/* ------------------------------------------------------------------------- */ +/* ERROR CODES */ +/* ------------------------------------------------------------------------- */ +#define ZLIMIT_OF_ERROR 600 // Limit check for error codes +#define ZCHECKROOT_ERROR 601 // Delete fragment error code +#define ZCONNECT_SIZE_ERROR 602 // ACC_SEIZEREF +#define ZDIR_RANGE_ERROR 603 // Add fragment error code +#define ZFULL_FRAGRECORD_ERROR 604 // Add fragment error code +#define ZFULL_ROOTFRAGRECORD_ERROR 605 // Add fragment error code +#define ZROOTFRAG_STATE_ERROR 606 // Add fragment +#define ZOVERTAB_REC_ERROR 607 // Add fragment + +#define ZSCAN_REFACC_CONNECT_ERROR 608 // ACC_SCANREF +#define ZFOUR_ACTIVE_SCAN_ERROR 609 // ACC_SCANREF +#define ZNULL_SCAN_REC_ERROR 610 // ACC_SCANREF + +#define ZDIRSIZE_ERROR 623 +#define ZOVER_REC_ERROR 624 // Insufficient Space +#define ZPAGESIZE_ERROR 625 +#define ZTUPLE_DELETED_ERROR 626 +#define ZREAD_ERROR 626 +#define ZWRITE_ERROR 630 +#define ZTO_OP_STATE_ERROR 631 +#define ZTOO_EARLY_ACCESS_ERROR 632 +#define ZTEMPORARY_ACC_UNDO_FAILURE 677 +#endif + +class ElementHeader { + /** + * + * l = Locked -- If true contains operation else scan bits + hash value + * s = Scan bits + * h = Hash value + * o = Operation ptr I + * + * 1111111111222222222233 + * 01234567890123456789012345678901 + * lssssssssssss hhhhhhhhhhhhhhhh + * ooooooooooooooooooooooooooooooo + */ +public: + STATIC_CONST( HASH_VALUE_PART_MASK = 0xFFFF ); + + static bool getLocked(Uint32 data); + static bool getUnlocked(Uint32 data); + static Uint32 getScanBits(Uint32 data); + static Uint32 getHashValuePart(Uint32 data); + static Uint32 getOpPtrI(Uint32 data); + + static Uint32 setLocked(Uint32 opPtrI); + static Uint32 setUnlocked(Uint32 hashValuePart, Uint32 scanBits); + static Uint32 setScanBit(Uint32 header, Uint32 scanBit); + static Uint32 clearScanBit(Uint32 header, Uint32 scanBit); +}; + +inline +bool +ElementHeader::getLocked(Uint32 data){ + return (data & 1) == 0; +} + +inline +bool +ElementHeader::getUnlocked(Uint32 data){ + return (data & 1) == 1; +} + +inline +Uint32 +ElementHeader::getScanBits(Uint32 data){ + assert(getUnlocked(data)); + return (data >> 1) & ((1 << MAX_PARALLEL_SCANS_PER_FRAG) - 1); +} + +inline +Uint32 +ElementHeader::getHashValuePart(Uint32 data){ + assert(getUnlocked(data)); + return data >> 16; +} + +inline +Uint32 +ElementHeader::getOpPtrI(Uint32 data){ + assert(getLocked(data)); + return data >> 1; +} + +inline +Uint32 +ElementHeader::setLocked(Uint32 opPtrI){ + return (opPtrI << 1) + 0; +} +inline +Uint32 +ElementHeader::setUnlocked(Uint32 hashValue, Uint32 scanBits){ + return (hashValue << 16) + (scanBits << 1) + 1; +} + +inline +Uint32 +ElementHeader::setScanBit(Uint32 header, Uint32 scanBit){ + assert(getUnlocked(header)); + return header | (scanBit << 1); +} + +inline +Uint32 +ElementHeader::clearScanBit(Uint32 header, Uint32 scanBit){ + assert(getUnlocked(header)); + return header & (~(scanBit << 1)); +} + + +class Dbacc: public SimulatedBlock { +public: +// State values +enum State { + FREEFRAG = 0, + ACTIVEFRAG = 1, + SEND_QUE_OP = 2, + WAIT_ACC_LCPREQ = 3, + LCP_SEND_PAGES = 4, + LCP_SEND_OVER_PAGES = 5, + LCP_SEND_ZERO_PAGE = 6, + SR_READ_PAGES = 7, + SR_READ_OVER_PAGES = 8, + WAIT_ZERO_PAGE_STORED = 9, + WAIT_NOTHING = 10, + WAIT_OPEN_UNDO_LCP = 11, + WAIT_OPEN_UNDO_LCP_NEXT = 12, + WAIT_OPEN_DATA_FILE_FOR_READ = 13, + WAIT_OPEN_DATA_FILE_FOR_WRITE = 14, + OPEN_UNDO_FILE_SR = 15, + READ_UNDO_PAGE = 16, + READ_UNDO_PAGE_AND_CLOSE = 17, + WAIT_READ_DATA = 18, + WAIT_READ_PAGE_ZERO = 19, + WAIT_WRITE_DATA = 20, + WAIT_WRITE_UNDO = 21, + WAIT_WRITE_UNDO_EXIT = 22, + WAIT_CLOSE_UNDO = 23, + LCP_CLOSE_DATA = 24, + SR_CLOSE_DATA = 25, + WAIT_ONE_CONF = 26, + WAIT_TWO_CONF = 27, + LCP_FREE = 28, + LCP_ACTIVE = 29, + FREE_OP = 30, + WAIT_EXE_OP = 32, + WAIT_IN_QUEUE = 34, + EXE_OP = 35, + SCAN_ACTIVE = 36, + SCAN_WAIT_IN_QUEUE = 37, + IDLE = 39, + ACTIVE = 40, + WAIT_COMMIT_ABORT = 41, + ABORT = 42, + ABORTADDFRAG = 43, + REFUSEADDFRAG = 44, + DELETEFRAG = 45, + DELETETABLE = 46, + UNDEFINEDROOT = 47, + ADDFIRSTFRAG = 48, + ADDSECONDFRAG = 49, + DELETEFIRSTFRAG = 50, + DELETESECONDFRAG = 51, + ACTIVEROOT = 52, + LCP_CREATION = 53 +}; + +// Records + + +//---------------------------------------------------------------------------------- +// LONGKEY PAGE RECORD +// +// A long key page consist of a header part, a key data part and an index part. The +// page starts with a header of size HEAD_SIZE. As you can see below, not every word +// in the header is used. After the header comes the data part, where the actual +// keys are stored. A key is always inserted after the existing keys in the data +// part. If we have a fragmented data part and a new key doesn't fit after the +// existing keys we reorganize the keys. The index part starts at the end of the +// page and grows towards the end of the data part. This means that the limit +// between the data part and the index part is floating. Each inserted key have a +// word in the index part that describes size and position of the key in the data +// part. The free indexes in the index part are single linked. +//---------------------------------------------------------------------------------- + union LongKeyPage { + struct { + Uint32 pageId; // ZPOS_PAGE_ID 0 + Uint32 b; + // The number of keys in page. + Uint32 noOfElements; // ZPOS_NO_ELEM_IN_PAGE 2 + Uint32 d; + Uint32 e; + // The free area in the data part of page. + Uint32 freeArea; // ZPOS_FREE_AREA_IN_PAGE 5 + // The index position, which defines the limit between the data and the index part. + Uint32 highestIndex; // ZPOS_LAST_INDEX 6 + // The position where to insert the actual key in the data part. + Uint32 insertPos; // ZPOS_INSERT_INDEX 7 + // Position in a page array where the pages are stored in a double linked list. + // Based on the free area in the page. Values 0 to 3. + Uint32 pageArrayPos; // ZPOS_ARRAY_POS 8 + // Next free position in the index part. + Uint32 nextFreeIndex; // ZPOS_NEXT_FREE_INDEX 9 + // Next page in the double linked list. + Uint32 nextPage; // ZPOS_NEXT_PAGE 10 + // Previous page in the double linked list. + Uint32 prevPage; // ZPOS_PREV_PAGE 11 + } header; + // This is kept to keep the logic and to make changes to a minimum. + Uint32 word32[2048]; + }; + +/* --------------------------------------------------------------------------------- */ +/* UNDO HEADER RECORD */ +/* --------------------------------------------------------------------------------- */ + + struct UndoHeader { + enum UndoHeaderType{ + ZPAGE_INFO = 0, + ZOVER_PAGE_INFO = 1, + ZOP_INFO = 2, + ZUNDO_INSERT_LONG_KEY = 3, + ZUNDO_DELETE_LONG_KEY = 4, + ZNO_UNDORECORD_TYPES = 5 + }; + UintR tableId; + UintR rootFragId; + UintR localFragId; + UintR variousInfo; + UintR logicalPageId; + UintR prevUndoAddressForThisFrag; + UintR prevUndoAddress; + }; + +/* --------------------------------------------------------------------------------- */ +/* DIRECTORY RANGE */ +/* --------------------------------------------------------------------------------- */ + struct DirRange { + Uint32 dirArray[256]; + }; /* p2c: size = 1024 bytes */ + + typedef Ptr DirRangePtr; + +/* --------------------------------------------------------------------------------- */ +/* DIRECTORYARRAY */ +/* --------------------------------------------------------------------------------- */ +struct Directoryarray { + Uint32 pagep[256]; +}; /* p2c: size = 1024 bytes */ + + typedef Ptr DirectoryarrayPtr; + +/* --------------------------------------------------------------------------------- */ +/* FRAGMENTREC. ALL INFORMATION ABOUT FRAMENT AND HASH TABLE IS SAVED IN FRAGMENT */ +/* REC A POINTER TO FRAGMENT RECORD IS SAVED IN ROOTFRAGMENTREC FRAGMENT */ +/* --------------------------------------------------------------------------------- */ +struct Fragmentrec { +//----------------------------------------------------------------------------- +// References to long key pages with free area. Some type of buddy structure +// where references in higher index have more free space. +//----------------------------------------------------------------------------- + Uint32 longKeyPageArray[4]; + +//----------------------------------------------------------------------------- +// These variables keep track of allocated pages, the number of them and the +// start file page of them. Used during local checkpoints. +//----------------------------------------------------------------------------- + Uint32 datapages[8]; + Uint32 activeDataPage; + Uint32 activeDataFilePage; + +//----------------------------------------------------------------------------- +// Temporary variables used during shrink and expand process. +//----------------------------------------------------------------------------- + Uint32 expReceivePageptr; + Uint32 expReceiveIndex; + Uint32 expReceiveForward; + Uint32 expSenderDirIndex; + Uint32 expSenderDirptr; + Uint32 expSenderIndex; + Uint32 expSenderPageptr; + +//----------------------------------------------------------------------------- +// List of lock owners and list of lock waiters to support LCP handling +//----------------------------------------------------------------------------- + Uint32 lockOwnersList; + Uint32 firstWaitInQueOp; + Uint32 lastWaitInQueOp; + Uint32 sentWaitInQueOp; + +//----------------------------------------------------------------------------- +// References to Directory Ranges (which in turn references directories, which +// in its turn references the pages) for the bucket pages and the overflow +// bucket pages. +//----------------------------------------------------------------------------- + Uint32 directory; + Uint32 dirsize; + Uint32 overflowdir; + Uint32 lastOverIndex; + +//----------------------------------------------------------------------------- +// These variables are used to support LCP and Restore from disk. +// lcpDirIndex: used during LCP as the frag page id currently stored. +// lcpMaxDirIndex: The dirsize at start of LCP. +// lcpMaxOverDirIndex: The xx at start of LCP +// During a LCP one writes the minimum of the number of pages in the directory +// and the number of pages at the start of the LCP. +// noStoredPages: Number of bucket pages written in LCP used at restore +// noOfOverStoredPages: Number of overflow pages written in LCP used at restore +// This variable is also used during LCP to calculate this number. +//----------------------------------------------------------------------------- + Uint32 lcpDirIndex; + Uint32 lcpMaxDirIndex; + Uint32 lcpMaxOverDirIndex; + Uint32 noStoredPages; + Uint32 noOfStoredOverPages; + +//----------------------------------------------------------------------------- +// We have a list of overflow pages with free areas. We have a special record, +// the overflow record representing these pages. The reason is that the +// same record is also used to represent pages in the directory array that have +// been released since they were empty (there were however higher indexes with +// data in them). These are put in the firstFreeDirIndexRec-list. +// An overflow record representing a page can only be in one of these lists. +//----------------------------------------------------------------------------- + Uint32 firstOverflowRec; + Uint32 lastOverflowRec; + Uint32 firstFreeDirindexRec; + +//----------------------------------------------------------------------------- +// localCheckpId is used during execution of UNDO log to ensure that we only +// apply UNDO log records from the restored LCP of the fragment. +// lcpLqhPtr keeps track of LQH record for this fragment to checkpoint +//----------------------------------------------------------------------------- + Uint32 localCheckpId; + Uint32 lcpLqhPtr; + +//----------------------------------------------------------------------------- +// Counter keeping track of how many times we have expanded. We need to ensure +// that we do not shrink so many times that this variable becomes negative. +//----------------------------------------------------------------------------- + Uint32 expandCounter; +//----------------------------------------------------------------------------- +// Reference to record for open file at LCP and restore +//----------------------------------------------------------------------------- + Uint32 fsConnPtr; + +//----------------------------------------------------------------------------- +// These variables are important for the linear hashing algorithm. +// localkeylen is the size of the local key (1 and 2 is currently supported) +// maxloadfactor is the factor specifying when to expand +// minloadfactor is the factor specifying when to shrink (hysteresis model) +// maxp and p +// maxp and p is the variables most central to linear hashing. p + maxp + 1 is the +// current number of buckets. maxp is the largest value of the type 2**n - 1 +// which is smaller than the number of buckets. These values are used to find +// correct bucket with the aid of the hash value. +// +// slack is the variable keeping track of whether we have inserted more than +// the current size is suitable for or less. Slack together with the boundaries +// set by maxloadfactor and minloadfactor decides when to expand/shrink +// slackCheck When slack goes over this value it is time to expand. +// slackCheck = (maxp + p + 1)*(maxloadfactor - minloadfactor) or +// bucketSize * hysteresis +//----------------------------------------------------------------------------- + Uint32 localkeylen; + Uint32 maxp; + Uint32 maxloadfactor; + Uint32 minloadfactor; + Uint32 p; + Uint32 slack; + Uint32 slackCheck; + +//----------------------------------------------------------------------------- +// myfid is the fragment id of the fragment +// myroot is the reference to the root fragment record +// nextfreefrag is the next free fragment if linked into a free list +//----------------------------------------------------------------------------- + Uint32 myfid; + Uint32 myroot; + Uint32 myTableId; + Uint32 nextfreefrag; + +//----------------------------------------------------------------------------- +// This variable is used during restore to keep track of page id of read pages. +// During read of bucket pages this is used to calculate the page id and also +// to verify that the page id of the read page is correct. During read of over- +// flow pages it is only used to keep track of the number of pages read. +//----------------------------------------------------------------------------- + Uint32 nextAllocPage; + +//----------------------------------------------------------------------------- +// Keeps track of undo position for fragment during LCP and restore. +//----------------------------------------------------------------------------- + Uint32 prevUndoposition; + +//----------------------------------------------------------------------------- +// Page reference during LCP and restore of page zero where fragment data is +// saved +//----------------------------------------------------------------------------- + Uint32 zeroPagePtr; + +//----------------------------------------------------------------------------- +// Number of pages read from file during restore +//----------------------------------------------------------------------------- + Uint32 noOfExpectedPages; + +//----------------------------------------------------------------------------- +// Fragment State, mostly applicable during LCP and restore +//----------------------------------------------------------------------------- + State fragState; + +//----------------------------------------------------------------------------- +// Keep track of number of outstanding writes of UNDO log records to ensure that +// we have saved all UNDO info before concluding local checkpoint. +//----------------------------------------------------------------------------- + Uint32 nrWaitWriteUndoExit; + +//----------------------------------------------------------------------------- +// lastUndoIsStored is used to handle parallel writes of UNDO log and pages to +// know when LCP is completed +//----------------------------------------------------------------------------- + Uint8 lastUndoIsStored; + +//----------------------------------------------------------------------------- +// Set to ZTRUE when local checkpoint freeze occurs and set to ZFALSE when +// local checkpoint concludes. +//----------------------------------------------------------------------------- + Uint8 createLcp; + +//----------------------------------------------------------------------------- +// Flag indicating whether we are in the load phase of restore still. +//----------------------------------------------------------------------------- + Uint8 loadingFlag; + +//----------------------------------------------------------------------------- +// elementLength: Length of element in bucket and overflow pages +// keyLength: Length of key (== 0 if long key or variable key length) +//----------------------------------------------------------------------------- + Uint8 elementLength; + Uint8 keyLength; + +//----------------------------------------------------------------------------- +// This flag is used to avoid sending a big number of expand or shrink signals +// when simultaneously committing many inserts or deletes. +//----------------------------------------------------------------------------- + Uint8 expandFlag; + +//----------------------------------------------------------------------------- +// hashcheckbit is the bit to check whether to send element to split bucket or not +// k (== 6) is the number of buckets per page +// lhfragbits is the number of bits used to calculate the fragment id +// lhdirbits is the number of bits used to calculate the page id +//----------------------------------------------------------------------------- + Uint8 hashcheckbit; + Uint8 k; + Uint8 lhfragbits; + Uint8 lhdirbits; + +//----------------------------------------------------------------------------- +// nodetype can only be STORED in this release. Is currently only set, never read +// stopQueOp is indicator that locked operations will not start until LCP have +// released the lock on the fragment +//----------------------------------------------------------------------------- + Uint8 nodetype; + Uint8 stopQueOp; +}; + + typedef Ptr FragmentrecPtr; + +/* --------------------------------------------------------------------------------- */ +/* FS_CONNECTREC */ +/* --------------------------------------------------------------------------------- */ +struct FsConnectrec { + Uint32 fsNext; + Uint32 fsPrev; + Uint32 fragrecPtr; + Uint32 fsPtr; + State fsState; + Uint8 activeFragId; + Uint8 fsPart; +}; /* p2c: size = 24 bytes */ + + typedef Ptr FsConnectrecPtr; + +/* --------------------------------------------------------------------------------- */ +/* FS_OPREC */ +/* --------------------------------------------------------------------------------- */ +struct FsOprec { + Uint32 fsOpnext; + Uint32 fsOpfragrecPtr; + Uint32 fsConptr; + State fsOpstate; + Uint16 fsOpMemPage; +}; /* p2c: size = 20 bytes */ + + typedef Ptr FsOprecPtr; + +/* --------------------------------------------------------------------------------- */ +/* LCP_CONNECTREC */ +/* --------------------------------------------------------------------------------- */ +struct LcpConnectrec { + Uint32 nextLcpConn; + Uint32 lcpUserptr; + Uint32 rootrecptr; + State syncUndopageState; + State lcpstate; + Uint32 lcpUserblockref; + Uint16 localCheckPid; + Uint8 noOfLcpConf; +}; + typedef Ptr LcpConnectrecPtr; + +/* --------------------------------------------------------------------------------- */ +/* OPERATIONREC */ +/* --------------------------------------------------------------------------------- */ +struct Operationrec { + Uint32 keydata[8]; + Uint32 localdata[2]; + Uint32 elementIsforward; + Uint32 elementPage; + Uint32 elementPointer; + Uint32 fid; + Uint32 fragptr; + Uint32 hashvaluePart; + Uint32 hashValue; + Uint32 insertDeleteLen; + Uint32 keyinfoPage; + Uint32 nextLockOwnerOp; + Uint32 nextOp; + Uint32 nextParallelQue; + Uint32 nextQueOp; + Uint32 nextSerialQue; + Uint32 prevOp; + Uint32 prevLockOwnerOp; + Uint32 prevParallelQue; + Uint32 prevQueOp; + Uint32 prevSerialQue; + Uint32 scanRecPtr; + Uint32 transId1; + Uint32 transId2; + Uint32 longPagePtr; + Uint32 longKeyPageIndex; + State opState; + Uint32 userptr; + State transactionstate; + Uint16 elementContainer; + Uint16 tupkeylen; + Uint32 userblockref; + Uint32 scanBits; + Uint8 elementIsDisappeared; + Uint8 insertIsDone; + Uint8 lockMode; + Uint8 lockOwner; + Uint8 nodeType; + Uint8 operation; + Uint8 opSimple; + Uint8 dirtyRead; + Uint8 commitDeleteCheckFlag; + Uint8 isAccLockReq; + Uint32 nextOpList; +}; /* p2c: size = 168 bytes */ + + typedef Ptr OperationrecPtr; + +/* --------------------------------------------------------------------------------- */ +/* OVERFLOW_RECORD */ +/* --------------------------------------------------------------------------------- */ +struct OverflowRecord { + Uint32 dirindex; + Uint32 nextOverRec; + Uint32 nextOverList; + Uint32 prevOverRec; + Uint32 prevOverList; + Uint32 overpage; + Uint32 nextfreeoverrec; +}; + + typedef Ptr OverflowRecordPtr; + +/* --------------------------------------------------------------------------------- */ +/* PAGE8 */ +/* --------------------------------------------------------------------------------- */ +struct Page8 { + Uint32 word32[2048]; +}; /* p2c: size = 8192 bytes */ + + typedef Ptr Page8Ptr; + +/* --------------------------------------------------------------------------------- */ +/* ROOTFRAGMENTREC */ +/* DURING EXPAND FRAGMENT PROCESS, EACH FRAGMEND WILL BE EXPAND INTO TWO */ +/* NEW FRAGMENTS.TO MAKE THIS PROCESS EASIER, DURING ADD FRAGMENT PROCESS */ +/* NEXT FRAGMENT IDENTIIES WILL BE CALCULATED, AND TWO FRAGMENTS WILL BE */ +/* ADDED IN (NDBACC). THEREBY EXPAND OF FRAGMENT CAN BE PERFORMED QUICK AND */ +/* EASY.THE NEW FRAGMENT ID SENDS TO TUP MANAGER FOR ALL OPERATION PROCESS. */ +/* --------------------------------------------------------------------------------- */ +struct Rootfragmentrec { + Uint32 scan[MAX_PARALLEL_SCANS_PER_FRAG]; + Uint32 fragmentptr[2]; + Uint32 fragmentid[2]; + Uint32 lcpPtr; + Uint32 mytabptr; + Uint32 nextroot; + Uint32 roothashcheck; + Uint32 noOfElements; + State rootState; +}; /* p2c: size = 72 bytes */ + + typedef Ptr RootfragmentrecPtr; + +/* --------------------------------------------------------------------------------- */ +/* SCAN_REC */ +/* --------------------------------------------------------------------------------- */ +struct ScanRec { + enum ScanState { + WAIT_NEXT, + SCAN_DISCONNECT + }; + enum ScanBucketState { + FIRST_LAP, + SECOND_LAP, + SCAN_COMPLETED + }; + Uint32 activeLocalFrag; + Uint32 rootPtr; + Uint32 nextBucketIndex; + Uint32 scanNextfreerec; + Uint32 scanFirstActiveOp; + Uint32 scanFirstLockedOp; + Uint32 scanLastLockedOp; + Uint32 scanFirstQueuedOp; + Uint32 scanLastQueuedOp; + Uint32 scanUserptr; + Uint32 scanTrid1; + Uint32 scanTrid2; + Uint32 startNoOfBuckets; + Uint32 minBucketIndexToRescan; + Uint32 maxBucketIndexToRescan; + Uint32 scanOpsAllocated; + ScanBucketState scanBucketState; + ScanState scanState; + Uint16 scanLockHeld; + Uint32 scanUserblockref; + Uint32 scanMask; + Uint8 scanLockMode; + Uint8 scanKeyinfoFlag; + Uint8 scanTimer; + Uint8 scanContinuebCounter; + Uint8 scanReadCommittedFlag; +}; + + typedef Ptr ScanRecPtr; + +/* --------------------------------------------------------------------------------- */ +/* SR_VERSION_REC */ +/* --------------------------------------------------------------------------------- */ +struct SrVersionRec { + Uint32 nextFreeSr; + Uint32 checkPointId; + Uint32 prevAddress; + Uint32 srUnused; /* p2c: Not used */ +}; /* p2c: size = 16 bytes */ + + typedef Ptr SrVersionRecPtr; + +/* --------------------------------------------------------------------------------- */ +/* TABREC */ +/* --------------------------------------------------------------------------------- */ +struct Tabrec { + Uint32 fragholder[NO_OF_FRAG_PER_NODE]; + Uint32 fragptrholder[NO_OF_FRAG_PER_NODE]; + Uint32 tabUserPtr; + BlockReference tabUserRef; +}; + typedef Ptr TabrecPtr; + +/* --------------------------------------------------------------------------------- */ +/* UNDOPAGE */ +/* --------------------------------------------------------------------------------- */ +struct Undopage { + Uint32 undoword[8192]; +}; /* p2c: size = 32768 bytes */ + + typedef Ptr UndopagePtr; + +public: + Dbacc(const class Configuration &); + virtual ~Dbacc(); + +private: + BLOCK_DEFINES(Dbacc); + + // Transit signals + void execDEBUG_SIG(Signal* signal); + void execCONTINUEB(Signal* signal); + void execACC_CHECK_SCAN(Signal* signal); + void execEXPANDCHECK2(Signal* signal); + void execSHRINKCHECK2(Signal* signal); + void execACC_OVER_REC(Signal* signal); + void execACC_SAVE_PAGES(Signal* signal); + void execNEXTOPERATION(Signal* signal); + + // Received signals + void execSTTOR(Signal* signal); + void execSR_FRAGIDREQ(Signal* signal); + void execLCP_FRAGIDREQ(Signal* signal); + void execLCP_HOLDOPREQ(Signal* signal); + void execEND_LCPREQ(Signal* signal); + void execACC_LCPREQ(Signal* signal); + void execSTART_RECREQ(Signal* signal); + void execACC_CONTOPREQ(Signal* signal); + void execACCKEYREQ(Signal* signal); + void execACCSEIZEREQ(Signal* signal); + void execACCFRAGREQ(Signal* signal); + void execACC_SRREQ(Signal* signal); + void execNEXT_SCANREQ(Signal* signal); + void execACC_ABORTREQ(Signal* signal); + void execACC_SCANREQ(Signal* signal); + void execACCMINUPDATE(Signal* signal); + void execACC_COMMITREQ(Signal* signal); + void execACC_TO_REQ(Signal* signal); + void execACC_LOCKREQ(Signal* signal); + void execFSOPENCONF(Signal* signal); + void execFSOPENREF(Signal* signal); + void execFSCLOSECONF(Signal* signal); + void execFSCLOSEREF(Signal* signal); + void execFSWRITECONF(Signal* signal); + void execFSWRITEREF(Signal* signal); + void execFSREADCONF(Signal* signal); + void execFSREADREF(Signal* signal); + void execNDB_STTOR(Signal* signal); + void execDROP_TAB_REQ(Signal* signal); + void execFSREMOVECONF(Signal* signal); + void execFSREMOVEREF(Signal* signal); + void execSIZEALT_REP(Signal* signal); + void execSET_VAR_REQ(Signal* signal); + void execDUMP_STATE_ORD(Signal* signal); + + // Statement blocks + void ACCKEY_error(Uint32 fromWhere); + + void commitDeleteCheck(); + + void initRootFragPageZero(RootfragmentrecPtr, Page8Ptr); + void initRootFragSr(RootfragmentrecPtr, Page8Ptr); + void initFragAdd(Signal*, Uint32 rootFragIndex, Uint32 rootIndex, FragmentrecPtr); + void initFragPageZero(FragmentrecPtr, Page8Ptr); + void initFragSr(FragmentrecPtr, Page8Ptr); + void initFragGeneral(FragmentrecPtr); + void verifyFragCorrect(FragmentrecPtr regFragPtr); + void sendFSREMOVEREQ(Signal* signal, Uint32 tableId); + void sendDROP_TABFILECONF(Signal* signal, TabrecPtr tabPtr); + void releaseFragResources(Signal* signal, Uint32 fragIndex); + void releaseRootFragRecord(Signal* signal, RootfragmentrecPtr rootPtr); + void sendREL_TABMEMCONF(Signal* signal, TabrecPtr tabPtr); + void releaseRootFragResources(Signal* signal, Uint32 tableId); + void releaseDirResources(Signal* signal, + Uint32 fragIndex, + Uint32 dirIndex, + Uint32 startIndex); + void releaseDirectoryResources(Signal* signal, + Uint32 fragIndex, + Uint32 dirIndex, + Uint32 startIndex, + Uint32 directoryIndex); + void releaseOverflowResources(Signal* signal, FragmentrecPtr regFragPtr); + void releaseDirIndexResources(Signal* signal, FragmentrecPtr regFragPtr); + void releaseFragRecord(Signal* signal, FragmentrecPtr regFragPtr); + Uint32 remainingUndoPages(); + void updateLastUndoPageIdWritten(Signal* signal, Uint32 aNewValue); + void updateUndoPositionPage(Signal* signal, Uint32 aNewValue); + void srCheckPage(Signal* signal); + void srCheckContainer(Signal* signal); + void initScanFragmentPart(Signal* signal); + Uint32 checkScanExpand(Signal* signal); + Uint32 checkScanShrink(Signal* signal); + void sendInitialiseRecords(Signal* signal); + void initialiseDirRec(Signal* signal); + void initialiseDirRangeRec(Signal* signal); + void initialiseFragRec(Signal* signal); + void initialiseFsConnectionRec(Signal* signal); + void initialiseFsOpRec(Signal* signal); + void initialiseLcpConnectionRec(Signal* signal); + void initialiseOperationRec(Signal* signal); + void initialiseOverflowRec(Signal* signal); + void initialisePageRec(Signal* signal); + void initialiseLcpPages(Signal* signal); + void initialiseRootfragRec(Signal* signal); + void initialiseScanRec(Signal* signal); + void initialiseSrVerRec(Signal* signal); + void initialiseTableRec(Signal* signal); + bool addfragtotab(Signal* signal, Uint32 rootIndex, Uint32 fragId); + void initOpRec(Signal* signal); + void sendAcckeyconf(Signal* signal); + Uint32 placeReadInLockQueue(Signal* signal); + void placeSerialQueueRead(Signal* signal); + void checkOnlyReadEntry(Signal* signal); + void getNoParallelTransaction(Signal* signal); + void moveLastParallelQueue(Signal* signal); + void moveLastParallelQueueWrite(Signal* signal); + Uint32 placeWriteInLockQueue(Signal* signal); + void placeSerialQueueWrite(Signal* signal); + void expandcontainer(Signal* signal); + void shrinkcontainer(Signal* signal); + void nextcontainerinfoExp(Signal* signal); + void lcpCopyPage(Signal* signal); + void lcpUpdatePage(Signal* signal); + void checkUndoPages(Signal* signal); + void undoWritingProcess(Signal* signal); + void writeUndoDataInfo(Signal* signal); + void writeUndoHeader(Signal* signal, + Uint32 logicalPageId, + UndoHeader::UndoHeaderType pageType); + void writeUndoOpInfo(Signal* signal); + void checksumControl(Signal* signal, Uint32 checkPage); + void startActiveUndo(Signal* signal); + void releaseAndCommitActiveOps(Signal* signal); + void releaseAndCommitQueuedOps(Signal* signal); + void releaseAndAbortLockedOps(Signal* signal); + void containerinfo(Signal* signal); + bool getScanElement(Signal* signal); + void initScanOpRec(Signal* signal); + void nextcontainerinfo(Signal* signal); + void putActiveScanOp(Signal* signal); + void putOpScanLockQue(); + void putReadyScanQueue(Signal* signal, Uint32 scanRecIndex); + void releaseScanBucket(Signal* signal); + void releaseScanContainer(Signal* signal); + void releaseScanRec(Signal* signal); + bool searchScanContainer(Signal* signal); + void sendNextScanConf(Signal* signal); + void sendScaninfo(Signal* signal); + void setlock(Signal* signal); + void takeOutActiveScanOp(Signal* signal); + void takeOutScanLockQueue(Uint32 scanRecIndex); + void takeOutReadyScanQueue(Signal* signal); + void insertElement(Signal* signal); + void insertContainer(Signal* signal); + void addnewcontainer(Signal* signal); + void getfreelist(Signal* signal); + void increaselistcont(Signal* signal); + void seizeLeftlist(Signal* signal); + void seizeRightlist(Signal* signal); + void allocLongOverflowPage(Signal* signal); + void allocSpecificLongOverflowPage(Signal* signal); + void getLongKeyPage(Signal* signal); + void initLongOverpage(Signal* signal); + void storeLongKeys(Signal* signal); + void storeLongKeysAtPos(Signal* signal); + void reorgLongPage(Signal* signal); + void getElement(Signal* signal); + void searchLongKey(Signal* signal); + void getdirindex(Signal* signal); + void commitdelete(Signal* signal, bool systemRestart); + void deleteElement(Signal* signal); + void getLastAndRemove(Signal* signal); + void releaseLeftlist(Signal* signal); + void releaseRightlist(Signal* signal); + void checkoverfreelist(Signal* signal); + void deleteLongKey(Signal* signal); + void removeFromPageArrayList(Signal* signal); + void insertPageArrayList(Signal* signal); + void checkPageArrayList(Signal* signal, char *); + void checkPageB4Insert(Uint32, char *); + void checkPageB4Remove(Uint32, char *); + void checkIndexInLongKeyPage(Uint32, char *); + void printoutInfoAndShutdown(LongKeyPage *); + void releaseLongPage(Signal* signal); + void abortOperation(Signal* signal); + void accAbortReqLab(Signal* signal, bool sendConf); + void commitOperation(Signal* signal); + void copyOpInfo(Signal* signal); + Uint32 executeNextOperation(Signal* signal); + void releaselock(Signal* signal); + void takeOutFragWaitQue(Signal* signal); + void allocOverflowPage(Signal* signal); + bool getrootfragmentrec(Signal* signal, RootfragmentrecPtr&, Uint32 fragId); + void insertLockOwnersList(Signal* signal, const OperationrecPtr&); + void takeOutLockOwnersList(Signal* signal, const OperationrecPtr&); + void initFsOpRec(Signal* signal); + void initLcpConnRec(Signal* signal); + void initOverpage(Signal* signal); + void initPage(Signal* signal); + void initPageZero(Signal* signal); + void initRootfragrec(Signal* signal); + void putOpInFragWaitQue(Signal* signal); + void putOverflowRecInFrag(Signal* signal); + void putRecInFreeOverdir(Signal* signal); + void releaseDirectory(Signal* signal); + void releaseDirrange(Signal* signal); + void releaseFsConnRec(Signal* signal); + void releaseFsOpRec(Signal* signal); + void releaseLcpConnectRec(Signal* signal); + void releaseOpRec(Signal* signal); + void releaseOverflowRec(Signal* signal); + void releaseOverpage(Signal* signal); + void releasePage(Signal* signal); + void releaseLcpPage(Signal* signal); + void releaseSrRec(Signal* signal); + void releaseLogicalPage(Fragmentrec * fragP, Uint32 logicalPageId); + void seizeDirectory(Signal* signal); + void seizeDirrange(Signal* signal); + void seizeFragrec(Signal* signal); + void seizeFsConnectRec(Signal* signal); + void seizeFsOpRec(Signal* signal); + void seizeLcpConnectRec(Signal* signal); + void seizeOpRec(Signal* signal); + void seizeOverRec(Signal* signal); + void seizePage(Signal* signal); + void seizeLcpPage(Page8Ptr&); + void seizeRootfragrec(Signal* signal); + void seizeScanRec(Signal* signal); + void seizeSrVerRec(Signal* signal); + void sendSystemerror(Signal* signal); + void takeRecOutOfFreeOverdir(Signal* signal); + void takeRecOutOfFreeOverpage(Signal* signal); + void sendScanHbRep(Signal* signal, Uint32); + + void addFragRefuse(Signal* signal, Uint32 errorCode); + void ndbsttorryLab(Signal* signal); + void srCloseDataFileLab(Signal* signal); + void acckeyref1Lab(Signal* signal, Uint32 result_code); + void insertelementLab(Signal* signal); + void startUndoLab(Signal* signal); + void checkNextFragmentLab(Signal* signal); + void endofexpLab(Signal* signal); + void endofshrinkbucketLab(Signal* signal); + void srStartUndoLab(Signal* signal); + void senddatapagesLab(Signal* signal); + void undoNext2Lab(Signal* signal); + void sttorrysignalLab(Signal* signal); + void sendholdconfsignalLab(Signal* signal); + void accIsLockedLab(Signal* signal); + void insertExistElemLab(Signal* signal); + void refaccConnectLab(Signal* signal); + void srReadOverPagesLab(Signal* signal); + void releaseScanLab(Signal* signal); + void exeoperationLab(Signal* signal); + void saveKeyDataLab(Signal* signal); + void lcpOpenUndofileConfLab(Signal* signal); + void srFsOpenConfLab(Signal* signal); + void checkSyncUndoPagesLab(Signal* signal); + void sendaccSrconfLab(Signal* signal); + void checkSendLcpConfLab(Signal* signal); + void endsaveoverpageLab(Signal* signal); + void lcpCloseDataFileLab(Signal* signal); + void srOpenDataFileLoopLab(Signal* signal); + void srReadPagesLab(Signal* signal); + void srDoUndoLab(Signal* signal); + void ndbrestart1Lab(Signal* signal); + void initialiseRecordsLab(Signal* signal); + void srReadPagesAllocLab(Signal* signal); + void checkNextBucketLab(Signal* signal); + void endsavepageLab(Signal* signal); + void saveZeroPageLab(Signal* signal); + void srAllocPage0011Lab(Signal* signal); + void allocscanrecLab(Signal* signal); + void sendLcpFragidconfLab(Signal* signal); + void savepagesLab(Signal* signal); + void saveOverPagesLab(Signal* signal); + void srReadPageZeroLab(Signal* signal); + void storeDataPageInDirectoryLab(Signal* signal); + void lcpFsOpenConfLab(Signal* signal); + + void zpagesize_error(const char* where); + + void reportMemoryUsage(Signal* signal, int gth); + + + // Initialisation + void initData(); + void initRecords(); + + // Variables +/* --------------------------------------------------------------------------------- */ +/* DIRECTORY RANGE */ +/* --------------------------------------------------------------------------------- */ + DirRange *dirRange; + DirRangePtr expDirRangePtr; + DirRangePtr gnsDirRangePtr; + DirRangePtr newDirRangePtr; + DirRangePtr rdDirRangePtr; + DirRangePtr nciOverflowrangeptr; + Uint32 cdirrangesize; + Uint32 cfirstfreeDirrange; +/* --------------------------------------------------------------------------------- */ +/* DIRECTORYARRAY */ +/* --------------------------------------------------------------------------------- */ + Directoryarray *directoryarray; + DirectoryarrayPtr expDirptr; + DirectoryarrayPtr rdDirptr; + DirectoryarrayPtr sdDirptr; + DirectoryarrayPtr nciOverflowDirptr; + Uint32 cdirarraysize; + Uint32 cdirmemory; + Uint32 cfirstfreedir; +/* --------------------------------------------------------------------------------- */ +/* FRAGMENTREC. ALL INFORMATION ABOUT FRAMENT AND HASH TABLE IS SAVED IN FRAGMENT */ +/* REC A POINTER TO FRAGMENT RECORD IS SAVED IN ROOTFRAGMENTREC FRAGMENT */ +/* --------------------------------------------------------------------------------- */ + Fragmentrec *fragmentrec; + FragmentrecPtr fragrecptr; + Uint32 cfirstfreefrag; + Uint32 cfragmentsize; +/* --------------------------------------------------------------------------------- */ +/* FS_CONNECTREC */ +/* --------------------------------------------------------------------------------- */ + FsConnectrec *fsConnectrec; + FsConnectrecPtr fsConnectptr; + Uint32 cfsConnectsize; + Uint32 cfsFirstfreeconnect; +/* --------------------------------------------------------------------------------- */ +/* FS_OPREC */ +/* --------------------------------------------------------------------------------- */ + FsOprec *fsOprec; + FsOprecPtr fsOpptr; + Uint32 cfsOpsize; + Uint32 cfsFirstfreeop; +/* --------------------------------------------------------------------------------- */ +/* LCP_CONNECTREC */ +/* --------------------------------------------------------------------------------- */ + LcpConnectrec *lcpConnectrec; + LcpConnectrecPtr lcpConnectptr; + Uint32 clcpConnectsize; + Uint32 cfirstfreelcpConnect; +/* --------------------------------------------------------------------------------- */ +/* OPERATIONREC */ +/* --------------------------------------------------------------------------------- */ + Operationrec *operationrec; + OperationrecPtr operationRecPtr; + OperationrecPtr idrOperationRecPtr; + OperationrecPtr copyInOperPtr; + OperationrecPtr copyOperPtr; + OperationrecPtr mlpqOperPtr; + OperationrecPtr queOperPtr; + OperationrecPtr readWriteOpPtr; + OperationrecPtr tgnptMainOpPtr; + Uint32 cfreeopRec; + Uint32 coprecsize; +/* --------------------------------------------------------------------------------- */ +/* OVERFLOW_RECORD */ +/* --------------------------------------------------------------------------------- */ + OverflowRecord *overflowRecord; + OverflowRecordPtr iopOverflowRecPtr; + OverflowRecordPtr tfoOverflowRecPtr; + OverflowRecordPtr porOverflowRecPtr; + OverflowRecordPtr priOverflowRecPtr; + OverflowRecordPtr rorOverflowRecPtr; + OverflowRecordPtr sorOverflowRecPtr; + OverflowRecordPtr troOverflowRecPtr; + Uint32 cfirstfreeoverrec; + Uint32 coverflowrecsize; + +/* --------------------------------------------------------------------------------- */ +/* PAGE8 */ +/* --------------------------------------------------------------------------------- */ + Page8 *page8; + /* 8 KB PAGE */ + Page8Ptr aslpPageptr; + Page8Ptr alpPageptr; + Page8Ptr ancPageptr; + Page8Ptr colPageptr; + Page8Ptr ccoPageptr; + Page8Ptr datapageptr; + Page8Ptr delPageptr; + Page8Ptr excPageptr; + Page8Ptr expPageptr; + Page8Ptr gdiPageptr; + Page8Ptr gePageptr; + Page8Ptr gflPageptr; + Page8Ptr glkPageptr; + Page8Ptr idrPageptr; + Page8Ptr ilcPageptr; + Page8Ptr iloPageptr; + Page8Ptr inpPageptr; + Page8Ptr iopPageptr; + Page8Ptr ipzPageptr; + Page8Ptr lastPageptr; + Page8Ptr lastPrevpageptr; + Page8Ptr lcnPageptr; + Page8Ptr lcnCopyPageptr; + Page8Ptr lupPageptr; + Page8Ptr dlkPageptr; + Page8Ptr ipaPagePtr; + Page8Ptr priPageptr; + Page8Ptr pwiPageptr; + Page8Ptr rfpPageptr; + Page8Ptr relpPageptr; + Page8Ptr rlopPageptr; + Page8Ptr slkPageptr; + Page8Ptr slkCopyPageptr; + Page8Ptr slkapPageptr; + Page8Ptr slkapCopyPageptr; + Page8Ptr ciPageidptr; + Page8Ptr gsePageidptr; + Page8Ptr isoPageptr; + Page8Ptr nciPageidptr; + Page8Ptr rsbPageidptr; + Page8Ptr rscPageidptr; + Page8Ptr slPageidptr; + Page8Ptr sscPageidptr; + Page8Ptr rlPageptr; + Page8Ptr rlpPageptr; + Page8Ptr ropPageptr; + Page8Ptr rpPageptr; + Page8Ptr slPageptr; + Page8Ptr slpPageptr; + Page8Ptr spPageptr; + Uint32 cfirstfreepage; + Uint32 cfreepage; + Uint32 cpagesize; + Uint32 cfirstfreeLcpPage; + Uint32 cnoOfAllocatedPages; + Uint32 cnoLcpPages; +/* --------------------------------------------------------------------------------- */ +/* ROOTFRAGMENTREC */ +/* DURING EXPAND FRAGMENT PROCESS, EACH FRAGMEND WILL BE EXPAND INTO TWO */ +/* NEW FRAGMENTS.TO MAKE THIS PROCESS EASIER, DURING ADD FRAGMENT PROCESS */ +/* NEXT FRAGMENT IDENTIIES WILL BE CALCULATED, AND TWO FRAGMENTS WILL BE */ +/* ADDED IN (NDBACC). THEREBY EXPAND OF FRAGMENT CAN BE PERFORMED QUICK AND */ +/* EASY.THE NEW FRAGMENT ID SENDS TO TUP MANAGER FOR ALL OPERATION PROCESS. */ +/* --------------------------------------------------------------------------------- */ + Rootfragmentrec *rootfragmentrec; + RootfragmentrecPtr rootfragrecptr; + RootfragmentrecPtr tmprootfrgptr; + Uint32 crootfragmentsize; + Uint32 cfirstfreerootfrag; +/* --------------------------------------------------------------------------------- */ +/* SCAN_REC */ +/* --------------------------------------------------------------------------------- */ + ScanRec *scanRec; + ScanRecPtr scanPtr; + Uint32 cscanRecSize; + Uint32 cfirstFreeScanRec; +/* --------------------------------------------------------------------------------- */ +/* SR_VERSION_REC */ +/* --------------------------------------------------------------------------------- */ + SrVersionRec *srVersionRec; + SrVersionRecPtr srVersionPtr; + Uint32 csrVersionRecSize; + Uint32 cfirstFreeSrVersionRec; +/* --------------------------------------------------------------------------------- */ +/* TABREC */ +/* --------------------------------------------------------------------------------- */ + Tabrec *tabrec; + TabrecPtr tabptr; + Uint32 ctablesize; +/* --------------------------------------------------------------------------------- */ +/* UNDOPAGE */ +/* --------------------------------------------------------------------------------- */ + Undopage *undopage; + /* 32 KB PAGE */ + UndopagePtr undopageptr; + Uint32 tpwiElementptr; + Uint32 tpriElementptr; + Uint32 tgseElementptr; + Uint32 tgseContainerptr; + Uint32 tiloIndex; + Uint32 trlHead; + Uint32 trlRelCon; + Uint32 trlNextused; + Uint32 trlPrevused; + Uint32 tlcnChecksum; + Uint32 tlupElemIndex; + Uint32 tlupIndex; + Uint32 tlupForward; + Uint32 tslkPageIndex; + Uint32 tslkKeyLen; + Uint32 tslkapKeyLen; + Uint32 tslkapPageIndex; + Uint32 tipaArrayPos; + Uint32 trfpArrayPos; + Uint32 tdlkLogicalPageIndex; + Uint32 tancNext; + Uint32 tancBufType; + Uint32 tancContainerptr; + Uint32 tancPageindex; + Uint32 tancPageid; + Uint32 tidrResult; + Uint32 tidrKeyLen; + Uint32 tidrElemhead; + Uint32 tidrForward; + Uint32 tidrPageindex; + Uint32 tidrContainerptr; + Uint32 tidrContainerhead; + Uint32 tlastForward; + Uint32 tlastPageindex; + Uint32 tlastContainerlen; + Uint32 tlastElementptr; + Uint32 tlastContainerptr; + Uint32 tlastContainerhead; + Uint32 trlPageindex; + Uint32 tdelContainerptr; + Uint32 tdelElementptr; + Uint32 tdelForward; + Uint32 tiopPageId; + Uint32 tipPageId; + Uint32 ttupKeyLength; + Uint32 tgeLocked; + Uint32 tgeResult; + Uint32 tgeContainerptr; + Uint32 tgeElementptr; + Uint32 tgeForward; + Uint32 tslcResult; + Uint32 tslcPagedir; + Uint32 tslcPageIndex; + Uint32 tundoElemIndex; + Uint32 texpReceivedBucket; + Uint32 texpDirInd; + Uint32 texpDirRangeIndex; + Uint32 texpDirPageIndex; + Uint32 tdata0; + Uint32 tcheckpointid; + Uint32 tciContainerptr; + Uint32 tnciContainerptr; + Uint32 tisoContainerptr; + Uint32 trscContainerptr; + Uint32 tsscContainerptr; + Uint32 tciContainerlen; + Uint32 trscContainerlen; + Uint32 tsscContainerlen; + Uint32 tciContainerhead; + Uint32 tnciContainerhead; + Uint32 tslElementptr; + Uint32 tisoElementptr; + Uint32 tsscElementptr; + Uint32 tfid; + Uint32 tscanFlag; + Uint32 theadundoindex; + Uint32 tgflBufType; + Uint32 thashvalue; + Uint32 tgseIsforward; + Uint32 tsscIsforward; + Uint32 trscIsforward; + Uint32 tciIsforward; + Uint32 tnciIsforward; + Uint32 tisoIsforward; + Uint32 tgseIsLocked; + Uint32 tsscIsLocked; + Uint32 tkey1; + Uint32 tkey2; + Uint32 tkey3; + Uint32 tkey4; + Uint32 tkeylen; + Uint32 tkSize; + Uint32 tlhfragbits; + Uint32 tlhdirbits; + Uint32 tlocalkeylen; + Uint32 tmaxloadfactor; + Uint32 tminloadfactor; + Uint32 tmp; + Uint32 tmpP; + Uint32 tmpP2; + Uint32 taslpDirIndex; + Uint32 tmp1; + Uint32 tmp2; + Uint32 tgflPageindex; + Uint32 tmpindex; + Uint32 tslNextfree; + Uint32 tslPageindex; + Uint32 tgsePageindex; + Uint32 tnciNextSamePage; + Uint32 tslPrevfree; + Uint32 tciPageindex; + Uint32 trsbPageindex; + Uint32 tnciPageindex; + Uint32 tlastPrevconptr; + Uint32 treqinfo; + Uint32 transactionid1; + Uint32 transactionid2; + Uint32 tresult; + Uint32 tslUpdateHeader; + Uint32 tuserptr; + BlockReference tuserblockref; + Uint32 tundoindex; + Uint32 tlqhPointer; + Uint32 tholdSentOp; + Uint32 tholdMore; + Uint32 tlcpLqhCheckV; + Uint32 tgdiPageindex; + Uint32 tiopIndex; + Uint32 tnciTmp; + Uint32 tlenKeyinfo; + Uint32 tullIndex; + Uint32 turlIndex; + Uint32 tlfrTmp1; + Uint32 tlfrTmp2; + Uint32 tgnptNrTransaction; + Uint32 tudqeIndex; + Uint32 tscanTrid1; + Uint32 tscanTrid2; + Uint32 taccscanTmp; + + Uint16 clastUndoPageIdWritten; + Uint32 cactiveCheckpId; + Uint32 cactiveRootfrag; + Uint32 cactiveSrFsPtr; + Uint32 cactiveUndoFilePage; + Uint32 cactiveOpenUndoFsPtr; + Uint32 cactiveSrUndoPage; + Uint32 cprevUndoaddress; + Uint32 creadyUndoaddress; + Uint32 ctest; + Uint32 cundoLogActive; + Uint32 clqhPtr; + BlockReference clqhBlockRef; + Uint32 cminusOne; + NodeId cmynodeid; + Uint32 cactiveUndoFileVersion; + BlockReference cownBlockref; + BlockReference cndbcntrRef; + Uint16 csignalkey; + Uint32 cundopagesize; + Uint32 cundoposition; + Uint32 cundoElemIndex; + Uint32 cundoinfolength; + Uint32 czero; + Uint32 csrVersList[16]; + Uint32 clblPageCounter; + Uint32 clblPageOver; + Uint32 clblPagesPerTick; + Uint32 clblPagesPerTickAfterSr; + Uint32 csystemRestart; + Uint32 cexcForward; + Uint32 cexcPageindex; + Uint32 cexcContainerptr; + Uint32 cexcContainerhead; + Uint32 cexcContainerlen; + Uint32 cexcElementptr; + Uint32 cexcPrevconptr; + Uint32 cexcMovedLen; + Uint32 cexcPrevpageptr; + Uint32 cexcPrevpageindex; + Uint32 cexcPrevforward; + Uint32 clocalkey[32]; + Uint32 ckeys[2048]; + + Uint32 c_errorInsert3000_TableId; + Uint32 cSrUndoRecords[5]; +}; + +#endif diff --git a/ndb/src/kernel/blocks/dbacc/DbaccInit.cpp b/ndb/src/kernel/blocks/dbacc/DbaccInit.cpp new file mode 100644 index 00000000000..107420c7148 --- /dev/null +++ b/ndb/src/kernel/blocks/dbacc/DbaccInit.cpp @@ -0,0 +1,248 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + +#define DBACC_C +#include "Dbacc.hpp" + +#define DEBUG(x) { ndbout << "ACC::" << x << endl; } + +void Dbacc::initData() +{ + cdirarraysize = ZDIRARRAY; + coprecsize = ZOPRECSIZE; + cpagesize = ZPAGESIZE; + clcpConnectsize = ZLCP_CONNECTSIZE; + ctablesize = ZTABLESIZE; + cfragmentsize = ZFRAGMENTSIZE; + crootfragmentsize = ZROOTFRAGMENTSIZE; + cdirrangesize = ZDIRRANGESIZE; + coverflowrecsize = ZOVERFLOWRECSIZE; + cundopagesize = ZUNDOPAGESIZE; + cfsConnectsize = ZFS_CONNECTSIZE; + cfsOpsize = ZFS_OPSIZE; + cscanRecSize = ZSCAN_REC_SIZE; + csrVersionRecSize = ZSR_VERSION_REC_SIZE; + + + dirRange = 0; + directoryarray = 0; + fragmentrec = 0; + fsConnectrec = 0; + fsOprec = 0; + lcpConnectrec = 0; + operationrec = 0; + overflowRecord = 0; + page8 = 0; + rootfragmentrec = 0; + scanRec = 0; + srVersionRec = 0; + tabrec = 0; + undopage = 0; + + // Records with constant sizes +}//Dbacc::initData() + +void Dbacc::initRecords() +{ + // Records with dynamic sizes + dirRange = (DirRange*)allocRecord("DirRange", + sizeof(DirRange), + cdirrangesize); + + directoryarray = (Directoryarray*)allocRecord("Directoryarray", + sizeof(Directoryarray), + cdirarraysize); + + fragmentrec = (Fragmentrec*)allocRecord("Fragmentrec", + sizeof(Fragmentrec), + cfragmentsize); + + fsConnectrec = (FsConnectrec*)allocRecord("FsConnectrec", + sizeof(FsConnectrec), + cfsConnectsize); + + fsOprec = (FsOprec*)allocRecord("FsOprec", + sizeof(FsOprec), + cfsOpsize); + + lcpConnectrec = (LcpConnectrec*)allocRecord("LcpConnectrec", + sizeof(LcpConnectrec), + clcpConnectsize); + + operationrec = (Operationrec*)allocRecord("Operationrec", + sizeof(Operationrec), + coprecsize); + + overflowRecord = (OverflowRecord*)allocRecord("OverflowRecord", + sizeof(OverflowRecord), + coverflowrecsize); + + page8 = (Page8*)allocRecord("Page8", + sizeof(Page8), + cpagesize); + + rootfragmentrec = (Rootfragmentrec*)allocRecord("Rootfragmentrec", + sizeof(Rootfragmentrec), + crootfragmentsize); + + scanRec = (ScanRec*)allocRecord("ScanRec", + sizeof(ScanRec), + cscanRecSize); + + srVersionRec = (SrVersionRec*)allocRecord("SrVersionRec", + sizeof(SrVersionRec), + csrVersionRecSize); + + tabrec = (Tabrec*)allocRecord("Tabrec", + sizeof(Tabrec), + ctablesize); + + undopage = (Undopage*)allocRecord("Undopage", + sizeof(Undopage), + cundopagesize); + + // Initialize BAT for interface to file system + + NewVARIABLE* bat = allocateBat(3); + bat[1].WA = &page8->word32[0]; + bat[1].nrr = cpagesize; + bat[1].ClusterSize = sizeof(Page8); + bat[1].bits.q = 11; + bat[1].bits.v = 5; + bat[2].WA = &undopage->undoword[0]; + bat[2].nrr = cundopagesize; + bat[2].ClusterSize = sizeof(Undopage); + bat[2].bits.q = 13; + bat[2].bits.v = 5; +}//Dbacc::initRecords() + +Dbacc::Dbacc(const class Configuration & conf): + SimulatedBlock(DBACC, conf) +{ + BLOCK_CONSTRUCTOR(Dbacc); + + // Transit signals + addRecSignal(GSN_DUMP_STATE_ORD, &Dbacc::execDUMP_STATE_ORD); + addRecSignal(GSN_DEBUG_SIG, &Dbacc::execDEBUG_SIG); + addRecSignal(GSN_CONTINUEB, &Dbacc::execCONTINUEB); + addRecSignal(GSN_ACC_CHECK_SCAN, &Dbacc::execACC_CHECK_SCAN); + addRecSignal(GSN_EXPANDCHECK2, &Dbacc::execEXPANDCHECK2); + addRecSignal(GSN_SHRINKCHECK2, &Dbacc::execSHRINKCHECK2); + addRecSignal(GSN_ACC_OVER_REC, &Dbacc::execACC_OVER_REC); + addRecSignal(GSN_ACC_SAVE_PAGES, &Dbacc::execACC_SAVE_PAGES); + addRecSignal(GSN_NEXTOPERATION, &Dbacc::execNEXTOPERATION); + + // Received signals + addRecSignal(GSN_STTOR, &Dbacc::execSTTOR); + addRecSignal(GSN_SR_FRAGIDREQ, &Dbacc::execSR_FRAGIDREQ); + addRecSignal(GSN_LCP_FRAGIDREQ, &Dbacc::execLCP_FRAGIDREQ); + addRecSignal(GSN_LCP_HOLDOPREQ, &Dbacc::execLCP_HOLDOPREQ); + addRecSignal(GSN_END_LCPREQ, &Dbacc::execEND_LCPREQ); + addRecSignal(GSN_ACC_LCPREQ, &Dbacc::execACC_LCPREQ); + addRecSignal(GSN_START_RECREQ, &Dbacc::execSTART_RECREQ); + addRecSignal(GSN_ACC_CONTOPREQ, &Dbacc::execACC_CONTOPREQ); + addRecSignal(GSN_ACCKEYREQ, &Dbacc::execACCKEYREQ); + addRecSignal(GSN_ACCSEIZEREQ, &Dbacc::execACCSEIZEREQ); + addRecSignal(GSN_ACCFRAGREQ, &Dbacc::execACCFRAGREQ); + addRecSignal(GSN_ACC_SRREQ, &Dbacc::execACC_SRREQ); + addRecSignal(GSN_NEXT_SCANREQ, &Dbacc::execNEXT_SCANREQ); + addRecSignal(GSN_ACC_ABORTREQ, &Dbacc::execACC_ABORTREQ); + addRecSignal(GSN_ACC_SCANREQ, &Dbacc::execACC_SCANREQ); + addRecSignal(GSN_ACCMINUPDATE, &Dbacc::execACCMINUPDATE); + addRecSignal(GSN_ACC_COMMITREQ, &Dbacc::execACC_COMMITREQ); + addRecSignal(GSN_ACC_TO_REQ, &Dbacc::execACC_TO_REQ); + addRecSignal(GSN_ACC_LOCKREQ, &Dbacc::execACC_LOCKREQ); + addRecSignal(GSN_FSOPENCONF, &Dbacc::execFSOPENCONF); + addRecSignal(GSN_FSOPENREF, &Dbacc::execFSOPENREF); + addRecSignal(GSN_FSCLOSECONF, &Dbacc::execFSCLOSECONF); + addRecSignal(GSN_FSCLOSEREF, &Dbacc::execFSCLOSEREF); + addRecSignal(GSN_FSWRITECONF, &Dbacc::execFSWRITECONF); + addRecSignal(GSN_FSWRITEREF, &Dbacc::execFSWRITEREF); + addRecSignal(GSN_FSREADCONF, &Dbacc::execFSREADCONF); + addRecSignal(GSN_FSREADREF, &Dbacc::execFSREADREF); + addRecSignal(GSN_NDB_STTOR, &Dbacc::execNDB_STTOR); + addRecSignal(GSN_DROP_TAB_REQ, &Dbacc::execDROP_TAB_REQ); + addRecSignal(GSN_FSREMOVECONF, &Dbacc::execFSREMOVECONF); + addRecSignal(GSN_FSREMOVEREF, &Dbacc::execFSREMOVEREF); + addRecSignal(GSN_SIZEALT_REP, &Dbacc::execSIZEALT_REP); + addRecSignal(GSN_SET_VAR_REQ, &Dbacc::execSET_VAR_REQ); + + initData(); +}//Dbacc::Dbacc() + +Dbacc::~Dbacc() +{ + deallocRecord((void **)&dirRange, "DirRange", + sizeof(DirRange), + cdirrangesize); + + deallocRecord((void **)&directoryarray, "Directoryarray", + sizeof(Directoryarray), + cdirarraysize); + + deallocRecord((void **)&fragmentrec, "Fragmentrec", + sizeof(Fragmentrec), + cfragmentsize); + + deallocRecord((void **)&fsConnectrec, "FsConnectrec", + sizeof(FsConnectrec), + cfsConnectsize); + + deallocRecord((void **)&fsOprec, "FsOprec", + sizeof(FsOprec), + cfsOpsize); + + deallocRecord((void **)&lcpConnectrec, "LcpConnectrec", + sizeof(LcpConnectrec), + clcpConnectsize); + + deallocRecord((void **)&operationrec, "Operationrec", + sizeof(Operationrec), + coprecsize); + + deallocRecord((void **)&overflowRecord, "OverflowRecord", + sizeof(OverflowRecord), + coverflowrecsize); + + deallocRecord((void **)&page8, "Page8", + sizeof(Page8), + cpagesize); + + deallocRecord((void **)&rootfragmentrec, "Rootfragmentrec", + sizeof(Rootfragmentrec), + crootfragmentsize); + + deallocRecord((void **)&scanRec, "ScanRec", + sizeof(ScanRec), + cscanRecSize); + + deallocRecord((void **)&srVersionRec, "SrVersionRec", + sizeof(SrVersionRec), + csrVersionRecSize); + + deallocRecord((void **)&tabrec, "Tabrec", + sizeof(Tabrec), + ctablesize); + + deallocRecord((void **)&undopage, "Undopage", + sizeof(Undopage), + cundopagesize); + +}//Dbacc::~Dbacc() + +BLOCK_FUNCTIONS(Dbacc); diff --git a/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp b/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp new file mode 100644 index 00000000000..ea8d808458b --- /dev/null +++ b/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp @@ -0,0 +1,13285 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBACC_C +#include "Dbacc.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// TO_DO_RONM is a label for comments on what needs to be improved in future versions +// when more time is given. + +#ifdef VM_TRACE +#define DEBUG(x) ndbout << "DBACC: "<< x << endl; +#else +#define DEBUG(x) +#endif + + +Uint32 +Dbacc::remainingUndoPages(){ + Uint32 HeadPage = cundoposition >> ZUNDOPAGEINDEXBITS; + Uint32 TailPage = clastUndoPageIdWritten; + + // Head must be larger or same as tail + ndbrequire(HeadPage>=TailPage); + + Uint32 UsedPages = HeadPage - TailPage; + Uint32 Remaining = cundopagesize - UsedPages; + + // There can not be more than cundopagesize remaining + ndbrequire(Remaining<=cundopagesize); + + return Remaining; +}//Dbacc::remainingUndoPages() + +void +Dbacc::updateLastUndoPageIdWritten(Signal* signal, Uint32 aNewValue){ + if (remainingUndoPages() < ZMIN_UNDO_PAGES_AT_COMMIT) { + clastUndoPageIdWritten = aNewValue; + if (remainingUndoPages() >= ZMIN_UNDO_PAGES_AT_COMMIT) { + jam(); + EXECUTE_DIRECT(DBLQH, GSN_ACC_COM_UNBLOCK, signal, 1); + jamEntry(); + }//if + } else { + clastUndoPageIdWritten = aNewValue; + }//if +}//Dbacc::updateLastUndoPageIdWritten() + +void +Dbacc::updateUndoPositionPage(Signal* signal, Uint32 aNewValue){ + if (remainingUndoPages() >= ZMIN_UNDO_PAGES_AT_COMMIT) { + cundoposition = aNewValue; + if (remainingUndoPages() < ZMIN_UNDO_PAGES_AT_COMMIT) { + jam(); + EXECUTE_DIRECT(DBLQH, GSN_ACC_COM_BLOCK, signal, 1); + jamEntry(); + }//if + } else { + cundoposition = aNewValue; + }//if +}//Dbacc::updateUndoPositionPage() + +// Signal entries and statement blocks +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* COMMON SIGNAL RECEPTION MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ + +/* --------------------------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* CONTINUEB CONTINUE SIGNAL */ +/* ******************------------------------------+ */ +/* SENDER: ACC, LEVEL B */ +void Dbacc::execCONTINUEB(Signal* signal) +{ + Uint32 tcase; + + jamEntry(); + tcase = signal->theData[0]; + tdata0 = signal->theData[1]; + tresult = 0; + switch (tcase) { + case ZLOAD_BAL_LCP_TIMER: + if (clblPageOver == 0) { + jam(); + clblPageCounter = clblPagesPerTick; + } else { + if (clblPageOver > clblPagesPerTick) { + jam(); + clblPageOver = clblPageOver - clblPagesPerTick; + } else { + jam(); + clblPageOver = 0; + clblPageCounter = clblPagesPerTick - clblPageOver; + }//if + }//if + signal->theData[0] = ZLOAD_BAL_LCP_TIMER; + sendSignalWithDelay(cownBlockref, GSN_CONTINUEB, signal, 100, 1); + return; + break; + case ZINITIALISE_RECORDS: + jam(); + initialiseRecordsLab(signal); + return; + break; + case ZSR_READ_PAGES_ALLOC: + jam(); + fragrecptr.i = tdata0; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + srReadPagesAllocLab(signal); + return; + break; + case ZSTART_UNDO: + jam(); + startUndoLab(signal); + return; + break; + case ZSEND_SCAN_HBREP: + jam(); + sendScanHbRep(signal, tdata0); + break; + case ZREL_ROOT_FRAG: + { + jam(); + Uint32 tableId = signal->theData[1]; + releaseRootFragResources(signal, tableId); + break; + } + case ZREL_FRAG: + { + jam(); + Uint32 fragIndex = signal->theData[1]; + releaseFragResources(signal, fragIndex); + break; + } + case ZREL_DIR: + { + jam(); + Uint32 fragIndex = signal->theData[1]; + Uint32 dirIndex = signal->theData[2]; + Uint32 startIndex = signal->theData[3]; + releaseDirResources(signal, fragIndex, dirIndex, startIndex); + break; + } + case ZREPORT_MEMORY_USAGE:{ + jam(); + static int c_currentMemUsed = 0; + int now = (cnoOfAllocatedPages * 100)/cpagesize; + const int thresholds[] = { 99, 90, 80, 0}; + + Uint32 i = 0; + const Uint32 sz = sizeof(thresholds)/sizeof(thresholds[0]); + for(i = 0; i= thresholds[i]){ + now = thresholds[i]; + break; + } + } + + if(now != c_currentMemUsed){ + reportMemoryUsage(signal, now > c_currentMemUsed ? 1 : -1); + } + + c_currentMemUsed = now; + + signal->theData[0] = ZREPORT_MEMORY_USAGE; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 2000, 1); + return; + } + + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbacc::execCONTINUEB() + +/* ******************--------------------------------------------------------------- */ +/* FSCLOSECONF CLOSE FILE CONF */ +/* ******************------------------------------+ */ +/* SENDER: FS, LEVEL B */ +void Dbacc::execFSCLOSECONF(Signal* signal) +{ + jamEntry(); + fsConnectptr.i = signal->theData[0]; + ptrCheckGuard(fsConnectptr, cfsConnectsize, fsConnectrec); + tresult = 0; + switch (fsConnectptr.p->fsState) { + case WAIT_CLOSE_UNDO: + jam(); + releaseFsConnRec(signal); + break; + case LCP_CLOSE_DATA: + jam(); + checkSyncUndoPagesLab(signal); + return; + break; + case SR_CLOSE_DATA: + jam(); + sendaccSrconfLab(signal); + return; + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbacc::execFSCLOSECONF() + +/* ******************--------------------------------------------------------------- */ +/* FSCLOSEREF OPENFILE CONF */ +/* ******************------------------------------+ */ +/* SENDER: FS, LEVEL B */ +void Dbacc::execFSCLOSEREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +}//Dbacc::execFSCLOSEREF() + +/* ******************--------------------------------------------------------------- */ +/* FSOPENCONF OPENFILE CONF */ +/* ******************------------------------------+ */ +/* SENDER: FS, LEVEL B */ +void Dbacc::execFSOPENCONF(Signal* signal) +{ + jamEntry(); + fsConnectptr.i = signal->theData[0]; + ptrCheckGuard(fsConnectptr, cfsConnectsize, fsConnectrec); + tuserptr = signal->theData[1]; + tresult = 0; /* RESULT CHECK VALUE */ + switch (fsConnectptr.p->fsState) { + case WAIT_OPEN_UNDO_LCP: + jam(); + lcpOpenUndofileConfLab(signal); + return; + break; + case WAIT_OPEN_UNDO_LCP_NEXT: + jam(); + fsConnectptr.p->fsPtr = tuserptr; + return; + break; + case OPEN_UNDO_FILE_SR: + jam(); + fsConnectptr.p->fsPtr = tuserptr; + srStartUndoLab(signal); + return; + break; + case WAIT_OPEN_DATA_FILE_FOR_WRITE: + jam(); + lcpFsOpenConfLab(signal); + return; + break; + case WAIT_OPEN_DATA_FILE_FOR_READ: + jam(); + fsConnectptr.p->fsPtr = tuserptr; + srFsOpenConfLab(signal); + return; + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbacc::execFSOPENCONF() + +/* ******************--------------------------------------------------------------- */ +/* FSOPENREF OPENFILE REF */ +/* ******************------------------------------+ */ +/* SENDER: FS, LEVEL B */ +void Dbacc::execFSOPENREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +}//Dbacc::execFSOPENREF() + +/* ******************--------------------------------------------------------------- */ +/* FSREADCONF OPENFILE CONF */ +/* ******************------------------------------+ */ +/* SENDER: FS, LEVEL B */ +void Dbacc::execFSREADCONF(Signal* signal) +{ + jamEntry(); + fsConnectptr.i = signal->theData[0]; + ptrCheckGuard(fsConnectptr, cfsConnectsize, fsConnectrec); + tresult = 0; /* RESULT CHECK VALUE */ + switch (fsConnectptr.p->fsState) { + case WAIT_READ_PAGE_ZERO: + jam(); + fragrecptr.i = fsConnectptr.p->fragrecPtr; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + srReadPageZeroLab(signal); + return; + break; + case WAIT_READ_DATA: + jam(); + fragrecptr.i = fsConnectptr.p->fragrecPtr; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + storeDataPageInDirectoryLab(signal); + return; + break; + case READ_UNDO_PAGE: + jam(); + srDoUndoLab(signal); + return; + break; + case READ_UNDO_PAGE_AND_CLOSE: + jam(); + fsConnectptr.p->fsState = WAIT_CLOSE_UNDO; + /* ************************ */ + /* FSCLOSEREQ */ + /* ************************ */ + signal->theData[0] = fsConnectptr.p->fsPtr; + signal->theData[1] = cownBlockref; + signal->theData[2] = fsConnectptr.i; + signal->theData[3] = 0; + sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA); + /* FLAG = DO NOT DELETE FILE */ + srDoUndoLab(signal); + return; + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbacc::execFSREADCONF() + +/* ******************--------------------------------------------------------------- */ +/* FSREADRREF OPENFILE CONF */ +/* ******************------------------------------+ */ +/* SENDER: FS, LEVEL B */ +void Dbacc::execFSREADREF(Signal* signal) +{ + jamEntry(); + progError(0, __LINE__, "Read of file refused"); + return; +}//Dbacc::execFSREADREF() + +/* ******************--------------------------------------------------------------- */ +/* FSWRITECONF OPENFILE CONF */ +/* ******************------------------------------+ */ +/* SENDER: FS, LEVEL B */ +void Dbacc::execFSWRITECONF(Signal* signal) +{ + jamEntry(); + fsOpptr.i = signal->theData[0]; + ptrCheckGuard(fsOpptr, cfsOpsize, fsOprec); + /* FS_OPERATION PTR */ + tresult = 0; /* RESULT CHECK VALUE */ + fsConnectptr.i = fsOpptr.p->fsConptr; + ptrCheckGuard(fsConnectptr, cfsConnectsize, fsConnectrec); + fragrecptr.i = fsOpptr.p->fsOpfragrecPtr; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + switch (fsOpptr.p->fsOpstate) { + case WAIT_WRITE_UNDO: + jam(); + updateLastUndoPageIdWritten(signal, fsOpptr.p->fsOpMemPage); + releaseFsOpRec(signal); + if (fragrecptr.p->nrWaitWriteUndoExit == 0) { + jam(); + checkSendLcpConfLab(signal); + return; + } else { + jam(); + fragrecptr.p->lastUndoIsStored = ZTRUE; + }//if + return; + break; + case WAIT_WRITE_UNDO_EXIT: + jam(); + updateLastUndoPageIdWritten(signal, fsOpptr.p->fsOpMemPage); + releaseFsOpRec(signal); + if (fragrecptr.p->nrWaitWriteUndoExit > 0) { + jam(); + fragrecptr.p->nrWaitWriteUndoExit--; + }//if + if (fsConnectptr.p->fsState == WAIT_CLOSE_UNDO) { + jam(); + /* ************************ */ + /* FSCLOSEREQ */ + /* ************************ */ + signal->theData[0] = fsConnectptr.p->fsPtr; + signal->theData[1] = cownBlockref; + signal->theData[2] = fsConnectptr.i; + signal->theData[3] = ZFALSE; + sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA); + }//if + if (fragrecptr.p->nrWaitWriteUndoExit == 0) { + if (fragrecptr.p->lastUndoIsStored == ZTRUE) { + jam(); + fragrecptr.p->lastUndoIsStored = ZFALSE; + checkSendLcpConfLab(signal); + return; + }//if + }//if + return; + break; + case WAIT_WRITE_DATA: + jam(); + releaseFsOpRec(signal); + fragrecptr.p->activeDataFilePage += ZWRITEPAGESIZE; + fragrecptr.p->activeDataPage = 0; + rootfragrecptr.i = fragrecptr.p->myroot; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + lcpConnectptr.i = rootfragrecptr.p->lcpPtr; + ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec); + switch (fragrecptr.p->fragState) { + case LCP_SEND_PAGES: + jam(); + savepagesLab(signal); + return; + break; + case LCP_SEND_OVER_PAGES: + jam(); + saveOverPagesLab(signal); + return; + break; + case LCP_SEND_ZERO_PAGE: + jam(); + saveZeroPageLab(signal); + return; + break; + case WAIT_ZERO_PAGE_STORED: + jam(); + lcpCloseDataFileLab(signal); + return; + break; + default: + ndbrequire(false); + return; + break; + }//switch + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbacc::execFSWRITECONF() + +/* ******************--------------------------------------------------------------- */ +/* FSWRITEREF OPENFILE CONF */ +/* ******************------------------------------+ */ +/* SENDER: FS, LEVEL B */ +void Dbacc::execFSWRITEREF(Signal* signal) +{ + jamEntry(); + progError(0, __LINE__, "Write to file refused"); + return; +}//Dbacc::execFSWRITEREF() + +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* */ +/* END OF COMMON SIGNAL RECEPTION MODULE */ +/* */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* */ +/* SYSTEM RESTART MODULE */ +/* */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +void Dbacc::execNDB_STTOR(Signal* signal) +{ + Uint32 tstartphase; + Uint32 tconfig1; + Uint32 tconfig2; + Uint32 tlqhConfig1; + Uint32 tStartType; + + jamEntry(); + cndbcntrRef = signal->theData[0]; + cmynodeid = signal->theData[1]; + tstartphase = signal->theData[2]; + tStartType = signal->theData[3]; + tlqhConfig1 = signal->theData[10]; /* DBLQH */ + tconfig1 = signal->theData[16]; /* DBACC */ + tconfig2 = signal->theData[17]; /* DBACC */ + switch (tstartphase) { + case ZSPH1: + jam(); + ndbsttorryLab(signal); + return; + break; + case ZSPH2: + cnoLcpPages = 2 * (ZWRITEPAGESIZE + 1); + initialiseLcpPages(signal); + ndbsttorryLab(signal); + return; + break; + case ZSPH3: + if ((tStartType == NodeState::ST_NODE_RESTART) || + (tStartType == NodeState::ST_INITIAL_NODE_RESTART)) { + jam(); + //--------------------------------------------- + // csystemRestart is used to check what is needed + // during log execution. When starting a node it + // is not a log execution and rather a normal + // execution. Thus we reset the variable here to + // avoid unnecessary system crashes. + //--------------------------------------------- + csystemRestart = ZFALSE; + }//if + if (tconfig1 > 0) { + jam(); + clblPagesPerTick = tconfig1; + } else { + jam(); + clblPagesPerTick = 1; + }//if + clblPageCounter = clblPagesPerTick; + if (tconfig2 > 0) { + jam(); + clblPagesPerTickAfterSr = tconfig2; + } else { + jam(); + clblPagesPerTickAfterSr = 1; + }//if + signal->theData[0] = ZLOAD_BAL_LCP_TIMER; + sendSignalWithDelay(cownBlockref, GSN_CONTINUEB, signal, 100, 1); + break; + case ZSPH6: + jam(); + clblPagesPerTick = clblPagesPerTickAfterSr; + csystemRestart = ZFALSE; + + signal->theData[0] = ZREPORT_MEMORY_USAGE; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 2000, 1); + break; + default: + jam(); + /*empty*/; + break; + }//switch + ndbsttorryLab(signal); + return; +}//Dbacc::execNDB_STTOR() + +/* ******************--------------------------------------------------------------- */ +/* STTOR START / RESTART */ +/* ******************------------------------------+ */ +/* SENDER: ANY, LEVEL B */ +void Dbacc::execSTTOR(Signal* signal) +{ + jamEntry(); + // tstartphase = signal->theData[1]; + tuserblockref = signal->theData[3]; + csignalkey = signal->theData[6]; + sttorrysignalLab(signal); + return; +}//Dbacc::execSTTOR() + +/* --------------------------------------------------------------------------------- */ +/* ZSPH1 */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::ndbrestart1Lab(Signal* signal) +{ + cmynodeid = globalData.ownId; + cownBlockref = numberToRef(DBACC, cmynodeid); + czero = 0; + cminusOne = czero - 1; + ctest = 0; + cundoLogActive = ZFALSE; + csystemRestart = ZTRUE; + clblPageOver = 0; + clblPageCounter = 0; + cactiveUndoFilePage = 0; + cprevUndoaddress = cminusOne; + cundoposition = 0; + clastUndoPageIdWritten = 0; + cactiveUndoFileVersion = RNIL; + cactiveOpenUndoFsPtr = RNIL; + for (Uint32 tmp = 0; tmp < ZMAX_UNDO_VERSION; tmp++) { + csrVersList[tmp] = RNIL; + }//for + tdata0 = 0; + initialiseRecordsLab(signal); + return; +}//Dbacc::ndbrestart1Lab() + +void Dbacc::initialiseRecordsLab(Signal* signal) +{ + switch (tdata0) { + case 0: + jam(); + initialiseTableRec(signal); + sendInitialiseRecords(signal); + break; + case 1: + jam(); + initialiseFsConnectionRec(signal); + sendInitialiseRecords(signal); + break; + case 2: + jam(); + initialiseFsOpRec(signal); + sendInitialiseRecords(signal); + break; + case 3: + jam(); + initialiseLcpConnectionRec(signal); + sendInitialiseRecords(signal); + break; + case 4: + jam(); + initialiseDirRec(signal); + sendInitialiseRecords(signal); + break; + case 5: + jam(); + initialiseDirRangeRec(signal); + sendInitialiseRecords(signal); + break; + case 6: + jam(); + initialiseFragRec(signal); + sendInitialiseRecords(signal); + break; + case 7: + jam(); + initialiseOverflowRec(signal); + sendInitialiseRecords(signal); + break; + case 8: + jam(); + initialiseOperationRec(signal); + sendInitialiseRecords(signal); + break; + case 9: + jam(); + initialisePageRec(signal); + sendInitialiseRecords(signal); + break; + case 10: + jam(); + initialiseRootfragRec(signal); + sendInitialiseRecords(signal); + break; + case 11: + jam(); + initialiseScanRec(signal); + sendInitialiseRecords(signal); + break; + case 12: + jam(); + initialiseSrVerRec(signal); + signal->theData[0] = cownBlockref; + sendSignal(CMVMI_REF, GSN_SIZEALT_ACK, signal, 1, JBB); + return; + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbacc::initialiseRecordsLab() + +/* --------------------------------------------------------------------------------- */ +/* SEND REAL-TIME BREAK DURING INITIALISATION OF VARIABLES DURING SYSTEM RESTART.*/ +/* --------------------------------------------------------------------------------- */ +void Dbacc::sendInitialiseRecords(Signal* signal) +{ + signal->theData[0] = ZINITIALISE_RECORDS; + signal->theData[1] = tdata0 + 1; + signal->theData[2] = 0; + sendSignal(cownBlockref, GSN_CONTINUEB, signal, 3, JBB); +}//Dbacc::sendInitialiseRecords() + +/* *********************************<< */ +/* NDB_STTORRY */ +/* *********************************<< */ +void Dbacc::ndbsttorryLab(Signal* signal) +{ + signal->theData[0] = cownBlockref; + sendSignal(cndbcntrRef, GSN_NDB_STTORRY, signal, 1, JBB); + return; +}//Dbacc::ndbsttorryLab() + +/* *********************************<< */ +/* SIZEALT_REP SIZE ALTERATION */ +/* *********************************<< */ +void Dbacc::execSIZEALT_REP(Signal* signal) +{ + Uint32 tsizealtBlockRef; + + jamEntry(); + tsizealtBlockRef = signal->theData[AccSizeAltReq::IND_BLOCK_REF]; + cdirrangesize = signal->theData[AccSizeAltReq::IND_DIR_RANGE]; + cdirarraysize = signal->theData[AccSizeAltReq::IND_DIR_ARRAY]; + cfragmentsize = signal->theData[AccSizeAltReq::IND_FRAGMENT]; + coprecsize = signal->theData[AccSizeAltReq::IND_OP_RECS]; + coverflowrecsize = signal->theData[AccSizeAltReq::IND_OVERFLOW_RECS]; + cpagesize = signal->theData[AccSizeAltReq::IND_PAGE8]; + crootfragmentsize = signal->theData[AccSizeAltReq::IND_ROOT_FRAG]; + ctablesize = signal->theData[AccSizeAltReq::IND_TABLE]; + cscanRecSize = signal->theData[AccSizeAltReq::IND_SCAN]; + initRecords(); + ndbrestart1Lab(signal); + return; +}//Dbacc::execSIZEALT_REP() + +/* *********************************<< */ +/* STTORRY */ +/* *********************************<< */ +void Dbacc::sttorrysignalLab(Signal* signal) +{ + signal->theData[0] = csignalkey; + signal->theData[1] = 3; + /* BLOCK CATEGORY */ + signal->theData[2] = 2; + /* SIGNAL VERSION NUMBER */ + signal->theData[3] = ZSPH1; + signal->theData[4] = 255; + sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 5, JBB); + /* END OF START PHASES */ + return; +}//Dbacc::sttorrysignalLab() + +/* --------------------------------------------------------------------------------- */ +/* INITIALISE_DIR_REC */ +/* INITIALATES THE DIRECTORY RECORDS. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initialiseDirRec(Signal* signal) +{ + DirectoryarrayPtr idrDirptr; + ndbrequire(cdirarraysize > 0); + for (idrDirptr.i = 0; idrDirptr.i < cdirarraysize; idrDirptr.i++) { + ptrAss(idrDirptr, directoryarray); + for (Uint32 i = 0; i <= 255; i++) { + idrDirptr.p->pagep[i] = RNIL; + }//for + }//for + cdirmemory = 0; + cfirstfreedir = RNIL; +}//Dbacc::initialiseDirRec() + +/* --------------------------------------------------------------------------------- */ +/* INITIALISE_DIR_RANGE_REC */ +/* INITIALATES THE DIR_RANGE RECORDS. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initialiseDirRangeRec(Signal* signal) +{ + DirRangePtr idrDirRangePtr; + + ndbrequire(cdirrangesize > 0); + for (idrDirRangePtr.i = 0; idrDirRangePtr.i < cdirrangesize; idrDirRangePtr.i++) { + ptrAss(idrDirRangePtr, dirRange); + idrDirRangePtr.p->dirArray[0] = idrDirRangePtr.i + 1; + for (Uint32 i = 1; i < 256; i++) { + idrDirRangePtr.p->dirArray[i] = RNIL; + }//for + }//for + idrDirRangePtr.i = cdirrangesize - 1; + ptrAss(idrDirRangePtr, dirRange); + idrDirRangePtr.p->dirArray[0] = RNIL; + cfirstfreeDirrange = 0; +}//Dbacc::initialiseDirRangeRec() + +/* --------------------------------------------------------------------------------- */ +/* INITIALISE_FRAG_REC */ +/* INITIALATES THE FRAGMENT RECORDS. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initialiseFragRec(Signal* signal) +{ + FragmentrecPtr regFragPtr; + ndbrequire(cfragmentsize > 0); + for (regFragPtr.i = 0; regFragPtr.i < cfragmentsize; regFragPtr.i++) { + jam(); + ptrAss(regFragPtr, fragmentrec); + initFragGeneral(regFragPtr); + regFragPtr.p->nextfreefrag = regFragPtr.i + 1; + }//for + regFragPtr.i = cfragmentsize - 1; + ptrAss(regFragPtr, fragmentrec); + regFragPtr.p->nextfreefrag = RNIL; + cfirstfreefrag = 0; +}//Dbacc::initialiseFragRec() + +/* --------------------------------------------------------------------------------- */ +/* INITIALISE_FS_CONNECTION_REC */ +/* INITIALATES THE FS_CONNECTION RECORDS */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initialiseFsConnectionRec(Signal* signal) +{ + ndbrequire(cfsConnectsize > 0); + for (fsConnectptr.i = 0; fsConnectptr.i < cfsConnectsize; fsConnectptr.i++) { + ptrAss(fsConnectptr, fsConnectrec); + fsConnectptr.p->fsNext = fsConnectptr.i + 1; + fsConnectptr.p->fsPrev = RNIL; + fsConnectptr.p->fragrecPtr = RNIL; + fsConnectptr.p->fsState = WAIT_NOTHING; + }//for + fsConnectptr.i = cfsConnectsize - 1; + ptrAss(fsConnectptr, fsConnectrec); + fsConnectptr.p->fsNext = RNIL; /* INITIALITES THE LAST CONNECTRECORD */ + cfsFirstfreeconnect = 0; /* INITIATES THE FIRST FREE CONNECT RECORD */ +}//Dbacc::initialiseFsConnectionRec() + +/* --------------------------------------------------------------------------------- */ +/* INITIALISE_FS_OP_REC */ +/* INITIALATES THE FS_OP RECORDS */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initialiseFsOpRec(Signal* signal) +{ + ndbrequire(cfsOpsize > 0); + for (fsOpptr.i = 0; fsOpptr.i < cfsOpsize; fsOpptr.i++) { + ptrAss(fsOpptr, fsOprec); + fsOpptr.p->fsOpnext = fsOpptr.i + 1; + fsOpptr.p->fsOpfragrecPtr = RNIL; + fsOpptr.p->fsConptr = RNIL; + fsOpptr.p->fsOpstate = WAIT_NOTHING; + }//for + fsOpptr.i = cfsOpsize - 1; + ptrAss(fsOpptr, fsOprec); + fsOpptr.p->fsOpnext = RNIL; + cfsFirstfreeop = 0; +}//Dbacc::initialiseFsOpRec() + +/* --------------------------------------------------------------------------------- */ +/* INITIALISE_LCP_CONNECTION_REC */ +/* INITIALATES THE LCP_CONNECTION RECORDS */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initialiseLcpConnectionRec(Signal* signal) +{ + ndbrequire(clcpConnectsize > 0); + for (lcpConnectptr.i = 0; lcpConnectptr.i < clcpConnectsize; lcpConnectptr.i++) { + ptrAss(lcpConnectptr, lcpConnectrec); + lcpConnectptr.p->nextLcpConn = lcpConnectptr.i + 1; + lcpConnectptr.p->lcpUserptr = RNIL; + lcpConnectptr.p->rootrecptr = RNIL; + lcpConnectptr.p->lcpstate = LCP_FREE; + }//for + lcpConnectptr.i = clcpConnectsize - 1; + ptrAss(lcpConnectptr, lcpConnectrec); + lcpConnectptr.p->nextLcpConn = RNIL; + cfirstfreelcpConnect = 0; +}//Dbacc::initialiseLcpConnectionRec() + +/* --------------------------------------------------------------------------------- */ +/* INITIALISE_OPERATION_REC */ +/* INITIALATES THE OPERATION RECORDS. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initialiseOperationRec(Signal* signal) +{ + ndbrequire(coprecsize > 0); + for (operationRecPtr.i = 0; operationRecPtr.i < coprecsize; operationRecPtr.i++) { + ptrAss(operationRecPtr, operationrec); + operationRecPtr.p->transactionstate = IDLE; + operationRecPtr.p->operation = ZUNDEFINED_OP; + operationRecPtr.p->opState = FREE_OP; + operationRecPtr.p->nextOp = operationRecPtr.i + 1; + }//for + operationRecPtr.i = coprecsize - 1; + ptrAss(operationRecPtr, operationrec); + operationRecPtr.p->nextOp = RNIL; + cfreeopRec = 0; +}//Dbacc::initialiseOperationRec() + +/* --------------------------------------------------------------------------------- */ +/* INITIALISE_OVERFLOW_REC */ +/* INITIALATES THE OVERFLOW RECORDS */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initialiseOverflowRec(Signal* signal) +{ + OverflowRecordPtr iorOverflowRecPtr; + + ndbrequire(coverflowrecsize > 0); + for (iorOverflowRecPtr.i = 0; iorOverflowRecPtr.i < coverflowrecsize; iorOverflowRecPtr.i++) { + ptrAss(iorOverflowRecPtr, overflowRecord); + iorOverflowRecPtr.p->nextfreeoverrec = iorOverflowRecPtr.i + 1; + }//for + iorOverflowRecPtr.i = coverflowrecsize - 1; + ptrAss(iorOverflowRecPtr, overflowRecord); + iorOverflowRecPtr.p->nextfreeoverrec = RNIL; + cfirstfreeoverrec = 0; +}//Dbacc::initialiseOverflowRec() + +/* --------------------------------------------------------------------------------- */ +/* INITIALISE_PAGE_REC */ +/* INITIALATES THE PAGE RECORDS. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initialisePageRec(Signal* signal) +{ + ndbrequire(cpagesize > 0); + cfreepage = 0; + cfirstfreepage = RNIL; + cnoOfAllocatedPages = 0; +}//Dbacc::initialisePageRec() + +/* --------------------------------------------------------------------------------- */ +/* INITIALISE_LCP_PAGES */ +/* INITIALATES THE LCP PAGE RECORDS. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initialiseLcpPages(Signal* signal) +{ + Uint32 tilpIndex; + + ndbrequire(cnoLcpPages >= (2 * (ZWRITEPAGESIZE + 1))); + /* --------------------------------------------------------------------------------- */ + /* AN ABSOLUTE MINIMUM IS THAT WE HAVE 16 LCP PAGES TO HANDLE TWO CONCURRENT */ + /* LCP'S ON LOCAL FRAGMENTS. */ + /* --------------------------------------------------------------------------------- */ + ndbrequire(cpagesize >= (cnoLcpPages + 8)); + /* --------------------------------------------------------------------------------- */ + /* THE NUMBER OF PAGES MUST BE AT LEAST 8 PLUS THE NUMBER OF PAGES REQUIRED BY */ + /* THE LOCAL CHECKPOINT PROCESS. THIS NUMBER IS 8 TIMES THE PARALLELISM OF */ + /* LOCAL CHECKPOINTS. */ + /* --------------------------------------------------------------------------------- */ + /* --------------------------------------------------------------------------------- */ + /* WE SET UP A LINKED LIST OF PAGES FOR EXCLUSIVE USE BY LOCAL CHECKPOINTS. */ + /* --------------------------------------------------------------------------------- */ + cfirstfreeLcpPage = RNIL; + for (tilpIndex = 0; tilpIndex < cnoLcpPages; tilpIndex++) { + jam(); + seizePage(signal); + rlpPageptr = spPageptr; + releaseLcpPage(signal); + }//for +}//Dbacc::initialiseLcpPages() + +/* --------------------------------------------------------------------------------- */ +/* INITIALISE_ROOTFRAG_REC */ +/* INITIALATES THE ROOTFRAG RECORDS. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initialiseRootfragRec(Signal* signal) +{ + ndbrequire(crootfragmentsize > 0); + for (rootfragrecptr.i = 0; rootfragrecptr.i < crootfragmentsize; rootfragrecptr.i++) { + ptrAss(rootfragrecptr, rootfragmentrec); + rootfragrecptr.p->nextroot = rootfragrecptr.i + 1; + rootfragrecptr.p->fragmentptr[0] = RNIL; + rootfragrecptr.p->fragmentptr[1] = RNIL; + }//for + rootfragrecptr.i = crootfragmentsize - 1; + ptrAss(rootfragrecptr, rootfragmentrec); + rootfragrecptr.p->nextroot = RNIL; + cfirstfreerootfrag = 0; +}//Dbacc::initialiseRootfragRec() + +/* --------------------------------------------------------------------------------- */ +/* INITIALISE_SCAN_REC */ +/* INITIALATES THE QUE_SCAN RECORDS. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initialiseScanRec(Signal* signal) +{ + ndbrequire(cscanRecSize > 0); + for (scanPtr.i = 0; scanPtr.i < cscanRecSize; scanPtr.i++) { + ptrAss(scanPtr, scanRec); + scanPtr.p->scanNextfreerec = scanPtr.i + 1; + scanPtr.p->scanState = ScanRec::SCAN_DISCONNECT; + scanPtr.p->scanTimer = 0; + scanPtr.p->scanContinuebCounter = 0; + }//for + scanPtr.i = cscanRecSize - 1; + ptrAss(scanPtr, scanRec); + scanPtr.p->scanNextfreerec = RNIL; + cfirstFreeScanRec = 0; +}//Dbacc::initialiseScanRec() + +/* --------------------------------------------------------------------------------- */ +/* INITIALISE_SR_VER_REC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initialiseSrVerRec(Signal* signal) +{ + ndbrequire(csrVersionRecSize > 0); + for (srVersionPtr.i = 0; srVersionPtr.i < csrVersionRecSize; srVersionPtr.i++) { + ptrAss(srVersionPtr, srVersionRec); + srVersionPtr.p->nextFreeSr = srVersionPtr.i + 1; + }//for + srVersionPtr.i = csrVersionRecSize - 1; + ptrAss(srVersionPtr, srVersionRec); + srVersionPtr.p->nextFreeSr = RNIL; + cfirstFreeSrVersionRec = 0; +}//Dbacc::initialiseSrVerRec() + +/* --------------------------------------------------------------------------------- */ +/* INITIALISE_TABLE_REC */ +/* INITIALATES THE TABLE RECORDS. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initialiseTableRec(Signal* signal) +{ + ndbrequire(ctablesize > 0); + for (tabptr.i = 0; tabptr.i < ctablesize; tabptr.i++) { + ptrAss(tabptr, tabrec); + for (Uint32 i = 0; i < NO_OF_FRAG_PER_NODE; i++) { + tabptr.p->fragholder[i] = RNIL; + tabptr.p->fragptrholder[i] = RNIL; + }//for + }//for +}//Dbacc::initialiseTableRec() + +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* END OF SYSTEM RESTART MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* ADD/DELETE FRAGMENT MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ + +void Dbacc::initRootfragrec(Signal* signal) +{ + const AccFragReq * const req = (AccFragReq*)&signal->theData[0]; + rootfragrecptr.p->mytabptr = req->tableId; + rootfragrecptr.p->roothashcheck = req->kValue + req->lhFragBits; + rootfragrecptr.p->noOfElements = 0; + for (Uint32 i = 0; i < MAX_PARALLEL_SCANS_PER_FRAG; i++) { + rootfragrecptr.p->scan[i] = RNIL; + }//for +}//Dbacc::initRootfragrec() + +void Dbacc::execACCFRAGREQ(Signal* signal) +{ + const AccFragReq * const req = (AccFragReq*)&signal->theData[0]; + jamEntry(); + tabptr.i = req->tableId; + ptrCheckGuard(tabptr, ctablesize, tabrec); + ndbrequire((req->reqInfo & 0xF) == ZADDFRAG); + ndbrequire(!getrootfragmentrec(signal, rootfragrecptr, req->fragId)); + if (cfirstfreerootfrag == RNIL) { + jam(); + addFragRefuse(signal, ZFULL_ROOTFRAGRECORD_ERROR); + return; + }//if + seizeRootfragrec(signal); + if (!addfragtotab(signal, rootfragrecptr.i, req->fragId)) { + jam(); + releaseRootFragRecord(signal, rootfragrecptr); + addFragRefuse(signal, ZFULL_ROOTFRAGRECORD_ERROR); + return; + }//if + initRootfragrec(signal); + for (Uint32 i = 0; i < 2; i++) { + jam(); + if (cfirstfreefrag == RNIL) { + jam(); + addFragRefuse(signal, ZFULL_FRAGRECORD_ERROR); + return; + }//if + seizeFragrec(signal); + initFragGeneral(fragrecptr); + initFragAdd(signal, i, rootfragrecptr.i, fragrecptr); + rootfragrecptr.p->fragmentptr[i] = fragrecptr.i; + rootfragrecptr.p->fragmentid[i] = fragrecptr.p->myfid; + if (cfirstfreeDirrange == RNIL) { + jam(); + addFragRefuse(signal, ZDIR_RANGE_ERROR); + return; + } else { + jam(); + seizeDirrange(signal); + }//if + fragrecptr.p->directory = newDirRangePtr.i; + seizeDirectory(signal); + if (tresult < ZLIMIT_OF_ERROR) { + jam(); + newDirRangePtr.p->dirArray[0] = sdDirptr.i; + } else { + jam(); + addFragRefuse(signal, tresult); + return; + }//if + seizePage(signal); + if (tresult > ZLIMIT_OF_ERROR) { + jam(); + addFragRefuse(signal, tresult); + return; + }//if + sdDirptr.p->pagep[0] = spPageptr.i; + tipPageId = 0; + inpPageptr = spPageptr; + initPage(signal); + if (cfirstfreeDirrange == RNIL) { + jam(); + addFragRefuse(signal, ZDIR_RANGE_ERROR); + return; + } else { + jam(); + seizeDirrange(signal); + }//if + fragrecptr.p->overflowdir = newDirRangePtr.i; + seizeDirectory(signal); + if (tresult < ZLIMIT_OF_ERROR) { + jam(); + newDirRangePtr.p->dirArray[0] = sdDirptr.i; + } else { + jam(); + addFragRefuse(signal, tresult); + return; + }//if + }//for + Uint32 userPtr = req->userPtr; + BlockReference retRef = req->userRef; + rootfragrecptr.p->rootState = ACTIVEROOT; + AccFragConf * const conf = (AccFragConf*)&signal->theData[0]; + + conf->userPtr = userPtr; + conf->rootFragPtr = rootfragrecptr.i; + conf->fragId[0] = rootfragrecptr.p->fragmentid[0]; + conf->fragId[1] = rootfragrecptr.p->fragmentid[1]; + conf->fragPtr[0] = rootfragrecptr.p->fragmentptr[0]; + conf->fragPtr[1] = rootfragrecptr.p->fragmentptr[1]; + conf->rootHashCheck = rootfragrecptr.p->roothashcheck; + sendSignal(retRef, GSN_ACCFRAGCONF, signal, AccFragConf::SignalLength, JBB); +}//Dbacc::execACCFRAGREQ() + +void Dbacc::addFragRefuse(Signal* signal, Uint32 errorCode) +{ + const AccFragReq * const req = (AccFragReq*)&signal->theData[0]; + AccFragRef * const ref = (AccFragRef*)&signal->theData[0]; + Uint32 userPtr = req->userPtr; + BlockReference retRef = req->userRef; + + ref->userPtr = userPtr; + ref->errorCode = errorCode; + sendSignal(retRef, GSN_ACCFRAGREF, signal, AccFragRef::SignalLength, JBB); + return; +}//Dbacc::addFragRefuseEarly() + +void +Dbacc::execDROP_TAB_REQ(Signal* signal){ + jamEntry(); + DropTabReq* req = (DropTabReq*)signal->getDataPtr(); + + TabrecPtr tabPtr; + tabPtr.i = req->tableId; + ptrCheckGuard(tabPtr, ctablesize, tabrec); + + tabPtr.p->tabUserRef = req->senderRef; + tabPtr.p->tabUserPtr = req->senderData; + + signal->theData[0] = ZREL_ROOT_FRAG; + signal->theData[1] = tabPtr.i; + sendSignal(cownBlockref, GSN_CONTINUEB, signal, 2, JBB); +} + +void Dbacc::releaseRootFragResources(Signal* signal, Uint32 tableId) +{ + RootfragmentrecPtr rootPtr; + TabrecPtr tabPtr; + tabPtr.i = tableId; + ptrCheckGuard(tabPtr, ctablesize, tabrec); + for (Uint32 i = 0; i < NO_OF_FRAG_PER_NODE; i++) { + jam(); + if (tabPtr.p->fragholder[i] != RNIL) { + jam(); + Uint32 fragIndex; + rootPtr.i = tabPtr.p->fragptrholder[i]; + ptrCheckGuard(rootPtr, crootfragmentsize, rootfragmentrec); + if (rootPtr.p->fragmentptr[0] != RNIL) { + jam(); + fragIndex = rootPtr.p->fragmentptr[0]; + rootPtr.p->fragmentptr[0] = RNIL; + } else if (rootPtr.p->fragmentptr[1] != RNIL) { + jam(); + fragIndex = rootPtr.p->fragmentptr[1]; + rootPtr.p->fragmentptr[1] = RNIL; + } else { + jam(); + releaseRootFragRecord(signal, rootPtr); + tabPtr.p->fragholder[i] = RNIL; + tabPtr.p->fragptrholder[i] = RNIL; + continue; + }//if + releaseFragResources(signal, fragIndex); + return; + }//if + }//for + + /** + * Finished... + */ + sendFSREMOVEREQ(signal, tableId); +}//Dbacc::releaseRootFragResources() + +void Dbacc::releaseRootFragRecord(Signal* signal, RootfragmentrecPtr rootPtr) +{ + rootPtr.p->nextroot = cfirstfreerootfrag; + cfirstfreerootfrag = rootPtr.i; +}//Dbacc::releaseRootFragRecord() + +void Dbacc::releaseFragResources(Signal* signal, Uint32 fragIndex) +{ + FragmentrecPtr regFragPtr; + regFragPtr.i = fragIndex; + ptrCheckGuard(regFragPtr, cfragmentsize, fragmentrec); + verifyFragCorrect(regFragPtr); + if (regFragPtr.p->directory != RNIL) { + jam(); + releaseDirResources(signal, regFragPtr.i, regFragPtr.p->directory, 0); + regFragPtr.p->directory = RNIL; + } else if (regFragPtr.p->overflowdir != RNIL) { + jam(); + releaseDirResources(signal, regFragPtr.i, regFragPtr.p->overflowdir, 0); + regFragPtr.p->overflowdir = RNIL; + } else if (regFragPtr.p->firstOverflowRec != RNIL) { + jam(); + releaseOverflowResources(signal, regFragPtr); + } else if (regFragPtr.p->firstFreeDirindexRec != RNIL) { + jam(); + releaseDirIndexResources(signal, regFragPtr); + } else { + RootfragmentrecPtr rootPtr; + jam(); + rootPtr.i = regFragPtr.p->myroot; + ptrCheckGuard(rootPtr, crootfragmentsize, rootfragmentrec); + releaseFragRecord(signal, regFragPtr); + signal->theData[0] = ZREL_ROOT_FRAG; + signal->theData[1] = rootPtr.p->mytabptr; + sendSignal(cownBlockref, GSN_CONTINUEB, signal, 2, JBB); + }//if +}//Dbacc::releaseFragResources() + +void Dbacc::verifyFragCorrect(FragmentrecPtr regFragPtr) +{ + for (Uint32 i = 0; i < ZWRITEPAGESIZE; i++) { + jam(); + ndbrequire(regFragPtr.p->datapages[i] == RNIL); + }//for + ndbrequire(regFragPtr.p->lockOwnersList == RNIL); + ndbrequire(regFragPtr.p->firstWaitInQueOp == RNIL); + ndbrequire(regFragPtr.p->lastWaitInQueOp == RNIL); + ndbrequire(regFragPtr.p->sentWaitInQueOp == RNIL); + //ndbrequire(regFragPtr.p->fsConnPtr == RNIL); + ndbrequire(regFragPtr.p->zeroPagePtr == RNIL); + ndbrequire(regFragPtr.p->nrWaitWriteUndoExit == 0); + ndbrequire(regFragPtr.p->sentWaitInQueOp == RNIL); +}//Dbacc::verifyFragCorrect() + +void Dbacc::releaseDirResources(Signal* signal, + Uint32 fragIndex, + Uint32 dirIndex, + Uint32 startIndex) +{ + DirRangePtr regDirRangePtr; + regDirRangePtr.i = dirIndex; + ptrCheckGuard(regDirRangePtr, cdirrangesize, dirRange); + for (Uint32 i = startIndex; i < 256; i++) { + jam(); + if (regDirRangePtr.p->dirArray[i] != RNIL) { + jam(); + Uint32 directoryIndex = regDirRangePtr.p->dirArray[i]; + regDirRangePtr.p->dirArray[i] = RNIL; + releaseDirectoryResources(signal, fragIndex, dirIndex, (i + 1), directoryIndex); + return; + }//if + }//for + rdDirRangePtr = regDirRangePtr; + releaseDirrange(signal); + signal->theData[0] = ZREL_FRAG; + signal->theData[1] = fragIndex; + sendSignal(cownBlockref, GSN_CONTINUEB, signal, 2, JBB); +}//Dbacc::releaseDirResources() + +void Dbacc::releaseDirectoryResources(Signal* signal, + Uint32 fragIndex, + Uint32 dirIndex, + Uint32 startIndex, + Uint32 directoryIndex) +{ + DirectoryarrayPtr regDirPtr; + regDirPtr.i = directoryIndex; + ptrCheckGuard(regDirPtr, cdirarraysize, directoryarray); + for (Uint32 i = 0; i < 256; i++) { + jam(); + if (regDirPtr.p->pagep[i] != RNIL) { + jam(); + rpPageptr.i = regDirPtr.p->pagep[i]; + ptrCheckGuard(rpPageptr, cpagesize, page8); + releasePage(signal); + regDirPtr.p->pagep[i] = RNIL; + }//if + }//for + rdDirptr = regDirPtr; + releaseDirectory(signal); + signal->theData[0] = ZREL_DIR; + signal->theData[1] = fragIndex; + signal->theData[2] = dirIndex; + signal->theData[3] = startIndex; + sendSignal(cownBlockref, GSN_CONTINUEB, signal, 4, JBB); +}//Dbacc::releaseDirectoryResources() + +void Dbacc::releaseOverflowResources(Signal* signal, FragmentrecPtr regFragPtr) +{ + Uint32 loopCount = 0; + OverflowRecordPtr regOverflowRecPtr; + while ((regFragPtr.p->firstOverflowRec != RNIL) && + (loopCount < 1)) { + jam(); + regOverflowRecPtr.i = regFragPtr.p->firstOverflowRec; + ptrCheckGuard(regOverflowRecPtr, coverflowrecsize, overflowRecord); + regFragPtr.p->firstOverflowRec = regOverflowRecPtr.p->nextOverRec; + rorOverflowRecPtr = regOverflowRecPtr; + releaseOverflowRec(signal); + loopCount++; + }//while + signal->theData[0] = ZREL_FRAG; + signal->theData[1] = regFragPtr.i; + sendSignal(cownBlockref, GSN_CONTINUEB, signal, 2, JBB); +}//Dbacc::releaseOverflowResources() + +void Dbacc::releaseDirIndexResources(Signal* signal, FragmentrecPtr regFragPtr) +{ + Uint32 loopCount = 0; + OverflowRecordPtr regOverflowRecPtr; + while ((regFragPtr.p->firstFreeDirindexRec != RNIL) && + (loopCount < 1)) { + jam(); + regOverflowRecPtr.i = regFragPtr.p->firstFreeDirindexRec; + ptrCheckGuard(regOverflowRecPtr, coverflowrecsize, overflowRecord); + regFragPtr.p->firstFreeDirindexRec = regOverflowRecPtr.p->nextOverList; + rorOverflowRecPtr = regOverflowRecPtr; + releaseOverflowRec(signal); + loopCount++; + }//while + signal->theData[0] = ZREL_FRAG; + signal->theData[1] = regFragPtr.i; + sendSignal(cownBlockref, GSN_CONTINUEB, signal, 2, JBB); +}//Dbacc::releaseDirIndexResources() + +void Dbacc::releaseFragRecord(Signal* signal, FragmentrecPtr regFragPtr) +{ + regFragPtr.p->nextfreefrag = cfirstfreefrag; + cfirstfreefrag = regFragPtr.i; + initFragGeneral(regFragPtr); +}//Dbacc::releaseFragRecord() + +void Dbacc::sendFSREMOVEREQ(Signal* signal, Uint32 tableId) +{ + FsRemoveReq * const fsReq = (FsRemoveReq *)signal->getDataPtrSend(); + fsReq->userReference = cownBlockref; + fsReq->userPointer = tableId; + fsReq->fileNumber[0] = tableId; + fsReq->fileNumber[1] = (Uint32)-1; // Remove all fragments + fsReq->fileNumber[2] = (Uint32)-1; // Remove all data files within fragment + fsReq->fileNumber[3] = 255 | // No P-value used here + (3 << 8) | // Data-files in D3 + (0 << 16) | // Data-files + (1 << 24); // Version 1 of fileNumber + fsReq->directory = 1; + fsReq->ownDirectory = 1; + sendSignal(NDBFS_REF, GSN_FSREMOVEREQ, signal, FsRemoveReq::SignalLength, JBA); +}//Dbacc::sendFSREMOVEREQ() + +void Dbacc::execFSREMOVECONF(Signal* signal) +{ + FsConf * const fsConf = (FsConf *)signal->getDataPtrSend(); + TabrecPtr tabPtr; + tabPtr.i = fsConf->userPointer; + ptrCheckGuard(tabPtr, ctablesize, tabrec); + + DropTabConf * const dropConf = (DropTabConf *)signal->getDataPtrSend(); + dropConf->senderRef = reference(); + dropConf->senderData = tabPtr.p->tabUserPtr; + dropConf->tableId = tabPtr.i; + sendSignal(tabPtr.p->tabUserRef, GSN_DROP_TAB_CONF, + signal, DropTabConf::SignalLength, JBB); + + tabPtr.p->tabUserPtr = RNIL; + tabPtr.p->tabUserRef = 0; +}//Dbacc::execFSREMOVECONF() + +void Dbacc::execFSREMOVEREF(Signal* signal) +{ + ndbrequire(false); +}//Dbacc::execFSREMOVEREF() + +/* -------------------------------------------------------------------------- */ +/* ADDFRAGTOTAB */ +/* DESCRIPTION: PUTS A FRAGMENT ID AND A POINTER TO ITS RECORD INTO */ +/* TABLE ARRRAY OF THE TABLE RECORD. */ +/* -------------------------------------------------------------------------- */ +bool Dbacc::addfragtotab(Signal* signal, Uint32 rootIndex, Uint32 fid) +{ + for (Uint32 i = 0; i < NO_OF_FRAG_PER_NODE; i++) { + jam(); + if (tabptr.p->fragholder[i] == RNIL) { + jam(); + tabptr.p->fragholder[i] = fid; + tabptr.p->fragptrholder[i] = rootIndex; + return true; + }//if + }//for + return false; +}//Dbacc::addfragtotab() + +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* END OF ADD/DELETE FRAGMENT MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* CONNECTION MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* ACCSEIZEREQ SEIZE REQ */ +/* SENDER: LQH, LEVEL B */ +/* ENTER ACCSEIZEREQ WITH */ +/* TUSERPTR , CONECTION PTR OF LQH */ +/* TUSERBLOCKREF BLOCK REFERENCE OF LQH */ +/* ******************--------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* ACCSEIZEREQ SEIZE REQ */ +/* ******************------------------------------+ */ +/* SENDER: LQH, LEVEL B */ +void Dbacc::execACCSEIZEREQ(Signal* signal) +{ + jamEntry(); + tuserptr = signal->theData[0]; + /* CONECTION PTR OF LQH */ + tuserblockref = signal->theData[1]; + /* BLOCK REFERENCE OF LQH */ + tresult = 0; + if (cfreeopRec == RNIL) { + jam(); + refaccConnectLab(signal); + return; + }//if + seizeOpRec(signal); + ptrGuard(operationRecPtr); + operationRecPtr.p->userptr = tuserptr; + operationRecPtr.p->userblockref = tuserblockref; + operationRecPtr.p->operation = ZUNDEFINED_OP; + operationRecPtr.p->transactionstate = IDLE; + /* ******************************< */ + /* ACCSEIZECONF */ + /* ******************************< */ + signal->theData[0] = tuserptr; + signal->theData[1] = operationRecPtr.i; + sendSignal(tuserblockref, GSN_ACCSEIZECONF, signal, 2, JBB); + return; +}//Dbacc::execACCSEIZEREQ() + +void Dbacc::refaccConnectLab(Signal* signal) +{ + tresult = ZCONNECT_SIZE_ERROR; + /* ******************************< */ + /* ACCSEIZEREF */ + /* ******************************< */ + signal->theData[0] = tuserptr; + signal->theData[1] = tresult; + sendSignal(tuserblockref, GSN_ACCSEIZEREF, signal, 2, JBB); + return; +}//Dbacc::refaccConnectLab() + +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* END OF CONNECTION MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* EXECUTE OPERATION MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* INIT_OP_REC */ +/* INFORMATION WHICH IS RECIEVED BY ACCKEYREQ WILL BE SAVED */ +/* IN THE OPERATION RECORD. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initOpRec(Signal* signal) +{ + register Uint32 Treqinfo; + + Treqinfo = signal->theData[2]; + + operationRecPtr.p->hashValue = signal->theData[3]; + operationRecPtr.p->tupkeylen = signal->theData[4]; + operationRecPtr.p->transId1 = signal->theData[5]; + operationRecPtr.p->transId2 = signal->theData[6]; + operationRecPtr.p->transactionstate = ACTIVE; + operationRecPtr.p->commitDeleteCheckFlag = ZFALSE; + operationRecPtr.p->operation = Treqinfo & 0x7; + /* --------------------------------------------------------------------------------- */ + // opSimple is not used in this version. Is needed for deadlock handling later on. + /* --------------------------------------------------------------------------------- */ + // operationRecPtr.p->opSimple = (Treqinfo >> 3) & 0x1; + + operationRecPtr.p->lockMode = (Treqinfo >> 4) & 0x3; + + Uint32 readFlag = (((Treqinfo >> 4) & 0x3) == 0); // Only 1 if Read + Uint32 dirtyFlag = (((Treqinfo >> 6) & 0x1) == 1); // Only 1 if Dirty + Uint32 dirtyReadFlag = readFlag & dirtyFlag; + operationRecPtr.p->dirtyRead = dirtyReadFlag; + + operationRecPtr.p->nodeType = (Treqinfo >> 7) & 0x3; + operationRecPtr.p->fid = fragrecptr.p->myfid; + operationRecPtr.p->fragptr = fragrecptr.i; + operationRecPtr.p->nextParallelQue = RNIL; + operationRecPtr.p->prevParallelQue = RNIL; + operationRecPtr.p->prevQueOp = RNIL; + operationRecPtr.p->nextQueOp = RNIL; + operationRecPtr.p->nextSerialQue = RNIL; + operationRecPtr.p->prevSerialQue = RNIL; + operationRecPtr.p->elementPage = RNIL; + operationRecPtr.p->keyinfoPage = RNIL; + operationRecPtr.p->lockOwner = ZFALSE; + operationRecPtr.p->insertIsDone = ZFALSE; + operationRecPtr.p->elementIsDisappeared = ZFALSE; + operationRecPtr.p->insertDeleteLen = fragrecptr.p->elementLength; + operationRecPtr.p->longPagePtr = RNIL; + operationRecPtr.p->longKeyPageIndex = RNIL; + operationRecPtr.p->scanRecPtr = RNIL; + + // bit to mark lock operation + operationRecPtr.p->isAccLockReq = (Treqinfo >> 31) & 0x1; +}//Dbacc::initOpRec() + +/* --------------------------------------------------------------------------------- */ +/* SEND_ACCKEYCONF */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::sendAcckeyconf(Signal* signal) +{ + signal->theData[0] = operationRecPtr.p->userptr; + signal->theData[1] = operationRecPtr.p->insertIsDone; + signal->theData[2] = operationRecPtr.p->fid; + signal->theData[3] = operationRecPtr.p->localdata[0]; + signal->theData[4] = operationRecPtr.p->localdata[1]; + signal->theData[5] = fragrecptr.p->localkeylen; +}//Dbacc::sendAcckeyconf() + + +void Dbacc::ACCKEY_error(Uint32 fromWhere) +{ + switch(fromWhere) { + case 0: + ndbrequire(false); + case 1: + ndbrequire(false); + case 2: + ndbrequire(false); + case 3: + ndbrequire(false); + case 4: + ndbrequire(false); + case 5: + ndbrequire(false); + case 6: + ndbrequire(false); + case 7: + ndbrequire(false); + case 8: + ndbrequire(false); + case 9: + ndbrequire(false); + default: + ndbrequire(false); + }//switch +}//Dbacc::ACCKEY_error() + +/* ******************--------------------------------------------------------------- */ +/* ACCKEYREQ REQUEST FOR INSERT, DELETE, */ +/* RERAD AND UPDATE, A TUPLE. */ +/* SENDER: LQH, LEVEL B */ +/* SIGNAL DATA: OPERATION_REC_PTR, CONNECTION PTR */ +/* TABPTR, TABLE ID = TABLE RECORD POINTER */ +/* TREQINFO, */ +/* THASHVALUE, HASH VALUE OF THE TUP */ +/* TKEYLEN, LENGTH OF THE PRIMARY KEYS */ +/* TKEY1, PRIMARY KEY 1 */ +/* TKEY2, PRIMARY KEY 2 */ +/* TKEY3, PRIMARY KEY 3 */ +/* TKEY4, PRIMARY KEY 4 */ +/* ******************--------------------------------------------------------------- */ +void Dbacc::execACCKEYREQ(Signal* signal) +{ + jamEntry(); + operationRecPtr.i = signal->theData[0]; /* CONNECTION PTR */ + fragrecptr.i = signal->theData[1]; /* FRAGMENT RECORD POINTER */ + if (!((operationRecPtr.i < coprecsize) || + (fragrecptr.i < cfragmentsize))) { + ACCKEY_error(0); + return; + }//if + ptrAss(operationRecPtr, operationrec); + ptrAss(fragrecptr, fragmentrec); + ndbrequire(operationRecPtr.p->transactionstate == IDLE); + + initOpRec(signal); + /*---------------------------------------------------------------*/ + /* */ + /* WE WILL USE THE HASH VALUE TO LOOK UP THE PROPER MEMORY */ + /* PAGE AND MEMORY PAGE INDEX TO START THE SEARCH WITHIN. */ + /* WE REMEMBER THESE ADDRESS IF WE LATER NEED TO INSERT */ + /* THE ITEM AFTER NOT FINDING THE ITEM. */ + /*---------------------------------------------------------------*/ + getElement(signal); + + if (tgeResult == ZTRUE) { + switch (operationRecPtr.p->operation) { + case ZREAD: + case ZUPDATE: + case ZDELETE: + case ZWRITE: + case ZSCAN_OP: + if (!tgeLocked){ + sendAcckeyconf(signal); + if (operationRecPtr.p->dirtyRead == ZFALSE) { + /*---------------------------------------------------------------*/ + // It is not a dirty read. We proceed by locking and continue with + // the operation. + /*---------------------------------------------------------------*/ + Uint32 eh = gePageptr.p->word32[tgeElementptr]; + operationRecPtr.p->scanBits = ElementHeader::getScanBits(eh); + operationRecPtr.p->hashvaluePart = ElementHeader::getHashValuePart(eh); + operationRecPtr.p->elementPage = gePageptr.i; + operationRecPtr.p->elementContainer = tgeContainerptr; + operationRecPtr.p->elementPointer = tgeElementptr; + operationRecPtr.p->elementIsforward = tgeForward; + + eh = ElementHeader::setLocked(operationRecPtr.i); + dbgWord32(gePageptr, tgeElementptr, eh); + gePageptr.p->word32[tgeElementptr] = eh; + + insertLockOwnersList(signal , operationRecPtr); + return; + } else { + jam(); + /*---------------------------------------------------------------*/ + // It is a dirty read. We do not lock anything. Set state to + // IDLE since no COMMIT call will come. + /*---------------------------------------------------------------*/ + operationRecPtr.p->transactionstate = IDLE; + operationRecPtr.p->operation = ZUNDEFINED_OP; + return; + }//if + } else { + jam(); + accIsLockedLab(signal); + return; + }//if + break; + case ZINSERT: + jam(); + insertExistElemLab(signal); + return; + break; + default: + ndbrequire(false); + break; + }//switch + } else if (tgeResult == ZFALSE) { + switch (operationRecPtr.p->operation) { + case ZINSERT: + case ZWRITE: + jam(); + // If a write operation makes an insert we switch operation to ZINSERT so + // that the commit-method knows an insert has been made and updates noOfElements. + operationRecPtr.p->operation = ZINSERT; + operationRecPtr.p->insertIsDone = ZTRUE; + insertelementLab(signal); + return; + break; + case ZREAD: + case ZUPDATE: + case ZDELETE: + case ZSCAN_OP: + jam(); + acckeyref1Lab(signal, ZREAD_ERROR); + return; + break; + default: + ndbrequire(false); + break; + }//switch + } else { + jam(); + acckeyref1Lab(signal, tgeResult); + return; + }//if + return; +}//Dbacc::execACCKEYREQ() + +void Dbacc::accIsLockedLab(Signal* signal) +{ + ndbrequire(csystemRestart == ZFALSE); + queOperPtr.i = ElementHeader::getOpPtrI(gePageptr.p->word32[tgeElementptr]); + ptrCheckGuard(queOperPtr, coprecsize, operationrec); + if (operationRecPtr.p->dirtyRead == ZFALSE) { + Uint32 return_result; + if (operationRecPtr.p->lockMode == ZREADLOCK) { + jam(); + priPageptr = gePageptr; + tpriElementptr = tgeElementptr; + return_result = placeReadInLockQueue(signal); + } else { + jam(); + pwiPageptr = gePageptr; + tpwiElementptr = tgeElementptr; + return_result = placeWriteInLockQueue(signal); + }//if + if (return_result == ZPARALLEL_QUEUE) { + jam(); + sendAcckeyconf(signal); + return; + } else if (return_result == ZSERIAL_QUEUE) { + jam(); + signal->theData[0] = RNIL; + return; + } else if (return_result == ZWRITE_ERROR) { + jam(); + acckeyref1Lab(signal, return_result); + return; + }//if + ndbrequire(false); + } else { + if (queOperPtr.p->elementIsDisappeared == ZFALSE) { + jam(); + /*---------------------------------------------------------------*/ + // It is a dirty read. We do not lock anything. Set state to + // IDLE since no COMMIT call will arrive. + /*---------------------------------------------------------------*/ + sendAcckeyconf(signal); + operationRecPtr.p->transactionstate = IDLE; + operationRecPtr.p->operation = ZUNDEFINED_OP; + return; + } else { + jam(); + /*---------------------------------------------------------------*/ + // The tuple does not exist in the committed world currently. + // Report read error. + /*---------------------------------------------------------------*/ + acckeyref1Lab(signal, ZREAD_ERROR); + return; + }//if + }//if +}//Dbacc::accIsLockedLab() + +/* --------------------------------------------------------------------------------- */ +/* I N S E R T E X I S T E L E M E N T */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::insertExistElemLab(Signal* signal) +{ + if (!tgeLocked){ + jam(); + acckeyref1Lab(signal, ZWRITE_ERROR);/* THE ELEMENT ALREADY EXIST */ + return; + }//if + accIsLockedLab(signal); +}//Dbacc::insertExistElemLab() + +/* --------------------------------------------------------------------------------- */ +/* INSERTELEMENT */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::insertelementLab(Signal* signal) +{ + Uint32 tinsKeyLen; + + if (fragrecptr.p->createLcp == ZTRUE) { + if (remainingUndoPages() < ZMIN_UNDO_PAGES_AT_OPERATION) { + jam(); + acckeyref1Lab(signal, ZTEMPORARY_ACC_UNDO_FAILURE); + return; + }//if + }//if + if (fragrecptr.p->firstOverflowRec == RNIL) { + jam(); + allocOverflowPage(signal); + if (tresult > ZLIMIT_OF_ERROR) { + jam(); + acckeyref1Lab(signal, tresult); + return; + }//if + }//if + if (fragrecptr.p->keyLength != operationRecPtr.p->tupkeylen) { + ndbrequire(fragrecptr.p->keyLength == 0); + }//if + if (fragrecptr.p->keyLength != 0) { + ndbrequire(operationRecPtr.p->tupkeylen <= 8); + for (Uint32 i = 0; i < operationRecPtr.p->tupkeylen; i++) { + jam(); + ckeys[i] = signal->theData[i + 7]; + }//for + tinsKeyLen = operationRecPtr.p->tupkeylen; + } else { + jam(); + seizePage(signal); + if (tresult > ZLIMIT_OF_ERROR) { + jam(); + acckeyref1Lab(signal, tresult); + return; + }//if + operationRecPtr.p->keyinfoPage = spPageptr.i; + for (Uint32 i = 0; i < signal->theData[4]; i++) { + spPageptr.p->word32[i] = signal->theData[i + 7]; + }//for + + getLongKeyPage(signal); + if (tresult > ZLIMIT_OF_ERROR) { + jam(); + acckeyref1Lab(signal, tresult); + return; + }//if + slkPageptr = glkPageptr; + slkCopyPageptr.i = operationRecPtr.p->keyinfoPage; + ptrCheckGuard(slkCopyPageptr, cpagesize, page8); + tslkKeyLen = operationRecPtr.p->tupkeylen; + storeLongKeys(signal); + ckeys[0] = (slkPageptr.p->word32[ZPOS_PAGE_ID] << 10) + tslkPageIndex; + tinsKeyLen = ZACTIVE_LONG_KEY_LEN; + rpPageptr.i = operationRecPtr.p->keyinfoPage; + ptrCheckGuard(rpPageptr, cpagesize, page8); + releasePage(signal); + operationRecPtr.p->keyinfoPage = RNIL; + }//if + + signal->theData[0] = operationRecPtr.p->userptr; + Uint32 blockNo = refToBlock(operationRecPtr.p->userblockref); + EXECUTE_DIRECT(blockNo, GSN_LQH_ALLOCREQ, signal, 1); + jamEntry(); + if (signal->theData[0] != 0) { + jam(); + Uint32 result_code = signal->theData[0]; + acckeyref1Lab(signal, result_code); + return; + }//if + Uint32 localKey = (signal->theData[1] << MAX_TUPLES_BITS) + signal->theData[2]; + + insertLockOwnersList(signal, operationRecPtr); + + const Uint32 tmp = fragrecptr.p->k + fragrecptr.p->lhfragbits; + operationRecPtr.p->hashvaluePart = + (operationRecPtr.p->hashValue >> tmp) & 0xFFFF; + operationRecPtr.p->scanBits = 0; /* NOT ANY ACTIVE SCAN */ + tidrElemhead = ElementHeader::setLocked(operationRecPtr.i); + idrPageptr = gdiPageptr; + tidrPageindex = tgdiPageindex; + tidrForward = ZTRUE; + tidrKeyLen = tinsKeyLen; + idrOperationRecPtr = operationRecPtr; + clocalkey[0] = localKey; + operationRecPtr.p->localdata[0] = localKey; + /* --------------------------------------------------------------------------------- */ + /* WE SET THE LOCAL KEY TO MINUS ONE TO INDICATE IT IS NOT YET VALID. */ + /* --------------------------------------------------------------------------------- */ + insertElement(signal); + sendAcckeyconf(signal); + return; +}//Dbacc::insertelementLab() + +/* --------------------------------------------------------------------------------- */ +/* PLACE_READ_IN_LOCK_QUEUE */ +/* INPUT: OPERATION_REC_PTR OUR OPERATION POINTER */ +/* QUE_OPER_PTR LOCK QUEUE OWNER OPERATION POINTER */ +/* PRI_PAGEPTR PAGE POINTER OF ELEMENT */ +/* TPRI_ELEMENTPTR ELEMENT POINTER OF ELEMENT */ +/* OUTPUT TRESULT = */ +/* ZPARALLEL_QUEUE OPERATION PLACED IN PARALLEL QUEUE */ +/* OPERATION CAN PROCEED NOW. */ +/* ZSERIAL_QUEUE OPERATION PLACED IN SERIAL QUEUE */ +/* ERROR CODE OPERATION NEEDS ABORTING */ +/* THE ELEMENT WAS LOCKED AND WE WANT TO READ THE TUPLE. WE WILL CHECK THE LOCK */ +/* QUEUES TO PERFORM THE PROPER ACTION. */ +/* */ +/* IN SOME PLACES IN THE CODE BELOW THAT HANDLES WHAT TO DO WHEN THE TUPLE IS LOCKED */ +/* WE DO ASSUME THAT NEXT_PARALLEL_QUEUE AND NEXT_SERIAL_QUEUE ON OPERATION_REC_PTR */ +/* HAVE BEEN INITIALISED TO RNIL. THUS WE DO NOT PERFORM THIS ONCE MORE EVEN IF IT */ +/* COULD BE NICE FOR READABILITY. */ +/* --------------------------------------------------------------------------------- */ +Uint32 Dbacc::placeReadInLockQueue(Signal* signal) +{ + tgnptMainOpPtr = queOperPtr; + getNoParallelTransaction(signal); + if (tgnptNrTransaction == 1) { + if ((queOperPtr.p->transId1 == operationRecPtr.p->transId1) && + (queOperPtr.p->transId2 == operationRecPtr.p->transId2)) { + /* --------------------------------------------------------------------------------- */ + /* WE ARE PERFORMING A READ OPERATION AND THIS TRANSACTION ALREADY OWNS THE LOCK */ + /* ALONE. PUT THE OPERATION LAST IN THE PARALLEL QUEUE. */ + /* --------------------------------------------------------------------------------- */ + jam(); + mlpqOperPtr = queOperPtr; + moveLastParallelQueue(signal); + operationRecPtr.p->localdata[0] = queOperPtr.p->localdata[0]; + operationRecPtr.p->localdata[1] = queOperPtr.p->localdata[1]; + operationRecPtr.p->prevParallelQue = mlpqOperPtr.i; + mlpqOperPtr.p->nextParallelQue = operationRecPtr.i; + switch (queOperPtr.p->lockMode) { + case ZREADLOCK: + jam(); + /*empty*/; + break; + default: + jam(); + /* --------------------------------------------------------------------------------- */ + /* IF THE TRANSACTION PREVIOUSLY SET A WRITE LOCK WE MUST ENSURE THAT ALL */ + /* OPERATIONS IN THE PARALLEL QUEUE HAVE WRITE LOCK MODE TO AVOID STRANGE BUGS.*/ + /* --------------------------------------------------------------------------------- */ + operationRecPtr.p->lockMode = queOperPtr.p->lockMode; + break; + }//switch + return ZPARALLEL_QUEUE; + }//if + }//if + if (queOperPtr.p->nextSerialQue == RNIL) { + /* --------------------------------------------------------------------------------- */ + /* WE ARE PERFORMING A READ OPERATION AND THERE IS NO SERIAL QUEUE. IF THERE IS NO */ + /* WRITE OPERATION THAT OWNS THE LOCK OR ANY WRITE OPERATION IN THE PARALLEL QUEUE */ + /* IT IS ENOUGH TO CHECK THE LOCK MODE OF THE LEADER IN THE PARALLEL QUEUE. IF IT IS */ + /* A READ LOCK THEN WE PLACE OURSELVES IN THE PARALLEL QUEUE OTHERWISE WE GO ON TO */ + /* PLACE OURSELVES IN THE SERIAL QUEUE. */ + /* --------------------------------------------------------------------------------- */ + switch (queOperPtr.p->lockMode) { + case ZREADLOCK: + jam(); + mlpqOperPtr = queOperPtr; + moveLastParallelQueue(signal); + operationRecPtr.p->prevParallelQue = mlpqOperPtr.i; + mlpqOperPtr.p->nextParallelQue = operationRecPtr.i; + operationRecPtr.p->localdata[0] = queOperPtr.p->localdata[0]; + operationRecPtr.p->localdata[1] = queOperPtr.p->localdata[1]; + return ZPARALLEL_QUEUE; + default: + jam(); + queOperPtr.p->nextSerialQue = operationRecPtr.i; + operationRecPtr.p->prevSerialQue = queOperPtr.i; + putOpInFragWaitQue(signal); + break; + }//switch + } else { + jam(); + placeSerialQueueRead(signal); + }//if + return ZSERIAL_QUEUE; +}//Dbacc::placeReadInLockQueue() + +/* --------------------------------------------------------------------------------- */ +/* WE WILL CHECK IF THIS TRANSACTION IS ALREADY PLACED AT SOME SPOT IN THE PARALLEL */ +/* SERIAL QUEUE WITHOUT ANY NEIGHBORS FROM OTHER TRANSACTION. IF SO WE WILL INSERT */ +/* IT IN THAT PARALLEL QUEUE. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::placeSerialQueueRead(Signal* signal) +{ + readWriteOpPtr.i = queOperPtr.p->nextSerialQue; + ptrCheckGuard(readWriteOpPtr, coprecsize, operationrec); + PSQR_LOOP: + jam(); + if (readWriteOpPtr.p->nextSerialQue == RNIL) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THERE WAS NO PREVIOUS OPERATION IN THIS TRANSACTION WHICH WE COULD PUT IT */ + /* IN THE PARALLEL QUEUE TOGETHER WITH. */ + /* --------------------------------------------------------------------------------- */ + checkOnlyReadEntry(signal); + return; + }//if + tgnptMainOpPtr = readWriteOpPtr; + getNoParallelTransaction(signal); + if (tgnptNrTransaction == 1) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THERE WAS ONLY ONE TRANSACTION INVOLVED IN THE PARALLEL QUEUE. IF THIS IS OUR */ + /* TRANSACTION WE CAN STILL GET HOLD OF THE LOCK. */ + /* --------------------------------------------------------------------------------- */ + if ((readWriteOpPtr.p->transId1 == operationRecPtr.p->transId1) && + (readWriteOpPtr.p->transId2 == operationRecPtr.p->transId2)) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* WE ARE PERFORMING A READ IN THE SAME TRANSACTION WHERE WE ALREADY */ + /* PREVIOUSLY HAVE EXECUTED AN OPERATION. INSERT-DELETE, READ-UPDATE, READ-READ, */ + /* UPDATE-UPDATE, UPDATE-DELETE, READ-DELETE, INSERT-READ, INSERT-UPDATE ARE ALLOWED */ + /* COMBINATIONS. A NEW INSERT AFTER A DELETE IS NOT ALLOWED AND SUCH AN INSERT WILL */ + /* GO TO THE SERIAL LOCK QUEUE WHICH IT WILL NOT LEAVE UNTIL A TIME-OUT AND THE */ + /* TRANSACTION IS ABORTED. READS AND UPDATES AFTER DELETES IS ALSO NOT ALLOWED. */ + /* --------------------------------------------------------------------------------- */ + mlpqOperPtr = readWriteOpPtr; + moveLastParallelQueue(signal); + readWriteOpPtr = mlpqOperPtr; + operationRecPtr.p->prevParallelQue = readWriteOpPtr.i; + readWriteOpPtr.p->nextParallelQue = operationRecPtr.i; + operationRecPtr.p->localdata[0] = readWriteOpPtr.p->localdata[0]; + operationRecPtr.p->localdata[1] = readWriteOpPtr.p->localdata[1]; + switch (readWriteOpPtr.p->lockMode) { + case ZREADLOCK: + jam(); + /*empty*/; + break; + default: + jam(); + /* --------------------------------------------------------------------------------- */ + /* IF THE TRANSACTION PREVIOUSLY SET A WRITE LOCK WE MUST ENSURE THAT ALL */ + /* OPERATIONS IN THE PARALLEL QUEUE HAVE WRITE LOCK MODE TO AVOID STRANGE BUGS.*/ + /* --------------------------------------------------------------------------------- */ + operationRecPtr.p->lockMode = readWriteOpPtr.p->lockMode; + break; + }//switch + putOpInFragWaitQue(signal); + return; + }//if + }//if + readWriteOpPtr.i = readWriteOpPtr.p->nextSerialQue; + ptrCheckGuard(readWriteOpPtr, coprecsize, operationrec); + goto PSQR_LOOP; +}//Dbacc::placeSerialQueueRead() + +/* --------------------------------------------------------------------------------- */ +/* WE WILL CHECK IF THE LAST ENTRY IN THE SERIAL QUEUE CONTAINS ONLY READ */ +/* OPERATIONS. IF SO WE WILL INSERT IT IN THAT PARALLEL QUEUE. OTHERWISE WE */ +/* WILL PLACE IT AT THE END OF THE SERIAL QUEUE. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::checkOnlyReadEntry(Signal* signal) +{ + switch (readWriteOpPtr.p->lockMode) { + case ZREADLOCK: + jam(); + /* --------------------------------------------------------------------------------- */ + /* SINCE THIS LAST QUEUE ONLY CONTAINS READ LOCKS WE CAN JOIN THE PARALLEL QUEUE AT */ + /* THE END. */ + /* --------------------------------------------------------------------------------- */ + mlpqOperPtr = readWriteOpPtr; + moveLastParallelQueue(signal); + readWriteOpPtr = mlpqOperPtr; + operationRecPtr.p->prevParallelQue = readWriteOpPtr.i; + readWriteOpPtr.p->nextParallelQue = operationRecPtr.i; + operationRecPtr.p->localdata[0] = readWriteOpPtr.p->localdata[0]; + operationRecPtr.p->localdata[1] = readWriteOpPtr.p->localdata[1]; + break; + default: + jam(); /* PUT THE OPERATION RECORD IN THE SERIAL QUEUE */ + readWriteOpPtr.p->nextSerialQue = operationRecPtr.i; + operationRecPtr.p->prevSerialQue = readWriteOpPtr.i; + break; + }//switch + putOpInFragWaitQue(signal); +}//Dbacc::checkOnlyReadEntry() + +/* --------------------------------------------------------------------------------- */ +/* GET_NO_PARALLEL_TRANSACTION */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::getNoParallelTransaction(Signal* signal) +{ + OperationrecPtr tnptOpPtr; + + tgnptNrTransaction = 1; + tnptOpPtr.i = tgnptMainOpPtr.p->nextParallelQue; + while ((tnptOpPtr.i != RNIL) && + (tgnptNrTransaction == 1)) { + jam(); + ptrCheckGuard(tnptOpPtr, coprecsize, operationrec); + if ((tnptOpPtr.p->transId1 == tgnptMainOpPtr.p->transId1) && + (tnptOpPtr.p->transId2 == tgnptMainOpPtr.p->transId2)) { + tnptOpPtr.i = tnptOpPtr.p->nextParallelQue; + } else { + jam(); + tgnptNrTransaction++; + }//if + }//while +}//Dbacc::getNoParallelTransaction() + +void Dbacc::moveLastParallelQueue(Signal* signal) +{ + while (mlpqOperPtr.p->nextParallelQue != RNIL) { + jam(); + mlpqOperPtr.i = mlpqOperPtr.p->nextParallelQue; + ptrCheckGuard(mlpqOperPtr, coprecsize, operationrec); + }//if +}//Dbacc::moveLastParallelQueue() + +void Dbacc::moveLastParallelQueueWrite(Signal* signal) +{ + /* --------------------------------------------------------------------------------- */ + /* ENSURE THAT ALL OPERATIONS HAVE LOCK MODE SET TO WRITE SINCE WE INSERT A */ + /* WRITE LOCK INTO THE PARALLEL QUEUE. */ + /* --------------------------------------------------------------------------------- */ + while (mlpqOperPtr.p->nextParallelQue != RNIL) { + jam(); + mlpqOperPtr.p->lockMode = operationRecPtr.p->lockMode; + mlpqOperPtr.i = mlpqOperPtr.p->nextParallelQue; + ptrCheckGuard(mlpqOperPtr, coprecsize, operationrec); + }//if + mlpqOperPtr.p->lockMode = operationRecPtr.p->lockMode; +}//Dbacc::moveLastParallelQueueWrite() + +/* --------------------------------------------------------------------------------- */ +/* PLACE_WRITE_IN_LOCK_QUEUE */ +/* INPUT: OPERATION_REC_PTR OUR OPERATION POINTER */ +/* QUE_OPER_PTR LOCK QUEUE OWNER OPERATION POINTER */ +/* PWI_PAGEPTR PAGE POINTER OF ELEMENT */ +/* TPWI_ELEMENTPTR ELEMENT POINTER OF ELEMENT */ +/* OUTPUT TRESULT = */ +/* ZPARALLEL_QUEUE OPERATION PLACED IN PARALLEL QUEUE */ +/* OPERATION CAN PROCEED NOW. */ +/* ZSERIAL_QUEUE OPERATION PLACED IN SERIAL QUEUE */ +/* ERROR CODE OPERATION NEEDS ABORTING */ +/* --------------------------------------------------------------------------------- */ +Uint32 Dbacc::placeWriteInLockQueue(Signal* signal) +{ + tgnptMainOpPtr = queOperPtr; + getNoParallelTransaction(signal); + if (!((tgnptNrTransaction == 1) && + (queOperPtr.p->transId1 == operationRecPtr.p->transId1) && + (queOperPtr.p->transId2 == operationRecPtr.p->transId2))) { + jam(); + placeSerialQueueWrite(signal); + return ZSERIAL_QUEUE; + }//if + + /* + WE ARE PERFORMING AN READ EXCLUSIVE, INSERT, UPDATE OR DELETE IN THE SAME + TRANSACTION WHERE WE PREVIOUSLY HAVE EXECUTED AN OPERATION. + Read-All, Update-All, Insert-All and Delete-Insert are allowed + combinations. + Delete-Read, Delete-Update and Delete-Delete are not an allowed + combination and will result in tuple not found error. + */ + mlpqOperPtr = queOperPtr; + moveLastParallelQueueWrite(signal); + + if (operationRecPtr.p->operation == ZINSERT && + mlpqOperPtr.p->operation != ZDELETE){ + jam(); + return ZWRITE_ERROR; + }//if + + operationRecPtr.p->localdata[0] = queOperPtr.p->localdata[0]; + operationRecPtr.p->localdata[1] = queOperPtr.p->localdata[1]; + operationRecPtr.p->prevParallelQue = mlpqOperPtr.i; + mlpqOperPtr.p->nextParallelQue = operationRecPtr.i; + return ZPARALLEL_QUEUE; +}//Dbacc::placeWriteInLockQueue() + +/* --------------------------------------------------------------------------------- */ +/* WE HAVE TO PLACE IT SOMEWHERE IN THE SERIAL QUEUE INSTEAD. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::placeSerialQueueWrite(Signal* signal) +{ + readWriteOpPtr = queOperPtr; + PSQW_LOOP: + if (readWriteOpPtr.p->nextSerialQue == RNIL) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* WE COULD NOT PUT IN ANY PARALLEL QUEUE. WE MUST PUT IT LAST IN THE SERIAL QUEUE. */ + /* --------------------------------------------------------------------------------- */ + readWriteOpPtr.p->nextSerialQue = operationRecPtr.i; + operationRecPtr.p->prevSerialQue = readWriteOpPtr.i; + putOpInFragWaitQue(signal); + return; + }//if + readWriteOpPtr.i = readWriteOpPtr.p->nextSerialQue; + ptrCheckGuard(readWriteOpPtr, coprecsize, operationrec); + tgnptMainOpPtr = readWriteOpPtr; + getNoParallelTransaction(signal); + if (tgnptNrTransaction == 1) { + /* --------------------------------------------------------------------------------- */ + /* THERE WAS ONLY ONE TRANSACTION INVOLVED IN THE PARALLEL QUEUE. IF THIS IS OUR */ + /* TRANSACTION WE CAN STILL GET HOLD OF THE LOCK. */ + /* --------------------------------------------------------------------------------- */ + if ((readWriteOpPtr.p->transId1 == operationRecPtr.p->transId1) && + (readWriteOpPtr.p->transId2 == operationRecPtr.p->transId2)) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* WE ARE PERFORMING AN UPDATE OR DELETE IN THE SAME TRANSACTION WHERE WE ALREADY */ + /* PREVIOUSLY HAVE EXECUTED AN OPERATION. INSERT-DELETE, READ-UPDATE, READ-READ, */ + /* UPDATE-UPDATE, UPDATE-DELETE, READ-DELETE, INSERT-READ, INSERT-UPDATE ARE ALLOWED */ + /* COMBINATIONS. A NEW INSERT AFTER A DELETE IS NOT ALLOWED AND SUCH AN INSERT WILL */ + /* GO TO THE SERIAL LOCK QUEUE WHICH IT WILL NOT LEAVE UNTIL A TIME-OUT AND THE */ + /* TRANSACTION IS ABORTED. READS AND UPDATES AFTER DELETES IS ALSO NOT ALLOWED. */ + /* --------------------------------------------------------------------------------- */ + mlpqOperPtr = readWriteOpPtr; + moveLastParallelQueueWrite(signal); + readWriteOpPtr = mlpqOperPtr; + operationRecPtr.p->prevParallelQue = readWriteOpPtr.i; + readWriteOpPtr.p->nextParallelQue = operationRecPtr.i; + operationRecPtr.p->localdata[0] = readWriteOpPtr.p->localdata[0]; + operationRecPtr.p->localdata[1] = readWriteOpPtr.p->localdata[1]; + putOpInFragWaitQue(signal); + return; + }//if + }//if + goto PSQW_LOOP; +}//Dbacc::placeSerialQueueWrite() + +/* ------------------------------------------------------------------------- */ +/* ACC KEYREQ END */ +/* ------------------------------------------------------------------------- */ +void Dbacc::acckeyref1Lab(Signal* signal, Uint32 result_code) +{ + if (operationRecPtr.p->keyinfoPage != RNIL) { + jam(); + rpPageptr.i = operationRecPtr.p->keyinfoPage; + ptrCheckGuard(rpPageptr, cpagesize, page8); + releasePage(signal); + operationRecPtr.p->keyinfoPage = RNIL; + }//if + operationRecPtr.p->transactionstate = WAIT_COMMIT_ABORT; + /* ************************<< */ + /* ACCKEYREF */ + /* ************************<< */ + signal->theData[0] = cminusOne; + signal->theData[1] = result_code; + return; +}//Dbacc::acckeyref1Lab() + +/* ******************--------------------------------------------------------------- */ +/* ACCMINUPDATE UPDATE LOCAL KEY REQ */ +/* DESCRIPTION: UPDATES LOCAL KEY OF AN ELEMENTS IN THE HASH TABLE */ +/* THIS SIGNAL IS WAITED AFTER ANY INSERT REQ */ +/* ENTER ACCMINUPDATE WITH SENDER: LQH, LEVEL B */ +/* OPERATION_REC_PTR, OPERATION RECORD PTR */ +/* CLOCALKEY(0), LOCAL KEY 1 */ +/* CLOCALKEY(1) LOCAL KEY 2 */ +/* ******************--------------------------------------------------------------- */ +void Dbacc::execACCMINUPDATE(Signal* signal) +{ + Page8Ptr ulkPageidptr; + Uint32 tulkLocalPtr; + Uint32 tlocalkey1, tlocalkey2; + Uint32 TlogStart; + + jamEntry(); + operationRecPtr.i = signal->theData[0]; + tlocalkey1 = signal->theData[1]; + tlocalkey2 = signal->theData[2]; + ptrCheckGuard(operationRecPtr, coprecsize, operationrec); + if (operationRecPtr.p->transactionstate == ACTIVE) { + fragrecptr.i = operationRecPtr.p->fragptr; + ulkPageidptr.i = operationRecPtr.p->elementPage; + tulkLocalPtr = operationRecPtr.p->elementPointer + operationRecPtr.p->elementIsforward; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + ptrCheckGuard(ulkPageidptr, cpagesize, page8); + if (fragrecptr.p->createLcp == ZTRUE) { + //---------------------------------------------------------- + // To avoid undo log the element header we take care to only + // undo log the local key part. + //---------------------------------------------------------- + if (operationRecPtr.p->elementIsforward == 1) { + jam(); + TlogStart = tulkLocalPtr; + } else { + jam(); + TlogStart = tulkLocalPtr - fragrecptr.p->localkeylen + 1; + }//if + datapageptr.p = ulkPageidptr.p; + cundoinfolength = fragrecptr.p->localkeylen; + cundoElemIndex = TlogStart; + undoWritingProcess(signal); + }//if + dbgWord32(ulkPageidptr, tulkLocalPtr, tlocalkey1); + arrGuard(tulkLocalPtr, 2048); + ulkPageidptr.p->word32[tulkLocalPtr] = tlocalkey1; + operationRecPtr.p->localdata[0] = tlocalkey1; + if (fragrecptr.p->localkeylen == 1) { + return; + } else if (fragrecptr.p->localkeylen == 2) { + jam(); + tulkLocalPtr = tulkLocalPtr + operationRecPtr.p->elementIsforward; + operationRecPtr.p->localdata[1] = tlocalkey2; + dbgWord32(ulkPageidptr, tulkLocalPtr, tlocalkey2); + arrGuard(tulkLocalPtr, 2048); + ulkPageidptr.p->word32[tulkLocalPtr] = tlocalkey2; + return; + } else { + jam(); + }//if + }//if + ndbrequire(false); +}//Dbacc::execACCMINUPDATE() + +/* ******************--------------------------------------------------------------- */ +/* ACC_COMMITREQ COMMIT TRANSACTION */ +/* SENDER: LQH, LEVEL B */ +/* INPUT: OPERATION_REC_PTR , */ +/* ******************--------------------------------------------------------------- */ +void Dbacc::execACC_COMMITREQ(Signal* signal) +{ + Uint8 Toperation; + jamEntry(); + operationRecPtr.i = signal->theData[0]; + ptrCheckGuard(operationRecPtr, coprecsize, operationrec); + ndbrequire(operationRecPtr.p->transactionstate == ACTIVE); + fragrecptr.i = operationRecPtr.p->fragptr; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + commitOperation(signal); + Toperation = operationRecPtr.p->operation; + operationRecPtr.p->transactionstate = IDLE; + operationRecPtr.p->operation = ZUNDEFINED_OP; + if (Toperation != ZINSERT) { + if (Toperation != ZDELETE) { + return; + } else { + jam(); + rootfragrecptr.i = fragrecptr.p->myroot; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + rootfragrecptr.p->noOfElements--; + fragrecptr.p->slack += operationRecPtr.p->insertDeleteLen; + if (fragrecptr.p->slack > fragrecptr.p->slackCheck) { /* TIME FOR JOIN BUCKETS PROCESS */ + if (fragrecptr.p->expandCounter > 0) { + if (fragrecptr.p->expandFlag == 0) { + jam(); + fragrecptr.p->expandFlag = 1; + signal->theData[0] = fragrecptr.i; + signal->theData[1] = fragrecptr.p->p; + signal->theData[2] = fragrecptr.p->maxp; + sendSignal(cownBlockref, GSN_SHRINKCHECK2, signal, 3, JBB); + }//if + }//if + }//if + }//if + } else { + jam(); /* EXPAND PROCESS HANDLING */ + rootfragrecptr.i = fragrecptr.p->myroot; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + rootfragrecptr.p->noOfElements++; + fragrecptr.p->slack -= operationRecPtr.p->insertDeleteLen; + if (fragrecptr.p->slack >= (Uint32)(1 << 31)) { /* IT MEANS THAT IF SLACK < ZERO */ + if (fragrecptr.p->expandFlag == 0) { + jam(); + fragrecptr.p->expandFlag = 1; + signal->theData[0] = fragrecptr.i; + signal->theData[1] = fragrecptr.p->p; + signal->theData[2] = fragrecptr.p->maxp; + sendSignal(cownBlockref, GSN_EXPANDCHECK2, signal, 3, JBB); + }//if + }//if + }//if + return; +}//Dbacc::execACC_COMMITREQ() + +/* ******************--------------------------------------------------------------- */ +/* ACC ABORT REQ ABORT ALL OPERATION OF THE TRANSACTION */ +/* ******************------------------------------+ */ +/* SENDER: LQH, LEVEL B */ +/* ******************--------------------------------------------------------------- */ +/* ACC ABORT REQ ABORT TRANSACTION */ +/* ******************------------------------------+ */ +/* SENDER: LQH, LEVEL B */ +void Dbacc::execACC_ABORTREQ(Signal* signal) +{ + jamEntry(); + accAbortReqLab(signal, true); +}//Dbacc::execACC_ABORTREQ() + +void Dbacc::accAbortReqLab(Signal* signal, bool sendConf) +{ + operationRecPtr.i = signal->theData[0]; + ptrCheckGuard(operationRecPtr, coprecsize, operationrec); + tresult = 0; /* ZFALSE */ + if ((operationRecPtr.p->transactionstate == ACTIVE) || + (operationRecPtr.p->transactionstate == WAIT_COMMIT_ABORT)) { + jam(); + fragrecptr.i = operationRecPtr.p->fragptr; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + operationRecPtr.p->transactionstate = ABORT; + abortOperation(signal); + } else { + ndbrequire(operationRecPtr.p->transactionstate == IDLE); + jam(); + }//if + operationRecPtr.p->transactionstate = IDLE; + operationRecPtr.p->operation = ZUNDEFINED_OP; + if (! sendConf) + return; + signal->theData[0] = operationRecPtr.p->userptr; + sendSignal(operationRecPtr.p->userblockref, GSN_ACC_ABORTCONF, signal, 1, JBB); + return; +}//Dbacc::accAbortReqLab() + +/* + * Lock or unlock tuple. + */ +void Dbacc::execACC_LOCKREQ(Signal* signal) +{ + jamEntry(); + AccLockReq* sig = (AccLockReq*)signal->getDataPtrSend(); + AccLockReq reqCopy = *sig; + AccLockReq* const req = &reqCopy; + Uint32 lockOp = (req->requestInfo & 0xFF); + if (lockOp == AccLockReq::LockShared || + lockOp == AccLockReq::LockExclusive) { + jam(); + // find table + tabptr.i = req->tableId; + ptrCheckGuard(tabptr, ctablesize, tabrec); + // find fragment (TUX will know it) + if (req->fragPtrI == RNIL) { + for (Uint32 i = 0; i < NO_OF_FRAG_PER_NODE; i++) { + jam(); + if (tabptr.p->fragptrholder[i] != RNIL) { + rootfragrecptr.i = tabptr.p->fragptrholder[i]; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + if (rootfragrecptr.p->fragmentid[0] == req->fragId) { + jam(); + req->fragPtrI = rootfragrecptr.p->fragmentptr[0]; + break; + } + if (rootfragrecptr.p->fragmentid[1] == req->fragId) { + jam(); + req->fragPtrI = rootfragrecptr.p->fragmentptr[1]; + break; + } + } + } + } + fragrecptr.i = req->fragPtrI; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + // caller must be explicit here + ndbrequire(req->accOpPtr == RNIL); + // seize operation to hold the lock + if (cfreeopRec != RNIL) { + jam(); + seizeOpRec(signal); + // init as in ACCSEIZEREQ + operationRecPtr.p->userptr = req->userPtr; + operationRecPtr.p->userblockref = req->userRef; + operationRecPtr.p->operation = ZUNDEFINED_OP; + operationRecPtr.p->transactionstate = IDLE; + // do read with lock via ACCKEYREQ + Uint32 lockMode = (lockOp == AccLockReq::LockShared) ? 0 : 1; + Uint32 opCode = ZSCAN_OP; + signal->theData[0] = operationRecPtr.i; + signal->theData[1] = fragrecptr.i; + signal->theData[2] = opCode | (lockMode << 4) | (1 << 31); + signal->theData[3] = req->hashValue; + signal->theData[4] = 1; // fake primKeyLen + signal->theData[5] = req->transId1; + signal->theData[6] = req->transId2; + signal->theData[7] = req->tupAddr; + EXECUTE_DIRECT(DBACC, GSN_ACCKEYREQ, signal, 8); + // translate the result + if (signal->theData[0] < RNIL) { + jam(); + req->returnCode = AccLockReq::Success; + req->accOpPtr = operationRecPtr.i; + } else if (signal->theData[0] == RNIL) { + jam(); + req->returnCode = AccLockReq::IsBlocked; + req->accOpPtr = operationRecPtr.i; + } else { + ndbrequire(signal->theData[0] == (UintR)-1); + releaseOpRec(signal); + req->returnCode = AccLockReq::Refused; + req->accOpPtr = RNIL; + } + } else { + jam(); + req->returnCode = AccLockReq::NoFreeOp; + } + *sig = *req; + return; + } + if (lockOp == AccLockReq::Unlock) { + jam(); + // do unlock via ACC_COMMITREQ (immediate) + signal->theData[0] = req->accOpPtr; + EXECUTE_DIRECT(DBACC, GSN_ACC_COMMITREQ, signal, 1); + releaseOpRec(signal); + req->returnCode = AccLockReq::Success; + *sig = *req; + return; + } + if (lockOp == AccLockReq::Abort) { + jam(); + // do abort via ACC_ABORTREQ (immediate) + signal->theData[0] = req->accOpPtr; + accAbortReqLab(signal, false); + releaseOpRec(signal); + req->returnCode = AccLockReq::Success; + *sig = *req; + return; + } + if (lockOp == AccLockReq::AbortWithConf) { + jam(); + // do abort via ACC_ABORTREQ (with conf signal) + signal->theData[0] = req->accOpPtr; + accAbortReqLab(signal, true); + releaseOpRec(signal); + req->returnCode = AccLockReq::Success; + *sig = *req; + return; + } + ndbrequire(false); +} + +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* END OF EXECUTE OPERATION MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* MODULE: INSERT */ +/* THE FOLLOWING SUBROUTINES ARE ONLY USED BY INSERT_ELEMENT. THIS */ +/* ROUTINE IS THE SOLE INTERFACE TO INSERT ELEMENTS INTO THE INDEX. */ +/* CURRENT USERS ARE INSERT REQUESTS, EXPAND CONTAINER AND SHRINK */ +/* CONTAINER. */ +/* */ +/* THE FOLLOWING SUBROUTINES ARE INCLUDED IN THIS MODULE: */ +/* INSERT_ELEMENT */ +/* INSERT_CONTAINER */ +/* ADDNEWCONTAINER */ +/* GETFREELIST */ +/* INCREASELISTCONT */ +/* SEIZE_LEFTLIST */ +/* SEIZE_RIGHTLIST */ +/* */ +/* THESE ROUTINES ARE ONLY USED BY THIS MODULE AND BY NO ONE ELSE. */ +/* ALSO THE ROUTINES MAKE NO USE OF ROUTINES IN OTHER MODULES. */ +/* TAKE_REC_OUT_OF_FREE_OVERPAGE AND RELEASE_OVERFLOW_REC ARE */ +/* EXCEPTIONS TO THIS RULE. */ +/* */ +/* THE ONLY SHORT-LIVED VARIABLES USED IN OTHER PARTS OF THE BLOCK ARE */ +/* THOSE DEFINED AS INPUT AND OUTPUT IN INSERT_ELEMENT */ +/* SHORT-LIVED VARIABLES INCLUDE TEMPORARY VARIABLES, COMMON VARIABLES */ +/* AND POINTER VARIABLES. */ +/* THE ONLY EXCEPTION TO THIS RULE IS FRAGRECPTR WHICH POINTS TO THE */ +/* FRAGMENT RECORD. THIS IS MORE LESS STATIC ALWAYS DURING A SIGNAL */ +/* EXECUTION. */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* INSERT_ELEMENT */ +/* INPUT: */ +/* IDR_PAGEPTR (POINTER TO THE ACTIVE PAGE REC) */ +/* TIDR_PAGEINDEX (INDEX OF THE CONTAINER) */ +/* TIDR_FORWARD (DIRECTION FORWARD OR BACKWARD) */ +/* TIDR_ELEMHEAD (HEADER OF ELEMENT TO BE INSERTED */ +/* CIDR_KEYS(ARRAY OF TUPLE KEYS) */ +/* CLOCALKEY(ARRAY OF LOCAL KEYS). */ +/* FRAGRECPTR */ +/* IDR_OPERATION_REC_PTR */ +/* TIDR_KEY_LEN */ +/* */ +/* OUTPUT: */ +/* TIDR_PAGEINDEX (PAGE INDEX OF INSERTED ELEMENT) */ +/* IDR_PAGEPTR (PAGE POINTER OF INSERTED ELEMENT) */ +/* TIDR_FORWARD (CONTAINER DIRECTION OF INSERTED ELEMENT) */ +/* NONE */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::insertElement(Signal* signal) +{ + DirRangePtr inrOverflowrangeptr; + DirectoryarrayPtr inrOverflowDirptr; + OverflowRecordPtr inrOverflowRecPtr; + Page8Ptr inrNewPageptr; + Uint32 tinrNextSamePage; + Uint32 tinrTmp; + + do { + insertContainer(signal); + if (tidrResult != ZFALSE) { + jam(); + return; + /* INSERTION IS DONE, OR */ + /* AN ERROR IS DETECTED */ + }//if + if (((tidrContainerhead >> 7) & 0x3) != 0) { + tinrNextSamePage = (tidrContainerhead >> 9) & 0x1; /* CHECK BIT FOR CHECKING WHERE */ + /* THE NEXT CONTAINER IS IN THE SAME PAGE */ + tidrPageindex = tidrContainerhead & 0x7f; /* NEXT CONTAINER PAGE INDEX 7 BITS */ + if (((tidrContainerhead >> 7) & 3) == ZLEFT) { + jam(); + tidrForward = ZTRUE; + } else if (((tidrContainerhead >> 7) & 3) == ZRIGHT) { + jam(); + tidrForward = cminusOne; + } else { + ndbrequire(false); + return; + }//if + if (tinrNextSamePage == ZFALSE) { + jam(); /* NEXT CONTAINER IS IN AN OVERFLOW PAGE */ + tinrTmp = idrPageptr.p->word32[tidrContainerptr + 1]; + inrOverflowrangeptr.i = fragrecptr.p->overflowdir; + ptrCheckGuard(inrOverflowrangeptr, cdirrangesize, dirRange); + arrGuard((tinrTmp >> 8), 256); + inrOverflowDirptr.i = inrOverflowrangeptr.p->dirArray[tinrTmp >> 8]; + ptrCheckGuard(inrOverflowDirptr, cdirarraysize, directoryarray); + idrPageptr.i = inrOverflowDirptr.p->pagep[tinrTmp & 0xff]; + ptrCheckGuard(idrPageptr, cpagesize, page8); + }//if + ndbrequire(tidrPageindex < ZEMPTYLIST); + } else { + break; + }//if + } while (1); + gflPageptr.p = idrPageptr.p; + getfreelist(signal); + if (tgflPageindex == ZEMPTYLIST) { + jam(); + /* NO FREE BUFFER IS FOUND */ + if (fragrecptr.p->firstOverflowRec == RNIL) { + jam(); + allocOverflowPage(signal); + ndbrequire(tresult <= ZLIMIT_OF_ERROR); + }//if + inrOverflowRecPtr.i = fragrecptr.p->firstOverflowRec; + ptrCheckGuard(inrOverflowRecPtr, coverflowrecsize, overflowRecord); + inrNewPageptr.i = inrOverflowRecPtr.p->overpage; + ptrCheckGuard(inrNewPageptr, cpagesize, page8); + gflPageptr.p = inrNewPageptr.p; + getfreelist(signal); + ndbrequire(tgflPageindex != ZEMPTYLIST); + tancNext = 0; + } else { + jam(); + inrNewPageptr = idrPageptr; + tancNext = 1; + }//if + tslUpdateHeader = ZTRUE; + tslPageindex = tgflPageindex; + slPageptr.p = inrNewPageptr.p; + if (tgflBufType == ZLEFT) { + seizeLeftlist(signal); + tidrForward = ZTRUE; + } else { + seizeRightlist(signal); + tidrForward = cminusOne; + }//if + tancPageindex = tgflPageindex; + tancPageid = inrNewPageptr.p->word32[ZPOS_PAGE_ID]; + tancBufType = tgflBufType; + tancContainerptr = tidrContainerptr; + ancPageptr.p = idrPageptr.p; + addnewcontainer(signal); + + idrPageptr = inrNewPageptr; + tidrPageindex = tgflPageindex; + insertContainer(signal); + ndbrequire(tidrResult == ZTRUE); +}//Dbacc::insertElement() + +/* --------------------------------------------------------------------------------- */ +/* INSERT_CONTAINER */ +/* INPUT: */ +/* IDR_PAGEPTR (POINTER TO THE ACTIVE PAGE REC) */ +/* TIDR_PAGEINDEX (INDEX OF THE CONTAINER) */ +/* TIDR_FORWARD (DIRECTION FORWARD OR BACKWARD) */ +/* TIDR_ELEMHEAD (HEADER OF ELEMENT TO BE INSERTED */ +/* CKEYS(ARRAY OF TUPLE KEYS) */ +/* CLOCALKEY(ARRAY 0F LOCAL KEYS). */ +/* TIDR_KEY_LEN */ +/* FRAGRECPTR */ +/* IDR_OPERATION_REC_PTR */ +/* OUTPUT: */ +/* TIDR_RESULT (ZTRUE FOR SUCCESS AND ZFALSE OTHERWISE) */ +/* TIDR_CONTAINERHEAD (HEADER OF CONTAINER) */ +/* TIDR_CONTAINERPTR (POINTER TO CONTAINER HEADER) */ +/* */ +/* DESCRIPTION: */ +/* THE FREE AREA OF THE CONTAINER WILL BE CALCULATED. IF IT IS */ +/* LARGER THAN OR EQUAL THE ELEMENT LENGTH. THE ELEMENT WILL BE */ +/* INSERT IN THE CONTAINER AND CONTAINER HEAD WILL BE UPDATED. */ +/* THIS ROUTINE ALWAYS DEALS WITH ONLY ONE CONTAINER AND DO NEVER */ +/* START ANYTHING OUTSIDE OF THIS CONTAINER. */ +/* */ +/* SHORT FORM: IDR */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::insertContainer(Signal* signal) +{ + Uint32 tidrContainerlen; + Uint32 tidrConfreelen; + Uint32 tidrNextSide; + Uint32 tidrNextConLen; + Uint32 tidrIndex; + Uint32 tidrInputIndex; + Uint32 tidrContLen; + Uint32 guard26; + + tidrResult = ZFALSE; + tidrContainerptr = (tidrPageindex << ZSHIFT_PLUS) - (tidrPageindex << ZSHIFT_MINUS); + tidrContainerptr = tidrContainerptr + ZHEAD_SIZE; + /* --------------------------------------------------------------------------------- */ + /* CALCULATE THE POINTER TO THE ELEMENT TO BE INSERTED AND THE POINTER TO THE */ + /* CONTAINER HEADER OF THE OTHER SIDE OF THE BUFFER. */ + /* --------------------------------------------------------------------------------- */ + if (tidrForward == ZTRUE) { + jam(); + tidrNextSide = tidrContainerptr + (ZBUF_SIZE - ZCON_HEAD_SIZE); + arrGuard(tidrNextSide + 1, 2048); + tidrContainerhead = idrPageptr.p->word32[tidrContainerptr]; + tidrContainerlen = tidrContainerhead >> 26; + tidrIndex = tidrContainerptr + tidrContainerlen; + } else { + jam(); + tidrNextSide = tidrContainerptr; + tidrContainerptr = tidrContainerptr + (ZBUF_SIZE - ZCON_HEAD_SIZE); + arrGuard(tidrContainerptr + 1, 2048); + tidrContainerhead = idrPageptr.p->word32[tidrContainerptr]; + tidrContainerlen = tidrContainerhead >> 26; + tidrIndex = (tidrContainerptr - tidrContainerlen) + (ZCON_HEAD_SIZE - 1); + }//if + if (tidrContainerlen > (ZBUF_SIZE - 3)) { + return; + }//if + tidrConfreelen = ZBUF_SIZE - tidrContainerlen; + /* --------------------------------------------------------------------------------- */ + /* WE CALCULATE THE TOTAL LENGTH THE CONTAINER CAN EXPAND TO */ + /* THIS INCLUDES THE OTHER SIDE OF THE BUFFER IF POSSIBLE TO EXPAND THERE. */ + /* --------------------------------------------------------------------------------- */ + if (((tidrContainerhead >> 10) & 1) == 0) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* WE HAVE NOT EXPANDED TO THE ENTIRE BUFFER YET. WE CAN THUS READ THE OTHER */ + /* SIDE'S CONTAINER HEADER TO READ HIS LENGTH. */ + /* --------------------------------------------------------------------------------- */ + tidrNextConLen = idrPageptr.p->word32[tidrNextSide] >> 26; + tidrConfreelen = tidrConfreelen - tidrNextConLen; + if (tidrConfreelen > ZBUF_SIZE) { + ndbrequire(false); + /* --------------------------------------------------------------------------------- */ + /* THE BUFFERS ARE PLACED ON TOP OF EACH OTHER. THIS SHOULD NEVER OCCUR. */ + /* --------------------------------------------------------------------------------- */ + return; + }//if + } else { + jam(); + tidrNextConLen = 1; /* INDICATE OTHER SIDE IS NOT PART OF FREE LIST */ + }//if + if (tidrConfreelen < fragrecptr.p->elementLength) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THE CONTAINER COULD NOT BE EXPANDED TO FIT THE NEW ELEMENT. WE HAVE TO */ + /* RETURN AND FIND A NEW CONTAINER TO INSERT IT INTO. */ + /* --------------------------------------------------------------------------------- */ + return; + }//if + tidrContainerlen = tidrContainerlen + fragrecptr.p->elementLength; + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + datapageptr.p = idrPageptr.p; + cundoElemIndex = tidrContainerptr; + cundoinfolength = 1; + undoWritingProcess(signal); + }//if + if (tidrNextConLen == 0) { + /* EACH SIDE OF THE BUFFER WHICH BELONG TO A FREE */ + /* LIST, HAS ZERO AS LENGTH. */ + if (tidrContainerlen > ZUP_LIMIT) { + dbgWord32(idrPageptr, tidrContainerptr, idrPageptr.p->word32[tidrContainerptr] | (1 << 10)); + idrPageptr.p->word32[tidrContainerptr] = idrPageptr.p->word32[tidrContainerptr] | (1 << 10); + tslUpdateHeader = ZFALSE; + tslPageindex = tidrPageindex; + slPageptr.p = idrPageptr.p; + if (tidrForward == ZTRUE) { + jam(); + seizeRightlist(signal); /* REMOVE THE RIGHT SIDE OF THE BUFFER FROM THE LIST */ + } else { + jam(); + /* OF THE FREE CONTAINERS */ + seizeLeftlist(signal); /* REMOVE THE LEFT SIDE OF THE BUFFER FROM THE LIST */ + }//if + }//if + }//if + /* OF THE FREE CONTAINERS */ + /* --------------------------------------------------------------------------------- */ + /* WE HAVE NOW FOUND A FREE SPOT IN THE CURRENT CONTAINER. WE INSERT THE */ + /* ELEMENT HERE. THE ELEMENT CONTAINS A HEADER, A LOCAL KEY AND A TUPLE KEY. */ + /* BEFORE INSERTING THE ELEMENT WE WILL UPDATE THE OPERATION RECORD WITH THE */ + /* DATA CONCERNING WHERE WE INSERTED THE ELEMENT. THIS MAKES IT EASY TO FIND */ + /* THIS INFORMATION WHEN WE RETURN TO UPDATE THE LOCAL KEY OR RETURN TO COMMIT */ + /* OR ABORT THE INSERT. IF NO OPERATION RECORD EXIST IT MEANS THAT WE ARE */ + /* PERFORMING THIS AS A PART OF THE EXPAND OR SHRINK PROCESS. */ + /* --------------------------------------------------------------------------------- */ + if (idrOperationRecPtr.i != RNIL) { + jam(); + idrOperationRecPtr.p->elementIsforward = tidrForward; + idrOperationRecPtr.p->elementPage = idrPageptr.i; + idrOperationRecPtr.p->elementContainer = tidrContainerptr; + idrOperationRecPtr.p->elementPointer = tidrIndex; + }//if + /* --------------------------------------------------------------------------------- */ + /* WE CHOOSE TO UNDO LOG INSERTS BY WRITING THE BEFORE VALUE TO THE UNDO LOG. */ + /* WE COULD ALSO HAVE DONE THIS BY WRITING THIS BEFORE VALUE WHEN DELETING */ + /* ELEMENTS. WE CHOOSE TO PUT IT HERE SINCE WE THEREBY ENSURE THAT WE ALWAYS */ + /* UNDO LOG ALL WRITES TO PAGE MEMORY. IT SHOULD BE EASIER TO MAINTAIN SUCH A */ + /* STRUCTURE. IT IS RATHER DIFFICULT TO MAINTAIN A LOGICAL STRUCTURE WHERE */ + /* DELETES ARE INSERTS AND INSERTS ARE PURELY DELETES. */ + /* --------------------------------------------------------------------------------- */ + if (fragrecptr.p->createLcp == ZTRUE) { + if (tidrForward == ZTRUE) { + cundoElemIndex = tidrIndex; + } else { + cundoElemIndex = (tidrIndex + 1) - fragrecptr.p->elementLength; + }//if + cundoinfolength = fragrecptr.p->elementLength; + undoWritingProcess(signal); + }//if + dbgWord32(idrPageptr, tidrIndex, tidrElemhead); + idrPageptr.p->word32[tidrIndex] = tidrElemhead; /* INSERTS THE HEAD OF THE ELEMENT */ + tidrIndex += tidrForward; + guard26 = fragrecptr.p->localkeylen - 1; + arrGuard(guard26, 2); + for (tidrInputIndex = 0; tidrInputIndex <= guard26; tidrInputIndex++) { + dbgWord32(idrPageptr, tidrIndex, clocalkey[tidrInputIndex]); + arrGuard(tidrIndex, 2048); + idrPageptr.p->word32[tidrIndex] = clocalkey[tidrInputIndex]; /* INSERTS LOCALKEY */ + tidrIndex += tidrForward; + }//for + guard26 = tidrKeyLen - 1; + arrGuard(guard26, 8); + for (tidrInputIndex = 0; tidrInputIndex <= guard26; tidrInputIndex++) { + dbgWord32(idrPageptr, tidrIndex, ckeys[tidrInputIndex]); + arrGuard(tidrIndex, 2048); + idrPageptr.p->word32[tidrIndex] = ckeys[tidrInputIndex]; /* INSERTS TUPLE KEY */ + tidrIndex += tidrForward; + }//for + tidrContLen = idrPageptr.p->word32[tidrContainerptr] << 6; + tidrContLen = tidrContLen >> 6; + dbgWord32(idrPageptr, tidrContainerptr, (tidrContainerlen << 26) | tidrContLen); + idrPageptr.p->word32[tidrContainerptr] = (tidrContainerlen << 26) | tidrContLen; + tidrResult = ZTRUE; +}//Dbacc::insertContainer() + +/* --------------------------------------------------------------------------------- */ +/* ADDNEWCONTAINER */ +/* INPUT: */ +/* TANC_CONTAINERPTR */ +/* ANC_PAGEPTR */ +/* TANC_NEXT */ +/* TANC_PAGEINDEX */ +/* TANC_BUF_TYPE */ +/* TANC_PAGEID */ +/* OUTPUT: */ +/* NONE */ +/* */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::addnewcontainer(Signal* signal) +{ + Uint32 tancTmp1; + + if (fragrecptr.p->createLcp == ZTRUE) { + cundoElemIndex = tancContainerptr; + datapageptr.p = ancPageptr.p; + cundoinfolength = 2; + undoWritingProcess(signal); /* WHEN UNDO PROCESS HAS STARTED, */ + }//if + /* THE OLD DATA IS STORED ON AN UNDO PAGE */ + /* --------------------------------------------------------------------------------- */ + /* KEEP LENGTH INFORMATION IN BIT 26-31. */ + /* SET BIT 9 INDICATING IF NEXT BUFFER IN THE SAME PAGE USING TANC_NEXT. */ + /* SET TYPE OF NEXT CONTAINER IN BIT 7-8. */ + /* SET PAGE INDEX OF NEXT CONTAINER IN BIT 0-6. */ + /* KEEP INDICATOR OF OWNING OTHER SIDE OF BUFFER IN BIT 10. */ + /* --------------------------------------------------------------------------------- */ + tancTmp1 = ancPageptr.p->word32[tancContainerptr] >> 10; + tancTmp1 = tancTmp1 << 1; + tancTmp1 = tancTmp1 | tancNext; + tancTmp1 = tancTmp1 << 2; + tancTmp1 = tancTmp1 | tancBufType; /* TYPE OF THE NEXT CONTAINER */ + tancTmp1 = tancTmp1 << 7; + tancTmp1 = tancTmp1 | tancPageindex; + dbgWord32(ancPageptr, tancContainerptr, tancTmp1); + ancPageptr.p->word32[tancContainerptr] = tancTmp1; /* HEAD OF THE CONTAINER IS UPDATED */ + dbgWord32(ancPageptr, tancContainerptr + 1, tancPageid); + ancPageptr.p->word32[tancContainerptr + 1] = tancPageid; +}//Dbacc::addnewcontainer() + +/* --------------------------------------------------------------------------------- */ +/* GETFREELIST */ +/* INPUT: */ +/* GFL_PAGEPTR (POINTER TO A PAGE RECORD). */ +/* OUTPUT: */ +/* TGFL_PAGEINDEX(POINTER TO A FREE BUFFER IN THE FREEPAGE), AND */ +/* TGFL_BUF_TYPE( TYPE OF THE FREE BUFFER). */ +/* DESCRIPTION: SEARCHS IN THE FREE LIST OF THE FREE BUFFER IN THE PAGE HEAD */ +/* (WORD32(1)),AND RETURN ADDRESS OF A FREE BUFFER OR NIL. */ +/* THE FREE BUFFER CAN BE A RIGHT CONTAINER OR A LEFT ONE */ +/* THE KIND OF THE CONTAINER IS NOTED BY TGFL_BUF_TYPE. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::getfreelist(Signal* signal) +{ + Uint32 tgflTmp; + + tgflTmp = gflPageptr.p->word32[ZPOS_EMPTY_LIST]; + tgflPageindex = (tgflTmp >> 7) & 0x7f; /* LEFT FREE LIST */ + tgflBufType = ZLEFT; + if (tgflPageindex == ZEMPTYLIST) { + jam(); + tgflPageindex = tgflTmp & 0x7f; /* RIGHT FREE LIST */ + tgflBufType = ZRIGHT; + }//if + ndbrequire(tgflPageindex <= ZEMPTYLIST); +}//Dbacc::getfreelist() + +/* --------------------------------------------------------------------------------- */ +/* INCREASELISTCONT */ +/* INPUT: */ +/* ILC_PAGEPTR PAGE POINTER TO INCREASE NUMBER OF CONTAINERS IN */ +/* A CONTAINER OF AN OVERFLOW PAGE (FREEPAGEPTR) IS ALLOCATED, NR OF */ +/* ALLOCATED CONTAINER HAVE TO BE INCRESE BY ONE . */ +/* IF THE NUMBER OF ALLOCATED CONTAINERS IS ABOVE THE FREE LIMIT WE WILL */ +/* REMOVE THE PAGE FROM THE FREE LIST. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::increaselistcont(Signal* signal) +{ + OverflowRecordPtr ilcOverflowRecPtr; + + dbgWord32(ilcPageptr, ZPOS_ALLOC_CONTAINERS, ilcPageptr.p->word32[ZPOS_ALLOC_CONTAINERS] + 1); + ilcPageptr.p->word32[ZPOS_ALLOC_CONTAINERS] = ilcPageptr.p->word32[ZPOS_ALLOC_CONTAINERS] + 1; + if (ilcPageptr.p->word32[ZPOS_ALLOC_CONTAINERS] > ZFREE_LIMIT) { + if (ilcPageptr.p->word32[ZPOS_OVERFLOWREC] != RNIL) { + jam(); + ilcOverflowRecPtr.i = ilcPageptr.p->word32[ZPOS_OVERFLOWREC]; + dbgWord32(ilcPageptr, ZPOS_OVERFLOWREC, RNIL); + ilcPageptr.p->word32[ZPOS_OVERFLOWREC] = RNIL; + ptrCheckGuard(ilcOverflowRecPtr, coverflowrecsize, overflowRecord); + tfoOverflowRecPtr = ilcOverflowRecPtr; + takeRecOutOfFreeOverpage(signal); + rorOverflowRecPtr = ilcOverflowRecPtr; + releaseOverflowRec(signal); + }//if + }//if +}//Dbacc::increaselistcont() + +/* --------------------------------------------------------------------------------- */ +/* SEIZE_LEFTLIST */ +/* INPUT: */ +/* TSL_PAGEINDEX PAGE INDEX OF CONTAINER TO SEIZE */ +/* SL_PAGEPTR PAGE POINTER OF CONTAINER TO SEIZE */ +/* TSL_UPDATE_HEADER SHOULD WE UPDATE THE CONTAINER HEADER */ +/* */ +/* OUTPUT: */ +/* NONE */ +/* DESCRIPTION: THE BUFFER NOTED BY TSL_PAGEINDEX WILL BE REMOVED FROM THE */ +/* LIST OF LEFT FREE CONTAINER, IN THE HEADER OF THE PAGE */ +/* (FREEPAGEPTR). PREVIOUS AND NEXT BUFFER OF REMOVED BUFFER */ +/* WILL BE UPDATED. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::seizeLeftlist(Signal* signal) +{ + Uint32 tsllTmp1; + Uint32 tsllNewHead; + Uint32 tsllHeadIndex; + Uint32 tsllTmp; + + tsllHeadIndex = ((tslPageindex << ZSHIFT_PLUS) - (tslPageindex << ZSHIFT_MINUS)) + ZHEAD_SIZE; + arrGuard(tsllHeadIndex + 1, 2048); + tslNextfree = slPageptr.p->word32[tsllHeadIndex]; + tslPrevfree = slPageptr.p->word32[tsllHeadIndex + 1]; + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + datapageptr.p = slPageptr.p; + cundoElemIndex = tsllHeadIndex; + cundoinfolength = 2; + undoWritingProcess(signal); + }//if + if (fragrecptr.p->createLcp == ZTRUE) { + cundoElemIndex = ZPOS_EMPTY_LIST; + cundoinfolength = 2; + undoWritingProcess(signal); + }//if + if (tslPrevfree == ZEMPTYLIST) { + jam(); + /* UPDATE FREE LIST OF LEFT CONTAINER IN PAGE HEAD */ + tsllTmp1 = slPageptr.p->word32[ZPOS_EMPTY_LIST]; + tsllTmp = tsllTmp1 & 0x7f; + tsllTmp1 = (tsllTmp1 >> 14) << 14; + tsllTmp1 = (tsllTmp1 | (tslNextfree << 7)) | tsllTmp; + dbgWord32(slPageptr, ZPOS_EMPTY_LIST, tsllTmp1); + slPageptr.p->word32[ZPOS_EMPTY_LIST] = tsllTmp1; + } else { + ndbrequire(tslPrevfree < ZEMPTYLIST); + jam(); + tsllTmp = ((tslPrevfree << ZSHIFT_PLUS) - (tslPrevfree << ZSHIFT_MINUS)) + ZHEAD_SIZE; + if (fragrecptr.p->createLcp == ZTRUE) { + cundoElemIndex = tsllTmp; + cundoinfolength = 1; + undoWritingProcess(signal); + }//if + dbgWord32(slPageptr, tsllTmp, tslNextfree); + slPageptr.p->word32[tsllTmp] = tslNextfree; + }//if + if (tslNextfree < ZEMPTYLIST) { + jam(); + tsllTmp = (((tslNextfree << ZSHIFT_PLUS) - (tslNextfree << ZSHIFT_MINUS)) + ZHEAD_SIZE) + 1; + if (fragrecptr.p->createLcp == ZTRUE) { + cundoElemIndex = tsllTmp; + cundoinfolength = 1; + undoWritingProcess(signal); + }//if + dbgWord32(slPageptr, tsllTmp, tslPrevfree); + slPageptr.p->word32[tsllTmp] = tslPrevfree; + } else { + ndbrequire(tslNextfree == ZEMPTYLIST); + jam(); + }//if + /* --------------------------------------------------------------------------------- */ + /* IF WE ARE UPDATING THE HEADER WE ARE CREATING A NEW CONTAINER IN THE PAGE. */ + /* TO BE ABLE TO FIND ALL LOCKED ELEMENTS WE KEEP ALL CONTAINERS IN LINKED */ + /* LISTS IN THE PAGE. */ + /* */ + /* ZPOS_EMPTY_LIST CONTAINS A NEXT POINTER IN BIT 16-22 THAT REFERS TO THE */ + /* FIRST CONTAINER IN A LIST OF USED RIGHT CONTAINERS IN THE PAGE. */ + /* ZPOS_EMPTY_LIST CONTAINS A NEXT POINTER IN BIT 23-29 THAT REFERS TO THE */ + /* FIRST CONTAINER IN A LIST OF USED LEFT CONTAINERS IN THE PAGE. */ + /* EACH CONTAINER IN THE LIST CONTAINS A NEXT POINTER IN BIT 11-17 AND IT */ + /* CONTAINS A PREVIOUS POINTER IN BIT 18-24. */ + /* WE ALSO SET BIT 25 TO INDICATE THAT IT IS A CONTAINER HEADER. */ + /* --------------------------------------------------------------------------------- */ + if (tslUpdateHeader == ZTRUE) { + jam(); + tslNextfree = (slPageptr.p->word32[ZPOS_EMPTY_LIST] >> 23) & 0x7f; + tsllNewHead = ZCON_HEAD_SIZE; + tsllNewHead = ((tsllNewHead << 8) + ZEMPTYLIST) + (1 << 7); + tsllNewHead = (tsllNewHead << 7) + tslNextfree; + tsllNewHead = tsllNewHead << 11; + dbgWord32(slPageptr, tsllHeadIndex, tsllNewHead); + slPageptr.p->word32[tsllHeadIndex] = tsllNewHead; + tsllTmp = slPageptr.p->word32[ZPOS_EMPTY_LIST] & 0xc07fffff; + tsllTmp = tsllTmp | (tslPageindex << 23); + dbgWord32(slPageptr, ZPOS_EMPTY_LIST, tsllTmp); + slPageptr.p->word32[ZPOS_EMPTY_LIST] = tsllTmp; + if (tslNextfree < ZEMPTYLIST) { + jam(); + tsllTmp = ((tslNextfree << ZSHIFT_PLUS) - (tslNextfree << ZSHIFT_MINUS)) + ZHEAD_SIZE; + if (fragrecptr.p->createLcp == ZTRUE) { + cundoElemIndex = tsllTmp; + cundoinfolength = 1; + undoWritingProcess(signal); + }//if + tsllTmp1 = slPageptr.p->word32[tsllTmp] & 0xfe03ffff; + tsllTmp1 = tsllTmp1 | (tslPageindex << 18); + dbgWord32(slPageptr, tsllTmp, tsllTmp1); + slPageptr.p->word32[tsllTmp] = tsllTmp1; + } else { + ndbrequire(tslNextfree == ZEMPTYLIST); + jam(); + }//if + }//if + ilcPageptr.p = slPageptr.p; + increaselistcont(signal); +}//Dbacc::seizeLeftlist() + +/* --------------------------------------------------------------------------------- */ +/* SEIZE_RIGHTLIST */ +/* DESCRIPTION: THE BUFFER NOTED BY TSL_PAGEINDEX WILL BE REMOVED FROM THE */ +/* LIST OF RIGHT FREE CONTAINER, IN THE HEADER OF THE PAGE */ +/* (SL_PAGEPTR). PREVIOUS AND NEXT BUFFER OF REMOVED BUFFER */ +/* WILL BE UPDATED. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::seizeRightlist(Signal* signal) +{ + Uint32 tsrlTmp1; + Uint32 tsrlNewHead; + Uint32 tsrlHeadIndex; + Uint32 tsrlTmp; + + tsrlHeadIndex = ((tslPageindex << ZSHIFT_PLUS) - (tslPageindex << ZSHIFT_MINUS)) + ((ZHEAD_SIZE + ZBUF_SIZE) - ZCON_HEAD_SIZE); + arrGuard(tsrlHeadIndex + 1, 2048); + tslNextfree = slPageptr.p->word32[tsrlHeadIndex]; + tslPrevfree = slPageptr.p->word32[tsrlHeadIndex + 1]; + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + datapageptr.p = slPageptr.p; + cundoElemIndex = tsrlHeadIndex; + cundoinfolength = 2; + undoWritingProcess(signal); + }//if + if (fragrecptr.p->createLcp == ZTRUE) { + cundoElemIndex = ZPOS_EMPTY_LIST; + cundoinfolength = 2; + undoWritingProcess(signal); + }//if + if (tslPrevfree == ZEMPTYLIST) { + jam(); + tsrlTmp = slPageptr.p->word32[ZPOS_EMPTY_LIST]; + dbgWord32(slPageptr, ZPOS_EMPTY_LIST, ((tsrlTmp >> 7) << 7) | tslNextfree); + slPageptr.p->word32[ZPOS_EMPTY_LIST] = ((tsrlTmp >> 7) << 7) | tslNextfree; + } else { + ndbrequire(tslPrevfree < ZEMPTYLIST); + jam(); + tsrlTmp = ((tslPrevfree << ZSHIFT_PLUS) - (tslPrevfree << ZSHIFT_MINUS)) + ((ZHEAD_SIZE + ZBUF_SIZE) - ZCON_HEAD_SIZE); + if (fragrecptr.p->createLcp == ZTRUE) { + cundoElemIndex = tsrlTmp; + cundoinfolength = 1; + undoWritingProcess(signal); + }//if + dbgWord32(slPageptr, tsrlTmp, tslNextfree); + slPageptr.p->word32[tsrlTmp] = tslNextfree; + }//if + if (tslNextfree < ZEMPTYLIST) { + jam(); + tsrlTmp = ((tslNextfree << ZSHIFT_PLUS) - (tslNextfree << ZSHIFT_MINUS)) + ((ZHEAD_SIZE + ZBUF_SIZE) - (ZCON_HEAD_SIZE - 1)); + if (fragrecptr.p->createLcp == ZTRUE) { + cundoElemIndex = tsrlTmp; + cundoinfolength = 1; + undoWritingProcess(signal); + }//if + dbgWord32(slPageptr, tsrlTmp, tslPrevfree); + slPageptr.p->word32[tsrlTmp] = tslPrevfree; + } else { + ndbrequire(tslNextfree == ZEMPTYLIST); + jam(); + }//if + /* --------------------------------------------------------------------------------- */ + /* IF WE ARE UPDATING THE HEADER WE ARE CREATING A NEW CONTAINER IN THE PAGE. */ + /* TO BE ABLE TO FIND ALL LOCKED ELEMENTS WE KEEP ALL CONTAINERS IN LINKED */ + /* LISTS IN THE PAGE. */ + /* */ + /* ZPOS_EMPTY_LIST CONTAINS A NEXT POINTER IN BIT 16-22 THAT REFERS TO THE */ + /* FIRST CONTAINER IN A LIST OF USED RIGHT CONTAINERS IN THE PAGE. */ + /* ZPOS_EMPTY_LIST CONTAINS A NEXT POINTER IN BIT 23-29 THAT REFERS TO THE */ + /* FIRST CONTAINER IN A LIST OF USED LEFT CONTAINERS IN THE PAGE. */ + /* EACH CONTAINER IN THE LIST CONTAINS A NEXT POINTER IN BIT 11-17 AND IT */ + /* CONTAINS A PREVIOUS POINTER IN BIT 18-24. */ + /* --------------------------------------------------------------------------------- */ + if (tslUpdateHeader == ZTRUE) { + jam(); + tslNextfree = (slPageptr.p->word32[ZPOS_EMPTY_LIST] >> 16) & 0x7f; + tsrlNewHead = ZCON_HEAD_SIZE; + tsrlNewHead = ((tsrlNewHead << 8) + ZEMPTYLIST) + (1 << 7); + tsrlNewHead = (tsrlNewHead << 7) + tslNextfree; + tsrlNewHead = tsrlNewHead << 11; + dbgWord32(slPageptr, tsrlHeadIndex, tsrlNewHead); + slPageptr.p->word32[tsrlHeadIndex] = tsrlNewHead; + tsrlTmp = slPageptr.p->word32[ZPOS_EMPTY_LIST] & 0xff80ffff; + dbgWord32(slPageptr, ZPOS_EMPTY_LIST, tsrlTmp | (tslPageindex << 16)); + slPageptr.p->word32[ZPOS_EMPTY_LIST] = tsrlTmp | (tslPageindex << 16); + if (tslNextfree < ZEMPTYLIST) { + jam(); + tsrlTmp = ((tslNextfree << ZSHIFT_PLUS) - (tslNextfree << ZSHIFT_MINUS)) + ((ZHEAD_SIZE + ZBUF_SIZE) - ZCON_HEAD_SIZE); + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + cundoElemIndex = tsrlTmp; + cundoinfolength = 1; + undoWritingProcess(signal); + }//if + tsrlTmp1 = slPageptr.p->word32[tsrlTmp] & 0xfe03ffff; + dbgWord32(slPageptr, tsrlTmp, tsrlTmp1 | (tslPageindex << 18)); + slPageptr.p->word32[tsrlTmp] = tsrlTmp1 | (tslPageindex << 18); + } else { + ndbrequire(tslNextfree == ZEMPTYLIST); + jam(); + }//if + }//if + ilcPageptr.p = slPageptr.p; + increaselistcont(signal); +}//Dbacc::seizeRightlist() + + +//--------------------------------------------------------------------------------- +// ALLOC_SPECIFIC_LONG_OVERFLOW_PAGE +// +// DESCRIPTION: ALLOCATES A LONG OVER FLOW PAGE AND PUTS IT IN A SPECIFIED +// DIRINDEX. THIS IS TO SUPPORT AN UNDO_DELETE AFTER AN +// UNDO_INSERT ON THE SAME LONG KEY IN A LCP. +// UNDO_INSERT ONLY HAVE A REFERENCE TO THE KEY AND TO MAKE +// IT POSSIBLE TO DELETE THE KEY, THE REFERENCE MUST BE +// ACCURATE, WHICH MEANS THE KEY MUST BE SAVED ON THE SAME +// PLACE IT WAS DELETED FROM. +//--------------------------------------------------------------------------------- +void Dbacc::allocSpecificLongOverflowPage(Signal* signal) +{ + DirRangePtr aloDirRangePtr; + DirectoryarrayPtr aloOverflowDirptr; + + if ((cfirstfreepage == RNIL) && + (cfreepage >= cpagesize)) { + jam(); + zpagesize_error("Dbacc::allocSpecificLongOverflowPage"); + tresult = ZPAGESIZE_ERROR; + return; + } + + if ((cfirstfreedir == RNIL) && + (cdirarraysize <= cdirmemory)) { + jam(); + tresult = ZDIRSIZE_ERROR; + return; + } + + tmpP = taslpDirIndex; + aloDirRangePtr.i = fragrecptr.p->overflowdir; + tmpP2 = tmpP >> 8; + tmpP = tmpP & 0xff; + ptrCheckGuard(aloDirRangePtr, cdirrangesize, dirRange); + arrGuard(tmpP2, 256); + + if (aloDirRangePtr.p->dirArray[tmpP2] == RNIL) { + jam(); + seizeDirectory(signal); + if (tresult > ZLIMIT_OF_ERROR) { + jam(); + sendSystemerror(signal); + return; + } + aloDirRangePtr.p->dirArray[tmpP2] = sdDirptr.i; + } else { + jam(); + sdDirptr.i = RNIL; + ptrNull(sdDirptr); + } + + aloOverflowDirptr.i = aloDirRangePtr.p->dirArray[tmpP2]; + ptrCheckGuard(aloOverflowDirptr, cdirarraysize, directoryarray); + seizePage(signal); + if (tresult > ZLIMIT_OF_ERROR) { + jam(); + sendSystemerror(signal); + return; + }//if + + if (aloOverflowDirptr.p->pagep[tmpP] != RNIL) { + jam(); + sendSystemerror(signal); + return; + } + + aloOverflowDirptr.p->pagep[tmpP] = spPageptr.i; + iloPageptr.p = spPageptr.p; + iloPageptr.i = spPageptr.i; + tiloIndex = taslpDirIndex; + initLongOverpage(signal); + aslpPageptr.i = spPageptr.i; + aslpPageptr.p = spPageptr.p; +}//Dbacc::allocSpecificLongOverflowPage + +/* --------------------------------------------------------------------------------- */ +/* ALLOC_LONG_OVERFLOW_PAGE */ +/* DESCRIPTION: */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::allocLongOverflowPage(Signal* signal) +{ + DirRangePtr aloDirRangePtr; + DirectoryarrayPtr aloOverflowDirptr; + OverflowRecordPtr aloOverflowRecPtr; + Uint32 taloIndex; + + if ((cfirstfreepage == RNIL) && + (cfreepage >= cpagesize)) { + jam(); + zpagesize_error("Dbacc::allocLongOverflowPage"); + tresult = ZPAGESIZE_ERROR; + return; + }//if + if ((cfirstfreedir == RNIL) && + (cdirarraysize <= cdirmemory)) { + jam(); + tresult = ZDIRSIZE_ERROR; + return; + }//if + if (fragrecptr.p->firstFreeDirindexRec != RNIL) { + jam(); + aloOverflowRecPtr.i = fragrecptr.p->firstFreeDirindexRec; + ptrCheckGuard(aloOverflowRecPtr, coverflowrecsize, overflowRecord); + troOverflowRecPtr.p = aloOverflowRecPtr.p; + takeRecOutOfFreeOverdir(signal); + taloIndex = aloOverflowRecPtr.p->dirindex; + rorOverflowRecPtr = aloOverflowRecPtr; + releaseOverflowRec(signal); + } else { + jam(); + taloIndex = fragrecptr.p->lastOverIndex; + fragrecptr.p->lastOverIndex++; + }//if + tmpP = taloIndex; + aloDirRangePtr.i = fragrecptr.p->overflowdir; + tmpP2 = tmpP >> 8; + tmpP = tmpP & 0xff; + ptrCheckGuard(aloDirRangePtr, cdirrangesize, dirRange); + arrGuard(tmpP2, 256); + if (aloDirRangePtr.p->dirArray[tmpP2] == RNIL) { + jam(); + seizeDirectory(signal); + ndbrequire(tresult <= ZLIMIT_OF_ERROR); + aloDirRangePtr.p->dirArray[tmpP2] = sdDirptr.i; + } else { + jam(); + sdDirptr.i = RNIL; + ptrNull(sdDirptr); + }//if + aloOverflowDirptr.i = aloDirRangePtr.p->dirArray[tmpP2]; + ptrCheckGuard(aloOverflowDirptr, cdirarraysize, directoryarray); + seizePage(signal); + ndbrequire(tresult <= ZLIMIT_OF_ERROR); + aloOverflowDirptr.p->pagep[tmpP] = spPageptr.i; + iloPageptr = spPageptr; + tiloIndex = taloIndex; + initLongOverpage(signal); + alpPageptr = spPageptr; + ipaPagePtr = spPageptr; + tipaArrayPos = 3; + insertPageArrayList(signal); +}//Dbacc::allocLongOverflowPage() + +/* --------------------------------------------------------------------------------- */ +/* GET_LONG_KEY_PAGE */ +/* DESCRIPTION: SEARCH FOR A FREE OVERFLOW PAGE TO STORE A LONG KEY. */ +/* LONG_KEY_PAGE_PTR IS RETURNED. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::getLongKeyPage(Signal* signal) +{ + LongKeyPage *glkPage; + + jam(); + + Uint32 tglkLongIndex = 0; + + ndbrequire(operationRecPtr.p->tupkeylen <= ZWORDS_IN_PAGE - ZHEAD_SIZE); + + // Do not look in longKeyPageArray[tglkLongIndex] where the pages are to small. + if(operationRecPtr.p->tupkeylen < 128) { + jam(); + tglkLongIndex = 0; + } else { + jam(); + tglkLongIndex = (operationRecPtr.p->tupkeylen - 128) / 512; + }//if + + // Go through the longKeyPageArray and search for a page. + for (; tglkLongIndex <= ZMAX_LONG_KEY_ARRAY_INDEX; tglkLongIndex++) { + jam(); + glkPageptr.i = fragrecptr.p->longKeyPageArray[tglkLongIndex]; + + if (glkPageptr.i != RNIL) { + // A page is found. + jam(); + do { + ptrCheckGuard(glkPageptr, cpagesize, page8); + glkPage = (LongKeyPage *) &glkPageptr.p->word32[0]; + + // Check page if there is enough memory available. Accept only page + // with free_area > tupkeylen, this leaves at least one word for eventually + // an increase in the index area. + if (glkPage->header.freeArea > operationRecPtr.p->tupkeylen){ + // The page found is OK + jam(); + return; + } else { + // Not enough space in page, look in the next page if not RNIL, + // otherwise continue with for-loop. + jam(); + glkPageptr.i = glkPage->header.nextPage; + } + }//do + while (glkPageptr.i != RNIL); + }//if + }//for + + // No page with enough space was available, allocate a new page! + jam(); + allocLongOverflowPage(signal); + glkPageptr = alpPageptr; +}//Dbacc::getLongKeyPage() + +/* --------------------------------------------------------------------------------- */ +/* INIT_LONG_OVERPAGE */ +/* INPUT. ILO_PAGEPTR, POINTER TO AN OVERFLOW PAGE RECORD */ +/* DESCRIPTION: CONTAINERS AND FREE LISTS OF THE PAGE, GET INITIALE VALUE */ +/* ACCORDING TO LH3 AND PAGE STRUCTOR DISACRIPTION OF NDBACC BLOCK */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initLongOverpage(Signal* signal) +{ + iloPageptr.p->word32[ZPOS_PAGE_ID] = tiloIndex; + iloPageptr.p->word32[ZPOS_PAGE_TYPE] = ZLONG_PAGE_TYPE << ZPOS_PAGE_TYPE_BIT; + iloPageptr.p->word32[ZPOS_NO_ELEM_IN_PAGE] = 0; + iloPageptr.p->word32[ZPOS_OVERFLOWREC] = RNIL; + iloPageptr.p->word32[ZPOS_FREE_AREA_IN_PAGE] = ZWORDS_IN_PAGE - ZHEAD_SIZE; + iloPageptr.p->word32[ZPOS_LAST_INDEX] = 0; + iloPageptr.p->word32[ZPOS_INSERT_INDEX] = ZHEAD_SIZE; + iloPageptr.p->word32[ZPOS_ARRAY_POS] = ZDEFAULT_LIST; + iloPageptr.p->word32[ZPOS_NEXT_FREE_INDEX] = 0; + iloPageptr.p->word32[ZPOS_NEXT_PAGE] = RNIL; + iloPageptr.p->word32[ZPOS_PREV_PAGE] = RNIL; + iloPageptr.p->word32[12] = 0; + iloPageptr.p->word32[13] = 0; + iloPageptr.p->word32[14] = 0; + iloPageptr.p->word32[15] = 0; + // Initialize free indexes + for (int i = 1; i < (ZWORDS_IN_PAGE - ZHEAD_SIZE); i++) + iloPageptr.p->word32[ZWORDS_IN_PAGE - i] = i + 1; +}//Dbacc::initLongOverpage() + +//--------------------------------------------------------------------------------- +// STORE_LONG_KEYS_AT_POS +// +// INPUT: SLKAP_PAGEPTR +// SLKAP_COPY_PAGEPTR +// TSLKAP_KEY_LEN +// TSLKAP_PAGE_INDEX +// +// DESCRIPTION: A LONG ELEMENT IS STORED ON A LONG_KEY_PAGE AT A +// SPECIFIC POSITION. THIS FUNCTION IS USED BY UNDO_DELETE. +//--------------------------------------------------------------------------------- +void Dbacc::storeLongKeysAtPos(Signal* signal) +{ + Uint32 tslkapHighestIndex; + Uint32 tslkapLastSize; + Uint32 tslkapInsertIndex; + Uint32 tslkapIndexIncreaseSize; + Uint32 tslkapTmp; + + LongKeyPage *slkapPage; + + jam(); + slkapPage = (LongKeyPage *) &slkapPageptr.p->word32[0]; + +#ifdef VM_TRACE + checkIndexInLongKeyPage(slkapPageptr.i, "storeLongKeysAtPos"); +#endif + + // if (csystemRestart != ZTRUE) { + if (cundoLogActive != ZTRUE) { + //------------------------------------------------------------- + // This function is only allowed to be called during + // undolog execution. + //------------------------------------------------------------- + jam(); + sendSystemerror(signal); + return; + } + + if (slkapPage->word32[ZWORDS_IN_PAGE - tslkapPageIndex] >> 16 != 0 ) { + //------------------------------------------------------------- + // The index should be empty, we have a serious problem. + //------------------------------------------------------------- + jam(); + sendSystemerror(signal); + return; + } + + //------------------------------------------------------------- + // Calculate some variables to use later. + //------------------------------------------------------------- + tslkapHighestIndex = slkapPage->header.highestIndex; + tslkapPageIndex > tslkapHighestIndex ? + tslkapIndexIncreaseSize = tslkapPageIndex - tslkapHighestIndex : + tslkapIndexIncreaseSize = 0; + + slkapPage->header.highestIndex += tslkapIndexIncreaseSize; + + if ((slkapPage->header.freeArea - tslkapIndexIncreaseSize) + < tslkapKeyLen) { + //------------------------------------------------------------- + // Not enough area in the page, a serious problem. + //------------------------------------------------------------- + jam(); + sendSystemerror(signal); + return; + } + + //------------------------------------------------------------- + // Fix the free index list. We might put in a key in the + // middle of the list, so we must fix the free list and the + // free index pointers. + //------------------------------------------------------------- + slkapPage->header.nextFreeIndex = 0; + + for (Uint32 i = tslkapHighestIndex + tslkapIndexIncreaseSize; i > 0; i--) { + if (i == tslkapPageIndex) { + // The key index shall not be in the free list. + continue; + } + + if (slkapPage->word32[ZWORDS_IN_PAGE - i] >> 16 == 0 ) { + // Go through all empty indexes. + slkapPage->word32[ZWORDS_IN_PAGE - i] = slkapPage->header.nextFreeIndex; + arrGuard(i, 2048); + slkapPage->header.nextFreeIndex = i; + } + } + + //------------------------------------------------------------- + // Decrement the free area in page according to the above + // increase in index size. + //------------------------------------------------------------- + slkapPage->header.freeArea -= tslkapIndexIncreaseSize; + + tslkapLastSize = ZWORDS_IN_PAGE - slkapPage->header.highestIndex + - slkapPage->header.insertPos; + + //------------------------------------------------------------- + // Check if we have to reorganize the page. + //------------------------------------------------------------- + if (tslkapLastSize >= tslkapKeyLen) { + jam(); + } else { + jam(); + relpPageptr.p = slkapPageptr.p; + reorgLongPage(signal); + } + + //------------------------------------------------------------- + // Insert the key and update page attributes. + //------------------------------------------------------------- + jam(); + // Increase the number of element in the page. + slkapPage->header.noOfElements++; + jam(); + // Put in the key reference into the index. The reference + // consists of key length and insert position. + arrGuard(ZWORDS_IN_PAGE - tslkapPageIndex, 2048); + slkapPage->word32[ZWORDS_IN_PAGE - tslkapPageIndex] = + slkapPage->header.insertPos | (tslkapKeyLen << 16); + jam(); + // Increase the key insert position. + tslkapInsertIndex = slkapPage->header.insertPos; + slkapPage->header.insertPos += tslkapKeyLen; + jam(); + // Decrease the free area. + slkapPage->header.freeArea -= tslkapKeyLen; + jam(); + + // Update pageArrayPos. insertPageArrayList() called from execACC_OVER_REC + // needs this value. + if (slkapPage->header.freeArea < 128) { + jam(); + slkapPage->header.pageArrayPos = 4; + } else { + jam(); + slkapPage->header.pageArrayPos = (slkapPage->header.freeArea - 128) / 512; + }//if + + // Store the actual key at the insert position. + Uint32 guard27 = tslkapKeyLen - 1; + arrGuard(guard27 + tslkapInsertIndex, 2048); + for (tslkapTmp = 0; tslkapTmp <= guard27; tslkapTmp++) { + jam(); + slkapPage->word32[tslkapTmp + tslkapInsertIndex] = slkapCopyPageptr.p->word32[tslkapTmp]; + }//for +}//Dbacc::storeLongKeysAtPos + +/* --------------------------------------------------------------------------------- */ +/* STORE_LONG_KEYS */ +/* INPUT: SLK_PAGEPTR */ +/* SLK_COPY_PAGEPTR */ +/* TSLK_KEY_LEN */ +/* OUTPUT: TSLK_PAGE_INDEX */ +/* */ +/* DESCRIPTION: A LONG ELEMENT IS STORED ON A LONG_KEY_PAGE. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::storeLongKeys(Signal* signal) +{ + Uint32 tslkLastSize; + Uint32 tslkInsertIndex; + Uint32 tslkArrayPos; + Uint32 tslkTmp; + Uint32 guard27; + LongKeyPage *slkPage; + + jam(); + slkPage = (LongKeyPage *) &slkPageptr.p->word32[0]; + +#ifdef VM_TRACE + checkIndexInLongKeyPage(slkPageptr.i, "storeLongKeys1"); +#endif + + // Accept only page with free_area > tupkeylen, this leaves at least + // one word for eventually an increase in the index area. + ndbrequire(slkPage->header.freeArea > tslkKeyLen); + + dbgWord32(slkPageptr, ZPOS_LAST_INDEX, slkPage->header.highestIndex); + dbgWord32(slkPageptr, ZPOS_INSERT_INDEX, slkPage->header.insertPos); + + tslkLastSize = ZWORDS_IN_PAGE - slkPage->header.highestIndex - slkPage->header.insertPos; + + if (tslkLastSize > operationRecPtr.p->tupkeylen) { + // WE DO NOT NEED TO REORGANIZE THE PAGE TO INSERT THE NEW KEY. IT FITS INTO THE + // SIZE REMAINING AT THE END. + jam(); + } else { + // THE KEY FITS INTO THE PAGE BUT ONLY AFTER REORGANISING THE PAGE. + jam(); + relpPageptr.p = slkPageptr.p; + reorgLongPage(signal); + }//if + + if (slkPage->header.nextFreeIndex == 0) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THE PAGE INDEX HAS NO EMPTY SLOTS. WE MUST EXTEND THE PAGE INDEX BY ONE NEW SLOT.*/ + /* --------------------------------------------------------------------------------- */ + tslkPageIndex = slkPage->header.highestIndex + 1; + } else { + jam(); + tslkPageIndex = slkPage->header.nextFreeIndex; + }//if + + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* ON LONG PAGES WE USE A PHYSIOLOGICAL LOGGING SCHEME. THIS MEANS THAT WE ONLY NEED*/ + /* TO SPECIFY WHICH INDEX TO DELETE IN ORDER TO UNDO THE CHANGES WE DO. THE */ + /* POSSIBLE REORGANISATION DO NOT CHANGE THE LOGICAL LAYOUT OF THE PAGE. */ + /* --------------------------------------------------------------------------------- */ + datapageptr.p = slkPageptr.p; + cundoElemIndex = tslkPageIndex; + cundoinfolength = 0; + undoWritingProcess(signal); + }//if + + if (slkPage->header.nextFreeIndex == 0) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THE PAGE INDEX HAS NO EMPTY SLOTS. WE MUST EXTEND THE PAGE INDEX BY ONE NEW SLOT.*/ + /* --------------------------------------------------------------------------------- */ + dbgWord32(slkPageptr, ZPOS_LAST_INDEX, slkPage->header.highestIndex + 1); + slkPage->header.highestIndex++; + ndbrequire(slkPage->header.insertPos < (ZWORDS_IN_PAGE - slkPage->header.highestIndex)); + // Reset index. We have already checked that we can increase "highestIndex" value + // without overwriting the data part. + slkPage->word32[ZWORDS_IN_PAGE - slkPage->header.highestIndex] = 0; + dbgWord32(slkPageptr, ZPOS_FREE_AREA_IN_PAGE, slkPage->header.freeArea - 1); + slkPage->header.freeArea--; + } else { + jam(); + dbgWord32(slkPageptr, ZPOS_NEXT_FREE_INDEX, slkPage->word32[ZWORDS_IN_PAGE - tslkPageIndex]); + arrGuard(ZWORDS_IN_PAGE - tslkPageIndex, 2048); + arrGuard(slkPage->word32[ZWORDS_IN_PAGE - tslkPageIndex], 2048); + + slkPage->header.nextFreeIndex = slkPage->word32[ZWORDS_IN_PAGE - tslkPageIndex]; + if(slkPage->header.nextFreeIndex > slkPage->header.highestIndex){ + slkPage->header.nextFreeIndex = 0; + dbgWord32(slkPageptr, ZPOS_NEXT_FREE_INDEX, slkPage->header.nextFreeIndex); + } + }//if + + dbgWord32(slkPageptr, ZWORDS_IN_PAGE - tslkPageIndex, tslkKeyLen); + dbgWord32(slkPageptr, ZWORDS_IN_PAGE - tslkPageIndex, slkPage->header.insertPos); + arrGuard(ZWORDS_IN_PAGE - tslkPageIndex, 2048); + slkPage->word32[ZWORDS_IN_PAGE - tslkPageIndex] = + slkPage->header.insertPos | (tslkKeyLen << 16); + + dbgWord32(slkPageptr, ZPOS_INSERT_INDEX, slkPage->header.insertPos); + tslkInsertIndex = slkPage->header.insertPos; + slkPage->header.insertPos += tslkKeyLen; + + dbgWord32(slkPageptr, ZPOS_FREE_AREA_IN_PAGE, slkPage->header.freeArea - tslkKeyLen); + slkPage->header.freeArea = slkPage->header.freeArea - tslkKeyLen; + if (slkPage->header.freeArea < 128) { + jam(); + tslkArrayPos = 4; + } else { + jam(); + tslkArrayPos = (slkPage->header.freeArea - 128) / 512; + }//if + + if (tslkArrayPos != slkPage->header.pageArrayPos) { + jam(); + if (cundoLogActive != ZTRUE) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* WE ONLY HANDLE THE LISTS WHEN WE ARE NOT IN A SYSTEM RESTART. */ + /* --------------------------------------------------------------------------------- */ + rfpPageptr = slkPageptr; + trfpArrayPos = slkPage->header.pageArrayPos; + removeFromPageArrayList(signal); + ipaPagePtr = slkPageptr; + tipaArrayPos = tslkArrayPos; + slkPage->header.pageArrayPos = tipaArrayPos; + if (tslkArrayPos != 4) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THE PAGE WILL STILL BE ON ONE OF THE FREE LISTS SINCE AT LEAST 128 * 4 */ + /* BYTES OF FREE SPACE REMAINS ON THE PAGE. */ + /* --------------------------------------------------------------------------------- */ + insertPageArrayList(signal); + }//if + } else { + // This should never happen. Should use storeLongKeysAtPos() instead when executing + // undolog. + ndbrequire(false); + } + }//if + /* --------------------------------------------------------------------------------- */ + /* INCREASE THE NUMBER OF ELEMENTS IN THE PAGE. */ + /* --------------------------------------------------------------------------------- */ + dbgWord32(slkPageptr, ZPOS_NO_ELEM_IN_PAGE, slkPage->header.noOfElements + 1); + slkPage->header.noOfElements++; + + guard27 = tslkKeyLen - 1; + arrGuard(guard27 + tslkInsertIndex, 2048); + for (tslkTmp = 0; tslkTmp <= guard27; tslkTmp++) { + dbgWord32(slkPageptr, tslkTmp + tslkInsertIndex, slkCopyPageptr.p->word32[tslkTmp]); + slkPage->word32[tslkTmp + tslkInsertIndex] = slkCopyPageptr.p->word32[tslkTmp]; + }//for + + // Used by abortoperation() in case of an abort. + operationRecPtr.p->longPagePtr = slkPageptr.i; + + // This is for an eventual LCP start in the middle of this locked operation. + operationRecPtr.p->longKeyPageIndex = tslkPageIndex; + +#ifdef VM_TRACE + if (cundoLogActive != ZTRUE) checkPageArrayList(signal, "storeLongKeys"); + checkIndexInLongKeyPage(slkPageptr.i, "storeLongKeys2"); +#endif + +}//Dbacc::storeLongKeys() + +/* --------------------------------------------------------------------------------- */ +/* REORGANIZE THE PAGE BY COPYING IT TEMPORARILY TO A NEW AREA AND THEN SIMPLY */ +/* PUTTING THE OBJECTS BACK ON THE PAGE IN THE SAME ORDER AS THEY ARE PLACED IN THE */ +/* INDEX. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::reorgLongPage(Signal* signal) +{ + Uint32 indexStartPos; + Uint32 pagePos; + Uint32 pagePos2; + Uint32 indexNo; + Uint32 insertPos; + Uint32 indexValue; + Uint32 keyLength; + Uint32 keyPos; + Uint32 keyEndPos; + LongKeyPage *reOrgPage; + + ptrGuard(relpPageptr); + reOrgPage = (LongKeyPage *) &relpPageptr.p->word32[0]; + + dbgWord32(relpPageptr, ZPOS_LAST_INDEX, reOrgPage->header.highestIndex); + indexStartPos = ZWORDS_IN_PAGE - reOrgPage->header.highestIndex; + + // Copy key data part of page to a temporary page. + for (pagePos = ZHEAD_SIZE; pagePos < indexStartPos; pagePos++) { + jam(); + arrGuard(pagePos, 2048); + ckeys[pagePos] = reOrgPage->word32[pagePos]; + }//for + + insertPos = ZHEAD_SIZE; + + // Walk through all the indexes. + for (indexNo = 1; indexNo <= reOrgPage->header.highestIndex; indexNo++) { + jam(); + arrGuard(ZWORDS_IN_PAGE - indexNo, 2048); + dbgWord32(relpPageptr, ZWORDS_IN_PAGE - indexNo, reOrgPage->word32[ZWORDS_IN_PAGE - indexNo]); + indexValue = reOrgPage->word32[ZWORDS_IN_PAGE - indexNo]; + + if ((indexValue >> 16) != 0) { + // The index contains a reference to a key. + jam(); + keyPos = indexValue & 0xffff; + keyLength = indexValue >> 16; + dbgWord32(relpPageptr, ZWORDS_IN_PAGE - indexNo, insertPos + (keyLength << 16)); + arrGuard(ZWORDS_IN_PAGE - indexNo, 2048); + + // Refresh the index data with the new key start position in the data part. + reOrgPage->word32[ZWORDS_IN_PAGE - indexNo] = insertPos + (keyLength << 16); + keyEndPos = keyPos + keyLength; + arrGuard(keyEndPos, 2048); + + // Copy the key from the temporary page + // to the insert position at original page. + for (pagePos2 = keyPos; pagePos2 < keyEndPos; pagePos2++, insertPos++) { + jam(); + dbgWord32(relpPageptr, insertPos, ckeys[pagePos2]); + arrGuard(insertPos, 2048); + arrGuard(pagePos2, 2048); + reOrgPage->word32[insertPos] = ckeys[pagePos2]; + }//for + }//if + }//for + dbgWord32(relpPageptr, ZPOS_INSERT_INDEX, insertPos); + reOrgPage->header.insertPos = insertPos; +}//Dbacc::reorgLongPage() + + +/* --------------------------------------------------------------------------------- */ +/* DELETE_LONG_KEY */ +/* INPUT: DLK_PAGEPTR PAGE POINTER OF DELETED KEY OBJECT */ +/* TDLK_LOGICAL_PAGE_INDEX LOGICAL PAGE INDEX OF DELETED KEY OBJECT */ +/* */ +/* DESCRIPTION: DELETE AN ELEMENT OF A LONG_KEY_PAGE. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::deleteLongKey(Signal* signal) +{ + Uint32 tdlkLastIndex; + Uint32 tdlkNextPosition; + Uint32 tdlkFreeArea; + Uint32 tdlkArrayPos; + Uint32 tdlkOldArrayPos; + LongKeyPage *dlkPage; + + jam(); + dlkPage = (LongKeyPage *) &dlkPageptr.p->word32[0]; + +#ifdef VM_TRACE + checkIndexInLongKeyPage(dlkPageptr.i, "deleteLongKey1"); +#endif + + dbgWord32(dlkPageptr, ZWORDS_IN_PAGE - tdlkLogicalPageIndex, dlkPage->word32[ZWORDS_IN_PAGE - tdlkLogicalPageIndex] >> 16); + dbgWord32(dlkPageptr, ZWORDS_IN_PAGE - tdlkLogicalPageIndex, dlkPage->word32[ZWORDS_IN_PAGE - tdlkLogicalPageIndex] & 0xffff); + arrGuard(ZWORDS_IN_PAGE - tdlkLogicalPageIndex, 2048); + + const Uint32 tdlkIndexValue = dlkPage->word32[ZWORDS_IN_PAGE - tdlkLogicalPageIndex]; + const Uint32 tdlkKeyLen = tdlkIndexValue >> 16; + const Uint32 tdlkPhysPageIndex = tdlkIndexValue & 0xffff; + + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* WE LOG THE DELETE LONG KEY BY LOGGING THE DELETED KEY AND ITS LOGICAL INDEX.*/ + /* --------------------------------------------------------------------------------- */ + datapageptr.p = dlkPageptr.p; + cundoElemIndex = tdlkLogicalPageIndex; + cundoinfolength = tdlkKeyLen; + undoWritingProcess(signal); + }//if + /* --------------------------------------------------------------------------------- */ + /* DECREASE THE NUMBER OF ELEMENTS IN THE PAGE. */ + /* --------------------------------------------------------------------------------- */ + dbgWord32(dlkPageptr, ZPOS_NO_ELEM_IN_PAGE, dlkPage->header.noOfElements - 1); + dlkPage->header.noOfElements--; + + arrGuard(dlkPage->header.noOfElements, ZMAX_NO_OF_LONGKEYS_IN_PAGE); + + /* --------------------------------------------------------------------------------- */ + /* INCREASE THE FREE AREA IN THE PAGE. */ + /* --------------------------------------------------------------------------------- */ + dbgWord32(dlkPageptr, ZPOS_FREE_AREA_IN_PAGE, dlkPage->header.freeArea + tdlkKeyLen); + dbgWord32(dlkPageptr, ZPOS_LAST_INDEX, dlkPage->header.highestIndex); + + dlkPage->header.freeArea += tdlkKeyLen; + + if (dlkPage->header.noOfElements == 0) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THE PAGE IS NOW EMPTY, WE CAN RELEASE IT. */ + /* --------------------------------------------------------------------------------- */ + if (dlkPage->header.freeArea != + (ZWORDS_IN_PAGE - ZHEAD_SIZE - dlkPage->header.highestIndex )) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* SOME AREA IN THE PAGE IS STILL LEFT BUT NO ELEMENTS, INCONSISTENT */ + /* --------------------------------------------------------------------------------- */ + sendSystemerror(signal); + }//if + /* --------------------------------------------------------------------------------- */ + /* WE REMOVE THE PAGE FROM THE LIST OF FREE LONG PAGES. THERE IS NO RISK THAT IT */ + /* DID NOT BELONG TO ANY SINCE IT IS NOT ALLOWED TO HAVE THAT LARGE KEYS. */ + /* --------------------------------------------------------------------------------- */ + + if (cundoLogActive != ZTRUE) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* WHEN DELETING KEYS DURING SYSTEM RESTART WE NEED NOT UPDATE THE LISTS. */ + /* --------------------------------------------------------------------------------- */ + // REMOVEFROMLIST is done by releaseLongPage(). EDTJAMO. + // rfpPageptr = dlkPageptr; + // trfpArrayPos = dlkPage->header.pageArrayPos; + // removeFromPageArrayList(signal, "deleteLongKey"); + rlopPageptr = dlkPageptr; + releaseLongPage(signal); + return; + } else { + // Must remove reference to the removed key, otherwise left in index. EDTJAMO. + arrGuard(ZWORDS_IN_PAGE - tdlkLogicalPageIndex, 2048); + arrGuard(tdlkLogicalPageIndex, 2048); + + tdlkNextPosition = dlkPage->header.nextFreeIndex; + dlkPage->header.nextFreeIndex = tdlkLogicalPageIndex; + dbgWord32(dlkPageptr, ZWORDS_IN_PAGE - tdlkLogicalPageIndex, tdlkNextPosition); + dlkPage->word32[ZWORDS_IN_PAGE - tdlkLogicalPageIndex] = tdlkNextPosition; + } + } else { + /* --------------------------------------------------------------------------------- */ + /* THE PAGE IS NOT EMPTY SO WE WILL REMOVE THE KEY OBJECT AND UPDATE THE */ + /* HEADER INFORMATION AND PLACE THE PAGE IN THE PROPER PAGE LIST. */ + /* --------------------------------------------------------------------------------- */ + tdlkLastIndex = dlkPage->header.highestIndex; + arrGuard(ZWORDS_IN_PAGE - tdlkLastIndex, 2048); + if (tdlkLastIndex == tdlkLogicalPageIndex) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* WE DELETE THE LAST PAGE INDEX SO WE NEED TO UPDATE THE VALUE. WE MOVE */ + /* BACKWARDS UNTIL WE EITHER FIND A USED INDEX OR THAT WE COME TO INDEX ZERO. */ + /* --------------------------------------------------------------------------------- */ + tdlkLastIndex--; + while( (tdlkLastIndex > 1) && + (dlkPage->word32[ZWORDS_IN_PAGE - tdlkLastIndex] >> 16) == 0 ) { + jam(); + tdlkLastIndex--; + } + //----------------------------------------------------- + // Reorganize the rest of the index. Set up the free + // list and the free index. + //----------------------------------------------------- + UintR dlkTmp = tdlkLastIndex; + dlkPage->header.nextFreeIndex = 0; + while( dlkTmp > 0) { + if ( (dlkPage->word32[ZWORDS_IN_PAGE - dlkTmp] >> 16) == 0 ) { + jam(); + dlkPage->word32[ZWORDS_IN_PAGE - dlkTmp] = dlkPage->header.nextFreeIndex; + arrGuard(dlkTmp, 2048); + dlkPage->header.nextFreeIndex = dlkTmp; + } + dlkTmp--; + } + //----------------------------------------------------- + // Update free area in page and last index. + //----------------------------------------------------- + dbgWord32(dlkPageptr, ZPOS_LAST_INDEX, tdlkLastIndex); + dlkPage->header.highestIndex = tdlkLastIndex; + dlkPage->header.freeArea = tdlkLogicalPageIndex + + dlkPage->header.freeArea - tdlkLastIndex; + tdlkNextPosition = 0; + } else { + if (dlkPage->header.highestIndex > tdlkLogicalPageIndex) { + jam(); + tdlkNextPosition = dlkPage->header.nextFreeIndex; + dbgWord32(dlkPageptr, ZPOS_NEXT_FREE_INDEX, tdlkLogicalPageIndex); + arrGuard(tdlkLogicalPageIndex, 2048); + dlkPage->header.nextFreeIndex = tdlkLogicalPageIndex; + } else { + jam(); + /* --------------------------------------------------------------------------------- */ + /* LOGICAL PAGE INDEX LARGER THAN LARGEST INDEX, INCONSISTENT. */ + /* --------------------------------------------------------------------------------- */ + sendSystemerror(signal); + return; // Just to keep compiler happy + }//if + }//if + /* --------------------------------------------------------------------------------- */ + /* WE INSERT ZERO INTO THE LENGTH PART TO INDICATE A FREE INDEX POSITION. */ + /* WE INSERT A POINTER TO THE NEXT FREE INDEX TO AS TO PUT IT INTO A FREE */ + /* LIST OF INDEX POSITIONS. WE ONLY DO SO IF IT WAS NOT THE LAST INDEX. */ + /* --------------------------------------------------------------------------------- */ + dbgWord32(dlkPageptr, ZWORDS_IN_PAGE - tdlkLogicalPageIndex, tdlkNextPosition); + arrGuard(ZWORDS_IN_PAGE - tdlkLogicalPageIndex, 2048); + dlkPage->word32[ZWORDS_IN_PAGE - tdlkLogicalPageIndex] = tdlkNextPosition; + if (dlkPage->header.insertPos == (tdlkPhysPageIndex + tdlkKeyLen)) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THIS ENTRY IS THE LAST ON THE PAGE SO WE WILL UPDATE THE INSERT INDEX */ + /* --------------------------------------------------------------------------------- */ + dbgWord32(dlkPageptr, ZPOS_INSERT_INDEX, tdlkPhysPageIndex); + dlkPage->header.insertPos = tdlkPhysPageIndex; + }//if + }//if + dbgWord32(dlkPageptr, ZPOS_FREE_AREA_IN_PAGE, dlkPage->header.freeArea); + tdlkFreeArea = dlkPage->header.freeArea; + ndbrequire(tdlkFreeArea <= (ZWORDS_IN_PAGE - ZHEAD_SIZE)); + if (tdlkFreeArea < 128) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* FREE AREA IS STILL LESS THAN 128 WORDS SO IT SHOULD NOT BE PLACED IN ANY OF THE */ + /* FREE LISTS. */ + /* --------------------------------------------------------------------------------- */ + dbgWord32(dlkPageptr, ZPOS_ARRAY_POS, dlkPage->header.pageArrayPos); + ndbrequire(dlkPage->header.pageArrayPos == 4); + } else { + jam(); + // Calculate an eventually new arraypos. + dbgWord32(dlkPageptr, 0, (tdlkFreeArea - 128) / 512); + tdlkArrayPos = (tdlkFreeArea - 128) / 512; + + if (cundoLogActive != ZTRUE) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* WHEN DELETING KEYS DURING SYSTEM RESTART WE NEED NOT UPDATE THE LISTS. */ + /* --------------------------------------------------------------------------------- */ + dbgWord32(dlkPageptr, ZPOS_ARRAY_POS, dlkPage->header.pageArrayPos); + tdlkOldArrayPos = dlkPage->header.pageArrayPos; + if (tdlkArrayPos != tdlkOldArrayPos) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THE NEW MEMORY AREA HAS ENABLED THE PAGE TO MOVE TO A NEW FREE PAGE LIST */ + /* --------------------------------------------------------------------------------- */ + rfpPageptr = dlkPageptr; + trfpArrayPos = tdlkOldArrayPos; + if (tdlkOldArrayPos != 4) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THERE WAS A FREE PAGE LIST TO REMOVE THE PAGE FROM. IF FREE SPACE IS LESS THAN */ + /* 128 BYTES THEN IT IS NOT ON ANY FREE LIST. */ + /* --------------------------------------------------------------------------------- */ + removeFromPageArrayList(signal); + }//if + dlkPage->header.pageArrayPos = tdlkArrayPos; + ipaPagePtr = dlkPageptr; + tipaArrayPos = tdlkArrayPos; + insertPageArrayList(signal); + }//if + } else { + // Update pageArrayPos. We are in a SR, executing undolog, insertPageArrayList() called + // from execACC_OVER_REC needs this value later. + dlkPage->header.pageArrayPos = tdlkArrayPos; + } + }//if +#ifdef VM_TRACE + if (cundoLogActive != ZTRUE) checkPageArrayList(signal, "deleteLongKey"); + checkIndexInLongKeyPage(dlkPageptr.i, "deleteLongKey2"); +#endif +}//Dbacc::deleteLongKey() + + +void Dbacc::checkIndexInLongKeyPage(Uint32 pageId, char *calledFrom) { + Page8Ptr pagePtr; + LongKeyPage *page; + Uint32 indexNo; + Uint32 indexValue; + Uint32 keyLength; + Uint32 keyPos; + + pagePtr.i = pageId; + ptrCheckGuard(pagePtr, cpagesize, page8); + page = (LongKeyPage *) &pagePtr.p->word32[0]; + + // Check the header variables. + if (page->header.nextFreeIndex > 2048 || + page->header.highestIndex > 2048 || + page->header.insertPos > 2048 || + page->header.freeArea > 2048 || + page->header.noOfElements > 225) { + ndbout << " ERROR in checkIndexInLongKeyPage, called from " << calledFrom << endl + << " pagePtr.i = " << pageId << endl; + printoutInfoAndShutdown(page); + } + + // Walk through all the indexes. + for (indexNo = 1; indexNo <= page->header.highestIndex; indexNo++) { + jam(); + indexValue = page->word32[ZWORDS_IN_PAGE - indexNo]; + + if ((indexValue >> 16) == 0) { + ; // key length is 0, means no key reference at this position in index. + } else { + // The index contains a reference to a key. + jam(); + keyPos = indexValue & 0xffff; + keyLength = indexValue >> 16; + if (keyPos >= ZWORDS_IN_PAGE || keyLength >= ZWORDS_IN_PAGE) { + jam(); + ndbout << " ERROR in checkIndexInLongKeyPage, called from " << calledFrom << endl + << " keyPos = " << keyPos << endl + << " keyLength = " << keyLength << endl + << " page->header.noOfElements = " << page->header.noOfElements << endl + << " page->header.freeArea = " << page->header.freeArea << endl + << " indexNo = " << indexNo << endl + << " page->header.highestIndex = " << page->header.highestIndex << endl; + ndbrequire(false); + } + } + } +}//Dbacc::checkIndexInLongKeyPage + + +/* --------------------------------------------------------------------------------- */ +/* REMOVE A PAGE FROM THE PAGE ARRAY LIST. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::removeFromPageArrayList(Signal* signal) +{ + Page8Ptr rfpPrevPageptr; + Page8Ptr rfpNextPageptr; + LongKeyPage *page; + LongKeyPage *prevPage; + LongKeyPage *nextPage; + + jam(); + +#ifdef VM_TRACE + checkPageB4Remove(rfpPageptr.i, "removeFromPageArrayList"); +#endif + + page = (LongKeyPage *) &rfpPageptr.p->word32[0]; + + if (page->header.prevPage == RNIL) { + jam(); + arrGuard(trfpArrayPos, 4); + // This page was first in list, remove reference + // to this page from the start of the list. + ndbrequire(fragrecptr.p->longKeyPageArray[trfpArrayPos] == rfpPageptr.i); + fragrecptr.p->longKeyPageArray[trfpArrayPos] = page->header.nextPage; + } else { + jam(); + rfpPrevPageptr.i = page->header.prevPage; + ptrCheckGuard(rfpPrevPageptr, cpagesize, page8); + prevPage = (LongKeyPage *) &rfpPrevPageptr.p->word32[0]; + // This page wasn't first in list, remove reference + // to this page from the previous page. + ndbrequire(prevPage->header.nextPage == rfpPageptr.i); + prevPage->header.nextPage = page->header.nextPage; + }//if + + if (page->header.nextPage != RNIL) { + jam(); + rfpNextPageptr.i = page->header.nextPage; + ptrCheckGuard(rfpNextPageptr, cpagesize, page8); + nextPage = (LongKeyPage *) &rfpNextPageptr.p->word32[0]; + // This page wasn't last in list, remove reference + // to this page from the next page. + ndbrequire(nextPage->header.prevPage == rfpPageptr.i); + nextPage->header.prevPage = page->header.prevPage; + // Remove reference to next page in list. + page->header.nextPage = RNIL; + }//if + + // This couldn't be set until now. + // Remove reference to previous page in list. + page->header.prevPage = RNIL; + +#ifdef VM_TRACE + checkPageArrayList(signal, "removeFromPageArrayList"); +#endif +}//Dbacc::removeFromPageArrayList() + +/* --------------------------------------------------------------------------------- */ +/* INSERT A PAGE INTO THE PAGE ARRAY LIST. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::insertPageArrayList(Signal* signal) +{ + Page8Ptr ipaNextPagePtr; + LongKeyPage *page; + LongKeyPage *nextPage; + + jam(); + +#ifdef VM_TRACE + checkPageArrayList(signal, "insertPageArrayList1"); + checkPageB4Insert(ipaPagePtr.i, "insertPageArrayList1"); +#endif + + page = (LongKeyPage *) &ipaPagePtr.p->word32[0]; + + arrGuard(tipaArrayPos, 4); + + if (fragrecptr.p->longKeyPageArray[tipaArrayPos] != RNIL) { + jam(); + ipaNextPagePtr.i = fragrecptr.p->longKeyPageArray[tipaArrayPos]; + ptrCheckGuard(ipaNextPagePtr, cpagesize, page8); + nextPage = (LongKeyPage *) &ipaNextPagePtr.p->word32[0]; + + // A page already existed in the list, add reference + // to this page in the next page. + nextPage->header.prevPage = ipaPagePtr.i; + }//if + + page->header.prevPage = RNIL; + page->header.nextPage = fragrecptr.p->longKeyPageArray[tipaArrayPos]; + page->header.pageArrayPos = tipaArrayPos; + + fragrecptr.p->longKeyPageArray[tipaArrayPos] = ipaPagePtr.i; + +#ifdef VM_TRACE + checkPageArrayList(signal, "insertPageArrayList2"); +#endif +}//Dbacc::insertPageArrayList() + +// --------------------------------------------------------------------------------- */ +// Check the page array list. +// --------------------------------------------------------------------------------- */ +void Dbacc::checkPageArrayList(Signal* signal, char *calledFrom) +{ + Page8Ptr pagePtr; + Uint32 pageArrayIndex; + LongKeyPage *page; + Uint32 prevPage; + + // Go through the longKeyPageArray and search for a page. + for (pageArrayIndex = 0; pageArrayIndex <= ZMAX_LONG_KEY_ARRAY_INDEX; pageArrayIndex++) { + jam(); + pagePtr.i = fragrecptr.p->longKeyPageArray[pageArrayIndex]; + prevPage = RNIL; + + if (pagePtr.i != RNIL) { + // A page is found. + jam(); + do { + ptrCheckGuard(pagePtr, cpagesize, page8); + page = (LongKeyPage *) &pagePtr.p->word32[0]; + + if ((page->header.freeArea >= 128) && + (((page->header.freeArea - 128) / 512) == page->header.pageArrayPos) && + (pageArrayIndex == page->header.pageArrayPos) && + (page->header.prevPage == prevPage)) { + // The page found is OK, test next page. + prevPage = pagePtr.i; + pagePtr.i = page->header.nextPage; + jam(); + } else { + jam(); + ndbout << " ERROR in checkPageArrayList, called from " << calledFrom << endl + << " pagePtr.i = " << pagePtr.i << endl + << " prevPage = " << prevPage << endl + << " pageArrayIndex = " << pageArrayIndex << endl; + printoutInfoAndShutdown(page); + } + }//do + while (pagePtr.i != RNIL); + }//if + }//for +}//Dbacc::checkPageArrayList() + +// --------------------------------------------------------------------------------- */ +// Check the page to put into the pageArrayList. +// --------------------------------------------------------------------------------- */ +void Dbacc::checkPageB4Insert(Uint32 pageId, char *calledFrom) { + Page8Ptr pagePtr; + Uint32 pageArrayIndex; + LongKeyPage *page; + + pagePtr.i = pageId; + ptrCheckGuard(pagePtr, cpagesize, page8); + page = (LongKeyPage *) &pagePtr.p->word32[0]; + + if ((page->header.nextPage != RNIL) || + (page->header.prevPage != RNIL)) { + jam(); + ndbout << " ERROR in checkPageB4Insert, called from " << calledFrom << endl + << " pagePtr.i = " << pagePtr.i << endl + << " page->header.nextPage = " << page->header.nextPage << endl + << " page->header.prevPage = " << page->header.prevPage << endl; + ndbrequire(false); + } + + // Page should not be inserted in list if free area is less than 512 byte. + if (page->header.freeArea < 128) { + jam(); + ndbout << " ERROR in checkPageB4Insert, called from " << calledFrom << endl + << " Page has to little free area to be in list." << endl + << " pagePtr.i = " << pagePtr.i << endl + << " tipaArrayPos = " << tipaArrayPos << endl; + printoutInfoAndShutdown(page); + } + + // Check if position in list is correct + if ((((page->header.freeArea - 128) / 512) != page->header.pageArrayPos) || + (page->header.pageArrayPos != tipaArrayPos)) { + ndbout << " ERROR in checkPageB4Insert, called from " << calledFrom << endl + << " Incorrect position in list." << endl + << " pagePtr.i = " << pagePtr.i << endl + << " tipaArrayPos = " << tipaArrayPos << endl; + printoutInfoAndShutdown(page); + } + + // Check if page is already in list. + for (pageArrayIndex = 0; pageArrayIndex <= ZMAX_LONG_KEY_ARRAY_INDEX; pageArrayIndex++) { + jam(); + pagePtr.i = fragrecptr.p->longKeyPageArray[pageArrayIndex]; + + if (pagePtr.i != RNIL) { + // A page is found. + jam(); + do { + ptrCheckGuard(pagePtr, cpagesize, page8); + page = (LongKeyPage *) &pagePtr.p->word32[0]; + if (pagePtr.i == pageId) { + jam(); + ndbout << "ERROR in checkPageB4Insert, called from " << calledFrom << endl + << "Page exists already in list." << endl + << " pagePtr.i = " << pagePtr.i << endl; + printoutInfoAndShutdown(page); + } + pagePtr.i = page->header.nextPage; + }//do + while (pagePtr.i != RNIL); + }//if + }//for +}//Dbacc::checkPageB4Insert() + +// --------------------------------------------------------------------------------- */ +// Check the page to remove from the pageArrayList. +// --------------------------------------------------------------------------------- */ +void Dbacc::checkPageB4Remove(Uint32 pageId, char *calledFrom) { + Page8Ptr pagePtr; + Uint32 pageArrayIndex; + Uint32 noOfOccurrence = 0; + Uint32 noOfPagesInList = 0; + LongKeyPage *page; + + LongKeyPage *prevPage; + LongKeyPage *nextPage; + Page8Ptr rfpPrevPageptr; + Page8Ptr rfpNextPageptr; + + + pagePtr.i = pageId; + ptrCheckGuard(pagePtr, cpagesize, page8); + page = (LongKeyPage *) &pagePtr.p->word32[0]; + + // Check that page is in list. + for (pageArrayIndex = 0; pageArrayIndex <= ZMAX_LONG_KEY_ARRAY_INDEX; pageArrayIndex++) { + jam(); + pagePtr.i = fragrecptr.p->longKeyPageArray[pageArrayIndex]; + + if (pagePtr.i != RNIL) { + // A page is found. + jam(); + do { + noOfPagesInList++; + ptrCheckGuard(pagePtr, cpagesize, page8); + page = (LongKeyPage *) &pagePtr.p->word32[0]; + if (pagePtr.i == pageId) { + // Check the consistent in list. + if (page->header.prevPage != RNIL) { + rfpPrevPageptr.i = page->header.prevPage; + ptrCheckGuard(rfpPrevPageptr, cpagesize, page8); + prevPage = (LongKeyPage *) &rfpPrevPageptr.p->word32[0]; + if (prevPage->header.nextPage != pageId) { + ndbout << "ERROR: inconsistent in checkPageB4Remove, called from " << calledFrom << endl + << "prevPage->header.nextPage = " << prevPage->header.nextPage << endl + << "pageId = " << pageId << endl; + printoutInfoAndShutdown(page); + } + } + // Check the consistent in list. + if (page->header.nextPage != RNIL) { + rfpNextPageptr.i = page->header.nextPage; + ptrCheckGuard(rfpNextPageptr, cpagesize, page8); + nextPage = (LongKeyPage *) &rfpNextPageptr.p->word32[0]; + if (nextPage->header.prevPage != pageId) { + ndbout << "ERROR: inconsistent in checkPageB4Remove, called from " << calledFrom << endl + << "nextPage->header.prevPage = " << nextPage->header.prevPage << endl + << "pageId = " << pageId << endl; + printoutInfoAndShutdown(page); + } + } + jam(); + noOfOccurrence++; + } + pagePtr.i = page->header.nextPage; + }//do + while (pagePtr.i != RNIL); + }//if + }//for + + if (noOfOccurrence != 1) { + pagePtr.i = pageId; + ptrCheckGuard(pagePtr, cpagesize, page8); + page = (LongKeyPage *) &pagePtr.p->word32[0]; + ndbout << "ERROR in checkPageB4Remove, called from " << calledFrom << endl + << "Page occur " << noOfOccurrence << " times in list" << endl + << "pageId = " << pageId << endl; + printoutInfoAndShutdown(page); + } +}//Dbacc::checkPageB4Remove() + + +// --------------------------------------------------------------------------------- */ +// Printout an error message and shutdown node. +// --------------------------------------------------------------------------------- */ +void Dbacc::printoutInfoAndShutdown(LongKeyPage *page) { + ndbout << " page->header.pageArrayPos = " << page->header.pageArrayPos << endl + << " ((page->header.freeArea - 128) / 512) = " + << ((page->header.freeArea - 128) / 512) << endl + << " page->header.freeArea = " << page->header.freeArea << endl + << " page->header.noOfElements = " << page->header.noOfElements << endl + << " page->header.nextPage = " << page->header.nextPage << endl + << " page->header.prevPage = " << page->header.prevPage << endl + << " page->header.nextFreeIndex = " << page->header.nextFreeIndex << endl + << " page->header.insertPos = " << page->header.insertPos << endl + << " page->header.highestIndex = " << page->header.highestIndex << endl + << " page->header.pageId = " << page->header.pageId << endl; + ndbrequire(false); +}//Dbacc::printoutInfoAndShutdown() + +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* END OF INSERT_ELEMENT MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* MODULE: READ */ +/* THE FOLLOWING SUBROUTINES ARE ONLY USED BY GET_ELEMENT AND */ +/* GETDIRINDEX. THIS ROUTINE IS THE SOLE INTERFACE TO GET ELEMENTS */ +/* FROM THE INDEX. CURRENT USERS ARE ALL REQUESTS AND EXECUTE UNDO LOG */ +/* */ +/* THE FOLLOWING SUBROUTINES ARE INCLUDED IN THIS MODULE: */ +/* GET_ELEMENT */ +/* GET_DIRINDEX */ +/* SEARCH_LONG_KEY */ +/* */ +/* THESE ROUTINES ARE ONLY USED BY THIS MODULE AND BY NO ONE ELSE. */ +/* ALSO THE ROUTINES MAKE NO USE OF ROUTINES IN OTHER MODULES. */ +/* THE ONLY SHORT-LIVED VARIABLES USED IN OTHER PARTS OF THE BLOCK ARE */ +/* THOSE DEFINED AS INPUT AND OUTPUT IN GET_ELEMENT AND GETDIRINDEX */ +/* SHORT-LIVED VARIABLES INCLUDE TEMPORARY VARIABLES, COMMON VARIABLES */ +/* AND POINTER VARIABLES. */ +/* THE ONLY EXCEPTION TO THIS RULE IS FRAGRECPTR WHICH POINTS TO THE */ +/* FRAGMENT RECORD. THIS IS MORE LESS STATIC ALWAYS DURING A SIGNAL */ +/* EXECUTION. */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* GETDIRINDEX */ +/* SUPPORT ROUTINE FOR INSERT ELEMENT, GET ELEMENT AND COMMITDELETE */ +/* INPUT:FRAGRECPTR ( POINTER TO THE ACTIVE FRAGMENT REC) */ +/* OPERATION_REC_PTR (POINTER TO THE OPERATION REC). */ +/* */ +/* OUTPUT:GDI_PAGEPTR ( POINTER TO THE PAGE OF THE ELEMENT) */ +/* TGDI_PAGEINDEX ( INDEX OF THE ELEMENT IN THE PAGE). */ +/* */ +/* DESCRIPTION: CHECK THE HASH VALUE OF THE OPERATION REC AND CALCULATE THE */ +/* THE ADDRESS OF THE ELEMENT IN THE HASH TABLE,(GDI_PAGEPTR, */ +/* TGDI_PAGEINDEX) ACCORDING TO LH3. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::getdirindex(Signal* signal) +{ + DirRangePtr gdiDirRangePtr; + DirectoryarrayPtr gdiDirptr; + Uint32 tgdiTmp; + Uint32 tgdiAddress; + + tgdiTmp = fragrecptr.p->k + fragrecptr.p->lhfragbits; /* OBS K = 6 */ + tgdiPageindex = operationRecPtr.p->hashValue & ((1 << fragrecptr.p->k) - 1); + tgdiTmp = operationRecPtr.p->hashValue >> tgdiTmp; + tgdiTmp = (tgdiTmp << fragrecptr.p->k) | tgdiPageindex; + tgdiAddress = tgdiTmp & fragrecptr.p->maxp; + gdiDirRangePtr.i = fragrecptr.p->directory; + ptrCheckGuard(gdiDirRangePtr, cdirrangesize, dirRange); + if (tgdiAddress < fragrecptr.p->p) { + jam(); + tgdiAddress = tgdiTmp & ((fragrecptr.p->maxp << 1) | 1); + }//if + tgdiTmp = tgdiAddress >> fragrecptr.p->k; + arrGuard((tgdiTmp >> 8), 256); + gdiDirptr.i = gdiDirRangePtr.p->dirArray[tgdiTmp >> 8]; + ptrCheckGuard(gdiDirptr, cdirarraysize, directoryarray); + gdiPageptr.i = gdiDirptr.p->pagep[tgdiTmp & 0xff]; /* DIRECTORY INDEX OF SEND BUCKET PAGE */ + ptrCheckGuard(gdiPageptr, cpagesize, page8); +}//Dbacc::getdirindex() + +/* --------------------------------------------------------------------------------- */ +/* GET_ELEMENT */ +/* INPUT: */ +/* OPERATION_REC_PTR */ +/* FRAGRECPTR */ +/* OUTPUT: */ +/* TGE_RESULT RESULT SUCCESS = ZTRUE OTHERWISE ZFALSE */ +/* TGE_LOCKED LOCK INFORMATION IF SUCCESSFUL RESULT */ +/* GE_PAGEPTR PAGE POINTER OF FOUND ELEMENT */ +/* TGE_CONTAINERPTR CONTAINER INDEX OF FOUND ELEMENT */ +/* TGE_ELEMENTPTR ELEMENT INDEX OF FOUND ELEMENT */ +/* TGE_FORWARD DIRECTION OF CONTAINER WHERE ELEMENT FOUND */ +/* */ +/* DESCRIPTION: THE SUBROUTIN GOES THROUGH ALL CONTAINERS OF THE ACTIVE */ +/* BUCKET, AND SERCH FOR ELEMENT.THE PRIMARY KEYS WHICH IS SAVED */ +/* IN THE OPERATION REC ARE THE CHECK ITEMS IN THE SEARCHING. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::getElement(Signal* signal) +{ + DirRangePtr geOverflowrangeptr; + DirectoryarrayPtr geOverflowDirptr; + OperationrecPtr geTmpOperationRecPtr; + Uint32 tgeElementHeader; + Uint32 tgeElemStep; + Uint32 tgeContainerhead; + Uint32 tgePageindex; + Uint32 tgeActivePageDir; + Uint32 tgeNextptrtype; + register Uint32 tgeKeyptr; + register Uint32 tgeRemLen; + register Uint32 tgeCompareLen; + register Uint32 TelemLen = fragrecptr.p->elementLength; + register Uint32* Tkeydata = (Uint32*)&signal->theData[7]; + + getdirindex(signal); + tgePageindex = tgdiPageindex; + gePageptr = gdiPageptr; + tgeResult = ZFALSE; + tgeCompareLen = fragrecptr.p->keyLength; + const Uint32 isAccLockReq = operationRecPtr.p->isAccLockReq; + if (isAccLockReq) { + jam(); + tgeCompareLen = 0; + } + + // We can handle keylength up to 8, but not more (0 means dynamic) + if (tgeCompareLen >= 9) { + ACCKEY_error(2); return; + }//if + if (TelemLen < 3) { + ACCKEY_error(3); return; + }//if + tgeNextptrtype = ZLEFT; + tgeLocked = 0; + + const Uint32 tmp = fragrecptr.p->k + fragrecptr.p->lhfragbits; + const Uint32 opHashValuePart = (operationRecPtr.p->hashValue >> tmp) &0xFFFF; + do { + tgeContainerptr = (tgePageindex << ZSHIFT_PLUS) - (tgePageindex << ZSHIFT_MINUS); + if (tgeNextptrtype == ZLEFT) { + jam(); + tgeContainerptr = tgeContainerptr + ZHEAD_SIZE; + tgeElementptr = tgeContainerptr + ZCON_HEAD_SIZE; + tgeKeyptr = (tgeElementptr + ZELEM_HEAD_SIZE) + fragrecptr.p->localkeylen; + tgeElemStep = TelemLen; + tgeForward = 1; + if (tgeContainerptr >= 2048) { ACCKEY_error(4); return;} + tgeRemLen = gePageptr.p->word32[tgeContainerptr] >> 26; + if ((tgeContainerptr + tgeRemLen - 1) >= 2048) { ACCKEY_error(5); return;} + } else if (tgeNextptrtype == ZRIGHT) { + jam(); + tgeContainerptr = tgeContainerptr + ((ZHEAD_SIZE + ZBUF_SIZE) - ZCON_HEAD_SIZE); + tgeElementptr = tgeContainerptr - 1; + tgeKeyptr = (tgeElementptr - ZELEM_HEAD_SIZE) - fragrecptr.p->localkeylen; + tgeElemStep = 0 - TelemLen; + tgeForward = (Uint32)-1; + if (tgeContainerptr >= 2048) { ACCKEY_error(4); return;} + tgeRemLen = gePageptr.p->word32[tgeContainerptr] >> 26; + if ((tgeContainerptr - tgeRemLen) >= 2048) { ACCKEY_error(5); return;} + } else { + ACCKEY_error(6); return; + }//if + if (tgeRemLen >= TelemLen) { + if (tgeRemLen > ZBUF_SIZE) { + ACCKEY_error(7); return; + }//if + /* --------------------------------------------------------------------------------- */ + // There is at least one element in this container. Check if it is the element + // searched for. + /* --------------------------------------------------------------------------------- */ + if (tgeCompareLen != 0) { + /* --------------------------------------------------------------------------------- */ + /* THIS PART IS USED TO SEARCH FOR KEYS WITH FIXED SIZE. THE LOOP TAKES CARE */ + /* OF SEARCHING THROUGH ALL ELEMENTS IN ONE CONTAINER. */ + /* --------------------------------------------------------------------------------- */ + do { + register Uint32 TdataIndex = 0; + register Uint32 TgeIndex = 0; + jam(); + tgeRemLen = tgeRemLen - TelemLen; + do { + if (gePageptr.p->word32[tgeKeyptr + TgeIndex] != Tkeydata[TdataIndex]) { + goto compare_next; + }//if + TdataIndex++; + TgeIndex += tgeForward; + } while (TdataIndex < tgeCompareLen); + /* --------------------------------------------------------------------------------- */ + /* WE HAVE FOUND THE ELEMENT. GET THE LOCK INDICATOR AND RETURN FOUND. */ + /* --------------------------------------------------------------------------------- */ + jam(); + tgeLocked = ElementHeader::getLocked(gePageptr.p->word32[tgeElementptr]); + tgeResult = ZTRUE; + TdataIndex = tgeElementptr + tgeForward; + TgeIndex = TdataIndex + tgeForward; + operationRecPtr.p->localdata[0] = gePageptr.p->word32[TdataIndex]; + operationRecPtr.p->localdata[1] = gePageptr.p->word32[TgeIndex]; + return; + /* --------------------------------------------------------------------------------- */ + /* COMPARE NEXT ELEMENT */ + /* --------------------------------------------------------------------------------- */ + compare_next: + if (tgeRemLen <= ZCON_HEAD_SIZE) { + break; + }//if + tgeKeyptr = tgeKeyptr + tgeElemStep; + tgeElementptr = tgeElementptr + tgeElemStep; + } while (1); + } else if (! isAccLockReq) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THIS PART IS USED TO SEARCH FOR KEYS WITH VARIABLE LENGTH OR FIXED LENGTH */ + /* GREATER THAN 32 BYTES. IN THIS CASE THE KEY PART IS STORED IN A SPECIAL */ + /* LONG PAGE PART AND THE HASH INDEX CONTAINS A REFERENCE TO THERE PLUS A */ + /* PART OF THE HASH VALUE. */ + /* --------------------------------------------------------------------------------- */ + do { + tgeElementHeader = gePageptr.p->word32[tgeElementptr]; + tgeRemLen = tgeRemLen - TelemLen; + Uint32 hashValuePart; + if (ElementHeader::getLocked(tgeElementHeader)) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* IN THIS CASE THE HASH VALUE PART OF THE ELEMENT HEADER IS STORED IN THE */ + /* OPERATION THAT OWNS THE LOCK. IN THIS CASE WE MIGHT AS WELL GO AHEAD AND */ + /* CHECK THE KEY IN THE LONG PAGE. */ + /* --------------------------------------------------------------------------------- */ + geTmpOperationRecPtr.i = + ElementHeader::getOpPtrI(tgeElementHeader); + ptrCheckGuard(geTmpOperationRecPtr, coprecsize, operationrec); + hashValuePart = geTmpOperationRecPtr.p->hashvaluePart; + } else { + jam(); + /* --------------------------------------------------------------------------------- */ + /* IN THIS CASE THE HASH VALUE PART CAN BE CHECKED TO SEE IF THE HASH VALUE */ + /* GIVES US A REASON TO CONTINUE CHECKING THE FULL KEY. */ + /* --------------------------------------------------------------------------------- */ + hashValuePart = ElementHeader::getHashValuePart(tgeElementHeader); + }//if + + if (hashValuePart == opHashValuePart) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* IF THE HASH VALUES ARE EQUAL THEN XOR-ING THEM WILL GIVE THE RESULT 0. */ + /* --------------------------------------------------------------------------------- */ + /* WE HAVE FOUND A KEY WITH IDENTICAL HASH VALUE. MOST LIKELY WE HAVE FOUND THE*/ + /* ELEMENT BUT FIRST WE NEED TO PERFORM A KEY COMPARISON. */ + /* --------------------------------------------------------------------------------- */ + tslcPageIndex = gePageptr.p->word32[tgeKeyptr] & 0x3ff; + tslcPagedir = gePageptr.p->word32[tgeKeyptr] >> 10; + searchLongKey(signal); + if (tslcResult == ZTRUE) { + register Uint32 TlocData1, TlocData2; + jam(); + /* --------------------------------------------------------------------------------- */ + /* WE HAVE FOUND THE ELEMENT. GET THE LOCK INDICATOR AND RETURN FOUND. */ + /* --------------------------------------------------------------------------------- */ + tgeLocked = ElementHeader::getLocked(tgeElementHeader); + tgeResult = ZTRUE; + TlocData1 = tgeElementptr + tgeForward; + TlocData2 = TlocData1 + tgeForward; + operationRecPtr.p->localdata[0] = gePageptr.p->word32[TlocData1]; + operationRecPtr.p->localdata[1] = gePageptr.p->word32[TlocData2]; + return; + }//if + } + /* --------------------------------------------------------------------------------- */ + /* COMPARE NEXT ELEMENT */ + /* --------------------------------------------------------------------------------- */ + if (tgeRemLen <= ZCON_HEAD_SIZE) { + break; + }//if + tgeKeyptr = tgeKeyptr + tgeElemStep; + tgeElementptr = tgeElementptr + tgeElemStep; + } while (1); + } else { + jam(); + /* --------------------------------------------------------------------------------- */ + /* Search for local key in a lock request */ + /* --------------------------------------------------------------------------------- */ + do { + tgeRemLen = tgeRemLen - TelemLen; + // position of local key word 1 + Uint32 TdataIndex = tgeElementptr + tgeForward; + // XXX assume localkeylen is 1 + if (gePageptr.p->word32[TdataIndex] == Tkeydata[0]) { + jam(); + tgeLocked = ElementHeader::getLocked(gePageptr.p->word32[tgeElementptr]); + tgeResult = ZTRUE; + // position of local key word 2 + Uint32 TgeIndex = TdataIndex + tgeForward; + operationRecPtr.p->localdata[0] = gePageptr.p->word32[TdataIndex]; + operationRecPtr.p->localdata[1] = gePageptr.p->word32[TgeIndex]; + return; + }//if + if (tgeRemLen <= ZCON_HEAD_SIZE) { + break; + }//if + tgeElementptr = tgeElementptr + tgeElemStep; + } while (1); + }//if + }//if + if (tgeRemLen != ZCON_HEAD_SIZE) { + ACCKEY_error(8); return; + }//if + tgeContainerhead = gePageptr.p->word32[tgeContainerptr]; + tgeNextptrtype = (tgeContainerhead >> 7) & 0x3; + if (tgeNextptrtype == 0) { + jam(); + return; /* NO MORE CONTAINER */ + }//if + tgePageindex = tgeContainerhead & 0x7f; /* NEXT CONTAINER PAGE INDEX 7 BITS */ + if (tgePageindex > ZEMPTYLIST) { + ACCKEY_error(9); return; + }//if + if (((tgeContainerhead >> 9) & 1) == ZFALSE) { + jam(); + tgeActivePageDir = gePageptr.p->word32[tgeContainerptr + 1]; /* NEXT PAGE ID */ + geOverflowrangeptr.i = fragrecptr.p->overflowdir; + ptrCheckGuard(geOverflowrangeptr, cdirrangesize, dirRange); + arrGuard((tgeActivePageDir >> 8), 256); + geOverflowDirptr.i = geOverflowrangeptr.p->dirArray[tgeActivePageDir >> 8]; + ptrCheckGuard(geOverflowDirptr, cdirarraysize, directoryarray); + gePageptr.i = geOverflowDirptr.p->pagep[tgeActivePageDir & 0xff]; + ptrCheckGuard(gePageptr, cpagesize, page8); + }//if + } while (1); + return; +}//Dbacc::getElement() + +/* --------------------------------------------------------------------------------- */ +/* SEARCH_LONG_KEY */ +/* INPUT: */ +/* TSLC_PAGEDIR PAGE DIRECTORY OF LONG PAGE */ +/* TSLC_PAGE_INDEX PAGE INDEX IN LONG PAGE */ +/* GE_OPERATION_REC_PTR */ +/* OUTPUT: */ +/* TSLC_RESULT */ +/* DESCRIPTION: SEARCH FOR AN ELEMENT IN A LONG_KEY_PAGE. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::searchLongKey(Signal* signal) +{ + DirRangePtr slcOverflowrangeptr; + DirectoryarrayPtr slcOverflowDirptr; + Page8Ptr slcPageptr; + Uint32 tslcIndexValue; + Uint32 tslcStartIndex; + Uint32 tslcIndex; + Uint32 guard30; + Uint32* Tkeydata = (Uint32*)&signal->theData[7]; + + + slcOverflowrangeptr.i = fragrecptr.p->overflowdir; + ptrCheckGuard(slcOverflowrangeptr, cdirrangesize, dirRange); + arrGuard((tslcPagedir >> 8), 256); + slcOverflowDirptr.i = slcOverflowrangeptr.p->dirArray[tslcPagedir >> 8]; + ptrCheckGuard(slcOverflowDirptr, cdirarraysize, directoryarray); + + // dbgWord32(slcOverflowDirptr, (int) (tslcPagedir & 0xff), slcOverflowDirptr.p->pagep[tslcPagedir & 0xff]); + + slcPageptr.i = slcOverflowDirptr.p->pagep[tslcPagedir & 0xff]; + ptrCheckGuard(slcPageptr, cpagesize, page8); + arrGuard(ZWORDS_IN_PAGE - tslcPageIndex, 2048); + dbgWord32(slcPageptr, ZWORDS_IN_PAGE - tslcPageIndex, (int)slcPageptr.p->word32[ZWORDS_IN_PAGE - tslcPageIndex] & 0xffff); + dbgWord32(slcPageptr, ZWORDS_IN_PAGE - tslcPageIndex, slcPageptr.p->word32[ZWORDS_IN_PAGE - tslcPageIndex] >> 16); + tslcIndexValue = slcPageptr.p->word32[ZWORDS_IN_PAGE - tslcPageIndex]; + if ((tslcIndexValue >> 16) != operationRecPtr.p->tupkeylen) { + jam(); + tslcResult = ZFALSE; + return; + }//if + tslcStartIndex = tslcIndexValue & 0xffff; + guard30 = operationRecPtr.p->tupkeylen - 1; + arrGuard(guard30, 2048); + arrGuard(guard30 + tslcStartIndex, 2048); + for (tslcIndex = 0; tslcIndex <= guard30; tslcIndex++) { + dbgWord32(slcPageptr, tslcIndex + tslcStartIndex, slcPageptr.p->word32[tslcIndex + tslcStartIndex]); + if (slcPageptr.p->word32[tslcIndex + tslcStartIndex] != Tkeydata[tslcIndex]) { + jam(); + tslcResult = ZFALSE; + return; + }//if + }//for + jam(); + tslcResult = ZTRUE; + operationRecPtr.p->longPagePtr = slcPageptr.i; + operationRecPtr.p->longKeyPageIndex = tslcPageIndex; + arrGuard(tslcPageIndex, ZMAX_NO_OF_LONGKEYS_IN_PAGE); + arrGuard(slcPageptr.i, cpagesize); +}//Dbacc::searchLongKey() + +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* END OF GET_ELEMENT MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* MODULE: DELETE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* COMMITDELETE */ +/* INPUT: OPERATION_REC_PTR, PTR TO AN OPERATION RECORD. */ +/* FRAGRECPTR, PTR TO A FRAGMENT RECORD */ +/* */ +/* OUTPUT: */ +/* NONE */ +/* DESCRIPTION: DELETE OPERATIONS WILL BE COMPLETED AT THE COMMIT OF TRANSA- */ +/* CTION. THIS SUBROUTINE SEARCHS FOR ELEMENT AND DELETES IT. IT DOES SO BY */ +/* REPLACING IT WITH THE LAST ELEMENT IN THE BUCKET. IF THE DELETED ELEMENT */ +/* IS ALSO THE LAST ELEMENT THEN IT IS ONLY NECESSARY TO REMOVE THE ELEMENT. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::commitdelete(Signal* signal, bool systemRestart) +{ + if (!systemRestart) { + jam(); + signal->theData[0] = fragrecptr.p->myfid; + signal->theData[1] = fragrecptr.p->myTableId; + signal->theData[2] = operationRecPtr.p->localdata[0]; + Uint32 localKey = operationRecPtr.p->localdata[0]; + Uint32 pageId = localKey >> MAX_TUPLES_BITS; + Uint32 pageIndex = localKey & ((1 << MAX_TUPLES_BITS) - 1); + signal->theData[2] = pageId; + signal->theData[3] = pageIndex; + EXECUTE_DIRECT(DBTUP, GSN_TUP_DEALLOCREQ, signal, 4); + jamEntry(); + }//if + if (fragrecptr.p->keyLength == 0) { + jam(); + tdlkLogicalPageIndex = operationRecPtr.p->longKeyPageIndex; + dlkPageptr.i = operationRecPtr.p->longPagePtr; + ptrCheckGuard(dlkPageptr, cpagesize, page8); + deleteLongKey(signal); + }//if + getdirindex(signal); + tlastPageindex = tgdiPageindex; + lastPageptr.i = gdiPageptr.i; + lastPageptr.p = gdiPageptr.p; + tlastForward = ZTRUE; + tlastContainerptr = (tlastPageindex << ZSHIFT_PLUS) - (tlastPageindex << ZSHIFT_MINUS); + tlastContainerptr = tlastContainerptr + ZHEAD_SIZE; + arrGuard(tlastContainerptr, 2048); + tlastContainerhead = lastPageptr.p->word32[tlastContainerptr]; + tlastContainerlen = tlastContainerhead >> 26; + lastPrevpageptr.i = RNIL; + ptrNull(lastPrevpageptr); + tlastPrevconptr = 0; + getLastAndRemove(signal); + + delPageptr.i = operationRecPtr.p->elementPage; + ptrCheckGuard(delPageptr, cpagesize, page8); + tdelElementptr = operationRecPtr.p->elementPointer; + /* --------------------------------------------------------------------------------- */ + // Here we have to take extreme care since we do not want locks to end up after the + // log execution. Thus it is necessary to put back the element in unlocked shape. + // We thus update the element header to ensure we log an unlocked element. We do not + // need to restore it later since it is deleted immediately anyway. + /* --------------------------------------------------------------------------------- */ + const Uint32 hv = operationRecPtr.p->hashvaluePart; + const Uint32 eh = ElementHeader::setUnlocked(hv, 0); + delPageptr.p->word32[tdelElementptr] = eh; + if (operationRecPtr.p->elementPage == lastPageptr.i) { + if (operationRecPtr.p->elementPointer == tlastElementptr) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THE LAST ELEMENT WAS THE ELEMENT TO BE DELETED. WE NEED NOT COPY IT. */ + /* --------------------------------------------------------------------------------- */ + return; + }//if + }//if + /* --------------------------------------------------------------------------------- */ + /* THE DELETED ELEMENT IS NOT THE LAST. WE READ THE LAST ELEMENT AND OVERWRITE THE */ + /* DELETED ELEMENT. */ + /* --------------------------------------------------------------------------------- */ + tdelContainerptr = operationRecPtr.p->elementContainer; + tdelForward = operationRecPtr.p->elementIsforward; + deleteElement(signal); +}//Dbacc::commitdelete() + +/* --------------------------------------------------------------------------------- */ +/* DELETE_ELEMENT */ +/* INPUT: FRAGRECPTR, POINTER TO A FRAGMENT RECORD */ +/* LAST_PAGEPTR, POINTER TO THE PAGE OF THE LAST ELEMENT */ +/* DEL_PAGEPTR, POINTER TO THE PAGE OF THE DELETED ELEMENT */ +/* TLAST_ELEMENTPTR, ELEMENT POINTER OF THE LAST ELEMENT */ +/* TDEL_ELEMENTPTR, ELEMENT POINTER OF THE DELETED ELEMENT */ +/* TLAST_FORWARD, DIRECTION OF LAST ELEMENT */ +/* TDEL_FORWARD, DIRECTION OF DELETED ELEMENT */ +/* TDEL_CONTAINERPTR, CONTAINER POINTER OF DELETED ELEMENT */ +/* DESCRIPTION: COPY LAST ELEMENT TO DELETED ELEMENT AND UPDATE UNDO LOG AND */ +/* UPDATE ANY ACTIVE OPERATION ON THE MOVED ELEMENT. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::deleteElement(Signal* signal) +{ + OperationrecPtr deOperationRecPtr; + Uint32 tdeIndex; + Uint32 tlastMoveElemptr; + Uint32 tdelMoveElemptr; + Uint32 guard31; + + if (tlastElementptr >= 2048) + goto deleteElement_index_error1; + { + const Uint32 tdeElemhead = lastPageptr.p->word32[tlastElementptr]; + if (fragrecptr.p->createLcp == ZTRUE) { + datapageptr.p = delPageptr.p; + cundoinfolength = fragrecptr.p->elementLength; + if (tdelForward == ZTRUE) { + jam(); + cundoElemIndex = tdelElementptr; + } else { + jam(); + cundoElemIndex = (tdelElementptr + 1) - fragrecptr.p->elementLength; + }//if + undoWritingProcess(signal); + }//if + tlastMoveElemptr = tlastElementptr; + tdelMoveElemptr = tdelElementptr; + guard31 = fragrecptr.p->elementLength - 1; + for (tdeIndex = 0; tdeIndex <= guard31; tdeIndex++) { + dbgWord32(delPageptr, tdelMoveElemptr, lastPageptr.p->word32[tlastMoveElemptr]); + if ((tlastMoveElemptr >= 2048) || + (tdelMoveElemptr >= 2048)) + goto deleteElement_index_error2; + delPageptr.p->word32[tdelMoveElemptr] = lastPageptr.p->word32[tlastMoveElemptr]; + tdelMoveElemptr = tdelMoveElemptr + tdelForward; + tlastMoveElemptr = tlastMoveElemptr + tlastForward; + }//for + if (ElementHeader::getLocked(tdeElemhead)) { + /* --------------------------------------------------------------------------------- */ + /* THE LAST ELEMENT IS LOCKED AND IS THUS REFERENCED BY AN OPERATION RECORD. WE NEED */ + /* TO UPDATE THE OPERATION RECORD WITH THE NEW REFERENCE TO THE ELEMENT. */ + /* --------------------------------------------------------------------------------- */ + deOperationRecPtr.i = ElementHeader::getOpPtrI(tdeElemhead); + ptrCheckGuard(deOperationRecPtr, coprecsize, operationrec); + if (cundoLogActive == ZFALSE) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* WE DO NOT BOTHER WITH THIS INFORMATION DURING EXECUTION OF THE UNDO LOG. */ + /* --------------------------------------------------------------------------------- */ + deOperationRecPtr.p->elementPage = delPageptr.i; + deOperationRecPtr.p->elementContainer = tdelContainerptr; + deOperationRecPtr.p->elementPointer = tdelElementptr; + deOperationRecPtr.p->elementIsforward = tdelForward; + }//if + /* --------------------------------------------------------------------------------- */ + // We need to take extreme care to not install locked records after system restart. + // An undo of the delete will reinstall the moved record. We have to ensure that the + // lock is removed to ensure that no such thing happen. + /* --------------------------------------------------------------------------------- */ + Uint32 eh = ElementHeader::setUnlocked(deOperationRecPtr.p->hashvaluePart, + 0); + lastPageptr.p->word32[tlastElementptr] = eh; + }//if + return; + } + + deleteElement_index_error1: + arrGuard(tlastElementptr, 2048); + return; + + deleteElement_index_error2: + arrGuard(tdelMoveElemptr + guard31, 2048); + arrGuard(tlastMoveElemptr, 2048); + return; + +}//Dbacc::deleteElement() + +/* --------------------------------------------------------------------------------- */ +/* GET_LAST_AND_REMOVE */ +/* INPUT: */ +/* LAST_PAGEPTR PAGE POINTER OF FIRST CONTAINER IN SEARCH OF LAST*/ +/* TLAST_CONTAINERPTR CONTAINER INDEX OF THE SAME */ +/* TLAST_CONTAINERHEAD CONTAINER HEADER OF THE SAME */ +/* TLAST_PAGEINDEX PAGE INDEX OF THE SAME */ +/* TLAST_FORWARD CONTAINER DIRECTION OF THE SAME */ +/* TLAST_CONTAINERLEN CONTAINER LENGTH OF THE SAME */ +/* LAST_PREVPAGEPTR PAGE POINTER OF PREVIOUS CONTAINER OF THE SAME */ +/* TLAST_PREVCONPTR CONTAINER INDEX OF PREVIOUS CONTAINER OF THE SAME*/ +/* */ +/* OUTPUT: */ +/* ALL VARIABLES FROM INPUT BUT NOW CONTAINING INFO ABOUT LAST */ +/* CONTAINER. */ +/* TLAST_ELEMENTPTR LAST ELEMENT POINTER IN LAST CONTAINER */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::getLastAndRemove(Signal* signal) +{ + DirRangePtr glrOverflowrangeptr; + DirectoryarrayPtr glrOverflowDirptr; + Uint32 tglrHead; + Uint32 tglrTmp; + + GLR_LOOP_10: + if (((tlastContainerhead >> 7) & 0x3) != 0) { + jam(); + lastPrevpageptr.i = lastPageptr.i; + lastPrevpageptr.p = lastPageptr.p; + tlastPrevconptr = tlastContainerptr; + tlastPageindex = tlastContainerhead & 0x7f; + if (((tlastContainerhead >> 9) & 0x1) == ZFALSE) { + jam(); + arrGuard(tlastContainerptr + 1, 2048); + tglrTmp = lastPageptr.p->word32[tlastContainerptr + 1]; + glrOverflowrangeptr.i = fragrecptr.p->overflowdir; + ptrCheckGuard(glrOverflowrangeptr, cdirrangesize, dirRange); + arrGuard((tglrTmp >> 8), 256); + glrOverflowDirptr.i = glrOverflowrangeptr.p->dirArray[tglrTmp >> 8]; + ptrCheckGuard(glrOverflowDirptr, cdirarraysize, directoryarray); + lastPageptr.i = glrOverflowDirptr.p->pagep[tglrTmp & 0xff]; + ptrCheckGuard(lastPageptr, cpagesize, page8); + }//if + tlastContainerptr = (tlastPageindex << ZSHIFT_PLUS) - (tlastPageindex << ZSHIFT_MINUS); + if (((tlastContainerhead >> 7) & 3) == ZLEFT) { + jam(); + tlastForward = ZTRUE; + tlastContainerptr = tlastContainerptr + ZHEAD_SIZE; + } else if (((tlastContainerhead >> 7) & 3) == ZRIGHT) { + jam(); + tlastForward = cminusOne; + tlastContainerptr = ((tlastContainerptr + ZHEAD_SIZE) + ZBUF_SIZE) - ZCON_HEAD_SIZE; + } else { + ndbrequire(false); + return; + }//if + arrGuard(tlastContainerptr, 2048); + tlastContainerhead = lastPageptr.p->word32[tlastContainerptr]; + tlastContainerlen = tlastContainerhead >> 26; + ndbrequire(tlastContainerlen >= ((Uint32)ZCON_HEAD_SIZE + fragrecptr.p->elementLength)); + goto GLR_LOOP_10; + }//if + tlastContainerlen = tlastContainerlen - fragrecptr.p->elementLength; + if (tlastForward == ZTRUE) { + jam(); + tlastElementptr = tlastContainerptr + tlastContainerlen; + } else { + jam(); + tlastElementptr = (tlastContainerptr + (ZCON_HEAD_SIZE - 1)) - tlastContainerlen; + }//if + rlPageptr.i = lastPageptr.i; + rlPageptr.p = lastPageptr.p; + trlPageindex = tlastPageindex; + if (((tlastContainerhead >> 10) & 1) == 1) { + /* --------------------------------------------------------------------------------- */ + /* WE HAVE OWNERSHIP OF BOTH PARTS OF THE CONTAINER ENDS. */ + /* --------------------------------------------------------------------------------- */ + if (tlastContainerlen < ZDOWN_LIMIT) { + /* --------------------------------------------------------------------------------- */ + /* WE HAVE DECREASED THE SIZE BELOW THE DOWN LIMIT, WE MUST GIVE UP THE OTHER */ + /* SIDE OF THE BUFFER. */ + /* --------------------------------------------------------------------------------- */ + tlastContainerhead = tlastContainerhead ^ (1 << 10); + trlRelCon = ZFALSE; + if (tlastForward == ZTRUE) { + jam(); + turlIndex = tlastContainerptr + (ZBUF_SIZE - ZCON_HEAD_SIZE); + releaseRightlist(signal); + } else { + jam(); + tullIndex = tlastContainerptr - (ZBUF_SIZE - ZCON_HEAD_SIZE); + releaseLeftlist(signal); + }//if + }//if + }//if + if (tlastContainerlen <= 2) { + ndbrequire(tlastContainerlen == 2); + if (lastPrevpageptr.i != RNIL) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THE LAST CONTAINER IS EMPTY AND IS NOT THE FIRST CONTAINER WHICH IS NOT REMOVED. */ + /* DELETE THE LAST CONTAINER AND UPDATE THE PREVIOUS CONTAINER. ALSO PUT THIS */ + /* CONTAINER IN FREE CONTAINER LIST OF THE PAGE. */ + /* --------------------------------------------------------------------------------- */ + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + datapageptr.p = lastPrevpageptr.p; + cundoElemIndex = tlastPrevconptr; + cundoinfolength = 1; + undoWritingProcess(signal); + }//if + ndbrequire(tlastPrevconptr < 2048); + tglrTmp = lastPrevpageptr.p->word32[tlastPrevconptr] >> 9; + dbgWord32(lastPrevpageptr, tlastPrevconptr, tglrTmp << 9); + lastPrevpageptr.p->word32[tlastPrevconptr] = tglrTmp << 9; + trlRelCon = ZTRUE; + if (tlastForward == ZTRUE) { + jam(); + tullIndex = tlastContainerptr; + releaseLeftlist(signal); + } else { + jam(); + turlIndex = tlastContainerptr; + releaseRightlist(signal); + }//if + return; + }//if + }//if + tglrHead = tlastContainerhead << 6; + tglrHead = tglrHead >> 6; + tglrHead = tglrHead | (tlastContainerlen << 26); + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + datapageptr.p = lastPageptr.p; + cundoElemIndex = tlastContainerptr; + cundoinfolength = 1; + undoWritingProcess(signal); + }//if + dbgWord32(lastPageptr, tlastContainerptr, tglrHead); + arrGuard(tlastContainerptr, 2048); + lastPageptr.p->word32[tlastContainerptr] = tglrHead; +}//Dbacc::getLastAndRemove() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_LEFTLIST */ +/* INPUT: */ +/* RL_PAGEPTR PAGE POINTER OF CONTAINER TO BE RELEASED */ +/* TRL_PAGEINDEX PAGE INDEX OF CONTAINER TO BE RELEASED */ +/* TURL_INDEX INDEX OF CONTAINER TO BE RELEASED */ +/* TRL_REL_CON TRUE IF CONTAINER RELEASED OTHERWISE ONLY */ +/* A PART IS RELEASED. */ +/* */ +/* OUTPUT: */ +/* NONE */ +/* */ +/* THE FREE LIST OF LEFT FREE BUFFER IN THE PAGE WILL BE UPDATE */ +/* TULL_INDEX IS INDEX TO THE FIRST WORD IN THE LEFT SIDE OF THE BUFFER */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseLeftlist(Signal* signal) +{ + Uint32 tullTmp; + Uint32 tullTmp1; + + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + datapageptr.p = rlPageptr.p; + cundoElemIndex = tullIndex; + cundoinfolength = 2; + undoWritingProcess(signal); + }//if + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + cundoElemIndex = ZPOS_EMPTY_LIST; + cundoinfolength = 2; + undoWritingProcess(signal); + }//if + /* --------------------------------------------------------------------------------- */ + /* IF A CONTAINER IS RELEASED AND NOT ONLY A PART THEN WE HAVE TO REMOVE IT */ + /* FROM THE LIST OF USED CONTAINERS IN THE PAGE. THIS IN ORDER TO ENSURE THAT */ + /* WE CAN FIND ALL LOCKED ELEMENTS DURING LOCAL CHECKPOINT. */ + /* --------------------------------------------------------------------------------- */ + if (trlRelCon == ZTRUE) { + arrGuard(tullIndex, 2048); + trlHead = rlPageptr.p->word32[tullIndex]; + trlNextused = (trlHead >> 11) & 0x7f; + trlPrevused = (trlHead >> 18) & 0x7f; + if (trlNextused < ZEMPTYLIST) { + jam(); + tullTmp1 = (trlNextused << ZSHIFT_PLUS) - (trlNextused << ZSHIFT_MINUS); + tullTmp1 = tullTmp1 + ZHEAD_SIZE; + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + cundoElemIndex = tullTmp1; + cundoinfolength = 1; + undoWritingProcess(signal); + }//if + tullTmp = rlPageptr.p->word32[tullTmp1] & 0xfe03ffff; + dbgWord32(rlPageptr, tullTmp1, tullTmp | (trlPrevused << 18)); + rlPageptr.p->word32[tullTmp1] = tullTmp | (trlPrevused << 18); + } else { + ndbrequire(trlNextused == ZEMPTYLIST); + jam(); + }//if + if (trlPrevused < ZEMPTYLIST) { + jam(); + tullTmp1 = (trlPrevused << ZSHIFT_PLUS) - (trlPrevused << ZSHIFT_MINUS); + tullTmp1 = tullTmp1 + ZHEAD_SIZE; + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + cundoElemIndex = tullTmp1; + cundoinfolength = 1; + undoWritingProcess(signal); + }//if + tullTmp = rlPageptr.p->word32[tullTmp1] & 0xfffc07ff; + dbgWord32(rlPageptr, tullTmp1, tullTmp | (trlNextused << 11)); + rlPageptr.p->word32[tullTmp1] = tullTmp | (trlNextused << 11); + } else { + ndbrequire(trlPrevused == ZEMPTYLIST); + jam(); + /* --------------------------------------------------------------------------------- */ + /* WE ARE FIRST IN THE LIST AND THUS WE NEED TO UPDATE THE FIRST POINTER. */ + /* --------------------------------------------------------------------------------- */ + tullTmp = rlPageptr.p->word32[ZPOS_EMPTY_LIST] & 0xc07fffff; + dbgWord32(rlPageptr, ZPOS_EMPTY_LIST, tullTmp | (trlNextused << 23)); + rlPageptr.p->word32[ZPOS_EMPTY_LIST] = tullTmp | (trlNextused << 23); + }//if + }//if + dbgWord32(rlPageptr, tullIndex + 1, ZEMPTYLIST); + arrGuard(tullIndex + 1, 2048); + rlPageptr.p->word32[tullIndex + 1] = ZEMPTYLIST; + tullTmp1 = (rlPageptr.p->word32[ZPOS_EMPTY_LIST] >> 7) & 0x7f; + dbgWord32(rlPageptr, tullIndex, tullTmp1); + arrGuard(tullIndex, 2048); + rlPageptr.p->word32[tullIndex] = tullTmp1; + if (tullTmp1 < ZEMPTYLIST) { + jam(); + tullTmp1 = (tullTmp1 << ZSHIFT_PLUS) - (tullTmp1 << ZSHIFT_MINUS); + tullTmp1 = (tullTmp1 + ZHEAD_SIZE) + 1; + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + cundoElemIndex = tullTmp1; + cundoinfolength = 1; + undoWritingProcess(signal); + }//if + dbgWord32(rlPageptr, tullTmp1, trlPageindex); + rlPageptr.p->word32[tullTmp1] = trlPageindex; /* UPDATES PREV POINTER IN THE NEXT FREE */ + } else { + ndbrequire(tullTmp1 == ZEMPTYLIST); + }//if + tullTmp = rlPageptr.p->word32[ZPOS_EMPTY_LIST]; + tullTmp = (((tullTmp >> 14) << 14) | (trlPageindex << 7)) | (tullTmp & 0x7f); + dbgWord32(rlPageptr, ZPOS_EMPTY_LIST, tullTmp); + rlPageptr.p->word32[ZPOS_EMPTY_LIST] = tullTmp; + dbgWord32(rlPageptr, ZPOS_ALLOC_CONTAINERS, rlPageptr.p->word32[ZPOS_ALLOC_CONTAINERS] - 1); + rlPageptr.p->word32[ZPOS_ALLOC_CONTAINERS] = rlPageptr.p->word32[ZPOS_ALLOC_CONTAINERS] - 1; + ndbrequire(rlPageptr.p->word32[ZPOS_ALLOC_CONTAINERS] <= ZNIL); + if (((rlPageptr.p->word32[ZPOS_EMPTY_LIST] >> ZPOS_PAGE_TYPE_BIT) & 3) == 1) { + jam(); + colPageptr.i = rlPageptr.i; + colPageptr.p = rlPageptr.p; + ptrCheck(colPageptr, cpagesize, page8); + checkoverfreelist(signal); + }//if +}//Dbacc::releaseLeftlist() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_RIGHTLIST */ +/* INPUT: */ +/* RL_PAGEPTR PAGE POINTER OF CONTAINER TO BE RELEASED */ +/* TRL_PAGEINDEX PAGE INDEX OF CONTAINER TO BE RELEASED */ +/* TURL_INDEX INDEX OF CONTAINER TO BE RELEASED */ +/* TRL_REL_CON TRUE IF CONTAINER RELEASED OTHERWISE ONLY */ +/* A PART IS RELEASED. */ +/* */ +/* OUTPUT: */ +/* NONE */ +/* */ +/* THE FREE LIST OF RIGHT FREE BUFFER IN THE PAGE WILL BE UPDATE. */ +/* TURL_INDEX IS INDEX TO THE FIRST WORD IN THE RIGHT SIDE OF */ +/* THE BUFFER, WHICH IS THE LAST WORD IN THE BUFFER. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseRightlist(Signal* signal) +{ + Uint32 turlTmp1; + Uint32 turlTmp; + + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + datapageptr.p = rlPageptr.p; + cundoElemIndex = turlIndex; + cundoinfolength = 2; + undoWritingProcess(signal); + }//if + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + cundoElemIndex = ZPOS_EMPTY_LIST; + cundoinfolength = 2; + undoWritingProcess(signal); + }//if + /* --------------------------------------------------------------------------------- */ + /* IF A CONTAINER IS RELEASED AND NOT ONLY A PART THEN WE HAVE TO REMOVE IT */ + /* FROM THE LIST OF USED CONTAINERS IN THE PAGE. THIS IN ORDER TO ENSURE THAT */ + /* WE CAN FIND ALL LOCKED ELEMENTS DURING LOCAL CHECKPOINT. */ + /* --------------------------------------------------------------------------------- */ + if (trlRelCon == ZTRUE) { + jam(); + arrGuard(turlIndex, 2048); + trlHead = rlPageptr.p->word32[turlIndex]; + trlNextused = (trlHead >> 11) & 0x7f; + trlPrevused = (trlHead >> 18) & 0x7f; + if (trlNextused < ZEMPTYLIST) { + jam(); + turlTmp1 = (trlNextused << ZSHIFT_PLUS) - (trlNextused << ZSHIFT_MINUS); + turlTmp1 = turlTmp1 + ((ZHEAD_SIZE + ZBUF_SIZE) - ZCON_HEAD_SIZE); + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + cundoElemIndex = turlTmp1; + cundoinfolength = 1; + undoWritingProcess(signal); + }//if + turlTmp = rlPageptr.p->word32[turlTmp1] & 0xfe03ffff; + dbgWord32(rlPageptr, turlTmp1, turlTmp | (trlPrevused << 18)); + rlPageptr.p->word32[turlTmp1] = turlTmp | (trlPrevused << 18); + } else { + ndbrequire(trlNextused == ZEMPTYLIST); + jam(); + }//if + if (trlPrevused < ZEMPTYLIST) { + jam(); + turlTmp1 = (trlPrevused << ZSHIFT_PLUS) - (trlPrevused << ZSHIFT_MINUS); + turlTmp1 = turlTmp1 + ((ZHEAD_SIZE + ZBUF_SIZE) - ZCON_HEAD_SIZE); + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + cundoElemIndex = turlTmp1; + cundoinfolength = 1; + undoWritingProcess(signal); + }//if + turlTmp = rlPageptr.p->word32[turlTmp1] & 0xfffc07ff; + dbgWord32(rlPageptr, turlTmp1, turlTmp | (trlNextused << 11)); + rlPageptr.p->word32[turlTmp1] = turlTmp | (trlNextused << 11); + } else { + ndbrequire(trlPrevused == ZEMPTYLIST); + jam(); + /* --------------------------------------------------------------------------------- */ + /* WE ARE FIRST IN THE LIST AND THUS WE NEED TO UPDATE THE FIRST POINTER */ + /* OF THE RIGHT CONTAINER LIST. */ + /* --------------------------------------------------------------------------------- */ + turlTmp = rlPageptr.p->word32[ZPOS_EMPTY_LIST] & 0xff80ffff; + dbgWord32(rlPageptr, ZPOS_EMPTY_LIST, turlTmp | (trlNextused << 16)); + rlPageptr.p->word32[ZPOS_EMPTY_LIST] = turlTmp | (trlNextused << 16); + }//if + }//if + dbgWord32(rlPageptr, turlIndex + 1, ZEMPTYLIST); + arrGuard(turlIndex + 1, 2048); + rlPageptr.p->word32[turlIndex + 1] = ZEMPTYLIST; + turlTmp1 = rlPageptr.p->word32[ZPOS_EMPTY_LIST] & 0x7f; + dbgWord32(rlPageptr, turlIndex, turlTmp1); + arrGuard(turlIndex, 2048); + rlPageptr.p->word32[turlIndex] = turlTmp1; + if (turlTmp1 < ZEMPTYLIST) { + jam(); + turlTmp = (turlTmp1 << ZSHIFT_PLUS) - (turlTmp1 << ZSHIFT_MINUS); + turlTmp = turlTmp + ((ZHEAD_SIZE + ZBUF_SIZE) - (ZCON_HEAD_SIZE - 1)); + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + cundoElemIndex = turlTmp; + cundoinfolength = 1; + undoWritingProcess(signal); + }//if + dbgWord32(rlPageptr, turlTmp, trlPageindex); + rlPageptr.p->word32[turlTmp] = trlPageindex; /* UPDATES PREV POINTER IN THE NEXT FREE */ + } else { + ndbrequire(turlTmp1 == ZEMPTYLIST); + }//if + turlTmp = rlPageptr.p->word32[ZPOS_EMPTY_LIST]; + dbgWord32(rlPageptr, ZPOS_EMPTY_LIST, ((turlTmp >> 7) << 7) | trlPageindex); + rlPageptr.p->word32[ZPOS_EMPTY_LIST] = ((turlTmp >> 7) << 7) | trlPageindex; + dbgWord32(rlPageptr, ZPOS_ALLOC_CONTAINERS, rlPageptr.p->word32[ZPOS_ALLOC_CONTAINERS] - 1); + rlPageptr.p->word32[ZPOS_ALLOC_CONTAINERS] = rlPageptr.p->word32[ZPOS_ALLOC_CONTAINERS] - 1; + ndbrequire(rlPageptr.p->word32[ZPOS_ALLOC_CONTAINERS] <= ZNIL); + if (((rlPageptr.p->word32[ZPOS_EMPTY_LIST] >> ZPOS_PAGE_TYPE_BIT) & 3) == 1) { + jam(); + colPageptr.i = rlPageptr.i; + colPageptr.p = rlPageptr.p; + checkoverfreelist(signal); + }//if +}//Dbacc::releaseRightlist() + +/* --------------------------------------------------------------------------------- */ +/* CHECKOVERFREELIST */ +/* INPUT: COL_PAGEPTR, POINTER OF AN OVERFLOW PAGE RECORD. */ +/* DESCRIPTION: CHECKS IF THE PAGE HAVE TO PUT IN FREE LIST OF OVER FLOW */ +/* PAGES. WHEN IT HAVE TO, AN OVERFLOW REC PTR WILL BE ALLOCATED */ +/* TO KEEP NFORMATION ABOUT THE PAGE. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::checkoverfreelist(Signal* signal) +{ + Uint32 tcolTmp; + + if (fragrecptr.p->loadingFlag == ZFALSE) { + tcolTmp = colPageptr.p->word32[ZPOS_ALLOC_CONTAINERS]; + if (tcolTmp <= ZFREE_LIMIT) { + if (tcolTmp == 0) { + jam(); + ropPageptr = colPageptr; + releaseOverpage(signal); + } else { + jam(); + if (colPageptr.p->word32[ZPOS_OVERFLOWREC] == RNIL) { + ndbrequire(cfirstfreeoverrec != RNIL); + jam(); + seizeOverRec(signal); + sorOverflowRecPtr.p->dirindex = colPageptr.p->word32[ZPOS_PAGE_ID]; + sorOverflowRecPtr.p->overpage = colPageptr.i; + dbgWord32(colPageptr, ZPOS_OVERFLOWREC, sorOverflowRecPtr.i); + colPageptr.p->word32[ZPOS_OVERFLOWREC] = sorOverflowRecPtr.i; + porOverflowRecPtr = sorOverflowRecPtr; + putOverflowRecInFrag(signal); + }//if + }//if + }//if + }//if +}//Dbacc::checkoverfreelist() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_LONG_PAGE */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseLongPage(Signal* signal) +{ + DirRangePtr rlpOverflowrangeptr; + DirectoryarrayPtr rlpOverflowDirptr; + Uint32 trlpTmp1; + Uint32 trlpTmp2; + Uint32 trlpTmp3; + + jam(); + seizeOverRec(signal); + sorOverflowRecPtr.p->dirindex = rlopPageptr.p->word32[ZPOS_PAGE_ID]; + sorOverflowRecPtr.p->overpage = RNIL; + priOverflowRecPtr = sorOverflowRecPtr; + putRecInFreeOverdir(signal); + trlpTmp1 = sorOverflowRecPtr.p->dirindex; + rlpOverflowrangeptr.i = fragrecptr.p->overflowdir; + trlpTmp2 = trlpTmp1 >> 8; + trlpTmp3 = trlpTmp1 & 0xff; + ptrCheckGuard(rlpOverflowrangeptr, cdirrangesize, dirRange); + arrGuard(trlpTmp2, 256); + rlpOverflowDirptr.i = rlpOverflowrangeptr.p->dirArray[trlpTmp2]; + ptrCheckGuard(rlpOverflowDirptr, cdirarraysize, directoryarray); + rlpOverflowDirptr.p->pagep[trlpTmp3] = RNIL; + + if (cundoLogActive != ZTRUE) { + // Remove from page array. + trfpArrayPos = rlopPageptr.p->word32[ZPOS_ARRAY_POS]; + rfpPageptr = rlopPageptr; + removeFromPageArrayList(signal); + } + + // Reset page header + iloPageptr = rlopPageptr; + tiloIndex = rlopPageptr.p->word32[ZPOS_PAGE_ID]; + initLongOverpage(signal); + + rpPageptr = rlopPageptr; + releasePage(signal); +}//Dbacc::releaseLongPage() + + +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* */ +/* END OF DELETE MODULE */ +/* */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* */ +/* COMMIT AND ABORT MODULE */ +/* */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* ABORT_OPERATION */ +/*DESCRIPTION: AN OPERATION RECORD CAN BE IN A LOCK QUEUE OF AN ELEMENT OR */ +/*OWNS THE LOCK. BY THIS SUBROUTINE THE LOCK STATE OF THE OPERATION WILL */ +/*BE CHECKED. THE OPERATION RECORD WILL BE REMOVED FROM THE QUEUE IF IT */ +/*BELONGED TO ANY ONE, OTHERWISE THE ELEMENT HEAD WILL BE UPDATED. */ +/* ------------------------------------------------------------------------- */ +void Dbacc::abortOperation(Signal* signal) +{ + OperationrecPtr aboOperRecPtr; + OperationrecPtr TaboOperRecPtr; + Page8Ptr aboPageidptr; + Uint32 taboElementptr; + Uint32 tmp2Olq; + + if (operationRecPtr.p->lockOwner == ZTRUE) { + takeOutLockOwnersList(signal, operationRecPtr); + if (operationRecPtr.p->insertIsDone == ZTRUE) { + jam(); + operationRecPtr.p->elementIsDisappeared = ZTRUE; + }//if + if ((operationRecPtr.p->nextParallelQue != RNIL) || + (operationRecPtr.p->nextSerialQue != RNIL)) { + jam(); + releaselock(signal); + } else { + /* --------------------------------------------------------------------------------- */ + /* WE ARE OWNER OF THE LOCK AND NO OTHER OPERATIONS ARE QUEUED. IF INSERT OR STANDBY */ + /* WE DELETE THE ELEMENT OTHERWISE WE REMOVE THE LOCK FROM THE ELEMENT. */ + /* --------------------------------------------------------------------------------- */ + if (operationRecPtr.p->elementIsDisappeared == ZFALSE) { + jam(); + taboElementptr = operationRecPtr.p->elementPointer; + aboPageidptr.i = operationRecPtr.p->elementPage; + tmp2Olq = ElementHeader::setUnlocked(operationRecPtr.p->hashvaluePart, + operationRecPtr.p->scanBits); + ptrCheckGuard(aboPageidptr, cpagesize, page8); + dbgWord32(aboPageidptr, taboElementptr, tmp2Olq); + arrGuard(taboElementptr, 2048); + aboPageidptr.p->word32[taboElementptr] = tmp2Olq; + return; + } else { + jam(); + commitdelete(signal, false); + }//if + }//if + } else { + /* --------------------------------------------------------------- */ + // We are not the lock owner. + /* --------------------------------------------------------------- */ + jam(); + takeOutFragWaitQue(signal); + if (operationRecPtr.p->prevParallelQue != RNIL) { + jam(); + /* ---------------------------------------------------------------------------------- */ + /* SINCE WE ARE NOT QUEUE LEADER WE NEED NOT CONSIDER IF THE ELEMENT IS TO BE DELETED.*/ + /* We will simply remove it from the parallel list without any other rearrangements. */ + /* ---------------------------------------------------------------------------------- */ + aboOperRecPtr.i = operationRecPtr.p->prevParallelQue; + ptrCheckGuard(aboOperRecPtr, coprecsize, operationrec); + aboOperRecPtr.p->nextParallelQue = operationRecPtr.p->nextParallelQue; + if (operationRecPtr.p->nextParallelQue != RNIL) { + jam(); + aboOperRecPtr.i = operationRecPtr.p->nextParallelQue; + ptrCheckGuard(aboOperRecPtr, coprecsize, operationrec); + aboOperRecPtr.p->prevParallelQue = operationRecPtr.p->prevParallelQue; + }//if + } else if (operationRecPtr.p->prevSerialQue != RNIL) { + /* ------------------------------------------------------------------------- */ + // We are not in the parallel queue owning the lock. Thus we are in another parallel + // queue longer down in the serial queue. We are however first since prevParallelQue + // == RNIL. + /* ------------------------------------------------------------------------- */ + if (operationRecPtr.p->nextParallelQue != RNIL) { + jam(); + /* ------------------------------------------------------------------------- */ + // We have an operation in the queue after us. We simply rearrange this parallel queue. + // The new leader of this parallel queue will be operation in the serial queue. + /* ------------------------------------------------------------------------- */ + aboOperRecPtr.i = operationRecPtr.p->nextParallelQue; + ptrCheckGuard(aboOperRecPtr, coprecsize, operationrec); + aboOperRecPtr.p->nextSerialQue = operationRecPtr.p->nextSerialQue; + aboOperRecPtr.p->prevSerialQue = operationRecPtr.p->prevSerialQue; + aboOperRecPtr.p->prevParallelQue = RNIL; // Queue Leader + if (operationRecPtr.p->nextSerialQue != RNIL) { + jam(); + TaboOperRecPtr.i = operationRecPtr.p->nextSerialQue; + ptrCheckGuard(TaboOperRecPtr, coprecsize, operationrec); + TaboOperRecPtr.p->prevSerialQue = aboOperRecPtr.i; + }//if + TaboOperRecPtr.i = operationRecPtr.p->prevSerialQue; + ptrCheckGuard(TaboOperRecPtr, coprecsize, operationrec); + TaboOperRecPtr.p->nextSerialQue = aboOperRecPtr.i; + } else { + jam(); + /* ------------------------------------------------------------------------- */ + // We are the only operation in this parallel queue. We will thus shrink the serial + // queue. + /* ------------------------------------------------------------------------- */ + aboOperRecPtr.i = operationRecPtr.p->prevSerialQue; + ptrCheckGuard(aboOperRecPtr, coprecsize, operationrec); + aboOperRecPtr.p->nextSerialQue = operationRecPtr.p->nextSerialQue; + if (operationRecPtr.p->nextSerialQue != RNIL) { + jam(); + aboOperRecPtr.i = operationRecPtr.p->nextSerialQue; + ptrCheckGuard(aboOperRecPtr, coprecsize, operationrec); + aboOperRecPtr.p->prevSerialQue = operationRecPtr.p->prevSerialQue; + }//if + }//if + }//if + }//if + /* ------------------------------------------------------------------------- */ + // If prevParallelQue = RNIL and prevSerialQue = RNIL and we are not owner of the + // lock then we cannot be in any lock queue at all. + /* ------------------------------------------------------------------------- */ +}//Dbacc::abortOperation() + +void Dbacc::commitDeleteCheck() +{ + OperationrecPtr opPtr; + OperationrecPtr lastOpPtr; + OperationrecPtr deleteOpPtr; + bool elementDeleted = false; + bool deleteCheckOngoing = true; + Uint32 hashValue = 0; + lastOpPtr = operationRecPtr; + opPtr.i = operationRecPtr.p->nextParallelQue; + while (opPtr.i != RNIL) { + jam(); + ptrCheckGuard(opPtr, coprecsize, operationrec); + lastOpPtr = opPtr; + opPtr.i = opPtr.p->nextParallelQue; + }//while + deleteOpPtr = lastOpPtr; + do { + if (deleteOpPtr.p->operation == ZDELETE) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* IF THE CURRENT OPERATION TO BE COMMITTED IS A DELETE OPERATION DUE TO A */ + /* SCAN-TAKEOVER THE ACTUAL DELETE WILL BE PERFORMED BY THE PREVIOUS OPERATION (SCAN)*/ + /* IN THE PARALLEL QUEUE WHICH OWNS THE LOCK.THE PROBLEM IS THAT THE SCAN OPERATION */ + /* DOES NOT HAVE A HASH VALUE ASSIGNED TO IT SO WE COPY IT FROM THIS OPERATION. */ + /* */ + /* WE ASSUME THAT THIS SOLUTION WILL WORK BECAUSE THE ONLY WAY A SCAN CAN PERFORM */ + /* A DELETE IS BY BEING FOLLOWED BY A NORMAL DELETE-OPERATION THAT HAS A HASH VALUE. */ + /* --------------------------------------------------------------------------------- */ + hashValue = deleteOpPtr.p->hashValue; + elementDeleted = true; + deleteCheckOngoing = false; + } else if ((deleteOpPtr.p->operation == ZREAD) || + (deleteOpPtr.p->operation == ZSCAN_OP)) { + /* --------------------------------------------------------------------------------- */ + /* We are trying to find out whether the commit will in the end delete the tuple. */ + /* Normally the delete will be the last operation in the list of operations on this */ + /* It is however possible to issue reads and scans in the same savepoint as the */ + /* delete operation was issued and these can end up after the delete in the list of */ + /* operations in the parallel queue. Thus if we discover a read or a scan we have to */ + /* continue scanning the list looking for a delete operation. */ + /* --------------------------------------------------------------------------------- */ + deleteOpPtr.i = deleteOpPtr.p->prevParallelQue; + if (deleteOpPtr.i == RNIL) { + jam(); + deleteCheckOngoing = false; + } else { + jam(); + ptrCheckGuard(deleteOpPtr, coprecsize, operationrec); + }//if + } else { + jam(); + /* --------------------------------------------------------------------------------- */ + /* Finding an UPDATE or INSERT before finding a DELETE means we cannot be deleting */ + /* as the end result of this transaction. */ + /* --------------------------------------------------------------------------------- */ + deleteCheckOngoing = false; + }//if + } while (deleteCheckOngoing); + opPtr = lastOpPtr; + do { + jam(); + opPtr.p->commitDeleteCheckFlag = ZTRUE; + if (elementDeleted) { + jam(); + opPtr.p->elementIsDisappeared = ZTRUE; + opPtr.p->hashValue = hashValue; + }//if + opPtr.i = opPtr.p->prevParallelQue; + if (opPtr.i == RNIL) { + jam(); + break; + }//if + ptrCheckGuard(opPtr, coprecsize, operationrec); + } while (true); +}//Dbacc::commitDeleteCheck() + +/* ------------------------------------------------------------------------- */ +/* COMMIT_OPERATION */ +/* INPUT: OPERATION_REC_PTR, POINTER TO AN OPERATION RECORD */ +/* DESCRIPTION: THE OPERATION RECORD WILL BE TAKE OUT OF ANY LOCK QUEUE. */ +/* IF IT OWNS THE ELEMENT LOCK. HEAD OF THE ELEMENT WILL BE UPDATED. */ +/* ------------------------------------------------------------------------- */ +void Dbacc::commitOperation(Signal* signal) +{ + OperationrecPtr tolqTmpPtr; + Page8Ptr coPageidptr; + Uint32 tcoElementptr; + Uint32 tmp2Olq; + + if ((operationRecPtr.p->commitDeleteCheckFlag == ZFALSE) && + (operationRecPtr.p->operation != ZSCAN_OP)) { + jam(); + /* This method is used to check whether the end result of the transaction + will be to delete the tuple. In this case all operation will be marked + with elementIsDisappeared = true to ensure that the last operation + committed will remove the tuple. We only run this once per transaction + (commitDeleteCheckFlag = true if performed earlier) and we don't + execute this code when committing a scan operation since committing + a scan operation only means that the scan is continuing and the scan + lock is released. + */ + commitDeleteCheck(); + }//if + if (operationRecPtr.p->lockOwner == ZTRUE) { + takeOutLockOwnersList(signal, operationRecPtr); + if ((operationRecPtr.p->nextParallelQue == RNIL) && + (operationRecPtr.p->nextSerialQue == RNIL) && + (operationRecPtr.p->elementIsDisappeared == ZFALSE)) { + /* + This is the normal path through the commit for operations owning the + lock without any queues and not a delete operation. + */ + coPageidptr.i = operationRecPtr.p->elementPage; + tcoElementptr = operationRecPtr.p->elementPointer; + tmp2Olq = ElementHeader::setUnlocked(operationRecPtr.p->hashvaluePart, + operationRecPtr.p->scanBits); + ptrCheckGuard(coPageidptr, cpagesize, page8); + dbgWord32(coPageidptr, tcoElementptr, tmp2Olq); + arrGuard(tcoElementptr, 2048); + coPageidptr.p->word32[tcoElementptr] = tmp2Olq; + return; + } else if ((operationRecPtr.p->nextParallelQue != RNIL) || + (operationRecPtr.p->nextSerialQue != RNIL)) { + jam(); + /* + The case when there is a queue lined up. + Release the lock and pass it to the next operation lined up. + */ + releaselock(signal); + return; + } else { + jam(); + /* + No queue and elementIsDisappeared is true. We perform the actual delete + operation. + */ + commitdelete(signal, false); + return; + }//if + } else { + /* + THE OPERATION DOES NOT OWN THE LOCK. IT MUST BE IN A LOCK QUEUE OF THE + ELEMENT. + */ + ndbrequire(operationRecPtr.p->prevParallelQue != RNIL); + jam(); + tolqTmpPtr.i = operationRecPtr.p->prevParallelQue; + ptrCheckGuard(tolqTmpPtr, coprecsize, operationrec); + tolqTmpPtr.p->nextParallelQue = operationRecPtr.p->nextParallelQue; + if (operationRecPtr.p->nextParallelQue != RNIL) { + jam(); + tolqTmpPtr.i = operationRecPtr.p->nextParallelQue; + ptrCheckGuard(tolqTmpPtr, coprecsize, operationrec); + tolqTmpPtr.p->prevParallelQue = operationRecPtr.p->prevParallelQue; + }//if + }//if +}//Dbacc::commitOperation() + +/* ------------------------------------------------------------------------- */ +/* RELEASELOCK */ +/* RESETS LOCK OF AN ELEMENT. */ +/* INFORMATION ABOUT THE ELEMENT IS SAVED IN THE OPERATION RECORD */ +/* THESE INFORMATION IS USED TO UPDATE HEADER OF THE ELEMENT */ +/* ------------------------------------------------------------------------- */ +void Dbacc::releaselock(Signal* signal) +{ + OperationrecPtr rloOperPtr; + OperationrecPtr trlOperPtr; + OperationrecPtr trlTmpOperPtr; + Uint32 TelementIsDisappeared; + + trlOperPtr.i = RNIL; + if (operationRecPtr.p->nextParallelQue != RNIL) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* NEXT OPERATION TAKES OVER THE LOCK. We will simply move the info from the leader */ + // to the new queue leader. + /* --------------------------------------------------------------------------------- */ + trlOperPtr.i = operationRecPtr.p->nextParallelQue; + ptrCheckGuard(trlOperPtr, coprecsize, operationrec); + copyInOperPtr = trlOperPtr; + copyOperPtr = operationRecPtr; + copyOpInfo(signal); + trlOperPtr.p->prevParallelQue = RNIL; + if (operationRecPtr.p->nextSerialQue != RNIL) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THERE IS A SERIAL QUEUE. MOVE IT FROM RELEASED OP REC TO THE NEW LOCK OWNER. */ + /* --------------------------------------------------------------------------------- */ + trlOperPtr.p->nextSerialQue = operationRecPtr.p->nextSerialQue; + trlTmpOperPtr.i = trlOperPtr.p->nextSerialQue; + ptrCheckGuard(trlTmpOperPtr, coprecsize, operationrec); + trlTmpOperPtr.p->prevSerialQue = trlOperPtr.i; + }//if + /* --------------------------------------------------------------------------------- */ + /* SINCE THERE ARE STILL ITEMS IN THE PARALLEL QUEUE WE NEED NOT WORRY ABOUT */ + /* STARTING QUEUED OPERATIONS. THUS WE CAN END HERE. */ + /* --------------------------------------------------------------------------------- */ + } else { + ndbrequire(operationRecPtr.p->nextSerialQue != RNIL); + jam(); + /* --------------------------------------------------------------------------------- */ + /* THE PARALLEL QUEUE IS EMPTY AND THE SERIAL QUEUE IS NOT EMPTY. WE NEED TO */ + /* REARRANGE LISTS AND START A NUMBER OF OPERATIONS. */ + /* --------------------------------------------------------------------------------- */ + trlOperPtr.i = operationRecPtr.p->nextSerialQue; + ptrCheckGuard(trlOperPtr, coprecsize, operationrec); + copyOperPtr = operationRecPtr; + copyInOperPtr = trlOperPtr; + copyOpInfo(signal); + trlOperPtr.p->prevSerialQue = RNIL; + ndbrequire(trlOperPtr.p->prevParallelQue == RNIL); + /* --------------------------------------------------------------------------------- */ + /* WE HAVE MOVED TO THE NEXT PARALLEL QUEUE. WE MUST START ALL OF THOSE */ + /* OPERATIONS WHICH UP TILL NOW HAVE BEEN QUEUED WAITING FOR THE LOCK. */ + /* --------------------------------------------------------------------------------- */ + rloOperPtr = operationRecPtr; + trlTmpOperPtr = trlOperPtr; + TelementIsDisappeared = trlOperPtr.p->elementIsDisappeared; + Uint32 ThashValue = trlOperPtr.p->hashValue; + do { + /* --------------------------------------------------------------------------------- */ + // Ensure that all operations in the queue are assigned with the elementIsDisappeared + // to ensure that the element is removed after a previous delete. An insert does + // however revert this decision since the element is put back again. Local checkpoints + // complicate life here since they do not execute the next operation but simply change + // the state on the operation. We need to set-up the variable elementIsDisappeared + // properly even when local checkpoints and inserts/writes after deletes occur. + /* --------------------------------------------------------------------------------- */ + trlTmpOperPtr.p->elementIsDisappeared = TelementIsDisappeared; + if (TelementIsDisappeared == ZTRUE) { + /* --------------------------------------------------------------------------------- */ + // If the elementIsDisappeared is set then we know that the hashValue is also set + // since it always originates from a committing abort or a aborting insert. Scans + // do not initialise the hashValue and must have this value initialised if they are + // to successfully commit the delete. + /* --------------------------------------------------------------------------------- */ + jam(); + trlTmpOperPtr.p->hashValue = ThashValue; + }//if + trlTmpOperPtr.p->localdata[0] = trlOperPtr.p->localdata[0]; + trlTmpOperPtr.p->localdata[1] = trlOperPtr.p->localdata[1]; + /* --------------------------------------------------------------------------------- */ + // Restart the queued operation. + /* --------------------------------------------------------------------------------- */ + operationRecPtr = trlTmpOperPtr; + TelementIsDisappeared = executeNextOperation(signal); + ThashValue = operationRecPtr.p->hashValue; + if (trlTmpOperPtr.p->nextParallelQue != RNIL) { + jam(); + /* --------------------------------------------------------------------------------- */ + // We will continue with the next operation in the parallel queue and start this as + // well. + /* --------------------------------------------------------------------------------- */ + trlTmpOperPtr.i = trlTmpOperPtr.p->nextParallelQue; + ptrCheckGuard(trlTmpOperPtr, coprecsize, operationrec); + } else { + jam(); + break; + }//if + } while (1); + operationRecPtr = rloOperPtr; + }//if + + // Insert the next op into the lock owner list + insertLockOwnersList(signal, trlOperPtr); + return; +}//Dbacc::releaselock() + +/* --------------------------------------------------------------------------------- */ +/* COPY_OP_INFO */ +/* INPUT: COPY_IN_OPER_PTR AND COPY_OPER_PTR. */ +/* DESCRIPTION:INFORMATION ABOUT THE ELEMENT WILL BE MOVED FROM OPERATION */ +/* REC TO QUEUE OP REC. QUE OP REC TAKES OVER THE LOCK. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::copyOpInfo(Signal* signal) +{ + Page8Ptr coiPageidptr; + + copyInOperPtr.p->elementPage = copyOperPtr.p->elementPage; + copyInOperPtr.p->elementIsforward = copyOperPtr.p->elementIsforward; + copyInOperPtr.p->elementContainer = copyOperPtr.p->elementContainer; + copyInOperPtr.p->elementPointer = copyOperPtr.p->elementPointer; + copyInOperPtr.p->scanBits = copyOperPtr.p->scanBits; + copyInOperPtr.p->hashvaluePart = copyOperPtr.p->hashvaluePart; + copyInOperPtr.p->elementIsDisappeared = copyOperPtr.p->elementIsDisappeared; + if (copyInOperPtr.p->elementIsDisappeared == ZTRUE) { + /* --------------------------------------------------------------------------------- */ + // If the elementIsDisappeared is set then we know that the hashValue is also set + // since it always originates from a committing abort or a aborting insert. Scans + // do not initialise the hashValue and must have this value initialised if they are + // to successfully commit the delete. + /* --------------------------------------------------------------------------------- */ + jam(); + copyInOperPtr.p->hashValue = copyOperPtr.p->hashValue; + }//if + coiPageidptr.i = copyOperPtr.p->elementPage; + ptrCheckGuard(coiPageidptr, cpagesize, page8); + const Uint32 tmp = ElementHeader::setLocked(copyInOperPtr.i); + dbgWord32(coiPageidptr, copyOperPtr.p->elementPointer, tmp); + arrGuard(copyOperPtr.p->elementPointer, 2048); + coiPageidptr.p->word32[copyOperPtr.p->elementPointer] = tmp; + copyInOperPtr.p->localdata[0] = copyOperPtr.p->localdata[0]; + copyInOperPtr.p->localdata[1] = copyOperPtr.p->localdata[1]; +}//Dbacc::copyOpInfo() + +/* ******************--------------------------------------------------------------- */ +/* EXECUTE NEXT OPERATION */ +/* NEXT OPERATION IN A LOCK QUEUE WILL BE EXECUTED. */ +/* --------------------------------------------------------------------------------- */ +Uint32 Dbacc::executeNextOperation(Signal* signal) +{ + ndbrequire(operationRecPtr.p->transactionstate == ACTIVE); + if (fragrecptr.p->stopQueOp == ZTRUE) { + Uint32 TelemDisappeared; + jam(); + TelemDisappeared = operationRecPtr.p->elementIsDisappeared; + if ((operationRecPtr.p->elementIsDisappeared == ZTRUE) && + (operationRecPtr.p->prevParallelQue == RNIL) && + ((operationRecPtr.p->operation == ZINSERT) || + (operationRecPtr.p->operation == ZWRITE))) { + jam(); + /* --------------------------------------------------------------------------------- */ + // In this case we do not wish to change the elementIsDisappeared since that would + // create an error the next time this method is called for this operation after local + // checkpoint starts up operations again. We must however ensure that operations + // that follow in the queue do not get the value ZTRUE when actually an INSERT/WRITE + // precedes them (only if the INSERT/WRITE is the first operation). + /* --------------------------------------------------------------------------------- */ + TelemDisappeared = ZFALSE; + }//if + /* --------------------------------------------------------------------------------- */ + /* A LOCAL CHECKPOINT HAS STOPPED OPERATIONS. WE MUST NOT START THE OPERATION */ + /* AT THIS TIME. WE SET THE STATE TO INDICATE THAT WE ARE READY TO START AS */ + /* SOON AS WE ARE ALLOWED. */ + /* --------------------------------------------------------------------------------- */ + operationRecPtr.p->opState = WAIT_EXE_OP; + return TelemDisappeared; + }//if + takeOutFragWaitQue(signal); + if (operationRecPtr.p->elementIsDisappeared == ZTRUE) { + /* --------------------------------------------------------------------------------- */ + /* PREVIOUS OPERATION WAS DELETE OPERATION AND THE ELEMENT IS ALREADY DELETED. */ + /* --------------------------------------------------------------------------------- */ + if (((operationRecPtr.p->operation != ZINSERT) && + (operationRecPtr.p->operation != ZWRITE)) || + (operationRecPtr.p->prevParallelQue != RNIL)) { + if (operationRecPtr.p->operation != ZSCAN_OP || + operationRecPtr.p->isAccLockReq) { + jam(); + /* --------------------------------------------------------------------------------- */ + // Updates and reads with a previous delete simply aborts with read error indicating + // that tuple did not exist. Also inserts and writes not being the first operation. + /* --------------------------------------------------------------------------------- */ + operationRecPtr.p->transactionstate = WAIT_COMMIT_ABORT; + signal->theData[0] = operationRecPtr.p->userptr; + signal->theData[1] = ZREAD_ERROR; + sendSignal(operationRecPtr.p->userblockref, GSN_ACCKEYREF, signal, 2, JBB); + return operationRecPtr.p->elementIsDisappeared; + } else { + /* --------------------------------------------------------------------------------- */ + /* ABORT OF OPERATION NEEDED BUT THE OPERATION IS A SCAN => SPECIAL TREATMENT. */ + /* IF THE SCAN WAITS IN QUEUE THEN WE MUST REMOVE THE OPERATION FROM THE SCAN */ + /* LOCK QUEUE AND IF NO MORE OPERATIONS ARE QUEUED THEN WE SHOULD RESTART THE */ + /* SCAN PROCESS. OTHERWISE WE SIMPLY RELEASE THE OPERATION AND DECREASE THE */ + /* NUMBER OF LOCKS HELD. */ + /* --------------------------------------------------------------------------------- */ + takeOutScanLockQueue(operationRecPtr.p->scanRecPtr); + putReadyScanQueue(signal, operationRecPtr.p->scanRecPtr); + return operationRecPtr.p->elementIsDisappeared; + }//if + }//if + /* --------------------------------------------------------------------------------- */ + // Insert and writes can continue but need to be converted to inserts. + /* --------------------------------------------------------------------------------- */ + jam(); + operationRecPtr.p->elementIsDisappeared = ZFALSE; + operationRecPtr.p->operation = ZINSERT; + operationRecPtr.p->insertIsDone = ZTRUE; + } else if (operationRecPtr.p->operation == ZINSERT) { + bool abortFlag = true; + if (operationRecPtr.p->prevParallelQue != RNIL) { + OperationrecPtr prevOpPtr; + jam(); + prevOpPtr.i = operationRecPtr.p->prevParallelQue; + ptrCheckGuard(prevOpPtr, coprecsize, operationrec); + if (prevOpPtr.p->operation == ZDELETE) { + jam(); + abortFlag = false; + }//if + }//if + if (abortFlag) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* ELEMENT STILL REMAINS AND WE ARE TRYING TO INSERT IT AGAIN. THIS IS CLEARLY */ + /* NOT A GOOD IDEA. */ + /* --------------------------------------------------------------------------------- */ + operationRecPtr.p->transactionstate = WAIT_COMMIT_ABORT; + signal->theData[0] = operationRecPtr.p->userptr; + signal->theData[1] = ZWRITE_ERROR; + sendSignal(operationRecPtr.p->userblockref, GSN_ACCKEYREF, signal, 2, JBB); + return operationRecPtr.p->elementIsDisappeared; + }//if + }//if + if (operationRecPtr.p->operation == ZSCAN_OP && + ! operationRecPtr.p->isAccLockReq) { + jam(); + takeOutScanLockQueue(operationRecPtr.p->scanRecPtr); + putReadyScanQueue(signal, operationRecPtr.p->scanRecPtr); + } else { + jam(); + sendAcckeyconf(signal); + sendSignal(operationRecPtr.p->userblockref, GSN_ACCKEYCONF, signal, 6, JBB); + }//if + return operationRecPtr.p->elementIsDisappeared; +}//Dbacc::executeNextOperation() + +/* --------------------------------------------------------------------------------- */ +/* TAKE_OUT_FRAG_WAIT_QUE */ +/* DESCRIPTION: AN OPERATION WHICH OWNS A LOCK OF AN ELEMENT, IS IN A LIST */ +/* OF THE FRAGMENT. THIS LIST IS USED TO STOP THE QUEUE OPERATION */ +/* DURING CREATE CHECK POINT PROSESS FOR STOP AND RESTART OF THE */ +/* OPERATIONS. THIS SUBRUTIN TAKES A OPERATION RECORD OUT OF THE LIST */ +/* -------------------------------------------------------------------------------- */ +void Dbacc::takeOutFragWaitQue(Signal* signal) +{ + OperationrecPtr tofwqOperRecPtr; + + if (operationRecPtr.p->opState == WAIT_IN_QUEUE) { + if (fragrecptr.p->sentWaitInQueOp == operationRecPtr.i) { + jam(); + fragrecptr.p->sentWaitInQueOp = operationRecPtr.p->nextQueOp; + }//if + if (operationRecPtr.p->prevQueOp != RNIL) { + jam(); + tofwqOperRecPtr.i = operationRecPtr.p->prevQueOp; + ptrCheckGuard(tofwqOperRecPtr, coprecsize, operationrec); + tofwqOperRecPtr.p->nextQueOp = operationRecPtr.p->nextQueOp; + } else { + jam(); + fragrecptr.p->firstWaitInQueOp = operationRecPtr.p->nextQueOp; + }//if + if (operationRecPtr.p->nextQueOp != RNIL) { + jam(); + tofwqOperRecPtr.i = operationRecPtr.p->nextQueOp; + ptrCheckGuard(tofwqOperRecPtr, coprecsize, operationrec); + tofwqOperRecPtr.p->prevQueOp = operationRecPtr.p->prevQueOp; + } else { + jam(); + fragrecptr.p->lastWaitInQueOp = operationRecPtr.p->prevQueOp; + }//if + operationRecPtr.p->opState = FREE_OP; + return; + } else { + ndbrequire(operationRecPtr.p->opState == FREE_OP); + }//if +}//Dbacc::takeOutFragWaitQue() + +/** + * takeOutLockOwnersList + * + * Description: Take out an operation from the doubly linked + * lock owners list on the fragment. + * + */ +void Dbacc::takeOutLockOwnersList(Signal* signal, + const OperationrecPtr& outOperPtr) +{ + const Uint32 Tprev = outOperPtr.p->prevLockOwnerOp; + const Uint32 Tnext = outOperPtr.p->nextLockOwnerOp; + +#ifdef VM_TRACE + // Check that operation is already in the list + OperationrecPtr tmpOperPtr; + bool inList = false; + tmpOperPtr.i = fragrecptr.p->lockOwnersList; + while (tmpOperPtr.i != RNIL){ + ptrCheckGuard(tmpOperPtr, coprecsize, operationrec); + if (tmpOperPtr.i == outOperPtr.i) + inList = true; + tmpOperPtr.i = tmpOperPtr.p->nextLockOwnerOp; + } + ndbrequire(inList == true); +#endif + + ndbrequire(outOperPtr.p->lockOwner == ZTRUE); + outOperPtr.p->lockOwner = ZFALSE; + + // Fast path through the code for the common case. + if ((Tprev == RNIL) && (Tnext == RNIL)) { + ndbrequire(fragrecptr.p->lockOwnersList == outOperPtr.i); + fragrecptr.p->lockOwnersList = RNIL; + return; + } + + // Check previous operation + if (Tprev != RNIL) { + jam(); + arrGuard(Tprev, coprecsize); + operationrec[Tprev].nextLockOwnerOp = Tnext; + } else { + fragrecptr.p->lockOwnersList = Tnext; + }//if + + // Check next operation + if (Tnext == RNIL) { + return; + } else { + jam(); + arrGuard(Tnext, coprecsize); + operationrec[Tnext].prevLockOwnerOp = Tprev; + }//if + + return; +}//Dbacc::takeOutLockOwnersList() + +/** + * insertLockOwnersList + * + * Description: Insert an operation first in the dubly linked lock owners + * list on the fragment. + * + */ +void Dbacc::insertLockOwnersList(Signal* signal, + const OperationrecPtr& insOperPtr) +{ + OperationrecPtr tmpOperPtr; + +#ifdef VM_TRACE + // Check that operation is not already in list + tmpOperPtr.i = fragrecptr.p->lockOwnersList; + while(tmpOperPtr.i != RNIL){ + ptrCheckGuard(tmpOperPtr, coprecsize, operationrec); + ndbrequire(tmpOperPtr.i != insOperPtr.i); + tmpOperPtr.i = tmpOperPtr.p->nextLockOwnerOp; + } +#endif + + ndbrequire(insOperPtr.p->lockOwner == ZFALSE); + + insOperPtr.p->lockOwner = ZTRUE; + insOperPtr.p->prevLockOwnerOp = RNIL; + tmpOperPtr.i = fragrecptr.p->lockOwnersList; + fragrecptr.p->lockOwnersList = insOperPtr.i; + insOperPtr.p->nextLockOwnerOp = tmpOperPtr.i; + if (tmpOperPtr.i == RNIL) { + return; + } else { + jam(); + ptrCheckGuard(tmpOperPtr, coprecsize, operationrec); + tmpOperPtr.p->prevLockOwnerOp = insOperPtr.i; + }//if +}//Dbacc::insertLockOwnersList() + + +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* END OF COMMIT AND ABORT MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* ALLOC_OVERFLOW_PAGE */ +/* DESCRIPTION: */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::allocOverflowPage(Signal* signal) +{ + DirRangePtr aopDirRangePtr; + DirectoryarrayPtr aopOverflowDirptr; + OverflowRecordPtr aopOverflowRecPtr; + Uint32 taopTmp1; + Uint32 taopTmp2; + Uint32 taopTmp3; + + tresult = 0; + if ((cfirstfreepage == RNIL) && + (cfreepage >= cpagesize)) { + jam(); + zpagesize_error("Dbacc::allocOverflowPage"); + tresult = ZPAGESIZE_ERROR; + return; + }//if + if (fragrecptr.p->firstFreeDirindexRec != RNIL) { + jam(); + /* FRAGRECPTR:FIRST_FREE_DIRINDEX_REC POINTS */ + /* TO THE FIRST ELEMENT IN A FREE LIST OF THE */ + /* DIRECTORY INDEX WICH HAVE NULL AS PAGE */ + aopOverflowRecPtr.i = fragrecptr.p->firstFreeDirindexRec; + ptrCheckGuard(aopOverflowRecPtr, coverflowrecsize, overflowRecord); + troOverflowRecPtr.p = aopOverflowRecPtr.p; + takeRecOutOfFreeOverdir(signal); + } else if (cfirstfreeoverrec == RNIL) { + jam(); + tresult = ZOVER_REC_ERROR; + return; + } else if ((cfirstfreedir == RNIL) && + (cdirarraysize <= cdirmemory)) { + jam(); + tresult = ZDIRSIZE_ERROR; + return; + } else { + jam(); + seizeOverRec(signal); + aopOverflowRecPtr = sorOverflowRecPtr; + aopOverflowRecPtr.p->dirindex = fragrecptr.p->lastOverIndex; + }//if + aopOverflowRecPtr.p->nextOverRec = RNIL; + aopOverflowRecPtr.p->prevOverRec = RNIL; + fragrecptr.p->firstOverflowRec = aopOverflowRecPtr.i; + fragrecptr.p->lastOverflowRec = aopOverflowRecPtr.i; + taopTmp1 = aopOverflowRecPtr.p->dirindex; + aopDirRangePtr.i = fragrecptr.p->overflowdir; + taopTmp2 = taopTmp1 >> 8; + taopTmp3 = taopTmp1 & 0xff; + ptrCheckGuard(aopDirRangePtr, cdirrangesize, dirRange); + arrGuard(taopTmp2, 256); + if (aopDirRangePtr.p->dirArray[taopTmp2] == RNIL) { + jam(); + seizeDirectory(signal); + ndbrequire(tresult <= ZLIMIT_OF_ERROR); + aopDirRangePtr.p->dirArray[taopTmp2] = sdDirptr.i; + }//if + aopOverflowDirptr.i = aopDirRangePtr.p->dirArray[taopTmp2]; + seizePage(signal); + ndbrequire(tresult <= ZLIMIT_OF_ERROR); + ptrCheckGuard(aopOverflowDirptr, cdirarraysize, directoryarray); + aopOverflowDirptr.p->pagep[taopTmp3] = spPageptr.i; + tiopPageId = aopOverflowRecPtr.p->dirindex; + iopOverflowRecPtr = aopOverflowRecPtr; + iopPageptr = spPageptr; + initOverpage(signal); + aopOverflowRecPtr.p->overpage = spPageptr.i; + if (fragrecptr.p->lastOverIndex <= aopOverflowRecPtr.p->dirindex) { + jam(); + ndbrequire(fragrecptr.p->lastOverIndex == aopOverflowRecPtr.p->dirindex); + fragrecptr.p->lastOverIndex++; + }//if +}//Dbacc::allocOverflowPage() + +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* EXPAND/SHRINK MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/*EXPANDCHECK EXPAND BUCKET ORD */ +/* SENDER: ACC, LEVEL B */ +/* INPUT: FRAGRECPTR, POINTS TO A FRAGMENT RECORD. */ +/* DESCRIPTION: A BUCKET OF A FRAGMENT PAGE WILL BE EXPAND INTO TWO BUCKETS */ +/* ACCORDING TO LH3. */ +/* ******************--------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* EXPANDCHECK EXPAND BUCKET ORD */ +/* ******************------------------------------+ */ +/* SENDER: ACC, LEVEL B */ +/* A BUCKET OF THE FRAGMENT WILL */ +/* BE EXPANDED ACORDING TO LH3, */ +/* AND COMMIT TRANSACTION PROCESS */ +/* WILL BE CONTINUED */ +Uint32 Dbacc::checkScanExpand(Signal* signal) +{ + Uint32 Ti; + Uint32 TreturnCode = 0; + Uint32 TPageIndex; + Uint32 TDirInd; + Uint32 TSplit; + Uint32 TreleaseInd = 0; + Uint32 TreleaseScanBucket; + Uint32 TreleaseScanIndicator[4]; + DirectoryarrayPtr TDirptr; + DirRangePtr TDirRangePtr; + Page8Ptr TPageptr; + ScanRecPtr TscanPtr; + RootfragmentrecPtr Trootfragrecptr; + + Trootfragrecptr.i = fragrecptr.p->myroot; + TSplit = fragrecptr.p->p; + ptrCheckGuard(Trootfragrecptr, crootfragmentsize, rootfragmentrec); + for (Ti = 0; Ti < 4; Ti++) { + TreleaseScanIndicator[Ti] = 0; + if (Trootfragrecptr.p->scan[Ti] != RNIL) { + //------------------------------------------------------------- + // A scan is ongoing on this particular local fragment. We have + // to check its current state. + //------------------------------------------------------------- + TscanPtr.i = Trootfragrecptr.p->scan[Ti]; + ptrCheckGuard(TscanPtr, cscanRecSize, scanRec); + if (TscanPtr.p->activeLocalFrag == fragrecptr.i) { + if (TscanPtr.p->scanBucketState == ScanRec::FIRST_LAP) { + if (TSplit == TscanPtr.p->nextBucketIndex) { + jam(); + //------------------------------------------------------------- + // We are currently scanning this bucket. We cannot split it + // simultaneously with the scan. We have to pass this offer for + // splitting the bucket. + //------------------------------------------------------------- + TreturnCode = 1; + return TreturnCode; + } else if (TSplit > TscanPtr.p->nextBucketIndex) { + jam(); + //------------------------------------------------------------- + // This bucket has not yet been scanned. We must reset the scanned + // bit indicator for this scan on this bucket. + //------------------------------------------------------------- + TreleaseScanIndicator[Ti] = 1; + TreleaseInd = 1; + } else { + jam(); + }//if + } else if (TscanPtr.p->scanBucketState == ScanRec::SECOND_LAP) { + jam(); + //------------------------------------------------------------- + // We are performing a second lap to handle buckets that was + // merged during the first lap of scanning. During this second + // lap we do not allow any splits or merges. + //------------------------------------------------------------- + TreturnCode = 1; + return TreturnCode; + } else { + ndbrequire(TscanPtr.p->scanBucketState == ScanRec::SCAN_COMPLETED); + jam(); + //------------------------------------------------------------- + // The scan is completed and we can thus go ahead and perform + // the split. + //------------------------------------------------------------- + }//if + }//if + }//if + }//for + if (TreleaseInd == 1) { + TreleaseScanBucket = TSplit; + TDirRangePtr.i = fragrecptr.p->directory; + TPageIndex = TreleaseScanBucket & ((1 << fragrecptr.p->k) - 1); /* PAGE INDEX OBS K = 6 */ + TDirInd = TreleaseScanBucket >> fragrecptr.p->k; /* DIRECTORY INDEX OBS K = 6 */ + ptrCheckGuard(TDirRangePtr, cdirrangesize, dirRange); + arrGuard((TDirInd >> 8), 256); + TDirptr.i = TDirRangePtr.p->dirArray[TDirInd >> 8]; + ptrCheckGuard(TDirptr, cdirarraysize, directoryarray); + TPageptr.i = TDirptr.p->pagep[TDirInd & 0xff]; + ptrCheckGuard(TPageptr, cpagesize, page8); + for (Ti = 0; Ti < 4; Ti++) { + if (TreleaseScanIndicator[Ti] == 1) { + jam(); + scanPtr.i = Trootfragrecptr.p->scan[Ti]; + ptrCheckGuard(scanPtr, cscanRecSize, scanRec); + rsbPageidptr = TPageptr; + trsbPageindex = TPageIndex; + releaseScanBucket(signal); + }//if + }//for + }//if + return TreturnCode; +}//Dbacc::checkScanExpand() + +void Dbacc::execEXPANDCHECK2(Signal* signal) +{ + DirectoryarrayPtr newDirptr; + + jamEntry(); + fragrecptr.i = signal->theData[0]; + tresult = 0; /* 0= FALSE,1= TRUE,> ZLIMIT_OF_ERROR =ERRORCODE */ + Uint32 tmp = 1; + tmp = tmp << 31; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + fragrecptr.p->expandFlag = 0; + if (fragrecptr.p->slack < tmp) { + jam(); + /* IT MEANS THAT IF SLACK > ZERO */ + /*--------------------------------------------------------------*/ + /* THE SLACK HAS IMPROVED AND IS NOW ACCEPTABLE AND WE */ + /* CAN FORGET ABOUT THE EXPAND PROCESS. */ + /*--------------------------------------------------------------*/ + return; + }//if + if (fragrecptr.p->firstOverflowRec == RNIL) { + jam(); + allocOverflowPage(signal); + if (tresult > ZLIMIT_OF_ERROR) { + jam(); + /*--------------------------------------------------------------*/ + /* WE COULD NOT ALLOCATE ANY OVERFLOW PAGE. THUS WE HAVE TO STOP*/ + /* THE EXPAND SINCE WE CANNOT GUARANTEE ITS COMPLETION. */ + /*--------------------------------------------------------------*/ + return; + }//if + }//if + if (cfirstfreepage == RNIL) { + if (cfreepage >= cpagesize) { + jam(); + /*--------------------------------------------------------------*/ + /* WE HAVE TO STOP THE EXPAND PROCESS SINCE THERE ARE NO FREE */ + /* PAGES. THIS MEANS THAT WE COULD BE FORCED TO CRASH SINCE WE */ + /* CANNOT COMPLETE THE EXPAND. TO AVOID THE CRASH WE EXIT HERE. */ + /*--------------------------------------------------------------*/ + return; + }//if + }//if + if (checkScanExpand(signal) == 1) { + jam(); + /*--------------------------------------------------------------*/ + // A scan state was inconsistent with performing an expand + // operation. + /*--------------------------------------------------------------*/ + return; + }//if + if (fragrecptr.p->createLcp == ZTRUE) { + if (remainingUndoPages() < ZMIN_UNDO_PAGES_AT_EXPAND) { + jam(); + /*--------------------------------------------------------------*/ + // We did not have enough undo log buffers to start up an + // expand operation + /*--------------------------------------------------------------*/ + return; + }//if + }//if + /*--------------------------------------------------------------------------*/ + /* WE START BY FINDING THE PAGE, THE PAGE INDEX AND THE PAGE DIRECTORY*/ + /* OF THE NEW BUCKET WHICH SHALL RECEIVE THE ELEMENT WHICH HAVE A 1 IN*/ + /* THE NEXT HASH BIT. THIS BIT IS USED IN THE SPLIT MECHANISM TO */ + /* DECIDE WHICH ELEMENT GOES WHERE. */ + /*--------------------------------------------------------------------------*/ + expDirRangePtr.i = fragrecptr.p->directory; + texpReceivedBucket = (fragrecptr.p->maxp + fragrecptr.p->p) + 1; /* RECEIVED BUCKET */ + texpDirInd = texpReceivedBucket >> fragrecptr.p->k; + newDirptr.i = RNIL; + ptrNull(newDirptr); + texpDirRangeIndex = texpDirInd >> 8; + ptrCheckGuard(expDirRangePtr, cdirrangesize, dirRange); + arrGuard(texpDirRangeIndex, 256); + expDirptr.i = expDirRangePtr.p->dirArray[texpDirRangeIndex]; + if (expDirptr.i == RNIL) { + jam(); + seizeDirectory(signal); + if (tresult > ZLIMIT_OF_ERROR) { + jam(); + return; + } else { + jam(); + newDirptr = sdDirptr; + expDirptr = sdDirptr; + expDirRangePtr.p->dirArray[texpDirRangeIndex] = sdDirptr.i; + }//if + } else { + ptrCheckGuard(expDirptr, cdirarraysize, directoryarray); + }//if + texpDirPageIndex = texpDirInd & 0xff; + expPageptr.i = expDirptr.p->pagep[texpDirPageIndex]; + if (expPageptr.i == RNIL) { + jam(); + seizePage(signal); + if (tresult > ZLIMIT_OF_ERROR) { + jam(); + if (newDirptr.i != RNIL) { + jam(); + rdDirptr.i = newDirptr.i; + releaseDirectory(signal); + }//if + return; + }//if + expDirptr.p->pagep[texpDirPageIndex] = spPageptr.i; + tipPageId = texpDirInd; + inpPageptr = spPageptr; + initPage(signal); + fragrecptr.p->dirsize++; + expPageptr = spPageptr; + } else { + ptrCheckGuard(expPageptr, cpagesize, page8); + }//if + fragrecptr.p->expReceivePageptr = expPageptr.i; + fragrecptr.p->expReceiveIndex = texpReceivedBucket & ((1 << fragrecptr.p->k) - 1); + /*--------------------------------------------------------------------------*/ + /* THE NEXT ACTION IS TO FIND THE PAGE, THE PAGE INDEX AND THE PAGE */ + /* DIRECTORY OF THE BUCKET TO BE SPLIT. */ + /*--------------------------------------------------------------------------*/ + expDirRangePtr.i = fragrecptr.p->directory; + cexcPageindex = fragrecptr.p->p & ((1 << fragrecptr.p->k) - 1); /* PAGE INDEX OBS K = 6 */ + texpDirInd = fragrecptr.p->p >> fragrecptr.p->k; /* DIRECTORY INDEX OBS K = 6 */ + ptrCheckGuard(expDirRangePtr, cdirrangesize, dirRange); + arrGuard((texpDirInd >> 8), 256); + expDirptr.i = expDirRangePtr.p->dirArray[texpDirInd >> 8]; + ptrCheckGuard(expDirptr, cdirarraysize, directoryarray); + excPageptr.i = expDirptr.p->pagep[texpDirInd & 0xff]; + fragrecptr.p->expSenderIndex = cexcPageindex; + fragrecptr.p->expSenderPageptr = excPageptr.i; + if (excPageptr.i == RNIL) { + jam(); + endofexpLab(signal); /* EMPTY BUCKET */ + return; + }//if + fragrecptr.p->expReceiveForward = ZTRUE; + ptrCheckGuard(excPageptr, cpagesize, page8); + expandcontainer(signal); + endofexpLab(signal); + return; +}//Dbacc::execEXPANDCHECK2() + +void Dbacc::endofexpLab(Signal* signal) +{ + fragrecptr.p->p++; + fragrecptr.p->slack += fragrecptr.p->maxloadfactor; + fragrecptr.p->expandCounter++; + if (fragrecptr.p->p > fragrecptr.p->maxp) { + jam(); + fragrecptr.p->maxp = (fragrecptr.p->maxp << 1) | 1; + fragrecptr.p->lhdirbits++; + fragrecptr.p->hashcheckbit++; + fragrecptr.p->p = 0; + }//if + Uint32 noOfBuckets = (fragrecptr.p->maxp + 1) + fragrecptr.p->p; + Uint32 Thysteres = fragrecptr.p->maxloadfactor - fragrecptr.p->minloadfactor; + fragrecptr.p->slackCheck = noOfBuckets * Thysteres; + if (fragrecptr.p->slack > (Uint32)(1 << 31)) { + jam(); + /* IT MEANS THAT IF SLACK < ZERO */ + /* --------------------------------------------------------------------------------- */ + /* IT IS STILL NECESSARY TO EXPAND THE FRAGMENT EVEN MORE. START IT FROM HERE */ + /* WITHOUT WAITING FOR NEXT COMMIT ON THE FRAGMENT. */ + /* --------------------------------------------------------------------------------- */ + fragrecptr.p->expandFlag = 1; + signal->theData[0] = fragrecptr.i; + signal->theData[1] = fragrecptr.p->p; + signal->theData[2] = fragrecptr.p->maxp; + sendSignal(cownBlockref, GSN_EXPANDCHECK2, signal, 3, JBB); + }//if + return; +}//Dbacc::endofexpLab() + +void Dbacc::execDEBUG_SIG(Signal* signal) +{ + jamEntry(); + expPageptr.i = signal->theData[0]; + + progError(__LINE__, + ERR_SR_UNDOLOG); + return; +}//Dbacc::execDEBUG_SIG() + +/* --------------------------------------------------------------------------------- */ +/* EXPANDCONTAINER */ +/* INPUT: EXC_PAGEPTR (POINTER TO THE ACTIVE PAGE RECORD) */ +/* CEXC_PAGEINDEX (INDEX OF THE BUCKET). */ +/* */ +/* DESCRIPTION: THE HASH VALUE OF ALL ELEMENTS IN THE CONTAINER WILL BE */ +/* CHECKED. SOME OF THIS ELEMENTS HAVE TO MOVE TO THE NEW CONTAINER */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::expandcontainer(Signal* signal) +{ + Uint32 texcHashvalue; + Uint32 texcTmp; + Uint32 texcIndex; + Uint32 texpKeyLen; + Uint32 guard20; + + texpKeyLen = fragrecptr.p->keyLength; + if (texpKeyLen == 0) { + jam(); + texpKeyLen = ZACTIVE_LONG_KEY_LEN; + }//if + cexcPrevpageptr = RNIL; + cexcPrevconptr = 0; + cexcForward = ZTRUE; + EXP_CONTAINER_LOOP: + cexcContainerptr = (cexcPageindex << ZSHIFT_PLUS) - (cexcPageindex << ZSHIFT_MINUS); + if (cexcForward == ZTRUE) { + jam(); + cexcContainerptr = cexcContainerptr + ZHEAD_SIZE; + cexcElementptr = cexcContainerptr + ZCON_HEAD_SIZE; + } else { + jam(); + cexcContainerptr = ((cexcContainerptr + ZHEAD_SIZE) + ZBUF_SIZE) - ZCON_HEAD_SIZE; + cexcElementptr = cexcContainerptr - 1; + }//if + arrGuard(cexcContainerptr, 2048); + cexcContainerhead = excPageptr.p->word32[cexcContainerptr]; + cexcContainerlen = cexcContainerhead >> 26; + cexcMovedLen = ZCON_HEAD_SIZE; + if (cexcContainerlen <= ZCON_HEAD_SIZE) { + ndbrequire(cexcContainerlen >= ZCON_HEAD_SIZE); + jam(); + goto NEXT_ELEMENT; + }//if + NEXT_ELEMENT_LOOP: + idrOperationRecPtr.i = RNIL; + ptrNull(idrOperationRecPtr); + /* --------------------------------------------------------------------------------- */ + /* CEXC_PAGEINDEX PAGE INDEX OF CURRENT CONTAINER BEING EXAMINED. */ + /* CEXC_CONTAINERPTR INDEX OF CURRENT CONTAINER BEING EXAMINED. */ + /* CEXC_ELEMENTPTR INDEX OF CURRENT ELEMENT BEING EXAMINED. */ + /* EXC_PAGEPTR PAGE WHERE CURRENT ELEMENT RESIDES. */ + /* CEXC_PREVPAGEPTR PAGE OF PREVIOUS CONTAINER. */ + /* CEXC_PREVCONPTR INDEX OF PREVIOUS CONTAINER */ + /* CEXC_FORWARD DIRECTION OF CURRENT CONTAINER */ + /* --------------------------------------------------------------------------------- */ + arrGuard(cexcElementptr, 2048); + tidrElemhead = excPageptr.p->word32[cexcElementptr]; + if (ElementHeader::getUnlocked(tidrElemhead)){ + jam(); + texcHashvalue = ElementHeader::getHashValuePart(tidrElemhead); + } else { + jam(); + idrOperationRecPtr.i = ElementHeader::getOpPtrI(tidrElemhead); + ptrCheckGuard(idrOperationRecPtr, coprecsize, operationrec); + texcHashvalue = idrOperationRecPtr.p->hashvaluePart; + if ((fragrecptr.p->createLcp == ZTRUE) && + (((texcHashvalue >> fragrecptr.p->hashcheckbit) & 1) != 0)) { + jam(); + /* --------------------------------------------------------------------------------- */ + // During local checkpoints we must ensure that we restore the element header in + // unlocked state and with the hash value part there with tuple status zeroed. + // Otherwise a later insert over the same element will write an UNDO log that will + // ensure that the now removed element is restored together with its locked element + // header and without the hash value part. + /* --------------------------------------------------------------------------------- */ + const Uint32 hv = idrOperationRecPtr.p->hashvaluePart; + const Uint32 eh = ElementHeader::setUnlocked(hv, 0); + excPageptr.p->word32[cexcElementptr] = eh; + }//if + }//if + if (((texcHashvalue >> fragrecptr.p->hashcheckbit) & 1) == 0) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THIS ELEMENT IS NOT TO BE MOVED. WE CALCULATE THE WHEREABOUTS OF THE NEXT */ + /* ELEMENT AND PROCEED WITH THAT OR END THE SEARCH IF THERE ARE NO MORE */ + /* ELEMENTS IN THIS CONTAINER. */ + /* --------------------------------------------------------------------------------- */ + goto NEXT_ELEMENT; + }//if + /* --------------------------------------------------------------------------------- */ + /* THE HASH BIT WAS SET AND WE SHALL MOVE THIS ELEMENT TO THE NEW BUCKET. */ + /* WE START BY READING THE ELEMENT TO BE ABLE TO INSERT IT INTO THE NEW BUCKET.*/ + /* THEN WE INSERT THE ELEMENT INTO THE NEW BUCKET. THE NEXT STEP IS TO DELETE */ + /* THE ELEMENT FROM THIS BUCKET. THIS IS PERFORMED BY REPLACING IT WITH THE */ + /* LAST ELEMENT IN THE BUCKET. IF THIS ELEMENT IS TO BE MOVED WE MOVE IT AND */ + /* GET THE LAST ELEMENT AGAIN UNTIL WE EITHER FIND ONE THAT STAYS OR THIS */ + /* ELEMENT IS THE LAST ELEMENT. */ + /* --------------------------------------------------------------------------------- */ + texcTmp = cexcElementptr + cexcForward; + guard20 = fragrecptr.p->localkeylen - 1; + for (texcIndex = 0; texcIndex <= guard20; texcIndex++) { + arrGuard(texcIndex, 2); + arrGuard(texcTmp, 2048); + clocalkey[texcIndex] = excPageptr.p->word32[texcTmp]; + texcTmp = texcTmp + cexcForward; + }//for + guard20 = texpKeyLen - 1; + for (texcIndex = 0; texcIndex <= guard20; texcIndex++) { + arrGuard(texcIndex, 2048); + arrGuard(texcTmp, 2048); + ckeys[texcIndex] = excPageptr.p->word32[texcTmp]; + texcTmp = texcTmp + cexcForward; + }//for + tidrPageindex = fragrecptr.p->expReceiveIndex; + idrPageptr.i = fragrecptr.p->expReceivePageptr; + ptrCheckGuard(idrPageptr, cpagesize, page8); + tidrForward = fragrecptr.p->expReceiveForward; + tidrKeyLen = texpKeyLen; + insertElement(signal); + fragrecptr.p->expReceiveIndex = tidrPageindex; + fragrecptr.p->expReceivePageptr = idrPageptr.i; + fragrecptr.p->expReceiveForward = tidrForward; + REMOVE_LAST_LOOP: + jam(); + lastPageptr.i = excPageptr.i; + lastPageptr.p = excPageptr.p; + tlastContainerptr = cexcContainerptr; + lastPrevpageptr.i = cexcPrevpageptr; + ptrCheck(lastPrevpageptr, cpagesize, page8); + tlastPrevconptr = cexcPrevconptr; + arrGuard(tlastContainerptr, 2048); + tlastContainerhead = lastPageptr.p->word32[tlastContainerptr]; + tlastContainerlen = tlastContainerhead >> 26; + tlastForward = cexcForward; + tlastPageindex = cexcPageindex; + getLastAndRemove(signal); + if (excPageptr.i == lastPageptr.i) { + if (cexcElementptr == tlastElementptr) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THE CURRENT ELEMENT WAS ALSO THE LAST ELEMENT. */ + /* --------------------------------------------------------------------------------- */ + return; + }//if + }//if + /* --------------------------------------------------------------------------------- */ + /* THE CURRENT ELEMENT WAS NOT THE LAST ELEMENT. IF THE LAST ELEMENT SHOULD */ + /* STAY WE COPY IT TO THE POSITION OF THE CURRENT ELEMENT, OTHERWISE WE INSERT */ + /* INTO THE NEW BUCKET, REMOVE IT AND TRY WITH THE NEW LAST ELEMENT. */ + /* --------------------------------------------------------------------------------- */ + idrOperationRecPtr.i = RNIL; + ptrNull(idrOperationRecPtr); + arrGuard(tlastElementptr, 2048); + tidrElemhead = lastPageptr.p->word32[tlastElementptr]; + if (ElementHeader::getUnlocked(tidrElemhead)) { + jam(); + texcHashvalue = ElementHeader::getHashValuePart(tidrElemhead); + } else { + jam(); + idrOperationRecPtr.i = ElementHeader::getOpPtrI(tidrElemhead); + ptrCheckGuard(idrOperationRecPtr, coprecsize, operationrec); + texcHashvalue = idrOperationRecPtr.p->hashvaluePart; + if ((fragrecptr.p->createLcp == ZTRUE) && + (((texcHashvalue >> fragrecptr.p->hashcheckbit) & 1) != 0)) { + jam(); + /* --------------------------------------------------------------------------------- */ + // During local checkpoints we must ensure that we restore the element header in + // unlocked state and with the hash value part there with tuple status zeroed. + // Otherwise a later insert over the same element will write an UNDO log that will + // ensure that the now removed element is restored together with its locked element + // header and without the hash value part. + /* --------------------------------------------------------------------------------- */ + const Uint32 hv = idrOperationRecPtr.p->hashvaluePart; + const Uint32 eh = ElementHeader::setUnlocked(hv, 0); + lastPageptr.p->word32[tlastElementptr] = eh; + }//if + }//if + if (((texcHashvalue >> fragrecptr.p->hashcheckbit) & 1) == 0) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THE LAST ELEMENT IS NOT TO BE MOVED. WE COPY IT TO THE CURRENT ELEMENT. */ + /* --------------------------------------------------------------------------------- */ + delPageptr = excPageptr; + tdelContainerptr = cexcContainerptr; + tdelForward = cexcForward; + tdelElementptr = cexcElementptr; + deleteElement(signal); + } else { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THE LAST ELEMENT IS ALSO TO BE MOVED. */ + /* --------------------------------------------------------------------------------- */ + texcTmp = tlastElementptr + tlastForward; + for (texcIndex = 0; texcIndex < fragrecptr.p->localkeylen; texcIndex++) { + arrGuard(texcIndex, 2); + arrGuard(texcTmp, 2048); + clocalkey[texcIndex] = lastPageptr.p->word32[texcTmp]; + texcTmp = texcTmp + tlastForward; + }//for + for (texcIndex = 0; texcIndex < texpKeyLen; texcIndex++) { + arrGuard(texcIndex, 2048); + arrGuard(texcTmp, 2048); + ckeys[texcIndex] = lastPageptr.p->word32[texcTmp]; + texcTmp = texcTmp + tlastForward; + }//for + tidrPageindex = fragrecptr.p->expReceiveIndex; + idrPageptr.i = fragrecptr.p->expReceivePageptr; + ptrCheckGuard(idrPageptr, cpagesize, page8); + tidrForward = fragrecptr.p->expReceiveForward; + tidrKeyLen = texpKeyLen; + insertElement(signal); + fragrecptr.p->expReceiveIndex = tidrPageindex; + fragrecptr.p->expReceivePageptr = idrPageptr.i; + fragrecptr.p->expReceiveForward = tidrForward; + goto REMOVE_LAST_LOOP; + }//if + NEXT_ELEMENT: + arrGuard(cexcContainerptr, 2048); + cexcContainerhead = excPageptr.p->word32[cexcContainerptr]; + cexcMovedLen = cexcMovedLen + fragrecptr.p->elementLength; + if ((cexcContainerhead >> 26) > cexcMovedLen) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* WE HAVE NOT YET MOVED THE COMPLETE CONTAINER. WE PROCEED WITH THE NEXT */ + /* ELEMENT IN THE CONTAINER. IT IS IMPORTANT TO READ THE CONTAINER LENGTH */ + /* FROM THE CONTAINER HEADER SINCE IT MIGHT CHANGE BY REMOVING THE LAST */ + /* ELEMENT IN THE BUCKET. */ + /* --------------------------------------------------------------------------------- */ + cexcElementptr = cexcElementptr + (cexcForward * fragrecptr.p->elementLength); + goto NEXT_ELEMENT_LOOP; + }//if + if (((cexcContainerhead >> 7) & 3) != 0) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* WE PROCEED TO THE NEXT CONTAINER IN THE BUCKET. */ + /* --------------------------------------------------------------------------------- */ + cexcPrevpageptr = excPageptr.i; + cexcPrevconptr = cexcContainerptr; + nextcontainerinfoExp(signal); + goto EXP_CONTAINER_LOOP; + }//if +}//Dbacc::expandcontainer() + +/* ******************--------------------------------------------------------------- */ +/* SHRINKCHECK JOIN BUCKET ORD */ +/* SENDER: ACC, LEVEL B */ +/* INPUT: FRAGRECPTR, POINTS TO A FRAGMENT RECORD. */ +/* DESCRIPTION: TWO BUCKET OF A FRAGMENT PAGE WILL BE JOINED TOGETHER */ +/* ACCORDING TO LH3. */ +/* ******************--------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* SHRINKCHECK JOIN BUCKET ORD */ +/* ******************------------------------------+ */ +/* SENDER: ACC, LEVEL B */ +/* TWO BUCKETS OF THE FRAGMENT */ +/* WILL BE JOINED ACORDING TO LH3 */ +/* AND COMMIT TRANSACTION PROCESS */ +/* WILL BE CONTINUED */ +Uint32 Dbacc::checkScanShrink(Signal* signal) +{ + Uint32 Ti; + Uint32 TreturnCode = 0; + Uint32 TPageIndex; + Uint32 TDirInd; + Uint32 TmergeDest; + Uint32 TmergeSource; + Uint32 TreleaseScanBucket; + Uint32 TreleaseInd = 0; + Uint32 TreleaseScanIndicator[4]; + DirectoryarrayPtr TDirptr; + DirRangePtr TDirRangePtr; + Page8Ptr TPageptr; + ScanRecPtr TscanPtr; + RootfragmentrecPtr Trootfragrecptr; + + Trootfragrecptr.i = fragrecptr.p->myroot; + ptrCheckGuard(Trootfragrecptr, crootfragmentsize, rootfragmentrec); + if (fragrecptr.p->p == 0) { + jam(); + TmergeDest = fragrecptr.p->maxp >> 1; + } else { + jam(); + TmergeDest = fragrecptr.p->p - 1; + }//if + TmergeSource = fragrecptr.p->maxp + fragrecptr.p->p; + for (Ti = 0; Ti < 4; Ti++) { + TreleaseScanIndicator[Ti] = 0; + if (Trootfragrecptr.p->scan[Ti] != RNIL) { + TscanPtr.i = Trootfragrecptr.p->scan[Ti]; + ptrCheckGuard(TscanPtr, cscanRecSize, scanRec); + if (TscanPtr.p->activeLocalFrag == fragrecptr.i) { + //------------------------------------------------------------- + // A scan is ongoing on this particular local fragment. We have + // to check its current state. + //------------------------------------------------------------- + if (TscanPtr.p->scanBucketState == ScanRec::FIRST_LAP) { + jam(); + if ((TmergeDest == TscanPtr.p->nextBucketIndex) || + (TmergeSource == TscanPtr.p->nextBucketIndex)) { + jam(); + //------------------------------------------------------------- + // We are currently scanning one of the buckets involved in the + // merge. We cannot merge while simultaneously performing a scan. + // We have to pass this offer for merging the buckets. + //------------------------------------------------------------- + TreturnCode = 1; + return TreturnCode; + } else if (TmergeDest < TscanPtr.p->nextBucketIndex) { + jam(); + TreleaseScanIndicator[Ti] = 1; + TreleaseInd = 1; + }//if + } else if (TscanPtr.p->scanBucketState == ScanRec::SECOND_LAP) { + jam(); + //------------------------------------------------------------- + // We are performing a second lap to handle buckets that was + // merged during the first lap of scanning. During this second + // lap we do not allow any splits or merges. + //------------------------------------------------------------- + TreturnCode = 1; + return TreturnCode; + } else if (TscanPtr.p->scanBucketState == ScanRec::SCAN_COMPLETED) { + jam(); + //------------------------------------------------------------- + // The scan is completed and we can thus go ahead and perform + // the split. + //------------------------------------------------------------- + } else { + jam(); + sendSystemerror(signal); + return TreturnCode; + }//if + }//if + }//if + }//for + if (TreleaseInd == 1) { + jam(); + TreleaseScanBucket = TmergeSource; + TDirRangePtr.i = fragrecptr.p->directory; + TPageIndex = TreleaseScanBucket & ((1 << fragrecptr.p->k) - 1); /* PAGE INDEX OBS K = 6 */ + TDirInd = TreleaseScanBucket >> fragrecptr.p->k; /* DIRECTORY INDEX OBS K = 6 */ + ptrCheckGuard(TDirRangePtr, cdirrangesize, dirRange); + arrGuard((TDirInd >> 8), 256); + TDirptr.i = TDirRangePtr.p->dirArray[TDirInd >> 8]; + ptrCheckGuard(TDirptr, cdirarraysize, directoryarray); + TPageptr.i = TDirptr.p->pagep[TDirInd & 0xff]; + ptrCheckGuard(TPageptr, cpagesize, page8); + for (Ti = 0; Ti < 4; Ti++) { + if (TreleaseScanIndicator[Ti] == 1) { + jam(); + scanPtr.i = Trootfragrecptr.p->scan[Ti]; + ptrCheckGuard(scanPtr, cscanRecSize, scanRec); + rsbPageidptr.i = TPageptr.i; + rsbPageidptr.p = TPageptr.p; + trsbPageindex = TPageIndex; + releaseScanBucket(signal); + if (TmergeDest < scanPtr.p->minBucketIndexToRescan) { + jam(); + //------------------------------------------------------------- + // We have to keep track of the starting bucket to Rescan in the + // second lap. + //------------------------------------------------------------- + scanPtr.p->minBucketIndexToRescan = TmergeDest; + }//if + if (TmergeDest > scanPtr.p->maxBucketIndexToRescan) { + jam(); + //------------------------------------------------------------- + // We have to keep track of the ending bucket to Rescan in the + // second lap. + //------------------------------------------------------------- + scanPtr.p->maxBucketIndexToRescan = TmergeDest; + }//if + }//if + }//for + }//if + return TreturnCode; +}//Dbacc::checkScanShrink() + +void Dbacc::execSHRINKCHECK2(Signal* signal) +{ + Uint32 tshrTmp1; + + jamEntry(); + fragrecptr.i = signal->theData[0]; + tresult = 0; /* 0= FALSE,1= TRUE,> ZLIMIT_OF_ERROR =ERRORCODE */ + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + fragrecptr.p->expandFlag = 0; + if (fragrecptr.p->slack <= fragrecptr.p->slackCheck) { + jam(); + /* TIME FOR JOIN BUCKETS PROCESS */ + /*--------------------------------------------------------------*/ + /* NO LONGER NECESSARY TO SHRINK THE FRAGMENT. */ + /*--------------------------------------------------------------*/ + return; + }//if + if (fragrecptr.p->slack > (Uint32)(1 << 31)) { + jam(); + /*--------------------------------------------------------------*/ + /* THE SLACK IS NEGATIVE, IN THIS CASE WE WILL NOT NEED ANY */ + /* SHRINK. */ + /*--------------------------------------------------------------*/ + return; + }//if + texpDirInd = (fragrecptr.p->maxp + fragrecptr.p->p) >> fragrecptr.p->k; + if (((fragrecptr.p->maxp + fragrecptr.p->p) & ((1 << fragrecptr.p->k) - 1)) == 0) { + if (fragrecptr.p->createLcp == ZTRUE) { + if (fragrecptr.p->fragState == LCP_SEND_PAGES) { + if (fragrecptr.p->lcpMaxDirIndex > texpDirInd) { + if (fragrecptr.p->lcpDirIndex <= texpDirInd) { + jam(); + /*--------------------------------------------------------------*/ + /* WE DO NOT ALLOW ANY SHRINKS THAT REMOVE PAGES THAT ARE */ + /* NEEDED AS PART OF THE LOCAL CHECKPOINT. */ + /*--------------------------------------------------------------*/ + return; + }//if + }//if + }//if + }//if + }//if + if (fragrecptr.p->firstOverflowRec == RNIL) { + jam(); + allocOverflowPage(signal); + if (tresult > ZLIMIT_OF_ERROR) { + jam(); + return; + }//if + }//if + if (cfirstfreepage == RNIL) { + if (cfreepage >= cpagesize) { + jam(); + /*--------------------------------------------------------------*/ + /* WE HAVE TO STOP THE SHRINK PROCESS SINCE THERE ARE NO FREE */ + /* PAGES. THIS MEANS THAT WE COULD BE FORCED TO CRASH SINCE WE */ + /* CANNOT COMPLETE THE SHRINK. TO AVOID THE CRASH WE EXIT HERE. */ + /*--------------------------------------------------------------*/ + return; + }//if + }//if + if (checkScanShrink(signal) == 1) { + jam(); + /*--------------------------------------------------------------*/ + // A scan state was inconsistent with performing a shrink + // operation. + /*--------------------------------------------------------------*/ + return; + }//if + if (fragrecptr.p->createLcp == ZTRUE) { + if (remainingUndoPages() < ZMIN_UNDO_PAGES_AT_EXPAND) { + jam(); + /*--------------------------------------------------------------*/ + // We did not have enough undo log buffers to start up an + // shrink operation + /*--------------------------------------------------------------*/ + return; + }//if + }//if + if (fragrecptr.p->p == 0) { + jam(); + fragrecptr.p->maxp = fragrecptr.p->maxp >> 1; + fragrecptr.p->p = fragrecptr.p->maxp; + fragrecptr.p->lhdirbits--; + fragrecptr.p->hashcheckbit--; + } else { + jam(); + fragrecptr.p->p--; + }//if + /*--------------------------------------------------------------------------*/ + /* WE START BY FINDING THE NECESSARY INFORMATION OF THE BUCKET TO BE */ + /* REMOVED WHICH WILL SEND ITS ELEMENTS TO THE RECEIVING BUCKET. */ + /*--------------------------------------------------------------------------*/ + expDirRangePtr.i = fragrecptr.p->directory; + cexcPageindex = ((fragrecptr.p->maxp + fragrecptr.p->p) + 1) & ((1 << fragrecptr.p->k) - 1); + texpDirInd = ((fragrecptr.p->maxp + fragrecptr.p->p) + 1) >> fragrecptr.p->k; + texpDirRangeIndex = texpDirInd >> 8; + texpDirPageIndex = texpDirInd & 0xff; + ptrCheckGuard(expDirRangePtr, cdirrangesize, dirRange); + arrGuard(texpDirRangeIndex, 256); + expDirptr.i = expDirRangePtr.p->dirArray[texpDirRangeIndex]; + ptrCheckGuard(expDirptr, cdirarraysize, directoryarray); + excPageptr.i = expDirptr.p->pagep[texpDirPageIndex]; + fragrecptr.p->expSenderDirptr = expDirptr.i; + fragrecptr.p->expSenderIndex = cexcPageindex; + fragrecptr.p->expSenderPageptr = excPageptr.i; + fragrecptr.p->expSenderDirIndex = texpDirInd; + /*--------------------------------------------------------------------------*/ + /* WE NOW PROCEED BY FINDING THE NECESSARY INFORMATION ABOUT THE */ + /* RECEIVING BUCKET. */ + /*--------------------------------------------------------------------------*/ + expDirRangePtr.i = fragrecptr.p->directory; + texpReceivedBucket = fragrecptr.p->p >> fragrecptr.p->k; + ptrCheckGuard(expDirRangePtr, cdirrangesize, dirRange); + arrGuard((texpReceivedBucket >> 8), 256); + expDirptr.i = expDirRangePtr.p->dirArray[texpReceivedBucket >> 8]; + ptrCheckGuard(expDirptr, cdirarraysize, directoryarray); + fragrecptr.p->expReceivePageptr = expDirptr.p->pagep[texpReceivedBucket & 0xff]; + fragrecptr.p->expReceiveIndex = fragrecptr.p->p & ((1 << fragrecptr.p->k) - 1); + fragrecptr.p->expReceiveForward = ZTRUE; + if (excPageptr.i == RNIL) { + jam(); + endofshrinkbucketLab(signal); /* EMPTY BUCKET */ + return; + }//if + /*--------------------------------------------------------------------------*/ + /* INITIALISE THE VARIABLES FOR THE SHRINK PROCESS. */ + /*--------------------------------------------------------------------------*/ + ptrCheckGuard(excPageptr, cpagesize, page8); + cexcForward = ZTRUE; + cexcContainerptr = (cexcPageindex << ZSHIFT_PLUS) - (cexcPageindex << ZSHIFT_MINUS); + cexcContainerptr = cexcContainerptr + ZHEAD_SIZE; + arrGuard(cexcContainerptr, 2048); + cexcContainerhead = excPageptr.p->word32[cexcContainerptr]; + cexcContainerlen = cexcContainerhead >> 26; + if (cexcContainerlen <= ZCON_HEAD_SIZE) { + ndbrequire(cexcContainerlen == ZCON_HEAD_SIZE); + } else { + jam(); + shrinkcontainer(signal); + }//if + /*--------------------------------------------------------------------------*/ + /* THIS CONTAINER IS NOT YET EMPTY AND WE REMOVE ALL THE ELEMENTS. */ + /*--------------------------------------------------------------------------*/ + if (((cexcContainerhead >> 10) & 1) == 1) { + jam(); + rlPageptr = excPageptr; + trlPageindex = cexcPageindex; + trlRelCon = ZFALSE; + turlIndex = cexcContainerptr + (ZBUF_SIZE - ZCON_HEAD_SIZE); + releaseRightlist(signal); + }//if + tshrTmp1 = ZCON_HEAD_SIZE; + tshrTmp1 = tshrTmp1 << 26; + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + datapageptr.p = excPageptr.p; + cundoinfolength = 1; + cundoElemIndex = cexcContainerptr; + undoWritingProcess(signal); + }//if + dbgWord32(excPageptr, cexcContainerptr, tshrTmp1); + arrGuard(cexcContainerptr, 2048); + excPageptr.p->word32[cexcContainerptr] = tshrTmp1; + if (((cexcContainerhead >> 7) & 0x3) == 0) { + jam(); + endofshrinkbucketLab(signal); + return; + }//if + nextcontainerinfoExp(signal); + do { + cexcContainerptr = (cexcPageindex << ZSHIFT_PLUS) - (cexcPageindex << ZSHIFT_MINUS); + if (cexcForward == ZTRUE) { + jam(); + cexcContainerptr = cexcContainerptr + ZHEAD_SIZE; + } else { + jam(); + cexcContainerptr = ((cexcContainerptr + ZHEAD_SIZE) + ZBUF_SIZE) - ZCON_HEAD_SIZE; + }//if + arrGuard(cexcContainerptr, 2048); + cexcContainerhead = excPageptr.p->word32[cexcContainerptr]; + cexcContainerlen = cexcContainerhead >> 26; + ndbrequire(cexcContainerlen > ZCON_HEAD_SIZE); + /*--------------------------------------------------------------------------*/ + /* THIS CONTAINER IS NOT YET EMPTY AND WE REMOVE ALL THE ELEMENTS. */ + /*--------------------------------------------------------------------------*/ + shrinkcontainer(signal); + cexcPrevpageptr = excPageptr.i; + cexcPrevpageindex = cexcPageindex; + cexcPrevforward = cexcForward; + if (((cexcContainerhead >> 7) & 0x3) != 0) { + jam(); + /*--------------------------------------------------------------------------*/ + /* WE MUST CALL THE NEXT CONTAINER INFO ROUTINE BEFORE WE RELEASE THE */ + /* CONTAINER SINCE THE RELEASE WILL OVERWRITE THE NEXT POINTER. */ + /*--------------------------------------------------------------------------*/ + nextcontainerinfoExp(signal); + }//if + rlPageptr.i = cexcPrevpageptr; + ptrCheckGuard(rlPageptr, cpagesize, page8); + trlPageindex = cexcPrevpageindex; + if (cexcPrevforward == ZTRUE) { + jam(); + if (((cexcContainerhead >> 10) & 1) == 1) { + jam(); + trlRelCon = ZFALSE; + turlIndex = cexcContainerptr + (ZBUF_SIZE - ZCON_HEAD_SIZE); + releaseRightlist(signal); + }//if + trlRelCon = ZTRUE; + tullIndex = cexcContainerptr; + releaseLeftlist(signal); + } else { + jam(); + if (((cexcContainerhead >> 10) & 1) == 1) { + jam(); + trlRelCon = ZFALSE; + tullIndex = cexcContainerptr - (ZBUF_SIZE - ZCON_HEAD_SIZE); + releaseLeftlist(signal); + }//if + trlRelCon = ZTRUE; + turlIndex = cexcContainerptr; + releaseRightlist(signal); + }//if + } while (((cexcContainerhead >> 7) & 0x3) != 0); + endofshrinkbucketLab(signal); + return; +}//Dbacc::execSHRINKCHECK2() + +void Dbacc::endofshrinkbucketLab(Signal* signal) +{ + fragrecptr.p->expandCounter--; + fragrecptr.p->slack -= fragrecptr.p->maxloadfactor; + if (fragrecptr.p->expSenderIndex == 0) { + jam(); + fragrecptr.p->dirsize--; + if (fragrecptr.p->expSenderPageptr != RNIL) { + jam(); + rpPageptr.i = fragrecptr.p->expSenderPageptr; + ptrCheckGuard(rpPageptr, cpagesize, page8); + releasePage(signal); + expDirptr.i = fragrecptr.p->expSenderDirptr; + ptrCheckGuard(expDirptr, cdirarraysize, directoryarray); + expDirptr.p->pagep[fragrecptr.p->expSenderDirIndex & 0xff] = RNIL; + }//if + if (((((fragrecptr.p->p + fragrecptr.p->maxp) + 1) >> fragrecptr.p->k) & 0xff) == 0) { + jam(); + rdDirptr.i = fragrecptr.p->expSenderDirptr; + releaseDirectory(signal); + expDirRangePtr.i = fragrecptr.p->directory; + ptrCheckGuard(expDirRangePtr, cdirrangesize, dirRange); + arrGuard((fragrecptr.p->expSenderDirIndex >> 8), 256); + expDirRangePtr.p->dirArray[fragrecptr.p->expSenderDirIndex >> 8] = RNIL; + }//if + }//if + if (fragrecptr.p->slack < (Uint32)(1 << 31)) { + jam(); + /*--------------------------------------------------------------*/ + /* THE SLACK IS POSITIVE, IN THIS CASE WE WILL CHECK WHETHER */ + /* WE WILL CONTINUE PERFORM ANOTHER SHRINK. */ + /*--------------------------------------------------------------*/ + Uint32 noOfBuckets = (fragrecptr.p->maxp + 1) + fragrecptr.p->p; + Uint32 Thysteresis = fragrecptr.p->maxloadfactor - fragrecptr.p->minloadfactor; + fragrecptr.p->slackCheck = noOfBuckets * Thysteresis; + if (fragrecptr.p->slack > Thysteresis) { + /*--------------------------------------------------------------*/ + /* IT IS STILL NECESSARY TO SHRINK THE FRAGMENT MORE. THIS*/ + /* CAN HAPPEN WHEN A NUMBER OF SHRINKS GET REJECTED */ + /* DURING A LOCAL CHECKPOINT. WE START A NEW SHRINK */ + /* IMMEDIATELY FROM HERE WITHOUT WAITING FOR A COMMIT TO */ + /* START IT. */ + /*--------------------------------------------------------------*/ + if (fragrecptr.p->expandCounter > 0) { + jam(); + /*--------------------------------------------------------------*/ + /* IT IS VERY IMPORTANT TO NOT TRY TO SHRINK MORE THAN */ + /* WAS EXPANDED. IF MAXP IS SET TO A VALUE BELOW 63 THEN */ + /* WE WILL LOSE RECORDS SINCE GETDIRINDEX CANNOT HANDLE */ + /* SHRINKING BELOW 2^K - 1 (NOW 63). THIS WAS A BUG THAT */ + /* WAS REMOVED 2000-05-12. */ + /*--------------------------------------------------------------*/ + fragrecptr.p->expandFlag = 1; + signal->theData[0] = fragrecptr.i; + signal->theData[1] = fragrecptr.p->p; + signal->theData[2] = fragrecptr.p->maxp; + sendSignal(cownBlockref, GSN_SHRINKCHECK2, signal, 3, JBB); + }//if + }//if + }//if + ndbrequire(fragrecptr.p->maxp >= (Uint32)((1 << fragrecptr.p->k) - 1)); + return; +}//Dbacc::endofshrinkbucketLab() + +/* --------------------------------------------------------------------------------- */ +/* SHRINKCONTAINER */ +/* INPUT: EXC_PAGEPTR (POINTER TO THE ACTIVE PAGE RECORD) */ +/* CEXC_CONTAINERLEN (LENGTH OF THE CONTAINER). */ +/* CEXC_CONTAINERPTR (ARRAY INDEX OF THE CONTAINER). */ +/* CEXC_FORWARD (CONTAINER FORWARD (+1) OR BACKWARD (-1)) */ +/* */ +/* DESCRIPTION: ALL ELEMENTS OF THE ACTIVE CONTAINER HAVE TO MOVE TO THE NEW */ +/* CONTAINER. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::shrinkcontainer(Signal* signal) +{ + Uint32 tshrElementptr; + Uint32 tshrRemLen; + Uint32 tshrInc; + Uint32 tshrKeyLen; + Uint32 tshrTmp; + Uint32 tshrIndex; + Uint32 guard21; + + tshrRemLen = cexcContainerlen - ZCON_HEAD_SIZE; + tshrKeyLen = fragrecptr.p->keyLength; + if (tshrKeyLen == 0) { + jam(); + tshrKeyLen = ZACTIVE_LONG_KEY_LEN; + }//if + tshrInc = (ZELEM_HEAD_SIZE + tshrKeyLen) + fragrecptr.p->localkeylen; + if (cexcForward == ZTRUE) { + jam(); + tshrElementptr = cexcContainerptr + ZCON_HEAD_SIZE; + } else { + jam(); + tshrElementptr = cexcContainerptr - 1; + }//if + SHR_LOOP: + idrOperationRecPtr.i = RNIL; + ptrNull(idrOperationRecPtr); + /* --------------------------------------------------------------------------------- */ + /* THE CODE BELOW IS ALL USED TO PREPARE FOR THE CALL TO INSERT_ELEMENT AND */ + /* HANDLE THE RESULT FROM INSERT_ELEMENT. INSERT_ELEMENT INSERTS THE ELEMENT */ + /* INTO ANOTHER BUCKET. */ + /* --------------------------------------------------------------------------------- */ + arrGuard(tshrElementptr, 2048); + tidrElemhead = excPageptr.p->word32[tshrElementptr]; + if (ElementHeader::getLocked(tidrElemhead)) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* IF THE ELEMENT IS LOCKED WE MUST UPDATE THE ELEMENT INFO IN THE OPERATION */ + /* RECORD OWNING THE LOCK. WE DO THIS BY READING THE OPERATION RECORD POINTER */ + /* FROM THE ELEMENT HEADER. */ + /* --------------------------------------------------------------------------------- */ + idrOperationRecPtr.i = ElementHeader::getOpPtrI(tidrElemhead); + ptrCheckGuard(idrOperationRecPtr, coprecsize, operationrec); + if (fragrecptr.p->createLcp == ZTRUE) { + jam(); + /* --------------------------------------------------------------------------------- */ + // During local checkpoints we must ensure that we restore the element header in + // unlocked state and with the hash value part there with tuple status zeroed. + // Otherwise a later insert over the same element will write an UNDO log that will + // ensure that the now removed element is restored together with its locked element + // header and without the hash value part. + /* --------------------------------------------------------------------------------- */ + const Uint32 hv = idrOperationRecPtr.p->hashvaluePart; + const Uint32 eh = ElementHeader::setUnlocked(hv, 0); + excPageptr.p->word32[tshrElementptr] = eh; + }//if + }//if + tshrTmp = tshrElementptr + cexcForward; + guard21 = fragrecptr.p->localkeylen - 1; + for (tshrIndex = 0; tshrIndex <= guard21; tshrIndex++) { + arrGuard(tshrIndex, 2); + arrGuard(tshrTmp, 2048); + clocalkey[tshrIndex] = excPageptr.p->word32[tshrTmp]; + tshrTmp = tshrTmp + cexcForward; + }//for + guard21 = tshrKeyLen - 1; + for (tshrIndex = 0; tshrIndex <= guard21; tshrIndex++) { + arrGuard(tshrIndex, 2048); + arrGuard(tshrTmp, 2048); + ckeys[tshrIndex] = excPageptr.p->word32[tshrTmp]; + tshrTmp = tshrTmp + cexcForward; + }//for + tidrPageindex = fragrecptr.p->expReceiveIndex; + idrPageptr.i = fragrecptr.p->expReceivePageptr; + ptrCheckGuard(idrPageptr, cpagesize, page8); + tidrForward = fragrecptr.p->expReceiveForward; + tidrKeyLen = tshrKeyLen; + insertElement(signal); + /* --------------------------------------------------------------------------------- */ + /* TAKE CARE OF RESULT FROM INSERT_ELEMENT. */ + /* --------------------------------------------------------------------------------- */ + fragrecptr.p->expReceiveIndex = tidrPageindex; + fragrecptr.p->expReceivePageptr = idrPageptr.i; + fragrecptr.p->expReceiveForward = tidrForward; + if (tshrRemLen < tshrInc) { + jam(); + sendSystemerror(signal); + }//if + tshrRemLen = tshrRemLen - tshrInc; + if (tshrRemLen != 0) { + jam(); + tshrElementptr = tshrTmp; + goto SHR_LOOP; + }//if +}//Dbacc::shrinkcontainer() + +/* --------------------------------------------------------------------------------- */ +/* NEXTCONTAINERINFO_EXP */ +/* DESCRIPTION:THE CONTAINER HEAD WILL BE CHECKED TO CALCULATE INFORMATION */ +/* ABOUT NEXT CONTAINER IN THE BUCKET. */ +/* INPUT: CEXC_CONTAINERHEAD */ +/* CEXC_CONTAINERPTR */ +/* EXC_PAGEPTR */ +/* OUTPUT: */ +/* CEXC_PAGEINDEX (INDEX FROM WHICH PAGE INDEX CAN BE CALCULATED. */ +/* EXC_PAGEPTR (PAGE REFERENCE OF NEXT CONTAINER) */ +/* CEXC_FORWARD */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::nextcontainerinfoExp(Signal* signal) +{ + tnciNextSamePage = (cexcContainerhead >> 9) & 0x1; /* CHECK BIT FOR CHECKING WHERE */ + /* THE NEXT CONTAINER IS IN THE SAME PAGE */ + cexcPageindex = cexcContainerhead & 0x7f; /* NEXT CONTAINER PAGE INDEX 7 BITS */ + if (((cexcContainerhead >> 7) & 3) == ZLEFT) { + jam(); + cexcForward = ZTRUE; + } else if (((cexcContainerhead >> 7) & 3) == ZRIGHT) { + jam(); + cexcForward = cminusOne; + } else { + jam(); + sendSystemerror(signal); + cexcForward = 0; /* DUMMY FOR COMPILER */ + }//if + if (tnciNextSamePage == ZFALSE) { + jam(); + /* NEXT CONTAINER IS IN AN OVERFLOW PAGE */ + arrGuard(cexcContainerptr + 1, 2048); + tnciTmp = excPageptr.p->word32[cexcContainerptr + 1]; + nciOverflowrangeptr.i = fragrecptr.p->overflowdir; + ptrCheckGuard(nciOverflowrangeptr, cdirrangesize, dirRange); + arrGuard((tnciTmp >> 8), 256); + nciOverflowDirptr.i = nciOverflowrangeptr.p->dirArray[tnciTmp >> 8]; + ptrCheckGuard(nciOverflowDirptr, cdirarraysize, directoryarray); + excPageptr.i = nciOverflowDirptr.p->pagep[tnciTmp & 0xff]; + ptrCheckGuard(excPageptr, cpagesize, page8); + }//if +}//Dbacc::nextcontainerinfoExp() + +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* END OF EXPAND/SHRINK MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* LOCAL CHECKPOINT MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* LCP_FRAGIDREQ */ +/* SENDER: LQH, LEVEL B */ +/* ENTER LCP_FRAGIDREQ WITH */ +/* TUSERPTR LQH CONNECTION PTR */ +/* TUSERBLOCKREF, LQH BLOCK REFERENCE */ +/* TCHECKPOINTID, THE CHECKPOINT NUMBER TO USE */ +/* (E.G. 1,2 OR 3) */ +/* TABPTR, TABLE ID = TABLE RECORD POINTER */ +/* TFID ROOT FRAGMENT ID */ +/* CACTIVE_UNDO_FILE_VERSION UNDO FILE VERSION 0,1,2 OR 3. */ +/* ******************--------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* LCP_FRAGIDREQ REQUEST FOR LIST OF STOPED OPERATION */ +/* ******************------------------------------+ */ +/* SENDER: LQH, LEVEL B */ +void Dbacc::execLCP_FRAGIDREQ(Signal* signal) +{ + jamEntry(); + tuserptr = signal->theData[0]; /* LQH CONNECTION PTR */ + tuserblockref = signal->theData[1]; /* LQH BLOCK REFERENCE */ + tcheckpointid = signal->theData[2]; /* THE CHECKPOINT NUMBER TO USE */ + /* (E.G. 1,2 OR 3) */ + tabptr.i = signal->theData[3]; /* TABLE ID = TABLE RECORD POINTER */ + ptrCheck(tabptr, ctablesize, tabrec); + tfid = signal->theData[4]; /* ROOT FRAGMENT ID */ + cactiveUndoFileVersion = signal->theData[5]; /* UNDO FILE VERSION 0,1,2 OR 3. */ + tresult = 0; + ndbrequire(getrootfragmentrec(signal, rootfragrecptr, tfid)); + ndbrequire(rootfragrecptr.p->rootState == ACTIVEROOT); + seizeLcpConnectRec(signal); + initLcpConnRec(signal); + lcpConnectptr.p->rootrecptr = rootfragrecptr.i; + rootfragrecptr.p->lcpPtr = lcpConnectptr.i; + lcpConnectptr.p->localCheckPid = tcheckpointid; + lcpConnectptr.p->lcpstate = LCP_ACTIVE; + rootfragrecptr.p->rootState = LCP_CREATION; + fragrecptr.i = rootfragrecptr.p->fragmentptr[0]; + /* D6 AT FSOPENREQ =#010003FF. */ + tlfrTmp1 = 0x010003ff; /* FILE TYPE = .DATA ,VERSION OF FILENAME = 1 */ + tlfrTmp2 = 0x301; /* D7 CREATE, WRITE ONLY, TRUNCATE TO ZERO */ + ndbrequire(cfsFirstfreeconnect != RNIL); + seizeFsConnectRec(signal); + fsConnectptr.p->fragrecPtr = fragrecptr.i; + fsConnectptr.p->fsState = WAIT_OPEN_DATA_FILE_FOR_WRITE; + /* ----------- FILENAME (FILESYSTEM)/D3/DBACC/"T"TABID/"F"FRAGID/"S"VERSIONID.DATA ------------ */ + /* ************************ */ + /* FSOPENREQ */ + /* ************************ */ + signal->theData[0] = cownBlockref; + signal->theData[1] = fsConnectptr.i; + signal->theData[2] = tabptr.i; /* TABLE IDENTITY */ + signal->theData[3] = rootfragrecptr.p->fragmentid[0]; /* FRAGMENT IDENTITY */ + signal->theData[4] = lcpConnectptr.p->localCheckPid; /* CHECKPOINT ID */ + signal->theData[5] = tlfrTmp1; + signal->theData[6] = tlfrTmp2; + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA); + return; +}//Dbacc::execLCP_FRAGIDREQ() + +/* ******************--------------------------------------------------------------- */ +/* FSOPENCONF OPENFILE CONF */ +/* SENDER: FS, LEVEL B */ +/* ENTER FSOPENCONF WITH */ +/* FS_CONNECTPTR, FS_CONNECTION PTR */ +/* TUSERPOINTER, FILE POINTER */ +/* ******************--------------------------------------------------------------- */ +void Dbacc::lcpFsOpenConfLab(Signal* signal) +{ + fsConnectptr.p->fsPtr = tuserptr; + fragrecptr.i = fsConnectptr.p->fragrecPtr; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + rootfragrecptr.i = fragrecptr.p->myroot; + fragrecptr.p->activeDataFilePage = 1; /* ZERO IS KEPT FOR PAGE_ZERO */ + fragrecptr.p->fsConnPtr = fsConnectptr.i; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + lcpConnectptr.i = rootfragrecptr.p->lcpPtr; + ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec); + if (rootfragrecptr.p->fragmentptr[0] == fragrecptr.i) { + jam(); + fragrecptr.i = rootfragrecptr.p->fragmentptr[1]; + ptrCheck(fragrecptr, cfragmentsize, fragmentrec); + /* ----------- FILENAME (FILESYSTEM)/D3/DBACC/"T"TABID/"F"FRAGID/"S"VERSIONID.DATA ------------ */ + /* D6 AT FSOPENREQ =#010003FF. */ + tlfrTmp1 = 0x010003ff; /* FILE TYPE = .DATA ,VERSION OF FILENAME = 1 */ + tlfrTmp2 = 0x301; /* D7 CREATE, WRITE ONLY, TRUNCATE TO ZERO */ + ndbrequire(cfsFirstfreeconnect != RNIL); + seizeFsConnectRec(signal); + fsConnectptr.p->fragrecPtr = fragrecptr.i; + fsConnectptr.p->fsState = WAIT_OPEN_DATA_FILE_FOR_WRITE; + /* ************************ */ + /* FSOPENREQ */ + /* ************************ */ + signal->theData[0] = cownBlockref; + signal->theData[1] = fsConnectptr.i; + signal->theData[2] = rootfragrecptr.p->mytabptr; /* TABLE IDENTITY */ + signal->theData[3] = rootfragrecptr.p->fragmentid[1]; /* FRAGMENT IDENTITY */ + signal->theData[4] = lcpConnectptr.p->localCheckPid; /* CHECKPOINT ID */ + signal->theData[5] = tlfrTmp1; + signal->theData[6] = tlfrTmp2; + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA); + return; + } else { + ndbrequire(rootfragrecptr.p->fragmentptr[1] == fragrecptr.i); + }//if + /*---- BOTH DATA FILES ARE OPEN------*/ + /* ----IF THE UNDO FILE IS CLOSED , OPEN IT.----- */ + if (cactiveOpenUndoFsPtr != RNIL) { + jam(); + sendLcpFragidconfLab(signal); + return; + }//if + cactiveUndoFilePage = 0; + cprevUndoaddress = cminusOne; + cundoposition = 0; + clastUndoPageIdWritten = 0; + ndbrequire(cfsFirstfreeconnect != RNIL); + seizeFsConnectRec(signal); + fsConnectptr.p->fsState = WAIT_OPEN_UNDO_LCP; + fsConnectptr.p->fsPart = 0; /* FILE INDEX, SECOND FILE IN THE DIRECTORY */ + cactiveOpenUndoFsPtr = fsConnectptr.i; + cactiveRootfrag = rootfragrecptr.i; + tlfrTmp1 = 1; /* FILE VERSION */ + tlfrTmp1 = (tlfrTmp1 << 8) + ZLOCALLOGFILE; /* .LOCLOG = 2 */ + tlfrTmp1 = (tlfrTmp1 << 8) + 4; /* ROOT DIRECTORY = D4 */ + tlfrTmp1 = (tlfrTmp1 << 8) + fsConnectptr.p->fsPart; /* P2 */ + tlfrTmp2 = 0x302; /* D7 CREATE , READ / WRITE , TRUNCATE TO ZERO */ + /* ---FILE NAME "D4"/"DBACC"/LCP_CONNECTPTR:LOCAL_CHECK_PID/FS_CONNECTPTR:FS_PART".LOCLOG-- */ + /* ************************ */ + /* FSOPENREQ */ + /* ************************ */ + signal->theData[0] = cownBlockref; + signal->theData[1] = fsConnectptr.i; + signal->theData[2] = cminusOne; /* #FFFFFFFF */ + signal->theData[3] = cminusOne; /* #FFFFFFFF */ + signal->theData[4] = cactiveUndoFileVersion; + /* A GROUP OF UNDO FILES WHICH ARE UPDATED */ + signal->theData[5] = tlfrTmp1; + signal->theData[6] = tlfrTmp2; + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA); + return; +}//Dbacc::lcpFsOpenConfLab() + +void Dbacc::lcpOpenUndofileConfLab(Signal* signal) +{ + ptrGuard(fsConnectptr); + fsConnectptr.p->fsState = WAIT_NOTHING; + rootfragrecptr.i = cactiveRootfrag; + ptrCheck(rootfragrecptr, crootfragmentsize, rootfragmentrec); + fsConnectptr.p->fsPtr = tuserptr; + sendLcpFragidconfLab(signal); + return; +}//Dbacc::lcpOpenUndofileConfLab() + +void Dbacc::sendLcpFragidconfLab(Signal* signal) +{ + ptrGuard(rootfragrecptr); + lcpConnectptr.i = rootfragrecptr.p->lcpPtr; + ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec); + /* ************************ */ + /* LCP_FRAGIDCONF */ + /* ************************ */ + signal->theData[0] = lcpConnectptr.p->lcpUserptr; + signal->theData[1] = lcpConnectptr.i; + signal->theData[2] = 2; + /* NO OF LOCAL FRAGMENTS */ + signal->theData[3] = rootfragrecptr.p->fragmentid[0]; + signal->theData[4] = rootfragrecptr.p->fragmentid[1]; + signal->theData[5] = RNIL; + signal->theData[6] = RNIL; + sendSignal(lcpConnectptr.p->lcpUserblockref, GSN_LCP_FRAGIDCONF, signal, 7, JBB); + return; +}//Dbacc::sendLcpFragidconfLab() + +/* ******************--------------------------------------------------------------- */ +/* LCP_HOLDOPERATION REQUEST FOR LIST OF STOPED OPERATION */ +/* SENDER: LQH, LEVEL B */ +/* ENTER LCP_HOLDOPREQ WITH */ +/* LCP_CONNECTPTR CONNECTION POINTER */ +/* TFID, LOCAL FRAGMENT ID */ +/* THOLD_PREV_SENT_OP NR OF SENT OPERATIONS AT */ +/* PREVIOUS SIGNALS */ +/* TLQH_POINTER LQH USER POINTER */ +/* ******************--------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* LCP_HOLDOPERATION REQUEST FOR LIST OF STOPED OPERATION */ +/* ******************------------------------------+ */ +/* SENDER: LQH, LEVEL B */ +void Dbacc::execLCP_HOLDOPREQ(Signal* signal) +{ + Uint32 tholdPrevSentOp; + + jamEntry(); + lcpConnectptr.i = signal->theData[0]; /* CONNECTION POINTER */ + tfid = signal->theData[1]; /* LOCAL FRAGMENT ID */ + tholdPrevSentOp = signal->theData[2]; /* NR OF SENT OPERATIONS AT */ + /* PREVIOUS SIGNALS */ + tlqhPointer = signal->theData[3]; /* LQH USER POINTER */ + + tresult = 0; + ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec); + ndbrequire(lcpConnectptr.p->lcpstate == LCP_ACTIVE); + rootfragrecptr.i = lcpConnectptr.p->rootrecptr; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + if (rootfragrecptr.p->fragmentid[0] == tfid) { + jam(); + fragrecptr.i = rootfragrecptr.p->fragmentptr[0]; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + } else { + ndbrequire(rootfragrecptr.p->fragmentid[1] == tfid); + jam(); + fragrecptr.i = rootfragrecptr.p->fragmentptr[1]; + }//if + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + fragrecptr.p->lcpLqhPtr = tlqhPointer; + if (tholdPrevSentOp != 0) { + ndbrequire(fragrecptr.p->fragState == SEND_QUE_OP); + } else if (tholdPrevSentOp == 0) { + jam(); + fragrecptr.p->fragState = SEND_QUE_OP; + fragrecptr.p->stopQueOp = ZTRUE; + fragrecptr.p->sentWaitInQueOp = fragrecptr.p->firstWaitInQueOp; + }//if + tholdSentOp = 0; /* NR OF OPERATION WHICH ARE SENT THIS TIME */ + operationRecPtr.i = fragrecptr.p->sentWaitInQueOp; + + /* --------------------------------------------- */ + /* GO THROUGH ALL OPERATION IN THE WAIT */ + /* LIST AND SEND THE LQH CONNECTION PTR OF THE */ + /* OPERATIONS TO THE LQH BLOCK. MAX 23 0PERATION */ + /* PER SIGNAL */ + /* --------------------------------------------- */ + while (operationRecPtr.i != RNIL) { + jam(); + ptrCheckGuard(operationRecPtr, coprecsize, operationrec); + ckeys[tholdSentOp] = operationRecPtr.p->userptr; + operationRecPtr.i = operationRecPtr.p->nextQueOp; + tholdSentOp++; + if ((tholdSentOp >= 23) && + (operationRecPtr.i != RNIL)) { + jam(); + /* ----------------------------------------------- */ + /* THERE IS MORE THAN 23 WAIT OPERATION. WE */ + /* HAVE TO SEND THESE 23 AND WAITE FOR NEXT SIGNAL */ + /* ----------------------------------------------- */ + tholdMore = ZTRUE; /* SECOUND DATA AT THE CONF SIGNAL , = MORE */ + fragrecptr.p->sentWaitInQueOp = operationRecPtr.i; + sendholdconfsignalLab(signal); + return; + }//if + }//while + /* ----------------------------------------------- */ + /* OPERATION_REC_PTR = RNIL */ + /* THERE IS NO MORE WAITING OPERATION, STATE OF */ + /* THE FRAGMENT RRECORD IS CHANGED AND RETURN */ + /* SIGNAL IS SENT */ + /* ----------------------------------------------- */ + fragrecptr.p->sentWaitInQueOp = RNIL; + tholdMore = ZFALSE; /* SECOND DATA AT THE CONF SIGNAL , = NOT MORE */ + fragrecptr.p->fragState = WAIT_ACC_LCPREQ; + sendholdconfsignalLab(signal); + return; +}//Dbacc::execLCP_HOLDOPREQ() + +void Dbacc::sendholdconfsignalLab(Signal* signal) +{ + tholdMore = (tholdMore << 16) + tholdSentOp; + /* SECOND SIGNAL DATA, LENGTH + MORE */ + /* ************************ */ + /* LCP_HOLDOPCONF */ + /* ************************ */ + signal->theData[0] = fragrecptr.p->lcpLqhPtr; + signal->theData[1] = tholdMore; + signal->theData[2] = ckeys[0]; + signal->theData[3] = ckeys[1]; + signal->theData[4] = ckeys[2]; + signal->theData[5] = ckeys[3]; + signal->theData[6] = ckeys[4]; + signal->theData[7] = ckeys[5]; + signal->theData[8] = ckeys[6]; + signal->theData[9] = ckeys[7]; + signal->theData[10] = ckeys[8]; + signal->theData[11] = ckeys[9]; + signal->theData[12] = ckeys[10]; + signal->theData[13] = ckeys[11]; + signal->theData[14] = ckeys[12]; + signal->theData[15] = ckeys[13]; + signal->theData[16] = ckeys[14]; + signal->theData[17] = ckeys[15]; + signal->theData[18] = ckeys[16]; + signal->theData[19] = ckeys[17]; + signal->theData[20] = ckeys[18]; + signal->theData[21] = ckeys[19]; + signal->theData[22] = ckeys[20]; + signal->theData[23] = ckeys[21]; + signal->theData[24] = ckeys[22]; + sendSignal(lcpConnectptr.p->lcpUserblockref, GSN_LCP_HOLDOPCONF, signal, 25, JBA); + return; +}//Dbacc::sendholdconfsignalLab() + +/** + * execACC_LCPREQ + * Perform local checkpoint of a fragment + * + * SENDER: LQH, LEVEL B + * ENTER ACC_LCPREQ WITH + * LCP_CONNECTPTR, OPERATION RECORD PTR + * TLCP_LQH_CHECK_V, LQH'S LOCAL FRAG CHECK VALUE + * TLCP_LOCAL_FRAG_ID, LOCAL FRAG ID + * + */ +void Dbacc::execACC_LCPREQ(Signal* signal) +{ + Uint32 tlcpLocalFragId; + Uint32 tlcpLqhCheckV; + + jamEntry(); + lcpConnectptr.i = signal->theData[0]; // CONNECTION PTR + tlcpLqhCheckV = signal->theData[1]; // LQH'S LOCAL FRAG CHECK VALUE + tlcpLocalFragId = signal->theData[2]; // LOCAL FRAG ID + tresult = 0; + ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec); + ndbrequire(lcpConnectptr.p->lcpstate == LCP_ACTIVE); + + rootfragrecptr.i = lcpConnectptr.p->rootrecptr; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + if (rootfragrecptr.p->fragmentid[0] == tlcpLocalFragId) { + jam(); + fragrecptr.i = rootfragrecptr.p->fragmentptr[0]; + } else { + ndbrequire(rootfragrecptr.p->fragmentid[1] == tlcpLocalFragId); + jam(); + fragrecptr.i = rootfragrecptr.p->fragmentptr[1]; + }//if + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + ndbrequire(fragrecptr.p->fragState == WAIT_ACC_LCPREQ); + fragrecptr.p->lcpLqhPtr = tlcpLqhCheckV; + + Page8Ptr zeroPagePtr; + seizeLcpPage(zeroPagePtr); + fragrecptr.p->zeroPagePtr = zeroPagePtr.i; + fragrecptr.p->prevUndoposition = cminusOne; + initRootFragPageZero(rootfragrecptr, zeroPagePtr); + initFragPageZero(fragrecptr, zeroPagePtr); + /*-----------------------------------------------------------------*/ + /* SEIZE ZERO PAGE FIRST AND THEN SEIZE DATA PAGES IN */ + /* BACKWARDS ORDER. THIS IS TO ENSURE THAT WE GET THE PAGES */ + /* IN ORDER. ON WINDOWS NT THIS WILL BE A BENEFIT SINCE WE */ + /* CAN THEN DO 1 WRITE_FILE INSTEAD OF 8. */ + /* WHEN WE RELEASE THE PAGES WE RELEASE THEM IN THE OPPOSITE */ + /* ORDER. */ + /*-----------------------------------------------------------------*/ + for (Uint32 taspTmp = ZWRITEPAGESIZE - 1; (Uint32)~taspTmp; taspTmp--) { + Page8Ptr dataPagePtr; + jam(); + ndbrequire(fragrecptr.p->datapages[taspTmp] == RNIL); + seizeLcpPage(dataPagePtr); + fragrecptr.p->datapages[taspTmp] = dataPagePtr.i; + }//for + fragrecptr.p->lcpMaxDirIndex = fragrecptr.p->dirsize; + fragrecptr.p->lcpMaxOverDirIndex = fragrecptr.p->lastOverIndex; + fragrecptr.p->createLcp = ZTRUE; + operationRecPtr.i = fragrecptr.p->lockOwnersList; + while (operationRecPtr.i != RNIL) { + jam(); + ptrCheckGuard(operationRecPtr, coprecsize, operationrec); + + if ((operationRecPtr.p->operation == ZINSERT) || + (operationRecPtr.p->elementIsDisappeared == ZTRUE)){ + /******************************************************************* + * Only log inserts and elements that are marked as dissapeared. + * All other operations update the element header and that is handled + * when pages are written to disk + ********************************************************************/ + undopageptr.i = (cundoposition>>ZUNDOPAGEINDEXBITS) & (cundopagesize-1); + ptrAss(undopageptr, undopage); + theadundoindex = cundoposition & ZUNDOPAGEINDEX_MASK; + tundoindex = theadundoindex + ZUNDOHEADSIZE; + + writeUndoOpInfo(signal);/* THE INFORMATION ABOUT ELEMENT HEADER, STORED*/ + /* IN OP REC, IS WRITTEN AT UNDO PAGES */ + cundoElemIndex = 0;/* DEFAULT VALUE USED BY WRITE_UNDO_HEADER SUBROTINE */ + writeUndoHeader(signal, RNIL, UndoHeader::ZOP_INFO); /* WRITE THE HEAD OF THE UNDO ELEMENT */ + checkUndoPages(signal); /* SEND UNDO PAGE TO DISK WHEN A GROUP OF */ + /* UNDO PAGES,CURRENTLY 8, IS FILLED */ + }//if + + operationRecPtr.i = operationRecPtr.p->nextLockOwnerOp; + }//while + + signal->theData[0] = fragrecptr.p->lcpLqhPtr; + sendSignal(lcpConnectptr.p->lcpUserblockref, GSN_ACC_LCPSTARTED, + signal, 1, JBA); + + fragrecptr.p->activeDataPage = 0; + fragrecptr.p->lcpDirIndex = 0; + fragrecptr.p->fragState = LCP_SEND_PAGES; + + signal->theData[0] = lcpConnectptr.i; + signal->theData[1] = fragrecptr.i; + sendSignal(cownBlockref, GSN_ACC_SAVE_PAGES, signal, 2, JBB); + return; +}//Dbacc::execACC_LCPREQ() + +/* ******************--------------------------------------------------------------- */ +/* ACC_SAVE_PAGES A GROUP OF PAGES IS ALLOCATED. THE PAGES AND OVERFLOW */ +/* PAGES OF THE FRAGMENT ARE COPIED IN THEM AND IS SEND TO */ +/* THE DATA FILE OF THE CHECK POINT. */ +/* SENDER: ACC, LEVEL B */ +/* ENTER ACC_SAVE_PAGES WITH */ +/* LCP_CONNECTPTR, CONNECTION RECORD PTR */ +/* FRAGRECPTR FRAGMENT RECORD PTR */ +/* ******************--------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* ACC_SAVE_PAGES REQUEST TO SEND THE PAGE TO DISK */ +/* ******************------------------------------+ UNDO PAGES */ +/* SENDER: ACC, LEVEL B */ +void Dbacc::execACC_SAVE_PAGES(Signal* signal) +{ + jamEntry(); + lcpConnectptr.i = signal->theData[0]; + /* CONNECTION RECORD PTR */ + fragrecptr.i = signal->theData[1]; + /* FRAGMENT RECORD PTR */ + tresult = 0; + ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec); + if (lcpConnectptr.p->lcpstate != LCP_ACTIVE) { + jam(); + sendSystemerror(signal); + return; + }//if + if (ERROR_INSERTED(3000)) { + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + rootfragrecptr.i = fragrecptr.p->myroot; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + if (rootfragrecptr.p->mytabptr == c_errorInsert3000_TableId){ + ndbout << "Delay writing of datapages" << endl; + // Delay writing of pages + jam(); + sendSignalWithDelay(cownBlockref, GSN_ACC_SAVE_PAGES, signal, 1000, 2); + return; + } + } + if (clblPageCounter == 0) { + jam(); + signal->theData[0] = lcpConnectptr.i; + signal->theData[1] = fragrecptr.i; + sendSignalWithDelay(cownBlockref, GSN_ACC_SAVE_PAGES, signal, 100, 2); + return; + } else { + jam(); + clblPageCounter = clblPageCounter - 1; + }//if + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + if (fragrecptr.p->fragState == LCP_SEND_PAGES) { + jam(); + savepagesLab(signal); + return; + } else { + if (fragrecptr.p->fragState == LCP_SEND_OVER_PAGES) { + jam(); + saveOverPagesLab(signal); + return; + } else { + ndbrequire(fragrecptr.p->fragState == LCP_SEND_ZERO_PAGE); + jam(); + saveZeroPageLab(signal); + return; + }//if + }//if +}//Dbacc::execACC_SAVE_PAGES() + +void Dbacc::savepagesLab(Signal* signal) +{ + DirRangePtr spDirRangePtr; + DirectoryarrayPtr spDirptr; + Page8Ptr aspPageptr; + Page8Ptr aspCopyPageptr; + Uint32 taspDirindex; + Uint32 taspDirIndex; + Uint32 taspIndex; + + if ((fragrecptr.p->lcpDirIndex >= fragrecptr.p->dirsize) || + (fragrecptr.p->lcpDirIndex >= fragrecptr.p->lcpMaxDirIndex)) { + jam(); + endsavepageLab(signal); + return; + }//if + /* SOME EXPAND PROCESSES HAVE BEEN PERFORMED. */ + /* THE ADDED PAGE ARE NOT SENT TO DISK */ + arrGuard(fragrecptr.p->activeDataPage, 8); + aspCopyPageptr.i = fragrecptr.p->datapages[fragrecptr.p->activeDataPage]; + ptrCheckGuard(aspCopyPageptr, cpagesize, page8); + taspDirindex = fragrecptr.p->lcpDirIndex; /* DIRECTORY OF ACTIVE PAGE */ + spDirRangePtr.i = fragrecptr.p->directory; + taspDirIndex = taspDirindex >> 8; + taspIndex = taspDirindex & 0xff; + ptrCheckGuard(spDirRangePtr, cdirrangesize, dirRange); + arrGuard(taspDirIndex, 256); + spDirptr.i = spDirRangePtr.p->dirArray[taspDirIndex]; + ptrCheckGuard(spDirptr, cdirarraysize, directoryarray); + aspPageptr.i = spDirptr.p->pagep[taspIndex]; + ptrCheckGuard(aspPageptr, cpagesize, page8); + ndbrequire(aspPageptr.p->word32[ZPOS_PAGE_ID] == fragrecptr.p->lcpDirIndex); + lcnPageptr = aspPageptr; + lcnCopyPageptr = aspCopyPageptr; + lcpCopyPage(signal); + fragrecptr.p->lcpDirIndex++; + fragrecptr.p->activeDataPage++; + if (fragrecptr.p->activeDataPage < ZWRITEPAGESIZE) { + jam(); + signal->theData[0] = lcpConnectptr.i; + signal->theData[1] = fragrecptr.i; + sendSignal(cownBlockref, GSN_ACC_SAVE_PAGES, signal, 2, JBB); + return; + }//if + senddatapagesLab(signal); + return; +}//Dbacc::savepagesLab() + +/* FRAGRECPTR:ACTIVE_DATA_PAGE = ZWRITEPAGESIZE */ +/* SEND A GROUP OF PAGES TO DISK */ +void Dbacc::senddatapagesLab(Signal* signal) +{ + fsConnectptr.i = fragrecptr.p->fsConnPtr; + ptrCheckGuard(fsConnectptr, cfsConnectsize, fsConnectrec); + seizeFsOpRec(signal); + initFsOpRec(signal); + fsOpptr.p->fsOpstate = WAIT_WRITE_DATA; + ndbrequire(fragrecptr.p->activeDataPage <= 8); + for (Uint32 i = 0; i < fragrecptr.p->activeDataPage; i++) { + signal->theData[i + 6] = fragrecptr.p->datapages[i]; + }//for + signal->theData[fragrecptr.p->activeDataPage + 6] = fragrecptr.p->activeDataFilePage; + signal->theData[0] = fsConnectptr.p->fsPtr; + signal->theData[1] = cownBlockref; + signal->theData[2] = fsOpptr.i; + signal->theData[3] = 0x2; + signal->theData[4] = ZPAGE8_BASE_ADD; + signal->theData[5] = fragrecptr.p->activeDataPage; + sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal, 15, JBA); + return; +}//Dbacc::senddatapagesLab() + +void Dbacc::endsavepageLab(Signal* signal) +{ + Page8Ptr espPageidptr; + + espPageidptr.i = fragrecptr.p->zeroPagePtr; + ptrCheckGuard(espPageidptr, cpagesize, page8); + dbgWord32(espPageidptr, ZPAGEZERO_NO_PAGES, fragrecptr.p->lcpDirIndex); + espPageidptr.p->word32[ZPAGEZERO_NO_PAGES] = fragrecptr.p->lcpDirIndex; + fragrecptr.p->fragState = LCP_SEND_OVER_PAGES; + fragrecptr.p->noOfStoredOverPages = 0; + fragrecptr.p->lcpDirIndex = 0; + saveOverPagesLab(signal); + return; +}//Dbacc::endsavepageLab() + +/* ******************--------------------------------------------------------------- */ +/* ACC_SAVE_OVER_PAGES CONTINUE SAVING THE LEFT OVERPAGES. */ +/* ******************--------------------------------------------------------------- */ +void Dbacc::saveOverPagesLab(Signal* signal) +{ + DirRangePtr sopDirRangePtr; + DirectoryarrayPtr sopOverflowDirptr; + Page8Ptr sopPageptr; + Page8Ptr sopCopyPageptr; + Uint32 tsopDirindex; + Uint32 tsopDirInd; + Uint32 tsopIndex; + + if ((fragrecptr.p->lcpDirIndex >= fragrecptr.p->lastOverIndex) || + (fragrecptr.p->lcpDirIndex >= fragrecptr.p->lcpMaxOverDirIndex)) { + jam(); + endsaveoverpageLab(signal); + return; + }//if + arrGuard(fragrecptr.p->activeDataPage, 8); + sopCopyPageptr.i = fragrecptr.p->datapages[fragrecptr.p->activeDataPage]; + ptrCheckGuard(sopCopyPageptr, cpagesize, page8); + tsopDirindex = fragrecptr.p->lcpDirIndex; + sopDirRangePtr.i = fragrecptr.p->overflowdir; + tsopDirInd = tsopDirindex >> 8; + tsopIndex = tsopDirindex & 0xff; + ptrCheckGuard(sopDirRangePtr, cdirrangesize, dirRange); + arrGuard(tsopDirInd, 256); + sopOverflowDirptr.i = sopDirRangePtr.p->dirArray[tsopDirInd]; + ptrCheckGuard(sopOverflowDirptr, cdirarraysize, directoryarray); + sopPageptr.i = sopOverflowDirptr.p->pagep[tsopIndex]; + fragrecptr.p->lcpDirIndex++; + if (sopPageptr.i != RNIL) { + jam(); + ptrCheckGuard(sopPageptr, cpagesize, page8); + ndbrequire(sopPageptr.p->word32[ZPOS_PAGE_ID] == tsopDirindex); + ndbrequire(((sopPageptr.p->word32[ZPOS_PAGE_TYPE] >> ZPOS_PAGE_TYPE_BIT) & 3) != ZNORMAL_PAGE_TYPE); + lcnPageptr = sopPageptr; + lcnCopyPageptr = sopCopyPageptr; + lcpCopyPage(signal); + fragrecptr.p->noOfStoredOverPages++; + fragrecptr.p->activeDataPage++; + if ((sopPageptr.p->word32[ZPOS_ALLOC_CONTAINERS] == 0)) { + //ndbrequire(((sopPageptr.p->word32[ZPOS_PAGE_TYPE] >> ZPOS_PAGE_TYPE_BIT) & 3) == ZOVERFLOW_PAGE_TYPE); + if (((sopPageptr.p->word32[ZPOS_PAGE_TYPE] >> ZPOS_PAGE_TYPE_BIT) & 3) == + ZOVERFLOW_PAGE_TYPE) { + /*--------------------------------------------------------------------------------*/ + /* THE PAGE IS EMPTY AND WAITING TO BE RELEASED. IT COULD NOT BE RELEASED */ + /* EARLIER SINCE IT WAS PART OF A LOCAL CHECKPOINT. */ + /*--------------------------------------------------------------------------------*/ + jam(); + ropPageptr = sopPageptr; + releaseOverpage(signal); + } else if (((sopPageptr.p->word32[ZPOS_PAGE_TYPE] >> ZPOS_PAGE_TYPE_BIT) & 3) == + ZLONG_PAGE_TYPE) { + //---------------------------------------------------------------------- + // The long key page is empty, release it. + //---------------------------------------------------------------------- + jam(); + rlopPageptr = sopPageptr; + releaseLongPage(signal); + } else { + jam(); + sendSystemerror(signal); + } + }//if + } + if (fragrecptr.p->activeDataPage == ZWRITEPAGESIZE) { + jam(); + senddatapagesLab(signal); + return; + }//if + signal->theData[0] = lcpConnectptr.i; + signal->theData[1] = fragrecptr.i; + sendSignal(cownBlockref, GSN_ACC_SAVE_PAGES, signal, 2, JBB); + return; +}//Dbacc::saveOverPagesLab() + +void Dbacc::endsaveoverpageLab(Signal* signal) +{ + Page8Ptr esoPageidptr; + + esoPageidptr.i = fragrecptr.p->zeroPagePtr; + ptrCheckGuard(esoPageidptr, cpagesize, page8); + dbgWord32(esoPageidptr, ZPAGEZERO_NO_OVER_PAGE, fragrecptr.p->noOfStoredOverPages); + esoPageidptr.p->word32[ZPAGEZERO_NO_OVER_PAGE] = fragrecptr.p->noOfStoredOverPages; + fragrecptr.p->fragState = LCP_SEND_ZERO_PAGE; + if (fragrecptr.p->activeDataPage != 0) { + jam(); + senddatapagesLab(signal); /* SEND LEFT PAGES TO DISK */ + return; + }//if + saveZeroPageLab(signal); + return; +}//Dbacc::endsaveoverpageLab() + +/* ******************--------------------------------------------------------------- */ +/* ACC_SAVE_ZERO_PAGE PAGE ZERO IS SENT TO DISK.IT IS THE LAST STAGE AT THE */ +/* CREATION LCP. ACC_LCPCONF IS RETURND. */ +/* ******************--------------------------------------------------------------- */ +void Dbacc::saveZeroPageLab(Signal* signal) +{ + Page8Ptr szpPageidptr; + Uint32 Tchs; + Uint32 Ti; + + fragrecptr.p->createLcp = ZFALSE; + fsConnectptr.i = fragrecptr.p->fsConnPtr; + ptrCheckGuard(fsConnectptr, cfsConnectsize, fsConnectrec); + szpPageidptr.i = fragrecptr.p->zeroPagePtr; + ptrCheckGuard(szpPageidptr, cpagesize, page8); + dbgWord32(szpPageidptr, ZPAGEZERO_PREV_UNDOP, fragrecptr.p->prevUndoposition); + szpPageidptr.p->word32[ZPAGEZERO_PREV_UNDOP] = fragrecptr.p->prevUndoposition; + dbgWord32(szpPageidptr, ZPAGEZERO_NEXT_UNDO_FILE, cactiveUndoFileVersion); + szpPageidptr.p->word32[ZPAGEZERO_NEXT_UNDO_FILE] = cactiveUndoFileVersion; + fragrecptr.p->fragState = WAIT_ZERO_PAGE_STORED; + + /* --------------------------------------------------------------------------------- */ + // Calculate the checksum and store it for the zero page of the fragment. + /* --------------------------------------------------------------------------------- */ + szpPageidptr.p->word32[ZPOS_CHECKSUM] = 0; + Tchs = 0; + for (Ti = 0; Ti < 2048; Ti++) { + Tchs = Tchs ^ szpPageidptr.p->word32[Ti]; + }//for + szpPageidptr.p->word32[ZPOS_CHECKSUM] = Tchs; + dbgWord32(szpPageidptr, ZPOS_CHECKSUM, Tchs); + + seizeFsOpRec(signal); + initFsOpRec(signal); + fsOpptr.p->fsOpstate = WAIT_WRITE_DATA; + if (clblPageCounter > 0) { + jam(); + clblPageCounter = clblPageCounter - 1; + } else { + jam(); + clblPageOver = clblPageOver + 1; + }//if + /* ************************ */ + /* FSWRITEREQ */ + /* ************************ */ + signal->theData[0] = fsConnectptr.p->fsPtr; + signal->theData[1] = cownBlockref; + signal->theData[2] = fsOpptr.i; + signal->theData[3] = 0x10; + /* FLAG = LIST MEM PAGES, LIST FILE PAGES */ + /* SYNC FILE AFTER WRITING */ + signal->theData[4] = ZPAGE8_BASE_ADD; + signal->theData[5] = 1; + /* NO OF PAGES */ + signal->theData[6] = fragrecptr.p->zeroPagePtr; + /* ZERO PAGE */ + signal->theData[7] = 0; + sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal, 8, JBA); + /* ZERO PAGE AT DATA FILE */ + return; +}//Dbacc::saveZeroPageLab() + +/* ******************--------------------------------------------------------------- */ +/* FSWRITECONF OPENFILE CONF */ +/* ENTER FSWRITECONF WITH SENDER: FS, LEVEL B */ +/* FS_OPPTR FS_CONNECTION PTR */ +/* ******************--------------------------------------------------------------- */ +void Dbacc::lcpCloseDataFileLab(Signal* signal) +{ + rootfragrecptr.i = fragrecptr.p->myroot; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + lcpConnectptr.i = rootfragrecptr.p->lcpPtr; + ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec); + fsConnectptr.p->fsState = LCP_CLOSE_DATA; + /* ************************ */ + /* FSCLOSEREQ */ + /* ************************ */ + /* CLOSE DATA FILE */ + signal->theData[0] = fsConnectptr.p->fsPtr; + signal->theData[1] = cownBlockref; + signal->theData[2] = fsConnectptr.i; + signal->theData[3] = ZFALSE; + sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA); + /* FLAG = 0, DO NOT DELETE FILE */ + return; +}//Dbacc::lcpCloseDataFileLab() + +void Dbacc::checkSyncUndoPagesLab(Signal* signal) +{ + fragrecptr.i = fsConnectptr.p->fragrecPtr; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + releaseFsConnRec(signal); + rootfragrecptr.i = fragrecptr.p->myroot; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + lcpConnectptr.i = rootfragrecptr.p->lcpPtr; + ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec); + switch (lcpConnectptr.p->syncUndopageState) { + case WAIT_NOTHING: + jam(); + lcpConnectptr.p->syncUndopageState = WAIT_ONE_CONF; + break; + case WAIT_ONE_CONF: + jam(); + lcpConnectptr.p->syncUndopageState = WAIT_TWO_CONF; + break; + default: + jam(); + sendSystemerror(signal); + return; + break; + }//switch + + /* ACTIVE UNDO PAGE ID */ + Uint32 tundoPageId = cundoposition >> ZUNDOPAGEINDEXBITS; + tmp1 = tundoPageId - (tundoPageId & (ZWRITE_UNDOPAGESIZE - 1)); + /* START PAGE OF THE LAST UNDO PAGES GROUP */ + tmp2 = (tundoPageId - tmp1) + 1; /* NO OF LEFT UNDO PAGES */ + tmp1 = tmp1 & (cundopagesize - 1); /* 1 MBYTE PAGE WINDOW IN MEMORY */ + fsConnectptr.i = cactiveOpenUndoFsPtr; + ptrCheckGuard(fsConnectptr, cfsConnectsize, fsConnectrec); + seizeFsOpRec(signal); + initFsOpRec(signal); + fsOpptr.p->fsOpstate = WAIT_WRITE_UNDO; + fsOpptr.p->fsOpMemPage = tundoPageId; /* RECORD MEMORY PAGE WRITTEN */ + if (clblPageCounter >= (4 * tmp2)) { + jam(); + clblPageCounter = clblPageCounter - (4 * tmp2); + } else { + jam(); + clblPageOver = clblPageOver + ((4 * tmp2) - clblPageCounter); + clblPageCounter = 0; + }//if + /* ************************ */ + /* FSWRITEREQ */ + /* ************************ */ + signal->theData[0] = fsConnectptr.p->fsPtr; + signal->theData[1] = cownBlockref; + signal->theData[2] = fsOpptr.i; + /* FLAG = START MEM PAGES, START FILE PAGES */ + /* SYNC FILE AFTER WRITING */ + signal->theData[3] = 0x11; + signal->theData[4] = ZUNDOPAGE_BASE_ADD; + /* NO OF UNDO PAGES */ + signal->theData[5] = tmp2; + /* FIRST MEMORY PAGE */ + signal->theData[6] = tmp1; + /* ACTIVE PAGE AT UNDO FILE */ + signal->theData[7] = cactiveUndoFilePage; + sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal, 8, JBA); + + return; +}//Dbacc::checkSyncUndoPagesLab() + +void Dbacc::checkSendLcpConfLab(Signal* signal) +{ + rootfragrecptr.i = fragrecptr.p->myroot; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + lcpConnectptr.i = rootfragrecptr.p->lcpPtr; + ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec); + ndbrequire(lcpConnectptr.p->lcpstate == LCP_ACTIVE); + switch (lcpConnectptr.p->syncUndopageState) { + case WAIT_ONE_CONF: + jam(); + lcpConnectptr.p->syncUndopageState = WAIT_NOTHING; + break; + case WAIT_TWO_CONF: + jam(); + lcpConnectptr.p->syncUndopageState = WAIT_ONE_CONF; + break; + default: + ndbrequire(false); + break; + }//switch + lcpConnectptr.p->noOfLcpConf++; + ndbrequire(lcpConnectptr.p->noOfLcpConf <= 2); + fragrecptr.p->fragState = ACTIVEFRAG; + rlpPageptr.i = fragrecptr.p->zeroPagePtr; + ptrCheckGuard(rlpPageptr, cpagesize, page8); + releaseLcpPage(signal); + fragrecptr.p->zeroPagePtr = RNIL; + for (Uint32 i = 0; i < ZWRITEPAGESIZE; i++) { + jam(); + if (fragrecptr.p->datapages[i] != RNIL) { + jam(); + rlpPageptr.i = fragrecptr.p->datapages[i]; + ptrCheckGuard(rlpPageptr, cpagesize, page8); + releaseLcpPage(signal); + fragrecptr.p->datapages[i] = RNIL; + }//if + }//for + signal->theData[0] = fragrecptr.p->lcpLqhPtr; + sendSignal(lcpConnectptr.p->lcpUserblockref, GSN_ACC_LCPCONF, signal, 1, JBB); + if (lcpConnectptr.p->noOfLcpConf == 2) { + jam(); + releaseLcpConnectRec(signal); + rootfragrecptr.i = fragrecptr.p->myroot; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + rootfragrecptr.p->rootState = ACTIVEROOT; + }//if +}//Dbacc::checkSendLcpConfLab() + +/* ******************--------------------------------------------------------------- */ +/* ACC_CONTOPREQ */ +/* SENDER: LQH, LEVEL B */ +/* ENTER ACC_CONTOPREQ WITH */ +/* LCP_CONNECTPTR */ +/* TMP1 LOCAL FRAG ID */ +/* ******************--------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* ACC_CONTOPREQ COMMIT TRANSACTION */ +/* ******************------------------------------+ */ +/* SENDER: LQH, LEVEL B */ +void Dbacc::execACC_CONTOPREQ(Signal* signal) +{ + Uint32 tcorLocalFrag; + + jamEntry(); + lcpConnectptr.i = signal->theData[0]; + /* CONNECTION PTR */ + tcorLocalFrag = signal->theData[1]; + /* LOCAL FRAG ID */ + tresult = 0; + ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec); + ndbrequire(lcpConnectptr.p->lcpstate == LCP_ACTIVE); + rootfragrecptr.i = lcpConnectptr.p->rootrecptr; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + if (rootfragrecptr.p->fragmentid[0] == tcorLocalFrag) { + jam(); + fragrecptr.i = rootfragrecptr.p->fragmentptr[0]; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + } else { + ndbrequire(rootfragrecptr.p->fragmentid[1] == tcorLocalFrag); + jam(); + fragrecptr.i = rootfragrecptr.p->fragmentptr[1]; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + }//if + operationRecPtr.i = fragrecptr.p->firstWaitInQueOp; + fragrecptr.p->sentWaitInQueOp = RNIL; + fragrecptr.p->stopQueOp = ZFALSE; + while (operationRecPtr.i != RNIL) { + jam(); + ptrCheckGuard(operationRecPtr, coprecsize, operationrec); + if (operationRecPtr.p->opState == WAIT_EXE_OP) { + jam(); + //------------------------------------------------------------ + // Indicate that we are now a normal waiter in the queue. We + // will remove the operation from the queue as part of starting + // operation again. + //------------------------------------------------------------ + operationRecPtr.p->opState = WAIT_IN_QUEUE; + executeNextOperation(signal); + }//if + operationRecPtr.i = operationRecPtr.p->nextQueOp; + }//while + signal->theData[0] = fragrecptr.p->lcpLqhPtr; + sendSignal(lcpConnectptr.p->lcpUserblockref, GSN_ACC_CONTOPCONF, signal, 1, JBA); + return; /* ALL QUEUED OPERATION ARE RESTARTED IF NEEDED. */ +}//Dbacc::execACC_CONTOPREQ() + +/* ******************--------------------------------------------------------------- */ +/* END_LCPREQ END OF LOCAL CHECK POINT */ +/* ENTER END_LCPREQ WITH SENDER: LQH, LEVEL B */ +/* CLQH_PTR, LQH PTR */ +/* CLQH_BLOCK_REF LQH BLOCK REF */ +/* ******************--------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* END_LCPREQ PERFORM A LOCAL CHECK POINT */ +/* ******************------------------------------+ */ +/* SENDER: LQH, LEVEL B */ +void Dbacc::execEND_LCPREQ(Signal* signal) +{ + jamEntry(); + clqhPtr = signal->theData[0]; + /* LQH PTR */ + clqhBlockRef = signal->theData[1]; + /* LQH BLOCK REF */ + tresult = 0; + fsConnectptr.i = cactiveOpenUndoFsPtr; + ptrCheckGuard(fsConnectptr, cfsConnectsize, fsConnectrec); + fsConnectptr.p->fsState = WAIT_CLOSE_UNDO; /* CLOSE FILE AFTER WRITTING */ + /* ************************ */ + /* FSCLOSEREQ */ + /* ************************ */ + signal->theData[0] = fsConnectptr.p->fsPtr; + signal->theData[1] = cownBlockref; + signal->theData[2] = fsConnectptr.i; + signal->theData[3] = ZFALSE; + sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA); + /* FLAG = 0, DO NOT DELETE FILE */ + cactiveUndoFileVersion = RNIL; + cactiveOpenUndoFsPtr = RNIL; + /* ************************ */ + /* END_LCPCONF */ + /* ************************ */ + signal->theData[0] = clqhPtr; + sendSignal(clqhBlockRef, GSN_END_LCPCONF, signal, 1, JBB); + return; +}//Dbacc::execEND_LCPREQ() + +/*-----------------------------------------------------------------*/ +/* WHEN WE COPY THE PAGE WE ALSO WRITE THE ELEMENT HEADER AS */ +/* UNLOCKED IF THEY ARE CURRENTLY LOCKED. */ +/*-----------------------------------------------------------------*/ +void Dbacc::lcpCopyPage(Signal* signal) +{ + Uint32 tlcnNextContainer; + Uint32 tlcnTmp; + Uint32 tlcnConIndex; + Uint32 tlcnIndex; + Uint32 Tmp1; + Uint32 Tmp2; + Uint32 Tmp3; + Uint32 Tmp4; + Uint32 Ti; + Uint32 Tchs; + Uint32 Tlimit; + + Tchs = 0; + lupPageptr.p = lcnCopyPageptr.p; + lcnPageptr.p->word32[ZPOS_CHECKSUM] = Tchs; + for (Ti = 0; Ti < 32 ; Ti++) { + Tlimit = 16 + (Ti << 6); + for (tlcnTmp = (Ti << 6); tlcnTmp < Tlimit; tlcnTmp ++) { + Tmp1 = lcnPageptr.p->word32[tlcnTmp]; + Tmp2 = lcnPageptr.p->word32[tlcnTmp + 16]; + Tmp3 = lcnPageptr.p->word32[tlcnTmp + 32]; + Tmp4 = lcnPageptr.p->word32[tlcnTmp + 48]; + + lcnCopyPageptr.p->word32[tlcnTmp] = Tmp1; + lcnCopyPageptr.p->word32[tlcnTmp + 16] = Tmp2; + lcnCopyPageptr.p->word32[tlcnTmp + 32] = Tmp3; + lcnCopyPageptr.p->word32[tlcnTmp + 48] = Tmp4; + + Tchs = Tchs ^ Tmp1; + Tchs = Tchs ^ Tmp2; + Tchs = Tchs ^ Tmp3; + Tchs = Tchs ^ Tmp4; + }//for + }//for + tlcnChecksum = Tchs; + if (((lcnCopyPageptr.p->word32[ZPOS_PAGE_TYPE] >> ZPOS_PAGE_TYPE_BIT) & 3) != ZLONG_PAGE_TYPE) { + jam(); + if (((lcnCopyPageptr.p->word32[ZPOS_PAGE_TYPE] >> ZPOS_PAGE_TYPE_BIT) & 3) == ZNORMAL_PAGE_TYPE) { + jam(); + /*-----------------------------------------------------------------*/ + /* TAKE CARE OF ALL 64 BUFFERS ADDRESSED BY ALGORITHM IN */ + /* FIRST PAGE. IF THEY ARE EMPTY THEY STILL HAVE A CONTAINER */ + /* HEADER OF 2 WORDS. */ + /*-----------------------------------------------------------------*/ + tlcnConIndex = ZHEAD_SIZE; + tlupForward = 1; + for (tlcnIndex = 0; tlcnIndex <= ZNO_CONTAINERS - 1; tlcnIndex++) { + tlupIndex = tlcnConIndex; + tlupElemIndex = tlcnConIndex + ZCON_HEAD_SIZE; + lcpUpdatePage(signal); + tlcnConIndex = tlcnConIndex + ZBUF_SIZE; + }//for + }//if + /*-----------------------------------------------------------------*/ + /* TAKE CARE OF ALL USED BUFFERS ON THE LEFT SIDE. */ + /*-----------------------------------------------------------------*/ + tlcnNextContainer = (lcnCopyPageptr.p->word32[ZPOS_EMPTY_LIST] >> 23) & 0x7f; + while (tlcnNextContainer < ZEMPTYLIST) { + tlcnConIndex = (tlcnNextContainer << ZSHIFT_PLUS) - (tlcnNextContainer << ZSHIFT_MINUS); + tlcnConIndex = tlcnConIndex + ZHEAD_SIZE; + tlupIndex = tlcnConIndex; + tlupElemIndex = tlcnConIndex + ZCON_HEAD_SIZE; + tlupForward = 1; + lcpUpdatePage(signal); + tlcnNextContainer = (lcnCopyPageptr.p->word32[tlcnConIndex] >> 11) & 0x7f; + }//while + if (tlcnNextContainer == ZEMPTYLIST) { + jam(); + /*empty*/; + } else { + jam(); + sendSystemerror(signal); + return; + }//if + /*-----------------------------------------------------------------*/ + /* TAKE CARE OF ALL USED BUFFERS ON THE RIGHT SIDE. */ + /*-----------------------------------------------------------------*/ + tlupForward = cminusOne; + tlcnNextContainer = (lcnCopyPageptr.p->word32[ZPOS_EMPTY_LIST] >> 16) & 0x7f; + while (tlcnNextContainer < ZEMPTYLIST) { + tlcnConIndex = (tlcnNextContainer << ZSHIFT_PLUS) - (tlcnNextContainer << ZSHIFT_MINUS); + tlcnConIndex = tlcnConIndex + ((ZHEAD_SIZE + ZBUF_SIZE) - ZCON_HEAD_SIZE); + tlupIndex = tlcnConIndex; + tlupElemIndex = tlcnConIndex - 1; + lcpUpdatePage(signal); + tlcnNextContainer = (lcnCopyPageptr.p->word32[tlcnConIndex] >> 11) & 0x7f; + }//while + if (tlcnNextContainer == ZEMPTYLIST) { + jam(); + /*empty*/; + } else { + jam(); + sendSystemerror(signal); + return; + }//if + }//if + lcnCopyPageptr.p->word32[ZPOS_CHECKSUM] = tlcnChecksum; +}//Dbacc::lcpCopyPage() + +/* --------------------------------------------------------------------------------- */ +/* THIS SUBROUTINE GOES THROUGH ONE CONTAINER TO CHECK FOR LOCKED ELEMENTS AND */ +/* UPDATING THEM TO ENSURE ALL ELEMENTS ARE UNLOCKED ON DISK. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::lcpUpdatePage(Signal* signal) +{ + OperationrecPtr lupOperationRecPtr; + Uint32 tlupElemHead; + Uint32 tlupElemLen; + Uint32 tlupElemStep; + Uint32 tlupConLen; + + tlupConLen = lupPageptr.p->word32[tlupIndex] >> 26; + tlupElemLen = fragrecptr.p->elementLength; + tlupElemStep = tlupForward * tlupElemLen; + while (tlupConLen > ZCON_HEAD_SIZE) { + jam(); + tlupElemHead = lupPageptr.p->word32[tlupElemIndex]; + if (ElementHeader::getLocked(tlupElemHead)) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* WHEN CHANGING THE ELEMENT HEADER WE ALSO HAVE TO UPDATE THE CHECKSUM. IN */ + /* DOING THIS WE USE THE FORMULA (A XOR B) XOR B = A WHICH MEANS THAT IF WE */ + /* XOR SOMETHING TWICE WITH THE SAME OPERAND THEN WE RETURN TO THE ORIGINAL */ + /* VALUE. THEN WE ALSO HAVE TO USE THE NEW ELEMENT HEADER IN THE CHECKSUM */ + /* CALCULATION. */ + /* --------------------------------------------------------------------------------- */ + tlcnChecksum = tlcnChecksum ^ tlupElemHead; + lupOperationRecPtr.i = ElementHeader::getOpPtrI(tlupElemHead); + ptrCheckGuard(lupOperationRecPtr, coprecsize, operationrec); + const Uint32 hv = lupOperationRecPtr.p->hashvaluePart; + tlupElemHead = ElementHeader::setUnlocked(hv , 0); + arrGuard(tlupElemIndex, 2048); + lupPageptr.p->word32[tlupElemIndex] = tlupElemHead; + tlcnChecksum = tlcnChecksum ^ tlupElemHead; + }//if + tlupConLen = tlupConLen - tlupElemLen; + tlupElemIndex = tlupElemIndex + tlupElemStep; + }//while + if (tlupConLen < ZCON_HEAD_SIZE) { + jam(); + sendSystemerror(signal); + }//if +}//Dbacc::lcpUpdatePage() + +/*-----------------------------------------------------------------*/ +// At a system restart we check that the page do not contain any +// locks that hinder the system restart procedure. +/*-----------------------------------------------------------------*/ +void Dbacc::srCheckPage(Signal* signal) +{ + Uint32 tlcnNextContainer; + Uint32 tlcnConIndex; + Uint32 tlcnIndex; + + lupPageptr.p = lcnCopyPageptr.p; + if (((lcnCopyPageptr.p->word32[ZPOS_PAGE_TYPE] >> ZPOS_PAGE_TYPE_BIT) & 3) != ZLONG_PAGE_TYPE) { + jam(); + if (((lcnCopyPageptr.p->word32[ZPOS_PAGE_TYPE] >> ZPOS_PAGE_TYPE_BIT) & 3) == ZNORMAL_PAGE_TYPE) { + jam(); + /*-----------------------------------------------------------------*/ + /* TAKE CARE OF ALL 64 BUFFERS ADDRESSED BY ALGORITHM IN */ + /* FIRST PAGE. IF THEY ARE EMPTY THEY STILL HAVE A CONTAINER */ + /* HEADER OF 2 WORDS. */ + /*-----------------------------------------------------------------*/ + tlcnConIndex = ZHEAD_SIZE; + tlupForward = 1; + for (tlcnIndex = 0; tlcnIndex <= ZNO_CONTAINERS - 1; tlcnIndex++) { + tlupIndex = tlcnConIndex; + tlupElemIndex = tlcnConIndex + ZCON_HEAD_SIZE; + srCheckContainer(signal); + if (tresult != 0) { + jam(); + return; + }//if + tlcnConIndex = tlcnConIndex + ZBUF_SIZE; + }//for + }//if + /*-----------------------------------------------------------------*/ + /* TAKE CARE OF ALL USED BUFFERS ON THE LEFT SIDE. */ + /*-----------------------------------------------------------------*/ + tlcnNextContainer = (lcnCopyPageptr.p->word32[ZPOS_EMPTY_LIST] >> 23) & 0x7f; + while (tlcnNextContainer < ZEMPTYLIST) { + tlcnConIndex = (tlcnNextContainer << ZSHIFT_PLUS) - (tlcnNextContainer << ZSHIFT_MINUS); + tlcnConIndex = tlcnConIndex + ZHEAD_SIZE; + tlupIndex = tlcnConIndex; + tlupElemIndex = tlcnConIndex + ZCON_HEAD_SIZE; + tlupForward = 1; + srCheckContainer(signal); + if (tresult != 0) { + jam(); + return; + }//if + tlcnNextContainer = (lcnCopyPageptr.p->word32[tlcnConIndex] >> 11) & 0x7f; + }//while + if (tlcnNextContainer == ZEMPTYLIST) { + jam(); + /*empty*/; + } else { + jam(); + tresult = 4; + return; + }//if + /*-----------------------------------------------------------------*/ + /* TAKE CARE OF ALL USED BUFFERS ON THE RIGHT SIDE. */ + /*-----------------------------------------------------------------*/ + tlupForward = cminusOne; + tlcnNextContainer = (lcnCopyPageptr.p->word32[ZPOS_EMPTY_LIST] >> 16) & 0x7f; + while (tlcnNextContainer < ZEMPTYLIST) { + tlcnConIndex = (tlcnNextContainer << ZSHIFT_PLUS) - (tlcnNextContainer << ZSHIFT_MINUS); + tlcnConIndex = tlcnConIndex + ((ZHEAD_SIZE + ZBUF_SIZE) - ZCON_HEAD_SIZE); + tlupIndex = tlcnConIndex; + tlupElemIndex = tlcnConIndex - 1; + srCheckContainer(signal); + if (tresult != 0) { + jam(); + return; + }//if + tlcnNextContainer = (lcnCopyPageptr.p->word32[tlcnConIndex] >> 11) & 0x7f; + }//while + if (tlcnNextContainer == ZEMPTYLIST) { + jam(); + /*empty*/; + } else { + jam(); + tresult = 4; + return; + }//if + }//if +}//Dbacc::srCheckPage() + +/* --------------------------------------------------------------------------------- */ +/* THIS SUBROUTINE GOES THROUGH ONE CONTAINER TO CHECK FOR LOCKED ELEMENTS AND */ +/* UPDATING THEM TO ENSURE ALL ELEMENTS ARE UNLOCKED ON DISK. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::srCheckContainer(Signal* signal) +{ + Uint32 tlupElemLen; + Uint32 tlupElemStep; + Uint32 tlupConLen; + + tlupConLen = lupPageptr.p->word32[tlupIndex] >> 26; + tlupElemLen = fragrecptr.p->elementLength; + tlupElemStep = tlupForward * tlupElemLen; + while (tlupConLen > ZCON_HEAD_SIZE) { + jam(); + const Uint32 tlupElemHead = lupPageptr.p->word32[tlupElemIndex]; + if (ElementHeader::getLocked(tlupElemHead)){ + jam(); + //------------------------------------------------------- + // This is absolutely undesirable. We have a lock remaining + // after the system restart. We send a crash signal that will + // enter the trace file. + //------------------------------------------------------- + tresult = 2; + return; + }//if + tlupConLen = tlupConLen - tlupElemLen; + tlupElemIndex = tlupElemIndex + tlupElemStep; + }//while + if (tlupConLen < ZCON_HEAD_SIZE) { + jam(); + tresult = 3; + }//if + return; +}//Dbacc::srCheckContainer() + +/* ------------------------------------------------------------------------- */ +/* CHECK_UNDO_PAGES */ +/* DESCRIPTION: CHECKS WHEN A PAGE OR A GROUP OF UNDO PAGES IS FILLED.WHEN */ +/* A PAGE IS FILLED, CUNDOPOSITION WILL BE UPDATE, THE NEW */ +/* POSITION IS THE BEGNING OF THE NEXT UNDO PAGE. */ +/* IN CASE THAT A GROUP IS FILLED THE PAGES ARE SENT TO DISK, */ +/* AND A NEW GROUP IS CHOSEN. */ +/* ------------------------------------------------------------------------- */ +void Dbacc::checkUndoPages(Signal* signal) +{ + + fragrecptr.p->prevUndoposition = cundoposition; + cprevUndoaddress = cundoposition; + + // Calculate active undo page id + Uint32 tundoPageId = cundoposition >> ZUNDOPAGEINDEXBITS; + + /** + * WE WILL WRITE UNTIL WE HAVE ABOUT 8 KBYTE REMAINING ON THE 32 KBYTE + * PAGE. THIS IS TO ENSURE THAT WE DO NOT HAVE ANY UNDO LOG RECORDS THAT PASS + * A PAGE BOUNDARIE. THIS SIMPLIFIES CODING TRADING SOME INEFFICIENCY. + */ + static const Uint32 ZMAXUNDOPAGEINDEX = 7100; + if (tundoindex < ZMAXUNDOPAGEINDEX) { + jam(); + cundoposition = (tundoPageId << ZUNDOPAGEINDEXBITS) + tundoindex; + return; + }//if + + /** + * WE CHECK IF MORE THAN 1 MBYTE OF WRITES ARE OUTSTANDING TO THE UNDO FILE. + * IF SO WE HAVE TO CRASH SINCE WE HAVE NO MORE SPACE TO WRITE UNDO LOG + * RECORDS IN + */ + Uint16 nextUndoPageId = tundoPageId + 1; + if (nextUndoPageId > (clastUndoPageIdWritten + cundopagesize)){ + // No more undolog, crash node + progError(__LINE__, + ERR_NO_MORE_UNDOLOG, + "There are more than 1Mbyte undolog writes outstanding"); + } + updateUndoPositionPage(signal, nextUndoPageId << ZUNDOPAGEINDEXBITS); + + if ((tundoPageId & (ZWRITE_UNDOPAGESIZE - 1)) == (ZWRITE_UNDOPAGESIZE - 1)) { + jam(); + /* ---------- SEND A GROUP OF UNDO PAGES TO DISK --------- */ + fsConnectptr.i = cactiveOpenUndoFsPtr; + ptrCheckGuard(fsConnectptr, cfsConnectsize, fsConnectrec); + Uint32 tcupTmp1 = (tundoPageId - ZWRITE_UNDOPAGESIZE) + 1; + tcupTmp1 = tcupTmp1 & (cundopagesize - 1); /* 1 MBYTE PAGE WINDOW */ + seizeFsOpRec(signal); + initFsOpRec(signal); + fsOpptr.p->fsOpstate = WAIT_WRITE_UNDO_EXIT; + fsOpptr.p->fsOpMemPage = tundoPageId; + fragrecptr.p->nrWaitWriteUndoExit++; + if (clblPageCounter >= 8) { + jam(); + clblPageCounter = clblPageCounter - 8; + } else { + jam(); + clblPageOver = clblPageOver + (8 - clblPageCounter); + clblPageCounter = 0; + }//if + /* ************************ */ + /* FSWRITEREQ */ + /* ************************ */ + signal->theData[0] = fsConnectptr.p->fsPtr; + signal->theData[1] = cownBlockref; + signal->theData[2] = fsOpptr.i; + signal->theData[3] = 0x1; + /* FLAG = START MEM PAGES, START FILE PAGES */ + signal->theData[4] = ZUNDOPAGE_BASE_ADD; + signal->theData[5] = ZWRITE_UNDOPAGESIZE; + signal->theData[6] = tcupTmp1; + signal->theData[7] = cactiveUndoFilePage; + sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal, 8, JBA); + cactiveUndoFilePage = cactiveUndoFilePage + ZWRITE_UNDOPAGESIZE; + }//if +}//Dbacc::checkUndoPages() + +/* --------------------------------------------------------------------------------- */ +/* UNDO_WRITING_PROCESS */ +/* INPUT: FRAGRECPTR, CUNDO_ELEM_INDEX, DATAPAGEPTR, CUNDOINFOLENGTH */ +/* DESCRIPTION: WHEN THE PROCESS OF CREATION LOCAL CHECK POINT HAS */ +/* STARTED. IF THE ACTIVE PAGE IS NOT ALREADY SENT TO DISK, THE */ +/* OLD VALUE OF THE ITEM WHICH IS GOING TO BE CHECKED IS STORED ON */ +/* THE ACTIVE UNDO PAGE. INFORMATION ABOUT UNDO PROCESS IN THE */ +/* BLOCK AND IN THE FRAGMENT WILL BE UPDATED. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::undoWritingProcess(Signal* signal) +{ + const Uint32 tactivePageDir = datapageptr.p->word32[ZPOS_PAGE_ID]; + const Uint32 tpageType = (datapageptr.p->word32[ZPOS_EMPTY_LIST] >> ZPOS_PAGE_TYPE_BIT) & 3; + if (fragrecptr.p->fragState == LCP_SEND_PAGES) { + if (tpageType == ZNORMAL_PAGE_TYPE) { + /* --------------------------------------------------------------------------- */ + /* HANDLING OF LOG OF NORMAL PAGES DURING WRITE OF NORMAL PAGES. */ + /* --------------------------------------------------------------------------- */ + if (tactivePageDir < fragrecptr.p->lcpDirIndex) { + jam(); + /* ------------------------------------------------------------------- */ + /* THIS PAGE HAS ALREADY BEEN WRITTEN IN THE LOCAL CHECKPOINT. */ + /* ------------------------------------------------------------------- */ + /*empty*/; + } else { + if (tactivePageDir >= fragrecptr.p->lcpMaxDirIndex) { + jam(); + /* --------------------------------------------------------------------------- */ + /* OBVIOUSLY THE FRAGMENT HAS EXPANDED SINCE THE START OF THE LOCAL CHECKPOINT.*/ + /* WE NEED NOT LOG ANY UPDATES OF PAGES THAT DID NOT EXIST AT START OF LCP. */ + /* --------------------------------------------------------------------------- */ + /*empty*/; + } else { + jam(); + /* --------------------------------------------------------------------------- */ + /* IN ALL OTHER CASES WE HAVE TO WRITE TO THE UNDO LOG. */ + /* --------------------------------------------------------------------------- */ + undopageptr.i = (cundoposition >> ZUNDOPAGEINDEXBITS) & (cundopagesize - 1); + ptrAss(undopageptr, undopage); + theadundoindex = cundoposition & ZUNDOPAGEINDEX_MASK; + tundoindex = theadundoindex + ZUNDOHEADSIZE; + writeUndoHeader(signal, tactivePageDir, UndoHeader::ZPAGE_INFO); + tundoElemIndex = cundoElemIndex; + writeUndoDataInfo(signal); + checkUndoPages(signal); + }//if + }//if + } else if (tpageType == ZOVERFLOW_PAGE_TYPE) { + /* --------------------------------------------------------------------------------- */ + /* OVERFLOW PAGE HANDLING DURING WRITE OF NORMAL PAGES. */ + /* --------------------------------------------------------------------------------- */ + if (tactivePageDir >= fragrecptr.p->lcpMaxOverDirIndex) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* OBVIOUSLY THE FRAGMENT HAS EXPANDED THE NUMBER OF OVERFLOW PAGES SINCE THE */ + /* START OF THE LOCAL CHECKPOINT. WE NEED NOT LOG ANY UPDATES OF PAGES THAT DID*/ + /* NOT EXIST AT START OF LCP. */ + /* --------------------------------------------------------------------------------- */ + /*empty*/; + } else { + jam(); + undopageptr.i = (cundoposition >> ZUNDOPAGEINDEXBITS) & (cundopagesize - 1); + ptrAss(undopageptr, undopage); + theadundoindex = cundoposition & ZUNDOPAGEINDEX_MASK; + tundoindex = theadundoindex + ZUNDOHEADSIZE; + writeUndoHeader(signal, tactivePageDir, UndoHeader::ZOVER_PAGE_INFO); + tundoElemIndex = cundoElemIndex; + writeUndoDataInfo(signal); + checkUndoPages(signal); + }//if + } else if (tpageType != ZLONG_PAGE_TYPE) { + jam(); + /* --------------------------------------------------------------------------- */ + /* ONLY PAGE INFO AND OVERFLOW PAGE INFO CAN BE LOGGED BY THIS ROUTINE. A */ + /* SERIOUS ERROR. */ + /* --------------------------------------------------------------------------- */ + sendSystemerror(signal); + } else { + /* --------------------------------------------------------------------------------- */ + /* THIS LOG RECORD IS GENERATED ON A LONG KEY PAGE. THESE PAGES USE LOGICAL */ + /* LOGGING. */ + /* --------------------------------------------------------------------------------- */ + if (tactivePageDir >= fragrecptr.p->lcpMaxOverDirIndex) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* OBVIOUSLY THE FRAGMENT HAS EXPANDED THE NUMBER OF OVERFLOW PAGES SINCE THE */ + /* START OF THE LOCAL CHECKPOINT. WE NEED NOT LOG ANY UPDATES OF PAGES THAT DID*/ + /* NOT EXIST AT START OF LCP. */ + /* --------------------------------------------------------------------------------- */ + /*empty*/; + } else { + jam(); + /* --------------------------------------------------------------------------------- */ + /* LOGICAL LOGGING OF LONG KEY PAGES CAN EITHER BE UNDO OF AN INSERT OR UNDO */ + /* OF A DELETE KEY. UNDO OF DELETE NEEDS TO LOG THE KEY TO BE REINSERTED WHILE */ + /* UNDO OF INSERT ONLY NEEDS TO LOG THE INDEX TO BE DELETED. */ + /* --------------------------------------------------------------------------------- */ + undopageptr.i = (cundoposition >> ZUNDOPAGEINDEXBITS) & (cundopagesize - 1); + ptrAss(undopageptr, undopage); + theadundoindex = cundoposition & ZUNDOPAGEINDEX_MASK; + tundoindex = theadundoindex + ZUNDOHEADSIZE; + if (cundoinfolength == 0) { + jam(); + writeUndoHeader(signal, tactivePageDir, UndoHeader::ZUNDO_INSERT_LONG_KEY); + } else { + jam(); + writeUndoHeader(signal, tactivePageDir, UndoHeader::ZUNDO_DELETE_LONG_KEY); + arrGuard(ZWORDS_IN_PAGE - cundoElemIndex, 2048); + tundoElemIndex = datapageptr.p->word32[ZWORDS_IN_PAGE - cundoElemIndex] & 0xffff; + writeUndoDataInfo(signal); + }//if + checkUndoPages(signal); + }//if + }//if + } else { + if (fragrecptr.p->fragState == LCP_SEND_OVER_PAGES) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* DURING WRITE OF OVERFLOW PAGES WE NEED NOT WORRY ANYMORE ABOUT NORMAL PAGES.*/ + /* --------------------------------------------------------------------------------- */ + if (tpageType == ZOVERFLOW_PAGE_TYPE) { + if (tactivePageDir < fragrecptr.p->lcpDirIndex) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THIS PAGE HAS ALREADY BEEN WRITTEN IN THE LOCAL CHECKPOINT. */ + /* --------------------------------------------------------------------------------- */ + /*empty*/; + } else { + if (tactivePageDir >= fragrecptr.p->lcpMaxOverDirIndex) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* OBVIOUSLY THE FRAGMENT HAS EXPANDED THE NUMBER OF OVERFLOW PAGES SINCE THE */ + /* START OF THE LOCAL CHECKPOINT. WE NEED NOT LOG ANY UPDATES OF PAGES THAT DID*/ + /* NOT EXIST AT START OF LCP. */ + /* --------------------------------------------------------------------------------- */ + /*empty*/; + } else { + jam(); + undopageptr.i = (cundoposition >> ZUNDOPAGEINDEXBITS) & (cundopagesize - 1); + ptrAss(undopageptr, undopage); + theadundoindex = cundoposition & ZUNDOPAGEINDEX_MASK; + tundoindex = theadundoindex + ZUNDOHEADSIZE; + writeUndoHeader(signal, tactivePageDir, UndoHeader::ZOVER_PAGE_INFO); + tundoElemIndex = cundoElemIndex; + writeUndoDataInfo(signal); + checkUndoPages(signal); + }//if + }//if + } else if (tpageType == ZLONG_PAGE_TYPE) { + if (tactivePageDir < fragrecptr.p->lcpDirIndex) { + jam(); + // ------------------------------------------------------------- + // THIS PAGE HAS ALREADY BEEN WRITTEN IN THE LOCAL CHECKPOINT. + // ------------------------------------------------------------- + } else { + if (tactivePageDir >= fragrecptr.p->lcpMaxOverDirIndex) { + jam(); + // ------------------------------------------------------------- + // OBVIOUSLY THE FRAGMENT HAS EXPANDED THE NUMBER OF OVERFLOW + // PAGES SINCE THE START OF THE LOCAL CHECKPOINT. WE NEED NOT + // LOG ANY UPDATES OF PAGES THAT DID NOT EXIST AT START OF LCP. + // ------------------------------------------------------------- + } else { + jam(); + // ------------------------------------------------------------- + // LOGICAL LOGGING OF LONG KEY PAGES CAN EITHER BE UNDO OF AN + // INSERT OR UNDO OF A DELETE KEY. UNDO OF DELETE NEEDS TO LOG + // THE KEY TO BE REINSERTED WHILE UNDO OF INSERT ONLY NEEDS TO + // LOG THE INDEX TO BE DELETED. + // ------------------------------------------------------------- + undopageptr.i = (cundoposition >> ZUNDOPAGEINDEXBITS) & (cundopagesize - 1); + ptrAss(undopageptr, undopage); + theadundoindex = cundoposition & ZUNDOPAGEINDEX_MASK; + tundoindex = theadundoindex + ZUNDOHEADSIZE; + if (cundoinfolength == 0) { + jam(); + writeUndoHeader(signal, tactivePageDir, UndoHeader::ZUNDO_INSERT_LONG_KEY); + } else { + jam(); + writeUndoHeader(signal, tactivePageDir, UndoHeader::ZUNDO_DELETE_LONG_KEY); + arrGuard(ZWORDS_IN_PAGE - cundoElemIndex, 2048); + tundoElemIndex = datapageptr.p->word32[ZWORDS_IN_PAGE - cundoElemIndex] & 0xffff; + writeUndoDataInfo(signal); + }//if + checkUndoPages(signal); + }//if + }//if + }//if + }//if + }//if +}//Dbacc::undoWritingProcess() + +/* --------------------------------------------------------------------------------- */ +/* OTHER STATES MEANS THAT WE HAVE ALREADY WRITTEN ALL PAGES BUT NOT YET RESET */ +/* THE CREATE_LCP FLAG. */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* WRITE_UNDO_DATA_INFO */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::writeUndoDataInfo(Signal* signal) +{ + Uint32 twudiIndex; + Uint32 guard22; + + guard22 = cundoinfolength; + arrGuard((tundoindex + guard22 - 1), 8192); + arrGuard((tundoElemIndex + guard22 - 1), 2048); + for (twudiIndex = 1; twudiIndex <= guard22; twudiIndex++) { + undopageptr.p->undoword[tundoindex] = datapageptr.p->word32[tundoElemIndex]; + tundoindex++; + tundoElemIndex++; + }//for +}//Dbacc::writeUndoDataInfo() + +/* --------------------------------------------------------------------------------- */ +/* WRITE_UNDO_HEADER */ +/* THE HEAD OF UNDO ELEMENT IS 24 BYTES AND CONTAINS THE FOLLOWING INFORMATION: */ +/* TABLE IDENTITY 32 BITS */ +/* ROOT FRAGMENT IDENTITY 32 BITS */ +/* LOCAL FRAGMENT IDENTITY 32 BITS */ +/* LENGTH OF ELEMENT INF0 (BIT 31 - 18) 14 BITS */ +/* INFO TYPE (BIT 17 - 14) 4 BITS */ +/* PAGE INDEX OF THE FIRST FIELD IN THE FRAGMENT (BIT 13 - 0) 14 BITS */ +/* DIRECTORY INDEX OF THE PAGE IN THE FRAGMENT 32 BITS */ +/* ADDRESS OF THE PREVIOUS ELEMENT OF THE FRAGMENT 64 BITS */ +/* ADDRESS OF THE PREVIOUS ELEMENT IN THE UNDO PAGES 64 BITS */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::writeUndoHeader(Signal* signal, + Uint32 logicalPageId, + UndoHeader::UndoHeaderType pageType) +{ + rootfragrecptr.i = fragrecptr.p->myroot; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + arrGuard(theadundoindex + 6, 8192); + + // Set the structpointer to point at the undo page at the right address. + UndoHeader * const & undoHeaderPtr = + (UndoHeader *) &undopageptr.p->undoword[theadundoindex]; + + undoHeaderPtr->tableId = rootfragrecptr.p->mytabptr; + undoHeaderPtr->rootFragId = rootfragrecptr.p->fragmentid[0]; + undoHeaderPtr->localFragId = fragrecptr.p->myfid; + Uint32 Ttmp = cundoinfolength; + Ttmp = (Ttmp << 4) + pageType; + Ttmp = Ttmp << 14; + undoHeaderPtr->variousInfo = Ttmp + cundoElemIndex; + undoHeaderPtr->logicalPageId = logicalPageId; + undoHeaderPtr->prevUndoAddressForThisFrag = fragrecptr.p->prevUndoposition; + undoHeaderPtr->prevUndoAddress = cprevUndoaddress; +}//Dbacc::writeUndoHeader() + +/* --------------------------------------------------------------------------------- */ +/* WRITE_UNDO_OP_INFO */ +/* FOR A LOCKED ELEMENT, OPERATION TYPE, UNDO OF ELEMENT HEADER AND THE LENGTH OF*/ +/* THE TUPLE KEY HAVE TO BE SAVED IN UNDO PAGES. IN THIS CASE AN UNDO ELEMENT */ +/* INCLUDES THE FLLOWING ITEMS. */ +/* OPERATION TYPE 32 BITS */ +/* HASH VALUE 32 BITS */ +/* LENGTH OF THE TUPLE = N 32 BITS */ +/* TUPLE KEYS N * 32 BITS */ +/* */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::writeUndoOpInfo(Signal* signal) +{ + Page8Ptr locPageptr; + + arrGuard((tundoindex + 3), 8192); + undopageptr.p->undoword[tundoindex] = operationRecPtr.p->operation; + undopageptr.p->undoword[tundoindex + 1] = operationRecPtr.p->hashValue; + undopageptr.p->undoword[tundoindex + 2] = operationRecPtr.p->tupkeylen; + tundoindex = tundoindex + 3; + if (fragrecptr.p->keyLength != 0) { + // Fixed size keys + jam(); + locPageptr.i = operationRecPtr.p->elementPage; + ptrCheckGuard(locPageptr, cpagesize, page8); + Uint32 Tforward = operationRecPtr.p->elementIsforward; + Uint32 TelemPtr = operationRecPtr.p->elementPointer; + TelemPtr += Tforward; + TelemPtr += Tforward; + //--------------------------------------------------------------------------------- + // Now the pointer is at the start of the key part of the element. Now copy from there + // to the UNDO log. + //--------------------------------------------------------------------------------- + Uint32 keyLen = operationRecPtr.p->tupkeylen; + ndbrequire(keyLen <= 8); + arrGuard(tundoindex+keyLen, 8192); + for (Uint32 twuoiIndex = 0; twuoiIndex < keyLen; twuoiIndex++) { + jam(); + arrGuard(TelemPtr, 2048); + undopageptr.p->undoword[tundoindex] = locPageptr.p->word32[TelemPtr]; + tundoindex++; + TelemPtr += Tforward; + }//for + cundoinfolength = ZOP_HEAD_INFO_LN + operationRecPtr.p->tupkeylen; + } else { + // Long keys + jam(); + + arrGuard(operationRecPtr.p->longKeyPageIndex, ZMAX_NO_OF_LONGKEYS_IN_PAGE); + locPageptr.i = operationRecPtr.p->longPagePtr; + ptrCheckGuard(locPageptr, cpagesize, page8); + + Uint32 indexValue = + locPageptr.p->word32[ZWORDS_IN_PAGE - operationRecPtr.p->longKeyPageIndex]; + Uint32 keyLen = indexValue >> 16; + Uint32 physPageIndex = indexValue & 0xffff; + ndbrequire(keyLen == operationRecPtr.p->tupkeylen); + + arrGuard(tundoindex+keyLen, 8192); + arrGuard(physPageIndex+keyLen, 2048); + for (Uint32 i = 0; i < keyLen; i++){ + undopageptr.p->undoword[tundoindex + i] = locPageptr.p->word32[physPageIndex+i]; + } + tundoindex = tundoindex + keyLen; + cundoinfolength = ZOP_HEAD_INFO_LN + keyLen; + }//if +}//Dbacc::writeUndoOpInfo() + +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* END OF LOCAL CHECKPOINT MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* SYSTEM RESTART MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* SR_FRAGIDREQ REQUEST FOR RESTART OF A FRAGMENT */ +/* SENDER: LQH, LEVEL B */ +/* ENTER SR_FRAGIDREQ WITH */ +/* TUSERPTR, LQH CONNECTION PTR */ +/* TUSERBLOCKREF, LQH BLOCK REFERENCE */ +/* TCHECKPOINTID, THE CHECKPOINT NUMBER TO USE */ +/* (E.G. 1,2 OR 3) */ +/* TABPTR, TABLE ID = TABLE RECORD POINTER */ +/* TFID, ROOT FRAGMENT ID */ +/* ******************--------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* SR_FRAGIDREQ REQUEST FOR LIST OF STOPED OPERATION */ +/* ******************------------------------------+ */ +/* SENDER: LQH, LEVEL B */ +void Dbacc::execSR_FRAGIDREQ(Signal* signal) +{ + jamEntry(); + tuserptr = signal->theData[0]; /* LQH CONNECTION PTR */ + tuserblockref = signal->theData[1]; /* LQH BLOCK REFERENCE */ + tcheckpointid = signal->theData[2]; /* THE CHECKPOINT NUMBER TO USE */ + /* (E.G. 1,2 OR 3) */ + tabptr.i = signal->theData[3]; + ptrCheckGuard(tabptr, ctablesize, tabrec); + /* TABLE ID = TABLE RECORD POINTER */ + tfid = signal->theData[4]; /* ROOT FRAGMENT ID */ + tresult = 0; /* 0= FALSE,1= TRUE,> ZLIMIT_OF_ERROR =ERRORCODE */ + seizeLcpConnectRec(signal); + initLcpConnRec(signal); + + ndbrequire(getrootfragmentrec(signal, rootfragrecptr, tfid)); + rootfragrecptr.p->lcpPtr = lcpConnectptr.i; + lcpConnectptr.p->rootrecptr = rootfragrecptr.i; + lcpConnectptr.p->localCheckPid = tcheckpointid; + for (Uint32 i = 0; i < 2; i++) { + Page8Ptr zeroPagePtr; + jam(); + fragrecptr.i = rootfragrecptr.p->fragmentptr[i]; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + seizeLcpPage(zeroPagePtr); + fragrecptr.p->zeroPagePtr = zeroPagePtr.i; + }//for + + /* ---------------------------OPEN THE DATA FILE WHICH BELONGS TO TFID AND TCHECK POINT ---- */ + fragrecptr.i = rootfragrecptr.p->fragmentptr[0]; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + tfid = rootfragrecptr.p->fragmentid[0]; + tmp = 0; + srOpenDataFileLoopLab(signal); + + return; +}//Dbacc::execSR_FRAGIDREQ() + +void Dbacc::srOpenDataFileLoopLab(Signal* signal) +{ + /* D6 AT FSOPENREQ. FILE TYPE = .DATA */ + tmp1 = 0x010003ff; /* VERSION OF FILENAME = 1 */ + tmp2 = 0x0; /* D7 DON'T CREATE, READ ONLY */ + ndbrequire(cfsFirstfreeconnect != RNIL); + seizeFsConnectRec(signal); + + fragrecptr.p->fsConnPtr = fsConnectptr.i; + fsConnectptr.p->fragrecPtr = fragrecptr.i; + fsConnectptr.p->fsState = WAIT_OPEN_DATA_FILE_FOR_READ; + fsConnectptr.p->activeFragId = tmp; /* LOCAL FRAG INDEX */ + /* ************************ */ + /* FSOPENREQ */ + /* ************************ */ + signal->theData[0] = cownBlockref; + signal->theData[1] = fsConnectptr.i; + signal->theData[2] = rootfragrecptr.p->mytabptr; /* TABLE IDENTITY */ + signal->theData[3] = tfid; /* FRAGMENT IDENTITY */ + signal->theData[4] = lcpConnectptr.p->localCheckPid; /* CHECKPOINT ID */ + signal->theData[5] = tmp1; + signal->theData[6] = tmp2; + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA); + return; +}//Dbacc::srOpenDataFileLoopLab() + +void Dbacc::srFsOpenConfLab(Signal* signal) +{ + fsConnectptr.p->fsState = WAIT_READ_PAGE_ZERO; + /* ------------------------ READ ZERO PAGE ---------- */ + fragrecptr.i = fsConnectptr.p->fragrecPtr; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + signal->theData[0] = fsConnectptr.p->fsPtr; + signal->theData[1] = cownBlockref; + signal->theData[2] = fsConnectptr.i; + signal->theData[3] = 0x0; + /* FLAG = LIST MEM PAGES, LIST FILE PAGES */ + signal->theData[4] = ZPAGE8_BASE_ADD; + signal->theData[5] = 1; /* NO OF PAGES */ + signal->theData[6] = fragrecptr.p->zeroPagePtr; /* ZERO PAGE */ + signal->theData[7] = 0; /* PAGE ZERO OF THE DATA FILE */ + sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 8, JBA); + return; +}//Dbacc::srFsOpenConfLab() + +void Dbacc::srReadPageZeroLab(Signal* signal) +{ + Page8Ptr srzPageptr; + + rootfragrecptr.i = fragrecptr.p->myroot; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + fragrecptr.p->activeDataFilePage = 1; + srzPageptr.i = fragrecptr.p->zeroPagePtr; + ptrCheckGuard(srzPageptr, cpagesize, page8); + /* --------------------------------------------------------------------------------- */ + // Check that the checksum of the zero page is ok. + /* --------------------------------------------------------------------------------- */ + ccoPageptr.p = srzPageptr.p; + checksumControl(signal, (Uint32)0); + if (tresult > 0) { + jam(); + return; // We will crash through a DEBUG_SIG + }//if + + ndbrequire(srzPageptr.p->word32[ZPAGEZERO_FRAGID0] == rootfragrecptr.p->fragmentid[0]); + lcpConnectptr.i = rootfragrecptr.p->lcpPtr; + ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec); + if (fsConnectptr.p->activeFragId == 0) { + jam(); + rootfragrecptr.p->fragmentid[1] = srzPageptr.p->word32[ZPAGEZERO_FRAGID1]; + /* ---------------------------OPEN THE DATA FILE FOR NEXT LOCAL FRAGMENT ----------- ---- */ + tfid = rootfragrecptr.p->fragmentid[1]; + tmp = 1; /* LOCAL FRAG INDEX */ + fragrecptr.i = rootfragrecptr.p->fragmentptr[1]; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + srOpenDataFileLoopLab(signal); + return; + } else { + jam(); + lcpConnectptr.p->lcpstate = LCP_ACTIVE; + signal->theData[0] = lcpConnectptr.p->lcpUserptr; + signal->theData[1] = lcpConnectptr.i; + signal->theData[2] = 2; /* NO OF LOCAL FRAGMENTS */ + signal->theData[3] = srzPageptr.p->word32[ZPAGEZERO_FRAGID0]; + /* ROOTFRAGRECPTR:FRAGMENTID(0) */ + signal->theData[4] = srzPageptr.p->word32[ZPAGEZERO_FRAGID1]; + /* ROOTFRAGRECPTR:FRAGMENTID(1) */ + signal->theData[5] = RNIL; + signal->theData[6] = RNIL; + signal->theData[7] = rootfragrecptr.p->fragmentptr[0]; + signal->theData[8] = rootfragrecptr.p->fragmentptr[1]; + signal->theData[9] = srzPageptr.p->word32[ZPAGEZERO_HASH_CHECK]; + sendSignal(lcpConnectptr.p->lcpUserblockref, GSN_SR_FRAGIDCONF, signal, 10, JBB); + }//if + return; +}//Dbacc::srReadPageZeroLab() + +void Dbacc::initFragAdd(Signal* signal, + Uint32 rootFragIndex, + Uint32 rootIndex, + FragmentrecPtr regFragPtr) +{ + const AccFragReq * const req = (AccFragReq*)&signal->theData[0]; + Uint32 lhFragBits = req->lhFragBits + 1; + Uint32 minLoadFactor = (req->minLoadFactor * ZBUF_SIZE) / 100; + Uint32 maxLoadFactor = (req->maxLoadFactor * ZBUF_SIZE) / 100; + if (minLoadFactor >= maxLoadFactor) { + jam(); + minLoadFactor = maxLoadFactor - 1; + }//if + regFragPtr.p->fragState = ACTIVEFRAG; + // NOTE: next line must match calculation in Dblqh::execLQHFRAGREQ + regFragPtr.p->myfid = (rootFragIndex << (lhFragBits - 1)) | req->fragId; + regFragPtr.p->myroot = rootIndex; + regFragPtr.p->myTableId = req->tableId; + ndbrequire(req->kValue == 6); + regFragPtr.p->k = req->kValue; /* TK_SIZE = 6 IN THIS VERSION */ + regFragPtr.p->expandCounter = 0; + regFragPtr.p->expandFlag = 0; + regFragPtr.p->p = 0; + regFragPtr.p->maxp = (1 << req->kValue) - 1; + regFragPtr.p->minloadfactor = minLoadFactor; + regFragPtr.p->maxloadfactor = maxLoadFactor; + regFragPtr.p->slack = (regFragPtr.p->maxp + 1) * maxLoadFactor; + regFragPtr.p->lhfragbits = lhFragBits; + regFragPtr.p->lhdirbits = 0; + regFragPtr.p->hashcheckbit = 0; //lhFragBits; + regFragPtr.p->localkeylen = req->localKeyLen; + regFragPtr.p->nodetype = (req->reqInfo >> 4) & 0x3; + regFragPtr.p->lastOverIndex = 0; + regFragPtr.p->dirsize = 1; + regFragPtr.p->loadingFlag = ZFALSE; + regFragPtr.p->keyLength = req->keyLength; + if (req->keyLength == 0) { + jam(); + regFragPtr.p->elementLength = (1 + ZELEM_HEAD_SIZE) + regFragPtr.p->localkeylen; + } else { + jam(); + regFragPtr.p->elementLength = (ZELEM_HEAD_SIZE + regFragPtr.p->localkeylen) + regFragPtr.p->keyLength; + }//if + Uint32 Tmp1 = (regFragPtr.p->maxp + 1) + regFragPtr.p->p; + Uint32 Tmp2 = regFragPtr.p->maxloadfactor - regFragPtr.p->minloadfactor; + Tmp2 = Tmp1 * Tmp2; + regFragPtr.p->slackCheck = Tmp2; +}//Dbacc::initFragAdd() + +void Dbacc::initFragGeneral(FragmentrecPtr regFragPtr) +{ + regFragPtr.p->directory = RNIL; + regFragPtr.p->overflowdir = RNIL; + regFragPtr.p->fsConnPtr = RNIL; + regFragPtr.p->firstOverflowRec = RNIL; + regFragPtr.p->lastOverflowRec = RNIL; + regFragPtr.p->firstWaitInQueOp = RNIL; + regFragPtr.p->lastWaitInQueOp = RNIL; + regFragPtr.p->sentWaitInQueOp = RNIL; + regFragPtr.p->lockOwnersList = RNIL; + regFragPtr.p->firstFreeDirindexRec = RNIL; + regFragPtr.p->zeroPagePtr = RNIL; + + regFragPtr.p->activeDataPage = 0; + regFragPtr.p->createLcp = ZFALSE; + regFragPtr.p->stopQueOp = ZFALSE; + regFragPtr.p->nextAllocPage = 0; + regFragPtr.p->nrWaitWriteUndoExit = 0; + regFragPtr.p->lastUndoIsStored = ZFALSE; + regFragPtr.p->loadingFlag = ZFALSE; + regFragPtr.p->fragState = FREEFRAG; + for (Uint32 i = 0; i < ZWRITEPAGESIZE; i++) { + regFragPtr.p->datapages[i] = RNIL; + }//for + for (Uint32 i = 0; i < 4; i++) { + regFragPtr.p->longKeyPageArray[i] = RNIL; + }//for +}//Dbacc::initFragGeneral() + +void Dbacc::initFragSr(FragmentrecPtr regFragPtr, Page8Ptr regPagePtr) +{ + regFragPtr.p->prevUndoposition = regPagePtr.p->word32[ZPAGEZERO_PREV_UNDOP]; + regFragPtr.p->noOfStoredOverPages = regPagePtr.p->word32[ZPAGEZERO_NO_OVER_PAGE]; + regFragPtr.p->noStoredPages = regPagePtr.p->word32[ZPAGEZERO_NO_PAGES]; + regFragPtr.p->dirsize = regPagePtr.p->word32[ZPAGEZERO_DIRSIZE]; + regFragPtr.p->expandCounter = regPagePtr.p->word32[ZPAGEZERO_EXPCOUNTER]; + regFragPtr.p->slack = regPagePtr.p->word32[ZPAGEZERO_SLACK]; + regFragPtr.p->hashcheckbit = regPagePtr.p->word32[ZPAGEZERO_HASHCHECKBIT]; + regFragPtr.p->k = regPagePtr.p->word32[ZPAGEZERO_K]; + regFragPtr.p->lhfragbits = regPagePtr.p->word32[ZPAGEZERO_LHFRAGBITS]; + regFragPtr.p->lhdirbits = regPagePtr.p->word32[ZPAGEZERO_LHDIRBITS]; + regFragPtr.p->localkeylen = regPagePtr.p->word32[ZPAGEZERO_LOCALKEYLEN]; + regFragPtr.p->maxp = regPagePtr.p->word32[ZPAGEZERO_MAXP]; + regFragPtr.p->maxloadfactor = regPagePtr.p->word32[ZPAGEZERO_MAXLOADFACTOR]; + regFragPtr.p->minloadfactor = regPagePtr.p->word32[ZPAGEZERO_MINLOADFACTOR]; + regFragPtr.p->myfid = regPagePtr.p->word32[ZPAGEZERO_MYFID]; + regFragPtr.p->lastOverIndex = regPagePtr.p->word32[ZPAGEZERO_LAST_OVER_INDEX]; + regFragPtr.p->nodetype = regPagePtr.p->word32[ZPAGEZERO_NODETYPE]; + regFragPtr.p->p = regPagePtr.p->word32[ZPAGEZERO_P]; + regFragPtr.p->elementLength = regPagePtr.p->word32[ZPAGEZERO_ELEMENT_LENGTH]; + regFragPtr.p->keyLength = regPagePtr.p->word32[ZPAGEZERO_KEY_LENGTH]; + regFragPtr.p->slackCheck = regPagePtr.p->word32[ZPAGEZERO_SLACK_CHECK]; + + regFragPtr.p->loadingFlag = ZTRUE; + +}//Dbacc::initFragSr() + +void Dbacc::initFragPageZero(FragmentrecPtr regFragPtr, Page8Ptr regPagePtr) +{ + //------------------------------------------------------------------ + // PREV_UNDOP, NEXT_UNDO_FILE, NO_OVER_PAGE, NO_PAGES + // is set at end of copy phase + //------------------------------------------------------------------ + regPagePtr.p->word32[ZPAGEZERO_DIRSIZE] = regFragPtr.p->dirsize; + regPagePtr.p->word32[ZPAGEZERO_EXPCOUNTER] = regFragPtr.p->expandCounter; + regPagePtr.p->word32[ZPAGEZERO_SLACK] = regFragPtr.p->slack; + regPagePtr.p->word32[ZPAGEZERO_HASHCHECKBIT] = regFragPtr.p->hashcheckbit; + regPagePtr.p->word32[ZPAGEZERO_K] = regFragPtr.p->k; + regPagePtr.p->word32[ZPAGEZERO_LHFRAGBITS] = regFragPtr.p->lhfragbits; + regPagePtr.p->word32[ZPAGEZERO_LHDIRBITS] = regFragPtr.p->lhdirbits; + regPagePtr.p->word32[ZPAGEZERO_LOCALKEYLEN] = regFragPtr.p->localkeylen; + regPagePtr.p->word32[ZPAGEZERO_MAXP] = regFragPtr.p->maxp; + regPagePtr.p->word32[ZPAGEZERO_MAXLOADFACTOR] = regFragPtr.p->maxloadfactor; + regPagePtr.p->word32[ZPAGEZERO_MINLOADFACTOR] = regFragPtr.p->minloadfactor; + regPagePtr.p->word32[ZPAGEZERO_MYFID] = regFragPtr.p->myfid; + regPagePtr.p->word32[ZPAGEZERO_LAST_OVER_INDEX] = regFragPtr.p->lastOverIndex; + regPagePtr.p->word32[ZPAGEZERO_NODETYPE] = regFragPtr.p->nodetype; + regPagePtr.p->word32[ZPAGEZERO_P] = regFragPtr.p->p; + regPagePtr.p->word32[ZPAGEZERO_ELEMENT_LENGTH] = regFragPtr.p->elementLength; + regPagePtr.p->word32[ZPAGEZERO_KEY_LENGTH] = regFragPtr.p->keyLength; + regPagePtr.p->word32[ZPAGEZERO_SLACK_CHECK] = regFragPtr.p->slackCheck; +}//Dbacc::initFragPageZero() + +void Dbacc::initRootFragPageZero(RootfragmentrecPtr rootPtr, Page8Ptr regPagePtr) +{ + regPagePtr.p->word32[ZPAGEZERO_TABID] = rootPtr.p->mytabptr; + regPagePtr.p->word32[ZPAGEZERO_FRAGID0] = rootPtr.p->fragmentid[0]; + regPagePtr.p->word32[ZPAGEZERO_FRAGID1] = rootPtr.p->fragmentid[1]; + regPagePtr.p->word32[ZPAGEZERO_HASH_CHECK] = rootPtr.p->roothashcheck; + regPagePtr.p->word32[ZPAGEZERO_NO_OF_ELEMENTS] = rootPtr.p->noOfElements; +}//Dbacc::initRootFragPageZero() + +void Dbacc::initRootFragSr(RootfragmentrecPtr rootPtr, Page8Ptr regPagePtr) +{ + rootPtr.p->roothashcheck = regPagePtr.p->word32[ZPAGEZERO_HASH_CHECK]; + rootPtr.p->noOfElements = regPagePtr.p->word32[ZPAGEZERO_NO_OF_ELEMENTS]; +}//Dbacc::initRootFragSr() + +/* ******************--------------------------------------------------------------- */ +/* ACC_SRREQ SYSTEM RESTART OF A LOCAL CHECK POINT */ +/* SENDER: LQH, LEVEL B */ +/* ENTER ACC_SRREQ WITH */ +/* LCP_CONNECTPTR, OPERATION RECORD PTR */ +/* TMP2, LQH'S LOCAL FRAG CHECK VALUE */ +/* TFID, LOCAL FRAG ID */ +/* TMP1, LOCAL CHECKPOINT ID */ +/* ******************--------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* ACC_SRREQ PERFORM A LOCAL CHECK POINT */ +/* ******************------------------------------+ */ +/* SENDER: LQH, LEVEL B */ +void Dbacc::execACC_SRREQ(Signal* signal) +{ + Page8Ptr asrPageidptr; + jamEntry(); + lcpConnectptr.i = signal->theData[0]; + ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec); + Uint32 lqhPtr = signal->theData[1]; + Uint32 fragId = signal->theData[2]; + Uint32 lcpId = signal->theData[3]; + tresult = 0; + ndbrequire(lcpConnectptr.p->lcpstate == LCP_ACTIVE); + rootfragrecptr.i = lcpConnectptr.p->rootrecptr; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + if (rootfragrecptr.p->fragmentid[0] == fragId) { + jam(); + fragrecptr.i = rootfragrecptr.p->fragmentptr[0]; + } else { + ndbrequire(rootfragrecptr.p->fragmentid[1] == fragId); + jam(); + fragrecptr.i = rootfragrecptr.p->fragmentptr[1]; + }//if + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + fragrecptr.p->lcpLqhPtr = lqhPtr; + fragrecptr.p->localCheckpId = lcpId; + asrPageidptr.i = fragrecptr.p->zeroPagePtr; + ptrCheckGuard(asrPageidptr, cpagesize, page8); + ndbrequire(asrPageidptr.p->word32[ZPAGEZERO_TABID] == rootfragrecptr.p->mytabptr); + ndbrequire(asrPageidptr.p->word32[ZPAGEZERO_FRAGID0] == rootfragrecptr.p->fragmentid[0]); + ndbrequire(asrPageidptr.p->word32[ZPAGEZERO_FRAGID1] == rootfragrecptr.p->fragmentid[1]); + initRootFragSr(rootfragrecptr, asrPageidptr); + initFragSr(fragrecptr, asrPageidptr); + for (Uint32 i = 0; i < ZMAX_UNDO_VERSION; i++) { + jam(); + if (csrVersList[i] != RNIL) { + jam(); + srVersionPtr.i = csrVersList[i]; + ptrCheckGuard(srVersionPtr, csrVersionRecSize, srVersionRec); + if (fragrecptr.p->localCheckpId == srVersionPtr.p->checkPointId) { + jam(); + ndbrequire(srVersionPtr.p->checkPointId == asrPageidptr.p->word32[ZPAGEZERO_NEXT_UNDO_FILE]); + /*--------------------------------------------------------------------------------*/ + /* SINCE -1 IS THE END OF LOG CODE WE MUST TREAT THIS CODE WITH CARE. WHEN */ + /* COMPARING IT IS LARGER THAN EVERYTHING ELSE BUT SHOULD BE TREATED AS THE */ + /* SMALLEST POSSIBLE VALUE, MEANING EMPTY. */ + /*--------------------------------------------------------------------------------*/ + if (fragrecptr.p->prevUndoposition != cminusOne) { + if (srVersionPtr.p->prevAddress < fragrecptr.p->prevUndoposition) { + jam(); + srVersionPtr.p->prevAddress = fragrecptr.p->prevUndoposition; + } else if (srVersionPtr.p->prevAddress == cminusOne) { + jam(); + srVersionPtr.p->prevAddress = fragrecptr.p->prevUndoposition; + }//if + }//if + srAllocPage0011Lab(signal); + return; + }//if + } else { + jam(); + seizeSrVerRec(signal); + srVersionPtr.p->checkPointId = fragrecptr.p->localCheckpId; + srVersionPtr.p->prevAddress = fragrecptr.p->prevUndoposition; + csrVersList[i] = srVersionPtr.i; + srAllocPage0011Lab(signal); + return; + }//if + }//for + ndbrequire(false); +}//Dbacc::execACC_SRREQ() + +void +Dbacc::releaseLogicalPage(Fragmentrec * fragP, Uint32 logicalPageId){ + Ptr dirRangePtr; + dirRangePtr.i = fragP->directory; + ptrCheckGuard(dirRangePtr, cdirrangesize, dirRange); + + const Uint32 lp1 = logicalPageId >> 8; + const Uint32 lp2 = logicalPageId & 0xFF; + ndbrequire(lp1 < 256); + + Ptr dirArrPtr; + dirArrPtr.i = dirRangePtr.p->dirArray[lp1]; + ptrCheckGuard(dirArrPtr, cdirarraysize, directoryarray); + + const Uint32 physicalPageId = dirArrPtr.p->pagep[lp2]; + + rpPageptr.i = physicalPageId; + ptrCheckGuard(rpPageptr, cpagesize, page8); + releasePage(0); + + dirArrPtr.p->pagep[lp2] = RNIL; +} + +void Dbacc::srAllocPage0011Lab(Signal* signal) +{ + releaseLogicalPage(fragrecptr.p, 0); + +#if JONAS + ndbrequire(cfirstfreeDirrange != RNIL); + seizeDirrange(signal); + fragrecptr.p->directory = newDirRangePtr.i; + ndbrequire(cfirstfreeDirrange != RNIL); + seizeDirrange(signal); + fragrecptr.p->overflowdir = newDirRangePtr.i; + seizeDirectory(signal); + ndbrequire(tresult < ZLIMIT_OF_ERROR); + newDirRangePtr.p->dirArray[0] = sdDirptr.i; +#endif + + fragrecptr.p->nextAllocPage = 0; + fragrecptr.p->fragState = SR_READ_PAGES; + srReadPagesLab(signal); + return; +}//Dbacc::srAllocPage0011Lab() + +void Dbacc::srReadPagesLab(Signal* signal) +{ + if (fragrecptr.p->nextAllocPage >= fragrecptr.p->noStoredPages) { + /*--------------------------------------------------------------------------------*/ + /* WE HAVE NOW READ ALL NORMAL PAGES FROM THE FILE. */ + /*--------------------------------------------------------------------------------*/ + if (fragrecptr.p->nextAllocPage == fragrecptr.p->dirsize) { + jam(); + /*--------------------------------------------------------------------------------*/ + /* WE HAVE NOW READ ALL NORMAL PAGES AND ALLOCATED ALL THE NEEDED PAGES. */ + /*--------------------------------------------------------------------------------*/ + fragrecptr.p->nextAllocPage = 0; /* THE NEXT OVER FLOW PAGE WHICH WILL BE READ */ + fragrecptr.p->fragState = SR_READ_OVER_PAGES; + srReadOverPagesLab(signal); + } else { + ndbrequire(fragrecptr.p->nextAllocPage < fragrecptr.p->dirsize); + jam(); + /*--------------------------------------------------------------------------------*/ + /* WE NEEDED TO ALLOCATE PAGES THAT WERE DEALLOCATED DURING THE LOCAL */ + /* CHECKPOINT. */ + /* ALLOCATE THE PAGE AND INITIALISE IT. THEN WE INSERT A REAL-TIME BREAK. */ + /*--------------------------------------------------------------------------------*/ + seizePage(signal); + ndbrequire(tresult <= ZLIMIT_OF_ERROR); + tipPageId = fragrecptr.p->nextAllocPage; + inpPageptr.i = spPageptr.i; + ptrCheckGuard(inpPageptr, cpagesize, page8); + initPage(signal); + fragrecptr.p->noOfExpectedPages = 1; + fragrecptr.p->datapages[0] = spPageptr.i; + signal->theData[0] = ZSR_READ_PAGES_ALLOC; + signal->theData[1] = fragrecptr.i; + sendSignal(cownBlockref, GSN_CONTINUEB, signal, 2, JBB); + }//if + return; + }//if + Uint32 limitLoop; + if ((fragrecptr.p->noStoredPages - fragrecptr.p->nextAllocPage) < ZWRITEPAGESIZE) { + jam(); + limitLoop = fragrecptr.p->noStoredPages - fragrecptr.p->nextAllocPage; + } else { + jam(); + limitLoop = ZWRITEPAGESIZE; + }//if + ndbrequire(limitLoop <= 8); + for (Uint32 i = 0; i < limitLoop; i++) { + jam(); + seizePage(signal); + ndbrequire(tresult <= ZLIMIT_OF_ERROR); + fragrecptr.p->datapages[i] = spPageptr.i; + signal->theData[i + 6] = spPageptr.i; + }//for + signal->theData[limitLoop + 6] = fragrecptr.p->activeDataFilePage; + fragrecptr.p->noOfExpectedPages = limitLoop; + /* -----------------SEND READ PAGES SIGNAL TO THE FILE MANAGER --------- */ + fsConnectptr.i = fragrecptr.p->fsConnPtr; + ptrCheckGuard(fsConnectptr, cfsConnectsize, fsConnectrec); + fsConnectptr.p->fsState = WAIT_READ_DATA; + signal->theData[0] = fsConnectptr.p->fsPtr; + signal->theData[1] = cownBlockref; + signal->theData[2] = fsConnectptr.i; + signal->theData[3] = 2; + /* FLAG = LIST MEM PAGES, RANGE OF FILE PAGES */ + signal->theData[4] = ZPAGE8_BASE_ADD; + signal->theData[5] = fragrecptr.p->noOfExpectedPages; + sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 15, JBA); + return; +}//Dbacc::srReadPagesLab() + +void Dbacc::storeDataPageInDirectoryLab(Signal* signal) +{ + fragrecptr.p->activeDataFilePage += fragrecptr.p->noOfExpectedPages; + srReadPagesAllocLab(signal); + return; +}//Dbacc::storeDataPageInDirectoryLab() + +void Dbacc::srReadPagesAllocLab(Signal* signal) +{ + DirRangePtr srpDirRangePtr; + DirectoryarrayPtr srpDirptr; + DirectoryarrayPtr srpOverflowDirptr; + Page8Ptr srpPageidptr; + + if (fragrecptr.p->fragState == SR_READ_PAGES) { + jam(); + for (Uint32 i = 0; i < fragrecptr.p->noOfExpectedPages; i++) { + jam(); + tmpP = fragrecptr.p->nextAllocPage; + srpDirRangePtr.i = fragrecptr.p->directory; + tmpP2 = tmpP >> 8; + tmp = tmpP & 0xff; + ptrCheckGuard(srpDirRangePtr, cdirrangesize, dirRange); + arrGuard(tmpP2, 256); + if (srpDirRangePtr.p->dirArray[tmpP2] == RNIL) { + seizeDirectory(signal); + ndbrequire(tresult <= ZLIMIT_OF_ERROR); + srpDirptr.i = sdDirptr.i; + srpDirRangePtr.p->dirArray[tmpP2] = srpDirptr.i; + } else { + jam(); + srpDirptr.i = srpDirRangePtr.p->dirArray[tmpP2]; + }//if + ptrCheckGuard(srpDirptr, cdirarraysize, directoryarray); + arrGuard(i, 8); + srpDirptr.p->pagep[tmp] = fragrecptr.p->datapages[i]; + srpPageidptr.i = fragrecptr.p->datapages[i]; + ptrCheckGuard(srpPageidptr, cpagesize, page8); + ndbrequire(srpPageidptr.p->word32[ZPOS_PAGE_ID] == fragrecptr.p->nextAllocPage); + ndbrequire(((srpPageidptr.p->word32[ZPOS_PAGE_TYPE] >> ZPOS_PAGE_TYPE_BIT) & 3) == 0); + ccoPageptr.p = srpPageidptr.p; + checksumControl(signal, (Uint32)1); + if (tresult > 0) { + jam(); + return; // We will crash through a DEBUG_SIG + }//if + dbgWord32(srpPageidptr, ZPOS_OVERFLOWREC, RNIL); + srpPageidptr.p->word32[ZPOS_OVERFLOWREC] = RNIL; + fragrecptr.p->datapages[i] = RNIL; + fragrecptr.p->nextAllocPage++; + }//for + srReadPagesLab(signal); + return; + } else { + ndbrequire(fragrecptr.p->fragState == SR_READ_OVER_PAGES); + for (Uint32 i = 0; i < fragrecptr.p->noOfExpectedPages; i++) { + jam(); + arrGuard(i, 8); + srpPageidptr.i = fragrecptr.p->datapages[i]; + ptrCheckGuard(srpPageidptr, cpagesize, page8); + tmpP = srpPageidptr.p->word32[ZPOS_PAGE_ID]; /* DIR INDEX OF THE OVERFLOW PAGE */ + /*--------------------------------------------------------------------------------*/ + /* IT IS POSSIBLE THAT WE HAVE LOGICAL PAGES WHICH ARE NOT PART OF THE LOCAL*/ + /* CHECKPOINT. THUS WE USE THE LOGICAL PAGE ID FROM THE PAGE HERE. */ + /*--------------------------------------------------------------------------------*/ + srpDirRangePtr.i = fragrecptr.p->overflowdir; + tmpP2 = tmpP >> 8; + tmpP = tmpP & 0xff; + ptrCheckGuard(srpDirRangePtr, cdirrangesize, dirRange); + arrGuard(tmpP2, 256); + if (srpDirRangePtr.p->dirArray[tmpP2] == RNIL) { + jam(); + seizeDirectory(signal); + ndbrequire(tresult <= ZLIMIT_OF_ERROR); + srpDirRangePtr.p->dirArray[tmpP2] = sdDirptr.i; + }//if + srpOverflowDirptr.i = srpDirRangePtr.p->dirArray[tmpP2]; + ndbrequire(((srpPageidptr.p->word32[ZPOS_PAGE_TYPE] >> ZPOS_PAGE_TYPE_BIT) & 3) != 0); + ndbrequire(((srpPageidptr.p->word32[ZPOS_PAGE_TYPE] >> ZPOS_PAGE_TYPE_BIT) & 3) != 3); + ptrCheckGuard(srpOverflowDirptr, cdirarraysize, directoryarray); + ndbrequire(srpOverflowDirptr.p->pagep[tmpP] == RNIL); + srpOverflowDirptr.p->pagep[tmpP] = srpPageidptr.i; + ccoPageptr.p = srpPageidptr.p; + checksumControl(signal, (Uint32)1); + ndbrequire(tresult == 0); + dbgWord32(srpPageidptr, ZPOS_OVERFLOWREC, RNIL); + srpPageidptr.p->word32[ZPOS_OVERFLOWREC] = RNIL; + fragrecptr.p->nextAllocPage++; + }//for + srReadOverPagesLab(signal); + return; + }//if +}//Dbacc::srReadPagesAllocLab() + +void Dbacc::srReadOverPagesLab(Signal* signal) +{ + if (fragrecptr.p->nextAllocPage >= fragrecptr.p->noOfStoredOverPages) { + fragrecptr.p->nextAllocPage = 0; + if (fragrecptr.p->prevUndoposition == cminusOne) { + jam(); + /* ************************ */ + /* ACC_OVER_REC */ + /* ************************ */ + /*--------------------------------------------------------------------------------*/ + /* UPDATE FREE LIST OF OVERFLOW PAGES AS PART OF SYSTEM RESTART AFTER */ + /* READING PAGES AND EXECUTING THE UNDO LOG. */ + /*--------------------------------------------------------------------------------*/ + signal->theData[0] = fragrecptr.i; + sendSignal(cownBlockref, GSN_ACC_OVER_REC, signal, 1, JBB); + } else { + jam(); + srCloseDataFileLab(signal); + }//if + return; + }//if + Uint32 limitLoop; + if ((fragrecptr.p->noOfStoredOverPages - fragrecptr.p->nextAllocPage) < ZWRITEPAGESIZE) { + jam(); + limitLoop = fragrecptr.p->noOfStoredOverPages - fragrecptr.p->nextAllocPage; + } else { + jam(); + limitLoop = ZWRITEPAGESIZE; + }//if + ndbrequire(limitLoop <= 8); + for (Uint32 i = 0; i < limitLoop; i++) { + jam(); + seizePage(signal); + ndbrequire(tresult <= ZLIMIT_OF_ERROR); + fragrecptr.p->datapages[i] = spPageptr.i; + signal->theData[i + 6] = spPageptr.i; + }//for + fragrecptr.p->noOfExpectedPages = limitLoop; + signal->theData[limitLoop + 6] = fragrecptr.p->activeDataFilePage; + /* -----------------SEND READ PAGES SIGNAL TO THE FILE MANAGER --------- */ + fsConnectptr.i = fragrecptr.p->fsConnPtr; + ptrCheckGuard(fsConnectptr, cfsConnectsize, fsConnectrec); + fsConnectptr.p->fsState = WAIT_READ_DATA; + signal->theData[0] = fsConnectptr.p->fsPtr; + signal->theData[1] = cownBlockref; + signal->theData[2] = fsConnectptr.i; + signal->theData[3] = 2; + signal->theData[4] = ZPAGE8_BASE_ADD; + signal->theData[5] = fragrecptr.p->noOfExpectedPages; + sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 15, JBA); + return; +}//Dbacc::srReadOverPagesLab() + +void Dbacc::srCloseDataFileLab(Signal* signal) +{ + fsConnectptr.i = fragrecptr.p->fsConnPtr; + ptrCheckGuard(fsConnectptr, cfsConnectsize, fsConnectrec); + fsConnectptr.p->fsState = SR_CLOSE_DATA; + /* ************************ */ + /* FSCLOSEREQ */ + /* ************************ */ + signal->theData[0] = fsConnectptr.p->fsPtr; + signal->theData[1] = cownBlockref; + signal->theData[2] = fsConnectptr.i; + signal->theData[3] = 0; + sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA); + return; +}//Dbacc::srCloseDataFileLab() + +/* ************************ */ +/* ACC_SRCONF */ +/* ************************ */ +void Dbacc::sendaccSrconfLab(Signal* signal) +{ + fragrecptr.i = fsConnectptr.p->fragrecPtr; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + releaseFsConnRec(signal); + rootfragrecptr.i = fragrecptr.p->myroot; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + lcpConnectptr.i = rootfragrecptr.p->lcpPtr; + ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec); + fragrecptr.p->fragState = ACTIVEFRAG; + fragrecptr.p->fsConnPtr = RNIL; + for (Uint32 i = 0; i < ZWRITEPAGESIZE; i++) { + fragrecptr.p->datapages[i] = RNIL; + }//for + rlpPageptr.i = fragrecptr.p->zeroPagePtr; + ptrCheckGuard(rlpPageptr, cpagesize, page8); + releaseLcpPage(signal); + fragrecptr.p->zeroPagePtr = RNIL; + signal->theData[0] = fragrecptr.p->lcpLqhPtr; + sendSignal(lcpConnectptr.p->lcpUserblockref, GSN_ACC_SRCONF, signal, 1, JBB); + lcpConnectptr.p->noOfLcpConf++; + if (lcpConnectptr.p->noOfLcpConf == 2) { + jam(); + releaseLcpConnectRec(signal); + rootfragrecptr.p->lcpPtr = RNIL; + rootfragrecptr.p->rootState = ACTIVEROOT; + }//if + return; +}//Dbacc::sendaccSrconfLab() + +/* --------------------------------------------------------------------------------- */ +/* CHECKSUM_CONTROL */ +/* INPUT: CCO_PAGEPTR */ +/* OUTPUT: TRESULT */ +/* */ +/* CHECK THAT CHECKSUM IN PAGE IS CORRECT TO ENSURE THAT NO ONE HAS CORRUPTED */ +/* THE PAGE INFORMATION. WHEN CALCULATING THE CHECKSUM WE REMOVE THE CHECKSUM */ +/* ITSELF FROM THE CHECKSUM BY XOR'ING THE CHECKSUM TWICE. WHEN CALCULATING */ +/* THE CHECKSUM THE CHECKSUM WORD IS ZERO WHICH MEANS NO CHANGE FROM XOR'ING. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::checksumControl(Signal* signal, Uint32 checkPage) +{ + Uint32 Tchs; + Uint32 tccoIndex; + Uint32 Ti; + Uint32 Tmp1; + Uint32 Tmp2; + Uint32 Tmp3; + Uint32 Tmp4; + Uint32 Tlimit; + + Tchs = 0; + for (Ti = 0; Ti < 32 ; Ti++) { + Tlimit = 16 + (Ti << 6); + for (tccoIndex = (Ti << 6); tccoIndex < Tlimit; tccoIndex ++) { + Tmp1 = ccoPageptr.p->word32[tccoIndex]; + Tmp2 = ccoPageptr.p->word32[tccoIndex + 16]; + Tmp3 = ccoPageptr.p->word32[tccoIndex + 32]; + Tmp4 = ccoPageptr.p->word32[tccoIndex + 48]; + + Tchs = Tchs ^ Tmp1; + Tchs = Tchs ^ Tmp2; + Tchs = Tchs ^ Tmp3; + Tchs = Tchs ^ Tmp4; + }//for + }//for + if (Tchs == 0) { + tresult = 0; + if (checkPage != 0) { + jam(); + lcnCopyPageptr.p = ccoPageptr.p; + srCheckPage(signal); + }//if + } else { + tresult = 1; + }//if + if (tresult != 0) { + jam(); + rootfragrecptr.i = fragrecptr.p->myroot; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + signal->theData[0] = RNIL; + signal->theData[1] = rootfragrecptr.p->mytabptr; + signal->theData[2] = fragrecptr.p->myfid; + signal->theData[3] = ccoPageptr.p->word32[ZPOS_PAGE_ID]; + signal->theData[4] = tlupElemIndex; + signal->theData[5] = ccoPageptr.p->word32[ZPOS_PAGE_TYPE]; + signal->theData[6] = tresult; + sendSignal(cownBlockref, GSN_DEBUG_SIG, signal, 7, JBA); + }//if +}//Dbacc::checksumControl() + +/* ******************--------------------------------------------------------------- */ +/* START_RECREQ REQUEST TO START UNDO PROCESS */ +/* SENDER: LQH, LEVEL B */ +/* ENTER START_RECREQ WITH */ +/* CLQH_PTR, LQH CONNECTION PTR */ +/* CLQH_BLOCK_REF, LQH BLOCK REFERENCE */ +/* ******************--------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* START_RECREQ REQUEST TO START UNDO PROCESS */ +/* ******************------------------------------+ */ +/* SENDER: LQH, LEVEL B */ +void Dbacc::execSTART_RECREQ(Signal* signal) +{ + jamEntry(); + clqhPtr = signal->theData[0]; /* LQH CONNECTION PTR */ + clqhBlockRef = signal->theData[1]; /* LQH BLOCK REFERENCE */ + tresult = 0; /* 0= FALSE,1= TRUE,> ZLIMIT_OF_ERROR =ERRORCODE */ + for (int i = 0; i < UndoHeader::ZNO_UNDORECORD_TYPES; i++) + cSrUndoRecords[i] = 0; + startUndoLab(signal); + return; +}//Dbacc::execSTART_RECREQ() + +void Dbacc::startUndoLab(Signal* signal) +{ + cundoLogActive = ZTRUE; + /* ----- OPEN UNDO FILES --------- */ + for (tmp = 0; tmp <= ZMAX_UNDO_VERSION - 1; tmp++) { + jam(); + if (csrVersList[tmp] != RNIL) { + jam(); + /*---------------------------------------------------------------------------*/ + /* SELECT THE NEXT SYSTEM RESTART RECORD WHICH CONTAINS AN UNDO LOG */ + /* THAT NEEDS TO BE EXECUTED AND SET UP THE DATA TO EXECUTE IT. */ + /*---------------------------------------------------------------------------*/ + srVersionPtr.i = csrVersList[tmp]; + csrVersList[tmp] = RNIL; + ptrCheckGuard(srVersionPtr, csrVersionRecSize, srVersionRec); + cactiveUndoFilePage = srVersionPtr.p->prevAddress >> 13; + cprevUndoaddress = srVersionPtr.p->prevAddress; + cactiveCheckpId = srVersionPtr.p->checkPointId; + + releaseSrRec(signal); + startActiveUndo(signal); + return; + }//if + }//for + + // Send report of how many undo log records where executed + signal->theData[0] = EventReport::UNDORecordsExecuted; + signal->theData[1] = DBACC; // From block + signal->theData[2] = 0; // Total records executed + for (int i = 0; i < 10; i++){ + if (i < UndoHeader::ZNO_UNDORECORD_TYPES){ + signal->theData[i+3] = cSrUndoRecords[i]; + signal->theData[2] += cSrUndoRecords[i]; + }else{ + signal->theData[i+3] = 0; + } + } + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 12, JBB); + + /* ******************************< */ + /* START_RECCONF */ + /* ******************************< */ + /*---------------------------------------------------------------------------*/ + /* REPORT COMPLETION OF UNDO LOG EXECUTION. */ + /*---------------------------------------------------------------------------*/ + cundoLogActive = ZFALSE; + signal->theData[0] = clqhPtr; + sendSignal(clqhBlockRef, GSN_START_RECCONF, signal, 1, JBB); + /* LQH CONNECTION PTR */ + return; +}//Dbacc::startUndoLab() + +/*---------------------------------------------------------------------------*/ +/* START THE UNDO OF AN UNDO LOG FILE BY OPENING THE UNDO LOG FILE. */ +/*---------------------------------------------------------------------------*/ +void Dbacc::startActiveUndo(Signal* signal) +{ + if (cprevUndoaddress == cminusOne) { + jam(); + /*---------------------------------------------------------------------------*/ + /* THERE WAS NO UNDO LOG INFORMATION IN THIS LOG FILE. WE GET THE NEXT */ + /* OR REPORT COMPLETION. */ + /*---------------------------------------------------------------------------*/ + signal->theData[0] = ZSTART_UNDO; + sendSignal(cownBlockref, GSN_CONTINUEB, signal, 1, JBB); + } else { + jam(); + /*---------------------------------------------------------------------------*/ + /* OPEN THE LOG FILE PERTAINING TO THIS UNDO LOG. */ + /*---------------------------------------------------------------------------*/ + if (cfsFirstfreeconnect == RNIL) { + jam(); + sendSystemerror(signal); + }//if + seizeFsConnectRec(signal); + cactiveSrFsPtr = fsConnectptr.i; + fsConnectptr.p->fsState = OPEN_UNDO_FILE_SR; + fsConnectptr.p->fsPart = 0; + tmp1 = 1; /* FILE VERSION ? */ + tmp1 = (tmp1 << 8) + ZLOCALLOGFILE; /* .LOCLOG = 2 */ + tmp1 = (tmp1 << 8) + 4; /* ROOT DIRECTORY = D4 */ + tmp1 = (tmp1 << 8) + fsConnectptr.p->fsPart; /* P2 */ + tmp2 = 0x0; /* D7 DON'T CREATE , READ ONLY */ + /* DON'T TRUNCATE TO ZERO */ + /* ---FILE NAME "D4"/"DBACC"/LCP_CONNECTPTR:LOCAL_CHECK_PID/FS_CONNECTPTR:FS_PART".LOCLOG-- */ + /* ************************ */ + /* FSOPENREQ */ + /* ************************ */ + signal->theData[0] = cownBlockref; + signal->theData[1] = fsConnectptr.i; + signal->theData[2] = cminusOne; /* #FFFFFFFF */ + signal->theData[3] = cminusOne; /* #FFFFFFFF */ + signal->theData[4] = cactiveCheckpId; /* CHECKPOINT VERSION */ + signal->theData[5] = tmp1; + signal->theData[6] = tmp2; + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA); + }//if +}//Dbacc::startActiveUndo() + +/* ------- READ A GROUP OF UNDO PAGES --------------- */ +void Dbacc::srStartUndoLab(Signal* signal) +{ + /*---------------------------------------------------------------------------*/ + /* ALL LOG FILES HAVE BEEN OPENED. WE CAN NOW READ DATA FROM THE LAST */ + /* PAGE IN THE LAST LOG FILE AND BACKWARDS UNTIL WE REACH THE VERY */ + /* FIRST UNDO LOG RECORD. */ + /*---------------------------------------------------------------------------*/ + if (cactiveUndoFilePage >= ZWRITE_UNDOPAGESIZE) { + jam(); + tmp1 = ZWRITE_UNDOPAGESIZE; /* NO OF READ UNDO PAGES */ + cactiveSrUndoPage = ZWRITE_UNDOPAGESIZE - 1; /* LAST PAGE */ + } else { + jam(); + tmp1 = cactiveUndoFilePage + 1; /* NO OF READ UNDO PAGES */ + cactiveSrUndoPage = cactiveUndoFilePage; + }//if + fsConnectptr.i = cactiveSrFsPtr; + ptrCheckGuard(fsConnectptr, cfsConnectsize, fsConnectrec); + signal->theData[0] = fsConnectptr.p->fsPtr; + signal->theData[1] = cownBlockref; + signal->theData[2] = fsConnectptr.i; + signal->theData[3] = 0; + /* FLAG = LIST MEM PAGES, LIST FILE PAGES */ + signal->theData[4] = ZUNDOPAGE_BASE_ADD; + signal->theData[5] = tmp1; + signal->theData[6] = 0; + signal->theData[7] = (cactiveUndoFilePage - tmp1) + 1; + signal->theData[8] = 1; + signal->theData[9] = cactiveUndoFilePage; + + sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 10, JBA); + if (tmp1 > cactiveUndoFilePage) { + jam(); + /*---------------------------------------------------------------------------*/ + /* THIS IS THE LAST READ IN THIS LOG FILE. WE SET THE ACTIVE FILE */ + /* POINTER. IF IT IS THE FIRST WE SHOULD NEVER ATTEMPT ANY MORE READS */ + /* SINCE WE SHOULD ENCOUNTER A FIRST LOG RECORD WITH PREVIOUS PAGE ID */ + /* EQUAL TO RNIL. */ + /*---------------------------------------------------------------------------*/ + cactiveSrFsPtr = RNIL; + fsConnectptr.p->fsState = READ_UNDO_PAGE_AND_CLOSE; + } else { + jam(); + /*---------------------------------------------------------------------------*/ + /* WE STILL HAVE MORE INFORMATION IN THIS LOG FILE. WE ONLY MOVE BACK */ + /* THE FILE PAGE. */ + /*---------------------------------------------------------------------------*/ + cactiveUndoFilePage = cactiveUndoFilePage - tmp1; + fsConnectptr.p->fsState = READ_UNDO_PAGE; + }//if + return; +}//Dbacc::srStartUndoLab() + +/* ------- DO UNDO ---------------------------*/ +/* ******************--------------------------------------------------------------- */ +/* NEXTOPERATION ORD FOR EXECUTION OF NEXT OP */ +/* ******************------------------------------+ */ +/* SENDER: ACC, LEVEL B */ +void Dbacc::execNEXTOPERATION(Signal* signal) +{ + jamEntry(); + tresult = 0; + srDoUndoLab(signal); + return; +}//Dbacc::execNEXTOPERATION() + +void Dbacc::srDoUndoLab(Signal* signal) +{ + DirRangePtr souDirRangePtr; + DirectoryarrayPtr souDirptr; + Page8Ptr souPageidptr; + Uint32 tundoPageindex; + UndoHeader *undoHeaderPtr; + Uint32 tmpindex; + + jam(); + undopageptr.i = cactiveSrUndoPage; + ptrCheckGuard(undopageptr, cundopagesize, undopage); + /*---------------------------------------------------------------------------*/ + /* LAYOUT OF AN UNDO LOG RECORD: */ + /* ***************************** */ + /* */ + /* |----------------------------------------------------| */ + /* | TABLE ID | */ + /* |----------------------------------------------------| */ + /* | ROOT FRAGMENT ID | */ + /* |----------------------------------------------------| */ + /* | LOCAL FRAGMENT ID | */ + /* |----------------------------------------------------| */ + /* | UNDO INFO LEN 14 b | TYPE 4 b | PAGE INDEX 14 b | */ + /* |----------------------------------------------------| */ + /* | INDEX INTO PAGE DIRECTORY (LOGICAL PAGE ID) | */ + /* |----------------------------------------------------| */ + /* | PREVIOUS UNDO LOG RECORD FOR THE FRAGMENT | */ + /* |----------------------------------------------------| */ + /* | PREVIOUS UNDO LOG RECORD FOR ALL FRAGMENTS | */ + /* |----------------------------------------------------| */ + /* | TYPE SPECIFIC PART | */ + /* |----------------------------------------------------| */ + /*---------------------------------------------------------------------------*/ + /*---------------------------------------------------------------------------*/ + /* SET THE PAGE POINTER. WE ONLY WORK WITH TWO PAGES IN THIS RESTART */ + /* ACTIVITY. GET THE PAGE POINTER AND THE PAGE INDEX TO READ FROM. */ + /*---------------------------------------------------------------------------*/ + tundoindex = cprevUndoaddress & ZUNDOPAGEINDEX_MASK; //0x1fff, 13 bits. + undoHeaderPtr = (UndoHeader *) &undopageptr.p->undoword[tundoindex]; + tundoindex = tundoindex + ZUNDOHEADSIZE; + + /*------------------------------------------------------------------------*/ + /* READ TABLE ID AND ROOT FRAGMENT ID AND USE THIS TO GET ROOT RECORD. */ + /*------------------------------------------------------------------------*/ + arrGuard((tundoindex + 6), 8192); + + // TABLE ID + tabptr.i = undoHeaderPtr->tableId; + ptrCheckGuard(tabptr, ctablesize, tabrec); + + // ROOT FRAGMENT ID + tfid = undoHeaderPtr->rootFragId; + if (!getrootfragmentrec(signal, rootfragrecptr, tfid)) { + jam(); + /*---------------------------------------------------------------------*/ + /* THE ROOT RECORD WAS NOT FOUND. OBVIOUSLY WE ARE NOT RESTARTING THIS */ + /* FRAGMENT. WE THUS IGNORE THIS LOG RECORD AND PROCEED WITH THE NEXT. */ + /*---------------------------------------------------------------------*/ + creadyUndoaddress = cprevUndoaddress; + // PREVIOUS UNDO LOG RECORD FOR ALL FRAGMENTS + cprevUndoaddress = undoHeaderPtr->prevUndoAddress; + undoNext2Lab(signal); + return; + }//if + /*-----------------------------------------------------------------------*/ + /* READ THE LOCAL FRAGMENT ID AND VERIFY THAT IT IS CORRECT. */ + /*-----------------------------------------------------------------------*/ + if (rootfragrecptr.p->fragmentid[0] == undoHeaderPtr->localFragId) { + jam(); + fragrecptr.i = rootfragrecptr.p->fragmentptr[0]; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + } else { + if (rootfragrecptr.p->fragmentid[1] == undoHeaderPtr->localFragId) { + jam(); + fragrecptr.i = rootfragrecptr.p->fragmentptr[1]; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + } else { + jam(); + progError(__LINE__, 0, "Invalid local fragment id in undo log"); + return; + }//if + }//if + /*------------------------------------------------------------------------*/ + /* READ UNDO INFO LENGTH, TYPE OF LOG RECORD AND PAGE INDEX WHERE TO */ + /* APPLY THIS LOG RECORD. ALSO STEP INDEX TO PREPARE READ OF LOGICAL */ + /* PAGE ID. SET TMPINDEX TO INDEX THE FIRST WORD IN THE TYPE SPECIFIC */ + /* PART. */ + /*------------------------------------------------------------------------*/ + // UNDO INFO LENGTH 14 b | TYPE 4 b | PAGE INDEX 14 b + const Uint32 tmp1 = undoHeaderPtr->variousInfo; + cundoinfolength = tmp1 >> 18; + const Uint32 tpageType = (tmp1 >> 14) & 0xf; + tundoPageindex = tmp1 & 0x3fff; + + // INDEX INTO PAGE DIRECTORY (LOGICAL PAGE ID) + tmpP = undoHeaderPtr->logicalPageId ; + tmpindex = tundoindex; + arrGuard((tmpindex + cundoinfolength - 1), 8192); + if (fragrecptr.p->localCheckpId != cactiveCheckpId) { + jam(); + /*-----------------------------------------------------------------------*/ + /* THE FRAGMENT DID EXIST BUT IS NOT AFFECTED BY THIS UNDO LOG */ + /* EXECUTION. EITHER IT BELONGS TO ANOTHER OR IT IS CREATED AND ONLY IN */ + /* NEED OF EXECUTION OF REDO LOG RECORDS FROM LQH. */ + /*-----------------------------------------------------------------------*/ + creadyUndoaddress = cprevUndoaddress; + // PREVIOUS UNDO LOG RECORD FOR ALL FRAGMENTS + cprevUndoaddress = undoHeaderPtr->prevUndoAddress; + + undoNext2Lab(signal); + return; + }//if + /*-----------------------------------------------------------------------*/ + /* VERIFY CONSISTENCY OF UNDO LOG RECORDS. */ + /*-----------------------------------------------------------------------*/ + ndbrequire(fragrecptr.p->prevUndoposition == cprevUndoaddress); + cSrUndoRecords[tpageType]++; + switch(tpageType){ + + case UndoHeader::ZPAGE_INFO:{ + jam(); + /*----------------------------------------------------------------------*/ + /* WE HAVE TO UNDO UPDATES IN A NORMAL PAGE. GET THE PAGE POINTER BY */ + /* USING THE LOGICAL PAGE ID. THEN RESET THE OLD VALUE IN THE PAGE BY */ + /* USING THE OLD DATA WHICH IS STORED IN THIS UNDO LOG RECORD. */ + /*----------------------------------------------------------------------*/ + souDirRangePtr.i = fragrecptr.p->directory; + tmpP2 = tmpP >> 8; + tmpP = tmpP & 0xff; + ptrCheckGuard(souDirRangePtr, cdirrangesize, dirRange); + arrGuard(tmpP2, 256); + souDirptr.i = souDirRangePtr.p->dirArray[tmpP2]; + ptrCheckGuard(souDirptr, cdirarraysize, directoryarray); + souPageidptr.i = souDirptr.p->pagep[tmpP]; + ptrCheckGuard(souPageidptr, cpagesize, page8); + Uint32 loopLimit = tundoPageindex + cundoinfolength; + ndbrequire(loopLimit <= 2048); + for (Uint32 tmp = tundoPageindex; tmp < loopLimit; tmp++) { + dbgWord32(souPageidptr, tmp, undopageptr.p->undoword[tmpindex]); + souPageidptr.p->word32[tmp] = undopageptr.p->undoword[tmpindex]; + tmpindex = tmpindex + 1; + }//for + break; + } + + case UndoHeader::ZOVER_PAGE_INFO:{ + jam(); + /*----------------------------------------------------------------------*/ + /* WE HAVE TO UNDO UPDATES IN AN OVERFLOW PAGE. GET THE PAGE POINTER BY*/ + /* USING THE LOGICAL PAGE ID. THEN RESET THE OLD VALUE IN THE PAGE BY */ + /* USING THE OLD DATA WHICH IS STORED IN THIS UNDO LOG RECORD. */ + /*----------------------------------------------------------------------*/ + souDirRangePtr.i = fragrecptr.p->overflowdir; + tmpP2 = tmpP >> 8; + tmpP = tmpP & 0xff; + ptrCheckGuard(souDirRangePtr, cdirrangesize, dirRange); + arrGuard(tmpP2, 256); + souDirptr.i = souDirRangePtr.p->dirArray[tmpP2]; + ptrCheckGuard(souDirptr, cdirarraysize, directoryarray); + souPageidptr.i = souDirptr.p->pagep[tmpP]; + ptrCheckGuard(souPageidptr, cpagesize, page8); + Uint32 loopLimit = tundoPageindex + cundoinfolength; + ndbrequire(loopLimit <= 2048); + for (Uint32 tmp = tundoPageindex; tmp < loopLimit; tmp++) { + dbgWord32(souPageidptr, tmp, undopageptr.p->undoword[tmpindex]); + souPageidptr.p->word32[tmp] = undopageptr.p->undoword[tmpindex]; + tmpindex = tmpindex + 1; + }//for + break; + } + + case UndoHeader::ZUNDO_INSERT_LONG_KEY:{ + jam(); + /*---------------------------------------------------------------------*/ + /* WE WILL UNDO AN INSERT OF A LONG KEY. THIS IS PERFORMED BY DELETING */ + /* THE LONG KEY. */ + /*---------------------------------------------------------------------*/ + souDirRangePtr.i = fragrecptr.p->overflowdir; + tmpP2 = tmpP >> 8; + tmpP = tmpP & 0xff; + arrGuard(tmpP2, 256); + ptrCheckGuard(souDirRangePtr, cdirrangesize, dirRange); + souDirptr.i = souDirRangePtr.p->dirArray[tmpP2]; + ptrCheckGuard(souDirptr, cdirarraysize, directoryarray); + dlkPageptr.i = souDirptr.p->pagep[tmpP]; + ptrCheckGuard(dlkPageptr, cpagesize, page8); + tdlkLogicalPageIndex = tundoPageindex; + deleteLongKey(signal); + break; + } + + case UndoHeader::ZUNDO_DELETE_LONG_KEY: { + jam(); + /*----------------------------------------------------------------------*/ + /* WE WILL UNDO DELETE OF A LONG KEY. THIS IS PERFORMED BY INSERTING */ + /* IT AGAIN. */ + /*----------------------------------------------------------------------*/ + souDirRangePtr.i = fragrecptr.p->overflowdir; + taslpDirIndex = tmpP; + tmpP2 = tmpP >> 8; + tmpP = tmpP & 0xff; + ptrCheckGuard(souDirRangePtr, cdirrangesize, dirRange); + arrGuard(tmpP2, 256); + souDirptr.i = souDirRangePtr.p->dirArray[tmpP2]; + + if(souDirptr.i == RNIL) { + //---------------------------------------------------------------- + // Allocate a directory. + //---------------------------------------------------------------- + jam(); + seizeDirectory(signal); + if (tresult > ZLIMIT_OF_ERROR) { + jam(); + sendSystemerror(signal); + return; + } + souDirRangePtr.p->dirArray[tmpP2] = sdDirptr.i; + souDirptr.i = souDirRangePtr.p->dirArray[tmpP2]; + } + + ptrCheckGuard(souDirptr, cdirarraysize, directoryarray); + slkapPageptr.i = souDirptr.p->pagep[tmpP]; + + if(slkapPageptr.i == RNIL) { + //---------------------------------------------------------------- + // The delete operation was probably the last on the page and the + // page was released and not written down to disk. We need to + // allocate a page and put it in the same dirindex as it was in + // before it was released. + // This is because an eventual UNDO_INSERT on the same key in the + // same LCP must be able to find the key and it has only the + // dirindex to go on, the key itself is not saved on disk in a + // UNDO_INSERT. + //---------------------------------------------------------------- + jam(); + allocSpecificLongOverflowPage(signal); + slkapPageptr.i = aslpPageptr.i; + } + + ptrCheckGuard(slkapPageptr, cpagesize, page8); + seizePage(signal); + ndbrequire(tresult <= ZLIMIT_OF_ERROR); + + slkapCopyPageptr = spPageptr; + ndbrequire(cundoinfolength <= 2048); + + for (Uint32 tmp = 0; tmp < cundoinfolength; tmp++) { + dbgWord32(slkapCopyPageptr, tmp, undopageptr.p->undoword[tmpindex]); + slkapCopyPageptr.p->word32[tmp] = undopageptr.p->undoword[tmpindex]; + tmpindex = tmpindex + 1; + }//for + jam(); + //---------------------------------------------------------------- + // We must store the key at the same place it was deleted from. + // This is because an eventual UNDO_INSERT on the same key in the + // same LCP must be able to find the key and it has only the index + // information stored on disk to go on, the key itself is not + // saved on disk in an UNDO_INSERT. + //---------------------------------------------------------------- + tslkapKeyLen = cundoinfolength; + tslkapPageIndex = tundoPageindex; + storeLongKeysAtPos(signal); + + rpPageptr = slkapCopyPageptr; + releasePage(signal); + break; + } + + case UndoHeader::ZOP_INFO: { + jam(); + /*---------------------------------------------------------------------*/ + /* AN OPERATION WAS ACTIVE WHEN LOCAL CHECKPOINT WAS EXECUTED. WE NEED */ + /* TO RESET THE LOCKS IT HAS SET. IF THE OPERATION WAS AN INSERT OR */ + /* THE ELEMENT WAS MARKED AS DISSAPEARED IT WILL ALSO BE REMOVED */ + /* FROM THE PAGE */ + /* */ + /* BEGIN BY SEARCHING AFTER THE ELEMENT, WHEN FOUND UNDO THE */ + /* CHANGES ON THE ELEMENT HEADER. IF IT WAS AN INSERT OPERATION OR */ + /* MARKED AS DISSAPEARED PROCEED BY REMOVING THE ELEMENT. */ + /*---------------------------------------------------------------------*/ + seizeOpRec(signal); + // Initialise the opRec + operationRecPtr.p->transId1 = 0; + operationRecPtr.p->transId2 = RNIL; + operationRecPtr.p->transactionstate = ACTIVE; + operationRecPtr.p->commitDeleteCheckFlag = ZFALSE; + operationRecPtr.p->lockMode = 0; + operationRecPtr.p->dirtyRead = 0; + operationRecPtr.p->nodeType = 0; + operationRecPtr.p->fid = fragrecptr.p->myfid; + operationRecPtr.p->nextParallelQue = RNIL; + operationRecPtr.p->prevParallelQue = RNIL; + operationRecPtr.p->nextQueOp = RNIL; + operationRecPtr.p->prevQueOp = RNIL; + operationRecPtr.p->nextSerialQue = RNIL; + operationRecPtr.p->prevSerialQue = RNIL; + operationRecPtr.p->elementPage = RNIL; + operationRecPtr.p->keyinfoPage = RNIL; + operationRecPtr.p->insertIsDone = ZFALSE; + operationRecPtr.p->lockOwner = ZFALSE; + operationRecPtr.p->elementIsDisappeared = ZFALSE; + operationRecPtr.p->insertDeleteLen = fragrecptr.p->elementLength; + operationRecPtr.p->longPagePtr = RNIL; + operationRecPtr.p->longKeyPageIndex = RNIL; + operationRecPtr.p->scanRecPtr = RNIL; + operationRecPtr.p->isAccLockReq = ZFALSE; + + // Read operation values from undo page + operationRecPtr.p->operation = undopageptr.p->undoword[tmpindex]; + tmpindex++; + operationRecPtr.p->hashValue = undopageptr.p->undoword[tmpindex]; + tmpindex++; + const Uint32 tkeylen = undopageptr.p->undoword[tmpindex]; + tmpindex++; + operationRecPtr.p->tupkeylen = tkeylen; + operationRecPtr.p->fragptr = fragrecptr.i; + + ndbrequire((fragrecptr.p->keyLength == 0) || + ((fragrecptr.p->keyLength != 0) && + (fragrecptr.p->keyLength == tkeylen))); + + // Read keydata from undo page + for (Uint32 tmp = 0; tmp < tkeylen; tmp++) { + signal->theData[7+tmp] = undopageptr.p->undoword[tmpindex]; + tmpindex = tmpindex + 1; + }//for + arrGuard((tmpindex - 1), 8192); + getElement(signal); + if (tgeResult != ZTRUE) { + jam(); + signal->theData[0] = RNIL; + signal->theData[1] = tabptr.i; + signal->theData[2] = cactiveCheckpId; + signal->theData[3] = cprevUndoaddress; + signal->theData[4] = operationRecPtr.p->operation; + signal->theData[5] = operationRecPtr.p->hashValue; + signal->theData[6] = operationRecPtr.p->tupkeylen; + sendSignal(cownBlockref, GSN_DEBUG_SIG, signal, 11, JBA); + return; + }//if + + operationRecPtr.p->elementPage = gePageptr.i; + operationRecPtr.p->elementContainer = tgeContainerptr; + operationRecPtr.p->elementPointer = tgeElementptr; + operationRecPtr.p->elementIsforward = tgeForward; + + commitdelete(signal, true); + releaseOpRec(signal); + break; + } + + default: + jam(); + progError(__LINE__, 0, "Invalid pagetype in undo log"); + break; + + }//switch(tpageType) + + /*----------------------------------------------------------------------*/ + /* READ THE PAGE ID AND THE PAGE INDEX OF THE PREVIOUS UNDO LOG RECORD */ + /* FOR THIS FRAGMENT. */ + /*----------------------------------------------------------------------*/ + fragrecptr.p->prevUndoposition = undoHeaderPtr->prevUndoAddressForThisFrag; + /*----------------------------------------------------------------------*/ + /* READ THE PAGE ID AND THE PAGE INDEX OF THE PREVIOUS UNDO LOG RECORD */ + /* FOR THIS UNDO LOG. */ + /*----------------------------------------------------------------------*/ + creadyUndoaddress = cprevUndoaddress; + cprevUndoaddress = undoHeaderPtr->prevUndoAddress; + + if (fragrecptr.p->prevUndoposition == cminusOne) { + jam(); + /*---------------------------------------------------------------------*/ + /* WE HAVE NOW EXECUTED ALL UNDO LOG RECORDS FOR THIS FRAGMENT. WE */ + /* NOW NEED TO UPDATE THE FREE LIST OF OVERFLOW PAGES. */ + /*---------------------------------------------------------------------*/ + ndbrequire(fragrecptr.p->nextAllocPage == 0); + + signal->theData[0] = fragrecptr.i; + sendSignal(cownBlockref, GSN_ACC_OVER_REC, signal, 1, JBB); + return; + }//if + undoNext2Lab(signal); + return; +}//Dbacc::srDoUndoLab() + +void Dbacc::undoNext2Lab(Signal* signal) +{ + /*---------------------------------------------------------------------------*/ + /* EXECUTE NEXT UNDO LOG RECORD. */ + /*---------------------------------------------------------------------------*/ + if (cprevUndoaddress == cminusOne) { + jam(); + /*---------------------------------------------------------------------------*/ + /* WE HAVE EXECUTED THIS UNDO LOG TO COMPLETION. IT IS NOW TIME TO TAKE*/ + /* OF THE NEXT UNDO LOG OR REPORT COMPLETION OF UNDO LOG EXECUTION. */ + /*---------------------------------------------------------------------------*/ + signal->theData[0] = ZSTART_UNDO; + sendSignal(cownBlockref, GSN_CONTINUEB, signal, 1, JBB); + return; + }//if + if ((creadyUndoaddress >> 13) != (cprevUndoaddress >> 13)) { + /*---------------------------------------------------------------------------*/ + /* WE ARE CHANGING PAGE. */ + /*---------------------------------------------------------------------------*/ + if (cactiveSrUndoPage == 0) { + jam(); + /*---------------------------------------------------------------------------*/ + /* WE HAVE READ AND EXECUTED ALL UNDO LOG INFORMATION IN THE CURRENTLY */ + /* READ PAGES. WE STILL HAVE MORE INFORMATION TO READ FROM FILE SINCE */ + /* WE HAVEN'T FOUND THE FIRST LOG RECORD IN THE LOG FILE YET. */ + /*---------------------------------------------------------------------------*/ + srStartUndoLab(signal); + return; + } else { + jam(); + /*---------------------------------------------------------------------------*/ + /* WE HAVE ANOTHER PAGE READ THAT WE NEED TO EXECUTE. */ + /*---------------------------------------------------------------------------*/ + cactiveSrUndoPage = cactiveSrUndoPage - 1; + }//if + }//if + /*---------------------------------------------------------------------------*/ + /* REAL-TIME BREAK */ + /*---------------------------------------------------------------------------*/ + /* ******************************< */ + /* NEXTOPERATION */ + /* ******************************< */ + sendSignal(cownBlockref, GSN_NEXTOPERATION, signal, 1, JBB); + return; +}//Dbacc::undoNext2Lab() + +/*-----------------------------------------------------------------------------------*/ +/* AFTER COMPLETING THE READING OF DATA PAGES FROM DISK AND EXECUTING THE UNDO */ +/* LOG WE ARE READY TO UPDATE THE FREE LIST OF OVERFLOW PAGES. THIS LIST MUST */ +/* BE BUILT AGAIN SINCE IT IS NOT CHECKPOINTED. WHEN THE PAGES ARE ALLOCATED */ +/* THEY ARE NOT PART OF ANY LIST. PAGES CAN EITHER BE PUT IN FREE LIST, NOT */ +/* IN FREE LIST OR BE PUT INTO LIST OF LONG KEY PAGES. */ +/*-----------------------------------------------------------------------------------*/ +void Dbacc::execACC_OVER_REC(Signal* signal) +{ + DirRangePtr pnoDirRangePtr; + DirectoryarrayPtr pnoOverflowDirptr; + Page8Ptr pnoPageidptr; + Uint32 tpnoPageType; + Uint32 toverPageCheck; + + jamEntry(); + fragrecptr.i = signal->theData[0]; + toverPageCheck = 0; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + ndbrequire((fragrecptr.p->nextAllocPage != 0) || + (fragrecptr.p->firstOverflowRec == RNIL)); + /*-----------------------------------------------------------------------------------*/ + /* WHO HAS PUT SOMETHING INTO THE LIST BEFORE WE EVEN STARTED PUTTING THINGS */ + /* THERE. */ + /*-----------------------------------------------------------------------------------*/ + ndbrequire(fragrecptr.p->loadingFlag == ZTRUE); + /*---------------------------------------------------------------------------*/ + /* LOADING HAS STOPPED BEFORE WE HAVE LOADED, SYSTEM ERROR. */ + /*---------------------------------------------------------------------------*/ + while (toverPageCheck < ZNO_OF_OP_PER_SIGNAL) { + jam(); + if (fragrecptr.p->nextAllocPage >= fragrecptr.p->lastOverIndex) { + jam(); + fragrecptr.p->loadingFlag = ZFALSE; + rootfragrecptr.i = fragrecptr.p->myroot; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + if (rootfragrecptr.p->lcpPtr != RNIL) { + jam(); + srCloseDataFileLab(signal); + } else { + jam(); + undoNext2Lab(signal); + }//if + return; + }//if + tmpP = fragrecptr.p->nextAllocPage; + pnoDirRangePtr.i = fragrecptr.p->overflowdir; + tmpP2 = tmpP >> 8; + tmpP = tmpP & 0xff; + arrGuard(tmpP2, 256); + ptrCheckGuard(pnoDirRangePtr, cdirrangesize, dirRange); + if (pnoDirRangePtr.p->dirArray[tmpP2] == RNIL) { + jam(); + pnoPageidptr.i = RNIL; + } else { + pnoOverflowDirptr.i = pnoDirRangePtr.p->dirArray[tmpP2]; + if (pnoOverflowDirptr.i == RNIL) { + jam(); + pnoPageidptr.i = RNIL; + } else { + jam(); + ptrCheckGuard(pnoOverflowDirptr, cdirarraysize, directoryarray); + pnoPageidptr.i = pnoOverflowDirptr.p->pagep[tmpP]; + }//if + }//if + if (pnoPageidptr.i == RNIL) { + jam(); + seizeOverRec(signal); + sorOverflowRecPtr.p->dirindex = fragrecptr.p->nextAllocPage; + sorOverflowRecPtr.p->overpage = RNIL; + priOverflowRecPtr = sorOverflowRecPtr; + putRecInFreeOverdir(signal); + } else { + ptrCheckGuard(pnoPageidptr, cpagesize, page8); + tpnoPageType = pnoPageidptr.p->word32[ZPOS_PAGE_TYPE]; + tpnoPageType = (tpnoPageType >> ZPOS_PAGE_TYPE_BIT) & 3; + if (tpnoPageType == ZLONG_PAGE_TYPE) { + jam(); + // This is to clean the list parameters. + pnoPageidptr.p->word32[ZPOS_PREV_PAGE] = RNIL; + pnoPageidptr.p->word32[ZPOS_NEXT_PAGE] = RNIL; + if (pnoPageidptr.p->word32[ZPOS_ARRAY_POS] != 4) { + jam(); + /*---------------------------------------------------------------------------*/ + /* THE PAGE WAS A LONG PAGE AND IT BELONGED TO A FREE LIST. PUT IT INTO ONE */ + /* OF THE FREE LIST THEN. */ + /*---------------------------------------------------------------------------*/ + // Insert page! + ipaPagePtr = pnoPageidptr; + tipaArrayPos = pnoPageidptr.p->word32[ZPOS_ARRAY_POS]; + insertPageArrayList(signal); + }//if + } else { + if (pnoPageidptr.p->word32[ZPOS_ALLOC_CONTAINERS] > ZFREE_LIMIT) { + jam(); + dbgWord32(pnoPageidptr, ZPOS_OVERFLOWREC, RNIL); + pnoPageidptr.p->word32[ZPOS_OVERFLOWREC] = RNIL; + ndbrequire(pnoPageidptr.p->word32[ZPOS_PAGE_ID] == fragrecptr.p->nextAllocPage); + } else { + jam(); + seizeOverRec(signal); + sorOverflowRecPtr.p->dirindex = pnoPageidptr.p->word32[ZPOS_PAGE_ID]; + ndbrequire(sorOverflowRecPtr.p->dirindex == fragrecptr.p->nextAllocPage); + dbgWord32(pnoPageidptr, ZPOS_OVERFLOWREC, sorOverflowRecPtr.i); + pnoPageidptr.p->word32[ZPOS_OVERFLOWREC] = sorOverflowRecPtr.i; + sorOverflowRecPtr.p->overpage = pnoPageidptr.i; + porOverflowRecPtr = sorOverflowRecPtr; + putOverflowRecInFrag(signal); + if (pnoPageidptr.p->word32[ZPOS_ALLOC_CONTAINERS] == 0) { + jam(); + ropPageptr = pnoPageidptr; + releaseOverpage(signal); + }//if + }//if + }//if + }//if + fragrecptr.p->nextAllocPage++; + toverPageCheck++; + }//while + signal->theData[0] = fragrecptr.i; + sendSignal(cownBlockref, GSN_ACC_OVER_REC, signal, 1, JBB); +}//Dbacc::execACC_OVER_REC() + +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* END OF SYSTEM RESTART MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* SCAN MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* ACC_SCANREQ START OF A SCAN PROCESS */ +/* SENDER: LQH, LEVEL B */ +/* ENTER ACC_SCANREQ WITH */ +/* TUSERPTR, LQH SCAN_CONNECT POINTER */ +/* TUSERBLOCKREF, LQH BLOCK REFERENCE */ +/* TABPTR, TABLE IDENTITY AND PTR */ +/* TFID ROOT FRAGMENT IDENTITY */ +/* TSCAN_FLAG , = ZCOPY, ZSCAN, ZSCAN_LOCK_ALL */ +/* ZREADLOCK, ZWRITELOCK */ +/* TSCAN_TRID1 , TRANSACTION ID PART 1 */ +/* TSCAN_TRID2 TRANSACTION ID PART 2 */ +/* ******************--------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* ACC_SCANREQ START OF A SCAN PROCESS */ +/* ******************------------------------------+ */ +/* SENDER: LQH, LEVEL B */ +void Dbacc::execACC_SCANREQ(Signal* signal) +{ + jamEntry(); + AccScanReq * req = (AccScanReq*)&signal->theData[0]; + tuserptr = req->senderData; + tuserblockref = req->senderRef; + tabptr.i = req->tableId; + tfid = req->fragmentNo; + tscanFlag = req->requestInfo; + tscanTrid1 = req->transId1; + tscanTrid2 = req->transId2; + + tresult = 0; + ptrCheckGuard(tabptr, ctablesize, tabrec); + ndbrequire(getrootfragmentrec(signal,rootfragrecptr, tfid)); + + Uint32 i; + for (i = 0; i < MAX_PARALLEL_SCANS_PER_FRAG; i++) { + jam(); + if (rootfragrecptr.p->scan[i] == RNIL) { + jam(); + break; + } + } + ndbrequire(i != MAX_PARALLEL_SCANS_PER_FRAG); + ndbrequire(cfirstFreeScanRec != RNIL); + seizeScanRec(signal); + + rootfragrecptr.p->scan[i] = scanPtr.i; + scanPtr.p->scanBucketState = ScanRec::FIRST_LAP; + scanPtr.p->scanLockMode = AccScanReq::getLockMode(tscanFlag); + scanPtr.p->scanKeyinfoFlag = AccScanReq::getKeyinfoFlag(tscanFlag); + scanPtr.p->scanReadCommittedFlag = AccScanReq::getReadCommittedFlag(tscanFlag); + + /* TWELVE BITS OF THE ELEMENT HEAD ARE SCAN */ + /* CHECK BITS. THE MASK NOTES WHICH BIT IS */ + /* ALLOCATED FOR THE ACTIVE SCAN */ + scanPtr.p->scanMask = 1 << i; + scanPtr.p->scanUserptr = tuserptr; + scanPtr.p->scanUserblockref = tuserblockref; + scanPtr.p->scanTrid1 = tscanTrid1; + scanPtr.p->scanTrid2 = tscanTrid2; + scanPtr.p->rootPtr = rootfragrecptr.i; + scanPtr.p->scanLockHeld = 0; + scanPtr.p->scanOpsAllocated = 0; + scanPtr.p->scanFirstActiveOp = RNIL; + scanPtr.p->scanFirstQueuedOp = RNIL; + scanPtr.p->scanLastQueuedOp = RNIL; + scanPtr.p->scanFirstLockedOp = RNIL; + scanPtr.p->scanLastLockedOp = RNIL; + scanPtr.p->scanState = ScanRec::WAIT_NEXT; + fragrecptr.i = rootfragrecptr.p->fragmentptr[0]; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + initScanFragmentPart(signal); + + /*------------------------------------------------------*/ + /* We start the timeout loop for the scan process here. */ + /*------------------------------------------------------*/ + ndbrequire(scanPtr.p->scanTimer == 0); + if (scanPtr.p->scanContinuebCounter == 0) { + jam(); + scanPtr.p->scanContinuebCounter = 1; + signal->theData[0] = ZSEND_SCAN_HBREP; + signal->theData[1] = scanPtr.i; + sendSignalWithDelay(cownBlockref, GSN_CONTINUEB, signal, 100, 2); + }//if + scanPtr.p->scanTimer = scanPtr.p->scanContinuebCounter; + /* ************************ */ + /* ACC_SCANCONF */ + /* ************************ */ + signal->theData[0] = scanPtr.p->scanUserptr; + signal->theData[1] = scanPtr.i; + signal->theData[2] = 2; + /* NR OF LOCAL FRAGMENT */ + signal->theData[3] = rootfragrecptr.p->fragmentid[0]; + signal->theData[4] = rootfragrecptr.p->fragmentid[1]; + signal->theData[7] = AccScanConf::ZNOT_EMPTY_FRAGMENT; + sendSignal(scanPtr.p->scanUserblockref, GSN_ACC_SCANCONF, signal, 8, JBB); + /* NOT EMPTY FRAGMENT */ + return; +}//Dbacc::execACC_SCANREQ() + +/* ******************--------------------------------------------------------------- */ +/* NEXT_SCANREQ REQUEST FOR NEXT ELEMENT OF */ +/* ******************------------------------------+ A FRAGMENT. */ +/* SENDER: LQH, LEVEL B */ +void Dbacc::execNEXT_SCANREQ(Signal* signal) +{ + Uint32 tscanNextFlag; + jamEntry(); + scanPtr.i = signal->theData[0]; + operationRecPtr.i = signal->theData[1]; + tscanNextFlag = signal->theData[2]; + /* ------------------------------------------ */ + /* 1 = ZCOPY_NEXT GET NEXT ELEMENT */ + /* 2 = ZCOPY_NEXT_COMMIT COMMIT THE */ + /* ACTIVE ELEMENT AND GET THE NEXT ONE */ + /* 3 = ZCOPY_COMMIT COMMIT THE ACTIVE ELEMENT */ + /* 4 = ZCOPY_REPEAT GET THE ACTIVE ELEMENT */ + /* 5 = ZCOPY_ABORT RELOCK THE ACTIVE ELEMENT */ + /* 6 = ZCOPY_CLOSE THE SCAN PROCESS IS READY */ + /* ------------------------------------------ */ + tresult = 0; + ptrCheckGuard(scanPtr, cscanRecSize, scanRec); + ndbrequire(scanPtr.p->scanState == ScanRec::WAIT_NEXT); + + scanPtr.p->scanTimer = scanPtr.p->scanContinuebCounter; + switch (tscanNextFlag) { + case ZCOPY_NEXT: + jam(); + /*empty*/; + break; + case ZCOPY_NEXT_COMMIT: + case ZCOPY_COMMIT: + jam(); + /* --------------------------------------------------------------------------------- */ + /* COMMIT ACTIVE OPERATION. SEND NEXT SCAN ELEMENT IF IT IS ZCOPY_NEXT_COMMIT. */ + /* --------------------------------------------------------------------------------- */ + ptrCheckGuard(operationRecPtr, coprecsize, operationrec); + fragrecptr.i = operationRecPtr.p->fragptr; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + if (!scanPtr.p->scanReadCommittedFlag) { + if (fragrecptr.p->createLcp == ZTRUE) { + if (remainingUndoPages() < ZMIN_UNDO_PAGES_AT_COMMIT) { + jam(); + /*--------------------------------------------------------------*/ + // We did not have enough undo log buffers to safely commit an + // operation. Try again in 10 milliseconds. + /*--------------------------------------------------------------*/ + sendSignalWithDelay(cownBlockref, GSN_NEXT_SCANREQ, signal, 10, 3); + return; + }//if + }//if + commitOperation(signal); + }//if + takeOutActiveScanOp(signal); + releaseOpRec(signal); + scanPtr.p->scanOpsAllocated--; + if (tscanNextFlag == ZCOPY_COMMIT) { + jam(); + signal->theData[0] = scanPtr.p->scanUserptr; + Uint32 blockNo = refToBlock(scanPtr.p->scanUserblockref); + EXECUTE_DIRECT(blockNo, GSN_NEXT_SCANCONF, signal, 1); + return; + }//if + break; + case ZCOPY_CLOSE: + jam(); + fragrecptr.i = scanPtr.p->activeLocalFrag; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + if (!scanPtr.p->scanReadCommittedFlag) { + if (fragrecptr.p->createLcp == ZTRUE) { + if (remainingUndoPages() < ZMIN_UNDO_PAGES_AT_OPERATION) { + jam(); + /*--------------------------------------------------------------*/ + // We did not have enough undo log buffers to commit a set of + // operations. Try again in 10 milliseconds. + /*--------------------------------------------------------------*/ + sendSignalWithDelay(cownBlockref, GSN_NEXT_SCANREQ, signal, 10, 3); + return; + }//if + }//if + }//if + /* --------------------------------------------------------------------------------- */ + /* THE SCAN PROCESS IS FINISHED. RELOCK ALL LOCKED EL. RELESE ALL INVOLVED REC. */ + /* --------------------------------------------------------------------------------- */ + releaseScanLab(signal); + return; + break; + default: + ndbrequire(false); + break; + }//switch + signal->theData[0] = scanPtr.i; + signal->theData[1] = AccCheckScan::ZNOT_CHECK_LCP_STOP; + execACC_CHECK_SCAN(signal); + return; +}//Dbacc::execNEXT_SCANREQ() + +void Dbacc::checkNextBucketLab(Signal* signal) +{ + DirRangePtr cscDirRangePtr; + DirectoryarrayPtr cscDirptr; + DirectoryarrayPtr tnsDirptr; + Page8Ptr nsPageptr; + Page8Ptr cscPageidptr; + Page8Ptr gnsPageidptr; + Page8Ptr tnsPageidptr; + Uint32 tnsElementptr; + Uint32 tnsContainerptr; + Uint32 tnsIsLocked; + Uint32 tnsTmp1; + Uint32 tnsTmp2; + Uint32 tnsCopyIndex1; + Uint32 tnsCopyIndex2; + Uint32 tnsCopyDir; + + tnsCopyDir = scanPtr.p->nextBucketIndex >> fragrecptr.p->k; + tnsCopyIndex1 = tnsCopyDir >> 8; + tnsCopyIndex2 = tnsCopyDir & 0xff; + arrGuard(tnsCopyIndex1, 256); + tnsDirptr.i = gnsDirRangePtr.p->dirArray[tnsCopyIndex1]; + ptrCheckGuard(tnsDirptr, cdirarraysize, directoryarray); + tnsPageidptr.i = tnsDirptr.p->pagep[tnsCopyIndex2]; + ptrCheckGuard(tnsPageidptr, cpagesize, page8); + gnsPageidptr.i = tnsPageidptr.i; + gnsPageidptr.p = tnsPageidptr.p; + tnsTmp1 = (1 << fragrecptr.p->k) - 1; + tgsePageindex = scanPtr.p->nextBucketIndex & tnsTmp1; + gsePageidptr.i = gnsPageidptr.i; + gsePageidptr.p = gnsPageidptr.p; + if (!getScanElement(signal)) { + scanPtr.p->nextBucketIndex++; + if (scanPtr.p->scanBucketState == ScanRec::SECOND_LAP) { + if (scanPtr.p->nextBucketIndex > scanPtr.p->maxBucketIndexToRescan) { + /* --------------------------------------------------------------------------------- */ + // We have finished the rescan phase. We are ready to proceed with the next fragment part. + /* --------------------------------------------------------------------------------- */ + jam(); + checkNextFragmentLab(signal); + return; + }//if + } else if (scanPtr.p->scanBucketState == ScanRec::FIRST_LAP) { + if ((fragrecptr.p->p + fragrecptr.p->maxp) < scanPtr.p->nextBucketIndex) { + /* --------------------------------------------------------------------------------- */ + // All buckets have been scanned a first time. + /* --------------------------------------------------------------------------------- */ + if (scanPtr.p->minBucketIndexToRescan == 0xFFFFFFFF) { + jam(); + /* --------------------------------------------------------------------------------- */ + // We have not had any merges behind the scan. Thus it is not necessary to perform + // any rescan any buckets and we can proceed immediately with the next fragment part. + /* --------------------------------------------------------------------------------- */ + checkNextFragmentLab(signal); + return; + } else { + jam(); + /* --------------------------------------------------------------------------------- */ + // Some buckets are in the need of rescanning due to merges that have moved records + // from in front of the scan to behind the scan. During the merges we kept track of + // which buckets that need a rescan. We start with the minimum and end with maximum. + /* --------------------------------------------------------------------------------- */ + scanPtr.p->nextBucketIndex = scanPtr.p->minBucketIndexToRescan; + scanPtr.p->scanBucketState = ScanRec::SECOND_LAP; + if (scanPtr.p->maxBucketIndexToRescan > (fragrecptr.p->p + fragrecptr.p->maxp)) { + jam(); + /* --------------------------------------------------------------------------------- */ + // If we have had so many merges that the maximum is bigger than the number of buckets + // then we will simply satisfy ourselves with scanning to the end. This can only happen + // after bringing down the total of buckets to less than half and the minimum should + // be 0 otherwise there is some problem. + /* --------------------------------------------------------------------------------- */ + if (scanPtr.p->minBucketIndexToRescan != 0) { + jam(); + sendSystemerror(signal); + return; + }//if + scanPtr.p->maxBucketIndexToRescan = fragrecptr.p->p + fragrecptr.p->maxp; + }//if + }//if + }//if + }//if + if ((scanPtr.p->scanBucketState == ScanRec::FIRST_LAP) && + (scanPtr.p->nextBucketIndex <= scanPtr.p->startNoOfBuckets)) { + /* --------------------------------------------------------------------------------- */ + // We will only reset the scan indicator on the buckets that existed at the start of the + // scan. The others will be handled by the split and merge code. + /* --------------------------------------------------------------------------------- */ + tnsTmp2 = (1 << fragrecptr.p->k) - 1; + trsbPageindex = scanPtr.p->nextBucketIndex & tnsTmp2; + if (trsbPageindex != 0) { + jam(); + rsbPageidptr.i = gnsPageidptr.i; + rsbPageidptr.p = gnsPageidptr.p; + } else { + jam(); + cscDirRangePtr.i = fragrecptr.p->directory; + tmpP = scanPtr.p->nextBucketIndex >> fragrecptr.p->k; + tmpP2 = tmpP >> 8; + tmpP = tmpP & 0xff; + ptrCheckGuard(cscDirRangePtr, cdirrangesize, dirRange); + arrGuard(tmpP2, 256); + cscDirptr.i = cscDirRangePtr.p->dirArray[tmpP2]; + ptrCheckGuard(cscDirptr, cdirarraysize, directoryarray); + cscPageidptr.i = cscDirptr.p->pagep[tmpP]; + ptrCheckGuard(cscPageidptr, cpagesize, page8); + tmp1 = (1 << fragrecptr.p->k) - 1; + trsbPageindex = scanPtr.p->nextBucketIndex & tmp1; + rsbPageidptr.i = cscPageidptr.i; + rsbPageidptr.p = cscPageidptr.p; + }//if + releaseScanBucket(signal); + }//if + signal->theData[0] = scanPtr.i; + signal->theData[1] = AccCheckScan::ZCHECK_LCP_STOP; + sendSignal(cownBlockref, GSN_ACC_CHECK_SCAN, signal, 2, JBB); + return; + }//if + /* ----------------------------------------------------------------------- */ + /* AN ELEMENT WHICH HAVE NOT BEEN SCANNED WAS FOUND. WE WILL PREPARE IT */ + /* TO BE SENT TO THE LQH BLOCK FOR FURTHER PROCESSING. */ + /* WE ASSUME THERE ARE OPERATION RECORDS AVAILABLE SINCE LQH SHOULD HAVE*/ + /* GUARANTEED THAT THROUGH EARLY BOOKING. */ + /* ----------------------------------------------------------------------- */ + tnsIsLocked = tgseIsLocked; + tnsElementptr = tgseElementptr; + tnsContainerptr = tgseContainerptr; + nsPageptr.i = gsePageidptr.i; + nsPageptr.p = gsePageidptr.p; + seizeOpRec(signal); + tisoIsforward = tgseIsforward; + tisoContainerptr = tnsContainerptr; + tisoElementptr = tnsElementptr; + isoPageptr.i = nsPageptr.i; + isoPageptr.p = nsPageptr.p; + initScanOpRec(signal); + + if (!tnsIsLocked){ + if (!scanPtr.p->scanReadCommittedFlag) { + jam(); + slPageidptr = nsPageptr; + tslElementptr = tnsElementptr; + setlock(signal); + insertLockOwnersList(signal, operationRecPtr); + }//if + } else { + arrGuard(tnsElementptr, 2048); + queOperPtr.i = + ElementHeader::getOpPtrI(nsPageptr.p->word32[tnsElementptr]); + ptrCheckGuard(queOperPtr, coprecsize, operationrec); + if (queOperPtr.p->elementIsDisappeared == ZTRUE) { + jam(); + /* --------------------------------------------------------------------------------- */ + // If the lock owner indicates the element is disappeared then we will not report this + // tuple. We will continue with the next tuple. + /* --------------------------------------------------------------------------------- */ + releaseOpRec(signal); + scanPtr.p->scanOpsAllocated--; + signal->theData[0] = scanPtr.i; + signal->theData[1] = AccCheckScan::ZCHECK_LCP_STOP; + sendSignal(cownBlockref, GSN_ACC_CHECK_SCAN, signal, 2, JBB); + return; + }//if + if (!scanPtr.p->scanReadCommittedFlag) { + Uint32 return_result; + if (scanPtr.p->scanLockMode == ZREADLOCK) { + jam(); + priPageptr = nsPageptr; + tpriElementptr = tnsElementptr; + return_result = placeReadInLockQueue(signal); + } else { + jam(); + pwiPageptr = nsPageptr; + tpwiElementptr = tnsElementptr; + return_result = placeWriteInLockQueue(signal); + }//if + if (return_result == ZSERIAL_QUEUE) { + /* --------------------------------------------------------------------------------- */ + /* WE PLACED THE OPERATION INTO A SERIAL QUEUE AND THUS WE HAVE TO WAIT FOR */ + /* THE LOCK TO BE RELEASED. WE CONTINUE WITH THE NEXT ELEMENT. */ + /* --------------------------------------------------------------------------------- */ + putOpScanLockQue(); /* PUT THE OP IN A QUE IN THE SCAN REC */ + signal->theData[0] = scanPtr.i; + signal->theData[1] = AccCheckScan::ZCHECK_LCP_STOP; + sendSignal(cownBlockref, GSN_ACC_CHECK_SCAN, signal, 2, JBB); + return; + } else if (return_result == ZWRITE_ERROR) { + jam(); + /* --------------------------------------------------------------------------------- */ + // The tuple is either not committed yet or a delete in the same transaction (not + // possible here since we are a scan). Thus we simply continue with the next tuple. + /* --------------------------------------------------------------------------------- */ + releaseOpRec(signal); + scanPtr.p->scanOpsAllocated--; + signal->theData[0] = scanPtr.i; + signal->theData[1] = AccCheckScan::ZCHECK_LCP_STOP; + sendSignal(cownBlockref, GSN_ACC_CHECK_SCAN, signal, 2, JBB); + return; + }//if + ndbassert(return_result == ZPARALLEL_QUEUE); + }//if + }//if + /* --------------------------------------------------------------------------------- */ + // Committed read proceed without caring for locks immediately down here except when + // the tuple was deleted permanently and no new operation has inserted it again. + /* --------------------------------------------------------------------------------- */ + putActiveScanOp(signal); + sendNextScanConf(signal); + return; +}//Dbacc::checkNextBucketLab() + + +void Dbacc::checkNextFragmentLab(Signal* signal) +{ + RootfragmentrecPtr cnfRootfragrecptr; + + cnfRootfragrecptr.i = fragrecptr.p->myroot; + ptrCheckGuard(cnfRootfragrecptr, crootfragmentsize, rootfragmentrec); + if (scanPtr.p->activeLocalFrag == cnfRootfragrecptr.p->fragmentptr[0]) { + jam(); + fragrecptr.i = cnfRootfragrecptr.p->fragmentptr[1]; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + initScanFragmentPart(signal); + signal->theData[0] = scanPtr.i; + signal->theData[1] = AccCheckScan::ZCHECK_LCP_STOP; + sendSignal(cownBlockref, GSN_ACC_CHECK_SCAN, signal, 2, JBB); + return; + } else { + if (scanPtr.p->activeLocalFrag == cnfRootfragrecptr.p->fragmentptr[1]) { + jam(); + /* --------------------------------------------------------------------------------- */ + // Both fragments have completed their scan part and we can indicate that the scan is + // now completed. + /* --------------------------------------------------------------------------------- */ + scanPtr.p->scanBucketState = ScanRec::SCAN_COMPLETED; + /*empty*/; + } else { + jam(); + /* ALL ELEMENTS ARE SENT */ + sendSystemerror(signal); + }//if + }//if + /* --------------------------------------------------------------------------------- */ + // The scan is completed. ACC_CHECK_SCAN will perform all the necessary checks to see + // what the next step is. + /* --------------------------------------------------------------------------------- */ + signal->theData[0] = scanPtr.i; + signal->theData[1] = AccCheckScan::ZCHECK_LCP_STOP; + execACC_CHECK_SCAN(signal); + return; +}//Dbacc::checkNextFragmentLab() + +void Dbacc::initScanFragmentPart(Signal* signal) +{ + DirRangePtr cnfDirRangePtr; + DirectoryarrayPtr cnfDirptr; + Page8Ptr cnfPageidptr; + /* --------------------------------------------------------------------------------- */ + // Set the active fragment part. + // Set the current bucket scanned to the first. + // Start with the first lap. + // Remember the number of buckets at start of the scan. + // Set the minimum and maximum to values that will always be smaller and larger than. + // Reset the scan indicator on the first bucket. + /* --------------------------------------------------------------------------------- */ + scanPtr.p->activeLocalFrag = fragrecptr.i; + scanPtr.p->nextBucketIndex = 0; /* INDEX OF SCAN BUCKET */ + scanPtr.p->scanBucketState = ScanRec::FIRST_LAP; + scanPtr.p->startNoOfBuckets = fragrecptr.p->p + fragrecptr.p->maxp; + scanPtr.p->minBucketIndexToRescan = 0xFFFFFFFF; + scanPtr.p->maxBucketIndexToRescan = 0; + cnfDirRangePtr.i = fragrecptr.p->directory; + ptrCheckGuard(cnfDirRangePtr, cdirrangesize, dirRange); + cnfDirptr.i = cnfDirRangePtr.p->dirArray[0]; + ptrCheckGuard(cnfDirptr, cdirarraysize, directoryarray); + cnfPageidptr.i = cnfDirptr.p->pagep[0]; + ptrCheckGuard(cnfPageidptr, cpagesize, page8); + trsbPageindex = scanPtr.p->nextBucketIndex & ((1 << fragrecptr.p->k) - 1); + rsbPageidptr.i = cnfPageidptr.i; + rsbPageidptr.p = cnfPageidptr.p; + releaseScanBucket(signal); +}//Dbacc::initScanFragmentPart() + +/* --------------------------------------------------------------------------------- */ +/* FLAG = 6 = ZCOPY_CLOSE THE SCAN PROCESS IS READY OR ABORTED. ALL OPERATION IN THE */ +/* ACTIVE OR WAIT QUEUE ARE RELEASED, SCAN FLAG OF ROOT FRAG IS RESET AND THE SCAN */ +/* RECORD IS RELEASED. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseScanLab(Signal* signal) +{ + releaseAndCommitActiveOps(signal); + releaseAndCommitQueuedOps(signal); + releaseAndAbortLockedOps(signal); + + rootfragrecptr.i = scanPtr.p->rootPtr; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + for (tmp = 0; tmp < MAX_PARALLEL_SCANS_PER_FRAG; tmp++) { + jam(); + if (rootfragrecptr.p->scan[tmp] == scanPtr.i) { + jam(); + rootfragrecptr.p->scan[tmp] = RNIL; + }//if + }//for + // Stops the heartbeat. + scanPtr.p->scanTimer = 0; + signal->theData[0] = scanPtr.p->scanUserptr; + signal->theData[1] = RNIL; + signal->theData[2] = RNIL; + sendSignal(scanPtr.p->scanUserblockref, GSN_NEXT_SCANCONF, signal, 3, JBB); + releaseScanRec(signal); + return; +}//Dbacc::releaseScanLab() + + +void Dbacc::releaseAndCommitActiveOps(Signal* signal) +{ + OperationrecPtr trsoOperPtr; + operationRecPtr.i = scanPtr.p->scanFirstActiveOp; + while (operationRecPtr.i != RNIL) { + jam(); + ptrCheckGuard(operationRecPtr, coprecsize, operationrec); + trsoOperPtr.i = operationRecPtr.p->nextOp; + fragrecptr.i = operationRecPtr.p->fragptr; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + if (!scanPtr.p->scanReadCommittedFlag) { + jam(); + commitOperation(signal); + }//if + takeOutActiveScanOp(signal); + releaseOpRec(signal); + scanPtr.p->scanOpsAllocated--; + operationRecPtr.i = trsoOperPtr.i; + }//if +}//Dbacc::releaseAndCommitActiveOps() + + +void Dbacc::releaseAndCommitQueuedOps(Signal* signal) +{ + OperationrecPtr trsoOperPtr; + operationRecPtr.i = scanPtr.p->scanFirstQueuedOp; + while (operationRecPtr.i != RNIL) { + jam(); + ptrCheckGuard(operationRecPtr, coprecsize, operationrec); + trsoOperPtr.i = operationRecPtr.p->nextOp; + fragrecptr.i = operationRecPtr.p->fragptr; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + if (!scanPtr.p->scanReadCommittedFlag) { + jam(); + commitOperation(signal); + }//if + takeOutReadyScanQueue(signal); + releaseOpRec(signal); + scanPtr.p->scanOpsAllocated--; + operationRecPtr.i = trsoOperPtr.i; + }//if +}//Dbacc::releaseAndCommitQueuedOps() + +void Dbacc::releaseAndAbortLockedOps(Signal* signal) { + + OperationrecPtr trsoOperPtr; + operationRecPtr.i = scanPtr.p->scanFirstLockedOp; + while (operationRecPtr.i != RNIL) { + jam(); + ptrCheckGuard(operationRecPtr, coprecsize, operationrec); + trsoOperPtr.i = operationRecPtr.p->nextOp; + fragrecptr.i = operationRecPtr.p->fragptr; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + if (!scanPtr.p->scanReadCommittedFlag) { + jam(); + abortOperation(signal); + }//if + takeOutScanLockQueue(scanPtr.i); + releaseOpRec(signal); + scanPtr.p->scanOpsAllocated--; + operationRecPtr.i = trsoOperPtr.i; + }//if +}//Dbacc::releaseAndAbortLockedOps() + +/* 3.18.3 ACC_CHECK_SCAN */ +/* ******************--------------------------------------------------------------- */ +/* ACC_CHECK_SCAN */ +/* ENTER ACC_CHECK_SCAN WITH */ +/* SCAN_PTR */ +/* ******************--------------------------------------------------------------- */ +/* ******************--------------------------------------------------------------- */ +/* ACC_CHECK_SCAN */ +/* ******************------------------------------+ */ +void Dbacc::execACC_CHECK_SCAN(Signal* signal) +{ + Uint32 TcheckLcpStop; + jamEntry(); + scanPtr.i = signal->theData[0]; + TcheckLcpStop = signal->theData[1]; + ptrCheckGuard(scanPtr, cscanRecSize, scanRec); + while (scanPtr.p->scanFirstQueuedOp != RNIL) { + jam(); + //---------------------------------------------------------------------------- + // An operation has been released from the lock queue. We are in the parallel + // queue of this tuple. We are ready to report the tuple now. + //---------------------------------------------------------------------------- + operationRecPtr.i = scanPtr.p->scanFirstQueuedOp; + ptrCheckGuard(operationRecPtr, coprecsize, operationrec); + takeOutReadyScanQueue(signal); + if (operationRecPtr.p->elementIsDisappeared == ZTRUE) { + jam(); + fragrecptr.i = operationRecPtr.p->fragptr; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + if (fragrecptr.p->createLcp == ZTRUE) { + if (remainingUndoPages() < ZMIN_UNDO_PAGES_AT_COMMIT) { + jam(); + /*--------------------------------------------------------------*/ + // We did not have enough undo log buffers to safely abort an + // operation. Try again in 10 milliseconds. + /*--------------------------------------------------------------*/ + sendSignalWithDelay(cownBlockref, GSN_ACC_CHECK_SCAN, signal, 10, 2); + return; + }//if + }//if + abortOperation(signal); + releaseOpRec(signal); + scanPtr.p->scanOpsAllocated--; + continue; + }//if + putActiveScanOp(signal); + sendNextScanConf(signal); + return; + }//while + + + if ((scanPtr.p->scanBucketState == ScanRec::SCAN_COMPLETED) && + (scanPtr.p->scanLockHeld == 0)) { + jam(); + //---------------------------------------------------------------------------- + // The scan is now completed and there are no more locks outstanding. Thus we + // we will report the scan as completed to LQH. + //---------------------------------------------------------------------------- + signal->theData[0] = scanPtr.p->scanUserptr; + signal->theData[1] = RNIL; + signal->theData[2] = RNIL; + sendSignal(scanPtr.p->scanUserblockref, GSN_NEXT_SCANCONF, signal, 3, JBB); + return; + }//if + if (TcheckLcpStop == AccCheckScan::ZCHECK_LCP_STOP) { + //--------------------------------------------------------------------------- + // To ensure that the block of the fragment occurring at the start of a local + // checkpoint is not held for too long we insert a release and reacquiring of + // that lock here. This is performed in LQH. If we are blocked or if we have + // requested a sleep then we will receive RNIL in the returning signal word. + //--------------------------------------------------------------------------- + signal->theData[0] = scanPtr.p->scanUserptr; + signal->theData[1] = + ((scanPtr.p->scanLockHeld >= ZSCAN_MAX_LOCK) || + (scanPtr.p->scanBucketState == ScanRec::SCAN_COMPLETED)); + EXECUTE_DIRECT(DBLQH, GSN_CHECK_LCP_STOP, signal, 2); + jamEntry(); + if (signal->theData[0] == RNIL) { + jam(); + return; + }//if + }//if + /** + * If we have more than max locks held OR + * scan is completed AND at least one lock held + * - Inform LQH about this condition + */ + if ((scanPtr.p->scanLockHeld >= ZSCAN_MAX_LOCK) || + (cfreeopRec == RNIL) || + ((scanPtr.p->scanBucketState == ScanRec::SCAN_COMPLETED) && + (scanPtr.p->scanLockHeld > 0))) { + jam(); + signal->theData[0] = scanPtr.p->scanUserptr; + signal->theData[1] = RNIL; // No operation is returned + signal->theData[2] = 512; // MASV + sendSignal(scanPtr.p->scanUserblockref, GSN_NEXT_SCANCONF, signal, 3, JBB); + return; + } + if (scanPtr.p->scanBucketState == ScanRec::SCAN_COMPLETED) { + jam(); + signal->theData[0] = scanPtr.i; + signal->theData[1] = AccCheckScan::ZCHECK_LCP_STOP; + execACC_CHECK_SCAN(signal); + return; + }//if + + scanPtr.p->scanTimer = scanPtr.p->scanContinuebCounter; + + fragrecptr.i = scanPtr.p->activeLocalFrag; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + gnsDirRangePtr.i = fragrecptr.p->directory; + ptrCheckGuard(gnsDirRangePtr, cdirrangesize, dirRange); + checkNextBucketLab(signal); + return; +}//Dbacc::execACC_CHECK_SCAN() + +/* ******************---------------------------------------------------- */ +/* ACC_TO_REQ PERFORM A TAKE OVER */ +/* ******************-------------------+ */ +/* SENDER: LQH, LEVEL B */ +void Dbacc::execACC_TO_REQ(Signal* signal) +{ + OperationrecPtr tatrOpPtr; + + jamEntry(); + tatrOpPtr.i = signal->theData[1]; /* OPER PTR OF ACC */ + ptrCheckGuard(tatrOpPtr, coprecsize, operationrec); + if (tatrOpPtr.p->operation == ZSCAN_OP) { + tatrOpPtr.p->transId1 = signal->theData[2]; + tatrOpPtr.p->transId2 = signal->theData[3]; + } else { + jam(); + signal->theData[0] = cminusOne; + signal->theData[1] = ZTO_OP_STATE_ERROR; + }//if + return; +}//Dbacc::execACC_TO_REQ() + +/* --------------------------------------------------------------------------------- */ +/* CONTAINERINFO */ +/* INPUT: */ +/* CI_PAGEIDPTR (PAGE POINTER WHERE CONTAINER RESIDES) */ +/* TCI_PAGEINDEX (INDEX OF CONTAINER, USED TO CALCULATE PAGE INDEX) */ +/* TCI_ISFORWARD (DIRECTION OF CONTAINER FORWARD OR BACKWARD) */ +/* */ +/* OUTPUT: */ +/* TCI_CONTAINERPTR (A POINTER TO THE HEAD OF THE CONTAINER) */ +/* TCI_CONTAINERLEN (LENGTH OF THE CONTAINER */ +/* TCI_CONTAINERHEAD (THE HEADER OF THE CONTAINER) */ +/* */ +/* DESCRIPTION: THE ADDRESS OF THE CONTAINER WILL BE CALCULATED AND */ +/* ALL INFORMATION ABOUT THE CONTAINER WILL BE READ */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::containerinfo(Signal* signal) +{ + tciContainerptr = (tciPageindex << ZSHIFT_PLUS) - (tciPageindex << ZSHIFT_MINUS); + if (tciIsforward == ZTRUE) { + jam(); + tciContainerptr = tciContainerptr + ZHEAD_SIZE; + } else { + jam(); + tciContainerptr = ((tciContainerptr + ZHEAD_SIZE) + ZBUF_SIZE) - ZCON_HEAD_SIZE; + }//if + arrGuard(tciContainerptr, 2048); + tciContainerhead = ciPageidptr.p->word32[tciContainerptr]; + tciContainerlen = tciContainerhead >> 26; +}//Dbacc::containerinfo() + +/* --------------------------------------------------------------------------------- */ +/* GET_SCAN_ELEMENT */ +/* INPUT: GSE_PAGEIDPTR */ +/* TGSE_PAGEINDEX */ +/* OUTPUT: TGSE_IS_LOCKED (IF TRESULT /= ZFALSE) */ +/* GSE_PAGEIDPTR */ +/* TGSE_PAGEINDEX */ +/* --------------------------------------------------------------------------------- */ +bool Dbacc::getScanElement(Signal* signal) +{ + tgseIsforward = ZTRUE; + NEXTSEARCH_SCAN_LOOP: + ciPageidptr.i = gsePageidptr.i; + ciPageidptr.p = gsePageidptr.p; + tciPageindex = tgsePageindex; + tciIsforward = tgseIsforward; + containerinfo(signal); + sscPageidptr.i = gsePageidptr.i; + sscPageidptr.p = gsePageidptr.p; + tsscContainerlen = tciContainerlen; + tsscContainerptr = tciContainerptr; + tsscIsforward = tciIsforward; + if (searchScanContainer(signal)) { + jam(); + tgseIsLocked = tsscIsLocked; + tgseElementptr = tsscElementptr; + tgseContainerptr = tsscContainerptr; + return true; + }//if + if (((tciContainerhead >> 7) & 0x3) != 0) { + jam(); + nciPageidptr.i = gsePageidptr.i; + nciPageidptr.p = gsePageidptr.p; + tnciContainerhead = tciContainerhead; + tnciContainerptr = tciContainerptr; + nextcontainerinfo(signal); + tgsePageindex = tnciPageindex; + gsePageidptr.i = nciPageidptr.i; + gsePageidptr.p = nciPageidptr.p; + tgseIsforward = tnciIsforward; + goto NEXTSEARCH_SCAN_LOOP; + }//if + return false; +}//Dbacc::getScanElement() + +/* --------------------------------------------------------------------------------- */ +/* INIT_SCAN_OP_REC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initScanOpRec(Signal* signal) +{ + Uint32 tisoTmp; + Uint32 tisoLocalPtr; + Uint32 guard24; + Uint32 tisoPageIndex; + Uint32 tisoPagedir; + DirRangePtr tisoOverflowrangeptr; + DirectoryarrayPtr tisoOverflowDirptr; + Page8Ptr tisoPageptr; + + scanPtr.p->scanOpsAllocated++; + + operationRecPtr.p->scanRecPtr = scanPtr.i; + operationRecPtr.p->operation = ZSCAN_OP; + operationRecPtr.p->transactionstate = ACTIVE; + operationRecPtr.p->commitDeleteCheckFlag = ZFALSE; + operationRecPtr.p->lockMode = scanPtr.p->scanLockMode; + operationRecPtr.p->fid = fragrecptr.p->myfid; + operationRecPtr.p->fragptr = fragrecptr.i; + operationRecPtr.p->elementIsDisappeared = ZFALSE; + operationRecPtr.p->nextParallelQue = RNIL; + operationRecPtr.p->prevParallelQue = RNIL; + operationRecPtr.p->nextSerialQue = RNIL; + operationRecPtr.p->prevSerialQue = RNIL; + operationRecPtr.p->prevQueOp = RNIL; + operationRecPtr.p->nextQueOp = RNIL; + operationRecPtr.p->keyinfoPage = RNIL; // Safety precaution + operationRecPtr.p->transId1 = scanPtr.p->scanTrid1; + operationRecPtr.p->transId2 = scanPtr.p->scanTrid2; + operationRecPtr.p->lockOwner = ZFALSE; + operationRecPtr.p->dirtyRead = 0; + operationRecPtr.p->nodeType = 0; // Not a stand-by node + operationRecPtr.p->elementIsforward = tisoIsforward; + operationRecPtr.p->elementContainer = tisoContainerptr; + operationRecPtr.p->elementPointer = tisoElementptr; + operationRecPtr.p->elementPage = isoPageptr.i; + operationRecPtr.p->isAccLockReq = ZFALSE; + tisoLocalPtr = tisoElementptr + tisoIsforward; + guard24 = fragrecptr.p->localkeylen - 1; + for (tisoTmp = 0; tisoTmp <= guard24; tisoTmp++) { + arrGuard(tisoTmp, 2); + arrGuard(tisoLocalPtr, 2048); + operationRecPtr.p->localdata[tisoTmp] = isoPageptr.p->word32[tisoLocalPtr]; + tisoLocalPtr = tisoLocalPtr + tisoIsforward; + }//for + arrGuard(tisoLocalPtr, 2048); + operationRecPtr.p->keydata[0] = isoPageptr.p->word32[tisoLocalPtr]; + if (fragrecptr.p->keyLength != 0) { + jam(); + operationRecPtr.p->tupkeylen = fragrecptr.p->keyLength; + guard24 = fragrecptr.p->keyLength - 1; + for (tisoTmp = 0; tisoTmp <= guard24; tisoTmp++) { + arrGuard(tisoTmp, 8); + arrGuard(tisoLocalPtr, 2048); + operationRecPtr.p->keydata[tisoTmp] = isoPageptr.p->word32[tisoLocalPtr]; + tisoLocalPtr = tisoLocalPtr + tisoIsforward; + }//for + } else { + // Long key handling. Put the long key reference in the operation records. + tisoPageIndex = operationRecPtr.p->keydata[0] & 0x3ff; + arrGuard(ZWORDS_IN_PAGE - tisoPageIndex, 2048); + + tisoPagedir = operationRecPtr.p->keydata[0] >> 10; + arrGuard((tisoPagedir >> 8), 256); + + tisoOverflowrangeptr.i = fragrecptr.p->overflowdir; + ptrCheckGuard(tisoOverflowrangeptr, cdirrangesize, dirRange); + + tisoOverflowDirptr.i = tisoOverflowrangeptr.p->dirArray[tisoPagedir >> 8]; + ptrCheckGuard(tisoOverflowDirptr, cdirarraysize, directoryarray); + + tisoPageptr.i = tisoOverflowDirptr.p->pagep[tisoPagedir & 0xff]; + ptrCheckGuard(tisoPageptr, cpagesize, page8); + + operationRecPtr.p->longPagePtr = tisoPageptr.i; + operationRecPtr.p->longKeyPageIndex = tisoPageIndex; + + // Read length of key from page + Uint32 tmp = tisoPageptr.p->word32[ZWORDS_IN_PAGE - tisoPageIndex]; + operationRecPtr.p->tupkeylen = tmp >> 16; + } +}//Dbacc::initScanOpRec() + +/* --------------------------------------------------------------------------------- */ +/* NEXTCONTAINERINFO */ +/* DESCRIPTION:THE CONTAINER HEAD WILL BE CHECKED TO CALCULATE INFORMATION */ +/* ABOUT NEXT CONTAINER IN THE BUCKET. */ +/* INPUT: TNCI_CONTAINERHEAD */ +/* NCI_PAGEIDPTR */ +/* TNCI_CONTAINERPTR */ +/* OUTPUT: */ +/* TNCI_PAGEINDEX (INDEX FROM WHICH PAGE INDEX CAN BE CALCULATED). */ +/* TNCI_ISFORWARD (IS THE NEXT CONTAINER FORWARD (+1) OR BACKWARD (-1) */ +/* NCI_PAGEIDPTR (PAGE REFERENCE OF NEXT CONTAINER) */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::nextcontainerinfo(Signal* signal) +{ + tnciNextSamePage = (tnciContainerhead >> 9) & 0x1; /* CHECK BIT FOR CHECKING WHERE */ + /* THE NEXT CONTAINER IS IN THE SAME PAGE */ + tnciPageindex = tnciContainerhead & 0x7f; /* NEXT CONTAINER PAGE INDEX 7 BITS */ + if (((tnciContainerhead >> 7) & 3) == ZLEFT) { + jam(); + tnciIsforward = ZTRUE; + } else { + jam(); + tnciIsforward = cminusOne; + }//if + if (tnciNextSamePage == ZFALSE) { + jam(); + /* NEXT CONTAINER IS IN AN OVERFLOW PAGE */ + arrGuard(tnciContainerptr + 1, 2048); + tnciTmp = nciPageidptr.p->word32[tnciContainerptr + 1]; + nciOverflowrangeptr.i = fragrecptr.p->overflowdir; + ptrCheckGuard(nciOverflowrangeptr, cdirrangesize, dirRange); + arrGuard((tnciTmp >> 8), 256); + nciOverflowDirptr.i = nciOverflowrangeptr.p->dirArray[tnciTmp >> 8]; + ptrCheckGuard(nciOverflowDirptr, cdirarraysize, directoryarray); + nciPageidptr.i = nciOverflowDirptr.p->pagep[tnciTmp & 0xff]; + ptrCheckGuard(nciPageidptr, cpagesize, page8); + }//if +}//Dbacc::nextcontainerinfo() + +/* --------------------------------------------------------------------------------- */ +/* PUT_ACTIVE_SCAN_OP */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::putActiveScanOp(Signal* signal) +{ + OperationrecPtr pasOperationRecPtr; + pasOperationRecPtr.i = scanPtr.p->scanFirstActiveOp; + if (pasOperationRecPtr.i != RNIL) { + jam(); + ptrCheckGuard(pasOperationRecPtr, coprecsize, operationrec); + pasOperationRecPtr.p->prevOp = operationRecPtr.i; + }//if + operationRecPtr.p->nextOp = pasOperationRecPtr.i; + operationRecPtr.p->prevOp = RNIL; + scanPtr.p->scanFirstActiveOp = operationRecPtr.i; +}//Dbacc::putActiveScanOp() + +/** + * putOpScanLockQueue + * + * Description: Put an operation in the doubly linked + * lock list on a scan record. The list is used to + * keep track of which operations belonging + * to the scan are put in serial lock list of another + * operation + * + * @note Use takeOutScanLockQueue to remove an operation + * from the list + * + */ +void Dbacc::putOpScanLockQue() +{ + +#ifdef VM_TRACE + // DEBUG CODE + // Check that there are as many operations in the lockqueue as + // scanLockHeld indicates + OperationrecPtr tmpOp; + int numLockedOpsBefore = 0; + tmpOp.i = scanPtr.p->scanFirstLockedOp; + while(tmpOp.i != RNIL){ + numLockedOpsBefore++; + ptrCheckGuard(tmpOp, coprecsize, operationrec); + if (tmpOp.p->nextOp == RNIL) + ndbrequire(tmpOp.i == scanPtr.p->scanLastLockedOp); + tmpOp.i = tmpOp.p->nextOp; + } + ndbrequire(numLockedOpsBefore==scanPtr.p->scanLockHeld); +#endif + + OperationrecPtr pslOperationRecPtr; + ScanRec theScanRec; + theScanRec = *scanPtr.p; + + pslOperationRecPtr.i = scanPtr.p->scanLastLockedOp; + operationRecPtr.p->prevOp = pslOperationRecPtr.i; + operationRecPtr.p->nextOp = RNIL; + if (pslOperationRecPtr.i != RNIL) { + jam(); + ptrCheckGuard(pslOperationRecPtr, coprecsize, operationrec); + pslOperationRecPtr.p->nextOp = operationRecPtr.i; + } else { + jam(); + scanPtr.p->scanFirstLockedOp = operationRecPtr.i; + }//if + scanPtr.p->scanLastLockedOp = operationRecPtr.i; + scanPtr.p->scanLockHeld++; + +}//Dbacc::putOpScanLockQue() + +/* --------------------------------------------------------------------------------- */ +/* PUT_READY_SCAN_QUEUE */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::putReadyScanQueue(Signal* signal, Uint32 scanRecIndex) +{ + OperationrecPtr prsOperationRecPtr; + ScanRecPtr TscanPtr; + + TscanPtr.i = scanRecIndex; + ptrCheckGuard(TscanPtr, cscanRecSize, scanRec); + + prsOperationRecPtr.i = TscanPtr.p->scanLastQueuedOp; + operationRecPtr.p->prevOp = prsOperationRecPtr.i; + operationRecPtr.p->nextOp = RNIL; + TscanPtr.p->scanLastQueuedOp = operationRecPtr.i; + if (prsOperationRecPtr.i != RNIL) { + jam(); + ptrCheckGuard(prsOperationRecPtr, coprecsize, operationrec); + prsOperationRecPtr.p->nextOp = operationRecPtr.i; + } else { + jam(); + TscanPtr.p->scanFirstQueuedOp = operationRecPtr.i; + }//if +}//Dbacc::putReadyScanQueue() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_SCAN_BUCKET */ +// Input: +// rsbPageidptr.i Index to page where buckets starts +// rsbPageidptr.p Pointer to page where bucket starts +// trsbPageindex Page index of starting container in bucket +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseScanBucket(Signal* signal) +{ + Uint32 trsbIsforward; + + trsbIsforward = ZTRUE; + NEXTRELEASESCANLOOP: + ciPageidptr.i = rsbPageidptr.i; + ciPageidptr.p = rsbPageidptr.p; + tciPageindex = trsbPageindex; + tciIsforward = trsbIsforward; + containerinfo(signal); + rscPageidptr.i = rsbPageidptr.i; + rscPageidptr.p = rsbPageidptr.p; + trscContainerlen = tciContainerlen; + trscContainerptr = tciContainerptr; + trscIsforward = trsbIsforward; + releaseScanContainer(signal); + if (((tciContainerhead >> 7) & 0x3) != 0) { + jam(); + nciPageidptr.i = rsbPageidptr.i; + nciPageidptr.p = rsbPageidptr.p; + tnciContainerhead = tciContainerhead; + tnciContainerptr = tciContainerptr; + nextcontainerinfo(signal); + rsbPageidptr.i = nciPageidptr.i; + rsbPageidptr.p = nciPageidptr.p; + trsbPageindex = tnciPageindex; + trsbIsforward = tnciIsforward; + goto NEXTRELEASESCANLOOP; + }//if +}//Dbacc::releaseScanBucket() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_SCAN_CONTAINER */ +/* INPUT: TRSC_CONTAINERLEN */ +/* RSC_PAGEIDPTR */ +/* TRSC_CONTAINERPTR */ +/* TRSC_ISFORWARD */ +/* SCAN_PTR */ +/* */ +/* DESCRIPTION: SEARCHS IN A CONTAINER, AND THE SCAN BIT OF THE ELEMENTS */ +/* OF THE CONTAINER IS RESET */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseScanContainer(Signal* signal) +{ + OperationrecPtr rscOperPtr; + Uint32 trscElemStep; + Uint32 trscElementptr; + Uint32 trscElemlens; + Uint32 trscElemlen; + + if (trscContainerlen < 5) { + if (trscContainerlen != ZCON_HEAD_SIZE) { + jam(); + sendSystemerror(signal); + }//if + return; /* 3 IS THE MINIMUM SIZE OF THE ELEMENT */ + }//if + trscElemlens = trscContainerlen - 2; + if (fragrecptr.p->keyLength != 0) { + jam(); + trscElemlen = (1 + fragrecptr.p->keyLength) + fragrecptr.p->localkeylen; /* LENGTH OF THE ELEMENT */ + } else { + jam(); + trscElemlen = (1 + ZACTIVE_LONG_KEY_LEN) + fragrecptr.p->localkeylen; /* LENGTH OF THE ELEMENT */ + }//if + if (trscIsforward == 1) { + jam(); + trscElementptr = trscContainerptr + ZCON_HEAD_SIZE; + trscElemStep = trscElemlen; + } else { + jam(); + trscElementptr = trscContainerptr - 1; + trscElemStep = 0 - trscElemlen; + }//if + do { + arrGuard(trscElementptr, 2048); + const Uint32 eh = rscPageidptr.p->word32[trscElementptr]; + const Uint32 scanMask = scanPtr.p->scanMask; + if (ElementHeader::getUnlocked(eh)) { + jam(); + const Uint32 tmp = ElementHeader::clearScanBit(eh, scanMask); + dbgWord32(rscPageidptr, trscElementptr, tmp); + rscPageidptr.p->word32[trscElementptr] = tmp; + } else { + jam(); + rscOperPtr.i = ElementHeader::getOpPtrI(eh); + ptrCheckGuard(rscOperPtr, coprecsize, operationrec); + rscOperPtr.p->scanBits &= ~scanMask; + }//if + trscElemlens = trscElemlens - trscElemlen; + trscElementptr = trscElementptr + trscElemStep; + } while (trscElemlens > 2); + if (trscElemlens != 0) { + jam(); + sendSystemerror(signal); + }//if +}//Dbacc::releaseScanContainer() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_SCAN_REC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseScanRec(Signal* signal) +{ + // Check that all ops this scan has allocated have been + // released + ndbrequire(scanPtr.p->scanOpsAllocated==0); + + // Check that all locks this scan might have aquired + // have been properly released + ndbrequire(scanPtr.p->scanLockHeld == 0); + ndbrequire(scanPtr.p->scanFirstLockedOp == RNIL); + ndbrequire(scanPtr.p->scanLastLockedOp == RNIL); + + // Check that all active operations have been + // properly released + ndbrequire(scanPtr.p->scanFirstActiveOp == RNIL); + + // Check that all queued operations have been + // properly released + ndbrequire(scanPtr.p->scanFirstQueuedOp == RNIL); + ndbrequire(scanPtr.p->scanLastQueuedOp == RNIL); + + // Put scan record in free list + scanPtr.p->scanNextfreerec = cfirstFreeScanRec; + scanPtr.p->scanState = ScanRec::SCAN_DISCONNECT; + cfirstFreeScanRec = scanPtr.i; + +}//Dbacc::releaseScanRec() + +/* --------------------------------------------------------------------------------- */ +/* SEARCH_SCAN_CONTAINER */ +/* INPUT: TSSC_CONTAINERLEN */ +/* TSSC_CONTAINERPTR */ +/* TSSC_ISFORWARD */ +/* SSC_PAGEIDPTR */ +/* SCAN_PTR */ +/* OUTPUT: TSSC_IS_LOCKED */ +/* */ +/* DESCRIPTION: SEARCH IN A CONTAINER TO FIND THE NEXT SCAN ELEMENT. */ +/* TO DO THIS THE SCAN BIT OF THE ELEMENT HEADER IS CHECKED. IF */ +/* THIS BIT IS ZERO, IT IS SET TO ONE AND THE ELEMENT IS RETURNED.*/ +/* --------------------------------------------------------------------------------- */ +bool Dbacc::searchScanContainer(Signal* signal) +{ + OperationrecPtr sscOperPtr; + Uint32 tsscScanBits; + Uint32 tsscElemlens; + Uint32 tsscElemlen; + Uint32 tsscElemStep; + + if (tsscContainerlen < 5) { + jam(); + return false; /* 3 IS THE MINIMUM SIZE OF THE ELEMENT */ + }//if + tsscElemlens = tsscContainerlen - ZCON_HEAD_SIZE; + if (fragrecptr.p->keyLength == 0) { + jam(); + tsscElemlen = (ZELEM_HEAD_SIZE + ZACTIVE_LONG_KEY_LEN) + fragrecptr.p->localkeylen; + } else { + jam(); + /* LENGTH OF THE ELEMENT */ + tsscElemlen = (ZELEM_HEAD_SIZE + fragrecptr.p->keyLength) + fragrecptr.p->localkeylen; + }//if + /* LENGTH OF THE ELEMENT */ + if (tsscIsforward == 1) { + jam(); + tsscElementptr = tsscContainerptr + ZCON_HEAD_SIZE; + tsscElemStep = tsscElemlen; + } else { + jam(); + tsscElementptr = tsscContainerptr - 1; + tsscElemStep = 0 - tsscElemlen; + }//if + SCANELEMENTLOOP001: + arrGuard(tsscElementptr, 2048); + const Uint32 eh = sscPageidptr.p->word32[tsscElementptr]; + tsscIsLocked = ElementHeader::getLocked(eh); + if (!tsscIsLocked){ + jam(); + tsscScanBits = ElementHeader::getScanBits(eh); + if ((scanPtr.p->scanMask & tsscScanBits) == 0) { + jam(); + const Uint32 tmp = ElementHeader::setScanBit(eh, scanPtr.p->scanMask); + dbgWord32(sscPageidptr, tsscElementptr, tmp); + sscPageidptr.p->word32[tsscElementptr] = tmp; + return true; + }//if + } else { + jam(); + sscOperPtr.i = ElementHeader::getOpPtrI(eh); + ptrCheckGuard(sscOperPtr, coprecsize, operationrec); + if ((sscOperPtr.p->scanBits & scanPtr.p->scanMask) == 0) { + jam(); + sscOperPtr.p->scanBits |= scanPtr.p->scanMask; + return true; + }//if + }//if + /* THE ELEMENT IS ALREADY SENT. */ + /* SEARCH FOR NEXT ONE */ + tsscElemlens = tsscElemlens - tsscElemlen; + if (tsscElemlens > 2) { + jam(); + tsscElementptr = tsscElementptr + tsscElemStep; + goto SCANELEMENTLOOP001; + }//if + return false; +}//Dbacc::searchScanContainer() + +/* --------------------------------------------------------------------------------- */ +/* SEND THE RESPONSE NEXT_SCANCONF AND POSSIBLE KEYINFO SIGNALS AS WELL. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::sendNextScanConf(Signal* signal) +{ + scanPtr.p->scanTimer = scanPtr.p->scanContinuebCounter; + Uint32 blockNo = refToBlock(scanPtr.p->scanUserblockref); + if (!scanPtr.p->scanKeyinfoFlag){ + jam(); + /** --------------------------------------------------------------------- + * LQH WILL NOT HAVE ANY USE OF THE TUPLE KEY LENGTH IN THIS CASE AND + * SO WE DO NOT PROVIDE IT. IN THIS CASE THESE VALUES ARE UNDEFINED. + * ---------------------------------------------------------------------- */ + signal->theData[0] = scanPtr.p->scanUserptr; + signal->theData[1] = operationRecPtr.i; + signal->theData[2] = operationRecPtr.p->fid; + signal->theData[3] = operationRecPtr.p->localdata[0]; + signal->theData[4] = operationRecPtr.p->localdata[1]; + signal->theData[5] = fragrecptr.p->localkeylen; + EXECUTE_DIRECT(blockNo, GSN_NEXT_SCANCONF, signal, 6); + return; + }//if + + fragrecptr.i = operationRecPtr.p->fragptr; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + if (fragrecptr.p->keyLength != 0) { + jam(); + signal->theData[0] = scanPtr.p->scanUserptr; + signal->theData[1] = operationRecPtr.i; + signal->theData[2] = operationRecPtr.p->fid; + signal->theData[3] = operationRecPtr.p->localdata[0]; + signal->theData[4] = operationRecPtr.p->localdata[1]; + signal->theData[5] = fragrecptr.p->localkeylen; + signal->theData[6] = fragrecptr.p->keyLength; + signal->theData[7] = operationRecPtr.p->keydata[0]; + signal->theData[8] = operationRecPtr.p->keydata[1]; + signal->theData[9] = operationRecPtr.p->keydata[2]; + signal->theData[10] = operationRecPtr.p->keydata[3]; + EXECUTE_DIRECT(blockNo, GSN_NEXT_SCANCONF, signal, 11); + if (fragrecptr.p->keyLength > ZKEYINKEYREQ) { + jam(); + /* = 4 */ + signal->theData[0] = scanPtr.p->scanUserptr; + signal->theData[1] = operationRecPtr.i; + signal->theData[2] = operationRecPtr.p->fid; + signal->theData[3] = fragrecptr.p->keyLength - ZKEYINKEYREQ; + signal->theData[4] = operationRecPtr.p->keydata[4]; + signal->theData[5] = operationRecPtr.p->keydata[5]; + signal->theData[6] = operationRecPtr.p->keydata[6]; + signal->theData[7] = operationRecPtr.p->keydata[7]; + EXECUTE_DIRECT(blockNo, GSN_ACC_SCAN_INFO, signal, 8); + return; + }//if + } else { + jam(); + sendScaninfo(signal); + return; + }//if +}//Dbacc::sendNextScanConf() + +/* --------------------------------------------------------------------------------- */ +/* SEND_SCANINFO */ +/* DESCRIPTION: SCAN AN ELEMENT OF A LONG_KEY_PAGE. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::sendScaninfo(Signal* signal) +{ + DirRangePtr ssiOverflowrangeptr; + DirectoryarrayPtr ssiOverflowDirptr; + Page8Ptr ssiPageptr; + Uint32 tssiPageIndex; + Uint32 tssiPagedir; + Uint32 tssiKeyLen; + Uint32 tssiStartIndex; + Uint32 tssiIndexValue; + Uint32 tssiTmp; + + Uint32 blockNo = refToBlock(scanPtr.p->scanUserblockref); + + tssiPageIndex = operationRecPtr.p->keydata[0] & 0x3ff; + tssiPagedir = operationRecPtr.p->keydata[0] >> 10; + ssiOverflowrangeptr.i = fragrecptr.p->overflowdir; + ptrCheckGuard(ssiOverflowrangeptr, cdirrangesize, dirRange); + arrGuard((tssiPagedir >> 8), 256); + ssiOverflowDirptr.i = ssiOverflowrangeptr.p->dirArray[tssiPagedir >> 8]; + ptrCheckGuard(ssiOverflowDirptr, cdirarraysize, directoryarray); + ssiPageptr.i = ssiOverflowDirptr.p->pagep[tssiPagedir & 0xff]; + ptrCheckGuard(ssiPageptr, cpagesize, page8); + arrGuard(ZWORDS_IN_PAGE - tssiPageIndex, 2048); + tssiIndexValue = ssiPageptr.p->word32[ZWORDS_IN_PAGE - tssiPageIndex]; + tssiStartIndex = tssiIndexValue & 0xffff; + tssiKeyLen = tssiIndexValue >> 16; + signal->theData[0] = scanPtr.p->scanUserptr; + signal->theData[1] = operationRecPtr.i; + signal->theData[2] = operationRecPtr.p->fid; + signal->theData[3] = operationRecPtr.p->localdata[0]; + signal->theData[4] = operationRecPtr.p->localdata[1]; + signal->theData[5] = fragrecptr.p->localkeylen; + signal->theData[6] = tssiKeyLen; + arrGuard(tssiStartIndex + 3, 2048); + signal->theData[7] = ssiPageptr.p->word32[tssiStartIndex]; + signal->theData[8] = ssiPageptr.p->word32[tssiStartIndex + 1]; + signal->theData[9] = ssiPageptr.p->word32[tssiStartIndex + 2]; + signal->theData[10] = ssiPageptr.p->word32[tssiStartIndex + 3]; + EXECUTE_DIRECT(blockNo, GSN_NEXT_SCANCONF, signal, 11); + if (tssiKeyLen > 4) { + tssiKeyLen = tssiKeyLen - 4; + tssiStartIndex = tssiStartIndex + 4; + SSI_LOOP_10: + jamEntry(); + if (tssiKeyLen > ZMAXSCANSIGNALLEN) { + jam(); + signal->theData[0] = scanPtr.p->scanUserptr; + signal->theData[1] = operationRecPtr.i; + signal->theData[2] = operationRecPtr.p->fid; + signal->theData[3] = ZMAXSCANSIGNALLEN; + arrGuard(tssiStartIndex + 19, 2048); + signal->theData[4] = ssiPageptr.p->word32[tssiStartIndex]; + signal->theData[5] = ssiPageptr.p->word32[tssiStartIndex + 1]; + signal->theData[6] = ssiPageptr.p->word32[tssiStartIndex + 2]; + signal->theData[7] = ssiPageptr.p->word32[tssiStartIndex + 3]; + signal->theData[8] = ssiPageptr.p->word32[tssiStartIndex + 4]; + signal->theData[9] = ssiPageptr.p->word32[tssiStartIndex + 5]; + signal->theData[10] = ssiPageptr.p->word32[tssiStartIndex + 6]; + signal->theData[11] = ssiPageptr.p->word32[tssiStartIndex + 7]; + signal->theData[12] = ssiPageptr.p->word32[tssiStartIndex + 8]; + signal->theData[13] = ssiPageptr.p->word32[tssiStartIndex + 9]; + signal->theData[14] = ssiPageptr.p->word32[tssiStartIndex + 10]; + signal->theData[15] = ssiPageptr.p->word32[tssiStartIndex + 11]; + signal->theData[16] = ssiPageptr.p->word32[tssiStartIndex + 12]; + signal->theData[17] = ssiPageptr.p->word32[tssiStartIndex + 13]; + signal->theData[18] = ssiPageptr.p->word32[tssiStartIndex + 14]; + signal->theData[19] = ssiPageptr.p->word32[tssiStartIndex + 15]; + signal->theData[20] = ssiPageptr.p->word32[tssiStartIndex + 16]; + signal->theData[21] = ssiPageptr.p->word32[tssiStartIndex + 17]; + signal->theData[22] = ssiPageptr.p->word32[tssiStartIndex + 18]; + signal->theData[23] = ssiPageptr.p->word32[tssiStartIndex + 19]; + EXECUTE_DIRECT(blockNo, GSN_ACC_SCAN_INFO24, signal, 24); + tssiStartIndex = tssiStartIndex + ZMAXSCANSIGNALLEN; + tssiKeyLen = tssiKeyLen - ZMAXSCANSIGNALLEN; + goto SSI_LOOP_10; + } else { + jam(); + ndbrequire((tssiStartIndex + tssiKeyLen) <= 2048); + for (tssiTmp = 0; tssiTmp < tssiKeyLen; tssiTmp++) { + ckeys[tssiTmp] = ssiPageptr.p->word32[tssiStartIndex + tssiTmp]; + }//for + signal->theData[0] = scanPtr.p->scanUserptr; + signal->theData[1] = operationRecPtr.i; + signal->theData[2] = operationRecPtr.p->fid; + /* LOCAL FRAGMENT IDENTITY */ + signal->theData[3] = tssiKeyLen; + signal->theData[4] = ckeys[0]; + signal->theData[5] = ckeys[1]; + signal->theData[6] = ckeys[2]; + signal->theData[7] = ckeys[3]; + signal->theData[8] = ckeys[4]; + signal->theData[9] = ckeys[5]; + signal->theData[10] = ckeys[6]; + signal->theData[11] = ckeys[7]; + signal->theData[12] = ckeys[8]; + signal->theData[13] = ckeys[9]; + signal->theData[14] = ckeys[10]; + signal->theData[15] = ckeys[11]; + signal->theData[16] = ckeys[12]; + signal->theData[17] = ckeys[13]; + signal->theData[18] = ckeys[14]; + signal->theData[19] = ckeys[15]; + signal->theData[20] = ckeys[16]; + signal->theData[21] = ckeys[17]; + signal->theData[22] = ckeys[18]; + signal->theData[23] = ckeys[19]; + EXECUTE_DIRECT(blockNo, GSN_ACC_SCAN_INFO24, signal, 24); + }//if + }//if +}//Dbacc::sendScaninfo() + +/*--------------------------------------------------------------------------- + * sendScanHbRep + * Description: Using Dispatcher::execute() to send a heartbeat to DBTC + * from DBLQH telling the scan is alive. We use the sendScanHbRep() + * in DBLQH, this needs to be done here in DBACC since it can take + * a while before LQH receives an answer the normal way from ACC. + *--------------------------------------------------------------------------*/ +void Dbacc::sendScanHbRep(Signal* signal, Uint32 scanPtrIndex) +{ + scanPtr.i = scanPtrIndex; + ptrCheckGuard(scanPtr, cscanRecSize, scanRec); + + // If the timer status is on we continue with a new heartbeat in one second, + // else the loop stops and we will not send a new CONTINUEB + if (scanPtr.p->scanTimer != 0){ + if (scanPtr.p->scanTimer == scanPtr.p->scanContinuebCounter){ + jam(); + ndbrequire(scanPtr.p->scanState != ScanRec::SCAN_DISCONNECT); + + signal->theData[0] = scanPtr.p->scanUserptr; + signal->theData[1] = scanPtr.p->scanTrid1; + signal->theData[2] = scanPtr.p->scanTrid2; + EXECUTE_DIRECT(DBLQH, GSN_SCAN_HBREP, signal, 3); + jamEntry(); + }//if + scanPtr.p->scanContinuebCounter++; + signal->theData[0] = ZSEND_SCAN_HBREP; + signal->theData[1] = scanPtr.i; + sendSignalWithDelay(cownBlockref, GSN_CONTINUEB, signal, 100, 2); + } else { + jam(); + scanPtr.p->scanContinuebCounter = 0; + }//if +}//Dbacc::sendScanHbRep() + +/* --------------------------------------------------------------------------------- */ +/* SETLOCK */ +/* DESCRIPTION:SETS LOCK ON AN ELEMENT. INFORMATION ABOUT THE ELEMENT IS */ +/* SAVED IN THE ELEMENT HEAD.A COPY OF THIS INFORMATION WILL */ +/* BE PUT IN THE OPERATION RECORD. A FIELD IN THE HEADER OF */ +/* THE ELEMENT POINTS TO THE OPERATION RECORD. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::setlock(Signal* signal) +{ + Uint32 tselTmp1; + + arrGuard(tslElementptr, 2048); + tselTmp1 = slPageidptr.p->word32[tslElementptr]; + operationRecPtr.p->scanBits = ElementHeader::getScanBits(tselTmp1); + operationRecPtr.p->hashvaluePart = ElementHeader::getHashValuePart(tselTmp1); + + tselTmp1 = ElementHeader::setLocked(operationRecPtr.i); + dbgWord32(slPageidptr, tslElementptr, tselTmp1); + slPageidptr.p->word32[tslElementptr] = tselTmp1; +}//Dbacc::setlock() + +/* --------------------------------------------------------------------------------- */ +/* TAKE_OUT_ACTIVE_SCAN_OP */ +/* DESCRIPTION: AN ACTIVE SCAN OPERATION IS BELOGED TO AN ACTIVE LIST OF THE */ +/* SCAN RECORD. BY THIS SUBRUTIN THE LIST IS UPDATED. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::takeOutActiveScanOp(Signal* signal) +{ + OperationrecPtr tasOperationRecPtr; + + if (operationRecPtr.p->prevOp != RNIL) { + jam(); + tasOperationRecPtr.i = operationRecPtr.p->prevOp; + ptrCheckGuard(tasOperationRecPtr, coprecsize, operationrec); + tasOperationRecPtr.p->nextOp = operationRecPtr.p->nextOp; + } else { + jam(); + scanPtr.p->scanFirstActiveOp = operationRecPtr.p->nextOp; + }//if + if (operationRecPtr.p->nextOp != RNIL) { + jam(); + tasOperationRecPtr.i = operationRecPtr.p->nextOp; + ptrCheckGuard(tasOperationRecPtr, coprecsize, operationrec); + tasOperationRecPtr.p->prevOp = operationRecPtr.p->prevOp; + }//if +}//Dbacc::takeOutActiveScanOp() + +/** + * takeOutScanLockQueue + * + * Description: Take out an operation from the doubly linked + * lock list on a scan record. + * + * @note Use putOpScanLockQue to insert a operation in + * the list + * + */ +void Dbacc::takeOutScanLockQueue(Uint32 scanRecIndex) +{ + OperationrecPtr tslOperationRecPtr; + ScanRecPtr TscanPtr; + + TscanPtr.i = scanRecIndex; + ptrCheckGuard(TscanPtr, cscanRecSize, scanRec); + + if (operationRecPtr.p->prevOp != RNIL) { + jam(); + tslOperationRecPtr.i = operationRecPtr.p->prevOp; + ptrCheckGuard(tslOperationRecPtr, coprecsize, operationrec); + tslOperationRecPtr.p->nextOp = operationRecPtr.p->nextOp; + } else { + jam(); + // Check that first are pointing at operation to take out + ndbrequire(TscanPtr.p->scanFirstLockedOp==operationRecPtr.i); + TscanPtr.p->scanFirstLockedOp = operationRecPtr.p->nextOp; + }//if + if (operationRecPtr.p->nextOp != RNIL) { + jam(); + tslOperationRecPtr.i = operationRecPtr.p->nextOp; + ptrCheckGuard(tslOperationRecPtr, coprecsize, operationrec); + tslOperationRecPtr.p->prevOp = operationRecPtr.p->prevOp; + } else { + jam(); + // Check that last are pointing at operation to take out + ndbrequire(TscanPtr.p->scanLastLockedOp==operationRecPtr.i); + TscanPtr.p->scanLastLockedOp = operationRecPtr.p->prevOp; + }//if + TscanPtr.p->scanLockHeld--; + +#ifdef VM_TRACE + // DEBUG CODE + // Check that there are as many operations in the lockqueue as + // scanLockHeld indicates + OperationrecPtr tmpOp; + int numLockedOps = 0; + tmpOp.i = TscanPtr.p->scanFirstLockedOp; + while(tmpOp.i != RNIL){ + numLockedOps++; + ptrCheckGuard(tmpOp, coprecsize, operationrec); + if (tmpOp.p->nextOp == RNIL) + ndbrequire(tmpOp.i == TscanPtr.p->scanLastLockedOp); + tmpOp.i = tmpOp.p->nextOp; + } + ndbrequire(numLockedOps==TscanPtr.p->scanLockHeld); +#endif +}//Dbacc::takeOutScanLockQueue() + +/* --------------------------------------------------------------------------------- */ +/* TAKE_OUT_READY_SCAN_QUEUE */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::takeOutReadyScanQueue(Signal* signal) +{ + OperationrecPtr trsOperationRecPtr; + + if (operationRecPtr.p->prevOp != RNIL) { + jam(); + trsOperationRecPtr.i = operationRecPtr.p->prevOp; + ptrCheckGuard(trsOperationRecPtr, coprecsize, operationrec); + trsOperationRecPtr.p->nextOp = operationRecPtr.p->nextOp; + } else { + jam(); + scanPtr.p->scanFirstQueuedOp = operationRecPtr.p->nextOp; + }//if + if (operationRecPtr.p->nextOp != RNIL) { + jam(); + trsOperationRecPtr.i = operationRecPtr.p->nextOp; + ptrCheckGuard(trsOperationRecPtr, coprecsize, operationrec); + trsOperationRecPtr.p->prevOp = operationRecPtr.p->prevOp; + } else { + jam(); + scanPtr.p->scanLastQueuedOp = operationRecPtr.p->nextOp; + }//if +}//Dbacc::takeOutReadyScanQueue() + +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ +/* */ +/* END OF SCAN MODULE */ +/* */ +/* --------------------------------------------------------------------------------- */ +/* --------------------------------------------------------------------------------- */ + +bool Dbacc::getrootfragmentrec(Signal* signal, RootfragmentrecPtr& rootPtr, Uint32 fid) +{ + for (Uint32 i = 0; i < NO_OF_FRAG_PER_NODE; i++) { + jam(); + if (tabptr.p->fragholder[i] == fid) { + jam(); + rootPtr.i = tabptr.p->fragptrholder[i]; + ptrCheckGuard(rootPtr, crootfragmentsize, rootfragmentrec); + return true; + }//if + }//for + return false; +}//Dbacc::getrootfragmentrec() + +/* --------------------------------------------------------------------------------- */ +/* INIT_FS_OP_REC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initFsOpRec(Signal* signal) +{ + fsOpptr.p->fsOpfragrecPtr = fragrecptr.i; + fsOpptr.p->fsConptr = fsConnectptr.i; +}//Dbacc::initFsOpRec() + +/* --------------------------------------------------------------------------------- */ +/* INIT_LCP_CONN_REC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initLcpConnRec(Signal* signal) +{ + lcpConnectptr.p->lcpUserblockref = tuserblockref; + lcpConnectptr.p->lcpUserptr = tuserptr; + lcpConnectptr.p->noOfLcpConf = 0; /* NO OF RETUREND CONF SIGNALS */ + lcpConnectptr.p->syncUndopageState = WAIT_NOTHING; +}//Dbacc::initLcpConnRec() + +/* --------------------------------------------------------------------------------- */ +/* INIT_OVERPAGE */ +/* INPUT. IOP_PAGEPTR, POINTER TO AN OVERFLOW PAGE RECORD */ +/* DESCRIPTION: CONTAINERS AND FREE LISTS OF THE PAGE, GET INITIALE VALUE */ +/* ACCORDING TO LH3 AND PAGE STRUCTOR DESCRIPTION OF NDBACC BLOCK */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initOverpage(Signal* signal) +{ + Uint32 tiopTmp; + Uint32 tiopPrevFree; + Uint32 tiopNextFree; + + for (tiopIndex = 0; tiopIndex <= 2047; tiopIndex++) { + iopPageptr.p->word32[tiopIndex] = 0; + }//for + iopPageptr.p->word32[ZPOS_OVERFLOWREC] = iopOverflowRecPtr.i; + iopPageptr.p->word32[ZPOS_CHECKSUM] = 0; + iopPageptr.p->word32[ZPOS_PAGE_ID] = tiopPageId; + iopPageptr.p->word32[ZPOS_ALLOC_CONTAINERS] = 0; + tiopTmp = ZEMPTYLIST; + tiopTmp = (tiopTmp << 16) + (tiopTmp << 23); + iopPageptr.p->word32[ZPOS_EMPTY_LIST] = tiopTmp + (1 << ZPOS_PAGE_TYPE_BIT); + /* --------------------------------------------------------------------------------- */ + /* INITIALISE PREVIOUS PART OF DOUBLY LINKED LIST FOR LEFT CONTAINERS. */ + /* --------------------------------------------------------------------------------- */ + tiopIndex = ZHEAD_SIZE + 1; + iopPageptr.p->word32[tiopIndex] = ZEMPTYLIST; + for (tiopPrevFree = 0; tiopPrevFree <= ZEMPTYLIST - 2; tiopPrevFree++) { + tiopIndex = tiopIndex + ZBUF_SIZE; + iopPageptr.p->word32[tiopIndex] = tiopPrevFree; + }//for + /* --------------------------------------------------------------------------------- */ + /* INITIALISE NEXT PART OF DOUBLY LINKED LIST FOR LEFT CONTAINERS. */ + /* --------------------------------------------------------------------------------- */ + tiopIndex = ZHEAD_SIZE; + for (tiopNextFree = 1; tiopNextFree <= ZEMPTYLIST - 1; tiopNextFree++) { + iopPageptr.p->word32[tiopIndex] = tiopNextFree; + tiopIndex = tiopIndex + ZBUF_SIZE; + }//for + iopPageptr.p->word32[tiopIndex] = ZEMPTYLIST; /* LEFT_LIST IS UPDATED */ + /* --------------------------------------------------------------------------------- */ + /* INITIALISE PREVIOUS PART OF DOUBLY LINKED LIST FOR RIGHT CONTAINERS. */ + /* --------------------------------------------------------------------------------- */ + tiopIndex = (ZBUF_SIZE + ZHEAD_SIZE) - 1; + iopPageptr.p->word32[tiopIndex] = ZEMPTYLIST; + for (tiopPrevFree = 0; tiopPrevFree <= ZEMPTYLIST - 2; tiopPrevFree++) { + tiopIndex = tiopIndex + ZBUF_SIZE; + iopPageptr.p->word32[tiopIndex] = tiopPrevFree; + }//for + /* --------------------------------------------------------------------------------- */ + /* INITIALISE NEXT PART OF DOUBLY LINKED LIST FOR RIGHT CONTAINERS. */ + /* --------------------------------------------------------------------------------- */ + tiopIndex = (ZBUF_SIZE + ZHEAD_SIZE) - 2; + for (tiopNextFree = 1; tiopNextFree <= ZEMPTYLIST - 1; tiopNextFree++) { + iopPageptr.p->word32[tiopIndex] = tiopNextFree; + tiopIndex = tiopIndex + ZBUF_SIZE; + }//for + iopPageptr.p->word32[tiopIndex] = ZEMPTYLIST; /* RIGHT_LIST IS UPDATED */ +}//Dbacc::initOverpage() + +/* --------------------------------------------------------------------------------- */ +/* INIT_PAGE */ +/* INPUT. INP_PAGEPTR, POINTER TO A PAGE RECORD */ +/* DESCRIPTION: CONTAINERS AND FREE LISTS OF THE PAGE, GET INITIALE VALUE */ +/* ACCORDING TO LH3 AND PAGE STRUCTOR DISACRIPTION OF NDBACC BLOCK */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::initPage(Signal* signal) +{ + Uint32 tinpTmp1; + Uint32 tinpIndex; + Uint32 tinpTmp; + Uint32 tinpPrevFree; + Uint32 tinpNextFree; + + for (tiopIndex = 0; tiopIndex <= 2047; tiopIndex++) { + inpPageptr.p->word32[tiopIndex] = 0; + }//for + /* --------------------------------------------------------------------------------- */ + /* SET PAGE ID FOR USE OF CHECKPOINTER. */ + /* PREPARE CONTAINER HEADERS INDICATING EMPTY CONTAINERS WITHOUT NEXT. */ + /* --------------------------------------------------------------------------------- */ + inpPageptr.p->word32[ZPOS_PAGE_ID] = tipPageId; + tinpTmp1 = ZCON_HEAD_SIZE; + tinpTmp1 = tinpTmp1 << 26; + /* --------------------------------------------------------------------------------- */ + /* INITIALISE ZNO_CONTAINERS PREDEFINED HEADERS ON LEFT SIZE. */ + /* --------------------------------------------------------------------------------- */ + tinpIndex = ZHEAD_SIZE; + for (tinpTmp = 0; tinpTmp <= ZNO_CONTAINERS - 1; tinpTmp++) { + inpPageptr.p->word32[tinpIndex] = tinpTmp1; + tinpIndex = tinpIndex + ZBUF_SIZE; + }//for + /* WORD32(ZPOS_EMPTY_LIST) DATA STRUCTURE:*/ + /*--------------------------------------- */ + /*| PAGE TYPE|LEFT FREE|RIGHT FREE */ + /*| 1 | LIST | LIST */ + /*| BIT | 7 BITS | 7 BITS */ + /*--------------------------------------- */ + /* --------------------------------------------------------------------------------- */ + /* INITIALISE FIRST POINTER TO DOUBLY LINKED LIST OF FREE CONTAINERS. */ + /* INITIALISE EMPTY LISTS OF USED CONTAINERS. */ + /* INITIALISE LEFT FREE LIST TO 64 AND RIGHT FREE LIST TO ZERO. */ + /* ALSO INITIALISE PAGE TYPE TO NOT OVERFLOW PAGE. */ + /* --------------------------------------------------------------------------------- */ + tinpTmp = ZEMPTYLIST; + tinpTmp = (tinpTmp << 16) + (tinpTmp << 23); + tinpTmp = tinpTmp + (ZNO_CONTAINERS << 7); + inpPageptr.p->word32[ZPOS_EMPTY_LIST] = tinpTmp; + /* --------------------------------------------------------------------------------- */ + /* INITIALISE PREVIOUS PART OF DOUBLY LINKED LIST FOR RIGHT CONTAINERS. */ + /* --------------------------------------------------------------------------------- */ + tinpIndex = (ZHEAD_SIZE + ZBUF_SIZE) - 1; + inpPageptr.p->word32[tinpIndex] = ZEMPTYLIST; + for (tinpPrevFree = 0; tinpPrevFree <= ZEMPTYLIST - 2; tinpPrevFree++) { + tinpIndex = tinpIndex + ZBUF_SIZE; + inpPageptr.p->word32[tinpIndex] = tinpPrevFree; + }//for + /* --------------------------------------------------------------------------------- */ + /* INITIALISE NEXT PART OF DOUBLY LINKED LIST FOR RIGHT CONTAINERS. */ + /* --------------------------------------------------------------------------------- */ + tinpIndex = (ZHEAD_SIZE + ZBUF_SIZE) - 2; + for (tinpNextFree = 1; tinpNextFree <= ZEMPTYLIST - 1; tinpNextFree++) { + inpPageptr.p->word32[tinpIndex] = tinpNextFree; + tinpIndex = tinpIndex + ZBUF_SIZE; + }//for + inpPageptr.p->word32[tinpIndex] = ZEMPTYLIST; + /* --------------------------------------------------------------------------------- */ + /* INITIALISE PREVIOUS PART OF DOUBLY LINKED LIST FOR LEFT CONTAINERS. */ + /* THE FIRST ZNO_CONTAINERS ARE NOT PUT INTO FREE LIST SINCE THEY ARE */ + /* PREDEFINED AS OCCUPIED. */ + /* --------------------------------------------------------------------------------- */ + tinpIndex = (ZNO_CONTAINERS * ZBUF_SIZE) + ZHEAD_SIZE; + for (tinpNextFree = ZNO_CONTAINERS + 1; tinpNextFree <= ZEMPTYLIST - 1; tinpNextFree++) { + inpPageptr.p->word32[tinpIndex] = tinpNextFree; + tinpIndex = tinpIndex + ZBUF_SIZE; + }//for + inpPageptr.p->word32[tinpIndex] = ZEMPTYLIST; + /* --------------------------------------------------------------------------------- */ + /* INITIALISE NEXT PART OF DOUBLY LINKED LIST FOR LEFT CONTAINERS. */ + /* THE FIRST ZNO_CONTAINERS ARE NOT PUT INTO FREE LIST SINCE THEY ARE */ + /* PREDEFINED AS OCCUPIED. */ + /* --------------------------------------------------------------------------------- */ + tinpIndex = ((ZNO_CONTAINERS * ZBUF_SIZE) + ZHEAD_SIZE) + 1; + inpPageptr.p->word32[tinpIndex] = ZEMPTYLIST; + for (tinpPrevFree = ZNO_CONTAINERS; tinpPrevFree <= ZEMPTYLIST - 2; tinpPrevFree++) { + tinpIndex = tinpIndex + ZBUF_SIZE; + inpPageptr.p->word32[tinpIndex] = tinpPrevFree; + }//for + /* --------------------------------------------------------------------------------- */ + /* INITIALISE HEADER POSITIONS NOT CURRENTLY USED AND ENSURE USE OF OVERFLOW */ + /* RECORD POINTER ON THIS PAGE LEADS TO ERROR. */ + /* --------------------------------------------------------------------------------- */ + inpPageptr.p->word32[ZPOS_CHECKSUM] = 0; + inpPageptr.p->word32[ZPOS_ALLOC_CONTAINERS] = 0; + inpPageptr.p->word32[ZPOS_OVERFLOWREC] = RNIL; +}//Dbacc::initPage() + +/* --------------------------------------------------------------------------------- */ +/* PUT_OP_IN_FRAG_WAIT_QUE */ +/* DESCRIPTION: AN OPERATION WHICH OWNS A LOCK OF AN ELEMENT, IS PUT IN A */ +/* LIST OF THE FRAGMENT. THIS LIST IS USED TO STOP THE QUEUE */ +/* OPERATION DURING CREATE CHECK POINT PROSESS FOR STOP AND */ +/* RESTART OF THE OPERATIONS. */ +/* */ +/* IF CONTINUEB SIGNALS ARE INTRODUCED AFTER STARTING TO EXECUTE ACCKEYREQ WE */ +/* MUST PUT IT IN THIS LIST BEFORE EXITING TO ENSURE THAT WE ARE NOT BEING */ +/* LOCKED AFTER THAT LQH HAS RECEIVED ALL LCP_HOLDOP'S. THEN THE LCP WILL NEVER*/ +/* PROCEED. WE ALSO PUT IT INTO THIS LIST WHEN WAITING FOR LONG KEYS. THIS IS */ +/* ONLY NEEDED IF SIGNALS CAN ENTER BETWEEN THE KEYDATA CARRYING SIGNALS. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::putOpInFragWaitQue(Signal* signal) +{ + OperationrecPtr tpiwOperRecPtr; + + if (operationRecPtr.p->operation != ZSCAN_OP) { + if (fragrecptr.p->firstWaitInQueOp == RNIL) { + jam(); + fragrecptr.p->firstWaitInQueOp = operationRecPtr.i; + } else { + jam(); + tpiwOperRecPtr.i = fragrecptr.p->lastWaitInQueOp; + ptrCheckGuard(tpiwOperRecPtr, coprecsize, operationrec); + tpiwOperRecPtr.p->nextQueOp = operationRecPtr.i; + }//if + operationRecPtr.p->opState = WAIT_IN_QUEUE; + operationRecPtr.p->nextQueOp = RNIL; + operationRecPtr.p->prevQueOp = fragrecptr.p->lastWaitInQueOp; + fragrecptr.p->lastWaitInQueOp = operationRecPtr.i; + }//if +}//Dbacc::putOpInFragWaitQue() + +/* --------------------------------------------------------------------------------- */ +/* PUT_OVERFLOW_REC_IN_FRAG */ +/* DESCRIPTION: AN OVERFLOW RECORD WITCH IS USED TO KEEP INFORMATION ABOUT */ +/* OVERFLOW PAGE WILL BE PUT IN A LIST OF OVERFLOW RECORDS IN */ +/* THE FRAGMENT RECORD. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::putOverflowRecInFrag(Signal* signal) +{ + OverflowRecordPtr tpifNextOverrecPtr; + OverflowRecordPtr tpifPrevOverrecPtr; + + tpifNextOverrecPtr.i = fragrecptr.p->firstOverflowRec; + tpifPrevOverrecPtr.i = RNIL; + while (tpifNextOverrecPtr.i != RNIL) { + ptrCheckGuard(tpifNextOverrecPtr, coverflowrecsize, overflowRecord); + if (tpifNextOverrecPtr.p->dirindex < porOverflowRecPtr.p->dirindex) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* PROCEED IN LIST TO THE NEXT IN THE LIST SINCE THE ENTRY HAD A LOWER PAGE ID.*/ + /* WE WANT TO ENSURE THAT LOWER PAGE ID'S ARE KEPT FULL RATHER THAN THE */ + /* OPPOSITE TO ENSURE THAT HIGH PAGE ID'S CAN BE REMOVED WHEN SHRINKS ARE */ + /* PERFORMED. */ + /* --------------------------------------------------------------------------------- */ + tpifPrevOverrecPtr = tpifNextOverrecPtr; + tpifNextOverrecPtr.i = tpifNextOverrecPtr.p->nextOverRec; + } else { + jam(); + ndbrequire(tpifNextOverrecPtr.p->dirindex != porOverflowRecPtr.p->dirindex); + /* --------------------------------------------------------------------------------- */ + /* TRYING TO INSERT THE SAME PAGE TWICE. SYSTEM ERROR. */ + /* --------------------------------------------------------------------------------- */ + break; + }//if + }//while + if (tpifNextOverrecPtr.i == RNIL) { + jam(); + fragrecptr.p->lastOverflowRec = porOverflowRecPtr.i; + } else { + jam(); + tpifNextOverrecPtr.p->prevOverRec = porOverflowRecPtr.i; + }//if + if (tpifPrevOverrecPtr.i == RNIL) { + jam(); + fragrecptr.p->firstOverflowRec = porOverflowRecPtr.i; + } else { + jam(); + tpifPrevOverrecPtr.p->nextOverRec = porOverflowRecPtr.i; + }//if + porOverflowRecPtr.p->prevOverRec = tpifPrevOverrecPtr.i; + porOverflowRecPtr.p->nextOverRec = tpifNextOverrecPtr.i; +}//Dbacc::putOverflowRecInFrag() + +/* --------------------------------------------------------------------------------- */ +/* PUT_REC_IN_FREE_OVERDIR */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::putRecInFreeOverdir(Signal* signal) +{ + OverflowRecordPtr tpfoNextOverrecPtr; + OverflowRecordPtr tpfoPrevOverrecPtr; + + tpfoNextOverrecPtr.i = fragrecptr.p->firstFreeDirindexRec; + tpfoPrevOverrecPtr.i = RNIL; + while (tpfoNextOverrecPtr.i != RNIL) { + ptrCheckGuard(tpfoNextOverrecPtr, coverflowrecsize, overflowRecord); + if (tpfoNextOverrecPtr.p->dirindex < priOverflowRecPtr.p->dirindex) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* PROCEED IN LIST TO THE NEXT IN THE LIST SINCE THE ENTRY HAD A LOWER PAGE ID.*/ + /* WE WANT TO ENSURE THAT LOWER PAGE ID'S ARE KEPT FULL RATHER THAN THE */ + /* OPPOSITE TO ENSURE THAT HIGH PAGE ID'S CAN BE REMOVED WHEN SHRINKS ARE */ + /* PERFORMED. */ + /* --------------------------------------------------------------------------------- */ + tpfoPrevOverrecPtr = tpfoNextOverrecPtr; + tpfoNextOverrecPtr.i = tpfoNextOverrecPtr.p->nextOverList; + } else { + jam(); + ndbrequire(tpfoNextOverrecPtr.p->dirindex != priOverflowRecPtr.p->dirindex); + /* --------------------------------------------------------------------------------- */ + /* ENSURE WE ARE NOT TRYING TO INSERT THE SAME PAGE TWICE. */ + /* --------------------------------------------------------------------------------- */ + break; + }//if + }//while + if (tpfoNextOverrecPtr.i != RNIL) { + jam(); + tpfoNextOverrecPtr.p->prevOverList = priOverflowRecPtr.i; + }//if + if (tpfoPrevOverrecPtr.i == RNIL) { + jam(); + fragrecptr.p->firstFreeDirindexRec = priOverflowRecPtr.i; + } else { + jam(); + tpfoPrevOverrecPtr.p->nextOverList = priOverflowRecPtr.i; + }//if + priOverflowRecPtr.p->prevOverList = tpfoPrevOverrecPtr.i; + priOverflowRecPtr.p->nextOverList = tpfoNextOverrecPtr.i; +}//Dbacc::putRecInFreeOverdir() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_DIRECTORY */ +/* --------------------------------------- ----------------------------------------- */ +void Dbacc::releaseDirectory(Signal* signal) +{ + ptrCheckGuard(rdDirptr, cdirarraysize, directoryarray); + rdDirptr.p->pagep[0] = cfirstfreedir; + cfirstfreedir = rdDirptr.i; +}//Dbacc::releaseDirectory() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_DIRRANGE */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseDirrange(Signal* signal) +{ + ptrCheckGuard(rdDirRangePtr, cdirrangesize, dirRange); + rdDirRangePtr.p->dirArray[0] = cfirstfreeDirrange; + cfirstfreeDirrange = rdDirRangePtr.i; +}//Dbacc::releaseDirrange() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_FS_CONN_REC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseFsConnRec(Signal* signal) +{ + fsConnectptr.p->fsNext = cfsFirstfreeconnect; + cfsFirstfreeconnect = fsConnectptr.i; + fsConnectptr.p->fsState = WAIT_NOTHING; +}//Dbacc::releaseFsConnRec() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_FS_OP_REC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseFsOpRec(Signal* signal) +{ + fsOpptr.p->fsOpnext = cfsFirstfreeop; + cfsFirstfreeop = fsOpptr.i; + fsOpptr.p->fsOpstate = WAIT_NOTHING; +}//Dbacc::releaseFsOpRec() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_LCP_CONNECT_REC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseLcpConnectRec(Signal* signal) +{ + lcpConnectptr.p->lcpstate = LCP_FREE; + lcpConnectptr.p->nextLcpConn = cfirstfreelcpConnect; + lcpConnectptr.p->lcpstate = LCP_FREE; + cfirstfreelcpConnect = lcpConnectptr.i; +}//Dbacc::releaseLcpConnectRec() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE OP RECORD */ +/* PUT A FREE OPERATION IN A FREE LIST OF THE OPERATIONS */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseOpRec(Signal* signal) +{ +#ifdef VM_TRACE + // DEBUG CODE + // Check that the operation to be released isn't + // already in the list of free operations + // Since this code loops through the entire list of free operations + // it's only enabled in VM_TRACE mode + OperationrecPtr opRecPtr; + bool opInList = false; + opRecPtr.i = cfreeopRec; + while (opRecPtr.i != RNIL){ + if (opRecPtr.i == operationRecPtr.i){ + opInList = true; + break; + } + ptrCheckGuard(opRecPtr, coprecsize, operationrec); + opRecPtr.i = opRecPtr.p->nextOp; + } + ndbrequire(opInList == false); +#endif + ndbrequire(operationRecPtr.p->lockOwner == ZFALSE); + + operationRecPtr.p->nextOp = cfreeopRec; + cfreeopRec = operationRecPtr.i; /* UPDATE FREE LIST OF OP RECORDS */ + operationRecPtr.p->prevOp = RNIL; + operationRecPtr.p->opState = FREE_OP; + operationRecPtr.p->transactionstate = IDLE; + operationRecPtr.p->operation = ZUNDEFINED_OP; +}//Dbacc::releaseOpRec() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_OVERFLOW_REC */ +/* PUT A FREE OVERFLOW REC IN A FREE LIST OF THE OVERFLOW RECORDS */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseOverflowRec(Signal* signal) +{ + rorOverflowRecPtr.p->nextfreeoverrec = cfirstfreeoverrec; + cfirstfreeoverrec = rorOverflowRecPtr.i; +}//Dbacc::releaseOverflowRec() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_OVERPAGE */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseOverpage(Signal* signal) +{ + DirRangePtr ropOverflowrangeptr; + DirectoryarrayPtr ropOverflowDirptr; + OverflowRecordPtr ropOverflowRecPtr; + OverflowRecordPtr tuodOverflowRecPtr; + Uint32 tropTmp; + Uint32 tropTmp1; + Uint32 tropTmp2; + + ropOverflowRecPtr.i = ropPageptr.p->word32[ZPOS_OVERFLOWREC]; + ndbrequire(ropOverflowRecPtr.i != RNIL); + /* THE OVERFLOW REC WILL BE TAKEN OUT OF THE */ + /* FREELIST OF OVERFLOW PAGE WITH FREE */ + /* CONTAINER AND WILL BE PUT IN THE FREE LIST */ + /* OF THE FREE DIRECTORY INDEXES. */ + if ((fragrecptr.p->lastOverflowRec == ropOverflowRecPtr.i) && + (fragrecptr.p->firstOverflowRec == ropOverflowRecPtr.i)) { + jam(); + return; /* THERE IS ONLY ONE OVERFLOW PAGE */ + }//if + if ((fragrecptr.p->createLcp == ZTRUE) && + (fragrecptr.p->lcpMaxOverDirIndex > ropPageptr.p->word32[ZPOS_PAGE_ID])) { + /* --------------------------------------------------------------------------------- */ + /* THE PAGE PARTICIPATES IN THE LOCAL CHECKPOINT. */ + /* --------------------------------------------------------------------------------- */ + if (fragrecptr.p->fragState == LCP_SEND_PAGES) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* THE PAGE PARTICIPATES IN THE LOCAL CHECKPOINT AND THE WRITE TO DISK HAS NOT */ + /* YET BEEN COMPLETED. WE MUST KEEP IT A WHILE LONGER SINCE AN EMPTY PAGE IS */ + /* NOT EQUIVALENT TO AN INITIALISED PAGE SINCE THE FREE LISTS CAN DIFFER. */ + /* --------------------------------------------------------------------------------- */ + return; + } else { + if ((fragrecptr.p->fragState == LCP_SEND_OVER_PAGES) && + (fragrecptr.p->lcpDirIndex <= ropPageptr.p->word32[ZPOS_PAGE_ID])) { + jam(); + /* --------------------------------------------------------------------------------- */ + /* SEE COMMENT ABOVE */ + /* --------------------------------------------------------------------------------- */ + return; + }//if + }//if + }//if +#if kalle + logicalPage = 0; + + i = fragrecptr.p->directory; + p = dirRange.getPtr(i); + + i1 = logicalPage >> 8; + i2 = logicalPage & 0xFF; + + ndbrequire(i1 < 256); + + i = p->dirArray[i1]; + p = directoryarray.getPtr(i); + + physicPageId = p->pagep[i2]; + physicPageP = page8.getPtr(physicPageId); + + p->pagep[i2] = RNIL; + rpPageptr = { physicPageId, physicPageP }; + releasePage(signal); + +#endif + + /* --------------------------------------------------------------------------------- */ + /* IT WAS OK TO RELEASE THE PAGE. */ + /* --------------------------------------------------------------------------------- */ + ptrCheckGuard(ropOverflowRecPtr, coverflowrecsize, overflowRecord); + tfoOverflowRecPtr = ropOverflowRecPtr; + takeRecOutOfFreeOverpage(signal); + ropOverflowRecPtr.p->overpage = RNIL; + priOverflowRecPtr = ropOverflowRecPtr; + putRecInFreeOverdir(signal); + tropTmp = ropPageptr.p->word32[ZPOS_PAGE_ID]; + ropOverflowrangeptr.i = fragrecptr.p->overflowdir; + tropTmp1 = tropTmp >> 8; + tropTmp2 = tropTmp & 0xff; + ptrCheckGuard(ropOverflowrangeptr, cdirrangesize, dirRange); + arrGuard(tropTmp1, 256); + ropOverflowDirptr.i = ropOverflowrangeptr.p->dirArray[tropTmp1]; + ptrCheckGuard(ropOverflowDirptr, cdirarraysize, directoryarray); + ropOverflowDirptr.p->pagep[tropTmp2] = RNIL; + rpPageptr = ropPageptr; + releasePage(signal); + if (ropOverflowRecPtr.p->dirindex != (fragrecptr.p->lastOverIndex - 1)) { + jam(); + return; + }//if + /* --------------------------------------------------------------------------------- */ + /* THE LAST PAGE IN THE DIRECTORY WAS RELEASED IT IS NOW NECESSARY TO REMOVE */ + /* ALL RELEASED OVERFLOW DIRECTORIES AT THE END OF THE LIST. */ + /* --------------------------------------------------------------------------------- */ + do { + fragrecptr.p->lastOverIndex--; + if (tropTmp2 == 0) { + jam(); + ndbrequire(tropTmp1 != 0); + ropOverflowrangeptr.p->dirArray[tropTmp1] = RNIL; + rdDirptr.i = ropOverflowDirptr.i; + releaseDirectory(signal); + tropTmp1--; + tropTmp2 = 255; + } else { + jam(); + tropTmp2--; + }//if + ropOverflowDirptr.i = ropOverflowrangeptr.p->dirArray[tropTmp1]; + ptrCheckGuard(ropOverflowDirptr, cdirarraysize, directoryarray); + } while (ropOverflowDirptr.p->pagep[tropTmp2] == RNIL); + /* --------------------------------------------------------------------------------- */ + /* RELEASE ANY OVERFLOW RECORDS THAT ARE PART OF THE FREE INDEX LIST WHICH */ + /* DIRECTORY INDEX NOW HAS BEEN RELEASED. */ + /* --------------------------------------------------------------------------------- */ + tuodOverflowRecPtr.i = fragrecptr.p->firstFreeDirindexRec; + jam(); + while (tuodOverflowRecPtr.i != RNIL) { + jam(); + ptrCheckGuard(tuodOverflowRecPtr, coverflowrecsize, overflowRecord); + if (tuodOverflowRecPtr.p->dirindex >= fragrecptr.p->lastOverIndex) { + jam(); + rorOverflowRecPtr = tuodOverflowRecPtr; + troOverflowRecPtr.p = tuodOverflowRecPtr.p; + tuodOverflowRecPtr.i = troOverflowRecPtr.p->nextOverList; + takeRecOutOfFreeOverdir(signal); + releaseOverflowRec(signal); + } else { + jam(); + tuodOverflowRecPtr.i = tuodOverflowRecPtr.p->nextOverList; + }//if + }//while +}//Dbacc::releaseOverpage() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_PAGE */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releasePage(Signal* signal) +{ +#ifdef VM_TRACE + bool inList = false; + Uint32 numInList = 0; + Page8Ptr tmpPagePtr; + tmpPagePtr.i = cfirstfreepage; + while (tmpPagePtr.i != RNIL){ + ptrCheckGuard(tmpPagePtr, cpagesize, page8); + if (tmpPagePtr.i == rpPageptr.i){ + jam(); inList = true; + break; + } + numInList++; + tmpPagePtr.i = tmpPagePtr.p->word32[0]; + } + ndbrequire(inList == false); + // ndbrequire(numInList == cnoOfAllocatedPages); +#endif + rpPageptr.p->word32[0] = cfirstfreepage; + cfirstfreepage = rpPageptr.i; + cnoOfAllocatedPages--; +}//Dbacc::releasePage() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_LCP_PAGE */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseLcpPage(Signal* signal) +{ + rlpPageptr.p->word32[0] = cfirstfreeLcpPage; + cfirstfreeLcpPage = rlpPageptr.i; +}//Dbacc::releaseLcpPage() + +/* --------------------------------------------------------------------------------- */ +/* RELEASE_SR_REC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::releaseSrRec(Signal* signal) +{ + srVersionPtr.p->nextFreeSr = cfirstFreeSrVersionRec; + cfirstFreeSrVersionRec = srVersionPtr.i; +}//Dbacc::releaseSrRec() + +/* --------------------------------------------------------------------------------- */ +/* SEIZE_DIRECTORY */ +/* DESCRIPTION: A DIRECTORY BLOCK (ZDIRBLOCKSIZE NUMBERS OF DIRECTORY */ +/* RECORDS WILL BE ALLOCATED AND RETURNED. */ +/* SIZE OF DIRECTORY ERROR_CODE, WILL BE RETURNED IF THERE IS NO ANY */ +/* FREE BLOCK */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::seizeDirectory(Signal* signal) +{ + Uint32 tsdyIndex; + + if (cfirstfreedir == RNIL) { + jam(); + if (cdirarraysize <= cdirmemory) { + jam(); + tresult = ZDIRSIZE_ERROR; + return; + } else { + jam(); + sdDirptr.i = cdirmemory; + ptrCheckGuard(sdDirptr, cdirarraysize, directoryarray); + cdirmemory = cdirmemory + 1; + }//if + } else { + jam(); + sdDirptr.i = cfirstfreedir; + ptrCheckGuard(sdDirptr, cdirarraysize, directoryarray); + cfirstfreedir = sdDirptr.p->pagep[0]; + sdDirptr.p->pagep[0] = RNIL; + }//if + for (tsdyIndex = 0; tsdyIndex <= 255; tsdyIndex++) { + sdDirptr.p->pagep[tsdyIndex] = RNIL; + }//for +}//Dbacc::seizeDirectory() + +/* --------------------------------------------------------------------------------- */ +/* SEIZE_DIRRANGE */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::seizeDirrange(Signal* signal) +{ + Uint32 tsdeIndex; + + newDirRangePtr.i = cfirstfreeDirrange; + ptrCheckGuard(newDirRangePtr, cdirrangesize, dirRange); + cfirstfreeDirrange = newDirRangePtr.p->dirArray[0]; + for (tsdeIndex = 0; tsdeIndex <= 255; tsdeIndex++) { + newDirRangePtr.p->dirArray[tsdeIndex] = RNIL; + }//for +}//Dbacc::seizeDirrange() + +/* --------------------------------------------------------------------------------- */ +/* SEIZE FRAGREC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::seizeFragrec(Signal* signal) +{ + fragrecptr.i = cfirstfreefrag; + ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec); + cfirstfreefrag = fragrecptr.p->nextfreefrag; + fragrecptr.p->nextfreefrag = RNIL; +}//Dbacc::seizeFragrec() + +/* --------------------------------------------------------------------------------- */ +/* SEIZE_FS_CONNECT_REC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::seizeFsConnectRec(Signal* signal) +{ + fsConnectptr.i = cfsFirstfreeconnect; + ptrCheckGuard(fsConnectptr, cfsConnectsize, fsConnectrec); + cfsFirstfreeconnect = fsConnectptr.p->fsNext; + fsConnectptr.p->fsNext = RNIL; + fsConnectptr.p->fsState = WAIT_NOTHING; +}//Dbacc::seizeFsConnectRec() + +/* --------------------------------------------------------------------------------- */ +/* SEIZE_FS_OP_REC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::seizeFsOpRec(Signal* signal) +{ + fsOpptr.i = cfsFirstfreeop; + ptrCheckGuard(fsOpptr, cfsOpsize, fsOprec); + cfsFirstfreeop = fsOpptr.p->fsOpnext; + fsOpptr.p->fsOpnext = RNIL; +}//Dbacc::seizeFsOpRec() + +/* --------------------------------------------------------------------------------- */ +/* SEIZE_LCP_CONNECT_REC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::seizeLcpConnectRec(Signal* signal) +{ + lcpConnectptr.i = cfirstfreelcpConnect; + ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec); + cfirstfreelcpConnect = lcpConnectptr.p->nextLcpConn; + lcpConnectptr.p->nextLcpConn = RNIL; +}//Dbacc::seizeLcpConnectRec() + +/* --------------------------------------------------------------------------------- */ +/* SEIZE_OP_REC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::seizeOpRec(Signal* signal) +{ + operationRecPtr.i = cfreeopRec; + ptrCheckGuard(operationRecPtr, coprecsize, operationrec); + cfreeopRec = operationRecPtr.p->nextOp; /* UPDATE FREE LIST OF OP RECORDS */ + /* PUTS OPERTION RECORD PTR IN THE LIST */ + /* OF OPERATION IN CONNECTION RECORD */ + operationRecPtr.p->nextOp = RNIL; +}//Dbacc::seizeOpRec() + +/* --------------------------------------------------------------------------------- */ +/* SEIZE OVERFLOW RECORD */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::seizeOverRec(Signal* signal) { + sorOverflowRecPtr.i = cfirstfreeoverrec; + ptrCheckGuard(sorOverflowRecPtr, coverflowrecsize, overflowRecord); + cfirstfreeoverrec = sorOverflowRecPtr.p->nextfreeoverrec; + sorOverflowRecPtr.p->nextfreeoverrec = RNIL; + sorOverflowRecPtr.p->prevOverRec = RNIL; + sorOverflowRecPtr.p->nextOverRec = RNIL; +}//Dbacc::seizeOverRec() + + +/** + * A ZPAGESIZE_ERROR has occured, out of index pages + * Print some debug info if debug compiled + */ +void Dbacc::zpagesize_error(const char* where){ + DEBUG(where << endl + << " ZPAGESIZE_ERROR" << endl + << " cfirstfreepage=" << cfirstfreepage << endl + << " cfreepage=" <word32[0]; + cnoOfAllocatedPages++; + }//if +}//Dbacc::seizePage() + +/* --------------------------------------------------------------------------------- */ +/* SEIZE_PAGE */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::seizeLcpPage(Page8Ptr& regPagePtr) +{ + regPagePtr.i = cfirstfreeLcpPage; + ptrCheckGuard(regPagePtr, cpagesize, page8); + cfirstfreeLcpPage = regPagePtr.p->word32[0]; +}//Dbacc::seizeLcpPage() + +/* --------------------------------------------------------------------------------- */ +/* SEIZE_ROOTFRAGREC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::seizeRootfragrec(Signal* signal) +{ + rootfragrecptr.i = cfirstfreerootfrag; + ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec); + cfirstfreerootfrag = rootfragrecptr.p->nextroot; + rootfragrecptr.p->nextroot = RNIL; +}//Dbacc::seizeRootfragrec() + +/* --------------------------------------------------------------------------------- */ +/* SEIZE_SCAN_REC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::seizeScanRec(Signal* signal) +{ + scanPtr.i = cfirstFreeScanRec; + ptrCheckGuard(scanPtr, cscanRecSize, scanRec); + ndbrequire(scanPtr.p->scanState == ScanRec::SCAN_DISCONNECT); + cfirstFreeScanRec = scanPtr.p->scanNextfreerec; +}//Dbacc::seizeScanRec() + +/* --------------------------------------------------------------------------------- */ +/* SEIZE_SR_VERSION_REC */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::seizeSrVerRec(Signal* signal) +{ + srVersionPtr.i = cfirstFreeSrVersionRec; + ptrCheckGuard(srVersionPtr, csrVersionRecSize, srVersionRec); + cfirstFreeSrVersionRec = srVersionPtr.p->nextFreeSr; +}//Dbacc::seizeSrVerRec() + +/* --------------------------------------------------------------------------------- */ +/* SEND_SYSTEMERROR */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::sendSystemerror(Signal* signal) +{ + progError(0, 0); +}//Dbacc::sendSystemerror() + +/* --------------------------------------------------------------------------------- */ +/* TAKE_REC_OUT_OF_FREE_OVERDIR */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::takeRecOutOfFreeOverdir(Signal* signal) +{ + OverflowRecordPtr tofoOverrecPtr; + if (troOverflowRecPtr.p->nextOverList != RNIL) { + jam(); + tofoOverrecPtr.i = troOverflowRecPtr.p->nextOverList; + ptrCheckGuard(tofoOverrecPtr, coverflowrecsize, overflowRecord); + tofoOverrecPtr.p->prevOverList = troOverflowRecPtr.p->prevOverList; + }//if + if (troOverflowRecPtr.p->prevOverList != RNIL) { + jam(); + tofoOverrecPtr.i = troOverflowRecPtr.p->prevOverList; + ptrCheckGuard(tofoOverrecPtr, coverflowrecsize, overflowRecord); + tofoOverrecPtr.p->nextOverList = troOverflowRecPtr.p->nextOverList; + } else { + jam(); + fragrecptr.p->firstFreeDirindexRec = troOverflowRecPtr.p->nextOverList; + }//if +}//Dbacc::takeRecOutOfFreeOverdir() + +/* --------------------------------------------------------------------------------- */ +/* TAKE_REC_OUT_OF_FREE_OVERPAGE */ +/* DESCRIPTION: AN OVERFLOW PAGE WHICH IS EMPTY HAVE TO BE TAKE OUT OF THE */ +/* FREE LIST OF OVERFLOW PAGE. BY THIS SUBROUTINE THIS LIST */ +/* WILL BE UPDATED. */ +/* --------------------------------------------------------------------------------- */ +void Dbacc::takeRecOutOfFreeOverpage(Signal* signal) +{ + OverflowRecordPtr tfoNextOverflowRecPtr; + OverflowRecordPtr tfoPrevOverflowRecPtr; + + if (tfoOverflowRecPtr.p->nextOverRec != RNIL) { + jam(); + tfoNextOverflowRecPtr.i = tfoOverflowRecPtr.p->nextOverRec; + ptrCheckGuard(tfoNextOverflowRecPtr, coverflowrecsize, overflowRecord); + tfoNextOverflowRecPtr.p->prevOverRec = tfoOverflowRecPtr.p->prevOverRec; + } else { + ndbrequire(fragrecptr.p->lastOverflowRec == tfoOverflowRecPtr.i); + jam(); + fragrecptr.p->lastOverflowRec = tfoOverflowRecPtr.p->prevOverRec; + }//if + if (tfoOverflowRecPtr.p->prevOverRec != RNIL) { + jam(); + tfoPrevOverflowRecPtr.i = tfoOverflowRecPtr.p->prevOverRec; + ptrCheckGuard(tfoPrevOverflowRecPtr, coverflowrecsize, overflowRecord); + tfoPrevOverflowRecPtr.p->nextOverRec = tfoOverflowRecPtr.p->nextOverRec; + } else { + ndbrequire(fragrecptr.p->firstOverflowRec == tfoOverflowRecPtr.i); + jam(); + fragrecptr.p->firstOverflowRec = tfoOverflowRecPtr.p->nextOverRec; + }//if +}//Dbacc::takeRecOutOfFreeOverpage() + +void +Dbacc::reportMemoryUsage(Signal* signal, int gth){ + signal->theData[0] = EventReport::MemoryUsage; + signal->theData[1] = gth; + signal->theData[2] = sizeof(* rpPageptr.p); + signal->theData[3] = cnoOfAllocatedPages; + signal->theData[4] = cpagesize; + signal->theData[5] = DBACC; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 6, JBB); +} + +void +Dbacc::execDUMP_STATE_ORD(Signal* signal) +{ + DumpStateOrd * const dumpState = (DumpStateOrd *)&signal->theData[0]; + if (dumpState->args[0] == DumpStateOrd::AccDumpOneScanRec){ + Uint32 recordNo = RNIL; + if (signal->length() == 2) + recordNo = dumpState->args[1]; + else + return; + + if (recordNo >= cscanRecSize) + return; + + scanPtr.i = recordNo; + ptrAss(scanPtr, scanRec); + infoEvent("Dbacc::ScanRec[%d]: state=%d, transid(0x%x, 0x%x)", + scanPtr.i, scanPtr.p->scanState,scanPtr.p->scanTrid1, + scanPtr.p->scanTrid2); + infoEvent(" timer=%d, continueBCount=%d, " + "activeLocalFrag=%d, root=%d, nextBucketIndex=%d", + scanPtr.p->scanTimer, + scanPtr.p->scanContinuebCounter, + scanPtr.p->activeLocalFrag, + scanPtr.p->rootPtr, + scanPtr.p->nextBucketIndex); + infoEvent(" scanNextfreerec=%d firstActOp=%d firstLockedOp=%d, " + "scanLastLockedOp=%d firstQOp=%d lastQOp=%d", + scanPtr.p->scanNextfreerec, + scanPtr.p->scanFirstActiveOp, + scanPtr.p->scanFirstLockedOp, + scanPtr.p->scanLastLockedOp, + scanPtr.p->scanFirstQueuedOp, + scanPtr.p->scanLastQueuedOp); + infoEvent(" scanUserP=%d, startNoBuck=%d, minBucketIndexToRescan=%d, " + "maxBucketIndexToRescan=%d", + scanPtr.p->scanUserptr, + scanPtr.p->startNoOfBuckets, + scanPtr.p->minBucketIndexToRescan, + scanPtr.p->maxBucketIndexToRescan); + infoEvent(" scanBucketState=%d, scanLockHeld=%d, userBlockRef=%d, " + "scanMask=%d scanLockMode=%d, keyInfoFlag=%d", + scanPtr.p->scanBucketState, + scanPtr.p->scanLockHeld, + scanPtr.p->scanUserblockref, + scanPtr.p->scanMask, + scanPtr.p->scanLockMode, + scanPtr.p->scanKeyinfoFlag); + return; + } + + // Dump all ScanRec(ords) + if (dumpState->args[0] == DumpStateOrd::AccDumpAllScanRec){ + Uint32 recordNo = 0; + if (signal->length() == 1) + infoEvent("ACC: Dump all ScanRec - size: %d", + cscanRecSize); + else if (signal->length() == 2) + recordNo = dumpState->args[1]; + else + return; + + dumpState->args[0] = DumpStateOrd::AccDumpOneScanRec; + dumpState->args[1] = recordNo; + execDUMP_STATE_ORD(signal); + + if (recordNo < cscanRecSize-1){ + dumpState->args[0] = DumpStateOrd::AccDumpAllScanRec; + dumpState->args[1] = recordNo+1; + sendSignal(reference(), GSN_DUMP_STATE_ORD, signal, 2, JBB); + } + return; + } + + // Dump all active ScanRec(ords) + if (dumpState->args[0] == DumpStateOrd::AccDumpAllActiveScanRec){ + Uint32 recordNo = 0; + if (signal->length() == 1) + infoEvent("ACC: Dump active ScanRec - size: %d", + cscanRecSize); + else if (signal->length() == 2) + recordNo = dumpState->args[1]; + else + return; + + ScanRecPtr sp; + sp.i = recordNo; + ptrAss(sp, scanRec); + if (sp.p->scanState != ScanRec::SCAN_DISCONNECT){ + dumpState->args[0] = DumpStateOrd::AccDumpOneScanRec; + dumpState->args[1] = recordNo; + execDUMP_STATE_ORD(signal); + } + + if (recordNo < cscanRecSize-1){ + dumpState->args[0] = DumpStateOrd::AccDumpAllActiveScanRec; + dumpState->args[1] = recordNo+1; + sendSignal(reference(), GSN_DUMP_STATE_ORD, signal, 2, JBB); + } + return; + } + + if(dumpState->args[0] == DumpStateOrd::DumpPageMemory){ + reportMemoryUsage(signal, 0); + return; + } + + if(dumpState->args[0] == DumpStateOrd::EnableUndoDelayDataWrite){ + ndbout << "Dbacc:: delay write of datapages for table = " + << dumpState->args[1]<< endl; + c_errorInsert3000_TableId = dumpState->args[1]; + SET_ERROR_INSERT_VALUE(3000); + return; + } + + if(dumpState->args[0] == DumpStateOrd::AccDumpOneOperationRec){ + Uint32 recordNo = RNIL; + if (signal->length() == 2) + recordNo = dumpState->args[1]; + else + return; + + if (recordNo >= coprecsize) + return; + + OperationrecPtr tmpOpPtr; + tmpOpPtr.i = recordNo; + ptrAss(tmpOpPtr, operationrec); + infoEvent("Dbacc::operationrec[%d]: opState=%d, transid(0x%x, 0x%x)", + tmpOpPtr.i, tmpOpPtr.p->opState, tmpOpPtr.p->transId1, + tmpOpPtr.p->transId2); + infoEvent("elementIsforward=%d, elementPage=%d, elementPointer=%d ", + tmpOpPtr.p->elementIsforward, tmpOpPtr.p->elementPage, + tmpOpPtr.p->elementPointer); + infoEvent("fid=%d, fragptr=%d, hashvaluePart=%d ", + tmpOpPtr.p->fid, tmpOpPtr.p->fragptr, + tmpOpPtr.p->hashvaluePart); + infoEvent("hashValue=%d, insertDeleteLen=%d, keyinfoPage=%d ", + tmpOpPtr.p->hashValue, tmpOpPtr.p->insertDeleteLen, + tmpOpPtr.p->keyinfoPage); + infoEvent("nextLockOwnerOp=%d, nextOp=%d, nextParallelQue=%d ", + tmpOpPtr.p->nextLockOwnerOp, tmpOpPtr.p->nextOp, + tmpOpPtr.p->nextParallelQue); + infoEvent("nextQueOp=%d, nextSerialQue=%d, prevOp=%d ", + tmpOpPtr.p->nextQueOp, tmpOpPtr.p->nextSerialQue, + tmpOpPtr.p->prevOp); + infoEvent("prevLockOwnerOp=%d, prevParallelQue=%d, prevQueOp=%d ", + tmpOpPtr.p->prevLockOwnerOp, tmpOpPtr.p->nextParallelQue, + tmpOpPtr.p->prevQueOp); + infoEvent("prevSerialQue=%d, scanRecPtr=%d, longPagePtr=%d ", + tmpOpPtr.p->prevSerialQue, tmpOpPtr.p->scanRecPtr, + tmpOpPtr.p->longPagePtr); + infoEvent("transactionstate=%d, elementIsDisappeared=%d, insertIsDone=%d ", + tmpOpPtr.p->transactionstate, tmpOpPtr.p->elementIsDisappeared, + tmpOpPtr.p->insertIsDone); + infoEvent("lockMode=%d, lockOwner=%d, nodeType=%d ", + tmpOpPtr.p->lockMode, tmpOpPtr.p->lockOwner, + tmpOpPtr.p->nodeType); + infoEvent("operation=%d, opSimple=%d, dirtyRead=%d,scanBits=%d ", + tmpOpPtr.p->operation, tmpOpPtr.p->opSimple, + tmpOpPtr.p->dirtyRead, tmpOpPtr.p->scanBits); + return; + } + + if(dumpState->args[0] == DumpStateOrd::AccDumpNumOpRecs){ + + Uint32 freeOpRecs = 0; + OperationrecPtr opRecPtr; + opRecPtr.i = cfreeopRec; + while (opRecPtr.i != RNIL){ + freeOpRecs++; + ptrCheckGuard(opRecPtr, coprecsize, operationrec); + opRecPtr.i = opRecPtr.p->nextOp; + } + + infoEvent("Dbacc::OperationRecords: num=%d, free=%d", + coprecsize, freeOpRecs); + + return; + } + if(dumpState->args[0] == DumpStateOrd::AccDumpFreeOpRecs){ + + OperationrecPtr opRecPtr; + opRecPtr.i = cfreeopRec; + while (opRecPtr.i != RNIL){ + + dumpState->args[0] = DumpStateOrd::AccDumpOneOperationRec; + dumpState->args[1] = opRecPtr.i; + execDUMP_STATE_ORD(signal); + + ptrCheckGuard(opRecPtr, coprecsize, operationrec); + opRecPtr.i = opRecPtr.p->nextOp; + } + + + return; + } + + if(dumpState->args[0] == DumpStateOrd::AccDumpNotFreeOpRecs){ + Uint32 recordStart = RNIL; + if (signal->length() == 2) + recordStart = dumpState->args[1]; + else + return; + + if (recordStart >= coprecsize) + return; + + for (Uint32 i = recordStart; i < coprecsize; i++){ + + bool inFreeList = false; + OperationrecPtr opRecPtr; + opRecPtr.i = cfreeopRec; + while (opRecPtr.i != RNIL){ + if (opRecPtr.i == i){ + inFreeList = true; + break; + } + ptrCheckGuard(opRecPtr, coprecsize, operationrec); + opRecPtr.i = opRecPtr.p->nextOp; + } + if (inFreeList == false){ + dumpState->args[0] = DumpStateOrd::AccDumpOneOperationRec; + dumpState->args[1] = i; + execDUMP_STATE_ORD(signal); + } + } + return; + } + +#if 0 + if (type == 100) { + RelTabMemReq * const req = (RelTabMemReq *)signal->getDataPtrSend(); + req->primaryTableId = 2; + req->secondaryTableId = RNIL; + req->userPtr = 2; + req->userRef = DBDICT_REF; + sendSignal(cownBlockref, GSN_REL_TABMEMREQ, signal, + RelTabMemReq::SignalLength, JBB); + return; + }//if + if (type == 101) { + RelTabMemReq * const req = (RelTabMemReq *)signal->getDataPtrSend(); + req->primaryTableId = 4; + req->secondaryTableId = 5; + req->userPtr = 4; + req->userRef = DBDICT_REF; + sendSignal(cownBlockref, GSN_REL_TABMEMREQ, signal, + RelTabMemReq::SignalLength, JBB); + return; + }//if + if (type == 102) { + RelTabMemReq * const req = (RelTabMemReq *)signal->getDataPtrSend(); + req->primaryTableId = 6; + req->secondaryTableId = 8; + req->userPtr = 6; + req->userRef = DBDICT_REF; + sendSignal(cownBlockref, GSN_REL_TABMEMREQ, signal, + RelTabMemReq::SignalLength, JBB); + return; + }//if + if (type == 103) { + DropTabFileReq * const req = (DropTabFileReq *)signal->getDataPtrSend(); + req->primaryTableId = 2; + req->secondaryTableId = RNIL; + req->userPtr = 2; + req->userRef = DBDICT_REF; + sendSignal(cownBlockref, GSN_DROP_TABFILEREQ, signal, + DropTabFileReq::SignalLength, JBB); + return; + }//if + if (type == 104) { + DropTabFileReq * const req = (DropTabFileReq *)signal->getDataPtrSend(); + req->primaryTableId = 4; + req->secondaryTableId = 5; + req->userPtr = 4; + req->userRef = DBDICT_REF; + sendSignal(cownBlockref, GSN_DROP_TABFILEREQ, signal, + DropTabFileReq::SignalLength, JBB); + return; + }//if + if (type == 105) { + DropTabFileReq * const req = (DropTabFileReq *)signal->getDataPtrSend(); + req->primaryTableId = 6; + req->secondaryTableId = 8; + req->userPtr = 6; + req->userRef = DBDICT_REF; + sendSignal(cownBlockref, GSN_DROP_TABFILEREQ, signal, + DropTabFileReq::SignalLength, JBB); + return; + }//if +#endif +}//Dbacc::execDUMP_STATE_ORD() + +void Dbacc::execSET_VAR_REQ(Signal* signal) +{ + SetVarReq* const setVarReq = (SetVarReq*)&signal->theData[0]; + ConfigParamId var = setVarReq->variable(); + int val = setVarReq->value(); + + + switch (var) { + + case NoOfDiskPagesToDiskAfterRestartACC: + clblPagesPerTick = val; + sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB); + break; + + case NoOfDiskPagesToDiskDuringRestartACC: + // Valid only during start so value not set. + sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB); + break; + + default: + sendSignal(CMVMI_REF, GSN_SET_VAR_REF, signal, 1, JBB); + } // switch + + +}//execSET_VAR_REQ() diff --git a/ndb/src/kernel/blocks/dbacc/Makefile b/ndb/src/kernel/blocks/dbacc/Makefile new file mode 100644 index 00000000000..93a830cec95 --- /dev/null +++ b/ndb/src/kernel/blocks/dbacc/Makefile @@ -0,0 +1,11 @@ +include .defs.mk + +TYPE := kernel + +ARCHIVE_TARGET := dbacc + +SOURCES = \ + DbaccInit.cpp \ + DbaccMain.cpp + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/kernel/blocks/dbdict/CreateIndex.txt b/ndb/src/kernel/blocks/dbdict/CreateIndex.txt new file mode 100644 index 00000000000..3d11e501c07 --- /dev/null +++ b/ndb/src/kernel/blocks/dbdict/CreateIndex.txt @@ -0,0 +1,152 @@ +Unique Hash Index +================= + +unique hash index X on T(A1,...,An) becomes: +table X with primary key A1,...,An and extra attribute NDB$PK + +NDB$PK is primary key of T concatenated at 4-byte boundaries + +Protocols: + +U - user, initiator of protocol +C - coordinator +P - participants, including coordinator node + +RT_ - request type, current state + +P always replies to C with current RT_ (initially RT_DICT_PREPARE) +C replies to U at the end + +CREATE INDEX +------------ + +U: RT_USER + +C: forward request to P's +P: check and reply + +C: invoke CREATE TABLE for index table + +C: invoke ALTER INDEX online + +C: send RT_DICT_COMMIT to P's +P: reply + +C: reply to U + +DROP INDEX +---------- + +[ todo ] + +ALTER INDEX online +------------------ + +U: RT_USER, RT_CREATE_INDEX, RT_NODERESTART, RT_SYSTEMRESTART + +C: forward request to P's +P: check and reply + +C: send RT_DICT_TC to P's +P: create index in local TC, and reply + +C: invoke CREATE TRIGGER for insert/update/delete triggers + +C: invoke BUILD INDEX + +C: send RT_DICT_COMMIT to P's +P: reply + +C: reply to U + +ALTER INDEX offline +------------------- + +[ todo ] + +BUILD INDEX +----------- + +U: RT_USER, RT_ALTER_INDEX + +C: forward request to P's +P: check and reply + +C: invoke CREATE TRIGGER for read-only constraint on NDB$PK + +C: send RT_DICT_TRIX to P's +P: build index via local TRIX, and reply + +C: invoke DROP TRIGGER for read-only constraint on NDB$PK + +C: send RT_DICT_TC to P's +P: online index in local TC, and reply + +CREATE TRIGGER +-------------- + +U: RT_USER, RT_ALTER_INDEX, RT_BUILD_INDEX + +C: forward request to P's +P: check and reply + +C: seize trigger id and send RT_DICT_CREATE to P's +P: create trigger in DICT (also connect to index record), and reply + +C: invoke ALTER TRIGGER online [ not if subscription trigger ] + +C: send RT_DICT_COMMIT to P's +P: reply + +C: reply to U + +DROP TRIGGER +------------ + +[ todo ] + +ALTER TRIGGER online +-------------------- + +U: RT_USER, RT_CREATE_TRIGGER + +C: forward request to P's +P: check and reply + +C: send RT_DICT_TC to P's +P: create trigger in local TC, and reply + +C: send RT_DICT_LQH to P's +P: create trigger in local LQH (which just forwards to TUP), and reply + +C: send RT_DICT_COMMIT to P's +P: reply + +C: reply to U + +ALTER TRIGGER offline +--------------------- + +[ todo ] + +Ordered Index << under work >> +============= + +created as DICT table, as before, to reuse the code + +keep NDB$PK as last attribute (not used but logically correct) + +create fragments and attributes must be modified + +global metadata? implemented but will use signals anyway + +create (after-) insert/update/delete triggers as DICT objects, as before + +skip following: +- create index in TC +- create triggers in TC +- read-only constraint on NDB$PK + +create (before-) commit trigger in TUP + +alter online (in TUX, instead of TC) is needed diff --git a/ndb/src/kernel/blocks/dbdict/CreateTable.new.txt b/ndb/src/kernel/blocks/dbdict/CreateTable.new.txt new file mode 100644 index 00000000000..d37732dcda1 --- /dev/null +++ b/ndb/src/kernel/blocks/dbdict/CreateTable.new.txt @@ -0,0 +1,29 @@ + +1) Receive from client (sequence of DICTTABINFO) + +2) CREATE_FRAGMENTATION_REQ -> local DIH + Returns all fragments for table + some other stuff + NOTE without side effects in DIH + +3) Pack table description + +4) CREATE_TAB -> all DICTs (including table data) + 1) Write schema file (ADD_STARTED) + 2) Write table descriptor to file + 3) CREATE_TAB (DIADDTABREQ) -> local DIH (including fragment info) + 4) DIH + 1) write table descriptor + 2) For each local fragment + ADD_FRAG -> local DICT + LQHFRAGREQ -> local LQH + LQHADDATTREQ -> local LQH + 5) TAB_COMMITREQ -> local LQH + +5) WAIT_GCP + +6) ALTER_TAB (activate) -> all DICTs + 1) Write schema file (CREATED) + 2) TAB_COMMITREQ -> local DIH + 3) TC_SCHVERREQ -> local TC + + diff --git a/ndb/src/kernel/blocks/dbdict/CreateTable.txt b/ndb/src/kernel/blocks/dbdict/CreateTable.txt new file mode 100644 index 00000000000..0b37e5d767f --- /dev/null +++ b/ndb/src/kernel/blocks/dbdict/CreateTable.txt @@ -0,0 +1,35 @@ + +1) Receive from client (sequence of DICTTABINFO) + +2) DICT_SCHEMAREQ -> all DICTs + Write ADD_STARTED in schema file + +3) Pack table description + +4) DICTTABINFO -> all DICTs (but self) (containing packed table info) + self -> Write 2 file + 1) Write 2 file + +5) DICT_SCHEMAREQ -> all DICTs + Write UPDATE_PAGE_COUNT in schema file + +6) DIADDTABREQ -> local DIH + 1) Create fragments + 2) For each fragment + DIHADDFRAGREQ -> all DIH + 3) For each fragment + DICTFRAGSREQ -> local DICT + 1) LQHFRAGREQ -> concerned LQH + 2) For each attribute + LQHADDATTREQ -> concerned LQH + +7) WAIT_GCP -> local DIH + +8) DICT_SCHEMAREQ -> all DICTs + Write TABLE_ADD_COMMITTED in schema file + +9) TAB_COMMITREQ -> all LQH & DIH + +10) TC_SCHVERREQ -> all TC + +11) UNBLO_DICTREQ -> all DICT diff --git a/ndb/src/kernel/blocks/dbdict/Dbdict.cpp b/ndb/src/kernel/blocks/dbdict/Dbdict.cpp new file mode 100644 index 00000000000..9a72d9deb50 --- /dev/null +++ b/ndb/src/kernel/blocks/dbdict/Dbdict.cpp @@ -0,0 +1,11628 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBDICT_C +#include "Dbdict.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +//#include + +#include + +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include "../dbtc/Dbtc.hpp" +#include + +#define ZNOT_FOUND 626 +#define ZALREADYEXIST 630 + +//#define EVENT_PH2_DEBUG +//#define EVENT_PH3_DEBUG +//#define EVENT_DEBUG + +#define EVENT_TRACE \ +// ndbout_c("Event debug trace: File: %s Line: %u", __FILE__, __LINE__) + +#define DIV(x,y) (((x)+(y)-1)/(y)) +#include + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* MODULE: GENERAL MODULE -------------------------------- */ +/* ---------------------------------------------------------------- */ +/* */ +/* This module contains general stuff. Mostly debug signals and */ +/* general signals that go into a specific module after checking a */ +/* state variable. Also general subroutines used by many. */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ + +/* ---------------------------------------------------------------- */ +// This signal is used to dump states of various variables in the +// block by command. +/* ---------------------------------------------------------------- */ +void +Dbdict::execDUMP_STATE_ORD(Signal* signal) +{ + jamEntry(); + +#ifdef NDB_DEBUG + if(signal->theData[0] == 1222){ + const Uint32 tab = signal->theData[1]; + PrepDropTabReq* req = (PrepDropTabReq*)signal->getDataPtr(); + req->senderRef = reference(); + req->senderData = 1222; + req->tableId = tab; + sendSignal(DBLQH_REF, GSN_PREP_DROP_TAB_REQ, signal, + PrepDropTabReq::SignalLength, JBB); + } + + if(signal->theData[0] == 1223){ + const Uint32 tab = signal->theData[1]; + PrepDropTabReq* req = (PrepDropTabReq*)signal->getDataPtr(); + req->senderRef = reference(); + req->senderData = 1222; + req->tableId = tab; + sendSignal(DBTC_REF, GSN_PREP_DROP_TAB_REQ, signal, + PrepDropTabReq::SignalLength, JBB); + } + + if(signal->theData[0] == 1224){ + const Uint32 tab = signal->theData[1]; + PrepDropTabReq* req = (PrepDropTabReq*)signal->getDataPtr(); + req->senderRef = reference(); + req->senderData = 1222; + req->tableId = tab; + sendSignal(DBDIH_REF, GSN_PREP_DROP_TAB_REQ, signal, + PrepDropTabReq::SignalLength, JBB); + } + + if(signal->theData[0] == 1225){ + const Uint32 tab = signal->theData[1]; + const Uint32 ver = signal->theData[2]; + TableRecordPtr tabRecPtr; + c_tableRecordPool.getPtr(tabRecPtr, tab); + DropTableReq * req = (DropTableReq*)signal->getDataPtr(); + req->senderData = 1225; + req->senderRef = numberToRef(1,1); + req->tableId = tab; + req->tableVersion = tabRecPtr.p->tableVersion + ver; + sendSignal(DBDICT_REF, GSN_DROP_TABLE_REQ, signal, + DropTableReq::SignalLength, JBB); + } +#endif + + return; +}//Dbdict::execDUMP_STATE_ORD() + +/* ---------------------------------------------------------------- */ +/* ---------------------------------------------------------------- */ +// CONTINUEB is used when a real-time break is needed for long +// processes. +/* ---------------------------------------------------------------- */ +/* ---------------------------------------------------------------- */ +void Dbdict::execCONTINUEB(Signal* signal) +{ + jamEntry(); + switch (signal->theData[0]) { + case ZPACK_TABLE_INTO_PAGES : + jam(); + packTableIntoPages(signal, signal->theData[1], signal->theData[2]); + break; + + case ZSEND_GET_TAB_RESPONSE : + jam(); + sendGetTabResponse(signal); + break; + + default : + ndbrequire(false); + break; + }//switch + return; +}//execCONTINUEB() + +/* ---------------------------------------------------------------- */ +/* ---------------------------------------------------------------- */ +// Routine to handle pack table into pages. +/* ---------------------------------------------------------------- */ +/* ---------------------------------------------------------------- */ + +void Dbdict::packTableIntoPages(Signal* signal, Uint32 tableId, Uint32 pageId) +{ + + PageRecordPtr pagePtr; + TableRecordPtr tablePtr; + c_pageRecordArray.getPtr(pagePtr, pageId); + + memset(&pagePtr.p->word[0], 0, 4 * ZPAGE_HEADER_SIZE); + c_tableRecordPool.getPtr(tablePtr, tableId); + LinearWriter w(&pagePtr.p->word[ZPAGE_HEADER_SIZE], + 8 * ZSIZE_OF_PAGES_IN_WORDS); + + w.first(); + packTableIntoPagesImpl(w, tablePtr); + + Uint32 wordsOfTable = w.getWordsUsed(); + Uint32 pagesUsed = + DIV(wordsOfTable + ZPAGE_HEADER_SIZE, ZSIZE_OF_PAGES_IN_WORDS); + pagePtr.p->word[ZPOS_CHECKSUM] = + computeChecksum(&pagePtr.p->word[0], pagesUsed * ZSIZE_OF_PAGES_IN_WORDS); + + switch (c_packTable.m_state) { + case PackTable::PTS_IDLE: + case PackTable::PTS_ADD_TABLE_MASTER: + case PackTable::PTS_ADD_TABLE_SLAVE: + case PackTable::PTS_RESTART: + ndbrequire(false); + break; + case PackTable::PTS_GET_TAB: + jam(); + c_retrieveRecord.retrievedNoOfPages = pagesUsed; + c_retrieveRecord.retrievedNoOfWords = wordsOfTable; + sendGetTabResponse(signal); + return; + break; + }//switch + ndbrequire(false); + return; +}//packTableIntoPages() + +void +Dbdict::packTableIntoPagesImpl(SimpleProperties::Writer & w, + TableRecordPtr tablePtr){ + + w.add(DictTabInfo::TableName, tablePtr.p->tableName); + w.add(DictTabInfo::TableId, tablePtr.i); + w.add(DictTabInfo::SecondTableId, tablePtr.p->secondTable); + w.add(DictTabInfo::TableVersion, tablePtr.p->tableVersion); + w.add(DictTabInfo::NoOfKeyAttr, tablePtr.p->noOfPrimkey); + w.add(DictTabInfo::NoOfAttributes, tablePtr.p->noOfAttributes); + w.add(DictTabInfo::NoOfNullable, tablePtr.p->noOfNullAttr); + w.add(DictTabInfo::NoOfVariable, (Uint32)0); + w.add(DictTabInfo::KeyLength, tablePtr.p->tupKeyLength); + + w.add(DictTabInfo::TableLoggedFlag, tablePtr.p->storedTable); + w.add(DictTabInfo::MinLoadFactor, tablePtr.p->minLoadFactor); + w.add(DictTabInfo::MaxLoadFactor, tablePtr.p->maxLoadFactor); + w.add(DictTabInfo::TableKValue, tablePtr.p->kValue); + w.add(DictTabInfo::FragmentTypeVal, tablePtr.p->fragmentType); + w.add(DictTabInfo::FragmentKeyTypeVal, tablePtr.p->fragmentKeyType); + w.add(DictTabInfo::TableTypeVal, tablePtr.p->tableType); + + if (tablePtr.p->primaryTableId != RNIL){ + TableRecordPtr primTab; + c_tableRecordPool.getPtr(primTab, tablePtr.p->primaryTableId); + w.add(DictTabInfo::PrimaryTable, primTab.p->tableName); + w.add(DictTabInfo::PrimaryTableId, tablePtr.p->primaryTableId); + w.add(DictTabInfo::IndexState, tablePtr.p->indexState); + w.add(DictTabInfo::InsertTriggerId, tablePtr.p->insertTriggerId); + w.add(DictTabInfo::UpdateTriggerId, tablePtr.p->updateTriggerId); + w.add(DictTabInfo::DeleteTriggerId, tablePtr.p->deleteTriggerId); + w.add(DictTabInfo::CustomTriggerId, tablePtr.p->customTriggerId); + } + w.add(DictTabInfo::FrmLen, tablePtr.p->frmLen); + w.add(DictTabInfo::FrmData, tablePtr.p->frmData, tablePtr.p->frmLen); + + Uint32 nextAttribute = tablePtr.p->firstAttribute; + AttributeRecordPtr attrPtr; + do { + jam(); + c_attributeRecordPool.getPtr(attrPtr, nextAttribute); + + w.add(DictTabInfo::AttributeName, attrPtr.p->attributeName); + w.add(DictTabInfo::AttributeId, attrPtr.p->attributeId); + w.add(DictTabInfo::AttributeKeyFlag, attrPtr.p->tupleKey > 0); + + const Uint32 desc = attrPtr.p->attributeDescriptor; + const Uint32 attrType = AttributeDescriptor::getType(desc); + const Uint32 attrSize = AttributeDescriptor::getSize(desc); + const Uint32 arraySize = AttributeDescriptor::getArraySize(desc); + const Uint32 nullable = AttributeDescriptor::getNullable(desc); + const Uint32 DGroup = AttributeDescriptor::getDGroup(desc); + const Uint32 DKey = AttributeDescriptor::getDKey(desc); + const Uint32 attrStoredInd = AttributeDescriptor::getStoredInTup(desc); + + w.add(DictTabInfo::AttributeType, attrType); + w.add(DictTabInfo::AttributeSize, attrSize); + w.add(DictTabInfo::AttributeArraySize, arraySize); + w.add(DictTabInfo::AttributeNullableFlag, nullable); + w.add(DictTabInfo::AttributeDGroup, DGroup); + w.add(DictTabInfo::AttributeDKey, DKey); + w.add(DictTabInfo::AttributeStoredInd, attrStoredInd); + w.add(DictTabInfo::AttributeExtType, attrPtr.p->extType); + w.add(DictTabInfo::AttributeExtPrecision, attrPtr.p->extPrecision); + w.add(DictTabInfo::AttributeExtScale, attrPtr.p->extScale); + w.add(DictTabInfo::AttributeExtLength, attrPtr.p->extLength); + w.add(DictTabInfo::AttributeAutoIncrement, + (Uint32)attrPtr.p->autoIncrement); + w.add(DictTabInfo::AttributeDefaultValue, attrPtr.p->defaultValue); + + w.add(DictTabInfo::AttributeEnd, 1); + nextAttribute = attrPtr.p->nextAttrInTable; + } while (nextAttribute != RNIL); + + w.add(DictTabInfo::TableEnd, 1); +} + +/* ---------------------------------------------------------------- */ +/* ---------------------------------------------------------------- */ +// The routines to handle responses from file system. +/* ---------------------------------------------------------------- */ +/* ---------------------------------------------------------------- */ + +/* ---------------------------------------------------------------- */ +// A file was successfully closed. +/* ---------------------------------------------------------------- */ +void Dbdict::execFSCLOSECONF(Signal* signal) +{ + FsConnectRecordPtr fsPtr; + FsConf * const fsConf = (FsConf *)&signal->theData[0]; + jamEntry(); + c_fsConnectRecordPool.getPtr(fsPtr, fsConf->userPointer); + switch (fsPtr.p->fsState) { + case FsConnectRecord::CLOSE_WRITE_SCHEMA: + jam(); + closeWriteSchemaConf(signal, fsPtr); + break; + case FsConnectRecord::CLOSE_READ_SCHEMA: + jam(); + closeReadSchemaConf(signal, fsPtr); + break; + case FsConnectRecord::CLOSE_READ_TAB_FILE: + jam(); + closeReadTableConf(signal, fsPtr); + break; + case FsConnectRecord::CLOSE_WRITE_TAB_FILE: + jam(); + closeWriteTableConf(signal, fsPtr); + break; + default: + jamLine((fsPtr.p->fsState & 0xFFF)); + ndbrequire(false); + break; + }//switch +}//execFSCLOSECONF() + +/* ---------------------------------------------------------------- */ +// A close file was refused. +/* ---------------------------------------------------------------- */ +void Dbdict::execFSCLOSEREF(Signal* signal) +{ + jamEntry(); + progError(0, 0); +}//execFSCLOSEREF() + +/* ---------------------------------------------------------------- */ +// A file was successfully opened. +/* ---------------------------------------------------------------- */ +void Dbdict::execFSOPENCONF(Signal* signal) +{ + FsConnectRecordPtr fsPtr; + jamEntry(); + FsConf * const fsConf = (FsConf *)&signal->theData[0]; + c_fsConnectRecordPool.getPtr(fsPtr, fsConf->userPointer); + + Uint32 filePointer = fsConf->filePointer; + fsPtr.p->filePtr = filePointer; + switch (fsPtr.p->fsState) { + case FsConnectRecord::OPEN_WRITE_SCHEMA: + jam(); + fsPtr.p->fsState = FsConnectRecord::WRITE_SCHEMA; + writeSchemaFile(signal, filePointer, fsPtr.i); + break; + case FsConnectRecord::OPEN_READ_SCHEMA1: + jam(); + fsPtr.p->fsState = FsConnectRecord::READ_SCHEMA1; + readSchemaFile(signal, filePointer, fsPtr.i); + break; + case FsConnectRecord::OPEN_READ_SCHEMA2: + jam(); + fsPtr.p->fsState = FsConnectRecord::READ_SCHEMA2; + readSchemaFile(signal, filePointer, fsPtr.i); + break; + case FsConnectRecord::OPEN_READ_TAB_FILE1: + jam(); + fsPtr.p->fsState = FsConnectRecord::READ_TAB_FILE1; + readTableFile(signal, filePointer, fsPtr.i); + break; + case FsConnectRecord::OPEN_READ_TAB_FILE2: + jam(); + fsPtr.p->fsState = FsConnectRecord::READ_TAB_FILE2; + readTableFile(signal, filePointer, fsPtr.i); + break; + case FsConnectRecord::OPEN_WRITE_TAB_FILE: + jam(); + fsPtr.p->fsState = FsConnectRecord::WRITE_TAB_FILE; + writeTableFile(signal, filePointer, fsPtr.i); + break; + default: + jamLine((fsPtr.p->fsState & 0xFFF)); + ndbrequire(false); + break; + }//switch +}//execFSOPENCONF() + +/* ---------------------------------------------------------------- */ +// An open file was refused. +/* ---------------------------------------------------------------- */ +void Dbdict::execFSOPENREF(Signal* signal) +{ + jamEntry(); + FsRef * const fsRef = (FsRef *)&signal->theData[0]; + FsConnectRecordPtr fsPtr; + c_fsConnectRecordPool.getPtr(fsPtr, fsRef->userPointer); + switch (fsPtr.p->fsState) { + case FsConnectRecord::OPEN_READ_SCHEMA1: + openReadSchemaRef(signal, fsPtr); + break; + case FsConnectRecord::OPEN_READ_TAB_FILE1: + jam(); + openReadTableRef(signal, fsPtr); + break; + default: + jamLine((fsPtr.p->fsState & 0xFFF)); + ndbrequire(false); + break; + }//switch +}//execFSOPENREF() + +/* ---------------------------------------------------------------- */ +// A file was successfully read. +/* ---------------------------------------------------------------- */ +void Dbdict::execFSREADCONF(Signal* signal) +{ + jamEntry(); + FsConf * const fsConf = (FsConf *)&signal->theData[0]; + FsConnectRecordPtr fsPtr; + c_fsConnectRecordPool.getPtr(fsPtr, fsConf->userPointer); + switch (fsPtr.p->fsState) { + case FsConnectRecord::READ_SCHEMA1: + case FsConnectRecord::READ_SCHEMA2: + readSchemaConf(signal ,fsPtr); + break; + case FsConnectRecord::READ_TAB_FILE1: + case FsConnectRecord::READ_TAB_FILE2: + jam(); + readTableConf(signal ,fsPtr); + break; + default: + jamLine((fsPtr.p->fsState & 0xFFF)); + ndbrequire(false); + break; + }//switch +}//execFSREADCONF() + +/* ---------------------------------------------------------------- */ +// A read file was refused. +/* ---------------------------------------------------------------- */ +void Dbdict::execFSREADREF(Signal* signal) +{ + jamEntry(); + FsRef * const fsRef = (FsRef *)&signal->theData[0]; + FsConnectRecordPtr fsPtr; + c_fsConnectRecordPool.getPtr(fsPtr, fsRef->userPointer); + switch (fsPtr.p->fsState) { + case FsConnectRecord::READ_SCHEMA1: + readSchemaRef(signal, fsPtr); + break; + case FsConnectRecord::READ_TAB_FILE1: + jam(); + readTableRef(signal, fsPtr); + break; + default: + jamLine((fsPtr.p->fsState & 0xFFF)); + ndbrequire(false); + break; + }//switch +}//execFSREADREF() + +/* ---------------------------------------------------------------- */ +// A file was successfully written. +/* ---------------------------------------------------------------- */ +void Dbdict::execFSWRITECONF(Signal* signal) +{ + FsConf * const fsConf = (FsConf *)&signal->theData[0]; + FsConnectRecordPtr fsPtr; + jamEntry(); + c_fsConnectRecordPool.getPtr(fsPtr, fsConf->userPointer); + switch (fsPtr.p->fsState) { + case FsConnectRecord::WRITE_TAB_FILE: + writeTableConf(signal, fsPtr); + break; + case FsConnectRecord::WRITE_SCHEMA: + jam(); + writeSchemaConf(signal, fsPtr); + break; + default: + jamLine((fsPtr.p->fsState & 0xFFF)); + ndbrequire(false); + break; + }//switch +}//execFSWRITECONF() + +/* ---------------------------------------------------------------- */ +// A write file was refused. +/* ---------------------------------------------------------------- */ +void Dbdict::execFSWRITEREF(Signal* signal) +{ + jamEntry(); + progError(0, 0); +}//execFSWRITEREF() + +/* ---------------------------------------------------------------- */ +// Routines to handle Read/Write of Table Files +/* ---------------------------------------------------------------- */ +void +Dbdict::writeTableFile(Signal* signal, Uint32 tableId, + SegmentedSectionPtr tabInfoPtr, Callback* callback){ + + ndbrequire(c_writeTableRecord.tableWriteState == WriteTableRecord::IDLE); + + Uint32 sz = tabInfoPtr.sz + ZPAGE_HEADER_SIZE; + + c_writeTableRecord.noOfPages = DIV(sz, ZSIZE_OF_PAGES_IN_WORDS); + c_writeTableRecord.tableWriteState = WriteTableRecord::CALLBACK; + c_writeTableRecord.m_callback = * callback; + + c_writeTableRecord.pageId = 0; + ndbrequire(c_writeTableRecord.noOfPages < 8); + + PageRecordPtr pageRecPtr; + c_pageRecordArray.getPtr(pageRecPtr, c_writeTableRecord.pageId); + copy(&pageRecPtr.p->word[ZPAGE_HEADER_SIZE], tabInfoPtr); + + memset(&pageRecPtr.p->word[0], 0, 4 * ZPAGE_HEADER_SIZE); + pageRecPtr.p->word[ZPOS_CHECKSUM] = + computeChecksum(&pageRecPtr.p->word[0], + c_writeTableRecord.noOfPages * ZSIZE_OF_PAGES_IN_WORDS); + + startWriteTableFile(signal, tableId); + +} + +void Dbdict::startWriteTableFile(Signal* signal, Uint32 tableId) +{ + FsConnectRecordPtr fsPtr; + c_writeTableRecord.tableId = tableId; + c_fsConnectRecordPool.getPtr(fsPtr, getFsConnRecord()); + fsPtr.p->fsState = FsConnectRecord::OPEN_WRITE_TAB_FILE; + openTableFile(signal, 0, fsPtr.i, tableId, true); + c_writeTableRecord.noOfTableFilesHandled = 0; +}//Dbdict::startWriteTableFile() + +void Dbdict::openTableFile(Signal* signal, + Uint32 fileNo, + Uint32 fsConPtr, + Uint32 tableId, + bool writeFlag) +{ + TableRecordPtr tablePtr; + FsOpenReq * const fsOpenReq = (FsOpenReq *)&signal->theData[0]; + c_tableRecordPool.getPtr(tablePtr, tableId); + + fsOpenReq->userReference = reference(); + fsOpenReq->userPointer = fsConPtr; + if (writeFlag) { + jam(); + fsOpenReq->fileFlags = + FsOpenReq::OM_WRITEONLY | + FsOpenReq::OM_TRUNCATE | + FsOpenReq::OM_CREATE | + FsOpenReq::OM_SYNC; + } else { + jam(); + fsOpenReq->fileFlags = FsOpenReq::OM_READONLY; + }//if + ndbrequire(tablePtr.p->tableVersion < ZNIL); + fsOpenReq->fileNumber[3] = 0; // Initialise before byte changes + FsOpenReq::setVersion(fsOpenReq->fileNumber, 1); + FsOpenReq::setSuffix(fsOpenReq->fileNumber, FsOpenReq::S_TABLELIST); + FsOpenReq::v1_setDisk(fsOpenReq->fileNumber, (fileNo + 1)); + FsOpenReq::v1_setTable(fsOpenReq->fileNumber, tableId); + FsOpenReq::v1_setFragment(fsOpenReq->fileNumber, (Uint32)-1); + FsOpenReq::v1_setS(fsOpenReq->fileNumber, tablePtr.p->tableVersion); + FsOpenReq::v1_setP(fsOpenReq->fileNumber, 255); +/* ---------------------------------------------------------------- */ +// File name : D1/DBDICT/T0/S1.TableList +// D1 means Disk 1 (set by fileNo + 1) +// T0 means table id = 0 +// S1 means tableVersion 1 +// TableList indicates that this is a file for a table description. +/* ---------------------------------------------------------------- */ + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, FsOpenReq::SignalLength, JBA); +}//openTableFile() + +void Dbdict::writeTableFile(Signal* signal, Uint32 filePtr, Uint32 fsConPtr) +{ + FsReadWriteReq * const fsRWReq = (FsReadWriteReq *)&signal->theData[0]; + + fsRWReq->filePointer = filePtr; + fsRWReq->userReference = reference(); + fsRWReq->userPointer = fsConPtr; + fsRWReq->operationFlag = 0; // Initialise before bit changes + FsReadWriteReq::setSyncFlag(fsRWReq->operationFlag, 1); + FsReadWriteReq::setFormatFlag(fsRWReq->operationFlag, + FsReadWriteReq::fsFormatArrayOfPages); + fsRWReq->varIndex = ZALLOCATE; + fsRWReq->numberOfPages = c_writeTableRecord.noOfPages; + fsRWReq->data.arrayOfPages.varIndex = c_writeTableRecord.pageId; + fsRWReq->data.arrayOfPages.fileOffset = 0; // Write to file page 0 + sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal, 8, JBA); +}//writeTableFile() + +void Dbdict::writeTableConf(Signal* signal, + FsConnectRecordPtr fsPtr) +{ + fsPtr.p->fsState = FsConnectRecord::CLOSE_WRITE_TAB_FILE; + closeFile(signal, fsPtr.p->filePtr, fsPtr.i); + return; +}//Dbdict::writeTableConf() + +void Dbdict::closeWriteTableConf(Signal* signal, + FsConnectRecordPtr fsPtr) +{ + c_writeTableRecord.noOfTableFilesHandled++; + if (c_writeTableRecord.noOfTableFilesHandled < 2) { + jam(); + fsPtr.p->fsState = FsConnectRecord::OPEN_WRITE_TAB_FILE; + openTableFile(signal, 1, fsPtr.i, c_writeTableRecord.tableId, true); + return; + } + ndbrequire(c_writeTableRecord.noOfTableFilesHandled == 2); + c_fsConnectRecordPool.release(fsPtr); + WriteTableRecord::TableWriteState state = c_writeTableRecord.tableWriteState; + c_writeTableRecord.tableWriteState = WriteTableRecord::IDLE; + switch (state) { + case WriteTableRecord::IDLE: + case WriteTableRecord::WRITE_ADD_TABLE_MASTER : + case WriteTableRecord::WRITE_ADD_TABLE_SLAVE : + case WriteTableRecord::WRITE_RESTART_FROM_MASTER : + case WriteTableRecord::WRITE_RESTART_FROM_OWN : + ndbrequire(false); + break; + case WriteTableRecord::CALLBACK: + jam(); + execute(signal, c_writeTableRecord.m_callback, 0); + return; + } + ndbrequire(false); +}//Dbdict::closeWriteTableConf() + +void Dbdict::startReadTableFile(Signal* signal, Uint32 tableId) +{ + //globalSignalLoggers.log(number(), "startReadTableFile"); + ndbrequire(!c_readTableRecord.inUse); + + FsConnectRecordPtr fsPtr; + c_fsConnectRecordPool.getPtr(fsPtr, getFsConnRecord()); + c_readTableRecord.inUse = true; + c_readTableRecord.tableId = tableId; + fsPtr.p->fsState = FsConnectRecord::OPEN_READ_TAB_FILE1; + openTableFile(signal, 0, fsPtr.i, tableId, false); +}//Dbdict::startReadTableFile() + +void Dbdict::openReadTableRef(Signal* signal, + FsConnectRecordPtr fsPtr) +{ + fsPtr.p->fsState = FsConnectRecord::OPEN_READ_TAB_FILE2; + openTableFile(signal, 1, fsPtr.i, c_readTableRecord.tableId, false); + return; +}//Dbdict::openReadTableConf() + +void Dbdict::readTableFile(Signal* signal, Uint32 filePtr, Uint32 fsConPtr) +{ + FsReadWriteReq * const fsRWReq = (FsReadWriteReq *)&signal->theData[0]; + + fsRWReq->filePointer = filePtr; + fsRWReq->userReference = reference(); + fsRWReq->userPointer = fsConPtr; + fsRWReq->operationFlag = 0; // Initialise before bit changes + FsReadWriteReq::setSyncFlag(fsRWReq->operationFlag, 0); + FsReadWriteReq::setFormatFlag(fsRWReq->operationFlag, + FsReadWriteReq::fsFormatArrayOfPages); + fsRWReq->varIndex = ZALLOCATE; + fsRWReq->numberOfPages = c_readTableRecord.noOfPages; + fsRWReq->data.arrayOfPages.varIndex = c_readTableRecord.pageId; + fsRWReq->data.arrayOfPages.fileOffset = 0; // Write to file page 0 + sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 8, JBA); +}//readTableFile() + +void Dbdict::readTableConf(Signal* signal, + FsConnectRecordPtr fsPtr) +{ + /* ---------------------------------------------------------------- */ + // Verify the data read from disk + /* ---------------------------------------------------------------- */ + bool crashInd; + if (fsPtr.p->fsState == FsConnectRecord::READ_TAB_FILE1) { + jam(); + crashInd = false; + } else { + jam(); + crashInd = true; + }//if + + PageRecordPtr tmpPagePtr; + c_pageRecordArray.getPtr(tmpPagePtr, c_readTableRecord.pageId); + Uint32 sz = c_readTableRecord.noOfPages * ZSIZE_OF_PAGES_IN_WORDS; + Uint32 chk = computeChecksum((const Uint32*)tmpPagePtr.p, sz); + + ndbrequire((chk == 0) || !crashInd); + if(chk != 0){ + jam(); + ndbrequire(fsPtr.p->fsState == FsConnectRecord::READ_TAB_FILE1); + readTableRef(signal, fsPtr); + return; + }//if + + fsPtr.p->fsState = FsConnectRecord::CLOSE_READ_TAB_FILE; + closeFile(signal, fsPtr.p->filePtr, fsPtr.i); + return; +}//Dbdict::readTableConf() + +void Dbdict::readTableRef(Signal* signal, + FsConnectRecordPtr fsPtr) +{ + fsPtr.p->fsState = FsConnectRecord::OPEN_READ_TAB_FILE2; + openTableFile(signal, 1, fsPtr.i, c_readTableRecord.tableId, false); + return; +}//Dbdict::readTableRef() + +void Dbdict::closeReadTableConf(Signal* signal, + FsConnectRecordPtr fsPtr) +{ + c_fsConnectRecordPool.release(fsPtr); + c_readTableRecord.inUse = false; + + execute(signal, c_readTableRecord.m_callback, 0); + return; +}//Dbdict::closeReadTableConf() + +/* ---------------------------------------------------------------- */ +// Routines to handle Read/Write of Schema Files +/* ---------------------------------------------------------------- */ +void +Dbdict::updateSchemaState(Signal* signal, Uint32 tableId, + SchemaFile::TableEntry* te, Callback* callback){ + + jam(); + PageRecordPtr pagePtr; + c_pageRecordArray.getPtr(pagePtr, c_schemaRecord.schemaPage); + + ndbrequire(tableId < c_tableRecordPool.getSize()); + SchemaFile::TableEntry * tableEntry = getTableEntry(pagePtr.p, tableId); + + SchemaFile::TableState newState = + (SchemaFile::TableState)te->m_tableState; + SchemaFile::TableState oldState = + (SchemaFile::TableState)tableEntry->m_tableState; + + Uint32 newVersion = te->m_tableVersion; + Uint32 oldVersion = tableEntry->m_tableVersion; + + bool ok = false; + switch(newState){ + case SchemaFile::ADD_STARTED: + jam(); + ok = true; + ndbrequire((oldVersion + 1) == newVersion); + ndbrequire(oldState == SchemaFile::INIT || + oldState == SchemaFile::DROP_TABLE_COMMITTED); + break; + case SchemaFile::TABLE_ADD_COMMITTED: + jam(); + ok = true; + ndbrequire(newVersion == oldVersion); + ndbrequire(oldState == SchemaFile::ADD_STARTED); + break; + case SchemaFile::ALTER_TABLE_COMMITTED: + jam(); + ok = true; + ndbrequire((oldVersion + 1) == newVersion); + ndbrequire(oldState == SchemaFile::TABLE_ADD_COMMITTED || + oldState == SchemaFile::ALTER_TABLE_COMMITTED); + break; + case SchemaFile::DROP_TABLE_STARTED: + jam(); + case SchemaFile::DROP_TABLE_COMMITTED: + jam(); + ok = true; + ndbrequire(false); + break; + case SchemaFile::INIT: + jam(); + ok = true; + ndbrequire((oldState == SchemaFile::ADD_STARTED)); + }//if + ndbrequire(ok); + + * tableEntry = * te; + computeChecksum((SchemaFile*)pagePtr.p); + + ndbrequire(c_writeSchemaRecord.inUse == false); + c_writeSchemaRecord.inUse = true; + + c_writeSchemaRecord.pageId = c_schemaRecord.schemaPage; + c_writeSchemaRecord.m_callback = * callback; + + startWriteSchemaFile(signal); +} + +void Dbdict::startWriteSchemaFile(Signal* signal) +{ + FsConnectRecordPtr fsPtr; + c_fsConnectRecordPool.getPtr(fsPtr, getFsConnRecord()); + fsPtr.p->fsState = FsConnectRecord::OPEN_WRITE_SCHEMA; + openSchemaFile(signal, 0, fsPtr.i, true); + c_writeSchemaRecord.noOfSchemaFilesHandled = 0; +}//Dbdict::startWriteSchemaFile() + +void Dbdict::openSchemaFile(Signal* signal, + Uint32 fileNo, + Uint32 fsConPtr, + bool writeFlag) +{ + FsOpenReq * const fsOpenReq = (FsOpenReq *)&signal->theData[0]; + fsOpenReq->userReference = reference(); + fsOpenReq->userPointer = fsConPtr; + if (writeFlag) { + jam(); + fsOpenReq->fileFlags = + FsOpenReq::OM_WRITEONLY | + FsOpenReq::OM_TRUNCATE | + FsOpenReq::OM_CREATE | + FsOpenReq::OM_SYNC; + } else { + jam(); + fsOpenReq->fileFlags = FsOpenReq::OM_READONLY; + }//if + fsOpenReq->fileNumber[3] = 0; // Initialise before byte changes + FsOpenReq::setVersion(fsOpenReq->fileNumber, 1); + FsOpenReq::setSuffix(fsOpenReq->fileNumber, FsOpenReq::S_SCHEMALOG); + FsOpenReq::v1_setDisk(fsOpenReq->fileNumber, (fileNo + 1)); + FsOpenReq::v1_setTable(fsOpenReq->fileNumber, (Uint32)-1); + FsOpenReq::v1_setFragment(fsOpenReq->fileNumber, (Uint32)-1); + FsOpenReq::v1_setS(fsOpenReq->fileNumber, (Uint32)-1); + FsOpenReq::v1_setP(fsOpenReq->fileNumber, 0); +/* ---------------------------------------------------------------- */ +// File name : D1/DBDICT/P0.SchemaLog +// D1 means Disk 1 (set by fileNo + 1). Writes to both D1 and D2 +// SchemaLog indicates that this is a file giving a list of current tables. +/* ---------------------------------------------------------------- */ + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, FsOpenReq::SignalLength, JBA); +}//openSchemaFile() + +void Dbdict::writeSchemaFile(Signal* signal, Uint32 filePtr, Uint32 fsConPtr) +{ + FsReadWriteReq * const fsRWReq = (FsReadWriteReq *)&signal->theData[0]; + + fsRWReq->filePointer = filePtr; + fsRWReq->userReference = reference(); + fsRWReq->userPointer = fsConPtr; + fsRWReq->operationFlag = 0; // Initialise before bit changes + FsReadWriteReq::setSyncFlag(fsRWReq->operationFlag, 1); + FsReadWriteReq::setFormatFlag(fsRWReq->operationFlag, + FsReadWriteReq::fsFormatArrayOfPages); + fsRWReq->varIndex = ZALLOCATE; + fsRWReq->numberOfPages = 1; +// Write from memory page + fsRWReq->data.arrayOfPages.varIndex = c_writeSchemaRecord.pageId; + fsRWReq->data.arrayOfPages.fileOffset = 0; // Write to file page 0 + sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal, 8, JBA); +}//writeSchemaFile() + +void Dbdict::writeSchemaConf(Signal* signal, + FsConnectRecordPtr fsPtr) +{ + fsPtr.p->fsState = FsConnectRecord::CLOSE_WRITE_SCHEMA; + closeFile(signal, fsPtr.p->filePtr, fsPtr.i); + return; +}//Dbdict::writeSchemaConf() + +void Dbdict::closeFile(Signal* signal, Uint32 filePtr, Uint32 fsConPtr) +{ + FsCloseReq * const fsCloseReq = (FsCloseReq *)&signal->theData[0]; + fsCloseReq->filePointer = filePtr; + fsCloseReq->userReference = reference(); + fsCloseReq->userPointer = fsConPtr; + FsCloseReq::setRemoveFileFlag(fsCloseReq->fileFlag, false); + sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, FsCloseReq::SignalLength, JBA); + return; +}//closeFile() + +void Dbdict::closeWriteSchemaConf(Signal* signal, + FsConnectRecordPtr fsPtr) +{ + c_writeSchemaRecord.noOfSchemaFilesHandled++; + if (c_writeSchemaRecord.noOfSchemaFilesHandled < 2) { + jam(); + fsPtr.p->fsState = FsConnectRecord::OPEN_WRITE_SCHEMA; + openSchemaFile(signal, 1, fsPtr.i, true); + return; + } + ndbrequire(c_writeSchemaRecord.noOfSchemaFilesHandled == 2); + + c_fsConnectRecordPool.release(fsPtr); + + c_writeSchemaRecord.inUse = false; + execute(signal, c_writeSchemaRecord.m_callback, 0); + return; +}//Dbdict::closeWriteSchemaConf() + +void Dbdict::startReadSchemaFile(Signal* signal) +{ + //globalSignalLoggers.log(number(), "startReadSchemaFile"); + FsConnectRecordPtr fsPtr; + c_fsConnectRecordPool.getPtr(fsPtr, getFsConnRecord()); + fsPtr.p->fsState = FsConnectRecord::OPEN_READ_SCHEMA1; + openSchemaFile(signal, 0, fsPtr.i, false); +}//Dbdict::startReadSchemaFile() + +void Dbdict::openReadSchemaRef(Signal* signal, + FsConnectRecordPtr fsPtr) +{ + fsPtr.p->fsState = FsConnectRecord::OPEN_READ_SCHEMA2; + openSchemaFile(signal, 1, fsPtr.i, false); +}//Dbdict::openReadSchemaRef() + +void Dbdict::readSchemaFile(Signal* signal, Uint32 filePtr, Uint32 fsConPtr) +{ + FsReadWriteReq * const fsRWReq = (FsReadWriteReq *)&signal->theData[0]; + + fsRWReq->filePointer = filePtr; + fsRWReq->userReference = reference(); + fsRWReq->userPointer = fsConPtr; + fsRWReq->operationFlag = 0; // Initialise before bit changes + FsReadWriteReq::setSyncFlag(fsRWReq->operationFlag, 0); + FsReadWriteReq::setFormatFlag(fsRWReq->operationFlag, + FsReadWriteReq::fsFormatArrayOfPages); + fsRWReq->varIndex = ZALLOCATE; + fsRWReq->numberOfPages = 1; + fsRWReq->data.arrayOfPages.varIndex = c_readSchemaRecord.pageId; + fsRWReq->data.arrayOfPages.fileOffset = 0; + sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 8, JBA); +}//readSchemaFile() + +void Dbdict::readSchemaConf(Signal* signal, + FsConnectRecordPtr fsPtr) +{ +/* ---------------------------------------------------------------- */ +// Verify the data read from disk +/* ---------------------------------------------------------------- */ + bool crashInd; + if (fsPtr.p->fsState == FsConnectRecord::READ_SCHEMA1) { + jam(); + crashInd = false; + } else { + jam(); + crashInd = true; + }//if + PageRecordPtr tmpPagePtr; + c_pageRecordArray.getPtr(tmpPagePtr, c_readSchemaRecord.pageId); + + Uint32 sz = ZSIZE_OF_PAGES_IN_WORDS; + Uint32 chk = computeChecksum((const Uint32*)tmpPagePtr.p, sz); + + ndbrequire((chk == 0) || !crashInd); + + if (chk != 0){ + jam(); + ndbrequire(fsPtr.p->fsState == FsConnectRecord::READ_SCHEMA1); + readSchemaRef(signal, fsPtr); + return; + }//if + fsPtr.p->fsState = FsConnectRecord::CLOSE_READ_SCHEMA; + closeFile(signal, fsPtr.p->filePtr, fsPtr.i); + return; +}//Dbdict::readSchemaConf() + +void Dbdict::readSchemaRef(Signal* signal, + FsConnectRecordPtr fsPtr) +{ + fsPtr.p->fsState = FsConnectRecord::OPEN_READ_SCHEMA2; + openSchemaFile(signal, 1, fsPtr.i, false); + return; +}//Dbdict::readSchemaRef() + +void Dbdict::closeReadSchemaConf(Signal* signal, + FsConnectRecordPtr fsPtr) +{ + c_fsConnectRecordPool.release(fsPtr); + ReadSchemaRecord::SchemaReadState state = c_readSchemaRecord.schemaReadState; + c_readSchemaRecord.schemaReadState = ReadSchemaRecord::IDLE; + + switch(state) { + case ReadSchemaRecord::INITIAL_READ : + jam(); + sendNDB_STTORRY(signal); + break; + + default : + ndbrequire(false); + break; + + }//switch +}//Dbdict::closeReadSchemaConf() + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* MODULE: INITIALISATION MODULE ------------------------- */ +/* ---------------------------------------------------------------- */ +/* */ +/* This module contains initialisation of data at start/restart. */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ + +Dbdict::Dbdict(const class Configuration & conf): + SimulatedBlock(DBDICT, conf), + c_tableRecordHash(c_tableRecordPool), + c_attributeRecordHash(c_attributeRecordPool), + c_triggerRecordHash(c_triggerRecordPool), + c_opCreateTable(c_opRecordPool), + c_opDropTable(c_opRecordPool), + c_opCreateIndex(c_opRecordPool), + c_opDropIndex(c_opRecordPool), + c_opAlterIndex(c_opRecordPool), + c_opBuildIndex(c_opRecordPool), + c_opCreateEvent(c_opRecordPool), + c_opSubEvent(c_opRecordPool), + c_opDropEvent(c_opRecordPool), + c_opSignalUtil(c_opRecordPool), + c_opCreateTrigger(c_opRecordPool), + c_opDropTrigger(c_opRecordPool), + c_opAlterTrigger(c_opRecordPool), + c_opRecordSequence(0) +{ + BLOCK_CONSTRUCTOR(Dbdict); + + const Properties * p = conf.getOwnProperties(); + ndbrequire(p != 0); + + p->get("MaxNoOfTriggers", &c_maxNoOfTriggers); + // Transit signals + addRecSignal(GSN_DUMP_STATE_ORD, &Dbdict::execDUMP_STATE_ORD); + addRecSignal(GSN_GET_TABINFOREQ, &Dbdict::execGET_TABINFOREQ); + addRecSignal(GSN_GET_TABLEID_REQ, &Dbdict::execGET_TABLEDID_REQ); + addRecSignal(GSN_GET_TABINFO_CONF, &Dbdict::execGET_TABINFO_CONF); + addRecSignal(GSN_CONTINUEB, &Dbdict::execCONTINUEB); + + addRecSignal(GSN_CREATE_TABLE_REQ, &Dbdict::execCREATE_TABLE_REQ); + addRecSignal(GSN_CREATE_TAB_REQ, &Dbdict::execCREATE_TAB_REQ); + addRecSignal(GSN_CREATE_TAB_REF, &Dbdict::execCREATE_TAB_REF); + addRecSignal(GSN_CREATE_TAB_CONF, &Dbdict::execCREATE_TAB_CONF); + addRecSignal(GSN_CREATE_FRAGMENTATION_REF, &Dbdict::execCREATE_FRAGMENTATION_REF); + addRecSignal(GSN_CREATE_FRAGMENTATION_CONF, &Dbdict::execCREATE_FRAGMENTATION_CONF); + addRecSignal(GSN_DIADDTABCONF, &Dbdict::execDIADDTABCONF); + addRecSignal(GSN_DIADDTABREF, &Dbdict::execDIADDTABREF); + addRecSignal(GSN_ADD_FRAGREQ, &Dbdict::execADD_FRAGREQ); + addRecSignal(GSN_TAB_COMMITCONF, &Dbdict::execTAB_COMMITCONF); + addRecSignal(GSN_TAB_COMMITREF, &Dbdict::execTAB_COMMITREF); + addRecSignal(GSN_ALTER_TABLE_REQ, &Dbdict::execALTER_TABLE_REQ); + addRecSignal(GSN_ALTER_TAB_REQ, &Dbdict::execALTER_TAB_REQ); + addRecSignal(GSN_ALTER_TAB_REF, &Dbdict::execALTER_TAB_REF); + addRecSignal(GSN_ALTER_TAB_CONF, &Dbdict::execALTER_TAB_CONF); + + // Index signals + addRecSignal(GSN_CREATE_INDX_REQ, &Dbdict::execCREATE_INDX_REQ); + addRecSignal(GSN_CREATE_INDX_CONF, &Dbdict::execCREATE_INDX_CONF); + addRecSignal(GSN_CREATE_INDX_REF, &Dbdict::execCREATE_INDX_REF); + + addRecSignal(GSN_ALTER_INDX_REQ, &Dbdict::execALTER_INDX_REQ); + addRecSignal(GSN_ALTER_INDX_CONF, &Dbdict::execALTER_INDX_CONF); + addRecSignal(GSN_ALTER_INDX_REF, &Dbdict::execALTER_INDX_REF); + + addRecSignal(GSN_CREATE_TABLE_CONF, &Dbdict::execCREATE_TABLE_CONF); + addRecSignal(GSN_CREATE_TABLE_REF, &Dbdict::execCREATE_TABLE_REF); + + addRecSignal(GSN_DROP_INDX_REQ, &Dbdict::execDROP_INDX_REQ); + addRecSignal(GSN_DROP_INDX_CONF, &Dbdict::execDROP_INDX_CONF); + addRecSignal(GSN_DROP_INDX_REF, &Dbdict::execDROP_INDX_REF); + + addRecSignal(GSN_DROP_TABLE_CONF, &Dbdict::execDROP_TABLE_CONF); + addRecSignal(GSN_DROP_TABLE_REF, &Dbdict::execDROP_TABLE_REF); + + addRecSignal(GSN_BUILDINDXREQ, &Dbdict::execBUILDINDXREQ); + addRecSignal(GSN_BUILDINDXCONF, &Dbdict::execBUILDINDXCONF); + addRecSignal(GSN_BUILDINDXREF, &Dbdict::execBUILDINDXREF); + + // Util signals + addRecSignal(GSN_UTIL_PREPARE_CONF, &Dbdict::execUTIL_PREPARE_CONF); + addRecSignal(GSN_UTIL_PREPARE_REF, &Dbdict::execUTIL_PREPARE_REF); + + addRecSignal(GSN_UTIL_EXECUTE_CONF, &Dbdict::execUTIL_EXECUTE_CONF); + addRecSignal(GSN_UTIL_EXECUTE_REF, &Dbdict::execUTIL_EXECUTE_REF); + + addRecSignal(GSN_UTIL_RELEASE_CONF, &Dbdict::execUTIL_RELEASE_CONF); + addRecSignal(GSN_UTIL_RELEASE_REF, &Dbdict::execUTIL_RELEASE_REF); + + // Event signals + addRecSignal(GSN_CREATE_EVNT_REQ, &Dbdict::execCREATE_EVNT_REQ); + addRecSignal(GSN_CREATE_EVNT_CONF, &Dbdict::execCREATE_EVNT_CONF); + addRecSignal(GSN_CREATE_EVNT_REF, &Dbdict::execCREATE_EVNT_REF); + + addRecSignal(GSN_CREATE_SUBID_CONF, &Dbdict::execCREATE_SUBID_CONF); + addRecSignal(GSN_CREATE_SUBID_REF, &Dbdict::execCREATE_SUBID_REF); + + addRecSignal(GSN_SUB_CREATE_CONF, &Dbdict::execSUB_CREATE_CONF); + addRecSignal(GSN_SUB_CREATE_REF, &Dbdict::execSUB_CREATE_REF); + + addRecSignal(GSN_SUB_START_REQ, &Dbdict::execSUB_START_REQ); + addRecSignal(GSN_SUB_START_CONF, &Dbdict::execSUB_START_CONF); + addRecSignal(GSN_SUB_START_REF, &Dbdict::execSUB_START_REF); + + addRecSignal(GSN_SUB_STOP_REQ, &Dbdict::execSUB_STOP_REQ); + addRecSignal(GSN_SUB_STOP_CONF, &Dbdict::execSUB_STOP_CONF); + addRecSignal(GSN_SUB_STOP_REF, &Dbdict::execSUB_STOP_REF); + + addRecSignal(GSN_SUB_SYNC_CONF, &Dbdict::execSUB_SYNC_CONF); + addRecSignal(GSN_SUB_SYNC_REF, &Dbdict::execSUB_SYNC_REF); + + addRecSignal(GSN_DROP_EVNT_REQ, &Dbdict::execDROP_EVNT_REQ); + + addRecSignal(GSN_SUB_REMOVE_REQ, &Dbdict::execSUB_REMOVE_REQ); + addRecSignal(GSN_SUB_REMOVE_CONF, &Dbdict::execSUB_REMOVE_CONF); + addRecSignal(GSN_SUB_REMOVE_REF, &Dbdict::execSUB_REMOVE_REF); + + // Trigger signals + addRecSignal(GSN_CREATE_TRIG_REQ, &Dbdict::execCREATE_TRIG_REQ); + addRecSignal(GSN_CREATE_TRIG_CONF, &Dbdict::execCREATE_TRIG_CONF); + addRecSignal(GSN_CREATE_TRIG_REF, &Dbdict::execCREATE_TRIG_REF); + addRecSignal(GSN_ALTER_TRIG_REQ, &Dbdict::execALTER_TRIG_REQ); + addRecSignal(GSN_ALTER_TRIG_CONF, &Dbdict::execALTER_TRIG_CONF); + addRecSignal(GSN_ALTER_TRIG_REF, &Dbdict::execALTER_TRIG_REF); + addRecSignal(GSN_DROP_TRIG_REQ, &Dbdict::execDROP_TRIG_REQ); + addRecSignal(GSN_DROP_TRIG_CONF, &Dbdict::execDROP_TRIG_CONF); + addRecSignal(GSN_DROP_TRIG_REF, &Dbdict::execDROP_TRIG_REF); + + // Received signals + addRecSignal(GSN_HOT_SPAREREP, &Dbdict::execHOT_SPAREREP); + addRecSignal(GSN_GET_SCHEMA_INFOREQ, &Dbdict::execGET_SCHEMA_INFOREQ); + addRecSignal(GSN_SCHEMA_INFO, &Dbdict::execSCHEMA_INFO); + addRecSignal(GSN_SCHEMA_INFOCONF, &Dbdict::execSCHEMA_INFOCONF); + addRecSignal(GSN_DICTSTARTREQ, &Dbdict::execDICTSTARTREQ); + addRecSignal(GSN_READ_NODESCONF, &Dbdict::execREAD_NODESCONF); + addRecSignal(GSN_FSOPENCONF, &Dbdict::execFSOPENCONF); + addRecSignal(GSN_FSOPENREF, &Dbdict::execFSOPENREF); + addRecSignal(GSN_FSCLOSECONF, &Dbdict::execFSCLOSECONF); + addRecSignal(GSN_FSCLOSEREF, &Dbdict::execFSCLOSEREF); + addRecSignal(GSN_FSWRITECONF, &Dbdict::execFSWRITECONF); + addRecSignal(GSN_FSWRITEREF, &Dbdict::execFSWRITEREF); + addRecSignal(GSN_FSREADCONF, &Dbdict::execFSREADCONF); + addRecSignal(GSN_FSREADREF, &Dbdict::execFSREADREF); + addRecSignal(GSN_LQHFRAGCONF, &Dbdict::execLQHFRAGCONF); + addRecSignal(GSN_LQHADDATTCONF, &Dbdict::execLQHADDATTCONF); + addRecSignal(GSN_LQHADDATTREF, &Dbdict::execLQHADDATTREF); + addRecSignal(GSN_LQHFRAGREF, &Dbdict::execLQHFRAGREF); + addRecSignal(GSN_NDB_STTOR, &Dbdict::execNDB_STTOR); + addRecSignal(GSN_SIZEALT_REP, &Dbdict::execSIZEALT_REP); + addRecSignal(GSN_STTOR, &Dbdict::execSTTOR); + addRecSignal(GSN_TC_SCHVERCONF, &Dbdict::execTC_SCHVERCONF); + addRecSignal(GSN_NODE_FAILREP, &Dbdict::execNODE_FAILREP); + addRecSignal(GSN_INCL_NODEREQ, &Dbdict::execINCL_NODEREQ); + addRecSignal(GSN_API_FAILREQ, &Dbdict::execAPI_FAILREQ); + + addRecSignal(GSN_WAIT_GCP_REF, &Dbdict::execWAIT_GCP_REF); + addRecSignal(GSN_WAIT_GCP_CONF, &Dbdict::execWAIT_GCP_CONF); + + addRecSignal(GSN_LIST_TABLES_REQ, &Dbdict::execLIST_TABLES_REQ); + + addRecSignal(GSN_DROP_TABLE_REQ, &Dbdict::execDROP_TABLE_REQ); + + addRecSignal(GSN_PREP_DROP_TAB_REQ, &Dbdict::execPREP_DROP_TAB_REQ); + addRecSignal(GSN_PREP_DROP_TAB_REF, &Dbdict::execPREP_DROP_TAB_REF); + addRecSignal(GSN_PREP_DROP_TAB_CONF, &Dbdict::execPREP_DROP_TAB_CONF); + + addRecSignal(GSN_DROP_TAB_REQ, &Dbdict::execDROP_TAB_REQ); + addRecSignal(GSN_DROP_TAB_REF, &Dbdict::execDROP_TAB_REF); + addRecSignal(GSN_DROP_TAB_CONF, &Dbdict::execDROP_TAB_CONF); +}//Dbdict::Dbdict() + +Dbdict::~Dbdict() +{ +}//Dbdict::~Dbdict() + +BLOCK_FUNCTIONS(Dbdict); + +void Dbdict::initCommonData() +{ +/* ---------------------------------------------------------------- */ +// Initialise all common variables. +/* ---------------------------------------------------------------- */ + initRetrieveRecord(0, 0, 0); + initSchemaRecord(); + initRestartRecord(); + initSendSchemaRecord(); + initReadTableRecord(); + initWriteTableRecord(); + initReadSchemaRecord(); + initWriteSchemaRecord(); + + c_masterNodeId = ZNIL; + c_numberNode = 0; + c_noNodesFailed = 0; + c_failureNr = 0; + c_blockState = BS_IDLE; + c_packTable.m_state = PackTable::PTS_IDLE; + c_startPhase = 0; + c_restartType = 255; //Ensure not used restartType + c_tabinfoReceived = 0; + c_initialStart = false; + c_systemRestart = false; + c_initialNodeRestart = false; + c_nodeRestart = false; +}//Dbdict::initCommonData() + +void Dbdict::initRecords() +{ + initNodeRecords(); + initPageRecords(); + initTableRecords(); + initTriggerRecords(); +}//Dbdict::initRecords() + +void Dbdict::initSendSchemaRecord() +{ + c_sendSchemaRecord.noOfWords = (Uint32)-1; + c_sendSchemaRecord.pageId = RNIL; + c_sendSchemaRecord.noOfWordsCurrentlySent = 0; + c_sendSchemaRecord.noOfSignalsSentSinceDelay = 0; + c_sendSchemaRecord.inUse = false; + //c_sendSchemaRecord.sendSchemaState = SendSchemaRecord::IDLE; +}//initSendSchemaRecord() + +void Dbdict::initReadTableRecord() +{ + c_readTableRecord.noOfPages = (Uint32)-1; + c_readTableRecord.pageId = RNIL; + c_readTableRecord.tableId = ZNIL; + c_readTableRecord.inUse = false; +}//initReadTableRecord() + +void Dbdict::initWriteTableRecord() +{ + c_writeTableRecord.noOfPages = (Uint32)-1; + c_writeTableRecord.pageId = RNIL; + c_writeTableRecord.noOfTableFilesHandled = 3; + c_writeTableRecord.tableId = ZNIL; + c_writeTableRecord.tableWriteState = WriteTableRecord::IDLE; +}//initWriteTableRecord() + +void Dbdict::initReadSchemaRecord() +{ + c_readSchemaRecord.pageId = RNIL; + c_readSchemaRecord.schemaReadState = ReadSchemaRecord::IDLE; +}//initReadSchemaRecord() + +void Dbdict::initWriteSchemaRecord() +{ + c_writeSchemaRecord.inUse = false; + c_writeSchemaRecord.pageId = RNIL; + c_writeSchemaRecord.noOfSchemaFilesHandled = 3; +}//initWriteSchemaRecord() + +void Dbdict::initRetrieveRecord(Signal* signal, Uint32 i, Uint32 returnCode) +{ + c_retrieveRecord.busyState = false; + c_retrieveRecord.blockRef = 0; + c_retrieveRecord.m_senderData = RNIL; + c_retrieveRecord.tableId = RNIL; + c_retrieveRecord.currentSent = 0; + c_retrieveRecord.retrievedNoOfPages = 0; + c_retrieveRecord.retrievedNoOfWords = 0; + c_retrieveRecord.m_useLongSig = false; +}//initRetrieveRecord() + +void Dbdict::initSchemaRecord() +{ + c_schemaRecord.schemaPage = RNIL; +}//Dbdict::initSchemaRecord() + +void Dbdict::initRestartRecord() +{ + c_restartRecord.gciToRestart = 0; + c_restartRecord.activeTable = ZNIL; +}//Dbdict::initRestartRecord() + +void Dbdict::initNodeRecords() +{ + jam(); + for (unsigned i = 1; i < MAX_NODES; i++) { + NodeRecordPtr nodePtr; + c_nodes.getPtr(nodePtr, i); + nodePtr.p->hotSpare = false; + nodePtr.p->nodeState = NodeRecord::API_NODE; + }//for +}//Dbdict::initNodeRecords() + +void Dbdict::initPageRecords() +{ + c_schemaRecord.schemaPage = ZMAX_PAGES_OF_TABLE_DEFINITION; + c_schemaRecord.oldSchemaPage = ZMAX_PAGES_OF_TABLE_DEFINITION + 1; + c_retrieveRecord.retrievePage = ZMAX_PAGES_OF_TABLE_DEFINITION + 2; + ndbrequire(ZNUMBER_OF_PAGES >= (2 * ZMAX_PAGES_OF_TABLE_DEFINITION + 2)); +}//Dbdict::initPageRecords() + +void Dbdict::initTableRecords() +{ + TableRecordPtr tablePtr; + while (1) { + jam(); + c_tableRecordPool.seize(tablePtr); + if (tablePtr.i == RNIL) { + jam(); + break; + }//if + initialiseTableRecord(tablePtr); + }//while +}//Dbdict::initTableRecords() + +void Dbdict::initialiseTableRecord(TableRecordPtr tablePtr) +{ + tablePtr.p->activePage = RNIL; + tablePtr.p->filePtr[0] = RNIL; + tablePtr.p->filePtr[1] = RNIL; + tablePtr.p->firstAttribute = RNIL; + tablePtr.p->firstPage = RNIL; + tablePtr.p->lastAttribute = RNIL; + tablePtr.p->tableId = tablePtr.i; + tablePtr.p->tableVersion = (Uint32)-1; + tablePtr.p->tabState = TableRecord::NOT_DEFINED; + tablePtr.p->tabReturnState = TableRecord::TRS_IDLE; + tablePtr.p->storageType = DictTabInfo::MainMemory; + tablePtr.p->myConnect = RNIL; + tablePtr.p->fragmentType = DictTabInfo::AllNodesSmallTable; + tablePtr.p->fragmentKeyType = DictTabInfo::PrimaryKey; + memset(tablePtr.p->tableName, 0, sizeof(tablePtr.p->tableName)); + tablePtr.p->gciTableCreated = 0; + tablePtr.p->noOfAttributes = ZNIL; + tablePtr.p->noOfNullAttr = 0; + tablePtr.p->frmLen = 0; + memset(tablePtr.p->frmData, 0, sizeof(tablePtr.p->frmData)); + /* + tablePtr.p->lh3PageIndexBits = 0; + tablePtr.p->lh3DistrBits = 0; + tablePtr.p->lh3PageBits = 6; + */ + tablePtr.p->kValue = 6; + tablePtr.p->localKeyLen = 1; + tablePtr.p->maxLoadFactor = 80; + tablePtr.p->minLoadFactor = 70; + tablePtr.p->noOfPrimkey = 1; + tablePtr.p->tupKeyLength = 1; + tablePtr.p->storedTable = true; + tablePtr.p->tableType = DictTabInfo::UserTable; + tablePtr.p->primaryTableId = RNIL; + // volatile elements + tablePtr.p->indexState = TableRecord::IS_UNDEFINED; + tablePtr.p->insertTriggerId = RNIL; + tablePtr.p->updateTriggerId = RNIL; + tablePtr.p->deleteTriggerId = RNIL; + tablePtr.p->customTriggerId = RNIL; + tablePtr.p->buildTriggerId = RNIL; + tablePtr.p->indexLocal = 0; +}//Dbdict::initialiseTableRecord() + +void Dbdict::initTriggerRecords() +{ + TriggerRecordPtr triggerPtr; + while (1) { + jam(); + c_triggerRecordPool.seize(triggerPtr); + if (triggerPtr.i == RNIL) { + jam(); + break; + }//if + initialiseTriggerRecord(triggerPtr); + }//while +} + +void Dbdict::initialiseTriggerRecord(TriggerRecordPtr triggerPtr) +{ + triggerPtr.p->triggerState = TriggerRecord::TS_NOT_DEFINED; + triggerPtr.p->triggerLocal = 0; + memset(triggerPtr.p->triggerName, 0, sizeof(triggerPtr.p->triggerName)); + triggerPtr.p->triggerId = RNIL; + triggerPtr.p->tableId = RNIL; + triggerPtr.p->triggerType = (TriggerType::Value)~0; + triggerPtr.p->triggerActionTime = (TriggerActionTime::Value)~0; + triggerPtr.p->triggerEvent = (TriggerEvent::Value)~0; + triggerPtr.p->monitorReplicas = false; + triggerPtr.p->monitorAllAttributes = false; + triggerPtr.p->attributeMask.clear(); + triggerPtr.p->indexId = RNIL; +} + +Uint32 Dbdict::getFsConnRecord() +{ + FsConnectRecordPtr fsPtr; + c_fsConnectRecordPool.seize(fsPtr); + ndbrequire(fsPtr.i != RNIL); + fsPtr.p->filePtr = (Uint32)-1; + fsPtr.p->ownerPtr = RNIL; + fsPtr.p->fsState = FsConnectRecord::IDLE; + return fsPtr.i; +}//Dbdict::getFsConnRecord() + +Uint32 Dbdict::getFreeTableRecord(Uint32 primaryTableId) +{ + Uint32 minId = (primaryTableId == RNIL ? 0 : primaryTableId + 1); + TableRecordPtr tablePtr; + TableRecordPtr firstTablePtr; + bool firstFound = false; + Uint32 tabSize = c_tableRecordPool.getSize(); + for (tablePtr.i = minId; tablePtr.i < tabSize ; tablePtr.i++) { + jam(); + c_tableRecordPool.getPtr(tablePtr); + if (tablePtr.p->tabState == TableRecord::NOT_DEFINED) { + jam(); + initialiseTableRecord(tablePtr); + tablePtr.p->tabState = TableRecord::DEFINING; + firstFound = true; + firstTablePtr.i = tablePtr.i; + firstTablePtr.p = tablePtr.p; + break; + }//if + }//for + if (!firstFound) { + jam(); + return RNIL; + }//if + bool secondFound = false; + for (tablePtr.i = firstTablePtr.i + 1; tablePtr.i < tabSize ; tablePtr.i++) { + jam(); + c_tableRecordPool.getPtr(tablePtr); + if (tablePtr.p->tabState == TableRecord::NOT_DEFINED) { + jam(); + initialiseTableRecord(tablePtr); + tablePtr.p->tabState = TableRecord::REORG_TABLE_PREPARED; + tablePtr.p->secondTable = firstTablePtr.i; + firstTablePtr.p->secondTable = tablePtr.i; + secondFound = true; + break; + }//if + }//for + if (!secondFound) { + jam(); + firstTablePtr.p->tabState = TableRecord::NOT_DEFINED; + return RNIL; + }//if + return firstTablePtr.i; +}//Dbdict::getFreeTableRecord() + +Uint32 Dbdict::getFreeTriggerRecord() +{ + const Uint32 size = c_triggerRecordPool.getSize(); + TriggerRecordPtr triggerPtr; + for (triggerPtr.i = 0; triggerPtr.i < size; triggerPtr.i++) { + jam(); + c_triggerRecordPool.getPtr(triggerPtr); + if (triggerPtr.p->triggerState == TriggerRecord::TS_NOT_DEFINED) { + jam(); + initialiseTriggerRecord(triggerPtr); + return triggerPtr.i; + } + } + return RNIL; +} + +bool +Dbdict::getNewAttributeRecord(TableRecordPtr tablePtr, + AttributeRecordPtr & attrPtr) +{ + c_attributeRecordPool.seize(attrPtr); + if(attrPtr.i == RNIL){ + return false; + } + + memset(attrPtr.p->attributeName, 0, sizeof(attrPtr.p->attributeName)); + attrPtr.p->attributeDescriptor = 0x00012255; //Default value + attrPtr.p->attributeId = ZNIL; + attrPtr.p->nextAttrInTable = RNIL; + attrPtr.p->tupleKey = 0; + memset(attrPtr.p->defaultValue, 0, sizeof(attrPtr.p->defaultValue)); + + /* ---------------------------------------------------------------- */ + // A free attribute record has been acquired. We will now link it + // to the table record. + /* ---------------------------------------------------------------- */ + if (tablePtr.p->lastAttribute == RNIL) { + jam(); + tablePtr.p->firstAttribute = attrPtr.i; + } else { + jam(); + AttributeRecordPtr lastAttrPtr; + c_attributeRecordPool.getPtr(lastAttrPtr, tablePtr.p->lastAttribute); + lastAttrPtr.p->nextAttrInTable = attrPtr.i; + }//if + tablePtr.p->lastAttribute = attrPtr.i; + return true; +}//Dbdict::getNewAttributeRecord() + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* MODULE: START/RESTART HANDLING ------------------------ */ +/* ---------------------------------------------------------------- */ +/* */ +/* This module contains the code that is common for all */ +/* start/restart types. */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ + +/* ---------------------------------------------------------------- */ +// This is sent as the first signal during start/restart. +/* ---------------------------------------------------------------- */ +void Dbdict::execSTTOR(Signal* signal) +{ + jamEntry(); + c_startPhase = signal->theData[1]; + switch (c_startPhase) { + case 1: + initCommonData(); + break; + case 3: + c_restartType = signal->theData[7]; /* valid if 3 */ + ndbrequire(c_restartType == NodeState::ST_INITIAL_START || + c_restartType == NodeState::ST_SYSTEM_RESTART || + c_restartType == NodeState::ST_INITIAL_NODE_RESTART || + c_restartType == NodeState::ST_NODE_RESTART); + break; + } + sendSTTORRY(signal); +}//execSTTOR() + +void Dbdict::sendSTTORRY(Signal* signal) +{ + signal->theData[0] = 0; /* garbage SIGNAL KEY */ + signal->theData[1] = 0; /* garbage SIGNAL VERSION NUMBER */ + signal->theData[2] = 0; /* garbage */ + signal->theData[3] = 1; /* first wanted start phase */ + signal->theData[4] = 3; /* get type of start */ + signal->theData[5] = ZNOMOREPHASES; + sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 6, JBB); +} + +/* ---------------------------------------------------------------- */ +// We receive information about sizes of records. +/* ---------------------------------------------------------------- */ +void Dbdict::execSIZEALT_REP(Signal* signal) +{ + jamEntry(); + BlockReference tblockref; + tblockref = signal->theData[DictSizeAltReq::IND_BLOCK_REF]; + Uint32 attributesize = signal->theData[DictSizeAltReq::IND_ATTRIBUTE]; +// Uint32 connectsize = signal->theData[DictSizeAltReq::IND_CONNECT]; + Uint32 tablerecSize = signal->theData[DictSizeAltReq::IND_TABLE]; + + c_attributeRecordPool.setSize(attributesize); + c_attributeRecordHash.setSize(64); + c_fsConnectRecordPool.setSize(ZFS_CONNECT_SIZE); + c_nodes.setSize(MAX_NODES); + c_pageRecordArray.setSize(ZNUMBER_OF_PAGES); + c_tableRecordPool.setSize(tablerecSize); + c_tableRecordHash.setSize(tablerecSize); + c_triggerRecordPool.setSize(c_maxNoOfTriggers); + c_triggerRecordHash.setSize(c_maxNoOfTriggers); + c_opRecordPool.setSize(256); // XXX need config params + c_opCreateTable.setSize(8); + c_opDropTable.setSize(8); + c_opCreateIndex.setSize(8); + c_opCreateEvent.setSize(8); + c_opSubEvent.setSize(8); + c_opDropEvent.setSize(8); + c_opSignalUtil.setSize(8); + c_opDropIndex.setSize(8); + c_opAlterIndex.setSize(8); + c_opBuildIndex.setSize(8); + c_opCreateTrigger.setSize(8); + c_opDropTrigger.setSize(8); + c_opAlterTrigger.setSize(8); + + // Initialize BAT for interface to file system + PageRecordPtr pageRecPtr; + c_pageRecordArray.getPtr(pageRecPtr, 0); + NewVARIABLE* bat = allocateBat(2); + bat[1].WA = &pageRecPtr.p->word[0]; + bat[1].nrr = ZNUMBER_OF_PAGES; + bat[1].ClusterSize = ZSIZE_OF_PAGES_IN_WORDS * 4; + bat[1].bits.q = ZLOG_SIZE_OF_PAGES_IN_WORDS; // 2**13 = 8192 elements + bat[1].bits.v = 5; // 32 bits per element + + initRecords(); + signal->theData[0] = DBDICT_REF; + sendSignal(tblockref, GSN_SIZEALT_ACK, signal, 2, JBB); +}//execSIZEALT_REP() + +/* ---------------------------------------------------------------- */ +// Start phase signals sent by CNTR. We reply with NDB_STTORRY when +// we completed this phase. +/* ---------------------------------------------------------------- */ +void Dbdict::execNDB_STTOR(Signal* signal) +{ + jamEntry(); + c_startPhase = signal->theData[2]; + const Uint32 restartType = signal->theData[3]; + if (restartType == NodeState::ST_INITIAL_START) { + jam(); + c_initialStart = true; + } else if (restartType == NodeState::ST_SYSTEM_RESTART) { + jam(); + c_systemRestart = true; + } else if (restartType == NodeState::ST_INITIAL_NODE_RESTART) { + jam(); + c_initialNodeRestart = true; + } else if (restartType == NodeState::ST_NODE_RESTART) { + jam(); + c_nodeRestart = true; + } else { + ndbrequire(false); + }//if + switch (c_startPhase) { + case 1: + jam(); + initSchemaFile(signal); + break; + case 3: + jam(); + signal->theData[0] = reference(); + sendSignal(NDBCNTR_REF, GSN_READ_NODESREQ, signal, 1, JBB); + break; + case 6: + jam(); + c_initialStart = false; + c_systemRestart = false; + c_initialNodeRestart = false; + c_nodeRestart = false; + sendNDB_STTORRY(signal); + break; + case 7: + // uses c_restartType + if(restartType == NodeState::ST_SYSTEM_RESTART && + c_masterNodeId == getOwnNodeId()){ + rebuildIndexes(signal, 0); + return; + } + sendNDB_STTORRY(signal); + break; + default: + jam(); + sendNDB_STTORRY(signal); + break; + }//switch +}//execNDB_STTOR() + +void Dbdict::sendNDB_STTORRY(Signal* signal) +{ + signal->theData[0] = reference(); + sendSignal(NDBCNTR_REF, GSN_NDB_STTORRY, signal, 1, JBB); + return; +}//sendNDB_STTORRY() + +/* ---------------------------------------------------------------- */ +// We receive the information about which nodes that are up and down. +/* ---------------------------------------------------------------- */ +void Dbdict::execREAD_NODESCONF(Signal* signal) +{ + jamEntry(); + + ReadNodesConf * const readNodes = (ReadNodesConf *)&signal->theData[0]; + c_numberNode = readNodes->noOfNodes; + c_masterNodeId = readNodes->masterNodeId; + + c_noNodesFailed = 0; + c_aliveNodes.clear(); + for (unsigned i = 1; i < MAX_NDB_NODES; i++) { + jam(); + NodeRecordPtr nodePtr; + c_nodes.getPtr(nodePtr, i); + + if (NodeBitmask::get(readNodes->allNodes, i)) { + jam(); + nodePtr.p->nodeState = NodeRecord::NDB_NODE_ALIVE; + if (NodeBitmask::get(readNodes->inactiveNodes, i)) { + jam(); + /**------------------------------------------------------------------- + * + * THIS NODE IS DEFINED IN THE CLUSTER BUT IS NOT ALIVE CURRENTLY. + * WE ADD THE NODE TO THE SET OF FAILED NODES AND ALSO SET THE + * BLOCKSTATE TO BUSY TO AVOID ADDING TABLES WHILE NOT ALL NODES ARE + * ALIVE. + *------------------------------------------------------------------*/ + nodePtr.p->nodeState = NodeRecord::NDB_NODE_DEAD; + c_noNodesFailed++; + } else { + c_aliveNodes.set(i); + } + }//if + }//for + sendNDB_STTORRY(signal); +}//execREAD_NODESCONF() + +/* ---------------------------------------------------------------- */ +// HOT_SPAREREP informs DBDICT about which nodes that have become +// hot spare nodes. +/* ---------------------------------------------------------------- */ +void Dbdict::execHOT_SPAREREP(Signal* signal) +{ + Uint32 hotSpareNodes = 0; + jamEntry(); + HotSpareRep * const hotSpare = (HotSpareRep*)&signal->theData[0]; + for (unsigned i = 1; i < MAX_NDB_NODES; i++) { + if (NodeBitmask::get(hotSpare->theHotSpareNodes, i)) { + NodeRecordPtr nodePtr; + c_nodes.getPtr(nodePtr, i); + nodePtr.p->hotSpare = true; + hotSpareNodes++; + }//if + }//for + ndbrequire(hotSpareNodes == hotSpare->noHotSpareNodes); + c_noHotSpareNodes = hotSpareNodes; + return; +}//execHOT_SPAREREP() + +void Dbdict::initSchemaFile(Signal* signal) +{ + PageRecordPtr pagePtr; + c_pageRecordArray.getPtr(pagePtr, c_schemaRecord.schemaPage); + SchemaFile * schemaFile = (SchemaFile *)pagePtr.p; + initSchemaFile(schemaFile, 4 * ZSIZE_OF_PAGES_IN_WORDS); + + if (c_initialStart || c_initialNodeRestart) { + jam(); + ndbrequire(c_writeSchemaRecord.inUse == false); + c_writeSchemaRecord.inUse = true; + c_writeSchemaRecord.pageId = c_schemaRecord.schemaPage; + + c_writeSchemaRecord.m_callback.m_callbackFunction = + safe_cast(&Dbdict::initSchemaFile_conf); + + startWriteSchemaFile(signal); + } else if (c_systemRestart || c_nodeRestart) { + jam(); + ndbrequire(c_readSchemaRecord.schemaReadState == ReadSchemaRecord::IDLE); + c_readSchemaRecord.pageId = c_schemaRecord.oldSchemaPage; + c_readSchemaRecord.schemaReadState = ReadSchemaRecord::INITIAL_READ; + startReadSchemaFile(signal); + } else { + ndbrequire(false); + }//if +}//Dbdict::initSchemaFile() + +void +Dbdict::initSchemaFile_conf(Signal* signal, Uint32 callbackData, Uint32 rv){ + jam(); + sendNDB_STTORRY(signal); +} + +void +Dbdict::activateIndexes(Signal* signal, Uint32 i) +{ + AlterIndxReq* req = (AlterIndxReq*)signal->getDataPtrSend(); + TableRecordPtr tablePtr; + for (; i < c_tableRecordPool.getSize(); i++) { + tablePtr.i = i; + c_tableRecordPool.getPtr(tablePtr); + if (tablePtr.p->tabState != TableRecord::DEFINED) + continue; + if (! tablePtr.p->isIndex()) + continue; + jam(); + req->setUserRef(reference()); + req->setConnectionPtr(i); + req->setTableId(tablePtr.p->primaryTableId); + req->setIndexId(tablePtr.i); + req->setIndexVersion(tablePtr.p->tableVersion); + req->setOnline(true); + if (c_restartType == NodeState::ST_SYSTEM_RESTART) { + if (c_masterNodeId != getOwnNodeId()) + continue; + // from file index state is not defined currently + req->setRequestType(AlterIndxReq::RT_SYSTEMRESTART); + req->addRequestFlag((Uint32)RequestFlag::RF_NOBUILD); + } + else if ( + c_restartType == NodeState::ST_NODE_RESTART || + c_restartType == NodeState::ST_INITIAL_NODE_RESTART) { + // from master index must be online + if (tablePtr.p->indexState != TableRecord::IS_ONLINE) + continue; + req->setRequestType(AlterIndxReq::RT_NODERESTART); + // activate locally, rebuild not needed + req->addRequestFlag((Uint32)RequestFlag::RF_LOCAL); + req->addRequestFlag((Uint32)RequestFlag::RF_NOBUILD); + } else { + ndbrequire(false); + } + sendSignal(reference(), GSN_ALTER_INDX_REQ, + signal, AlterIndxReq::SignalLength, JBB); + return; + } + signal->theData[0] = reference(); + sendSignal(c_restartRecord.returnBlockRef, GSN_DICTSTARTCONF, + signal, 1, JBB); +} + +void +Dbdict::rebuildIndexes(Signal* signal, Uint32 i){ + BuildIndxReq* const req = (BuildIndxReq*)signal->getDataPtrSend(); + + TableRecordPtr indexPtr; + for (; i < c_tableRecordPool.getSize(); i++) { + indexPtr.i = i; + c_tableRecordPool.getPtr(indexPtr); + if (indexPtr.p->tabState != TableRecord::DEFINED) + continue; + if (! indexPtr.p->isIndex()) + continue; + + jam(); + + req->setUserRef(reference()); + req->setConnectionPtr(i); + req->setRequestType(BuildIndxReq::RT_SYSTEMRESTART); + req->setBuildId(0); // not used + req->setBuildKey(0); // not used + req->setIndexType(indexPtr.p->tableType); + req->setIndexId(indexPtr.i); + req->setTableId(indexPtr.p->primaryTableId); + req->setParallelism(16); + + // from file index state is not defined currently + if (indexPtr.p->storedTable) { + // rebuild not needed + req->addRequestFlag((Uint32)RequestFlag::RF_NOBUILD); + } + + // send + sendSignal(reference(), GSN_BUILDINDXREQ, + signal, BuildIndxReq::SignalLength, JBB); + return; + } + sendNDB_STTORRY(signal); +} + + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* MODULE: SYSTEM RESTART MODULE ------------------------- */ +/* ---------------------------------------------------------------- */ +/* */ +/* This module contains code specific for system restart */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ + +/* ---------------------------------------------------------------- */ +// DIH asks DICT to read in table data from disk during system +// restart. DIH also asks DICT to send information about which +// tables that should be started as part of this system restart. +// DICT will also activate the tables in TC as part of this process. +/* ---------------------------------------------------------------- */ +void Dbdict::execDICTSTARTREQ(Signal* signal) +{ + jamEntry(); + c_restartRecord.gciToRestart = signal->theData[0]; + c_restartRecord.returnBlockRef = signal->theData[1]; + if (c_nodeRestart || c_initialNodeRestart) { + jam(); + + CRASH_INSERTION(6000); + + BlockReference dictRef = calcDictBlockRef(c_masterNodeId); + signal->theData[0] = getOwnNodeId(); + sendSignal(dictRef, GSN_GET_SCHEMA_INFOREQ, signal, 1, JBB); + return; + } + ndbrequire(c_systemRestart); + ndbrequire(c_masterNodeId == getOwnNodeId()); + + c_schemaRecord.m_callback.m_callbackData = 0; + c_schemaRecord.m_callback.m_callbackFunction = + safe_cast(&Dbdict::masterRestart_checkSchemaStatusComplete); + + c_restartRecord.activeTable = 0; + c_schemaRecord.schemaPage = c_schemaRecord.oldSchemaPage; + checkSchemaStatus(signal); +}//execDICTSTARTREQ() + +void +Dbdict::masterRestart_checkSchemaStatusComplete(Signal* signal, + Uint32 callbackData, + Uint32 returnCode){ + + c_schemaRecord.schemaPage = ZMAX_PAGES_OF_TABLE_DEFINITION; + + LinearSectionPtr ptr[3]; + + PageRecordPtr pagePtr; + c_pageRecordArray.getPtr(pagePtr, c_schemaRecord.oldSchemaPage); + + ptr[0].p = &pagePtr.p->word[0]; + ptr[0].sz = ZSIZE_OF_PAGES_IN_WORDS; + + c_sendSchemaRecord.m_SCHEMAINFO_Counter = c_aliveNodes; + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + + rg.m_nodes.clear(getOwnNodeId()); + Callback c = { 0, 0 }; + sendFragmentedSignal(rg, + GSN_SCHEMA_INFO, + signal, + 1, //SchemaInfo::SignalLength, + JBB, + ptr, + 1, + c); + + PageRecordPtr newPagePtr; + c_pageRecordArray.getPtr(newPagePtr, c_schemaRecord.schemaPage); + memcpy(&newPagePtr.p->word[0], &pagePtr.p->word[0], + 4 * ZSIZE_OF_PAGES_IN_WORDS); + + signal->theData[0] = getOwnNodeId(); + sendSignal(reference(), GSN_SCHEMA_INFOCONF, signal, 1, JBB); +} + +void +Dbdict::execGET_SCHEMA_INFOREQ(Signal* signal){ + + const Uint32 ref = signal->getSendersBlockRef(); + //const Uint32 senderData = signal->theData[0]; + + ndbrequire(c_sendSchemaRecord.inUse == false); + c_sendSchemaRecord.inUse = true; + + LinearSectionPtr ptr[3]; + + PageRecordPtr pagePtr; + c_pageRecordArray.getPtr(pagePtr, c_schemaRecord.schemaPage); + + ptr[0].p = &pagePtr.p->word[0]; + ptr[0].sz = ZSIZE_OF_PAGES_IN_WORDS; + + Callback c = { safe_cast(&Dbdict::sendSchemaComplete), 0 }; + sendFragmentedSignal(ref, + GSN_SCHEMA_INFO, + signal, + 1, //GetSchemaInfoConf::SignalLength, + JBB, + ptr, + 1, + c); +}//Dbdict::execGET_SCHEMA_INFOREQ() + +void +Dbdict::sendSchemaComplete(Signal * signal, + Uint32 callbackData, + Uint32 returnCode){ + ndbrequire(c_sendSchemaRecord.inUse == true); + c_sendSchemaRecord.inUse = false; + +} + + +/* ---------------------------------------------------------------- */ +// We receive the schema info from master as part of all restarts +// except the initial start where no tables exists. +/* ---------------------------------------------------------------- */ +void Dbdict::execSCHEMA_INFO(Signal* signal) +{ + jamEntry(); + if(!assembleFragments(signal)){ + jam(); + return; + } + + if(getNodeState().getNodeRestartInProgress()){ + CRASH_INSERTION(6001); + } + + SegmentedSectionPtr schemaDataPtr; + signal->getSection(schemaDataPtr, 0); + + PageRecordPtr pagePtr; + c_pageRecordArray.getPtr(pagePtr, c_schemaRecord.schemaPage); + copy(&pagePtr.p->word[0], schemaDataPtr); + releaseSections(signal); + + validateChecksum((SchemaFile*)pagePtr.p); + + ndbrequire(signal->getSendersBlockRef() != reference()); + + /* ---------------------------------------------------------------- */ + // Synchronise our view on data with other nodes in the cluster. + // This is an important part of restart handling where we will handle + // cases where the table have been added but only partially, where + // tables have been deleted but not completed the deletion yet and + // other scenarios needing synchronisation. + /* ---------------------------------------------------------------- */ + c_schemaRecord.m_callback.m_callbackData = 0; + c_schemaRecord.m_callback.m_callbackFunction = + safe_cast(&Dbdict::restart_checkSchemaStatusComplete); + c_restartRecord.activeTable = 0; + checkSchemaStatus(signal); +}//execSCHEMA_INFO() + +void +Dbdict::restart_checkSchemaStatusComplete(Signal * signal, + Uint32 callbackData, + Uint32 returnCode){ + + ndbrequire(c_writeSchemaRecord.inUse == false); + c_writeSchemaRecord.inUse = true; + c_writeSchemaRecord.pageId = c_schemaRecord.schemaPage; + c_writeSchemaRecord.m_callback.m_callbackData = 0; + c_writeSchemaRecord.m_callback.m_callbackFunction = + safe_cast(&Dbdict::restart_writeSchemaConf); + + startWriteSchemaFile(signal); +} + +void +Dbdict::restart_writeSchemaConf(Signal * signal, + Uint32 callbackData, + Uint32 returnCode){ + + if(c_systemRestart){ + jam(); + signal->theData[0] = getOwnNodeId(); + sendSignal(calcDictBlockRef(c_masterNodeId), GSN_SCHEMA_INFOCONF, + signal, 1, JBB); + return; + } + + ndbrequire(c_nodeRestart || c_initialNodeRestart); + c_blockState = BS_IDLE; + activateIndexes(signal, 0); + return; +} + +void Dbdict::execSCHEMA_INFOCONF(Signal* signal) +{ + jamEntry(); + ndbrequire(signal->getNoOfSections() == 0); + +/* ---------------------------------------------------------------- */ +// This signal is received in the master as part of system restart +// from all nodes (including the master) after they have synchronised +// their data with the master node's schema information. +/* ---------------------------------------------------------------- */ + const Uint32 nodeId = signal->theData[0]; + c_sendSchemaRecord.m_SCHEMAINFO_Counter.clearWaitingFor(nodeId); + + if (!c_sendSchemaRecord.m_SCHEMAINFO_Counter.done()){ + jam(); + return; + }//if + activateIndexes(signal, 0); +}//execSCHEMA_INFOCONF() + +void Dbdict::checkSchemaStatus(Signal* signal) +{ + PageRecordPtr pagePtr; + c_pageRecordArray.getPtr(pagePtr, c_schemaRecord.schemaPage); + + PageRecordPtr oldPagePtr; + c_pageRecordArray.getPtr(oldPagePtr, c_schemaRecord.oldSchemaPage); + + for (; c_restartRecord.activeTable < MAX_TABLES; + c_restartRecord.activeTable++) { + jam(); + + Uint32 tableId = c_restartRecord.activeTable; + SchemaFile::TableEntry *newEntry = getTableEntry(pagePtr.p, tableId); + SchemaFile::TableEntry *oldEntry = getTableEntry(oldPagePtr.p, tableId, + true); + SchemaFile::TableState schemaState = + (SchemaFile::TableState)newEntry->m_tableState; + SchemaFile::TableState oldSchemaState = + (SchemaFile::TableState)oldEntry->m_tableState; + + if (c_restartRecord.activeTable >= c_tableRecordPool.getSize()) { + jam(); + ndbrequire(schemaState == SchemaFile::INIT); + ndbrequire(oldSchemaState == SchemaFile::INIT); + continue; + }//if + + switch(schemaState){ + case SchemaFile::INIT:{ + jam(); + bool ok = false; + switch(oldSchemaState) { + case SchemaFile::INIT: + jam(); + case SchemaFile::DROP_TABLE_COMMITTED: + jam(); + ok = true; + jam(); + break; + + case SchemaFile::ADD_STARTED: + jam(); + case SchemaFile::TABLE_ADD_COMMITTED: + jam(); + case SchemaFile::DROP_TABLE_STARTED: + jam(); + case SchemaFile::ALTER_TABLE_COMMITTED: + jam(); + ok = true; + jam(); + newEntry->m_tableState = SchemaFile::INIT; + restartDropTab(signal, tableId); + return; + }//switch + ndbrequire(ok); + break; + } + case SchemaFile::ADD_STARTED:{ + jam(); + bool ok = false; + switch(oldSchemaState) { + case SchemaFile::INIT: + jam(); + case SchemaFile::DROP_TABLE_COMMITTED: + jam(); + ok = true; + break; + case SchemaFile::ADD_STARTED: + jam(); + case SchemaFile::DROP_TABLE_STARTED: + jam(); + case SchemaFile::TABLE_ADD_COMMITTED: + jam(); + case SchemaFile::ALTER_TABLE_COMMITTED: + jam(); + ok = true; + //------------------------------------------------------------------ + // Add Table was started but not completed. Will be dropped in all + // nodes. Update schema information (restore table version). + //------------------------------------------------------------------ + newEntry->m_tableState = SchemaFile::INIT; + restartDropTab(signal, tableId); + return; + } + ndbrequire(ok); + break; + } + case SchemaFile::TABLE_ADD_COMMITTED:{ + jam(); + bool ok = false; + switch(oldSchemaState) { + case SchemaFile::INIT: + jam(); + case SchemaFile::ADD_STARTED: + jam(); + case SchemaFile::DROP_TABLE_STARTED: + jam(); + case SchemaFile::DROP_TABLE_COMMITTED: + jam(); + ok = true; + //------------------------------------------------------------------ + // Table was added in the master node but not in our node. We can + // retrieve the table definition from the master. + //------------------------------------------------------------------ + restartCreateTab(signal, tableId, oldEntry, false); + return; + break; + case SchemaFile::TABLE_ADD_COMMITTED: + jam(); + case SchemaFile::ALTER_TABLE_COMMITTED: + jam(); + ok = true; + //------------------------------------------------------------------ + // Table was added in both our node and the master node. We can + // retrieve the table definition from our own disk. + //------------------------------------------------------------------ + if(* newEntry == * oldEntry){ + jam(); + + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, tableId); + tablePtr.p->tableVersion = oldEntry->m_tableVersion; + tablePtr.p->tableType = (DictTabInfo::TableType)oldEntry->m_tableType; + + // On NR get index from master because index state is not on file + const bool file = c_systemRestart || tablePtr.p->isTable(); + restartCreateTab(signal, tableId, oldEntry, file); + + return; + } else { + //------------------------------------------------------------------ + // Must be a new version of the table if anything differs. Both table + // version and global checkpoint must be different. + // This should not happen for the master node. This can happen after + // drop table followed by add table or after change table. + // Not supported in this version. + //------------------------------------------------------------------ + ndbrequire(c_masterNodeId != getOwnNodeId()); + ndbrequire(newEntry->m_tableVersion != oldEntry->m_tableVersion); + jam(); + + restartCreateTab(signal, tableId, oldEntry, false); + return; + }//if + ndbrequire(ok); + break; + } + } + case SchemaFile::DROP_TABLE_STARTED: + jam(); + case SchemaFile::DROP_TABLE_COMMITTED:{ + jam(); + bool ok = false; + switch(oldSchemaState){ + case SchemaFile::INIT: + jam(); + case SchemaFile::DROP_TABLE_COMMITTED: + jam(); + ok = true; + break; + case SchemaFile::ADD_STARTED: + jam(); + case SchemaFile::TABLE_ADD_COMMITTED: + jam(); + case SchemaFile::DROP_TABLE_STARTED: + jam(); + case SchemaFile::ALTER_TABLE_COMMITTED: + jam(); + newEntry->m_tableState = SchemaFile::INIT; + restartDropTab(signal, tableId); + return; + } + ndbrequire(ok); + break; + } + case SchemaFile::ALTER_TABLE_COMMITTED: { + jam(); + bool ok = false; + switch(oldSchemaState) { + case SchemaFile::INIT: + jam(); + case SchemaFile::ADD_STARTED: + jam(); + case SchemaFile::DROP_TABLE_STARTED: + jam(); + case SchemaFile::DROP_TABLE_COMMITTED: + jam(); + case SchemaFile::TABLE_ADD_COMMITTED: + jam(); + ok = true; + //------------------------------------------------------------------ + // Table was altered in the master node but not in our node. We can + // retrieve the altered table definition from the master. + //------------------------------------------------------------------ + restartCreateTab(signal, tableId, oldEntry, false); + return; + break; + case SchemaFile::ALTER_TABLE_COMMITTED: + jam(); + ok = true; + + //------------------------------------------------------------------ + // Table was altered in both our node and the master node. We can + // retrieve the table definition from our own disk. + //------------------------------------------------------------------ + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, tableId); + tablePtr.p->tableVersion = oldEntry->m_tableVersion; + tablePtr.p->tableType = (DictTabInfo::TableType)oldEntry->m_tableType; + + // On NR get index from master because index state is not on file + const bool file = c_systemRestart || tablePtr.p->isTable(); + restartCreateTab(signal, tableId, oldEntry, file); + + return; + } + ndbrequire(ok); + break; + } + } + } + + execute(signal, c_schemaRecord.m_callback, 0); +}//checkSchemaStatus() + +void +Dbdict::restartCreateTab(Signal* signal, Uint32 tableId, + const SchemaFile::TableEntry * te, bool file){ + jam(); + + CreateTableRecordPtr createTabPtr; + c_opCreateTable.seize(createTabPtr); + ndbrequire(!createTabPtr.isNull()); + + createTabPtr.p->key = ++c_opRecordSequence; + c_opCreateTable.add(createTabPtr); + + createTabPtr.p->m_errorCode = 0; + createTabPtr.p->m_tablePtrI = tableId; + createTabPtr.p->m_coordinatorRef = reference(); + createTabPtr.p->m_senderRef = 0; + createTabPtr.p->m_senderData = RNIL; + createTabPtr.p->m_tabInfoPtrI = RNIL; + createTabPtr.p->m_dihAddFragPtr = RNIL; + + if(file && !ERROR_INSERTED(6002)){ + jam(); + + c_readTableRecord.noOfPages = te->m_noOfPages; + c_readTableRecord.pageId = 0; + c_readTableRecord.m_callback.m_callbackData = createTabPtr.p->key; + c_readTableRecord.m_callback.m_callbackFunction = + safe_cast(&Dbdict::restartCreateTab_readTableConf); + + startReadTableFile(signal, tableId); + return; + } else { + + ndbrequire(c_masterNodeId != getOwnNodeId()); + + /** + * Get from master + */ + GetTabInfoReq * const req = (GetTabInfoReq *)&signal->theData[0]; + req->senderRef = reference(); + req->senderData = createTabPtr.p->key; + req->requestType = GetTabInfoReq::RequestById | + GetTabInfoReq::LongSignalConf; + req->tableId = tableId; + sendSignal(calcDictBlockRef(c_masterNodeId), GSN_GET_TABINFOREQ, signal, + GetTabInfoReq::SignalLength, JBB); + + if(ERROR_INSERTED(6002)){ + NdbSleep_MilliSleep(10); + CRASH_INSERTION(6002); + } + } +} + +void +Dbdict::restartCreateTab_readTableConf(Signal* signal, + Uint32 callbackData, + Uint32 returnCode){ + jam(); + + PageRecordPtr pageRecPtr; + c_pageRecordArray.getPtr(pageRecPtr, c_readTableRecord.pageId); + + ParseDictTabInfoRecord parseRecord; + parseRecord.requestType = DictTabInfo::GetTabInfoConf; + parseRecord.errorCode = 0; + + Uint32 sz = c_readTableRecord.noOfPages * ZSIZE_OF_PAGES_IN_WORDS; + SimplePropertiesLinearReader r(&pageRecPtr.p->word[0], sz); + handleTabInfoInit(r, &parseRecord); + ndbrequire(parseRecord.errorCode == 0); + + /* ---------------------------------------------------------------- */ + // We have read the table description from disk as part of system restart. + // We will also write it back again to ensure that both copies are ok. + /* ---------------------------------------------------------------- */ + ndbrequire(c_writeTableRecord.tableWriteState == WriteTableRecord::IDLE); + c_writeTableRecord.noOfPages = c_readTableRecord.noOfPages; + c_writeTableRecord.pageId = c_readTableRecord.pageId; + c_writeTableRecord.tableWriteState = WriteTableRecord::CALLBACK; + c_writeTableRecord.m_callback.m_callbackData = callbackData; + c_writeTableRecord.m_callback.m_callbackFunction = + safe_cast(&Dbdict::restartCreateTab_writeTableConf); + startWriteTableFile(signal, c_readTableRecord.tableId); +} + +void +Dbdict::execGET_TABINFO_CONF(Signal* signal){ + jamEntry(); + + if(!assembleFragments(signal)){ + jam(); + return; + } + + GetTabInfoConf * const conf = (GetTabInfoConf*)signal->getDataPtr(); + + const Uint32 tableId = conf->tableId; + const Uint32 senderData = conf->senderData; + + SegmentedSectionPtr tabInfoPtr; + signal->getSection(tabInfoPtr, GetTabInfoConf::DICT_TAB_INFO); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, senderData)); + ndbrequire(!createTabPtr.isNull()); + ndbrequire(createTabPtr.p->m_tablePtrI == tableId); + + /** + * Put data into table record + */ + ParseDictTabInfoRecord parseRecord; + parseRecord.requestType = DictTabInfo::GetTabInfoConf; + parseRecord.errorCode = 0; + + SimplePropertiesSectionReader r(tabInfoPtr, getSectionSegmentPool()); + handleTabInfoInit(r, &parseRecord); + ndbrequire(parseRecord.errorCode == 0); + + Callback callback; + callback.m_callbackData = createTabPtr.p->key; + callback.m_callbackFunction = + safe_cast(&Dbdict::restartCreateTab_writeTableConf); + + writeTableFile(signal, createTabPtr.p->m_tablePtrI, tabInfoPtr, &callback); +} + +void +Dbdict::restartCreateTab_writeTableConf(Signal* signal, + Uint32 callbackData, + Uint32 returnCode){ + jam(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, callbackData)); + + Callback callback; + callback.m_callbackData = callbackData; + callback.m_callbackFunction = + safe_cast(&Dbdict::restartCreateTab_dihComplete); + + SegmentedSectionPtr fragDataPtr; fragDataPtr.setNull(); + createTab_dih(signal, createTabPtr, fragDataPtr, &callback); +} + +void +Dbdict::restartCreateTab_dihComplete(Signal* signal, + Uint32 callbackData, + Uint32 returnCode){ + jam(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, callbackData)); + + //@todo check error + ndbrequire(createTabPtr.p->m_errorCode == 0); + + Callback callback; + callback.m_callbackData = callbackData; + callback.m_callbackFunction = + safe_cast(&Dbdict::restartCreateTab_activateComplete); + + alterTab_activate(signal, createTabPtr, &callback); +} + +void +Dbdict::restartCreateTab_activateComplete(Signal* signal, + Uint32 callbackData, + Uint32 returnCode){ + jam(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, callbackData)); + + TableRecordPtr tabPtr; + c_tableRecordPool.getPtr(tabPtr, createTabPtr.p->m_tablePtrI); + tabPtr.p->tabState = TableRecord::DEFINED; + + c_opCreateTable.release(createTabPtr); + + c_restartRecord.activeTable++; + checkSchemaStatus(signal); +} + +void +Dbdict::restartDropTab(Signal* signal, Uint32 tableId){ + + const Uint32 key = ++c_opRecordSequence; + + DropTableRecordPtr dropTabPtr; + ndbrequire(c_opDropTable.seize(dropTabPtr)); + + dropTabPtr.p->key = key; + c_opDropTable.add(dropTabPtr); + + dropTabPtr.p->m_errorCode = 0; + dropTabPtr.p->m_request.tableId = tableId; + dropTabPtr.p->m_coordinatorRef = 0; + dropTabPtr.p->m_requestType = DropTabReq::RestartDropTab; + dropTabPtr.p->m_participantData.m_gsn = GSN_DROP_TAB_REQ; + + + dropTabPtr.p->m_participantData.m_block = 0; + dropTabPtr.p->m_participantData.m_callback.m_callbackData = key; + dropTabPtr.p->m_participantData.m_callback.m_callbackFunction = + safe_cast(&Dbdict::restartDropTab_complete); + dropTab_nextStep(signal, dropTabPtr); +} + +void +Dbdict::restartDropTab_complete(Signal* signal, + Uint32 callbackData, + Uint32 returnCode){ + jam(); + + DropTableRecordPtr dropTabPtr; + ndbrequire(c_opDropTable.find(dropTabPtr, callbackData)); + + //@todo check error + + c_opDropTable.release(dropTabPtr); + + c_restartRecord.activeTable++; + checkSchemaStatus(signal); +} + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* MODULE: NODE FAILURE HANDLING ------------------------- */ +/* ---------------------------------------------------------------- */ +/* */ +/* This module contains the code that is used when nodes */ +/* (kernel/api) fails. */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ + +/* ---------------------------------------------------------------- */ +// We receive a report of an API that failed. +/* ---------------------------------------------------------------- */ +void Dbdict::execAPI_FAILREQ(Signal* signal) +{ + jamEntry(); + Uint32 failedApiNode = signal->theData[0]; + BlockReference retRef = signal->theData[1]; + +#if 0 + Uint32 userNode = refToNode(c_connRecord.userBlockRef); + if (userNode == failedApiNode) { + jam(); + c_connRecord.userBlockRef = (Uint32)-1; + }//if +#endif + + signal->theData[0] = failedApiNode; + signal->theData[1] = reference(); + sendSignal(retRef, GSN_API_FAILCONF, signal, 2, JBB); +}//execAPI_FAILREQ() + +/* ---------------------------------------------------------------- */ +// We receive a report of one or more node failures of kernel nodes. +/* ---------------------------------------------------------------- */ +void Dbdict::execNODE_FAILREP(Signal* signal) +{ + jamEntry(); + NodeFailRep * const nodeFail = (NodeFailRep *)&signal->theData[0]; + + c_failureNr = nodeFail->failNo; + const Uint32 numberOfFailedNodes = nodeFail->noOfNodes; + const bool masterFailed = (c_masterNodeId != nodeFail->masterNodeId); + c_masterNodeId = nodeFail->masterNodeId; + + c_noNodesFailed += numberOfFailedNodes; + Uint32 theFailedNodes[NodeBitmask::Size]; + memcpy(theFailedNodes, nodeFail->theNodes, sizeof(theFailedNodes)); + + c_counterMgr.execNODE_FAILREP(signal); + + bool ok = false; + switch(c_blockState){ + case BS_IDLE: + jam(); + ok = true; + if(c_opRecordPool.getSize() != c_opRecordPool.getNoOfFree()){ + jam(); + c_blockState = BS_NODE_FAILURE; + } + break; + case BS_CREATE_TAB: + jam(); + ok = true; + if(!masterFailed) + break; + // fall through + case BS_BUSY: + case BS_NODE_FAILURE: + jam(); + c_blockState = BS_NODE_FAILURE; + ok = true; + break; + } + ndbrequire(ok); + + for(unsigned i = 1; i < MAX_NDB_NODES; i++) { + jam(); + if(NodeBitmask::get(theFailedNodes, i)) { + jam(); + NodeRecordPtr nodePtr; + c_nodes.getPtr(nodePtr, i); + + nodePtr.p->nodeState = NodeRecord::NDB_NODE_DEAD; + NFCompleteRep * const nfCompRep = (NFCompleteRep *)&signal->theData[0]; + nfCompRep->blockNo = DBDICT; + nfCompRep->nodeId = getOwnNodeId(); + nfCompRep->failedNodeId = nodePtr.i; + sendSignal(DBDIH_REF, GSN_NF_COMPLETEREP, signal, + NFCompleteRep::SignalLength, JBB); + + c_aliveNodes.clear(i); + }//if + }//for + +}//execNODE_FAILREP() + + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* MODULE: NODE START HANDLING --------------------------- */ +/* ---------------------------------------------------------------- */ +/* */ +/* This module contains the code that is used when kernel nodes */ +/* starts. */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ + +/* ---------------------------------------------------------------- */ +// Include a starting node in list of nodes to be part of adding +// and dropping tables. +/* ---------------------------------------------------------------- */ +void Dbdict::execINCL_NODEREQ(Signal* signal) +{ + jamEntry(); + NodeRecordPtr nodePtr; + BlockReference retRef = signal->theData[0]; + nodePtr.i = signal->theData[1]; + + ndbrequire(c_noNodesFailed > 0); + c_noNodesFailed--; + + c_nodes.getPtr(nodePtr); + ndbrequire(nodePtr.p->nodeState = NodeRecord::NDB_NODE_DEAD); + nodePtr.p->nodeState = NodeRecord::NDB_NODE_ALIVE; + signal->theData[0] = reference(); + sendSignal(retRef, GSN_INCL_NODECONF, signal, 1, JBB); + + c_aliveNodes.set(nodePtr.i); +}//execINCL_NODEREQ() + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* MODULE: ADD TABLE HANDLING ---------------------------- */ +/* ---------------------------------------------------------------- */ +/* */ +/* This module contains the code that is used when adding a table. */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ + +/* ---------------------------------------------------------------- */ +// This signal receives information about a table from either: +// API, Ndbcntr or from other DICT. +/* ---------------------------------------------------------------- */ +void +Dbdict::execCREATE_TABLE_REQ(Signal* signal){ + jamEntry(); + if(!assembleFragments(signal)){ + return; + } + + CreateTableReq* const req = (CreateTableReq*)signal->getDataPtr(); + const Uint32 senderRef = req->senderRef; + const Uint32 senderData = req->senderData; + + ParseDictTabInfoRecord parseRecord; + do { + if(getOwnNodeId() != c_masterNodeId){ + jam(); + parseRecord.errorCode = CreateTableRef::NotMaster; + break; + } + + if (c_blockState != BS_IDLE){ + jam(); + parseRecord.errorCode = CreateTableRef::Busy; + break; + } + + CreateTableRecordPtr createTabPtr; + c_opCreateTable.seize(createTabPtr); + + if(createTabPtr.isNull()){ + jam(); + parseRecord.errorCode = CreateTableRef::Busy; + break; + } + + parseRecord.requestType = DictTabInfo::CreateTableFromAPI; + parseRecord.errorCode = 0; + + SegmentedSectionPtr ptr; + signal->getSection(ptr, CreateTableReq::DICT_TAB_INFO); + SimplePropertiesSectionReader r(ptr, getSectionSegmentPool()); + + handleTabInfoInit(r, &parseRecord); + releaseSections(signal); + + if(parseRecord.errorCode != 0){ + jam(); + c_opCreateTable.release(createTabPtr); + break; + } + + createTabPtr.p->key = ++c_opRecordSequence; + c_opCreateTable.add(createTabPtr); + createTabPtr.p->m_errorCode = 0; + createTabPtr.p->m_senderRef = senderRef; + createTabPtr.p->m_senderData = senderData; + createTabPtr.p->m_tablePtrI = parseRecord.tablePtr.i; + createTabPtr.p->m_coordinatorRef = reference(); + createTabPtr.p->m_fragmentsPtrI = RNIL; + createTabPtr.p->m_dihAddFragPtr = RNIL; + + Uint32 * theData = signal->getDataPtrSend(); + CreateFragmentationReq * const req = (CreateFragmentationReq*)theData; + req->senderRef = reference(); + req->senderData = createTabPtr.p->key; + req->fragmentationType = parseRecord.tablePtr.p->fragmentType; + req->noOfFragments = 0; + req->fragmentNode = 0; + req->primaryTableId = RNIL; + if (parseRecord.tablePtr.p->isOrderedIndex()) { + // ordered index has same fragmentation as the table + const Uint32 primaryTableId = parseRecord.tablePtr.p->primaryTableId; + TableRecordPtr primaryTablePtr; + c_tableRecordPool.getPtr(primaryTablePtr, primaryTableId); + // fragmentationType must be consistent + req->fragmentationType = primaryTablePtr.p->fragmentType; + req->primaryTableId = primaryTableId; + } + sendSignal(DBDIH_REF, GSN_CREATE_FRAGMENTATION_REQ, signal, + CreateFragmentationReq::SignalLength, JBB); + + c_blockState = BS_CREATE_TAB; + return; + } while(0); + + /** + * Something went wrong + */ + releaseSections(signal); + + CreateTableRef * ref = (CreateTableRef*)signal->getDataPtrSend(); + ref->senderData = senderData; + ref->senderRef = reference(); + ref->masterNodeId = c_masterNodeId; + ref->errorCode = parseRecord.errorCode; + ref->errorLine = parseRecord.errorLine; + ref->errorKey = parseRecord.errorKey; + ref->status = parseRecord.status; + sendSignal(senderRef, GSN_CREATE_TABLE_REF, signal, + CreateTableRef::SignalLength, JBB); +} + +void +Dbdict::execALTER_TABLE_REQ(Signal* signal) +{ + // Received by master + jamEntry(); + if(!assembleFragments(signal)){ + return; + } + AlterTableReq* const req = (AlterTableReq*)signal->getDataPtr(); + const Uint32 senderRef = req->senderRef; + const Uint32 senderData = req->senderData; + const Uint32 changeMask = req->changeMask; + const Uint32 tableId = req->tableId; + const Uint32 tableVersion = req->tableVersion; + ParseDictTabInfoRecord* aParseRecord; + + // Get table definition + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, tableId, false); + if(tablePtr.isNull()){ + jam(); + alterTableRef(signal, req, AlterTableRef::NoSuchTable); + return; + } + + if(getOwnNodeId() != c_masterNodeId){ + jam(); + alterTableRef(signal, req, AlterTableRef::NotMaster); + return; + } + + if(c_blockState != BS_IDLE){ + jam(); + alterTableRef(signal, req, AlterTableRef::Busy); + return; + } + + const TableRecord::TabState tabState = tablePtr.p->tabState; + bool ok = false; + switch(tabState){ + case TableRecord::NOT_DEFINED: + case TableRecord::REORG_TABLE_PREPARED: + case TableRecord::DEFINING: + case TableRecord::CHECKED: + jam(); + alterTableRef(signal, req, AlterTableRef::NoSuchTable); + return; + case TableRecord::DEFINED: + ok = true; + jam(); + break; + case TableRecord::PREPARE_DROPPING: + case TableRecord::DROPPING: + jam(); + alterTableRef(signal, req, AlterTableRef::DropInProgress); + return; + } + ndbrequire(ok); + + if(tablePtr.p->tableVersion != tableVersion){ + jam(); + alterTableRef(signal, req, AlterTableRef::InvalidTableVersion); + return; + } + // Parse new table defintion + ParseDictTabInfoRecord parseRecord; + aParseRecord = &parseRecord; + + CreateTableRecordPtr alterTabPtr; // Reuse create table records + c_opCreateTable.seize(alterTabPtr); + CreateTableRecord * regAlterTabPtr = alterTabPtr.p; + + if(alterTabPtr.isNull()){ + jam(); + alterTableRef(signal, req, AlterTableRef::Busy); + return; + } + + regAlterTabPtr->m_changeMask = changeMask; + parseRecord.requestType = DictTabInfo::AlterTableFromAPI; + parseRecord.errorCode = 0; + + SegmentedSectionPtr ptr; + signal->getSection(ptr, AlterTableReq::DICT_TAB_INFO); + SimplePropertiesSectionReader r(ptr, getSectionSegmentPool()); + + handleTabInfoInit(r, &parseRecord, false); // Will not save info + + if(parseRecord.errorCode != 0){ + jam(); + c_opCreateTable.release(alterTabPtr); + parseRecord.tablePtr.p->tabState = TableRecord::NOT_DEFINED; + releaseTableObject(parseRecord.tablePtr.i, false); + alterTableRef(signal, req, + (AlterTableRef::ErrorCode) parseRecord.errorCode, + aParseRecord); + return; + } + + releaseSections(signal); + regAlterTabPtr->key = ++c_opRecordSequence; + c_opCreateTable.add(alterTabPtr); + ndbrequire(c_opCreateTable.find(alterTabPtr, regAlterTabPtr->key)); + regAlterTabPtr->m_errorCode = 0; + regAlterTabPtr->m_senderRef = senderRef; + regAlterTabPtr->m_senderData = senderData; + regAlterTabPtr->m_tablePtrI = parseRecord.tablePtr.i; + regAlterTabPtr->m_alterTableFailed = false; + regAlterTabPtr->m_coordinatorRef = reference(); + regAlterTabPtr->m_fragmentsPtrI = RNIL; + regAlterTabPtr->m_dihAddFragPtr = RNIL; + + // Alter table on all nodes + c_blockState = BS_BUSY; + + // Send prepare request to all alive nodes + SimplePropertiesSectionWriter w(getSectionSegmentPool()); + packTableIntoPagesImpl(w, parseRecord.tablePtr); + + SegmentedSectionPtr tabInfoPtr; + w.getPtr(tabInfoPtr); + signal->setSection(tabInfoPtr, AlterTabReq::DICT_TAB_INFO); + + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + regAlterTabPtr->m_coordinatorData.m_gsn = GSN_ALTER_TAB_REQ; + SafeCounter safeCounter(c_counterMgr, regAlterTabPtr->m_coordinatorData.m_counter); + safeCounter.init(rg, regAlterTabPtr->key); + + AlterTabReq * const lreq = (AlterTabReq*)signal->getDataPtrSend(); + lreq->senderRef = reference(); + lreq->senderData = regAlterTabPtr->key; + lreq->clientRef = regAlterTabPtr->m_senderRef; + lreq->clientData = regAlterTabPtr->m_senderData; + lreq->changeMask = changeMask; + lreq->tableId = tableId; + lreq->tableVersion = tableVersion + 1; + lreq->gci = tablePtr.p->gciTableCreated; + lreq->requestType = AlterTabReq::AlterTablePrepare; + + sendSignal(rg, GSN_ALTER_TAB_REQ, signal, + AlterTabReq::SignalLength, JBB); + +} + +void Dbdict::alterTableRef(Signal * signal, + AlterTableReq * req, + AlterTableRef::ErrorCode errCode, + ParseDictTabInfoRecord* parseRecord) +{ + jam(); + releaseSections(signal); + AlterTableRef * ref = (AlterTableRef*)signal->getDataPtrSend(); + Uint32 senderRef = req->senderRef; + ref->senderData = req->senderData; + ref->senderRef = reference(); + ref->masterNodeId = c_masterNodeId; + if (parseRecord) { + ref->errorCode = parseRecord->errorCode; + ref->errorLine = parseRecord->errorLine; + ref->errorKey = parseRecord->errorKey; + ref->status = parseRecord->status; + } + else { + ref->errorCode = errCode; + ref->errorLine = 0; + ref->errorKey = 0; + ref->status = 0; + } + sendSignal(senderRef, GSN_ALTER_TABLE_REF, signal, + AlterTableRef::SignalLength, JBB); +} + +void +Dbdict::execALTER_TAB_REQ(Signal * signal) +{ + // Received in all nodes to handle change locally + jamEntry(); + + if(!assembleFragments(signal)){ + return; + } + AlterTabReq* const req = (AlterTabReq*)signal->getDataPtr(); + const Uint32 senderRef = req->senderRef; + const Uint32 senderData = req->senderData; + const Uint32 changeMask = req->changeMask; + const Uint32 tableId = req->tableId; + const Uint32 tableVersion = req->tableVersion; + const Uint32 gci = req->gci; + AlterTabReq::RequestType requestType = + (AlterTabReq::RequestType) req->requestType; + + SegmentedSectionPtr tabInfoPtr; + signal->getSection(tabInfoPtr, AlterTabReq::DICT_TAB_INFO); + + CreateTableRecordPtr alterTabPtr; // Reuse create table records + + if (senderRef != reference()) { + jam(); + c_blockState = BS_BUSY; + } + if ((requestType == AlterTabReq::AlterTablePrepare) + && (senderRef != reference())) { + jam(); + c_opCreateTable.seize(alterTabPtr); + if(!alterTabPtr.isNull()) + alterTabPtr.p->m_changeMask = changeMask; + } + else { + jam(); + ndbrequire(c_opCreateTable.find(alterTabPtr, senderData)); + } + if(alterTabPtr.isNull()){ + jam(); + alterTabRef(signal, req, AlterTableRef::Busy); + return; + } + CreateTableRecord * regAlterTabPtr = alterTabPtr.p; + regAlterTabPtr->m_alterTableId = tableId; + regAlterTabPtr->m_coordinatorRef = senderRef; + + // Get table definition + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, tableId, false); + if(tablePtr.isNull()){ + jam(); + alterTabRef(signal, req, AlterTableRef::NoSuchTable); + return; + } + + switch(requestType) { + case(AlterTabReq::AlterTablePrepare): { + ParseDictTabInfoRecord* aParseRecord; + + const TableRecord::TabState tabState = tablePtr.p->tabState; + bool ok = false; + switch(tabState){ + case TableRecord::NOT_DEFINED: + case TableRecord::REORG_TABLE_PREPARED: + case TableRecord::DEFINING: + case TableRecord::CHECKED: + jam(); + alterTabRef(signal, req, AlterTableRef::NoSuchTable); + return; + case TableRecord::DEFINED: + ok = true; + jam(); + break; + case TableRecord::PREPARE_DROPPING: + case TableRecord::DROPPING: + jam(); + alterTabRef(signal, req, AlterTableRef::DropInProgress); + return; + } + ndbrequire(ok); + + if(tablePtr.p->tableVersion + 1 != tableVersion){ + jam(); + alterTabRef(signal, req, AlterTableRef::InvalidTableVersion); + return; + } + TableRecordPtr newTablePtr; + if (senderRef != reference()) { + jam(); + // Parse altered table defintion + ParseDictTabInfoRecord parseRecord; + aParseRecord = &parseRecord; + + parseRecord.requestType = DictTabInfo::AlterTableFromAPI; + parseRecord.errorCode = 0; + + SimplePropertiesSectionReader r(tabInfoPtr, getSectionSegmentPool()); + + handleTabInfoInit(r, &parseRecord, false); // Will not save info + + if(parseRecord.errorCode != 0){ + jam(); + c_opCreateTable.release(alterTabPtr); + parseRecord.tablePtr.p->tabState = TableRecord::NOT_DEFINED; + releaseTableObject(parseRecord.tablePtr.i, false); + alterTabRef(signal, req, + (AlterTableRef::ErrorCode) parseRecord.errorCode, + aParseRecord); + return; + } + regAlterTabPtr->key = senderData; + c_opCreateTable.add(alterTabPtr); + regAlterTabPtr->m_errorCode = 0; + regAlterTabPtr->m_senderRef = senderRef; + regAlterTabPtr->m_senderData = senderData; + regAlterTabPtr->m_tablePtrI = parseRecord.tablePtr.i; + regAlterTabPtr->m_fragmentsPtrI = RNIL; + regAlterTabPtr->m_dihAddFragPtr = RNIL; + newTablePtr = parseRecord.tablePtr; + newTablePtr.p->tableVersion = tableVersion; + } + else { // (req->senderRef == reference()) + jam(); + c_tableRecordPool.getPtr(newTablePtr, regAlterTabPtr->m_tablePtrI); + newTablePtr.p->tableVersion = tableVersion; + } + if (handleAlterTab(req, regAlterTabPtr, tablePtr, newTablePtr) == -1) { + jam(); + c_opCreateTable.release(alterTabPtr); + alterTabRef(signal, req, AlterTableRef::UnsupportedChange); + return; + } + releaseSections(signal); + // Propagate alter table to other local blocks + AlterTabReq * req = (AlterTabReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + req->senderData = senderData; + req->changeMask = changeMask; + req->tableId = tableId; + req->tableVersion = tableVersion; + req->gci = gci; + req->requestType = requestType; + sendSignal(DBLQH_REF, GSN_ALTER_TAB_REQ, signal, + AlterTabReq::SignalLength, JBB); + return; + } + case(AlterTabReq::AlterTableCommit): { + jam(); + // Write schema for altered table to disk + SegmentedSectionPtr tabInfoPtr; + signal->getSection(tabInfoPtr, AlterTabReq::DICT_TAB_INFO); + regAlterTabPtr->m_tabInfoPtrI = tabInfoPtr.i; + + signal->header.m_noOfSections = 0; + + // Update table record + tablePtr.p->packedSize = tabInfoPtr.sz; + tablePtr.p->tableVersion = tableVersion; + tablePtr.p->gciTableCreated = gci; + + SchemaFile::TableEntry tabEntry; + tabEntry.m_tableVersion = tableVersion; + tabEntry.m_tableType = tablePtr.p->tableType; + tabEntry.m_tableState = SchemaFile::ALTER_TABLE_COMMITTED; + tabEntry.m_gcp = gci; + tabEntry.m_noOfPages = + DIV(tabInfoPtr.sz + ZPAGE_HEADER_SIZE, ZSIZE_OF_PAGES_IN_WORDS); + + Callback callback; + callback.m_callbackData = senderData; + callback.m_callbackFunction = + safe_cast(&Dbdict::alterTab_writeSchemaConf); + + updateSchemaState(signal, tableId, &tabEntry, &callback); + break; + } + case(AlterTabReq::AlterTableRevert): { + jam(); + // Revert failed alter table + revertAlterTable(signal, changeMask, tableId, regAlterTabPtr); + // Acknowledge the reverted alter table + AlterTabConf * conf = (AlterTabConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = senderData; + conf->changeMask = changeMask; + conf->tableId = tableId; + conf->tableVersion = tableVersion; + conf->gci = gci; + conf->requestType = requestType; + sendSignal(senderRef, GSN_ALTER_TAB_CONF, signal, + AlterTabConf::SignalLength, JBB); + break; + } + default: ndbrequire(false); + } +} + +void Dbdict::alterTabRef(Signal * signal, + AlterTabReq * req, + AlterTableRef::ErrorCode errCode, + ParseDictTabInfoRecord* parseRecord) +{ + jam(); + releaseSections(signal); + AlterTabRef * ref = (AlterTabRef*)signal->getDataPtrSend(); + Uint32 senderRef = req->senderRef; + ref->senderData = req->senderData; + ref->senderRef = reference(); + if (parseRecord) { + jam(); + ref->errorCode = parseRecord->errorCode; + ref->errorLine = parseRecord->errorLine; + ref->errorKey = parseRecord->errorKey; + ref->errorStatus = parseRecord->status; + } + else { + jam(); + ref->errorCode = errCode; + ref->errorLine = 0; + ref->errorKey = 0; + ref->errorStatus = 0; + } + sendSignal(senderRef, GSN_ALTER_TAB_REF, signal, + AlterTabRef::SignalLength, JBB); + + c_blockState = BS_IDLE; +} + +void Dbdict::execALTER_TAB_REF(Signal * signal){ + jamEntry(); + + AlterTabRef * ref = (AlterTabRef*)signal->getDataPtr(); + + Uint32 senderRef = ref->senderRef; + Uint32 senderData = ref->senderData; + Uint32 errorCode = ref->errorCode; + Uint32 errorLine = ref->errorLine; + Uint32 errorKey = ref->errorKey; + Uint32 errorStatus = ref->errorStatus; + AlterTabReq::RequestType requestType = + (AlterTabReq::RequestType) ref->requestType; + CreateTableRecordPtr alterTabPtr; + ndbrequire(c_opCreateTable.find(alterTabPtr, senderData)); + CreateTableRecord * regAlterTabPtr = alterTabPtr.p; + Uint32 changeMask = regAlterTabPtr->m_changeMask; + SafeCounter safeCounter(c_counterMgr, regAlterTabPtr->m_coordinatorData.m_counter); + safeCounter.clearWaitingFor(refToNode(senderRef)); + switch (requestType) { + case(AlterTabReq::AlterTablePrepare): { + if (safeCounter.done()) { + jam(); + // Send revert request to all alive nodes + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, regAlterTabPtr->m_alterTableId); + Uint32 tableId = tablePtr.p->tableId; + Uint32 tableVersion = tablePtr.p->tableVersion; + Uint32 gci = tablePtr.p->gciTableCreated; + SimplePropertiesSectionWriter w(getSectionSegmentPool()); + packTableIntoPagesImpl(w, tablePtr); + SegmentedSectionPtr spDataPtr; + w.getPtr(spDataPtr); + signal->setSection(spDataPtr, AlterTabReq::DICT_TAB_INFO); + + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + regAlterTabPtr->m_coordinatorData.m_gsn = GSN_ALTER_TAB_REQ; + safeCounter.init(rg, regAlterTabPtr->key); + + AlterTabReq * const lreq = (AlterTabReq*)signal->getDataPtrSend(); + lreq->senderRef = reference(); + lreq->senderData = regAlterTabPtr->key; + lreq->clientRef = regAlterTabPtr->m_senderRef; + lreq->clientData = regAlterTabPtr->m_senderData; + lreq->changeMask = changeMask; + lreq->tableId = tableId; + lreq->tableVersion = tableVersion; + lreq->gci = gci; + lreq->requestType = AlterTabReq::AlterTableRevert; + + sendSignal(rg, GSN_ALTER_TAB_REQ, signal, + AlterTabReq::SignalLength, JBB); + } + else { + jam(); + regAlterTabPtr->m_alterTableFailed = true; + } + break; + } + case(AlterTabReq::AlterTableCommit): + jam(); + case(AlterTabReq::AlterTableRevert): { + AlterTableRef * apiRef = (AlterTableRef*)signal->getDataPtrSend(); + + apiRef->senderData = senderData; + apiRef->senderRef = reference(); + apiRef->masterNodeId = c_masterNodeId; + apiRef->errorCode = errorCode; + apiRef->errorLine = errorLine; + apiRef->errorKey = errorKey; + apiRef->status = errorStatus; + if (safeCounter.done()) { + jam(); + sendSignal(senderRef, GSN_ALTER_TABLE_REF, signal, + AlterTableRef::SignalLength, JBB); + c_blockState = BS_IDLE; + } + else { + jam(); + regAlterTabPtr->m_alterTableFailed = true; + regAlterTabPtr->m_alterTableRef = *apiRef; + } + break; + } + default: ndbrequire(false); + } +} + +void +Dbdict::execALTER_TAB_CONF(Signal * signal){ + jamEntry(); + AlterTabConf * const conf = (AlterTabConf*)signal->getDataPtr(); + Uint32 senderRef = conf->senderRef; + Uint32 senderData = conf->senderData; + Uint32 changeMask = conf->changeMask; + Uint32 tableId = conf->tableId; + Uint32 tableVersion = conf->tableVersion; + Uint32 gci = conf->gci; + AlterTabReq::RequestType requestType = + (AlterTabReq::RequestType) conf->requestType; + CreateTableRecordPtr alterTabPtr; + ndbrequire(c_opCreateTable.find(alterTabPtr, senderData)); + CreateTableRecord * regAlterTabPtr = alterTabPtr.p; + + switch (requestType) { + case(AlterTabReq::AlterTablePrepare): { + switch(refToBlock(signal->getSendersBlockRef())) { + case DBLQH: { + jam(); + AlterTabReq * req = (AlterTabReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + req->senderData = senderData; + req->changeMask = changeMask; + req->tableId = tableId; + req->tableVersion = tableVersion; + req->gci = gci; + req->requestType = requestType; + sendSignal(DBDIH_REF, GSN_ALTER_TAB_REQ, signal, + AlterTabReq::SignalLength, JBB); + return; + } + case DBDIH: { + jam(); + AlterTabReq * req = (AlterTabReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + req->senderData = senderData; + req->changeMask = changeMask; + req->tableId = tableId; + req->tableVersion = tableVersion; + req->gci = gci; + req->requestType = requestType; + sendSignal(DBTC_REF, GSN_ALTER_TAB_REQ, signal, + AlterTabReq::SignalLength, JBB); + return; + } + case DBTC: { + jam(); + // Participant is done with prepare phase, send conf to coordinator + AlterTabConf * conf = (AlterTabConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = senderData; + conf->changeMask = changeMask; + conf->tableId = tableId; + conf->tableVersion = tableVersion; + conf->gci = gci; + conf->requestType = requestType; + sendSignal(regAlterTabPtr->m_coordinatorRef, GSN_ALTER_TAB_CONF, signal, + AlterTabConf::SignalLength, JBB); + return; + } + default :break; + } + // Coordinator only + SafeCounter safeCounter(c_counterMgr, regAlterTabPtr->m_coordinatorData.m_counter); + safeCounter.clearWaitingFor(refToNode(senderRef)); + if (safeCounter.done()) { + jam(); + // We have received all local confirmations + if (regAlterTabPtr->m_alterTableFailed) { + jam(); + // Send revert request to all alive nodes + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, regAlterTabPtr->m_alterTableId); + Uint32 tableId = tablePtr.p->tableId; + Uint32 tableVersion = tablePtr.p->tableVersion; + Uint32 gci = tablePtr.p->gciTableCreated; + SimplePropertiesSectionWriter w(getSectionSegmentPool()); + packTableIntoPagesImpl(w, tablePtr); + SegmentedSectionPtr spDataPtr; + w.getPtr(spDataPtr); + signal->setSection(spDataPtr, AlterTabReq::DICT_TAB_INFO); + + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + regAlterTabPtr->m_coordinatorData.m_gsn = GSN_ALTER_TAB_REQ; + safeCounter.init(rg, regAlterTabPtr->key); + + AlterTabReq * const lreq = (AlterTabReq*)signal->getDataPtrSend(); + lreq->senderRef = reference(); + lreq->senderData = regAlterTabPtr->key; + lreq->clientRef = regAlterTabPtr->m_senderRef; + lreq->clientData = regAlterTabPtr->m_senderData; + lreq->changeMask = changeMask; + lreq->tableId = tableId; + lreq->tableVersion = tableVersion; + lreq->gci = gci; + lreq->requestType = AlterTabReq::AlterTableRevert; + + sendSignal(rg, GSN_ALTER_TAB_REQ, signal, + AlterTabReq::SignalLength, JBB); + } + else { + jam(); + // Send commit request to all alive nodes + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, tableId); + SimplePropertiesSectionWriter w(getSectionSegmentPool()); + packTableIntoPagesImpl(w, tablePtr); + SegmentedSectionPtr spDataPtr; + w.getPtr(spDataPtr); + signal->setSection(spDataPtr, AlterTabReq::DICT_TAB_INFO); + + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + regAlterTabPtr->m_coordinatorData.m_gsn = GSN_ALTER_TAB_REQ; + safeCounter.init(rg, regAlterTabPtr->key); + + AlterTabReq * const lreq = (AlterTabReq*)signal->getDataPtrSend(); + lreq->senderRef = reference(); + lreq->senderData = regAlterTabPtr->key; + lreq->clientRef = regAlterTabPtr->m_senderRef; + lreq->clientData = regAlterTabPtr->m_senderData; + lreq->changeMask = changeMask; + lreq->tableId = tableId; + lreq->tableVersion = tableVersion; + lreq->gci = gci; + lreq->requestType = AlterTabReq::AlterTableCommit; + + sendSignal(rg, GSN_ALTER_TAB_REQ, signal, + AlterTabReq::SignalLength, JBB); + } + } + else { + // (!safeCounter.done()) + jam(); + } + break; + } + case(AlterTabReq::AlterTableRevert): + jam(); + case(AlterTabReq::AlterTableCommit): { + SafeCounter safeCounter(c_counterMgr, regAlterTabPtr->m_coordinatorData.m_counter); + safeCounter.clearWaitingFor(refToNode(senderRef)); + if (safeCounter.done()) { + jam(); + // We have received all local confirmations + releaseSections(signal); + if (regAlterTabPtr->m_alterTableFailed) { + jam(); + AlterTableRef * apiRef = + (AlterTableRef*)signal->getDataPtrSend(); + *apiRef = regAlterTabPtr->m_alterTableRef; + sendSignal(regAlterTabPtr->m_senderRef, GSN_ALTER_TABLE_REF, signal, + AlterTableRef::SignalLength, JBB); + } + else { + jam(); + // Alter table completed, inform API + AlterTableConf * const apiConf = + (AlterTableConf*)signal->getDataPtrSend(); + apiConf->senderRef = reference(); + apiConf->senderData = regAlterTabPtr->m_senderData; + apiConf->tableId = tableId; + apiConf->tableVersion = tableVersion; + + //@todo check api failed + sendSignal(regAlterTabPtr->m_senderRef, GSN_ALTER_TABLE_CONF, signal, + AlterTableConf::SignalLength, JBB); + } + + // Release resources + TableRecordPtr tabPtr; + c_tableRecordPool.getPtr(tabPtr, regAlterTabPtr->m_tablePtrI); + tabPtr.p->tabState = TableRecord::NOT_DEFINED; + releaseTableObject(tabPtr.i, false); + c_opCreateTable.release(alterTabPtr); + c_blockState = BS_IDLE; + } + else { + // (!safeCounter.done()) + jam(); + } + break; + } + default: ndbrequire(false); + } +} + +// For debugging +inline +void Dbdict::printTables() +{ + DLHashTable::Iterator iter; + bool moreTables = c_tableRecordHash.first(iter); + printf("TABLES IN DICT:\n"); + while (moreTables) { + TableRecordPtr tablePtr = iter.curr; + printf("%s ", tablePtr.p->tableName); + moreTables = c_tableRecordHash.next(iter); + } + printf("\n"); +} + +int Dbdict::handleAlterTab(AlterTabReq * req, + CreateTableRecord * regAlterTabPtr, + TableRecordPtr origTablePtr, + TableRecordPtr newTablePtr) +{ + Uint32 changeMask = req->changeMask; + + if (AlterTableReq::getNameFlag(changeMask)) { + jam(); + // Table rename + // Remove from hashtable + c_tableRecordHash.remove(origTablePtr); + strcpy(regAlterTabPtr->previousTableName, origTablePtr.p->tableName); + strcpy(origTablePtr.p->tableName, newTablePtr.p->tableName); + // Set new schema version + origTablePtr.p->tableVersion = newTablePtr.p->tableVersion; + // Put it back + c_tableRecordHash.add(origTablePtr); + + return 0; + } + jam(); + return -1; +} + +void Dbdict::revertAlterTable(Signal * signal, + Uint32 changeMask, + Uint32 tableId, + CreateTableRecord * regAlterTabPtr) +{ + if (AlterTableReq::getNameFlag(changeMask)) { + jam(); + // Table rename + // Restore previous name + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, tableId); + // Remove from hashtable + c_tableRecordHash.remove(tablePtr); + // Restore name + strcpy(tablePtr.p->tableName, regAlterTabPtr->previousTableName); + // Revert schema version + tablePtr.p->tableVersion = tablePtr.p->tableVersion - 1; + // Put it back + c_tableRecordHash.add(tablePtr); + + return; + } + + ndbrequire(false); +} + +void +Dbdict::alterTab_writeSchemaConf(Signal* signal, + Uint32 callbackData, + Uint32 returnCode) +{ + jam(); + Uint32 key = callbackData; + CreateTableRecordPtr alterTabPtr; + ndbrequire(c_opCreateTable.find(alterTabPtr, key)); + CreateTableRecord * regAlterTabPtr = alterTabPtr.p; + Uint32 tableId = regAlterTabPtr->m_alterTableId; + + Callback callback; + callback.m_callbackData = regAlterTabPtr->key; + callback.m_callbackFunction = + safe_cast(&Dbdict::alterTab_writeTableConf); + + SegmentedSectionPtr tabInfoPtr; + getSection(tabInfoPtr, regAlterTabPtr->m_tabInfoPtrI); + + writeTableFile(signal, tableId, tabInfoPtr, &callback); + + signal->setSection(tabInfoPtr, 0); + releaseSections(signal); +} + +void +Dbdict::alterTab_writeTableConf(Signal* signal, + Uint32 callbackData, + Uint32 returnCode) +{ + jam(); + CreateTableRecordPtr alterTabPtr; + ndbrequire(c_opCreateTable.find(alterTabPtr, callbackData)); + CreateTableRecord * regAlterTabPtr = alterTabPtr.p; + Uint32 coordinatorRef = regAlterTabPtr->m_coordinatorRef; + TableRecordPtr tabPtr; + c_tableRecordPool.getPtr(tabPtr, regAlterTabPtr->m_alterTableId); + + // Alter table commit request handled successfully + AlterTabConf * conf = (AlterTabConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = callbackData; + conf->tableId = tabPtr.p->tableId; + conf->tableVersion = tabPtr.p->tableVersion; + conf->gci = tabPtr.p->gciTableCreated; + conf->requestType = AlterTabReq::AlterTableCommit; + sendSignal(coordinatorRef, GSN_ALTER_TAB_CONF, signal, + AlterTabConf::SignalLength, JBB); + if(coordinatorRef != reference()) { + jam(); + // Release resources + c_tableRecordPool.getPtr(tabPtr, regAlterTabPtr->m_tablePtrI); + tabPtr.p->tabState = TableRecord::NOT_DEFINED; + releaseTableObject(tabPtr.i, false); + c_opCreateTable.release(alterTabPtr); + c_blockState = BS_IDLE; + } +} + +void +Dbdict::execCREATE_FRAGMENTATION_REF(Signal * signal){ + jamEntry(); + const Uint32 * theData = signal->getDataPtr(); + CreateFragmentationRef * const ref = (CreateFragmentationRef*)theData; + (void)ref; + ndbrequire(false); +} + +void +Dbdict::execCREATE_FRAGMENTATION_CONF(Signal* signal){ + jamEntry(); + const Uint32 * theData = signal->getDataPtr(); + CreateFragmentationConf * const conf = (CreateFragmentationConf*)theData; + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, conf->senderData)); + + ndbrequire(signal->getNoOfSections() == 1); + + SegmentedSectionPtr fragDataPtr; + signal->getSection(fragDataPtr, CreateFragmentationConf::FRAGMENTS); + + signal->header.m_noOfSections = 0; + + /** + * Correct table + */ + TableRecordPtr tabPtr; + c_tableRecordPool.getPtr(tabPtr, createTabPtr.p->m_tablePtrI); + + PageRecordPtr pagePtr; + c_pageRecordArray.getPtr(pagePtr, c_schemaRecord.schemaPage); + SchemaFile::TableEntry * tabEntry = getTableEntry(pagePtr.p, tabPtr.i); + + /** + * Update table version + */ + tabPtr.p->tableVersion = tabEntry->m_tableVersion + 1; + + SimplePropertiesSectionWriter w(getSectionSegmentPool()); + packTableIntoPagesImpl(w, tabPtr); + + SegmentedSectionPtr spDataPtr; + w.getPtr(spDataPtr); + + signal->setSection(spDataPtr, CreateTabReq::DICT_TAB_INFO); + signal->setSection(fragDataPtr, CreateTabReq::FRAGMENTATION); + + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + SafeCounter tmp(c_counterMgr, createTabPtr.p->m_coordinatorData.m_counter); + createTabPtr.p->m_coordinatorData.m_gsn = GSN_CREATE_TAB_REQ; + createTabPtr.p->m_coordinatorData.m_requestType = CreateTabReq::CreateTablePrepare; + tmp.init(rg, GSN_CREATE_TAB_REF, createTabPtr.p->key); + + CreateTabReq * const req = (CreateTabReq*)theData; + req->senderRef = reference(); + req->senderData = createTabPtr.p->key; + req->clientRef = createTabPtr.p->m_senderRef; + req->clientData = createTabPtr.p->m_senderData; + req->requestType = CreateTabReq::CreateTablePrepare; + + req->gci = 0; + req->tableId = tabPtr.i; + req->tableVersion = tabEntry->m_tableVersion + 1; + + sendSignal(rg, GSN_CREATE_TAB_REQ, signal, + CreateTabReq::SignalLength, JBB); + + + return; +} + +void +Dbdict::execCREATE_TAB_REF(Signal* signal){ + jamEntry(); + + CreateTabRef * const ref = (CreateTabRef*)signal->getDataPtr(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, ref->senderData)); + + ndbrequire(createTabPtr.p->m_coordinatorRef == reference()); + ndbrequire(createTabPtr.p->m_coordinatorData.m_gsn == GSN_CREATE_TAB_REQ); + + if(ref->errorCode != CreateTabRef::NF_FakeErrorREF){ + createTabPtr.p->setErrorCode(ref->errorCode); + } + createTab_reply(signal, createTabPtr, refToNode(ref->senderRef)); +} + +void +Dbdict::execCREATE_TAB_CONF(Signal* signal){ + jamEntry(); + + ndbrequire(signal->getNoOfSections() == 0); + + CreateTabConf * const conf = (CreateTabConf*)signal->getDataPtr(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, conf->senderData)); + + ndbrequire(createTabPtr.p->m_coordinatorRef == reference()); + ndbrequire(createTabPtr.p->m_coordinatorData.m_gsn == GSN_CREATE_TAB_REQ); + + createTab_reply(signal, createTabPtr, refToNode(conf->senderRef)); +} + +void +Dbdict::createTab_reply(Signal* signal, + CreateTableRecordPtr createTabPtr, + Uint32 nodeId) +{ + + SafeCounter tmp(c_counterMgr, createTabPtr.p->m_coordinatorData.m_counter); + if(!tmp.clearWaitingFor(nodeId)){ + jam(); + return; + } + + switch(createTabPtr.p->m_coordinatorData.m_requestType){ + case CreateTabReq::CreateTablePrepare:{ + + if(createTabPtr.p->m_errorCode != 0){ + jam(); + /** + * Failed to prepare on atleast one node -> abort on all + */ + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + createTabPtr.p->m_coordinatorData.m_gsn = GSN_CREATE_TAB_REQ; + createTabPtr.p->m_coordinatorData.m_requestType = CreateTabReq::CreateTableDrop; + ndbrequire(tmp.init(rg, createTabPtr.p->key)); + + CreateTabReq * const req = (CreateTabReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + req->senderData = createTabPtr.p->key; + req->requestType = CreateTabReq::CreateTableDrop; + + sendSignal(rg, GSN_CREATE_TAB_REQ, signal, + CreateTabReq::SignalLength, JBB); + return; + } + + /** + * Lock mutex before commiting table + */ + Mutex mutex(signal, c_mutexMgr, createTabPtr.p->m_startLcpMutex); + Callback c = { safe_cast(&Dbdict::createTab_startLcpMutex_locked), + createTabPtr.p->key}; + + ndbrequire(mutex.lock(c)); + return; + } + case CreateTabReq::CreateTableCommit:{ + jam(); + ndbrequire(createTabPtr.p->m_errorCode == 0); + + /** + * Unlock mutex before commiting table + */ + Mutex mutex(signal, c_mutexMgr, createTabPtr.p->m_startLcpMutex); + Callback c = { safe_cast(&Dbdict::createTab_startLcpMutex_unlocked), + createTabPtr.p->key}; + mutex.unlock(c); + return; + } + case CreateTabReq::CreateTableDrop:{ + jam(); + CreateTableRef * const ref = (CreateTableRef*)signal->getDataPtr(); + ref->senderRef = reference(); + ref->senderData = createTabPtr.p->m_senderData; + ref->errorCode = createTabPtr.p->m_errorCode; + + //@todo check api failed + sendSignal(createTabPtr.p->m_senderRef, GSN_CREATE_TABLE_REF, signal, + CreateTableRef::SignalLength, JBB); + c_opCreateTable.release(createTabPtr); + c_blockState = BS_IDLE; + return; + } + } + ndbrequire(false); +} + +void +Dbdict::createTab_startLcpMutex_locked(Signal* signal, + Uint32 callbackData, + Uint32 retValue){ + jamEntry(); + + ndbrequire(retValue == 0); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, callbackData)); + + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + createTabPtr.p->m_coordinatorData.m_gsn = GSN_CREATE_TAB_REQ; + createTabPtr.p->m_coordinatorData.m_requestType = CreateTabReq::CreateTableCommit; + SafeCounter tmp(c_counterMgr, createTabPtr.p->m_coordinatorData.m_counter); + tmp.init(rg, GSN_CREATE_TAB_REF, createTabPtr.p->key); + + CreateTabReq * const req = (CreateTabReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + req->senderData = createTabPtr.p->key; + req->requestType = CreateTabReq::CreateTableCommit; + + sendSignal(rg, GSN_CREATE_TAB_REQ, signal, + CreateTabReq::SignalLength, JBB); +} + +void +Dbdict::createTab_startLcpMutex_unlocked(Signal* signal, + Uint32 callbackData, + Uint32 retValue){ + jamEntry(); + + ndbrequire(retValue == 0); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, callbackData)); + + createTabPtr.p->m_startLcpMutex.release(c_mutexMgr); + + TableRecordPtr tabPtr; + c_tableRecordPool.getPtr(tabPtr, createTabPtr.p->m_tablePtrI); + + CreateTableConf * const conf = (CreateTableConf*)signal->getDataPtr(); + conf->senderRef = reference(); + conf->senderData = createTabPtr.p->m_senderData; + conf->tableId = createTabPtr.p->m_tablePtrI; + conf->tableVersion = tabPtr.p->tableVersion; + + //@todo check api failed + sendSignal(createTabPtr.p->m_senderRef, GSN_CREATE_TABLE_CONF, signal, + CreateTableConf::SignalLength, JBB); + c_opCreateTable.release(createTabPtr); + c_blockState = BS_IDLE; + return; +} + +/*********************************************************** + * CreateTable participant code + **********************************************************/ +void +Dbdict::execCREATE_TAB_REQ(Signal* signal){ + jamEntry(); + + if(!assembleFragments(signal)){ + jam(); + return; + } + + CreateTabReq * const req = (CreateTabReq*)signal->getDataPtr(); + + CreateTabReq::RequestType rt = (CreateTabReq::RequestType)req->requestType; + switch(rt){ + case CreateTabReq::CreateTablePrepare: + CRASH_INSERTION2(14000, getOwnNodeId() != c_masterNodeId); + createTab_prepare(signal, req); + return; + case CreateTabReq::CreateTableCommit: + CRASH_INSERTION2(14001, getOwnNodeId() != c_masterNodeId); + createTab_commit(signal, req); + return; + case CreateTabReq::CreateTableDrop: + CRASH_INSERTION2(14002, getOwnNodeId() != c_masterNodeId); + createTab_drop(signal, req); + return; + } + ndbrequire(false); +} + +void +Dbdict::createTab_prepare(Signal* signal, CreateTabReq * req){ + + const Uint32 gci = req->gci; + const Uint32 tableId = req->tableId; + const Uint32 tableVersion = req->tableVersion; + + SegmentedSectionPtr tabInfoPtr; + signal->getSection(tabInfoPtr, CreateTabReq::DICT_TAB_INFO); + + CreateTableRecordPtr createTabPtr; + if(req->senderRef == reference()){ + jam(); + ndbrequire(c_opCreateTable.find(createTabPtr, req->senderData)); + } else { + jam(); + c_opCreateTable.seize(createTabPtr); + + ndbrequire(!createTabPtr.isNull()); + + createTabPtr.p->key = req->senderData; + c_opCreateTable.add(createTabPtr); + createTabPtr.p->m_errorCode = 0; + createTabPtr.p->m_tablePtrI = tableId; + createTabPtr.p->m_coordinatorRef = req->senderRef; + createTabPtr.p->m_senderRef = req->clientRef; + createTabPtr.p->m_senderData = req->clientData; + createTabPtr.p->m_dihAddFragPtr = RNIL; + + /** + * Put data into table record + */ + ParseDictTabInfoRecord parseRecord; + parseRecord.requestType = DictTabInfo::AddTableFromDict; + parseRecord.errorCode = 0; + + SimplePropertiesSectionReader r(tabInfoPtr, getSectionSegmentPool()); + + handleTabInfoInit(r, &parseRecord); + + ndbrequire(parseRecord.errorCode == 0); + } + + ndbrequire(!createTabPtr.isNull()); + + SegmentedSectionPtr fragPtr; + signal->getSection(fragPtr, CreateTabReq::FRAGMENTATION); + + createTabPtr.p->m_tabInfoPtrI = tabInfoPtr.i; + createTabPtr.p->m_fragmentsPtrI = fragPtr.i; + + signal->header.m_noOfSections = 0; + + TableRecordPtr tabPtr; + c_tableRecordPool.getPtr(tabPtr, tableId); + tabPtr.p->packedSize = tabInfoPtr.sz; + tabPtr.p->tableVersion = tableVersion; + tabPtr.p->gciTableCreated = gci; + + SchemaFile::TableEntry tabEntry; + tabEntry.m_tableVersion = tableVersion; + tabEntry.m_tableType = tabPtr.p->tableType; + tabEntry.m_tableState = SchemaFile::ADD_STARTED; + tabEntry.m_gcp = gci; + tabEntry.m_noOfPages = + DIV(tabInfoPtr.sz + ZPAGE_HEADER_SIZE, ZSIZE_OF_PAGES_IN_WORDS); + + Callback callback; + callback.m_callbackData = createTabPtr.p->key; + callback.m_callbackFunction = + safe_cast(&Dbdict::createTab_writeSchemaConf1); + + updateSchemaState(signal, tableId, &tabEntry, &callback); +} + +void getSection(SegmentedSectionPtr & ptr, Uint32 i); + +void +Dbdict::createTab_writeSchemaConf1(Signal* signal, + Uint32 callbackData, + Uint32 returnCode){ + jam(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, callbackData)); + + Callback callback; + callback.m_callbackData = createTabPtr.p->key; + callback.m_callbackFunction = + safe_cast(&Dbdict::createTab_writeTableConf); + + SegmentedSectionPtr tabInfoPtr; + getSection(tabInfoPtr, createTabPtr.p->m_tabInfoPtrI); + + writeTableFile(signal, createTabPtr.p->m_tablePtrI, tabInfoPtr, &callback); + + signal->setSection(tabInfoPtr, 0); + releaseSections(signal); +} + +void +Dbdict::createTab_writeTableConf(Signal* signal, + Uint32 callbackData, + Uint32 returnCode){ + jam(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, callbackData)); + + SegmentedSectionPtr fragDataPtr; + getSection(fragDataPtr, createTabPtr.p->m_fragmentsPtrI); + + Callback callback; + callback.m_callbackData = callbackData; + callback.m_callbackFunction = + safe_cast(&Dbdict::createTab_dihComplete); + + createTab_dih(signal, createTabPtr, fragDataPtr, &callback); +} + +void +Dbdict::createTab_dih(Signal* signal, + CreateTableRecordPtr createTabPtr, + SegmentedSectionPtr fragDataPtr, + Callback * c){ + jam(); + + createTabPtr.p->m_callback = * c; + + TableRecordPtr tabPtr; + c_tableRecordPool.getPtr(tabPtr, createTabPtr.p->m_tablePtrI); + + DiAddTabReq * req = (DiAddTabReq*)signal->getDataPtrSend(); + req->connectPtr = createTabPtr.p->key; + req->tableId = tabPtr.i; + req->fragType = tabPtr.p->fragmentType; + req->kValue = tabPtr.p->kValue; + req->noOfReplicas = 0; + req->storedTable = tabPtr.p->storedTable; + req->tableType = tabPtr.p->tableType; + req->schemaVersion = tabPtr.p->tableVersion; + req->primaryTableId = tabPtr.p->primaryTableId; + + if(!fragDataPtr.isNull()){ + signal->setSection(fragDataPtr, DiAddTabReq::FRAGMENTATION); + } + + sendSignal(DBDIH_REF, GSN_DIADDTABREQ, signal, + DiAddTabReq::SignalLength, JBB); +} + +static +void +calcLHbits(Uint32 * lhPageBits, Uint32 * lhDistrBits, + Uint32 fid, Uint32 totalFragments) +{ + Uint32 distrBits = 0; + Uint32 pageBits = 0; + + Uint32 tmp = 1; + while (tmp < totalFragments) { + jam(); + tmp <<= 1; + distrBits++; + }//while + if (tmp != totalFragments) { + tmp >>= 1; + if ((fid >= (totalFragments - tmp)) && (fid < (tmp - 1))) { + distrBits--; + }//if + }//if + * lhPageBits = pageBits; + * lhDistrBits = distrBits; + +}//calcLHbits() + + +void +Dbdict::execADD_FRAGREQ(Signal* signal) { + jamEntry(); + + AddFragReq * const req = (AddFragReq*)signal->getDataPtr(); + + Uint32 dihPtr = req->dihPtr; + Uint32 senderData = req->senderData; + Uint32 tableId = req->tableId; + Uint32 fragId = req->fragmentId; + Uint32 node = req->nodeId; + Uint32 lcpNo = req->nextLCP; + Uint32 fragCount = req->totalFragments; + Uint32 requestInfo = req->requestInfo; + Uint32 startGci = req->startGci; + + ndbrequire(node == getOwnNodeId()); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, senderData)); + + createTabPtr.p->m_dihAddFragPtr = dihPtr; + + TableRecordPtr tabPtr; + c_tableRecordPool.getPtr(tabPtr, tableId); + +#if 0 + tabPtr.p->gciTableCreated = (startGci > tabPtr.p->gciTableCreated ? startGci: + startGci > tabPtr.p->gciTableCreated); +#endif + + /** + * Calc lh3PageBits + */ + Uint32 lhDistrBits = 0; + Uint32 lhPageBits = 0; + ::calcLHbits(&lhPageBits, &lhDistrBits, fragId, fragCount); + + { + LqhFragReq* req = (LqhFragReq*)signal->getDataPtrSend(); + req->senderData = senderData; + req->senderRef = reference(); + req->fragmentId = fragId; + req->requestInfo = requestInfo; + req->tableId = tableId; + req->localKeyLength = tabPtr.p->localKeyLen; + req->maxLoadFactor = tabPtr.p->maxLoadFactor; + req->minLoadFactor = tabPtr.p->minLoadFactor; + req->kValue = tabPtr.p->kValue; + req->lh3DistrBits = lhDistrBits; + req->lh3PageBits = lhPageBits; + req->noOfAttributes = tabPtr.p->noOfAttributes; + req->noOfNullAttributes = tabPtr.p->noOfNullAttr; + req->noOfPagesToPreAllocate = 0; + req->schemaVersion = tabPtr.p->tableVersion; + Uint32 keyLen = tabPtr.p->tupKeyLength; + req->keyLength = keyLen > 8 ? 0 : keyLen; // Put this into ACC instead + req->nextLCP = lcpNo; + + req->noOfKeyAttr = tabPtr.p->noOfPrimkey; + req->noOfNewAttr = 0; + req->checksumIndicator = 1; + req->noOfAttributeGroups = 1; + req->GCPIndicator = 0; + req->startGci = startGci; + req->tableType = tabPtr.p->tableType; + req->primaryTableId = tabPtr.p->primaryTableId; + sendSignal(DBLQH_REF, GSN_LQHFRAGREQ, signal, + LqhFragReq::SignalLength, JBB); + } +} + +void +Dbdict::execLQHFRAGREF(Signal * signal){ + jamEntry(); + LqhFragRef * const ref = (LqhFragRef*)signal->getDataPtr(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, ref->senderData)); + + createTabPtr.p->setErrorCode(ref->errorCode); + + { + AddFragRef * const ref = (AddFragRef*)signal->getDataPtr(); + ref->dihPtr = createTabPtr.p->m_dihAddFragPtr; + sendSignal(DBDIH_REF, GSN_ADD_FRAGREF, signal, + AddFragRef::SignalLength, JBB); + } +} + +void +Dbdict::execLQHFRAGCONF(Signal * signal){ + jamEntry(); + LqhFragConf * const conf = (LqhFragConf*)signal->getDataPtr(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, conf->senderData)); + + createTabPtr.p->m_lqhFragPtr = conf->lqhFragPtr; + + TableRecordPtr tabPtr; + c_tableRecordPool.getPtr(tabPtr, createTabPtr.p->m_tablePtrI); + sendLQHADDATTRREQ(signal, createTabPtr, tabPtr.p->firstAttribute); +} + +void +Dbdict::sendLQHADDATTRREQ(Signal* signal, + CreateTableRecordPtr createTabPtr, + Uint32 attributePtrI){ + jam(); + TableRecordPtr tabPtr; + c_tableRecordPool.getPtr(tabPtr, createTabPtr.p->m_tablePtrI); + LqhAddAttrReq * const req = (LqhAddAttrReq*)signal->getDataPtrSend(); + Uint32 i = 0; + for(i = 0; iattributes[i]; + entry.attrId = attrPtr.p->attributeId; + entry.attrDescriptor = attrPtr.p->attributeDescriptor; + entry.extTypeInfo = attrPtr.p->extType; + if (tabPtr.p->isIndex()) { + Uint32 primaryAttrId; + if (attrPtr.p->nextAttrInTable != RNIL) { + getIndexAttr(tabPtr, attributePtrI, &primaryAttrId); + } else { + primaryAttrId = ZNIL; + if (tabPtr.p->isOrderedIndex()) + entry.attrId = 0; // attribute goes to TUP + } + entry.attrId |= (primaryAttrId << 16); + } + attributePtrI = attrPtr.p->nextAttrInTable; + } + req->lqhFragPtr = createTabPtr.p->m_lqhFragPtr; + req->senderData = createTabPtr.p->key; + req->senderAttrPtr = attributePtrI; + req->noOfAttributes = i; + + sendSignal(DBLQH_REF, GSN_LQHADDATTREQ, signal, + LqhAddAttrReq::HeaderLength + LqhAddAttrReq::EntryLength * i, JBB); +} + +void +Dbdict::execLQHADDATTREF(Signal * signal){ + jamEntry(); + LqhAddAttrRef * const ref = (LqhAddAttrRef*)signal->getDataPtr(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, ref->senderData)); + + createTabPtr.p->setErrorCode(ref->errorCode); + + { + AddFragRef * const ref = (AddFragRef*)signal->getDataPtr(); + ref->dihPtr = createTabPtr.p->m_dihAddFragPtr; + sendSignal(DBDIH_REF, GSN_ADD_FRAGREF, signal, + AddFragRef::SignalLength, JBB); + } + +} + +void +Dbdict::execLQHADDATTCONF(Signal * signal){ + jamEntry(); + LqhAddAttrConf * const conf = (LqhAddAttrConf*)signal->getDataPtr(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, conf->senderData)); + + const Uint32 fragId = conf->fragId; + const Uint32 nextAttrPtr = conf->senderAttrPtr; + if(nextAttrPtr != RNIL){ + jam(); + sendLQHADDATTRREQ(signal, createTabPtr, nextAttrPtr); + return; + } + + { + AddFragConf * const conf = (AddFragConf*)signal->getDataPtr(); + conf->dihPtr = createTabPtr.p->m_dihAddFragPtr; + conf->fragId = fragId; + sendSignal(DBDIH_REF, GSN_ADD_FRAGCONF, signal, + AddFragConf::SignalLength, JBB); + } +} + +void +Dbdict::execDIADDTABREF(Signal* signal){ + jam(); + + DiAddTabRef * const ref = (DiAddTabRef*)signal->getDataPtr(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, ref->senderData)); + + createTabPtr.p->setErrorCode(ref->errorCode); + execute(signal, createTabPtr.p->m_callback, 0); +} + +void +Dbdict::execDIADDTABCONF(Signal* signal){ + jam(); + + DiAddTabConf * const conf = (DiAddTabConf*)signal->getDataPtr(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, conf->senderData)); + + signal->theData[0] = createTabPtr.p->key; + signal->theData[1] = reference(); + signal->theData[2] = createTabPtr.p->m_tablePtrI; + + if(createTabPtr.p->m_dihAddFragPtr != RNIL){ + jam(); + + /** + * We did perform at least one LQHFRAGREQ + */ + sendSignal(DBLQH_REF, GSN_TAB_COMMITREQ, signal, 3, JBB); + return; + } else { + /** + * No local fragment (i.e. no LQHFRAGREQ) + */ + sendSignal(DBDIH_REF, GSN_TAB_COMMITREQ, signal, 3, JBB); + } +} + +void +Dbdict::execTAB_COMMITREF(Signal* signal) { + jamEntry(); + ndbrequire(false); +}//execTAB_COMMITREF() + +void +Dbdict::execTAB_COMMITCONF(Signal* signal){ + jamEntry(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, signal->theData[0])); + + if(refToBlock(signal->getSendersBlockRef()) == DBLQH){ + + execute(signal, createTabPtr.p->m_callback, 0); + return; + } + + if(refToBlock(signal->getSendersBlockRef()) == DBDIH){ + TableRecordPtr tabPtr; + c_tableRecordPool.getPtr(tabPtr, createTabPtr.p->m_tablePtrI); + + signal->theData[0] = tabPtr.i; + signal->theData[1] = tabPtr.p->tableVersion; + signal->theData[2] = (Uint32)tabPtr.p->storedTable; + signal->theData[3] = reference(); + signal->theData[4] = (Uint32)tabPtr.p->tableType; + signal->theData[5] = createTabPtr.p->key; + sendSignal(DBTC_REF, GSN_TC_SCHVERREQ, signal, 6, JBB); + return; + } + + ndbrequire(false); +} + +void +Dbdict::createTab_dihComplete(Signal* signal, + Uint32 callbackData, + Uint32 returnCode){ + jam(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, callbackData)); + + //@todo check for master failed + + if(createTabPtr.p->m_errorCode == 0){ + jam(); + + CreateTabConf * const conf = (CreateTabConf*)signal->getDataPtr(); + conf->senderRef = reference(); + conf->senderData = createTabPtr.p->key; + sendSignal(createTabPtr.p->m_coordinatorRef, GSN_CREATE_TAB_CONF, + signal, CreateTabConf::SignalLength, JBB); + return; + } + + CreateTabRef * const ref = (CreateTabRef*)signal->getDataPtr(); + ref->senderRef = reference(); + ref->senderData = createTabPtr.p->key; + ref->errorCode = createTabPtr.p->m_errorCode; + ref->errorLine = 0; + ref->errorKey = 0; + ref->errorStatus = 0; + + sendSignal(createTabPtr.p->m_coordinatorRef, GSN_CREATE_TAB_REF, + signal, CreateTabRef::SignalLength, JBB); +} + +void +Dbdict::createTab_commit(Signal * signal, CreateTabReq * req){ + jam(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, req->senderData)); + + TableRecordPtr tabPtr; + c_tableRecordPool.getPtr(tabPtr, createTabPtr.p->m_tablePtrI); + + SchemaFile::TableEntry tabEntry; + tabEntry.m_tableVersion = tabPtr.p->tableVersion; + tabEntry.m_tableType = tabPtr.p->tableType; + tabEntry.m_tableState = SchemaFile::TABLE_ADD_COMMITTED; + tabEntry.m_gcp = tabPtr.p->gciTableCreated; + tabEntry.m_noOfPages = + DIV(tabPtr.p->packedSize + ZPAGE_HEADER_SIZE, ZSIZE_OF_PAGES_IN_WORDS); + + Callback callback; + callback.m_callbackData = createTabPtr.p->key; + callback.m_callbackFunction = + safe_cast(&Dbdict::createTab_writeSchemaConf2); + + updateSchemaState(signal, tabPtr.i, &tabEntry, &callback); +} + +void +Dbdict::createTab_writeSchemaConf2(Signal* signal, + Uint32 callbackData, + Uint32 returnCode){ + jam(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, callbackData)); + + Callback c; + c.m_callbackData = callbackData; + c.m_callbackFunction = safe_cast(&Dbdict::createTab_alterComplete); + alterTab_activate(signal, createTabPtr, &c); +} + +void +Dbdict::createTab_alterComplete(Signal* signal, + Uint32 callbackData, + Uint32 returnCode){ + jam(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, callbackData)); + + TableRecordPtr tabPtr; + c_tableRecordPool.getPtr(tabPtr, createTabPtr.p->m_tablePtrI); + tabPtr.p->tabState = TableRecord::DEFINED; + + //@todo check error + //@todo check master failed + + CreateTabConf * const conf = (CreateTabConf*)signal->getDataPtr(); + conf->senderRef = reference(); + conf->senderData = createTabPtr.p->key; + sendSignal(createTabPtr.p->m_coordinatorRef, GSN_CREATE_TAB_CONF, + signal, CreateTabConf::SignalLength, JBB); + + if(createTabPtr.p->m_coordinatorRef != reference()){ + jam(); + c_opCreateTable.release(createTabPtr); + } +} + +void +Dbdict::createTab_drop(Signal* signal, CreateTabReq * req){ + jam(); + + const Uint32 key = req->senderData; + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, key)); + + TableRecordPtr tabPtr; + c_tableRecordPool.getPtr(tabPtr, createTabPtr.p->m_tablePtrI); + tabPtr.p->tabState = TableRecord::DROPPING; + + DropTableRecordPtr dropTabPtr; + ndbrequire(c_opDropTable.seize(dropTabPtr)); + + dropTabPtr.p->key = key; + c_opDropTable.add(dropTabPtr); + + dropTabPtr.p->m_errorCode = 0; + dropTabPtr.p->m_request.tableId = createTabPtr.p->m_tablePtrI; + dropTabPtr.p->m_requestType = DropTabReq::CreateTabDrop; + dropTabPtr.p->m_coordinatorRef = createTabPtr.p->m_coordinatorRef; + dropTabPtr.p->m_participantData.m_gsn = GSN_DROP_TAB_REQ; + + dropTabPtr.p->m_participantData.m_block = 0; + dropTabPtr.p->m_participantData.m_callback.m_callbackData = req->senderData; + dropTabPtr.p->m_participantData.m_callback.m_callbackFunction = + safe_cast(&Dbdict::createTab_dropComplete); + dropTab_nextStep(signal, dropTabPtr); +} + +void +Dbdict::createTab_dropComplete(Signal* signal, + Uint32 callbackData, + Uint32 returnCode){ + jam(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, callbackData)); + + DropTableRecordPtr dropTabPtr; + ndbrequire(c_opDropTable.find(dropTabPtr, callbackData)); + + TableRecordPtr tabPtr; + c_tableRecordPool.getPtr(tabPtr, createTabPtr.p->m_tablePtrI); + tabPtr.p->tabState = TableRecord::NOT_DEFINED; + + releaseTableObject(tabPtr.i); + PageRecordPtr pagePtr; + c_pageRecordArray.getPtr(pagePtr, c_schemaRecord.schemaPage); + + SchemaFile::TableEntry * tableEntry = getTableEntry(pagePtr.p, tabPtr.i); + tableEntry->m_tableState = SchemaFile::DROP_TABLE_COMMITTED; + + //@todo check error + //@todo check master failed + + CreateTabConf * const conf = (CreateTabConf*)signal->getDataPtr(); + conf->senderRef = reference(); + conf->senderData = createTabPtr.p->key; + sendSignal(createTabPtr.p->m_coordinatorRef, GSN_CREATE_TAB_CONF, + signal, CreateTabConf::SignalLength, JBB); + + if(createTabPtr.p->m_coordinatorRef != reference()){ + jam(); + c_opCreateTable.release(createTabPtr); + } + + c_opDropTable.release(dropTabPtr); +} + +void +Dbdict::alterTab_activate(Signal* signal, CreateTableRecordPtr createTabPtr, + Callback * c){ + + createTabPtr.p->m_callback = * c; + + signal->theData[0] = createTabPtr.p->key; + signal->theData[1] = reference(); + signal->theData[2] = createTabPtr.p->m_tablePtrI; + sendSignal(DBDIH_REF, GSN_TAB_COMMITREQ, signal, 3, JBB); +} + +void +Dbdict::execTC_SCHVERCONF(Signal* signal){ + jamEntry(); + + CreateTableRecordPtr createTabPtr; + ndbrequire(c_opCreateTable.find(createTabPtr, signal->theData[1])); + + execute(signal, createTabPtr.p->m_callback, 0); +} + +#define tabRequire(cond, error) \ + if (!(cond)) { \ + jam(); \ + parseP->errorCode = error; parseP->errorLine = __LINE__; \ + parseP->errorKey = it.getKey(); \ + return; \ + }//if + +// handleAddTableFailure(signal, __LINE__, allocatedTable); + +void Dbdict::handleTabInfoInit(SimpleProperties::Reader & it, + ParseDictTabInfoRecord * parseP, + bool checkExist) +{ +/* ---------------------------------------------------------------- */ +// We always start by handling table name since this must be the first +// item in the list. Through the table name we can derive if it is a +// correct name, a new name or an already existing table. +/* ---------------------------------------------------------------- */ + + it.first(); + + SimpleProperties::UnpackStatus status; + DictTabInfo::Table tableDesc; tableDesc.init(); + status = SimpleProperties::unpack(it, &tableDesc, + DictTabInfo::TableMapping, + DictTabInfo::TableMappingSize, + true, true); + + if(status != SimpleProperties::Break){ + parseP->errorCode = CreateTableRef::InvalidFormat; + parseP->status = status; + parseP->errorKey = it.getKey(); + parseP->errorLine = __LINE__; + return; + } + + /* ---------------------------------------------------------------- */ + // Verify that table name is an allowed table name. + // TODO + /* ---------------------------------------------------------------- */ + const Uint32 tableNameLength = strlen(tableDesc.TableName) + 1; + + TableRecord keyRecord; + tabRequire(tableNameLength <= sizeof(keyRecord.tableName), + CreateTableRef::TableNameTooLong); + strcpy(keyRecord.tableName, tableDesc.TableName); + + TableRecordPtr tablePtr; + c_tableRecordHash.find(tablePtr, keyRecord); + + if (checkExist) + jam(); + /* ---------------------------------------------------------------- */ + // Check if table already existed. + /* ---------------------------------------------------------------- */ + tabRequire(tablePtr.i == RNIL, CreateTableRef::TableAlreadyExist); + + switch (parseP->requestType) { + case DictTabInfo::CreateTableFromAPI: { + jam(); + } + case DictTabInfo::AlterTableFromAPI:{ + jam(); + tablePtr.i = getFreeTableRecord(tableDesc.PrimaryTableId); + /* ---------------------------------------------------------------- */ + // Check if no free tables existed. + /* ---------------------------------------------------------------- */ + tabRequire(tablePtr.i != RNIL, CreateTableRef::NoMoreTableRecords); + + c_tableRecordPool.getPtr(tablePtr); + break; + } + case DictTabInfo::AddTableFromDict: + case DictTabInfo::ReadTableFromDiskSR: + case DictTabInfo::GetTabInfoConf: + { +/* ---------------------------------------------------------------- */ +// Get table id and check that table doesn't already exist +/* ---------------------------------------------------------------- */ + tablePtr.i = tableDesc.TableId; + + if (parseP->requestType == DictTabInfo::ReadTableFromDiskSR) { + ndbrequire(tablePtr.i == c_restartRecord.activeTable); + }//if + if (parseP->requestType == DictTabInfo::GetTabInfoConf) { + ndbrequire(tablePtr.i == c_restartRecord.activeTable); + }//if + + c_tableRecordPool.getPtr(tablePtr); + ndbrequire(tablePtr.p->tabState == TableRecord::NOT_DEFINED); + + //Uint32 oldTableVersion = tablePtr.p->tableVersion; + initialiseTableRecord(tablePtr); + if (parseP->requestType == DictTabInfo::AddTableFromDict) { + jam(); + tablePtr.p->tabState = TableRecord::DEFINING; + }//if + +/* ---------------------------------------------------------------- */ +// Get id of second table id and check that table doesn't already exist +// and set up links between first and second table. +/* ---------------------------------------------------------------- */ + TableRecordPtr secondTablePtr; + secondTablePtr.i = tableDesc.SecondTableId; + c_tableRecordPool.getPtr(secondTablePtr); + ndbrequire(secondTablePtr.p->tabState == TableRecord::NOT_DEFINED); + + initialiseTableRecord(secondTablePtr); + secondTablePtr.p->tabState = TableRecord::REORG_TABLE_PREPARED; + secondTablePtr.p->secondTable = tablePtr.i; + tablePtr.p->secondTable = secondTablePtr.i; + +/* ---------------------------------------------------------------- */ +// Set table version +/* ---------------------------------------------------------------- */ + Uint32 tableVersion = tableDesc.TableVersion; + tablePtr.p->tableVersion = tableVersion; + + break; + } + default: + ndbrequire(false); + break; + }//switch + parseP->tablePtr = tablePtr; + + strcpy(tablePtr.p->tableName, keyRecord.tableName); + if (parseP->requestType != DictTabInfo::AlterTableFromAPI) { + jam(); + c_tableRecordHash.add(tablePtr); + } + +#ifdef VM_TRACE + ndbout_c("Dbdict: name=%s,id=%u", tablePtr.p->tableName, tablePtr.i); +#endif + + //tablePtr.p->noOfPrimkey = tableDesc.NoOfKeyAttr; + //tablePtr.p->noOfNullAttr = tableDesc.NoOfNullable; + //tablePtr.p->tupKeyLength = tableDesc.KeyLength; + tablePtr.p->noOfAttributes = tableDesc.NoOfAttributes; + tablePtr.p->storedTable = tableDesc.TableLoggedFlag; + tablePtr.p->minLoadFactor = tableDesc.MinLoadFactor; + tablePtr.p->maxLoadFactor = tableDesc.MaxLoadFactor; + tablePtr.p->fragmentType = (DictTabInfo::FragmentType)tableDesc.FragmentType; + tablePtr.p->fragmentKeyType = (DictTabInfo::FragmentKeyType)tableDesc.FragmentKeyType; + tablePtr.p->tableType = (DictTabInfo::TableType)tableDesc.TableType; + tablePtr.p->kValue = tableDesc.TableKValue; + + tablePtr.p->frmLen = tableDesc.FrmLen; + memcpy(tablePtr.p->frmData, tableDesc.FrmData, tableDesc.FrmLen); + + if(tableDesc.PrimaryTableId != RNIL) { + + tablePtr.p->primaryTableId = tableDesc.PrimaryTableId; + tablePtr.p->indexState = (TableRecord::IndexState)tableDesc.IndexState; + tablePtr.p->insertTriggerId = tableDesc.InsertTriggerId; + tablePtr.p->updateTriggerId = tableDesc.UpdateTriggerId; + tablePtr.p->deleteTriggerId = tableDesc.DeleteTriggerId; + tablePtr.p->customTriggerId = tableDesc.CustomTriggerId; + } else { + tablePtr.p->primaryTableId = RNIL; + tablePtr.p->indexState = TableRecord::IS_UNDEFINED; + tablePtr.p->insertTriggerId = RNIL; + tablePtr.p->updateTriggerId = RNIL; + tablePtr.p->deleteTriggerId = RNIL; + tablePtr.p->customTriggerId = RNIL; + } + tablePtr.p->buildTriggerId = RNIL; + tablePtr.p->indexLocal = 0; + + handleTabInfo(it, parseP); + + if(parseP->errorCode != 0){ + /** + * Release table + */ + releaseTableObject(tablePtr.i); + } +}//handleTabInfoInit() + +void Dbdict::handleTabInfo(SimpleProperties::Reader & it, + ParseDictTabInfoRecord * parseP) +{ + TableRecordPtr tablePtr = parseP->tablePtr; + + SimpleProperties::UnpackStatus status; + + Uint32 keyCount = 0; + Uint32 keyLength = 0; + Uint32 attrCount = tablePtr.p->noOfAttributes; + Uint32 nullCount = 0; + Uint32 recordLength = 0; + AttributeRecordPtr attrPtr; + c_attributeRecordHash.removeAll(); + + for(Uint32 i = 0; ierrorCode = CreateTableRef::InvalidFormat; + parseP->status = status; + parseP->errorKey = it.getKey(); + parseP->errorLine = __LINE__; + return; + } + + /** + * Check that attribute is not defined twice + */ + AttributeRecord tmpAttr; + { + strcpy(tmpAttr.attributeName, attrDesc.AttributeName); + + AttributeRecordPtr attrPtr; + c_attributeRecordHash.find(attrPtr, tmpAttr); + + if(attrPtr.i != RNIL){ + parseP->errorCode = CreateTableRef::AttributeNameTwice; + return; + } + } + + if(!getNewAttributeRecord(tablePtr, attrPtr)){ + jam(); + parseP->errorCode = CreateTableRef::NoMoreAttributeRecords; + return; + } + + /** + * TmpAttrib to Attribute mapping + */ + strcpy(attrPtr.p->attributeName, attrDesc.AttributeName); + attrPtr.p->attributeId = attrDesc.AttributeId; + attrPtr.p->tupleKey = (keyCount + 1) * attrDesc.AttributeKeyFlag; + + attrPtr.p->extType = attrDesc.AttributeExtType; + attrPtr.p->extPrecision = attrDesc.AttributeExtPrecision; + attrPtr.p->extScale = attrDesc.AttributeExtScale; + attrPtr.p->extLength = attrDesc.AttributeExtLength; + + /** + * Ignore incoming old-style type and recompute it. + */ + bool translateOk = attrDesc.translateExtType(); + tabRequire(translateOk, CreateTableRef::Inconsistency); + + if(attrDesc.AttributeArraySize > 65535){ + parseP->errorCode = CreateTableRef::ArraySizeTooBig; + parseP->status = status; + parseP->errorKey = it.getKey(); + parseP->errorLine = __LINE__; + return; + } + + Uint32 desc = 0; + AttributeDescriptor::setType(desc, attrDesc.AttributeType); + AttributeDescriptor::setSize(desc, attrDesc.AttributeSize); + AttributeDescriptor::setArray(desc, attrDesc.AttributeArraySize); + AttributeDescriptor::setNullable(desc, attrDesc.AttributeNullableFlag); + AttributeDescriptor::setDGroup(desc, attrDesc.AttributeDGroup); + AttributeDescriptor::setDKey(desc, attrDesc.AttributeDKey); + AttributeDescriptor::setPrimaryKey(desc, attrDesc.AttributeKeyFlag); + + AttributeDescriptor::setStoredInTup(desc, attrDesc.AttributeStoredInd); + attrPtr.p->attributeDescriptor = desc; + attrPtr.p->autoIncrement = attrDesc.AttributeAutoIncrement; + strcpy(attrPtr.p->defaultValue, attrDesc.AttributeDefaultValue); + + tabRequire(attrDesc.AttributeId == i, CreateTableRef::InvalidFormat); + + attrCount ++; + keyCount += attrDesc.AttributeKeyFlag; + nullCount += attrDesc.AttributeNullableFlag; + + const Uint32 aSz = (1 << attrDesc.AttributeSize); + const Uint32 sz = ((aSz * attrDesc.AttributeArraySize) + 31) >> 5; + + recordLength += sz; + if(attrDesc.AttributeKeyFlag){ + keyLength += sz; + + if(attrDesc.AttributeNullableFlag){ + parseP->errorCode = CreateTableRef::NullablePrimaryKey; + parseP->status = status; + parseP->errorKey = it.getKey(); + parseP->errorLine = __LINE__; + return; + } + } + + if (parseP->requestType != DictTabInfo::AlterTableFromAPI) + c_attributeRecordHash.add(attrPtr); + + if(!it.next()) + break; + + if(it.getKey() != DictTabInfo::AttributeName) + break; + }//while + + tablePtr.p->noOfPrimkey = keyCount; + tablePtr.p->noOfNullAttr = nullCount; + tablePtr.p->tupKeyLength = keyLength; + + tabRequire(recordLength<= MAX_TUPLE_SIZE_IN_WORDS, + CreateTableRef::RecordTooBig); + tabRequire(keyLength <= MAX_KEY_SIZE_IN_WORDS, + CreateTableRef::InvalidPrimaryKeySize); + tabRequire(keyLength > 0, + CreateTableRef::InvalidPrimaryKeySize); + +}//handleTabInfo() + + +/* ---------------------------------------------------------------- */ +// DICTTABCONF is sent when participants have received all DICTTABINFO +// and successfully handled it. +// Also sent to self (DICT master) when index table creation ready. +/* ---------------------------------------------------------------- */ +void Dbdict::execCREATE_TABLE_CONF(Signal* signal) +{ + jamEntry(); + ndbrequire(signal->getNoOfSections() == 0); + + CreateTableConf * const conf = (CreateTableConf *)signal->getDataPtr(); + // assume part of create index operation + OpCreateIndexPtr opPtr; + c_opCreateIndex.find(opPtr, conf->senderData); + ndbrequire(! opPtr.isNull()); + opPtr.p->m_request.setIndexId(conf->tableId); + opPtr.p->m_request.setIndexVersion(conf->tableVersion); + createIndex_fromCreateTable(signal, opPtr); +}//execCREATE_TABLE_CONF() + +void Dbdict::execCREATE_TABLE_REF(Signal* signal) +{ + jamEntry(); + + CreateTableRef * const ref = (CreateTableRef *)signal->getDataPtr(); + // assume part of create index operation + OpCreateIndexPtr opPtr; + c_opCreateIndex.find(opPtr, ref->senderData); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + createIndex_fromCreateTable(signal, opPtr); +}//execCREATE_TABLE_REF() + +/* ---------------------------------------------------------------- */ +// New global checkpoint created. +/* ---------------------------------------------------------------- */ +void Dbdict::execWAIT_GCP_CONF(Signal* signal) +{ +#if 0 + TableRecordPtr tablePtr; + jamEntry(); + WaitGCPConf* const conf = (WaitGCPConf*)&signal->theData[0]; + c_tableRecordPool.getPtr(tablePtr, c_connRecord.connTableId); + tablePtr.p->gciTableCreated = conf->gcp; + sendUpdateSchemaState(signal, + tablePtr.i, + SchemaFile::TABLE_ADD_COMMITTED, + c_connRecord.noOfPagesForTable, + conf->gcp); +#endif +}//execWAIT_GCP_CONF() + +/* ---------------------------------------------------------------- */ +// Refused new global checkpoint. +/* ---------------------------------------------------------------- */ +void Dbdict::execWAIT_GCP_REF(Signal* signal) +{ + jamEntry(); + WaitGCPRef* const ref = (WaitGCPRef*)&signal->theData[0]; +/* ---------------------------------------------------------------- */ +// Error Handling code needed +/* ---------------------------------------------------------------- */ + progError(ref->errorCode, 0); +}//execWAIT_GCP_REF() + + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* MODULE: DROP TABLE -------------------- */ +/* ---------------------------------------------------------------- */ +/* */ +/* This module contains the code used to drop a table. */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ +void +Dbdict::execDROP_TABLE_REQ(Signal* signal){ + jamEntry(); + DropTableReq* req = (DropTableReq*)signal->getDataPtr(); + + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, req->tableId, false); + if(tablePtr.isNull()){ + jam(); + dropTableRef(signal, req, DropTableRef::NoSuchTable); + return; + } + + if(getOwnNodeId() != c_masterNodeId){ + jam(); + dropTableRef(signal, req, DropTableRef::NotMaster); + return; + } + + if(c_blockState != BS_IDLE){ + jam(); + dropTableRef(signal, req, DropTableRef::Busy); + return; + } + + const TableRecord::TabState tabState = tablePtr.p->tabState; + bool ok = false; + switch(tabState){ + case TableRecord::NOT_DEFINED: + case TableRecord::REORG_TABLE_PREPARED: + case TableRecord::DEFINING: + case TableRecord::CHECKED: + jam(); + dropTableRef(signal, req, DropTableRef::NoSuchTable); + return; + case TableRecord::DEFINED: + ok = true; + jam(); + break; + case TableRecord::PREPARE_DROPPING: + case TableRecord::DROPPING: + jam(); + dropTableRef(signal, req, DropTableRef::DropInProgress); + return; + } + ndbrequire(ok); + + if(tablePtr.p->tableVersion != req->tableVersion){ + jam(); + dropTableRef(signal, req, DropTableRef::InvalidTableVersion); + return; + } + + /** + * Seems ok + */ + DropTableRecordPtr dropTabPtr; + c_opDropTable.seize(dropTabPtr); + + if(dropTabPtr.isNull()){ + jam(); + dropTableRef(signal, req, DropTableRef::NoDropTableRecordAvailable); + return; + } + + c_blockState = BS_BUSY; + + dropTabPtr.p->key = ++c_opRecordSequence; + c_opDropTable.add(dropTabPtr); + + tablePtr.p->tabState = TableRecord::PREPARE_DROPPING; + + dropTabPtr.p->m_request = * req; + dropTabPtr.p->m_errorCode = 0; + dropTabPtr.p->m_requestType = DropTabReq::OnlineDropTab; + dropTabPtr.p->m_coordinatorRef = reference(); + dropTabPtr.p->m_coordinatorData.m_gsn = GSN_PREP_DROP_TAB_REQ; + dropTabPtr.p->m_coordinatorData.m_block = 0; + prepDropTab_nextStep(signal, dropTabPtr); +} + +void +Dbdict::dropTableRef(Signal * signal, + DropTableReq * req, DropTableRef::ErrorCode errCode){ + + Uint32 tableId = req->tableId; + Uint32 tabVersion = req->tableVersion; + Uint32 senderData = req->senderData; + Uint32 senderRef = req->senderRef; + + DropTableRef * ref = (DropTableRef*)signal->getDataPtrSend(); + ref->tableId = tableId; + ref->tableVersion = tabVersion; + ref->senderData = senderData; + ref->senderRef = reference(); + ref->errorCode = errCode; + ref->masterNodeId = c_masterNodeId; + sendSignal(senderRef, GSN_DROP_TABLE_REF, signal, + DropTableRef::SignalLength, JBB); +} + +void +Dbdict::prepDropTab_nextStep(Signal* signal, DropTableRecordPtr dropTabPtr){ + + /** + * No errors currently allowed + */ + ndbrequire(dropTabPtr.p->m_errorCode == 0); + + Uint32 block = 0; + switch(dropTabPtr.p->m_coordinatorData.m_block){ + case 0: + jam(); + block = dropTabPtr.p->m_coordinatorData.m_block = DBDICT; + break; + case DBDICT: + jam(); + block = dropTabPtr.p->m_coordinatorData.m_block = DBLQH; + break; + case DBLQH: + jam(); + block = dropTabPtr.p->m_coordinatorData.m_block = DBTC; + break; + case DBTC: + jam(); + block = dropTabPtr.p->m_coordinatorData.m_block = DBDIH; + break; + case DBDIH: + jam(); + prepDropTab_complete(signal, dropTabPtr); + return; + default: + ndbrequire(false); + } + + PrepDropTabReq * prep = (PrepDropTabReq*)signal->getDataPtrSend(); + prep->senderRef = reference(); + prep->senderData = dropTabPtr.p->key; + prep->tableId = dropTabPtr.p->m_request.tableId; + prep->requestType = dropTabPtr.p->m_requestType; + + dropTabPtr.p->m_coordinatorData.m_signalCounter = c_aliveNodes; + NodeReceiverGroup rg(block, c_aliveNodes); + sendSignal(rg, GSN_PREP_DROP_TAB_REQ, signal, + PrepDropTabReq::SignalLength, JBB); + +#if 0 + for (Uint32 i = 1; i < MAX_NDB_NODES; i++){ + if(c_aliveNodes.get(i)){ + jam(); + BlockReference ref = numberToRef(block, i); + + dropTabPtr.p->m_coordinatorData.m_signalCounter.setWaitingFor(i); + } + } +#endif +} + +void +Dbdict::execPREP_DROP_TAB_CONF(Signal * signal){ + jamEntry(); + + PrepDropTabConf * prep = (PrepDropTabConf*)signal->getDataPtr(); + + DropTableRecordPtr dropTabPtr; + ndbrequire(c_opDropTable.find(dropTabPtr, prep->senderData)); + + ndbrequire(dropTabPtr.p->m_coordinatorRef == reference()); + ndbrequire(dropTabPtr.p->m_request.tableId == prep->tableId); + ndbrequire(dropTabPtr.p->m_coordinatorData.m_gsn == GSN_PREP_DROP_TAB_REQ); + + Uint32 nodeId = refToNode(prep->senderRef); + dropTabPtr.p->m_coordinatorData.m_signalCounter.clearWaitingFor(nodeId); + + if(!dropTabPtr.p->m_coordinatorData.m_signalCounter.done()){ + jam(); + return; + } + prepDropTab_nextStep(signal, dropTabPtr); +} + +void +Dbdict::execPREP_DROP_TAB_REF(Signal* signal){ + jamEntry(); + + PrepDropTabRef * prep = (PrepDropTabRef*)signal->getDataPtr(); + + DropTableRecordPtr dropTabPtr; + ndbrequire(c_opDropTable.find(dropTabPtr, prep->senderData)); + + ndbrequire(dropTabPtr.p->m_coordinatorRef == reference()); + ndbrequire(dropTabPtr.p->m_request.tableId == prep->tableId); + ndbrequire(dropTabPtr.p->m_coordinatorData.m_gsn == GSN_PREP_DROP_TAB_REQ); + + Uint32 nodeId = refToNode(prep->senderRef); + dropTabPtr.p->m_coordinatorData.m_signalCounter.clearWaitingFor(nodeId); + + dropTabPtr.p->setErrorCode((Uint32)prep->errorCode); + if(!dropTabPtr.p->m_coordinatorData.m_signalCounter.done()){ + jam(); + return; + } + prepDropTab_nextStep(signal, dropTabPtr); +} + +void +Dbdict::prepDropTab_complete(Signal* signal, DropTableRecordPtr dropTabPtr){ + jam(); + + dropTabPtr.p->m_coordinatorData.m_gsn = GSN_DROP_TAB_REQ; + dropTabPtr.p->m_coordinatorData.m_block = DBDICT; + + DropTabReq * req = (DropTabReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + req->senderData = dropTabPtr.p->key; + req->tableId = dropTabPtr.p->m_request.tableId; + req->requestType = dropTabPtr.p->m_requestType; + + dropTabPtr.p->m_coordinatorData.m_signalCounter = c_aliveNodes; + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + sendSignal(rg, GSN_DROP_TAB_REQ, signal, + DropTabReq::SignalLength, JBB); +} + +void +Dbdict::execDROP_TAB_REF(Signal* signal){ + jamEntry(); + + ndbrequire(false); +} + +void +Dbdict::execDROP_TAB_CONF(Signal* signal){ + jamEntry(); + + DropTabConf * const req = (DropTabConf*)signal->getDataPtr(); + + if(refToBlock(req->senderRef) != DBDICT){ + jam(); + ndbrequire(refToNode(req->senderRef) == getOwnNodeId()); + dropTab_localDROP_TAB_CONF(signal); + return; + } + + DropTableRecordPtr dropTabPtr; + ndbrequire(c_opDropTable.find(dropTabPtr, req->senderData)); + + ndbrequire(dropTabPtr.p->m_coordinatorRef == reference()); + ndbrequire(dropTabPtr.p->m_request.tableId == req->tableId); + ndbrequire(dropTabPtr.p->m_coordinatorData.m_gsn == GSN_DROP_TAB_REQ); + + Uint32 nodeId = refToNode(req->senderRef); + dropTabPtr.p->m_coordinatorData.m_signalCounter.clearWaitingFor(nodeId); + + if(!dropTabPtr.p->m_coordinatorData.m_signalCounter.done()){ + jam(); + return; + } + + DropTableConf* conf = (DropTableConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = dropTabPtr.p->m_request.senderData; + conf->tableId = dropTabPtr.p->m_request.tableId; + conf->tableVersion = dropTabPtr.p->m_request.tableVersion; + + Uint32 ref = dropTabPtr.p->m_request.senderRef; + sendSignal(ref, GSN_DROP_TABLE_CONF, signal, + DropTableConf::SignalLength, JBB); + + c_opDropTable.release(dropTabPtr); + c_blockState = BS_IDLE; +} + +/** + * DROP TABLE PARTICIPANT CODE + */ +void +Dbdict::execPREP_DROP_TAB_REQ(Signal* signal){ + jamEntry(); + PrepDropTabReq * prep = (PrepDropTabReq*)signal->getDataPtrSend(); + + DropTableRecordPtr dropTabPtr; + if(prep->senderRef == reference()){ + jam(); + ndbrequire(c_opDropTable.find(dropTabPtr, prep->senderData)); + ndbrequire(dropTabPtr.p->m_requestType == prep->requestType); + } else { + jam(); + c_opDropTable.seize(dropTabPtr); + if(!dropTabPtr.isNull()){ + dropTabPtr.p->key = prep->senderData; + c_opDropTable.add(dropTabPtr); + } + } + + ndbrequire(!dropTabPtr.isNull()); + + dropTabPtr.p->m_errorCode = 0; + dropTabPtr.p->m_request.tableId = prep->tableId; + dropTabPtr.p->m_requestType = prep->requestType; + dropTabPtr.p->m_coordinatorRef = prep->senderRef; + dropTabPtr.p->m_participantData.m_gsn = GSN_PREP_DROP_TAB_REQ; + + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, prep->tableId); + tablePtr.p->tabState = TableRecord::PREPARE_DROPPING; + + /** + * Modify schema + */ + PageRecordPtr pagePtr; + c_pageRecordArray.getPtr(pagePtr, c_schemaRecord.schemaPage); + + SchemaFile::TableEntry * tableEntry = getTableEntry(pagePtr.p, tablePtr.i); + SchemaFile::TableState tabState = + (SchemaFile::TableState)tableEntry->m_tableState; + ndbrequire(tabState == SchemaFile::TABLE_ADD_COMMITTED || + tabState == SchemaFile::ALTER_TABLE_COMMITTED); + tableEntry->m_tableState = SchemaFile::DROP_TABLE_STARTED; + computeChecksum((SchemaFile*)pagePtr.p); + + ndbrequire(c_writeSchemaRecord.inUse == false); + c_writeSchemaRecord.inUse = true; + + c_writeSchemaRecord.pageId = c_schemaRecord.schemaPage; + c_writeSchemaRecord.m_callback.m_callbackData = dropTabPtr.p->key; + c_writeSchemaRecord.m_callback.m_callbackFunction = + safe_cast(&Dbdict::prepDropTab_writeSchemaConf); + startWriteSchemaFile(signal); +} + +void +Dbdict::prepDropTab_writeSchemaConf(Signal* signal, + Uint32 dropTabPtrI, + Uint32 returnCode){ + jam(); + + DropTableRecordPtr dropTabPtr; + ndbrequire(c_opDropTable.find(dropTabPtr, dropTabPtrI)); + + ndbrequire(dropTabPtr.p->m_participantData.m_gsn == GSN_PREP_DROP_TAB_REQ); + + /** + * There probably should be node fail handlign here + * + * To check that coordinator hasn't died + */ + + PrepDropTabConf * prep = (PrepDropTabConf*)signal->getDataPtr(); + prep->senderRef = reference(); + prep->senderData = dropTabPtrI; + prep->tableId = dropTabPtr.p->m_request.tableId; + + dropTabPtr.p->m_participantData.m_gsn = GSN_PREP_DROP_TAB_CONF; + sendSignal(dropTabPtr.p->m_coordinatorRef, GSN_PREP_DROP_TAB_CONF, signal, + PrepDropTabConf::SignalLength, JBB); +} + +void +Dbdict::execDROP_TAB_REQ(Signal* signal){ + jamEntry(); + DropTabReq * req = (DropTabReq*)signal->getDataPtrSend(); + + DropTableRecordPtr dropTabPtr; + ndbrequire(c_opDropTable.find(dropTabPtr, req->senderData)); + + ndbrequire(dropTabPtr.p->m_participantData.m_gsn == GSN_PREP_DROP_TAB_CONF); + dropTabPtr.p->m_participantData.m_gsn = GSN_DROP_TAB_REQ; + + ndbrequire(dropTabPtr.p->m_requestType == req->requestType); + + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, dropTabPtr.p->m_request.tableId); + tablePtr.p->tabState = TableRecord::DROPPING; + + dropTabPtr.p->m_participantData.m_block = 0; + dropTabPtr.p->m_participantData.m_callback.m_callbackData = dropTabPtr.p->key; + dropTabPtr.p->m_participantData.m_callback.m_callbackFunction = + safe_cast(&Dbdict::dropTab_complete); + dropTab_nextStep(signal, dropTabPtr); +} + +#include + +void +Dbdict::dropTab_nextStep(Signal* signal, DropTableRecordPtr dropTabPtr){ + + /** + * No errors currently allowed + */ + ndbrequire(dropTabPtr.p->m_errorCode == 0); + + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, dropTabPtr.p->m_request.tableId); + + Uint32 block = 0; + switch(dropTabPtr.p->m_participantData.m_block){ + case 0: + jam(); + block = DBTC; + break; + case DBTC: + jam(); + if (tablePtr.p->isTable() || tablePtr.p->isHashIndex()) + block = DBACC; + if (tablePtr.p->isOrderedIndex()) + block = DBTUP; + break; + case DBACC: + jam(); + block = DBTUP; + break; + case DBTUP: + jam(); + if (tablePtr.p->isTable() || tablePtr.p->isHashIndex()) + block = DBLQH; + if (tablePtr.p->isOrderedIndex()) + block = DBTUX; + break; + case DBTUX: + jam(); + block = DBLQH; + break; + case DBLQH: + jam(); + block = DBDIH; + break; + case DBDIH: + jam(); + execute(signal, dropTabPtr.p->m_participantData.m_callback, 0); + return; + } + ndbrequire(block != 0); + dropTabPtr.p->m_participantData.m_block = block; + + DropTabReq * req = (DropTabReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + req->senderData = dropTabPtr.p->key; + req->tableId = dropTabPtr.p->m_request.tableId; + req->requestType = dropTabPtr.p->m_requestType; + + const Uint32 nodeId = getOwnNodeId(); + dropTabPtr.p->m_participantData.m_signalCounter.clearWaitingFor(); + dropTabPtr.p->m_participantData.m_signalCounter.setWaitingFor(nodeId); + BlockReference ref = numberToRef(block, 0); + sendSignal(ref, GSN_DROP_TAB_REQ, signal, DropTabReq::SignalLength, JBB); +} + +void +Dbdict::dropTab_localDROP_TAB_CONF(Signal* signal){ + jamEntry(); + + DropTabConf * conf = (DropTabConf*)signal->getDataPtr(); + + DropTableRecordPtr dropTabPtr; + ndbrequire(c_opDropTable.find(dropTabPtr, conf->senderData)); + + ndbrequire(dropTabPtr.p->m_request.tableId == conf->tableId); + ndbrequire(dropTabPtr.p->m_participantData.m_gsn == GSN_DROP_TAB_REQ); + + Uint32 nodeId = refToNode(conf->senderRef); + dropTabPtr.p->m_participantData.m_signalCounter.clearWaitingFor(nodeId); + + if(!dropTabPtr.p->m_participantData.m_signalCounter.done()){ + jam(); + ndbrequire(false); + return; + } + dropTab_nextStep(signal, dropTabPtr); +} + +void +Dbdict::dropTab_complete(Signal* signal, + Uint32 dropTabPtrI, + Uint32 returnCode){ + jam(); + + DropTableRecordPtr dropTabPtr; + ndbrequire(c_opDropTable.find(dropTabPtr, dropTabPtrI)); + + Uint32 tableId = dropTabPtr.p->m_request.tableId; + + /** + * Write to schema file + */ + PageRecordPtr pagePtr; + c_pageRecordArray.getPtr(pagePtr, c_schemaRecord.schemaPage); + + SchemaFile::TableEntry * tableEntry = getTableEntry(pagePtr.p, tableId); + SchemaFile::TableState tabState = + (SchemaFile::TableState)tableEntry->m_tableState; + ndbrequire(tabState == SchemaFile::DROP_TABLE_STARTED); + tableEntry->m_tableState = SchemaFile::DROP_TABLE_COMMITTED; + computeChecksum((SchemaFile*)pagePtr.p); + + ndbrequire(c_writeSchemaRecord.inUse == false); + c_writeSchemaRecord.inUse = true; + + c_writeSchemaRecord.pageId = c_schemaRecord.schemaPage; + c_writeSchemaRecord.m_callback.m_callbackData = dropTabPtr.p->key; + c_writeSchemaRecord.m_callback.m_callbackFunction = + safe_cast(&Dbdict::dropTab_writeSchemaConf); + startWriteSchemaFile(signal); +} + +void +Dbdict::dropTab_writeSchemaConf(Signal* signal, + Uint32 dropTabPtrI, + Uint32 returnCode){ + jam(); + + DropTableRecordPtr dropTabPtr; + ndbrequire(c_opDropTable.find(dropTabPtr, dropTabPtrI)); + + ndbrequire(dropTabPtr.p->m_participantData.m_gsn == GSN_DROP_TAB_REQ); + + dropTabPtr.p->m_participantData.m_gsn = GSN_DROP_TAB_CONF; + + releaseTableObject(dropTabPtr.p->m_request.tableId); + + DropTabConf * conf = (DropTabConf*)signal->getDataPtr(); + conf->senderRef = reference(); + conf->senderData = dropTabPtrI; + conf->tableId = dropTabPtr.p->m_request.tableId; + + dropTabPtr.p->m_participantData.m_gsn = GSN_DROP_TAB_CONF; + sendSignal(dropTabPtr.p->m_coordinatorRef, GSN_DROP_TAB_CONF, signal, + DropTabConf::SignalLength, JBB); + + if(dropTabPtr.p->m_coordinatorRef != reference()){ + c_opDropTable.release(dropTabPtr); + } +} + +void Dbdict::releaseTableObject(Uint32 tableId, bool removeFromHash) +{ + TableRecordPtr tablePtr; + AttributeRecordPtr attrPtr; + c_tableRecordPool.getPtr(tablePtr, tableId); + if (removeFromHash) + c_tableRecordHash.remove(tablePtr); + + Uint32 nextAttrRecord = tablePtr.p->firstAttribute; + while (nextAttrRecord != RNIL) { + jam(); +/* ---------------------------------------------------------------- */ +// Release all attribute records +/* ---------------------------------------------------------------- */ + c_attributeRecordPool.getPtr(attrPtr, nextAttrRecord); + nextAttrRecord = attrPtr.p->nextAttrInTable; + c_attributeRecordPool.release(attrPtr); + }//if + Uint32 secondTableId = tablePtr.p->secondTable; + initialiseTableRecord(tablePtr); + c_tableRecordPool.getPtr(tablePtr, secondTableId); + initialiseTableRecord(tablePtr); + return; +}//releaseTableObject() + +/** + * DICT receives these on index create and drop. + */ +void Dbdict::execDROP_TABLE_CONF(Signal* signal) +{ + jamEntry(); + ndbrequire(signal->getNoOfSections() == 0); + + DropTableConf * const conf = (DropTableConf *)signal->getDataPtr(); + // assume part of drop index operation + OpDropIndexPtr opPtr; + c_opDropIndex.find(opPtr, conf->senderData); + ndbrequire(! opPtr.isNull()); + ndbrequire(opPtr.p->m_request.getIndexId() == conf->tableId); + ndbrequire(opPtr.p->m_request.getIndexVersion() == conf->tableVersion); + dropIndex_fromDropTable(signal, opPtr); +} + +void Dbdict::execDROP_TABLE_REF(Signal* signal) +{ + jamEntry(); + + DropTableRef * const ref = (DropTableRef *)signal->getDataPtr(); + // assume part of drop index operation + OpDropIndexPtr opPtr; + c_opDropIndex.find(opPtr, ref->senderData); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + opPtr.p->m_errorLine = __LINE__; + dropIndex_fromDropTable(signal, opPtr); +} + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* MODULE: EXTERNAL INTERFACE TO DATA -------------------- */ +/* ---------------------------------------------------------------- */ +/* */ +/* This module contains the code that is used by other modules to. */ +/* access the data within DBDICT. */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ + +void Dbdict::execGET_TABLEDID_REQ(Signal * signal) +{ + jamEntry(); + ndbrequire(signal->getNoOfSections() == 1); + GetTableIdReq const * req = (GetTableIdReq *)signal->getDataPtr(); + Uint32 senderData = req->senderData; + Uint32 senderRef = req->senderRef; + Uint32 len = req->len; + + if(len>MAX_TAB_NAME_SIZE) + { + jam(); + sendGET_TABLEID_REF((Signal*)signal, + (GetTableIdReq *)req, + GetTableIdRef::TableNameTooLong); + return; + } + + char tableName[MAX_TAB_NAME_SIZE]; + TableRecord keyRecord; + SegmentedSectionPtr ssPtr; + signal->getSection(ssPtr,GetTableIdReq::TABLE_NAME); + copy((Uint32*)tableName, ssPtr); + strcpy(keyRecord.tableName, tableName); + releaseSections(signal); + + if(len > sizeof(keyRecord.tableName)){ + jam(); + sendGET_TABLEID_REF((Signal*)signal, + (GetTableIdReq *)req, + GetTableIdRef::TableNameTooLong); + return; + } + + TableRecordPtr tablePtr; + if(!c_tableRecordHash.find(tablePtr, keyRecord)) { + jam(); + sendGET_TABLEID_REF((Signal*)signal, + (GetTableIdReq *)req, + GetTableIdRef::TableNotDefined); + return; + } + GetTableIdConf * conf = (GetTableIdConf *)req; + conf->tableId = tablePtr.p->tableId; + conf->schemaVersion = tablePtr.p->tableVersion; + conf->senderData = senderData; + sendSignal(senderRef, GSN_GET_TABLEID_CONF, signal, + GetTableIdConf::SignalLength, JBB); + +} + + +void Dbdict::sendGET_TABLEID_REF(Signal* signal, + GetTableIdReq * req, + GetTableIdRef::ErrorCode errorCode) +{ + GetTableIdRef * const ref = (GetTableIdRef *)req; + /** + * The format of GetTabInfo Req/Ref is the same + */ + BlockReference retRef = req->senderRef; + ref->err = errorCode; + sendSignal(retRef, GSN_GET_TABLEID_REF, signal, + GetTableIdRef::SignalLength, JBB); +}//sendGET_TABINFOREF() + +/* ---------------------------------------------------------------- */ +// Get a full table description. +/* ---------------------------------------------------------------- */ +void Dbdict::execGET_TABINFOREQ(Signal* signal) +{ + jamEntry(); + if(!assembleFragments(signal)) { return; } + + GetTabInfoReq * const req = (GetTabInfoReq *)&signal->theData[0]; + + /** + * If I get a GET_TABINFO_REQ from myself + * it's is a one from the time queue + */ + bool fromTimeQueue = (signal->senderBlockRef() == reference()); + + if (c_retrieveRecord.busyState && fromTimeQueue == true) { + jam(); + + sendSignalWithDelay(reference(), GSN_GET_TABINFOREQ, signal, 30, + signal->length()); + return; + }//if + + const Uint32 MAX_WAITERS = 5; + + if(c_retrieveRecord.busyState && fromTimeQueue == false){ + jam(); + if(c_retrieveRecord.noOfWaiters < MAX_WAITERS){ + jam(); + c_retrieveRecord.noOfWaiters++; + + sendSignalWithDelay(reference(), GSN_GET_TABINFOREQ, signal, 30, + signal->length()); + return; + } + + sendGET_TABINFOREF(signal, req, GetTabInfoRef::Busy); + return; + } + + if(fromTimeQueue){ + jam(); + c_retrieveRecord.noOfWaiters--; + } + + const bool useLongSig = (req->requestType & GetTabInfoReq::LongSignalConf); + const Uint32 reqType = req->requestType & (~GetTabInfoReq::LongSignalConf); + + TableRecordPtr tablePtr; + if(reqType == GetTabInfoReq::RequestByName){ + jam(); + ndbrequire(signal->getNoOfSections() == 1); + const Uint32 len = req->tableNameLen; + + TableRecord keyRecord; + if(len > sizeof(keyRecord.tableName)){ + jam(); + releaseSections(signal); + sendGET_TABINFOREF(signal, req, GetTabInfoRef::TableNameTooLong); + return; + } + + char tableName[MAX_TAB_NAME_SIZE]; + SegmentedSectionPtr ssPtr; + signal->getSection(ssPtr,GetTabInfoReq::TABLE_NAME); + SimplePropertiesSectionReader r0(ssPtr, getSectionSegmentPool()); + r0.reset(); // undo implicit first() + if(r0.getWords((Uint32*)tableName, len)) + memcpy(keyRecord.tableName, tableName, len); + else { + jam(); + releaseSections(signal); + sendGET_TABINFOREF(signal, req, GetTabInfoRef::TableNotDefined); + return; + } + releaseSections(signal); + // memcpy(keyRecord.tableName, req->tableName, len); + //ntohS(&keyRecord.tableName[0], len); + + c_tableRecordHash.find(tablePtr, keyRecord); + } else { + jam(); + c_tableRecordPool.getPtr(tablePtr, req->tableId, false); + } + + // The table seached for was not found + if(tablePtr.i == RNIL){ + jam(); + sendGET_TABINFOREF(signal, req, GetTabInfoRef::InvalidTableId); + return; + }//if + + if (tablePtr.p->tabState != TableRecord::DEFINED) { + jam(); + sendGET_TABINFOREF(signal, req, GetTabInfoRef::TableNotDefined); + return; + }//if + + c_retrieveRecord.busyState = true; + c_retrieveRecord.blockRef = req->senderRef; + c_retrieveRecord.m_senderData = req->senderData; + c_retrieveRecord.tableId = tablePtr.i; + c_retrieveRecord.currentSent = 0; + c_retrieveRecord.m_useLongSig = useLongSig; + + c_packTable.m_state = PackTable::PTS_GET_TAB; + + signal->theData[0] = ZPACK_TABLE_INTO_PAGES; + signal->theData[1] = tablePtr.i; + signal->theData[2] = c_retrieveRecord.retrievePage; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); +}//execGET_TABINFOREQ() + +void Dbdict::sendGetTabResponse(Signal* signal) +{ + PageRecordPtr pagePtr; + DictTabInfo * const conf = (DictTabInfo *)&signal->theData[0]; + conf->senderRef = reference(); + conf->senderData = c_retrieveRecord.m_senderData; + conf->requestType = DictTabInfo::GetTabInfoConf; + conf->totalLen = c_retrieveRecord.retrievedNoOfWords; + + c_pageRecordArray.getPtr(pagePtr, c_retrieveRecord.retrievePage); + Uint32* pagePointer = (Uint32*)&pagePtr.p->word[0] + ZPAGE_HEADER_SIZE; + + if(c_retrieveRecord.m_useLongSig){ + jam(); + GetTabInfoConf* conf = (GetTabInfoConf*)signal->getDataPtr(); + conf->gci = 0; + conf->tableId = c_retrieveRecord.tableId; + conf->senderData = c_retrieveRecord.m_senderData; + conf->totalLen = c_retrieveRecord.retrievedNoOfWords; + + Callback c = { safe_cast(&Dbdict::initRetrieveRecord), 0 }; + LinearSectionPtr ptr[3]; + ptr[0].p = pagePointer; + ptr[0].sz = c_retrieveRecord.retrievedNoOfWords; + sendFragmentedSignal(c_retrieveRecord.blockRef, + GSN_GET_TABINFO_CONF, + signal, + GetTabInfoConf::SignalLength, + JBB, + ptr, + 1, + c); + return; + } + + ndbrequire(false); +}//sendGetTabResponse() + +void Dbdict::sendGET_TABINFOREF(Signal* signal, + GetTabInfoReq * req, + GetTabInfoRef::ErrorCode errorCode) +{ + jamEntry(); + GetTabInfoRef * const ref = (GetTabInfoRef *)&signal->theData[0]; + /** + * The format of GetTabInfo Req/Ref is the same + */ + BlockReference retRef = req->senderRef; + ref->errorCode = errorCode; + + sendSignal(retRef, GSN_GET_TABINFOREF, signal, signal->length(), JBB); +}//sendGET_TABINFOREF() + +Uint32 convertEndian(Uint32 in) { +#ifdef _BIG_ENDIAN + Uint32 ut = 0; + ut += ((in >> 24) & 255); + ut += (((in >> 16) & 255) << 8); + ut += (((in >> 8) & 255) << 16); + ut += ((in & 255) << 24); + return ut; +#else + return in; +#endif +} +void +Dbdict::execLIST_TABLES_REQ(Signal* signal) +{ + jamEntry(); + ListTablesReq * req = (ListTablesReq*)signal->getDataPtr(); + Uint32 senderRef = req->senderRef; + Uint32 senderData = req->senderData; + // save req flags + const Uint32 reqTableId = req->getTableId(); + const Uint32 reqTableType = req->getTableType(); + const bool reqListNames = req->getListNames(); + const bool reqListIndexes = req->getListIndexes(); + // init the confs + ListTablesConf * conf = (ListTablesConf *)signal->getDataPtrSend(); + conf->senderData = senderData; + conf->counter = 0; + Uint32 pos = 0; + for (Uint32 i = 0; i < c_tableRecordPool.getSize(); i++) { + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, i); + // filter + if (tablePtr.p->tabState == TableRecord::NOT_DEFINED || + tablePtr.p->tabState == TableRecord::REORG_TABLE_PREPARED) + continue; + + + if ((reqTableType != (Uint32)0) && (reqTableType != (unsigned)tablePtr.p->tableType)) + continue; + if (reqListIndexes && reqTableId != tablePtr.p->primaryTableId) + continue; + conf->tableData[pos] = 0; + // id + conf->setTableId(pos, tablePtr.i); + // type + conf->setTableType(pos, tablePtr.p->tableType); + // state + if (tablePtr.p->isTable()) { + switch (tablePtr.p->tabState) { + case TableRecord::DEFINING: + case TableRecord::CHECKED: + conf->setTableState(pos, DictTabInfo::StateBuilding); + break; + case TableRecord::PREPARE_DROPPING: + case TableRecord::DROPPING: + conf->setTableState(pos, DictTabInfo::StateDropping); + break; + case TableRecord::DEFINED: + conf->setTableState(pos, DictTabInfo::StateOnline); + break; + default: + conf->setTableState(pos, DictTabInfo::StateBroken); + break; + } + } + if (tablePtr.p->isIndex()) { + switch (tablePtr.p->indexState) { + case TableRecord::IS_OFFLINE: + conf->setTableState(pos, DictTabInfo::StateOffline); + break; + case TableRecord::IS_BUILDING: + conf->setTableState(pos, DictTabInfo::StateBuilding); + break; + case TableRecord::IS_DROPPING: + conf->setTableState(pos, DictTabInfo::StateDropping); + break; + case TableRecord::IS_ONLINE: + conf->setTableState(pos, DictTabInfo::StateOnline); + break; + default: + conf->setTableState(pos, DictTabInfo::StateBroken); + break; + } + } + // store + if (! tablePtr.p->storedTable) { + conf->setTableStore(pos, DictTabInfo::StoreTemporary); + } else { + conf->setTableStore(pos, DictTabInfo::StorePermanent); + } + pos++; + if (pos >= ListTablesConf::DataLength) { + sendSignal(senderRef, GSN_LIST_TABLES_CONF, signal, + ListTablesConf::SignalLength, JBB); + conf->counter++; + pos = 0; + } + if (! reqListNames) + continue; + const Uint32 size = strlen(tablePtr.p->tableName) + 1; + conf->tableData[pos] = size; + pos++; + if (pos >= ListTablesConf::DataLength) { + sendSignal(senderRef, GSN_LIST_TABLES_CONF, signal, + ListTablesConf::SignalLength, JBB); + conf->counter++; + pos = 0; + } + Uint32 i = 0; + while (i < size) { + char* p = (char*)&conf->tableData[pos]; + for (Uint32 j = 0; j < 4; j++) { + if (i < size) + *p++ = tablePtr.p->tableName[i++]; + else + *p++ = 0; + } + pos++; + if (pos >= ListTablesConf::DataLength) { + sendSignal(senderRef, GSN_LIST_TABLES_CONF, signal, + ListTablesConf::SignalLength, JBB); + conf->counter++; + pos = 0; + } + } + } + // XXX merge with above somehow + for (Uint32 i = 0; i < c_triggerRecordPool.getSize(); i++) { + if (reqListIndexes) + break; + TriggerRecordPtr triggerPtr; + c_triggerRecordPool.getPtr(triggerPtr, i); + if (triggerPtr.p->triggerState == TriggerRecord::TS_NOT_DEFINED) + continue; + // constant 10 hardcoded + Uint32 type = 10 + triggerPtr.p->triggerType; + if (reqTableType != 0 && reqTableType != type) + continue; + conf->tableData[pos] = 0; + conf->setTableId(pos, triggerPtr.i); + conf->setTableType(pos, type); + switch (triggerPtr.p->triggerState) { + case TriggerRecord::TS_OFFLINE: + conf->setTableState(pos, DictTabInfo::StateOffline); + break; + case TriggerRecord::TS_ONLINE: + conf->setTableState(pos, DictTabInfo::StateOnline); + break; + default: + conf->setTableState(pos, DictTabInfo::StateBroken); + break; + } + conf->setTableStore(pos, DictTabInfo::StoreTemporary); + pos++; + if (pos >= ListTablesConf::DataLength) { + sendSignal(senderRef, GSN_LIST_TABLES_CONF, signal, + ListTablesConf::SignalLength, JBB); + conf->counter++; + pos = 0; + } + if (! reqListNames) + continue; + const Uint32 size = strlen(triggerPtr.p->triggerName) + 1; + conf->tableData[pos] = size; + pos++; + if (pos >= ListTablesConf::DataLength) { + sendSignal(senderRef, GSN_LIST_TABLES_CONF, signal, + ListTablesConf::SignalLength, JBB); + conf->counter++; + pos = 0; + } + Uint32 i = 0; + while (i < size) { + char* p = (char*)&conf->tableData[pos]; + for (Uint32 j = 0; j < 4; j++) { + if (i < size) + *p++ = triggerPtr.p->triggerName[i++]; + else + *p++ = 0; + } + pos++; + if (pos >= ListTablesConf::DataLength) { + sendSignal(senderRef, GSN_LIST_TABLES_CONF, signal, + ListTablesConf::SignalLength, JBB); + conf->counter++; + pos = 0; + } + } + } + // last signal must have less than max length + sendSignal(senderRef, GSN_LIST_TABLES_CONF, signal, + ListTablesConf::HeaderLength + pos, JBB); +} + +/** + * MODULE: Create index + * + * Create index in DICT via create table operation. Then invoke alter + * index opearation to online the index. + * + * Request type in CREATE_INDX signals: + * + * RT_USER - from API to DICT master + * RT_DICT_PREPARE - prepare participants + * RT_DICT_COMMIT - commit participants + * RT_TC - create index in TC (part of alter index operation) + */ + +void +Dbdict::execCREATE_INDX_REQ(Signal* signal) +{ + jamEntry(); + CreateIndxReq* const req = (CreateIndxReq*)signal->getDataPtrSend(); + OpCreateIndexPtr opPtr; + const Uint32 senderRef = signal->senderBlockRef(); + const CreateIndxReq::RequestType requestType = req->getRequestType(); + if (requestType == CreateIndxReq::RT_USER) { + jam(); + if (! assembleFragments(signal)) { + jam(); + return; + } + if (signal->getLength() == CreateIndxReq::SignalLength) { + jam(); + if (getOwnNodeId() != c_masterNodeId) { + jam(); + // forward to DICT master + sendSignal(calcDictBlockRef(c_masterNodeId), GSN_CREATE_INDX_REQ, + signal, signal->getLength(), JBB); + return; + } + // forward initial request plus operation key to all + req->setOpKey(++c_opRecordSequence); + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + sendSignal(rg, GSN_CREATE_INDX_REQ, + signal, CreateIndxReq::SignalLength + 1, JBB); + return; + } + // seize operation record + ndbrequire(signal->getLength() == CreateIndxReq::SignalLength + 1); + const Uint32 opKey = req->getOpKey(); + OpCreateIndex opBusy; + if (! c_opCreateIndex.seize(opPtr)) + opPtr.p = &opBusy; + opPtr.p->save(req); + opPtr.p->m_coordinatorRef = senderRef; + opPtr.p->m_isMaster = (senderRef == reference()); + opPtr.p->key = opKey; + opPtr.p->m_requestType = CreateIndxReq::RT_DICT_PREPARE; + if (opPtr.p == &opBusy) { + jam(); + opPtr.p->m_errorCode = CreateIndxRef::Busy; + opPtr.p->m_errorLine = __LINE__; + releaseSections(signal); + createIndex_sendReply(signal, opPtr, opPtr.p->m_isMaster); + return; + } + c_opCreateIndex.add(opPtr); + // save attribute list + SegmentedSectionPtr ssPtr; + signal->getSection(ssPtr, CreateIndxReq::ATTRIBUTE_LIST_SECTION); + SimplePropertiesSectionReader r0(ssPtr, getSectionSegmentPool()); + r0.reset(); // undo implicit first() + if (! r0.getWord(&opPtr.p->m_attrList.sz) || + ! r0.getWords(opPtr.p->m_attrList.id, opPtr.p->m_attrList.sz)) { + jam(); + opPtr.p->m_errorCode = CreateIndxRef::InvalidName; + opPtr.p->m_errorLine = __LINE__; + releaseSections(signal); + createIndex_sendReply(signal, opPtr, opPtr.p->m_isMaster); + return; + } + // save name and index table properties + signal->getSection(ssPtr, CreateIndxReq::INDEX_NAME_SECTION); + SimplePropertiesSectionReader r1(ssPtr, getSectionSegmentPool()); + DictTabInfo::Table tableDesc; + tableDesc.init(); + SimpleProperties::UnpackStatus status = SimpleProperties::unpack( + r1, &tableDesc, + DictTabInfo::TableMapping, DictTabInfo::TableMappingSize, + true, true); + if (status != SimpleProperties::Eof) { + opPtr.p->m_errorCode = CreateIndxRef::InvalidName; + opPtr.p->m_errorLine = __LINE__; + releaseSections(signal); + createIndex_sendReply(signal, opPtr, opPtr.p->m_isMaster); + return; + } + memcpy(opPtr.p->m_indexName, tableDesc.TableName, MAX_TAB_NAME_SIZE); + opPtr.p->m_storedIndex = tableDesc.TableLoggedFlag; + releaseSections(signal); + // master expects to hear from all + if (opPtr.p->m_isMaster) + opPtr.p->m_signalCounter = c_aliveNodes; + createIndex_slavePrepare(signal, opPtr); + createIndex_sendReply(signal, opPtr, false); + return; + } + c_opCreateIndex.find(opPtr, req->getConnectionPtr()); + if (! opPtr.isNull()) { + opPtr.p->m_requestType = requestType; + if (requestType == CreateIndxReq::RT_DICT_COMMIT || + requestType == CreateIndxReq::RT_DICT_ABORT) { + jam(); + if (requestType == CreateIndxReq::RT_DICT_COMMIT) { + opPtr.p->m_request.setIndexId(req->getIndexId()); + opPtr.p->m_request.setIndexVersion(req->getIndexVersion()); + createIndex_slaveCommit(signal, opPtr); + } else { + createIndex_slaveAbort(signal, opPtr); + } + createIndex_sendReply(signal, opPtr, false); + // done in slave + if (! opPtr.p->m_isMaster) + c_opCreateIndex.release(opPtr); + return; + } + } + jam(); + // return to sender + releaseSections(signal); + OpCreateIndex opBad; + opPtr.p = &opBad; + opPtr.p->save(req); + opPtr.p->m_errorCode = CreateIndxRef::BadRequestType; + opPtr.p->m_errorLine = __LINE__; + createIndex_sendReply(signal, opPtr, true); +} + +void +Dbdict::execCREATE_INDX_CONF(Signal* signal) +{ + jamEntry(); + ndbrequire(signal->getNoOfSections() == 0); + CreateIndxConf* conf = (CreateIndxConf*)signal->getDataPtrSend(); + createIndex_recvReply(signal, conf, 0); +} + +void +Dbdict::execCREATE_INDX_REF(Signal* signal) +{ + jamEntry(); + CreateIndxRef* ref = (CreateIndxRef*)signal->getDataPtrSend(); + createIndex_recvReply(signal, ref->getConf(), ref); +} + +void +Dbdict::createIndex_recvReply(Signal* signal, const CreateIndxConf* conf, + const CreateIndxRef* ref) +{ + jam(); + const Uint32 senderRef = signal->senderBlockRef(); + const CreateIndxReq::RequestType requestType = conf->getRequestType(); + const Uint32 key = conf->getConnectionPtr(); + if (requestType == CreateIndxReq::RT_TC) { + jam(); + // part of alter index operation + OpAlterIndexPtr opPtr; + c_opAlterIndex.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + alterIndex_fromCreateTc(signal, opPtr); + return; + } + OpCreateIndexPtr opPtr; + c_opCreateIndex.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + ndbrequire(opPtr.p->m_isMaster); + ndbrequire(opPtr.p->m_requestType == requestType); + opPtr.p->setError(ref); + opPtr.p->m_signalCounter.clearWaitingFor(refToNode(senderRef)); + if (! opPtr.p->m_signalCounter.done()) { + jam(); + return; + } + if (requestType == CreateIndxReq::RT_DICT_COMMIT || + requestType == CreateIndxReq::RT_DICT_ABORT) { + jam(); + // send reply to user + createIndex_sendReply(signal, opPtr, true); + c_opCreateIndex.release(opPtr); + return; + } + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = CreateIndxReq::RT_DICT_ABORT; + createIndex_sendSlaveReq(signal, opPtr); + return; + } + if (requestType == CreateIndxReq::RT_DICT_PREPARE) { + jam(); + // start index table create + createIndex_toCreateTable(signal, opPtr); + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = CreateIndxReq::RT_DICT_ABORT; + createIndex_sendSlaveReq(signal, opPtr); + return; + } + return; + } + ndbrequire(false); +} + +void +Dbdict::createIndex_slavePrepare(Signal* signal, OpCreateIndexPtr opPtr) +{ + jam(); +} + +void +Dbdict::createIndex_toCreateTable(Signal* signal, OpCreateIndexPtr opPtr) +{ + jam(); + const CreateIndxReq* const req = &opPtr.p->m_request; + // signal data writer + Uint32* wbuffer = &c_indexPage.word[0]; + LinearWriter w(wbuffer, sizeof(c_indexPage) >> 2); + w.first(); + // get table being indexed + if (! (req->getTableId() < c_tableRecordPool.getSize())) { + jam(); + opPtr.p->m_errorCode = CreateIndxRef::InvalidPrimaryTable; + opPtr.p->m_errorLine = __LINE__; + return; + } + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, req->getTableId()); + if (tablePtr.p->tabState != TableRecord::DEFINED) { + jam(); + opPtr.p->m_errorCode = CreateIndxRef::InvalidPrimaryTable; + opPtr.p->m_errorLine = __LINE__; + return; + } + if (! tablePtr.p->isTable()) { + jam(); + opPtr.p->m_errorCode = CreateIndxRef::InvalidPrimaryTable; + opPtr.p->m_errorLine = __LINE__; + return; + } + // compute index table record + TableRecord indexRec; + TableRecordPtr indexPtr; + indexPtr.i = RNIL; // invalid + indexPtr.p = &indexRec; + initialiseTableRecord(indexPtr); + if (req->getIndexType() == DictTabInfo::UniqueHashIndex) { + indexPtr.p->storedTable = opPtr.p->m_storedIndex; + indexPtr.p->fragmentType = tablePtr.p->fragmentType; + } else if (req->getIndexType() == DictTabInfo::OrderedIndex) { + // first version will not supported logging + if (opPtr.p->m_storedIndex) { + jam(); + opPtr.p->m_errorCode = CreateIndxRef::InvalidIndexType; + opPtr.p->m_errorLine = __LINE__; + return; + } + indexPtr.p->storedTable = false; + // follows table fragmentation + indexPtr.p->fragmentType = tablePtr.p->fragmentType; + } else { + jam(); + opPtr.p->m_errorCode = CreateIndxRef::InvalidIndexType; + opPtr.p->m_errorLine = __LINE__; + return; + } + indexPtr.p->tableType = (DictTabInfo::TableType)req->getIndexType(); + indexPtr.p->primaryTableId = req->getTableId(); + indexPtr.p->noOfAttributes = opPtr.p->m_attrList.sz; + indexPtr.p->tupKeyLength = 0; + if (indexPtr.p->noOfAttributes == 0) { + jam(); + opPtr.p->m_errorCode = CreateIndxRef::InvalidIndexType; + opPtr.p->m_errorLine = __LINE__; + return; + } + if (indexPtr.p->isOrderedIndex()) { + // tree node size in words (make configurable later) + indexPtr.p->tupKeyLength = MAX_TTREE_NODE_SIZE; + } + // hash index attributes must currently be in table order + Uint32 prevAttrId = RNIL; + for (Uint32 k = 0; k < opPtr.p->m_attrList.sz; k++) { + jam(); + bool found = false; + for (Uint32 tAttr = tablePtr.p->firstAttribute; tAttr != RNIL; ) { + AttributeRecord* aRec = c_attributeRecordPool.getPtr(tAttr); + tAttr = aRec->nextAttrInTable; + if (aRec->attributeId != opPtr.p->m_attrList.id[k]) + continue; + jam(); + found = true; + const Uint32 a = aRec->attributeDescriptor; + bool isNullable = AttributeDescriptor::getNullable(a); + // We do not allow more than one NULLable attribute for hash index + if (isNullable && + indexPtr.p->isHashIndex() && + (opPtr.p->m_attrList.sz > 1)) { + jam(); + opPtr.p->m_errorCode = CreateIndxRef::AttributeNullable; + opPtr.p->m_errorLine = __LINE__; + return; + } + if (indexPtr.p->isHashIndex()) { + const Uint32 s1 = AttributeDescriptor::getSize(a); + const Uint32 s2 = AttributeDescriptor::getArraySize(a); + indexPtr.p->tupKeyLength += ((1 << s1) * s2 + 31) >> 5; + } + } + if (! found) { + jam(); + opPtr.p->m_errorCode = CreateIndxRef::BadRequestType; + opPtr.p->m_errorLine = __LINE__; + return; + } + if (indexPtr.p->isHashIndex() && + k > 0 && prevAttrId >= opPtr.p->m_attrList.id[k]) { + jam(); + opPtr.p->m_errorCode = CreateIndxRef::InvalidAttributeOrder; + opPtr.p->m_errorLine = __LINE__; + return; + } + prevAttrId = opPtr.p->m_attrList.id[k]; + } + indexPtr.p->noOfPrimkey = indexPtr.p->noOfAttributes; + // plus concatenated primary table key attribute + indexPtr.p->noOfAttributes += 1; + indexPtr.p->noOfNullAttr = 0; + // write index table + w.add(DictTabInfo::TableName, opPtr.p->m_indexName); + w.add(DictTabInfo::TableLoggedFlag, indexPtr.p->storedTable); + w.add(DictTabInfo::FragmentTypeVal, indexPtr.p->fragmentType); + w.add(DictTabInfo::TableTypeVal, indexPtr.p->tableType); + w.add(DictTabInfo::PrimaryTable, tablePtr.p->tableName); + w.add(DictTabInfo::PrimaryTableId, tablePtr.i); + w.add(DictTabInfo::NoOfAttributes, indexPtr.p->noOfAttributes); + w.add(DictTabInfo::NoOfKeyAttr, indexPtr.p->noOfPrimkey); + w.add(DictTabInfo::NoOfNullable, indexPtr.p->noOfNullAttr); + w.add(DictTabInfo::KeyLength, indexPtr.p->tupKeyLength); + // write index key attributes + AttributeRecordPtr aRecPtr; + c_attributeRecordPool.getPtr(aRecPtr, tablePtr.p->firstAttribute); + for (Uint32 k = 0; k < opPtr.p->m_attrList.sz; k++) { + jam(); + for (Uint32 tAttr = tablePtr.p->firstAttribute; tAttr != RNIL; ) { + AttributeRecord* aRec = c_attributeRecordPool.getPtr(tAttr); + tAttr = aRec->nextAttrInTable; + if (aRec->attributeId != opPtr.p->m_attrList.id[k]) + continue; + jam(); + const Uint32 a = aRec->attributeDescriptor; + bool isNullable = AttributeDescriptor::getNullable(a); + w.add(DictTabInfo::AttributeName, aRec->attributeName); + w.add(DictTabInfo::AttributeId, k); + if (indexPtr.p->isHashIndex()) { + w.add(DictTabInfo::AttributeKeyFlag, (Uint32)true); + w.add(DictTabInfo::AttributeNullableFlag, (Uint32)false); + } + if (indexPtr.p->isOrderedIndex()) { + w.add(DictTabInfo::AttributeKeyFlag, (Uint32)false); + w.add(DictTabInfo::AttributeNullableFlag, (Uint32)isNullable); + } + w.add(DictTabInfo::AttributeStoredInd, (Uint32)DictTabInfo::Stored); + // ext type overrides + w.add(DictTabInfo::AttributeExtType, aRec->extType); + w.add(DictTabInfo::AttributeExtLength, aRec->extLength); + w.add(DictTabInfo::AttributeEnd, (Uint32)true); + } + } + if (indexPtr.p->isHashIndex()) { + jam(); + // write concatenated primary table key attribute + w.add(DictTabInfo::AttributeName, "NDB$PK"); + w.add(DictTabInfo::AttributeId, opPtr.p->m_attrList.sz); + w.add(DictTabInfo::AttributeKeyFlag, (Uint32)false); + w.add(DictTabInfo::AttributeStoredInd, (Uint32)DictTabInfo::Stored); + w.add(DictTabInfo::AttributeNullableFlag, (Uint32)false); + // ext type overrides + w.add(DictTabInfo::AttributeExtType, (Uint32)DictTabInfo::ExtUnsigned); + w.add(DictTabInfo::AttributeExtLength, tablePtr.p->tupKeyLength); + w.add(DictTabInfo::AttributeEnd, (Uint32)true); + } + if (indexPtr.p->isOrderedIndex()) { + jam(); + // write index tree node as Uint32 array attribute + w.add(DictTabInfo::AttributeName, "NDB$TNODE"); + w.add(DictTabInfo::AttributeId, opPtr.p->m_attrList.sz); + w.add(DictTabInfo::AttributeKeyFlag, (Uint32)true); + w.add(DictTabInfo::AttributeStoredInd, (Uint32)DictTabInfo::Stored); + w.add(DictTabInfo::AttributeNullableFlag, (Uint32)false); + // ext type overrides + w.add(DictTabInfo::AttributeExtType, (Uint32)DictTabInfo::ExtUnsigned); + w.add(DictTabInfo::AttributeExtLength, indexPtr.p->tupKeyLength); + w.add(DictTabInfo::AttributeEnd, (Uint32)true); + } + // finish + w.add(DictTabInfo::TableEnd, (Uint32)true); + // remember to... + releaseSections(signal); + // send create index table request + CreateTableReq * const cre = (CreateTableReq*)signal->getDataPtrSend(); + cre->senderRef = reference(); + cre->senderData = opPtr.p->key; + LinearSectionPtr lsPtr[3]; + lsPtr[0].p = wbuffer; + lsPtr[0].sz = w.getWordsUsed(); + sendSignal(DBDICT_REF, GSN_CREATE_TABLE_REQ, + signal, CreateTableReq::SignalLength, JBB, lsPtr, 1); +} + +void +Dbdict::createIndex_fromCreateTable(Signal* signal, OpCreateIndexPtr opPtr) +{ + jam(); + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = CreateIndxReq::RT_DICT_ABORT; + createIndex_sendSlaveReq(signal, opPtr); + return; + } + if (! opPtr.p->m_request.getOnline()) { + jam(); + opPtr.p->m_requestType = CreateIndxReq::RT_DICT_COMMIT; + createIndex_sendSlaveReq(signal, opPtr); + return; + } + createIndex_toAlterIndex(signal, opPtr); +} + +void +Dbdict::createIndex_toAlterIndex(Signal* signal, OpCreateIndexPtr opPtr) +{ + jam(); + AlterIndxReq* const req = (AlterIndxReq*)signal->getDataPtrSend(); + req->setUserRef(reference()); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(AlterIndxReq::RT_CREATE_INDEX); + req->addRequestFlag(opPtr.p->m_requestFlag); + req->setTableId(opPtr.p->m_request.getTableId()); + req->setIndexId(opPtr.p->m_request.getIndexId()); + req->setIndexVersion(opPtr.p->m_request.getIndexVersion()); + req->setOnline(true); + sendSignal(reference(), GSN_ALTER_INDX_REQ, + signal, AlterIndxReq::SignalLength, JBB); +} + +void +Dbdict::createIndex_fromAlterIndex(Signal* signal, OpCreateIndexPtr opPtr) +{ + jam(); + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = CreateIndxReq::RT_DICT_ABORT; + createIndex_sendSlaveReq(signal, opPtr); + return; + } + opPtr.p->m_requestType = CreateIndxReq::RT_DICT_COMMIT; + createIndex_sendSlaveReq(signal, opPtr); +} + +void +Dbdict::createIndex_slaveCommit(Signal* signal, OpCreateIndexPtr opPtr) +{ + jam(); + const Uint32 indexId = opPtr.p->m_request.getIndexId(); + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, indexId); + if (! opPtr.p->m_request.getOnline()) { + ndbrequire(indexPtr.p->indexState == TableRecord::IS_UNDEFINED); + indexPtr.p->indexState = TableRecord::IS_OFFLINE; + } else { + ndbrequire(indexPtr.p->indexState == TableRecord::IS_ONLINE); + } +} + +void +Dbdict::createIndex_slaveAbort(Signal* signal, OpCreateIndexPtr opPtr) +{ + jam(); + CreateIndxReq* const req = &opPtr.p->m_request; + const Uint32 indexId = req->getIndexId(); + if (indexId >= c_tableRecordPool.getSize()) { + jam(); + return; + } + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, indexId); + if (! indexPtr.p->isIndex()) { + jam(); + return; + } + indexPtr.p->indexState = TableRecord::IS_BROKEN; +} + +void +Dbdict::createIndex_sendSlaveReq(Signal* signal, OpCreateIndexPtr opPtr) +{ + jam(); + CreateIndxReq* const req = (CreateIndxReq*)signal->getDataPtrSend(); + *req = opPtr.p->m_request; + req->setUserRef(opPtr.p->m_coordinatorRef); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(opPtr.p->m_requestType); + req->addRequestFlag(opPtr.p->m_requestFlag); + opPtr.p->m_signalCounter = c_aliveNodes; + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + sendSignal(rg, GSN_CREATE_INDX_REQ, + signal, CreateIndxReq::SignalLength, JBB); +} + +void +Dbdict::createIndex_sendReply(Signal* signal, OpCreateIndexPtr opPtr, + bool toUser) +{ + CreateIndxRef* rep = (CreateIndxRef*)signal->getDataPtrSend(); + Uint32 gsn = GSN_CREATE_INDX_CONF; + Uint32 length = CreateIndxConf::InternalLength; + bool sendRef = opPtr.p->hasError(); + if (! toUser) { + rep->setUserRef(opPtr.p->m_coordinatorRef); + rep->setConnectionPtr(opPtr.p->key); + rep->setRequestType(opPtr.p->m_requestType); + if (opPtr.p->m_requestType == CreateIndxReq::RT_DICT_ABORT) + sendRef = false; + } else { + rep->setUserRef(opPtr.p->m_request.getUserRef()); + rep->setConnectionPtr(opPtr.p->m_request.getConnectionPtr()); + rep->setRequestType(opPtr.p->m_request.getRequestType()); + length = CreateIndxConf::SignalLength; + } + rep->setTableId(opPtr.p->m_request.getTableId()); + rep->setIndexId(opPtr.p->m_request.getIndexId()); + rep->setIndexVersion(opPtr.p->m_request.getIndexVersion()); + if (sendRef) { + if (opPtr.p->m_errorNode == 0) + opPtr.p->m_errorNode = getOwnNodeId(); + rep->setErrorCode(opPtr.p->m_errorCode); + rep->setErrorLine(opPtr.p->m_errorLine); + rep->setErrorNode(opPtr.p->m_errorNode); + gsn = GSN_CREATE_INDX_REF; + length = CreateIndxRef::SignalLength; + } + sendSignal(rep->getUserRef(), gsn, signal, length, JBB); +} + +/** + * MODULE: Drop index. + * + * Drop index. First alters the index offline (i.e. drops metadata in + * other blocks) and then drops the index table. + */ + +void +Dbdict::execDROP_INDX_REQ(Signal* signal) +{ + jamEntry(); + DropIndxReq* const req = (DropIndxReq*)signal->getDataPtrSend(); + OpDropIndexPtr opPtr; + const Uint32 senderRef = signal->senderBlockRef(); + const DropIndxReq::RequestType requestType = req->getRequestType(); + if (requestType == DropIndxReq::RT_USER) { + jam(); + if (signal->getLength() == DropIndxReq::SignalLength) { + jam(); + if (getOwnNodeId() != c_masterNodeId) { + jam(); + // forward to DICT master + sendSignal(calcDictBlockRef(c_masterNodeId), GSN_DROP_INDX_REQ, + signal, signal->getLength(), JBB); + return; + } + // forward initial request plus operation key to all + req->setOpKey(++c_opRecordSequence); + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + sendSignal(rg, GSN_DROP_INDX_REQ, + signal, DropIndxReq::SignalLength + 1, JBB); + return; + } + // seize operation record + ndbrequire(signal->getLength() == DropIndxReq::SignalLength + 1); + const Uint32 opKey = req->getOpKey(); + OpDropIndex opBusy; + if (! c_opDropIndex.seize(opPtr)) + opPtr.p = &opBusy; + opPtr.p->save(req); + opPtr.p->m_coordinatorRef = senderRef; + opPtr.p->m_isMaster = (senderRef == reference()); + opPtr.p->key = opKey; + opPtr.p->m_requestType = DropIndxReq::RT_DICT_PREPARE; + if (opPtr.p == &opBusy) { + jam(); + opPtr.p->m_errorCode = DropIndxRef::Busy; + opPtr.p->m_errorLine = __LINE__; + dropIndex_sendReply(signal, opPtr, opPtr.p->m_isMaster); + return; + } + c_opDropIndex.add(opPtr); + // master expects to hear from all + if (opPtr.p->m_isMaster) + opPtr.p->m_signalCounter = c_aliveNodes; + dropIndex_slavePrepare(signal, opPtr); + dropIndex_sendReply(signal, opPtr, false); + return; + } + c_opDropIndex.find(opPtr, req->getConnectionPtr()); + if (! opPtr.isNull()) { + opPtr.p->m_requestType = requestType; + if (requestType == DropIndxReq::RT_DICT_COMMIT || + requestType == DropIndxReq::RT_DICT_ABORT) { + jam(); + if (requestType == DropIndxReq::RT_DICT_COMMIT) + dropIndex_slaveCommit(signal, opPtr); + else + dropIndex_slaveAbort(signal, opPtr); + dropIndex_sendReply(signal, opPtr, false); + // done in slave + if (! opPtr.p->m_isMaster) + c_opDropIndex.release(opPtr); + return; + } + } + jam(); + // return to sender + OpDropIndex opBad; + opPtr.p = &opBad; + opPtr.p->save(req); + opPtr.p->m_errorCode = DropIndxRef::BadRequestType; + opPtr.p->m_errorLine = __LINE__; + dropIndex_sendReply(signal, opPtr, true); +} + +void +Dbdict::execDROP_INDX_CONF(Signal* signal) +{ + jamEntry(); + DropIndxConf* conf = (DropIndxConf*)signal->getDataPtrSend(); + dropIndex_recvReply(signal, conf, 0); +} + +void +Dbdict::execDROP_INDX_REF(Signal* signal) +{ + jamEntry(); + DropIndxRef* ref = (DropIndxRef*)signal->getDataPtrSend(); + dropIndex_recvReply(signal, ref->getConf(), ref); +} + +void +Dbdict::dropIndex_recvReply(Signal* signal, const DropIndxConf* conf, + const DropIndxRef* ref) +{ + jam(); + const Uint32 senderRef = signal->senderBlockRef(); + const DropIndxReq::RequestType requestType = conf->getRequestType(); + const Uint32 key = conf->getConnectionPtr(); + if (requestType == DropIndxReq::RT_TC) { + jam(); + // part of alter index operation + OpAlterIndexPtr opPtr; + c_opAlterIndex.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + alterIndex_fromDropTc(signal, opPtr); + return; + } + OpDropIndexPtr opPtr; + c_opDropIndex.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + ndbrequire(opPtr.p->m_isMaster); + ndbrequire(opPtr.p->m_requestType == requestType); + opPtr.p->setError(ref); + opPtr.p->m_signalCounter.clearWaitingFor(refToNode(senderRef)); + if (! opPtr.p->m_signalCounter.done()) { + jam(); + return; + } + if (requestType == DropIndxReq::RT_DICT_COMMIT || + requestType == DropIndxReq::RT_DICT_ABORT) { + jam(); + // send reply to user + dropIndex_sendReply(signal, opPtr, true); + c_opDropIndex.release(opPtr); + return; + } + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = DropIndxReq::RT_DICT_ABORT; + dropIndex_sendSlaveReq(signal, opPtr); + return; + } + if (requestType == DropIndxReq::RT_DICT_PREPARE) { + jam(); + // start alter offline + dropIndex_toAlterIndex(signal, opPtr); + return; + } + ndbrequire(false); +} + +void +Dbdict::dropIndex_slavePrepare(Signal* signal, OpDropIndexPtr opPtr) +{ + jam(); + DropIndxReq* const req = &opPtr.p->m_request; + // check index exists + TableRecordPtr indexPtr; + if (! (req->getIndexId() < c_tableRecordPool.getSize())) { + jam(); + opPtr.p->m_errorCode = DropIndxRef::IndexNotFound; + opPtr.p->m_errorLine = __LINE__; + return; + } + c_tableRecordPool.getPtr(indexPtr, req->getIndexId()); + if (indexPtr.p->tabState != TableRecord::DEFINED) { + jam(); + opPtr.p->m_errorCode = DropIndxRef::IndexNotFound; + opPtr.p->m_errorLine = __LINE__; + return; + } + if (! indexPtr.p->isIndex()) { + jam(); + opPtr.p->m_errorCode = DropIndxRef::NotAnIndex; + opPtr.p->m_errorLine = __LINE__; + return; + } + // ignore incoming primary table id + req->setTableId(indexPtr.p->primaryTableId); +} + +void +Dbdict::dropIndex_toAlterIndex(Signal* signal, OpDropIndexPtr opPtr) +{ + jam(); + AlterIndxReq* const req = (AlterIndxReq*)signal->getDataPtrSend(); + req->setUserRef(reference()); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(AlterIndxReq::RT_DROP_INDEX); + req->addRequestFlag(opPtr.p->m_requestFlag); + req->setTableId(opPtr.p->m_request.getTableId()); + req->setIndexId(opPtr.p->m_request.getIndexId()); + req->setIndexVersion(opPtr.p->m_request.getIndexVersion()); + req->setOnline(false); + sendSignal(reference(), GSN_ALTER_INDX_REQ, + signal, AlterIndxReq::SignalLength, JBB); +} + +void +Dbdict::dropIndex_fromAlterIndex(Signal* signal, OpDropIndexPtr opPtr) +{ + jam(); + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = DropIndxReq::RT_DICT_ABORT; + dropIndex_sendSlaveReq(signal, opPtr); + return; + } + dropIndex_toDropTable(signal, opPtr); +} + +void +Dbdict::dropIndex_toDropTable(Signal* signal, OpDropIndexPtr opPtr) +{ + jam(); + DropTableReq* const req = (DropTableReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + req->senderData = opPtr.p->key; + req->tableId = opPtr.p->m_request.getIndexId(); + req->tableVersion = opPtr.p->m_request.getIndexVersion(); + sendSignal(reference(), GSN_DROP_TABLE_REQ, + signal,DropTableReq::SignalLength, JBB); +} + +void +Dbdict::dropIndex_fromDropTable(Signal* signal, OpDropIndexPtr opPtr) +{ + jam(); + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = DropIndxReq::RT_DICT_ABORT; + dropIndex_sendSlaveReq(signal, opPtr); + return; + } + opPtr.p->m_requestType = DropIndxReq::RT_DICT_COMMIT; + dropIndex_sendSlaveReq(signal, opPtr); +} + +void +Dbdict::dropIndex_slaveCommit(Signal* signal, OpDropIndexPtr opPtr) +{ + jam(); +} + +void +Dbdict::dropIndex_slaveAbort(Signal* signal, OpDropIndexPtr opPtr) +{ + jam(); + DropIndxReq* const req = &opPtr.p->m_request; + const Uint32 indexId = req->getIndexId(); + if (indexId >= c_tableRecordPool.getSize()) { + jam(); + return; + } + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, indexId); + indexPtr.p->indexState = TableRecord::IS_BROKEN; +} + +void +Dbdict::dropIndex_sendSlaveReq(Signal* signal, OpDropIndexPtr opPtr) +{ + DropIndxReq* const req = (DropIndxReq*)signal->getDataPtrSend(); + *req = opPtr.p->m_request; + req->setUserRef(opPtr.p->m_coordinatorRef); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(opPtr.p->m_requestType); + req->addRequestFlag(opPtr.p->m_requestFlag); + opPtr.p->m_signalCounter = c_aliveNodes; + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + sendSignal(rg, GSN_DROP_INDX_REQ, + signal, DropIndxReq::SignalLength, JBB); +} + +void +Dbdict::dropIndex_sendReply(Signal* signal, OpDropIndexPtr opPtr, + bool toUser) +{ + DropIndxRef* rep = (DropIndxRef*)signal->getDataPtrSend(); + Uint32 gsn = GSN_DROP_INDX_CONF; + Uint32 length = DropIndxConf::InternalLength; + bool sendRef = opPtr.p->hasError(); + if (! toUser) { + rep->setUserRef(opPtr.p->m_coordinatorRef); + rep->setConnectionPtr(opPtr.p->key); + rep->setRequestType(opPtr.p->m_requestType); + if (opPtr.p->m_requestType == DropIndxReq::RT_DICT_ABORT) + sendRef = false; + } else { + rep->setUserRef(opPtr.p->m_request.getUserRef()); + rep->setConnectionPtr(opPtr.p->m_request.getConnectionPtr()); + rep->setRequestType(opPtr.p->m_request.getRequestType()); + length = DropIndxConf::SignalLength; + } + rep->setTableId(opPtr.p->m_request.getTableId()); + rep->setIndexId(opPtr.p->m_request.getIndexId()); + rep->setIndexVersion(opPtr.p->m_request.getIndexVersion()); + if (sendRef) { + if (opPtr.p->m_errorNode == 0) + opPtr.p->m_errorNode = getOwnNodeId(); + rep->setErrorCode(opPtr.p->m_errorCode); + rep->setErrorLine(opPtr.p->m_errorLine); + rep->setErrorNode(opPtr.p->m_errorNode); + gsn = GSN_DROP_INDX_REF; + length = DropIndxRef::SignalLength; + } + sendSignal(rep->getUserRef(), gsn, signal, length, JBB); +} + +/***************************************************** + * + * Util signalling + * + *****************************************************/ + +int +Dbdict::sendSignalUtilReq(Callback *pcallback, + BlockReference ref, + GlobalSignalNumber gsn, + Signal* signal, + Uint32 length, + JobBufferLevel jbuf, + LinearSectionPtr ptr[3], + Uint32 noOfSections) +{ + jam(); + EVENT_TRACE; + OpSignalUtilPtr utilRecPtr; + + // Seize a Util Send record + if (!c_opSignalUtil.seize(utilRecPtr)) { + // Failed to allocate util record + return -1; + } + utilRecPtr.p->m_callback = *pcallback; + + // should work for all util signal classes + UtilPrepareReq *req = (UtilPrepareReq*)signal->getDataPtrSend(); + utilRecPtr.p->m_userData = req->getSenderData(); + req->setSenderData(utilRecPtr.i); + + if (ptr) { + jam(); + sendSignal(ref, gsn, signal, length, jbuf, ptr, noOfSections); + } else { + jam(); + sendSignal(ref, gsn, signal, length, jbuf); + } + + return 0; +} + +int +Dbdict::recvSignalUtilReq(Signal* signal, Uint32 returnCode) +{ + jam(); + EVENT_TRACE; + UtilPrepareConf * const req = (UtilPrepareConf*)signal->getDataPtr(); + OpSignalUtilPtr utilRecPtr; + utilRecPtr.i = req->getSenderData(); + if ((utilRecPtr.p = c_opSignalUtil.getPtr(utilRecPtr.i)) == NULL) { + jam(); + return -1; + } + + req->setSenderData(utilRecPtr.p->m_userData); + Callback c = utilRecPtr.p->m_callback; + c_opSignalUtil.release(utilRecPtr); + + execute(signal, c, returnCode); + return 0; +} + +void Dbdict::execUTIL_PREPARE_CONF(Signal *signal) +{ + jamEntry(); + EVENT_TRACE; + ndbrequire(recvSignalUtilReq(signal, 0) == 0); +} + +void +Dbdict::execUTIL_PREPARE_REF(Signal *signal) +{ + jamEntry(); + EVENT_TRACE; + ndbrequire(recvSignalUtilReq(signal, 1) == 0); +} + +void Dbdict::execUTIL_EXECUTE_CONF(Signal *signal) +{ + jamEntry(); + EVENT_TRACE; + ndbrequire(recvSignalUtilReq(signal, 0) == 0); +} + +void Dbdict::execUTIL_EXECUTE_REF(Signal *signal) +{ + jamEntry(); + EVENT_TRACE; + +#ifdef EVENT_DEBUG + UtilExecuteRef * ref = (UtilExecuteRef *)signal->getDataPtrSend(); + + ndbout_c("execUTIL_EXECUTE_REF"); + ndbout_c("senderData %u",ref->getSenderData()); + ndbout_c("errorCode %u",ref->getErrorCode()); + ndbout_c("TCErrorCode %u",ref->getTCErrorCode()); +#endif + + ndbrequire(recvSignalUtilReq(signal, 1) == 0); +} +void Dbdict::execUTIL_RELEASE_CONF(Signal *signal) +{ + jamEntry(); + EVENT_TRACE; + ndbrequire(false); + ndbrequire(recvSignalUtilReq(signal, 0) == 0); +} +void Dbdict::execUTIL_RELEASE_REF(Signal *signal) +{ + jamEntry(); + EVENT_TRACE; + ndbrequire(false); + ndbrequire(recvSignalUtilReq(signal, 1) == 0); +} + +/** + * MODULE: Create event + * + * Create event in DICT. + * + * + * Request type in CREATE_EVNT signals: + * + * Signalflow see Dbdict.txt + * + */ + +/***************************************************************** + * + * Systable stuff + * + */ + +const Uint32 Dbdict::sysTab_NDBEVENTS_0_szs[EVENT_SYSTEM_TABLE_LENGTH] = { + sizeof(((sysTab_NDBEVENTS_0*)0)->NAME), + sizeof(((sysTab_NDBEVENTS_0*)0)->EVENT_TYPE), + sizeof(((sysTab_NDBEVENTS_0*)0)->TABLE_NAME), + sizeof(((sysTab_NDBEVENTS_0*)0)->ATTRIBUTE_MASK), + sizeof(((sysTab_NDBEVENTS_0*)0)->SUBID), + sizeof(((sysTab_NDBEVENTS_0*)0)->SUBKEY) +}; + +void +Dbdict::prepareTransactionEventSysTable (Callback *pcallback, + Signal* signal, + Uint32 senderData, + UtilPrepareReq::OperationTypeValue prepReq) +{ + // find table id for event system table + TableRecord keyRecord; + strcpy(keyRecord.tableName, EVENT_SYSTEM_TABLE_NAME); + + TableRecordPtr tablePtr; + c_tableRecordHash.find(tablePtr, keyRecord); + + ndbrequire(tablePtr.i != RNIL); // system table must exist + + Uint32 tableId = tablePtr.p->tableId; /* System table */ + Uint32 noAttr = tablePtr.p->noOfAttributes; + ndbrequire(noAttr == EVENT_SYSTEM_TABLE_LENGTH); + + switch (prepReq) { + case UtilPrepareReq::Update: + case UtilPrepareReq::Insert: + case UtilPrepareReq::Write: + case UtilPrepareReq::Read: + jam(); + break; + case UtilPrepareReq::Delete: + jam(); + noAttr = 1; // only involves Primary key which should be the first + break; + } + prepareUtilTransaction(pcallback, signal, senderData, tableId, NULL, + prepReq, noAttr, NULL, NULL); +} + +void +Dbdict::prepareUtilTransaction(Callback *pcallback, + Signal* signal, + Uint32 senderData, + Uint32 tableId, + const char* tableName, + UtilPrepareReq::OperationTypeValue prepReq, + Uint32 noAttr, + Uint32 attrIds[], + const char *attrNames[]) +{ + jam(); + EVENT_TRACE; + + UtilPrepareReq * utilPrepareReq = + (UtilPrepareReq *)signal->getDataPtrSend(); + + utilPrepareReq->setSenderRef(reference()); + utilPrepareReq->setSenderData(senderData); + + const Uint32 pageSizeInWords = 128; + Uint32 propPage[pageSizeInWords]; + LinearWriter w(&propPage[0],128); + w.first(); + w.add(UtilPrepareReq::NoOfOperations, 1); + w.add(UtilPrepareReq::OperationType, prepReq); + if (tableName) { + jam(); + w.add(UtilPrepareReq::TableName, tableName); + } else { + jam(); + w.add(UtilPrepareReq::TableId, tableId); + } + for(Uint32 i = 0; i < noAttr; i++) + if (tableName) { + jam(); + w.add(UtilPrepareReq::AttributeName, attrNames[i]); + } else { + if (attrIds) { + jam(); + w.add(UtilPrepareReq::AttributeId, attrIds[i]); + } else { + jam(); + w.add(UtilPrepareReq::AttributeId, i); + } + } +#ifdef EVENT_DEBUG + // Debugging + SimplePropertiesLinearReader reader(propPage, w.getWordsUsed()); + printf("Dict::prepareInsertTransactions: Sent SimpleProperties:\n"); + reader.printAll(ndbout); +#endif + + struct LinearSectionPtr sectionsPtr[UtilPrepareReq::NoOfSections]; + sectionsPtr[UtilPrepareReq::PROPERTIES_SECTION].p = propPage; + sectionsPtr[UtilPrepareReq::PROPERTIES_SECTION].sz = w.getWordsUsed(); + + sendSignalUtilReq(pcallback, DBUTIL_REF, GSN_UTIL_PREPARE_REQ, signal, + UtilPrepareReq::SignalLength, JBB, + sectionsPtr, UtilPrepareReq::NoOfSections); +} + +/***************************************************************** + * + * CREATE_EVNT_REQ has three types RT_CREATE, RT_GET (from user) + * and RT_DICT_AFTER_GET send from master DICT to slaves + * + * This function just dscpaches these to + * + * createEvent_RT_USER_CREATE + * createEvent_RT_USER_GET + * createEvent_RT_DICT_AFTER_GET + * + * repectively + * + */ + +void +Dbdict::execCREATE_EVNT_REQ(Signal* signal) +{ + jamEntry(); + +#if 0 + { + SafeCounterHandle handle; + { + SafeCounter tmp(c_counterMgr, handle); + tmp.init(CMVMI, GSN_DUMP_STATE_ORD, /* senderData */ 13); + tmp.clearWaitingFor(); + tmp.setWaitingFor(3); + ndbrequire(!tmp.done()); + ndbout_c("Allocted"); + } + ndbrequire(!handle.done()); + { + SafeCounter tmp(c_counterMgr, handle); + tmp.clearWaitingFor(3); + ndbrequire(tmp.done()); + ndbout_c("Deallocted"); + } + ndbrequire(handle.done()); + } + { + NodeBitmask nodes; + nodes.clear(); + + nodes.set(2); + nodes.set(3); + nodes.set(4); + nodes.set(5); + + { + Uint32 i = 0; + while((i = nodes.find(i)) != NodeBitmask::NotFound){ + ndbout_c("1 Node id = %u", i); + i++; + } + } + + NodeReceiverGroup rg(DBDICT, nodes); + RequestTracker rt2; + ndbrequire(rt2.done()); + ndbrequire(!rt2.hasRef()); + ndbrequire(!rt2.hasConf()); + rt2.init(c_counterMgr, rg, GSN_CREATE_EVNT_REF, 13); + + RequestTracker rt3; + rt3.init(c_counterMgr, rg, GSN_CREATE_EVNT_REF, 13); + + ndbrequire(!rt2.done()); + ndbrequire(!rt3.done()); + + rt2.reportRef(c_counterMgr, 2); + rt3.reportConf(c_counterMgr, 2); + + ndbrequire(!rt2.done()); + ndbrequire(!rt3.done()); + + rt2.reportConf(c_counterMgr, 3); + rt3.reportConf(c_counterMgr, 3); + + ndbrequire(!rt2.done()); + ndbrequire(!rt3.done()); + + rt2.reportConf(c_counterMgr, 4); + rt3.reportConf(c_counterMgr, 4); + + ndbrequire(!rt2.done()); + ndbrequire(!rt3.done()); + + rt2.reportConf(c_counterMgr, 5); + rt3.reportConf(c_counterMgr, 5); + + ndbrequire(rt2.done()); + ndbrequire(rt3.done()); + } +#endif + + if (! assembleFragments(signal)) { + jam(); + return; + } + + CreateEvntReq *req = (CreateEvntReq*)signal->getDataPtr(); + const CreateEvntReq::RequestType requestType = req->getRequestType(); + const Uint32 requestFlag = req->getRequestFlag(); + + OpCreateEventPtr evntRecPtr; + // Seize a Create Event record + if (!c_opCreateEvent.seize(evntRecPtr)) { + // Failed to allocate event record + jam(); + releaseSections(signal); + + CreateEvntRef * ret = (CreateEvntRef *)signal->getDataPtrSend(); + ret->senderRef = reference(); + ret->setErrorCode(CreateEvntRef::SeizeError); + ret->setErrorLine(__LINE__); + ret->setErrorNode(reference()); + sendSignal(signal->senderBlockRef(), GSN_CREATE_EVNT_REF, signal, + CreateEvntRef::SignalLength, JBB); + return; + } + +#ifdef EVENT_DEBUG + ndbout_c("DBDICT::execCREATE_EVNT_REQ from %u evntRecId = (%d)", refToNode(signal->getSendersBlockRef()), evntRecPtr.i); +#endif + + ndbrequire(req->getUserRef() == signal->getSendersBlockRef()); + + evntRecPtr.p->init(req,this); + + if (requestFlag & (Uint32)CreateEvntReq::RT_DICT_AFTER_GET) { + jam(); + EVENT_TRACE; + createEvent_RT_DICT_AFTER_GET(signal, evntRecPtr); + return; + } + if (requestType == CreateEvntReq::RT_USER_GET) { + jam(); + EVENT_TRACE; + createEvent_RT_USER_GET(signal, evntRecPtr); + return; + } + if (requestType == CreateEvntReq::RT_USER_CREATE) { + jam(); + EVENT_TRACE; + createEvent_RT_USER_CREATE(signal, evntRecPtr); + return; + } + +#ifdef EVENT_DEBUG + ndbout << "Dbdict.cpp: Dbdict::execCREATE_EVNT_REQ other" << endl; +#endif + jam(); + releaseSections(signal); + + evntRecPtr.p->m_errorCode = CreateEvntRef::Undefined; + evntRecPtr.p->m_errorLine = __LINE__; + evntRecPtr.p->m_errorNode = reference(); + + createEvent_sendReply(signal, evntRecPtr); +} + +/******************************************************************** + * + * Event creation + * + *****************************************************************/ + +void +Dbdict::createEvent_RT_USER_CREATE(Signal* signal, OpCreateEventPtr evntRecPtr){ + jam(); + evntRecPtr.p->m_request.setUserRef(signal->senderBlockRef()); + +#ifdef EVENT_DEBUG + ndbout << "Dbdict.cpp: Dbdict::execCREATE_EVNT_REQ RT_USER" << endl; + char buf[128] = {0}; + AttributeMask mask = evntRecPtr.p->m_request.getAttrListBitmask(); + mask.getText(buf); + ndbout_c("mask = %s", buf); +#endif + + // Interpret the long signal + + SegmentedSectionPtr ssPtr; + // save name and event properties + signal->getSection(ssPtr, CreateEvntReq::EVENT_NAME_SECTION); + + SimplePropertiesSectionReader r0(ssPtr, getSectionSegmentPool()); +#ifdef EVENT_DEBUG + r0.printAll(ndbout); +#endif + // event name + if ((!r0.first()) || + (r0.getValueType() != SimpleProperties::StringValue) || + (r0.getValueLen() <= 0)) { + jam(); + releaseSections(signal); + + evntRecPtr.p->m_errorCode = CreateEvntRef::Undefined; + evntRecPtr.p->m_errorLine = __LINE__; + evntRecPtr.p->m_errorNode = reference(); + + createEvent_sendReply(signal, evntRecPtr); + return; + } + r0.getString(evntRecPtr.p->m_eventRec.NAME); + { + int len = strlen(evntRecPtr.p->m_eventRec.NAME); + memset(evntRecPtr.p->m_eventRec.NAME+len, 0, MAX_TAB_NAME_SIZE-len); +#ifdef EVENT_DEBUG + printf("CreateEvntReq::RT_USER_CREATE; EventName %s, len %u\n", + evntRecPtr.p->m_eventRec.NAME, len); + for(int i = 0; i < MAX_TAB_NAME_SIZE/4; i++) + printf("H'%.8x ", ((Uint32*)evntRecPtr.p->m_eventRec.NAME)[i]); + printf("\n"); +#endif + } + // table name + if ((!r0.next()) || + (r0.getValueType() != SimpleProperties::StringValue) || + (r0.getValueLen() <= 0)) { + jam(); + releaseSections(signal); + + evntRecPtr.p->m_errorCode = CreateEvntRef::Undefined; + evntRecPtr.p->m_errorLine = __LINE__; + evntRecPtr.p->m_errorNode = reference(); + + createEvent_sendReply(signal, evntRecPtr); + return; + } + r0.getString(evntRecPtr.p->m_eventRec.TABLE_NAME); + { + int len = strlen(evntRecPtr.p->m_eventRec.TABLE_NAME); + memset(evntRecPtr.p->m_eventRec.TABLE_NAME+len, 0, MAX_TAB_NAME_SIZE-len); + } + +#ifdef EVENT_DEBUG + ndbout_c("event name: %s",evntRecPtr.p->m_eventRec.NAME); + ndbout_c("table name: %s",evntRecPtr.p->m_eventRec.TABLE_NAME); +#endif + + releaseSections(signal); + + // Send request to SUMA + + CreateSubscriptionIdReq * sumaIdReq = + (CreateSubscriptionIdReq *)signal->getDataPtrSend(); + + // make sure we save the original sender for later + sumaIdReq->senderData = evntRecPtr.i; +#ifdef EVENT_DEBUG + ndbout << "sumaIdReq->senderData = " << sumaIdReq->senderData << endl; +#endif + sendSignal(SUMA_REF, GSN_CREATE_SUBID_REQ, signal, + CreateSubscriptionIdReq::SignalLength, JBB); + // we should now return in either execCREATE_SUBID_CONF + // or execCREATE_SUBID_REF +} + +void Dbdict::execCREATE_SUBID_REF(Signal* signal) +{ + jamEntry(); + EVENT_TRACE; + CreateSubscriptionIdRef * const ref = + (CreateSubscriptionIdRef *)signal->getDataPtr(); + OpCreateEventPtr evntRecPtr; + + evntRecPtr.i = ref->senderData; + ndbrequire((evntRecPtr.p = c_opCreateEvent.getPtr(evntRecPtr.i)) != NULL); + + evntRecPtr.p->m_errorCode = CreateEvntRef::Undefined; + evntRecPtr.p->m_errorLine = __LINE__; + evntRecPtr.p->m_errorNode = reference(); + + createEvent_sendReply(signal, evntRecPtr); +} + +void Dbdict::execCREATE_SUBID_CONF(Signal* signal) +{ + jamEntry(); + EVENT_TRACE; + + CreateSubscriptionIdConf const * sumaIdConf = + (CreateSubscriptionIdConf *)signal->getDataPtr(); + + Uint32 evntRecId = sumaIdConf->senderData; + OpCreateEvent *evntRec; + + ndbrequire((evntRec = c_opCreateEvent.getPtr(evntRecId)) != NULL); + + evntRec->m_request.setEventId(sumaIdConf->subscriptionId); + evntRec->m_request.setEventKey(sumaIdConf->subscriptionKey); + + releaseSections(signal); + + Callback c = { safe_cast(&Dbdict::createEventUTIL_PREPARE), 0 }; + + prepareTransactionEventSysTable(&c, signal, evntRecId, + UtilPrepareReq::Insert); +} + +void +Dbdict::createEventComplete_RT_USER_CREATE(Signal* signal, + OpCreateEventPtr evntRecPtr){ + jam(); + createEvent_sendReply(signal, evntRecPtr); +} + +/********************************************************************* + * + * UTIL_PREPARE, UTIL_EXECUTE + * + * insert or read systable NDB$EVENTS_0 + */ + +void interpretUtilPrepareErrorCode(UtilPrepareRef::ErrorCode errorCode, + bool& temporary, Uint32& line) +{ + switch (errorCode) { + case UtilPrepareRef::NO_ERROR: + jam(); + line = __LINE__; + EVENT_TRACE; + break; + case UtilPrepareRef::PREPARE_SEIZE_ERROR: + jam(); + temporary = true; + line = __LINE__; + EVENT_TRACE; + break; + case UtilPrepareRef::PREPARE_PAGES_SEIZE_ERROR: + jam(); + line = __LINE__; + EVENT_TRACE; + break; + case UtilPrepareRef::PREPARED_OPERATION_SEIZE_ERROR: + jam(); + line = __LINE__; + EVENT_TRACE; + break; + case UtilPrepareRef::DICT_TAB_INFO_ERROR: + jam(); + line = __LINE__; + EVENT_TRACE; + break; + case UtilPrepareRef::MISSING_PROPERTIES_SECTION: + jam(); + line = __LINE__; + EVENT_TRACE; + break; + default: + jam(); + line = __LINE__; + EVENT_TRACE; + break; + } +} + +void +Dbdict::createEventUTIL_PREPARE(Signal* signal, + Uint32 callbackData, + Uint32 returnCode) +{ + jam(); + EVENT_TRACE; + if (returnCode == 0) { + UtilPrepareConf* const req = (UtilPrepareConf*)signal->getDataPtr(); + OpCreateEventPtr evntRecPtr; + jam(); + evntRecPtr.i = req->getSenderData(); + const Uint32 prepareId = req->getPrepareId(); + + ndbrequire((evntRecPtr.p = c_opCreateEvent.getPtr(evntRecPtr.i)) != NULL); + + Callback c = { safe_cast(&Dbdict::createEventUTIL_EXECUTE), 0 }; + + switch (evntRecPtr.p->m_requestType) { + case CreateEvntReq::RT_USER_GET: +#ifdef EVENT_DEBUG + printf("get type = %d\n", CreateEvntReq::RT_USER_GET); +#endif + jam(); + executeTransEventSysTable(&c, signal, + evntRecPtr.i, evntRecPtr.p->m_eventRec, + prepareId, UtilPrepareReq::Read); + break; + case CreateEvntReq::RT_USER_CREATE: +#ifdef EVENT_DEBUG + printf("create type = %d\n", CreateEvntReq::RT_USER_CREATE); +#endif + { + evntRecPtr.p->m_eventRec.EVENT_TYPE = evntRecPtr.p->m_request.getEventType(); + AttributeMask m = evntRecPtr.p->m_request.getAttrListBitmask(); + memcpy(evntRecPtr.p->m_eventRec.ATTRIBUTE_MASK, &m, + sizeof(evntRecPtr.p->m_eventRec.ATTRIBUTE_MASK)); + evntRecPtr.p->m_eventRec.SUBID = evntRecPtr.p->m_request.getEventId(); + evntRecPtr.p->m_eventRec.SUBKEY = evntRecPtr.p->m_request.getEventKey(); + } + jam(); + executeTransEventSysTable(&c, signal, + evntRecPtr.i, evntRecPtr.p->m_eventRec, + prepareId, UtilPrepareReq::Insert); + break; + default: +#ifdef EVENT_DEBUG + printf("type = %d\n", evntRecPtr.p->m_requestType); + printf("bet type = %d\n", CreateEvntReq::RT_USER_GET); + printf("create type = %d\n", CreateEvntReq::RT_USER_CREATE); +#endif + ndbrequire(false); + } + } else { // returnCode != 0 + UtilPrepareRef* const ref = (UtilPrepareRef*)signal->getDataPtr(); + + const UtilPrepareRef::ErrorCode errorCode = + (UtilPrepareRef::ErrorCode)ref->getErrorCode(); + + OpCreateEventPtr evntRecPtr; + evntRecPtr.i = ref->getSenderData(); + ndbrequire((evntRecPtr.p = c_opCreateEvent.getPtr(evntRecPtr.i)) != NULL); + + bool temporary = false; + interpretUtilPrepareErrorCode(errorCode, + temporary, evntRecPtr.p->m_errorLine); + if (temporary) { + evntRecPtr.p->m_errorCode = + CreateEvntRef::makeTemporary(CreateEvntRef::Undefined); + } + + if (evntRecPtr.p->m_errorCode == 0) { + evntRecPtr.p->m_errorCode = CreateEvntRef::Undefined; + } + evntRecPtr.p->m_errorNode = reference(); + + createEvent_sendReply(signal, evntRecPtr); + } +} + +void Dbdict::executeTransEventSysTable(Callback *pcallback, Signal *signal, + const Uint32 ptrI, + sysTab_NDBEVENTS_0& m_eventRec, + const Uint32 prepareId, + UtilPrepareReq::OperationTypeValue prepReq) +{ + jam(); + const Uint32 noAttr = EVENT_SYSTEM_TABLE_LENGTH; + Uint32 total_len = 0; + + Uint32* attrHdr = signal->theData + 25; + Uint32* attrPtr = attrHdr; + + Uint32 id=0; + // attribute 0 event name: Primary Key + { + AttributeHeader::init(attrPtr, id, sysTab_NDBEVENTS_0_szs[id]/4); + total_len += sysTab_NDBEVENTS_0_szs[id]; + attrPtr++; id++; + } + + switch (prepReq) { + case UtilPrepareReq::Read: + jam(); + EVENT_TRACE; + // no more + while ( id < noAttr ) + AttributeHeader::init(attrPtr++, id++, 0); + ndbrequire(id == (Uint32) noAttr); + break; + case UtilPrepareReq::Insert: + jam(); + EVENT_TRACE; + while ( id < noAttr ) { + AttributeHeader::init(attrPtr, id, sysTab_NDBEVENTS_0_szs[id]/4); + total_len += sysTab_NDBEVENTS_0_szs[id]; + attrPtr++; id++; + } + ndbrequire(id == (Uint32) noAttr); + break; + case UtilPrepareReq::Delete: + ndbrequire(id == 1); + break; + default: + ndbrequire(false); + } + + LinearSectionPtr headerPtr; + LinearSectionPtr dataPtr; + + headerPtr.p = attrHdr; + headerPtr.sz = noAttr; + + dataPtr.p = (Uint32*)&m_eventRec; + dataPtr.sz = total_len/4; + + ndbrequire((total_len == sysTab_NDBEVENTS_0_szs[0]) || + (total_len == sizeof(sysTab_NDBEVENTS_0))); + +#if 0 + printf("Header size %u\n", headerPtr.sz); + for(int i = 0; i < (int)headerPtr.sz; i++) + printf("H'%.8x ", attrHdr[i]); + printf("\n"); + + printf("Data size %u\n", dataPtr.sz); + for(int i = 0; i < (int)dataPtr.sz; i++) + printf("H'%.8x ", dataPage[i]); + printf("\n"); +#endif + + executeTransaction(pcallback, signal, + ptrI, + prepareId, + id, + headerPtr, + dataPtr); +} + +void Dbdict::executeTransaction(Callback *pcallback, + Signal* signal, + Uint32 senderData, + Uint32 prepareId, + Uint32 noAttr, + LinearSectionPtr headerPtr, + LinearSectionPtr dataPtr) +{ + jam(); + EVENT_TRACE; + + UtilExecuteReq * utilExecuteReq = + (UtilExecuteReq *)signal->getDataPtrSend(); + + utilExecuteReq->setSenderRef(reference()); + utilExecuteReq->setSenderData(senderData); + utilExecuteReq->setPrepareId(prepareId); + utilExecuteReq->setReleaseFlag(); // must be done after setting prepareId + +#if 0 + printf("Header size %u\n", headerPtr.sz); + for(int i = 0; i < (int)headerPtr.sz; i++) + printf("H'%.8x ", headerBuffer[i]); + printf("\n"); + + printf("Data size %u\n", dataPtr.sz); + for(int i = 0; i < (int)dataPtr.sz; i++) + printf("H'%.8x ", dataBuffer[i]); + printf("\n"); +#endif + + struct LinearSectionPtr sectionsPtr[UtilExecuteReq::NoOfSections]; + sectionsPtr[UtilExecuteReq::HEADER_SECTION].p = headerPtr.p; + sectionsPtr[UtilExecuteReq::HEADER_SECTION].sz = noAttr; + sectionsPtr[UtilExecuteReq::DATA_SECTION].p = dataPtr.p; + sectionsPtr[UtilExecuteReq::DATA_SECTION].sz = dataPtr.sz; + + sendSignalUtilReq(pcallback, DBUTIL_REF, GSN_UTIL_EXECUTE_REQ, signal, + UtilExecuteReq::SignalLength, JBB, + sectionsPtr, UtilExecuteReq::NoOfSections); +} + +void Dbdict::parseReadEventSys(Signal* signal, sysTab_NDBEVENTS_0& m_eventRec) +{ + SegmentedSectionPtr headerPtr, dataPtr; + jam(); + signal->getSection(headerPtr, UtilExecuteReq::HEADER_SECTION); + SectionReader headerReader(headerPtr, getSectionSegmentPool()); + + signal->getSection(dataPtr, UtilExecuteReq::DATA_SECTION); + SectionReader dataReader(dataPtr, getSectionSegmentPool()); + + AttributeHeader header; + Uint32 *dst = (Uint32*)&m_eventRec; + + for (int i = 0; i < EVENT_SYSTEM_TABLE_LENGTH; i++) { + headerReader.getWord((Uint32 *)&header); + int sz = header.getDataSize(); + for (int i=0; i < sz; i++) + dataReader.getWord(dst++); + } + + ndbrequire( ((char*)dst-(char*)&m_eventRec) == sizeof(m_eventRec) ); + + releaseSections(signal); +} + +void Dbdict::createEventUTIL_EXECUTE(Signal *signal, + Uint32 callbackData, + Uint32 returnCode) +{ + jam(); + EVENT_TRACE; + if (returnCode == 0) { + // Entry into system table all set + UtilExecuteConf* const conf = (UtilExecuteConf*)signal->getDataPtr(); + jam(); + OpCreateEventPtr evntRecPtr; + evntRecPtr.i = conf->getSenderData(); + + ndbrequire((evntRecPtr.p = c_opCreateEvent.getPtr(evntRecPtr.i)) != NULL); + OpCreateEvent *evntRec = evntRecPtr.p; + + switch (evntRec->m_requestType) { + case CreateEvntReq::RT_USER_GET: { +#ifdef EVENT_DEBUG + printf("get type = %d\n", CreateEvntReq::RT_USER_GET); +#endif + parseReadEventSys(signal, evntRecPtr.p->m_eventRec); + + evntRec->m_request.setEventType(evntRecPtr.p->m_eventRec.EVENT_TYPE); + evntRec->m_request.setAttrListBitmask(*(AttributeMask*)evntRecPtr.p->m_eventRec.ATTRIBUTE_MASK); + evntRec->m_request.setEventId(evntRecPtr.p->m_eventRec.SUBID); + evntRec->m_request.setEventKey(evntRecPtr.p->m_eventRec.SUBKEY); + +#ifdef EVENT_DEBUG + printf("EventName: %s\n", evntRec->m_eventRec.NAME); + printf("TableName: %s\n", evntRec->m_eventRec.TABLE_NAME); +#endif + + // find table id for event table + TableRecord keyRecord; + strcpy(keyRecord.tableName, evntRecPtr.p->m_eventRec.TABLE_NAME); + + TableRecordPtr tablePtr; + c_tableRecordHash.find(tablePtr, keyRecord); + + if (tablePtr.i == RNIL) { + jam(); + evntRecPtr.p->m_errorCode = CreateEvntRef::Undefined; + evntRecPtr.p->m_errorLine = __LINE__; + evntRecPtr.p->m_errorNode = reference(); + + createEvent_sendReply(signal, evntRecPtr); + return; + } + + evntRec->m_request.setTableId(tablePtr.p->tableId); + + createEventComplete_RT_USER_GET(signal, evntRecPtr); + return; + } + case CreateEvntReq::RT_USER_CREATE: { +#ifdef EVENT_DEBUG + printf("create type = %d\n", CreateEvntReq::RT_USER_CREATE); +#endif + jam(); + createEventComplete_RT_USER_CREATE(signal, evntRecPtr); + return; + } + break; + default: + ndbrequire(false); + } + } else { // returnCode != 0 + UtilExecuteRef * const ref = (UtilExecuteRef *)signal->getDataPtr(); + OpCreateEventPtr evntRecPtr; + evntRecPtr.i = ref->getSenderData(); + ndbrequire((evntRecPtr.p = c_opCreateEvent.getPtr(evntRecPtr.i)) != NULL); + jam(); + evntRecPtr.p->m_errorNode = reference(); + evntRecPtr.p->m_errorLine = __LINE__; + + switch (ref->getErrorCode()) { + case UtilExecuteRef::TCError: + switch (ref->getTCErrorCode()) { + case ZNOT_FOUND: + jam(); + evntRecPtr.p->m_errorCode = CreateEvntRef::EventNotFound; + break; + case ZALREADYEXIST: + jam(); + evntRecPtr.p->m_errorCode = CreateEvntRef::EventExists; + break; + default: + jam(); + evntRecPtr.p->m_errorCode = CreateEvntRef::UndefinedTCError; + break; + } + break; + default: + jam(); + evntRecPtr.p->m_errorCode = CreateEvntRef::Undefined; + break; + } + + createEvent_sendReply(signal, evntRecPtr); + } +} + +/*********************************************************************** + * + * NdbEventOperation, reading systable, creating event in suma + * + */ + +void +Dbdict::createEvent_RT_USER_GET(Signal* signal, OpCreateEventPtr evntRecPtr){ + jam(); + EVENT_TRACE; +#ifdef EVENT_PH2_DEBUG + ndbout_c("DBDICT(Coordinator) got GSN_CREATE_EVNT_REQ::RT_USER_GET evntRecPtr.i = (%d), ref = %u", evntRecPtr.i, evntRecPtr.p->m_request.getUserRef()); +#endif + + SegmentedSectionPtr ssPtr; + + signal->getSection(ssPtr, 0); + + SimplePropertiesSectionReader r0(ssPtr, getSectionSegmentPool()); +#ifdef EVENT_DEBUG + r0.printAll(ndbout); +#endif + if ((!r0.first()) || + (r0.getValueType() != SimpleProperties::StringValue) || + (r0.getValueLen() <= 0)) { + jam(); + releaseSections(signal); + + evntRecPtr.p->m_errorCode = CreateEvntRef::Undefined; + evntRecPtr.p->m_errorLine = __LINE__; + evntRecPtr.p->m_errorNode = reference(); + + createEvent_sendReply(signal, evntRecPtr); + return; + } + + r0.getString(evntRecPtr.p->m_eventRec.NAME); + int len = strlen(evntRecPtr.p->m_eventRec.NAME); + memset(evntRecPtr.p->m_eventRec.NAME+len, 0, MAX_TAB_NAME_SIZE-len); + + releaseSections(signal); + + Callback c = { safe_cast(&Dbdict::createEventUTIL_PREPARE), 0 }; + + prepareTransactionEventSysTable(&c, signal, evntRecPtr.i, + UtilPrepareReq::Read); + /* + * Will read systable and fill an OpCreateEventPtr + * and return below + */ +} + +void +Dbdict::createEventComplete_RT_USER_GET(Signal* signal, + OpCreateEventPtr evntRecPtr){ + jam(); + + // Send to oneself and the other DICT's + CreateEvntReq * req = (CreateEvntReq *)signal->getDataPtrSend(); + + *req = evntRecPtr.p->m_request; + req->senderRef = reference(); + req->senderData = evntRecPtr.i; + + req->addRequestFlag(CreateEvntReq::RT_DICT_AFTER_GET); + +#ifdef EVENT_PH2_DEBUG + ndbout_c("DBDICT(Coordinator) sending GSN_CREATE_EVNT_REQ::RT_DICT_AFTER_GET to DBDICT participants evntRecPtr.i = (%d)", evntRecPtr.i); +#endif + + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + evntRecPtr.p->m_reqTracker.init + (c_counterMgr, rg, GSN_CREATE_EVNT_REF, evntRecPtr.i); + sendSignal(rg, GSN_CREATE_EVNT_REQ, signal, CreateEvntReq::SignalLength, JBB); +} + +void +Dbdict::createEvent_nodeFailCallback(Signal* signal, Uint32 eventRecPtrI, + Uint32 returnCode){ + OpCreateEventPtr evntRecPtr; + c_opCreateEvent.getPtr(evntRecPtr, eventRecPtrI); + createEvent_sendReply(signal, evntRecPtr); +} + +void Dbdict::execCREATE_EVNT_REF(Signal* signal) +{ + jamEntry(); + EVENT_TRACE; + CreateEvntRef * const ref = (CreateEvntRef *)signal->getDataPtr(); + OpCreateEventPtr evntRecPtr; + + evntRecPtr.i = ref->getUserData(); + + ndbrequire((evntRecPtr.p = c_opCreateEvent.getPtr(evntRecPtr.i)) != NULL); + +#ifdef EVENT_PH2_DEBUG + ndbout_c("DBDICT(Coordinator) got GSN_CREATE_EVNT_REF evntRecPtr.i = (%d)", evntRecPtr.i); +#endif + + if (ref->errorCode == CreateEvntRef::NF_FakeErrorREF){ + jam(); + evntRecPtr.p->m_reqTracker.ignoreRef(c_counterMgr, refToNode(ref->senderRef)); + } else { + jam(); + evntRecPtr.p->m_reqTracker.reportRef(c_counterMgr, refToNode(ref->senderRef)); + } + createEvent_sendReply(signal, evntRecPtr); + + return; +} + +void Dbdict::execCREATE_EVNT_CONF(Signal* signal) +{ + jamEntry(); + EVENT_TRACE; + CreateEvntConf * const conf = (CreateEvntConf *)signal->getDataPtr(); + OpCreateEventPtr evntRecPtr; + + evntRecPtr.i = conf->getUserData(); + + ndbrequire((evntRecPtr.p = c_opCreateEvent.getPtr(evntRecPtr.i)) != NULL); + +#ifdef EVENT_PH2_DEBUG + ndbout_c("DBDICT(Coordinator) got GSN_CREATE_EVNT_CONF evntRecPtr.i = (%d)", evntRecPtr.i); +#endif + + evntRecPtr.p->m_reqTracker.reportConf(c_counterMgr, refToNode(conf->senderRef)); + + // we will only have a valid tablename if it the master DICT sending this + // but that's ok + LinearSectionPtr ptr[1]; + ptr[0].p = (Uint32 *)evntRecPtr.p->m_eventRec.TABLE_NAME; + ptr[0].sz = + (strlen(evntRecPtr.p->m_eventRec.TABLE_NAME)+4)/4; // to make sure we have a null + + createEvent_sendReply(signal, evntRecPtr, ptr, 1); + + return; +} + +/************************************************ + * + * Participant stuff + * + */ + +void +Dbdict::createEvent_RT_DICT_AFTER_GET(Signal* signal, OpCreateEventPtr evntRecPtr){ + jam(); + evntRecPtr.p->m_request.setUserRef(signal->senderBlockRef()); + +#ifdef EVENT_PH2_DEBUG + ndbout_c("DBDICT(Participant) got CREATE_EVNT_REQ::RT_DICT_AFTER_GET evntRecPtr.i = (%d)", evntRecPtr.i); +#endif + + // the signal comes from the DICT block that got the first user request! + // This code runs on all DICT nodes, including oneself + + // Seize a Create Event record, the Coordinator will now have two seized + // but that's ok, it's like a recursion + + SubCreateReq * sumaReq = (SubCreateReq *)signal->getDataPtrSend(); + + sumaReq->subscriberRef = reference(); // reference to DICT + sumaReq->subscriberData = evntRecPtr.i; + sumaReq->subscriptionId = evntRecPtr.p->m_request.getEventId(); + sumaReq->subscriptionKey = evntRecPtr.p->m_request.getEventKey(); + sumaReq->subscriptionType = SubCreateReq::TableEvent; + sumaReq->tableId = evntRecPtr.p->m_request.getTableId(); + +#ifdef EVENT_PH2_DEBUG + ndbout_c("sending GSN_SUB_CREATE_REQ"); +#endif + + sendSignal(SUMA_REF, GSN_SUB_CREATE_REQ, signal, + SubCreateReq::SignalLength+1 /*to get table Id*/, JBB); +} + +void Dbdict::execSUB_CREATE_REF(Signal* signal) +{ + jamEntry(); + EVENT_TRACE; + SubCreateRef * const ref = (SubCreateRef *)signal->getDataPtr(); + OpCreateEventPtr evntRecPtr; + + evntRecPtr.i = ref->subscriberData; + ndbrequire((evntRecPtr.p = c_opCreateEvent.getPtr(evntRecPtr.i)) != NULL); + +#ifdef EVENT_PH2_DEBUG + ndbout_c("DBDICT(Participant) got SUB_CREATE_REF evntRecPtr.i = (%d)", evntRecPtr.i); +#endif + + if (ref->err == GrepError::SUBSCRIPTION_ID_NOT_UNIQUE) { + jam(); +#ifdef EVENT_PH2_DEBUG + ndbout_c("SUBSCRIPTION_ID_NOT_UNIQUE"); +#endif + createEvent_sendReply(signal, evntRecPtr); + return; + } + +#ifdef EVENT_PH2_DEBUG + ndbout_c("Other error"); +#endif + + evntRecPtr.p->m_errorCode = CreateEvntRef::Undefined; + evntRecPtr.p->m_errorLine = __LINE__; + evntRecPtr.p->m_errorNode = reference(); + + createEvent_sendReply(signal, evntRecPtr); +} + +void Dbdict::execSUB_CREATE_CONF(Signal* signal) +{ + jamEntry(); + EVENT_TRACE; + + SubCreateConf * const sumaConf = (SubCreateConf *)signal->getDataPtr(); + + const Uint32 subscriptionId = sumaConf->subscriptionId; + const Uint32 subscriptionKey = sumaConf->subscriptionKey; + const Uint32 evntRecId = sumaConf->subscriberData; + + OpCreateEvent *evntRec; + ndbrequire((evntRec = c_opCreateEvent.getPtr(evntRecId)) != NULL); + +#ifdef EVENT_PH2_DEBUG + ndbout_c("DBDICT(Participant) got SUB_CREATE_CONF evntRecPtr.i = (%d)", evntRecId); +#endif + + SubSyncReq *sumaSync = (SubSyncReq *)signal->getDataPtrSend(); + + sumaSync->subscriptionId = subscriptionId; + sumaSync->subscriptionKey = subscriptionKey; + sumaSync->part = (Uint32) SubscriptionData::MetaData; + sumaSync->subscriberData = evntRecId; + + sendSignal(SUMA_REF, GSN_SUB_SYNC_REQ, signal, + SubSyncReq::SignalLength, JBB); +} + +void Dbdict::execSUB_SYNC_REF(Signal* signal) +{ + jamEntry(); + EVENT_TRACE; + SubSyncRef * const ref = (SubSyncRef *)signal->getDataPtr(); + OpCreateEventPtr evntRecPtr; + + evntRecPtr.i = ref->subscriberData; + ndbrequire((evntRecPtr.p = c_opCreateEvent.getPtr(evntRecPtr.i)) != NULL); + + evntRecPtr.p->m_errorCode = CreateEvntRef::Undefined; + evntRecPtr.p->m_errorLine = __LINE__; + evntRecPtr.p->m_errorNode = reference(); + + createEvent_sendReply(signal, evntRecPtr); +} + +void Dbdict::execSUB_SYNC_CONF(Signal* signal) +{ + jamEntry(); + EVENT_TRACE; + + SubSyncConf * const sumaSyncConf = (SubSyncConf *)signal->getDataPtr(); + + // Uint32 subscriptionId = sumaSyncConf->subscriptionId; + // Uint32 subscriptionKey = sumaSyncConf->subscriptionKey; + OpCreateEventPtr evntRecPtr; + + evntRecPtr.i = sumaSyncConf->subscriberData; + ndbrequire((evntRecPtr.p = c_opCreateEvent.getPtr(evntRecPtr.i)) != NULL); + + ndbrequire(sumaSyncConf->part == (Uint32)SubscriptionData::MetaData); + + createEvent_sendReply(signal, evntRecPtr); +} + +/**************************************************** + * + * common create reply method + * + *******************************************************/ + +void Dbdict::createEvent_sendReply(Signal* signal, + OpCreateEventPtr evntRecPtr, + LinearSectionPtr *ptr, int noLSP) +{ + jam(); + EVENT_TRACE; + + // check if we're ready to sent reply + // if we are the master dict we might be waiting for conf/ref + + if (!evntRecPtr.p->m_reqTracker.done()) { + jam(); + return; // there's more to come + } + + if (evntRecPtr.p->m_reqTracker.hasRef()) { + ptr = NULL; // we don't want to return anything if there's an error + if (!evntRecPtr.p->hasError()) { + evntRecPtr.p->m_errorCode = CreateEvntRef::Undefined; + evntRecPtr.p->m_errorLine = __LINE__; + evntRecPtr.p->m_errorNode = reference(); + jam(); + } else + jam(); + } + + // reference to API if master DICT + // else reference to master DICT + Uint32 senderRef = evntRecPtr.p->m_request.getUserRef(); + Uint32 signalLength; + Uint32 gsn; + + if (evntRecPtr.p->hasError()) { + jam(); + EVENT_TRACE; + CreateEvntRef * ret = (CreateEvntRef *)signal->getDataPtrSend(); + + ret->setEventId(evntRecPtr.p->m_request.getEventId()); + ret->setEventKey(evntRecPtr.p->m_request.getEventKey()); + ret->setUserData(evntRecPtr.p->m_request.getUserData()); + ret->senderRef = reference(); + ret->setTableId(evntRecPtr.p->m_request.getTableId()); + ret->setEventType(evntRecPtr.p->m_request.getEventType()); + ret->setRequestType(evntRecPtr.p->m_request.getRequestType()); + + ret->setErrorCode(evntRecPtr.p->m_errorCode); + ret->setErrorLine(evntRecPtr.p->m_errorLine); + ret->setErrorNode(evntRecPtr.p->m_errorNode); + + signalLength = CreateEvntRef::SignalLength; +#ifdef EVENT_PH2_DEBUG + ndbout_c("DBDICT sending GSN_CREATE_EVNT_REF to evntRecPtr.i = (%d) node = %u ref = %u", evntRecPtr.i, refToNode(senderRef), senderRef); + ndbout_c("errorCode = %u", evntRecPtr.p->m_errorCode); + ndbout_c("errorLine = %u", evntRecPtr.p->m_errorLine); +#endif + gsn = GSN_CREATE_EVNT_REF; + + } else { + jam(); + EVENT_TRACE; + CreateEvntConf * evntConf = (CreateEvntConf *)signal->getDataPtrSend(); + + evntConf->setEventId(evntRecPtr.p->m_request.getEventId()); + evntConf->setEventKey(evntRecPtr.p->m_request.getEventKey()); + evntConf->setUserData(evntRecPtr.p->m_request.getUserData()); + evntConf->senderRef = reference(); + evntConf->setTableId(evntRecPtr.p->m_request.getTableId()); + evntConf->setAttrListBitmask(evntRecPtr.p->m_request.getAttrListBitmask()); + evntConf->setEventType(evntRecPtr.p->m_request.getEventType()); + evntConf->setRequestType(evntRecPtr.p->m_request.getRequestType()); + + signalLength = CreateEvntConf::SignalLength; +#ifdef EVENT_PH2_DEBUG + ndbout_c("DBDICT sending GSN_CREATE_EVNT_CONF to evntRecPtr.i = (%d) node = %u ref = %u", evntRecPtr.i, refToNode(senderRef), senderRef); +#endif + gsn = GSN_CREATE_EVNT_CONF; + } + + if (ptr) { + jam(); + sendSignal(senderRef, gsn, signal, signalLength, JBB, ptr, noLSP); + } else { + jam(); + sendSignal(senderRef, gsn, signal, signalLength, JBB); + } + + c_opCreateEvent.release(evntRecPtr); +} + +/*************************************************************/ + +/******************************************************************** + * + * Start event + * + *******************************************************************/ + +void Dbdict::execSUB_START_REQ(Signal* signal) +{ + jamEntry(); + + Uint32 origSenderRef = signal->senderBlockRef(); + + OpSubEventPtr subbPtr; + if (!c_opSubEvent.seize(subbPtr)) { + SubStartRef * ref = (SubStartRef *)signal->getDataPtrSend(); + { // fix + Uint32 subcriberRef = ((SubStartReq*)signal->getDataPtr())->subscriberRef; + ref->subscriberRef = subcriberRef; + } + jam(); + // ret->setErrorCode(SubStartRef::SeizeError); + // ret->setErrorLine(__LINE__); + // ret->setErrorNode(reference()); + ref->senderRef = reference(); + ref->setTemporary(SubStartRef::Busy); + + sendSignal(origSenderRef, GSN_SUB_START_REF, signal, + SubStartRef::SignalLength2, JBB); + return; + } + + { + const SubStartReq* req = (SubStartReq*) signal->getDataPtr(); + subbPtr.p->m_senderRef = req->senderRef; + subbPtr.p->m_senderData = req->senderData; + subbPtr.p->m_errorCode = 0; + } + + if (refToBlock(origSenderRef) != DBDICT) { + /* + * Coordinator + */ + jam(); + + subbPtr.p->m_senderRef = origSenderRef; // not sure if API sets correctly + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + subbPtr.p->m_reqTracker.init(c_counterMgr, rg, GSN_SUB_START_REF, subbPtr.i); + + SubStartReq* req = (SubStartReq*) signal->getDataPtrSend(); + + req->senderRef = reference(); + req->senderData = subbPtr.i; + +#ifdef EVENT_PH3_DEBUG + ndbout_c("DBDICT(Coordinator) sending GSN_SUB_START_REQ to DBDICT participants subbPtr.i = (%d)", subbPtr.i); +#endif + + sendSignal(rg, GSN_SUB_START_REQ, signal, SubStartReq::SignalLength2, JBB); + return; + } + /* + * Participant + */ + ndbrequire(refToBlock(origSenderRef) == DBDICT); + + { + SubStartReq* req = (SubStartReq*) signal->getDataPtrSend(); + + req->senderRef = reference(); + req->senderData = subbPtr.i; + +#ifdef EVENT_PH3_DEBUG + ndbout_c("DBDICT(Participant) sending GSN_SUB_START_REQ to SUMA subbPtr.i = (%d)", subbPtr.i); +#endif + sendSignal(SUMA_REF, GSN_SUB_START_REQ, signal, SubStartReq::SignalLength2, JBB); + } +} + +void Dbdict::execSUB_START_REF(Signal* signal) +{ + jamEntry(); + + const SubStartRef* ref = (SubStartRef*) signal->getDataPtr(); + Uint32 senderRef = ref->senderRef; + + OpSubEventPtr subbPtr; + c_opSubEvent.getPtr(subbPtr, ref->senderData); + + if (refToBlock(senderRef) == SUMA) { + /* + * Participant + */ + jam(); + +#ifdef EVENT_PH3_DEBUG + ndbout_c("DBDICT(Participant) got GSN_SUB_START_REF = (%d)", subbPtr.i); +#endif + + if (ref->isTemporary()){ + jam(); + SubStartReq* req = (SubStartReq*)signal->getDataPtrSend(); + { // fix + Uint32 subscriberRef = ref->subscriberRef; + req->subscriberRef = subscriberRef; + } + req->senderRef = reference(); + req->senderData = subbPtr.i; + sendSignal(SUMA_REF, GSN_SUB_START_REQ, + signal, SubStartReq::SignalLength2, JBB); + } else { + jam(); + + SubStartRef* ref = (SubStartRef*) signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = subbPtr.p->m_senderData; + sendSignal(subbPtr.p->m_senderRef, GSN_SUB_START_REF, + signal, SubStartRef::SignalLength2, JBB); + c_opSubEvent.release(subbPtr); + } + return; + } + /* + * Coordinator + */ + ndbrequire(refToBlock(senderRef) == DBDICT); +#ifdef EVENT_PH3_DEBUG + ndbout_c("DBDICT(Coordinator) got GSN_SUB_START_REF = (%d)", subbPtr.i); +#endif + if (ref->errorCode == SubStartRef::NF_FakeErrorREF){ + jam(); + subbPtr.p->m_reqTracker.ignoreRef(c_counterMgr, refToNode(senderRef)); + } else { + jam(); + subbPtr.p->m_reqTracker.reportRef(c_counterMgr, refToNode(senderRef)); + } + completeSubStartReq(signal,subbPtr.i,0); +} + +void Dbdict::execSUB_START_CONF(Signal* signal) +{ + jamEntry(); + + const SubStartConf* conf = (SubStartConf*) signal->getDataPtr(); + Uint32 senderRef = conf->senderRef; + + OpSubEventPtr subbPtr; + c_opSubEvent.getPtr(subbPtr, conf->senderData); + + if (refToBlock(senderRef) == SUMA) { + /* + * Participant + */ + jam(); + SubStartConf* conf = (SubStartConf*) signal->getDataPtrSend(); + +#ifdef EVENT_PH3_DEBUG + ndbout_c("DBDICT(Participant) got GSN_SUB_START_CONF = (%d)", subbPtr.i); +#endif + + conf->senderRef = reference(); + conf->senderData = subbPtr.p->m_senderData; + + sendSignal(subbPtr.p->m_senderRef, GSN_SUB_START_CONF, + signal, SubStartConf::SignalLength2, JBB); + c_opSubEvent.release(subbPtr); + return; + } + /* + * Coordinator + */ + ndbrequire(refToBlock(senderRef) == DBDICT); +#ifdef EVENT_PH3_DEBUG + ndbout_c("DBDICT(Coordinator) got GSN_SUB_START_CONF = (%d)", subbPtr.i); +#endif + subbPtr.p->m_reqTracker.reportConf(c_counterMgr, refToNode(senderRef)); + completeSubStartReq(signal,subbPtr.i,0); +} + +/* + * Coordinator + */ +void Dbdict::completeSubStartReq(Signal* signal, + Uint32 ptrI, + Uint32 returnCode){ + jam(); + + OpSubEventPtr subbPtr; + c_opSubEvent.getPtr(subbPtr, ptrI); + + if (!subbPtr.p->m_reqTracker.done()){ + jam(); + return; + } + + if (subbPtr.p->m_reqTracker.hasRef()) { + jam(); +#ifdef EVENT_DEBUG + ndbout_c("SUB_START_REF"); +#endif + sendSignal(subbPtr.p->m_senderRef, GSN_SUB_START_REF, + signal, SubStartRef::SignalLength, JBB); + if (subbPtr.p->m_reqTracker.hasConf()) { + // stopStartedNodes(signal); + } + c_opSubEvent.release(subbPtr); + return; + } +#ifdef EVENT_DEBUG + ndbout_c("SUB_START_CONF"); +#endif + sendSignal(subbPtr.p->m_senderRef, GSN_SUB_START_CONF, + signal, SubStartConf::SignalLength, JBB); + c_opSubEvent.release(subbPtr); +} + +/******************************************************************** + * + * Stop event + * + *******************************************************************/ + +void Dbdict::execSUB_STOP_REQ(Signal* signal) +{ + jamEntry(); + + Uint32 origSenderRef = signal->senderBlockRef(); + + OpSubEventPtr subbPtr; + if (!c_opSubEvent.seize(subbPtr)) { + SubStopRef * ref = (SubStopRef *)signal->getDataPtrSend(); + jam(); + // ret->setErrorCode(SubStartRef::SeizeError); + // ret->setErrorLine(__LINE__); + // ret->setErrorNode(reference()); + ref->senderRef = reference(); + ref->setTemporary(SubStopRef::Busy); + + sendSignal(origSenderRef, GSN_SUB_STOP_REF, signal, + SubStopRef::SignalLength, JBB); + return; + } + + { + const SubStopReq* req = (SubStopReq*) signal->getDataPtr(); + subbPtr.p->m_senderRef = req->senderRef; + subbPtr.p->m_senderData = req->senderData; + subbPtr.p->m_errorCode = 0; + } + + if (refToBlock(origSenderRef) != DBDICT) { + /* + * Coordinator + */ + jam(); +#ifdef EVENT_DEBUG + ndbout_c("SUB_STOP_REQ 1"); +#endif + subbPtr.p->m_senderRef = origSenderRef; // not sure if API sets correctly + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + subbPtr.p->m_reqTracker.init(c_counterMgr, rg, GSN_SUB_STOP_REF, subbPtr.i); + + SubStopReq* req = (SubStopReq*) signal->getDataPtrSend(); + + req->senderRef = reference(); + req->senderData = subbPtr.i; + + sendSignal(rg, GSN_SUB_STOP_REQ, signal, SubStopReq::SignalLength, JBB); + return; + } + /* + * Participant + */ +#ifdef EVENT_DEBUG + ndbout_c("SUB_STOP_REQ 2"); +#endif + ndbrequire(refToBlock(origSenderRef) == DBDICT); + { + SubStopReq* req = (SubStopReq*) signal->getDataPtrSend(); + + req->senderRef = reference(); + req->senderData = subbPtr.i; + + sendSignal(SUMA_REF, GSN_SUB_STOP_REQ, signal, SubStopReq::SignalLength, JBB); + } +} + +void Dbdict::execSUB_STOP_REF(Signal* signal) +{ + jamEntry(); + const SubStopRef* ref = (SubStopRef*) signal->getDataPtr(); + Uint32 senderRef = ref->senderRef; + + OpSubEventPtr subbPtr; + c_opSubEvent.getPtr(subbPtr, ref->senderData); + + if (refToBlock(senderRef) == SUMA) { + /* + * Participant + */ + jam(); + if (ref->isTemporary()){ + jam(); + SubStopReq* req = (SubStopReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + req->senderData = subbPtr.i; + sendSignal(SUMA_REF, GSN_SUB_STOP_REQ, + signal, SubStopReq::SignalLength, JBB); + } else { + jam(); + SubStopRef* ref = (SubStopRef*) signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = subbPtr.p->m_senderData; + sendSignal(subbPtr.p->m_senderRef, GSN_SUB_STOP_REF, + signal, SubStopRef::SignalLength, JBB); + c_opSubEvent.release(subbPtr); + } + return; + } + /* + * Coordinator + */ + ndbrequire(refToBlock(senderRef) == DBDICT); + if (ref->errorCode == SubStopRef::NF_FakeErrorREF){ + jam(); + subbPtr.p->m_reqTracker.ignoreRef(c_counterMgr, refToNode(senderRef)); + } else { + jam(); + subbPtr.p->m_reqTracker.reportRef(c_counterMgr, refToNode(senderRef)); + } + completeSubStopReq(signal,subbPtr.i,0); +} + +void Dbdict::execSUB_STOP_CONF(Signal* signal) +{ + jamEntry(); + + const SubStopConf* conf = (SubStopConf*) signal->getDataPtr(); + Uint32 senderRef = conf->senderRef; + + OpSubEventPtr subbPtr; + c_opSubEvent.getPtr(subbPtr, conf->senderData); + + if (refToBlock(senderRef) == SUMA) { + /* + * Participant + */ + jam(); + SubStopConf* conf = (SubStopConf*) signal->getDataPtrSend(); + + conf->senderRef = reference(); + conf->senderData = subbPtr.p->m_senderData; + + sendSignal(subbPtr.p->m_senderRef, GSN_SUB_STOP_CONF, + signal, SubStopConf::SignalLength, JBB); + c_opSubEvent.release(subbPtr); + return; + } + /* + * Coordinator + */ + ndbrequire(refToBlock(senderRef) == DBDICT); + subbPtr.p->m_reqTracker.reportConf(c_counterMgr, refToNode(senderRef)); + completeSubStopReq(signal,subbPtr.i,0); +} + +/* + * Coordinator + */ +void Dbdict::completeSubStopReq(Signal* signal, + Uint32 ptrI, + Uint32 returnCode){ + OpSubEventPtr subbPtr; + c_opSubEvent.getPtr(subbPtr, ptrI); + + if (!subbPtr.p->m_reqTracker.done()){ + jam(); + return; + } + + if (subbPtr.p->m_reqTracker.hasRef()) { + jam(); +#ifdef EVENT_DEBUG + ndbout_c("SUB_STOP_REF"); +#endif + SubStopRef* ref = (SubStopRef*)signal->getDataPtrSend(); + + ref->senderRef = reference(); + ref->senderData = subbPtr.p->m_senderData; + /* + ref->subscriptionId = subbPtr.p->m_senderData; + ref->subscriptionKey = subbPtr.p->m_senderData; + ref->part = subbPtr.p->m_part; // SubscriptionData::Part + ref->subscriberData = subbPtr.p->m_subscriberData; + ref->subscriberRef = subbPtr.p->m_subscriberRef; + */ + ref->errorCode = subbPtr.p->m_errorCode; + + + sendSignal(subbPtr.p->m_senderRef, GSN_SUB_STOP_REF, + signal, SubStopRef::SignalLength, JBB); + if (subbPtr.p->m_reqTracker.hasConf()) { + // stopStartedNodes(signal); + } + c_opSubEvent.release(subbPtr); + return; + } +#ifdef EVENT_DEBUG + ndbout_c("SUB_STOP_CONF"); +#endif + sendSignal(subbPtr.p->m_senderRef, GSN_SUB_STOP_CONF, + signal, SubStopConf::SignalLength, JBB); + c_opSubEvent.release(subbPtr); +} + +/*************************************************************** + * MODULE: Drop event. + * + * Drop event. + * + * TODO + */ + +void +Dbdict::execDROP_EVNT_REQ(Signal* signal) +{ + jamEntry(); + EVENT_TRACE; + + DropEvntReq *req = (DropEvntReq*)signal->getDataPtr(); + const Uint32 senderRef = signal->senderBlockRef(); + OpDropEventPtr evntRecPtr; + + // Seize a Create Event record + if (!c_opDropEvent.seize(evntRecPtr)) { + // Failed to allocate event record + jam(); + releaseSections(signal); + + DropEvntRef * ret = (DropEvntRef *)signal->getDataPtrSend(); + ret->setErrorCode(DropEvntRef::SeizeError); + ret->setErrorLine(__LINE__); + ret->setErrorNode(reference()); + sendSignal(senderRef, GSN_DROP_EVNT_REF, signal, + DropEvntRef::SignalLength, JBB); + return; + } + +#ifdef EVENT_DEBUG + ndbout_c("DBDICT::execDROP_EVNT_REQ evntRecId = (%d)", evntRecPtr.i); +#endif + + OpDropEvent* evntRec = evntRecPtr.p; + evntRec->init(req); + + SegmentedSectionPtr ssPtr; + + signal->getSection(ssPtr, 0); + + SimplePropertiesSectionReader r0(ssPtr, getSectionSegmentPool()); +#ifdef EVENT_DEBUG + r0.printAll(ndbout); +#endif + // event name + if ((!r0.first()) || + (r0.getValueType() != SimpleProperties::StringValue) || + (r0.getValueLen() <= 0)) { + jam(); + releaseSections(signal); + + evntRecPtr.p->m_errorCode = DropEvntRef::Undefined; + evntRecPtr.p->m_errorLine = __LINE__; + evntRecPtr.p->m_errorNode = reference(); + + dropEvent_sendReply(signal, evntRecPtr); + return; + } + r0.getString(evntRecPtr.p->m_eventRec.NAME); + { + int len = strlen(evntRecPtr.p->m_eventRec.NAME); + memset(evntRecPtr.p->m_eventRec.NAME+len, 0, MAX_TAB_NAME_SIZE-len); +#ifdef EVENT_DEBUG + printf("DropEvntReq; EventName %s, len %u\n", + evntRecPtr.p->m_eventRec.NAME, len); + for(int i = 0; i < MAX_TAB_NAME_SIZE/4; i++) + printf("H'%.8x ", ((Uint32*)evntRecPtr.p->m_eventRec.NAME)[i]); + printf("\n"); +#endif + } + + releaseSections(signal); + + Callback c = { safe_cast(&Dbdict::dropEventUTIL_PREPARE_READ), 0 }; + + prepareTransactionEventSysTable(&c, signal, evntRecPtr.i, + UtilPrepareReq::Read); +} + +void +Dbdict::dropEventUTIL_PREPARE_READ(Signal* signal, + Uint32 callbackData, + Uint32 returnCode) +{ + jam(); + EVENT_TRACE; + if (returnCode != 0) { + EVENT_TRACE; + dropEventUtilPrepareRef(signal, callbackData, returnCode); + return; + } + + UtilPrepareConf* const req = (UtilPrepareConf*)signal->getDataPtr(); + OpDropEventPtr evntRecPtr; + evntRecPtr.i = req->getSenderData(); + const Uint32 prepareId = req->getPrepareId(); + + ndbrequire((evntRecPtr.p = c_opDropEvent.getPtr(evntRecPtr.i)) != NULL); + + Callback c = { safe_cast(&Dbdict::dropEventUTIL_EXECUTE_READ), 0 }; + + executeTransEventSysTable(&c, signal, + evntRecPtr.i, evntRecPtr.p->m_eventRec, + prepareId, UtilPrepareReq::Read); +} + +void +Dbdict::dropEventUTIL_EXECUTE_READ(Signal* signal, + Uint32 callbackData, + Uint32 returnCode) +{ + jam(); + EVENT_TRACE; + if (returnCode != 0) { + EVENT_TRACE; + dropEventUtilExecuteRef(signal, callbackData, returnCode); + return; + } + + OpDropEventPtr evntRecPtr; + UtilExecuteConf * const ref = (UtilExecuteConf *)signal->getDataPtr(); + jam(); + evntRecPtr.i = ref->getSenderData(); + ndbrequire((evntRecPtr.p = c_opDropEvent.getPtr(evntRecPtr.i)) != NULL); + + parseReadEventSys(signal, evntRecPtr.p->m_eventRec); + + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + evntRecPtr.p->m_reqTracker.init(c_counterMgr, rg, GSN_SUB_REMOVE_REF, + evntRecPtr.i); + + SubRemoveReq* req = (SubRemoveReq*) signal->getDataPtrSend(); + + req->senderRef = reference(); + req->senderData = evntRecPtr.i; + req->subscriptionId = evntRecPtr.p->m_eventRec.SUBID; + req->subscriptionKey = evntRecPtr.p->m_eventRec.SUBKEY; + + sendSignal(rg, GSN_SUB_REMOVE_REQ, signal, SubRemoveReq::SignalLength, JBB); +} + +/* + * Participant + */ + +void +Dbdict::execSUB_REMOVE_REQ(Signal* signal) +{ + jamEntry(); + + Uint32 origSenderRef = signal->senderBlockRef(); + + OpSubEventPtr subbPtr; + if (!c_opSubEvent.seize(subbPtr)) { + SubRemoveRef * ref = (SubRemoveRef *)signal->getDataPtrSend(); + jam(); + ref->senderRef = reference(); + ref->setTemporary(SubRemoveRef::Busy); + + sendSignal(origSenderRef, GSN_SUB_REMOVE_REF, signal, + SubRemoveRef::SignalLength, JBB); + return; + } + + { + const SubRemoveReq* req = (SubRemoveReq*) signal->getDataPtr(); + subbPtr.p->m_senderRef = req->senderRef; + subbPtr.p->m_senderData = req->senderData; + subbPtr.p->m_errorCode = 0; + } + + SubRemoveReq* req = (SubRemoveReq*) signal->getDataPtrSend(); + req->senderRef = reference(); + req->senderData = subbPtr.i; + + sendSignal(SUMA_REF, GSN_SUB_REMOVE_REQ, signal, SubRemoveReq::SignalLength, JBB); +} + +/* + * Coordintor/Participant + */ + +void +Dbdict::execSUB_REMOVE_REF(Signal* signal) +{ + jamEntry(); + const SubRemoveRef* ref = (SubRemoveRef*) signal->getDataPtr(); + Uint32 senderRef = ref->senderRef; + + if (refToBlock(senderRef) == SUMA) { + /* + * Participant + */ + jam(); + OpSubEventPtr subbPtr; + c_opSubEvent.getPtr(subbPtr, ref->senderData); + if (ref->errorCode == (Uint32) GrepError::SUBSCRIPTION_ID_NOT_FOUND) { + // conf this since this may occur if a nodefailiure has occured + // earlier so that the systable was not cleared + SubRemoveConf* conf = (SubRemoveConf*) signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = subbPtr.p->m_senderData; + sendSignal(subbPtr.p->m_senderRef, GSN_SUB_REMOVE_CONF, + signal, SubRemoveConf::SignalLength, JBB); + } else { + SubRemoveRef* ref = (SubRemoveRef*) signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = subbPtr.p->m_senderData; + sendSignal(subbPtr.p->m_senderRef, GSN_SUB_REMOVE_REF, + signal, SubRemoveRef::SignalLength, JBB); + } + c_opSubEvent.release(subbPtr); + return; + } + /* + * Coordinator + */ + ndbrequire(refToBlock(senderRef) == DBDICT); + OpDropEventPtr eventRecPtr; + c_opDropEvent.getPtr(eventRecPtr, ref->senderData); + if (ref->errorCode == SubRemoveRef::NF_FakeErrorREF){ + jam(); + eventRecPtr.p->m_reqTracker.ignoreRef(c_counterMgr, refToNode(senderRef)); + } else { + jam(); + eventRecPtr.p->m_reqTracker.reportRef(c_counterMgr, refToNode(senderRef)); + } + completeSubRemoveReq(signal,eventRecPtr.i,0); +} + +void +Dbdict::execSUB_REMOVE_CONF(Signal* signal) +{ + jamEntry(); + const SubRemoveConf* conf = (SubRemoveConf*) signal->getDataPtr(); + Uint32 senderRef = conf->senderRef; + + if (refToBlock(senderRef) == SUMA) { + /* + * Participant + */ + jam(); + OpSubEventPtr subbPtr; + c_opSubEvent.getPtr(subbPtr, conf->senderData); + SubRemoveConf* conf = (SubRemoveConf*) signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = subbPtr.p->m_senderData; + sendSignal(subbPtr.p->m_senderRef, GSN_SUB_REMOVE_CONF, + signal, SubRemoveConf::SignalLength, JBB); + c_opSubEvent.release(subbPtr); + return; + } + /* + * Coordinator + */ + ndbrequire(refToBlock(senderRef) == DBDICT); + OpDropEventPtr eventRecPtr; + c_opDropEvent.getPtr(eventRecPtr, conf->senderData); + eventRecPtr.p->m_reqTracker.reportConf(c_counterMgr, refToNode(senderRef)); + completeSubRemoveReq(signal,eventRecPtr.i,0); +} + +void +Dbdict::completeSubRemoveReq(Signal* signal, Uint32 ptrI, Uint32 xxx) +{ + OpDropEventPtr evntRecPtr; + c_opDropEvent.getPtr(evntRecPtr, ptrI); + + if (!evntRecPtr.p->m_reqTracker.done()){ + jam(); + return; + } + + if (evntRecPtr.p->m_reqTracker.hasRef()) { + jam(); + evntRecPtr.p->m_errorNode = reference(); + evntRecPtr.p->m_errorLine = __LINE__; + evntRecPtr.p->m_errorCode = DropEvntRef::Undefined; + dropEvent_sendReply(signal, evntRecPtr); + return; + } + + Callback c = { safe_cast(&Dbdict::dropEventUTIL_PREPARE_DELETE), 0 }; + + prepareTransactionEventSysTable(&c, signal, evntRecPtr.i, + UtilPrepareReq::Delete); +} + +void +Dbdict::dropEventUTIL_PREPARE_DELETE(Signal* signal, + Uint32 callbackData, + Uint32 returnCode) +{ + jam(); + EVENT_TRACE; + if (returnCode != 0) { + EVENT_TRACE; + dropEventUtilPrepareRef(signal, callbackData, returnCode); + return; + } + + UtilPrepareConf* const req = (UtilPrepareConf*)signal->getDataPtr(); + OpDropEventPtr evntRecPtr; + jam(); + evntRecPtr.i = req->getSenderData(); + const Uint32 prepareId = req->getPrepareId(); + + ndbrequire((evntRecPtr.p = c_opDropEvent.getPtr(evntRecPtr.i)) != NULL); +#ifdef EVENT_DEBUG + printf("DropEvntUTIL_PREPARE; evntRecPtr.i len %u\n",evntRecPtr.i); +#endif + + Callback c = { safe_cast(&Dbdict::dropEventUTIL_EXECUTE_DELETE), 0 }; + + executeTransEventSysTable(&c, signal, + evntRecPtr.i, evntRecPtr.p->m_eventRec, + prepareId, UtilPrepareReq::Delete); +} + +void +Dbdict::dropEventUTIL_EXECUTE_DELETE(Signal* signal, + Uint32 callbackData, + Uint32 returnCode) +{ + jam(); + EVENT_TRACE; + if (returnCode != 0) { + EVENT_TRACE; + dropEventUtilExecuteRef(signal, callbackData, returnCode); + return; + } + + OpDropEventPtr evntRecPtr; + UtilExecuteConf * const ref = (UtilExecuteConf *)signal->getDataPtr(); + jam(); + evntRecPtr.i = ref->getSenderData(); + ndbrequire((evntRecPtr.p = c_opDropEvent.getPtr(evntRecPtr.i)) != NULL); + + dropEvent_sendReply(signal, evntRecPtr); +} + +void +Dbdict::dropEventUtilPrepareRef(Signal* signal, + Uint32 callbackData, + Uint32 returnCode) +{ + jam(); + EVENT_TRACE; + UtilPrepareRef * const ref = (UtilPrepareRef *)signal->getDataPtr(); + OpDropEventPtr evntRecPtr; + evntRecPtr.i = ref->getSenderData(); + ndbrequire((evntRecPtr.p = c_opDropEvent.getPtr(evntRecPtr.i)) != NULL); + + bool temporary = false; + interpretUtilPrepareErrorCode((UtilPrepareRef::ErrorCode)ref->getErrorCode(), + temporary, evntRecPtr.p->m_errorLine); + if (temporary) { + evntRecPtr.p->m_errorCode = (DropEvntRef::ErrorCode) + ((Uint32) DropEvntRef::Undefined | (Uint32) DropEvntRef::Temporary); + } + + if (evntRecPtr.p->m_errorCode == 0) { + evntRecPtr.p->m_errorCode = DropEvntRef::Undefined; + evntRecPtr.p->m_errorLine = __LINE__; + } + evntRecPtr.p->m_errorNode = reference(); + + dropEvent_sendReply(signal, evntRecPtr); +} + +void +Dbdict::dropEventUtilExecuteRef(Signal* signal, + Uint32 callbackData, + Uint32 returnCode) +{ + jam(); + EVENT_TRACE; + OpDropEventPtr evntRecPtr; + UtilExecuteRef * const ref = (UtilExecuteRef *)signal->getDataPtr(); + jam(); + evntRecPtr.i = ref->getSenderData(); + ndbrequire((evntRecPtr.p = c_opDropEvent.getPtr(evntRecPtr.i)) != NULL); + + evntRecPtr.p->m_errorNode = reference(); + evntRecPtr.p->m_errorLine = __LINE__; + + switch (ref->getErrorCode()) { + case UtilExecuteRef::TCError: + switch (ref->getTCErrorCode()) { + case ZNOT_FOUND: + jam(); + evntRecPtr.p->m_errorCode = DropEvntRef::EventNotFound; + break; + default: + jam(); + evntRecPtr.p->m_errorCode = DropEvntRef::UndefinedTCError; + break; + } + break; + default: + jam(); + evntRecPtr.p->m_errorCode = DropEvntRef::Undefined; + break; + } + dropEvent_sendReply(signal, evntRecPtr); +} + +void Dbdict::dropEvent_sendReply(Signal* signal, + OpDropEventPtr evntRecPtr) +{ + jam(); + EVENT_TRACE; + Uint32 senderRef = evntRecPtr.p->m_request.getUserRef(); + + if (evntRecPtr.p->hasError()) { + jam(); + DropEvntRef * ret = (DropEvntRef *)signal->getDataPtrSend(); + + ret->setUserData(evntRecPtr.p->m_request.getUserData()); + ret->setUserRef(evntRecPtr.p->m_request.getUserRef()); + + ret->setErrorCode(evntRecPtr.p->m_errorCode); + ret->setErrorLine(evntRecPtr.p->m_errorLine); + ret->setErrorNode(evntRecPtr.p->m_errorNode); + + sendSignal(senderRef, GSN_DROP_EVNT_REF, signal, + DropEvntRef::SignalLength, JBB); + } else { + jam(); + DropEvntConf * evntConf = (DropEvntConf *)signal->getDataPtrSend(); + + evntConf->setUserData(evntRecPtr.p->m_request.getUserData()); + evntConf->setUserRef(evntRecPtr.p->m_request.getUserRef()); + + sendSignal(senderRef, GSN_DROP_EVNT_CONF, signal, + DropEvntConf::SignalLength, JBB); + } + + c_opDropEvent.release(evntRecPtr); +} + +/** + * MODULE: Alter index + * + * Alter index state. Alter online creates the index in each TC and + * then invokes create trigger and alter trigger protocols to activate + * the 3 triggers. Alter offline does the opposite. + * + * Request type received in REQ and returned in CONF/REF: + * + * RT_USER - from API to DICT master + * RT_CREATE_INDEX - part of create index operation + * RT_DROP_INDEX - part of drop index operation + * RT_NODERESTART - node restart, activate locally only + * RT_SYSTEMRESTART - system restart, activate and build if not logged + * RT_DICT_PREPARE - prepare participants + * RT_DICT_TC - to local TC via each participant + * RT_DICT_COMMIT - commit in each participant + */ + +void +Dbdict::execALTER_INDX_REQ(Signal* signal) +{ + jamEntry(); + AlterIndxReq* const req = (AlterIndxReq*)signal->getDataPtrSend(); + OpAlterIndexPtr opPtr; + const Uint32 senderRef = signal->senderBlockRef(); + const AlterIndxReq::RequestType requestType = req->getRequestType(); + if (requestType == AlterIndxReq::RT_USER || + requestType == AlterIndxReq::RT_CREATE_INDEX || + requestType == AlterIndxReq::RT_DROP_INDEX || + requestType == AlterIndxReq::RT_NODERESTART || + requestType == AlterIndxReq::RT_SYSTEMRESTART) { + jam(); + const bool isLocal = req->getRequestFlag() & RequestFlag::RF_LOCAL; + NdbNodeBitmask receiverNodes = c_aliveNodes; + if (isLocal) { + receiverNodes.clear(); + receiverNodes.set(getOwnNodeId()); + } + if (signal->getLength() == AlterIndxReq::SignalLength) { + jam(); + if (! isLocal && getOwnNodeId() != c_masterNodeId) { + jam(); + // forward to DICT master + sendSignal(calcDictBlockRef(c_masterNodeId), GSN_ALTER_INDX_REQ, + signal, signal->getLength(), JBB); + return; + } + // forward initial request plus operation key to all + req->setOpKey(++c_opRecordSequence); + NodeReceiverGroup rg(DBDICT, receiverNodes); + sendSignal(rg, GSN_ALTER_INDX_REQ, + signal, AlterIndxReq::SignalLength + 1, JBB); + return; + } + // seize operation record + ndbrequire(signal->getLength() == AlterIndxReq::SignalLength + 1); + const Uint32 opKey = req->getOpKey(); + OpAlterIndex opBusy; + if (! c_opAlterIndex.seize(opPtr)) + opPtr.p = &opBusy; + opPtr.p->save(req); + opPtr.p->m_coordinatorRef = senderRef; + opPtr.p->m_isMaster = (senderRef == reference()); + opPtr.p->key = opKey; + opPtr.p->m_requestType = AlterIndxReq::RT_DICT_PREPARE; + if (opPtr.p == &opBusy) { + jam(); + opPtr.p->m_errorCode = AlterIndxRef::Busy; + opPtr.p->m_errorLine = __LINE__; + alterIndex_sendReply(signal, opPtr, opPtr.p->m_isMaster); + return; + } + c_opAlterIndex.add(opPtr); + // master expects to hear from all + if (opPtr.p->m_isMaster) + opPtr.p->m_signalCounter = receiverNodes; + // check request in all participants + alterIndex_slavePrepare(signal, opPtr); + alterIndex_sendReply(signal, opPtr, false); + return; + } + c_opAlterIndex.find(opPtr, req->getConnectionPtr()); + if (! opPtr.isNull()) { + opPtr.p->m_requestType = requestType; + if (requestType == AlterIndxReq::RT_DICT_TC) { + jam(); + if (opPtr.p->m_request.getOnline()) + alterIndex_toCreateTc(signal, opPtr); + else + alterIndex_toDropTc(signal, opPtr); + return; + } + if (requestType == AlterIndxReq::RT_DICT_COMMIT || + requestType == AlterIndxReq::RT_DICT_ABORT) { + jam(); + if (requestType == AlterIndxReq::RT_DICT_COMMIT) + alterIndex_slaveCommit(signal, opPtr); + else + alterIndex_slaveAbort(signal, opPtr); + alterIndex_sendReply(signal, opPtr, false); + // done in slave + if (! opPtr.p->m_isMaster) + c_opAlterIndex.release(opPtr); + return; + } + } + jam(); + // return to sender + OpAlterIndex opBad; + opPtr.p = &opBad; + opPtr.p->save(req); + opPtr.p->m_errorCode = AlterIndxRef::BadRequestType; + opPtr.p->m_errorLine = __LINE__; + alterIndex_sendReply(signal, opPtr, true); +} + +void +Dbdict::execALTER_INDX_CONF(Signal* signal) +{ + jamEntry(); + ndbrequire(signal->getNoOfSections() == 0); + AlterIndxConf* conf = (AlterIndxConf*)signal->getDataPtrSend(); + alterIndex_recvReply(signal, conf, 0); +} + +void +Dbdict::execALTER_INDX_REF(Signal* signal) +{ + jamEntry(); + AlterIndxRef* ref = (AlterIndxRef*)signal->getDataPtrSend(); + alterIndex_recvReply(signal, ref->getConf(), ref); +} + +void +Dbdict::alterIndex_recvReply(Signal* signal, const AlterIndxConf* conf, + const AlterIndxRef* ref) +{ + jam(); + const Uint32 senderRef = signal->senderBlockRef(); + const AlterIndxReq::RequestType requestType = conf->getRequestType(); + const Uint32 key = conf->getConnectionPtr(); + if (requestType == AlterIndxReq::RT_CREATE_INDEX) { + jam(); + // part of create index operation + OpCreateIndexPtr opPtr; + c_opCreateIndex.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + createIndex_fromAlterIndex(signal, opPtr); + return; + } + if (requestType == AlterIndxReq::RT_DROP_INDEX) { + jam(); + // part of drop index operation + OpDropIndexPtr opPtr; + c_opDropIndex.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + dropIndex_fromAlterIndex(signal, opPtr); + return; + } + if (requestType == AlterIndxReq::RT_TC || + requestType == AlterIndxReq::RT_TUX) { + jam(); + // part of build index operation + OpBuildIndexPtr opPtr; + c_opBuildIndex.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + buildIndex_fromOnline(signal, opPtr); + return; + } + if (requestType == AlterIndxReq::RT_NODERESTART) { + jam(); + if (ref == 0) { + infoEvent("DICT: index %u activated", (unsigned)key); + } else { + warningEvent("DICT: index %u activation failed: code=%d line=%d", + (unsigned)key, + ref->getErrorCode(), ref->getErrorLine()); + } + activateIndexes(signal, key + 1); + return; + } + if (requestType == AlterIndxReq::RT_SYSTEMRESTART) { + jam(); + if (ref == 0) { + infoEvent("DICT: index %u activated done", (unsigned)key); + } else { + warningEvent("DICT: index %u activated failed: code=%d line=%d node=%d", + (unsigned)key, + ref->getErrorCode(), ref->getErrorLine(), ref->getErrorNode()); + } + activateIndexes(signal, key + 1); + return; + } + OpAlterIndexPtr opPtr; + c_opAlterIndex.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + ndbrequire(opPtr.p->m_isMaster); + ndbrequire(opPtr.p->m_requestType == requestType); + opPtr.p->setError(ref); + opPtr.p->m_signalCounter.clearWaitingFor(refToNode(senderRef)); + if (! opPtr.p->m_signalCounter.done()) { + jam(); + return; + } + if (requestType == AlterIndxReq::RT_DICT_COMMIT || + requestType == AlterIndxReq::RT_DICT_ABORT) { + jam(); + // send reply to user + alterIndex_sendReply(signal, opPtr, true); + c_opAlterIndex.release(opPtr); + return; + } + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = AlterIndxReq::RT_DICT_ABORT; + alterIndex_sendSlaveReq(signal, opPtr); + return; + } + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId()); + if (indexPtr.p->isHashIndex()) { + if (requestType == AlterIndxReq::RT_DICT_PREPARE) { + jam(); + if (opPtr.p->m_request.getOnline()) { + opPtr.p->m_requestType = AlterIndxReq::RT_DICT_TC; + alterIndex_sendSlaveReq(signal, opPtr); + } else { + // start drop triggers + alterIndex_toDropTrigger(signal, opPtr); + } + return; + } + if (requestType == AlterIndxReq::RT_DICT_TC) { + jam(); + if (opPtr.p->m_request.getOnline()) { + // start create triggers + alterIndex_toCreateTrigger(signal, opPtr); + } else { + opPtr.p->m_requestType = AlterIndxReq::RT_DICT_COMMIT; + alterIndex_sendSlaveReq(signal, opPtr); + } + return; + } + } + if (indexPtr.p->isOrderedIndex()) { + if (requestType == AlterIndxReq::RT_DICT_PREPARE) { + jam(); + if (opPtr.p->m_request.getOnline()) { + // start create triggers + alterIndex_toCreateTrigger(signal, opPtr); + } else { + // start drop triggers + alterIndex_toDropTrigger(signal, opPtr); + } + return; + } + } + ndbrequire(false); +} + +void +Dbdict::alterIndex_slavePrepare(Signal* signal, OpAlterIndexPtr opPtr) +{ + jam(); + const AlterIndxReq* const req = &opPtr.p->m_request; + if (! (req->getIndexId() < c_tableRecordPool.getSize())) { + jam(); + opPtr.p->m_errorCode = AlterIndxRef::Inconsistency; + opPtr.p->m_errorLine = __LINE__; + return; + } + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, req->getIndexId()); + if (indexPtr.p->tabState != TableRecord::DEFINED) { + jam(); + opPtr.p->m_errorCode = AlterIndxRef::IndexNotFound; + opPtr.p->m_errorLine = __LINE__; + return; + } + if (! indexPtr.p->isIndex()) { + jam(); + opPtr.p->m_errorCode = AlterIndxRef::NotAnIndex; + opPtr.p->m_errorLine = __LINE__; + return; + } + if (req->getOnline()) + indexPtr.p->indexState = TableRecord::IS_BUILDING; + else + indexPtr.p->indexState = TableRecord::IS_DROPPING; +} + +void +Dbdict::alterIndex_toCreateTc(Signal* signal, OpAlterIndexPtr opPtr) +{ + jam(); + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId()); + // request to create index in local TC + CreateIndxReq* const req = (CreateIndxReq*)signal->getDataPtrSend(); + req->setUserRef(reference()); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(CreateIndxReq::RT_TC); + req->setIndexType(indexPtr.p->tableType); + req->setTableId(indexPtr.p->primaryTableId); + req->setIndexId(indexPtr.i); + req->setOnline(true); + getIndexAttrList(indexPtr, opPtr.p->m_attrList); + // send + LinearSectionPtr lsPtr[3]; + lsPtr[0].p = (Uint32*)&opPtr.p->m_attrList; + lsPtr[0].sz = 1 + opPtr.p->m_attrList.sz; + sendSignal(calcTcBlockRef(getOwnNodeId()), GSN_CREATE_INDX_REQ, + signal, CreateIndxReq::SignalLength, JBB, lsPtr, 1); +} + +void +Dbdict::alterIndex_fromCreateTc(Signal* signal, OpAlterIndexPtr opPtr) +{ + jam(); + // mark created in local TC + if (! opPtr.p->hasError()) { + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId()); + indexPtr.p->indexLocal |= TableRecord::IL_CREATED_TC; + } + // forward CONF or REF to master + ndbrequire(opPtr.p->m_requestType == AlterIndxReq::RT_DICT_TC); + alterIndex_sendReply(signal, opPtr, false); +} + +void +Dbdict::alterIndex_toDropTc(Signal* signal, OpAlterIndexPtr opPtr) +{ + jam(); + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId()); + // broken index + if (! (indexPtr.p->indexLocal & TableRecord::IL_CREATED_TC)) { + jam(); + alterIndex_sendReply(signal, opPtr, false); + return; + } + // request to drop in local TC + DropIndxReq* const req = (DropIndxReq*)signal->getDataPtrSend(); + req->setUserRef(reference()); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(DropIndxReq::RT_TC); + req->setTableId(indexPtr.p->primaryTableId); + req->setIndexId(indexPtr.i); + req->setIndexVersion(indexPtr.p->tableVersion); + // send + sendSignal(calcTcBlockRef(getOwnNodeId()), GSN_DROP_INDX_REQ, + signal, DropIndxReq::SignalLength, JBB); +} + +void +Dbdict::alterIndex_fromDropTc(Signal* signal, OpAlterIndexPtr opPtr) +{ + jam(); + ndbrequire(opPtr.p->m_requestType == AlterIndxReq::RT_DICT_TC); + if (! opPtr.p->hasError()) { + // mark dropped in local TC + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId()); + indexPtr.p->indexLocal &= ~TableRecord::IL_CREATED_TC; + } + // forward CONF or REF to master + alterIndex_sendReply(signal, opPtr, false); +} + +void +Dbdict::alterIndex_toCreateTrigger(Signal* signal, OpAlterIndexPtr opPtr) +{ + jam(); + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId()); + // start creation of index triggers + CreateTrigReq* const req = (CreateTrigReq*)signal->getDataPtrSend(); + req->setUserRef(reference()); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(CreateTrigReq::RT_ALTER_INDEX); + req->addRequestFlag(opPtr.p->m_requestFlag); + req->setTableId(opPtr.p->m_request.getTableId()); + req->setIndexId(opPtr.p->m_request.getIndexId()); + req->setTriggerId(RNIL); + req->setTriggerActionTime(TriggerActionTime::TA_AFTER); + req->setMonitorAllAttributes(false); + req->setOnline(true); // alter online after create + req->setReceiverRef(0); // implicit for index triggers + getIndexAttrMask(indexPtr, req->getAttributeMask()); + // name section + char triggerName[MAX_TAB_NAME_SIZE]; + Uint32 buffer[2 + ((MAX_TAB_NAME_SIZE + 3) >> 2)]; // SP string + LinearWriter w(buffer, sizeof(buffer) >> 2); + LinearSectionPtr lsPtr[3]; + if (indexPtr.p->isHashIndex()) { + req->setTriggerType(TriggerType::SECONDARY_INDEX); + req->setMonitorReplicas(false); + // insert + if (opPtr.p->m_requestFlag & RequestFlag::RF_LOCAL) + req->setTriggerId(indexPtr.p->insertTriggerId); + req->setTriggerEvent(TriggerEvent::TE_INSERT); + sprintf(triggerName, "NDB$INDEX_%u_INSERT", opPtr.p->m_request.getIndexId()); + w.reset(); + w.add(CreateTrigReq::TriggerNameKey, triggerName); + lsPtr[0].p = buffer; + lsPtr[0].sz = w.getWordsUsed(); + sendSignal(reference(), GSN_CREATE_TRIG_REQ, + signal, CreateTrigReq::SignalLength, JBB, lsPtr, 1); + // update + if (opPtr.p->m_requestFlag & RequestFlag::RF_LOCAL) + req->setTriggerId(indexPtr.p->updateTriggerId); + req->setTriggerEvent(TriggerEvent::TE_UPDATE); + sprintf(triggerName, "NDB$INDEX_%u_UPDATE", opPtr.p->m_request.getIndexId()); + w.reset(); + w.add(CreateTrigReq::TriggerNameKey, triggerName); + lsPtr[0].p = buffer; + lsPtr[0].sz = w.getWordsUsed(); + sendSignal(reference(), GSN_CREATE_TRIG_REQ, + signal, CreateTrigReq::SignalLength, JBB, lsPtr, 1); + // delete + if (opPtr.p->m_requestFlag & RequestFlag::RF_LOCAL) + req->setTriggerId(indexPtr.p->deleteTriggerId); + req->setTriggerEvent(TriggerEvent::TE_DELETE); + sprintf(triggerName, "NDB$INDEX_%u_DELETE", opPtr.p->m_request.getIndexId()); + w.reset(); + w.add(CreateTrigReq::TriggerNameKey, triggerName); + lsPtr[0].p = buffer; + lsPtr[0].sz = w.getWordsUsed(); + sendSignal(reference(), GSN_CREATE_TRIG_REQ, + signal, CreateTrigReq::SignalLength, JBB, lsPtr, 1); + // triggers left to create + opPtr.p->m_triggerCounter = 3; + return; + } + if (indexPtr.p->isOrderedIndex()) { + req->addRequestFlag(RequestFlag::RF_NOTCTRIGGER); + req->setTriggerType(TriggerType::ORDERED_INDEX); + req->setTriggerActionTime(TriggerActionTime::TA_CUSTOM); + req->setMonitorReplicas(true); + // one trigger for 5 events (insert, update, delete, commit, abort) + if (opPtr.p->m_requestFlag & RequestFlag::RF_LOCAL) + req->setTriggerId(indexPtr.p->customTriggerId); + req->setTriggerEvent(TriggerEvent::TE_CUSTOM); + sprintf(triggerName, "NDB$INDEX_%u_CUSTOM", opPtr.p->m_request.getIndexId()); + w.reset(); + w.add(CreateTrigReq::TriggerNameKey, triggerName); + lsPtr[0].p = buffer; + lsPtr[0].sz = w.getWordsUsed(); + sendSignal(reference(), GSN_CREATE_TRIG_REQ, + signal, CreateTrigReq::SignalLength, JBB, lsPtr, 1); + // triggers left to create + opPtr.p->m_triggerCounter = 1; + return; + } + ndbrequire(false); +} + +void +Dbdict::alterIndex_fromCreateTrigger(Signal* signal, OpAlterIndexPtr opPtr) +{ + jam(); + ndbrequire(opPtr.p->m_triggerCounter != 0); + if (--opPtr.p->m_triggerCounter != 0) { + jam(); + return; + } + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = AlterIndxReq::RT_DICT_ABORT; + alterIndex_sendSlaveReq(signal, opPtr); + return; + } + if(opPtr.p->m_requestType != AlterIndxReq::RT_SYSTEMRESTART){ + // send build request + alterIndex_toBuildIndex(signal, opPtr); + return; + } + + /** + * During system restart, + * leave index in activated but not build state. + * + * Build a bit later when REDO has been run + */ + alterIndex_sendReply(signal, opPtr, true); +} + +void +Dbdict::alterIndex_toDropTrigger(Signal* signal, OpAlterIndexPtr opPtr) +{ + jam(); + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId()); + // start drop of index triggers + DropTrigReq* const req = (DropTrigReq*)signal->getDataPtrSend(); + req->setUserRef(reference()); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(DropTrigReq::RT_ALTER_INDEX); + req->setTableId(opPtr.p->m_request.getTableId()); + req->setIndexId(opPtr.p->m_request.getIndexId()); + req->setTriggerInfo(0); // not used + opPtr.p->m_triggerCounter = 0; + // insert + if (indexPtr.p->insertTriggerId != RNIL) { + req->setTriggerId(indexPtr.p->insertTriggerId); + sendSignal(reference(), GSN_DROP_TRIG_REQ, + signal, DropTrigReq::SignalLength, JBB); + opPtr.p->m_triggerCounter++; + } + // update + if (indexPtr.p->updateTriggerId != RNIL) { + req->setTriggerId(indexPtr.p->updateTriggerId); + sendSignal(reference(), GSN_DROP_TRIG_REQ, + signal, DropTrigReq::SignalLength, JBB); + opPtr.p->m_triggerCounter++; + } + // delete + if (indexPtr.p->deleteTriggerId != RNIL) { + req->setTriggerId(indexPtr.p->deleteTriggerId); + sendSignal(reference(), GSN_DROP_TRIG_REQ, + signal, DropTrigReq::SignalLength, JBB); + opPtr.p->m_triggerCounter++; + } + // custom + if (indexPtr.p->customTriggerId != RNIL) { + req->setTriggerId(indexPtr.p->customTriggerId); + sendSignal(reference(), GSN_DROP_TRIG_REQ, + signal, DropTrigReq::SignalLength, JBB); + opPtr.p->m_triggerCounter++; + } + // build + if (indexPtr.p->buildTriggerId != RNIL) { + req->setTriggerId(indexPtr.p->buildTriggerId); + sendSignal(reference(), GSN_DROP_TRIG_REQ, + signal, DropTrigReq::SignalLength, JBB); + opPtr.p->m_triggerCounter++; + } + if (opPtr.p->m_triggerCounter == 0) { + // drop in each TC + jam(); + opPtr.p->m_requestType = AlterIndxReq::RT_DICT_TC; + alterIndex_sendSlaveReq(signal, opPtr); + } +} + +void +Dbdict::alterIndex_fromDropTrigger(Signal* signal, OpAlterIndexPtr opPtr) +{ + jam(); + ndbrequire(opPtr.p->m_triggerCounter != 0); + if (--opPtr.p->m_triggerCounter != 0) { + jam(); + return; + } + // finally drop index in each TC + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId()); + const bool isHashIndex = indexPtr.p->isHashIndex(); + const bool isOrderedIndex = indexPtr.p->isOrderedIndex(); + ndbrequire(isHashIndex != isOrderedIndex); // xor + if (isHashIndex) + opPtr.p->m_requestType = AlterIndxReq::RT_DICT_TC; + if (isOrderedIndex) + opPtr.p->m_requestType = AlterIndxReq::RT_DICT_COMMIT; + alterIndex_sendSlaveReq(signal, opPtr); +} + +void +Dbdict::alterIndex_toBuildIndex(Signal* signal, OpAlterIndexPtr opPtr) +{ + jam(); + // get index and table records + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId()); + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, indexPtr.p->primaryTableId); + // build request to self (short signal) + BuildIndxReq* const req = (BuildIndxReq*)signal->getDataPtrSend(); + req->setUserRef(reference()); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(BuildIndxReq::RT_ALTER_INDEX); + req->addRequestFlag(opPtr.p->m_requestFlag); + req->setBuildId(0); // not used + req->setBuildKey(0); // not used + req->setIndexType(indexPtr.p->tableType); + req->setIndexId(indexPtr.i); + req->setTableId(indexPtr.p->primaryTableId); + req->setParallelism(16); + // send + sendSignal(reference(), GSN_BUILDINDXREQ, + signal, BuildIndxReq::SignalLength, JBB); +} + +void +Dbdict::alterIndex_fromBuildIndex(Signal* signal, OpAlterIndexPtr opPtr) +{ + jam(); + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = AlterIndxReq::RT_DICT_ABORT; + alterIndex_sendSlaveReq(signal, opPtr); + return; + } + opPtr.p->m_requestType = AlterIndxReq::RT_DICT_COMMIT; + alterIndex_sendSlaveReq(signal, opPtr); +} + +void +Dbdict::alterIndex_slaveCommit(Signal* signal, OpAlterIndexPtr opPtr) +{ + jam(); + // get index record + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId()); + indexPtr.p->indexState = TableRecord::IS_ONLINE; +} + +void +Dbdict::alterIndex_slaveAbort(Signal* signal, OpAlterIndexPtr opPtr) +{ + jam(); + // find index record + const Uint32 indexId = opPtr.p->m_request.getIndexId(); + if (indexId >= c_tableRecordPool.getSize()) + return; + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, indexId); + if (! indexPtr.p->isIndex()) + return; + // mark broken + indexPtr.p->indexState = TableRecord::IS_BROKEN; +} + +void +Dbdict::alterIndex_sendSlaveReq(Signal* signal, OpAlterIndexPtr opPtr) +{ + AlterIndxReq* const req = (AlterIndxReq*)signal->getDataPtrSend(); + *req = opPtr.p->m_request; + req->setUserRef(opPtr.p->m_coordinatorRef); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(opPtr.p->m_requestType); + req->addRequestFlag(opPtr.p->m_requestFlag); + NdbNodeBitmask receiverNodes = c_aliveNodes; + if (opPtr.p->m_requestFlag & RequestFlag::RF_LOCAL) { + receiverNodes.clear(); + receiverNodes.set(getOwnNodeId()); + } + opPtr.p->m_signalCounter = receiverNodes; + NodeReceiverGroup rg(DBDICT, receiverNodes); + sendSignal(rg, GSN_ALTER_INDX_REQ, + signal, AlterIndxReq::SignalLength, JBB); +} + +void +Dbdict::alterIndex_sendReply(Signal* signal, OpAlterIndexPtr opPtr, + bool toUser) +{ + AlterIndxRef* rep = (AlterIndxRef*)signal->getDataPtrSend(); + Uint32 gsn = GSN_ALTER_INDX_CONF; + Uint32 length = AlterIndxConf::InternalLength; + bool sendRef = opPtr.p->hasError(); + if (! toUser) { + rep->setUserRef(opPtr.p->m_coordinatorRef); + rep->setConnectionPtr(opPtr.p->key); + rep->setRequestType(opPtr.p->m_requestType); + if (opPtr.p->m_requestType == AlterIndxReq::RT_DICT_ABORT) + sendRef = false; + } else { + rep->setUserRef(opPtr.p->m_request.getUserRef()); + rep->setConnectionPtr(opPtr.p->m_request.getConnectionPtr()); + rep->setRequestType(opPtr.p->m_request.getRequestType()); + length = AlterIndxConf::SignalLength; + } + rep->setTableId(opPtr.p->m_request.getTableId()); + rep->setIndexId(opPtr.p->m_request.getIndexId()); + if (sendRef) { + if (opPtr.p->m_errorNode == 0) + opPtr.p->m_errorNode = getOwnNodeId(); + rep->setErrorCode(opPtr.p->m_errorCode); + rep->setErrorLine(opPtr.p->m_errorLine); + rep->setErrorNode(opPtr.p->m_errorNode); + gsn = GSN_ALTER_INDX_REF; + length = AlterIndxRef::SignalLength; + } + sendSignal(rep->getUserRef(), gsn, signal, length, JBB); +} + +/** + * MODULE: Build index + * + * Build index or all indexes on a table. Request type: + * + * RT_USER - normal user request, not yet used + * RT_ALTER_INDEX - from alter index + * RT_SYSTEM_RESTART - + * RT_DICT_PREPARE - prepare participants + * RT_DICT_TRIX - to participant on way to local TRIX + * RT_DICT_COMMIT - commit in each participant + * RT_DICT_ABORT - abort + * RT_TRIX - to local TRIX + */ + +void +Dbdict::execBUILDINDXREQ(Signal* signal) +{ + jamEntry(); + BuildIndxReq* const req = (BuildIndxReq*)signal->getDataPtrSend(); + OpBuildIndexPtr opPtr; + const Uint32 senderRef = signal->senderBlockRef(); + const BuildIndxReq::RequestType requestType = req->getRequestType(); + if (requestType == BuildIndxReq::RT_USER || + requestType == BuildIndxReq::RT_ALTER_INDEX || + requestType == BuildIndxReq::RT_SYSTEMRESTART) { + jam(); + if (signal->getLength() == BuildIndxReq::SignalLength) { + jam(); + if (getOwnNodeId() != c_masterNodeId) { + jam(); + // forward to DICT master + sendSignal(calcDictBlockRef(c_masterNodeId), GSN_BUILDINDXREQ, + signal, signal->getLength(), JBB); + return; + } + // forward initial request plus operation key to all + req->setOpKey(++c_opRecordSequence); + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + sendSignal(rg, GSN_BUILDINDXREQ, + signal, BuildIndxReq::SignalLength + 1, JBB); + return; + } + // seize operation record + ndbrequire(signal->getLength() == BuildIndxReq::SignalLength + 1); + const Uint32 opKey = req->getOpKey(); + OpBuildIndex opBusy; + if (! c_opBuildIndex.seize(opPtr)) + opPtr.p = &opBusy; + opPtr.p->save(req); + opPtr.p->m_coordinatorRef = senderRef; + opPtr.p->m_isMaster = (senderRef == reference()); + opPtr.p->key = opKey; + opPtr.p->m_requestType = BuildIndxReq::RT_DICT_PREPARE; + if (opPtr.p == &opBusy) { + jam(); + opPtr.p->m_errorCode = BuildIndxRef::Busy; + opPtr.p->m_errorLine = __LINE__; + buildIndex_sendReply(signal, opPtr, opPtr.p->m_isMaster); + return; + } + c_opBuildIndex.add(opPtr); + // master expects to hear from all + opPtr.p->m_signalCounter = c_aliveNodes; + buildIndex_sendReply(signal, opPtr, false); + return; + } + c_opBuildIndex.find(opPtr, req->getConnectionPtr()); + if (! opPtr.isNull()) { + opPtr.p->m_requestType = requestType; + if (requestType == BuildIndxReq::RT_DICT_TRIX) { + jam(); + buildIndex_buildTrix(signal, opPtr); + return; + } + if (requestType == BuildIndxReq::RT_DICT_TC || + requestType == BuildIndxReq::RT_DICT_TUX) { + jam(); + buildIndex_toOnline(signal, opPtr); + return; + } + if (requestType == BuildIndxReq::RT_DICT_COMMIT || + requestType == BuildIndxReq::RT_DICT_ABORT) { + jam(); + buildIndex_sendReply(signal, opPtr, false); + // done in slave + if (! opPtr.p->m_isMaster) + c_opBuildIndex.release(opPtr); + return; + } + } + jam(); + // return to sender + OpBuildIndex opBad; + opPtr.p = &opBad; + opPtr.p->save(req); + opPtr.p->m_errorCode = BuildIndxRef::BadRequestType; + opPtr.p->m_errorLine = __LINE__; + buildIndex_sendReply(signal, opPtr, true); +} + +void +Dbdict::execBUILDINDXCONF(Signal* signal) +{ + jamEntry(); + ndbrequire(signal->getNoOfSections() == 0); + BuildIndxConf* conf = (BuildIndxConf*)signal->getDataPtrSend(); + buildIndex_recvReply(signal, conf, 0); +} + +void +Dbdict::execBUILDINDXREF(Signal* signal) +{ + jamEntry(); + BuildIndxRef* ref = (BuildIndxRef*)signal->getDataPtrSend(); + buildIndex_recvReply(signal, ref->getConf(), ref); +} + +void +Dbdict::buildIndex_recvReply(Signal* signal, const BuildIndxConf* conf, + const BuildIndxRef* ref) +{ + jam(); + const Uint32 senderRef = signal->senderBlockRef(); + const BuildIndxReq::RequestType requestType = conf->getRequestType(); + const Uint32 key = conf->getConnectionPtr(); + if (requestType == BuildIndxReq::RT_ALTER_INDEX) { + jam(); + // part of alter index operation + OpAlterIndexPtr opPtr; + c_opAlterIndex.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + alterIndex_fromBuildIndex(signal, opPtr); + return; + } + + if (requestType == BuildIndxReq::RT_SYSTEMRESTART) { + jam(); + if (ref == 0) { + infoEvent("DICT: index %u rebuild done", (unsigned)key); + } else { + warningEvent("DICT: index %u rebuild failed: code=%d line=%d node=%d", + (unsigned)key, ref->getErrorCode()); + } + rebuildIndexes(signal, key + 1); + return; + } + + OpBuildIndexPtr opPtr; + c_opBuildIndex.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + if (requestType == BuildIndxReq::RT_TRIX) { + jam(); + // forward to master + opPtr.p->m_requestType = BuildIndxReq::RT_DICT_TRIX; + buildIndex_sendReply(signal, opPtr, false); + return; + } + ndbrequire(opPtr.p->m_isMaster); + ndbrequire(opPtr.p->m_requestType == requestType); + opPtr.p->m_signalCounter.clearWaitingFor(refToNode(senderRef)); + if (! opPtr.p->m_signalCounter.done()) { + jam(); + return; + } + if (requestType == BuildIndxReq::RT_DICT_COMMIT || + requestType == BuildIndxReq::RT_DICT_ABORT) { + jam(); + // send reply to user + buildIndex_sendReply(signal, opPtr, true); + c_opBuildIndex.release(opPtr); + return; + } + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = BuildIndxReq::RT_DICT_ABORT; + buildIndex_sendSlaveReq(signal, opPtr); + return; + } + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId()); + if (indexPtr.p->isHashIndex()) { + if (requestType == BuildIndxReq::RT_DICT_PREPARE) { + jam(); + if (! (opPtr.p->m_requestFlag & RequestFlag::RF_NOBUILD)) { + buildIndex_toCreateConstr(signal, opPtr); + } else { + opPtr.p->m_requestType = BuildIndxReq::RT_DICT_TC; + buildIndex_sendSlaveReq(signal, opPtr); + } + return; + } + if (requestType == BuildIndxReq::RT_DICT_TRIX) { + jam(); + ndbrequire(! (opPtr.p->m_requestFlag & RequestFlag::RF_NOBUILD)); + buildIndex_toDropConstr(signal, opPtr); + return; + } + if (requestType == BuildIndxReq::RT_DICT_TC) { + jam(); + opPtr.p->m_requestType = BuildIndxReq::RT_DICT_COMMIT; + buildIndex_sendSlaveReq(signal, opPtr); + return; + } + } + if (indexPtr.p->isOrderedIndex()) { + if (requestType == BuildIndxReq::RT_DICT_PREPARE) { + jam(); + if (! (opPtr.p->m_requestFlag & RequestFlag::RF_NOBUILD)) { + opPtr.p->m_requestType = BuildIndxReq::RT_DICT_TRIX; + buildIndex_sendSlaveReq(signal, opPtr); + } else { + opPtr.p->m_requestType = BuildIndxReq::RT_DICT_TUX; + buildIndex_sendSlaveReq(signal, opPtr); + } + return; + } + if (requestType == BuildIndxReq::RT_DICT_TRIX) { + jam(); + ndbrequire(! (opPtr.p->m_requestFlag & RequestFlag::RF_NOBUILD)); + opPtr.p->m_requestType = BuildIndxReq::RT_DICT_TUX; + buildIndex_sendSlaveReq(signal, opPtr); + return; + } + if (requestType == BuildIndxReq::RT_DICT_TUX) { + jam(); + opPtr.p->m_requestType = BuildIndxReq::RT_DICT_COMMIT; + buildIndex_sendSlaveReq(signal, opPtr); + return; + } + } + ndbrequire(false); +} + +void +Dbdict::buildIndex_toCreateConstr(Signal* signal, OpBuildIndexPtr opPtr) +{ + jam(); + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId()); + // request to create constraint trigger + CreateTrigReq* req = (CreateTrigReq*)signal->getDataPtrSend(); + req->setUserRef(reference()); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(CreateTrigReq::RT_BUILD_INDEX); + req->addRequestFlag(0); // none + req->setTableId(indexPtr.i); + req->setIndexId(RNIL); + req->setTriggerId(RNIL); + req->setTriggerType(TriggerType::READ_ONLY_CONSTRAINT); + req->setTriggerActionTime(TriggerActionTime::TA_AFTER); + req->setTriggerEvent(TriggerEvent::TE_UPDATE); + req->setMonitorReplicas(false); + req->setMonitorAllAttributes(false); + req->setOnline(true); // alter online after create + req->setReceiverRef(0); // no receiver, REF-ed by TUP + req->getAttributeMask().clear(); + // NDB$PK is last attribute + req->getAttributeMask().set(indexPtr.p->noOfAttributes - 1); + // name section + char triggerName[MAX_TAB_NAME_SIZE]; + Uint32 buffer[2 + ((MAX_TAB_NAME_SIZE + 3) >> 2)]; // SP string + LinearWriter w(buffer, sizeof(buffer) >> 2); + LinearSectionPtr lsPtr[3]; + sprintf(triggerName, "NDB$INDEX_%u_BUILD", indexPtr.i); + w.reset(); + w.add(CreateTrigReq::TriggerNameKey, triggerName); + lsPtr[0].p = buffer; + lsPtr[0].sz = w.getWordsUsed(); + sendSignal(reference(), GSN_CREATE_TRIG_REQ, + signal, CreateTrigReq::SignalLength, JBB, lsPtr, 1); +} + +void +Dbdict::buildIndex_fromCreateConstr(Signal* signal, OpBuildIndexPtr opPtr) +{ + jam(); + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = BuildIndxReq::RT_DICT_ABORT; + buildIndex_sendSlaveReq(signal, opPtr); + return; + } + opPtr.p->m_requestType = BuildIndxReq::RT_DICT_TRIX; + buildIndex_sendSlaveReq(signal, opPtr); +} + +void +Dbdict::buildIndex_buildTrix(Signal* signal, OpBuildIndexPtr opPtr) +{ + jam(); + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId()); + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, indexPtr.p->primaryTableId); + // build request + BuildIndxReq* const req = (BuildIndxReq*)signal->getDataPtrSend(); + req->setUserRef(reference()); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(BuildIndxReq::RT_TRIX); + req->setBuildId(0); // not yet.. + req->setBuildKey(0); // ..in use + req->setIndexType(indexPtr.p->tableType); + req->setIndexId(indexPtr.i); + req->setTableId(indexPtr.p->primaryTableId); + req->setParallelism(16); + if (indexPtr.p->isHashIndex()) { + jam(); + getIndexAttrList(indexPtr, opPtr.p->m_attrList); + getTableKeyList(tablePtr, opPtr.p->m_tableKeyList); + // send + LinearSectionPtr lsPtr[3]; + lsPtr[0].sz = opPtr.p->m_attrList.sz; + lsPtr[0].p = opPtr.p->m_attrList.id; + lsPtr[1].sz = opPtr.p->m_tableKeyList.sz; + lsPtr[1].p = opPtr.p->m_tableKeyList.id; + sendSignal(calcTrixBlockRef(getOwnNodeId()), GSN_BUILDINDXREQ, + signal, BuildIndxReq::SignalLength, JBB, lsPtr, 2); + return; + } + if (indexPtr.p->isOrderedIndex()) { + jam(); + sendSignal(calcTupBlockRef(getOwnNodeId()), GSN_BUILDINDXREQ, + signal, BuildIndxReq::SignalLength, JBB); + return; + } + ndbrequire(false); +} + +void +Dbdict::buildIndex_toDropConstr(Signal* signal, OpBuildIndexPtr opPtr) +{ + jam(); + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId()); + // request to drop constraint trigger + DropTrigReq* req = (DropTrigReq*)signal->getDataPtrSend(); + req->setUserRef(reference()); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(DropTrigReq::RT_BUILD_INDEX); + req->addRequestFlag(0); // none + req->setTableId(indexPtr.i); + req->setIndexId(RNIL); + req->setTriggerId(opPtr.p->m_constrTriggerId); + req->setTriggerInfo(0); // not used + sendSignal(reference(), GSN_DROP_TRIG_REQ, + signal, DropTrigReq::SignalLength, JBB); +} + +void +Dbdict::buildIndex_fromDropConstr(Signal* signal, OpBuildIndexPtr opPtr) +{ + jam(); + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = BuildIndxReq::RT_DICT_ABORT; + buildIndex_sendSlaveReq(signal, opPtr); + return; + } + opPtr.p->m_requestType = BuildIndxReq::RT_DICT_TC; + buildIndex_sendSlaveReq(signal, opPtr); +} + +void +Dbdict::buildIndex_toOnline(Signal* signal, OpBuildIndexPtr opPtr) +{ + jam(); + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId()); + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, indexPtr.p->primaryTableId); + // request to set index online in TC or TUX + AlterIndxReq* const req = (AlterIndxReq*)signal->getDataPtrSend(); + req->setUserRef(reference()); + req->setConnectionPtr(opPtr.p->key); + if (opPtr.p->m_requestType == BuildIndxReq::RT_DICT_TC) { + req->setRequestType(AlterIndxReq::RT_TC); + } else if (opPtr.p->m_requestType == BuildIndxReq::RT_DICT_TUX) { + req->setRequestType(AlterIndxReq::RT_TUX); + } else { + ndbrequire(false); + } + req->setTableId(tablePtr.i); + req->setIndexId(indexPtr.i); + req->setIndexVersion(indexPtr.p->tableVersion); + req->setOnline(true); + BlockReference blockRef = 0; + if (opPtr.p->m_requestType == BuildIndxReq::RT_DICT_TC) { + blockRef = calcTcBlockRef(getOwnNodeId()); + } else if (opPtr.p->m_requestType == BuildIndxReq::RT_DICT_TUX) { + blockRef = calcTuxBlockRef(getOwnNodeId()); + } else { + ndbrequire(false); + } + // send + sendSignal(blockRef, GSN_ALTER_INDX_REQ, + signal, BuildIndxReq::SignalLength, JBB); +} + +void +Dbdict::buildIndex_fromOnline(Signal* signal, OpBuildIndexPtr opPtr) +{ + jam(); + // forward to master + buildIndex_sendReply(signal, opPtr, false); +} + +void +Dbdict::buildIndex_sendSlaveReq(Signal* signal, OpBuildIndexPtr opPtr) +{ + BuildIndxReq* const req = (BuildIndxReq*)signal->getDataPtrSend(); + *req = opPtr.p->m_request; + req->setUserRef(opPtr.p->m_coordinatorRef); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(opPtr.p->m_requestType); + req->addRequestFlag(opPtr.p->m_requestFlag); + opPtr.p->m_signalCounter = c_aliveNodes; + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + sendSignal(rg, GSN_BUILDINDXREQ, + signal, BuildIndxReq::SignalLength, JBB); +} + +void +Dbdict::buildIndex_sendReply(Signal* signal, OpBuildIndexPtr opPtr, + bool toUser) +{ + BuildIndxRef* rep = (BuildIndxRef*)signal->getDataPtrSend(); + Uint32 gsn = GSN_BUILDINDXCONF; + Uint32 length = BuildIndxConf::InternalLength; + bool sendRef = opPtr.p->hasError(); + if (! toUser) { + rep->setUserRef(opPtr.p->m_coordinatorRef); + rep->setConnectionPtr(opPtr.p->key); + rep->setRequestType(opPtr.p->m_requestType); + if (opPtr.p->m_requestType == BuildIndxReq::RT_DICT_ABORT) + sendRef = false; + } else { + rep->setUserRef(opPtr.p->m_request.getUserRef()); + rep->setConnectionPtr(opPtr.p->m_request.getConnectionPtr()); + rep->setRequestType(opPtr.p->m_request.getRequestType()); + length = BuildIndxConf::SignalLength; + } + rep->setIndexType(opPtr.p->m_request.getIndexType()); + rep->setTableId(opPtr.p->m_request.getTableId()); + rep->setIndexId(opPtr.p->m_request.getIndexId()); + if (sendRef) { + rep->setErrorCode(opPtr.p->m_errorCode); + gsn = GSN_BUILDINDXREF; + length = BuildIndxRef::SignalLength; + } + sendSignal(rep->getUserRef(), gsn, signal, length, JBB); +} + +/** + * MODULE: Create trigger + * + * Create trigger in all DICT blocks. Optionally start alter trigger + * operation to set the trigger online. + * + * Request type received in REQ and returned in CONF/REF: + * + * RT_USER - normal user e.g. BACKUP + * RT_ALTER_INDEX - from alter index online + * RT_DICT_PREPARE - seize operation in each DICT + * RT_DICT_COMMIT - commit create in each DICT + * RT_TC - sending to TC (operation alter trigger) + * RT_LQH - sending to LQH (operation alter trigger) + */ + +void +Dbdict::execCREATE_TRIG_REQ(Signal* signal) +{ + jamEntry(); + CreateTrigReq* const req = (CreateTrigReq*)signal->getDataPtrSend(); + OpCreateTriggerPtr opPtr; + const Uint32 senderRef = signal->senderBlockRef(); + const CreateTrigReq::RequestType requestType = req->getRequestType(); + if (requestType == CreateTrigReq::RT_USER || + requestType == CreateTrigReq::RT_ALTER_INDEX || + requestType == CreateTrigReq::RT_BUILD_INDEX) { + jam(); + if (! assembleFragments(signal)) { + jam(); + return; + } + const bool isLocal = req->getRequestFlag() & RequestFlag::RF_LOCAL; + NdbNodeBitmask receiverNodes = c_aliveNodes; + if (isLocal) { + receiverNodes.clear(); + receiverNodes.set(getOwnNodeId()); + } + if (signal->getLength() == CreateTrigReq::SignalLength) { + jam(); + if (! isLocal && getOwnNodeId() != c_masterNodeId) { + jam(); + // forward to DICT master + sendSignal(calcDictBlockRef(c_masterNodeId), GSN_CREATE_TRIG_REQ, + signal, signal->getLength(), JBB); + return; + } + // forward initial request plus operation key to all + req->setOpKey(++c_opRecordSequence); + NodeReceiverGroup rg(DBDICT, receiverNodes); + sendSignal(rg, GSN_CREATE_TRIG_REQ, + signal, CreateTrigReq::SignalLength + 1, JBB); + return; + } + // seize operation record + ndbrequire(signal->getLength() == CreateTrigReq::SignalLength + 1); + const Uint32 opKey = req->getOpKey(); + OpCreateTrigger opBusy; + if (! c_opCreateTrigger.seize(opPtr)) + opPtr.p = &opBusy; + opPtr.p->save(req); + opPtr.p->m_coordinatorRef = senderRef; + opPtr.p->m_isMaster = (senderRef == reference()); + opPtr.p->key = opKey; + opPtr.p->m_requestType = CreateTrigReq::RT_DICT_PREPARE; + if (opPtr.p == &opBusy) { + jam(); + opPtr.p->m_errorCode = CreateTrigRef::Busy; + opPtr.p->m_errorLine = __LINE__; + releaseSections(signal); + createTrigger_sendReply(signal, opPtr, opPtr.p->m_isMaster); + return; + } + c_opCreateTrigger.add(opPtr); + { + // save name + SegmentedSectionPtr ssPtr; + signal->getSection(ssPtr, CreateTrigReq::TRIGGER_NAME_SECTION); + SimplePropertiesSectionReader ssReader(ssPtr, getSectionSegmentPool()); + if (ssReader.getKey() != CreateTrigReq::TriggerNameKey || + ! ssReader.getString(opPtr.p->m_triggerName)) { + jam(); + opPtr.p->m_errorCode = CreateTrigRef::InvalidName; + opPtr.p->m_errorLine = __LINE__; + releaseSections(signal); + createTrigger_sendReply(signal, opPtr, opPtr.p->m_isMaster); + return; + } + } + releaseSections(signal); + { + // check that trigger name is unique + TriggerRecordPtr triggerPtr; + TriggerRecord keyRecord; + strcpy(keyRecord.triggerName, opPtr.p->m_triggerName); + c_triggerRecordHash.find(triggerPtr, keyRecord); + if (triggerPtr.i != RNIL) { + jam(); + opPtr.p->m_errorCode = CreateTrigRef::TriggerExists; + opPtr.p->m_errorLine = __LINE__; + createTrigger_sendReply(signal, opPtr, opPtr.p->m_isMaster); + return; + } + } + + // master expects to hear from all + if (opPtr.p->m_isMaster) + opPtr.p->m_signalCounter = receiverNodes; + // check request in all participants + createTrigger_slavePrepare(signal, opPtr); + createTrigger_sendReply(signal, opPtr, false); + return; + } + c_opCreateTrigger.find(opPtr, req->getConnectionPtr()); + if (! opPtr.isNull()) { + opPtr.p->m_requestType = requestType; + if (requestType == CreateTrigReq::RT_DICT_CREATE) { + jam(); + // master has set trigger id + opPtr.p->m_request.setTriggerId(req->getTriggerId()); + createTrigger_slaveCreate(signal, opPtr); + createTrigger_sendReply(signal, opPtr, false); + return; + } + if (requestType == CreateTrigReq::RT_DICT_COMMIT || + requestType == CreateTrigReq::RT_DICT_ABORT) { + jam(); + if (requestType == CreateTrigReq::RT_DICT_COMMIT) + createTrigger_slaveCommit(signal, opPtr); + else + createTrigger_slaveAbort(signal, opPtr); + createTrigger_sendReply(signal, opPtr, false); + // done in slave + if (! opPtr.p->m_isMaster) + c_opCreateTrigger.release(opPtr); + return; + } + } + jam(); + // return to sender + releaseSections(signal); + OpCreateTrigger opBad; + opPtr.p = &opBad; + opPtr.p->save(req); + opPtr.p->m_errorCode = CreateTrigRef::BadRequestType; + opPtr.p->m_errorLine = __LINE__; + createTrigger_sendReply(signal, opPtr, true); +} + +void +Dbdict::execCREATE_TRIG_CONF(Signal* signal) +{ + jamEntry(); + ndbrequire(signal->getNoOfSections() == 0); + CreateTrigConf* conf = (CreateTrigConf*)signal->getDataPtrSend(); + createTrigger_recvReply(signal, conf, 0); +} + +void +Dbdict::execCREATE_TRIG_REF(Signal* signal) +{ + jamEntry(); + CreateTrigRef* ref = (CreateTrigRef*)signal->getDataPtrSend(); + createTrigger_recvReply(signal, ref->getConf(), ref); +} + +void +Dbdict::createTrigger_recvReply(Signal* signal, const CreateTrigConf* conf, + const CreateTrigRef* ref) +{ + jam(); + const Uint32 senderRef = signal->senderBlockRef(); + const CreateTrigReq::RequestType requestType = conf->getRequestType(); + const Uint32 key = conf->getConnectionPtr(); + if (requestType == CreateTrigReq::RT_ALTER_INDEX) { + jam(); + // part of alter index operation + OpAlterIndexPtr opPtr; + c_opAlterIndex.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + alterIndex_fromCreateTrigger(signal, opPtr); + return; + } + if (requestType == CreateTrigReq::RT_BUILD_INDEX) { + jam(); + // part of build index operation + OpBuildIndexPtr opPtr; + c_opBuildIndex.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + // fill in trigger id + opPtr.p->m_constrTriggerId = conf->getTriggerId(); + buildIndex_fromCreateConstr(signal, opPtr); + return; + } + if (requestType == CreateTrigReq::RT_TC || + requestType == CreateTrigReq::RT_LQH) { + jam(); + // part of alter trigger operation + OpAlterTriggerPtr opPtr; + c_opAlterTrigger.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + alterTrigger_fromCreateLocal(signal, opPtr); + return; + } + OpCreateTriggerPtr opPtr; + c_opCreateTrigger.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + ndbrequire(opPtr.p->m_isMaster); + ndbrequire(opPtr.p->m_requestType == requestType); + opPtr.p->setError(ref); + opPtr.p->m_signalCounter.clearWaitingFor(refToNode(senderRef)); + if (! opPtr.p->m_signalCounter.done()) { + jam(); + return; + } + if (requestType == CreateTrigReq::RT_DICT_COMMIT || + requestType == CreateTrigReq::RT_DICT_ABORT) { + jam(); + // send reply to user + createTrigger_sendReply(signal, opPtr, true); + c_opCreateTrigger.release(opPtr); + return; + } + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = CreateTrigReq::RT_DICT_ABORT; + createTrigger_sendSlaveReq(signal, opPtr); + return; + } + if (requestType == CreateTrigReq::RT_DICT_PREPARE) { + jam(); + // seize trigger id in master + createTrigger_masterSeize(signal, opPtr); + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = CreateTrigReq::RT_DICT_ABORT; + createTrigger_sendSlaveReq(signal, opPtr); + return; + } + opPtr.p->m_requestType = CreateTrigReq::RT_DICT_CREATE; + createTrigger_sendSlaveReq(signal, opPtr); + return; + } + if (requestType == CreateTrigReq::RT_DICT_CREATE) { + jam(); + if (opPtr.p->m_request.getOnline()) { + jam(); + // start alter online + createTrigger_toAlterTrigger(signal, opPtr); + return; + } + opPtr.p->m_requestType = CreateTrigReq::RT_DICT_COMMIT; + createTrigger_sendSlaveReq(signal, opPtr); + return; + } + ndbrequire(false); +} + +void +Dbdict::createTrigger_slavePrepare(Signal* signal, OpCreateTriggerPtr opPtr) +{ + jam(); + const CreateTrigReq* const req = &opPtr.p->m_request; + // check trigger type + if (req->getRequestType() == CreateTrigReq::RT_USER && + req->getTriggerType() == TriggerType::SUBSCRIPTION || + req->getRequestType() == CreateTrigReq::RT_ALTER_INDEX && + req->getTriggerType() == TriggerType::SECONDARY_INDEX || + req->getRequestType() == CreateTrigReq::RT_ALTER_INDEX && + req->getTriggerType() == TriggerType::ORDERED_INDEX || + req->getRequestType() == CreateTrigReq::RT_BUILD_INDEX && + req->getTriggerType() == TriggerType::READ_ONLY_CONSTRAINT) { + ; + } else { + jam(); + opPtr.p->m_errorCode = CreateTrigRef::UnsupportedTriggerType; + opPtr.p->m_errorLine = __LINE__; + return; + } + // check the table + const Uint32 tableId = req->getTableId(); + if (! (tableId < c_tableRecordPool.getSize())) { + jam(); + opPtr.p->m_errorCode = CreateTrigRef::InvalidTable; + opPtr.p->m_errorLine = __LINE__; + return; + } + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, tableId); + if (tablePtr.p->tabState != TableRecord::DEFINED) { + jam(); + opPtr.p->m_errorCode = CreateTrigRef::InvalidTable; + opPtr.p->m_errorLine = __LINE__; + return; + } +} + +void +Dbdict::createTrigger_masterSeize(Signal* signal, OpCreateTriggerPtr opPtr) +{ + TriggerRecordPtr triggerPtr; + if (opPtr.p->m_requestFlag & RequestFlag::RF_LOCAL) { + triggerPtr.i = opPtr.p->m_request.getTriggerId(); + } else { + triggerPtr.i = getFreeTriggerRecord(); + if (triggerPtr.i == RNIL) { + jam(); + opPtr.p->m_errorCode = CreateTrigRef::TooManyTriggers; + opPtr.p->m_errorLine = __LINE__; + return; + } + } + c_triggerRecordPool.getPtr(triggerPtr); + initialiseTriggerRecord(triggerPtr); + triggerPtr.p->triggerState = TriggerRecord::TS_DEFINING; + opPtr.p->m_request.setTriggerId(triggerPtr.i); +} + +void +Dbdict::createTrigger_slaveCreate(Signal* signal, OpCreateTriggerPtr opPtr) +{ + jam(); + const CreateTrigReq* const req = &opPtr.p->m_request; + // get the trigger record + const Uint32 triggerId = req->getTriggerId(); + TriggerRecordPtr triggerPtr; + c_triggerRecordPool.getPtr(triggerPtr, triggerId); + initialiseTriggerRecord(triggerPtr); + // fill in trigger data + strcpy(triggerPtr.p->triggerName, opPtr.p->m_triggerName); + triggerPtr.p->triggerId = triggerId; + triggerPtr.p->tableId = req->getTableId(); + triggerPtr.p->indexId = RNIL; + triggerPtr.p->triggerType = req->getTriggerType(); + triggerPtr.p->triggerActionTime = req->getTriggerActionTime(); + triggerPtr.p->triggerEvent = req->getTriggerEvent(); + triggerPtr.p->monitorReplicas = req->getMonitorReplicas(); + triggerPtr.p->monitorAllAttributes = req->getMonitorAllAttributes(); + triggerPtr.p->attributeMask = req->getAttributeMask(); + triggerPtr.p->triggerState = TriggerRecord::TS_OFFLINE; + // add to hash table + // ndbout_c("++++++++++++ Adding trigger id %u, %s", triggerPtr.p->triggerId, triggerPtr.p->triggerName); + c_triggerRecordHash.add(triggerPtr); + if (triggerPtr.p->triggerType == TriggerType::SECONDARY_INDEX || + triggerPtr.p->triggerType == TriggerType::ORDERED_INDEX) { + jam(); + // connect to index record XXX should be done in caller instead + triggerPtr.p->indexId = req->getIndexId(); + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, triggerPtr.p->indexId); + switch (triggerPtr.p->triggerEvent) { + case TriggerEvent::TE_INSERT: + indexPtr.p->insertTriggerId = triggerPtr.p->triggerId; + break; + case TriggerEvent::TE_UPDATE: + indexPtr.p->updateTriggerId = triggerPtr.p->triggerId; + break; + case TriggerEvent::TE_DELETE: + indexPtr.p->deleteTriggerId = triggerPtr.p->triggerId; + break; + case TriggerEvent::TE_CUSTOM: + indexPtr.p->customTriggerId = triggerPtr.p->triggerId; + break; + default: + ndbrequire(false); + break; + } + } + if (triggerPtr.p->triggerType == TriggerType::READ_ONLY_CONSTRAINT) { + jam(); + // connect to index record XXX should be done in caller instead + triggerPtr.p->indexId = req->getTableId(); + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, triggerPtr.p->indexId); + indexPtr.p->buildTriggerId = triggerPtr.p->triggerId; + } +} + +void +Dbdict::createTrigger_toAlterTrigger(Signal* signal, OpCreateTriggerPtr opPtr) +{ + jam(); + AlterTrigReq* req = (AlterTrigReq*)signal->getDataPtrSend(); + req->setUserRef(reference()); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(AlterTrigReq::RT_CREATE_TRIGGER); + req->addRequestFlag(opPtr.p->m_requestFlag); + req->setTableId(opPtr.p->m_request.getTableId()); + req->setTriggerId(opPtr.p->m_request.getTriggerId()); + req->setTriggerInfo(0); // not used + req->setOnline(true); + req->setReceiverRef(opPtr.p->m_request.getReceiverRef()); + sendSignal(reference(), GSN_ALTER_TRIG_REQ, + signal, AlterTrigReq::SignalLength, JBB); +} + +void +Dbdict::createTrigger_fromAlterTrigger(Signal* signal, OpCreateTriggerPtr opPtr) +{ + jam(); + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = CreateTrigReq::RT_DICT_ABORT; + createTrigger_sendSlaveReq(signal, opPtr); + return; + } + opPtr.p->m_requestType = CreateTrigReq::RT_DICT_COMMIT; + createTrigger_sendSlaveReq(signal, opPtr); +} + +void +Dbdict::createTrigger_slaveCommit(Signal* signal, OpCreateTriggerPtr opPtr) +{ + jam(); + const CreateTrigReq* const req = &opPtr.p->m_request; + // get the trigger record + const Uint32 triggerId = req->getTriggerId(); + TriggerRecordPtr triggerPtr; + c_triggerRecordPool.getPtr(triggerPtr, triggerId); + if (! req->getOnline()) { + triggerPtr.p->triggerState = TriggerRecord::TS_OFFLINE; + } else { + ndbrequire(triggerPtr.p->triggerState == TriggerRecord::TS_ONLINE); + } +} + +void +Dbdict::createTrigger_slaveAbort(Signal* signal, OpCreateTriggerPtr opPtr) +{ + jam(); +} + +void +Dbdict::createTrigger_sendSlaveReq(Signal* signal, OpCreateTriggerPtr opPtr) +{ + CreateTrigReq* const req = (CreateTrigReq*)signal->getDataPtrSend(); + *req = opPtr.p->m_request; + req->setUserRef(opPtr.p->m_coordinatorRef); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(opPtr.p->m_requestType); + req->addRequestFlag(opPtr.p->m_requestFlag); + NdbNodeBitmask receiverNodes = c_aliveNodes; + if (opPtr.p->m_requestFlag & RequestFlag::RF_LOCAL) { + receiverNodes.clear(); + receiverNodes.set(getOwnNodeId()); + } + opPtr.p->m_signalCounter = receiverNodes; + NodeReceiverGroup rg(DBDICT, receiverNodes); + sendSignal(rg, GSN_CREATE_TRIG_REQ, + signal, CreateTrigReq::SignalLength, JBB); +} + +void +Dbdict::createTrigger_sendReply(Signal* signal, OpCreateTriggerPtr opPtr, + bool toUser) +{ + CreateTrigRef* rep = (CreateTrigRef*)signal->getDataPtrSend(); + Uint32 gsn = GSN_CREATE_TRIG_CONF; + Uint32 length = CreateTrigConf::InternalLength; + bool sendRef = opPtr.p->hasError(); + if (! toUser) { + rep->setUserRef(opPtr.p->m_coordinatorRef); + rep->setConnectionPtr(opPtr.p->key); + rep->setRequestType(opPtr.p->m_requestType); + if (opPtr.p->m_requestType == CreateTrigReq::RT_DICT_ABORT) + sendRef = false; + } else { + rep->setUserRef(opPtr.p->m_request.getUserRef()); + rep->setConnectionPtr(opPtr.p->m_request.getConnectionPtr()); + rep->setRequestType(opPtr.p->m_request.getRequestType()); + length = CreateTrigConf::SignalLength; + } + rep->setTableId(opPtr.p->m_request.getTableId()); + rep->setIndexId(opPtr.p->m_request.getIndexId()); + rep->setTriggerId(opPtr.p->m_request.getTriggerId()); + rep->setTriggerInfo(opPtr.p->m_request.getTriggerInfo()); + if (sendRef) { + if (opPtr.p->m_errorNode == 0) + opPtr.p->m_errorNode = getOwnNodeId(); + rep->setErrorCode(opPtr.p->m_errorCode); + rep->setErrorLine(opPtr.p->m_errorLine); + rep->setErrorNode(opPtr.p->m_errorNode); + gsn = GSN_CREATE_TRIG_REF; + length = CreateTrigRef::SignalLength; + } + sendSignal(rep->getUserRef(), gsn, signal, length, JBB); +} + +/** + * MODULE: Drop trigger. + */ + +void +Dbdict::execDROP_TRIG_REQ(Signal* signal) +{ + jamEntry(); + DropTrigReq* const req = (DropTrigReq*)signal->getDataPtrSend(); + OpDropTriggerPtr opPtr; + const Uint32 senderRef = signal->senderBlockRef(); + const DropTrigReq::RequestType requestType = req->getRequestType(); + + if (signal->getNoOfSections() > 0) { + ndbrequire(signal->getNoOfSections() == 1); + jam(); + TriggerRecord keyRecord; + OpDropTrigger opTmp; + opPtr.p=&opTmp; + + SegmentedSectionPtr ssPtr; + signal->getSection(ssPtr, DropTrigReq::TRIGGER_NAME_SECTION); + SimplePropertiesSectionReader ssReader(ssPtr, getSectionSegmentPool()); + if (ssReader.getKey() != DropTrigReq::TriggerNameKey || + ! ssReader.getString(keyRecord.triggerName)) { + jam(); + opPtr.p->m_errorCode = DropTrigRef::InvalidName; + opPtr.p->m_errorLine = __LINE__; + releaseSections(signal); + dropTrigger_sendReply(signal, opPtr, opPtr.p->m_isMaster); + return; + } + releaseSections(signal); + + TriggerRecordPtr triggerPtr; + + // ndbout_c("++++++++++++++ Looking for trigger %s", keyRecord.triggerName); + c_triggerRecordHash.find(triggerPtr, keyRecord); + if (triggerPtr.i == RNIL) { + jam(); + req->setTriggerId(RNIL); + } else { + jam(); + // ndbout_c("++++++++++ Found trigger %s", triggerPtr.p->triggerName); + req->setTriggerId(triggerPtr.p->triggerId); + req->setTableId(triggerPtr.p->tableId); + } + } + if (requestType == DropTrigReq::RT_USER || + requestType == DropTrigReq::RT_ALTER_INDEX || + requestType == DropTrigReq::RT_BUILD_INDEX) { + jam(); + if (signal->getLength() == DropTrigReq::SignalLength) { + if (getOwnNodeId() != c_masterNodeId) { + jam(); + // forward to DICT master + sendSignal(calcDictBlockRef(c_masterNodeId), GSN_DROP_TRIG_REQ, + signal, signal->getLength(), JBB); + return; + } + if (!c_triggerRecordPool.findId(req->getTriggerId())) { + jam(); + // return to sender + OpDropTrigger opBad; + opPtr.p = &opBad; + opPtr.p->save(req); + opPtr.p->m_errorCode = DropTrigRef::TriggerNotFound; + opPtr.p->m_errorLine = __LINE__; + dropTrigger_sendReply(signal, opPtr, true); + return; + } + // forward initial request plus operation key to all + req->setOpKey(++c_opRecordSequence); + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + sendSignal(rg, GSN_DROP_TRIG_REQ, + signal, DropTrigReq::SignalLength + 1, JBB); + return; + } + // seize operation record + ndbrequire(signal->getLength() == DropTrigReq::SignalLength + 1); + const Uint32 opKey = req->getOpKey(); + OpDropTrigger opBusy; + if (! c_opDropTrigger.seize(opPtr)) + opPtr.p = &opBusy; + opPtr.p->save(req); + opPtr.p->m_coordinatorRef = senderRef; + opPtr.p->m_isMaster = (senderRef == reference()); + opPtr.p->key = opKey; + opPtr.p->m_requestType = DropTrigReq::RT_DICT_PREPARE; + if (opPtr.p == &opBusy) { + jam(); + opPtr.p->m_errorCode = DropTrigRef::Busy; + opPtr.p->m_errorLine = __LINE__; + dropTrigger_sendReply(signal, opPtr, opPtr.p->m_isMaster); + return; + } + c_opDropTrigger.add(opPtr); + // master expects to hear from all + if (opPtr.p->m_isMaster) + opPtr.p->m_signalCounter = c_aliveNodes; + dropTrigger_slavePrepare(signal, opPtr); + dropTrigger_sendReply(signal, opPtr, false); + return; + } + c_opDropTrigger.find(opPtr, req->getConnectionPtr()); + if (! opPtr.isNull()) { + opPtr.p->m_requestType = requestType; + if (requestType == DropTrigReq::RT_DICT_COMMIT || + requestType == DropTrigReq::RT_DICT_ABORT) { + jam(); + if (requestType == DropTrigReq::RT_DICT_COMMIT) + dropTrigger_slaveCommit(signal, opPtr); + else + dropTrigger_slaveAbort(signal, opPtr); + dropTrigger_sendReply(signal, opPtr, false); + // done in slave + if (! opPtr.p->m_isMaster) + c_opDropTrigger.release(opPtr); + return; + } + } + jam(); + // return to sender + OpDropTrigger opBad; + opPtr.p = &opBad; + opPtr.p->save(req); + opPtr.p->m_errorCode = DropTrigRef::BadRequestType; + opPtr.p->m_errorLine = __LINE__; + dropTrigger_sendReply(signal, opPtr, true); +} + +void +Dbdict::execDROP_TRIG_CONF(Signal* signal) +{ + jamEntry(); + DropTrigConf* conf = (DropTrigConf*)signal->getDataPtrSend(); + dropTrigger_recvReply(signal, conf, 0); +} + +void +Dbdict::execDROP_TRIG_REF(Signal* signal) +{ + jamEntry(); + DropTrigRef* ref = (DropTrigRef*)signal->getDataPtrSend(); + dropTrigger_recvReply(signal, ref->getConf(), ref); +} + +void +Dbdict::dropTrigger_recvReply(Signal* signal, const DropTrigConf* conf, + const DropTrigRef* ref) +{ + jam(); + const Uint32 senderRef = signal->senderBlockRef(); + const DropTrigReq::RequestType requestType = conf->getRequestType(); + const Uint32 key = conf->getConnectionPtr(); + if (requestType == DropTrigReq::RT_ALTER_INDEX) { + jam(); + // part of alter index operation + OpAlterIndexPtr opPtr; + c_opAlterIndex.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + alterIndex_fromDropTrigger(signal, opPtr); + return; + } + if (requestType == DropTrigReq::RT_BUILD_INDEX) { + jam(); + // part of build index operation + OpBuildIndexPtr opPtr; + c_opBuildIndex.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + buildIndex_fromDropConstr(signal, opPtr); + return; + } + if (requestType == DropTrigReq::RT_TC || + requestType == DropTrigReq::RT_LQH) { + jam(); + // part of alter trigger operation + OpAlterTriggerPtr opPtr; + c_opAlterTrigger.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + alterTrigger_fromDropLocal(signal, opPtr); + return; + } + OpDropTriggerPtr opPtr; + c_opDropTrigger.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + ndbrequire(opPtr.p->m_isMaster); + ndbrequire(opPtr.p->m_requestType == requestType); + opPtr.p->setError(ref); + opPtr.p->m_signalCounter.clearWaitingFor(refToNode(senderRef)); + if (! opPtr.p->m_signalCounter.done()) { + jam(); + return; + } + if (requestType == DropTrigReq::RT_DICT_COMMIT || + requestType == DropTrigReq::RT_DICT_ABORT) { + jam(); + // send reply to user + dropTrigger_sendReply(signal, opPtr, true); + c_opDropTrigger.release(opPtr); + return; + } + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = DropTrigReq::RT_DICT_ABORT; + dropTrigger_sendSlaveReq(signal, opPtr); + return; + } + if (requestType == DropTrigReq::RT_DICT_PREPARE) { + jam(); + // start alter offline + dropTrigger_toAlterTrigger(signal, opPtr); + return; + } + ndbrequire(false); +} + +void +Dbdict::dropTrigger_slavePrepare(Signal* signal, OpDropTriggerPtr opPtr) +{ + jam(); +} + +void +Dbdict::dropTrigger_toAlterTrigger(Signal* signal, OpDropTriggerPtr opPtr) +{ + jam(); + AlterTrigReq* req = (AlterTrigReq*)signal->getDataPtrSend(); + req->setUserRef(reference()); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(AlterTrigReq::RT_DROP_TRIGGER); + req->setTableId(opPtr.p->m_request.getTableId()); + req->setTriggerId(opPtr.p->m_request.getTriggerId()); + req->setTriggerInfo(0); // not used + req->setOnline(false); + req->setReceiverRef(0); + sendSignal(reference(), GSN_ALTER_TRIG_REQ, + signal, AlterTrigReq::SignalLength, JBB); +} + +void +Dbdict::dropTrigger_fromAlterTrigger(Signal* signal, OpDropTriggerPtr opPtr) +{ + jam(); + // remove in all + opPtr.p->m_requestType = DropTrigReq::RT_DICT_COMMIT; + dropTrigger_sendSlaveReq(signal, opPtr); +} + +void +Dbdict::dropTrigger_sendSlaveReq(Signal* signal, OpDropTriggerPtr opPtr) +{ + DropTrigReq* const req = (DropTrigReq*)signal->getDataPtrSend(); + *req = opPtr.p->m_request; + req->setUserRef(opPtr.p->m_coordinatorRef); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(opPtr.p->m_requestType); + req->addRequestFlag(opPtr.p->m_requestFlag); + opPtr.p->m_signalCounter = c_aliveNodes; + NodeReceiverGroup rg(DBDICT, c_aliveNodes); + sendSignal(rg, GSN_DROP_TRIG_REQ, + signal, DropTrigReq::SignalLength, JBB); +} + +void +Dbdict::dropTrigger_slaveCommit(Signal* signal, OpDropTriggerPtr opPtr) +{ + jam(); + const DropTrigReq* const req = &opPtr.p->m_request; + // get trigger record + const Uint32 triggerId = req->getTriggerId(); + TriggerRecordPtr triggerPtr; + c_triggerRecordPool.getPtr(triggerPtr, triggerId); + if (triggerPtr.p->triggerType == TriggerType::SECONDARY_INDEX || + triggerPtr.p->triggerType == TriggerType::ORDERED_INDEX) { + jam(); + // disconnect from index if index trigger XXX move to drop index + triggerPtr.p->indexId = req->getIndexId(); + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, triggerPtr.p->indexId); + ndbrequire(! indexPtr.isNull()); + switch (triggerPtr.p->triggerEvent) { + case TriggerEvent::TE_INSERT: + indexPtr.p->insertTriggerId = RNIL; + break; + case TriggerEvent::TE_UPDATE: + indexPtr.p->updateTriggerId = RNIL; + break; + case TriggerEvent::TE_DELETE: + indexPtr.p->deleteTriggerId = RNIL; + break; + case TriggerEvent::TE_CUSTOM: + indexPtr.p->customTriggerId = RNIL; + break; + default: + ndbrequire(false); + break; + } + } + if (triggerPtr.p->triggerType == TriggerType::READ_ONLY_CONSTRAINT) { + jam(); + // disconnect from index record XXX should be done in caller instead + triggerPtr.p->indexId = req->getTableId(); + TableRecordPtr indexPtr; + c_tableRecordPool.getPtr(indexPtr, triggerPtr.p->indexId); + indexPtr.p->buildTriggerId = RNIL; + } + // remove trigger + // ndbout_c("++++++++++++ Removing trigger id %u, %s", triggerPtr.p->triggerId, triggerPtr.p->triggerName); + c_triggerRecordHash.remove(triggerPtr); + triggerPtr.p->triggerState = TriggerRecord::TS_NOT_DEFINED; +} + +void +Dbdict::dropTrigger_slaveAbort(Signal* signal, OpDropTriggerPtr opPtr) +{ + jam(); +} + +void +Dbdict::dropTrigger_sendReply(Signal* signal, OpDropTriggerPtr opPtr, + bool toUser) +{ + DropTrigRef* rep = (DropTrigRef*)signal->getDataPtrSend(); + Uint32 gsn = GSN_DROP_TRIG_CONF; + Uint32 length = DropTrigConf::InternalLength; + bool sendRef = opPtr.p->hasError(); + if (! toUser) { + rep->setUserRef(opPtr.p->m_coordinatorRef); + rep->setConnectionPtr(opPtr.p->key); + rep->setRequestType(opPtr.p->m_requestType); + if (opPtr.p->m_requestType == DropTrigReq::RT_DICT_ABORT) + sendRef = false; + } else { + rep->setUserRef(opPtr.p->m_request.getUserRef()); + rep->setConnectionPtr(opPtr.p->m_request.getConnectionPtr()); + rep->setRequestType(opPtr.p->m_request.getRequestType()); + length = DropTrigConf::SignalLength; + } + rep->setTableId(opPtr.p->m_request.getTableId()); + rep->setIndexId(opPtr.p->m_request.getIndexId()); + rep->setTriggerId(opPtr.p->m_request.getTriggerId()); + if (sendRef) { + if (opPtr.p->m_errorNode == 0) + opPtr.p->m_errorNode = getOwnNodeId(); + rep->setErrorCode(opPtr.p->m_errorCode); + rep->setErrorLine(opPtr.p->m_errorLine); + rep->setErrorNode(opPtr.p->m_errorNode); + gsn = GSN_DROP_TRIG_REF; + length = CreateTrigRef::SignalLength; + } + sendSignal(rep->getUserRef(), gsn, signal, length, JBB); +} + +/** + * MODULE: Alter trigger. + * + * Alter trigger state. Alter online creates the trigger first in all + * TC (if index trigger) and then in all LQH-TUP. + * + * Request type received in REQ and returned in CONF/REF: + * + * RT_USER - normal user e.g. BACKUP + * RT_CREATE_TRIGGER - from create trigger + * RT_DROP_TRIGGER - from drop trigger + * RT_DICT_PREPARE - seize operations and check request + * RT_DICT_TC - master to each DICT on way to TC + * RT_DICT_LQH - master to each DICT on way to LQH-TUP + * RT_DICT_COMMIT - commit state change in each DICT (no reply) + */ + +void +Dbdict::execALTER_TRIG_REQ(Signal* signal) +{ + jamEntry(); + AlterTrigReq* const req = (AlterTrigReq*)signal->getDataPtrSend(); + OpAlterTriggerPtr opPtr; + const Uint32 senderRef = signal->senderBlockRef(); + const AlterTrigReq::RequestType requestType = req->getRequestType(); + if (requestType == AlterTrigReq::RT_USER || + requestType == AlterTrigReq::RT_CREATE_TRIGGER || + requestType == AlterTrigReq::RT_DROP_TRIGGER) { + jam(); + const bool isLocal = req->getRequestFlag() & RequestFlag::RF_LOCAL; + NdbNodeBitmask receiverNodes = c_aliveNodes; + if (isLocal) { + receiverNodes.clear(); + receiverNodes.set(getOwnNodeId()); + } + if (signal->getLength() == AlterTrigReq::SignalLength) { + jam(); + if (! isLocal && getOwnNodeId() != c_masterNodeId) { + jam(); + // forward to DICT master + sendSignal(calcDictBlockRef(c_masterNodeId), GSN_ALTER_TRIG_REQ, + signal, AlterTrigReq::SignalLength, JBB); + return; + } + // forward initial request plus operation key to all + req->setOpKey(++c_opRecordSequence); + NodeReceiverGroup rg(DBDICT, receiverNodes); + sendSignal(rg, GSN_ALTER_TRIG_REQ, + signal, AlterTrigReq::SignalLength + 1, JBB); + return; + } + // seize operation record + ndbrequire(signal->getLength() == AlterTrigReq::SignalLength + 1); + const Uint32 opKey = req->getOpKey(); + OpAlterTrigger opBusy; + if (! c_opAlterTrigger.seize(opPtr)) + opPtr.p = &opBusy; + opPtr.p->save(req); + opPtr.p->m_coordinatorRef = senderRef; + opPtr.p->m_isMaster = (senderRef == reference()); + opPtr.p->key = opKey; + opPtr.p->m_requestType = AlterTrigReq::RT_DICT_PREPARE; + if (opPtr.p == &opBusy) { + jam(); + opPtr.p->m_errorCode = AlterTrigRef::Busy; + opPtr.p->m_errorLine = __LINE__; + alterTrigger_sendReply(signal, opPtr, opPtr.p->m_isMaster); + return; + } + c_opAlterTrigger.add(opPtr); + // master expects to hear from all + if (opPtr.p->m_isMaster) { + opPtr.p->m_nodes = receiverNodes; + opPtr.p->m_signalCounter = receiverNodes; + } + alterTrigger_slavePrepare(signal, opPtr); + alterTrigger_sendReply(signal, opPtr, false); + return; + } + c_opAlterTrigger.find(opPtr, req->getConnectionPtr()); + if (! opPtr.isNull()) { + opPtr.p->m_requestType = requestType; + if (requestType == AlterTrigReq::RT_DICT_TC || + requestType == AlterTrigReq::RT_DICT_LQH) { + jam(); + if (req->getOnline()) + alterTrigger_toCreateLocal(signal, opPtr); + else + alterTrigger_toDropLocal(signal, opPtr); + return; + } + if (requestType == AlterTrigReq::RT_DICT_COMMIT || + requestType == AlterTrigReq::RT_DICT_ABORT) { + jam(); + if (requestType == AlterTrigReq::RT_DICT_COMMIT) + alterTrigger_slaveCommit(signal, opPtr); + else + alterTrigger_slaveAbort(signal, opPtr); + alterTrigger_sendReply(signal, opPtr, false); + // done in slave + if (! opPtr.p->m_isMaster) + c_opAlterTrigger.release(opPtr); + return; + } + } + jam(); + // return to sender + OpAlterTrigger opBad; + opPtr.p = &opBad; + opPtr.p->save(req); + opPtr.p->m_errorCode = AlterTrigRef::BadRequestType; + opPtr.p->m_errorLine = __LINE__; + alterTrigger_sendReply(signal, opPtr, true); + return; +} + +void +Dbdict::execALTER_TRIG_CONF(Signal* signal) +{ + jamEntry(); + AlterTrigConf* conf = (AlterTrigConf*)signal->getDataPtrSend(); + alterTrigger_recvReply(signal, conf, 0); +} + +void +Dbdict::execALTER_TRIG_REF(Signal* signal) +{ + jamEntry(); + AlterTrigRef* ref = (AlterTrigRef*)signal->getDataPtrSend(); + alterTrigger_recvReply(signal, ref->getConf(), ref); +} + +void +Dbdict::alterTrigger_recvReply(Signal* signal, const AlterTrigConf* conf, + const AlterTrigRef* ref) +{ + jam(); + const Uint32 senderRef = signal->senderBlockRef(); + const AlterTrigReq::RequestType requestType = conf->getRequestType(); + const Uint32 key = conf->getConnectionPtr(); + if (requestType == AlterTrigReq::RT_CREATE_TRIGGER) { + jam(); + // part of create trigger operation + OpCreateTriggerPtr opPtr; + c_opCreateTrigger.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + createTrigger_fromAlterTrigger(signal, opPtr); + return; + } + if (requestType == AlterTrigReq::RT_DROP_TRIGGER) { + jam(); + // part of drop trigger operation + OpDropTriggerPtr opPtr; + c_opDropTrigger.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + opPtr.p->setError(ref); + dropTrigger_fromAlterTrigger(signal, opPtr); + return; + } + OpAlterTriggerPtr opPtr; + c_opAlterTrigger.find(opPtr, key); + ndbrequire(! opPtr.isNull()); + ndbrequire(opPtr.p->m_isMaster); + ndbrequire(opPtr.p->m_requestType == requestType); + /* + * If refuse on drop trig, because of non-existent trigger, + * comes from anyone but the master node - ignore it and + * remove the node from forter ALTER_TRIG communication + * This will happen if a new node has started since the + * trigger whas created. + */ + if (ref && + refToNode(senderRef) != refToNode(reference()) && + opPtr.p->m_request.getRequestType() == AlterTrigReq::RT_DROP_TRIGGER && + ref->getErrorCode() == AlterTrigRef::TriggerNotFound) { + jam(); + ref = 0; // ignore this error + opPtr.p->m_nodes.clear(refToNode(senderRef)); // remove this from group + } + opPtr.p->setError(ref); + opPtr.p->m_signalCounter.clearWaitingFor(refToNode(senderRef)); + if (! opPtr.p->m_signalCounter.done()) { + jam(); + return; + } + if (requestType == AlterTrigReq::RT_DICT_COMMIT || + requestType == AlterTrigReq::RT_DICT_ABORT) { + jam(); + // send reply to user + alterTrigger_sendReply(signal, opPtr, true); + c_opAlterTrigger.release(opPtr); + return; + } + if (opPtr.p->hasError()) { + jam(); + opPtr.p->m_requestType = AlterTrigReq::RT_DICT_ABORT; + alterTrigger_sendSlaveReq(signal, opPtr); + return; + } + if (! (opPtr.p->m_request.getRequestFlag() & RequestFlag::RF_NOTCTRIGGER)) { + if (requestType == AlterTrigReq::RT_DICT_PREPARE) { + jam(); + if (opPtr.p->m_request.getOnline()) + opPtr.p->m_requestType = AlterTrigReq::RT_DICT_TC; + else + opPtr.p->m_requestType = AlterTrigReq::RT_DICT_LQH; + alterTrigger_sendSlaveReq(signal, opPtr); + return; + } + if (requestType == AlterTrigReq::RT_DICT_TC) { + jam(); + if (opPtr.p->m_request.getOnline()) + opPtr.p->m_requestType = AlterTrigReq::RT_DICT_LQH; + else + opPtr.p->m_requestType = AlterTrigReq::RT_DICT_COMMIT; + alterTrigger_sendSlaveReq(signal, opPtr); + return; + } + if (requestType == AlterTrigReq::RT_DICT_LQH) { + jam(); + if (opPtr.p->m_request.getOnline()) + opPtr.p->m_requestType = AlterTrigReq::RT_DICT_COMMIT; + else + opPtr.p->m_requestType = AlterTrigReq::RT_DICT_TC; + alterTrigger_sendSlaveReq(signal, opPtr); + return; + } + } else { + if (requestType == AlterTrigReq::RT_DICT_PREPARE) { + jam(); + opPtr.p->m_requestType = AlterTrigReq::RT_DICT_LQH; + alterTrigger_sendSlaveReq(signal, opPtr); + return; + } + if (requestType == AlterTrigReq::RT_DICT_LQH) { + jam(); + opPtr.p->m_requestType = AlterTrigReq::RT_DICT_COMMIT; + alterTrigger_sendSlaveReq(signal, opPtr); + return; + } + } + ndbrequire(false); +} + +void +Dbdict::alterTrigger_slavePrepare(Signal* signal, OpAlterTriggerPtr opPtr) +{ + jam(); + const AlterTrigReq* const req = &opPtr.p->m_request; + const Uint32 triggerId = req->getTriggerId(); + TriggerRecordPtr triggerPtr; + if (! (triggerId < c_triggerRecordPool.getSize())) { + jam(); + opPtr.p->m_errorCode = AlterTrigRef::TriggerNotFound; + opPtr.p->m_errorLine = __LINE__; + return; + } + c_triggerRecordPool.getPtr(triggerPtr, triggerId); + if (triggerPtr.p->triggerState == TriggerRecord::TS_NOT_DEFINED) { + jam(); + opPtr.p->m_errorCode = AlterTrigRef::TriggerNotFound; + opPtr.p->m_errorLine = __LINE__; + return; + } +} + +void +Dbdict::alterTrigger_toCreateLocal(Signal* signal, OpAlterTriggerPtr opPtr) +{ + jam(); + // find trigger record + const Uint32 triggerId = opPtr.p->m_request.getTriggerId(); + TriggerRecordPtr triggerPtr; + c_triggerRecordPool.getPtr(triggerPtr, triggerId); + CreateTrigReq* const req = (CreateTrigReq*)signal->getDataPtrSend(); + req->setUserRef(reference()); + req->setConnectionPtr(opPtr.p->key); + if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_TC) { + req->setRequestType(CreateTrigReq::RT_TC); + } else if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_LQH) { + req->setRequestType(CreateTrigReq::RT_LQH); + } else { + ndbassert(false); + } + req->setTableId(triggerPtr.p->tableId); + req->setIndexId(triggerPtr.p->indexId); + req->setTriggerId(triggerPtr.i); + req->setTriggerType(triggerPtr.p->triggerType); + req->setTriggerActionTime(triggerPtr.p->triggerActionTime); + req->setTriggerEvent(triggerPtr.p->triggerEvent); + req->setMonitorReplicas(triggerPtr.p->monitorReplicas); + req->setMonitorAllAttributes(triggerPtr.p->monitorAllAttributes); + req->setOnline(true); + req->setReceiverRef(opPtr.p->m_request.getReceiverRef()); + BlockReference blockRef = 0; + if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_TC) { + blockRef = calcTcBlockRef(getOwnNodeId()); + } else if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_LQH) { + blockRef = calcLqhBlockRef(getOwnNodeId()); + } else { + ndbassert(false); + } + req->setAttributeMask(triggerPtr.p->attributeMask); + sendSignal(blockRef, GSN_CREATE_TRIG_REQ, + signal, CreateTrigReq::SignalLength, JBB); +} + +void +Dbdict::alterTrigger_fromCreateLocal(Signal* signal, OpAlterTriggerPtr opPtr) +{ + jam(); + if (! opPtr.p->hasError()) { + // mark created locally + TriggerRecordPtr triggerPtr; + c_triggerRecordPool.getPtr(triggerPtr, opPtr.p->m_request.getTriggerId()); + if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_TC) { + triggerPtr.p->triggerLocal |= TriggerRecord::TL_CREATED_TC; + } else if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_LQH) { + triggerPtr.p->triggerLocal |= TriggerRecord::TL_CREATED_LQH; + } else { + ndbrequire(false); + } + } + // forward CONF or REF to master + alterTrigger_sendReply(signal, opPtr, false); +} + +void +Dbdict::alterTrigger_toDropLocal(Signal* signal, OpAlterTriggerPtr opPtr) +{ + jam(); + TriggerRecordPtr triggerPtr; + c_triggerRecordPool.getPtr(triggerPtr, opPtr.p->m_request.getTriggerId()); + DropTrigReq* const req = (DropTrigReq*)signal->getDataPtrSend(); + req->setUserRef(reference()); + req->setConnectionPtr(opPtr.p->key); + if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_TC) { + // broken trigger + if (! (triggerPtr.p->triggerLocal & TriggerRecord::TL_CREATED_TC)) { + jam(); + alterTrigger_sendReply(signal, opPtr, false); + return; + } + req->setRequestType(DropTrigReq::RT_TC); + } else if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_LQH) { + // broken trigger + if (! (triggerPtr.p->triggerLocal & TriggerRecord::TL_CREATED_LQH)) { + jam(); + alterTrigger_sendReply(signal, opPtr, false); + return; + } + req->setRequestType(DropTrigReq::RT_LQH); + } else { + ndbassert(false); + } + req->setTableId(triggerPtr.p->tableId); + req->setIndexId(triggerPtr.p->indexId); + req->setTriggerId(triggerPtr.i); + req->setTriggerType(triggerPtr.p->triggerType); + req->setTriggerActionTime(triggerPtr.p->triggerActionTime); + req->setTriggerEvent(triggerPtr.p->triggerEvent); + req->setMonitorReplicas(triggerPtr.p->monitorReplicas); + req->setMonitorAllAttributes(triggerPtr.p->monitorAllAttributes); + BlockReference blockRef = 0; + if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_TC) { + blockRef = calcTcBlockRef(getOwnNodeId()); + } else if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_LQH) { + blockRef = calcLqhBlockRef(getOwnNodeId()); + } else { + ndbassert(false); + } + sendSignal(blockRef, GSN_DROP_TRIG_REQ, + signal, DropTrigReq::SignalLength, JBB); +} + +void +Dbdict::alterTrigger_fromDropLocal(Signal* signal, OpAlterTriggerPtr opPtr) +{ + jam(); + if (! opPtr.p->hasError()) { + // mark dropped locally + TriggerRecordPtr triggerPtr; + c_triggerRecordPool.getPtr(triggerPtr, opPtr.p->m_request.getTriggerId()); + if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_TC) { + triggerPtr.p->triggerLocal &= ~TriggerRecord::TL_CREATED_TC; + } else if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_LQH) { + triggerPtr.p->triggerLocal &= ~TriggerRecord::TL_CREATED_LQH; + } else { + ndbrequire(false); + } + } + // forward CONF or REF to master + alterTrigger_sendReply(signal, opPtr, false); +} + +void +Dbdict::alterTrigger_slaveCommit(Signal* signal, OpAlterTriggerPtr opPtr) +{ + jam(); + TriggerRecordPtr triggerPtr; + c_triggerRecordPool.getPtr(triggerPtr, opPtr.p->m_request.getTriggerId()); + // set state + triggerPtr.p->triggerState = TriggerRecord::TS_ONLINE; +} + +void +Dbdict::alterTrigger_slaveAbort(Signal* signal, OpAlterTriggerPtr opPtr) +{ + jam(); +} + +void +Dbdict::alterTrigger_sendSlaveReq(Signal* signal, OpAlterTriggerPtr opPtr) +{ + AlterTrigReq* const req = (AlterTrigReq*)signal->getDataPtrSend(); + *req = opPtr.p->m_request; + req->setUserRef(opPtr.p->m_coordinatorRef); + req->setConnectionPtr(opPtr.p->key); + req->setRequestType(opPtr.p->m_requestType); + req->addRequestFlag(opPtr.p->m_requestFlag); + NdbNodeBitmask receiverNodes = c_aliveNodes; + if (opPtr.p->m_requestFlag & RequestFlag::RF_LOCAL) { + receiverNodes.clear(); + receiverNodes.set(getOwnNodeId()); + } else { + opPtr.p->m_nodes.bitAND(receiverNodes); + receiverNodes = opPtr.p->m_nodes; + } + opPtr.p->m_signalCounter = receiverNodes; + NodeReceiverGroup rg(DBDICT, receiverNodes); + sendSignal(rg, GSN_ALTER_TRIG_REQ, + signal, AlterTrigReq::SignalLength, JBB); +} + +void +Dbdict::alterTrigger_sendReply(Signal* signal, OpAlterTriggerPtr opPtr, + bool toUser) +{ + jam(); + AlterTrigRef* rep = (AlterTrigRef*)signal->getDataPtrSend(); + Uint32 gsn = GSN_ALTER_TRIG_CONF; + Uint32 length = AlterTrigConf::InternalLength; + bool sendRef = opPtr.p->hasError(); + if (! toUser) { + rep->setUserRef(opPtr.p->m_coordinatorRef); + rep->setConnectionPtr(opPtr.p->key); + rep->setRequestType(opPtr.p->m_requestType); + if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_ABORT) { + jam(); + sendRef = false; + } else { + jam(); + } + } else { + jam(); + rep->setUserRef(opPtr.p->m_request.getUserRef()); + rep->setConnectionPtr(opPtr.p->m_request.getConnectionPtr()); + rep->setRequestType(opPtr.p->m_request.getRequestType()); + length = AlterTrigConf::SignalLength; + } + rep->setTableId(opPtr.p->m_request.getTableId()); + rep->setTriggerId(opPtr.p->m_request.getTriggerId()); + if (sendRef) { + if (opPtr.p->m_errorNode == 0) { + jam(); + opPtr.p->m_errorNode = getOwnNodeId(); + } else { + jam(); + } + rep->setErrorCode(opPtr.p->m_errorCode); + rep->setErrorLine(opPtr.p->m_errorLine); + rep->setErrorNode(opPtr.p->m_errorNode); + gsn = GSN_ALTER_TRIG_REF; + length = AlterTrigRef::SignalLength; + } + sendSignal(rep->getUserRef(), gsn, signal, length, JBB); +} + +/** + * MODULE: Support routines for index and trigger. + */ + +void +Dbdict::getTableKeyList(TableRecordPtr tablePtr, AttributeList& list) +{ + jam(); + list.sz = 0; + for (Uint32 tAttr = tablePtr.p->firstAttribute; tAttr != RNIL; ) { + AttributeRecord* aRec = c_attributeRecordPool.getPtr(tAttr); + if (aRec->tupleKey) + list.id[list.sz++] = aRec->attributeId; + tAttr = aRec->nextAttrInTable; + } +} + +// XXX should store the primary attribute id +void +Dbdict::getIndexAttr(TableRecordPtr indexPtr, Uint32 itAttr, Uint32* id) +{ + jam(); + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, indexPtr.p->primaryTableId); + AttributeRecord* iaRec = c_attributeRecordPool.getPtr(itAttr); + for (Uint32 tAttr = tablePtr.p->firstAttribute; tAttr != RNIL; ) { + AttributeRecord* aRec = c_attributeRecordPool.getPtr(tAttr); + if (iaRec->equal(*aRec)) { + id[0] = aRec->attributeId; + return; + } + tAttr = aRec->nextAttrInTable; + } + ndbrequire(false); +} + +void +Dbdict::getIndexAttrList(TableRecordPtr indexPtr, AttributeList& list) +{ + jam(); + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, indexPtr.p->primaryTableId); + list.sz = 0; + memset(list.id, 0, sizeof(list.id)); + ndbrequire(indexPtr.p->noOfAttributes >= 2); + Uint32 itAttr = indexPtr.p->firstAttribute; + for (Uint32 i = 0; i < (Uint32)indexPtr.p->noOfAttributes - 1; i++) { + getIndexAttr(indexPtr, itAttr, &list.id[list.sz++]); + AttributeRecord* iaRec = c_attributeRecordPool.getPtr(itAttr); + itAttr = iaRec->nextAttrInTable; + } +} + +void +Dbdict::getIndexAttrMask(TableRecordPtr indexPtr, AttributeMask& mask) +{ + jam(); + TableRecordPtr tablePtr; + c_tableRecordPool.getPtr(tablePtr, indexPtr.p->primaryTableId); + mask.clear(); + ndbrequire(indexPtr.p->noOfAttributes >= 2); + Uint32 itAttr = indexPtr.p->firstAttribute; + for (Uint32 i = 0; i < (Uint32)indexPtr.p->noOfAttributes - 1; i++) { + Uint32 id; + getIndexAttr(indexPtr, itAttr, &id); + mask.set(id); + AttributeRecord* iaRec = c_attributeRecordPool.getPtr(itAttr); + itAttr = iaRec->nextAttrInTable; + } +} + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* MODULE: STORE/RESTORE SCHEMA FILE---------------------- */ +/* ---------------------------------------------------------------- */ +/* */ +/* General module used to store the schema file on disk and */ +/* similar function to restore it from disk. */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ + +void +Dbdict::initSchemaFile(SchemaFile * sf, Uint32 fileSz){ + memcpy(sf->Magic, "NDBSCHMA", sizeof(sf->Magic)); + sf->ByteOrder = 0x12345678; + sf->NdbVersion = NDB_VERSION; + sf->FileSize = fileSz; + sf->CheckSum = 0; + + Uint32 headSz = (sizeof(SchemaFile)-sizeof(SchemaFile::TableEntry)); + Uint32 noEntries = (fileSz - headSz) / sizeof(SchemaFile::TableEntry); + Uint32 slack = (fileSz - headSz) - noEntries * sizeof(SchemaFile::TableEntry); + + ndbrequire(noEntries > MAX_TABLES); + + sf->NoOfTableEntries = noEntries; + memset(sf->TableEntries, 0, sizeof(noEntries*sizeof(SchemaFile::TableEntry))); + memset(&(sf->TableEntries[noEntries]), 0, slack); + computeChecksum(sf); +} + +void +Dbdict::computeChecksum(SchemaFile * sf){ + sf->CheckSum = 0; + sf->CheckSum = computeChecksum((const Uint32*)sf, sf->FileSize/4); +} + +bool +Dbdict::validateChecksum(const SchemaFile * sf){ + + Uint32 c = computeChecksum((const Uint32*)sf, sf->FileSize/4); + return c == 0; +} + +Uint32 +Dbdict::computeChecksum(const Uint32 * src, Uint32 len){ + Uint32 ret = 0; + for(Uint32 i = 0; iNoOfTableEntries); + return &sf->TableEntries[tableId]; +} + +// global metadata support + +int +Dbdict::getMetaTablePtr(TableRecordPtr& tablePtr, Uint32 tableId, Uint32 tableVersion) +{ + if (tableId >= c_tableRecordPool.getSize()) { + return MetaData::InvalidArgument; + } + c_tableRecordPool.getPtr(tablePtr, tableId); + if (tablePtr.p->tabState == TableRecord::NOT_DEFINED) { + return MetaData::TableNotFound; + } + if (tablePtr.p->tableVersion != tableVersion) { + return MetaData::InvalidTableVersion; + } + // online flag is not maintained by DICT + tablePtr.p->online = + tablePtr.p->isTable() && tablePtr.p->tabState == TableRecord::DEFINED || + tablePtr.p->isIndex() && tablePtr.p->indexState == TableRecord::IS_ONLINE; + return 0; +} + +int +Dbdict::getMetaTable(MetaData::Table& table, Uint32 tableId, Uint32 tableVersion) +{ + int ret; + TableRecordPtr tablePtr; + if ((ret = getMetaTablePtr(tablePtr, tableId, tableVersion)) < 0) { + return ret; + } + new (&table) MetaData::Table(*tablePtr.p); + return 0; +} + +int +Dbdict::getMetaTable(MetaData::Table& table, const char* tableName) +{ + int ret; + TableRecordPtr tablePtr; + if (strlen(tableName) + 1 > MAX_TAB_NAME_SIZE) { + return MetaData::InvalidArgument; + } + TableRecord keyRecord; + strcpy(keyRecord.tableName, tableName); + c_tableRecordHash.find(tablePtr, keyRecord); + if (tablePtr.i == RNIL) { + return MetaData::TableNotFound; + } + if ((ret = getMetaTablePtr(tablePtr, tablePtr.i, tablePtr.p->tableVersion)) < 0) { + return ret; + } + new (&table) MetaData::Table(*tablePtr.p); + return 0; +} + +int +Dbdict::getMetaAttribute(MetaData::Attribute& attr, const MetaData::Table& table, Uint32 attributeId) +{ + int ret; + TableRecordPtr tablePtr; + if ((ret = getMetaTablePtr(tablePtr, table.tableId, table.tableVersion)) < 0) { + return ret; + } + AttributeRecordPtr attrPtr; + attrPtr.i = tablePtr.p->firstAttribute; + while (attrPtr.i != RNIL) { + c_attributeRecordPool.getPtr(attrPtr); + if (attrPtr.p->attributeId == attributeId) + break; + attrPtr.i = attrPtr.p->nextAttrInTable; + } + if (attrPtr.i == RNIL) { + return MetaData::AttributeNotFound; + } + new (&attr) MetaData::Attribute(*attrPtr.p); + return 0; +} + +int +Dbdict::getMetaAttribute(MetaData::Attribute& attr, const MetaData::Table& table, const char* attributeName) +{ + int ret; + TableRecordPtr tablePtr; + if ((ret = getMetaTablePtr(tablePtr, table.tableId, table.tableVersion)) < 0) { + return ret; + } + AttributeRecordPtr attrPtr; + attrPtr.i = tablePtr.p->firstAttribute; + while (attrPtr.i != RNIL) { + c_attributeRecordPool.getPtr(attrPtr); + if (strcmp(attrPtr.p->attributeName, attributeName) == 0) + break; + attrPtr.i = attrPtr.p->nextAttrInTable; + } + if (attrPtr.i == RNIL) { + return MetaData::AttributeNotFound; + } + new (&attr) MetaData::Attribute(*attrPtr.p); + return 0; +} diff --git a/ndb/src/kernel/blocks/dbdict/Dbdict.hpp b/ndb/src/kernel/blocks/dbdict/Dbdict.hpp new file mode 100644 index 00000000000..02e2d4496bf --- /dev/null +++ b/ndb/src/kernel/blocks/dbdict/Dbdict.hpp @@ -0,0 +1,1987 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DBDICT_H +#define DBDICT_H + +/** + * Dict : Dictionary Block + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "SchemaFile.hpp" +#include +#include +#include + +#ifdef DBDICT_C +// Debug Macros + +/*--------------------------------------------------------------*/ +// Constants for CONTINUEB +/*--------------------------------------------------------------*/ +#define ZPACK_TABLE_INTO_PAGES 0 +#define ZSEND_GET_TAB_RESPONSE 3 + + +/*--------------------------------------------------------------*/ +// Other constants in alphabetical order +/*--------------------------------------------------------------*/ +#define ZNOMOREPHASES 255 + +/*--------------------------------------------------------------*/ +// Schema file defines +/*--------------------------------------------------------------*/ +#define ZSCHEMA_WORDS 4 + +/*--------------------------------------------------------------*/ +// Page constants +/*--------------------------------------------------------------*/ +#define ZALLOCATE 1 //Variable number of page for NDBFS +#define ZPAGE_HEADER_SIZE 32 +#define ZPOS_PAGE_SIZE 16 +#define ZPOS_CHECKSUM 17 +#define ZPOS_VERSION 18 +#define ZPOS_PAGE_HEADER_SIZE 19 + +/*--------------------------------------------------------------*/ +// Size constants +/*--------------------------------------------------------------*/ +#define ZFS_CONNECT_SIZE 4 +#define ZSIZE_OF_PAGES_IN_WORDS 8192 +#define ZLOG_SIZE_OF_PAGES_IN_WORDS 13 +#define ZMAX_PAGES_OF_TABLE_DEFINITION 8 +#define ZNUMBER_OF_PAGES (2 * ZMAX_PAGES_OF_TABLE_DEFINITION + 2) +#define ZNO_OF_FRAGRECORD 5 + +/*--------------------------------------------------------------*/ +// Error codes +/*--------------------------------------------------------------*/ +#define ZNODE_FAILURE_ERROR 704 +#endif + +/** + * DICT - This blocks handles all metadata + */ +class Dbdict: public SimulatedBlock { +public: + /* + * 2.3 RECORD AND FILESIZES + */ + /** + * Shared table / index record. Most of this is permanent data stored + * on disk. Index trigger ids are volatile. + */ + struct TableRecord : public MetaData::Table { + /**************************************************** + * Support variables for table handling + ****************************************************/ + + /* Active page which is sent to disk */ + Uint32 activePage; + + /** File pointer received from disk */ + Uint32 filePtr[2]; + + /** Pointer to first attribute in table */ + Uint32 firstAttribute; + + /* Pointer to first page of table description */ + Uint32 firstPage; + + /** Pointer to last attribute in table */ + Uint32 lastAttribute; + + /* Temporary record used during add/drop table */ + Uint32 myConnect; + + /* Second table used by this table (for table reorg) */ + Uint32 secondTable; + + /* Next record in Pool */ + Uint32 nextPool; + + /* Next record in hash table */ + Uint32 nextHash; + + /* Previous record in Pool */ + Uint32 prevPool; + + /* Previous record in hash table */ + Uint32 prevHash; + + enum TabState { + NOT_DEFINED = 0, + REORG_TABLE_PREPARED = 1, + DEFINING = 2, + CHECKED = 3, + DEFINED = 4, + PREPARE_DROPPING = 5, + DROPPING = 6 + }; + TabState tabState; + + /* State when returning from TC_SCHVERREQ */ + enum TabReturnState { + TRS_IDLE = 0, + ADD_TABLE = 1, + SLAVE_SYSTEM_RESTART = 2, + MASTER_SYSTEM_RESTART = 3 + }; + TabReturnState tabReturnState; + + /** Number of words */ + Uint32 packedSize; + + /** Index state (volatile data) */ + enum IndexState { + IS_UNDEFINED = 0, // initial + IS_OFFLINE = 1, // index table created + IS_BUILDING = 2, // building (local state) + IS_DROPPING = 3, // dropping (local state) + IS_ONLINE = 4, // online + IS_BROKEN = 9 // build or drop aborted + }; + IndexState indexState; + + /** Trigger ids of index (volatile data) */ + Uint32 insertTriggerId; + Uint32 updateTriggerId; + Uint32 deleteTriggerId; + Uint32 customTriggerId; // ordered index + Uint32 buildTriggerId; // temp during build + + /** Index state in other blocks on this node */ + enum IndexLocal { + IL_CREATED_TC = 1 << 0 // created in TC + }; + Uint32 indexLocal; + + inline bool equal(TableRecord & rec) const { + return strcmp(tableName, rec.tableName) == 0; + } + + inline Uint32 hashValue() const { + Uint32 h = 0; + for (const char* p = tableName; *p != 0; p++) + h = (h << 5) + h + (*p); + return h; + } + + /** frm data for this table */ + /** TODO Could preferrably be made dynamic size */ + Uint32 frmLen; + char frmData[MAX_FRM_DATA_SIZE]; + + + }; + + typedef Ptr TableRecordPtr; + ArrayPool c_tableRecordPool; + DLHashTable c_tableRecordHash; + + /** + * Table attributes. Permanent data. + * + * Indexes have an attribute list which duplicates primary table + * attributes. This is wrong but convenient. + */ + struct AttributeRecord : public MetaData::Attribute { + union { + /** Pointer to the next attribute used by ArrayPool */ + Uint32 nextPool; + + /** Pointer to the next attribute used by DLHash */ + Uint32 nextHash; + }; + + /** Pointer to the previous attribute used by DLHash */ + Uint32 prevHash; + + /** Pointer to the next attribute in table */ + Uint32 nextAttrInTable; + + inline bool equal(AttributeRecord & rec) const { + return strcmp(attributeName, rec.attributeName) == 0; + } + + inline Uint32 hashValue() const { + Uint32 h = 0; + for (const char* p = attributeName; *p != 0; p++) + h = (h << 5) + h + (*p); + return h; + } + }; + + typedef Ptr AttributeRecordPtr; + ArrayPool c_attributeRecordPool; + DLHashTable c_attributeRecordHash; + + /** + * Triggers. This is volatile data not saved on disk. Setting a + * trigger online creates the trigger in TC (if index) and LQH-TUP. + */ + struct TriggerRecord { + + /** Trigger state */ + enum TriggerState { + TS_NOT_DEFINED = 0, + TS_DEFINING = 1, + TS_OFFLINE = 2, // created globally in DICT + TS_BUILDING = 3, + TS_DROPPING = 4, + TS_ONLINE = 5 // activated globally + }; + TriggerState triggerState; + + /** Trigger state in other blocks on this node */ + enum IndexLocal { + TL_CREATED_TC = 1 << 0, // created in TC + TL_CREATED_LQH = 1 << 1 // created in LQH-TUP + }; + Uint32 triggerLocal; + + /** Trigger name, used by DICT to identify the trigger */ + char triggerName[MAX_TAB_NAME_SIZE]; + + /** Trigger id, used by TRIX, TC, LQH, and TUP to identify the trigger */ + Uint32 triggerId; + + /** Table id, the table the trigger is defined on */ + Uint32 tableId; + + /** Trigger type, defines what the trigger is used for */ + TriggerType::Value triggerType; + + /** Trigger action time, defines when the trigger should fire */ + TriggerActionTime::Value triggerActionTime; + + /** Trigger event, defines what events the trigger should monitor */ + TriggerEvent::Value triggerEvent; + + /** Monitor all replicas */ + bool monitorReplicas; + + /** Monitor all, the trigger monitors changes of all attributes in table */ + bool monitorAllAttributes; + + /** + * Attribute mask, defines what attributes are to be monitored. + * Can be seen as a compact representation of SQL column name list. + */ + AttributeMask attributeMask; + + /** Index id, only used by secondary_index triggers */ + Uint32 indexId; + + union { + /** Pointer to the next attribute used by ArrayPool */ + Uint32 nextPool; + + /** Next record in hash table */ + Uint32 nextHash; + }; + + /** Previous record in hash table */ + Uint32 prevHash; + + /** Equal function, used by DLHashTable */ + inline bool equal(TriggerRecord & rec) const { + return strcmp(triggerName, rec.triggerName) == 0; + } + + /** Hash value function, used by DLHashTable */ + inline Uint32 hashValue() const { + Uint32 h = 0; + for (const char* p = triggerName; *p != 0; p++) + h = (h << 5) + h + (*p); + return h; + } + }; + + Uint32 c_maxNoOfTriggers; + typedef Ptr TriggerRecordPtr; + ArrayPool c_triggerRecordPool; + DLHashTable c_triggerRecordHash; + + /** + * Information for each FS connection. + ****************************************************************************/ + struct FsConnectRecord { + enum FsState { + IDLE = 0, + OPEN_WRITE_SCHEMA = 1, + WRITE_SCHEMA = 2, + CLOSE_WRITE_SCHEMA = 3, + OPEN_READ_SCHEMA1 = 4, + OPEN_READ_SCHEMA2 = 5, + READ_SCHEMA1 = 6, + READ_SCHEMA2 = 7, + CLOSE_READ_SCHEMA = 8, + OPEN_READ_TAB_FILE1 = 9, + OPEN_READ_TAB_FILE2 = 10, + READ_TAB_FILE1 = 11, + READ_TAB_FILE2 = 12, + CLOSE_READ_TAB_FILE = 13, + OPEN_WRITE_TAB_FILE = 14, + WRITE_TAB_FILE = 15, + CLOSE_WRITE_TAB_FILE = 16 + }; + /** File Pointer for this file system connection */ + Uint32 filePtr; + + /** Reference of owner record */ + Uint32 ownerPtr; + + /** State of file system connection */ + FsState fsState; + + /** Used by Array Pool for free list handling */ + Uint32 nextPool; + }; + + typedef Ptr FsConnectRecordPtr; + ArrayPool c_fsConnectRecordPool; + + /** + * This record stores all the information about a node and all its attributes + ****************************************************************************/ + struct NodeRecord { + enum NodeState { + API_NODE = 0, + NDB_NODE_ALIVE = 1, + NDB_NODE_DEAD = 2 + }; + bool hotSpare; + NodeState nodeState; + }; + + typedef Ptr NodeRecordPtr; + CArray c_nodes; + NdbNodeBitmask c_aliveNodes; + + /** + * This record stores all the information about a table and all its attributes + ****************************************************************************/ + struct PageRecord { + Uint32 word[8192]; + }; + + typedef Ptr PageRecordPtr; + CArray c_pageRecordArray; + + /** + * A page for create index table signal. + */ + PageRecord c_indexPage; + +public: + Dbdict(const class Configuration &); + virtual ~Dbdict(); + +private: + BLOCK_DEFINES(Dbdict); + + // Signal receivers + void execDICTSTARTREQ(Signal* signal); + + void execGET_TABINFOREQ(Signal* signal); + void execGET_TABLEDID_REQ(Signal* signal); + void execGET_TABINFO_REF(Signal* signal); + void execGET_TABINFO_CONF(Signal* signal); + void execCONTINUEB(Signal* signal); + + void execDUMP_STATE_ORD(Signal* signal); + void execHOT_SPAREREP(Signal* signal); + void execDIADDTABCONF(Signal* signal); + void execDIADDTABREF(Signal* signal); + void execTAB_COMMITCONF(Signal* signal); + void execTAB_COMMITREF(Signal* signal); + void execGET_SCHEMA_INFOREQ(Signal* signal); + void execSCHEMA_INFO(Signal* signal); + void execSCHEMA_INFOCONF(Signal* signal); + void execREAD_NODESCONF(Signal* signal); + void execFSCLOSECONF(Signal* signal); + void execFSCLOSEREF(Signal* signal); + void execFSOPENCONF(Signal* signal); + void execFSOPENREF(Signal* signal); + void execFSREADCONF(Signal* signal); + void execFSREADREF(Signal* signal); + void execFSWRITECONF(Signal* signal); + void execFSWRITEREF(Signal* signal); + void execNDB_STTOR(Signal* signal); + void execSIZEALT_REP(Signal* signal); + void execSTTOR(Signal* signal); + void execTC_SCHVERCONF(Signal* signal); + void execNODE_FAILREP(Signal* signal); + void execINCL_NODEREQ(Signal* signal); + void execAPI_FAILREQ(Signal* signal); + + void execWAIT_GCP_REF(Signal* signal); + void execWAIT_GCP_CONF(Signal* signal); + + void execLIST_TABLES_REQ(Signal* signal); + + // Index signals + void execCREATE_INDX_REQ(Signal* signal); + void execCREATE_INDX_CONF(Signal* signal); + void execCREATE_INDX_REF(Signal* signal); + + void execALTER_INDX_REQ(Signal* signal); + void execALTER_INDX_CONF(Signal* signal); + void execALTER_INDX_REF(Signal* signal); + + void execCREATE_TABLE_CONF(Signal* signal); + void execCREATE_TABLE_REF(Signal* signal); + + void execDROP_INDX_REQ(Signal* signal); + void execDROP_INDX_CONF(Signal* signal); + void execDROP_INDX_REF(Signal* signal); + + void execDROP_TABLE_CONF(Signal* signal); + void execDROP_TABLE_REF(Signal* signal); + + void execBUILDINDXREQ(Signal* signal); + void execBUILDINDXCONF(Signal* signal); + void execBUILDINDXREF(Signal* signal); + + // Util signals used by Event code + void execUTIL_PREPARE_CONF(Signal* signal); + void execUTIL_PREPARE_REF (Signal* signal); + void execUTIL_EXECUTE_CONF(Signal* signal); + void execUTIL_EXECUTE_REF (Signal* signal); + void execUTIL_RELEASE_CONF(Signal* signal); + void execUTIL_RELEASE_REF (Signal* signal); + + + // Event signals from API + void execCREATE_EVNT_REQ (Signal* signal); + void execCREATE_EVNT_CONF(Signal* signal); + void execCREATE_EVNT_REF (Signal* signal); + + void execDROP_EVNT_REQ (Signal* signal); + + void execSUB_START_REQ (Signal* signal); + void execSUB_START_CONF (Signal* signal); + void execSUB_START_REF (Signal* signal); + + void execSUB_STOP_REQ (Signal* signal); + void execSUB_STOP_CONF (Signal* signal); + void execSUB_STOP_REF (Signal* signal); + + // Event signals from SUMA + + void execCREATE_SUBID_CONF(Signal* signal); + void execCREATE_SUBID_REF (Signal* signal); + + void execSUB_CREATE_CONF(Signal* signal); + void execSUB_CREATE_REF (Signal* signal); + + void execSUB_SYNC_CONF(Signal* signal); + void execSUB_SYNC_REF (Signal* signal); + + void execSUB_REMOVE_REQ(Signal* signal); + void execSUB_REMOVE_CONF(Signal* signal); + void execSUB_REMOVE_REF(Signal* signal); + + // Trigger signals + void execCREATE_TRIG_REQ(Signal* signal); + void execCREATE_TRIG_CONF(Signal* signal); + void execCREATE_TRIG_REF(Signal* signal); + void execALTER_TRIG_REQ(Signal* signal); + void execALTER_TRIG_CONF(Signal* signal); + void execALTER_TRIG_REF(Signal* signal); + void execDROP_TRIG_REQ(Signal* signal); + void execDROP_TRIG_CONF(Signal* signal); + void execDROP_TRIG_REF(Signal* signal); + + void execDROP_TABLE_REQ(Signal* signal); + + void execPREP_DROP_TAB_REQ(Signal* signal); + void execPREP_DROP_TAB_REF(Signal* signal); + void execPREP_DROP_TAB_CONF(Signal* signal); + + void execDROP_TAB_REQ(Signal* signal); + void execDROP_TAB_REF(Signal* signal); + void execDROP_TAB_CONF(Signal* signal); + + void execCREATE_TABLE_REQ(Signal* signal); + void execALTER_TABLE_REQ(Signal* signal); + void execCREATE_FRAGMENTATION_REF(Signal*); + void execCREATE_FRAGMENTATION_CONF(Signal*); + void execCREATE_TAB_REQ(Signal* signal); + void execADD_FRAGREQ(Signal* signal); + void execLQHFRAGREF(Signal* signal); + void execLQHFRAGCONF(Signal* signal); + void execLQHADDATTREF(Signal* signal); + void execLQHADDATTCONF(Signal* signal); + void execCREATE_TAB_REF(Signal* signal); + void execCREATE_TAB_CONF(Signal* signal); + void execALTER_TAB_REQ(Signal* signal); + void execALTER_TAB_REF(Signal* signal); + void execALTER_TAB_CONF(Signal* signal); + + /* + * 2.4 COMMON STORED VARIABLES + */ + + /** + * This record stores all the state needed + * when the schema page is being sent to other nodes + ***************************************************************************/ + struct SendSchemaRecord { + /** Number of words of schema data */ + Uint32 noOfWords; + /** Page Id of schema data */ + Uint32 pageId; + + Uint32 nodeId; + SignalCounter m_SCHEMAINFO_Counter; + + Uint32 noOfWordsCurrentlySent; + Uint32 noOfSignalsSentSinceDelay; + + bool inUse; + }; + SendSchemaRecord c_sendSchemaRecord; + + /** + * This record stores all the state needed + * when a table file is being read from disk + ****************************************************************************/ + struct ReadTableRecord { + /** Number of Pages */ + Uint32 noOfPages; + /** Page Id*/ + Uint32 pageId; + /** Table Id of read table */ + Uint32 tableId; + + bool inUse; + Callback m_callback; + }; + ReadTableRecord c_readTableRecord; + + /** + * This record stores all the state needed + * when a table file is being written to disk + ****************************************************************************/ + struct WriteTableRecord { + /** Number of Pages */ + Uint32 noOfPages; + /** Page Id*/ + Uint32 pageId; + /** Table Files Handled, local state variable */ + Uint32 noOfTableFilesHandled; + /** Table Id of written table */ + Uint32 tableId; + /** State, indicates from where it was called */ + enum TableWriteState { + IDLE = 0, + WRITE_ADD_TABLE_MASTER = 1, + WRITE_ADD_TABLE_SLAVE = 2, + WRITE_RESTART_FROM_MASTER = 3, + WRITE_RESTART_FROM_OWN = 4, + CALLBACK = 5 + }; + TableWriteState tableWriteState; + Callback m_callback; + }; + WriteTableRecord c_writeTableRecord; + + /** + * This record stores all the state needed + * when a schema file is being read from disk + ****************************************************************************/ + struct ReadSchemaRecord { + /** Page Id of schema page */ + Uint32 pageId; + /** State, indicates from where it was called */ + enum SchemaReadState { + IDLE = 0, + INITIAL_READ = 1 + }; + SchemaReadState schemaReadState; + }; + ReadSchemaRecord c_readSchemaRecord; + +private: + /** + * This record stores all the state needed + * when a schema file is being written to disk + ****************************************************************************/ + struct WriteSchemaRecord { + /** Page Id of schema page */ + Uint32 pageId; + /** Schema Files Handled, local state variable */ + Uint32 noOfSchemaFilesHandled; + + bool inUse; + Callback m_callback; + }; + WriteSchemaRecord c_writeSchemaRecord; + + /** + * This record stores all the information needed + * when a file is being read from disk + ****************************************************************************/ + struct RestartRecord { + /** Global check point identity */ + Uint32 gciToRestart; + + /** The active table at restart process */ + Uint32 activeTable; + + /** The active table at restart process */ + BlockReference returnBlockRef; + }; + RestartRecord c_restartRecord; + + /** + * This record stores all the information needed + * when a file is being read from disk + ****************************************************************************/ + struct RetrieveRecord { + RetrieveRecord(){ noOfWaiters = 0;} + + /** Only one retrieve table definition at a time */ + bool busyState; + + /** + * No of waiting in time queue + */ + Uint32 noOfWaiters; + + /** Block Reference of retriever */ + BlockReference blockRef; + + /** Id of retriever */ + Uint32 m_senderData; + + /** Table id of retrieved table */ + Uint32 tableId; + + /** Starting page to retrieve data from */ + Uint32 retrievePage; + + /** Number of pages retrieved */ + Uint32 retrievedNoOfPages; + + /** Number of words retrieved */ + Uint32 retrievedNoOfWords; + + /** Number of words sent currently */ + Uint32 currentSent; + + /** + * Long signal stuff + */ + bool m_useLongSig; + }; + RetrieveRecord c_retrieveRecord; + + /** + * This record stores all the information needed + * when a file is being read from disk + * + * This is the info stored in one entry of the schema + * page. Each table has 4 words of info. + * Word 1: Schema version (upper 16 bits) + * Table State (lower 16 bits) + * Word 2: Number of pages of table description + * Word 3: Global checkpoint id table was created + * Word 4: Currently zero + ****************************************************************************/ + struct SchemaRecord { + /** Schema page */ + Uint32 schemaPage; + + /** Old Schema page (used at node restart) */ + Uint32 oldSchemaPage; + + Callback m_callback; + }; + SchemaRecord c_schemaRecord; + + void initSchemaFile(SchemaFile *, Uint32 sz); + void computeChecksum(SchemaFile *); + bool validateChecksum(const SchemaFile *); + SchemaFile::TableEntry * getTableEntry(void * buf, Uint32 tableId, + bool allowTooBig = false); + + Uint32 computeChecksum(const Uint32 * src, Uint32 len); + + + /* ----------------------------------------------------------------------- */ + // Node References + /* ----------------------------------------------------------------------- */ + Uint16 c_masterNodeId; + + /* ----------------------------------------------------------------------- */ + // Various current system properties + /* ----------------------------------------------------------------------- */ + Uint16 c_numberNode; + Uint16 c_noHotSpareNodes; + Uint16 c_noNodesFailed; + Uint32 c_failureNr; + + /* ----------------------------------------------------------------------- */ + // State variables + /* ----------------------------------------------------------------------- */ + + enum BlockState { + BS_IDLE = 0, + BS_CREATE_TAB = 1, + BS_BUSY = 2, + BS_NODE_FAILURE = 3 + }; + BlockState c_blockState; + + struct PackTable { + + enum PackTableState { + PTS_IDLE = 0, + PTS_ADD_TABLE_MASTER = 1, + PTS_ADD_TABLE_SLAVE = 2, + PTS_GET_TAB = 3, + PTS_RESTART = 4 + } m_state; + + } c_packTable; + + Uint32 c_startPhase; + Uint32 c_restartType; + bool c_initialStart; + bool c_systemRestart; + bool c_nodeRestart; + bool c_initialNodeRestart; + Uint32 c_tabinfoReceived; + + /** + * Temporary structure used when parsing table info + */ + struct ParseDictTabInfoRecord { + DictTabInfo::RequestType requestType; + Uint32 errorCode; + Uint32 errorLine; + + SimpleProperties::UnpackStatus status; + Uint32 errorKey; + TableRecordPtr tablePtr; + }; + + // Operation records + + /** + * Common part of operation records. Uses KeyTable2. Note that each + * seize/release invokes ctor/dtor automatically. + */ + struct OpRecordCommon { + Uint32 key; // key shared between master and slaves + Uint32 nextHash; + Uint32 prevHash; + Uint32 hashValue() const { + return key; + } + bool equal(const OpRecordCommon& rec) const { + return key == rec.key; + } + }; + + /** + * Create table record + */ + struct CreateTableRecord : OpRecordCommon { + Uint32 m_senderRef; + Uint32 m_senderData; + Uint32 m_coordinatorRef; + + Uint32 m_errorCode; + void setErrorCode(Uint32 c){ if(m_errorCode == 0) m_errorCode = c;} + + // For alter table + Uint32 m_changeMask; + bool m_alterTableFailed; + AlterTableRef m_alterTableRef; + Uint32 m_alterTableId; + + /* Previous table name (used for reverting failed table rename) */ + char previousTableName[MAX_TAB_NAME_SIZE]; + + Uint32 m_tablePtrI; + Uint32 m_tabInfoPtrI; + Uint32 m_fragmentsPtrI; + + Uint32 m_dihAddFragPtr; // Connect ptr towards DIH + Uint32 m_lqhFragPtr; // Connect ptr towards LQH + + Callback m_callback; // Who's using local create tab + MutexHandle2 m_startLcpMutex; + + struct CoordinatorData { + Uint32 m_gsn; + SafeCounterHandle m_counter; + CreateTabReq::RequestType m_requestType; + } m_coordinatorData; + }; + typedef Ptr CreateTableRecordPtr; + + /** + * Drop table record + */ + struct DropTableRecord : OpRecordCommon { + DropTableReq m_request; + + Uint32 m_requestType; + Uint32 m_coordinatorRef; + + Uint32 m_errorCode; + void setErrorCode(Uint32 c){ if(m_errorCode == 0) m_errorCode = c;} + + /** + * When sending stuff around + */ + struct CoordinatorData { + Uint32 m_gsn; + Uint32 m_block; + SignalCounter m_signalCounter; + } m_coordinatorData; + + struct ParticipantData { + Uint32 m_gsn; + Uint32 m_block; + SignalCounter m_signalCounter; + + Callback m_callback; + } m_participantData; + }; + typedef Ptr DropTableRecordPtr; + + /** + * Request flags passed in signals along with request type and + * propagated across operations. + */ + struct RequestFlag { + enum { + RF_LOCAL = 1 << 0, // create on local node only + RF_NOBUILD = 1 << 1, // no need to build index + RF_NOTCTRIGGER = 1 << 2 // alter trigger: no trigger in TC + }; + }; + + /** + * Operation record for create index. + */ + struct OpCreateIndex : OpRecordCommon { + // original request (index id will be added) + CreateIndxReq m_request; + AttributeList m_attrList; + char m_indexName[MAX_TAB_NAME_SIZE]; + bool m_storedIndex; + // coordinator DICT + Uint32 m_coordinatorRef; + bool m_isMaster; + // state info + CreateIndxReq::RequestType m_requestType; + Uint32 m_requestFlag; + // error info + CreateIndxRef::ErrorCode m_errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + // counters + SignalCounter m_signalCounter; + // ctor + OpCreateIndex() { + memset(&m_request, 0, sizeof(m_request)); + m_coordinatorRef = 0; + m_requestType = CreateIndxReq::RT_UNDEFINED; + m_requestFlag = 0; + m_errorCode = CreateIndxRef::NoError; + m_errorLine = 0; + m_errorNode = 0; + } + void save(const CreateIndxReq* req) { + m_request = *req; + m_requestType = req->getRequestType(); + m_requestFlag = req->getRequestFlag(); + } + bool hasError() { + return m_errorCode != CreateIndxRef::NoError; + } + void setError(const CreateIndxRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + void setError(const CreateTableRef* ref) { + if (ref != 0 && ! hasError()) { + switch (ref->getErrorCode()) { + case CreateTableRef::TableAlreadyExist: + m_errorCode = CreateIndxRef::IndexExists; + break; + default: + m_errorCode = (CreateIndxRef::ErrorCode)ref->getErrorCode(); + break; + } + m_errorLine = ref->getErrorLine(); + } + } + void setError(const AlterIndxRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = (CreateIndxRef::ErrorCode)ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + }; + typedef Ptr OpCreateIndexPtr; + + /** + * Operation record for drop index. + */ + struct OpDropIndex : OpRecordCommon { + // original request + DropIndxReq m_request; + // coordinator DICT + Uint32 m_coordinatorRef; + bool m_isMaster; + // state info + DropIndxReq::RequestType m_requestType; + Uint32 m_requestFlag; + // error info + DropIndxRef::ErrorCode m_errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + // counters + SignalCounter m_signalCounter; + // ctor + OpDropIndex() { + memset(&m_request, 0, sizeof(m_request)); + m_coordinatorRef = 0; + m_requestType = DropIndxReq::RT_UNDEFINED; + m_requestFlag = 0; + m_errorCode = DropIndxRef::NoError; + m_errorLine = 0; + m_errorNode = 0; + } + void save(const DropIndxReq* req) { + m_request = *req; + m_requestType = req->getRequestType(); + m_requestFlag = req->getRequestFlag(); + } + bool hasError() { + return m_errorCode != DropIndxRef::NoError; + } + void setError(const DropIndxRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + void setError(const AlterIndxRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = (DropIndxRef::ErrorCode)ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + void setError(const DropTableRef* ref) { + if (ref != 0 && ! hasError()) { + switch(ref->errorCode) { + case(DropTableRef::Busy): + m_errorCode = DropIndxRef::Busy; + break; + case(DropTableRef::NoSuchTable): + m_errorCode = DropIndxRef::IndexNotFound; + break; + case(DropTableRef::DropInProgress): + m_errorCode = DropIndxRef::Busy; + break; + case(DropTableRef::NoDropTableRecordAvailable): + m_errorCode = DropIndxRef::Busy; + break; + default: + m_errorCode = (DropIndxRef::ErrorCode)ref->errorCode; + break; + } + //m_errorLine = ref->getErrorLine(); + //m_errorNode = ref->getErrorNode(); + } + } + }; + typedef Ptr OpDropIndexPtr; + + /** + * Operation record for alter index. + */ + struct OpAlterIndex : OpRecordCommon { + // original request plus buffer for attribute lists + AlterIndxReq m_request; + AttributeList m_attrList; + AttributeList m_tableKeyList; + // coordinator DICT + Uint32 m_coordinatorRef; + bool m_isMaster; + // state info + AlterIndxReq::RequestType m_requestType; + Uint32 m_requestFlag; + // error info + AlterIndxRef::ErrorCode m_errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + // counters + SignalCounter m_signalCounter; + Uint32 m_triggerCounter; + // ctor + OpAlterIndex() { + memset(&m_request, 0, sizeof(m_request)); + m_coordinatorRef = 0; + m_requestType = AlterIndxReq::RT_UNDEFINED; + m_requestFlag = 0; + m_errorCode = AlterIndxRef::NoError; + m_errorLine = 0; + m_errorNode = 0; + m_triggerCounter = 0; + } + void save(const AlterIndxReq* req) { + m_request = *req; + m_requestType = req->getRequestType(); + m_requestFlag = req->getRequestFlag(); + } + bool hasError() { + return m_errorCode != AlterIndxRef::NoError; + } + void setError(const AlterIndxRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + void setError(const CreateIndxRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = (AlterIndxRef::ErrorCode)ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + void setError(const DropIndxRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = (AlterIndxRef::ErrorCode)ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + void setError(const BuildIndxRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = (AlterIndxRef::ErrorCode)ref->getErrorCode(); + } + } + void setError(const CreateTrigRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = (AlterIndxRef::ErrorCode)ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + void setError(const DropTrigRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = (AlterIndxRef::ErrorCode)ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + }; + typedef Ptr OpAlterIndexPtr; + + /** + * Operation record for build index. + */ + struct OpBuildIndex : OpRecordCommon { + // original request plus buffer for attribute lists + BuildIndxReq m_request; + AttributeList m_attrList; + AttributeList m_tableKeyList; + // coordinator DICT + Uint32 m_coordinatorRef; + bool m_isMaster; + // state info + BuildIndxReq::RequestType m_requestType; + Uint32 m_requestFlag; + Uint32 m_constrTriggerId; + // error info + BuildIndxRef::ErrorCode m_errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + // counters + SignalCounter m_signalCounter; + // ctor + OpBuildIndex() { + memset(&m_request, 0, sizeof(m_request)); + m_coordinatorRef = 0; + m_requestType = BuildIndxReq::RT_UNDEFINED; + m_requestFlag = 0; +// Uint32 m_constrTriggerId = RNIL; + m_errorCode = BuildIndxRef::NoError; + m_errorLine = 0; + m_errorNode = 0; + } + void save(const BuildIndxReq* req) { + m_request = *req; + m_requestType = req->getRequestType(); + m_requestFlag = req->getRequestFlag(); + } + bool hasError() { + return m_errorCode != BuildIndxRef::NoError; + } + void setError(const BuildIndxRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = ref->getErrorCode(); + } + } + void setError(const AlterIndxRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = (BuildIndxRef::ErrorCode)ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + void setError(const CreateTrigRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = (BuildIndxRef::ErrorCode)ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + void setError(const DropTrigRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = (BuildIndxRef::ErrorCode)ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + }; + typedef Ptr OpBuildIndexPtr; + + /** + * Operation record for Util Signals. + */ + struct OpSignalUtil : OpRecordCommon{ + Callback m_callback; + Uint32 m_userData; + }; + typedef Ptr OpSignalUtilPtr; + + /** + * Operation record for subscribe-start-stop + */ + struct OpSubEvent : OpRecordCommon { + Uint32 m_senderRef; + Uint32 m_senderData; + Uint32 m_errorCode; + RequestTracker m_reqTracker; + }; + typedef Ptr OpSubEventPtr; + + /** + * Systable NDB$EVENTS_0 + */ + +#define EVENT_SYSTEM_TABLE_NAME "sys/def/NDB$EVENTS_0" +#define EVENT_SYSTEM_TABLE_LENGTH 6 + + struct sysTab_NDBEVENTS_0 { + char NAME[MAX_TAB_NAME_SIZE]; + Uint32 EVENT_TYPE; + char TABLE_NAME[MAX_TAB_NAME_SIZE]; + Uint32 ATTRIBUTE_MASK[MAXNROFATTRIBUTESINWORDS]; + Uint32 SUBID; + Uint32 SUBKEY; + }; + + static const Uint32 sysTab_NDBEVENTS_0_szs[]; + + /** + * Operation record for create event. + */ + struct OpCreateEvent : OpRecordCommon { + // original request (event id will be added) + CreateEvntReq m_request; + //AttributeMask m_attrListBitmask; + // AttributeList m_attrList; + sysTab_NDBEVENTS_0 m_eventRec; + // char m_eventName[MAX_TAB_NAME_SIZE]; + // char m_tableName[MAX_TAB_NAME_SIZE]; + + // coordinator DICT + RequestTracker m_reqTracker; + // state info + CreateEvntReq::RequestType m_requestType; + Uint32 m_requestFlag; + // error info + CreateEvntRef::ErrorCode m_errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + // ctor + OpCreateEvent() { + memset(&m_request, 0, sizeof(m_request)); + m_requestType = CreateEvntReq::RT_UNDEFINED; + m_requestFlag = 0; + m_errorCode = CreateEvntRef::NoError; + m_errorLine = 0; + m_errorNode = 0; + } + void init(const CreateEvntReq* req, Dbdict* dp) { + m_request = *req; + m_errorCode = CreateEvntRef::NoError; + m_errorLine = 0; + m_errorNode = 0; + m_requestType = req->getRequestType(); + m_requestFlag = req->getRequestFlag(); + } + bool hasError() { + return m_errorCode != CreateEvntRef::NoError; + } + void setError(const CreateEvntRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + + }; + typedef Ptr OpCreateEventPtr; + + /** + * Operation record for drop event. + */ + struct OpDropEvent : OpRecordCommon { + // original request + DropEvntReq m_request; + // char m_eventName[MAX_TAB_NAME_SIZE]; + sysTab_NDBEVENTS_0 m_eventRec; + RequestTracker m_reqTracker; + // error info + DropEvntRef::ErrorCode m_errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + // ctor + OpDropEvent() { + memset(&m_request, 0, sizeof(m_request)); + m_errorCode = DropEvntRef::NoError; + m_errorLine = 0; + m_errorNode = 0; + } + void init(const DropEvntReq* req) { + m_request = *req; + m_errorCode = DropEvntRef::NoError; + m_errorLine = 0; + m_errorNode = 0; + } + bool hasError() { + return m_errorCode != DropEvntRef::NoError; + } + void setError(const DropEvntRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + }; + typedef Ptr OpDropEventPtr; + + /** + * Operation record for create trigger. + */ + struct OpCreateTrigger : OpRecordCommon { + // original request (trigger id will be added) + CreateTrigReq m_request; + char m_triggerName[MAX_TAB_NAME_SIZE]; + // coordinator DICT + Uint32 m_coordinatorRef; + bool m_isMaster; + // state info + CreateTrigReq::RequestType m_requestType; + Uint32 m_requestFlag; + // error info + CreateTrigRef::ErrorCode m_errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + // counters + SignalCounter m_signalCounter; + // ctor + OpCreateTrigger() { + memset(&m_request, 0, sizeof(m_request)); + m_coordinatorRef = 0; + m_requestType = CreateTrigReq::RT_UNDEFINED; + m_requestFlag = 0; + m_errorCode = CreateTrigRef::NoError; + m_errorLine = 0; + m_errorNode = 0; + } + void save(const CreateTrigReq* req) { + m_request = *req; + m_requestType = req->getRequestType(); + m_requestFlag = req->getRequestFlag(); + } + bool hasError() { + return m_errorCode != CreateTrigRef::NoError; + } + void setError(const CreateTrigRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + void setError(const AlterTrigRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = (CreateTrigRef::ErrorCode)ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + }; + typedef Ptr OpCreateTriggerPtr; + + /** + * Operation record for drop trigger. + */ + struct OpDropTrigger : OpRecordCommon { + // original request + DropTrigReq m_request; + // coordinator DICT + Uint32 m_coordinatorRef; + bool m_isMaster; + // state info + DropTrigReq::RequestType m_requestType; + Uint32 m_requestFlag; + // error info + DropTrigRef::ErrorCode m_errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + // counters + SignalCounter m_signalCounter; + // ctor + OpDropTrigger() { + memset(&m_request, 0, sizeof(m_request)); + m_coordinatorRef = 0; + m_requestType = DropTrigReq::RT_UNDEFINED; + m_requestFlag = 0; + m_errorCode = DropTrigRef::NoError; + m_errorLine = 0; + m_errorNode = 0; + } + void save(const DropTrigReq* req) { + m_request = *req; + m_requestType = req->getRequestType(); + m_requestFlag = req->getRequestFlag(); + } + bool hasError() { + return m_errorCode != DropTrigRef::NoError; + } + void setError(const DropTrigRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + void setError(const AlterTrigRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = (DropTrigRef::ErrorCode)ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + }; + typedef Ptr OpDropTriggerPtr; + + /** + * Operation record for alter trigger. + */ + struct OpAlterTrigger : OpRecordCommon { + // original request + AlterTrigReq m_request; + // nodes participating in operation + NdbNodeBitmask m_nodes; + // coordinator DICT + Uint32 m_coordinatorRef; + bool m_isMaster; + // state info + AlterTrigReq::RequestType m_requestType; + Uint32 m_requestFlag; + // error info + AlterTrigRef::ErrorCode m_errorCode; + Uint32 m_errorLine; + Uint32 m_errorNode; + // counters + SignalCounter m_signalCounter; + // ctor + OpAlterTrigger() { + memset(&m_request, 0, sizeof(m_request)); + m_coordinatorRef = 0; + m_requestType = AlterTrigReq::RT_UNDEFINED; + m_requestFlag = 0; + m_errorCode = AlterTrigRef::NoError; + m_errorLine = 0; + m_errorNode = 0; + } + void save(const AlterTrigReq* req) { + m_request = *req; + m_requestType = req->getRequestType(); + m_requestFlag = req->getRequestFlag(); + } + bool hasError() { + return m_errorCode != AlterTrigRef::NoError; + } + void setError(const AlterTrigRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = (AlterTrigRef::ErrorCode)ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + void setError(const CreateTrigRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = (AlterTrigRef::ErrorCode)ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + void setError(const DropTrigRef* ref) { + if (ref != 0 && ! hasError()) { + m_errorCode = (AlterTrigRef::ErrorCode)ref->getErrorCode(); + m_errorLine = ref->getErrorLine(); + m_errorNode = ref->getErrorNode(); + } + } + }; + typedef Ptr OpAlterTriggerPtr; + + // Common operation record pool +public: + static const size_t opCreateTableSize = sizeof(CreateTableRecord); + static const size_t opDropTableSize = sizeof(DropTableRecord); + static const size_t opCreateIndexSize = sizeof(OpCreateIndex); + static const size_t opDropIndexSize = sizeof(OpDropIndex); + static const size_t opAlterIndexSize = sizeof(OpAlterIndex); + static const size_t opBuildIndexSize = sizeof(OpBuildIndex); + static const size_t opCreateEventSize = sizeof(OpCreateEvent); + static const size_t opSubEventSize = sizeof(OpSubEvent); + static const size_t opDropEventSize = sizeof(OpDropEvent); + static const size_t opSignalUtilSize = sizeof(OpSignalUtil); + static const size_t opCreateTriggerSize = sizeof(OpCreateTrigger); + static const size_t opDropTriggerSize = sizeof(OpDropTrigger); + static const size_t opAlterTriggerSize = sizeof(OpAlterTrigger); +private: +#define PTR_ALIGN(n) ((((n)+sizeof(void*)-1)>>2)&~((sizeof(void*)-1)>>2)) + union OpRecordUnion { + Uint32 u_opCreateTable [PTR_ALIGN(opCreateTableSize)]; + Uint32 u_opDropTable [PTR_ALIGN(opDropTableSize)]; + Uint32 u_opCreateIndex [PTR_ALIGN(opCreateIndexSize)]; + Uint32 u_opDropIndex [PTR_ALIGN(opDropIndexSize)]; + Uint32 u_opCreateEvent [PTR_ALIGN(opCreateEventSize)]; + Uint32 u_opSubEvent [PTR_ALIGN(opSubEventSize)]; + Uint32 u_opDropEvent [PTR_ALIGN(opDropEventSize)]; + Uint32 u_opSignalUtil [PTR_ALIGN(opSignalUtilSize)]; + Uint32 u_opAlterIndex [PTR_ALIGN(opAlterIndexSize)]; + Uint32 u_opBuildIndex [PTR_ALIGN(opBuildIndexSize)]; + Uint32 u_opCreateTrigger[PTR_ALIGN(opCreateTriggerSize)]; + Uint32 u_opDropTrigger [PTR_ALIGN(opDropTriggerSize)]; + Uint32 u_opAlterTrigger [PTR_ALIGN(opAlterTriggerSize)]; + Uint32 nextPool; + }; + ArrayPool c_opRecordPool; + + // Operation records + KeyTable2 c_opCreateTable; + KeyTable2 c_opDropTable; + KeyTable2 c_opCreateIndex; + KeyTable2 c_opDropIndex; + KeyTable2 c_opAlterIndex; + KeyTable2 c_opBuildIndex; + KeyTable2 c_opCreateEvent; + KeyTable2 c_opSubEvent; + KeyTable2 c_opDropEvent; + KeyTable2 c_opSignalUtil; + KeyTable2 c_opCreateTrigger; + KeyTable2 c_opDropTrigger; + KeyTable2 c_opAlterTrigger; + + // Unique key for operation XXX move to some system table + Uint32 c_opRecordSequence; + + // Statement blocks + + /* ------------------------------------------------------------ */ + // Start/Restart Handling + /* ------------------------------------------------------------ */ + void sendSTTORRY(Signal* signal); + void sendNDB_STTORRY(Signal* signal); + void initSchemaFile(Signal* signal); + + /* ------------------------------------------------------------ */ + // Drop Table Handling + /* ------------------------------------------------------------ */ + void releaseTableObject(Uint32 tableId, bool removeFromHash = true); + + /* ------------------------------------------------------------ */ + // General Stuff + /* ------------------------------------------------------------ */ + Uint32 getFreeTableRecord(Uint32 primaryTableId); + Uint32 getFreeTriggerRecord(); + bool getNewAttributeRecord(TableRecordPtr tablePtr, + AttributeRecordPtr & attrPtr); + void packTableIntoPages(Signal* signal, Uint32 tableId, Uint32 pageId); + void packTableIntoPagesImpl(SimpleProperties::Writer &, TableRecordPtr); + + void sendGET_TABINFOREQ(Signal* signal, + Uint32 tableId); + void sendTC_SCHVERREQ(Signal* signal, + Uint32 tableId, + BlockReference tcRef); + + /* ------------------------------------------------------------ */ + // System Restart Handling + /* ------------------------------------------------------------ */ + void initSendSchemaData(Signal* signal); + void sendSchemaData(Signal* signal); + Uint32 sendSCHEMA_INFO(Signal* signal, Uint32 nodeId, Uint32* pagePointer); + void checkSchemaStatus(Signal* signal); + void sendDIHSTARTTAB_REQ(Signal* signal); + + /* ------------------------------------------------------------ */ + // Receive Table Handling + /* ------------------------------------------------------------ */ + void handleTabInfoInit(SimpleProperties::Reader &, + ParseDictTabInfoRecord *, + bool checkExist = true); + void handleTabInfo(SimpleProperties::Reader & it, ParseDictTabInfoRecord *); + + void handleAddTableFailure(Signal* signal, + Uint32 failureLine, + Uint32 tableId); + bool verifyTableCorrect(Signal* signal, Uint32 tableId); + + /* ------------------------------------------------------------ */ + // Add Table Handling + /* ------------------------------------------------------------ */ + + /* ------------------------------------------------------------ */ + // Add Fragment Handling + /* ------------------------------------------------------------ */ + void sendLQHADDATTRREQ(Signal*, CreateTableRecordPtr, Uint32 attributePtrI); + + /* ------------------------------------------------------------ */ + // Read/Write Schema and Table files + /* ------------------------------------------------------------ */ + void updateSchemaState(Signal* signal, Uint32 tableId, + SchemaFile::TableEntry*, Callback*); + void startWriteSchemaFile(Signal* signal); + void openSchemaFile(Signal* signal, + Uint32 fileNo, + Uint32 fsPtr, + bool writeFlag); + void writeSchemaFile(Signal* signal, Uint32 filePtr, Uint32 fsPtr); + void writeSchemaConf(Signal* signal, + FsConnectRecordPtr fsPtr); + void closeFile(Signal* signal, Uint32 filePtr, Uint32 fsPtr); + void closeWriteSchemaConf(Signal* signal, + FsConnectRecordPtr fsPtr); + void initSchemaFile_conf(Signal* signal, Uint32 i, Uint32 returnCode); + + void writeTableFile(Signal* signal, Uint32 tableId, + SegmentedSectionPtr tabInfo, Callback*); + void startWriteTableFile(Signal* signal, Uint32 tableId); + void openTableFile(Signal* signal, + Uint32 fileNo, + Uint32 fsPtr, + Uint32 tableId, + bool writeFlag); + void writeTableFile(Signal* signal, Uint32 filePtr, Uint32 fsPtr); + void writeTableConf(Signal* signal, + FsConnectRecordPtr fsPtr); + void closeWriteTableConf(Signal* signal, + FsConnectRecordPtr fsPtr); + + void startReadTableFile(Signal* signal, Uint32 tableId); + void openReadTableRef(Signal* signal, + FsConnectRecordPtr fsPtr); + void readTableFile(Signal* signal, Uint32 filePtr, Uint32 fsPtr); + void readTableConf(Signal* signal, + FsConnectRecordPtr fsPtr); + void readTableRef(Signal* signal, + FsConnectRecordPtr fsPtr); + void closeReadTableConf(Signal* signal, + FsConnectRecordPtr fsPtr); + + void startReadSchemaFile(Signal* signal); + void openReadSchemaRef(Signal* signal, + FsConnectRecordPtr fsPtr); + void readSchemaFile(Signal* signal, Uint32 filePtr, Uint32 fsPtr); + void readSchemaConf(Signal* signal, FsConnectRecordPtr fsPtr); + void readSchemaRef(Signal* signal, FsConnectRecordPtr fsPtr); + void closeReadSchemaConf(Signal* signal, + FsConnectRecordPtr fsPtr); + + /* ------------------------------------------------------------ */ + // Get table definitions + /* ------------------------------------------------------------ */ + void sendGET_TABINFOREF(Signal* signal, + GetTabInfoReq*, + GetTabInfoRef::ErrorCode errorCode); + + void sendGET_TABLEID_REF(Signal* signal, + GetTableIdReq * req, + GetTableIdRef::ErrorCode errorCode); + + void sendGetTabResponse(Signal* signal); + + /* ------------------------------------------------------------ */ + // Indexes and triggers + /* ------------------------------------------------------------ */ + + // reactivate and rebuild indexes on start up + void activateIndexes(Signal* signal, Uint32 i); + void rebuildIndexes(Signal* signal, Uint32 i); + + // create index + void createIndex_recvReply(Signal* signal, const CreateIndxConf* conf, + const CreateIndxRef* ref); + void createIndex_slavePrepare(Signal* signal, OpCreateIndexPtr opPtr); + void createIndex_toCreateTable(Signal* signal, OpCreateIndexPtr opPtr); + void createIndex_fromCreateTable(Signal* signal, OpCreateIndexPtr opPtr); + void createIndex_toAlterIndex(Signal* signal, OpCreateIndexPtr opPtr); + void createIndex_fromAlterIndex(Signal* signal, OpCreateIndexPtr opPtr); + void createIndex_slaveCommit(Signal* signal, OpCreateIndexPtr opPtr); + void createIndex_slaveAbort(Signal* signal, OpCreateIndexPtr opPtr); + void createIndex_sendSlaveReq(Signal* signal, OpCreateIndexPtr opPtr); + void createIndex_sendReply(Signal* signal, OpCreateIndexPtr opPtr, bool); + // drop index + void dropIndex_recvReply(Signal* signal, const DropIndxConf* conf, + const DropIndxRef* ref); + void dropIndex_slavePrepare(Signal* signal, OpDropIndexPtr opPtr); + void dropIndex_toAlterIndex(Signal* signal, OpDropIndexPtr opPtr); + void dropIndex_fromAlterIndex(Signal* signal, OpDropIndexPtr opPtr); + void dropIndex_toDropTable(Signal* signal, OpDropIndexPtr opPtr); + void dropIndex_fromDropTable(Signal* signal, OpDropIndexPtr opPtr); + void dropIndex_slaveCommit(Signal* signal, OpDropIndexPtr opPtr); + void dropIndex_slaveAbort(Signal* signal, OpDropIndexPtr opPtr); + void dropIndex_sendSlaveReq(Signal* signal, OpDropIndexPtr opPtr); + void dropIndex_sendReply(Signal* signal, OpDropIndexPtr opPtr, bool); + // alter index + void alterIndex_recvReply(Signal* signal, const AlterIndxConf* conf, + const AlterIndxRef* ref); + void alterIndex_slavePrepare(Signal* signal, OpAlterIndexPtr opPtr); + void alterIndex_toCreateTc(Signal* signal, OpAlterIndexPtr opPtr); + void alterIndex_fromCreateTc(Signal* signal, OpAlterIndexPtr opPtr); + void alterIndex_toDropTc(Signal* signal, OpAlterIndexPtr opPtr); + void alterIndex_fromDropTc(Signal* signal, OpAlterIndexPtr opPtr); + void alterIndex_toCreateTrigger(Signal* signal, OpAlterIndexPtr opPtr); + void alterIndex_fromCreateTrigger(Signal* signal, OpAlterIndexPtr opPtr); + void alterIndex_toDropTrigger(Signal* signal, OpAlterIndexPtr opPtr); + void alterIndex_fromDropTrigger(Signal* signal, OpAlterIndexPtr opPtr); + void alterIndex_toBuildIndex(Signal* signal, OpAlterIndexPtr opPtr); + void alterIndex_fromBuildIndex(Signal* signal, OpAlterIndexPtr opPtr); + void alterIndex_slaveCommit(Signal* signal, OpAlterIndexPtr opPtr); + void alterIndex_slaveAbort(Signal* signal, OpAlterIndexPtr opPtr); + void alterIndex_sendSlaveReq(Signal* signal, OpAlterIndexPtr opPtr); + void alterIndex_sendReply(Signal* signal, OpAlterIndexPtr opPtr, bool); + // build index + void buildIndex_recvReply(Signal* signal, const BuildIndxConf* conf, + const BuildIndxRef* ref); + void buildIndex_toCreateConstr(Signal* signal, OpBuildIndexPtr opPtr); + void buildIndex_fromCreateConstr(Signal* signal, OpBuildIndexPtr opPtr); + void buildIndex_buildTrix(Signal* signal, OpBuildIndexPtr opPtr); + void buildIndex_toDropConstr(Signal* signal, OpBuildIndexPtr opPtr); + void buildIndex_fromDropConstr(Signal* signal, OpBuildIndexPtr opPtr); + void buildIndex_toOnline(Signal* signal, OpBuildIndexPtr opPtr); + void buildIndex_fromOnline(Signal* signal, OpBuildIndexPtr opPtr); + void buildIndex_sendSlaveReq(Signal* signal, OpBuildIndexPtr opPtr); + void buildIndex_sendReply(Signal* signal, OpBuildIndexPtr opPtr, bool); + + // Events + void + createEventUTIL_PREPARE(Signal* signal, + Uint32 callbackData, + Uint32 returnCode); + void + createEventUTIL_EXECUTE(Signal *signal, + Uint32 callbackData, + Uint32 returnCode); + void + dropEventUTIL_PREPARE_READ(Signal* signal, + Uint32 callbackData, + Uint32 returnCode); + void + dropEventUTIL_EXECUTE_READ(Signal* signal, + Uint32 callbackData, + Uint32 returnCode); + void + dropEventUTIL_PREPARE_DELETE(Signal* signal, + Uint32 callbackData, + Uint32 returnCode); + void + dropEventUTIL_EXECUTE_DELETE(Signal *signal, + Uint32 callbackData, + Uint32 returnCode); + void + dropEventUtilPrepareRef(Signal* signal, + Uint32 callbackData, + Uint32 returnCode); + void + dropEventUtilExecuteRef(Signal* signal, + Uint32 callbackData, + Uint32 returnCode); + int + sendSignalUtilReq(Callback *c, + BlockReference ref, + GlobalSignalNumber gsn, + Signal* signal, + Uint32 length, + JobBufferLevel jbuf, + LinearSectionPtr ptr[3], + Uint32 noOfSections); + int + recvSignalUtilReq(Signal* signal, Uint32 returnCode); + + void completeSubStartReq(Signal* signal, Uint32 ptrI, Uint32 returnCode); + void completeSubStopReq(Signal* signal, Uint32 ptrI, Uint32 returnCode); + void completeSubRemoveReq(Signal* signal, Uint32 ptrI, Uint32 returnCode); + + void dropEvent_sendReply(Signal* signal, + OpDropEventPtr evntRecPtr); + + void createEvent_RT_USER_CREATE(Signal* signal, OpCreateEventPtr evntRecPtr); + void createEventComplete_RT_USER_CREATE(Signal* signal, + OpCreateEventPtr evntRecPtr); + void createEvent_RT_USER_GET(Signal* signal, OpCreateEventPtr evntRecPtr); + void createEventComplete_RT_USER_GET(Signal* signal, OpCreateEventPtr evntRecPtr); + + void createEvent_RT_DICT_AFTER_GET(Signal* signal, OpCreateEventPtr evntRecPtr); + + void createEvent_nodeFailCallback(Signal* signal, Uint32 eventRecPtrI, + Uint32 returnCode); + void createEvent_sendReply(Signal* signal, OpCreateEventPtr evntRecPtr, + LinearSectionPtr *ptr = NULL, int noLSP = 0); + + void prepareTransactionEventSysTable (Callback *c, + Signal* signal, + Uint32 senderData, + UtilPrepareReq::OperationTypeValue prepReq); + void prepareUtilTransaction(Callback *c, + Signal* signal, + Uint32 senderData, + Uint32 tableId, + const char *tableName, + UtilPrepareReq::OperationTypeValue prepReq, + Uint32 noAttr, + Uint32 attrIds[], + const char *attrNames[]); + + void executeTransEventSysTable(Callback *c, + Signal *signal, + const Uint32 ptrI, + sysTab_NDBEVENTS_0& m_eventRec, + const Uint32 prepareId, + UtilPrepareReq::OperationTypeValue prepReq); + void executeTransaction(Callback *c, + Signal* signal, + Uint32 senderData, + Uint32 prepareId, + Uint32 noAttr, + LinearSectionPtr headerPtr, + LinearSectionPtr dataPtr); + + void parseReadEventSys(Signal *signal, sysTab_NDBEVENTS_0& m_eventRec); + + // create trigger + void createTrigger_recvReply(Signal* signal, const CreateTrigConf* conf, + const CreateTrigRef* ref); + void createTrigger_slavePrepare(Signal* signal, OpCreateTriggerPtr opPtr); + void createTrigger_masterSeize(Signal* signal, OpCreateTriggerPtr opPtr); + void createTrigger_slaveCreate(Signal* signal, OpCreateTriggerPtr opPtr); + void createTrigger_toAlterTrigger(Signal* signal, OpCreateTriggerPtr opPtr); + void createTrigger_fromAlterTrigger(Signal* signal, OpCreateTriggerPtr opPtr); + void createTrigger_slaveCommit(Signal* signal, OpCreateTriggerPtr opPtr); + void createTrigger_slaveAbort(Signal* signal, OpCreateTriggerPtr opPtr); + void createTrigger_sendSlaveReq(Signal* signal, OpCreateTriggerPtr opPtr); + void createTrigger_sendReply(Signal* signal, OpCreateTriggerPtr opPtr, bool); + // drop trigger + void dropTrigger_recvReply(Signal* signal, const DropTrigConf* conf, + const DropTrigRef* ref); + void dropTrigger_slavePrepare(Signal* signal, OpDropTriggerPtr opPtr); + void dropTrigger_toAlterTrigger(Signal* signal, OpDropTriggerPtr opPtr); + void dropTrigger_fromAlterTrigger(Signal* signal, OpDropTriggerPtr opPtr); + void dropTrigger_slaveCommit(Signal* signal, OpDropTriggerPtr opPtr); + void dropTrigger_slaveAbort(Signal* signal, OpDropTriggerPtr opPtr); + void dropTrigger_sendSlaveReq(Signal* signal, OpDropTriggerPtr opPtr); + void dropTrigger_sendReply(Signal* signal, OpDropTriggerPtr opPtr, bool); + // alter trigger + void alterTrigger_recvReply(Signal* signal, const AlterTrigConf* conf, + const AlterTrigRef* ref); + void alterTrigger_slavePrepare(Signal* signal, OpAlterTriggerPtr opPtr); + void alterTrigger_toCreateLocal(Signal* signal, OpAlterTriggerPtr opPtr); + void alterTrigger_fromCreateLocal(Signal* signal, OpAlterTriggerPtr opPtr); + void alterTrigger_toDropLocal(Signal* signal, OpAlterTriggerPtr opPtr); + void alterTrigger_fromDropLocal(Signal* signal, OpAlterTriggerPtr opPtr); + void alterTrigger_slaveCommit(Signal* signal, OpAlterTriggerPtr opPtr); + void alterTrigger_slaveAbort(Signal* signal, OpAlterTriggerPtr opPtr); + void alterTrigger_sendSlaveReq(Signal* signal, OpAlterTriggerPtr opPtr); + void alterTrigger_sendReply(Signal* signal, OpAlterTriggerPtr opPtr, bool); + // support + void getTableKeyList(TableRecordPtr tablePtr, AttributeList& list); + void getIndexAttr(TableRecordPtr indexPtr, Uint32 itAttr, Uint32* id); + void getIndexAttrList(TableRecordPtr indexPtr, AttributeList& list); + void getIndexAttrMask(TableRecordPtr indexPtr, AttributeMask& mask); + + /* ------------------------------------------------------------ */ + // Initialisation + /* ------------------------------------------------------------ */ + void initCommonData(); + void initRecords(); + void initConnectRecord(); + void initRetrieveRecord(Signal*, Uint32, Uint32 returnCode); + void initSchemaRecord(); + void initRestartRecord(); + void initSendSchemaRecord(); + void initReadTableRecord(); + void initWriteTableRecord(); + void initReadSchemaRecord(); + void initWriteSchemaRecord(); + + void initNodeRecords(); + void initTableRecords(); + void initialiseTableRecord(TableRecordPtr tablePtr); + void initTriggerRecords(); + void initialiseTriggerRecord(TriggerRecordPtr triggerPtr); + void initPageRecords(); + + Uint32 getFsConnRecord(); + + bool getIsFailed(Uint32 nodeId) const; + + void dropTableRef(Signal * signal, DropTableReq *, DropTableRef::ErrorCode); + void printTables(); // For debugging only + int handleAlterTab(AlterTabReq * req, + CreateTableRecord * regAlterTabPtr, + TableRecordPtr origTablePtr, + TableRecordPtr newTablePtr); + void revertAlterTable(Signal * signal, + Uint32 changeMask, + Uint32 tableId, + CreateTableRecord * regAlterTabPtr); + void alterTableRef(Signal * signal, + AlterTableReq *, AlterTableRef::ErrorCode, + ParseDictTabInfoRecord* parseRecord = NULL); + void alterTabRef(Signal * signal, + AlterTabReq *, AlterTableRef::ErrorCode, + ParseDictTabInfoRecord* parseRecord = NULL); + void alterTab_writeSchemaConf(Signal* signal, + Uint32 callbackData, + Uint32 returnCode); + void alterTab_writeTableConf(Signal* signal, + Uint32 callbackData, + Uint32 returnCode); + + void prepDropTab_nextStep(Signal* signal, DropTableRecordPtr); + void prepDropTab_complete(Signal* signal, DropTableRecordPtr); + void prepDropTab_writeSchemaConf(Signal* signal, Uint32 dropTabPtrI, Uint32); + + void dropTab_localDROP_TAB_CONF(Signal* signal); + void dropTab_nextStep(Signal* signal, DropTableRecordPtr); + void dropTab_complete(Signal* signal, Uint32 dropTabPtrI, Uint32); + void dropTab_writeSchemaConf(Signal* signal, Uint32 dropTabPtrI, Uint32); + + void createTab_prepare(Signal* signal, CreateTabReq * req); + void createTab_writeSchemaConf1(Signal* signal, Uint32 callback, Uint32); + void createTab_writeTableConf(Signal* signal, Uint32 callbackData, Uint32); + void createTab_dih(Signal*, CreateTableRecordPtr, + SegmentedSectionPtr, Callback*); + void createTab_dihComplete(Signal* signal, Uint32 callbackData, Uint32); + + void createTab_startLcpMutex_locked(Signal* signal, Uint32, Uint32); + void createTab_startLcpMutex_unlocked(Signal* signal, Uint32, Uint32); + + void createTab_commit(Signal* signal, CreateTabReq * req); + void createTab_writeSchemaConf2(Signal* signal, Uint32 callbackData, Uint32); + void createTab_alterComplete(Signal*, Uint32 callbackData, Uint32); + + void createTab_drop(Signal* signal, CreateTabReq * req); + void createTab_dropComplete(Signal* signal, Uint32 callbackData, Uint32); + + void createTab_reply(Signal* signal, CreateTableRecordPtr, Uint32 nodeId); + void alterTab_activate(Signal*, CreateTableRecordPtr, Callback*); + + void restartCreateTab(Signal*, Uint32, const SchemaFile::TableEntry *, bool); + void restartCreateTab_readTableConf(Signal* signal, Uint32 callback, Uint32); + void restartCreateTab_writeTableConf(Signal* signal, Uint32 callback, Uint32); + void restartCreateTab_dihComplete(Signal* signal, Uint32 callback, Uint32); + void restartCreateTab_activateComplete(Signal*, Uint32 callback, Uint32); + + void restartDropTab(Signal* signal, Uint32 tableId); + void restartDropTab_complete(Signal*, Uint32 callback, Uint32); + + void restart_checkSchemaStatusComplete(Signal*, Uint32 callback, Uint32); + void restart_writeSchemaConf(Signal*, Uint32 callbackData, Uint32); + void masterRestart_checkSchemaStatusComplete(Signal*, Uint32, Uint32); + + void sendSchemaComplete(Signal*, Uint32 callbackData, Uint32); + + // global metadata support + friend class MetaData; + int getMetaTablePtr(TableRecordPtr& tablePtr, Uint32 tableId, Uint32 tableVersion); + int getMetaTable(MetaData::Table& table, Uint32 tableId, Uint32 tableVersion); + int getMetaTable(MetaData::Table& table, const char* tableName); + int getMetaAttribute(MetaData::Attribute& attribute, const MetaData::Table& table, Uint32 attributeId); + int getMetaAttribute(MetaData::Attribute& attribute, const MetaData::Table& table, const char* attributeName); +}; + +#endif diff --git a/ndb/src/kernel/blocks/dbdict/Dbdict.txt b/ndb/src/kernel/blocks/dbdict/Dbdict.txt new file mode 100644 index 00000000000..8d4267a1c42 --- /dev/null +++ b/ndb/src/kernel/blocks/dbdict/Dbdict.txt @@ -0,0 +1,88 @@ + +Event creation + +USER DICT(Master) UTIL SUMA +================================================================================ +CREATE_EVENT_REQ::create +--------------------------> + - Get ID + CREATE_SUBID + -----------------------------------------------> + <----------------------------------------------- + - insert into system table + UTIL_PREPARE::insert + ------------------------> + <------------------------ + UTIL_EXECUTE + ------------------------> + <------------------------ +CREATE_EVENT_CONF +<-------------------------- + + +Event dropping + +USER DICT(Master) UTIL SUMA +================================================================================ +DROP_EVENT_REQ +--------------------------> + - remove from system table + UTIL_PREPARE::delete + ------------------------> + <------------------------ + UTIL_EXECUTE + ------------------------> + <------------------------ +DROP_EVENT_CONF +<-------------------------- + + + +create NdbEventOperation + +USER DICT(Master) (Slaves) UTIL +======================================================================= +CREATE_EVENT_REQ::get +--------------------------> + - read from system table + UTIL_PREPARE::read + ----------------------------------------> + <---------------------------------------- + UTIL_EXECUTE + ----------------------------------------> + <---------------------------------------- + SUMA + CREATE_EVENT_REQ::after_get ====== + ----------------------> + SUB_CREATE + ------------------> + <------------------ + SUB_SYNC + ------------------> + <------------------ + CREATE_EVENT_CONF + <---------------------- +CREATE_EVENT_CONF +<------------------------- + + + +USER DICT(Master) (Slaves) SUMA +======================================================================= +SUB_START_REQ +--------------------------> + SUB_START_REQ + ----------------------> + SUB_START + ------------------> + <------------------ + SUB_START_CONF + <---------------------- +SUB_START_CONF +<------------------------- + + +SUB_STOP analogous to SUB_STOP + + + diff --git a/ndb/src/kernel/blocks/dbdict/DropTable.txt b/ndb/src/kernel/blocks/dbdict/DropTable.txt new file mode 100644 index 00000000000..8d364d15c57 --- /dev/null +++ b/ndb/src/kernel/blocks/dbdict/DropTable.txt @@ -0,0 +1,140 @@ +DROP TABLE DESCRIPTION +---------------------- + +Drop table is controlled by DICT. + +Drop table is used in the following cases in some sort. + - Drop Table + - Abort Add Table + - Drop table in node restart + - Drop table in system restart + +Sequence of Drop Table: +----------------------- + +1) PREP_DROP_TAB_REQ -> all DICT + Update schema files on disk + Table status = DROPPING + +2) Controlling DICT only + Report Table Dropped secured but not yet completed. + +------ PREP DROP + +4) PREP_DROP_TAB_REQ -> all LQHs + +5) PREP_DROP_TAB_REQ -> all TCs + +6) PREP_DROP_TAB_REQ -> all DIHs + + +--- LQH::PREP_DROP_TAB_REQ + +*) Mark the table so that no new operations will start +*) Mark all fragments so that new LCP_FRAG_ORD gets replied directly + w.o actually checkpointing the fragment +2) Start waiting for completion +3) Reply PREP_DROP_TAB_CONF + +- After this LQH accepts WAIT_DROP_TAB_REQ + +--- TC::PREP_DROP_TAB_REQ + +1) Mark the table so that no new transactions will start on the table +2) Send WAIT_DROP_TAB_REQ -> all connected LQH's +3) Wait for CONF (including NF-handling) from LQH:s +4) Reply PREP_DROP_TAB_CONF + +--- DIH::PREP_DROP_TAB_REQ + +1) Mark the table so that no new LCP will start on the table +2) If master (unlink any queued LCP_FRAG_ORD) +3) Send WAIT_DROP_TAB_REQ -> all connected LQH's +4) Wait for CONF (including NF-handling) from LQH:s +5) Reply PREP_DROP_TAB_CONF + +--- LQH::WAIT_DROP_TAB_REQ + +1) Wait for running operations + Wait for running LCP + +2) Reply + +------ PREP_DROP + +7) DROP_TAB_REQ -> all DICT's + *) DROP_TAB_REQ -> TC + *) DROP_TAB_REQ -> ACC + *) DROP_TAB_REQ -> TUP + *) DROP_TAB_REQ -> DIH + *) DROP_TAB_REQ -> LQH + *) Update schema files on disk DROPPED + +8) DICT_SCHEMAREQ -> all DICT + Table status = DROPPED + +--------------------------------- + +Sequence of Drop table in node/system restart +--------------------------------------------- + +In both node and system restart the node receives the schema information from +the master. If the table is in a state where it needs to complete the drop +table activity then DBACC, DBTUP, DBDIH, DBDICT is contacted to drop all files +related to the table. After this the schema information is updated with the new +state. Since all nodes receive the same schema information there is no risk of +different behaviour in the various NDB nodes. + +API Requirements for Drop Table +------------------------------- +Definition: + + Two tables are NOT the same if they were created with two create + tables at different points in time, even if the two create tables + had exactly the same definition. + +Requirements: + +1. Each operation in a transaction refering to a table (by name or by id) + should operate on the same table. (This is probably necessary.) + +2. Each operation in a transaction refering to a table (by name or by + id) should operate on the same table as were defined at the + startTransaction timepoint. (This is not strictly necessary for + API consistency.) + + Example 1: + + startTransaction() + + drop("TableName1") + create("TableName1") + + getNdbOperation("TableName1") + + execute(commit) + + - If both requirements 1 and 2 are fulfilled, then this should lead + to "Error: Invalid Schema Version" or similar error + + - If only requirement 1 is fulfilled, then this may be executed + without any errors. + + + Example 2: + + startTransaction() + + getNdbOperation("TableName1") + execute(NoCommit) + + drop("TableName1") + create("TableName1") + + getNdbOperation("TableName1") + + execute(commit) + + - This should always lead to "Error: Invalid Schema Version" or + similar error. + diff --git a/ndb/src/kernel/blocks/dbdict/Event.txt b/ndb/src/kernel/blocks/dbdict/Event.txt new file mode 100644 index 00000000000..553c915d9c5 --- /dev/null +++ b/ndb/src/kernel/blocks/dbdict/Event.txt @@ -0,0 +1,102 @@ + +Event creation + +USER DICT(Master) UTIL SUMA +================================================================================ +CREATE_EVENT_REQ::create +--------------------------> + - Get ID + CREATE_SUBID + -----------------------------------------------> + <----------------------------------------------- + - insert into system table + UTIL_PREPARE::insert + ------------------------> + <------------------------ + UTIL_EXECUTE + ------------------------> + <------------------------ +CREATE_EVENT_CONF +<-------------------------- + + +Event dropping + +USER DICT(Master) (Slaves) UTIL SUMA +================================================================================ +DROP_EVENT_REQ +--------------------------> + - read from system table + UTIL_PREPARE::read + ------------------------------------> + <------------------------------------ + UTIL_EXECUTE + ------------------------------------> + <------------------------------------ + SUB_REMOVE_REQ + --------------------> + SUB_REMOVE + ------------------------------> + <------------------------------ + SUB_REMOVE_CONF + <-------------------- + - remove from system table + UTIL_PREPARE::delete + ------------------------------------> + <------------------------------------ + UTIL_EXECUTE + ------------------------------------> + <------------------------------------ +DROP_EVENT_CONF +<-------------------------- + + + +create NdbEventOperation + +USER DICT(Master) (Slaves) UTIL +======================================================================= +CREATE_EVENT_REQ::get +--------------------------> + - read from system table + UTIL_PREPARE::read + ----------------------------------------> + <---------------------------------------- + UTIL_EXECUTE + ----------------------------------------> + <---------------------------------------- + SUMA + CREATE_EVENT_REQ::after_get ====== + ----------------------> + SUB_CREATE + ------------------> + <------------------ + SUB_SYNC + ------------------> + <------------------ + CREATE_EVENT_CONF + <---------------------- +CREATE_EVENT_CONF +<------------------------- + + + +USER DICT(Master) (Slaves) SUMA +======================================================================= +SUB_START_REQ +--------------------------> + SUB_START_REQ + ----------------------> + SUB_START + ------------------> + <------------------ + SUB_START_CONF + <---------------------- +SUB_START_CONF +<------------------------- + + +SUB_STOP analogous to SUB_STOP + + + diff --git a/ndb/src/kernel/blocks/dbdict/Makefile b/ndb/src/kernel/blocks/dbdict/Makefile new file mode 100644 index 00000000000..46d938114fb --- /dev/null +++ b/ndb/src/kernel/blocks/dbdict/Makefile @@ -0,0 +1,12 @@ +include .defs.mk + +TYPE := kernel + +ARCHIVE_TARGET := dbdict + +SOURCES = \ + Dbdict.cpp + +DIRS := printSchemafile + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/kernel/blocks/dbdict/Master_AddTable.sfl b/ndb/src/kernel/blocks/dbdict/Master_AddTable.sfl new file mode 100644 index 00000000000..1bcec156ef7 --- /dev/null +++ b/ndb/src/kernel/blocks/dbdict/Master_AddTable.sfl @@ -0,0 +1,751 @@ +// --------------------------------------------------------------------------- +// This file contains a signal log trace for DBDICT at the master for a +// create table. Another file contains the signal log for the participant +// node. Master node is 2, participant node 4 and api node is 3. +// + +// --------------------------------------------------------------------------- +// First arrives the table description in a number of DICTTABINFO signals. +// These have a header of 5 words (see DictTabInfo.hpp for details) and +// upto 20 words of property data per signal. The property data is packed +// by the SimpleProperties class. +// --------------------------------------------------------------------------- +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57069 gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 0 "API", s.proc: 3, s.sigId: 940284 length: 25 trace: 0 + H'00010003 H'00047700 H'00000001 H'00000042 H'00000000 H'4e444250 H'524f5053 + H'00010000 H'00000000 H'1c0a1203 H'524f4c46 H'00020001 H'0000000a H'56504e5f + H'55534552 H'53000000 H'0001000a H'0000004b H'000203e8 H'00000007 H'56504e5f + H'49440000 H'000103ee H'00000001 H'000203e8 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57069 gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 0 "API", s.proc: 3, s.sigId: 940284 length: 25 trace: 0 + H'00010003 H'00047700 H'00000001 H'00000042 H'00000014 H'00000007 H'56504e5f + H'4e420000 H'000103ee H'00000001 H'000203e8 H'0000000d H'44495245 H'43544f52 + H'595f4e42 H'00000000 H'000103eb H'00000003 H'000103ed H'0000000a H'000103ec + H'00000002 H'000203e8 H'00000010 H'4c415354 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57069 gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 0 "API", s.proc: 3, s.sigId: 940284 length: 25 trace: 0 + H'00010003 H'00047700 H'00000001 H'00000042 H'00000028 H'5f43414c H'4c5f5041 + H'52545900 H'000103eb H'00000003 H'000103ed H'0000000a H'000103ec H'00000002 + H'000203e8 H'00000006 H'44455343 H'52000000 H'000103eb H'00000003 H'000103ed + H'00000064 H'000103ec H'00000002 H'00010005 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57069 gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 0 "API", s.proc: 3, s.sigId: 940284 length: 11 trace: 0 + H'00010003 H'00047700 H'00000001 H'00000042 H'0000003c H'00000002 H'00010006 + H'00000005 H'0001000c H'00000002 H'0000ffff + +// --------------------------------------------------------------------------- +// Send DICT_SCHEMAREQ to all nodes including ourselves to write the state +// ADD_STARTED in the schema file for the new table. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 132 "DICT_SCHEMAREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57069 length: 7 trace: 0 + H'00010003 H'00047700 H'00000002 H'00000001 H'00000000 H'00000000 H'00000001 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, gsn: 132 "DICT_SCHEMAREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57069 length: 7 trace: 0 + H'00010003 H'00047700 H'00000002 H'00000001 H'00000000 H'00000000 H'00000001 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57069 gsn: 132 "DICT_SCHEMAREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57077 length: 7 trace: 0 + H'00010003 H'00047700 H'00000002 H'00000001 H'00000000 H'00000000 H'00000001 + +// --------------------------------------------------------------------------- +// Write both schema files with new state of table added. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57069 length: 7 trace: 0 + UserReference: H'00fa0002, userPointer: H'00000000 + FileNumber[1-4]: H'ffffffff H'ffffffff H'ffffffff H'01050100 + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57081 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57082 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 99 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57081 length: 8 trace: 0 + FilePointer: 99 + UserReference: H'00fa0002, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000008, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57090 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57091 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57090 length: 4 trace: 0 + FilePointer: 99 + UserReference: H'00fa0002, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57099 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57100 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57099 length: 7 trace: 0 + UserReference: H'00fa0002, userPointer: H'00000000 + FileNumber[1-4]: H'ffffffff H'ffffffff H'ffffffff H'01050200 + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57111 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57112 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 100 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57111 length: 8 trace: 0 + FilePointer: 100 + UserReference: H'00fa0002, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000008, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57123 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57124 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57123 length: 4 trace: 0 + FilePointer: 100 + UserReference: H'00fa0002, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57132 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57133 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 133 "DICT_SCHEMACONF" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57132 length: 1 trace: 0 + H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57132 gsn: 133 "DICT_SCHEMACONF" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57135 length: 1 trace: 0 + H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57132 gsn: 133 "DICT_SCHEMACONF" prio: 1 +s.bn: 250 "DBDICT", s.proc: 4, s.sigId: 46718 length: 1 trace: 0 + H'00000004 + +// --------------------------------------------------------------------------- +// Pack Table description into pages in DICT using SimpleProperties class. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57132 length: 3 trace: 0 + H'00000001 H'00000002 H'00000000 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57132 gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57140 length: 3 trace: 0 + H'00000001 H'00000002 H'00000000 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57132 length: 2 trace: 0 + H'00000002 H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57132 gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57141 length: 2 trace: 0 + H'00000002 H'00000002 + +// --------------------------------------------------------------------------- +// Send the table description over to the other NDB nodes. +// A CONTINUEB is sent for each signal sent to avoid overloading the +// transporters. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57132 length: 25 trace: 0 + H'00fa0002 H'00000000 H'00000002 H'0000006e H'00000000 H'4e444250 H'524f5053 + H'00002000 H'0000001c H'1c0a1203 H'524f4c46 H'00020001 H'0000000a H'56504e5f + H'55534552 H'53000000 H'0001000a H'0000004b H'000203e8 H'00000007 H'56504e5f + H'49440000 H'1cc03924 H'00000001 H'000203e8 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57132 length: 2 trace: 0 + H'00000002 H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57132 gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57142 length: 2 trace: 0 + H'00000002 H'00000002 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57132 length: 25 trace: 0 + H'00fa0002 H'00000000 H'00000002 H'0000006e H'00000014 H'00000007 H'56504e5f + H'4e420000 H'000103ee H'00000001 H'000203e8 H'0000000d H'44495245 H'43544f52 + H'595f4e42 H'00000000 H'000103eb H'00000003 H'524f4c46 H'00020001 H'0000000a + H'56504e5f H'55534552 H'53000010 H'00010002 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57132 length: 2 trace: 0 + H'00000002 H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57132 gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57143 length: 2 trace: 0 + H'00000002 H'00000002 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57132 length: 25 trace: 0 + H'00fa0002 H'00000000 H'00000002 H'0000006e H'00000028 H'00000002 H'00010011 + H'00000003 H'00010003 H'00000001 H'00010005 H'00000002 H'00010006 H'00000005 + H'0001000a H'0000004b H'0001000c H'00000002 H'000203e8 H'00000007 H'56504e5f + H'49440064 H'000103e9 H'00000000 H'000103ee +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57132 length: 2 trace: 0 + H'00000002 H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57132 gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57144 length: 2 trace: 0 + H'00000002 H'00000002 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57132 length: 25 trace: 0 + H'00fa0002 H'00000000 H'00000002 H'0000006e H'0000003c H'00000001 H'000203e8 + H'00000007 H'56504e5f H'4e420002 H'000103e9 H'00000001 H'000103ee H'00000001 + H'000203e8 H'0000000d H'44495245 H'43544f52 H'595f4e42 H'00000000 H'000103e9 + H'00000002 H'000103eb H'00000003 H'000103ec +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57132 length: 2 trace: 0 + H'00000002 H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57132 gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57145 length: 2 trace: 0 + H'00000002 H'00000002 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57132 length: 25 trace: 0 + H'00fa0002 H'00000000 H'00000002 H'0000006e H'00000050 H'00000002 H'000103ed + H'0000000a H'000203e8 H'00000010 H'4c415354 H'5f43414c H'4c5f5041 H'52545900 + H'000103e9 H'00000003 H'000103eb H'00000003 H'000103ec H'00000002 H'000103ed + H'0000000a H'000203e8 H'00000006 H'44455343 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57132 length: 2 trace: 0 + H'00000002 H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57132 gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57146 length: 2 trace: 0 + H'00000002 H'00000002 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57132 length: 15 trace: 0 + H'00fa0002 H'00000000 H'00000002 H'0000006e H'00000064 H'52000000 H'000103e9 + H'00000004 H'000103eb H'00000003 H'000103ec H'00000002 H'000103ed H'00000064 + H'0000ffff + +// --------------------------------------------------------------------------- +// In parallel with sending the table description to other nodes we will also +// write the table description to our local file system. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57132 length: 7 trace: 0 + UserReference: H'00fa0002, userPointer: H'00000000 + FileNumber[1-4]: H'00000002 H'ffffffff H'00000001 H'010401ff + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57165 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57166 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 101 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57165 length: 8 trace: 0 + FilePointer: 101 + UserReference: H'00fa0002, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000000, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57177 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57178 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57177 length: 4 trace: 0 + FilePointer: 101 + UserReference: H'00fa0002, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57186 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57187 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57186 length: 7 trace: 0 + UserReference: H'00fa0002, userPointer: H'00000000 + FileNumber[1-4]: H'00000002 H'ffffffff H'00000001 H'010402ff + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57195 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57196 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 102 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57195 length: 8 trace: 0 + FilePointer: 102 + UserReference: H'00fa0002, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000000, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57204 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57205 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57204 length: 4 trace: 0 + FilePointer: 102 + UserReference: H'00fa0002, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57218 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57219 length: 1 trace: 0 + UserPointer: H'00000000 + +// --------------------------------------------------------------------------- +// Completed writing to our file system the table description. +// --------------------------------------------------------------------------- + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57229 gsn: 24 "DICTTABCONF" prio: 1 +s.bn: 250 "DBDICT", s.proc: 4, s.sigId: 46803 length: 2 trace: 0 + H'00000002 H'00000004 + +// --------------------------------------------------------------------------- +// Also the participant have completed writing the table description to file. +// --------------------------------------------------------------------------- + +// --------------------------------------------------------------------------- +// Write the state UPDATE_PAGE_COUNT to schema file for the new table. +// This also contains the number of pages used for the table description. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 132 "DICT_SCHEMAREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57229 length: 7 trace: 0 + H'00010003 H'00047700 H'00000002 H'00000001 H'00000001 H'00000000 H'00000002 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, gsn: 132 "DICT_SCHEMAREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57229 length: 7 trace: 0 + H'00010003 H'00047700 H'00000002 H'00000001 H'00000001 H'00000000 H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57229 gsn: 132 "DICT_SCHEMAREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57234 length: 7 trace: 0 + H'00010003 H'00047700 H'00000002 H'00000001 H'00000001 H'00000000 H'00000002 + +// --------------------------------------------------------------------------- +// Write schema file to disk +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57229 length: 7 trace: 0 + UserReference: H'00fa0002, userPointer: H'00000000 + FileNumber[1-4]: H'ffffffff H'ffffffff H'ffffffff H'01050100 + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57238 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57239 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 103 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57238 length: 8 trace: 0 + FilePointer: 103 + UserReference: H'00fa0002, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000008, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57247 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57248 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57247 length: 4 trace: 0 + FilePointer: 103 + UserReference: H'00fa0002, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57257 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57258 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57257 length: 7 trace: 0 + UserReference: H'00fa0002, userPointer: H'00000000 + FileNumber[1-4]: H'ffffffff H'ffffffff H'ffffffff H'01050200 + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57267 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57268 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 104 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57267 length: 8 trace: 0 + FilePointer: 104 + UserReference: H'00fa0002, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000008, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57279 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57283 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57279 length: 4 trace: 0 + FilePointer: 104 + UserReference: H'00fa0002, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57290 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 57291 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 133 "DICT_SCHEMACONF" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57290 length: 1 trace: 0 + H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57290 gsn: 133 "DICT_SCHEMACONF" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57293 length: 1 trace: 0 + H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57299 gsn: 133 "DICT_SCHEMACONF" prio: 1 +s.bn: 250 "DBDICT", s.proc: 4, s.sigId: 46860 length: 1 trace: 0 + H'00000004 + +// --------------------------------------------------------------------------- +// All schema files in the system have been updated. +// --------------------------------------------------------------------------- + +// --------------------------------------------------------------------------- +// Now control is given to DIH for adding the fragments needed by this table. +// We first seize a record in DIH and then we send the add table request with +// the needed table parameters. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 246 "DBDIH", r.proc: 2, gsn: 238 "DISEIZEREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57299 length: 2 trace: 0 + H'00000000 H'00fa0002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57299 gsn: 236 "DISEIZECONF" prio: 1 +s.bn: 246 "DBDIH", s.proc: 2, s.sigId: 57304 length: 2 trace: 0 + H'00000000 H'00000210 +---- Send ----- Signal ---------------- +r.bn: 246 "DBDIH", r.proc: 2, gsn: 187 "DIADDTABREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57299 length: 6 trace: 0 + H'00000210 H'00000002 H'00000000 H'00000006 H'00000000 H'00000001 + +// --------------------------------------------------------------------------- +// DIH requests us to add a certain fragment replica. +// --------------------------------------------------------------------------- + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57400 gsn: 195 "DICTFRAGSREQ" prio: 1 +s.bn: 246 "DBDIH", s.proc: 2, s.sigId: 57418 length: 7 trace: 0 + H'00000000 H'00000000 H'00000000 H'00000002 H'00150040 H'00000001 H'00000002 + +// --------------------------------------------------------------------------- +// We add the fragment by contacting LQH through sending a LQHFRAGREQ and +// a number of LQHADDATTREQ (in this case only one since not more than 8 +// attributes). +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 247 "DBLQH", r.proc: 2, gsn: 313 "LQHFRAGREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57400 length: 17 trace: 0 + H'00000000 H'00fa0002 H'00000000 H'00000000 H'00000002 H'00000001 H'00000050 + H'0000004b H'00000006 H'00000001 H'00000000 H'00000005 H'00000000 H'00000000 + H'00000001 H'00000002 H'00000000 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57400 gsn: 311 "LQHFRAGCONF" prio: 1 +s.bn: 247 "DBLQH", s.proc: 2, s.sigId: 57428 length: 2 trace: 0 + H'00000000 H'00000000 +---- Send ----- Signal ---------------- +r.bn: 247 "DBLQH", r.proc: 2, gsn: 310 "LQHADDATTREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57400 length: 12 trace: 0 + H'00000000 H'00000005 H'00000000 H'00012255 H'00000001 H'00012255 H'00000002 + H'000a2236 H'00000003 H'000a2236 H'00000004 H'00642236 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57400 gsn: 308 "LQHADDATTCONF" prio: 1 +s.bn: 247 "DBLQH", s.proc: 2, s.sigId: 57450 length: 1 trace: 0 + H'00000000 + +// --------------------------------------------------------------------------- +// When we have completed adding the fragment we send DINEXTNODEREQ (should +// change name to DICTFRAGSCONF) to DIH indicate we have completed the task. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 246 "DBDIH", r.proc: 2, gsn: 231 "DINEXTNODEREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57400 length: 4 trace: 0 + H'00000210 H'00000000 H'00000001 H'00000000 + +// --------------------------------------------------------------------------- +// We continue by performing the same task again for the next fragment replica. +// We skip this from this log since they contain no more interesting stuff. +// --------------------------------------------------------------------------- + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 57618 gsn: 185 "DIADDTABCONF" prio: 1 +s.bn: 246 "DBDIH", s.proc: 2, s.sigId: 57655 length: 2 trace: 0 + H'00000000 H'00000002 + +// --------------------------------------------------------------------------- +// Now that we have added all fragments DIH gives back control to DICT by +// sending DIADDTABCONF. +// --------------------------------------------------------------------------- + +// --------------------------------------------------------------------------- +// It is now time to decide which global checkpoint this table will be born. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 246 "DBDIH", r.proc: 2, gsn: 499 "WAIT_GCP_REQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 57618 length: 3 trace: 0 + H'00fa0002 H'00000000 H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58288 gsn: 501 "WAIT_GCP_CONF" prio: 1 +s.bn: 246 "DBDIH", s.proc: 2, s.sigId: 58296 length: 2 trace: 0 + H'00000000 H'0000000c + +// --------------------------------------------------------------------------- +// We can update all schema files in the system with this global checkpoint +// number. We are certain that no transaction will be performed on the table +// before this global checkpoint. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 132 "DICT_SCHEMAREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58288 length: 7 trace: 0 + H'00010003 H'00047700 H'00000002 H'00000001 H'00000001 H'0000000c H'00000003 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, gsn: 132 "DICT_SCHEMAREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58288 length: 7 trace: 0 + H'00010003 H'00047700 H'00000002 H'00000001 H'00000001 H'0000000c H'00000003 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58288 gsn: 132 "DICT_SCHEMAREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 58298 length: 7 trace: 0 + H'00010003 H'00047700 H'00000002 H'00000001 H'00000001 H'0000000c H'00000003 + +// --------------------------------------------------------------------------- +// Write schema files as usual when updating schema file state. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58288 length: 7 trace: 0 + UserReference: H'00fa0002, userPointer: H'00000000 + FileNumber[1-4]: H'ffffffff H'ffffffff H'ffffffff H'01050100 + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58304 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 58305 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 117 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58304 length: 8 trace: 0 + FilePointer: 117 + UserReference: H'00fa0002, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000008, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58315 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 58316 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58315 length: 4 trace: 0 + FilePointer: 117 + UserReference: H'00fa0002, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58326 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 58327 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58326 length: 7 trace: 0 + UserReference: H'00fa0002, userPointer: H'00000000 + FileNumber[1-4]: H'ffffffff H'ffffffff H'ffffffff H'01050200 + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58339 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 58340 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 118 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58339 length: 8 trace: 0 + FilePointer: 118 + UserReference: H'00fa0002, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000008, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58348 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 58349 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 2, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58348 length: 4 trace: 0 + FilePointer: 118 + UserReference: H'00fa0002, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58359 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 2, s.sigId: 58360 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 133 "DICT_SCHEMACONF" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58359 length: 1 trace: 0 + H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58359 gsn: 133 "DICT_SCHEMACONF" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 58364 length: 1 trace: 0 + H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58359 gsn: 133 "DICT_SCHEMACONF" prio: 1 +s.bn: 250 "DBDICT", s.proc: 4, s.sigId: 47846 length: 1 trace: 0 + H'00000004 + +// --------------------------------------------------------------------------- +// Commit the table for usage in DIH and LQH in all nodes. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 247 "DBLQH", r.proc: 2, gsn: 398 "TAB_COMMITREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58359 length: 3 trace: 0 + H'00000000 H'00fa0002 H'00000002 +---- Send ----- Signal ---------------- +r.bn: 246 "DBDIH", r.proc: 2, gsn: 398 "TAB_COMMITREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58359 length: 3 trace: 0 + H'00000001 H'00fa0002 H'00000002 +---- Send ----- Signal ---------------- +r.bn: 247 "DBLQH", r.proc: 4, gsn: 398 "TAB_COMMITREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58359 length: 3 trace: 0 + H'00000000 H'00fa0002 H'00000002 +---- Send ----- Signal ---------------- +r.bn: 246 "DBDIH", r.proc: 4, gsn: 398 "TAB_COMMITREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58359 length: 3 trace: 0 + H'00000001 H'00fa0002 H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58359 gsn: 396 "TAB_COMMITCONF" prio: 1 +s.bn: 247 "DBLQH", s.proc: 2, s.sigId: 58370 length: 3 trace: 0 + H'00000000 H'00000002 H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58359 gsn: 396 "TAB_COMMITCONF" prio: 1 +s.bn: 246 "DBDIH", s.proc: 2, s.sigId: 58371 length: 3 trace: 0 + H'00000001 H'00000002 H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58359 gsn: 396 "TAB_COMMITCONF" prio: 1 +s.bn: 247 "DBLQH", s.proc: 4, s.sigId: 47846 length: 3 trace: 0 + H'00000000 H'00000004 H'00000002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58359 gsn: 396 "TAB_COMMITCONF" prio: 1 +s.bn: 246 "DBDIH", s.proc: 4, s.sigId: 47846 length: 3 trace: 0 + H'00000001 H'00000004 H'00000002 + +// --------------------------------------------------------------------------- +// Finally also open the table for usage from TC in all nodes. +// After this signal is received in TC it is ok to execute transactions on +// this new empty table. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 245 "DBTC", r.proc: 2, gsn: 404 "TC_SCHVERREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58359 length: 5 trace: 0 + H'00000002 H'00000001 H'00000001 H'00fa0002 H'00000000 +---- Send ----- Signal ---------------- +r.bn: 245 "DBTC", r.proc: 4, gsn: 404 "TC_SCHVERREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58359 length: 5 trace: 0 + H'00000002 H'00000001 H'00000001 H'00fa0002 H'00000000 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58359 gsn: 403 "TC_SCHVERCONF" prio: 1 +s.bn: 245 "DBTC", s.proc: 2, s.sigId: 58376 length: 2 trace: 0 + H'00000002 H'00000000 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58359 gsn: 403 "TC_SCHVERCONF" prio: 1 +s.bn: 245 "DBTC", s.proc: 4, s.sigId: 47846 length: 2 trace: 0 + H'00000002 H'00000001 + +// --------------------------------------------------------------------------- +// Unblock dictionary to allow for another add table. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 444 "UNBLO_DICTREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58359 length: 1 trace: 0 + H'00fa0002 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, gsn: 444 "UNBLO_DICTREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58359 length: 1 trace: 0 + H'00fa0002 + +// --------------------------------------------------------------------------- +// Send the confirmation to the requesting application process. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 1 "API", r.proc: 3, gsn: 24 "DICTTABCONF" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58359 length: 3 trace: 0 + H'00047700 H'00000002 H'00000001 + +// --------------------------------------------------------------------------- +// Also release the connection in DIH that was previously established. +// --------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 246 "DBDIH", r.proc: 2, gsn: 234 "DIRELEASEREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, sigId: 58359 length: 3 trace: 0 + H'00000210 H'00000000 H'00fa0002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58359 gsn: 444 "UNBLO_DICTREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 58378 length: 1 trace: 0 + H'00fa0002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, sigId: 58359 gsn: 232 "DIRELEASECONF" prio: 1 +s.bn: 246 "DBDIH", s.proc: 2, s.sigId: 58380 length: 1 trace: 0 + H'00000000 + +// --------------------------------------------------------------------------- +// Now all actions regarding this add table have completed. +// --------------------------------------------------------------------------- diff --git a/ndb/src/kernel/blocks/dbdict/SchemaFile.hpp b/ndb/src/kernel/blocks/dbdict/SchemaFile.hpp new file mode 100644 index 00000000000..7c3223d3d14 --- /dev/null +++ b/ndb/src/kernel/blocks/dbdict/SchemaFile.hpp @@ -0,0 +1,57 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DBDICT_SCHEMA_FILE_HPP +#define DBDICT_SCHEMA_FILE_HPP + +#include +#include + +struct SchemaFile { + char Magic[8]; + Uint32 ByteOrder; + Uint32 NdbVersion; + Uint32 FileSize; // In bytes + Uint32 Unused; + + Uint32 CheckSum; + + enum TableState { + INIT = 0, + ADD_STARTED = 1, + TABLE_ADD_COMMITTED = 2, + DROP_TABLE_STARTED = 3, + DROP_TABLE_COMMITTED = 4, + ALTER_TABLE_COMMITTED = 5 + }; + + struct TableEntry { + Uint32 m_tableState; + Uint32 m_tableVersion; + Uint32 m_tableType; + Uint32 m_noOfPages; + Uint32 m_gcp; + + bool operator==(const TableEntry& o) const { + return memcmp(this, &o, sizeof(* this))== 0; + } + }; + + Uint32 NoOfTableEntries; + TableEntry TableEntries[1]; +}; + +#endif diff --git a/ndb/src/kernel/blocks/dbdict/Slave_AddTable.sfl b/ndb/src/kernel/blocks/dbdict/Slave_AddTable.sfl new file mode 100644 index 00000000000..8740be9595d --- /dev/null +++ b/ndb/src/kernel/blocks/dbdict/Slave_AddTable.sfl @@ -0,0 +1,416 @@ +// --------------------------------------------------------------------------- +// This file contains a signal log trace for DBDICT at the participant for a +// add table. Another file contains the signal log for the master +// node. Master node is 2, participant node 4 and api node is 3. +// + +// --------------------------------------------------------------------------- +//-------------------------------------------------------------------------- +// Master requests us to save a new state of the table in the schema file +// == ADD_STARTED +//-------------------------------------------------------------------------- + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46661 gsn: 132 "DICT_SCHEMAREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57069 length: 7 trace: 0 + H'00010003 H'00047700 H'00000002 H'00000001 H'00000000 H'00000000 H'00000001 + +//-------------------------------------------------------------------------- +// Write the new state to the schema files. +//-------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46661 length: 7 trace: 0 + UserReference: H'00fa0004, userPointer: H'00000000 + FileNumber[1-4]: H'ffffffff H'ffffffff H'ffffffff H'01050100 + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46669 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46670 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 99 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46669 length: 8 trace: 0 + FilePointer: 99 + UserReference: H'00fa0004, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000008, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46679 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46680 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46679 length: 4 trace: 0 + FilePointer: 99 + UserReference: H'00fa0004, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46690 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46691 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46690 length: 7 trace: 0 + UserReference: H'00fa0004, userPointer: H'00000000 + FileNumber[1-4]: H'ffffffff H'ffffffff H'ffffffff H'01050200 + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46700 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46701 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 100 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46700 length: 8 trace: 0 + FilePointer: 100 + UserReference: H'00fa0004, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000008, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46709 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46710 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46709 length: 4 trace: 0 + FilePointer: 100 + UserReference: H'00fa0004, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46718 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46719 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 133 "DICT_SCHEMACONF" prio: 1 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46718 length: 1 trace: 0 + H'00000004 + +//-------------------------------------------------------------------------- +// We receive the table description from the master node. +// We set the data in the DICT block. (table and attribute records). +//-------------------------------------------------------------------------- + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46718 gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57132 length: 25 trace: 0 + H'00fa0002 H'00000000 H'00000002 H'0000006e H'00000000 H'4e444250 H'524f5053 + H'00002000 H'0000001c H'1c0a1203 H'524f4c46 H'00020001 H'0000000a H'56504e5f + H'55534552 H'53000000 H'0001000a H'0000004b H'000203e8 H'00000007 H'56504e5f + H'49440000 H'1cc03924 H'00000001 H'000203e8 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46718 gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57132 length: 25 trace: 0 + H'00fa0002 H'00000000 H'00000002 H'0000006e H'00000014 H'00000007 H'56504e5f + H'4e420000 H'000103ee H'00000001 H'000203e8 H'0000000d H'44495245 H'43544f52 + H'595f4e42 H'00000000 H'000103eb H'00000003 H'524f4c46 H'00020001 H'0000000a + H'56504e5f H'55534552 H'53000010 H'00010002 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46718 gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57132 length: 25 trace: 0 + H'00fa0002 H'00000000 H'00000002 H'0000006e H'00000028 H'00000002 H'00010011 + H'00000003 H'00010003 H'00000001 H'00010005 H'00000002 H'00010006 H'00000005 + H'0001000a H'0000004b H'0001000c H'00000002 H'000203e8 H'00000007 H'56504e5f + H'49440064 H'000103e9 H'00000000 H'000103ee +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46718 gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57132 length: 25 trace: 0 + H'00fa0002 H'00000000 H'00000002 H'0000006e H'0000003c H'00000001 H'000203e8 + H'00000007 H'56504e5f H'4e420002 H'000103e9 H'00000001 H'000103ee H'00000001 + H'000203e8 H'0000000d H'44495245 H'43544f52 H'595f4e42 H'00000000 H'000103e9 + H'00000002 H'000103eb H'00000003 H'000103ec +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46718 gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57132 length: 25 trace: 0 + H'00fa0002 H'00000000 H'00000002 H'0000006e H'00000050 H'00000002 H'000103ed + H'0000000a H'000203e8 H'00000010 H'4c415354 H'5f43414c H'4c5f5041 H'52545900 + H'000103e9 H'00000003 H'000103eb H'00000003 H'000103ec H'00000002 H'000103ed + H'0000000a H'000203e8 H'00000006 H'44455343 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46718 gsn: 204 "DICTTABINFO" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57132 length: 15 trace: 0 + H'00fa0002 H'00000000 H'00000002 H'0000006e H'00000064 H'52000000 H'000103e9 + H'00000004 H'000103eb H'00000003 H'000103ec H'00000002 H'000103ed H'00000064 + H'0000ffff + +//-------------------------------------------------------------------------- +// Pack the table description into pages. +//-------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46718 length: 3 trace: 0 + H'00000001 H'00000002 H'00000000 +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46718 gsn: 164 "CONTINUEB" prio: 1 +s.bn: 250 "DBDICT", s.proc: 4, s.sigId: 46730 length: 3 trace: 0 + H'00000001 H'00000002 H'00000000 + +//-------------------------------------------------------------------------- +// Write the pages of the table description to disk. +//-------------------------------------------------------------------------- + +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46718 length: 7 trace: 0 + UserReference: H'00fa0004, userPointer: H'00000000 + FileNumber[1-4]: H'00000002 H'ffffffff H'00000001 H'010401ff + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46748 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46749 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 101 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46748 length: 8 trace: 0 + FilePointer: 101 + UserReference: H'00fa0004, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000000, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46757 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46758 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46757 length: 4 trace: 0 + FilePointer: 101 + UserReference: H'00fa0004, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46766 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46767 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46766 length: 7 trace: 0 + UserReference: H'00fa0004, userPointer: H'00000000 + FileNumber[1-4]: H'00000002 H'ffffffff H'00000001 H'010402ff + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46783 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46784 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 102 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46783 length: 8 trace: 0 + FilePointer: 102 + UserReference: H'00fa0004, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000000, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46794 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46795 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46794 length: 4 trace: 0 + FilePointer: 102 + UserReference: H'00fa0004, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46803 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46804 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 24 "DICTTABCONF" prio: 1 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46803 length: 2 trace: 0 + H'00000002 H'00000004 + +//-------------------------------------------------------------------------- +// Update schema file ín memory and on disk to UPDATE_PAGE_COUNT. +//-------------------------------------------------------------------------- + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46803 gsn: 132 "DICT_SCHEMAREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 57229 length: 7 trace: 0 + H'00010003 H'00047700 H'00000002 H'00000001 H'00000001 H'00000000 H'00000002 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46803 length: 7 trace: 0 + UserReference: H'00fa0004, userPointer: H'00000000 + FileNumber[1-4]: H'ffffffff H'ffffffff H'ffffffff H'01050100 + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46813 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46814 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 103 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46813 length: 8 trace: 0 + FilePointer: 103 + UserReference: H'00fa0004, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000008, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46823 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46824 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46823 length: 4 trace: 0 + FilePointer: 103 + UserReference: H'00fa0004, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46833 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46834 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46833 length: 7 trace: 0 + UserReference: H'00fa0004, userPointer: H'00000000 + FileNumber[1-4]: H'ffffffff H'ffffffff H'ffffffff H'01050200 + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46842 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46843 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 104 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46842 length: 8 trace: 0 + FilePointer: 104 + UserReference: H'00fa0004, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000008, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46851 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46852 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46851 length: 4 trace: 0 + FilePointer: 104 + UserReference: H'00fa0004, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 46860 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 46861 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 133 "DICT_SCHEMACONF" prio: 1 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 46860 length: 1 trace: 0 + H'00000004 + +//-------------------------------------------------------------------------- +// Update schema file with information about the starting global checkpoint +// identity. +//-------------------------------------------------------------------------- + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 47782 gsn: 132 "DICT_SCHEMAREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 58288 length: 7 trace: 0 + H'00010003 H'00047700 H'00000002 H'00000001 H'00000001 H'0000000c H'00000003 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 47782 length: 7 trace: 0 + UserReference: H'00fa0004, userPointer: H'00000000 + FileNumber[1-4]: H'ffffffff H'ffffffff H'ffffffff H'01050100 + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 47793 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 47794 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 117 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 47793 length: 8 trace: 0 + FilePointer: 117 + UserReference: H'00fa0004, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000008, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 47804 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 47805 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 47804 length: 4 trace: 0 + FilePointer: 117 + UserReference: H'00fa0004, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 47817 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 47818 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 261 "FSOPENREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 47817 length: 7 trace: 0 + UserReference: H'00fa0004, userPointer: H'00000000 + FileNumber[1-4]: H'ffffffff H'ffffffff H'ffffffff H'01050200 + FileFlags: H'00000311 Open write only, Create new file, Truncate existing file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 47826 gsn: 259 "FSOPENCONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 47827 length: 3 trace: 0 + UserPointer: H'00000000 + FilePointer: 118 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 272 "FSWRITEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 47826 length: 8 trace: 0 + FilePointer: 118 + UserReference: H'00fa0004, UserPointer: H'00000000 + Operation flag: H'00000011, Sync, Format=Array of pages + varIndex: 1 + numberOfPages: 1 + pageData: H'00000008, H'00000000 + +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 47836 gsn: 270 "FSWRITECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 47837 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 253 "NDBFS", r.proc: 4, gsn: 257 "FSCLOSEREQ" prio: 0 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 47836 length: 4 trace: 0 + FilePointer: 118 + UserReference: H'00fa0004, userPointer: H'00000000 + Flags: H'00000000, Don't remove file +---- Received - Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 4, sigId: 47846 gsn: 255 "FSCLOSECONF" prio: 1 +s.bn: 253 "NDBFS", s.proc: 4, s.sigId: 47847 length: 1 trace: 0 + UserPointer: H'00000000 +---- Send ----- Signal ---------------- +r.bn: 250 "DBDICT", r.proc: 2, gsn: 133 "DICT_SCHEMACONF" prio: 1 +s.bn: 250 "DBDICT", s.proc: 4, sigId: 47846 length: 1 trace: 0 + H'00000004 +---- Received - Signal ---------------- + +//-------------------------------------------------------------------------- +// Finally unblock the DICT block so that it can handle add table as master +// if it becomes master in the future. +//-------------------------------------------------------------------------- + +r.bn: 250 "DBDICT", r.proc: 4, sigId: 47846 gsn: 444 "UNBLO_DICTREQ" prio: 1 +s.bn: 250 "DBDICT", s.proc: 2, s.sigId: 58359 length: 1 trace: 0 + H'00fa0002 + +//-------------------------------------------------------------------------- +// We completed the add table operation. +//-------------------------------------------------------------------------- + diff --git a/ndb/src/kernel/blocks/dbdict/printSchemafile/Makefile b/ndb/src/kernel/blocks/dbdict/printSchemafile/Makefile new file mode 100644 index 00000000000..1b097e2ce37 --- /dev/null +++ b/ndb/src/kernel/blocks/dbdict/printSchemafile/Makefile @@ -0,0 +1,12 @@ +include .defs.mk + +TYPE := ndbapi + +BIN_TARGET := printSchemafile +BIN_TARGET_ARCHIVES := portlib general + +CCFLAGS_LOC += -I.. + +SOURCES := printSchemafile.cpp + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/kernel/blocks/dbdict/printSchemafile/printSchemafile.cpp b/ndb/src/kernel/blocks/dbdict/printSchemafile/printSchemafile.cpp new file mode 100644 index 00000000000..b16990bda6c --- /dev/null +++ b/ndb/src/kernel/blocks/dbdict/printSchemafile/printSchemafile.cpp @@ -0,0 +1,99 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include +#include +#include +#include +#include + +void +usage(const char * prg){ + ndbout << "Usage " << prg + << " P0.SchemaLog" << endl; +} + +void +fill(const char * buf, int mod){ + int len = strlen(buf)+1; + ndbout << buf << " "; + while((len % mod) != 0){ + ndbout << " "; + len++; + } +} + +void +print(const char * filename, const SchemaFile * file){ + ndbout << "----- Schemafile: " << filename << " -----" << endl; + ndbout_c("Magic: %.*s ByteOrder: %.8x NdbVersion: %d FileSize: %d", + sizeof(file->Magic), file->Magic, + file->ByteOrder, + file->NdbVersion, + file->FileSize); + + for(Uint32 i = 0; iNoOfTableEntries; i++){ + SchemaFile::TableEntry te = file->TableEntries[i]; + if(te.m_tableState != SchemaFile::INIT){ + ndbout << "Table " << i << ": State = " << te.m_tableState + << " version = " << te.m_tableVersion + << " type = " << te.m_tableType + << " noOfPages = " << te.m_noOfPages + << " gcp: " << te.m_gcp << endl; + } + } +} + +NDB_COMMAND(printSchemafile, + "printSchemafile", "printSchemafile", "Prints a schemafile", 16384){ + if(argc < 2){ + usage(argv[0]); + return 0; + } + + const char * filename = argv[1]; + + struct stat sbuf; + const int res = stat(filename, &sbuf); + if(res != 0){ + ndbout << "Could not find file: \"" << filename << "\"" << endl; + return 0; + } + const Uint32 bytes = sbuf.st_size; + + Uint32 * buf = new Uint32[bytes/4+1]; + + FILE * f = fopen(filename, "rb"); + if(f == 0){ + ndbout << "Failed to open file" << endl; + delete [] buf; + return 0; + } + Uint32 sz = fread(buf, 1, bytes, f); + fclose(f); + if(sz != bytes){ + ndbout << "Failure while reading file" << endl; + delete [] buf; + return 0; + } + + print(filename, (SchemaFile *)&buf[0]); + delete [] buf; + return 0; +} diff --git a/ndb/src/kernel/blocks/dbdih/Dbdih.hpp b/ndb/src/kernel/blocks/dbdih/Dbdih.hpp new file mode 100644 index 00000000000..4ec699cebec --- /dev/null +++ b/ndb/src/kernel/blocks/dbdih/Dbdih.hpp @@ -0,0 +1,1606 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DBDIH_H +#define DBDIH_H + +#include +#include +#include +#include "Sysfile.hpp" +#include +#include + +#include +#include +#include + +#ifdef DBDIH_C + +/*###################*/ +/* FILE SYSTEM FLAGS */ +/*###################*/ +#define ZLIST_OF_PAIRS 0 +#define ZLIST_OF_PAIRS_SYNCH 16 +#define ZOPEN_READ_WRITE 2 +#define ZCREATE_READ_WRITE 0x302 +#define ZCLOSE_NO_DELETE 0 +#define ZCLOSE_DELETE 1 + +/*###############*/ +/* NODE STATES */ +/*###############*/ +#define ZIDLE 0 +#define ZACTIVE 1 + +/*#########*/ +/* GENERAL */ +/*#########*/ +#define ZVAR_NO_WORD 1 +#define ZVAR_NO_CRESTART_INFO 20 +#define ZVAR_NO_CRESTART_INFO_TO_FILE 21 +#define ZVALID 1 +#define ZINVALID 2 + +/*###############*/ +/* ERROR CODES */ +/*###############*/ +// ------------------------------------------ +// Error Codes for Transactions (None sofar) +// ------------------------------------------ + +// -------------------------------------- +// Error Codes for Add Table +// -------------------------------------- +#define ZREPLERROR1 306 +#define ZNOTIMPLEMENTED 307 +#define ZTABLEINSTALLED 310 +// -------------------------------------- +// Error Codes for Scan Table +// -------------------------------------- +#define ZERRONOUSSTATE 308 + +// -------------------------------------- +// Crash Codes +// -------------------------------------- +#define ZCOULD_NOT_OCCUR_ERROR 300 +#define ZNOT_MASTER_ERROR 301 +#define ZWRONG_FAILURE_NUMBER_ERROR 302 +#define ZWRONG_START_NODE_ERROR 303 +#define ZNO_REPLICA_FOUND_ERROR 304 +#define ZNODE_ALREADY_STARTING_ERROR 305 +#define ZNODE_START_DISALLOWED_ERROR 309 + +// -------------------------------------- +// Codes from LQH +// -------------------------------------- +#define ZNODE_FAILURE_ERROR 400 + + +/*#########*/ +/* PHASES */ +/*#########*/ +#define ZNDB_SPH1 1 +#define ZNDB_SPH2 2 +#define ZNDB_SPH3 3 +#define ZNDB_SPH4 4 +#define ZNDB_SPH5 5 +#define ZNDB_SPH6 6 +#define ZNDB_SPH7 7 +#define ZNDB_SPH8 8 +/*#########*/ +/* SIZES */ +/*#########*/ +#define ZPAGEREC 100 +#define ZCREATE_REPLICA_FILE_SIZE 4 +#define ZPROXY_MASTER_FILE_SIZE 10 +#define ZPROXY_FILE_SIZE 10 +#endif + +class Dbdih: public SimulatedBlock { +public: + + // Records + + /*¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ + * THE API CONNECT RECORD IS THE SAME RECORD POINTER AS USED IN THE TC BLOCK + * + * IT KEEPS TRACK OF ALL THE OPERATIONS CONNECTED TO THIS TRANSACTION. + * IT IS LINKED INTO A QUEUE IN CASE THE GLOBAL CHECKPOINT IS CURRENTLY + * ONGOING */ + struct ApiConnectRecord { + Uint32 apiGci; + Uint32 nextApi; + }; + typedef Ptr ApiConnectRecordPtr; + + /*############## CONNECT_RECORD ##############*/ + /*¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤*/ + /* THE CONNECT RECORD IS CREATED WHEN A TRANSACTION HAS TO START. IT KEEPS + ALL INTERMEDIATE INFORMATION NECESSARY FOR THE TRANSACTION FROM THE + DISTRIBUTED MANAGER. THE RECORD KEEPS INFORMATION ABOUT THE + OPERATIONS THAT HAVE TO BE CARRIED OUT BY THE TRANSACTION AND + ALSO THE TRAIL OF NODES FOR EACH OPERATION IN THE THE + TRANSACTION. + */ + struct ConnectRecord { + enum ConnectState { + INUSE = 0, + FREE = 1, + STARTED = 2 + }; + Uint32 nodes[MAX_REPLICAS]; + ConnectState connectState; + Uint32 nfConnect; + Uint32 table; + Uint32 userpointer; + Uint32 nodeCount; + BlockReference userblockref; + }; + typedef Ptr ConnectRecordPtr; + + /*¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤*/ + /* THESE RECORDS ARE USED WHEN CREATING REPLICAS DURING SYSTEM */ + /* RESTART. I NEED A COMPLEX DATA STRUCTURE DESCRIBING THE REPLICAS */ + /* I WILL TRY TO CREATE FOR EACH FRAGMENT. */ + /* */ + /* I STORE A REFERENCE TO THE FOUR POSSIBLE CREATE REPLICA RECORDS */ + /* IN A COMMON STORED VARIABLE. I ALLOW A MAXIMUM OF 4 REPLICAS TO */ + /* BE RESTARTED PER FRAGMENT. */ + /*¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤*/ + struct CreateReplicaRecord { + Uint32 logStartGci[MAX_LOG_EXEC]; + Uint32 logStopGci[MAX_LOG_EXEC]; + Uint16 logNodeId[MAX_LOG_EXEC]; + Uint32 createLcpId; + + bool hotSpareUse; + Uint32 replicaRec; + Uint16 dataNodeId; + Uint16 lcpNo; + Uint16 noLogNodes; + }; + typedef Ptr CreateReplicaRecordPtr; + + /*¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤*/ + /* THIS RECORD CONTAINS A FILE DESCRIPTION. THERE ARE TWO */ + /* FILES PER TABLE TO RAISE SECURITY LEVEL AGAINST DISK CRASHES. */ + /*¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤*/ + struct FileRecord { + enum FileStatus { + CLOSED = 0, + CRASHED = 1, + OPEN = 2 + }; + enum FileType { + TABLE_FILE = 0, + GCP_FILE = 1 + }; + enum ReqStatus { + IDLE = 0, + CREATING_GCP = 1, + OPENING_GCP = 2, + OPENING_COPY_GCI = 3, + WRITING_COPY_GCI = 4, + CREATING_COPY_GCI = 5, + OPENING_TABLE = 6, + READING_GCP = 7, + READING_TABLE = 8, + WRITE_INIT_GCP = 9, + TABLE_CREATE = 10, + TABLE_WRITE = 11, + TABLE_CLOSE = 12, + CLOSING_GCP = 13, + CLOSING_TABLE_CRASH = 14, + CLOSING_TABLE_SR = 15, + CLOSING_GCP_CRASH = 16, + TABLE_OPEN_FOR_DELETE = 17, + TABLE_CLOSE_DELETE = 18 + }; + Uint32 fileName[4]; + Uint32 fileRef; + FileStatus fileStatus; + FileType fileType; + Uint32 nextFile; + ReqStatus reqStatus; + Uint32 tabRef; + }; + typedef Ptr FileRecordPtr; + + /*¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤*/ + /* THIS RECORD KEEPS THE STORAGE AND DECISIONS INFORMATION OF A FRAGMENT */ + /* AND ITS REPLICAS. IF FRAGMENT HAS MORE THAN ONE BACK UP */ + /* REPLICA THEN A LIST OF MORE NODES IS ATTACHED TO THIS RECORD. */ + /* EACH RECORD IN MORE LIST HAS INFORMATION ABOUT ONE BACKUP. THIS RECORD */ + /* ALSO HAVE THE STATUS OF THE FRAGMENT. */ + /*¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤*/ + /* */ + /* FRAGMENTSTORE RECORD ALIGNED TO BE 64 BYTES */ + /*¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤*/ + struct Fragmentstore { + Uint16 activeNodes[MAX_REPLICAS]; + Uint32 preferredPrimary; + + Uint32 oldStoredReplicas; /* "DEAD" STORED REPLICAS */ + Uint32 storedReplicas; /* "ALIVE" STORED REPLICAS */ + Uint32 nextFragmentChunk; + + Uint8 distributionKey; + Uint8 fragReplicas; + Uint8 noOldStoredReplicas; /* NUMBER OF "DEAD" STORED REPLICAS */ + Uint8 noStoredReplicas; /* NUMBER OF "ALIVE" STORED REPLICAS*/ + Uint8 noLcpReplicas; ///< No of replicas remaining to be LCP:ed + }; + typedef Ptr FragmentstorePtr; + + /*########### PAGE RECORD ############*/ + /*¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤*/ + /* THIS RECORD KEEPS INFORMATION ABOUT NODE GROUPS. */ + /*¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤*/ + struct NodeGroupRecord { + Uint32 nodesInGroup[MAX_REPLICAS + 1]; + Uint32 nextReplicaNode; + Uint32 nodeCount; + bool activeTakeOver; + }; + typedef Ptr NodeGroupRecordPtr; + /*¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤*/ + /* THIS RECORD KEEPS INFORMATION ABOUT NODES. */ + /*¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤*/ + /* RECORD ALIGNED TO BE 64 BYTES. */ + /*¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤*/ + enum NodefailHandlingStep { + NF_REMOVE_NODE_FROM_TABLE = 1, + NF_GCP_TAKE_OVER = 2, + NF_LCP_TAKE_OVER = 4 + }; + + struct NodeRecord { + NodeRecord() { m_nodefailSteps.clear();} + + enum NodeStatus { + NOT_IN_CLUSTER = 0, + ALIVE = 1, + STARTING = 2, + DIED_NOW = 3, + DYING = 4, + DEAD = 5 + }; + + struct FragmentCheckpointInfo { + Uint32 tableId; + Uint32 fragId; + Uint32 replicaPtr; + }; + + enum GcpState { + READY = 0, + PREPARE_SENT = 1, + PREPARE_RECEIVED = 2, + COMMIT_SENT = 3, + NODE_FINISHED = 4, + SAVE_REQ_SENT = 5, + SAVE_RECEIVED = 6, + COPY_GCI_SENT = 7 + }; + + GcpState gcpstate; + Sysfile::ActiveStatus activeStatus; + + NodeStatus nodeStatus; + bool useInTransactions; + bool allowNodeStart; + bool copyCompleted; + bool m_inclDihLcp; + + FragmentCheckpointInfo startedChkpt[2]; + FragmentCheckpointInfo queuedChkpt[2]; + + Bitmask<1> m_nodefailSteps; + Uint32 activeTabptr; + Uint32 nextNode; + Uint32 ndbversion; + Uint32 nodeGroup; + + SignalCounter m_NF_COMPLETE_REP; + + Uint8 dbtcFailCompleted; + Uint8 dblqhFailCompleted; + Uint8 dbdihFailCompleted; + Uint8 dbdictFailCompleted; + Uint8 recNODE_FAILREP; + + Uint8 noOfQueuedChkpt; + Uint8 noOfStartedChkpt; + + MasterLCPConf::State lcpStateAtTakeOver; + }; + typedef Ptr NodeRecordPtr; + /**********************************************************************/ + /* THIS RECORD KEEPS THE INFORMATION ABOUT A TABLE AND ITS FRAGMENTS */ + /**********************************************************************/ + struct PageRecord { + Uint32 word[2048]; + /* 8 KBYTE PAGE*/ + Uint32 nextfreepage; + }; + typedef Ptr PageRecordPtr; + + /************ REPLICA RECORD *************/ + /**********************************************************************/ + /* THIS RECORD KEEPS THE INFORMATION ABOUT A REPLICA OF A FRAGMENT */ + /**********************************************************************/ + struct ReplicaRecord { + /* -------------------------------------------------------------------- */ + /* THE GLOBAL CHECKPOINT IDENTITY WHEN THIS REPLICA WAS CREATED. */ + /* THERE IS ONE INDEX PER REPLICA. A REPLICA INDEX IS CREATED WHEN ANODE*/ + /* CRASH OCCURS. */ + /* -------------------------------------------------------------------- */ + Uint32 createGci[8]; + /* -------------------------------------------------------------------- */ + /* THE LAST GLOBAL CHECKPOINT IDENTITY WHICH HAS BEEN SAVED ON DISK. */ + /* THIS VARIABLE IS ONLY VALID FOR REPLICAS WHICH HAVE "DIED". A REPLICA*/ + /* "DIES" EITHER WHEN THE NODE CRASHES THAT KEPT THE REPLICA OR BY BEING*/ + /* STOPPED IN A CONTROLLED MANNER. */ + /* THERE IS ONE INDEX PER REPLICA. A REPLICA INDEX IS CREATED WHEN ANODE*/ + /* CRASH OCCURS. */ + /* -------------------------------------------------------------------- */ + Uint32 replicaLastGci[8]; + /* -------------------------------------------------------------------- */ + /* THE LOCAL CHECKPOINT IDENTITY OF A LOCAL CHECKPOINT. */ + /* -------------------------------------------------------------------- */ + Uint32 lcpId[MAX_LCP_STORED]; + /* -------------------------------------------------------------------- */ + /* THIS VARIABLE KEEPS TRACK OF THE MAXIMUM GLOBAL CHECKPOINT COMPLETED */ + /* FOR EACH OF THE LOCAL CHECKPOINTS IN THIS FRAGMENT REPLICA. */ + /* -------------------------------------------------------------------- */ + Uint32 maxGciCompleted[MAX_LCP_STORED]; + /* -------------------------------------------------------------------- */ + /* THIS VARIABLE KEEPS TRACK OF THE MINIMUM GLOBAL CHECKPOINT STARTEDFOR*/ + /* EACH OF THE LOCAL CHECKPOINTS IN THIS FRAGMENT REPLICA. */ + /* -------------------------------------------------------------------- */ + Uint32 maxGciStarted[MAX_LCP_STORED]; + /* -------------------------------------------------------------------- */ + /* THE GLOBAL CHECKPOINT IDENTITY WHEN THE TABLE WAS CREATED. */ + /* -------------------------------------------------------------------- */ + Uint32 initialGci; + + /* -------------------------------------------------------------------- */ + /* THE REFERENCE TO THE NEXT REPLICA. EITHER IT REFERS TO THE NEXT IN */ + /* THE FREE LIST OR IT REFERS TO THE NEXT IN A LIST OF REPLICAS ON A */ + /* FRAGMENT. */ + /* -------------------------------------------------------------------- */ + Uint32 nextReplica; + + /* -------------------------------------------------------------------- */ + /* THE NODE ID WHERE THIS REPLICA IS STORED. */ + /* -------------------------------------------------------------------- */ + Uint16 procNode; + + /* -------------------------------------------------------------------- */ + /* The last local checkpoint id started or queued on this replica. */ + /* -------------------------------------------------------------------- */ + Uint32 lcpIdStarted; // Started or queued + + /* -------------------------------------------------------------------- */ + /* THIS VARIABLE SPECIFIES WHAT THE STATUS OF THE LOCAL CHECKPOINT IS.IT*/ + /* CAN EITHER BE VALID OR INVALID. AT CREATION OF A FRAGMENT REPLICA ALL*/ + /* LCP'S ARE INVALID. ALSO IF IF INDEX >= NO_LCP THEN THELOCALCHECKPOINT*/ + /* IS ALWAYS INVALID. IF THE LCP BEFORE THE NEXT_LCP HAS LCP_ID THAT */ + /* DIFFERS FROM THE LATEST LCP_ID STARTED THEN THE NEXT_LCP IS ALSO */ + /* INVALID */ + /* -------------------------------------------------------------------- */ + Uint8 lcpStatus[MAX_LCP_STORED]; + + /* -------------------------------------------------------------------- */ + /* THE NEXT LOCAL CHECKPOINT TO EXECUTE IN THIS FRAGMENT REPLICA. */ + /* -------------------------------------------------------------------- */ + Uint8 nextLcp; + + /* -------------------------------------------------------------------- */ + /* THE NUMBER OF CRASHED REPLICAS IN THIS REPLICAS SO FAR. */ + /* -------------------------------------------------------------------- */ + Uint8 noCrashedReplicas; + + /** + * Is a LCP currently ongoing on fragment + */ + Uint8 lcpOngoingFlag; + }; + typedef Ptr ReplicaRecordPtr; + + /************************************************************************* + * TAB_DESCRIPTOR IS A DESCRIPTOR OF THE LOCATION OF THE FRAGMENTS BELONGING + * TO THE TABLE.THE INFORMATION ABOUT FRAGMENTS OF A TABLE ARE STORED IN + * CHUNKS OF FRAGMENTSTORE RECORDS. + * THIS RECORD ALSO HAS THE NECESSARY INFORMATION TO LOCATE A FRAGMENT AND + * TO LOCATE A FRAGMENT AND TO TRANSLATE A KEY OF A TUPLE TO THE FRAGMENT IT + * BELONGS + */ + struct TabRecord { + /** + * State for copying table description into pages + */ + enum CopyStatus { + CS_IDLE, + CS_SR_PHASE1_READ_PAGES, + CS_SR_PHASE2_READ_TABLE, + CS_SR_PHASE3_COPY_TABLE, + CS_REMOVE_NODE, + CS_LCP_READ_TABLE, + CS_COPY_TAB_REQ, + CS_COPY_NODE_STATE, + CS_ADD_TABLE_MASTER, + CS_ADD_TABLE_SLAVE, + CS_INVALIDATE_NODE_LCP + }; + /** + * State for copying pages to disk + */ + enum UpdateState { + US_IDLE, + US_LOCAL_CHECKPOINT, + US_REMOVE_NODE, + US_COPY_TAB_REQ, + US_ADD_TABLE_MASTER, + US_ADD_TABLE_SLAVE, + US_INVALIDATE_NODE_LCP + }; + enum TabLcpStatus { + TLS_ACTIVE = 1, + TLS_WRITING_TO_FILE = 2, + TLS_COMPLETED = 3 + }; + enum TabStatus { + TS_IDLE = 0, + TS_ACTIVE = 1, + TS_CREATING = 2, + TS_DROPPING = 3 + }; + enum Method { + HASH = 0, + NOTDEFINED = 1 + }; + CopyStatus tabCopyStatus; + UpdateState tabUpdateState; + TabLcpStatus tabLcpStatus; + TabStatus tabStatus; + Method method; + + Uint32 pageRef[8]; +//----------------------------------------------------------------------------- +// Each entry in this array contains a reference to 16 fragment records in a +// row. Thus finding the correct record is very quick provided the fragment id. +//----------------------------------------------------------------------------- + Uint32 startFid[MAX_NDB_NODES]; + + Uint32 tabFile[2]; + Uint32 connectrec; + Uint32 hashpointer; + Uint32 mask; + Uint32 noOfWords; + Uint32 schemaVersion; + Uint32 tabRemoveNode; + Uint32 totalfragments; + Uint32 noOfFragChunks; + Uint32 tabErrorCode; + struct { + Uint32 tabUserRef; + Uint32 tabUserPtr; + } m_dropTab; + + struct DropTable { + Uint32 senderRef; + Uint32 senderData; + SignalCounter waitDropTabCount; + } m_prepDropTab; + + Uint8 kvalue; + Uint8 noOfBackups; + Uint8 noPages; + Uint8 storedTable; /* 0 IF THE TABLE IS A TEMPORARY TABLE */ + Uint16 tableType; + Uint16 primaryTableId; + }; + typedef Ptr TabRecordPtr; + + /***************************************************************************/ + /* THIS RECORD IS USED TO KEEP TRACK OF TAKE OVER AND STARTING A NODE. */ + /* WE KEEP IT IN A RECORD TO ENABLE IT TO BE PARALLELISED IN THE FUTURE. */ + /**************************************************************************/ + struct TakeOverRecord { + enum ToMasterStatus { + IDLE = 0, + TO_WAIT_START_TAKE_OVER = 1, + TO_START_COPY = 2, + TO_START_COPY_ONGOING = 3, + TO_WAIT_START = 4, + STARTING = 5, + SELECTING_NEXT = 6, + TO_WAIT_PREPARE_CREATE = 9, + PREPARE_CREATE = 10, + COPY_FRAG = 11, + TO_WAIT_UPDATE_TO = 12, + TO_UPDATE_TO = 13, + COPY_ACTIVE = 14, + TO_WAIT_COMMIT_CREATE = 15, + LOCK_MUTEX = 23, + COMMIT_CREATE = 16, + TO_COPY_COMPLETED = 17, + WAIT_LCP = 18, + TO_END_COPY = 19, + TO_END_COPY_ONGOING = 20, + TO_WAIT_ENDING = 21, + ENDING = 22 + }; + enum ToSlaveStatus { + TO_SLAVE_IDLE = 0, + TO_SLAVE_STARTED = 1, + TO_SLAVE_CREATE_PREPARE = 2, + TO_SLAVE_COPY_FRAG_COMPLETED = 3, + TO_SLAVE_CREATE_COMMIT = 4, + TO_SLAVE_COPY_COMPLETED = 5 + }; + Uint32 startGci; + Uint32 toCopyNode; + Uint32 toCurrentFragid; + Uint32 toCurrentReplica; + Uint32 toCurrentTabref; + Uint32 toFailedNode; + Uint32 toStartingNode; + Uint32 nextTakeOver; + Uint32 prevTakeOver; + bool toNodeRestart; + ToMasterStatus toMasterStatus; + ToSlaveStatus toSlaveStatus; + MutexHandle2 m_switchPrimaryMutexHandle; + }; + typedef Ptr TakeOverRecordPtr; + +public: + Dbdih(const class Configuration &); + virtual ~Dbdih(); + + struct RWFragment { + Uint32 pageIndex; + Uint32 wordIndex; + Uint32 fragId; + TabRecordPtr rwfTabPtr; + PageRecordPtr rwfPageptr; + }; + struct CopyTableNode { + Uint32 pageIndex; + Uint32 wordIndex; + Uint32 noOfWords; + TabRecordPtr ctnTabPtr; + PageRecordPtr ctnPageptr; + }; + +private: + BLOCK_DEFINES(Dbdih); + + void execDUMP_STATE_ORD(Signal *); + void execNDB_TAMPER(Signal *); + void execDEBUG_SIG(Signal *); + void execEMPTY_LCP_CONF(Signal *); + void execMASTER_GCPREF(Signal *); + void execMASTER_GCPREQ(Signal *); + void execMASTER_GCPCONF(Signal *); + void execMASTER_LCPREF(Signal *); + void execMASTER_LCPREQ(Signal *); + void execMASTER_LCPCONF(Signal *); + void execNF_COMPLETEREP(Signal *); + void execSTART_PERMREQ(Signal *); + void execSTART_PERMCONF(Signal *); + void execSTART_PERMREF(Signal *); + void execINCL_NODEREQ(Signal *); + void execINCL_NODECONF(Signal *); + void execEND_TOREQ(Signal *); + void execEND_TOCONF(Signal *); + void execSTART_TOREQ(Signal *); + void execSTART_TOCONF(Signal *); + void execSTART_MEREQ(Signal *); + void execSTART_MECONF(Signal *); + void execSTART_MEREF(Signal *); + void execSTART_COPYREQ(Signal *); + void execSTART_COPYCONF(Signal *); + void execSTART_COPYREF(Signal *); + void execCREATE_FRAGREQ(Signal *); + void execCREATE_FRAGCONF(Signal *); + void execDIVERIFYREQ(Signal *); + void execGCP_SAVECONF(Signal *); + void execGCP_PREPARECONF(Signal *); + void execGCP_PREPARE(Signal *); + void execGCP_NODEFINISH(Signal *); + void execGCP_COMMIT(Signal *); + void execDIHNDBTAMPER(Signal *); + void execCONTINUEB(Signal *); + void execCOPY_GCIREQ(Signal *); + void execCOPY_GCICONF(Signal *); + void execCOPY_TABREQ(Signal *); + void execCOPY_TABCONF(Signal *); + void execTCGETOPSIZECONF(Signal *); + void execTC_CLOPSIZECONF(Signal *); + + void execLCP_FRAG_REP(Signal *); + void execLCP_COMPLETE_REP(Signal *); + void execSTART_LCP_REQ(Signal *); + void execSTART_LCP_CONF(Signal *); + MutexHandle2 c_startLcpMutexHandle; + void startLcpMutex_locked(Signal* signal, Uint32, Uint32); + void startLcpMutex_unlocked(Signal* signal, Uint32, Uint32); + + MutexHandle2 c_switchPrimaryMutexHandle; + void switchPrimaryMutex_locked(Signal* signal, Uint32, Uint32); + void switchPrimaryMutex_unlocked(Signal* signal, Uint32, Uint32); + void switch_primary_stop_node(Signal* signal, Uint32, Uint32); + + void execBLOCK_COMMIT_ORD(Signal *); + void execUNBLOCK_COMMIT_ORD(Signal *); + + void execDIH_SWITCH_REPLICA_REQ(Signal *); + void execDIH_SWITCH_REPLICA_REF(Signal *); + void execDIH_SWITCH_REPLICA_CONF(Signal *); + + void execSTOP_PERM_REQ(Signal *); + void execSTOP_PERM_REF(Signal *); + void execSTOP_PERM_CONF(Signal *); + + void execSTOP_ME_REQ(Signal *); + void execSTOP_ME_REF(Signal *); + void execSTOP_ME_CONF(Signal *); + + void execSIZEALT_REP(Signal *); + void execUNBLO_DICTCONF(Signal *); + void execCOPY_ACTIVECONF(Signal *); + void execTAB_COMMITREQ(Signal *); + void execNODE_FAILREP(Signal *); + void execCOPY_FRAGCONF(Signal *); + void execCOPY_FRAGREF(Signal *); + void execDIADDTABREQ(Signal *); + void execDIGETNODESREQ(Signal *); + void execDIRELEASEREQ(Signal *); + void execDISEIZEREQ(Signal *); + void execSTTOR(Signal *); + void execDI_FCOUNTREQ(Signal *); + void execDIGETPRIMREQ(Signal *); + void execGCP_SAVEREF(Signal *); + void execGCP_TCFINISHED(Signal *); + void execREAD_NODESCONF(Signal *); + void execNDB_STTOR(Signal *); + void execDICTSTARTCONF(Signal *); + void execNDB_STARTREQ(Signal *); + void execGETGCIREQ(Signal *); + void execDIH_RESTARTREQ(Signal *); + void execCNTR_CHANGEREP(Signal *); + void execSTART_RECCONF(Signal *); + void execSTART_FRAGCONF(Signal *); + void execADD_FRAGCONF(Signal *); + void execADD_FRAGREF(Signal *); + void execFSOPENCONF(Signal *); + void execFSOPENREF(Signal *); + void execFSCLOSECONF(Signal *); + void execFSCLOSEREF(Signal *); + void execFSREADCONF(Signal *); + void execFSREADREF(Signal *); + void execFSWRITECONF(Signal *); + void execFSWRITEREF(Signal *); + void execSET_VAR_REQ(Signal *); + void execCHECKNODEGROUPSREQ(Signal *); + void execSTART_INFOREQ(Signal*); + void execSTART_INFOREF(Signal*); + void execSTART_INFOCONF(Signal*); + void execWAIT_GCP_REQ(Signal* signal); + void execWAIT_GCP_REF(Signal* signal); + void execWAIT_GCP_CONF(Signal* signal); + void execUPDATE_TOREQ(Signal* signal); + void execUPDATE_TOCONF(Signal* signal); + + void execPREP_DROP_TAB_REQ(Signal* signal); + void execWAIT_DROP_TAB_REF(Signal* signal); + void execWAIT_DROP_TAB_CONF(Signal* signal); + void execDROP_TAB_REQ(Signal* signal); + + void execALTER_TAB_REQ(Signal* signal); + + void execCREATE_FRAGMENTATION_REQ(Signal*); + + void waitDropTabWritingToFile(Signal *, TabRecordPtr tabPtr); + void checkPrepDropTabComplete(Signal *, TabRecordPtr tabPtr); + void checkWaitDropTabFailedLqh(Signal *, Uint32 nodeId, Uint32 tableId); + + // Statement blocks +//------------------------------------ +// Methods that send signals +//------------------------------------ + void nullRoutine(Signal *, Uint32 nodeId); + void sendCOPY_GCIREQ(Signal *, Uint32 nodeId); + void sendDIH_SWITCH_REPLICA_REQ(Signal *, Uint32 nodeId); + void sendEMPTY_LCP_REQ(Signal *, Uint32 nodeId); + void sendEND_TOREQ(Signal *, Uint32 nodeId); + void sendGCP_COMMIT(Signal *, Uint32 nodeId); + void sendGCP_PREPARE(Signal *, Uint32 nodeId); + void sendGCP_SAVEREQ(Signal *, Uint32 nodeId); + void sendINCL_NODEREQ(Signal *, Uint32 nodeId); + void sendMASTER_GCPREQ(Signal *, Uint32 nodeId); + void sendMASTER_LCPREQ(Signal *, Uint32 nodeId); + void sendMASTER_LCPCONF(Signal * signal); + void sendSTART_RECREQ(Signal *, Uint32 nodeId); + void sendSTART_INFOREQ(Signal *, Uint32 nodeId); + void sendSTART_TOREQ(Signal *, Uint32 nodeId); + void sendSTOP_ME_REQ(Signal *, Uint32 nodeId); + void sendTC_CLOPSIZEREQ(Signal *, Uint32 nodeId); + void sendTCGETOPSIZEREQ(Signal *, Uint32 nodeId); + void sendUPDATE_TOREQ(Signal *, Uint32 nodeId); + void sendSTART_LCP_REQ(Signal *, Uint32 nodeId); + + void sendLCP_FRAG_ORD(Signal*, NodeRecord::FragmentCheckpointInfo info); + void sendLastLCP_FRAG_ORD(Signal *); + + void sendCopyTable(Signal *, CopyTableNode* ctn, + BlockReference ref, Uint32 reqinfo); + void sendCreateFragReq(Signal *, + Uint32 startGci, + Uint32 storedType, + Uint32 takeOverPtr); + void sendDihfragreq(Signal *, + TabRecordPtr regTabPtr, + Uint32 fragId); + void sendStartFragreq(Signal *, + TabRecordPtr regTabPtr, + Uint32 fragId); + void sendHOT_SPAREREP(Signal *); + void sendAddFragreq(Signal *, + TabRecordPtr regTabPtr, + Uint32 fragId, + Uint32 lcpNo, + Uint32 param); + + void sendAddFragreq(Signal*, ConnectRecordPtr, TabRecordPtr, Uint32 fragId); + void addTable_closeConf(Signal* signal, Uint32 tabPtrI); + void resetReplicaSr(TabRecordPtr tabPtr); + void resetReplicaLcp(ReplicaRecord * replicaP, Uint32 stopGci); + +//------------------------------------ +// Methods for LCP functionality +//------------------------------------ + void checkKeepGci(Uint32 replicaStartIndex); + void checkLcpStart(Signal *, Uint32 lineNo); + void checkStartMoreLcp(Signal *, Uint32 nodeId); + bool reportLcpCompletion(const class LcpFragRep *); + void sendLCP_COMPLETE_REP(Signal *); + +//------------------------------------ +// Methods for Delete Table Files +//------------------------------------ + void startDeleteFile(Signal* signal, TabRecordPtr tabPtr); + void openTableFileForDelete(Signal* signal, Uint32 fileIndex); + void tableOpenLab(Signal* signal, FileRecordPtr regFilePtr); + void tableDeleteLab(Signal* signal, FileRecordPtr regFilePtr); + +//------------------------------------ +// File Record specific methods +//------------------------------------ + void closeFile(Signal *, FileRecordPtr regFilePtr); + void closeFileDelete(Signal *, FileRecordPtr regFilePtr); + void createFileRw(Signal *, FileRecordPtr regFilePtr); + void openFileRw(Signal *, FileRecordPtr regFilePtr); + void seizeFile(FileRecordPtr& regFilePtr); + void releaseFile(Uint32 fileIndex); + +//------------------------------------ +// Methods called when completing file +// operation. +//------------------------------------ + void creatingGcpLab(Signal *, FileRecordPtr regFilePtr); + void openingGcpLab(Signal *, FileRecordPtr regFilePtr); + void openingTableLab(Signal *, FileRecordPtr regFilePtr); + void tableCreateLab(Signal *, FileRecordPtr regFilePtr); + void creatingGcpErrorLab(Signal *, FileRecordPtr regFilePtr); + void openingCopyGciErrorLab(Signal *, FileRecordPtr regFilePtr); + void creatingCopyGciErrorLab(Signal *, FileRecordPtr regFilePtr); + void openingGcpErrorLab(Signal *, FileRecordPtr regFilePtr); + void openingTableErrorLab(Signal *, FileRecordPtr regFilePtr); + void tableCreateErrorLab(Signal *, FileRecordPtr regFilePtr); + void closingGcpLab(Signal *, FileRecordPtr regFilePtr); + void closingGcpCrashLab(Signal *, FileRecordPtr regFilePtr); + void closingTableCrashLab(Signal *, FileRecordPtr regFilePtr); + void closingTableSrLab(Signal *, FileRecordPtr regFilePtr); + void tableCloseLab(Signal *, FileRecordPtr regFilePtr); + void tableCloseErrorLab(FileRecordPtr regFilePtr); + void readingGcpLab(Signal *, FileRecordPtr regFilePtr); + void readingTableLab(Signal *, FileRecordPtr regFilePtr); + void readingGcpErrorLab(Signal *, FileRecordPtr regFilePtr); + void readingTableErrorLab(Signal *, FileRecordPtr regFilePtr); + void writingCopyGciLab(Signal *, FileRecordPtr regFilePtr); + void writeInitGcpLab(Signal *, FileRecordPtr regFilePtr); + void tableWriteLab(Signal *, FileRecordPtr regFilePtr); + void writeInitGcpErrorLab(Signal *, FileRecordPtr regFilePtr); + + + void calculateHotSpare(); + void checkEscalation(); + void clearRestartInfoBits(Signal *); + void invalidateLcpInfoAfterSr(); + + bool isMaster(); + bool isActiveMaster(); + + void emptyverificbuffer(Signal *, bool aContintueB); + Uint32 findHotSpare(); + void handleGcpStateInMaster(Signal *, NodeRecordPtr failedNodeptr); + void initRestartInfo(); + void initRestorableGciFiles(); + void makeNodeGroups(Uint32 nodeArray[]); + void makePrnList(class ReadNodesConf * readNodes, Uint32 nodeArray[]); + void nodeResetStart(); + void releaseTabPages(Uint32 tableId); + void replication(Uint32 noOfReplicas, + NodeGroupRecordPtr NGPtr, + FragmentstorePtr regFragptr); + void selectMasterCandidateAndSend(Signal *); + void setInitialActiveStatus(); + void setLcpActiveStatusEnd(); + void setLcpActiveStatusStart(Signal *); + void setNodeActiveStatus(); + void setNodeGroups(); + void setNodeInfo(Signal *); + void setNodeLcpActiveStatus(); + void setNodeRestartInfoBits(); + void startGcp(Signal *); + + void readFragment(RWFragment* rf, FragmentstorePtr regFragptr); + Uint32 readPageWord(RWFragment* rf); + void readReplica(RWFragment* rf, ReplicaRecordPtr readReplicaPtr); + void readReplicas(RWFragment* rf, FragmentstorePtr regFragptr); + void readRestorableGci(Signal *, FileRecordPtr regFilePtr); + void readTabfile(Signal *, TabRecord* tab, FileRecordPtr regFilePtr); + void writeFragment(RWFragment* wf, FragmentstorePtr regFragptr); + void writePageWord(RWFragment* wf, Uint32 dataWord); + void writeReplicas(RWFragment* wf, Uint32 replicaStartIndex); + void writeRestorableGci(Signal *, FileRecordPtr regFilePtr); + void writeTabfile(Signal *, TabRecord* tab, FileRecordPtr regFilePtr); + void copyTabReq_complete(Signal* signal, TabRecordPtr tabPtr); + + void gcpcommitreqLab(Signal *); + void gcpsavereqLab(Signal *); + void copyGciLab(Signal *, CopyGCIReq::CopyReason reason); + void storeNewLcpIdLab(Signal *); + void startLcpRoundLoopLab(Signal *, Uint32 startTableId, Uint32 startFragId); + + void nodeFailCompletedCheckLab(Signal*, NodeRecordPtr failedNodePtr); + + /** + * + */ + void setLocalNodefailHandling(Signal*, Uint32 failedNodeId, + NodefailHandlingStep step); + void checkLocalNodefailComplete(Signal*, Uint32 failedNodeId, + NodefailHandlingStep step); + + void ndbsttorry10Lab(Signal *, Uint32 _line); + void createMutexes(Signal* signal, Uint32 no); + void createMutex_done(Signal* signal, Uint32 no, Uint32 retVal); + void crashSystemAtGcpStop(Signal *); + void sendFirstDictfragsreq(Signal *, TabRecordPtr regTabPtr); + void addtabrefuseLab(Signal *, ConnectRecordPtr regConnectPtr, Uint32 errorCode); + void GCP_SAVEhandling(Signal *, Uint32 nodeId); + void packTableIntoPagesLab(Signal *, Uint32 tableId); + void readPagesIntoTableLab(Signal *, Uint32 tableId); + void readPagesIntoFragLab(Signal *, RWFragment* rf); + void readTabDescriptionLab(Signal *, Uint32 tableId); + void copyTableLab(Signal *, Uint32 tableId); + void breakCopyTableLab(Signal *, + TabRecordPtr regTabPtr, + Uint32 nodeId); + void checkAddfragCompletedLab(Signal *, + TabRecordPtr regTabPtr, + Uint32 fragId); + void completeRestartLab(Signal *); + void readTableFromPagesLab(Signal *, TabRecordPtr regTabPtr); + void srPhase2ReadTableLab(Signal *, TabRecordPtr regTabPtr); + void checkTcCounterLab(Signal *); + void calculateKeepGciLab(Signal *, Uint32 tableId, Uint32 fragId); + void tableUpdateLab(Signal *, TabRecordPtr regTabPtr); + void checkLcpCompletedLab(Signal *); + void initLcpLab(Signal *, Uint32 masterRef, Uint32 tableId); + void startGcpLab(Signal *, Uint32 aWaitTime); + void checkGcpStopLab(Signal *); + void MASTER_GCPhandling(Signal *, Uint32 failedNodeId); + void MASTER_LCPhandling(Signal *, Uint32 failedNodeId); + void rnfTableNotReadyLab(Signal *, TabRecordPtr regTabPtr, Uint32 removeNodeId); + void startLcpTakeOverLab(Signal *, Uint32 failedNodeId); + + void startLcpMasterTakeOver(Signal *, Uint32 failedNodeId); + void startGcpMasterTakeOver(Signal *, Uint32 failedNodeId); + void checkGcpOutstanding(Signal*, Uint32 failedNodeId); + + void checkEmptyLcpComplete(Signal *); + void lcpBlockedLab(Signal *); + void breakCheckTabCompletedLab(Signal *, TabRecordPtr regTabptr); + void readGciFileLab(Signal *); + void openingCopyGciSkipInitLab(Signal *, FileRecordPtr regFilePtr); + void startLcpRoundLab(Signal *); + void gcpBlockedLab(Signal *); + void initialStartCompletedLab(Signal *); + void allNodesLcpCompletedLab(Signal *); + void nodeRestartPh2Lab(Signal *); + void initGciFilesLab(Signal *); + void dictStartConfLab(Signal *); + void nodeDictStartConfLab(Signal *); + void ndbStartReqLab(Signal *, BlockReference ref); + void nodeRestartStartRecConfLab(Signal *); + void dihCopyCompletedLab(Signal *); + void copyTableNode(Signal *, + CopyTableNode* ctn, + NodeRecordPtr regNodePtr); + void startFragment(Signal *, Uint32 tableId, Uint32 fragId); + bool checkLcpAllTablesDoneInLqh(); + + void lcpStateAtNodeFailureLab(Signal *, Uint32 nodeId); + void copyNodeLab(Signal *, Uint32 tableId); + void copyGciReqLab(Signal *); + void allLab(Signal *, + ConnectRecordPtr regConnectPtr, + TabRecordPtr regTabPtr); + void tableCopyNodeLab(Signal *, TabRecordPtr regTabPtr); + + void removeNodeFromTables(Signal *, Uint32 tableId, Uint32 nodeId); + void removeNodeFromTable(Signal *, Uint32 tableId, TabRecordPtr tabPtr); + void removeNodeFromTablesComplete(Signal* signal, Uint32 nodeId); + + void packFragIntoPagesLab(Signal *, RWFragment* wf); + void startNextChkpt(Signal *); + void failedNodeLcpHandling(Signal*, NodeRecordPtr failedNodePtr); + void failedNodeSynchHandling(Signal *, NodeRecordPtr failedNodePtr); + void checkCopyTab(NodeRecordPtr failedNodePtr); + + void initCommonData(); + void initialiseRecordsLab(Signal *, Uint32 stepNo); + + void findReplica(ReplicaRecordPtr& regReplicaPtr, + Fragmentstore* fragPtrP, Uint32 nodeId); +//------------------------------------ +// Node failure handling methods +//------------------------------------ + void startRemoveFailedNode(Signal *, NodeRecordPtr failedNodePtr); + void handleGcpTakeOver(Signal *, NodeRecordPtr failedNodePtr); + void handleLcpTakeOver(Signal *, NodeRecordPtr failedNodePtr); + void handleNewMaster(Signal *, NodeRecordPtr failedNodePtr); + void checkTakeOverInMasterAllNodeFailure(Signal*, NodeRecordPtr failedNode); + void checkTakeOverInMasterCopyNodeFailure(Signal*, Uint32 failedNodeId); + void checkTakeOverInMasterStartNodeFailure(Signal*, Uint32 takeOverPtr); + void checkTakeOverInNonMasterStartNodeFailure(Signal*, Uint32 takeOverPtr); + void handleLcpMasterTakeOver(Signal *, Uint32 nodeId); + +//------------------------------------ +// Replica record specific methods +//------------------------------------ + Uint32 findLogInterval(ConstPtr regReplicaPtr, + Uint32 startGci); + void findMinGci(ReplicaRecordPtr fmgReplicaPtr, + Uint32& keeGci, + Uint32& oldestRestorableGci); + bool findStartGci(ConstPtr fstReplicaPtr, + Uint32 tfstStopGci, + Uint32& tfstStartGci, + Uint32& tfstLcp); + void newCrashedReplica(Uint32 nodeId, ReplicaRecordPtr ncrReplicaPtr); + void packCrashedReplicas(ReplicaRecordPtr pcrReplicaPtr); + void releaseReplicas(Uint32 replicaPtr); + void removeOldCrashedReplicas(ReplicaRecordPtr rocReplicaPtr); + void removeTooNewCrashedReplicas(ReplicaRecordPtr rtnReplicaPtr); + void seizeReplicaRec(ReplicaRecordPtr& replicaPtr); + +//------------------------------------ +// Methods operating on a fragment and +// its connected replicas and nodes. +//------------------------------------ + void allocStoredReplica(FragmentstorePtr regFragptr, + ReplicaRecordPtr& newReplicaPtr, + Uint32 nodeId); + Uint32 extractNodeInfo(const Fragmentstore * fragPtr, Uint32 nodes[]); + bool findBestLogNode(CreateReplicaRecord* createReplica, + FragmentstorePtr regFragptr, + Uint32 startGci, + Uint32 stopGci, + Uint32 logNode, + Uint32& fblStopGci); + bool findLogNodes(CreateReplicaRecord* createReplica, + FragmentstorePtr regFragptr, + Uint32 startGci, + Uint32 stopGci); + void findToReplica(TakeOverRecord* regTakeOver, + Uint32 replicaType, + FragmentstorePtr regFragptr, + ReplicaRecordPtr& ftrReplicaPtr); + void initFragstore(FragmentstorePtr regFragptr); + void insertBackup(FragmentstorePtr regFragptr, Uint32 nodeId); + void insertfraginfo(FragmentstorePtr regFragptr, + Uint32 noOfBackups, + Uint32* nodeArray); + void linkOldStoredReplica(FragmentstorePtr regFragptr, + ReplicaRecordPtr replicaPtr); + void linkStoredReplica(FragmentstorePtr regFragptr, + ReplicaRecordPtr replicaPtr); + void prepareReplicas(FragmentstorePtr regFragptr); + void removeNodeFromStored(Uint32 nodeId, + FragmentstorePtr regFragptr, + ReplicaRecordPtr replicaPtr); + void removeOldStoredReplica(FragmentstorePtr regFragptr, + ReplicaRecordPtr replicaPtr); + void removeStoredReplica(FragmentstorePtr regFragptr, + ReplicaRecordPtr replicaPtr); + void searchStoredReplicas(FragmentstorePtr regFragptr); + void updateNodeInfo(FragmentstorePtr regFragptr); + +//------------------------------------ +// Fragment allocation, deallocation and +// find methods +//------------------------------------ + void allocFragments(Uint32 noOfFragments, TabRecordPtr regTabPtr); + void releaseFragments(TabRecordPtr regTabPtr); + void getFragstore(TabRecord *, Uint32 fragNo, FragmentstorePtr & ptr); + void initialiseFragstore(); + +//------------------------------------ +// Page Record specific methods +//------------------------------------ + void allocpage(PageRecordPtr& regPagePtr); + void releasePage(Uint32 pageIndex); + +//------------------------------------ +// Table Record specific methods +//------------------------------------ + void initTable(TabRecordPtr regTabPtr); + void initTableFile(TabRecordPtr regTabPtr); + void releaseTable(TabRecordPtr tabPtr); + Uint32 findTakeOver(Uint32 failedNodeId); + void handleTakeOverMaster(Signal *, Uint32 takeOverPtr); + void handleTakeOverNewMaster(Signal *, Uint32 takeOverPtr); + +//------------------------------------ +// TakeOver Record specific methods +//------------------------------------ + void initTakeOver(TakeOverRecordPtr regTakeOverptr); + void seizeTakeOver(TakeOverRecordPtr& regTakeOverptr); + void allocateTakeOver(TakeOverRecordPtr& regTakeOverptr); + void releaseTakeOver(Uint32 takeOverPtr); + bool anyActiveTakeOver(); + void checkToCopy(); + void checkToCopyCompleted(Signal *); + bool checkToInterrupted(TakeOverRecordPtr& regTakeOverptr); + Uint32 getStartNode(Uint32 takeOverPtr); + +//------------------------------------ +// Methods for take over functionality +//------------------------------------ + void changeNodeGroups(Uint32 startNode, Uint32 nodeTakenOver); + void endTakeOver(Uint32 takeOverPtr); + void initStartTakeOver(const class StartToReq *, + TakeOverRecordPtr regTakeOverPtr); + + void nodeRestartTakeOver(Signal *, Uint32 startNodeId); + void systemRestartTakeOverLab(Signal *); + void startTakeOver(Signal *, + Uint32 takeOverPtr, + Uint32 startNode, + Uint32 toNode); + void sendStartTo(Signal *, Uint32 takeOverPtr); + void startNextCopyFragment(Signal *, Uint32 takeOverPtr); + void toCopyFragLab(Signal *, Uint32 takeOverPtr); + void startHsAddFragConfLab(Signal *); + void prepareSendCreateFragReq(Signal *, Uint32 takeOverPtr); + void sendUpdateTo(Signal *, Uint32 takeOverPtr, Uint32 updateState); + void toCopyCompletedLab(Signal *, TakeOverRecordPtr regTakeOverptr); + void takeOverCompleted(Uint32 aNodeId); + void sendEndTo(Signal *, Uint32 takeOverPtr); + +//------------------------------------ +// Node Record specific methods +//------------------------------------ + void checkStartTakeOver(Signal *); + void insertAlive(NodeRecordPtr newNodePtr); + void insertDeadNode(NodeRecordPtr removeNodePtr); + void removeAlive(NodeRecordPtr removeNodePtr); + void removeDeadNode(NodeRecordPtr removeNodePtr); + + NodeRecord::NodeStatus getNodeStatus(Uint32 nodeId); + void setNodeStatus(Uint32 nodeId, NodeRecord::NodeStatus); + Sysfile::ActiveStatus getNodeActiveStatus(Uint32 nodeId); + void setNodeActiveStatus(Uint32 nodeId, Sysfile::ActiveStatus newStatus); + void setNodeLcpActiveStatus(Uint32 nodeId, bool newState); + bool getNodeLcpActiveStatus(Uint32 nodeId); + bool getAllowNodeStart(Uint32 nodeId); + void setAllowNodeStart(Uint32 nodeId, bool newState); + bool getNodeCopyCompleted(Uint32 nodeId); + void setNodeCopyCompleted(Uint32 nodeId, bool newState); + void initNodeState(NodeRecordPtr regNodePtr); + bool checkNodeAlive(Uint32 nodeId); + + // Initialisation + void initData(); + void initRecords(); + + // Variables to support record structures and their free lists + + ApiConnectRecord *apiConnectRecord; + Uint32 capiConnectFileSize; + + ConnectRecord *connectRecord; + Uint32 cfirstconnect; + Uint32 cconnectFileSize; + + CreateReplicaRecord *createReplicaRecord; + Uint32 cnoOfCreateReplicas; + + FileRecord *fileRecord; + Uint32 cfirstfreeFile; + Uint32 cfileFileSize; + + Fragmentstore *fragmentstore; + Uint32 cfirstfragstore; + Uint32 cfragstoreFileSize; + + Uint32 c_nextNodeGroup; + NodeGroupRecord *nodeGroupRecord; + + NodeRecord *nodeRecord; + + PageRecord *pageRecord; + Uint32 cfirstfreepage; + Uint32 cpageFileSize; + + ReplicaRecord *replicaRecord; + Uint32 cfirstfreeReplica; + Uint32 cnoFreeReplicaRec; + Uint32 creplicaFileSize; + + TabRecord *tabRecord; + Uint32 ctabFileSize; + + TakeOverRecord *takeOverRecord; + Uint32 cfirstfreeTakeOver; + + /* + 2.4 C O M M O N S T O R E D V A R I A B L E S + ---------------------------------------------------- + */ + Uint32 cfirstVerifyQueue; + Uint32 clastVerifyQueue; + Uint32 cverifyQueueCounter; + + /*------------------------------------------------------------------------*/ + /* THIS VARIABLE KEEPS THE REFERENCES TO FILE RECORDS THAT DESCRIBE */ + /* THE TWO FILES THAT ARE USED TO STORE THE VARIABLE CRESTART_INFO */ + /* ON DISK. */ + /*------------------------------------------------------------------------*/ + Uint32 crestartInfoFile[2]; + /*------------------------------------------------------------------------*/ + /* THIS VARIABLE KEEPS TRACK OF THE STATUS OF A GLOBAL CHECKPOINT */ + /* PARTICIPANT. THIS IS NEEDED TO HANDLE A NODE FAILURE. WHEN A NODE*/ + /* FAILURE OCCURS IT IS EASY THAT THE PROTOCOL STOPS IF NO ACTION IS*/ + /* TAKEN TO PREVENT THIS. THIS VARIABLE ENSURES SUCH ACTION CAN BE */ + /* TAKEN. */ + /*------------------------------------------------------------------------*/ + enum GcpParticipantState { + GCP_PARTICIPANT_READY = 0, + GCP_PARTICIPANT_PREPARE_RECEIVED = 1, + GCP_PARTICIPANT_COMMIT_RECEIVED = 2, + GCP_PARTICIPANT_TC_FINISHED = 3, + GCP_PARTICIPANT_COPY_GCI_RECEIVED = 4 + }; + GcpParticipantState cgcpParticipantState; + /*------------------------------------------------------------------------*/ + /* THESE VARIABLES ARE USED TO CONTROL THAT GCP PROCESSING DO NOT */ + /*STOP FOR SOME REASON. */ + /*------------------------------------------------------------------------*/ + enum GcpStatus { + GCP_READY = 0, + GCP_PREPARE_SENT = 1, + GCP_COMMIT_SENT = 2, + GCP_NODE_FINISHED = 3, + GCP_SAVE_LQH_FINISHED = 4 + }; + GcpStatus cgcpStatus; + Uint32 cgcpStartCounter; + Uint32 coldGcpStatus; + Uint32 coldGcpId; + /*------------------------------------------------------------------------*/ + /* THIS VARIABLE KEEPS TRACK OF THE STATE OF THIS NODE AS MASTER. */ + /*------------------------------------------------------------------------*/ + enum MasterState { + MASTER_IDLE = 0, + MASTER_ACTIVE = 1, + MASTER_TAKE_OVER_GCP = 2 + }; + MasterState cmasterState; + Uint16 cmasterTakeOverNode; + /* NODE IS NOT MASTER */ + /* NODE IS ACTIVE AS MASTER */ + /* NODE IS TAKING OVER AS MASTER */ + + struct CopyGCIMaster { + CopyGCIMaster(){ m_copyReason = m_waiting = CopyGCIReq::IDLE;} + /*------------------------------------------------------------------------*/ + /* THIS STATE VARIABLE IS USED TO INDICATE IF COPYING OF RESTART */ + /* INFO WAS STARTED BY A LOCAL CHECKPOINT OR AS PART OF A SYSTEM */ + /* RESTART. */ + /*------------------------------------------------------------------------*/ + CopyGCIReq::CopyReason m_copyReason; + + /*------------------------------------------------------------------------*/ + /* COPYING RESTART INFO CAN BE STARTED BY LOCAL CHECKPOINTS AND BY */ + /* GLOBAL CHECKPOINTS. WE CAN HOWEVER ONLY HANDLE ONE SUCH COPY AT */ + /* THE TIME. THUS WE HAVE TO KEEP WAIT INFORMATION IN THIS VARIABLE.*/ + /*------------------------------------------------------------------------*/ + CopyGCIReq::CopyReason m_waiting; + } c_copyGCIMaster; + + struct CopyGCISlave { + CopyGCISlave(){ m_copyReason = CopyGCIReq::IDLE; m_expectedNextWord = 0;} + /*------------------------------------------------------------------------*/ + /* THIS STATE VARIABLE IS USED TO INDICATE IF COPYING OF RESTART */ + /* INFO WAS STARTED BY A LOCAL CHECKPOINT OR AS PART OF A SYSTEM */ + /* RESTART. THIS VARIABLE IS USED BY THE NODE THAT RECEIVES */ + /* COPY_GCI_REQ. */ + /*------------------------------------------------------------------------*/ + Uint32 m_senderData; + BlockReference m_senderRef; + CopyGCIReq::CopyReason m_copyReason; + + Uint32 m_expectedNextWord; + } c_copyGCISlave; + + /*------------------------------------------------------------------------*/ + /* THIS VARIABLE IS USED TO KEEP TRACK OF THE STATE OF LOCAL */ + /* CHECKPOINTS. */ + /*------------------------------------------------------------------------*/ +public: + enum LcpStatus { + LCP_STATUS_IDLE = 0, + LCP_TCGET = 1, // Only master + LCP_STATUS_ACTIVE = 2, + LCP_CALCULATE_KEEP_GCI = 4, // Only master + LCP_COPY_GCI = 5, + LCP_INIT_TABLES = 6, + LCP_TC_CLOPSIZE = 7, // Only master + LCP_START_LCP_ROUND = 8, + LCP_TAB_COMPLETED = 9, + LCP_TAB_SAVED = 10 + }; +private: + + struct LcpState { + LcpStatus lcpStatus; + Uint32 lcpStatusUpdatedPlace; + + void setLcpStatus(LcpStatus status, Uint32 line){ + lcpStatus = status; + lcpStatusUpdatedPlace = line; + } + + Uint32 lcpStart; + Uint32 lcpStartGcp; + Uint32 keepGci; /* USED TO CALCULATE THE GCI TO KEEP AFTER A LCP */ + Uint32 oldestRestorableGci; + + struct CurrentFragment { + Uint32 tableId; + Uint32 fragmentId; + } currentFragment; + + Uint32 noOfLcpFragRepOutstanding; + + /*------------------------------------------------------------------------*/ + /* USED TO ENSURE THAT LCP'S ARE EXECUTED WITH CERTAIN TIMEINTERVALS*/ + /* EVEN WHEN SYSTEM IS NOT DOING ANYTHING. */ + /*------------------------------------------------------------------------*/ + Uint32 ctimer; + Uint32 ctcCounter; + Uint32 clcpDelay; /* MAX. 2^(CLCP_DELAY - 2) SEC BETWEEN LCP'S */ + + /*------------------------------------------------------------------------*/ + /* THIS STATE IS USED TO TELL IF THE FIRST LCP AFTER START/RESTART */ + /* HAS BEEN RUN. AFTER A NODE RESTART THE NODE DOES NOT ENTER */ + /* STARTED STATE BEFORE THIS IS DONE. */ + /*------------------------------------------------------------------------*/ + bool immediateLcpStart; + bool m_LCP_COMPLETE_REP_From_Master_Received; + SignalCounter m_LCP_COMPLETE_REP_Counter_DIH; + SignalCounter m_LCP_COMPLETE_REP_Counter_LQH; + SignalCounter m_LAST_LCP_FRAG_ORD; + NdbNodeBitmask m_participatingLQH; + NdbNodeBitmask m_participatingDIH; + + Uint32 m_masterLcpDihRef; + bool m_MASTER_LCPREQ_Received; + Uint32 m_MASTER_LCPREQ_FailedNodeId; + } c_lcpState; + + /*------------------------------------------------------------------------*/ + /* THIS VARIABLE KEEPS TRACK OF HOW MANY TABLES ARE ACTIVATED WHEN */ + /* STARTING A LOCAL CHECKPOINT WE SHOULD AVOID STARTING A CHECKPOINT*/ + /* WHEN NO TABLES ARE ACTIVATED. */ + /*------------------------------------------------------------------------*/ + Uint32 cnoOfActiveTables; + Uint32 cgcpDelay; /* Delay between global checkpoints */ + + BlockReference cdictblockref; /* DICTIONARY BLOCK REFERENCE */ + Uint32 cfailurenr; /* EVERY TIME WHEN A NODE FAILURE IS REPORTED + THIS NUMBER IS INCREMENTED. AT THE START OF + THE SYSTEM THIS NUMBER MUST BE INITIATED TO + ZERO */ + bool cgckptflag; /* A FLAG WHICH IS SET WHILE A NEW GLOBAL CHECK + POINT IS BEING CREATED. NO VERIFICATION IS ALLOWED + IF THE FLAG IS SET*/ + Uint32 cgcpOrderBlocked; + BlockReference clocallqhblockref; + BlockReference clocaltcblockref; + BlockReference cmasterdihref; + Uint16 cownNodeId; + Uint32 cnewgcp; + BlockReference cndbStartReqBlockref; + BlockReference cntrlblockref; + Uint32 cgcpSameCounter; + Uint32 coldgcp; + Uint32 con_lineNodes; + Uint32 creceivedfrag; + Uint32 cremainingfrags; + Uint32 cstarttype; + Uint32 csystemnodes; + Uint32 currentgcp; + + enum GcpMasterTakeOverState { + GMTOS_IDLE = 0, + GMTOS_INITIAL = 1, + ALL_READY = 2, + ALL_PREPARED = 3, + COMMIT_STARTED_NOT_COMPLETED = 4, + COMMIT_COMPLETED = 5, + PREPARE_STARTED_NOT_COMMITTED = 6, + SAVE_STARTED_NOT_COMPLETED = 7 + }; + GcpMasterTakeOverState cgcpMasterTakeOverState; + +public: + enum LcpMasterTakeOverState { + LMTOS_IDLE = 0, + LMTOS_WAIT_EMPTY_LCP = 1, // Currently doing empty LCP + LMTOS_WAIT_LCP_FRAG_REP = 2,// Currently waiting for outst. LCP_FRAG_REP + LMTOS_INITIAL = 3, + LMTOS_ALL_IDLE = 4, + LMTOS_ALL_ACTIVE = 5, + LMTOS_LCP_CONCLUDING = 6, + LMTOS_COPY_ONGOING = 7 + }; +private: + class MasterTakeOverState { + public: + void set(LcpMasterTakeOverState s, Uint32 line) { + state = s; updatePlace = line; + } + + LcpMasterTakeOverState state; + Uint32 updatePlace; + + Uint32 minTableId; + Uint32 minFragId; + Uint32 failedNodeId; + } c_lcpMasterTakeOverState; + + Uint16 cmasterNodeId; + Uint8 cnoHotSpare; + + struct NodeStartMasterRecord { + Uint32 startNode; + Uint32 wait; + Uint32 failNr; + Uint32 ndbVersion; + bool activeState; + bool blockLcp; + bool blockGcp; + Uint32 startInfoErrorCode; + Uint32 m_outstandingGsn; + }; + NodeStartMasterRecord c_nodeStartMaster; + + struct NodeStartSlaveRecord { + NodeStartSlaveRecord() { nodeId = 0;} + + Uint32 nodeId; + }; + NodeStartSlaveRecord c_nodeStartSlave; + + Uint32 cfirstAliveNode; + Uint32 cfirstDeadNode; + Uint32 cstartPhase; + Uint32 cnoReplicas; + + Uint32 c_startToLock; + Uint32 c_endToLock; + Uint32 c_createFragmentLock; + Uint32 c_updateToLock; + + bool cwaitLcpSr; + Uint32 cnoOfNodeGroups; + bool cstartGcpNow; + + Uint32 crestartGci; /* VALUE OF GCI WHEN SYSTEM RESTARTED OR STARTED */ + Uint32 cminHotSpareNodes; + + /** + * Counter variables keeping track of the number of outstanding signals + * for particular signals in various protocols. + */ + SignalCounter c_COPY_GCIREQ_Counter; + SignalCounter c_COPY_TABREQ_Counter; + SignalCounter c_CREATE_FRAGREQ_Counter; + SignalCounter c_DIH_SWITCH_REPLICA_REQ_Counter; + SignalCounter c_EMPTY_LCP_REQ_Counter; + SignalCounter c_END_TOREQ_Counter; + SignalCounter c_GCP_COMMIT_Counter; + SignalCounter c_GCP_PREPARE_Counter; + SignalCounter c_GCP_SAVEREQ_Counter; + SignalCounter c_INCL_NODEREQ_Counter; + SignalCounter c_MASTER_GCPREQ_Counter; + SignalCounter c_MASTER_LCPREQ_Counter; + SignalCounter c_START_INFOREQ_Counter; + SignalCounter c_START_RECREQ_Counter; + SignalCounter c_START_TOREQ_Counter; + SignalCounter c_STOP_ME_REQ_Counter; + SignalCounter c_TC_CLOPSIZEREQ_Counter; + SignalCounter c_TCGETOPSIZEREQ_Counter; + SignalCounter c_UPDATE_TOREQ_Counter; + SignalCounter c_START_LCP_REQ_Counter; + + bool c_blockCommit; + Uint32 c_blockCommitNo; + + bool getBlockCommit() const { + return c_blockCommit == true || cgckptflag == true; + } + + /** + * SwitchReplicaRecord - Should only be used by master + */ + struct SwitchReplicaRecord { + void clear(){} + + Uint32 nodeId; + Uint32 tableId; + Uint32 fragNo; + }; + SwitchReplicaRecord c_switchReplicas; + + struct StopPermProxyRecord { + StopPermProxyRecord() { clientRef = 0; } + + Uint32 clientData; + BlockReference clientRef; + BlockReference masterRef; + }; + + struct StopPermMasterRecord { + StopPermMasterRecord() { clientRef = 0;} + + Uint32 returnValue; + + Uint32 clientData; + BlockReference clientRef; + }; + + StopPermProxyRecord c_stopPermProxy; + StopPermMasterRecord c_stopPermMaster; + + void checkStopPermProxy(Signal*, NodeId failedNodeId); + void checkStopPermMaster(Signal*, NodeRecordPtr failedNodePtr); + + void switchReplica(Signal*, + Uint32 nodeId, + Uint32 tableId, + Uint32 fragNo); + + void switchReplicaReply(Signal*, NodeId nodeId); + + /** + * Wait GCP (proxy) + */ + struct WaitGCPProxyRecord { + WaitGCPProxyRecord() { clientRef = 0;} + + Uint32 clientData; + BlockReference clientRef; + BlockReference masterRef; + + union { Uint32 nextPool; Uint32 nextList; }; + Uint32 prevList; + }; + typedef Ptr WaitGCPProxyPtr; + + /** + * Wait GCP (master) + */ + struct WaitGCPMasterRecord { + WaitGCPMasterRecord() { clientRef = 0;} + Uint32 clientData; + BlockReference clientRef; + + union { Uint32 nextPool; Uint32 nextList; }; + Uint32 prevList; + }; + typedef Ptr WaitGCPMasterPtr; + + /** + * Pool/list of WaitGCPProxyRecord record + */ + ArrayPool waitGCPProxyPool; + ArrayList c_waitGCPProxyList; + + /** + * Pool/list of WaitGCPMasterRecord record + */ + ArrayPool waitGCPMasterPool; + ArrayList c_waitGCPMasterList; + + void checkWaitGCPProxy(Signal*, NodeId failedNodeId); + void checkWaitGCPMaster(Signal*, NodeId failedNodeId); + void emptyWaitGCPMasterQueue(Signal*); + + /** + * Stop me + */ + struct StopMeRecord { + StopMeRecord() { clientRef = 0;} + + BlockReference clientRef; + Uint32 clientData; + }; + StopMeRecord c_stopMe; + + void checkStopMe(Signal *, NodeRecordPtr failedNodePtr); + +#define DIH_CDATA_SIZE 128 + /** + * This variable must be atleast the size of Sysfile::SYSFILE_SIZE32 + */ + Uint32 cdata[DIH_CDATA_SIZE]; /* TEMPORARY ARRAY VARIABLE */ + + /** + * Sys file data + */ + Uint32 sysfileData[DIH_CDATA_SIZE]; + Uint32 sysfileDataToFile[DIH_CDATA_SIZE]; + + /** + * When a node comes up without filesystem + * we have to clear all LCP for that node + */ + void invalidateNodeLCP(Signal *, Uint32 nodeId, Uint32 tableId); + void invalidateNodeLCP(Signal *, Uint32 nodeId, TabRecordPtr); + + /** + * Reply from nodeId + */ + void startInfoReply(Signal *, Uint32 nodeId); +}; + +#if (DIH_CDATA_SIZE < _SYSFILE_SIZE32) +#error "cdata is to small compared to Sysfile size" +#endif + +#endif + diff --git a/ndb/src/kernel/blocks/dbdih/DbdihInit.cpp b/ndb/src/kernel/blocks/dbdih/DbdihInit.cpp new file mode 100644 index 00000000000..b115cc0297a --- /dev/null +++ b/ndb/src/kernel/blocks/dbdih/DbdihInit.cpp @@ -0,0 +1,319 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#define DBDIH_C +#include "Dbdih.hpp" +#include +#include + +#define DEBUG(x) { ndbout << "DIH::" << x << endl; } + +void Dbdih::initData() +{ + cpageFileSize = ZPAGEREC; + + apiConnectRecord = 0; + connectRecord = 0; + fileRecord = 0; + fragmentstore = 0; + pageRecord = 0; + replicaRecord = 0; + tabRecord = 0; + takeOverRecord = 0; + createReplicaRecord = 0; + nodeGroupRecord = 0; + nodeRecord = 0; + c_nextNodeGroup = 0; + + // Records with constant sizes + createReplicaRecord = (CreateReplicaRecord*) + allocRecord("CreateReplicaRecord", sizeof(CreateReplicaRecord), + ZCREATE_REPLICA_FILE_SIZE); + + nodeGroupRecord = (NodeGroupRecord*) + allocRecord("NodeGroupRecord", sizeof(NodeGroupRecord), MAX_NDB_NODES); + + nodeRecord = (NodeRecord*) + allocRecord("NodeRecord", sizeof(NodeRecord), MAX_NDB_NODES); + + for(Uint32 i = 0; iword[0]; + bat[1].nrr = cpageFileSize; + bat[1].ClusterSize = sizeof(PageRecord); + bat[1].bits.q = 11; + bat[1].bits.v = 5; + bat[20].WA = &sysfileData[0]; + bat[20].nrr = 1; + bat[20].ClusterSize = sizeof(sysfileData); + bat[20].bits.q = 7; + bat[20].bits.v = 5; + bat[21].WA = &sysfileDataToFile[0]; + bat[21].nrr = 1; + bat[21].ClusterSize = sizeof(sysfileDataToFile); + bat[21].bits.q = 7; + bat[21].bits.v = 5; +}//Dbdih::initRecords() + +Dbdih::Dbdih(const class Configuration & config): + SimulatedBlock(DBDIH, config), + c_waitGCPProxyList(waitGCPProxyPool), + c_waitGCPMasterList(waitGCPMasterPool) +{ + BLOCK_CONSTRUCTOR(Dbdih); + + addRecSignal(GSN_DUMP_STATE_ORD, &Dbdih::execDUMP_STATE_ORD); + addRecSignal(GSN_NDB_TAMPER, &Dbdih::execNDB_TAMPER, true); + addRecSignal(GSN_DEBUG_SIG, &Dbdih::execDEBUG_SIG); + addRecSignal(GSN_MASTER_GCPREQ, &Dbdih::execMASTER_GCPREQ); + addRecSignal(GSN_MASTER_GCPREF, &Dbdih::execMASTER_GCPREF); + addRecSignal(GSN_MASTER_GCPCONF, &Dbdih::execMASTER_GCPCONF); + addRecSignal(GSN_EMPTY_LCP_CONF, &Dbdih::execEMPTY_LCP_CONF); + addRecSignal(GSN_MASTER_LCPREQ, &Dbdih::execMASTER_LCPREQ); + addRecSignal(GSN_MASTER_LCPREF, &Dbdih::execMASTER_LCPREF); + addRecSignal(GSN_MASTER_LCPCONF, &Dbdih::execMASTER_LCPCONF); + addRecSignal(GSN_NF_COMPLETEREP, &Dbdih::execNF_COMPLETEREP); + addRecSignal(GSN_START_PERMREQ, &Dbdih::execSTART_PERMREQ); + addRecSignal(GSN_START_PERMCONF, &Dbdih::execSTART_PERMCONF); + addRecSignal(GSN_START_PERMREF, &Dbdih::execSTART_PERMREF); + addRecSignal(GSN_INCL_NODEREQ, &Dbdih::execINCL_NODEREQ); + addRecSignal(GSN_INCL_NODECONF, &Dbdih::execINCL_NODECONF); + addRecSignal(GSN_END_TOREQ, &Dbdih::execEND_TOREQ); + addRecSignal(GSN_END_TOCONF, &Dbdih::execEND_TOCONF); + addRecSignal(GSN_START_TOREQ, &Dbdih::execSTART_TOREQ); + addRecSignal(GSN_START_TOCONF, &Dbdih::execSTART_TOCONF); + addRecSignal(GSN_START_MEREQ, &Dbdih::execSTART_MEREQ); + addRecSignal(GSN_START_MECONF, &Dbdih::execSTART_MECONF); + addRecSignal(GSN_START_MEREF, &Dbdih::execSTART_MEREF); + addRecSignal(GSN_START_COPYREQ, &Dbdih::execSTART_COPYREQ); + addRecSignal(GSN_START_COPYCONF, &Dbdih::execSTART_COPYCONF); + addRecSignal(GSN_START_COPYREF, &Dbdih::execSTART_COPYREF); + addRecSignal(GSN_CREATE_FRAGREQ, &Dbdih::execCREATE_FRAGREQ); + addRecSignal(GSN_CREATE_FRAGCONF, &Dbdih::execCREATE_FRAGCONF); + addRecSignal(GSN_DIVERIFYREQ, &Dbdih::execDIVERIFYREQ); + addRecSignal(GSN_GCP_SAVECONF, &Dbdih::execGCP_SAVECONF); + addRecSignal(GSN_GCP_PREPARECONF, &Dbdih::execGCP_PREPARECONF); + addRecSignal(GSN_GCP_PREPARE, &Dbdih::execGCP_PREPARE); + addRecSignal(GSN_GCP_NODEFINISH, &Dbdih::execGCP_NODEFINISH); + addRecSignal(GSN_GCP_COMMIT, &Dbdih::execGCP_COMMIT); + addRecSignal(GSN_DIHNDBTAMPER, &Dbdih::execDIHNDBTAMPER); + addRecSignal(GSN_CONTINUEB, &Dbdih::execCONTINUEB); + addRecSignal(GSN_COPY_GCIREQ, &Dbdih::execCOPY_GCIREQ); + addRecSignal(GSN_COPY_GCICONF, &Dbdih::execCOPY_GCICONF); + addRecSignal(GSN_COPY_TABREQ, &Dbdih::execCOPY_TABREQ); + addRecSignal(GSN_COPY_TABCONF, &Dbdih::execCOPY_TABCONF); + addRecSignal(GSN_TCGETOPSIZECONF, &Dbdih::execTCGETOPSIZECONF); + addRecSignal(GSN_TC_CLOPSIZECONF, &Dbdih::execTC_CLOPSIZECONF); + + addRecSignal(GSN_LCP_COMPLETE_REP, &Dbdih::execLCP_COMPLETE_REP); + addRecSignal(GSN_LCP_FRAG_REP, &Dbdih::execLCP_FRAG_REP); + addRecSignal(GSN_START_LCP_REQ, &Dbdih::execSTART_LCP_REQ); + addRecSignal(GSN_START_LCP_CONF, &Dbdih::execSTART_LCP_CONF); + + addRecSignal(GSN_SIZEALT_REP, &Dbdih::execSIZEALT_REP); + addRecSignal(GSN_UNBLO_DICTCONF, &Dbdih::execUNBLO_DICTCONF); + addRecSignal(GSN_COPY_ACTIVECONF, &Dbdih::execCOPY_ACTIVECONF); + addRecSignal(GSN_TAB_COMMITREQ, &Dbdih::execTAB_COMMITREQ); + addRecSignal(GSN_NODE_FAILREP, &Dbdih::execNODE_FAILREP); + addRecSignal(GSN_COPY_FRAGCONF, &Dbdih::execCOPY_FRAGCONF); + addRecSignal(GSN_COPY_FRAGREF, &Dbdih::execCOPY_FRAGREF); + addRecSignal(GSN_DIADDTABREQ, &Dbdih::execDIADDTABREQ); + addRecSignal(GSN_DIGETNODESREQ, &Dbdih::execDIGETNODESREQ); + addRecSignal(GSN_DIRELEASEREQ, &Dbdih::execDIRELEASEREQ); + addRecSignal(GSN_DISEIZEREQ, &Dbdih::execDISEIZEREQ); + addRecSignal(GSN_STTOR, &Dbdih::execSTTOR); + addRecSignal(GSN_DI_FCOUNTREQ, &Dbdih::execDI_FCOUNTREQ); + addRecSignal(GSN_DIGETPRIMREQ, &Dbdih::execDIGETPRIMREQ); + addRecSignal(GSN_GCP_SAVEREF, &Dbdih::execGCP_SAVEREF); + addRecSignal(GSN_GCP_TCFINISHED, &Dbdih::execGCP_TCFINISHED); + addRecSignal(GSN_READ_NODESCONF, &Dbdih::execREAD_NODESCONF); + addRecSignal(GSN_NDB_STTOR, &Dbdih::execNDB_STTOR); + addRecSignal(GSN_DICTSTARTCONF, &Dbdih::execDICTSTARTCONF); + addRecSignal(GSN_NDB_STARTREQ, &Dbdih::execNDB_STARTREQ); + addRecSignal(GSN_GETGCIREQ, &Dbdih::execGETGCIREQ); + addRecSignal(GSN_DIH_RESTARTREQ, &Dbdih::execDIH_RESTARTREQ); + addRecSignal(GSN_CNTR_CHANGEREP, &Dbdih::execCNTR_CHANGEREP); + addRecSignal(GSN_START_RECCONF, &Dbdih::execSTART_RECCONF); + addRecSignal(GSN_START_FRAGCONF, &Dbdih::execSTART_FRAGCONF); + addRecSignal(GSN_ADD_FRAGCONF, &Dbdih::execADD_FRAGCONF); + addRecSignal(GSN_ADD_FRAGREF, &Dbdih::execADD_FRAGREF); + addRecSignal(GSN_FSOPENCONF, &Dbdih::execFSOPENCONF); + addRecSignal(GSN_FSOPENREF, &Dbdih::execFSOPENREF); + addRecSignal(GSN_FSCLOSECONF, &Dbdih::execFSCLOSECONF); + addRecSignal(GSN_FSCLOSEREF, &Dbdih::execFSCLOSEREF); + addRecSignal(GSN_FSREADCONF, &Dbdih::execFSREADCONF); + addRecSignal(GSN_FSREADREF, &Dbdih::execFSREADREF); + addRecSignal(GSN_FSWRITECONF, &Dbdih::execFSWRITECONF); + addRecSignal(GSN_FSWRITEREF, &Dbdih::execFSWRITEREF); + addRecSignal(GSN_SET_VAR_REQ, &Dbdih::execSET_VAR_REQ); + + addRecSignal(GSN_START_INFOREQ, + &Dbdih::execSTART_INFOREQ); + addRecSignal(GSN_START_INFOREF, + &Dbdih::execSTART_INFOREF); + addRecSignal(GSN_START_INFOCONF, + &Dbdih::execSTART_INFOCONF); + + addRecSignal(GSN_CHECKNODEGROUPSREQ, &Dbdih::execCHECKNODEGROUPSREQ); + + addRecSignal(GSN_BLOCK_COMMIT_ORD, + &Dbdih::execBLOCK_COMMIT_ORD); + addRecSignal(GSN_UNBLOCK_COMMIT_ORD, + &Dbdih::execUNBLOCK_COMMIT_ORD); + + addRecSignal(GSN_DIH_SWITCH_REPLICA_REQ, + &Dbdih::execDIH_SWITCH_REPLICA_REQ); + + addRecSignal(GSN_DIH_SWITCH_REPLICA_REF, + &Dbdih::execDIH_SWITCH_REPLICA_REF); + + addRecSignal(GSN_DIH_SWITCH_REPLICA_CONF, + &Dbdih::execDIH_SWITCH_REPLICA_CONF); + + addRecSignal(GSN_STOP_PERM_REQ, &Dbdih::execSTOP_PERM_REQ); + addRecSignal(GSN_STOP_PERM_REF, &Dbdih::execSTOP_PERM_REF); + addRecSignal(GSN_STOP_PERM_CONF, &Dbdih::execSTOP_PERM_CONF); + + addRecSignal(GSN_STOP_ME_REQ, &Dbdih::execSTOP_ME_REQ); + addRecSignal(GSN_STOP_ME_REF, &Dbdih::execSTOP_ME_REF); + addRecSignal(GSN_STOP_ME_CONF, &Dbdih::execSTOP_ME_CONF); + + addRecSignal(GSN_WAIT_GCP_REQ, &Dbdih::execWAIT_GCP_REQ); + addRecSignal(GSN_WAIT_GCP_REF, &Dbdih::execWAIT_GCP_REF); + addRecSignal(GSN_WAIT_GCP_CONF, &Dbdih::execWAIT_GCP_CONF); + + addRecSignal(GSN_UPDATE_TOREQ, &Dbdih::execUPDATE_TOREQ); + addRecSignal(GSN_UPDATE_TOCONF, &Dbdih::execUPDATE_TOCONF); + + addRecSignal(GSN_PREP_DROP_TAB_REQ, &Dbdih::execPREP_DROP_TAB_REQ); + addRecSignal(GSN_WAIT_DROP_TAB_CONF, &Dbdih::execWAIT_DROP_TAB_CONF); + addRecSignal(GSN_DROP_TAB_REQ, &Dbdih::execDROP_TAB_REQ); + + addRecSignal(GSN_ALTER_TAB_REQ, &Dbdih::execALTER_TAB_REQ); + + addRecSignal(GSN_CREATE_FRAGMENTATION_REQ, + &Dbdih::execCREATE_FRAGMENTATION_REQ); + + initData(); +}//Dbdih::Dbdih() + +Dbdih::~Dbdih() +{ + deallocRecord((void **)&apiConnectRecord, "ApiConnectRecord", + sizeof(ApiConnectRecord), + capiConnectFileSize); + + deallocRecord((void **)&connectRecord, "ConnectRecord", + sizeof(ConnectRecord), + cconnectFileSize); + + deallocRecord((void **)&fileRecord, "FileRecord", + sizeof(FileRecord), + cfileFileSize); + + deallocRecord((void **)&fragmentstore, "Fragmentstore", + sizeof(Fragmentstore), + cfragstoreFileSize); + + deallocRecord((void **)&pageRecord, "PageRecord", + sizeof(PageRecord), + cpageFileSize); + + deallocRecord((void **)&replicaRecord, "ReplicaRecord", + sizeof(ReplicaRecord), + creplicaFileSize); + + deallocRecord((void **)&tabRecord, "TabRecord", + sizeof(TabRecord), + ctabFileSize); + + // Records with constant sizes + deallocRecord((void **)&createReplicaRecord, + "CreateReplicaRecord", sizeof(CreateReplicaRecord), + ZCREATE_REPLICA_FILE_SIZE); + + deallocRecord((void **)&nodeGroupRecord, "NodeGroupRecord", + sizeof(NodeGroupRecord), MAX_NDB_NODES); + + deallocRecord((void **)&nodeRecord, "NodeRecord", + sizeof(NodeRecord), MAX_NDB_NODES); + + deallocRecord((void **)&takeOverRecord, "TakeOverRecord", + sizeof(TakeOverRecord), + MAX_NDB_NODES); + +}//Dbdih::~Dbdih() + +BLOCK_FUNCTIONS(Dbdih); + + + diff --git a/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp b/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp new file mode 100644 index 00000000000..cefbb3e66a3 --- /dev/null +++ b/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp @@ -0,0 +1,14104 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBDIH_C +#include +#include +#include + +#include "Dbdih.hpp" +#include "Configuration.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +#define SYSFILE ((Sysfile *)&sysfileData[0]) + +#define RETURN_IF_NODE_NOT_ALIVE(node) \ + if (!checkNodeAlive((node))) { \ + jam(); \ + return; \ + } \ + +#define RETURN_IF_TAKE_OVER_INTERRUPTED(takeOverIndex, regTOPtr) \ + regTOPtr.i = takeOverIndex; \ + ptrCheckGuard(regTOPtr, MAX_NDB_NODES, takeOverRecord); \ + if (checkToInterrupted(regTOPtr)) { \ + jam(); \ + return; \ + } \ + +#define receiveLoopMacro(sigName, receiveNodeId)\ +{ \ + c_##sigName##_Counter.clearWaitingFor(receiveNodeId); \ + if(c_##sigName##_Counter.done() == false){ \ + jam(); \ + return; \ + } \ +} + +#define sendLoopMacro(sigName, signalRoutine) \ +{ \ + c_##sigName##_Counter.clearWaitingFor(); \ + NodeRecordPtr specNodePtr; \ + specNodePtr.i = cfirstAliveNode; \ + do { \ + jam(); \ + ptrCheckGuard(specNodePtr, MAX_NDB_NODES, nodeRecord); \ + c_##sigName##_Counter.setWaitingFor(specNodePtr.i); \ + signalRoutine(signal, specNodePtr.i); \ + specNodePtr.i = specNodePtr.p->nextNode; \ + } while (specNodePtr.i != RNIL); \ +} + +static +Uint32 +prevLcpNo(Uint32 lcpNo){ + if(lcpNo == 0) + return MAX_LCP_STORED - 1; + return lcpNo - 1; +} + +static +Uint32 +nextLcpNo(Uint32 lcpNo){ + lcpNo++; + if(lcpNo == MAX_LCP_STORED) + return 0; + return lcpNo; +} + +#define gth(x, y) ndbrequire(((int)x)>((int)y)) + +void Dbdih::nullRoutine(Signal* signal, Uint32 nodeId) +{ +}//Dbdih::nullRoutine() + +void Dbdih::sendCOPY_GCIREQ(Signal* signal, Uint32 nodeId) +{ + ndbrequire(c_copyGCIMaster.m_copyReason != CopyGCIReq::IDLE); + + const BlockReference ref = calcDihBlockRef(nodeId); + const Uint32 wordPerSignal = CopyGCIReq::DATA_SIZE; + const Uint32 noOfSignals = ((Sysfile::SYSFILE_SIZE32 + (wordPerSignal - 1)) / + wordPerSignal); + + CopyGCIReq * const copyGCI = (CopyGCIReq *)&signal->theData[0]; + copyGCI->anyData = nodeId; + copyGCI->copyReason = c_copyGCIMaster.m_copyReason; + copyGCI->startWord = 0; + + for(Uint32 i = 0; i < noOfSignals; i++) { + jam(); + { // Do copy + const int startWord = copyGCI->startWord; + for(Uint32 j = 0; j < wordPerSignal; j++) { + copyGCI->data[j] = sysfileData[j+startWord]; + }//for + } + sendSignal(ref, GSN_COPY_GCIREQ, signal, 25, JBB); + copyGCI->startWord += wordPerSignal; + }//for +}//Dbdih::sendCOPY_GCIREQ() + + +void Dbdih::sendDIH_SWITCH_REPLICA_REQ(Signal* signal, Uint32 nodeId) +{ + const BlockReference ref = calcDihBlockRef(nodeId); + sendSignal(ref, GSN_DIH_SWITCH_REPLICA_REQ, signal, + DihSwitchReplicaReq::SignalLength, JBB); +}//Dbdih::sendDIH_SWITCH_REPLICA_REQ() + +void Dbdih::sendEMPTY_LCP_REQ(Signal* signal, Uint32 nodeId) +{ + BlockReference ref = calcLqhBlockRef(nodeId); + sendSignal(ref, GSN_EMPTY_LCP_REQ, signal, EmptyLcpReq::SignalLength, JBB); +}//Dbdih::sendEMPTY_LCPREQ() + +void Dbdih::sendEND_TOREQ(Signal* signal, Uint32 nodeId) +{ + BlockReference ref = calcDihBlockRef(nodeId); + sendSignal(ref, GSN_END_TOREQ, signal, EndToReq::SignalLength, JBB); +}//Dbdih::sendEND_TOREQ() + +void Dbdih::sendGCP_COMMIT(Signal* signal, Uint32 nodeId) +{ + BlockReference ref = calcDihBlockRef(nodeId); + signal->theData[0] = cownNodeId; + signal->theData[1] = cnewgcp; + sendSignal(ref, GSN_GCP_COMMIT, signal, 2, JBA); +}//Dbdih::sendGCP_COMMIT() + +void Dbdih::sendGCP_PREPARE(Signal* signal, Uint32 nodeId) +{ + BlockReference ref = calcDihBlockRef(nodeId); + signal->theData[0] = cownNodeId; + signal->theData[1] = cnewgcp; + sendSignal(ref, GSN_GCP_PREPARE, signal, 2, JBA); +}//Dbdih::sendGCP_PREPARE() + +void Dbdih::sendGCP_SAVEREQ(Signal* signal, Uint32 nodeId) +{ + GCPSaveReq * const saveReq = (GCPSaveReq*)&signal->theData[0]; + BlockReference ref = calcLqhBlockRef(nodeId); + saveReq->dihBlockRef = reference(); + saveReq->dihPtr = nodeId; + saveReq->gci = coldgcp; + sendSignal(ref, GSN_GCP_SAVEREQ, signal, GCPSaveReq::SignalLength, JBB); +}//Dbdih::sendGCP_SAVEREQ() + +void Dbdih::sendINCL_NODEREQ(Signal* signal, Uint32 nodeId) +{ + BlockReference nodeDihRef = calcDihBlockRef(nodeId); + signal->theData[0] = reference(); + signal->theData[1] = c_nodeStartMaster.startNode; + signal->theData[2] = c_nodeStartMaster.failNr; + signal->theData[3] = c_nodeStartMaster.ndbVersion; + signal->theData[4] = currentgcp; + sendSignal(nodeDihRef, GSN_INCL_NODEREQ, signal, 5, JBB); +}//Dbdih::sendINCL_NODEREQ() + +void Dbdih::sendMASTER_GCPREQ(Signal* signal, Uint32 nodeId) +{ + BlockReference ref = calcDihBlockRef(nodeId); + sendSignal(ref, GSN_MASTER_GCPREQ, signal, MasterGCPReq::SignalLength, JBB); +}//Dbdih::sendMASTER_GCPREQ() + +void Dbdih::sendMASTER_LCPREQ(Signal* signal, Uint32 nodeId) +{ + BlockReference ref = calcDihBlockRef(nodeId); + sendSignal(ref, GSN_MASTER_LCPREQ, signal, MasterLCPReq::SignalLength, JBB); +}//Dbdih::sendMASTER_LCPREQ() + +void Dbdih::sendSTART_INFOREQ(Signal* signal, Uint32 nodeId) +{ + const BlockReference ref = calcDihBlockRef(nodeId); + sendSignal(ref, GSN_START_INFOREQ, signal, StartInfoReq::SignalLength, JBB); +}//sendSTART_INFOREQ() + +void Dbdih::sendSTART_RECREQ(Signal* signal, Uint32 nodeId) +{ + StartRecReq * const req = (StartRecReq*)&signal->theData[0]; + BlockReference ref = calcLqhBlockRef(nodeId); + req->receivingNodeId = nodeId; + req->senderRef = reference(); + req->keepGci = SYSFILE->keepGCI; + req->lastCompletedGci = SYSFILE->lastCompletedGCI[nodeId]; + req->newestGci = SYSFILE->newestRestorableGCI; + sendSignal(ref, GSN_START_RECREQ, signal, StartRecReq::SignalLength, JBB); + + signal->theData[0] = EventReport::StartREDOLog; + signal->theData[1] = nodeId; + signal->theData[2] = SYSFILE->keepGCI; + signal->theData[3] = SYSFILE->lastCompletedGCI[nodeId]; + signal->theData[4] = SYSFILE->newestRestorableGCI; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 5, JBB); +}//Dbdih::sendSTART_RECREQ() + +void Dbdih::sendSTART_TOREQ(Signal* signal, Uint32 nodeId) +{ + BlockReference ref = calcDihBlockRef(nodeId); + sendSignal(ref, GSN_START_TOREQ, signal, StartToReq::SignalLength, JBB); +}//Dbdih::sendSTART_TOREQ() + +void Dbdih::sendSTOP_ME_REQ(Signal* signal, Uint32 nodeId) +{ + if (nodeId != getOwnNodeId()) { + jam(); + const BlockReference ref = calcDihBlockRef(nodeId); + sendSignal(ref, GSN_STOP_ME_REQ, signal, StopMeReq::SignalLength, JBB); + }//if +}//Dbdih::sendSTOP_ME_REQ() + +void Dbdih::sendTC_CLOPSIZEREQ(Signal* signal, Uint32 nodeId) +{ + BlockReference ref = calcTcBlockRef(nodeId); + signal->theData[0] = nodeId; + signal->theData[1] = reference(); + sendSignal(ref, GSN_TC_CLOPSIZEREQ, signal, 2, JBB); +}//Dbdih::sendTC_CLOPSIZEREQ() + +void Dbdih::sendTCGETOPSIZEREQ(Signal* signal, Uint32 nodeId) +{ + BlockReference ref = calcTcBlockRef(nodeId); + signal->theData[0] = nodeId; + signal->theData[1] = reference(); + sendSignal(ref, GSN_TCGETOPSIZEREQ, signal, 2, JBB); +}//Dbdih::sendTCGETOPSIZEREQ() + +void Dbdih::sendUPDATE_TOREQ(Signal* signal, Uint32 nodeId) +{ + const BlockReference ref = calcDihBlockRef(nodeId); + sendSignal(ref, GSN_UPDATE_TOREQ, signal, UpdateToReq::SignalLength, JBB); +}//sendUPDATE_TOREQ() + +void Dbdih::execCNTR_CHANGEREP(Signal* signal) +{ + (void)signal; // Don't want compiler warning + jamEntry(); + return; +}//Dbdih::execCNTR_CHANGEREP() + +void Dbdih::execCONTINUEB(Signal* signal) +{ + jamEntry(); + switch ((DihContinueB::Type)signal->theData[0]) { + case DihContinueB::ZPACK_TABLE_INTO_PAGES: + { + jam(); + Uint32 tableId = signal->theData[1]; + packTableIntoPagesLab(signal, tableId); + return; + break; + } + case DihContinueB::ZPACK_FRAG_INTO_PAGES: + { + RWFragment wf; + jam(); + wf.rwfTabPtr.i = signal->theData[1]; + ptrCheckGuard(wf.rwfTabPtr, ctabFileSize, tabRecord); + wf.fragId = signal->theData[2]; + wf.pageIndex = signal->theData[3]; + wf.wordIndex = signal->theData[4]; + packFragIntoPagesLab(signal, &wf); + return; + break; + } + case DihContinueB::ZREAD_PAGES_INTO_TABLE: + { + jam(); + Uint32 tableId = signal->theData[1]; + readPagesIntoTableLab(signal, tableId); + return; + break; + } + case DihContinueB::ZREAD_PAGES_INTO_FRAG: + { + RWFragment rf; + jam(); + rf.rwfTabPtr.i = signal->theData[1]; + ptrCheckGuard(rf.rwfTabPtr, ctabFileSize, tabRecord); + rf.fragId = signal->theData[2]; + rf.pageIndex = signal->theData[3]; + rf.wordIndex = signal->theData[4]; + readPagesIntoFragLab(signal, &rf); + return; + break; + } + case DihContinueB::ZCOPY_TABLE: + { + jam(); + Uint32 tableId = signal->theData[1]; + copyTableLab(signal, tableId); + return; + } + case DihContinueB::ZCOPY_TABLE_NODE: + { + NodeRecordPtr nodePtr; + CopyTableNode ctn; + jam(); + ctn.ctnTabPtr.i = signal->theData[1]; + ptrCheckGuard(ctn.ctnTabPtr, ctabFileSize, tabRecord); + nodePtr.i = signal->theData[2]; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + ctn.pageIndex = signal->theData[3]; + ctn.wordIndex = signal->theData[4]; + ctn.noOfWords = signal->theData[5]; + copyTableNode(signal, &ctn, nodePtr); + return; + } + case DihContinueB::ZSTART_FRAGMENT: + { + jam(); + Uint32 tableId = signal->theData[1]; + Uint32 fragId = signal->theData[2]; + startFragment(signal, tableId, fragId); + return; + } + case DihContinueB::ZCOMPLETE_RESTART: + jam(); + completeRestartLab(signal); + return; + case DihContinueB::ZREAD_TABLE_FROM_PAGES: + { + TabRecordPtr tabPtr; + jam(); + tabPtr.i = signal->theData[1]; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + readTableFromPagesLab(signal, tabPtr); + return; + } + case DihContinueB::ZSR_PHASE2_READ_TABLE: + { + TabRecordPtr tabPtr; + jam(); + tabPtr.i = signal->theData[1]; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + srPhase2ReadTableLab(signal, tabPtr); + return; + } + case DihContinueB::ZCHECK_TC_COUNTER: + jam(); +#ifndef NO_LCP + checkTcCounterLab(signal); +#endif + return; + case DihContinueB::ZCALCULATE_KEEP_GCI: + { + jam(); + Uint32 tableId = signal->theData[1]; + Uint32 fragId = signal->theData[2]; + calculateKeepGciLab(signal, tableId, fragId); + return; + } + case DihContinueB::ZSTORE_NEW_LCP_ID: + jam(); + storeNewLcpIdLab(signal); + return; + case DihContinueB::ZTABLE_UPDATE: + { + TabRecordPtr tabPtr; + jam(); + tabPtr.i = signal->theData[1]; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + tableUpdateLab(signal, tabPtr); + return; + } + case DihContinueB::ZCHECK_LCP_COMPLETED: + { + jam(); + checkLcpCompletedLab(signal); + return; + } + case DihContinueB::ZINIT_LCP: + { + jam(); + Uint32 senderRef = signal->theData[1]; + Uint32 tableId = signal->theData[2]; + initLcpLab(signal, senderRef, tableId); + return; + } + case DihContinueB::ZADD_TABLE_MASTER_PAGES: + { + TabRecordPtr tabPtr; + jam(); + tabPtr.i = signal->theData[1]; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + tabPtr.p->tabUpdateState = TabRecord::US_ADD_TABLE_MASTER; + tableUpdateLab(signal, tabPtr); + return; + break; + } + case DihContinueB::ZDIH_ADD_TABLE_MASTER: + { + jam(); + addTable_closeConf(signal, signal->theData[1]); + return; + } + case DihContinueB::ZADD_TABLE_SLAVE_PAGES: + { + TabRecordPtr tabPtr; + jam(); + tabPtr.i = signal->theData[1]; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + tabPtr.p->tabUpdateState = TabRecord::US_ADD_TABLE_SLAVE; + tableUpdateLab(signal, tabPtr); + return; + } + case DihContinueB::ZDIH_ADD_TABLE_SLAVE: + { + ndbrequire(false); + return; + } + case DihContinueB::ZSTART_GCP: + jam(); +#ifndef NO_GCP + startGcpLab(signal, signal->theData[1]); +#endif + return; + break; + case DihContinueB::ZCOPY_GCI:{ + jam(); + CopyGCIReq::CopyReason reason = (CopyGCIReq::CopyReason)signal->theData[1]; + ndbrequire(c_copyGCIMaster.m_copyReason == reason); + sendLoopMacro(COPY_GCIREQ, sendCOPY_GCIREQ); + return; + } + break; + case DihContinueB::ZEMPTY_VERIFY_QUEUE: + jam(); + emptyverificbuffer(signal, true); + return; + break; + case DihContinueB::ZCHECK_GCP_STOP: + jam(); +#ifndef NO_GCP + checkGcpStopLab(signal); +#endif + return; + break; + case DihContinueB::ZREMOVE_NODE_FROM_TABLE: + { + jam(); + Uint32 nodeId = signal->theData[1]; + Uint32 tableId = signal->theData[2]; + removeNodeFromTables(signal, nodeId, tableId); + return; + } + case DihContinueB::ZCOPY_NODE: + { + jam(); + Uint32 tableId = signal->theData[1]; + copyNodeLab(signal, tableId); + return; + } + case DihContinueB::ZSTART_TAKE_OVER: + { + jam(); + Uint32 takeOverPtrI = signal->theData[1]; + Uint32 startNode = signal->theData[2]; + Uint32 toNode = signal->theData[3]; + startTakeOver(signal, takeOverPtrI, startNode, toNode); + return; + break; + } + case DihContinueB::ZCHECK_START_TAKE_OVER: + jam(); + checkStartTakeOver(signal); + break; + case DihContinueB::ZTO_START_COPY_FRAG: + { + jam(); + Uint32 takeOverPtrI = signal->theData[1]; + startNextCopyFragment(signal, takeOverPtrI); + return; + } + case DihContinueB::ZINVALIDATE_NODE_LCP: + { + jam(); + const Uint32 nodeId = signal->theData[1]; + const Uint32 tableId = signal->theData[2]; + invalidateNodeLCP(signal, nodeId, tableId); + return; + } + case DihContinueB::ZINITIALISE_RECORDS: + jam(); + initialiseRecordsLab(signal, signal->theData[1]); + return; + break; + case DihContinueB::ZSTART_PERMREQ_AGAIN: + jam(); + nodeRestartPh2Lab(signal); + return; + break; + case DihContinueB::SwitchReplica: + { + jam(); + const Uint32 nodeId = signal->theData[1]; + const Uint32 tableId = signal->theData[2]; + const Uint32 fragNo = signal->theData[3]; + switchReplica(signal, nodeId, tableId, fragNo); + return; + } + case DihContinueB::ZSEND_START_TO: + { + jam(); + Uint32 takeOverPtrI = signal->theData[1]; + sendStartTo(signal, takeOverPtrI); + return; + } + case DihContinueB::ZSEND_ADD_FRAG: + { + jam(); + Uint32 takeOverPtrI = signal->theData[1]; + toCopyFragLab(signal, takeOverPtrI); + return; + } + case DihContinueB::ZSEND_UPDATE_TO: + { + jam(); + Uint32 takeOverPtrI = signal->theData[1]; + Uint32 updateState = signal->theData[4]; + sendUpdateTo(signal, takeOverPtrI, updateState); + return; + } + case DihContinueB::ZSEND_END_TO: + { + jam(); + Uint32 takeOverPtrI = signal->theData[1]; + sendEndTo(signal, takeOverPtrI); + return; + } + case DihContinueB::ZSEND_CREATE_FRAG: + { + jam(); + Uint32 takeOverPtrI = signal->theData[1]; + Uint32 storedType = signal->theData[2]; + Uint32 startGci = signal->theData[3]; + sendCreateFragReq(signal, startGci, storedType, takeOverPtrI); + return; + } + case DihContinueB::WAIT_DROP_TAB_WRITING_TO_FILE:{ + jam(); + TabRecordPtr tabPtr; + tabPtr.i = signal->theData[1]; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + waitDropTabWritingToFile(signal, tabPtr); + return; + } + case DihContinueB::CHECK_WAIT_DROP_TAB_FAILED_LQH:{ + jam(); + Uint32 nodeId = signal->theData[1]; + Uint32 tableId = signal->theData[2]; + checkWaitDropTabFailedLqh(signal, nodeId, tableId); + return; + } + }//switch + + ndbrequire(false); + return; +}//Dbdih::execCONTINUEB() + +void Dbdih::execCOPY_GCIREQ(Signal* signal) +{ + CopyGCIReq * const copyGCI = (CopyGCIReq *)&signal->theData[0]; + jamEntry(); + CopyGCIReq::CopyReason reason = (CopyGCIReq::CopyReason)copyGCI->copyReason; + const Uint32 tstart = copyGCI->startWord; + + ndbrequire(cmasterdihref == signal->senderBlockRef()) ; + ndbrequire(c_copyGCISlave.m_copyReason == CopyGCIReq::IDLE); + ndbrequire(c_copyGCISlave.m_expectedNextWord == tstart); + ndbrequire(reason != CopyGCIReq::IDLE); + + arrGuard(tstart + CopyGCIReq::DATA_SIZE, sizeof(sysfileData)/4); + for(Uint32 i = 0; idata[i]; + + if ((tstart + CopyGCIReq::DATA_SIZE) >= Sysfile::SYSFILE_SIZE32) { + jam(); + c_copyGCISlave.m_expectedNextWord = 0; + } else { + jam(); + c_copyGCISlave.m_expectedNextWord += CopyGCIReq::DATA_SIZE; + return; + }//if + + memcpy(sysfileData, cdata, sizeof(sysfileData)); + + c_copyGCISlave.m_copyReason = reason; + c_copyGCISlave.m_senderRef = signal->senderBlockRef(); + c_copyGCISlave.m_senderData = copyGCI->anyData; + + CRASH_INSERTION2(7020, reason==CopyGCIReq::LOCAL_CHECKPOINT); + CRASH_INSERTION2(7008, reason==CopyGCIReq::GLOBAL_CHECKPOINT); + + /* -------------------------------------------------------------------------*/ + /* WE SET THE REQUESTER OF THE COPY GCI TO THE CURRENT MASTER. IF THE */ + /* CURRENT MASTER WE DO NOT WANT THE NEW MASTER TO RECEIVE CONFIRM OF */ + /* SOMETHING HE HAS NOT SENT. THE TAKE OVER MUST BE CAREFUL. */ + /* -------------------------------------------------------------------------*/ + bool ok = false; + switch(reason){ + case CopyGCIReq::IDLE: + ok = true; + jam(); + ndbrequire(false); + break; + case CopyGCIReq::LOCAL_CHECKPOINT: { + ok = true; + jam(); + c_lcpState.setLcpStatus(LCP_COPY_GCI, __LINE__); + c_lcpState.m_masterLcpDihRef = cmasterdihref; + setNodeInfo(signal); + break; + } + case CopyGCIReq::RESTART: { + ok = true; + jam(); + coldgcp = SYSFILE->newestRestorableGCI; + crestartGci = SYSFILE->newestRestorableGCI; + Sysfile::setRestartOngoing(SYSFILE->systemRestartBits); + currentgcp = coldgcp + 1; + cnewgcp = coldgcp + 1; + setNodeInfo(signal); + if ((Sysfile::getLCPOngoing(SYSFILE->systemRestartBits))) { + jam(); + /* -------------------------------------------------------------------- */ + // IF THERE WAS A LOCAL CHECKPOINT ONGOING AT THE CRASH MOMENT WE WILL + // INVALIDATE THAT LOCAL CHECKPOINT. + /* -------------------------------------------------------------------- */ + invalidateLcpInfoAfterSr(); + }//if + break; + } + case CopyGCIReq::GLOBAL_CHECKPOINT: { + ok = true; + jam(); + cgcpParticipantState = GCP_PARTICIPANT_COPY_GCI_RECEIVED; + setNodeInfo(signal); + break; + }//if + case CopyGCIReq::INITIAL_START_COMPLETED: + ok = true; + jam(); + break; + } + ndbrequire(ok); + + /* ----------------------------------------------------------------------- */ + /* WE START BY TRYING TO OPEN THE FIRST RESTORABLE GCI FILE. */ + /* ----------------------------------------------------------------------- */ + FileRecordPtr filePtr; + filePtr.i = crestartInfoFile[0]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + if (filePtr.p->fileStatus == FileRecord::OPEN) { + jam(); + openingCopyGciSkipInitLab(signal, filePtr); + return; + }//if + openFileRw(signal, filePtr); + filePtr.p->reqStatus = FileRecord::OPENING_COPY_GCI; + return; +}//Dbdih::execCOPY_GCIREQ() + +void Dbdih::execDICTSTARTCONF(Signal* signal) +{ + jamEntry(); + Uint32 nodeId = refToNode(signal->getSendersBlockRef()); + if (nodeId != getOwnNodeId()) { + jam(); + nodeDictStartConfLab(signal); + } else { + jam(); + dictStartConfLab(signal); + }//if +}//Dbdih::execDICTSTARTCONF() + +void Dbdih::execFSCLOSECONF(Signal* signal) +{ + FileRecordPtr filePtr; + jamEntry(); + filePtr.i = signal->theData[0]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + filePtr.p->fileStatus = FileRecord::CLOSED; + FileRecord::ReqStatus status = filePtr.p->reqStatus; + filePtr.p->reqStatus = FileRecord::IDLE; + switch (status) { + case FileRecord::CLOSING_GCP: + jam(); + closingGcpLab(signal, filePtr); + break; + case FileRecord::CLOSING_GCP_CRASH: + jam(); + closingGcpCrashLab(signal, filePtr); + break; + case FileRecord::CLOSING_TABLE_CRASH: + jam(); + closingTableCrashLab(signal, filePtr); + break; + case FileRecord::CLOSING_TABLE_SR: + jam(); + closingTableSrLab(signal, filePtr); + break; + case FileRecord::TABLE_CLOSE: + jam(); + tableCloseLab(signal, filePtr); + break; + case FileRecord::TABLE_CLOSE_DELETE: + jam(); + tableDeleteLab(signal, filePtr); + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbdih::execFSCLOSECONF() + +void Dbdih::execFSCLOSEREF(Signal* signal) +{ + FileRecordPtr filePtr; + jamEntry(); + filePtr.i = signal->theData[0]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + FileRecord::ReqStatus status = filePtr.p->reqStatus; + filePtr.p->reqStatus = FileRecord::IDLE; + switch (status) { + case FileRecord::CLOSING_GCP: + ndbrequire(false); + break; + case FileRecord::CLOSING_GCP_CRASH: + jam(); + closingGcpCrashLab(signal, filePtr); + break; + case FileRecord::CLOSING_TABLE_CRASH: + jam(); + closingTableCrashLab(signal, filePtr); + break; + case FileRecord::CLOSING_TABLE_SR: + ndbrequire(false); + break; + case FileRecord::TABLE_CLOSE: + ndbrequire(false); + break; + case FileRecord::TABLE_CLOSE_DELETE: + ndbrequire(false); + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbdih::execFSCLOSEREF() + +void Dbdih::execFSOPENCONF(Signal* signal) +{ + FileRecordPtr filePtr; + jamEntry(); + filePtr.i = signal->theData[0]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + filePtr.p->fileRef = signal->theData[1]; + filePtr.p->fileStatus = FileRecord::OPEN; + FileRecord::ReqStatus status = filePtr.p->reqStatus; + filePtr.p->reqStatus = FileRecord::IDLE; + switch (status) { + case FileRecord::CREATING_GCP: + jam(); + creatingGcpLab(signal, filePtr); + break; + case FileRecord::OPENING_COPY_GCI: + jam(); + openingCopyGciSkipInitLab(signal, filePtr); + break; + case FileRecord::CREATING_COPY_GCI: + jam(); + openingCopyGciSkipInitLab(signal, filePtr); + break; + case FileRecord::OPENING_GCP: + jam(); + openingGcpLab(signal, filePtr); + break; + case FileRecord::OPENING_TABLE: + jam(); + openingTableLab(signal, filePtr); + break; + case FileRecord::TABLE_CREATE: + jam(); + tableCreateLab(signal, filePtr); + break; + case FileRecord::TABLE_OPEN_FOR_DELETE: + jam(); + tableOpenLab(signal, filePtr); + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbdih::execFSOPENCONF() + +void Dbdih::execFSOPENREF(Signal* signal) +{ + FileRecordPtr filePtr; + jamEntry(); + filePtr.i = signal->theData[0]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + FileRecord::ReqStatus status = filePtr.p->reqStatus; + filePtr.p->reqStatus = FileRecord::IDLE; + switch (status) { + case FileRecord::CREATING_GCP: + /* --------------------------------------------------------------------- */ + /* WE DID NOT MANAGE TO CREATE A GLOBAL CHECKPOINT FILE. SERIOUS ERROR */ + /* WHICH CAUSES A SYSTEM RESTART. */ + /* --------------------------------------------------------------------- */ + ndbrequire(false); + break; + case FileRecord::OPENING_COPY_GCI: + jam(); + openingCopyGciErrorLab(signal, filePtr); + break; + case FileRecord::CREATING_COPY_GCI: + ndbrequire(false); + break; + case FileRecord::OPENING_GCP: + jam(); + openingGcpErrorLab(signal, filePtr); + break; + case FileRecord::OPENING_TABLE: + jam(); + openingTableErrorLab(signal, filePtr); + break; + case FileRecord::TABLE_CREATE: + ndbrequire(false); + break; + case FileRecord::TABLE_OPEN_FOR_DELETE: + jam(); + tableDeleteLab(signal, filePtr); + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbdih::execFSOPENREF() + +void Dbdih::execFSREADCONF(Signal* signal) +{ + FileRecordPtr filePtr; + jamEntry(); + filePtr.i = signal->theData[0]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + FileRecord::ReqStatus status = filePtr.p->reqStatus; + filePtr.p->reqStatus = FileRecord::IDLE; + switch (status) { + case FileRecord::READING_GCP: + jam(); + readingGcpLab(signal, filePtr); + break; + case FileRecord::READING_TABLE: + jam(); + readingTableLab(signal, filePtr); + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbdih::execFSREADCONF() + +void Dbdih::execFSREADREF(Signal* signal) +{ + FileRecordPtr filePtr; + jamEntry(); + filePtr.i = signal->theData[0]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + FileRecord::ReqStatus status = filePtr.p->reqStatus; + filePtr.p->reqStatus = FileRecord::IDLE; + switch (status) { + case FileRecord::READING_GCP: + jam(); + readingGcpErrorLab(signal, filePtr); + break; + case FileRecord::READING_TABLE: + jam(); + readingTableErrorLab(signal, filePtr); + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbdih::execFSREADREF() + +void Dbdih::execFSWRITECONF(Signal* signal) +{ + FileRecordPtr filePtr; + jamEntry(); + filePtr.i = signal->theData[0]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + FileRecord::ReqStatus status = filePtr.p->reqStatus; + filePtr.p->reqStatus = FileRecord::IDLE; + switch (status) { + case FileRecord::WRITING_COPY_GCI: + jam(); + writingCopyGciLab(signal, filePtr); + break; + case FileRecord::WRITE_INIT_GCP: + jam(); + writeInitGcpLab(signal, filePtr); + break; + case FileRecord::TABLE_WRITE: + jam(); + tableWriteLab(signal, filePtr); + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbdih::execFSWRITECONF() + +void Dbdih::execFSWRITEREF(Signal* signal) +{ + FileRecordPtr filePtr; + jamEntry(); + filePtr.i = signal->theData[0]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + FileRecord::ReqStatus status = filePtr.p->reqStatus; + filePtr.p->reqStatus = FileRecord::IDLE; + switch (status) { + case FileRecord::WRITING_COPY_GCI: + /* --------------------------------------------------------------------- */ + /* EVEN CREATING THE FILE DID NOT WORK. WE WILL THEN CRASH. */ + /* ERROR IN WRITING FILE. WE WILL NOT CONTINUE FROM HERE. */ + /* --------------------------------------------------------------------- */ + ndbrequire(false); + break; + case FileRecord::WRITE_INIT_GCP: + /* --------------------------------------------------------------------- */ + /* AN ERROR OCCURRED IN WRITING A GCI FILE WHICH IS A SERIOUS ERROR */ + /* THAT CAUSE A SYSTEM RESTART. */ + /* --------------------------------------------------------------------- */ + ndbrequire(false); + break; + case FileRecord::TABLE_WRITE: + ndbrequire(false); + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbdih::execFSWRITEREF() + +void Dbdih::execGETGCIREQ(Signal* signal) +{ + + jamEntry(); + Uint32 userPtr = signal->theData[0]; + BlockReference userRef = signal->theData[1]; + + signal->theData[0] = userPtr; + signal->theData[1] = SYSFILE->newestRestorableGCI; + sendSignal(userRef, GSN_GETGCICONF, signal, 2, JBB); +}//Dbdih::execGETGCIREQ() + +void Dbdih::execSIZEALT_REP(Signal* signal) +{ + jamEntry(); + capiConnectFileSize = signal->theData[DihSizeAltReq::IND_API_CONNECT]; + cconnectFileSize = signal->theData[DihSizeAltReq::IND_CONNECT]; + cfragstoreFileSize = signal->theData[DihSizeAltReq::IND_FRAG_CONNECT]; + creplicaFileSize = signal->theData[DihSizeAltReq::IND_REPLICAS]; + ctabFileSize = signal->theData[DihSizeAltReq::IND_TABLE]; + cfileFileSize = (2 * ctabFileSize) + 2; + initRecords(); + initialiseRecordsLab(signal, 0); + return; +}//Dbdih::execSIZEALT_REP() + +void Dbdih::execSTART_COPYREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +}//Dbdih::execSTART_COPYREF() + +void Dbdih::execSTART_FRAGCONF(Signal* signal) +{ + (void)signal; // Don't want compiler warning + /* ********************************************************************* */ + /* If anyone wants to add functionality in this method, be aware that */ + /* for temporary tables no START_FRAGREQ is sent and therefore no */ + /* START_FRAGCONF signal will be received for those tables!! */ + /* ********************************************************************* */ + jamEntry(); + return; +}//Dbdih::execSTART_FRAGCONF() + +void Dbdih::execSTART_MEREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +}//Dbdih::execSTART_MEREF() + +void Dbdih::execTAB_COMMITREQ(Signal* signal) +{ + TabRecordPtr tabPtr; + jamEntry(); + Uint32 tdictPtr = signal->theData[0]; + BlockReference tdictBlockref = signal->theData[1]; + tabPtr.i = signal->theData[2]; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + + ndbrequire(tabPtr.p->tabStatus == TabRecord::TS_CREATING); + tabPtr.p->tabStatus = TabRecord::TS_ACTIVE; + signal->theData[0] = tdictPtr; + signal->theData[1] = cownNodeId; + signal->theData[2] = tabPtr.i; + sendSignal(tdictBlockref, GSN_TAB_COMMITCONF, signal, 3, JBB); + return; +}//Dbdih::execTAB_COMMITREQ() + +/* + 3.2 S T A N D A R D S U B P R O G R A M S I N P L E X + ************************************************************* + */ +/* + 3.2.1 S T A R T / R E S T A R T + ********************************** + */ +/*****************************************************************************/ +/* ********** START / RESTART MODULE *************/ +/*****************************************************************************/ +/* + 3.2.1.1 LOADING O W N B L O C K R E F E R E N C E (ABSOLUTE PHASE 1) + ***************************************************************************** + */ +void Dbdih::execDIH_RESTARTREQ(Signal* signal) +{ + jamEntry(); + cntrlblockref = signal->theData[0]; + if(theConfiguration.getInitialStart()){ + sendSignal(cntrlblockref, GSN_DIH_RESTARTREF, signal, 1, JBB); + } else { + readGciFileLab(signal); + } + return; +}//Dbdih::execDIH_RESTARTREQ() + +void Dbdih::execSTTOR(Signal* signal) +{ + jamEntry(); + + signal->theData[0] = 0; + signal->theData[1] = 0; + signal->theData[2] = 0; + signal->theData[3] = 1; // Next start phase + signal->theData[4] = 255; // Next start phase + sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 5, JBB); + return; +}//Dbdih::execSTTOR() + +void Dbdih::initialStartCompletedLab(Signal* signal) +{ + /*-------------------------------------------------------------------------*/ + /* NOW THAT (RE)START IS COMPLETED WE CAN START THE LCP.*/ + /*-------------------------------------------------------------------------*/ + return; +}//Dbdih::initialStartCompletedLab() + +/* + * *************************************************************************** + * S E N D I N G R E P L Y T O S T A R T / R E S T A R T R E Q U E S T S + * **************************************************************************** + */ +void Dbdih::ndbsttorry10Lab(Signal* signal, Uint32 _line) +{ + /*-------------------------------------------------------------------------*/ + // AN NDB START PHASE HAS BEEN COMPLETED. WHEN START PHASE 6 IS COMPLETED WE + // RECORD THAT THE SYSTEM IS RUNNING. + /*-------------------------------------------------------------------------*/ + signal->theData[0] = reference(); + sendSignal(cntrlblockref, GSN_NDB_STTORRY, signal, 1, JBB); + return; +}//Dbdih::ndbsttorry10Lab() + +/* +**************************************** +I N T E R N A L P H A S E S +**************************************** +*/ +/*---------------------------------------------------------------------------*/ +/*NDB_STTOR START SIGNAL AT START/RESTART */ +/*---------------------------------------------------------------------------*/ +void Dbdih::execNDB_STTOR(Signal* signal) +{ + jamEntry(); + BlockReference cntrRef = signal->theData[0]; /* SENDERS BLOCK REFERENCE */ + Uint32 ownNodeId = signal->theData[1]; /* OWN PROCESSOR ID*/ + Uint32 phase = signal->theData[2]; /* INTERNAL START PHASE*/ + Uint32 typestart = signal->theData[3]; + const Uint32 tconfig1 = signal->theData[8]; + const Uint32 tconfig2 = signal->theData[9]; + + cstarttype = typestart; + + cstartPhase = phase; + + switch (phase){ + case ZNDB_SPH1: + jam(); + /*----------------------------------------------------------------------*/ + /* Set the delay between local checkpoints in ndb startphase 1. */ + /*----------------------------------------------------------------------*/ + c_lcpState.clcpDelay = tconfig1 > 31 ? 31 : tconfig1; + + cminHotSpareNodes = tconfig2 > 2 ? 2 : tconfig2; + + cownNodeId = ownNodeId; + /*-----------------------------------------------------------------------*/ + // Compute all static block references in this node as part of + // ndb start phase 1. + /*-----------------------------------------------------------------------*/ + cntrlblockref = cntrRef; + clocaltcblockref = calcTcBlockRef(ownNodeId); + clocallqhblockref = calcLqhBlockRef(ownNodeId); + cdictblockref = calcDictBlockRef(ownNodeId); + ndbsttorry10Lab(signal, __LINE__); + break; + + case ZNDB_SPH2: + jam(); + /*-----------------------------------------------------------------------*/ + // Set the number of replicas, maximum is 4 replicas. + // Read the ndb nodes from the configuration. + /*-----------------------------------------------------------------------*/ + cnoReplicas = tconfig1 > 4 ? 4 : tconfig1; + cgcpDelay = tconfig2 > 60000 ? 60000 : (tconfig2 < 10 ? 10 : tconfig2); + + /*-----------------------------------------------------------------------*/ + // For node restarts we will also add a request for permission + // to continue the system restart. + // The permission is given by the master node in the alive set. + /*-----------------------------------------------------------------------*/ + createMutexes(signal, 0); + break; + + case ZNDB_SPH3: + jam(); + /*-----------------------------------------------------------------------*/ + // Non-master nodes performing an initial start will execute + // the start request here since the + // initial start do not synchronise so much from the master. + // In the master nodes the start + // request will be sent directly to dih (in ndb_startreq) when all + // nodes have completed phase 3 of the start. + /*-----------------------------------------------------------------------*/ + cmasterState = MASTER_IDLE; + if(cstarttype == NodeState::ST_INITIAL_START || + cstarttype == NodeState::ST_SYSTEM_RESTART){ + jam(); + cmasterState = isMaster() ? MASTER_ACTIVE : MASTER_IDLE; + } + if (!isMaster() && cstarttype == NodeState::ST_INITIAL_START) { + jam(); + ndbStartReqLab(signal, cntrRef); + return; + }//if + ndbsttorry10Lab(signal, __LINE__); + break; + + case ZNDB_SPH4: + jam(); + c_lcpState.setLcpStatus(LCP_STATUS_IDLE, __LINE__); + cmasterTakeOverNode = ZNIL; + switch(typestart){ + case NodeState::ST_INITIAL_START: + jam(); + ndbsttorry10Lab(signal, __LINE__); + return; + case NodeState::ST_SYSTEM_RESTART: + jam(); + if (isMaster()) { + jam(); + systemRestartTakeOverLab(signal); + if (anyActiveTakeOver() && false) { + jam(); + ndbout_c("1 - anyActiveTakeOver == true"); + return; + } + } + ndbsttorry10Lab(signal, __LINE__); + return; + case NodeState::ST_INITIAL_NODE_RESTART: + case NodeState::ST_NODE_RESTART: + jam(); + /*********************************************************************** + * When starting nodes while system is operational we must be controlled + * by the master since only one node restart is allowed at a time. + * When this signal is confirmed the master has also copied the + * dictionary and the distribution information. + */ + StartMeReq * req = (StartMeReq*)&signal->theData[0]; + req->startingRef = reference(); + req->startingVersion = NDB_VERSION; + sendSignal(cmasterdihref, GSN_START_MEREQ, signal, + StartMeReq::SignalLength, JBB); + return; + } + ndbrequire(false); + break; + case ZNDB_SPH5: + jam(); + switch(typestart){ + case NodeState::ST_INITIAL_START: + case NodeState::ST_SYSTEM_RESTART: + jam(); + jam(); + /*---------------------------------------------------------------------*/ + // WE EXECUTE A LOCAL CHECKPOINT AS A PART OF A SYSTEM RESTART. + // THE IDEA IS THAT WE NEED TO + // ENSURE THAT WE CAN RECOVER FROM PROBLEMS CAUSED BY MANY NODE + // CRASHES THAT CAUSES THE LOG + // TO GROW AND THE NUMBER OF LOG ROUNDS TO EXECUTE TO GROW. + // THIS CAN OTHERWISE GET US INTO + // A SITUATION WHICH IS UNREPAIRABLE. THUS WE EXECUTE A CHECKPOINT + // BEFORE ALLOWING ANY TRANSACTIONS TO START. + /*---------------------------------------------------------------------*/ + if (!isMaster()) { + jam(); + ndbsttorry10Lab(signal, __LINE__); + return; + }//if + + c_lcpState.immediateLcpStart = true; + cwaitLcpSr = true; + checkLcpStart(signal, __LINE__); + return; + case NodeState::ST_NODE_RESTART: + case NodeState::ST_INITIAL_NODE_RESTART: + jam(); + signal->theData[0] = cownNodeId; + signal->theData[1] = reference(); + sendSignal(cmasterdihref, GSN_START_COPYREQ, signal, 2, JBB); + return; + } + ndbrequire(false); + case ZNDB_SPH6: + jam(); + switch(typestart){ + case NodeState::ST_INITIAL_START: + case NodeState::ST_SYSTEM_RESTART: + jam(); + if(isMaster()){ + jam(); + startGcp(signal); + } + ndbsttorry10Lab(signal, __LINE__); + return; + case NodeState::ST_NODE_RESTART: + case NodeState::ST_INITIAL_NODE_RESTART: + ndbsttorry10Lab(signal, __LINE__); + return; + } + ndbrequire(false); + break; + default: + jam(); + ndbsttorry10Lab(signal, __LINE__); + break; + }//switch +}//Dbdih::execNDB_STTOR() + +void +Dbdih::createMutexes(Signal * signal, Uint32 count){ + Callback c = { safe_cast(&Dbdih::createMutex_done), count }; + + switch(count){ + case 0:{ + Mutex mutex(signal, c_mutexMgr, c_startLcpMutexHandle); + mutex.create(c); + return; + } + case 1:{ + Mutex mutex(signal, c_mutexMgr, c_switchPrimaryMutexHandle); + mutex.create(c); + return; + } + } + + signal->theData[0] = reference(); + sendSignal(cntrlblockref, GSN_READ_NODESREQ, signal, 1, JBB); +} + +void +Dbdih::createMutex_done(Signal* signal, Uint32 senderData, Uint32 retVal){ + jamEntry(); + ndbrequire(retVal == 0); + + switch(senderData){ + case 0:{ + Mutex mutex(signal, c_mutexMgr, c_startLcpMutexHandle); + mutex.release(); + } + case 1:{ + Mutex mutex(signal, c_mutexMgr, c_switchPrimaryMutexHandle); + mutex.release(); + } + } + + createMutexes(signal, senderData + 1); +} + +/*****************************************************************************/ +/* ------------------------------------------------------------------------- */ +/* WE HAVE BEEN REQUESTED BY NDBCNTR TO PERFORM A RESTART OF THE */ +/* DATABASE TABLES. */ +/* THIS SIGNAL IS SENT AFTER COMPLETING PHASE 3 IN ALL BLOCKS IN A */ +/* SYSTEM RESTART. WE WILL ALSO JUMP TO THIS LABEL FROM PHASE 3 IN AN */ +/* INITIAL START. */ +/* ------------------------------------------------------------------------- */ +/*****************************************************************************/ +void Dbdih::execNDB_STARTREQ(Signal* signal) +{ + jamEntry(); + BlockReference ref = signal->theData[0]; + cstarttype = signal->theData[1]; + ndbStartReqLab(signal, ref); +}//Dbdih::execNDB_STARTREQ() + +void Dbdih::ndbStartReqLab(Signal* signal, BlockReference ref) +{ + cndbStartReqBlockref = ref; + if (cstarttype == NodeState::ST_INITIAL_START) { + jam(); + initRestartInfo(); + initGciFilesLab(signal); + return; + } + + ndbrequire(isMaster()); + copyGciLab(signal, CopyGCIReq::RESTART); // We have already read the file! +}//Dbdih::ndbStartReqLab() + +void Dbdih::execREAD_NODESCONF(Signal* signal) +{ + ReadNodesConf * const readNodes = (ReadNodesConf *)&signal->theData[0]; + jamEntry(); + Uint32 nodeArray[MAX_NDB_NODES]; + + csystemnodes = readNodes->noOfNodes; + cmasterNodeId = readNodes->masterNodeId; + int index = 0; + for (unsigned i = 1; i < MAX_NDB_NODES; i++){ + jam(); + if(NodeBitmask::get(readNodes->allNodes, i)){ + jam(); + nodeArray[index] = i; + if(NodeBitmask::get(readNodes->inactiveNodes, i) == false){ + jam(); + con_lineNodes++; + }//if + index++; + }//if + }//for + ndbrequire(csystemnodes >= 1 && csystemnodes < MAX_NDB_NODES); + if (cstarttype == NodeState::ST_INITIAL_START) { + jam(); + ndbrequire(cnoReplicas <= csystemnodes); + calculateHotSpare(); + ndbrequire(cnoReplicas <= (csystemnodes - cnoHotSpare)); + }//if + + cmasterdihref = calcDihBlockRef(cmasterNodeId); + /*-------------------------------------------------------------------------*/ + /* MAKE THE LIST OF PRN-RECORD WHICH IS ONE OF THE NODES-LIST IN THIS BLOCK*/ + /*-------------------------------------------------------------------------*/ + makePrnList(readNodes, nodeArray); + if (cstarttype == NodeState::ST_INITIAL_START) { + jam(); + /**---------------------------------------------------------------------- + * WHEN WE INITIALLY START A DATABASE WE WILL CREATE NODE GROUPS. + * ALL NODES ARE PUT INTO NODE GROUPS ALTHOUGH HOT SPARE NODES ARE PUT + * INTO A SPECIAL NODE GROUP. IN EACH NODE GROUP WE HAVE THE SAME AMOUNT + * OF NODES AS THERE ARE NUMBER OF REPLICAS. + * ONE POSSIBLE USAGE OF NODE GROUPS ARE TO MAKE A NODE GROUP A COMPLETE + * FRAGMENT OF THE DATABASE. THIS MEANS THAT ALL REPLICAS WILL BE STORED + * IN THE NODE GROUP. + *-----------------------------------------------------------------------*/ + makeNodeGroups(nodeArray); + }//if + ndbrequire(checkNodeAlive(cmasterNodeId)); + if (cstarttype == NodeState::ST_INITIAL_START) { + jam(); + /**----------------------------------------------------------------------- + * INITIALISE THE SECOND NODE-LIST AND SET NODE BITS AND SOME NODE STATUS. + * VERY CONNECTED WITH MAKE_NODE_GROUPS. CHANGING ONE WILL AFFECT THE + * OTHER AS WELL. + *-----------------------------------------------------------------------*/ + setInitialActiveStatus(); + } else if (cstarttype == NodeState::ST_SYSTEM_RESTART) { + jam(); + /*empty*/; + } else if ((cstarttype == NodeState::ST_NODE_RESTART) || + (cstarttype == NodeState::ST_INITIAL_NODE_RESTART)) { + jam(); + nodeRestartPh2Lab(signal); + return; + } else { + ndbrequire(false); + }//if + /**------------------------------------------------------------------------ + * ESTABLISH CONNECTIONS WITH THE OTHER DIH BLOCKS AND INITIALISE THIS + * NODE-LIST THAT HANDLES CONNECTION WITH OTHER DIH BLOCKS. + *-------------------------------------------------------------------------*/ + ndbsttorry10Lab(signal, __LINE__); +}//Dbdih::execREAD_NODESCONF() + +/*---------------------------------------------------------------------------*/ +/* START NODE LOGIC FOR NODE RESTART */ +/*---------------------------------------------------------------------------*/ +void Dbdih::nodeRestartPh2Lab(Signal* signal) +{ + /*------------------------------------------------------------------------*/ + // REQUEST FOR PERMISSION FROM MASTER TO START A NODE IN AN ALREADY + // RUNNING SYSTEM. + /*------------------------------------------------------------------------*/ + StartPermReq * const req = (StartPermReq *)&signal->theData[0]; + + req->blockRef = reference(); + req->nodeId = cownNodeId; + req->startType = cstarttype; + sendSignal(cmasterdihref, GSN_START_PERMREQ, signal, 3, JBB); +}//Dbdih::nodeRestartPh2Lab() + +void Dbdih::execSTART_PERMCONF(Signal* signal) +{ + jamEntry(); + CRASH_INSERTION(7121); + Uint32 nodeId = signal->theData[0]; + cfailurenr = signal->theData[1]; + ndbrequire(nodeId == cownNodeId); + ndbsttorry10Lab(signal, __LINE__); +}//Dbdih::execSTART_PERMCONF() + +void Dbdih::execSTART_PERMREF(Signal* signal) +{ + jamEntry(); + Uint32 errorCode = signal->theData[1]; + if (errorCode == ZNODE_ALREADY_STARTING_ERROR) { + jam(); + /*-----------------------------------------------------------------------*/ + // The master was busy adding another node. We will wait for a second and + // try again. + /*-----------------------------------------------------------------------*/ + signal->theData[0] = DihContinueB::ZSTART_PERMREQ_AGAIN; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 3000, 1); + return; + }//if + /*------------------------------------------------------------------------*/ + // Some node process in another node involving our node was still active. We + // will recover from this by crashing here. + // This is controlled restart using the + // already existing features of node crashes. It is not a bug getting here. + /*-------------------------------------------------------------------------*/ + ndbrequire(false); + return; +}//Dbdih::execSTART_PERMREF() + +/*---------------------------------------------------------------------------*/ +/* THIS SIGNAL IS RECEIVED IN THE STARTING NODE WHEN THE START_MEREQ */ +/* HAS BEEN EXECUTED IN THE MASTER NODE. */ +/*---------------------------------------------------------------------------*/ +void Dbdih::execSTART_MECONF(Signal* signal) +{ + jamEntry(); + StartMeConf * const startMe = (StartMeConf *)&signal->theData[0]; + Uint32 nodeId = startMe->startingNodeId; + const Uint32 startWord = startMe->startWord; + + CRASH_INSERTION(7130); + ndbrequire(nodeId == cownNodeId); + arrGuard(startWord + StartMeConf::DATA_SIZE, sizeof(cdata)/4); + for(Uint32 i = 0; i < StartMeConf::DATA_SIZE; i++) + cdata[startWord+i] = startMe->data[i]; + + if(startWord + StartMeConf::DATA_SIZE < Sysfile::SYSFILE_SIZE32){ + jam(); + /** + * We are still waiting for data + */ + return; + } + jam(); + + /** + * Copy into sysfile + * + * But dont copy lastCompletedGCI:s + */ + Uint32 tempGCP[MAX_NDB_NODES]; + for(Uint32 i = 0; i < MAX_NDB_NODES; i++) + tempGCP[i] = SYSFILE->lastCompletedGCI[i]; + + for(Uint32 i = 0; i < Sysfile::SYSFILE_SIZE32; i++) + sysfileData[i] = cdata[i]; + for(Uint32 i = 0; i < MAX_NDB_NODES; i++) + SYSFILE->lastCompletedGCI[i] = tempGCP[i]; + + setNodeActiveStatus(); + setNodeGroups(); + ndbsttorry10Lab(signal, __LINE__); +}//Dbdih::execSTART_MECONF() + +void Dbdih::execSTART_COPYCONF(Signal* signal) +{ + jamEntry(); + Uint32 nodeId = signal->theData[0]; + ndbrequire(nodeId == cownNodeId); + CRASH_INSERTION(7132); + ndbsttorry10Lab(signal, __LINE__); + return; +}//Dbdih::execSTART_COPYCONF() + +/*---------------------------------------------------------------------------*/ +/* MASTER LOGIC FOR NODE RESTART */ +/*---------------------------------------------------------------------------*/ +/* NODE RESTART PERMISSION REQUEST */ +/*---------------------------------------------------------------------------*/ +// A REQUEST FROM A STARTING NODE TO PERFORM A NODE RESTART. IF NO OTHER NODE +// IS ACTIVE IN PERFORMING A NODE RESTART AND THERE ARE NO ACTIVE PROCESSES IN +// THIS NODE INVOLVING THE STARTING NODE THIS REQUEST WILL BE GRANTED. +/*---------------------------------------------------------------------------*/ +void Dbdih::execSTART_PERMREQ(Signal* signal) +{ + StartPermReq * const req = (StartPermReq*)&signal->theData[0]; + jamEntry(); + const BlockReference retRef = req->blockRef; + const Uint32 nodeId = req->nodeId; + const Uint32 typeStart = req->startType; + + CRASH_INSERTION(7122); + ndbrequire(isMaster()); + ndbrequire(refToNode(retRef) == nodeId); + if ((c_nodeStartMaster.activeState) || + (c_nodeStartMaster.wait != ZFALSE)) { + jam(); + signal->theData[0] = nodeId; + signal->theData[1] = ZNODE_ALREADY_STARTING_ERROR; + sendSignal(retRef, GSN_START_PERMREF, signal, 2, JBB); + return; + }//if + if (getNodeStatus(nodeId) != NodeRecord::DEAD){ + ndbout << "nodeStatus in START_PERMREQ = " + << getNodeStatus(nodeId) << endl; + ndbrequire(false); + }//if + + /*---------------------------------------------------------------------- + * WE START THE INCLUSION PROCEDURE + * ---------------------------------------------------------------------*/ + c_nodeStartMaster.failNr = cfailurenr; + c_nodeStartMaster.wait = ZFALSE; + c_nodeStartMaster.startInfoErrorCode = 0; + c_nodeStartMaster.startNode = nodeId; + c_nodeStartMaster.activeState = true; + + setNodeStatus(nodeId, NodeRecord::STARTING); + /** + * But if it's a NodeState::ST_INITIAL_NODE_RESTART + * + * We first have to clear LCP's + * For normal node restart we simply ensure that all nodes + * are informed of the node restart + */ + StartInfoReq *const r =(StartInfoReq*)&signal->theData[0]; + r->startingNodeId = nodeId; + r->typeStart = typeStart; + r->systemFailureNo = cfailurenr; + sendLoopMacro(START_INFOREQ, sendSTART_INFOREQ); +}//Dbdih::execSTART_PERMREQ() + +void Dbdih::execSTART_INFOREF(Signal* signal) +{ + StartInfoRef * ref = (StartInfoRef*)&signal->theData[0]; + if (getNodeStatus(ref->startingNodeId) != NodeRecord::STARTING) { + jam(); + return; + }//if + ndbrequire(c_nodeStartMaster.startNode == ref->startingNodeId); + c_nodeStartMaster.startInfoErrorCode = ref->errorCode; + startInfoReply(signal, ref->sendingNodeId); +}//Dbdih::execSTART_INFOREF() + +void Dbdih::execSTART_INFOCONF(Signal* signal) +{ + jamEntry(); + StartInfoConf * conf = (StartInfoConf*)&signal->theData[0]; + if (getNodeStatus(conf->startingNodeId) != NodeRecord::STARTING) { + jam(); + return; + }//if + ndbrequire(c_nodeStartMaster.startNode == conf->startingNodeId); + startInfoReply(signal, conf->sendingNodeId); +}//Dbdih::execSTART_INFOCONF() + +void Dbdih::startInfoReply(Signal* signal, Uint32 nodeId) +{ + receiveLoopMacro(START_INFOREQ, nodeId); + /** + * We're finished with the START_INFOREQ's + */ + if (c_nodeStartMaster.startInfoErrorCode == 0) { + jam(); + /** + * Everything has been a success so far + */ + StartPermConf * conf = (StartPermConf*)&signal->theData[0]; + conf->startingNodeId = c_nodeStartMaster.startNode; + conf->systemFailureNo = cfailurenr; + sendSignal(calcDihBlockRef(c_nodeStartMaster.startNode), + GSN_START_PERMCONF, signal, StartPermConf::SignalLength, JBB); + c_nodeStartMaster.m_outstandingGsn = GSN_START_PERMCONF; + } else { + jam(); + StartPermRef * ref = (StartPermRef*)&signal->theData[0]; + ref->startingNodeId = c_nodeStartMaster.startNode; + ref->errorCode = c_nodeStartMaster.startInfoErrorCode; + sendSignal(calcDihBlockRef(c_nodeStartMaster.startNode), + GSN_START_PERMREF, signal, StartPermRef::SignalLength, JBB); + nodeResetStart(); + }//if +}//Dbdih::startInfoReply() + +/*---------------------------------------------------------------------------*/ +/* NODE RESTART CONTINUE REQUEST */ +/*---------------------------------------------------------------------------*/ +// THIS SIGNAL AND THE CODE BELOW IS EXECUTED BY THE MASTER WHEN IT HAS BEEN +// REQUESTED TO START UP A NEW NODE. The master instructs the starting node +// how to set up its log for continued execution. +/*---------------------------------------------------------------------------*/ +void Dbdih::execSTART_MEREQ(Signal* signal) +{ + StartMeReq * req = (StartMeReq*)&signal->theData[0]; + jamEntry(); + const BlockReference Tblockref = req->startingRef; + const Uint32 Tnodeid = refToNode(Tblockref); + const Uint32 TndbVersion = req->startingVersion; + + ndbrequire(isMaster()); + ndbrequire(c_nodeStartMaster.startNode == Tnodeid); + ndbrequire(getNodeStatus(Tnodeid) == NodeRecord::STARTING); + + c_nodeStartMaster.ndbVersion = TndbVersion; + sendSTART_RECREQ(signal, Tnodeid); +}//Dbdih::execSTART_MEREQ() + +void Dbdih::nodeRestartStartRecConfLab(Signal* signal) +{ + c_nodeStartMaster.blockLcp = true; + if ((c_lcpState.lcpStatus != LCP_STATUS_IDLE) && + (c_lcpState.lcpStatus != LCP_TCGET)) { + jam(); + /*-----------------------------------------------------------------------*/ + // WE WILL NOT ALLOW A NODE RESTART TO COME IN WHEN A LOCAL CHECKPOINT IS + // ONGOING. IT WOULD COMPLICATE THE LCP PROTOCOL TOO MUCH. WE WILL ADD THIS + // LATER. + /*-----------------------------------------------------------------------*/ + return; + }//if + lcpBlockedLab(signal); +}//Dbdih::nodeRestartStartRecConfLab() + +void Dbdih::lcpBlockedLab(Signal* signal) +{ + ndbrequire(getNodeStatus(c_nodeStartMaster.startNode)==NodeRecord::STARTING); + /*------------------------------------------------------------------------*/ + // NOW WE HAVE COPIED ALL INFORMATION IN DICT WE ARE NOW READY TO COPY ALL + // INFORMATION IN DIH TO THE NEW NODE. + /*------------------------------------------------------------------------*/ + c_nodeStartMaster.wait = 10; + signal->theData[0] = DihContinueB::ZCOPY_NODE; + signal->theData[1] = 0; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + c_nodeStartMaster.m_outstandingGsn = GSN_COPY_TABREQ; +}//Dbdih::lcpBlockedLab() + +void Dbdih::nodeDictStartConfLab(Signal* signal) +{ + /*-------------------------------------------------------------------------*/ + // NOW WE HAVE COPIED BOTH DIH AND DICT INFORMATION. WE ARE NOW READY TO + // INTEGRATE THE NODE INTO THE LCP AND GCP PROTOCOLS AND TO ALLOW UPDATES OF + // THE DICTIONARY AGAIN. + /*-------------------------------------------------------------------------*/ + c_nodeStartMaster.wait = ZFALSE; + c_nodeStartMaster.blockGcp = true; + if (cgcpStatus != GCP_READY) { + /*-----------------------------------------------------------------------*/ + // The global checkpoint is executing. Wait until it is completed before we + // continue processing the node recovery. + /*-----------------------------------------------------------------------*/ + jam(); + return; + }//if + gcpBlockedLab(signal); + + /*-----------------------------------------------------------------*/ + // Report that node restart has completed copy of dictionary. + /*-----------------------------------------------------------------*/ + signal->theData[0] = EventReport::NR_CopyDict; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 1, JBB); +}//Dbdih::nodeDictStartConfLab() + +void Dbdih::dihCopyCompletedLab(Signal* signal) +{ + BlockReference ref = calcDictBlockRef(c_nodeStartMaster.startNode); + DictStartReq * req = (DictStartReq*)&signal->theData[0]; + req->restartGci = cnewgcp; + req->senderRef = reference(); + sendSignal(ref, GSN_DICTSTARTREQ, + signal, DictStartReq::SignalLength, JBB); + c_nodeStartMaster.m_outstandingGsn = GSN_DICTSTARTREQ; + c_nodeStartMaster.wait = 0; +}//Dbdih::dihCopyCompletedLab() + +void Dbdih::gcpBlockedLab(Signal* signal) +{ + /*-----------------------------------------------------------------*/ + // Report that node restart has completed copy of distribution info. + /*-----------------------------------------------------------------*/ + signal->theData[0] = EventReport::NR_CopyDistr; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 1, JBB); + + /** + * The node DIH will be part of LCP + */ + NodeRecordPtr nodePtr; + nodePtr.i = c_nodeStartMaster.startNode; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + nodePtr.p->m_inclDihLcp = true; + + /*-------------------------------------------------------------------------*/ + // NOW IT IS TIME TO INFORM ALL OTHER NODES IN THE CLUSTER OF THE STARTED + // NODE SUCH THAT THEY ALSO INCLUDE THE NODE IN THE NODE LISTS AND SO FORTH. + /*------------------------------------------------------------------------*/ + sendLoopMacro(INCL_NODEREQ, sendINCL_NODEREQ); + /*-------------------------------------------------------------------------*/ + // We also need to send to the starting node to ensure he is aware of the + // global checkpoint id and the correct state. We do not wait for any reply + // since the starting node will not send any. + /*-------------------------------------------------------------------------*/ + sendINCL_NODEREQ(signal, c_nodeStartMaster.startNode); +}//Dbdih::gcpBlockedLab() + +/*---------------------------------------------------------------------------*/ +// THIS SIGNAL IS EXECUTED IN BOTH SLAVES AND IN THE MASTER +/*---------------------------------------------------------------------------*/ +void Dbdih::execINCL_NODECONF(Signal* signal) +{ + Uint32 TsendNodeId; + Uint32 TstartNode_or_blockref; + + jamEntry(); + TstartNode_or_blockref = signal->theData[0]; + TsendNodeId = signal->theData[1]; + + if (TstartNode_or_blockref == clocallqhblockref) { + jam(); + /*-----------------------------------------------------------------------*/ + // THIS SIGNAL CAME FROM THE LOCAL LQH BLOCK. + // WE WILL NOW SEND INCLUDE TO THE TC BLOCK. + /*-----------------------------------------------------------------------*/ + signal->theData[0] = reference(); + signal->theData[1] = c_nodeStartSlave.nodeId; + sendSignal(clocaltcblockref, GSN_INCL_NODEREQ, signal, 2, JBB); + return; + }//if + if (TstartNode_or_blockref == clocaltcblockref) { + jam(); + /*----------------------------------------------------------------------*/ + // THIS SIGNAL CAME FROM THE LOCAL LQH BLOCK. + // WE WILL NOW SEND INCLUDE TO THE DICT BLOCK. + /*----------------------------------------------------------------------*/ + signal->theData[0] = reference(); + signal->theData[1] = c_nodeStartSlave.nodeId; + sendSignal(cdictblockref, GSN_INCL_NODEREQ, signal, 2, JBB); + return; + }//if + if (TstartNode_or_blockref == cdictblockref) { + jam(); + /*-----------------------------------------------------------------------*/ + // THIS SIGNAL CAME FROM THE LOCAL DICT BLOCK. WE WILL NOW SEND CONF TO THE + // BACKUP. + /*-----------------------------------------------------------------------*/ + signal->theData[0] = reference(); + signal->theData[1] = c_nodeStartSlave.nodeId; + sendSignal(BACKUP_REF, GSN_INCL_NODEREQ, signal, 2, JBB); + + // Suma will not send response to this for now, later... + sendSignal(SUMA_REF, GSN_INCL_NODEREQ, signal, 2, JBB); + // Grep will not send response to this for now, later... + sendSignal(GREP_REF, GSN_INCL_NODEREQ, signal, 2, JBB); + return; + }//if + if (TstartNode_or_blockref == numberToRef(BACKUP, getOwnNodeId())){ + jam(); + signal->theData[0] = c_nodeStartSlave.nodeId; + signal->theData[1] = cownNodeId; + sendSignal(cmasterdihref, GSN_INCL_NODECONF, signal, 2, JBB); + c_nodeStartSlave.nodeId = 0; + return; + } + + ndbrequire(cmasterdihref = reference()); + receiveLoopMacro(INCL_NODEREQ, TsendNodeId); + + CRASH_INSERTION(7128); + /*-------------------------------------------------------------------------*/ + // Now that we have included the starting node in the node lists in the + // various blocks we are ready to start the global checkpoint protocol + /*------------------------------------------------------------------------*/ + c_nodeStartMaster.wait = 11; + c_nodeStartMaster.blockGcp = false; + + signal->theData[0] = reference(); + sendSignal(reference(), GSN_UNBLO_DICTCONF, signal, 1, JBB); +}//Dbdih::execINCL_NODECONF() + +void Dbdih::execUNBLO_DICTCONF(Signal* signal) +{ + jamEntry(); + c_nodeStartMaster.wait = ZFALSE; + if (!c_nodeStartMaster.activeState) { + jam(); + return; + }//if + + CRASH_INSERTION(7129); + /**----------------------------------------------------------------------- + * WE HAVE NOW PREPARED IT FOR INCLUSION IN THE LCP PROTOCOL. + * WE CAN NOW START THE LCP PROTOCOL AGAIN. + * WE HAVE ALSO MADE THIS FOR THE GCP PROTOCOL. + * WE ARE READY TO START THE PROTOCOLS AND RESPOND TO THE START REQUEST + * FROM THE STARTING NODE. + *------------------------------------------------------------------------*/ + + StartMeConf * const startMe = (StartMeConf *)&signal->theData[0]; + + const Uint32 wordPerSignal = StartMeConf::DATA_SIZE; + const int noOfSignals = ((Sysfile::SYSFILE_SIZE32 + (wordPerSignal - 1)) / + wordPerSignal); + + startMe->startingNodeId = c_nodeStartMaster.startNode; + startMe->startWord = 0; + + const Uint32 ref = calcDihBlockRef(c_nodeStartMaster.startNode); + for(int i = 0; i < noOfSignals; i++){ + jam(); + { // Do copy + const int startWord = startMe->startWord; + for(Uint32 j = 0; j < wordPerSignal; j++){ + startMe->data[j] = sysfileData[j+startWord]; + } + } + sendSignal(ref, GSN_START_MECONF, signal, StartMeConf::SignalLength, JBB); + startMe->startWord += wordPerSignal; + }//for + c_nodeStartMaster.m_outstandingGsn = GSN_START_MECONF; +}//Dbdih::execUNBLO_DICTCONF() + +/*---------------------------------------------------------------------------*/ +/* NODE RESTART COPY REQUEST */ +/*---------------------------------------------------------------------------*/ +// A NODE RESTART HAS REACHED ITS FINAL PHASE WHEN THE DATA IS TO BE COPIED +// TO THE NODE. START_COPYREQ IS EXECUTED BY THE MASTER NODE. +/*---------------------------------------------------------------------------*/ +void Dbdih::execSTART_COPYREQ(Signal* signal) +{ + jamEntry(); + Uint32 startNodeId = signal->theData[0]; + //BlockReference startingRef = signal->theData[1]; + ndbrequire(c_nodeStartMaster.startNode == startNodeId); + /*-------------------------------------------------------------------------*/ + // REPORT Copy process of node restart is now about to start up. + /*-------------------------------------------------------------------------*/ + signal->theData[0] = EventReport::NR_CopyFragsStarted; + signal->theData[1] = startNodeId; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); + + CRASH_INSERTION(7131); + nodeRestartTakeOver(signal, startNodeId); + // BlockReference ref = calcQmgrBlockRef(startNodeId); + // signal->theData[0] = cownNodeId; + // Remove comments as soon as I open up the Qmgr block + // TODO_RONM + // sendSignal(ref, GSN_ALLOW_NODE_CRASHORD, signal, 1, JBB); +}//Dbdih::execSTART_COPYREQ() + +/*---------------------------------------------------------------------------*/ +/* SLAVE LOGIC FOR NODE RESTART */ +/*---------------------------------------------------------------------------*/ +void Dbdih::execSTART_INFOREQ(Signal* signal) +{ + jamEntry(); + StartInfoReq *const req =(StartInfoReq*)&signal->theData[0]; + Uint32 startNode = req->startingNodeId; + if (cfailurenr != req->systemFailureNo) { + jam(); + //--------------------------------------------------------------- + // A failure occurred since master sent this request. We will ignore + // this request since the node is already dead that is starting. + //--------------------------------------------------------------- + return; + }//if + CRASH_INSERTION(7123); + if (isMaster()) { + jam(); + ndbrequire(getNodeStatus(startNode) == NodeRecord::STARTING); + } else { + jam(); + ndbrequire(getNodeStatus(startNode) == NodeRecord::DEAD); + }//if + if ((!getAllowNodeStart(startNode)) || + (c_nodeStartSlave.nodeId != 0) || + (ERROR_INSERTED(7124))) { + jam(); + StartInfoRef *const ref =(StartInfoRef*)&signal->theData[0]; + ref->sendingNodeId = cownNodeId; + ref->errorCode = ZNODE_START_DISALLOWED_ERROR; + sendSignal(cmasterdihref, GSN_START_INFOREF, signal, 2, JBB); + return; + }//if + setNodeStatus(startNode, NodeRecord::STARTING); + if (req->typeStart == NodeState::ST_INITIAL_NODE_RESTART) { + jam(); + setAllowNodeStart(startNode, false); + invalidateNodeLCP(signal, startNode, 0); + } else { + jam(); + StartInfoConf * c = (StartInfoConf*)&signal->theData[0]; + c->sendingNodeId = cownNodeId; + c->startingNodeId = startNode; + sendSignal(cmasterdihref, GSN_START_INFOCONF, signal, + StartInfoConf::SignalLength, JBB); + return; + }//if +}//Dbdih::execSTART_INFOREQ() + +void Dbdih::execINCL_NODEREQ(Signal* signal) +{ + jamEntry(); + Uint32 retRef = signal->theData[0]; + Uint32 nodeId = signal->theData[1]; + Uint32 tnodeStartFailNr = signal->theData[2]; + Uint32 TndbVersion = signal->theData[3]; + currentgcp = signal->theData[4]; + CRASH_INSERTION(7127); + cnewgcp = currentgcp; + coldgcp = currentgcp - 1; + if (!isMaster()) { + jam(); + /*-----------------------------------------------------------------------*/ + // We don't want to change the state of the master since he can be in the + // state LCP_TCGET at this time. + /*-----------------------------------------------------------------------*/ + c_lcpState.setLcpStatus(LCP_STATUS_IDLE, __LINE__); + }//if + + /*-------------------------------------------------------------------------*/ + // When a node is restarted we must ensure that a lcp will be run + // as soon as possible and the reset the delay according to the original + // configuration. + // Without an initial local checkpoint the new node will not be available. + /*-------------------------------------------------------------------------*/ + if (getOwnNodeId() == nodeId) { + jam(); + /*-----------------------------------------------------------------------*/ + // We are the starting node. We came here only to set the global checkpoint + // id's and the lcp status. + /*-----------------------------------------------------------------------*/ + CRASH_INSERTION(7171); + return; + }//if + if (getNodeStatus(nodeId) != NodeRecord::STARTING) { + jam(); + return; + }//if + ndbrequire(cfailurenr == tnodeStartFailNr); + ndbrequire (c_nodeStartSlave.nodeId == 0); + c_nodeStartSlave.nodeId = nodeId; + + ndbrequire (retRef == cmasterdihref); + + NodeRecordPtr nodePtr; + nodePtr.i = nodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + + Sysfile::ActiveStatus TsaveState = nodePtr.p->activeStatus; + Uint32 TnodeGroup = nodePtr.p->nodeGroup; + + initNodeState(nodePtr); + nodePtr.p->nodeGroup = TnodeGroup; + nodePtr.p->activeStatus = TsaveState; + nodePtr.p->nodeStatus = NodeRecord::ALIVE; + nodePtr.p->useInTransactions = true; + nodePtr.p->m_inclDihLcp = true; + nodePtr.p->ndbversion = TndbVersion; + + removeDeadNode(nodePtr); + insertAlive(nodePtr); + con_lineNodes++; + + /*-------------------------------------------------------------------------*/ + // WE WILL ALSO SEND THE INCLUDE NODE REQUEST TO THE LOCAL LQH BLOCK. + /*-------------------------------------------------------------------------*/ + signal->theData[0] = reference(); + signal->theData[1] = nodeId; + signal->theData[2] = currentgcp; + sendSignal(clocallqhblockref, GSN_INCL_NODEREQ, signal, 3, JBB); +}//Dbdih::execINCL_NODEREQ() + +/* ------------------------------------------------------------------------- */ +// execINCL_NODECONF() is found in the master logic part since it is used by +// both the master and the slaves. +/* ------------------------------------------------------------------------- */ + +/*****************************************************************************/ +/*********** TAKE OVER DECISION MODULE *************/ +/*****************************************************************************/ +// This module contains the subroutines that take the decision whether to take +// over a node now or not. +/* ------------------------------------------------------------------------- */ +/* MASTER LOGIC FOR SYSTEM RESTART */ +/* ------------------------------------------------------------------------- */ +// WE ONLY COME HERE IF WE ARE THE MASTER AND WE ARE PERFORMING A SYSTEM +// RESTART. WE ALSO COME HERE DURING THIS SYSTEM RESTART ONE TIME PER NODE +// THAT NEEDS TAKE OVER. +/*---------------------------------------------------------------------------*/ +// WE CHECK IF ANY NODE NEEDS TO BE TAKEN OVER AND THE TAKE OVER HAS NOT YET +// BEEN STARTED OR COMPLETED. +/*---------------------------------------------------------------------------*/ +void +Dbdih::systemRestartTakeOverLab(Signal* signal) +{ + NodeRecordPtr nodePtr; + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRecord); + switch (nodePtr.p->activeStatus) { + case Sysfile::NS_Active: + case Sysfile::NS_ActiveMissed_1: + jam(); + break; + /*---------------------------------------------------------------------*/ + // WE HAVE NOT REACHED A STATE YET WHERE THIS NODE NEEDS TO BE TAKEN OVER + /*---------------------------------------------------------------------*/ + case Sysfile::NS_ActiveMissed_2: + case Sysfile::NS_NotActive_NotTakenOver: + jam(); + /*---------------------------------------------------------------------*/ + // THIS NODE IS IN TROUBLE. + // WE MUST SUCCEED WITH A LOCAL CHECKPOINT WITH THIS NODE TO REMOVE THE + // DANGER. IF THE NODE IS NOT ALIVE THEN THIS WILL NOT BE + // POSSIBLE AND WE CAN START THE TAKE OVER IMMEDIATELY IF WE HAVE ANY + // NODES THAT CAN PERFORM A TAKE OVER. + /*---------------------------------------------------------------------*/ + if (nodePtr.p->nodeStatus != NodeRecord::ALIVE) { + jam(); + Uint32 ThotSpareNode = findHotSpare(); + if (ThotSpareNode != RNIL) { + jam(); + startTakeOver(signal, RNIL, ThotSpareNode, nodePtr.i); + }//if + } else if(nodePtr.p->activeStatus == Sysfile::NS_NotActive_NotTakenOver){ + jam(); + /*-------------------------------------------------------------------*/ + // NOT ACTIVE NODES THAT HAVE NOT YET BEEN TAKEN OVER NEEDS TAKE OVER + // IMMEDIATELY. IF WE ARE ALIVE WE TAKE OVER OUR OWN NODE. + /*-------------------------------------------------------------------*/ + startTakeOver(signal, RNIL, nodePtr.i, nodePtr.i); + }//if + break; + case Sysfile::NS_TakeOver: + /**------------------------------------------------------------------- + * WE MUST HAVE FAILED IN THE MIDDLE OF THE TAKE OVER PROCESS. + * WE WILL CONCLUDE THE TAKE OVER PROCESS NOW. + *-------------------------------------------------------------------*/ + if (nodePtr.p->nodeStatus == NodeRecord::ALIVE) { + jam(); + Uint32 takeOverNode = Sysfile::getTakeOverNode(nodePtr.i, + SYSFILE->takeOver); + if(takeOverNode == 0){ + jam(); + warningEvent("Bug in take-over code restarting"); + takeOverNode = nodePtr.i; + } + startTakeOver(signal, RNIL, nodePtr.i, takeOverNode); + } else { + jam(); + /**------------------------------------------------------------------- + * We are not currently taking over, change our active status. + *-------------------------------------------------------------------*/ + nodePtr.p->activeStatus = Sysfile::NS_NotActive_NotTakenOver; + setNodeRestartInfoBits(); + }//if + break; + case Sysfile::NS_HotSpare: + jam(); + break; + /*---------------------------------------------------------------------*/ + // WE NEED NOT TAKE OVER NODES THAT ARE HOT SPARE. + /*---------------------------------------------------------------------*/ + case Sysfile::NS_NotDefined: + jam(); + break; + /*---------------------------------------------------------------------*/ + // WE NEED NOT TAKE OVER NODES THAT DO NOT EVEN EXIST IN THE CLUSTER. + /*---------------------------------------------------------------------*/ + default: + ndbrequire(false); + break; + }//switch + }//for + /*-------------------------------------------------------------------------*/ + /* NO TAKE OVER HAS BEEN INITIATED. */ + /*-------------------------------------------------------------------------*/ +}//Dbdih::systemRestartTakeOverLab() + +/*---------------------------------------------------------------------------*/ +// This subroutine is called as part of node restart in the master node. +/*---------------------------------------------------------------------------*/ +void Dbdih::nodeRestartTakeOver(Signal* signal, Uint32 startNodeId) +{ + switch (getNodeActiveStatus(startNodeId)) { + case Sysfile::NS_Active: + case Sysfile::NS_ActiveMissed_1: + case Sysfile::NS_ActiveMissed_2: + jam(); + /*-----------------------------------------------------------------------*/ + // AN ACTIVE NODE HAS BEEN STARTED. THE ACTIVE NODE MUST THEN GET ALL DATA + // IT HAD BEFORE ITS CRASH. WE START THE TAKE OVER IMMEDIATELY. + // SINCE WE ARE AN ACTIVE NODE WE WILL TAKE OVER OUR OWN NODE THAT + // PREVIOUSLY CRASHED. + /*-----------------------------------------------------------------------*/ + startTakeOver(signal, RNIL, startNodeId, startNodeId); + break; + case Sysfile::NS_HotSpare:{ + jam(); + /*-----------------------------------------------------------------------*/ + // WHEN STARTING UP A HOT SPARE WE WILL CHECK IF ANY NODE NEEDS TO TAKEN + // OVER. IF SO THEN WE WILL START THE TAKE OVER. + /*-----------------------------------------------------------------------*/ + bool takeOverStarted = false; + NodeRecordPtr nodePtr; + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRecord); + if (nodePtr.p->activeStatus == Sysfile::NS_NotActive_NotTakenOver) { + jam(); + takeOverStarted = true; + startTakeOver(signal, RNIL, startNodeId, nodePtr.i); + }//if + }//for + if (!takeOverStarted) { + jam(); + /*-------------------------------------------------------------------*/ + // NO TAKE OVER WAS NEEDED AT THE MOMENT WE START-UP AND WAIT UNTIL A + // TAKE OVER IS NEEDED. + /*-------------------------------------------------------------------*/ + BlockReference ref = calcDihBlockRef(startNodeId); + signal->theData[0] = startNodeId; + sendSignal(ref, GSN_START_COPYCONF, signal, 1, JBB); + }//if + break; + } + case Sysfile::NS_NotActive_NotTakenOver: + jam(); + /*-----------------------------------------------------------------------*/ + // ALL DATA IN THE NODE IS LOST BUT WE HAVE NOT TAKEN OVER YET. WE WILL + // TAKE OVER OUR OWN NODE + /*-----------------------------------------------------------------------*/ + startTakeOver(signal, RNIL, startNodeId, startNodeId); + break; + case Sysfile::NS_TakeOver:{ + jam(); + /*-------------------------------------------------------------------- + * We were in the process of taking over but it was not completed. + * We will complete it now instead. + *--------------------------------------------------------------------*/ + Uint32 takeOverNode = Sysfile::getTakeOverNode(startNodeId, + SYSFILE->takeOver); + startTakeOver(signal, RNIL, startNodeId, takeOverNode); + break; + } + default: + ndbrequire(false); + break; + }//switch + nodeResetStart(); +}//Dbdih::nodeRestartTakeOver() + +/*************************************************************************/ +// Ths routine is called when starting a local checkpoint. +/*************************************************************************/ +void Dbdih::checkStartTakeOver(Signal* signal) +{ + NodeRecordPtr csoNodeptr; + Uint32 tcsoHotSpareNode; + Uint32 tcsoTakeOverNode; + if (isMaster()) { + /*-----------------------------------------------------------------*/ + /* WE WILL ONLY START TAKE OVER IF WE ARE MASTER. */ + /*-----------------------------------------------------------------*/ + /* WE WILL ONLY START THE TAKE OVER IF THERE WERE A NEED OF */ + /* A TAKE OVER. */ + /*-----------------------------------------------------------------*/ + /* WE CAN ONLY PERFORM THE TAKE OVER IF WE HAVE A HOT SPARE */ + /* AVAILABLE. */ + /*-----------------------------------------------------------------*/ + tcsoTakeOverNode = 0; + tcsoHotSpareNode = 0; + for (csoNodeptr.i = 1; csoNodeptr.i < MAX_NDB_NODES; csoNodeptr.i++) { + ptrAss(csoNodeptr, nodeRecord); + if (csoNodeptr.p->activeStatus == Sysfile::NS_NotActive_NotTakenOver) { + jam(); + tcsoTakeOverNode = csoNodeptr.i; + } else { + jam(); + if (csoNodeptr.p->activeStatus == Sysfile::NS_HotSpare) { + jam(); + tcsoHotSpareNode = csoNodeptr.i; + }//if + }//if + }//for + if ((tcsoTakeOverNode != 0) && + (tcsoHotSpareNode != 0)) { + jam(); + startTakeOver(signal, RNIL, tcsoHotSpareNode, tcsoTakeOverNode); + }//if + }//if +}//Dbdih::checkStartTakeOver() + +/*****************************************************************************/ +/*********** NODE ADDING MODULE *************/ +/*********** CODE TO HANDLE TAKE OVER *************/ +/*****************************************************************************/ +// A take over can be initiated by a number of things: +// 1) A node restart, usually the node takes over itself but can also take +// over somebody else if its own data was already taken over +// 2) At system restart it is necessary to use the take over code to recover +// nodes which had too old checkpoints to be restorable by the usual +// restoration from disk. +// 3) When a node has missed too many local checkpoints and is decided by the +// master to be taken over by a hot spare node that sits around waiting +// for this to happen. +// +// To support multiple node failures efficiently the code is written such that +// only one take over can handle transitions in state but during a copy +// fragment other take over's can perform state transitions. +/*****************************************************************************/ +void Dbdih::startTakeOver(Signal* signal, + Uint32 takeOverPtrI, + Uint32 startNode, + Uint32 nodeTakenOver) +{ + NodeRecordPtr toNodePtr; + NodeGroupRecordPtr NGPtr; + toNodePtr.i = nodeTakenOver; + ptrCheckGuard(toNodePtr, MAX_NDB_NODES, nodeRecord); + NGPtr.i = toNodePtr.p->nodeGroup; + ptrCheckGuard(NGPtr, MAX_NDB_NODES, nodeGroupRecord); + TakeOverRecordPtr takeOverPtr; + if (takeOverPtrI == RNIL) { + jam(); + setAllowNodeStart(startNode, false); + seizeTakeOver(takeOverPtr); + if (startNode == c_nodeStartMaster.startNode) { + jam(); + takeOverPtr.p->toNodeRestart = true; + }//if + takeOverPtr.p->toStartingNode = startNode; + takeOverPtr.p->toFailedNode = nodeTakenOver; + } else { + jam(); + RETURN_IF_TAKE_OVER_INTERRUPTED(takeOverPtrI, takeOverPtr); + ndbrequire(takeOverPtr.p->toStartingNode == startNode); + ndbrequire(takeOverPtr.p->toFailedNode == nodeTakenOver); + ndbrequire(takeOverPtr.p->toMasterStatus == TakeOverRecord::TO_WAIT_START_TAKE_OVER); + }//if + if ((NGPtr.p->activeTakeOver) || (ERROR_INSERTED(7157))) { + jam(); + /**------------------------------------------------------------------------ + * A take over is already active in this node group. We only allow one + * take over per node group. Otherwise we will overload the node group and + * also we will require much more checks when starting up copying of + * fragments. The parallelism for take over is mainly to ensure that we + * can handle take over efficiently in large systems with 4 nodes and above + * A typical case is a 8 node system executing on two 8-cpu boxes. + * A box crash in one of the boxes will mean 4 nodes crashes. + * We want to be able to restart those four nodes to some + * extent in parallel. + * + * We will wait for a few seconds and then try again. + */ + takeOverPtr.p->toMasterStatus = TakeOverRecord::TO_WAIT_START_TAKE_OVER; + signal->theData[0] = DihContinueB::ZSTART_TAKE_OVER; + signal->theData[1] = takeOverPtr.i; + signal->theData[2] = startNode; + signal->theData[3] = nodeTakenOver; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 5000, 4); + return; + }//if + NGPtr.p->activeTakeOver = true; + if (startNode == nodeTakenOver) { + jam(); + switch (getNodeActiveStatus(nodeTakenOver)) { + case Sysfile::NS_Active: + case Sysfile::NS_ActiveMissed_1: + case Sysfile::NS_ActiveMissed_2: + jam(); + break; + case Sysfile::NS_NotActive_NotTakenOver: + case Sysfile::NS_TakeOver: + jam(); + setNodeActiveStatus(nodeTakenOver, Sysfile::NS_TakeOver); + break; + default: + ndbrequire(false); + }//switch + } else { + jam(); + setNodeActiveStatus(nodeTakenOver, Sysfile::NS_HotSpare); + setNodeActiveStatus(startNode, Sysfile::NS_TakeOver); + changeNodeGroups(startNode, nodeTakenOver); + }//if + setNodeRestartInfoBits(); + /* ---------------------------------------------------------------------- */ + /* WE SET THE RESTART INFORMATION TO INDICATE THAT WE ARE ABOUT TO TAKE */ + /* OVER THE FAILED NODE. WE SET THIS INFORMATION AND WAIT UNTIL THE */ + /* GLOBAL CHECKPOINT HAS WRITTEN THE RESTART INFORMATION. */ + /* ---------------------------------------------------------------------- */ + Sysfile::setTakeOverNode(takeOverPtr.p->toFailedNode, SYSFILE->takeOver, + startNode); + takeOverPtr.p->toMasterStatus = TakeOverRecord::TO_START_COPY; + + cstartGcpNow = true; +}//Dbdih::startTakeOver() + +void Dbdih::changeNodeGroups(Uint32 startNode, Uint32 nodeTakenOver) +{ + NodeRecordPtr startNodePtr; + NodeRecordPtr toNodePtr; + startNodePtr.i = startNode; + ptrCheckGuard(startNodePtr, MAX_NDB_NODES, nodeRecord); + toNodePtr.i = nodeTakenOver; + ptrCheckGuard(toNodePtr, MAX_NDB_NODES, nodeRecord); + ndbrequire(startNodePtr.p->nodeGroup == ZNIL); + NodeGroupRecordPtr NGPtr; + + NGPtr.i = toNodePtr.p->nodeGroup; + ptrCheckGuard(NGPtr, MAX_NDB_NODES, nodeGroupRecord); + bool nodeFound = false; + for (Uint32 i = 0; i < NGPtr.p->nodeCount; i++) { + jam(); + if (NGPtr.p->nodesInGroup[i] == nodeTakenOver) { + jam(); + NGPtr.p->nodesInGroup[i] = startNode; + nodeFound = true; + }//if + }//for + ndbrequire(nodeFound); + Sysfile::setNodeGroup(startNodePtr.i, SYSFILE->nodeGroups, toNodePtr.p->nodeGroup); + startNodePtr.p->nodeGroup = toNodePtr.p->nodeGroup; + Sysfile::setNodeGroup(toNodePtr.i, SYSFILE->nodeGroups, NO_NODE_GROUP_ID); + toNodePtr.p->nodeGroup = ZNIL; +}//Dbdih::changeNodeGroups() + +void Dbdih::checkToCopy() +{ + TakeOverRecordPtr takeOverPtr; + for (takeOverPtr.i = 0;takeOverPtr.i < MAX_NDB_NODES; takeOverPtr.i++) { + ptrAss(takeOverPtr, takeOverRecord); + /*----------------------------------------------------------------------*/ + // TAKE OVER HANDLING WRITES RESTART INFORMATION THROUGH + // THE GLOBAL CHECKPOINT + // PROTOCOL. WE CHECK HERE BEFORE STARTING A WRITE OF THE RESTART + // INFORMATION. + /*-----------------------------------------------------------------------*/ + if (takeOverPtr.p->toMasterStatus == TakeOverRecord::TO_START_COPY) { + jam(); + takeOverPtr.p->toMasterStatus = TakeOverRecord::TO_START_COPY_ONGOING; + } else if (takeOverPtr.p->toMasterStatus == TakeOverRecord::TO_END_COPY) { + jam(); + takeOverPtr.p->toMasterStatus = TakeOverRecord::TO_END_COPY_ONGOING; + }//if + }//for +}//Dbdih::checkToCopy() + +void Dbdih::checkToCopyCompleted(Signal* signal) +{ + /* ------------------------------------------------------------------------*/ + /* WE CHECK HERE IF THE WRITING OF TAKE OVER INFORMATION ALSO HAS BEEN */ + /* COMPLETED. */ + /* ------------------------------------------------------------------------*/ + TakeOverRecordPtr toPtr; + for (toPtr.i = 0; toPtr.i < MAX_NDB_NODES; toPtr.i++) { + ptrAss(toPtr, takeOverRecord); + if (toPtr.p->toMasterStatus == TakeOverRecord::TO_START_COPY_ONGOING){ + jam(); + sendStartTo(signal, toPtr.i); + } else if (toPtr.p->toMasterStatus == TakeOverRecord::TO_END_COPY_ONGOING){ + jam(); + sendEndTo(signal, toPtr.i); + } else { + jam(); + }//if + }//for +}//Dbdih::checkToCopyCompleted() + +bool Dbdih::checkToInterrupted(TakeOverRecordPtr& takeOverPtr) +{ + if (checkNodeAlive(takeOverPtr.p->toStartingNode)) { + jam(); + return false; + } else { + jam(); + endTakeOver(takeOverPtr.i); + return true; + }//if +}//Dbdih::checkToInterrupted() + +void Dbdih::sendStartTo(Signal* signal, Uint32 takeOverPtrI) +{ + TakeOverRecordPtr takeOverPtr; + CRASH_INSERTION(7155); + RETURN_IF_TAKE_OVER_INTERRUPTED(takeOverPtrI, takeOverPtr); + if ((c_startToLock != RNIL) || (ERROR_INSERTED(7158))) { + jam(); + takeOverPtr.p->toMasterStatus = TakeOverRecord::TO_WAIT_START; + signal->theData[0] = DihContinueB::ZSEND_START_TO; + signal->theData[1] = takeOverPtrI; + signal->theData[2] = takeOverPtr.p->toStartingNode; + signal->theData[3] = takeOverPtr.p->toFailedNode; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 30, 4); + return; + }//if + c_startToLock = takeOverPtrI; + StartToReq * const req = (StartToReq *)&signal->theData[0]; + req->userPtr = takeOverPtr.i; + req->userRef = reference(); + req->startingNodeId = takeOverPtr.p->toStartingNode; + req->nodeTakenOver = takeOverPtr.p->toFailedNode; + req->nodeRestart = takeOverPtr.p->toNodeRestart; + takeOverPtr.p->toMasterStatus = TakeOverRecord::STARTING; + sendLoopMacro(START_TOREQ, sendSTART_TOREQ); +}//Dbdih::sendStartTo() + +void Dbdih::execSTART_TOREQ(Signal* signal) +{ + TakeOverRecordPtr takeOverPtr; + jamEntry(); + const StartToReq * const req = (StartToReq *)&signal->theData[0]; + takeOverPtr.i = req->userPtr; + BlockReference ref = req->userRef; + Uint32 startingNode = req->startingNodeId; + + CRASH_INSERTION(7133); + RETURN_IF_NODE_NOT_ALIVE(req->startingNodeId); + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + allocateTakeOver(takeOverPtr); + initStartTakeOver(req, takeOverPtr); + + StartToConf * const conf = (StartToConf *)&signal->theData[0]; + conf->userPtr = takeOverPtr.i; + conf->sendingNodeId = cownNodeId; + conf->startingNodeId = startingNode; + sendSignal(ref, GSN_START_TOCONF, signal, StartToConf::SignalLength, JBB); +}//Dbdih::execSTART_TOREQ() + +void Dbdih::execSTART_TOCONF(Signal* signal) +{ + TakeOverRecordPtr takeOverPtr; + jamEntry(); + const StartToConf * const conf = (StartToConf *)&signal->theData[0]; + + CRASH_INSERTION(7147); + + RETURN_IF_NODE_NOT_ALIVE(conf->startingNodeId); + + takeOverPtr.i = conf->userPtr; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + ndbrequire(takeOverPtr.p->toMasterStatus == TakeOverRecord::STARTING); + ndbrequire(takeOverPtr.p->toStartingNode == conf->startingNodeId); + receiveLoopMacro(START_TOREQ, conf->sendingNodeId); + CRASH_INSERTION(7134); + c_startToLock = RNIL; + + startNextCopyFragment(signal, takeOverPtr.i); +}//Dbdih::execSTART_TOCONF() + +void Dbdih::initStartTakeOver(const StartToReq * req, + TakeOverRecordPtr takeOverPtr) +{ + takeOverPtr.p->toCurrentTabref = 0; + takeOverPtr.p->toCurrentFragid = 0; + takeOverPtr.p->toStartingNode = req->startingNodeId; + takeOverPtr.p->toFailedNode = req->nodeTakenOver; + takeOverPtr.p->toSlaveStatus = TakeOverRecord::TO_SLAVE_STARTED; + takeOverPtr.p->toCopyNode = RNIL; + takeOverPtr.p->toCurrentReplica = RNIL; + takeOverPtr.p->toNodeRestart = req->nodeRestart; +}//Dbdih::initStartTakeOver() + +void Dbdih::startNextCopyFragment(Signal* signal, Uint32 takeOverPtrI) +{ + TabRecordPtr tabPtr; + TakeOverRecordPtr takeOverPtr; + Uint32 loopCount; + RETURN_IF_TAKE_OVER_INTERRUPTED(takeOverPtrI, takeOverPtr); + takeOverPtr.p->toMasterStatus = TakeOverRecord::SELECTING_NEXT; + loopCount = 0; + if (ERROR_INSERTED(7159)) { + loopCount = 100; + }//if + while (loopCount++ < 100) { + tabPtr.i = takeOverPtr.p->toCurrentTabref; + if (tabPtr.i >= ctabFileSize) { + jam(); + CRASH_INSERTION(7136); + sendUpdateTo(signal, takeOverPtr.i, UpdateToReq::TO_COPY_COMPLETED); + return; + }//if + ptrAss(tabPtr, tabRecord); + if (tabPtr.p->tabStatus != TabRecord::TS_ACTIVE){ + jam(); + takeOverPtr.p->toCurrentFragid = 0; + takeOverPtr.p->toCurrentTabref++; + continue; + }//if + Uint32 fragId = takeOverPtr.p->toCurrentFragid; + if (fragId >= tabPtr.p->totalfragments) { + jam(); + takeOverPtr.p->toCurrentFragid = 0; + takeOverPtr.p->toCurrentTabref++; + if (ERROR_INSERTED(7135)) { + if (takeOverPtr.p->toCurrentTabref == 1) { + ndbrequire(false); + }//if + }//if + continue; + }//if + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, fragId, fragPtr); + ReplicaRecordPtr loopReplicaPtr; + loopReplicaPtr.i = fragPtr.p->oldStoredReplicas; + while (loopReplicaPtr.i != RNIL) { + ptrCheckGuard(loopReplicaPtr, creplicaFileSize, replicaRecord); + if (loopReplicaPtr.p->procNode == takeOverPtr.p->toFailedNode) { + jam(); + /* ----------------------------------------------------------------- */ + /* WE HAVE FOUND A REPLICA THAT BELONGED THE FAILED NODE THAT NEEDS */ + /* TAKE OVER. WE TAKE OVER THIS REPLICA TO THE NEW NODE. */ + /* ----------------------------------------------------------------- */ + takeOverPtr.p->toCurrentReplica = loopReplicaPtr.i; + toCopyFragLab(signal, takeOverPtr.i); + return; + } else if (loopReplicaPtr.p->procNode == takeOverPtr.p->toStartingNode) { + jam(); + /* ----------------------------------------------------------------- */ + /* WE HAVE OBVIOUSLY STARTED TAKING OVER THIS WITHOUT COMPLETING IT. */ + /* WE */ + /* NEED TO COMPLETE THE TAKE OVER OF THIS REPLICA. */ + /* ----------------------------------------------------------------- */ + takeOverPtr.p->toCurrentReplica = loopReplicaPtr.i; + toCopyFragLab(signal, takeOverPtr.i); + return; + } else { + jam(); + loopReplicaPtr.i = loopReplicaPtr.p->nextReplica; + }//if + }//while + takeOverPtr.p->toCurrentFragid++; + }//while + signal->theData[0] = DihContinueB::ZTO_START_COPY_FRAG; + signal->theData[1] = takeOverPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); +}//Dbdih::startNextCopyFragment() + +void Dbdih::toCopyFragLab(Signal* signal, + Uint32 takeOverPtrI) +{ + TakeOverRecordPtr takeOverPtr; + RETURN_IF_TAKE_OVER_INTERRUPTED(takeOverPtrI, takeOverPtr); + + CreateReplicaRecordPtr createReplicaPtr; + createReplicaPtr.i = 0; + ptrAss(createReplicaPtr, createReplicaRecord); + + ReplicaRecordPtr replicaPtr; + replicaPtr.i = takeOverPtr.p->toCurrentReplica; + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + + TabRecordPtr tabPtr; + tabPtr.i = takeOverPtr.p->toCurrentTabref; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + /* ----------------------------------------------------------------------- */ + /* WE HAVE FOUND A REPLICA THAT NEEDS TAKE OVER. WE WILL START THIS TAKE */ + /* OVER BY ADDING THE FRAGMENT WHEREAFTER WE WILL ORDER THE PRIMARY */ + /* REPLICA TO COPY ITS CONTENT TO THE NEW STARTING REPLICA. */ + /* THIS OPERATION IS A SINGLE USER OPERATION UNTIL WE HAVE SENT */ + /* COPY_FRAGREQ. AFTER SENDING COPY_FRAGREQ WE ARE READY TO START A NEW */ + /* FRAGMENT REPLICA. WE WILL NOT IMPLEMENT THIS IN THE FIRST PHASE. */ + /* ----------------------------------------------------------------------- */ + cnoOfCreateReplicas = 1; + createReplicaPtr.p->hotSpareUse = true; + createReplicaPtr.p->dataNodeId = takeOverPtr.p->toStartingNode; + + prepareSendCreateFragReq(signal, takeOverPtrI); +}//Dbdih::toCopyFragLab() + +void Dbdih::prepareSendCreateFragReq(Signal* signal, Uint32 takeOverPtrI) +{ + TakeOverRecordPtr takeOverPtr; + RETURN_IF_TAKE_OVER_INTERRUPTED(takeOverPtrI, takeOverPtr); + + TabRecordPtr tabPtr; + tabPtr.i = takeOverPtr.p->toCurrentTabref; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + FragmentstorePtr fragPtr; + + getFragstore(tabPtr.p, takeOverPtr.p->toCurrentFragid, fragPtr); + Uint32 nodes[MAX_REPLICAS]; + extractNodeInfo(fragPtr.p, nodes); + takeOverPtr.p->toCopyNode = nodes[0]; + sendCreateFragReq(signal, 0, CreateFragReq::STORED, takeOverPtr.i); +}//Dbdih::prepareSendCreateFragReq() + +void Dbdih::sendCreateFragReq(Signal* signal, + Uint32 startGci, + Uint32 replicaType, + Uint32 takeOverPtrI) +{ + TakeOverRecordPtr takeOverPtr; + RETURN_IF_TAKE_OVER_INTERRUPTED(takeOverPtrI, takeOverPtr); + if ((c_createFragmentLock != RNIL) || + ((ERROR_INSERTED(7161))&&(replicaType == CreateFragReq::STORED)) || + ((ERROR_INSERTED(7162))&&(replicaType == CreateFragReq::COMMIT_STORED))){ + if (replicaType == CreateFragReq::STORED) { + jam(); + takeOverPtr.p->toMasterStatus = TakeOverRecord::TO_WAIT_PREPARE_CREATE; + } else { + ndbrequire(replicaType == CreateFragReq::COMMIT_STORED); + jam(); + takeOverPtr.p->toMasterStatus = TakeOverRecord::TO_WAIT_COMMIT_CREATE; + }//if + signal->theData[0] = DihContinueB::ZSEND_CREATE_FRAG; + signal->theData[1] = takeOverPtr.i; + signal->theData[2] = replicaType; + signal->theData[3] = startGci; + signal->theData[4] = takeOverPtr.p->toStartingNode; + signal->theData[5] = takeOverPtr.p->toFailedNode; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 50, 6); + return; + }//if + c_createFragmentLock = takeOverPtr.i; + sendLoopMacro(CREATE_FRAGREQ, nullRoutine); + + CreateFragReq * const req = (CreateFragReq *)&signal->theData[0]; + req->userPtr = takeOverPtr.i; + req->userRef = reference(); + req->tableId = takeOverPtr.p->toCurrentTabref; + req->fragId = takeOverPtr.p->toCurrentFragid; + req->startingNodeId = takeOverPtr.p->toStartingNode; + req->copyNodeId = takeOverPtr.p->toCopyNode; + req->startGci = startGci; + req->replicaType = replicaType; + + NodeRecordPtr nodePtr; + nodePtr.i = cfirstAliveNode; + do { + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + BlockReference ref = calcDihBlockRef(nodePtr.i); + sendSignal(ref, GSN_CREATE_FRAGREQ, signal, + CreateFragReq::SignalLength, JBB); + nodePtr.i = nodePtr.p->nextNode; + } while (nodePtr.i != RNIL); + + if (replicaType == CreateFragReq::STORED) { + jam(); + takeOverPtr.p->toMasterStatus = TakeOverRecord::PREPARE_CREATE; + } else { + ndbrequire(replicaType == CreateFragReq::COMMIT_STORED); + jam(); + takeOverPtr.p->toMasterStatus = TakeOverRecord::COMMIT_CREATE; + } +}//Dbdih::sendCreateFragReq() + +/* --------------------------------------------------------------------------*/ +/* AN ORDER TO START OR COMMIT THE REPLICA CREATION ARRIVED FROM THE */ +/* MASTER. */ +/* --------------------------------------------------------------------------*/ +void Dbdih::execCREATE_FRAGREQ(Signal* signal) +{ + jamEntry(); + CreateFragReq * const req = (CreateFragReq *)&signal->theData[0]; + + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = req->userPtr; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + + BlockReference retRef = req->userRef; + + TabRecordPtr tabPtr; + tabPtr.i = req->tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + + Uint32 fragId = req->fragId; + Uint32 tdestNodeid = req->startingNodeId; + Uint32 tsourceNodeid = req->copyNodeId; + Uint32 startGci = req->startGci; + Uint32 replicaType = req->replicaType; + + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, fragId, fragPtr); + RETURN_IF_NODE_NOT_ALIVE(tdestNodeid); + ReplicaRecordPtr frReplicaPtr; + findToReplica(takeOverPtr.p, replicaType, fragPtr, frReplicaPtr); + ndbrequire(frReplicaPtr.i != RNIL); + + switch (replicaType) { + case CreateFragReq::STORED: + jam(); + CRASH_INSERTION(7138); + /* ----------------------------------------------------------------------*/ + /* HERE WE ARE INSERTING THE NEW BACKUP NODE IN THE EXECUTION OF ALL */ + /* OPERATIONS. FROM HERE ON ALL OPERATIONS ON THIS FRAGMENT WILL INCLUDE*/ + /* USE OF THE NEW REPLICA. */ + /* --------------------------------------------------------------------- */ + insertBackup(fragPtr, tdestNodeid); + takeOverPtr.p->toCopyNode = tsourceNodeid; + takeOverPtr.p->toSlaveStatus = TakeOverRecord::TO_SLAVE_CREATE_PREPARE; + + fragPtr.p->distributionKey++; + fragPtr.p->distributionKey &= 255; + break; + case CreateFragReq::COMMIT_STORED: + jam(); + CRASH_INSERTION(7139); + /* ----------------------------------------------------------------------*/ + /* HERE WE ARE MOVING THE REPLICA TO THE STORED SECTION SINCE IT IS NOW */ + /* FULLY LOADED WITH ALL DATA NEEDED. */ + // We also update the order of the replicas here so that if the new + // replica is the desired primary we insert it as primary. + /* ----------------------------------------------------------------------*/ + takeOverPtr.p->toSlaveStatus = TakeOverRecord::TO_SLAVE_CREATE_COMMIT; + removeOldStoredReplica(fragPtr, frReplicaPtr); + linkStoredReplica(fragPtr, frReplicaPtr); + updateNodeInfo(fragPtr); + break; + default: + ndbrequire(false); + break; + }//switch + + /* ------------------------------------------------------------------------*/ + /* THE NEW NODE OF THIS REPLICA IS THE STARTING NODE. */ + /* ------------------------------------------------------------------------*/ + if (frReplicaPtr.p->procNode != takeOverPtr.p->toStartingNode) { + jam(); + /* ---------------------------------------------------------------------*/ + /* IF WE ARE STARTING A TAKE OVER NODE WE MUST INVALIDATE ALL LCP'S. */ + /* OTHERWISE WE WILL TRY TO START LCP'S THAT DO NOT EXIST. */ + /* ---------------------------------------------------------------------*/ + frReplicaPtr.p->procNode = takeOverPtr.p->toStartingNode; + frReplicaPtr.p->noCrashedReplicas = 0; + frReplicaPtr.p->createGci[0] = startGci; + ndbrequire(startGci != 0xF1F1F1F1); + frReplicaPtr.p->replicaLastGci[0] = (Uint32)-1; + for (Uint32 i = 0; i < MAX_LCP_STORED; i++) { + frReplicaPtr.p->lcpStatus[i] = ZINVALID; + }//for + } else { + jam(); + const Uint32 noCrashed = frReplicaPtr.p->noCrashedReplicas; + arrGuard(noCrashed, 8); + frReplicaPtr.p->createGci[noCrashed] = startGci; + ndbrequire(startGci != 0xF1F1F1F1); + frReplicaPtr.p->replicaLastGci[noCrashed] = (Uint32)-1; + }//if + takeOverPtr.p->toCurrentTabref = tabPtr.i; + takeOverPtr.p->toCurrentFragid = fragId; + CreateFragConf * const conf = (CreateFragConf *)&signal->theData[0]; + conf->userPtr = takeOverPtr.i; + conf->tableId = tabPtr.i; + conf->fragId = fragId; + conf->sendingNodeId = cownNodeId; + conf->startingNodeId = tdestNodeid; + sendSignal(retRef, GSN_CREATE_FRAGCONF, signal, + CreateFragConf::SignalLength, JBB); +}//Dbdih::execCREATE_FRAGREQ() + +void Dbdih::execCREATE_FRAGCONF(Signal* signal) +{ + jamEntry(); + CRASH_INSERTION(7148); + const CreateFragConf * const conf = (CreateFragConf *)&signal->theData[0]; + Uint32 fragId = conf->fragId; + + RETURN_IF_NODE_NOT_ALIVE(conf->startingNodeId); + + TabRecordPtr tabPtr; + tabPtr.i = conf->tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = conf->userPtr; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + + ndbrequire(tabPtr.i == takeOverPtr.p->toCurrentTabref); + ndbrequire(fragId == takeOverPtr.p->toCurrentFragid); + receiveLoopMacro(CREATE_FRAGREQ, conf->sendingNodeId); + c_createFragmentLock = RNIL; + + if (takeOverPtr.p->toMasterStatus == TakeOverRecord::PREPARE_CREATE) { + jam(); + CRASH_INSERTION(7140); + /* --------------------------------------------------------------------- */ + /* ALL NODES HAVE PREPARED THE INTRODUCTION OF THIS NEW NODE AND IT IS */ + /* ALREADY IN USE. WE CAN NOW START COPYING THE FRAGMENT. */ + /*---------------------------------------------------------------------- */ + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, fragId, fragPtr); + takeOverPtr.p->toMasterStatus = TakeOverRecord::COPY_FRAG; + BlockReference ref = calcLqhBlockRef(takeOverPtr.p->toCopyNode); + CopyFragReq * const copyFragReq = (CopyFragReq *)&signal->theData[0]; + copyFragReq->userPtr = takeOverPtr.i; + copyFragReq->userRef = reference(); + copyFragReq->tableId = tabPtr.i; + copyFragReq->fragId = fragId; + copyFragReq->nodeId = takeOverPtr.p->toStartingNode; + copyFragReq->schemaVersion = tabPtr.p->schemaVersion; + copyFragReq->distributionKey = fragPtr.p->distributionKey; + sendSignal(ref, GSN_COPY_FRAGREQ, signal, CopyFragReq::SignalLength, JBB); + } else { + ndbrequire(takeOverPtr.p->toMasterStatus == TakeOverRecord::COMMIT_CREATE); + jam(); + CRASH_INSERTION(7141); + /* --------------------------------------------------------------------- */ + // REPORT that copy of fragment has been completed. + /* --------------------------------------------------------------------- */ + signal->theData[0] = EventReport::NR_CopyFragDone; + signal->theData[1] = takeOverPtr.p->toStartingNode; + signal->theData[2] = tabPtr.i; + signal->theData[3] = takeOverPtr.p->toCurrentFragid; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 4, JBB); + /* --------------------------------------------------------------------- */ + /* WE HAVE NOW CREATED THIS NEW REPLICA AND WE ARE READY TO TAKE THE */ + /* THE NEXT REPLICA. */ + /* --------------------------------------------------------------------- */ + + Mutex mutex(signal, c_mutexMgr, takeOverPtr.p->m_switchPrimaryMutexHandle); + mutex.unlock(); // ignore result + + takeOverPtr.p->toCurrentFragid++; + startNextCopyFragment(signal, takeOverPtr.i); + }//if +}//Dbdih::execCREATE_FRAGCONF() + +void Dbdih::execCOPY_FRAGREF(Signal* signal) +{ + const CopyFragRef * const ref = (CopyFragRef *)&signal->theData[0]; + jamEntry(); + Uint32 takeOverPtrI = ref->userPtr; + Uint32 startingNodeId = ref->startingNodeId; + Uint32 errorCode = ref->errorCode; + + TakeOverRecordPtr takeOverPtr; + RETURN_IF_TAKE_OVER_INTERRUPTED(takeOverPtrI, takeOverPtr); + ndbrequire(errorCode != ZNODE_FAILURE_ERROR); + ndbrequire(ref->tableId == takeOverPtr.p->toCurrentTabref); + ndbrequire(ref->fragId == takeOverPtr.p->toCurrentFragid); + ndbrequire(ref->startingNodeId == takeOverPtr.p->toStartingNode); + ndbrequire(ref->sendingNodeId == takeOverPtr.p->toCopyNode); + ndbrequire(takeOverPtr.p->toMasterStatus == TakeOverRecord::COPY_FRAG); + endTakeOver(takeOverPtrI); + //-------------------------------------------------------------------------- + // For some reason we did not succeed in copying a fragment. We treat this + // as a serious failure and crash the starting node. + //-------------------------------------------------------------------------- + BlockReference cntrRef = calcNdbCntrBlockRef(startingNodeId); + SystemError * const sysErr = (SystemError*)&signal->theData[0]; + sysErr->errorCode = SystemError::CopyFragRefError; + sysErr->errorRef = reference(); + sendSignal(cntrRef, GSN_SYSTEM_ERROR, signal, + SystemError::SignalLength, JBB); + return; +}//Dbdih::execCOPY_FRAGREF() + +void Dbdih::execCOPY_FRAGCONF(Signal* signal) +{ + const CopyFragConf * const conf = (CopyFragConf *)&signal->theData[0]; + jamEntry(); + CRASH_INSERTION(7142); + + TakeOverRecordPtr takeOverPtr; + Uint32 takeOverPtrI = conf->userPtr; + RETURN_IF_TAKE_OVER_INTERRUPTED(takeOverPtrI, takeOverPtr); + + ndbrequire(conf->tableId == takeOverPtr.p->toCurrentTabref); + ndbrequire(conf->fragId == takeOverPtr.p->toCurrentFragid); + ndbrequire(conf->startingNodeId == takeOverPtr.p->toStartingNode); + ndbrequire(conf->sendingNodeId == takeOverPtr.p->toCopyNode); + ndbrequire(takeOverPtr.p->toMasterStatus == TakeOverRecord::COPY_FRAG); + sendUpdateTo(signal, takeOverPtr.i, + (Uint32)UpdateToReq::TO_COPY_FRAG_COMPLETED); +}//Dbdih::execCOPY_FRAGCONF() + +void Dbdih::sendUpdateTo(Signal* signal, + Uint32 takeOverPtrI, Uint32 updateState) +{ + TakeOverRecordPtr takeOverPtr; + RETURN_IF_TAKE_OVER_INTERRUPTED(takeOverPtrI, takeOverPtr); + if ((c_updateToLock != RNIL) || + ((ERROR_INSERTED(7163)) && + (updateState == UpdateToReq::TO_COPY_FRAG_COMPLETED)) || + ((ERROR_INSERTED(7169)) && + (updateState == UpdateToReq::TO_COPY_COMPLETED))) { + jam(); + takeOverPtr.p->toMasterStatus = TakeOverRecord::TO_WAIT_UPDATE_TO; + signal->theData[0] = DihContinueB::ZSEND_UPDATE_TO; + signal->theData[1] = takeOverPtrI; + signal->theData[2] = takeOverPtr.p->toStartingNode; + signal->theData[3] = takeOverPtr.p->toFailedNode; + signal->theData[4] = updateState; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 30, 5); + return; + }//if + c_updateToLock = takeOverPtrI; + if (updateState == UpdateToReq::TO_COPY_FRAG_COMPLETED) { + jam(); + takeOverPtr.p->toMasterStatus = TakeOverRecord::TO_UPDATE_TO; + } else { + jam(); + ndbrequire(updateState == UpdateToReq::TO_COPY_COMPLETED); + takeOverPtr.p->toMasterStatus = TakeOverRecord::TO_COPY_COMPLETED; + }//if + + UpdateToReq * const req = (UpdateToReq *)&signal->theData[0]; + req->userPtr = takeOverPtr.i; + req->userRef = reference(); + req->updateState = (UpdateToReq::UpdateState)updateState; + req->startingNodeId = takeOverPtr.p->toStartingNode; + req->tableId = takeOverPtr.p->toCurrentTabref; + req->fragmentNo = takeOverPtr.p->toCurrentFragid; + sendLoopMacro(UPDATE_TOREQ, sendUPDATE_TOREQ); +}//Dbdih::sendUpdateTo() + +void Dbdih::execUPDATE_TOREQ(Signal* signal) +{ + jamEntry(); + const UpdateToReq * const req = (UpdateToReq *)&signal->theData[0]; + BlockReference ref = req->userRef; + ndbrequire(cmasterdihref == ref); + + CRASH_INSERTION(7154); + RETURN_IF_NODE_NOT_ALIVE(req->startingNodeId); + + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = req->userPtr; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + + ndbrequire(req->startingNodeId == takeOverPtr.p->toStartingNode); + if (req->updateState == UpdateToReq::TO_COPY_FRAG_COMPLETED) { + jam(); + ndbrequire(takeOverPtr.p->toSlaveStatus == TakeOverRecord::TO_SLAVE_CREATE_PREPARE); + takeOverPtr.p->toSlaveStatus = TakeOverRecord::TO_SLAVE_COPY_FRAG_COMPLETED; + takeOverPtr.p->toCurrentTabref = req->tableId; + takeOverPtr.p->toCurrentFragid = req->fragmentNo; + } else { + jam(); + ndbrequire(req->updateState == UpdateToReq::TO_COPY_COMPLETED); + takeOverPtr.p->toSlaveStatus = TakeOverRecord::TO_SLAVE_COPY_COMPLETED; + setNodeCopyCompleted(takeOverPtr.p->toStartingNode, true); + }//if + + + UpdateToConf * const conf = (UpdateToConf *)&signal->theData[0]; + conf->userPtr = takeOverPtr.i; + conf->sendingNodeId = cownNodeId; + conf->startingNodeId = takeOverPtr.p->toStartingNode; + sendSignal(ref, GSN_UPDATE_TOCONF, signal, UpdateToConf::SignalLength, JBB); +}//Dbdih::execUPDATE_TOREQ() + +void Dbdih::execUPDATE_TOCONF(Signal* signal) +{ + const UpdateToConf * const conf = (UpdateToConf *)&signal->theData[0]; + CRASH_INSERTION(7152); + + RETURN_IF_NODE_NOT_ALIVE(conf->startingNodeId); + + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = conf->userPtr; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + + receiveLoopMacro(UPDATE_TOREQ, conf->sendingNodeId); + CRASH_INSERTION(7153); + c_updateToLock = RNIL; + + if (takeOverPtr.p->toMasterStatus == TakeOverRecord::TO_COPY_COMPLETED) { + jam(); + toCopyCompletedLab(signal, takeOverPtr); + return; + } else { + ndbrequire(takeOverPtr.p->toMasterStatus == TakeOverRecord::TO_UPDATE_TO); + }//if + TabRecordPtr tabPtr; + tabPtr.i = takeOverPtr.p->toCurrentTabref; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, takeOverPtr.p->toCurrentFragid, fragPtr); + takeOverPtr.p->toMasterStatus = TakeOverRecord::COPY_ACTIVE; + BlockReference lqhRef = calcLqhBlockRef(takeOverPtr.p->toStartingNode); + CopyActiveReq * const req = (CopyActiveReq *)&signal->theData[0]; + req->userPtr = takeOverPtr.i; + req->userRef = reference(); + req->tableId = takeOverPtr.p->toCurrentTabref; + req->fragId = takeOverPtr.p->toCurrentFragid; + req->distributionKey = fragPtr.p->distributionKey; + + sendSignal(lqhRef, GSN_COPY_ACTIVEREQ, signal, + CopyActiveReq::SignalLength, JBB); +}//Dbdih::execUPDATE_TOCONF() + +void Dbdih::execCOPY_ACTIVECONF(Signal* signal) +{ + const CopyActiveConf * const conf = (CopyActiveConf *)&signal->theData[0]; + jamEntry(); + CRASH_INSERTION(7143); + + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = conf->userPtr; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + + ndbrequire(conf->tableId == takeOverPtr.p->toCurrentTabref); + ndbrequire(conf->fragId == takeOverPtr.p->toCurrentFragid); + ndbrequire(checkNodeAlive(conf->startingNodeId)); + ndbrequire(takeOverPtr.p->toMasterStatus == TakeOverRecord::COPY_ACTIVE); + + takeOverPtr.p->startGci = conf->startGci; + takeOverPtr.p->toMasterStatus = TakeOverRecord::LOCK_MUTEX; + + Mutex mutex(signal, c_mutexMgr, takeOverPtr.p->m_switchPrimaryMutexHandle); + Callback c = { safe_cast(&Dbdih::switchPrimaryMutex_locked), takeOverPtr.i }; + ndbrequire(mutex.lock(c)); +}//Dbdih::execCOPY_ACTIVECONF() + +void +Dbdih::switchPrimaryMutex_locked(Signal* signal, Uint32 toPtrI, Uint32 retVal){ + jamEntry(); + ndbrequire(retVal == 0); + + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = toPtrI; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + + ndbrequire(takeOverPtr.p->toMasterStatus == TakeOverRecord::LOCK_MUTEX); + + if (!checkNodeAlive((takeOverPtr.p->toStartingNode))) { + // We have mutex + Mutex mutex(signal, c_mutexMgr, takeOverPtr.p->m_switchPrimaryMutexHandle); + mutex.unlock(); // Ignore result + + c_createFragmentLock = RNIL; + c_CREATE_FRAGREQ_Counter.clearWaitingFor(); + endTakeOver(takeOverPtr.i); + return; + } + + takeOverPtr.p->toMasterStatus = TakeOverRecord::COMMIT_CREATE; + sendCreateFragReq(signal, takeOverPtr.p->startGci, + CreateFragReq::COMMIT_STORED, takeOverPtr.i); +} + +void Dbdih::toCopyCompletedLab(Signal * signal, TakeOverRecordPtr takeOverPtr) +{ + signal->theData[0] = EventReport::NR_CopyFragsCompleted; + signal->theData[1] = takeOverPtr.p->toStartingNode; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); + + c_lcpState.immediateLcpStart = true; + takeOverPtr.p->toMasterStatus = TakeOverRecord::WAIT_LCP; + + /*-----------------------------------------------------------------------*/ + /* NOW WE CAN ALLOW THE NEW NODE TO PARTICIPATE IN LOCAL CHECKPOINTS. */ + /* WHEN THE FIRST LOCAL CHECKPOINT IS READY WE DECLARE THE TAKE OVER AS */ + /* COMPLETED. SINCE LOCAL CHECKPOINTS HAVE BEEN BLOCKED DURING THE COPY */ + /* PROCESS WE MUST ALSO START A NEW LOCAL CHECKPOINT PROCESS BY ENSURING */ + /* THAT IT LOOKS LIKE IT IS TIME FOR A NEW LOCAL CHECKPOINT AND BY */ + /* UNBLOCKING THE LOCAL CHECKPOINT AGAIN. */ + /* --------------------------------------------------------------------- */ +}//Dbdih::toCopyCompletedLab() + +void Dbdih::sendEndTo(Signal* signal, Uint32 takeOverPtrI) +{ + TakeOverRecordPtr takeOverPtr; + CRASH_INSERTION(7156); + RETURN_IF_TAKE_OVER_INTERRUPTED(takeOverPtrI, takeOverPtr); + if ((c_endToLock != RNIL) || (ERROR_INSERTED(7164))) { + jam(); + takeOverPtr.p->toMasterStatus = TakeOverRecord::TO_WAIT_ENDING; + signal->theData[0] = DihContinueB::ZSEND_END_TO; + signal->theData[1] = takeOverPtrI; + signal->theData[2] = takeOverPtr.p->toStartingNode; + signal->theData[3] = takeOverPtr.p->toFailedNode; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 30, 4); + return; + }//if + c_endToLock = takeOverPtr.i; + takeOverPtr.p->toMasterStatus = TakeOverRecord::ENDING; + EndToReq * const req = (EndToReq *)&signal->theData[0]; + req->userPtr = takeOverPtr.i; + req->userRef = reference(); + req->startingNodeId = takeOverPtr.p->toStartingNode; + sendLoopMacro(END_TOREQ, sendEND_TOREQ); +}//Dbdih::sendStartTo() + +void Dbdih::execEND_TOREQ(Signal* signal) +{ + jamEntry(); + const EndToReq * const req = (EndToReq *)&signal->theData[0]; + BlockReference ref = req->userRef; + Uint32 startingNodeId = req->startingNodeId; + + CRASH_INSERTION(7144); + RETURN_IF_NODE_NOT_ALIVE(startingNodeId); + + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = req->userPtr; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + + ndbrequire(startingNodeId == takeOverPtr.p->toStartingNode); + takeOverPtr.p->toSlaveStatus = TakeOverRecord::TO_SLAVE_IDLE; + + if (!isMaster()) { + jam(); + endTakeOver(takeOverPtr.i); + }//if + + EndToConf * const conf = (EndToConf *)&signal->theData[0]; + conf->userPtr = takeOverPtr.i; + conf->sendingNodeId = cownNodeId; + conf->startingNodeId = startingNodeId; + sendSignal(ref, GSN_END_TOCONF, signal, EndToConf::SignalLength, JBB); +}//Dbdih::execEND_TOREQ() + +void Dbdih::execEND_TOCONF(Signal* signal) +{ + const EndToConf * const conf = (EndToConf *)&signal->theData[0]; + jamEntry(); + + const Uint32 nodeId = conf->startingNodeId; + CRASH_INSERTION(7145); + + RETURN_IF_NODE_NOT_ALIVE(nodeId); + + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = conf->userPtr; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + + ndbrequire(takeOverPtr.p->toMasterStatus == TakeOverRecord::ENDING); + ndbrequire(nodeId == takeOverPtr.p->toStartingNode); + + receiveLoopMacro(END_TOREQ, conf->sendingNodeId); + CRASH_INSERTION(7146); + c_endToLock = RNIL; + + /* -----------------------------------------------------------------------*/ + /* WE HAVE FINALLY COMPLETED THE TAKE OVER. WE RESET THE STATUS AND CHECK*/ + /* IF ANY MORE TAKE OVERS ARE NEEDED AT THE MOMENT. */ + /* FIRST WE CHECK IF A RESTART IS ONGOING. IN THAT CASE WE RESTART PHASE */ + /* 4 AND CHECK IF ANY MORE TAKE OVERS ARE NEEDED BEFORE WE START NDB */ + /* CLUSTER. THIS CAN ONLY HAPPEN IN A SYSTEM RESTART. */ + /* ---------------------------------------------------------------------- */ + if (takeOverPtr.p->toNodeRestart) { + jam(); + /* ----------------------------------------------------------------------*/ + /* THE TAKE OVER NODE WAS A STARTING NODE. WE WILL SEND START_COPYCONF */ + /* TO THE STARTING NODE SUCH THAT THE NODE CAN COMPLETE THE START-UP. */ + /* --------------------------------------------------------------------- */ + BlockReference ref = calcDihBlockRef(takeOverPtr.p->toStartingNode); + signal->theData[0] = takeOverPtr.p->toStartingNode; + sendSignal(ref, GSN_START_COPYCONF, signal, 1,JBB); + }//if + endTakeOver(takeOverPtr.i); + + ndbout_c("2 - endTakeOver"); + if (cstartPhase == ZNDB_SPH4) { + jam(); + ndbrequire(false); + if (anyActiveTakeOver()) { + jam(); + ndbout_c("4 - anyActiveTakeOver == true"); + return; + }//if + ndbout_c("5 - anyActiveTakeOver == false -> ndbsttorry10Lab"); + ndbsttorry10Lab(signal, __LINE__); + return; + }//if + checkStartTakeOver(signal); +}//Dbdih::execEND_TOCONF() + +void Dbdih::allocateTakeOver(TakeOverRecordPtr& takeOverPtr) +{ + if (isMaster()) { + jam(); + //-------------------------------------------- + // Master already seized the take over record. + //-------------------------------------------- + return; + }//if + if (takeOverPtr.i == cfirstfreeTakeOver) { + jam(); + seizeTakeOver(takeOverPtr); + } else { + TakeOverRecordPtr nextTakeOverptr; + TakeOverRecordPtr prevTakeOverptr; + nextTakeOverptr.i = takeOverPtr.p->nextTakeOver; + prevTakeOverptr.i = takeOverPtr.p->prevTakeOver; + if (prevTakeOverptr.i != RNIL) { + jam(); + ptrCheckGuard(prevTakeOverptr, MAX_NDB_NODES, takeOverRecord); + prevTakeOverptr.p->nextTakeOver = nextTakeOverptr.i; + }//if + if (nextTakeOverptr.i != RNIL) { + jam(); + ptrCheckGuard(nextTakeOverptr, MAX_NDB_NODES, takeOverRecord); + nextTakeOverptr.p->prevTakeOver = prevTakeOverptr.i; + }//if + }//if +}//Dbdih::allocateTakeOver() + +void Dbdih::seizeTakeOver(TakeOverRecordPtr& takeOverPtr) +{ + TakeOverRecordPtr nextTakeOverptr; + ndbrequire(cfirstfreeTakeOver != RNIL); + takeOverPtr.i = cfirstfreeTakeOver; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + cfirstfreeTakeOver = takeOverPtr.p->nextTakeOver; + nextTakeOverptr.i = takeOverPtr.p->nextTakeOver; + if (nextTakeOverptr.i != RNIL) { + jam(); + ptrCheckGuard(nextTakeOverptr, MAX_NDB_NODES, takeOverRecord); + nextTakeOverptr.p->prevTakeOver = RNIL; + }//if + takeOverPtr.p->nextTakeOver = RNIL; + takeOverPtr.p->prevTakeOver = RNIL; +}//Dbdih::seizeTakeOver() + +void Dbdih::endTakeOver(Uint32 takeOverPtrI) +{ + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = takeOverPtrI; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + + releaseTakeOver(takeOverPtrI); + if ((takeOverPtr.p->toMasterStatus != TakeOverRecord::IDLE) && + (takeOverPtr.p->toMasterStatus != TakeOverRecord::TO_WAIT_START_TAKE_OVER)) { + jam(); + NodeGroupRecordPtr NGPtr; + NodeRecordPtr nodePtr; + nodePtr.i = takeOverPtr.p->toStartingNode; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + NGPtr.i = nodePtr.p->nodeGroup; + ptrCheckGuard(NGPtr, MAX_NDB_NODES, nodeGroupRecord); + NGPtr.p->activeTakeOver = false; + }//if + setAllowNodeStart(takeOverPtr.p->toStartingNode, true); + initTakeOver(takeOverPtr); +}//Dbdih::endTakeOver() + +void Dbdih::releaseTakeOver(Uint32 takeOverPtrI) +{ + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = takeOverPtrI; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + + takeOverPtr.p->nextTakeOver = cfirstfreeTakeOver; + cfirstfreeTakeOver = takeOverPtr.i; +}//Dbdih::releaseTakeOver() + +void Dbdih::initTakeOver(TakeOverRecordPtr takeOverPtr) +{ + takeOverPtr.p->toCopyNode = RNIL; + takeOverPtr.p->toCurrentFragid = RNIL; + takeOverPtr.p->toCurrentReplica = RNIL; + takeOverPtr.p->toCurrentTabref = RNIL; + takeOverPtr.p->toFailedNode = RNIL; + takeOverPtr.p->toStartingNode = RNIL; + takeOverPtr.p->prevTakeOver = RNIL; + takeOverPtr.p->nextTakeOver = RNIL; + takeOverPtr.p->toNodeRestart = false; + takeOverPtr.p->toMasterStatus = TakeOverRecord::IDLE; + takeOverPtr.p->toSlaveStatus = TakeOverRecord::TO_SLAVE_IDLE; +}//Dbdih::initTakeOver() + +bool Dbdih::anyActiveTakeOver() +{ + TakeOverRecordPtr takeOverPtr; + for (takeOverPtr.i = 0; takeOverPtr.i < MAX_NDB_NODES; takeOverPtr.i++) { + ptrAss(takeOverPtr, takeOverRecord); + if (takeOverPtr.p->toMasterStatus != TakeOverRecord::IDLE) { + jam(); + return true; + }//if + }//for + return false; +}//Dbdih::anyActiveTakeOver() + +/*****************************************************************************/ +/* ------------------------------------------------------------------------- */ +/* WE HAVE BEEN REQUESTED TO PERFORM A SYSTEM RESTART. WE START BY */ +/* READING THE GCI FILES. THIS REQUEST WILL ONLY BE SENT TO THE MASTER */ +/* DIH. THAT MEANS WE HAVE TO REPLICATE THE INFORMATION WE READ FROM */ +/* OUR FILES TO ENSURE THAT ALL NODES HAVE THE SAME DISTRIBUTION */ +/* INFORMATION. */ +/* ------------------------------------------------------------------------- */ +/*****************************************************************************/ +void Dbdih::readGciFileLab(Signal* signal) +{ + FileRecordPtr filePtr; + filePtr.i = crestartInfoFile[0]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + filePtr.p->reqStatus = FileRecord::OPENING_GCP; + openFileRw(signal, filePtr); +}//Dbdih::readGciFileLab() + +void Dbdih::openingGcpLab(Signal* signal, FileRecordPtr filePtr) +{ + /* ----------------------------------------------------------------------- */ + /* WE HAVE SUCCESSFULLY OPENED A FILE CONTAINING INFORMATION ABOUT */ + /* THE GLOBAL CHECKPOINTS THAT ARE POSSIBLE TO RESTART. */ + /* ----------------------------------------------------------------------- */ + readRestorableGci(signal, filePtr); + filePtr.p->reqStatus = FileRecord::READING_GCP; +}//Dbdih::openingGcpLab() + +void Dbdih::readingGcpLab(Signal* signal, FileRecordPtr filePtr) +{ + /* ----------------------------------------------------------------------- */ + /* WE HAVE NOW SUCCESSFULLY MANAGED TO READ IN THE GLOBAL CHECKPOINT */ + /* INFORMATION FROM FILE. LATER WE WILL ADD SOME FUNCTIONALITY THAT */ + /* CHECKS THE RESTART TIMERS TO DEDUCE FROM WHERE TO RESTART. */ + /* NOW WE WILL SIMPLY RESTART FROM THE NEWEST GLOBAL CHECKPOINT */ + /* POSSIBLE TO RESTORE. */ + /* */ + /* BEFORE WE INVOKE DICT WE NEED TO COPY CRESTART_INFO TO ALL NODES. */ + /* WE ALSO COPY TO OUR OWN NODE. TO ENABLE US TO DO THIS PROPERLY WE */ + /* START BY CLOSING THIS FILE. */ + /* ----------------------------------------------------------------------- */ + closeFile(signal, filePtr); + filePtr.p->reqStatus = FileRecord::CLOSING_GCP; +}//Dbdih::readingGcpLab() + +void Dbdih::closingGcpLab(Signal* signal, FileRecordPtr filePtr) +{ + if (Sysfile::getInitialStartOngoing(SYSFILE->systemRestartBits) == false){ + jam(); + selectMasterCandidateAndSend(signal); + return; + } else { + jam(); + sendSignal(cntrlblockref, GSN_DIH_RESTARTREF, signal, 1, JBB); + return; + }//if +}//Dbdih::closingGcpLab() + +/* ------------------------------------------------------------------------- */ +/* SELECT THE MASTER CANDIDATE TO BE USED IN SYSTEM RESTARTS. */ +/* ------------------------------------------------------------------------- */ +void Dbdih::selectMasterCandidateAndSend(Signal* signal) +{ + Uint32 gci = 0; + Uint32 masterCandidateId = 0; + NodeRecordPtr nodePtr; + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRecord); + if (SYSFILE->lastCompletedGCI[nodePtr.i] > gci) { + jam(); + masterCandidateId = nodePtr.i; + gci = SYSFILE->lastCompletedGCI[nodePtr.i]; + }//if + }//for + ndbrequire(masterCandidateId != 0); + signal->theData[0] = masterCandidateId; + signal->theData[1] = gci; + sendSignal(cntrlblockref, GSN_DIH_RESTARTCONF, signal, 2, JBB); +}//Dbdih::selectMasterCandidate() + +/* ------------------------------------------------------------------------- */ +/* ERROR HANDLING DURING READING RESTORABLE GCI FROM FILE. */ +/* ------------------------------------------------------------------------- */ +void Dbdih::openingGcpErrorLab(Signal* signal, FileRecordPtr filePtr) +{ + filePtr.p->fileStatus = FileRecord::CRASHED; + filePtr.p->reqStatus = FileRecord::IDLE; + if (crestartInfoFile[0] == filePtr.i) { + jam(); + /* --------------------------------------------------------------------- */ + /* THE FIRST FILE WAS NOT ABLE TO BE OPENED. SET STATUS TO CRASHED AND */ + /* TRY OPEN THE NEXT FILE. */ + /* --------------------------------------------------------------------- */ + filePtr.i = crestartInfoFile[1]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + openFileRw(signal, filePtr); + filePtr.p->reqStatus = FileRecord::OPENING_GCP; + } else { + jam(); + /* --------------------------------------------------------------------- */ + /* WE FAILED IN OPENING THE SECOND FILE. BOTH FILES WERE CORRUPTED. WE */ + /* CANNOT CONTINUE THE RESTART IN THIS CASE. TELL NDBCNTR OF OUR */ + /* FAILURE. */ + /*---------------------------------------------------------------------- */ + sendSignal(cntrlblockref, GSN_DIH_RESTARTREF, signal, 1, JBB); + return; + }//if +}//Dbdih::openingGcpErrorLab() + +void Dbdih::readingGcpErrorLab(Signal* signal, FileRecordPtr filePtr) +{ + filePtr.p->fileStatus = FileRecord::CRASHED; + /* ----------------------------------------------------------------------- */ + /* WE FAILED IN READING THE FILE AS WELL. WE WILL CLOSE THIS FILE. */ + /* ----------------------------------------------------------------------- */ + closeFile(signal, filePtr); + filePtr.p->reqStatus = FileRecord::CLOSING_GCP_CRASH; +}//Dbdih::readingGcpErrorLab() + +void Dbdih::closingGcpCrashLab(Signal* signal, FileRecordPtr filePtr) +{ + if (crestartInfoFile[0] == filePtr.i) { + jam(); + /* --------------------------------------------------------------------- */ + /* ERROR IN FIRST FILE, TRY THE SECOND FILE. */ + /* --------------------------------------------------------------------- */ + filePtr.i = crestartInfoFile[1]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + openFileRw(signal, filePtr); + filePtr.p->reqStatus = FileRecord::OPENING_GCP; + return; + }//if + /* ----------------------------------------------------------------------- */ + /* WE DISCOVERED A FAILURE WITH THE SECOND FILE AS WELL. THIS IS A */ + /* SERIOUS PROBLEM. REPORT FAILURE TO NDBCNTR. */ + /* ----------------------------------------------------------------------- */ + sendSignal(cntrlblockref, GSN_DIH_RESTARTREF, signal, 1, JBB); +}//Dbdih::closingGcpCrashLab() + +/*****************************************************************************/ +/* ------------------------------------------------------------------------- */ +/* THIS IS AN INITIAL RESTART. WE WILL CREATE THE TWO FILES DESCRIBING */ +/* THE GLOBAL CHECKPOINTS THAT ARE RESTORABLE. */ +/* ------------------------------------------------------------------------- */ +/*****************************************************************************/ +void Dbdih::initGciFilesLab(Signal* signal) +{ + FileRecordPtr filePtr; + filePtr.i = crestartInfoFile[0]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + createFileRw(signal, filePtr); + filePtr.p->reqStatus = FileRecord::CREATING_GCP; +}//Dbdih::initGciFilesLab() + +/* ------------------------------------------------------------------------- */ +/* GLOBAL CHECKPOINT FILE HAVE BEEN SUCCESSFULLY CREATED. */ +/* ------------------------------------------------------------------------- */ +void Dbdih::creatingGcpLab(Signal* signal, FileRecordPtr filePtr) +{ + if (filePtr.i == crestartInfoFile[0]) { + jam(); + /* --------------------------------------------------------------------- */ + /* IF CREATED FIRST THEN ALSO CREATE THE SECOND FILE. */ + /* --------------------------------------------------------------------- */ + filePtr.i = crestartInfoFile[1]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + createFileRw(signal, filePtr); + filePtr.p->reqStatus = FileRecord::CREATING_GCP; + } else { + jam(); + /* --------------------------------------------------------------------- */ + /* BOTH FILES HAVE BEEN CREATED. NOW WRITE THE INITIAL DATA TO BOTH */ + /* OF THE FILES. */ + /* --------------------------------------------------------------------- */ + filePtr.i = crestartInfoFile[0]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + writeRestorableGci(signal, filePtr); + filePtr.p->reqStatus = FileRecord::WRITE_INIT_GCP; + }//if +}//Dbdih::creatingGcpLab() + +/* ------------------------------------------------------------------------- */ +/* WE HAVE SUCCESSFULLY WRITTEN A GCI FILE. */ +/* ------------------------------------------------------------------------- */ +void Dbdih::writeInitGcpLab(Signal* signal, FileRecordPtr filePtr) +{ + filePtr.p->reqStatus = FileRecord::IDLE; + if (filePtr.i == crestartInfoFile[0]) { + jam(); + /* --------------------------------------------------------------------- */ + /* WE HAVE WRITTEN THE FIRST FILE NOW ALSO WRITE THE SECOND FILE. */ + /* --------------------------------------------------------------------- */ + filePtr.i = crestartInfoFile[1]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + writeRestorableGci(signal, filePtr); + filePtr.p->reqStatus = FileRecord::WRITE_INIT_GCP; + } else { + /* --------------------------------------------------------------------- */ + /* WE HAVE WRITTEN BOTH FILES. LEAVE BOTH FILES OPEN AND CONFIRM OUR */ + /* PART OF THE INITIAL START. */ + /* --------------------------------------------------------------------- */ + if (isMaster()) { + jam(); + /*---------------------------------------------------------------------*/ + // IN MASTER NODES THE START REQUEST IS RECEIVED FROM NDBCNTR AND WE MUST + // RESPOND WHEN COMPLETED. + /*---------------------------------------------------------------------*/ + signal->theData[0] = reference(); + sendSignal(cndbStartReqBlockref, GSN_NDB_STARTCONF, signal, 1, JBB); + } else { + jam(); + ndbsttorry10Lab(signal, __LINE__); + return; + }//if + }//if +}//Dbdih::writeInitGcpLab() + +/*****************************************************************************/ +/* ********** NODES DELETION MODULE *************/ +/*****************************************************************************/ +/*---------------------------------------------------------------------------*/ +/* LOGIC FOR NODE FAILURE */ +/*---------------------------------------------------------------------------*/ +void Dbdih::execNODE_FAILREP(Signal* signal) +{ + Uint32 failedNodes[MAX_NDB_NODES]; + jamEntry(); + NodeFailRep * const nodeFail = (NodeFailRep *)&signal->theData[0]; + + cfailurenr = nodeFail->failNo; + Uint32 newMasterId = nodeFail->masterNodeId; + const Uint32 noOfFailedNodes = nodeFail->noOfNodes; + + /*-------------------------------------------------------------------------*/ + // The first step is to convert from a bit mask to an array of failed nodes. + /*-------------------------------------------------------------------------*/ + Uint32 index = 0; + for (Uint32 i = 1; i < MAX_NDB_NODES; i++) { + jam(); + if(NodeBitmask::get(nodeFail->theNodes, i)){ + jam(); + failedNodes[index] = i; + index++; + }//if + }//for + ndbrequire(noOfFailedNodes == index); + ndbrequire(noOfFailedNodes - 1 < MAX_NDB_NODES); + + /*-------------------------------------------------------------------------*/ + // The second step is to update the node status of the failed nodes, remove + // them from the alive node list and put them into the dead node list. Also + // update the number of nodes on-line. + // We also set certain state variables ensuring that the node no longer is + // used in transactions and also mark that we received this signal. + /*-------------------------------------------------------------------------*/ + for (Uint32 i = 0; i < noOfFailedNodes; i++) { + jam(); + NodeRecordPtr TNodePtr; + TNodePtr.i = failedNodes[i]; + ptrCheckGuard(TNodePtr, MAX_NDB_NODES, nodeRecord); + TNodePtr.p->useInTransactions = false; + TNodePtr.p->m_inclDihLcp = false; + TNodePtr.p->recNODE_FAILREP = ZTRUE; + if (TNodePtr.p->nodeStatus == NodeRecord::ALIVE) { + jam(); + con_lineNodes--; + TNodePtr.p->nodeStatus = NodeRecord::DIED_NOW; + removeAlive(TNodePtr); + insertDeadNode(TNodePtr); + }//if + }//for + + /*-------------------------------------------------------------------------*/ + // Verify that we can continue to operate the cluster. If we cannot we will + // not return from checkEscalation. + /*-------------------------------------------------------------------------*/ + checkEscalation(); + + /*------------------------------------------------------------------------*/ + // Verify that a starting node has also crashed. Reset the node start record. + /*-------------------------------------------------------------------------*/ + if (c_nodeStartMaster.startNode != RNIL) { + ndbrequire(getNodeStatus(c_nodeStartMaster.startNode)!= NodeRecord::ALIVE); + }//if + + /*--------------------------------------------------*/ + /* */ + /* WE CHANGE THE REFERENCE TO MASTER DIH */ + /* BLOCK AND POINTER AT THIS PLACE IN THE CODE*/ + /*--------------------------------------------------*/ + Uint32 oldMasterId = cmasterNodeId; + BlockReference oldMasterRef = cmasterdihref; + cmasterdihref = calcDihBlockRef(newMasterId); + cmasterNodeId = newMasterId; + + const bool masterTakeOver = (oldMasterId != newMasterId); + + for(Uint32 i = 0; i < noOfFailedNodes; i++) { + NodeRecordPtr failedNodePtr; + failedNodePtr.i = failedNodes[i]; + ptrCheckGuard(failedNodePtr, MAX_NDB_NODES, nodeRecord); + Uint32 activeTakeOverPtr = findTakeOver(failedNodes[i]); + if (oldMasterRef == reference()) { + /*-------------------------------------------------------*/ + // Functions that need to be called only for master nodes. + /*-------------------------------------------------------*/ + checkCopyTab(failedNodePtr); + checkStopPermMaster(signal, failedNodePtr); + checkWaitGCPMaster(signal, failedNodes[i]); + checkTakeOverInMasterAllNodeFailure(signal, failedNodePtr); + checkTakeOverInMasterCopyNodeFailure(signal, failedNodePtr.i); + checkTakeOverInMasterStartNodeFailure(signal, activeTakeOverPtr); + checkGcpOutstanding(signal, failedNodePtr.i); + } else { + jam(); + /*-----------------------------------------------------------*/ + // Functions that need to be called only for nodes that were + // not master before these failures. + /*-----------------------------------------------------------*/ + checkStopPermProxy(signal, failedNodes[i]); + checkWaitGCPProxy(signal, failedNodes[i]); + if (isMaster()) { + /*-----------------------------------------------------------*/ + // We take over as master since old master has failed + /*-----------------------------------------------------------*/ + handleTakeOverNewMaster(signal, activeTakeOverPtr); + } else { + /*-----------------------------------------------------------*/ + // We are not master and will not become master. + /*-----------------------------------------------------------*/ + checkTakeOverInNonMasterStartNodeFailure(signal, activeTakeOverPtr); + }//if + }//if + /*--------------------------------------------------*/ + // Functions that need to be called for all nodes. + /*--------------------------------------------------*/ + checkStopMe(signal, failedNodePtr); + failedNodeLcpHandling(signal, failedNodePtr); + checkWaitDropTabFailedLqh(signal, failedNodePtr.i, 0); // 0 = start w/ tab 0 + startRemoveFailedNode(signal, failedNodePtr); + + /** + * This is the last function called + * It modifies failedNodePtr.p->nodeStatus + */ + failedNodeSynchHandling(signal, failedNodePtr); + }//for + + if(masterTakeOver){ + jam(); + startLcpMasterTakeOver(signal, oldMasterId); + startGcpMasterTakeOver(signal, oldMasterId); + + if(getNodeState().getNodeRestartInProgress()){ + jam(); + progError(__LINE__, + ERR_SYSTEM_ERROR, + "Unhandle master failure during node restart"); + } + } + + + if (isMaster()) { + jam(); + setNodeRestartInfoBits(); + }//if +}//Dbdih::execNODE_FAILREP() + +void Dbdih::checkCopyTab(NodeRecordPtr failedNodePtr) +{ + jam(); + + if(c_nodeStartMaster.startNode != failedNodePtr.i){ + jam(); + return; + } + + switch(c_nodeStartMaster.m_outstandingGsn){ + case GSN_COPY_TABREQ: + jam(); + ndbrequire(c_COPY_TABREQ_Counter.isWaitingFor(failedNodePtr.i)); + releaseTabPages(failedNodePtr.p->activeTabptr); + c_COPY_TABREQ_Counter.clearWaitingFor(failedNodePtr.i); + c_nodeStartMaster.wait = ZFALSE; + break; + case GSN_START_PERMCONF: + case GSN_DICTSTARTREQ: + case GSN_START_MECONF: + jam(); + break; + default: + ndbout_c("outstanding gsn: %s(%d)", + getSignalName(c_nodeStartMaster.m_outstandingGsn), + c_nodeStartMaster.m_outstandingGsn); + ndbrequire(false); + } + + nodeResetStart(); +}//Dbdih::checkCopyTab() + +void Dbdih::checkStopMe(Signal* signal, NodeRecordPtr failedNodePtr) +{ + jam(); + if (c_STOP_ME_REQ_Counter.isWaitingFor(failedNodePtr.i)){ + jam(); + ndbrequire(c_stopMe.clientRef != 0); + StopMeConf * const stopMeConf = (StopMeConf *)&signal->theData[0]; + stopMeConf->senderRef = calcDihBlockRef(failedNodePtr.i); + stopMeConf->senderData = c_stopMe.clientData; + sendSignal(reference(), GSN_STOP_ME_CONF, signal, + StopMeConf::SignalLength, JBB); + }//if +}//Dbdih::checkStopMe() + +void Dbdih::checkStopPermMaster(Signal* signal, NodeRecordPtr failedNodePtr) +{ + DihSwitchReplicaRef* const ref = (DihSwitchReplicaRef*)&signal->theData[0]; + jam(); + if (c_DIH_SWITCH_REPLICA_REQ_Counter.isWaitingFor(failedNodePtr.i)){ + jam(); + ndbrequire(c_stopPermMaster.clientRef != 0); + ref->senderNode = failedNodePtr.i; + ref->errorCode = StopPermRef::NF_CausedAbortOfStopProcedure; + sendSignal(reference(), GSN_DIH_SWITCH_REPLICA_REF, signal, + DihSwitchReplicaRef::SignalLength, JBB); + return; + }//if +}//Dbdih::checkStopPermMaster() + +void Dbdih::checkStopPermProxy(Signal* signal, NodeId failedNodeId) +{ + jam(); + if(c_stopPermProxy.clientRef != 0 && + refToNode(c_stopPermProxy.masterRef) == failedNodeId){ + + /** + * The master has failed report to proxy-client + */ + jam(); + StopPermRef* const ref = (StopPermRef*)&signal->theData[0]; + + ref->senderData = c_stopPermProxy.clientData; + ref->errorCode = StopPermRef::NF_CausedAbortOfStopProcedure; + sendSignal(c_stopPermProxy.clientRef, GSN_STOP_PERM_REF, signal, 2, JBB); + c_stopPermProxy.clientRef = 0; + }//if +}//Dbdih::checkStopPermProxy() + +void +Dbdih::checkTakeOverInMasterAllNodeFailure(Signal* signal, + NodeRecordPtr failedNodePtr) +{ + //------------------------------------------------------------------------ + // This code is used to handle the failure of "all" nodes during the + // take over when "all" nodes are informed about state changes in + // the take over protocol. + //-------------------------------------------------------------------------- + if (c_START_TOREQ_Counter.isWaitingFor(failedNodePtr.i)){ + jam(); + StartToConf * const conf = (StartToConf *)&signal->theData[0]; + conf->userPtr = c_startToLock; + conf->sendingNodeId = failedNodePtr.i; + conf->startingNodeId = getStartNode(c_startToLock); + sendSignal(reference(), GSN_START_TOCONF, signal, + StartToConf::SignalLength, JBB); + }//if + if (c_CREATE_FRAGREQ_Counter.isWaitingFor(failedNodePtr.i)){ + jam(); + CreateFragConf * const conf = (CreateFragConf *)&signal->theData[0]; + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = c_createFragmentLock; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + conf->userPtr = takeOverPtr.i; + conf->tableId = takeOverPtr.p->toCurrentTabref; + conf->fragId = takeOverPtr.p->toCurrentFragid; + conf->sendingNodeId = failedNodePtr.i; + conf->startingNodeId = takeOverPtr.p->toStartingNode; + sendSignal(reference(), GSN_CREATE_FRAGCONF, signal, + CreateFragConf::SignalLength, JBB); + }//if + if (c_UPDATE_TOREQ_Counter.isWaitingFor(failedNodePtr.i)){ + jam(); + UpdateToConf * const conf = (UpdateToConf *)&signal->theData[0]; + conf->userPtr = c_updateToLock; + conf->sendingNodeId = failedNodePtr.i; + conf->startingNodeId = getStartNode(c_updateToLock); + sendSignal(reference(), GSN_UPDATE_TOCONF, signal, + UpdateToConf::SignalLength, JBB); + }//if + + if (c_END_TOREQ_Counter.isWaitingFor(failedNodePtr.i)){ + jam(); + EndToConf * const conf = (EndToConf *)&signal->theData[0]; + conf->userPtr = c_endToLock; + conf->sendingNodeId = failedNodePtr.i; + conf->startingNodeId = getStartNode(c_endToLock); + sendSignal(reference(), GSN_END_TOCONF, signal, + EndToConf::SignalLength, JBB); + }//if +}//Dbdih::checkTakeOverInMasterAllNodeFailure() + +void Dbdih::checkTakeOverInMasterCopyNodeFailure(Signal* signal, + Uint32 failedNodeId) +{ + //--------------------------------------------------------------------------- + // This code is used to handle failure of the copying node during a take over + //--------------------------------------------------------------------------- + TakeOverRecordPtr takeOverPtr; + for (Uint32 i = 0; i < MAX_NDB_NODES; i++) { + jam(); + takeOverPtr.i = i; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + if ((takeOverPtr.p->toMasterStatus == TakeOverRecord::COPY_FRAG) && + (takeOverPtr.p->toCopyNode == failedNodeId)) { + jam(); + /** + * The copying node failed but the system is still operational. + * We restart the copy process by selecting a new copy node. + * We do not need to add a fragment however since it is already added. + * We start again from the prepare create fragment phase. + */ + prepareSendCreateFragReq(signal, takeOverPtr.i); + }//if + }//for +}//Dbdih::checkTakeOverInMasterCopyNodeFailure() + +void Dbdih::checkTakeOverInMasterStartNodeFailure(Signal* signal, + Uint32 takeOverPtrI) +{ + jam(); + if (takeOverPtrI == RNIL) { + jam(); + return; + } + //----------------------------------------------------------------------- + // We are the master and the starting node has failed during a take over. + // We need to handle this failure in different ways depending on the state. + //----------------------------------------------------------------------- + + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = takeOverPtrI; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + + bool ok = false; + switch (takeOverPtr.p->toMasterStatus) { + case TakeOverRecord::IDLE: + //----------------------------------------------------------------------- + // The state cannot be idle when it has a starting node. + //----------------------------------------------------------------------- + ndbrequire(false); + break; + case TakeOverRecord::TO_WAIT_START_TAKE_OVER: + jam(); + case TakeOverRecord::TO_START_COPY: + jam(); + case TakeOverRecord::TO_START_COPY_ONGOING: + jam(); + case TakeOverRecord::TO_WAIT_START: + jam(); + case TakeOverRecord::TO_WAIT_PREPARE_CREATE: + jam(); + case TakeOverRecord::TO_WAIT_UPDATE_TO: + jam(); + case TakeOverRecord::TO_WAIT_COMMIT_CREATE: + jam(); + case TakeOverRecord::TO_END_COPY: + jam(); + case TakeOverRecord::TO_END_COPY_ONGOING: + jam(); + case TakeOverRecord::TO_WAIT_ENDING: + jam(); + //----------------------------------------------------------------------- + // We will not do anything since an internal signal process is outstanding. + // When the signal arrives the take over will be released. + //----------------------------------------------------------------------- + ok = true; + break; + case TakeOverRecord::STARTING: + jam(); + ok = true; + c_startToLock = RNIL; + c_START_TOREQ_Counter.clearWaitingFor(); + endTakeOver(takeOverPtr.i); + break; + case TakeOverRecord::TO_UPDATE_TO: + jam(); + ok = true; + c_updateToLock = RNIL; + c_UPDATE_TOREQ_Counter.clearWaitingFor(); + endTakeOver(takeOverPtr.i); + break; + case TakeOverRecord::ENDING: + jam(); + ok = true; + c_endToLock = RNIL; + c_END_TOREQ_Counter.clearWaitingFor(); + endTakeOver(takeOverPtr.i); + break; + case TakeOverRecord::COMMIT_CREATE: + ok = true; + jam(); + {// We have mutex + Mutex m(signal, c_mutexMgr, takeOverPtr.p->m_switchPrimaryMutexHandle); + m.unlock(); // Ignore result + } + // Fall through + case TakeOverRecord::PREPARE_CREATE: + ok = true; + jam(); + c_createFragmentLock = RNIL; + c_CREATE_FRAGREQ_Counter.clearWaitingFor(); + endTakeOver(takeOverPtr.i); + break; + case TakeOverRecord::LOCK_MUTEX: + ok = true; + jam(); + // Lock mutex will return and do endTakeOver + break; + + //----------------------------------------------------------------------- + // Signals are outstanding to external nodes. These signals carry the node + // id of the starting node and will not use the take over record if the + // starting node has failed. + //----------------------------------------------------------------------- + case TakeOverRecord::COPY_FRAG: + ok = true; + jam(); + //----------------------------------------------------------------------- + // The starting node will discover the problem. We will receive either + // COPY_FRAGREQ or COPY_FRAGCONF and then we can release the take over + // record and end the process. If the copying node should also die then + // we will try to send prepare create fragment and will then discover + // that the starting node has failed. + //----------------------------------------------------------------------- + break; + case TakeOverRecord::COPY_ACTIVE: + ok = true; + jam(); + //----------------------------------------------------------------------- + // In this we are waiting for a signal from the starting node. Thus we + // can release the take over record and end the process. + //----------------------------------------------------------------------- + endTakeOver(takeOverPtr.i); + break; + case TakeOverRecord::WAIT_LCP: + ok = true; + jam(); + //----------------------------------------------------------------------- + //----------------------------------------------------------------------- + endTakeOver(takeOverPtr.i); + break; + /** + * The following are states that it should not be possible to "be" in + */ + case TakeOverRecord::SELECTING_NEXT: + jam(); + case TakeOverRecord::TO_COPY_COMPLETED: + jam(); + ndbrequire(false); + } + if(!ok){ + jamLine(takeOverPtr.p->toSlaveStatus); + ndbrequire(ok); + } +}//Dbdih::checkTakeOverInMasterStartNodeFailure() + +void Dbdih::checkTakeOverInNonMasterStartNodeFailure(Signal* signal, + Uint32 takeOverPtrI) +{ + jam(); + if (takeOverPtrI == RNIL) { + jam(); + return; + } + //----------------------------------------------------------------------- + // We are not master and not taking over as master. A take over was ongoing + // but the starting node has now failed. Handle it according to the state + // of the take over. + //----------------------------------------------------------------------- + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = takeOverPtrI; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + bool ok = false; + switch (takeOverPtr.p->toSlaveStatus) { + case TakeOverRecord::TO_SLAVE_IDLE: + ndbrequire(false); + break; + case TakeOverRecord::TO_SLAVE_STARTED: + jam(); + case TakeOverRecord::TO_SLAVE_CREATE_PREPARE: + jam(); + case TakeOverRecord::TO_SLAVE_COPY_FRAG_COMPLETED: + jam(); + case TakeOverRecord::TO_SLAVE_CREATE_COMMIT: + jam(); + case TakeOverRecord::TO_SLAVE_COPY_COMPLETED: + jam(); + ok = true; + endTakeOver(takeOverPtr.i); + break; + }//switch + if(!ok){ + jamLine(takeOverPtr.p->toSlaveStatus); + ndbrequire(ok); + } +}//Dbdih::checkTakeOverInNonMasterStartNodeFailure() + +void Dbdih::failedNodeSynchHandling(Signal* signal, + NodeRecordPtr failedNodePtr) +{ + jam(); + /*----------------------------------------------------*/ + /* INITIALISE THE VARIABLES THAT KEEP TRACK OF */ + /* WHEN A NODE FAILURE IS COMPLETED. */ + /*----------------------------------------------------*/ + failedNodePtr.p->dbdictFailCompleted = ZFALSE; + failedNodePtr.p->dbtcFailCompleted = ZFALSE; + failedNodePtr.p->dbdihFailCompleted = ZFALSE; + failedNodePtr.p->dblqhFailCompleted = ZFALSE; + + failedNodePtr.p->m_NF_COMPLETE_REP.clearWaitingFor(); + + NodeRecordPtr nodePtr; + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + ptrAss(nodePtr, nodeRecord); + if (nodePtr.p->nodeStatus == NodeRecord::ALIVE) { + jam(); + /** + * We'r waiting for nodePtr.i to complete + * handling of failedNodePtr.i's death + */ + + failedNodePtr.p->m_NF_COMPLETE_REP.setWaitingFor(nodePtr.i); + } else { + jam(); + if ((nodePtr.p->nodeStatus == NodeRecord::DYING) && + (nodePtr.p->m_NF_COMPLETE_REP.isWaitingFor(failedNodePtr.i))){ + jam(); + /*----------------------------------------------------*/ + /* THE NODE FAILED BEFORE REPORTING THE FAILURE */ + /* HANDLING COMPLETED ON THIS FAILED NODE. */ + /* REPORT THAT NODE FAILURE HANDLING WAS */ + /* COMPLETED ON THE NEW FAILED NODE FOR THIS */ + /* PARTICULAR OLD FAILED NODE. */ + /*----------------------------------------------------*/ + NFCompleteRep * const nf = (NFCompleteRep *)&signal->theData[0]; + nf->blockNo = 0; + nf->nodeId = failedNodePtr.i; + nf->failedNodeId = nodePtr.i; + nf->from = __LINE__; + sendSignal(reference(), GSN_NF_COMPLETEREP, signal, + NFCompleteRep::SignalLength, JBB); + }//if + }//if + }//for + if (failedNodePtr.p->nodeStatus == NodeRecord::DIED_NOW) { + jam(); + failedNodePtr.p->nodeStatus = NodeRecord::DYING; + } else { + jam(); + /*----------------------------------------------------*/ + // No more processing needed when node not even started + // yet. We give the node status to DEAD since we do not + // care whether all nodes complete the node failure + // handling. The node have not been included in the + // node failure protocols. + /*----------------------------------------------------*/ + failedNodePtr.p->nodeStatus = NodeRecord::DEAD; + /**----------------------------------------------------------------------- + * WE HAVE COMPLETED HANDLING THE NODE FAILURE IN DIH. WE CAN REPORT THIS + * TO DIH THAT WAIT FOR THE OTHER BLOCKS TO BE CONCLUDED AS WELL. + *-----------------------------------------------------------------------*/ + NFCompleteRep * const nf = (NFCompleteRep *)&signal->theData[0]; + nf->blockNo = DBDIH; + nf->nodeId = cownNodeId; + nf->failedNodeId = failedNodePtr.i; + nf->from = __LINE__; + sendSignal(reference(), GSN_NF_COMPLETEREP, signal, + NFCompleteRep::SignalLength, JBB); + }//if +}//Dbdih::failedNodeSynchHandling() + +Uint32 Dbdih::findTakeOver(Uint32 failedNodeId) +{ + for (Uint32 i = 0; i < MAX_NDB_NODES; i++) { + jam(); + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = i; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + if (takeOverPtr.p->toStartingNode == failedNodeId) { + jam(); + return i; + }//if + }//for + return RNIL; +}//Dbdih::findTakeOver() + +Uint32 Dbdih::getStartNode(Uint32 takeOverPtrI) +{ + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = takeOverPtrI; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + return takeOverPtr.p->toStartingNode; +}//Dbdih::getStartNode() + +void Dbdih::failedNodeLcpHandling(Signal* signal, NodeRecordPtr failedNodePtr) +{ + jam(); + const Uint32 nodeId = failedNodePtr.i; + + if (c_lcpState.m_participatingLQH.get(failedNodePtr.i)){ + /*----------------------------------------------------*/ + /* THE NODE WAS INVOLVED IN A LOCAL CHECKPOINT. WE */ + /* MUST UPDATE THE ACTIVE STATUS TO INDICATE THAT */ + /* THE NODE HAVE MISSED A LOCAL CHECKPOINT. */ + /*----------------------------------------------------*/ + switch (failedNodePtr.p->activeStatus) { + case Sysfile::NS_Active: + jam(); + failedNodePtr.p->activeStatus = Sysfile::NS_ActiveMissed_1; + break; + case Sysfile::NS_ActiveMissed_1: + jam(); + failedNodePtr.p->activeStatus = Sysfile::NS_ActiveMissed_2; + break; + case Sysfile::NS_ActiveMissed_2: + jam(); + failedNodePtr.p->activeStatus = Sysfile::NS_NotActive_NotTakenOver; + break; + case Sysfile::NS_TakeOver: + jam(); + failedNodePtr.p->activeStatus = Sysfile::NS_NotActive_NotTakenOver; + break; + default: + ndbout << "activeStatus = " << failedNodePtr.p->activeStatus; + ndbout << " at failure after NODE_FAILREP of node = "; + ndbout << failedNodePtr.i << endl; + ndbrequire(false); + break; + }//switch + }//if + + c_lcpState.m_participatingDIH.clear(failedNodePtr.i); + c_lcpState.m_participatingLQH.clear(failedNodePtr.i); + + if(c_lcpState.m_LCP_COMPLETE_REP_Counter_DIH.isWaitingFor(failedNodePtr.i)){ + jam(); + LcpCompleteRep * rep = (LcpCompleteRep*)signal->getDataPtrSend(); + rep->nodeId = failedNodePtr.i; + rep->lcpId = SYSFILE->latestLCP_ID; + rep->blockNo = DBDIH; + sendSignal(reference(), GSN_LCP_COMPLETE_REP, signal, + LcpCompleteRep::SignalLength, JBB); + } + + /** + * Check if we'r waiting for the failed node's LQH to complete + * + * Note that this is ran "before" LCP master take over + */ + if(c_lcpState.m_LCP_COMPLETE_REP_Counter_LQH.isWaitingFor(nodeId)){ + jam(); + + LcpCompleteRep * rep = (LcpCompleteRep*)signal->getDataPtrSend(); + rep->nodeId = nodeId; + rep->lcpId = SYSFILE->latestLCP_ID; + rep->blockNo = DBLQH; + sendSignal(reference(), GSN_LCP_COMPLETE_REP, signal, + LcpCompleteRep::SignalLength, JBB); + + if(c_lcpState.m_LAST_LCP_FRAG_ORD.isWaitingFor(nodeId)){ + jam(); + /** + * Make sure we're ready to accept it + */ + c_lcpState.m_LAST_LCP_FRAG_ORD.clearWaitingFor(nodeId); + } + } + + if (c_TCGETOPSIZEREQ_Counter.isWaitingFor(failedNodePtr.i)) { + jam(); + signal->theData[0] = failedNodePtr.i; + signal->theData[1] = 0; + sendSignal(reference(), GSN_TCGETOPSIZECONF, signal, 2, JBB); + }//if + + if (c_TC_CLOPSIZEREQ_Counter.isWaitingFor(failedNodePtr.i)) { + jam(); + signal->theData[0] = failedNodePtr.i; + sendSignal(reference(), GSN_TC_CLOPSIZECONF, signal, 1, JBB); + }//if + + if (c_START_LCP_REQ_Counter.isWaitingFor(failedNodePtr.i)) { + jam(); + StartLcpConf * conf = (StartLcpConf*)signal->getDataPtrSend(); + conf->senderRef = numberToRef(DBLQH, failedNodePtr.i); + conf->lcpId = SYSFILE->latestLCP_ID; + sendSignal(reference(), GSN_START_LCP_CONF, signal, + StartLcpConf::SignalLength, JBB); + }//if + + if (c_EMPTY_LCP_REQ_Counter.isWaitingFor(failedNodePtr.i)) { + jam(); + EmptyLcpConf * const rep = (EmptyLcpConf *)&signal->theData[0]; + rep->senderNodeId = failedNodePtr.i; + rep->tableId = ~0; + rep->fragmentId = ~0; + rep->lcpNo = 0; + rep->lcpId = SYSFILE->latestLCP_ID; + rep->idle = true; + sendSignal(reference(), GSN_EMPTY_LCP_CONF, signal, + EmptyLcpConf::SignalLength, JBB); + }//if + + if (c_MASTER_LCPREQ_Counter.isWaitingFor(failedNodePtr.i)) { + jam(); + MasterLCPRef * const ref = (MasterLCPRef *)&signal->theData[0]; + ref->senderNodeId = failedNodePtr.i; + ref->failedNodeId = cmasterTakeOverNode; + sendSignal(reference(), GSN_MASTER_LCPREF, signal, + MasterLCPRef::SignalLength, JBB); + }//if + +}//Dbdih::failedNodeLcpHandling() + +void Dbdih::checkGcpOutstanding(Signal* signal, Uint32 failedNodeId){ + if (c_GCP_PREPARE_Counter.isWaitingFor(failedNodeId)){ + jam(); + signal->theData[0] = failedNodeId; + signal->theData[1] = cnewgcp; + sendSignal(reference(), GSN_GCP_PREPARECONF, signal, 2, JBB); + }//if + + if (c_GCP_COMMIT_Counter.isWaitingFor(failedNodeId)) { + jam(); + signal->theData[0] = failedNodeId; + signal->theData[1] = coldgcp; + signal->theData[2] = cfailurenr; + sendSignal(reference(), GSN_GCP_NODEFINISH, signal, 3, JBB); + }//if + + if (c_GCP_SAVEREQ_Counter.isWaitingFor(failedNodeId)) { + jam(); + GCPSaveRef * const saveRef = (GCPSaveRef*)&signal->theData[0]; + saveRef->dihPtr = failedNodeId; + saveRef->nodeId = failedNodeId; + saveRef->gci = coldgcp; + saveRef->errorCode = GCPSaveRef::FakedSignalDueToNodeFailure; + sendSignal(reference(), GSN_GCP_SAVEREF, signal, + GCPSaveRef::SignalLength, JBB); + }//if + + if (c_COPY_GCIREQ_Counter.isWaitingFor(failedNodeId)) { + jam(); + signal->theData[0] = failedNodeId; + sendSignal(reference(), GSN_COPY_GCICONF, signal, 1, JBB); + }//if + + if (c_MASTER_GCPREQ_Counter.isWaitingFor(failedNodeId)){ + jam(); + MasterGCPRef * const ref = (MasterGCPRef *)&signal->theData[0]; + ref->senderNodeId = failedNodeId; + ref->failedNodeId = cmasterTakeOverNode; + sendSignal(reference(), GSN_MASTER_GCPREF, signal, + MasterGCPRef::SignalLength, JBB); + }//if +}//Dbdih::handleGcpStateInMaster() + + +void +Dbdih::startLcpMasterTakeOver(Signal* signal, Uint32 nodeId){ + jam(); + + c_lcpMasterTakeOverState.minTableId = ~0; + c_lcpMasterTakeOverState.minFragId = ~0; + c_lcpMasterTakeOverState.failedNodeId = nodeId; + + c_lcpMasterTakeOverState.set(LMTOS_WAIT_EMPTY_LCP, __LINE__); + + if(c_EMPTY_LCP_REQ_Counter.done()){ + jam(); + c_lcpState.m_LAST_LCP_FRAG_ORD.clearWaitingFor(); + + EmptyLcpReq* req = (EmptyLcpReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + sendLoopMacro(EMPTY_LCP_REQ, sendEMPTY_LCP_REQ); + ndbrequire(!c_EMPTY_LCP_REQ_Counter.done()); + } else { + /** + * Node failure during master take over... + */ + ndbout_c("Nodefail during master take over"); + } + + setLocalNodefailHandling(signal, nodeId, NF_LCP_TAKE_OVER); +} + +void Dbdih::startGcpMasterTakeOver(Signal* signal, Uint32 oldMasterId){ + jam(); + /*--------------------------------------------------*/ + /* */ + /* THE MASTER HAVE FAILED AND WE WERE ELECTED */ + /* TO BE THE NEW MASTER NODE. WE NEED TO QUERY*/ + /* ALL THE OTHER NODES ABOUT THEIR STATUS IN */ + /* ORDER TO BE ABLE TO TAKE OVER CONTROL OF */ + /* THE GLOBAL CHECKPOINT PROTOCOL AND THE */ + /* LOCAL CHECKPOINT PROTOCOL. */ + /*--------------------------------------------------*/ + if(!isMaster()){ + jam(); + return; + } + cmasterState = MASTER_TAKE_OVER_GCP; + cmasterTakeOverNode = oldMasterId; + MasterGCPReq * const req = (MasterGCPReq *)&signal->theData[0]; + req->masterRef = reference(); + req->failedNodeId = oldMasterId; + sendLoopMacro(MASTER_GCPREQ, sendMASTER_GCPREQ); + cgcpMasterTakeOverState = GMTOS_INITIAL; + + signal->theData[0] = EventReport::GCP_TakeoverStarted; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 1, JBB); + + setLocalNodefailHandling(signal, oldMasterId, NF_GCP_TAKE_OVER); +}//Dbdih::handleNewMaster() + +void Dbdih::handleTakeOverNewMaster(Signal* signal, Uint32 takeOverPtrI) +{ + jam(); + if (takeOverPtrI != RNIL) { + jam(); + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = takeOverPtrI; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + bool ok = false; + switch (takeOverPtr.p->toSlaveStatus) { + case TakeOverRecord::TO_SLAVE_IDLE: + ndbrequire(false); + break; + case TakeOverRecord::TO_SLAVE_STARTED: + jam(); + case TakeOverRecord::TO_SLAVE_CREATE_PREPARE: + jam(); + case TakeOverRecord::TO_SLAVE_COPY_FRAG_COMPLETED: + jam(); + case TakeOverRecord::TO_SLAVE_CREATE_COMMIT: + jam(); + ok = true; + infoEvent("Unhandled MasterTO of TO slaveStatus=%d killing node %d", + takeOverPtr.p->toSlaveStatus, + takeOverPtr.p->toStartingNode); + takeOverPtr.p->toMasterStatus = TakeOverRecord::COPY_ACTIVE; + + { + BlockReference cntrRef = calcNdbCntrBlockRef(takeOverPtr.p->toStartingNode); + SystemError * const sysErr = (SystemError*)&signal->theData[0]; + sysErr->errorCode = SystemError::CopyFragRefError; + sysErr->errorRef = reference(); + sendSignal(cntrRef, GSN_SYSTEM_ERROR, signal, + SystemError::SignalLength, JBB); + } + break; + case TakeOverRecord::TO_SLAVE_COPY_COMPLETED: + ok = true; + jam(); + takeOverPtr.p->toMasterStatus = TakeOverRecord::WAIT_LCP; + break; + } + ndbrequire(ok); + }//if +}//Dbdih::handleTakeOverNewMaster() + +void Dbdih::startRemoveFailedNode(Signal* signal, NodeRecordPtr failedNodePtr) +{ + Uint32 nodeId = failedNodePtr.i; + if(failedNodePtr.p->nodeStatus != NodeRecord::DIED_NOW){ + jam(); + /** + * Is node isn't alive. It can't be part of LCP + */ + ndbrequire(!c_lcpState.m_LCP_COMPLETE_REP_Counter_LQH.isWaitingFor(nodeId)); + + /** + * And there is no point in removing any replicas + * It's dead... + */ + return; + } + + jam(); + signal->theData[0] = DihContinueB::ZREMOVE_NODE_FROM_TABLE; + signal->theData[1] = failedNodePtr.i; + signal->theData[2] = 0; // Tab id + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); + + setLocalNodefailHandling(signal, failedNodePtr.i, NF_REMOVE_NODE_FROM_TABLE); +}//Dbdih::startRemoveFailedNode() + +/*--------------------------------------------------*/ +/* THE MASTER HAS FAILED AND THE NEW MASTER IS*/ +/* QUERYING THIS NODE ABOUT THE STATE OF THE */ +/* GLOBAL CHECKPOINT PROTOCOL */ +/*--------------------------------------------------*/ +void Dbdih::execMASTER_GCPREQ(Signal* signal) +{ + NodeRecordPtr failedNodePtr; + MasterGCPReq * const masterGCPReq = (MasterGCPReq *)&signal->theData[0]; + jamEntry(); + const BlockReference newMasterBlockref = masterGCPReq->masterRef; + const Uint32 failedNodeId = masterGCPReq->failedNodeId; + if (c_copyGCISlave.m_copyReason != CopyGCIReq::IDLE) { + jam(); + /*--------------------------------------------------*/ + /* WE ARE CURRENTLY WRITING THE RESTART INFO */ + /* IN THIS NODE. SINCE ONLY ONE PROCESS IS */ + /* ALLOWED TO DO THIS AT A TIME WE MUST ENSURE*/ + /* THAT THIS IS NOT ONGOING WHEN THE NEW */ + /* MASTER TAKES OVER CONTROL. IF NOT ALL NODES*/ + /* RECEIVE THE SAME RESTART INFO DUE TO THE */ + /* FAILURE OF THE MASTER IT IS TAKEN CARE OF */ + /* BY THE NEW MASTER. */ + /*--------------------------------------------------*/ + sendSignalWithDelay(reference(), GSN_MASTER_GCPREQ, + signal, 10, MasterGCPReq::SignalLength); + return; + }//if + failedNodePtr.i = failedNodeId; + ptrCheckGuard(failedNodePtr, MAX_NDB_NODES, nodeRecord); + if (failedNodePtr.p->nodeStatus == NodeRecord::ALIVE) { + jam(); + /*--------------------------------------------------*/ + /* ENSURE THAT WE HAVE PROCESSED THE SIGNAL */ + /* NODE_FAILURE BEFORE WE PROCESS THIS REQUEST*/ + /* FROM THE NEW MASTER. THIS ENSURES THAT WE */ + /* HAVE REMOVED THE FAILED NODE FROM THE LIST */ + /* OF ACTIVE NODES AND SO FORTH. */ + /*--------------------------------------------------*/ + sendSignalWithDelay(reference(), GSN_MASTER_GCPREQ, + signal, 10, MasterGCPReq::SignalLength); + return; + } else { + ndbrequire(failedNodePtr.p->nodeStatus == NodeRecord::DYING); + }//if + MasterGCPConf::State gcpState; + switch (cgcpParticipantState) { + case GCP_PARTICIPANT_READY: + jam(); + /*--------------------------------------------------*/ + /* THE GLOBAL CHECKPOINT IS NOT ACTIVE SINCE */ + /* THE PREVIOUS GLOBAL CHECKPOINT IS COMPLETED*/ + /* AND THE NEW HAVE NOT STARTED YET. */ + /*--------------------------------------------------*/ + gcpState = MasterGCPConf::GCP_READY; + break; + case GCP_PARTICIPANT_PREPARE_RECEIVED: + jam(); + /*--------------------------------------------------*/ + /* GCP_PREPARE HAVE BEEN RECEIVED AND RESPONSE*/ + /* HAVE BEEN SENT. */ + /*--------------------------------------------------*/ + gcpState = MasterGCPConf::GCP_PREPARE_RECEIVED; + break; + case GCP_PARTICIPANT_COMMIT_RECEIVED: + jam(); + /*------------------------------------------------*/ + /* GCP_COMMIT HAVE BEEN RECEIVED BUT NOT YET*/ + /* GCP_TCFINISHED FROM LOCAL TC. */ + /*------------------------------------------------*/ + gcpState = MasterGCPConf::GCP_COMMIT_RECEIVED; + break; + case GCP_PARTICIPANT_TC_FINISHED: + jam(); + /*------------------------------------------------*/ + /* GCP_COMMIT HAS BEEN RECEIVED AND ALSO */ + /* GCP_TCFINISHED HAVE BEEN RECEIVED. */ + /*------------------------------------------------*/ + gcpState = MasterGCPConf::GCP_TC_FINISHED; + break; + case GCP_PARTICIPANT_COPY_GCI_RECEIVED: + /*--------------------------------------------------*/ + /* COPY RESTART INFORMATION HAS BEEN RECEIVED */ + /* BUT NOT YET COMPLETED. */ + /*--------------------------------------------------*/ + ndbrequire(false); + break; + default: + /*------------------------------------------------*/ + /* */ + /* THIS SHOULD NOT OCCUR SINCE THE ABOVE */ + /* STATES ARE THE ONLY POSSIBLE STATES AT A */ + /* NODE WHICH WAS NOT A MASTER NODE. */ + /*------------------------------------------------*/ + ndbrequire(false); + break; + }//switch + MasterGCPConf * const masterGCPConf = (MasterGCPConf *)&signal->theData[0]; + masterGCPConf->gcpState = gcpState; + masterGCPConf->senderNodeId = cownNodeId; + masterGCPConf->failedNodeId = failedNodeId; + masterGCPConf->newGCP = cnewgcp; + masterGCPConf->latestLCP = SYSFILE->latestLCP_ID; + masterGCPConf->oldestRestorableGCI = SYSFILE->oldestRestorableGCI; + masterGCPConf->keepGCI = SYSFILE->keepGCI; + for(Uint32 i = 0; i < NdbNodeBitmask::Size; i++) + masterGCPConf->lcpActive[i] = SYSFILE->lcpActive[i]; + sendSignal(newMasterBlockref, GSN_MASTER_GCPCONF, signal, + MasterGCPConf::SignalLength, JBB); +}//Dbdih::execMASTER_GCPREQ() + +void Dbdih::execMASTER_GCPCONF(Signal* signal) +{ + NodeRecordPtr senderNodePtr; + MasterGCPConf * const masterGCPConf = (MasterGCPConf *)&signal->theData[0]; + jamEntry(); + senderNodePtr.i = masterGCPConf->senderNodeId; + ptrCheckGuard(senderNodePtr, MAX_NDB_NODES, nodeRecord); + + MasterGCPConf::State gcpState = (MasterGCPConf::State)masterGCPConf->gcpState; + const Uint32 failedNodeId = masterGCPConf->failedNodeId; + const Uint32 newGcp = masterGCPConf->newGCP; + const Uint32 latestLcpId = masterGCPConf->latestLCP; + const Uint32 oldestRestorableGci = masterGCPConf->oldestRestorableGCI; + const Uint32 oldestKeepGci = masterGCPConf->keepGCI; + if (latestLcpId > SYSFILE->latestLCP_ID) { + jam(); +#if 0 + ndbout_c("Dbdih: Setting SYSFILE->latestLCP_ID to %d", latestLcpId); + SYSFILE->latestLCP_ID = latestLcpId; +#endif + SYSFILE->keepGCI = oldestKeepGci; + SYSFILE->oldestRestorableGCI = oldestRestorableGci; + for(Uint32 i = 0; i < NdbNodeBitmask::Size; i++) + SYSFILE->lcpActive[i] = masterGCPConf->lcpActive[i]; + }//if + switch (gcpState) { + case MasterGCPConf::GCP_READY: + jam(); + senderNodePtr.p->gcpstate = NodeRecord::READY; + break; + case MasterGCPConf::GCP_PREPARE_RECEIVED: + jam(); + senderNodePtr.p->gcpstate = NodeRecord::PREPARE_RECEIVED; + cnewgcp = newGcp; + break; + case MasterGCPConf::GCP_COMMIT_RECEIVED: + jam(); + senderNodePtr.p->gcpstate = NodeRecord::COMMIT_SENT; + break; + case MasterGCPConf::GCP_TC_FINISHED: + jam(); + senderNodePtr.p->gcpstate = NodeRecord::NODE_FINISHED; + break; + default: + ndbrequire(false); + break; + }//switch + switch (cgcpMasterTakeOverState) { + case GMTOS_INITIAL: + switch (gcpState) { + case MasterGCPConf::GCP_READY: + jam(); + cgcpMasterTakeOverState = ALL_READY; + break; + case MasterGCPConf::GCP_PREPARE_RECEIVED: + jam(); + cgcpMasterTakeOverState = ALL_PREPARED; + break; + case MasterGCPConf::GCP_COMMIT_RECEIVED: + jam(); + cgcpMasterTakeOverState = COMMIT_STARTED_NOT_COMPLETED; + break; + case MasterGCPConf::GCP_TC_FINISHED: + jam(); + cgcpMasterTakeOverState = COMMIT_COMPLETED; + break; + default: + ndbrequire(false); + break; + }//switch + break; + case ALL_READY: + switch (gcpState) { + case MasterGCPConf::GCP_READY: + jam(); + /*empty*/; + break; + case MasterGCPConf::GCP_PREPARE_RECEIVED: + jam(); + cgcpMasterTakeOverState = PREPARE_STARTED_NOT_COMMITTED; + break; + case MasterGCPConf::GCP_COMMIT_RECEIVED: + ndbrequire(false); + break; + case MasterGCPConf::GCP_TC_FINISHED: + jam(); + cgcpMasterTakeOverState = SAVE_STARTED_NOT_COMPLETED; + break; + default: + ndbrequire(false); + break; + }//switch + break; + case PREPARE_STARTED_NOT_COMMITTED: + switch (gcpState) { + case MasterGCPConf::GCP_READY: + jam(); + break; + case MasterGCPConf::GCP_PREPARE_RECEIVED: + jam(); + break; + case MasterGCPConf::GCP_COMMIT_RECEIVED: + ndbrequire(false); + break; + case MasterGCPConf::GCP_TC_FINISHED: + ndbrequire(false); + break; + default: + ndbrequire(false); + break; + }//switch + break; + case ALL_PREPARED: + switch (gcpState) { + case MasterGCPConf::GCP_READY: + jam(); + cgcpMasterTakeOverState = PREPARE_STARTED_NOT_COMMITTED; + break; + case MasterGCPConf::GCP_PREPARE_RECEIVED: + jam(); + break; + case MasterGCPConf::GCP_COMMIT_RECEIVED: + jam(); + cgcpMasterTakeOverState = COMMIT_STARTED_NOT_COMPLETED; + break; + case MasterGCPConf::GCP_TC_FINISHED: + jam(); + cgcpMasterTakeOverState = COMMIT_STARTED_NOT_COMPLETED; + break; + default: + ndbrequire(false); + break; + }//switch + break; + case COMMIT_STARTED_NOT_COMPLETED: + switch (gcpState) { + case MasterGCPConf::GCP_READY: + ndbrequire(false); + break; + case MasterGCPConf::GCP_PREPARE_RECEIVED: + jam(); + break; + case MasterGCPConf::GCP_COMMIT_RECEIVED: + jam(); + break; + case MasterGCPConf::GCP_TC_FINISHED: + jam(); + break; + default: + ndbrequire(false); + break; + }//switch + break; + case COMMIT_COMPLETED: + switch (gcpState) { + case MasterGCPConf::GCP_READY: + cgcpMasterTakeOverState = SAVE_STARTED_NOT_COMPLETED; + break; + case MasterGCPConf::GCP_PREPARE_RECEIVED: + jam(); + cgcpMasterTakeOverState = COMMIT_STARTED_NOT_COMPLETED; + break; + case MasterGCPConf::GCP_COMMIT_RECEIVED: + jam(); + cgcpMasterTakeOverState = COMMIT_STARTED_NOT_COMPLETED; + break; + case MasterGCPConf::GCP_TC_FINISHED: + jam(); + break; + default: + ndbrequire(false); + break; + }//switch + break; + case SAVE_STARTED_NOT_COMPLETED: + switch (gcpState) { + case MasterGCPConf::GCP_READY: + jam(); + break; + case MasterGCPConf::GCP_PREPARE_RECEIVED: + ndbrequire(false); + break; + case MasterGCPConf::GCP_COMMIT_RECEIVED: + ndbrequire(false); + break; + case MasterGCPConf::GCP_TC_FINISHED: + jam(); + break; + default: + ndbrequire(false); + break; + }//switch + break; + default: + ndbrequire(false); + break; + }//switch + receiveLoopMacro(MASTER_GCPREQ, senderNodePtr.i); + /*-------------------------------------------------------------------------*/ + // We have now received all responses and are ready to take over the GCP + // protocol as master. + /*-------------------------------------------------------------------------*/ + MASTER_GCPhandling(signal, failedNodeId); + return; +}//Dbdih::execMASTER_GCPCONF() + +void Dbdih::execMASTER_GCPREF(Signal* signal) +{ + const MasterGCPRef * const ref = (MasterGCPRef *)&signal->theData[0]; + jamEntry(); + receiveLoopMacro(MASTER_GCPREQ, ref->senderNodeId); + /*-------------------------------------------------------------------------*/ + // We have now received all responses and are ready to take over the GCP + // protocol as master. + /*-------------------------------------------------------------------------*/ + MASTER_GCPhandling(signal, ref->failedNodeId); +}//Dbdih::execMASTER_GCPREF() + +void Dbdih::MASTER_GCPhandling(Signal* signal, Uint32 failedNodeId) +{ + NodeRecordPtr failedNodePtr; + cmasterState = MASTER_ACTIVE; + /*----------------------------------------------------------*/ + /* REMOVE ALL ACTIVE STATUS ON ALREADY FAILED NODES */ + /* THIS IS PERFORMED HERE SINCE WE GET THE LCP ACTIVE */ + /* STATUS AS PART OF THE COPY RESTART INFO AND THIS IS*/ + /* HANDLED BY THE MASTER GCP TAKE OVER PROTOCOL. */ + /*----------------------------------------------------------*/ + + failedNodePtr.i = failedNodeId; + ptrCheckGuard(failedNodePtr, MAX_NDB_NODES, nodeRecord); + switch (cgcpMasterTakeOverState) { + case ALL_READY: + jam(); + startGcp(signal); + break; + case PREPARE_STARTED_NOT_COMMITTED: + { + NodeRecordPtr nodePtr; + jam(); + c_GCP_PREPARE_Counter.clearWaitingFor(); + nodePtr.i = cfirstAliveNode; + do { + jam(); + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + if (nodePtr.p->gcpstate == NodeRecord::READY) { + jam(); + c_GCP_PREPARE_Counter.setWaitingFor(nodePtr.i); + sendGCP_PREPARE(signal, nodePtr.i); + }//if + nodePtr.i = nodePtr.p->nextNode; + } while(nodePtr.i != RNIL); + if (c_GCP_PREPARE_Counter.done()) { + jam(); + gcpcommitreqLab(signal); + }//if + break; + } + case ALL_PREPARED: + jam(); + gcpcommitreqLab(signal); + break; + case COMMIT_STARTED_NOT_COMPLETED: + { + NodeRecordPtr nodePtr; + jam(); + c_GCP_COMMIT_Counter.clearWaitingFor(); + nodePtr.i = cfirstAliveNode; + do { + jam(); + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + if (nodePtr.p->gcpstate == NodeRecord::PREPARE_RECEIVED) { + jam(); + sendGCP_COMMIT(signal, nodePtr.i); + c_GCP_COMMIT_Counter.setWaitingFor(nodePtr.i); + } else { + ndbrequire((nodePtr.p->gcpstate == NodeRecord::NODE_FINISHED) || + (nodePtr.p->gcpstate == NodeRecord::COMMIT_SENT)); + }//if + nodePtr.i = nodePtr.p->nextNode; + } while(nodePtr.i != RNIL); + if (c_GCP_COMMIT_Counter.done()){ + jam(); + gcpsavereqLab(signal); + }//if + break; + } + case COMMIT_COMPLETED: + jam(); + gcpsavereqLab(signal); + break; + case SAVE_STARTED_NOT_COMPLETED: + { + NodeRecordPtr nodePtr; + jam(); + SYSFILE->newestRestorableGCI = coldgcp; + nodePtr.i = cfirstAliveNode; + do { + jam(); + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + SYSFILE->lastCompletedGCI[nodePtr.i] = coldgcp; + nodePtr.i = nodePtr.p->nextNode; + } while (nodePtr.i != RNIL); + /**------------------------------------------------------------------- + * THE FAILED NODE DID ALSO PARTICIPATE IN THIS GLOBAL CHECKPOINT + * WHICH IS RECORDED. + *-------------------------------------------------------------------*/ + SYSFILE->lastCompletedGCI[failedNodeId] = coldgcp; + copyGciLab(signal, CopyGCIReq::GLOBAL_CHECKPOINT); + break; + } + default: + ndbrequire(false); + break; + }//switch + + signal->theData[0] = EventReport::GCP_TakeoverCompleted; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 1, JBB); + + /*--------------------------------------------------*/ + /* WE SEPARATE HANDLING OF GLOBAL CHECKPOINTS */ + /* AND LOCAL CHECKPOINTS HERE. LCP'S HAVE TO */ + /* REMOVE ALL FAILED FRAGMENTS BEFORE WE CAN */ + /* HANDLE THE LCP PROTOCOL. */ + /*--------------------------------------------------*/ + checkLocalNodefailComplete(signal, failedNodeId, NF_GCP_TAKE_OVER); + + return; +}//Dbdih::masterGcpConfFromFailedLab() + +void +Dbdih::invalidateNodeLCP(Signal* signal, Uint32 nodeId, Uint32 tableId) +{ + jamEntry(); + TabRecordPtr tabPtr; + tabPtr.i = tableId; + const Uint32 RT_BREAK = 64; + if (ERROR_INSERTED(7125)) { + return; + }//if + for (Uint32 i = 0; i= ctabFileSize){ + jam(); + /** + * Ready with entire loop + * Return to master + */ + setAllowNodeStart(nodeId, true); + if (getNodeStatus(nodeId) == NodeRecord::STARTING) { + jam(); + StartInfoConf * conf = (StartInfoConf*)&signal->theData[0]; + conf->sendingNodeId = cownNodeId; + conf->startingNodeId = nodeId; + sendSignal(cmasterdihref, GSN_START_INFOCONF, signal, + StartInfoConf::SignalLength, JBB); + }//if + return; + }//if + ptrAss(tabPtr, tabRecord); + if (tabPtr.p->tabStatus == TabRecord::TS_ACTIVE) { + jam(); + invalidateNodeLCP(signal, nodeId, tabPtr); + return; + }//if + tabPtr.i++; + }//for + signal->theData[0] = DihContinueB::ZINVALIDATE_NODE_LCP; + signal->theData[1] = nodeId; + signal->theData[2] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); +}//Dbdih::invalidateNodeLCP() + +void +Dbdih::invalidateNodeLCP(Signal* signal, Uint32 nodeId, TabRecordPtr tabPtr) +{ + /** + * Check so that no one else is using the tab descriptior + */ + if (tabPtr.p->tabCopyStatus != TabRecord::CS_IDLE) { + jam(); + signal->theData[0] = DihContinueB::ZINVALIDATE_NODE_LCP; + signal->theData[1] = nodeId; + signal->theData[2] = tabPtr.i; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 20, 3); + return; + }//if + + /** + * For each fragment + */ + bool modified = false; + FragmentstorePtr fragPtr; + for(Uint32 fragNo = 0; fragNo < tabPtr.p->totalfragments; fragNo++){ + jam(); + getFragstore(tabPtr.p, fragNo, fragPtr); + /** + * For each of replica record + */ + ReplicaRecordPtr replicaPtr; + for(replicaPtr.i = fragPtr.p->oldStoredReplicas; replicaPtr.i != RNIL; + replicaPtr.i = replicaPtr.p->nextReplica) { + jam(); + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + if(replicaPtr.p->procNode == nodeId){ + jam(); + /** + * Found one with correct node id + */ + /** + * Invalidate all LCP's + */ + modified = true; + for(int i = 0; i < MAX_LCP_STORED; i++) { + replicaPtr.p->lcpStatus[i] = ZINVALID; + }//if + /** + * And reset nextLcp + */ + replicaPtr.p->nextLcp = 0; + }//if + }//for + }//for + + if (modified) { + jam(); + /** + * Save table description to disk + */ + tabPtr.p->tabCopyStatus = TabRecord::CS_INVALIDATE_NODE_LCP; + tabPtr.p->tabUpdateState = TabRecord::US_INVALIDATE_NODE_LCP; + tabPtr.p->tabRemoveNode = nodeId; + signal->theData[0] = DihContinueB::ZPACK_TABLE_INTO_PAGES; + signal->theData[1] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; + } + + jam(); + /** + * Move to next table + */ + tabPtr.i++; + signal->theData[0] = DihContinueB::ZINVALIDATE_NODE_LCP; + signal->theData[1] = nodeId; + signal->theData[2] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); + return; +}//Dbdih::invalidateNodeLCP() + +/*------------------------------------------------*/ +/* INPUT: TABPTR */ +/* TNODEID */ +/*------------------------------------------------*/ +void Dbdih::removeNodeFromTables(Signal* signal, + Uint32 nodeId, Uint32 tableId) +{ + jamEntry(); + TabRecordPtr tabPtr; + tabPtr.i = tableId; + const Uint32 RT_BREAK = 64; + for (Uint32 i = 0; i= ctabFileSize){ + jam(); + removeNodeFromTablesComplete(signal, nodeId); + return; + }//if + + ptrAss(tabPtr, tabRecord); + if (tabPtr.p->tabStatus == TabRecord::TS_ACTIVE) { + jam(); + removeNodeFromTable(signal, nodeId, tabPtr); + return; + }//if + tabPtr.i++; + }//for + signal->theData[0] = DihContinueB::ZREMOVE_NODE_FROM_TABLE; + signal->theData[1] = nodeId; + signal->theData[2] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); +} + +void Dbdih::removeNodeFromTable(Signal* signal, + Uint32 nodeId, TabRecordPtr tabPtr){ + + /** + * Check so that no one else is using the tab descriptior + */ + if (tabPtr.p->tabCopyStatus != TabRecord::CS_IDLE) { + jam(); + signal->theData[0] = DihContinueB::ZREMOVE_NODE_FROM_TABLE; + signal->theData[1] = nodeId; + signal->theData[2] = tabPtr.i; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 20, 3); + return; + }//if + + /** + * For each fragment + */ + Uint32 noOfRemovedReplicas = 0; // No of replicas removed + Uint32 noOfRemovedLcpReplicas = 0; // No of replicas in LCP removed + Uint32 noOfRemainingLcpReplicas = 0;// No of replicas in LCP remaining + + //const Uint32 lcpId = SYSFILE->latestLCP_ID; + const bool lcpOngoingFlag = (tabPtr.p->tabLcpStatus== TabRecord::TLS_ACTIVE); + + FragmentstorePtr fragPtr; + for(Uint32 fragNo = 0; fragNo < tabPtr.p->totalfragments; fragNo++){ + jam(); + getFragstore(tabPtr.p, fragNo, fragPtr); + + /** + * For each of replica record + */ + Uint32 replicaNo = 0; + ReplicaRecordPtr replicaPtr; + for(replicaPtr.i = fragPtr.p->storedReplicas; replicaPtr.i != RNIL; + replicaPtr.i = replicaPtr.p->nextReplica, replicaNo++) { + jam(); + + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + if(replicaPtr.p->procNode == nodeId){ + jam(); + noOfRemovedReplicas++; + removeNodeFromStored(nodeId, fragPtr, replicaPtr); + if(replicaPtr.p->lcpOngoingFlag){ + jam(); + /** + * This replica is currently LCP:ed + */ + ndbrequire(fragPtr.p->noLcpReplicas > 0); + fragPtr.p->noLcpReplicas --; + + noOfRemovedLcpReplicas ++; + replicaPtr.p->lcpOngoingFlag = false; + } + } + } + noOfRemainingLcpReplicas += fragPtr.p->noLcpReplicas; + } + + if(noOfRemovedReplicas == 0){ + jam(); + /** + * The table had no replica on the failed node + * continue with next table + */ + tabPtr.i++; + signal->theData[0] = DihContinueB::ZREMOVE_NODE_FROM_TABLE; + signal->theData[1] = nodeId; + signal->theData[2] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); + return; + } + + /** + * We did remove at least one replica + */ + bool ok = false; + switch(tabPtr.p->tabLcpStatus){ + case TabRecord::TLS_COMPLETED: + ok = true; + jam(); + /** + * WE WILL WRITE THE TABLE DESCRIPTION TO DISK AT THIS TIME + * INDEPENDENT OF WHAT THE LOCAL CHECKPOINT NEEDED. + * THIS IS TO ENSURE THAT THE FAILED NODES ARE ALSO UPDATED ON DISK + * IN THE DIH DATA STRUCTURES BEFORE WE COMPLETE HANDLING OF THE + * NODE FAILURE. + */ + ndbrequire(noOfRemovedLcpReplicas == 0); + + tabPtr.p->tabCopyStatus = TabRecord::CS_REMOVE_NODE; + tabPtr.p->tabUpdateState = TabRecord::US_REMOVE_NODE; + tabPtr.p->tabRemoveNode = nodeId; + signal->theData[0] = DihContinueB::ZPACK_TABLE_INTO_PAGES; + signal->theData[1] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; + break; + case TabRecord::TLS_ACTIVE: + ok = true; + jam(); + /** + * The table is participating in an LCP currently + */ + // Fall through + break; + case TabRecord::TLS_WRITING_TO_FILE: + ok = true; + jam(); + /** + * This should never happen since we in the beginning of this function + * checks the tabCopyStatus + */ + ndbrequire(lcpOngoingFlag); + ndbrequire(false); + break; + } + ndbrequire(ok); + + /** + * The table is participating in an LCP currently + * and we removed some replicas that should have been checkpointed + */ + ndbrequire(c_lcpState.lcpStatus != LCP_STATUS_IDLE); + ndbrequire(tabPtr.p->tabLcpStatus == TabRecord::TLS_ACTIVE); + + /** + * Save the table + */ + tabPtr.p->tabCopyStatus = TabRecord::CS_REMOVE_NODE; + tabPtr.p->tabUpdateState = TabRecord::US_REMOVE_NODE; + tabPtr.p->tabRemoveNode = nodeId; + signal->theData[0] = DihContinueB::ZPACK_TABLE_INTO_PAGES; + signal->theData[1] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + + if(noOfRemainingLcpReplicas == 0){ + jam(); + /** + * The removal on the failed node made the LCP complete + */ + tabPtr.p->tabLcpStatus = TabRecord::TLS_WRITING_TO_FILE; + checkLcpAllTablesDoneInLqh(); + } +} + +void +Dbdih::removeNodeFromTablesComplete(Signal* signal, Uint32 nodeId){ + jam(); + + /** + * Check if we "accidently" completed a LCP + */ + checkLcpCompletedLab(signal); + + /** + * Check if we (DIH) are finished with node fail handling + */ + checkLocalNodefailComplete(signal, nodeId, NF_REMOVE_NODE_FROM_TABLE); +} + +void +Dbdih::checkLocalNodefailComplete(Signal* signal, Uint32 failedNodeId, + NodefailHandlingStep step){ + jam(); + + NodeRecordPtr nodePtr; + nodePtr.i = failedNodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + + ndbrequire(nodePtr.p->m_nodefailSteps.get(step)); + nodePtr.p->m_nodefailSteps.clear(step); + + if(nodePtr.p->m_nodefailSteps.count() > 0){ + jam(); + return; + } + + NFCompleteRep * const nf = (NFCompleteRep *)&signal->theData[0]; + nf->blockNo = DBDIH; + nf->nodeId = cownNodeId; + nf->failedNodeId = failedNodeId; + nf->from = __LINE__; + sendSignal(reference(), GSN_NF_COMPLETEREP, signal, + NFCompleteRep::SignalLength, JBB); +} + + +void +Dbdih::setLocalNodefailHandling(Signal* signal, Uint32 failedNodeId, + NodefailHandlingStep step){ + jam(); + + NodeRecordPtr nodePtr; + nodePtr.i = failedNodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + + ndbrequire(!nodePtr.p->m_nodefailSteps.get(step)); + nodePtr.p->m_nodefailSteps.set(step); +} + +void Dbdih::startLcpTakeOverLab(Signal* signal, Uint32 failedNodeId) +{ + /*--------------------------------------------------------------------*/ + // Start LCP master take over process. Consists of the following steps. + // 1) Ensure that all LQH's have reported all fragments they have been + // told to checkpoint. Can be a fairly long step time-wise. + // 2) Query all nodes about their LCP status. + // During the query process we do not want our own state to change. + // This can change due to delayed reception of LCP_REPORT, completed + // save of table on disk or reception of DIH_LCPCOMPLETE from other + // node. + /*--------------------------------------------------------------------*/ +}//Dbdih::startLcpTakeOver() + +void Dbdih::execEMPTY_LCP_CONF(Signal* signal) +{ + jamEntry(); + + ndbrequire(c_lcpMasterTakeOverState.state == LMTOS_WAIT_EMPTY_LCP); + + const EmptyLcpConf * const conf = (EmptyLcpConf *)&signal->theData[0]; + Uint32 nodeId = conf->senderNodeId; + + if(!conf->idle){ + jam(); + if (conf->tableId < c_lcpMasterTakeOverState.minTableId) { + jam(); + c_lcpMasterTakeOverState.minTableId = conf->tableId; + c_lcpMasterTakeOverState.minFragId = conf->fragmentId; + } else if (conf->tableId == c_lcpMasterTakeOverState.minTableId && + conf->fragmentId < c_lcpMasterTakeOverState.minFragId) { + jam(); + c_lcpMasterTakeOverState.minFragId = conf->fragmentId; + }//if + if(isMaster()){ + jam(); + c_lcpState.m_LAST_LCP_FRAG_ORD.setWaitingFor(nodeId); + } + } + + receiveLoopMacro(EMPTY_LCP_REQ, nodeId); + /*--------------------------------------------------------------------*/ + // Received all EMPTY_LCPCONF. We can continue with next phase of the + // take over LCP master process. + /*--------------------------------------------------------------------*/ + c_lcpMasterTakeOverState.set(LMTOS_WAIT_LCP_FRAG_REP, __LINE__); + checkEmptyLcpComplete(signal); + return; +}//Dbdih::execEMPTY_LCPCONF() + +void +Dbdih::checkEmptyLcpComplete(Signal *signal){ + + ndbrequire(c_lcpMasterTakeOverState.state == LMTOS_WAIT_LCP_FRAG_REP); + + if(c_lcpState.noOfLcpFragRepOutstanding > 0){ + jam(); + return; + } + + if(isMaster()){ + jam(); + + signal->theData[0] = EventReport::LCP_TakeoverStarted; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 1, JBB); + + signal->theData[0] = 7012; + execDUMP_STATE_ORD(signal); + + c_lcpMasterTakeOverState.set(LMTOS_INITIAL, __LINE__); + MasterLCPReq * const req = (MasterLCPReq *)&signal->theData[0]; + req->masterRef = reference(); + req->failedNodeId = c_lcpMasterTakeOverState.failedNodeId; + sendLoopMacro(MASTER_LCPREQ, sendMASTER_LCPREQ); + } else { + sendMASTER_LCPCONF(signal); + } +} + +/*--------------------------------------------------*/ +/* THE MASTER HAS FAILED AND THE NEW MASTER IS*/ +/* QUERYING THIS NODE ABOUT THE STATE OF THE */ +/* LOCAL CHECKPOINT PROTOCOL. */ +/*--------------------------------------------------*/ +void Dbdih::execMASTER_LCPREQ(Signal* signal) +{ + const MasterLCPReq * const req = (MasterLCPReq *)&signal->theData[0]; + jamEntry(); + const BlockReference newMasterBlockref = req->masterRef; + + Uint32 failedNodeId = req->failedNodeId; + + /** + * There can be no take over with the same master + */ + ndbrequire(c_lcpState.m_masterLcpDihRef != newMasterBlockref); + c_lcpState.m_masterLcpDihRef = newMasterBlockref; + c_lcpState.m_MASTER_LCPREQ_Received = true; + c_lcpState.m_MASTER_LCPREQ_FailedNodeId = failedNodeId; + + if(newMasterBlockref != cmasterdihref){ + jam(); + ndbrequire(0); + } + + sendMASTER_LCPCONF(signal); +}//Dbdih::execMASTER_LCPREQ() + +void +Dbdih::sendMASTER_LCPCONF(Signal * signal){ + + if(!c_EMPTY_LCP_REQ_Counter.done()){ + /** + * Have not received all EMPTY_LCP_REP + * dare not answer MASTER_LCP_CONF yet + */ + jam(); + return; + } + + if(!c_lcpState.m_MASTER_LCPREQ_Received){ + jam(); + /** + * Has not received MASTER_LCPREQ yet + */ + return; + } + + if(c_lcpState.lcpStatus == LCP_INIT_TABLES){ + jam(); + /** + * Still aborting old initLcpLab + */ + return; + } + + if(c_lcpState.lcpStatus == LCP_COPY_GCI){ + jam(); + /** + * Restart it + */ + //Uint32 lcpId = SYSFILE->latestLCP_ID; + SYSFILE->latestLCP_ID--; + c_lcpState.setLcpStatus(LCP_STATUS_IDLE, __LINE__); +#if 0 + if(c_copyGCISlave.m_copyReason == CopyGCIReq::LOCAL_CHECKPOINT){ + ndbout_c("Dbdih: Also resetting c_copyGCISlave"); + c_copyGCISlave.m_copyReason = CopyGCIReq::IDLE; + c_copyGCISlave.m_expectedNextWord = 0; + } +#endif + } + + bool ok = false; + MasterLCPConf::State lcpState; + switch (c_lcpState.lcpStatus) { + case LCP_STATUS_IDLE: + ok = true; + jam(); + /*------------------------------------------------*/ + /* LOCAL CHECKPOINT IS CURRENTLY NOT ACTIVE */ + /* SINCE NO COPY OF RESTART INFORMATION HAVE*/ + /* BEEN RECEIVED YET. ALSO THE PREVIOUS */ + /* CHECKPOINT HAVE BEEN FULLY COMPLETED. */ + /*------------------------------------------------*/ + lcpState = MasterLCPConf::LCP_STATUS_IDLE; + break; + case LCP_STATUS_ACTIVE: + ok = true; + jam(); + /*--------------------------------------------------*/ + /* COPY OF RESTART INFORMATION HAS BEEN */ + /* PERFORMED AND ALSO RESPONSE HAVE BEEN SENT.*/ + /*--------------------------------------------------*/ + lcpState = MasterLCPConf::LCP_STATUS_ACTIVE; + break; + case LCP_TAB_COMPLETED: + ok = true; + jam(); + /*--------------------------------------------------------*/ + /* ALL LCP_REPORT'S HAVE BEEN COMPLETED FOR */ + /* ALL TABLES. SAVE OF AT LEAST ONE TABLE IS */ + /* ONGOING YET. */ + /*--------------------------------------------------------*/ + lcpState = MasterLCPConf::LCP_TAB_COMPLETED; + break; + case LCP_TAB_SAVED: + ok = true; + jam(); + /*--------------------------------------------------------*/ + /* ALL LCP_REPORT'S HAVE BEEN COMPLETED FOR */ + /* ALL TABLES. ALL TABLES HAVE ALSO BEEN SAVED */ + /* ALL OTHER NODES ARE NOT YET FINISHED WITH */ + /* THE LOCAL CHECKPOINT. */ + /*--------------------------------------------------------*/ + lcpState = MasterLCPConf::LCP_TAB_SAVED; + break; + case LCP_TCGET: + case LCP_CALCULATE_KEEP_GCI: + case LCP_TC_CLOPSIZE: + case LCP_START_LCP_ROUND: + /** + * These should only exists on the master + * but since this is master take over + * it not allowed + */ + ndbrequire(false); + break; + case LCP_COPY_GCI: + case LCP_INIT_TABLES: + ok = true; + /** + * These two states are handled by if statements above + */ + ndbrequire(false); + break; + }//switch + ndbrequire(ok); + + Uint32 failedNodeId = c_lcpState.m_MASTER_LCPREQ_FailedNodeId; + MasterLCPConf * const conf = (MasterLCPConf *)&signal->theData[0]; + conf->senderNodeId = cownNodeId; + conf->lcpState = lcpState; + conf->failedNodeId = failedNodeId; + sendSignal(c_lcpState.m_masterLcpDihRef, GSN_MASTER_LCPCONF, + signal, MasterLCPConf::SignalLength, JBB); + + // Answer to MASTER_LCPREQ sent, reset flag so + // that it's not sent again before another request comes in + c_lcpState.m_MASTER_LCPREQ_Received = false; + + if(c_lcpState.lcpStatus == LCP_TAB_SAVED){ +#ifdef VM_TRACE + ndbout_c("Sending extra GSN_LCP_COMPLETE_REP to new master"); +#endif + sendLCP_COMPLETE_REP(signal); + } + + if(!isMaster()){ + c_lcpMasterTakeOverState.set(LMTOS_IDLE, __LINE__); + checkLocalNodefailComplete(signal, failedNodeId, NF_LCP_TAKE_OVER); + } + + return; +} + +NdbOut& +operator<<(NdbOut& out, const Dbdih::LcpMasterTakeOverState state){ + switch(state){ + case Dbdih::LMTOS_IDLE: + out << "LMTOS_IDLE"; + break; + case Dbdih::LMTOS_WAIT_EMPTY_LCP: + out << "LMTOS_WAIT_EMPTY_LCP"; + break; + case Dbdih::LMTOS_WAIT_LCP_FRAG_REP: + out << "LMTOS_WAIT_EMPTY_LCP"; + break; + case Dbdih::LMTOS_INITIAL: + out << "LMTOS_INITIAL"; + break; + case Dbdih::LMTOS_ALL_IDLE: + out << "LMTOS_ALL_IDLE"; + break; + case Dbdih::LMTOS_ALL_ACTIVE: + out << "LMTOS_ALL_ACTIVE"; + break; + case Dbdih::LMTOS_LCP_CONCLUDING: + out << "LMTOS_LCP_CONCLUDING"; + break; + case Dbdih::LMTOS_COPY_ONGOING: + out << "LMTOS_COPY_ONGOING"; + break; + } + return out; +} + +struct MASTERLCP_StateTransitions { + Dbdih::LcpMasterTakeOverState CurrentState; + MasterLCPConf::State ParticipantState; + Dbdih::LcpMasterTakeOverState NewState; +}; + +static const +MASTERLCP_StateTransitions g_masterLCPTakeoverStateTransitions[] = { + /** + * Current = LMTOS_INITIAL + */ + { Dbdih::LMTOS_INITIAL, + MasterLCPConf::LCP_STATUS_IDLE, + Dbdih::LMTOS_ALL_IDLE }, + + { Dbdih::LMTOS_INITIAL, + MasterLCPConf::LCP_STATUS_ACTIVE, + Dbdih::LMTOS_ALL_ACTIVE }, + + { Dbdih::LMTOS_INITIAL, + MasterLCPConf::LCP_TAB_COMPLETED, + Dbdih::LMTOS_LCP_CONCLUDING }, + + { Dbdih::LMTOS_INITIAL, + MasterLCPConf::LCP_TAB_SAVED, + Dbdih::LMTOS_LCP_CONCLUDING }, + + /** + * Current = LMTOS_ALL_IDLE + */ + { Dbdih::LMTOS_ALL_IDLE, + MasterLCPConf::LCP_STATUS_IDLE, + Dbdih::LMTOS_ALL_IDLE }, + + { Dbdih::LMTOS_ALL_IDLE, + MasterLCPConf::LCP_STATUS_ACTIVE, + Dbdih::LMTOS_COPY_ONGOING }, + + { Dbdih::LMTOS_ALL_IDLE, + MasterLCPConf::LCP_TAB_COMPLETED, + Dbdih::LMTOS_LCP_CONCLUDING }, + + { Dbdih::LMTOS_ALL_IDLE, + MasterLCPConf::LCP_TAB_SAVED, + Dbdih::LMTOS_LCP_CONCLUDING }, + + /** + * Current = LMTOS_COPY_ONGOING + */ + { Dbdih::LMTOS_COPY_ONGOING, + MasterLCPConf::LCP_STATUS_IDLE, + Dbdih::LMTOS_COPY_ONGOING }, + + { Dbdih::LMTOS_COPY_ONGOING, + MasterLCPConf::LCP_STATUS_ACTIVE, + Dbdih::LMTOS_COPY_ONGOING }, + + /** + * Current = LMTOS_ALL_ACTIVE + */ + { Dbdih::LMTOS_ALL_ACTIVE, + MasterLCPConf::LCP_STATUS_IDLE, + Dbdih::LMTOS_COPY_ONGOING }, + + { Dbdih::LMTOS_ALL_ACTIVE, + MasterLCPConf::LCP_STATUS_ACTIVE, + Dbdih::LMTOS_ALL_ACTIVE }, + + { Dbdih::LMTOS_ALL_ACTIVE, + MasterLCPConf::LCP_TAB_COMPLETED, + Dbdih::LMTOS_LCP_CONCLUDING }, + + { Dbdih::LMTOS_ALL_ACTIVE, + MasterLCPConf::LCP_TAB_SAVED, + Dbdih::LMTOS_LCP_CONCLUDING }, + + /** + * Current = LMTOS_LCP_CONCLUDING + */ + { Dbdih::LMTOS_LCP_CONCLUDING, + MasterLCPConf::LCP_STATUS_IDLE, + Dbdih::LMTOS_LCP_CONCLUDING }, + + { Dbdih::LMTOS_LCP_CONCLUDING, + MasterLCPConf::LCP_STATUS_ACTIVE, + Dbdih::LMTOS_LCP_CONCLUDING }, + + { Dbdih::LMTOS_LCP_CONCLUDING, + MasterLCPConf::LCP_TAB_COMPLETED, + Dbdih::LMTOS_LCP_CONCLUDING }, + + { Dbdih::LMTOS_LCP_CONCLUDING, + MasterLCPConf::LCP_TAB_SAVED, + Dbdih::LMTOS_LCP_CONCLUDING } +}; + +const Uint32 g_masterLCPTakeoverStateTransitionsRows = +sizeof(g_masterLCPTakeoverStateTransitions) / sizeof(struct MASTERLCP_StateTransitions); + +void Dbdih::execMASTER_LCPCONF(Signal* signal) +{ + const MasterLCPConf * const conf = (MasterLCPConf *)&signal->theData[0]; + jamEntry(); + Uint32 senderNodeId = conf->senderNodeId; + MasterLCPConf::State lcpState = (MasterLCPConf::State)conf->lcpState; + const Uint32 failedNodeId = conf->failedNodeId; + NodeRecordPtr nodePtr; + nodePtr.i = senderNodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + nodePtr.p->lcpStateAtTakeOver = lcpState; + +#ifdef VM_TRACE + ndbout_c("MASTER_LCPCONF"); + printMASTER_LCP_CONF(stdout, &signal->theData[0], 0, 0); +#endif + + bool found = false; + for(Uint32 i = 0; iCurrentState == c_lcpMasterTakeOverState.state && + valid->ParticipantState == lcpState){ + jam(); + found = true; + c_lcpMasterTakeOverState.set(valid->NewState, __LINE__); + break; + } + } + ndbrequire(found); + + bool ok = false; + switch(lcpState){ + case MasterLCPConf::LCP_STATUS_IDLE: + ok = true; + break; + case MasterLCPConf::LCP_STATUS_ACTIVE: + case MasterLCPConf::LCP_TAB_COMPLETED: + case MasterLCPConf::LCP_TAB_SAVED: + ok = true; + c_lcpState.m_LCP_COMPLETE_REP_Counter_DIH.setWaitingFor(nodePtr.i); + break; + } + ndbrequire(ok); + + receiveLoopMacro(MASTER_LCPREQ, senderNodeId); + /*-------------------------------------------------------------------------*/ + // We have now received all responses and are ready to take over the LCP + // protocol as master. + /*-------------------------------------------------------------------------*/ + MASTER_LCPhandling(signal, failedNodeId); +}//Dbdih::execMASTER_LCPCONF() + +void Dbdih::execMASTER_LCPREF(Signal* signal) +{ + const MasterLCPRef * const ref = (MasterLCPRef *)&signal->theData[0]; + jamEntry(); + receiveLoopMacro(MASTER_LCPREQ, ref->senderNodeId); + /*-------------------------------------------------------------------------*/ + // We have now received all responses and are ready to take over the LCP + // protocol as master. + /*-------------------------------------------------------------------------*/ + MASTER_LCPhandling(signal, ref->failedNodeId); +}//Dbdih::execMASTER_LCPREF() + +void Dbdih::MASTER_LCPhandling(Signal* signal, Uint32 failedNodeId) +{ + /*------------------------------------------------------------------------- + * + * WE ARE NOW READY TO CONCLUDE THE TAKE OVER AS MASTER. + * WE HAVE ENOUGH INFO TO START UP ACTIVITIES IN THE PROPER PLACE. + * ALSO SET THE PROPER STATE VARIABLES. + *------------------------------------------------------------------------*/ + c_lcpState.currentFragment.tableId = c_lcpMasterTakeOverState.minTableId; + c_lcpState.currentFragment.fragmentId = c_lcpMasterTakeOverState.minFragId; + c_lcpState.m_LAST_LCP_FRAG_ORD = c_lcpState.m_LCP_COMPLETE_REP_Counter_LQH; + + NodeRecordPtr failedNodePtr; + failedNodePtr.i = failedNodeId; + ptrCheckGuard(failedNodePtr, MAX_NDB_NODES, nodeRecord); + + switch (c_lcpMasterTakeOverState.state) { + case LMTOS_ALL_IDLE: + jam(); + /* --------------------------------------------------------------------- */ + // All nodes were idle in the LCP protocol. Start checking for start of LCP + // protocol. + /* --------------------------------------------------------------------- */ +#ifdef VM_TRACE + ndbout_c("MASTER_LCPhandling:: LMTOS_ALL_IDLE -> checkLcpStart"); +#endif + checkLcpStart(signal, __LINE__); + break; + case LMTOS_COPY_ONGOING: + jam(); + /* --------------------------------------------------------------------- */ + // We were in the starting process of the LCP protocol. We will restart the + // protocol by calculating the keep gci and storing the new lcp id. + /* --------------------------------------------------------------------- */ +#ifdef VM_TRACE + ndbout_c("MASTER_LCPhandling:: LMTOS_COPY_ONGOING -> storeNewLcpId"); +#endif + if (c_lcpState.lcpStatus == LCP_STATUS_ACTIVE) { + jam(); + /*---------------------------------------------------------------------*/ + /* WE NEED TO DECREASE THE LATEST LCP ID SINCE WE HAVE ALREADY */ + /* STARTED THIS */ + /* LOCAL CHECKPOINT. */ + /*---------------------------------------------------------------------*/ + Uint32 lcpId = SYSFILE->latestLCP_ID; +#ifdef VM_TRACE + ndbout_c("Decreasing latestLCP_ID from %d to %d", lcpId, lcpId - 1); +#endif + SYSFILE->latestLCP_ID--; + }//if + storeNewLcpIdLab(signal); + break; + case LMTOS_ALL_ACTIVE: + { + jam(); + /* ------------------------------------------------------------------- + * Everybody was in the active phase. We will restart sending + * LCP_FRAGORD to the nodes from the new master. + * We also need to set dihLcpStatus to ZACTIVE + * in the master node since the master will wait for all nodes to + * complete before finalising the LCP process. + * ------------------------------------------------------------------ */ +#ifdef VM_TRACE + ndbout_c("MASTER_LCPhandling:: LMTOS_ALL_ACTIVE -> " + "startLcpRoundLoopLab(table=%u, fragment=%u)", + c_lcpMasterTakeOverState.minTableId, + c_lcpMasterTakeOverState.minFragId); +#endif + + c_lcpState.keepGci = SYSFILE->keepGCI; + c_lcpState.setLcpStatus(LCP_START_LCP_ROUND, __LINE__); + startLcpRoundLoopLab(signal, 0, 0); + break; + } + case LMTOS_LCP_CONCLUDING: + { + jam(); + /* ------------------------------------------------------------------- */ + // The LCP process is in the finalisation phase. We simply wait for it to + // complete with signals arriving in. We need to check also if we should + // change state due to table write completion during state + // collection phase. + /* ------------------------------------------------------------------- */ + ndbrequire(c_lcpState.lcpStatus != LCP_STATUS_IDLE); + startLcpRoundLoopLab(signal, 0, 0); + break; + } + default: + ndbrequire(false); + break; + }//switch + signal->theData[0] = EventReport::LCP_TakeoverCompleted; + signal->theData[1] = c_lcpMasterTakeOverState.state; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); + + signal->theData[0] = 7012; + execDUMP_STATE_ORD(signal); + + signal->theData[0] = 7015; + execDUMP_STATE_ORD(signal); + + c_lcpMasterTakeOverState.set(LMTOS_IDLE, __LINE__); + + checkLocalNodefailComplete(signal, failedNodePtr.i, NF_LCP_TAKE_OVER); +} + +/* ------------------------------------------------------------------------- */ +/* A BLOCK OR A NODE HAS COMPLETED THE HANDLING OF THE NODE FAILURE. */ +/* ------------------------------------------------------------------------- */ +void Dbdih::execNF_COMPLETEREP(Signal* signal) +{ + NodeRecordPtr failedNodePtr; + NFCompleteRep * const nfCompleteRep = (NFCompleteRep *)&signal->theData[0]; + jamEntry(); + const Uint32 blockNo = nfCompleteRep->blockNo; + Uint32 nodeId = nfCompleteRep->nodeId; + failedNodePtr.i = nfCompleteRep->failedNodeId; + + ptrCheckGuard(failedNodePtr, MAX_NDB_NODES, nodeRecord); + switch (blockNo) { + case DBTC: + jam(); + ndbrequire(failedNodePtr.p->dbtcFailCompleted == ZFALSE); + /* -------------------------------------------------------------------- */ + // Report the event that DBTC completed node failure handling. + /* -------------------------------------------------------------------- */ + signal->theData[0] = EventReport::NodeFailCompleted; + signal->theData[1] = DBTC; + signal->theData[2] = failedNodePtr.i; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB); + + failedNodePtr.p->dbtcFailCompleted = ZTRUE; + break; + case DBDICT: + jam(); + ndbrequire(failedNodePtr.p->dbdictFailCompleted == ZFALSE); + /* --------------------------------------------------------------------- */ + // Report the event that DBDICT completed node failure handling. + /* --------------------------------------------------------------------- */ + signal->theData[0] = EventReport::NodeFailCompleted; + signal->theData[1] = DBDICT; + signal->theData[2] = failedNodePtr.i; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB); + + failedNodePtr.p->dbdictFailCompleted = ZTRUE; + break; + case DBDIH: + jam(); + ndbrequire(failedNodePtr.p->dbdihFailCompleted == ZFALSE); + /* --------------------------------------------------------------------- */ + // Report the event that DBDIH completed node failure handling. + /* --------------------------------------------------------------------- */ + signal->theData[0] = EventReport::NodeFailCompleted; + signal->theData[1] = DBDIH; + signal->theData[2] = failedNodePtr.i; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB); + + failedNodePtr.p->dbdihFailCompleted = ZTRUE; + break; + case DBLQH: + jam(); + ndbrequire(failedNodePtr.p->dblqhFailCompleted == ZFALSE); + /* --------------------------------------------------------------------- */ + // Report the event that DBDIH completed node failure handling. + /* --------------------------------------------------------------------- */ + signal->theData[0] = EventReport::NodeFailCompleted; + signal->theData[1] = DBLQH; + signal->theData[2] = failedNodePtr.i; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB); + + failedNodePtr.p->dblqhFailCompleted = ZTRUE; + break; + case 0: /* Node has finished */ + jam(); + ndbrequire(nodeId < MAX_NDB_NODES); + + if (failedNodePtr.p->recNODE_FAILREP == ZFALSE) { + jam(); + /* ------------------------------------------------------------------- */ + // We received a report about completion of node failure before we + // received the message about the NODE failure ourselves. + // We will send the signal to ourselves with a small delay + // (10 milliseconds). + /* ------------------------------------------------------------------- */ + //nf->from = __LINE__; + sendSignalWithDelay(reference(), GSN_NF_COMPLETEREP, signal, 10, + signal->length()); + return; + }//if + + if (!failedNodePtr.p->m_NF_COMPLETE_REP.isWaitingFor(nodeId)){ + jam(); + return; + } + + failedNodePtr.p->m_NF_COMPLETE_REP.clearWaitingFor(nodeId);; + + /* -------------------------------------------------------------------- */ + // Report the event that nodeId has completed node failure handling. + /* -------------------------------------------------------------------- */ + signal->theData[0] = EventReport::NodeFailCompleted; + signal->theData[1] = 0; + signal->theData[2] = failedNodePtr.i; + signal->theData[3] = nodeId; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 4, JBB); + + nodeFailCompletedCheckLab(signal, failedNodePtr); + return; + break; + default: + ndbrequire(false); + return; + break; + }//switch + if (failedNodePtr.p->dbtcFailCompleted == ZFALSE) { + jam(); + return; + }//if + if (failedNodePtr.p->dbdictFailCompleted == ZFALSE) { + jam(); + return; + }//if + if (failedNodePtr.p->dbdihFailCompleted == ZFALSE) { + jam(); + return; + }//if + if (failedNodePtr.p->dblqhFailCompleted == ZFALSE) { + jam(); + return; + }//if + /* ----------------------------------------------------------------------- */ + /* ALL BLOCKS IN THIS NODE HAVE COMPLETED THEIR PART OF HANDLING THE */ + /* NODE FAILURE. WE CAN NOW REPORT THIS COMPLETION TO ALL OTHER NODES. */ + /* ----------------------------------------------------------------------- */ + NodeRecordPtr nodePtr; + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRecord); + if (nodePtr.p->nodeStatus == NodeRecord::ALIVE) { + jam(); + BlockReference ref = calcDihBlockRef(nodePtr.i); + NFCompleteRep * const nf = (NFCompleteRep *)&signal->theData[0]; + nf->blockNo = 0; + nf->nodeId = cownNodeId; + nf->failedNodeId = failedNodePtr.i; + nf->from = __LINE__; + sendSignal(ref, GSN_NF_COMPLETEREP, signal, + NFCompleteRep::SignalLength, JBB); + }//if + }//for + return; +}//Dbdih::execNF_COMPLETEREP() + +void Dbdih::nodeFailCompletedCheckLab(Signal* signal, + NodeRecordPtr failedNodePtr) +{ + jam(); + if (!failedNodePtr.p->m_NF_COMPLETE_REP.done()){ + jam(); + return; + }//if + /* ---------------------------------------------------------------------- */ + /* ALL BLOCKS IN ALL NODES HAVE NOW REPORTED COMPLETION OF THE NODE */ + /* FAILURE HANDLING. WE ARE NOW READY TO ACCEPT THAT THIS NODE STARTS */ + /* AGAIN. */ + /* ---------------------------------------------------------------------- */ + jam(); + failedNodePtr.p->nodeStatus = NodeRecord::DEAD; + failedNodePtr.p->recNODE_FAILREP = ZFALSE; + + /* ---------------------------------------------------------------------- */ + // Report the event that all nodes completed node failure handling. + /* ---------------------------------------------------------------------- */ + signal->theData[0] = EventReport::NodeFailCompleted; + signal->theData[1] = 0; + signal->theData[2] = failedNodePtr.i; + signal->theData[3] = 0; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 4, JBB); + + /* ---------------------------------------------------------------------- */ + // Report to QMGR that we have concluded recovery handling of this node. + /* ---------------------------------------------------------------------- */ + signal->theData[0] = failedNodePtr.i; + sendSignal(QMGR_REF, GSN_NDB_FAILCONF, signal, 1, JBB); + + if (isMaster()) { + jam(); + /* --------------------------------------------------------------------- */ + /* IF WE ARE MASTER WE MUST CHECK IF COPY FRAGMENT WAS INTERRUPTED */ + /* BY THE FAILED NODES. */ + /* --------------------------------------------------------------------- */ + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = 0; + ptrAss(takeOverPtr, takeOverRecord); + if ((takeOverPtr.p->toMasterStatus == TakeOverRecord::COPY_FRAG) && + (failedNodePtr.i == takeOverPtr.p->toCopyNode)) { + jam(); +#ifdef VM_TRACE + ndbrequire("Tell jonas" == 0); +#endif + /*------------------------------------------------------------------*/ + /* WE ARE CURRENTLY IN THE PROCESS OF COPYING A FRAGMENT. WE */ + /* WILL CHECK IF THE COPY NODE HAVE FAILED. */ + /*------------------------------------------------------------------*/ + takeOverPtr.p->toMasterStatus = TakeOverRecord::SELECTING_NEXT; + startNextCopyFragment(signal, takeOverPtr.i); + return; + }//if + checkStartTakeOver(signal); + }//if + return; +}//Dbdih::nodeFailCompletedCheckLab() + +/*****************************************************************************/ +/* ********** SEIZING / RELEASING MODULE *************/ +/*****************************************************************************/ +/* + 3.4 L O C A L N O D E S E I Z E + ************************************ + */ +/* + 3.4.1 L O C A L N O D E S E I Z E R E Q U E S T + ****************************************************** + */ +void Dbdih::execDISEIZEREQ(Signal* signal) +{ + ConnectRecordPtr connectPtr; + jamEntry(); + Uint32 userPtr = signal->theData[0]; + BlockReference userRef = signal->theData[1]; + ndbrequire(cfirstconnect != RNIL); + connectPtr.i = cfirstconnect; + ptrCheckGuard(connectPtr, cconnectFileSize, connectRecord); + cfirstconnect = connectPtr.p->nfConnect; + connectPtr.p->nfConnect = RNIL; + connectPtr.p->userpointer = userPtr; + connectPtr.p->userblockref = userRef; + connectPtr.p->connectState = ConnectRecord::INUSE; + signal->theData[0] = connectPtr.p->userpointer; + signal->theData[1] = connectPtr.i; + sendSignal(userRef, GSN_DISEIZECONF, signal, 2, JBB); +}//Dbdih::execDISEIZEREQ() + +/* + 3.5 L O C A L N O D E R E L E A S E + **************************************** + */ +/* + 3.5.1 L O C A L N O D E R E L E A S E R E Q U E S T + *******************************************************= + */ +void Dbdih::execDIRELEASEREQ(Signal* signal) +{ + ConnectRecordPtr connectPtr; + jamEntry(); + connectPtr.i = signal->theData[0]; + Uint32 userRef = signal->theData[2]; + ptrCheckGuard(connectPtr, cconnectFileSize, connectRecord); + ndbrequire(connectPtr.p->connectState != ConnectRecord::FREE); + ndbrequire(connectPtr.p->userblockref == userRef); + connectPtr.p->connectState = ConnectRecord::FREE; + signal->theData[0] = connectPtr.p->userpointer; + sendSignal(connectPtr.p->userblockref, GSN_DIRELEASECONF, signal, 1, JBB); + connectPtr.p->nfConnect = cfirstconnect; + cfirstconnect = connectPtr.i; + connectPtr.p->userblockref = ZNIL; + connectPtr.p->userpointer = RNIL; +}//Dbdih::execDIRELEASEREQ() + +/* + 3.7 A D D T A B L E + **********************= + */ +/*****************************************************************************/ +/* ********** TABLE ADDING MODULE *************/ +/*****************************************************************************/ +/* + 3.7.1 A D D T A B L E M A I N L Y + *************************************** + */ +void Dbdih::execCREATE_FRAGMENTATION_REQ(Signal * signal){ + jamEntry(); + CreateFragmentationReq * const req = + (CreateFragmentationReq*)signal->getDataPtr(); + + const Uint32 senderRef = req->senderRef; + const Uint32 senderData = req->senderData; + const Uint32 fragmentNode = req->fragmentNode; + const Uint32 fragmentType = req->fragmentationType; + //const Uint32 fragmentCount = req->noOfFragments; + const Uint32 primaryTableId = req->primaryTableId; + + Uint32 err = 0; + + do { + Uint32 noOfFragments = 0; + Uint32 noOfReplicas = cnoReplicas; + switch(fragmentType){ + case DictTabInfo::AllNodesSmallTable: + jam(); + noOfFragments = cnoOfNodeGroups; + break; + case DictTabInfo::AllNodesMediumTable: + jam(); + noOfFragments = 2 * cnoOfNodeGroups; + break; + case DictTabInfo::AllNodesLargeTable: + jam(); + noOfFragments = 8 * cnoOfNodeGroups; + break; + case DictTabInfo::SingleFragment: + jam(); + noOfFragments = 1; + break; +#if 0 + case DictTabInfo::SpecifiedFragmentCount: + noOfFragments = (fragmentCount == 0 ? 1 : (fragmentCount + 1)/ 2); + break; +#endif + default: + jam(); + err = CreateFragmentationRef::InvalidFragmentationType; + break; + } + if(err) + break; + + NodeGroupRecordPtr NGPtr; + TabRecordPtr primTabPtr; + if (primaryTableId == RNIL) { + if(fragmentNode == 0){ + jam(); + NGPtr.i = c_nextNodeGroup; + c_nextNodeGroup = (NGPtr.i + 1 == cnoOfNodeGroups ? 0 : NGPtr.i + 1); + } else if(! (fragmentNode < MAX_NDB_NODES)) { + jam(); + err = CreateFragmentationRef::InvalidNodeId; + } else { + jam(); + const Uint32 stat = Sysfile::getNodeStatus(fragmentNode, + SYSFILE->nodeStatus); + switch (stat) { + case Sysfile::NS_Active: + case Sysfile::NS_ActiveMissed_1: + case Sysfile::NS_ActiveMissed_2: + case Sysfile::NS_TakeOver: + jam(); + break; + case Sysfile::NS_NotActive_NotTakenOver: + jam(); + break; + case Sysfile::NS_HotSpare: + jam(); + case Sysfile::NS_NotDefined: + jam(); + default: + jam(); + err = CreateFragmentationRef::InvalidNodeType; + break; + } + if(err) + break; + NGPtr.i = Sysfile::getNodeGroup(fragmentNode, + SYSFILE->nodeGroups); + break; + } + } else { + if (primaryTableId >= ctabFileSize) { + jam(); + err = CreateFragmentationRef::InvalidPrimaryTable; + break; + } + primTabPtr.i = primaryTableId; + ptrAss(primTabPtr, tabRecord); + if (primTabPtr.p->tabStatus != TabRecord::TS_ACTIVE) { + jam(); + err = CreateFragmentationRef::InvalidPrimaryTable; + break; + } + if (noOfFragments != primTabPtr.p->totalfragments) { + jam(); + err = CreateFragmentationRef::InvalidFragmentationType; + break; + } + } + + //@todo use section writer + Uint32 count = 2; + Uint32 fragments[2 + 8*MAX_REPLICAS*MAX_NDB_NODES]; + if (primaryTableId == RNIL) { + jam(); + for(Uint32 fragNo = 0; fragNonextReplicaNode; + const Uint32 max = NGPtr.p->nodeCount; + + //------------------------------------------------------------------- + // We make an extra step to ensure that the primary replicas are + // spread among the nodes. + //------------------------------------------------------------------- + NGPtr.p->nextReplicaNode = (ind + 1 >= max ? 0 : ind + 1); + + for(Uint32 replicaNo = 0; replicaNonodesInGroup[ind++]; + fragments[count++] = nodeId; + ind = (ind == max ? 0 : ind); + } + + /** + * Next node group for next fragment + */ + NGPtr.i++; + NGPtr.i = (NGPtr.i == cnoOfNodeGroups ? 0 : NGPtr.i); + } + } else { + for (Uint32 fragNo = 0; + fragNo < primTabPtr.p->totalfragments; fragNo++) { + jam(); + FragmentstorePtr fragPtr; + ReplicaRecordPtr replicaPtr; + getFragstore(primTabPtr.p, fragNo, fragPtr); + fragments[count++] = fragPtr.p->preferredPrimary; + for (replicaPtr.i = fragPtr.p->storedReplicas; + replicaPtr.i != RNIL; + replicaPtr.i = replicaPtr.p->nextReplica) { + jam(); + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + if (replicaPtr.p->procNode != fragPtr.p->preferredPrimary) { + jam(); + fragments[count++] = replicaPtr.p->procNode; + }//if + }//for + for (replicaPtr.i = fragPtr.p->oldStoredReplicas; + replicaPtr.i != RNIL; + replicaPtr.i = replicaPtr.p->nextReplica) { + jam(); + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + if (replicaPtr.p->procNode != fragPtr.p->preferredPrimary) { + jam(); + fragments[count++] = replicaPtr.p->procNode; + }//if + }//for + } + } + ndbrequire(count == (2 + noOfReplicas * noOfFragments)); + + CreateFragmentationConf * const conf = + (CreateFragmentationConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = senderData; + conf->noOfReplicas = noOfReplicas; + conf->noOfFragments = noOfFragments; + + fragments[0] = noOfReplicas; + fragments[1] = noOfFragments; + + LinearSectionPtr ptr[3]; + ptr[0].p = &fragments[0]; + ptr[0].sz = count; + sendSignal(senderRef, + GSN_CREATE_FRAGMENTATION_CONF, + signal, + CreateFragmentationConf::SignalLength, + JBB, + ptr, + 1); + return; + } while(false); + + CreateFragmentationRef * const ref = + (CreateFragmentationRef*)signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = senderData; + ref->errorCode = err; + sendSignal(senderRef, GSN_CREATE_FRAGMENTATION_REF, signal, + CreateFragmentationRef::SignalLength, JBB); +} + +void Dbdih::execDIADDTABREQ(Signal* signal) +{ + jamEntry(); + + DiAddTabReq * const req = (DiAddTabReq*)signal->getDataPtr(); + + // Seize connect record + ndbrequire(cfirstconnect != RNIL); + ConnectRecordPtr connectPtr; + connectPtr.i = cfirstconnect; + ptrCheckGuard(connectPtr, cconnectFileSize, connectRecord); + cfirstconnect = connectPtr.p->nfConnect; + + const Uint32 userPtr = req->connectPtr; + const BlockReference userRef = signal->getSendersBlockRef(); + connectPtr.p->nfConnect = RNIL; + connectPtr.p->userpointer = userPtr; + connectPtr.p->userblockref = userRef; + connectPtr.p->connectState = ConnectRecord::INUSE; + connectPtr.p->table = req->tableId; + + TabRecordPtr tabPtr; + tabPtr.i = req->tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + tabPtr.p->connectrec = connectPtr.i; + tabPtr.p->tableType = req->tableType; + tabPtr.p->schemaVersion = req->schemaVersion; + tabPtr.p->primaryTableId = req->primaryTableId; + + if(tabPtr.p->tabStatus == TabRecord::TS_ACTIVE){ + jam(); + tabPtr.p->tabStatus = TabRecord::TS_CREATING; + sendAddFragreq(signal, connectPtr, tabPtr, 0); + return; + } + + if(getNodeState().getSystemRestartInProgress() && + tabPtr.p->tabStatus == TabRecord::TS_IDLE){ + jam(); + + ndbrequire(cmasterNodeId == getOwnNodeId()); + tabPtr.p->tabStatus = TabRecord::TS_CREATING; + + initTableFile(tabPtr); + FileRecordPtr filePtr; + filePtr.i = tabPtr.p->tabFile[0]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + openFileRw(signal, filePtr); + filePtr.p->reqStatus = FileRecord::OPENING_TABLE; + return; + } + + /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/ + /* AT THE TIME OF INITIATING THE FILE OF TABLE */ + /* DESCRIPTION IS CREATED FOR APPROPRIATE SIZE. EACH */ + /* EACH RECORD IN THIS FILE HAS THE INFORMATION ABOUT */ + /* ONE TABLE. THE POINTER TO THIS RECORD IS THE TABLE */ + /* REFERENCE. IN THE BEGINNING ALL RECORDS ARE CREATED */ + /* BUT THEY DO NOT HAVE ANY INFORMATION ABOUT ANY TABLE*/ + /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/ + tabPtr.p->tabStatus = TabRecord::TS_CREATING; + tabPtr.p->storedTable = req->storedTable; + tabPtr.p->method = TabRecord::HASH; + tabPtr.p->kvalue = req->kValue; + + Uint32 fragments[2 + 8*MAX_REPLICAS*MAX_NDB_NODES]; + SegmentedSectionPtr fragDataPtr; + signal->getSection(fragDataPtr, DiAddTabReq::FRAGMENTATION); + copy(fragments, fragDataPtr); + releaseSections(signal); + + const Uint32 noReplicas = fragments[0]; + const Uint32 noFragments = fragments[1]; + + tabPtr.p->noOfBackups = noReplicas - 1; + tabPtr.p->totalfragments = noFragments; + ndbrequire(noReplicas == cnoReplicas); // Only allowed + + if ((noReplicas * noFragments) > cnoFreeReplicaRec) { + jam(); + addtabrefuseLab(signal, connectPtr, ZREPLERROR1); + return; + }//if + if (noFragments > cremainingfrags) { + jam(); + addtabrefuseLab(signal, connectPtr, ZREPLERROR1); + return; + }//if + + Uint32 logTotalFragments = 1; + while (logTotalFragments <= tabPtr.p->totalfragments) { + jam(); + logTotalFragments <<= 1; + } + logTotalFragments >>= 1; + tabPtr.p->mask = logTotalFragments - 1; + tabPtr.p->hashpointer = tabPtr.p->totalfragments - logTotalFragments; + allocFragments(tabPtr.p->totalfragments, tabPtr); + + Uint32 index = 2; + for (Uint32 fragId = 0; fragId < noFragments; fragId++) { + jam(); + FragmentstorePtr fragPtr; + Uint32 activeIndex = 0; + getFragstore(tabPtr.p, fragId, fragPtr); + fragPtr.p->preferredPrimary = fragments[index]; + for (Uint32 i = 0; iactiveNodes[activeIndex] = nodeId; + activeIndex++; + } else { + jam(); + removeStoredReplica(fragPtr, replicaPtr); + linkOldStoredReplica(fragPtr, replicaPtr); + }//if + }//for + fragPtr.p->fragReplicas = activeIndex; + ndbrequire(activeIndex > 0 && fragPtr.p->storedReplicas != RNIL); + } + initTableFile(tabPtr); + tabPtr.p->tabCopyStatus = TabRecord::CS_ADD_TABLE_MASTER; + signal->theData[0] = DihContinueB::ZPACK_TABLE_INTO_PAGES; + signal->theData[1] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); +} + +void +Dbdih::addTable_closeConf(Signal * signal, Uint32 tabPtrI){ + TabRecordPtr tabPtr; + tabPtr.i = tabPtrI; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + + ConnectRecordPtr connectPtr; + connectPtr.i = tabPtr.p->connectrec; + ptrCheckGuard(connectPtr, cconnectFileSize, connectRecord); + + sendAddFragreq(signal, connectPtr, tabPtr, 0); +} + +void +Dbdih::sendAddFragreq(Signal* signal, ConnectRecordPtr connectPtr, + TabRecordPtr tabPtr, Uint32 fragId){ + jam(); + const Uint32 fragCount = tabPtr.p->totalfragments; + ReplicaRecordPtr replicaPtr; replicaPtr.i = RNIL; + for(; fragIdstoredReplicas; + while(replicaPtr.i != RNIL){ + jam(); + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + if(replicaPtr.p->procNode == getOwnNodeId()){ + break; + } + replicaPtr.i = replicaPtr.p->nextReplica; + } + + if(replicaPtr.i != RNIL){ + jam(); + break; + } + + replicaPtr.i = fragPtr.p->oldStoredReplicas; + while(replicaPtr.i != RNIL){ + jam(); + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + if(replicaPtr.p->procNode == getOwnNodeId()){ + break; + } + replicaPtr.i = replicaPtr.p->nextReplica; + } + + if(replicaPtr.i != RNIL){ + jam(); + break; + } + } + + if(replicaPtr.i != RNIL){ + jam(); + ndbrequire(fragId < fragCount); + ndbrequire(replicaPtr.p->procNode == getOwnNodeId()); + + Uint32 requestInfo = 0; + if(!tabPtr.p->storedTable){ + requestInfo |= LqhFragReq::TemporaryTable; + } + + if(getNodeState().getNodeRestartInProgress()){ + requestInfo |= LqhFragReq::CreateInRunning; + } + + AddFragReq* const req = (AddFragReq*)signal->getDataPtr(); + req->dihPtr = connectPtr.i; + req->senderData = connectPtr.p->userpointer; + req->fragmentId = fragId; + req->requestInfo = requestInfo; + req->tableId = tabPtr.i; + req->nextLCP = 0; + req->nodeId = getOwnNodeId(); + req->totalFragments = fragCount; + req->startGci = SYSFILE->newestRestorableGCI; + sendSignal(DBDICT_REF, GSN_ADD_FRAGREQ, signal, + AddFragReq::SignalLength, JBB); + return; + } + + // Done + DiAddTabConf * const conf = (DiAddTabConf*)signal->getDataPtr(); + conf->senderData = connectPtr.p->userpointer; + sendSignal(connectPtr.p->userblockref, GSN_DIADDTABCONF, signal, + DiAddTabConf::SignalLength, JBB); + + // Release + connectPtr.p->userblockref = ZNIL; + connectPtr.p->userpointer = RNIL; + connectPtr.p->connectState = ConnectRecord::FREE; + connectPtr.p->nfConnect = cfirstconnect; + cfirstconnect = connectPtr.i; +} + +void +Dbdih::execADD_FRAGCONF(Signal* signal){ + jamEntry(); + AddFragConf * const conf = (AddFragConf*)signal->getDataPtr(); + + ConnectRecordPtr connectPtr; + connectPtr.i = conf->dihPtr; + ptrCheckGuard(connectPtr, cconnectFileSize, connectRecord); + + TabRecordPtr tabPtr; + tabPtr.i = connectPtr.p->table; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + + sendAddFragreq(signal, connectPtr, tabPtr, conf->fragId + 1); +} + +void +Dbdih::execADD_FRAGREF(Signal* signal){ + jamEntry(); + AddFragRef * const ref = (AddFragRef*)signal->getDataPtr(); + + ConnectRecordPtr connectPtr; + connectPtr.i = ref->dihPtr; + ptrCheckGuard(connectPtr, cconnectFileSize, connectRecord); + + { + DiAddTabRef * const ref = (DiAddTabRef*)signal->getDataPtr(); + ref->senderData = connectPtr.p->userpointer; + ref->errorCode = ~0; + sendSignal(connectPtr.p->userblockref, GSN_DIADDTABREF, signal, + DiAddTabRef::SignalLength, JBB); + } + + // Release + connectPtr.p->userblockref = ZNIL; + connectPtr.p->userpointer = RNIL; + connectPtr.p->connectState = ConnectRecord::FREE; + connectPtr.p->nfConnect = cfirstconnect; + cfirstconnect = connectPtr.i; +} + +/* + 3.7.1.3 R E F U S E + ********************* + */ +void Dbdih::addtabrefuseLab(Signal* signal, ConnectRecordPtr connectPtr, Uint32 errorCode) +{ + connectPtr.p->connectState = ConnectRecord::INUSE; + signal->theData[0] = connectPtr.p->userpointer; + signal->theData[1] = errorCode; + sendSignal(connectPtr.p->userblockref, GSN_DIADDTABREF, signal, 2, JBB); + return; +}//Dbdih::addtabrefuseLab() + +/* + 3.7.2 A D D T A B L E D U P L I C A T I O N + ************************************************* + */ +/* + 3.7.2.1 A D D T A B L E D U P L I C A T I O N R E Q U E S T + *******************************************************************= + */ + +/* + D E L E T E T A B L E + **********************= + */ +/*****************************************************************************/ +/*********** DELETE TABLE MODULE *************/ +/*****************************************************************************/ +void +Dbdih::execDROP_TAB_REQ(Signal* signal){ + jamEntry(); + DropTabReq* req = (DropTabReq*)signal->getDataPtr(); + + TabRecordPtr tabPtr; + tabPtr.i = req->tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + + tabPtr.p->m_dropTab.tabUserRef = req->senderRef; + tabPtr.p->m_dropTab.tabUserPtr = req->senderData; + + DropTabReq::RequestType rt = (DropTabReq::RequestType)req->requestType; + + switch(rt){ + case DropTabReq::OnlineDropTab: + jam(); + ndbrequire(tabPtr.p->tabStatus == TabRecord::TS_DROPPING); + releaseTable(tabPtr); + break; + case DropTabReq::CreateTabDrop: + jam(); + releaseTable(tabPtr); + break; + case DropTabReq::RestartDropTab: + break; + } + + startDeleteFile(signal, tabPtr); +} + +void Dbdih::startDeleteFile(Signal* signal, TabRecordPtr tabPtr) +{ + if (tabPtr.p->tabFile[0] == RNIL) { + jam(); + initTableFile(tabPtr); + }//if + openTableFileForDelete(signal, tabPtr.p->tabFile[0]); +}//Dbdih::startDeleteFile() + +void Dbdih::openTableFileForDelete(Signal* signal, Uint32 fileIndex) +{ + FileRecordPtr filePtr; + filePtr.i = fileIndex; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + openFileRw(signal, filePtr); + filePtr.p->reqStatus = FileRecord::TABLE_OPEN_FOR_DELETE; +}//Dbdih::openTableFileForDelete() + +void Dbdih::tableOpenLab(Signal* signal, FileRecordPtr filePtr) +{ + closeFileDelete(signal, filePtr); + filePtr.p->reqStatus = FileRecord::TABLE_CLOSE_DELETE; + return; +}//Dbdih::tableOpenLab() + +void Dbdih::tableDeleteLab(Signal* signal, FileRecordPtr filePtr) +{ + TabRecordPtr tabPtr; + tabPtr.i = filePtr.p->tabRef; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + if (filePtr.i == tabPtr.p->tabFile[0]) { + jam(); + openTableFileForDelete(signal, tabPtr.p->tabFile[1]); + return; + }//if + ndbrequire(filePtr.i == tabPtr.p->tabFile[1]); + + releaseFile(tabPtr.p->tabFile[0]); + releaseFile(tabPtr.p->tabFile[1]); + tabPtr.p->tabFile[0] = tabPtr.p->tabFile[1] = RNIL; + + tabPtr.p->tabStatus = TabRecord::TS_IDLE; + + DropTabConf * const dropConf = (DropTabConf *)signal->getDataPtrSend(); + dropConf->senderRef = reference(); + dropConf->senderData = tabPtr.p->m_dropTab.tabUserPtr; + dropConf->tableId = tabPtr.i; + sendSignal(tabPtr.p->m_dropTab.tabUserRef, GSN_DROP_TAB_CONF, + signal, DropTabConf::SignalLength, JBB); + + tabPtr.p->m_dropTab.tabUserPtr = RNIL; + tabPtr.p->m_dropTab.tabUserRef = 0; +}//Dbdih::tableDeleteLab() + + +void Dbdih::releaseTable(TabRecordPtr tabPtr) +{ + FragmentstorePtr fragPtr; + for (Uint32 fragId = 0; fragId < tabPtr.p->totalfragments; fragId++) { + jam(); + getFragstore(tabPtr.p, fragId, fragPtr); + releaseReplicas(fragPtr.p->storedReplicas); + releaseReplicas(fragPtr.p->oldStoredReplicas); + }//for + releaseFragments(tabPtr); + if (tabPtr.p->tabFile[0] != RNIL) { + jam(); + releaseFile(tabPtr.p->tabFile[0]); + releaseFile(tabPtr.p->tabFile[1]); + tabPtr.p->tabFile[0] = tabPtr.p->tabFile[1] = RNIL; + }//if +}//Dbdih::releaseTable() + +void Dbdih::releaseReplicas(Uint32 replicaPtrI) +{ + ReplicaRecordPtr replicaPtr; + replicaPtr.i = replicaPtrI; + jam(); + while (replicaPtr.i != RNIL) { + jam(); + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + Uint32 tmp = replicaPtr.p->nextReplica; + replicaPtr.p->nextReplica = cfirstfreeReplica; + cfirstfreeReplica = replicaPtr.i; + replicaPtr.i = tmp; + cnoFreeReplicaRec++; + }//while +}//Dbdih::releaseReplicas() + +void Dbdih::seizeReplicaRec(ReplicaRecordPtr& replicaPtr) +{ + replicaPtr.i = cfirstfreeReplica; + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + cfirstfreeReplica = replicaPtr.p->nextReplica; + cnoFreeReplicaRec--; + replicaPtr.p->nextReplica = RNIL; +}//Dbdih::seizeReplicaRec() + +void Dbdih::releaseFile(Uint32 fileIndex) +{ + FileRecordPtr filePtr; + filePtr.i = fileIndex; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + filePtr.p->nextFile = cfirstfreeFile; + cfirstfreeFile = filePtr.i; +}//Dbdih::releaseFile() + + +void Dbdih::execALTER_TAB_REQ(Signal * signal) +{ + AlterTabReq* const req = (AlterTabReq*)signal->getDataPtr(); + const Uint32 senderRef = req->senderRef; + const Uint32 senderData = req->senderData; + const Uint32 changeMask = req->changeMask; + const Uint32 tableId = req->tableId; + const Uint32 tableVersion = req->tableVersion; + const Uint32 gci = req->gci; + AlterTabReq::RequestType requestType = + (AlterTabReq::RequestType) req->requestType; + + TabRecordPtr tabPtr; + tabPtr.i = tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + tabPtr.p->schemaVersion = tableVersion; + + // Request handled successfully + AlterTabConf * conf = (AlterTabConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = senderData; + conf->changeMask = changeMask; + conf->tableId = tableId; + conf->tableVersion = tableVersion; + conf->gci = gci; + conf->requestType = requestType; + sendSignal(senderRef, GSN_ALTER_TAB_CONF, signal, + AlterTabConf::SignalLength, JBB); +} + +/* + G E T N O D E S + **********************= + */ +/*****************************************************************************/ +/* ********** TRANSACTION HANDLING MODULE *************/ +/*****************************************************************************/ +/* + 3.8.1 G E T N O D E S R E Q U E S T + ****************************************** + Asks what nodes should be part of a transaction. +*/ +void Dbdih::execDIGETNODESREQ(Signal* signal) +{ + const DiGetNodesReq * const req = (DiGetNodesReq *)&signal->theData[0]; + FragmentstorePtr fragPtr; + TabRecordPtr tabPtr; + tabPtr.i = req->tableId; + Uint32 hashValue = req->hashValue; + Uint32 ttabFileSize = ctabFileSize; + TabRecord* regTabDesc = tabRecord; + jamEntry(); + ptrCheckGuard(tabPtr, ttabFileSize, regTabDesc); + hashValue = hashValue >> tabPtr.p->kvalue; + Uint32 fragId = tabPtr.p->mask & hashValue; + ndbrequire(tabPtr.p->tabStatus == TabRecord::TS_ACTIVE); + if (fragId < tabPtr.p->hashpointer) { + jam(); + fragId = hashValue & ((tabPtr.p->mask << 1) + 1); + }//if + getFragstore(tabPtr.p, fragId, fragPtr); + DiGetNodesConf * const conf = (DiGetNodesConf *)&signal->theData[0]; + Uint32 nodeCount = extractNodeInfo(fragPtr.p, conf->nodes); + Uint32 sig2 = (nodeCount - 1) + + (fragPtr.p->distributionKey << 16); + conf->zero = 0; + conf->reqinfo = sig2; + conf->fragId = fragId; +}//Dbdih::execDIGETNODESREQ() + +Uint32 Dbdih::extractNodeInfo(const Fragmentstore * fragPtr, Uint32 nodes[]) +{ + Uint32 nodeCount = 0; + for (Uint32 i = 0; i < fragPtr->fragReplicas; i++) { + jam(); + NodeRecordPtr nodePtr; + ndbrequire(i < MAX_REPLICAS); + nodePtr.i = fragPtr->activeNodes[i]; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + if (nodePtr.p->useInTransactions) { + jam(); + nodes[nodeCount] = nodePtr.i; + nodeCount++; + }//if + }//for + ndbrequire(nodeCount > 0); + return nodeCount; +}//Dbdih::extractNodeInfo() + +#define NO_OF_FRAGS_PER_CHUNK 16 +#define LOG_NO_OF_FRAGS_PER_CHUNK 4 + +void +Dbdih::getFragstore(TabRecord * tab, //In parameter + Uint32 fragNo, //In parameter + FragmentstorePtr & fragptr) //Out parameter +{ + FragmentstorePtr fragPtr; + Uint32 chunkNo = fragNo >> LOG_NO_OF_FRAGS_PER_CHUNK; + Uint32 chunkIndex = fragNo & (NO_OF_FRAGS_PER_CHUNK - 1); + Uint32 TfragstoreFileSize = cfragstoreFileSize; + Fragmentstore* TfragStore = fragmentstore; + if (chunkNo < MAX_NDB_NODES) { + fragPtr.i = tab->startFid[chunkNo] + chunkIndex; + ptrCheckGuard(fragPtr, TfragstoreFileSize, TfragStore); + fragptr = fragPtr; + return; + }//if + ndbrequire(false); +}//Dbdih::getFragstore() + +void Dbdih::allocFragments(Uint32 noOfFragments, TabRecordPtr tabPtr) +{ + FragmentstorePtr fragPtr; + Uint32 noOfChunks = (noOfFragments + (NO_OF_FRAGS_PER_CHUNK - 1)) >> LOG_NO_OF_FRAGS_PER_CHUNK; + ndbrequire(cremainingfrags >= noOfFragments); + for (Uint32 i = 0; i < noOfChunks; i++) { + jam(); + Uint32 baseFrag = cfirstfragstore; + tabPtr.p->startFid[i] = baseFrag; + fragPtr.i = baseFrag; + ptrCheckGuard(fragPtr, cfragstoreFileSize, fragmentstore); + cfirstfragstore = fragPtr.p->nextFragmentChunk; + cremainingfrags -= NO_OF_FRAGS_PER_CHUNK; + for (Uint32 j = 0; j < NO_OF_FRAGS_PER_CHUNK; j++) { + jam(); + fragPtr.i = baseFrag + j; + ptrCheckGuard(fragPtr, cfragstoreFileSize, fragmentstore); + initFragstore(fragPtr); + }//if + }//for + tabPtr.p->noOfFragChunks = noOfChunks; +}//Dbdih::allocFragments() + +void Dbdih::releaseFragments(TabRecordPtr tabPtr) +{ + FragmentstorePtr fragPtr; + for (Uint32 i = 0; i < tabPtr.p->noOfFragChunks; i++) { + jam(); + Uint32 baseFrag = tabPtr.p->startFid[i]; + fragPtr.i = baseFrag; + ptrCheckGuard(fragPtr, cfragstoreFileSize, fragmentstore); + fragPtr.p->nextFragmentChunk = cfirstfragstore; + cfirstfragstore = baseFrag; + tabPtr.p->startFid[i] = RNIL; + cremainingfrags += NO_OF_FRAGS_PER_CHUNK; + }//for + tabPtr.p->noOfFragChunks = 0; +}//Dbdih::releaseFragments() + +void Dbdih::initialiseFragstore() +{ + FragmentstorePtr fragPtr; + for (Uint32 i = 0; i < cfragstoreFileSize; i++) { + fragPtr.i = i; + ptrCheckGuard(fragPtr, cfragstoreFileSize, fragmentstore); + initFragstore(fragPtr); + }//for + Uint32 noOfChunks = cfragstoreFileSize >> LOG_NO_OF_FRAGS_PER_CHUNK; + fragPtr.i = 0; + cfirstfragstore = RNIL; + cremainingfrags = 0; + for (Uint32 i = 0; i < noOfChunks; i++) { + ptrCheckGuard(fragPtr, cfragstoreFileSize, fragmentstore); + fragPtr.p->nextFragmentChunk = cfirstfragstore; + cfirstfragstore = fragPtr.i; + fragPtr.i += NO_OF_FRAGS_PER_CHUNK; + cremainingfrags += NO_OF_FRAGS_PER_CHUNK; + }//for +}//Dbdih::initialiseFragstore() + +/* + 3.9 V E R I F I C A T I O N + ****************************= + */ +/****************************************************************************/ +/* ********** VERIFICATION SUB-MODULE *************/ +/****************************************************************************/ +/* + 3.9.1 R E C E I V I N G O F V E R I F I C A T I O N R E Q U E S T + ************************************************************************* + */ +void Dbdih::execDIVERIFYREQ(Signal* signal) +{ + + jamEntry(); + if ((getBlockCommit() == false) && + (cfirstVerifyQueue == RNIL)) { + jam(); + /*-----------------------------------------------------------------------*/ + // We are not blocked and the verify queue was empty currently so we can + // simply reply back to TC immediately. The method was called with + // EXECUTE_DIRECT so we reply back by setting signal data and returning. + // theData[0] already contains the correct information so + // we need not touch it. + /*-----------------------------------------------------------------------*/ + signal->theData[1] = currentgcp; + signal->theData[2] = 0; + return; + }//if + /*-------------------------------------------------------------------------*/ + // Since we are blocked we need to put this operation last in the verify + // queue to ensure that operation starts up in the correct order. + /*-------------------------------------------------------------------------*/ + ApiConnectRecordPtr tmpApiConnectptr; + ApiConnectRecordPtr localApiConnectptr; + + cverifyQueueCounter++; + localApiConnectptr.i = signal->theData[0]; + tmpApiConnectptr.i = clastVerifyQueue; + ptrCheckGuard(localApiConnectptr, capiConnectFileSize, apiConnectRecord); + localApiConnectptr.p->apiGci = cnewgcp; + localApiConnectptr.p->nextApi = RNIL; + clastVerifyQueue = localApiConnectptr.i; + if (tmpApiConnectptr.i == RNIL) { + jam(); + cfirstVerifyQueue = localApiConnectptr.i; + } else { + jam(); + ptrCheckGuard(tmpApiConnectptr, capiConnectFileSize, apiConnectRecord); + tmpApiConnectptr.p->nextApi = localApiConnectptr.i; + }//if + emptyverificbuffer(signal, false); + signal->theData[2] = 1; // Indicate no immediate return + return; +}//Dbdih::execDIVERIFYREQ() + +void Dbdih::execDI_FCOUNTREQ(Signal* signal) +{ + ConnectRecordPtr connectPtr; + TabRecordPtr tabPtr; + jamEntry(); + connectPtr.i = signal->theData[0]; + tabPtr.i = signal->theData[1]; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + + ndbrequire(tabPtr.p->tabStatus == TabRecord::TS_ACTIVE); + + if(connectPtr.i != RNIL){ + ptrCheckGuard(connectPtr, cconnectFileSize, connectRecord); + if (connectPtr.p->connectState == ConnectRecord::INUSE) { + jam(); + signal->theData[0] = connectPtr.p->userpointer; + signal->theData[1] = tabPtr.p->totalfragments; + sendSignal(connectPtr.p->userblockref, GSN_DI_FCOUNTCONF, signal,2, JBB); + return; + }//if + signal->theData[0] = connectPtr.p->userpointer; + signal->theData[1] = ZERRONOUSSTATE; + sendSignal(connectPtr.p->userblockref, GSN_DI_FCOUNTREF, signal, 2, JBB); + return; + }//if + + //connectPtr.i == RNIL -> question without connect record + const Uint32 senderData = signal->theData[2]; + const BlockReference senderRef = signal->senderBlockRef(); + signal->theData[0] = RNIL; + signal->theData[1] = tabPtr.p->totalfragments; + signal->theData[2] = tabPtr.i; + signal->theData[3] = senderData; + signal->theData[4] = tabPtr.p->noOfBackups; + sendSignal(senderRef, GSN_DI_FCOUNTCONF, signal, 5, JBB); +}//Dbdih::execDI_FCOUNTREQ() + +void Dbdih::execDIGETPRIMREQ(Signal* signal) +{ + FragmentstorePtr fragPtr; + ConnectRecordPtr connectPtr; + TabRecordPtr tabPtr; + jamEntry(); + Uint32 passThrough = signal->theData[1]; + tabPtr.i = signal->theData[2]; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + if (DictTabInfo::isOrderedIndex(tabPtr.p->tableType)) { + jam(); + tabPtr.i = tabPtr.p->primaryTableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + } + Uint32 fragId = signal->theData[3]; + + ndbrequire(tabPtr.p->tabStatus == TabRecord::TS_ACTIVE); + connectPtr.i = signal->theData[0]; + if(connectPtr.i != RNIL){ + jam(); + ptrCheckGuard(connectPtr, cconnectFileSize, connectRecord); + ndbrequire(connectPtr.p->connectState == ConnectRecord::INUSE); + getFragstore(tabPtr.p, fragId, fragPtr); + connectPtr.p->nodeCount = extractNodeInfo(fragPtr.p, connectPtr.p->nodes); + signal->theData[0] = connectPtr.p->userpointer; + signal->theData[1] = passThrough; + signal->theData[2] = connectPtr.p->nodes[0]; + sendSignal(connectPtr.p->userblockref, GSN_DIGETPRIMCONF, signal, 3, JBB); + return; + }//if + //connectPtr.i == RNIL -> question without connect record + Uint32 nodes[MAX_REPLICAS]; + getFragstore(tabPtr.p, fragId, fragPtr); + Uint32 count = extractNodeInfo(fragPtr.p, nodes); + + signal->theData[0] = RNIL; + signal->theData[1] = passThrough; + signal->theData[2] = nodes[0]; + signal->theData[3] = nodes[1]; + signal->theData[4] = nodes[2]; + signal->theData[5] = nodes[3]; + signal->theData[6] = count; + signal->theData[7] = tabPtr.i; + signal->theData[8] = fragId; + + const BlockReference senderRef = signal->senderBlockRef(); + sendSignal(senderRef, GSN_DIGETPRIMCONF, signal, 9, JBB); +}//Dbdih::execDIGETPRIMREQ() + +/****************************************************************************/ +/* ********** GLOBAL-CHECK-POINT HANDLING MODULE *************/ +/****************************************************************************/ +/* + 3.10 G L O B A L C H E C K P O I N T ( IN M A S T E R R O L E) + ******************************************************************* + */ +void Dbdih::checkGcpStopLab(Signal* signal) +{ + Uint32 tgcpStatus; + + tgcpStatus = cgcpStatus; + if (tgcpStatus == coldGcpStatus) { + jam(); + if (coldGcpId == cnewgcp) { + jam(); + if (cgcpStatus != GCP_READY) { + jam(); + cgcpSameCounter++; + if (cgcpSameCounter == 1200) { + jam(); +#ifdef VM_TRACE + ndbout << "System crash due to GCP Stop in state = "; + ndbout << cgcpStatus << endl; +#endif + crashSystemAtGcpStop(signal); + return; + }//if + } else { + jam(); + if (cgcpOrderBlocked == 0) { + jam(); + cgcpSameCounter++; + if (cgcpSameCounter == 1200) { + jam(); +#ifdef VM_TRACE + ndbout << "System crash due to GCP Stop in state = "; + ndbout << cgcpStatus << endl; +#endif + crashSystemAtGcpStop(signal); + return; + }//if + } else { + jam(); + cgcpSameCounter = 0; + }//if + }//if + } else { + jam(); + cgcpSameCounter = 0; + }//if + } else { + jam(); + cgcpSameCounter = 0; + }//if + signal->theData[0] = DihContinueB::ZCHECK_GCP_STOP; + signal->theData[1] = coldGcpStatus; + signal->theData[2] = cgcpStatus; + signal->theData[3] = coldGcpId; + signal->theData[4] = cnewgcp; + signal->theData[5] = cgcpSameCounter; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 6); + coldGcpStatus = cgcpStatus; + coldGcpId = cnewgcp; + return; +}//Dbdih::checkGcpStopLab() + +void Dbdih::startGcpLab(Signal* signal, Uint32 aWaitTime) +{ + if ((cgcpOrderBlocked == 1) || + (c_nodeStartMaster.blockGcp == true) || + (cfirstVerifyQueue != RNIL)) { + /*************************************************************************/ + // 1: Global Checkpoint has been stopped by management command + // 2: Global Checkpoint is blocked by node recovery activity + // 3: Previous global checkpoint is not yet completed. + // All this means that global checkpoint cannot start now. + /*************************************************************************/ + jam(); + cgcpStartCounter++; + signal->theData[0] = DihContinueB::ZSTART_GCP; + signal->theData[1] = aWaitTime > 100 ? (aWaitTime - 100) : 0; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 2); + return; + }//if + if (cstartGcpNow == false && aWaitTime > 100){ + /*************************************************************************/ + // We still have more than 100 milliseconds before we start the next and + // nobody has ordered immediate start of a global checkpoint. + // During initial start we will use continuos global checkpoints to + // speed it up since we need to complete a global checkpoint after + // inserting a lot of records. + /*************************************************************************/ + jam(); + cgcpStartCounter++; + signal->theData[0] = DihContinueB::ZSTART_GCP; + signal->theData[1] = (aWaitTime - 100); + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 2); + return; + }//if + cgcpStartCounter = 0; + cstartGcpNow = false; + /***************************************************************************/ + // Report the event that a global checkpoint has started. + /***************************************************************************/ + signal->theData[0] = EventReport::GlobalCheckpointStarted; //Event type + signal->theData[1] = cnewgcp; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); + + CRASH_INSERTION(7000); + cnewgcp++; + signal->setTrace(TestOrd::TraceGlobalCheckpoint); + sendLoopMacro(GCP_PREPARE, sendGCP_PREPARE); + cgcpStatus = GCP_PREPARE_SENT; +}//Dbdih::startGcpLab() + +void Dbdih::execGCP_PREPARECONF(Signal* signal) +{ + jamEntry(); + Uint32 senderNodeId = signal->theData[0]; + Uint32 gci = signal->theData[1]; + ndbrequire(gci == cnewgcp); + receiveLoopMacro(GCP_PREPARE, senderNodeId); + //------------------------------------------------------------- + // We have now received all replies. We are ready to continue + // with committing the global checkpoint. + //------------------------------------------------------------- + gcpcommitreqLab(signal); +}//Dbdih::execGCP_PREPARECONF() + +void Dbdih::gcpcommitreqLab(Signal* signal) +{ + CRASH_INSERTION(7001); + sendLoopMacro(GCP_COMMIT, sendGCP_COMMIT); + cgcpStatus = GCP_COMMIT_SENT; + return; +}//Dbdih::gcpcommitreqLab() + +void Dbdih::execGCP_NODEFINISH(Signal* signal) +{ + jamEntry(); + const Uint32 senderNodeId = signal->theData[0]; + const Uint32 gci = signal->theData[1]; + const Uint32 failureNr = signal->theData[2]; + if (!isMaster()) { + jam(); + ndbrequire(failureNr > cfailurenr); + //------------------------------------------------------------- + // Another node thinks we are master. This could happen when he + // has heard of a node failure which I have not heard of. Ignore + // signal in this case since we will discover it by sending + // MASTER_GCPREQ to the node. + //------------------------------------------------------------- + return; + } else if (cmasterState == MASTER_TAKE_OVER_GCP) { + jam(); + //------------------------------------------------------------- + // We are currently taking over as master. We will delay the + // signal until we have completed the take over gcp handling. + //------------------------------------------------------------- + sendSignalWithDelay(reference(), GSN_GCP_NODEFINISH, signal, 20, 3); + return; + } else { + ndbrequire(cmasterState == MASTER_ACTIVE); + }//if + ndbrequire(gci == coldgcp); + receiveLoopMacro(GCP_COMMIT, senderNodeId); + //------------------------------------------------------------- + // We have now received all replies. We are ready to continue + // with saving the global checkpoint to disk. + //------------------------------------------------------------- + CRASH_INSERTION(7002); + gcpsavereqLab(signal); + return; +}//Dbdih::execGCP_NODEFINISH() + +void Dbdih::gcpsavereqLab(Signal* signal) +{ + sendLoopMacro(GCP_SAVEREQ, sendGCP_SAVEREQ); + cgcpStatus = GCP_NODE_FINISHED; +}//Dbdih::gcpsavereqLab() + +void Dbdih::execGCP_SAVECONF(Signal* signal) +{ + jamEntry(); + const GCPSaveConf * const saveConf = (GCPSaveConf*)&signal->theData[0]; + ndbrequire(saveConf->gci == coldgcp); + ndbrequire(saveConf->nodeId == saveConf->dihPtr); + SYSFILE->lastCompletedGCI[saveConf->nodeId] = saveConf->gci; + GCP_SAVEhandling(signal, saveConf->nodeId); +}//Dbdih::execGCP_SAVECONF() + +void Dbdih::execGCP_SAVEREF(Signal* signal) +{ + jamEntry(); + const GCPSaveRef * const saveRef = (GCPSaveRef*)&signal->theData[0]; + ndbrequire(saveRef->gci == coldgcp); + ndbrequire(saveRef->nodeId == saveRef->dihPtr); + /** + * Only allow reason not to save + */ + ndbrequire(saveRef->errorCode == GCPSaveRef::NodeShutdownInProgress || + saveRef->errorCode == GCPSaveRef::FakedSignalDueToNodeFailure || + saveRef->errorCode == GCPSaveRef::NodeRestartInProgress); + GCP_SAVEhandling(signal, saveRef->nodeId); +}//Dbdih::execGCP_SAVEREF() + +void Dbdih::GCP_SAVEhandling(Signal* signal, Uint32 nodeId) +{ + receiveLoopMacro(GCP_SAVEREQ, nodeId); + /*-------------------------------------------------------------------------*/ + // All nodes have replied. We are ready to update the system file. + /*-------------------------------------------------------------------------*/ + cgcpStatus = GCP_SAVE_LQH_FINISHED; + CRASH_INSERTION(7003); + checkToCopy(); + /**------------------------------------------------------------------------ + * SET NEW RECOVERABLE GCI. ALSO RESET RESTART COUNTER TO ZERO. + * THIS INDICATES THAT THE SYSTEM HAS BEEN RECOVERED AND SURVIVED AT + * LEAST ONE GLOBAL CHECKPOINT PERIOD. WE WILL USE THIS PARAMETER TO + * SET BACK THE RESTART GCI IF WE ENCOUNTER MORE THAN ONE UNSUCCESSFUL + * RESTART. + *------------------------------------------------------------------------*/ + SYSFILE->newestRestorableGCI = coldgcp; + if(Sysfile::getInitialStartOngoing(SYSFILE->systemRestartBits) && + getNodeState().startLevel == NodeState::SL_STARTED){ + jam(); +#if 0 + ndbout_c("Dbdih: Clearing initial start ongoing"); +#endif + Sysfile::clearInitialStartOngoing(SYSFILE->systemRestartBits); + } + copyGciLab(signal, CopyGCIReq::GLOBAL_CHECKPOINT); +}//Dbdih::GCP_SAVEhandling() + +/* + 3.11 G L O B A L C H E C K P O I N T (N O T - M A S T E R) + ************************************************************* + */ +void Dbdih::execGCP_PREPARE(Signal* signal) +{ + jamEntry(); + CRASH_INSERTION(7005); + Uint32 masterNodeId = signal->theData[0]; + Uint32 gci = signal->theData[1]; + BlockReference retRef = calcDihBlockRef(masterNodeId); + + ndbrequire (cmasterdihref == retRef); + ndbrequire (cgcpParticipantState == GCP_PARTICIPANT_READY); + ndbrequire (gci == (currentgcp + 1)); + + cgckptflag = true; + cgcpParticipantState = GCP_PARTICIPANT_PREPARE_RECEIVED; + cnewgcp = gci; + + signal->theData[0] = cownNodeId; + signal->theData[1] = gci; + sendSignal(retRef, GSN_GCP_PREPARECONF, signal, 2, JBA); + return; +}//Dbdih::execGCP_PREPARE() + +void Dbdih::execGCP_COMMIT(Signal* signal) +{ + jamEntry(); + CRASH_INSERTION(7006); + Uint32 masterNodeId = signal->theData[0]; + Uint32 gci = signal->theData[1]; + + ndbrequire(gci == (currentgcp + 1)); + ndbrequire(masterNodeId = cmasterNodeId); + ndbrequire(cgcpParticipantState == GCP_PARTICIPANT_PREPARE_RECEIVED); + + coldgcp = currentgcp; + currentgcp = cnewgcp; + cgckptflag = false; + emptyverificbuffer(signal, true); + cgcpParticipantState = GCP_PARTICIPANT_COMMIT_RECEIVED; + signal->theData[1] = coldgcp; + sendSignal(clocaltcblockref, GSN_GCP_NOMORETRANS, signal, 2, JBB); + return; +}//Dbdih::execGCP_COMMIT() + +void Dbdih::execGCP_TCFINISHED(Signal* signal) +{ + jamEntry(); + CRASH_INSERTION(7007); + Uint32 gci = signal->theData[1]; + ndbrequire(gci == coldgcp); + + cgcpParticipantState = GCP_PARTICIPANT_TC_FINISHED; + signal->theData[0] = cownNodeId; + signal->theData[1] = coldgcp; + signal->theData[2] = cfailurenr; + sendSignal(cmasterdihref, GSN_GCP_NODEFINISH, signal, 3, JBB); +}//Dbdih::execGCP_TCFINISHED() + +/*****************************************************************************/ +//****** RECEIVING TAMPER REQUEST FROM NDBAPI ****** +/*****************************************************************************/ +void Dbdih::execDIHNDBTAMPER(Signal* signal) +{ + jamEntry(); + Uint32 tcgcpblocked = signal->theData[0]; + /* ACTION TO BE TAKEN BY DIH */ + Uint32 tuserpointer = signal->theData[1]; + BlockReference tuserblockref = signal->theData[2]; + switch (tcgcpblocked) { + case 1: + jam(); + if (isMaster()) { + jam(); + cgcpOrderBlocked = 1; + } else { + jam(); + /* TRANSFER THE REQUEST */ + /* TO MASTER*/ + signal->theData[0] = tcgcpblocked; + signal->theData[1] = tuserpointer; + signal->theData[2] = tuserblockref; + sendSignal(cmasterdihref, GSN_DIHNDBTAMPER, signal, 3, JBB); + }//if + break; + case 2: + jam(); + if (isMaster()) { + jam(); + cgcpOrderBlocked = 0; + } else { + jam(); + /* TRANSFER THE REQUEST */ + /* TO MASTER*/ + signal->theData[0] = tcgcpblocked; + signal->theData[1] = tuserpointer; + signal->theData[2] = tuserblockref; + sendSignal(cmasterdihref, GSN_DIHNDBTAMPER, signal, 3, JBB); + }//if + break; + case 3: + ndbrequire(false); + return; + break; + case 4: + jam(); + signal->theData[0] = tuserpointer; + signal->theData[1] = crestartGci; + sendSignal(tuserblockref, GSN_DIHNDBTAMPER, signal, 2, JBB); + break; +#ifdef ERROR_INSERT + case 5: + jam(); + /*----------------------------------------------------------------------*/ + // Insert errors. + /*----------------------------------------------------------------------*/ + if (tuserpointer < 1000) { + /*--------------------------------------------------------------------*/ + // Insert errors into QMGR. + /*--------------------------------------------------------------------*/ + jam(); + tuserblockref = QMGR_REF; + } else if (tuserpointer < 2000) { + /*--------------------------------------------------------------------*/ + // Insert errors into NDBCNTR. + /*--------------------------------------------------------------------*/ + jam(); + tuserblockref = NDBCNTR_REF; + } else if (tuserpointer < 3000) { + /*--------------------------------------------------------------------*/ + // Insert errors into NDBFS. + /*--------------------------------------------------------------------*/ + jam(); + tuserblockref = NDBFS_REF; + } else if (tuserpointer < 4000) { + /*--------------------------------------------------------------------*/ + // Insert errors into DBACC. + /*--------------------------------------------------------------------*/ + jam(); + tuserblockref = DBACC_REF; + } else if (tuserpointer < 5000) { + /*--------------------------------------------------------------------*/ + // Insert errors into DBTUP. + /*--------------------------------------------------------------------*/ + jam(); + tuserblockref = DBTUP_REF; + } else if (tuserpointer < 6000) { + /*---------------------------------------------------------------------*/ + // Insert errors into DBLQH. + /*---------------------------------------------------------------------*/ + jam(); + tuserblockref = DBLQH_REF; + } else if (tuserpointer < 7000) { + /*---------------------------------------------------------------------*/ + // Insert errors into DBDICT. + /*---------------------------------------------------------------------*/ + jam(); + tuserblockref = DBDICT_REF; + } else if (tuserpointer < 8000) { + /*---------------------------------------------------------------------*/ + // Insert errors into DBDIH. + /*--------------------------------------------------------------------*/ + jam(); + tuserblockref = DBDIH_REF; + } else if (tuserpointer < 9000) { + /*--------------------------------------------------------------------*/ + // Insert errors into DBTC. + /*--------------------------------------------------------------------*/ + jam(); + tuserblockref = DBTC_REF; + } else if (tuserpointer < 10000) { + /*--------------------------------------------------------------------*/ + // Insert errors into CMVMI. + /*--------------------------------------------------------------------*/ + jam(); + tuserblockref = CMVMI_REF; + } else if (tuserpointer < 11000) { + jam(); + tuserblockref = BACKUP_REF; + } else if (tuserpointer < 12000) { + // DBUTIL_REF ? + jam(); + } else if (tuserpointer < 13000) { + jam(); + tuserblockref = DBTUX_REF; + } else if (tuserpointer < 14000) { + jam(); + tuserblockref = SUMA_REF; + } else if (tuserpointer < 15000) { + jam(); + tuserblockref = DBDICT_REF; + } else if (tuserpointer < 30000) { + /*--------------------------------------------------------------------*/ + // Ignore errors in the 20000-range. + /*--------------------------------------------------------------------*/ + jam(); + return; + } else if (tuserpointer < 40000) { + jam(); + /*--------------------------------------------------------------------*/ + // Redirect errors to master DIH in the 30000-range. + /*--------------------------------------------------------------------*/ + tuserblockref = cmasterdihref; + tuserpointer -= 30000; + signal->theData[0] = 5; + signal->theData[1] = tuserpointer; + signal->theData[2] = tuserblockref; + sendSignal(tuserblockref, GSN_DIHNDBTAMPER, signal, 3, JBB); + return; + } else if (tuserpointer < 50000) { + NodeRecordPtr localNodeptr; + Uint32 Tfound = 0; + jam(); + /*--------------------------------------------------------------------*/ + // Redirect errors to non-master DIH in the 40000-range. + /*--------------------------------------------------------------------*/ + tuserpointer -= 40000; + for (localNodeptr.i = 1; + localNodeptr.i < MAX_NDB_NODES; + localNodeptr.i++) { + jam(); + ptrAss(localNodeptr, nodeRecord); + if ((localNodeptr.p->nodeStatus == NodeRecord::ALIVE) && + (localNodeptr.i != cmasterNodeId)) { + jam(); + tuserblockref = calcDihBlockRef(localNodeptr.i); + Tfound = 1; + break; + }//if + }//for + if (Tfound == 0) { + jam(); + /*-------------------------------------------------------------------*/ + // Ignore since no non-master node existed. + /*-------------------------------------------------------------------*/ + return; + }//if + signal->theData[0] = 5; + signal->theData[1] = tuserpointer; + signal->theData[2] = tuserblockref; + sendSignal(tuserblockref, GSN_DIHNDBTAMPER, signal, 3, JBB); + return; + } else { + jam(); + return; + }//if + signal->theData[0] = tuserpointer; + if (tuserpointer != 0) { + sendSignal(tuserblockref, GSN_NDB_TAMPER, signal, 1, JBB); + } else { + sendSignal(QMGR_REF, GSN_NDB_TAMPER, signal, 1, JBB); + sendSignal(NDBCNTR_REF, GSN_NDB_TAMPER, signal, 1, JBB); + sendSignal(NDBFS_REF, GSN_NDB_TAMPER, signal, 1, JBB); + sendSignal(DBACC_REF, GSN_NDB_TAMPER, signal, 1, JBB); + sendSignal(DBTUP_REF, GSN_NDB_TAMPER, signal, 1, JBB); + sendSignal(DBLQH_REF, GSN_NDB_TAMPER, signal, 1, JBB); + sendSignal(DBDICT_REF, GSN_NDB_TAMPER, signal, 1, JBB); + sendSignal(DBDIH_REF, GSN_NDB_TAMPER, signal, 1, JBB); + sendSignal(DBTC_REF, GSN_NDB_TAMPER, signal, 1, JBB); + sendSignal(CMVMI_REF, GSN_NDB_TAMPER, signal, 1, JBB); + }//if + break; +#endif + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbdih::execDIHNDBTAMPER() + +/*****************************************************************************/ +/* ********** FILE HANDLING MODULE *************/ +/*****************************************************************************/ +void Dbdih::copyGciLab(Signal* signal, CopyGCIReq::CopyReason reason) +{ + if(c_copyGCIMaster.m_copyReason != CopyGCIReq::IDLE){ + /** + * There can currently only be one waiting + */ + ndbrequire(c_copyGCIMaster.m_waiting == CopyGCIReq::IDLE); + c_copyGCIMaster.m_waiting = reason; + return; + } + c_copyGCIMaster.m_copyReason = reason; + sendLoopMacro(COPY_GCIREQ, sendCOPY_GCIREQ); + +}//Dbdih::copyGciLab() + +/* ------------------------------------------------------------------------- */ +/* COPY_GCICONF RESPONSE TO COPY_GCIREQ */ +/* ------------------------------------------------------------------------- */ +void Dbdih::execCOPY_GCICONF(Signal* signal) +{ + jamEntry(); + NodeRecordPtr senderNodePtr; + senderNodePtr.i = signal->theData[0]; + receiveLoopMacro(COPY_GCIREQ, senderNodePtr.i); + + CopyGCIReq::CopyReason waiting = c_copyGCIMaster.m_waiting; + CopyGCIReq::CopyReason current = c_copyGCIMaster.m_copyReason; + + c_copyGCIMaster.m_copyReason = CopyGCIReq::IDLE; + c_copyGCIMaster.m_waiting = CopyGCIReq::IDLE; + + bool ok = false; + switch(current){ + case CopyGCIReq::RESTART:{ + ok = true; + jam(); + DictStartReq * req = (DictStartReq*)&signal->theData[0]; + req->restartGci = SYSFILE->newestRestorableGCI; + req->senderRef = reference(); + sendSignal(cdictblockref, GSN_DICTSTARTREQ, + signal, DictStartReq::SignalLength, JBB); + break; + } + case CopyGCIReq::LOCAL_CHECKPOINT:{ + ok = true; + jam(); + startLcpRoundLab(signal); + break; + } + case CopyGCIReq::GLOBAL_CHECKPOINT: + ok = true; + jam(); + checkToCopyCompleted(signal); + + /************************************************************************/ + // Report the event that a global checkpoint has completed. + /************************************************************************/ + signal->setTrace(0); + signal->theData[0] = EventReport::GlobalCheckpointCompleted; //Event type + signal->theData[1] = coldgcp; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); + + CRASH_INSERTION(7004); + emptyWaitGCPMasterQueue(signal); + cgcpStatus = GCP_READY; + signal->theData[0] = DihContinueB::ZSTART_GCP; + signal->theData[1] = cgcpDelay; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 2); + if (c_nodeStartMaster.blockGcp == true) { + jam(); + /* ------------------------------------------------------------------ */ + /* A NEW NODE WANTS IN AND WE MUST ALLOW IT TO COME IN NOW SINCE THE */ + /* GCP IS COMPLETED. */ + /* ------------------------------------------------------------------ */ + gcpBlockedLab(signal); + }//if + break; + case CopyGCIReq::INITIAL_START_COMPLETED: + ok = true; + jam(); + initialStartCompletedLab(signal); + break; + case CopyGCIReq::IDLE: + ok = false; + jam(); + } + ndbrequire(ok); + + /** + * Pop queue + */ + if(waiting != CopyGCIReq::IDLE){ + c_copyGCIMaster.m_copyReason = waiting; + signal->theData[0] = DihContinueB::ZCOPY_GCI; + signal->theData[1] = waiting; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + } +}//Dbdih::execCOPY_GCICONF() + +void Dbdih::invalidateLcpInfoAfterSr() +{ + NodeRecordPtr nodePtr; + SYSFILE->latestLCP_ID--; + Sysfile::clearLCPOngoing(SYSFILE->systemRestartBits); + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRecord); + if (!NdbNodeBitmask::get(SYSFILE->lcpActive, nodePtr.i)){ + jam(); + /* ------------------------------------------------------------------- */ + // The node was not active in the local checkpoint. + // To avoid that we step the active status too fast to not + // active we step back one step from Sysfile::NS_ActiveMissed_x. + /* ------------------------------------------------------------------- */ + switch (nodePtr.p->activeStatus) { + case Sysfile::NS_Active: + /* ----------------------------------------------------------------- */ + // When not active in ongoing LCP and still active is a contradiction. + /* ----------------------------------------------------------------- */ + ndbrequire(false); + case Sysfile::NS_ActiveMissed_1: + jam(); + nodePtr.p->activeStatus = Sysfile::NS_Active; + break; + case Sysfile::NS_ActiveMissed_2: + jam(); + nodePtr.p->activeStatus = Sysfile::NS_ActiveMissed_1; + break; + default: + jam(); + break; + }//switch + }//if + }//for + setNodeRestartInfoBits(); +}//Dbdih::invalidateLcpInfoAfterSr() + +/* ------------------------------------------------------------------------- */ +/* THE NEXT STEP IS TO WRITE THE FILE. */ +/* ------------------------------------------------------------------------- */ +void Dbdih::openingCopyGciSkipInitLab(Signal* signal, FileRecordPtr filePtr) +{ + writeRestorableGci(signal, filePtr); + filePtr.p->reqStatus = FileRecord::WRITING_COPY_GCI; + return; +}//Dbdih::openingCopyGciSkipInitLab() + +void Dbdih::writingCopyGciLab(Signal* signal, FileRecordPtr filePtr) +{ + /* ----------------------------------------------------------------------- */ + /* WE HAVE NOW WRITTEN THIS FILE. WRITE ALSO NEXT FILE IF THIS IS NOT */ + /* ALREADY THE LAST. */ + /* ----------------------------------------------------------------------- */ + filePtr.p->reqStatus = FileRecord::IDLE; + if (filePtr.i == crestartInfoFile[0]) { + jam(); + filePtr.i = crestartInfoFile[1]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + if (filePtr.p->fileStatus == FileRecord::OPEN) { + jam(); + openingCopyGciSkipInitLab(signal, filePtr); + return; + }//if + openFileRw(signal, filePtr); + filePtr.p->reqStatus = FileRecord::OPENING_COPY_GCI; + return; + }//if + /* ----------------------------------------------------------------------- */ + /* WE HAVE COMPLETED WRITING BOTH FILES SUCCESSFULLY. NOW REPORT OUR */ + /* SUCCESS TO THE MASTER DIH. BUT FIRST WE NEED TO RESET A NUMBER OF */ + /* VARIABLES USED BY THE LOCAL CHECKPOINT PROCESS (ONLY IF TRIGGERED */ + /* BY LOCAL CHECKPOINT PROCESS. */ + /* ----------------------------------------------------------------------- */ + CopyGCIReq::CopyReason reason = c_copyGCISlave.m_copyReason; + + if (reason == CopyGCIReq::GLOBAL_CHECKPOINT) { + jam(); + cgcpParticipantState = GCP_PARTICIPANT_READY; + + SubGcpCompleteRep * const rep = (SubGcpCompleteRep*)signal->getDataPtr(); + rep->gci = coldgcp; + rep->senderData = 0; + sendSignal(SUMA_REF, GSN_SUB_GCP_COMPLETE_REP, signal, + SubGcpCompleteRep::SignalLength, JBB); + } + + jam(); + c_copyGCISlave.m_copyReason = CopyGCIReq::IDLE; + + if(c_copyGCISlave.m_senderRef == cmasterdihref){ + jam(); + /** + * Only if same master + */ + signal->theData[0] = c_copyGCISlave.m_senderData; + sendSignal(c_copyGCISlave.m_senderRef, GSN_COPY_GCICONF, signal, 1, JBB); + + } + return; +}//Dbdih::writingCopyGciLab() + +void Dbdih::execSTART_LCP_REQ(Signal* signal){ + StartLcpReq * req = (StartLcpReq*)signal->getDataPtr(); + + CRASH_INSERTION2(7021, isMaster()); + CRASH_INSERTION2(7022, !isMaster()); + + ndbrequire(c_lcpState.m_masterLcpDihRef = req->senderRef); + c_lcpState.m_participatingDIH = req->participatingDIH; + c_lcpState.m_participatingLQH = req->participatingLQH; + + c_lcpState.m_LCP_COMPLETE_REP_Counter_LQH = req->participatingLQH; + if(isMaster()){ + jam(); + ndbrequire(isActiveMaster()); + c_lcpState.m_LCP_COMPLETE_REP_Counter_DIH = req->participatingDIH; + + } else { + c_lcpState.m_LCP_COMPLETE_REP_Counter_DIH.clearWaitingFor(); + } + + c_lcpState.m_LCP_COMPLETE_REP_From_Master_Received = false; + + c_lcpState.setLcpStatus(LCP_INIT_TABLES, __LINE__); + + signal->theData[0] = DihContinueB::ZINIT_LCP; + signal->theData[1] = c_lcpState.m_masterLcpDihRef; + signal->theData[2] = 0; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); +} + +void Dbdih::initLcpLab(Signal* signal, Uint32 senderRef, Uint32 tableId) +{ + TabRecordPtr tabPtr; + tabPtr.i = tableId; + + if(c_lcpState.m_masterLcpDihRef != senderRef){ + jam(); + /** + * This is LCP master takeover + */ +#ifdef VM_TRACE + ndbout_c("initLcpLab aborted due to LCP master takeover - 1"); +#endif + c_lcpState.setLcpStatus(LCP_STATUS_IDLE, __LINE__); + sendMASTER_LCPCONF(signal); + return; + } + + if(c_lcpState.m_masterLcpDihRef != cmasterdihref){ + jam(); + /** + * Master take over but has not yet received MASTER_LCPREQ + */ +#ifdef VM_TRACE + ndbout_c("initLcpLab aborted due to LCP master takeover - 2"); +#endif + return; + } + + //const Uint32 lcpId = SYSFILE->latestLCP_ID; + + for(; tabPtr.i < ctabFileSize; tabPtr.i++){ + + ptrAss(tabPtr, tabRecord); + + if (tabPtr.p->tabStatus != TabRecord::TS_ACTIVE) { + jam(); + tabPtr.p->tabLcpStatus = TabRecord::TLS_COMPLETED; + continue; + } + + if (tabPtr.p->storedTable == 0) { + /** + * Temporary table + */ + jam(); + tabPtr.p->tabLcpStatus = TabRecord::TLS_COMPLETED; + continue; + } + + if (tabPtr.p->tabCopyStatus != TabRecord::CS_IDLE) { + /* ----------------------------------------------------------------- */ + // We protect the updates of table data structures by this variable. + /* ----------------------------------------------------------------- */ + jam(); + signal->theData[0] = DihContinueB::ZINIT_LCP; + signal->theData[1] = senderRef; + signal->theData[2] = tabPtr.i; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 20, 3); + return; + }//if + + /** + * Found a table + */ + tabPtr.p->tabLcpStatus = TabRecord::TLS_ACTIVE; + + /** + * For each fragment + */ + for (Uint32 fragId = 0; fragId < tabPtr.p->totalfragments; fragId++) { + jam(); + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, fragId, fragPtr); + + /** + * For each of replica record + */ + Uint32 replicaCount = 0; + ReplicaRecordPtr replicaPtr; + for(replicaPtr.i = fragPtr.p->storedReplicas; replicaPtr.i != RNIL; + replicaPtr.i = replicaPtr.p->nextReplica) { + jam(); + + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + Uint32 nodeId = replicaPtr.p->procNode; + if(c_lcpState.m_participatingLQH.get(nodeId)){ + jam(); + replicaCount++; + replicaPtr.p->lcpOngoingFlag = true; + } + } + + fragPtr.p->noLcpReplicas = replicaCount; + }//for + + signal->theData[0] = DihContinueB::ZINIT_LCP; + signal->theData[1] = senderRef; + signal->theData[2] = tabPtr.i + 1; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); + return; + } + + /** + * No more tables + */ + jam(); + + if (c_lcpState.m_masterLcpDihRef != reference()){ + jam(); + ndbrequire(!isMaster()); + c_lcpState.setLcpStatus(LCP_STATUS_ACTIVE, __LINE__); + } else { + jam(); + ndbrequire(isMaster()); + } + + CRASH_INSERTION2(7023, isMaster()); + CRASH_INSERTION2(7024, !isMaster()); + + jam(); + StartLcpConf * conf = (StartLcpConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + sendSignal(c_lcpState.m_masterLcpDihRef, GSN_START_LCP_CONF, signal, + StartLcpConf::SignalLength, JBB); + return; +}//Dbdih::initLcpLab() + +/* ------------------------------------------------------------------------- */ +/* ERROR HANDLING FOR COPY RESTORABLE GCI FILE. */ +/* ------------------------------------------------------------------------- */ +void Dbdih::openingCopyGciErrorLab(Signal* signal, FileRecordPtr filePtr) +{ + createFileRw(signal, filePtr); + /* ------------------------------------------------------------------------- */ + /* ERROR IN OPENING FILE. WE WILL TRY BY CREATING FILE INSTEAD. */ + /* ------------------------------------------------------------------------- */ + filePtr.p->reqStatus = FileRecord::CREATING_COPY_GCI; + return; +}//Dbdih::openingCopyGciErrorLab() + +/* ------------------------------------------------------------------------- */ +/* ENTER DICTSTARTCONF WITH */ +/* TBLOCKREF */ +/* ------------------------------------------------------------------------- */ +void Dbdih::dictStartConfLab(Signal* signal) +{ + /* ----------------------------------------------------------------------- */ + /* WE HAVE NOW RECEIVED ALL THE TABLES TO RESTART. */ + /* ----------------------------------------------------------------------- */ + signal->theData[0] = DihContinueB::ZSTART_FRAGMENT; + signal->theData[1] = 0; /* START WITH TABLE 0 */ + signal->theData[2] = 0; /* AND FRAGMENT 0 */ + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); + return; +}//Dbdih::dictStartConfLab() + + +void Dbdih::openingTableLab(Signal* signal, FileRecordPtr filePtr) +{ + /* ---------------------------------------------------------------------- */ + /* SUCCESSFULLY OPENED A FILE. READ THE FIRST PAGE OF THIS FILE. */ + /* ---------------------------------------------------------------------- */ + TabRecordPtr tabPtr; + PageRecordPtr pagePtr; + + tabPtr.i = filePtr.p->tabRef; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + tabPtr.p->noPages = 1; + allocpage(pagePtr); + tabPtr.p->pageRef[0] = pagePtr.i; + readTabfile(signal, tabPtr.p, filePtr); + filePtr.p->reqStatus = FileRecord::READING_TABLE; + return; +}//Dbdih::openingTableLab() + +void Dbdih::openingTableErrorLab(Signal* signal, FileRecordPtr filePtr) +{ + TabRecordPtr tabPtr; + tabPtr.i = filePtr.p->tabRef; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + /* ---------------------------------------------------------------------- */ + /* WE FAILED IN OPENING A FILE. IF THE FIRST FILE THEN TRY WITH THE */ + /* DUPLICATE FILE, OTHERWISE WE REPORT AN ERROR IN THE SYSTEM RESTART. */ + /* ---------------------------------------------------------------------- */ + ndbrequire(filePtr.i == tabPtr.p->tabFile[0]); + filePtr.i = tabPtr.p->tabFile[1]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + openFileRw(signal, filePtr); + filePtr.p->reqStatus = FileRecord::OPENING_TABLE; +}//Dbdih::openingTableErrorLab() + +void Dbdih::readingTableLab(Signal* signal, FileRecordPtr filePtr) +{ + TabRecordPtr tabPtr; + PageRecordPtr pagePtr; + /* ---------------------------------------------------------------------- */ + /* WE HAVE SUCCESSFULLY READ A NUMBER OF PAGES IN THE TABLE FILE. IF */ + /* MORE PAGES EXIST IN THE FILE THEN READ ALL PAGES IN THE FILE. */ + /* ---------------------------------------------------------------------- */ + filePtr.p->reqStatus = FileRecord::IDLE; + tabPtr.i = filePtr.p->tabRef; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + pagePtr.i = tabPtr.p->pageRef[0]; + ptrCheckGuard(pagePtr, cpageFileSize, pageRecord); + Uint32 noOfStoredPages = pagePtr.p->word[33]; + if (tabPtr.p->noPages < noOfStoredPages) { + jam(); + ndbrequire(noOfStoredPages <= 8); + for (Uint32 i = tabPtr.p->noPages; i < noOfStoredPages; i++) { + jam(); + allocpage(pagePtr); + tabPtr.p->pageRef[i] = pagePtr.i; + }//for + tabPtr.p->noPages = noOfStoredPages; + readTabfile(signal, tabPtr.p, filePtr); + filePtr.p->reqStatus = FileRecord::READING_TABLE; + } else { + ndbrequire(tabPtr.p->noPages == pagePtr.p->word[33]); + ndbrequire(tabPtr.p->tabCopyStatus == TabRecord::CS_IDLE); + jam(); + /* --------------------------------------------------------------------- */ + /* WE HAVE READ ALL PAGES. NOW READ FROM PAGES INTO TABLE AND FRAGMENT */ + /* DATA STRUCTURES. */ + /* --------------------------------------------------------------------- */ + tabPtr.p->tabCopyStatus = TabRecord::CS_SR_PHASE1_READ_PAGES; + signal->theData[0] = DihContinueB::ZREAD_PAGES_INTO_TABLE; + signal->theData[1] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; + }//if + return; +}//Dbdih::readingTableLab() + +void Dbdih::readTableFromPagesLab(Signal* signal, TabRecordPtr tabPtr) +{ + FileRecordPtr filePtr; + filePtr.i = tabPtr.p->tabFile[0]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + /* ---------------------------------------------------------------------- */ + /* WE HAVE NOW COPIED TO OUR NODE. WE HAVE NOW COMPLETED RESTORING */ + /* THIS TABLE. CONTINUE WITH THE NEXT TABLE. */ + /* WE ALSO NEED TO CLOSE THE TABLE FILE. */ + /* ---------------------------------------------------------------------- */ + if (filePtr.p->fileStatus != FileRecord::OPEN) { + jam(); + filePtr.i = tabPtr.p->tabFile[1]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + }//if + closeFile(signal, filePtr); + filePtr.p->reqStatus = FileRecord::CLOSING_TABLE_SR; + return; +}//Dbdih::readTableFromPagesLab() + +void Dbdih::closingTableSrLab(Signal* signal, FileRecordPtr filePtr) +{ + /** + * Update table/fragment info + */ + TabRecordPtr tabPtr; + tabPtr.i = filePtr.p->tabRef; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + resetReplicaSr(tabPtr); + + signal->theData[0] = DihContinueB::ZCOPY_TABLE; + signal->theData[1] = filePtr.p->tabRef; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + + return; +}//Dbdih::closingTableSrLab() + +void +Dbdih::resetReplicaSr(TabRecordPtr tabPtr){ + + const Uint32 newestRestorableGCI = SYSFILE->newestRestorableGCI; + + for(Uint32 i = 0; itotalfragments; i++){ + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, i, fragPtr); + + /** + * 1) Start by moving all replicas into oldStoredReplicas + */ + prepareReplicas(fragPtr); + + /** + * 2) Move all "alive" replicas into storedReplicas + * + update noCrashedReplicas... + */ + ReplicaRecordPtr replicaPtr; + replicaPtr.i = fragPtr.p->oldStoredReplicas; + while (replicaPtr.i != RNIL) { + jam(); + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + const Uint32 nextReplicaPtrI = replicaPtr.p->nextReplica; + + NodeRecordPtr nodePtr; + nodePtr.i = replicaPtr.p->procNode; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + + const Uint32 noCrashedReplicas = replicaPtr.p->noCrashedReplicas; + if (nodePtr.p->nodeStatus == NodeRecord::ALIVE) { + jam(); + switch (nodePtr.p->activeStatus) { + case Sysfile::NS_Active: + case Sysfile::NS_ActiveMissed_1: + case Sysfile::NS_ActiveMissed_2:{ + jam(); + /* --------------------------------------------------------------- */ + /* THE NODE IS ALIVE AND KICKING AND ACTIVE, LET'S USE IT. */ + /* --------------------------------------------------------------- */ + arrGuard(noCrashedReplicas, 8); + Uint32 lastGci = replicaPtr.p->replicaLastGci[noCrashedReplicas]; + if(lastGci >= newestRestorableGCI){ + jam(); + /** ------------------------------------------------------------- + * THE REPLICA WAS ALIVE AT THE SYSTEM FAILURE. WE WILL SET THE + * LAST REPLICA GCI TO MINUS ONE SINCE IT HASN'T FAILED YET IN THE + * NEW SYSTEM. + *-------------------------------------------------------------- */ + replicaPtr.p->replicaLastGci[noCrashedReplicas] = (Uint32)-1; + } else { + jam(); + /*-------------------------------------------------------------- + * SINCE IT WAS NOT ALIVE AT THE TIME OF THE SYSTEM CRASH THIS IS + * A COMPLETELY NEW REPLICA. WE WILL SET THE CREATE GCI TO BE THE + * NEXT GCI TO BE EXECUTED. + *--------_----------------------------------------------------- */ + const Uint32 nextCrashed = noCrashedReplicas + 1; + replicaPtr.p->noCrashedReplicas = nextCrashed; + arrGuard(nextCrashed, 8); + replicaPtr.p->createGci[nextCrashed] = newestRestorableGCI + 1; + ndbrequire(newestRestorableGCI + 1 != 0xF1F1F1F1); + replicaPtr.p->replicaLastGci[nextCrashed] = (Uint32)-1; + }//if + + resetReplicaLcp(replicaPtr.p, newestRestorableGCI); + + /* ----------------------------------------------------------------- + * LINK THE REPLICA INTO THE STORED REPLICA LIST. WE WILL USE THIS + * NODE AS A STORED REPLICA. + * WE MUST FIRST LINK IT OUT OF THE LIST OF OLD STORED REPLICAS. + * --------------------------------------------------------------- */ + removeOldStoredReplica(fragPtr, replicaPtr); + linkStoredReplica(fragPtr, replicaPtr); + + } + default: + jam(); + /*empty*/; + break; + } + } + replicaPtr.i = nextReplicaPtrI; + }//while + } +} + +void +Dbdih::resetReplicaLcp(ReplicaRecord * replicaP, Uint32 stopGci){ + + Uint32 lcpNo = replicaP->nextLcp; + const Uint32 startLcpNo = lcpNo; + do { + lcpNo = prevLcpNo(lcpNo); + ndbrequire(lcpNo < MAX_LCP_STORED); + if (replicaP->lcpStatus[lcpNo] == ZVALID) { + if (replicaP->maxGciStarted[lcpNo] < stopGci) { + jam(); + /* ----------------------------------------------------------------- */ + /* WE HAVE FOUND A USEFUL LOCAL CHECKPOINT THAT CAN BE USED FOR */ + /* RESTARTING THIS FRAGMENT REPLICA. */ + /* ----------------------------------------------------------------- */ + return ; + }//if + }//if + + /** + * WE COULD NOT USE THIS LOCAL CHECKPOINT. IT WAS TOO + * RECENT OR SIMPLY NOT A VALID CHECKPOINT. + * WE SHOULD THUS REMOVE THIS LOCAL CHECKPOINT SINCE IT WILL NEVER + * AGAIN BE USED. SET LCP_STATUS TO INVALID. + */ + replicaP->nextLcp = lcpNo; + replicaP->lcpId[lcpNo] = 0; + replicaP->lcpStatus[lcpNo] = ZINVALID; + } while (lcpNo != startLcpNo); + + replicaP->nextLcp = 0; +} + +void Dbdih::readingTableErrorLab(Signal* signal, FileRecordPtr filePtr) +{ + TabRecordPtr tabPtr; + tabPtr.i = filePtr.p->tabRef; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + /* ---------------------------------------------------------------------- */ + /* READING THIS FILE FAILED. CLOSE IT AFTER RELEASING ALL PAGES. */ + /* ---------------------------------------------------------------------- */ + ndbrequire(tabPtr.p->noPages <= 8); + for (Uint32 i = 0; i < tabPtr.p->noPages; i++) { + jam(); + releasePage(tabPtr.p->pageRef[i]); + }//for + closeFile(signal, filePtr); + filePtr.p->reqStatus = FileRecord::CLOSING_TABLE_CRASH; + return; +}//Dbdih::readingTableErrorLab() + +void Dbdih::closingTableCrashLab(Signal* signal, FileRecordPtr filePtr) +{ + TabRecordPtr tabPtr; + /* ---------------------------------------------------------------------- */ + /* WE HAVE NOW CLOSED A FILE WHICH WE HAD A READ ERROR WITH. PROCEED */ + /* WITH NEXT FILE IF NOT THE LAST OTHERWISE REPORT ERROR. */ + /* ---------------------------------------------------------------------- */ + tabPtr.i = filePtr.p->tabRef; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + ndbrequire(filePtr.i == tabPtr.p->tabFile[0]); + filePtr.i = tabPtr.p->tabFile[1]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + openFileRw(signal, filePtr); + filePtr.p->reqStatus = FileRecord::OPENING_TABLE; +}//Dbdih::closingTableCrashLab() + +/*****************************************************************************/ +/* ********** COPY TABLE MODULE *************/ +/*****************************************************************************/ +void Dbdih::execCOPY_TABREQ(Signal* signal) +{ + CRASH_INSERTION(7172); + + TabRecordPtr tabPtr; + PageRecordPtr pagePtr; + jamEntry(); + BlockReference ref = signal->theData[0]; + Uint32 reqinfo = signal->theData[1]; + tabPtr.i = signal->theData[2]; + Uint32 schemaVersion = signal->theData[3]; + Uint32 noOfWords = signal->theData[4]; + ndbrequire(ref == cmasterdihref); + ndbrequire(!isMaster()); + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + if (reqinfo == 1) { + jam(); + tabPtr.p->schemaVersion = schemaVersion; + initTableFile(tabPtr); + }//if + ndbrequire(tabPtr.p->noPages < 8); + if (tabPtr.p->noOfWords == 0) { + jam(); + allocpage(pagePtr); + tabPtr.p->pageRef[tabPtr.p->noPages] = pagePtr.i; + tabPtr.p->noPages++; + } else { + jam(); + pagePtr.i = tabPtr.p->pageRef[tabPtr.p->noPages - 1]; + ptrCheckGuard(pagePtr, cpageFileSize, pageRecord); + }//if + ndbrequire(tabPtr.p->noOfWords + 15 < 2048); + ndbrequire(tabPtr.p->noOfWords < 2048); + MEMCOPY_NO_WORDS(&pagePtr.p->word[tabPtr.p->noOfWords], &signal->theData[5], 16); + tabPtr.p->noOfWords += 16; + if (tabPtr.p->noOfWords == 2048) { + jam(); + tabPtr.p->noOfWords = 0; + }//if + if (noOfWords > 16) { + jam(); + return; + }//if + tabPtr.p->noOfWords = 0; + ndbrequire(tabPtr.p->tabCopyStatus == TabRecord::CS_IDLE); + tabPtr.p->tabCopyStatus = TabRecord::CS_COPY_TAB_REQ; + signal->theData[0] = DihContinueB::ZREAD_PAGES_INTO_TABLE; + signal->theData[1] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); +}//Dbdih::execCOPY_TABREQ() + +void +Dbdih::copyTabReq_complete(Signal* signal, TabRecordPtr tabPtr){ + if (!isMaster()) { + jam(); + //---------------------------------------------------------------------------- + // In this particular case we do not release table pages if we are master. The + // reason is that the master could still be sending the table info to another + // node. + //---------------------------------------------------------------------------- + releaseTabPages(tabPtr.i); + tabPtr.p->tabStatus = TabRecord::TS_ACTIVE; + for (Uint32 fragId = 0; fragId < tabPtr.p->totalfragments; fragId++) { + jam(); + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, fragId, fragPtr); + updateNodeInfo(fragPtr); + }//for + }//if + signal->theData[0] = cownNodeId; + signal->theData[1] = tabPtr.i; + sendSignal(cmasterdihref, GSN_COPY_TABCONF, signal, 2, JBB); +} + +/*****************************************************************************/ +/* ****** READ FROM A NUMBER OF PAGES INTO THE TABLE DATA STRUCTURES ********/ +/*****************************************************************************/ +void Dbdih::readPagesIntoTableLab(Signal* signal, Uint32 tableId) +{ + RWFragment rf; + rf.wordIndex = 35; + rf.pageIndex = 0; + rf.rwfTabPtr.i = tableId; + ptrCheckGuard(rf.rwfTabPtr, ctabFileSize, tabRecord); + rf.rwfPageptr.i = rf.rwfTabPtr.p->pageRef[0]; + ptrCheckGuard(rf.rwfPageptr, cpageFileSize, pageRecord); + rf.rwfTabPtr.p->totalfragments = readPageWord(&rf); + rf.rwfTabPtr.p->noOfBackups = readPageWord(&rf); + rf.rwfTabPtr.p->hashpointer = readPageWord(&rf); + rf.rwfTabPtr.p->kvalue = readPageWord(&rf); + rf.rwfTabPtr.p->mask = readPageWord(&rf); + ndbrequire(readPageWord(&rf) == TabRecord::HASH); + rf.rwfTabPtr.p->method = TabRecord::HASH; + /* ---------------------------------- */ + /* Type of table, 2 = temporary table */ + /* ---------------------------------- */ + rf.rwfTabPtr.p->storedTable = readPageWord(&rf); + + Uint32 noOfFrags = rf.rwfTabPtr.p->totalfragments; + ndbrequire(noOfFrags > 0); + ndbrequire((noOfFrags * (rf.rwfTabPtr.p->noOfBackups + 1)) <= cnoFreeReplicaRec); + allocFragments(noOfFrags, rf.rwfTabPtr); + + signal->theData[0] = DihContinueB::ZREAD_PAGES_INTO_FRAG; + signal->theData[1] = rf.rwfTabPtr.i; + signal->theData[2] = 0; + signal->theData[3] = rf.pageIndex; + signal->theData[4] = rf.wordIndex; + sendSignal(reference(), GSN_CONTINUEB, signal, 5, JBB); + return; +}//Dbdih::readPagesIntoTableLab() + +void Dbdih::readPagesIntoFragLab(Signal* signal, RWFragment* rf) +{ + ndbrequire(rf->pageIndex < 8); + rf->rwfPageptr.i = rf->rwfTabPtr.p->pageRef[rf->pageIndex]; + ptrCheckGuard(rf->rwfPageptr, cpageFileSize, pageRecord); + FragmentstorePtr fragPtr; + getFragstore(rf->rwfTabPtr.p, rf->fragId, fragPtr); + readFragment(rf, fragPtr); + readReplicas(rf, fragPtr); + rf->fragId++; + if (rf->fragId == rf->rwfTabPtr.p->totalfragments) { + jam(); + switch (rf->rwfTabPtr.p->tabCopyStatus) { + case TabRecord::CS_SR_PHASE1_READ_PAGES: + jam(); + releaseTabPages(rf->rwfTabPtr.i); + rf->rwfTabPtr.p->tabCopyStatus = TabRecord::CS_IDLE; + signal->theData[0] = DihContinueB::ZREAD_TABLE_FROM_PAGES; + signal->theData[1] = rf->rwfTabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; + break; + case TabRecord::CS_COPY_TAB_REQ: + jam(); + rf->rwfTabPtr.p->tabCopyStatus = TabRecord::CS_IDLE; + if(getNodeState().getSystemRestartInProgress()){ + jam(); + copyTabReq_complete(signal, rf->rwfTabPtr); + return; + } + rf->rwfTabPtr.p->tabCopyStatus = TabRecord::CS_IDLE; + rf->rwfTabPtr.p->tabUpdateState = TabRecord::US_COPY_TAB_REQ; + signal->theData[0] = DihContinueB::ZTABLE_UPDATE; + signal->theData[1] = rf->rwfTabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; + break; + default: + ndbrequire(false); + return; + break; + }//switch + } else { + jam(); + signal->theData[0] = DihContinueB::ZREAD_PAGES_INTO_FRAG; + signal->theData[1] = rf->rwfTabPtr.i; + signal->theData[2] = rf->fragId; + signal->theData[3] = rf->pageIndex; + signal->theData[4] = rf->wordIndex; + sendSignal(reference(), GSN_CONTINUEB, signal, 5, JBB); + }//if + return; +}//Dbdih::readPagesIntoFragLab() + +/*****************************************************************************/ +/***** WRITING FROM TABLE DATA STRUCTURES INTO A SET OF PAGES ******/ +// execCONTINUEB(ZPACK_TABLE_INTO_PAGES) +/*****************************************************************************/ +void Dbdih::packTableIntoPagesLab(Signal* signal, Uint32 tableId) +{ + RWFragment wf; + TabRecordPtr tabPtr; + allocpage(wf.rwfPageptr); + tabPtr.i = tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + tabPtr.p->pageRef[0] = wf.rwfPageptr.i; + tabPtr.p->noPages = 1; + wf.wordIndex = 35; + wf.pageIndex = 0; + writePageWord(&wf, tabPtr.p->totalfragments); + writePageWord(&wf, tabPtr.p->noOfBackups); + writePageWord(&wf, tabPtr.p->hashpointer); + writePageWord(&wf, tabPtr.p->kvalue); + writePageWord(&wf, tabPtr.p->mask); + writePageWord(&wf, TabRecord::HASH); + writePageWord(&wf, tabPtr.p->storedTable); + + signal->theData[0] = DihContinueB::ZPACK_FRAG_INTO_PAGES; + signal->theData[1] = tabPtr.i; + signal->theData[2] = 0; + signal->theData[3] = wf.pageIndex; + signal->theData[4] = wf.wordIndex; + sendSignal(reference(), GSN_CONTINUEB, signal, 5, JBB); +}//Dbdih::packTableIntoPagesLab() + +/*****************************************************************************/ +// execCONTINUEB(ZPACK_FRAG_INTO_PAGES) +/*****************************************************************************/ +void Dbdih::packFragIntoPagesLab(Signal* signal, RWFragment* wf) +{ + ndbrequire(wf->pageIndex < 8); + wf->rwfPageptr.i = wf->rwfTabPtr.p->pageRef[wf->pageIndex]; + ptrCheckGuard(wf->rwfPageptr, cpageFileSize, pageRecord); + FragmentstorePtr fragPtr; + getFragstore(wf->rwfTabPtr.p, wf->fragId, fragPtr); + writeFragment(wf, fragPtr); + writeReplicas(wf, fragPtr.p->storedReplicas); + writeReplicas(wf, fragPtr.p->oldStoredReplicas); + wf->fragId++; + if (wf->fragId == wf->rwfTabPtr.p->totalfragments) { + jam(); + PageRecordPtr pagePtr; + pagePtr.i = wf->rwfTabPtr.p->pageRef[0]; + ptrCheckGuard(pagePtr, cpageFileSize, pageRecord); + pagePtr.p->word[33] = wf->rwfTabPtr.p->noPages; + pagePtr.p->word[34] = ((wf->rwfTabPtr.p->noPages - 1) * 2048) + wf->wordIndex; + switch (wf->rwfTabPtr.p->tabCopyStatus) { + case TabRecord::CS_SR_PHASE2_READ_TABLE: + /* -------------------------------------------------------------------*/ + // We are performing a system restart and we are now ready to copy the + // table from this node (the master) to all other nodes. + /* -------------------------------------------------------------------*/ + jam(); + wf->rwfTabPtr.p->tabCopyStatus = TabRecord::CS_IDLE; + signal->theData[0] = DihContinueB::ZSR_PHASE2_READ_TABLE; + signal->theData[1] = wf->rwfTabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; + break; + case TabRecord::CS_COPY_NODE_STATE: + jam(); + tableCopyNodeLab(signal, wf->rwfTabPtr); + return; + break; + case TabRecord::CS_LCP_READ_TABLE: + jam(); + signal->theData[0] = DihContinueB::ZTABLE_UPDATE; + signal->theData[1] = wf->rwfTabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; + break; + case TabRecord::CS_REMOVE_NODE: + case TabRecord::CS_INVALIDATE_NODE_LCP: + jam(); + signal->theData[0] = DihContinueB::ZTABLE_UPDATE; + signal->theData[1] = wf->rwfTabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; + break; + case TabRecord::CS_ADD_TABLE_MASTER: + jam(); + wf->rwfTabPtr.p->tabCopyStatus = TabRecord::CS_IDLE; + signal->theData[0] = DihContinueB::ZADD_TABLE_MASTER_PAGES; + signal->theData[1] = wf->rwfTabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; + break; + case TabRecord::CS_ADD_TABLE_SLAVE: + jam(); + wf->rwfTabPtr.p->tabCopyStatus = TabRecord::CS_IDLE; + signal->theData[0] = DihContinueB::ZADD_TABLE_SLAVE_PAGES; + signal->theData[1] = wf->rwfTabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; + break; + default: + ndbrequire(false); + return; + break; + }//switch + } else { + jam(); + signal->theData[0] = DihContinueB::ZPACK_FRAG_INTO_PAGES; + signal->theData[1] = wf->rwfTabPtr.i; + signal->theData[2] = wf->fragId; + signal->theData[3] = wf->pageIndex; + signal->theData[4] = wf->wordIndex; + sendSignal(reference(), GSN_CONTINUEB, signal, 5, JBB); + }//if + return; +}//Dbdih::packFragIntoPagesLab() + +/*****************************************************************************/ +/* ********** START FRAGMENT MODULE *************/ +/*****************************************************************************/ +void Dbdih::startFragment(Signal* signal, Uint32 tableId, Uint32 fragId) +{ + Uint32 TloopCount = 0; + TabRecordPtr tabPtr; + while (true) { + if (TloopCount > 100) { + jam(); + signal->theData[0] = DihContinueB::ZSTART_FRAGMENT; + signal->theData[1] = tableId; + signal->theData[2] = 0; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); + return; + } + + if (tableId >= ctabFileSize) { + jam(); + signal->theData[0] = DihContinueB::ZCOMPLETE_RESTART; + sendSignal(reference(), GSN_CONTINUEB, signal, 1, JBB); + return; + }//if + + tabPtr.i = tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + if (tabPtr.p->tabStatus != TabRecord::TS_ACTIVE){ + jam(); + TloopCount++; + tableId++; + fragId = 0; + continue; + } + + if(tabPtr.p->storedTable == 0){ + jam(); + TloopCount++; + tableId++; + fragId = 0; + continue; + } + + jam(); + break; + }//while + + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, fragId, fragPtr); + /* ----------------------------------------------------------------------- */ + /* WE NEED TO RESET THE REPLICA DATA STRUCTURES. THIS MEANS THAT WE */ + /* MUST REMOVE REPLICAS THAT WAS NOT STARTED AT THE GCI TO RESTORE. WE */ + /* NEED TO PUT ALL STORED REPLICAS ON THE LIST OF OLD STORED REPLICAS */ + /* RESET THE NUMBER OF REPLICAS TO CREATE. */ + /* ----------------------------------------------------------------------- */ + cnoOfCreateReplicas = 0; + /* ----------------------------------------------------------------------- */ + /* WE WILL NEVER START MORE THAN FOUR FRAGMENT REPLICAS WHATEVER THE */ + /* DESIRED REPLICATION IS. */ + /* ----------------------------------------------------------------------- */ + ndbrequire(tabPtr.p->noOfBackups < 4); + /* ----------------------------------------------------------------------- */ + /* SEARCH FOR STORED REPLICAS THAT CAN BE USED TO RESTART THE SYSTEM. */ + /* ----------------------------------------------------------------------- */ + searchStoredReplicas(fragPtr); + if (cnoOfCreateReplicas == 0) { + /* --------------------------------------------------------------------- */ + /* THERE WERE NO STORED REPLICAS AVAILABLE THAT CAN SERVE AS REPLICA TO*/ + /* RESTART THE SYSTEM FROM. IN A LATER RELEASE WE WILL ADD */ + /* FUNCTIONALITY TO CHECK IF THERE ARE ANY STANDBY NODES THAT COULD DO */ + /* THIS TASK INSTEAD IN THIS IMPLEMENTATION WE SIMPLY CRASH THE SYSTEM.*/ + /* THIS WILL DECREASE THE GCI TO RESTORE WHICH HOPEFULLY WILL MAKE IT */ + /* POSSIBLE TO RESTORE THE SYSTEM. */ + /* --------------------------------------------------------------------- */ + char buf[100]; + snprintf(buf, sizeof(buf), + "Unable to find restorable replica for " + "table: %d fragment: %d gci: %d", + tableId, fragId, SYSFILE->newestRestorableGCI); + progError(__LINE__, + ERR_SYSTEM_ERROR, + buf); + ndbrequire(false); + return; + }//if + + /* ----------------------------------------------------------------------- */ + /* WE HAVE CHANGED THE NODE TO BE PRIMARY REPLICA AND THE NODES TO BE */ + /* BACKUP NODES. WE MUST UPDATE THIS NODES DATA STRUCTURE SINCE WE */ + /* WILL NOT COPY THE TABLE DATA TO OURSELF. */ + /* ----------------------------------------------------------------------- */ + updateNodeInfo(fragPtr); + /* ----------------------------------------------------------------------- */ + /* NOW WE HAVE COLLECTED ALL THE REPLICAS WE COULD GET. WE WILL NOW */ + /* RESTART THE FRAGMENT REPLICAS WE HAVE FOUND IRRESPECTIVE OF IF THERE*/ + /* ARE ENOUGH ACCORDING TO THE DESIRED REPLICATION. */ + /* ----------------------------------------------------------------------- */ + /* WE START BY SENDING ADD_FRAGREQ FOR THOSE REPLICAS THAT NEED IT. */ + /* ----------------------------------------------------------------------- */ + CreateReplicaRecordPtr createReplicaPtr; + for (createReplicaPtr.i = 0; + createReplicaPtr.i < cnoOfCreateReplicas; + createReplicaPtr.i++) { + jam(); + ptrCheckGuard(createReplicaPtr, 4, createReplicaRecord); + createReplicaPtr.p->hotSpareUse = false; + }//for + + sendStartFragreq(signal, tabPtr, fragId); + + /** + * Don't wait for START_FRAGCONF + */ + fragId++; + if (fragId >= tabPtr.p->totalfragments) { + jam(); + tabPtr.i++; + fragId = 0; + }//if + signal->theData[0] = DihContinueB::ZSTART_FRAGMENT; + signal->theData[1] = tabPtr.i; + signal->theData[2] = fragId; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); + + return; +}//Dbdih::startFragmentLab() + + +/*****************************************************************************/ +/* ********** COMPLETE RESTART MODULE *************/ +/*****************************************************************************/ +void Dbdih::completeRestartLab(Signal* signal) +{ + sendLoopMacro(START_RECREQ, sendSTART_RECREQ); +}//completeRestartLab() + +/* ------------------------------------------------------------------------- */ +// SYSTEM RESTART: +/* A NODE HAS COMPLETED RESTORING ALL DATABASE FRAGMENTS. */ +// NODE RESTART: +// THE STARTING NODE HAS PREPARED ITS LOG FILES TO ENABLE EXECUTION +// OF TRANSACTIONS. +// Precondition: +// This signal must be received by the master node. +/* ------------------------------------------------------------------------- */ +void Dbdih::execSTART_RECCONF(Signal* signal) +{ + jamEntry(); + Uint32 senderNodeId = signal->theData[0]; + ndbrequire(isMaster()); + if (getNodeState().startLevel >= NodeState::SL_STARTED){ + /* --------------------------------------------------------------------- */ + // Since our node is already up and running this must be a node restart. + // This means that we should be the master node, + // otherwise we have a problem. + /* --------------------------------------------------------------------- */ + jam(); + ndbrequire(senderNodeId == c_nodeStartMaster.startNode); + nodeRestartStartRecConfLab(signal); + return; + } else { + /* --------------------------------------------------------------------- */ + // This was the system restart case. We set the state indicating that the + // node has completed restoration of all fragments. + /* --------------------------------------------------------------------- */ + receiveLoopMacro(START_RECREQ, senderNodeId); + + signal->theData[0] = reference(); + sendSignal(cntrlblockref, GSN_NDB_STARTCONF, signal, 1, JBB); + return; + }//if +}//Dbdih::execSTART_RECCONF() + +void Dbdih::copyNodeLab(Signal* signal, Uint32 tableId) +{ + /* ----------------------------------------------------------------------- */ + // This code is executed by the master to assist a node restart in receiving + // the data in the master. + /* ----------------------------------------------------------------------- */ + Uint32 TloopCount = 0; + + if (!c_nodeStartMaster.activeState) { + jam(); + /* --------------------------------------------------------------------- */ + // Obviously the node crashed in the middle of its node restart. We will + // stop this process simply by returning after resetting the wait indicator. + /* ---------------------------------------------------------------------- */ + c_nodeStartMaster.wait = ZFALSE; + return; + }//if + TabRecordPtr tabPtr; + tabPtr.i = tableId; + while (tabPtr.i < ctabFileSize) { + ptrAss(tabPtr, tabRecord); + if (tabPtr.p->tabStatus == TabRecord::TS_ACTIVE) { + /* -------------------------------------------------------------------- */ + // The table is defined. We will start by packing the table into pages. + // The tabCopyStatus indicates to the CONTINUEB(ZPACK_TABLE_INTO_PAGES) + // who called it. After packing the table into page(s) it will be sent to + // the starting node by COPY_TABREQ signals. After returning from the + // starting node we will return to this subroutine and continue + // with the next table. + /* -------------------------------------------------------------------- */ + ndbrequire(tabPtr.p->tabCopyStatus == TabRecord::CS_IDLE); + tabPtr.p->tabCopyStatus = TabRecord::CS_COPY_NODE_STATE; + signal->theData[0] = DihContinueB::ZPACK_TABLE_INTO_PAGES; + signal->theData[1] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; + } else { + jam(); + if (TloopCount > 100) { + /* ------------------------------------------------------------------ */ + // Introduce real-time break after looping through 100 not copied tables + /* ----------------------------------------------------------------- */ + jam(); + signal->theData[0] = DihContinueB::ZCOPY_NODE; + signal->theData[1] = tabPtr.i + 1; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; + } else { + jam(); + TloopCount++; + tabPtr.i++; + }//if + }//if + }//while + dihCopyCompletedLab(signal); + return; +}//Dbdih::copyNodeLab() + +void Dbdih::tableCopyNodeLab(Signal* signal, TabRecordPtr tabPtr) +{ + /* ----------------------------------------------------------------------- */ + /* COPY PAGES READ TO STARTING NODE. */ + /* ----------------------------------------------------------------------- */ + if (!c_nodeStartMaster.activeState) { + jam(); + releaseTabPages(tabPtr.i); + c_nodeStartMaster.wait = ZFALSE; + return; + }//if + NodeRecordPtr copyNodePtr; + PageRecordPtr pagePtr; + copyNodePtr.i = c_nodeStartMaster.startNode; + ptrCheckGuard(copyNodePtr, MAX_NDB_NODES, nodeRecord); + + copyNodePtr.p->activeTabptr = tabPtr.i; + pagePtr.i = tabPtr.p->pageRef[0]; + ptrCheckGuard(pagePtr, cpageFileSize, pageRecord); + + signal->theData[0] = DihContinueB::ZCOPY_TABLE_NODE; + signal->theData[1] = tabPtr.i; + signal->theData[2] = copyNodePtr.i; + signal->theData[3] = 0; + signal->theData[4] = 0; + signal->theData[5] = pagePtr.p->word[34]; + sendSignal(reference(), GSN_CONTINUEB, signal, 6, JBB); +}//Dbdih::tableCopyNodeLab() + +/* ------------------------------------------------------------------------- */ +// execCONTINUEB(ZCOPY_TABLE) +// This routine is used to copy the table descriptions from the master to +// other nodes. It is used in the system restart to copy from master to all +// starting nodes. +/* ------------------------------------------------------------------------- */ +void Dbdih::copyTableLab(Signal* signal, Uint32 tableId) +{ + TabRecordPtr tabPtr; + tabPtr.i = tableId; + ptrAss(tabPtr, tabRecord); + + ndbrequire(tabPtr.p->tabCopyStatus == TabRecord::CS_IDLE); + tabPtr.p->tabCopyStatus = TabRecord::CS_SR_PHASE2_READ_TABLE; + signal->theData[0] = DihContinueB::ZPACK_TABLE_INTO_PAGES; + signal->theData[1] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; +}//Dbdih::copyTableLab() + +/* ------------------------------------------------------------------------- */ +// execCONTINUEB(ZSR_PHASE2_READ_TABLE) +/* ------------------------------------------------------------------------- */ +void Dbdih::srPhase2ReadTableLab(Signal* signal, TabRecordPtr tabPtr) +{ + /* ----------------------------------------------------------------------- */ + // We set the sendCOPY_TABREQState to ZACTIVE for all nodes since it is a long + // process to send off all table descriptions. Thus we ensure that we do + // not encounter race conditions where one node is completed before the + // sending process is completed. This could lead to that we start off the + // system before we actually finished all copying of table descriptions + // and could lead to strange errors. + /* ----------------------------------------------------------------------- */ + + //sendLoopMacro(COPY_TABREQ, nullRoutine); + + breakCopyTableLab(signal, tabPtr, cfirstAliveNode); + return; +}//Dbdih::srPhase2ReadTableLab() + +/* ------------------------------------------------------------------------- */ +/* COPY PAGES READ TO ALL NODES. */ +/* ------------------------------------------------------------------------- */ +void Dbdih::breakCopyTableLab(Signal* signal, TabRecordPtr tabPtr, Uint32 nodeId) +{ + NodeRecordPtr nodePtr; + nodePtr.i = nodeId; + while (nodePtr.i != RNIL) { + jam(); + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + if (nodePtr.i == getOwnNodeId()){ + jam(); + /* ------------------------------------------------------------------- */ + /* NOT NECESSARY TO COPY TO MY OWN NODE. I ALREADY HAVE THE PAGES. */ + /* I DO HOWEVER NEED TO STORE THE TABLE DESCRIPTION ONTO DISK. */ + /* ------------------------------------------------------------------- */ + /* IF WE ARE MASTER WE ONLY NEED TO SAVE THE TABLE ON DISK. WE ALREADY */ + /* HAVE THE TABLE DESCRIPTION IN THE DATA STRUCTURES. */ + // AFTER COMPLETING THE WRITE TO DISK THE MASTER WILL ALSO SEND + // COPY_TABCONF AS ALL THE OTHER NODES. + /* ------------------------------------------------------------------- */ + c_COPY_TABREQ_Counter.setWaitingFor(nodePtr.i); + tabPtr.p->tabUpdateState = TabRecord::US_COPY_TAB_REQ; + signal->theData[0] = DihContinueB::ZTABLE_UPDATE; + signal->theData[1] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + nodePtr.i = nodePtr.p->nextNode; + } else { + PageRecordPtr pagePtr; + /* -------------------------------------------------------------------- */ + // RATHER THAN SENDING ALL COPY_TABREQ IN PARALLEL WE WILL SERIALISE THIS + // ACTIVITY AND WILL THUS CALL breakCopyTableLab AGAIN WHEN COMPLETED THE + // SENDING OF COPY_TABREQ'S. + /* -------------------------------------------------------------------- */ + jam(); + tabPtr.p->tabCopyStatus = TabRecord::CS_SR_PHASE3_COPY_TABLE; + pagePtr.i = tabPtr.p->pageRef[0]; + ptrCheckGuard(pagePtr, cpageFileSize, pageRecord); + signal->theData[0] = DihContinueB::ZCOPY_TABLE_NODE; + signal->theData[1] = tabPtr.i; + signal->theData[2] = nodePtr.i; + signal->theData[3] = 0; + signal->theData[4] = 0; + signal->theData[5] = pagePtr.p->word[34]; + sendSignal(reference(), GSN_CONTINUEB, signal, 6, JBB); + return; + }//if + }//while + /* ----------------------------------------------------------------------- */ + /* WE HAVE NOW SENT THE TABLE PAGES TO ALL NODES. EXIT AND WAIT FOR ALL */ + /* REPLIES. */ + /* ----------------------------------------------------------------------- */ + return; +}//Dbdih::breakCopyTableLab() + +/* ------------------------------------------------------------------------- */ +// execCONTINUEB(ZCOPY_TABLE_NODE) +/* ------------------------------------------------------------------------- */ +void Dbdih::copyTableNode(Signal* signal, + CopyTableNode* ctn, NodeRecordPtr nodePtr) +{ + if (getNodeState().startLevel >= NodeState::SL_STARTED){ + /* --------------------------------------------------------------------- */ + // We are in the process of performing a node restart and are copying a + // table description to a starting node. We will check that no nodes have + // crashed in this process. + /* --------------------------------------------------------------------- */ + if (!c_nodeStartMaster.activeState) { + jam(); + /** ------------------------------------------------------------------ + * The starting node crashed. We will release table pages and stop this + * copy process and allow new node restarts to start. + * ------------------------------------------------------------------ */ + releaseTabPages(ctn->ctnTabPtr.i); + c_nodeStartMaster.wait = ZFALSE; + return; + }//if + }//if + ndbrequire(ctn->pageIndex < 8); + ctn->ctnPageptr.i = ctn->ctnTabPtr.p->pageRef[ctn->pageIndex]; + ptrCheckGuard(ctn->ctnPageptr, cpageFileSize, pageRecord); + /** + * If first page & firstWord reqinfo = 1 (first signal) + */ + Uint32 reqinfo = (ctn->pageIndex == 0) && (ctn->wordIndex == 0); + if(reqinfo == 1){ + c_COPY_TABREQ_Counter.setWaitingFor(nodePtr.i); + } + + for (Uint32 i = 0; i < 16; i++) { + jam(); + sendCopyTable(signal, ctn, calcDihBlockRef(nodePtr.i), reqinfo); + reqinfo = 0; + if (ctn->noOfWords <= 16) { + jam(); + switch (ctn->ctnTabPtr.p->tabCopyStatus) { + case TabRecord::CS_SR_PHASE3_COPY_TABLE: + /* ------------------------------------------------------------------ */ + // We have copied the table description to this node. + // We will now proceed + // with sending the table description to the next node in the node list. + /* ------------------------------------------------------------------ */ + jam(); + ctn->ctnTabPtr.p->tabCopyStatus = TabRecord::CS_IDLE; + breakCopyTableLab(signal, ctn->ctnTabPtr, nodePtr.p->nextNode); + return; + break; + case TabRecord::CS_COPY_NODE_STATE: + jam(); + ctn->ctnTabPtr.p->tabCopyStatus = TabRecord::CS_IDLE; + return; + break; + default: + ndbrequire(false); + break; + }//switch + } else { + jam(); + ctn->wordIndex += 16; + if (ctn->wordIndex == 2048) { + jam(); + ctn->wordIndex = 0; + ctn->pageIndex++; + ndbrequire(ctn->pageIndex < 8); + ctn->ctnPageptr.i = ctn->ctnTabPtr.p->pageRef[ctn->pageIndex]; + ptrCheckGuard(ctn->ctnPageptr, cpageFileSize, pageRecord); + }//if + ctn->noOfWords -= 16; + }//if + }//for + signal->theData[0] = DihContinueB::ZCOPY_TABLE_NODE; + signal->theData[1] = ctn->ctnTabPtr.i; + signal->theData[2] = nodePtr.i; + signal->theData[3] = ctn->pageIndex; + signal->theData[4] = ctn->wordIndex; + signal->theData[5] = ctn->noOfWords; + sendSignal(reference(), GSN_CONTINUEB, signal, 6, JBB); +}//Dbdih::copyTableNodeLab() + +void Dbdih::sendCopyTable(Signal* signal, CopyTableNode* ctn, + BlockReference ref, Uint32 reqinfo) +{ + signal->theData[0] = reference(); + signal->theData[1] = reqinfo; + signal->theData[2] = ctn->ctnTabPtr.i; + signal->theData[3] = ctn->ctnTabPtr.p->schemaVersion; + signal->theData[4] = ctn->noOfWords; + ndbrequire(ctn->wordIndex + 15 < 2048); + MEMCOPY_NO_WORDS(&signal->theData[5], &ctn->ctnPageptr.p->word[ctn->wordIndex], 16); + sendSignal(ref, GSN_COPY_TABREQ, signal, 21, JBB); +}//Dbdih::sendCopyTable() + +void Dbdih::execCOPY_TABCONF(Signal* signal) +{ + NodeRecordPtr nodePtr; + jamEntry(); + nodePtr.i = signal->theData[0]; + Uint32 tableId = signal->theData[1]; + if (getNodeState().startLevel >= NodeState::SL_STARTED){ + /* --------------------------------------------------------------------- */ + // We are in the process of performing a node restart. Continue by copying + // the next table to the starting node. + /* --------------------------------------------------------------------- */ + jam(); + NodeRecordPtr nodePtr; + nodePtr.i = signal->theData[0]; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + c_COPY_TABREQ_Counter.clearWaitingFor(nodePtr.i); + + releaseTabPages(tableId); + signal->theData[0] = DihContinueB::ZCOPY_NODE; + signal->theData[1] = tableId + 1; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; + } else { + /* --------------------------------------------------------------------- */ + // We are in the process of performing a system restart. Check if all nodes + // have saved the new table description to file and then continue with the + // next table. + /* --------------------------------------------------------------------- */ + receiveLoopMacro(COPY_TABREQ, nodePtr.i); + /* --------------------------------------------------------------------- */ + /* WE HAVE NOW COPIED TO ALL NODES. WE HAVE NOW COMPLETED RESTORING */ + /* THIS TABLE. CONTINUE WITH THE NEXT TABLE. */ + /* WE NEED TO RELEASE THE PAGES IN THE TABLE IN THIS NODE HERE. */ + /* WE ALSO NEED TO CLOSE THE TABLE FILE. */ + /* --------------------------------------------------------------------- */ + releaseTabPages(tableId); + + TabRecordPtr tabPtr; + tabPtr.i = tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + + ConnectRecordPtr connectPtr; + connectPtr.i = tabPtr.p->connectrec; + ptrCheckGuard(connectPtr, cconnectFileSize, connectRecord); + + sendAddFragreq(signal, connectPtr, tabPtr, 0); + return; + }//if +}//Dbdih::execCOPY_TABCONF() + +/* + 3.13 L O C A L C H E C K P O I N T (M A S T E R) + **************************************************** + */ +/*****************************************************************************/ +/* ********** LOCAL-CHECK-POINT-HANDLING MODULE *************/ +/*****************************************************************************/ +/* ------------------------------------------------------------------------- */ +/* IT IS TIME TO CHECK IF IT IS TIME TO START A LOCAL CHECKPOINT. */ +/* WE WILL EITHER START AFTER 1 MILLION WORDS HAVE ARRIVED OR WE WILL */ +/* EXECUTE AFTER ABOUT 16 MINUTES HAVE PASSED BY. */ +/* ------------------------------------------------------------------------- */ +void Dbdih::checkTcCounterLab(Signal* signal) +{ + CRASH_INSERTION(7009); + if (c_lcpState.lcpStatus != LCP_STATUS_IDLE) { + ndbout << "lcpStatus = " << c_lcpState.lcpStatus; + ndbout << "lcpStatusUpdatedPlace = " << + c_lcpState.lcpStatusUpdatedPlace << endl; + ndbrequire(false); + return; + }//if + c_lcpState.ctimer += 32; + if ((c_nodeStartMaster.blockLcp == true) || + ((c_lcpState.lcpStartGcp + 1) > currentgcp)) { + jam(); + /* --------------------------------------------------------------------- */ + // No reason to start juggling the states and checking for start of LCP if + // we are blocked to start an LCP anyway. + // We also block LCP start if we have not completed one global checkpoints + // before starting another local checkpoint. + /* --------------------------------------------------------------------- */ + signal->theData[0] = DihContinueB::ZCHECK_TC_COUNTER; + signal->theData[1] = __LINE__; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 1 * 100, 2); + return; + }//if + c_lcpState.setLcpStatus(LCP_TCGET, __LINE__); + + c_lcpState.ctcCounter = c_lcpState.ctimer; + sendLoopMacro(TCGETOPSIZEREQ, sendTCGETOPSIZEREQ); +}//Dbdih::checkTcCounterLab() + +void Dbdih::checkLcpStart(Signal* signal, Uint32 lineNo) +{ + /* ----------------------------------------------------------------------- */ + // Verify that we are not attempting to start another instance of the LCP + // when it is not alright to do so. + /* ----------------------------------------------------------------------- */ + ndbrequire(c_lcpState.lcpStart == ZIDLE); + c_lcpState.lcpStart = ZACTIVE; + signal->theData[0] = DihContinueB::ZCHECK_TC_COUNTER; + signal->theData[1] = lineNo; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 1000, 2); +}//Dbdih::checkLcpStart() + +/* ------------------------------------------------------------------------- */ +/*TCGETOPSIZECONF HOW MUCH OPERATION SIZE HAVE BEEN EXECUTED BY TC */ +/* ------------------------------------------------------------------------- */ +void Dbdih::execTCGETOPSIZECONF(Signal* signal) +{ + jamEntry(); + Uint32 senderNodeId = signal->theData[0]; + c_lcpState.ctcCounter += signal->theData[1]; + + receiveLoopMacro(TCGETOPSIZEREQ, senderNodeId); + + ndbrequire(c_lcpState.lcpStatus == LCP_TCGET); + ndbrequire(c_lcpState.lcpStart == ZACTIVE); + /* ----------------------------------------------------------------------- */ + // We are not actively starting another LCP, still we receive this signal. + // This is not ok. + /* ---------------------------------------------------------------------- */ + /* ALL TC'S HAVE RESPONDED NOW. NOW WE WILL CHECK IF ENOUGH OPERATIONS */ + /* HAVE EXECUTED TO ENABLE US TO START A NEW LOCAL CHECKPOINT. */ + /* WHILE COPYING DICTIONARY AND DISTRIBUTION INFO TO A STARTING NODE */ + /* WE WILL ALSO NOT ALLOW THE LOCAL CHECKPOINT TO PROCEED. */ + /*----------------------------------------------------------------------- */ + if (c_lcpState.immediateLcpStart == false) { + if ((c_lcpState.ctcCounter < + ((Uint32)1 << c_lcpState.clcpDelay)) || + (c_nodeStartMaster.blockLcp == true)) { + jam(); + c_lcpState.setLcpStatus(LCP_STATUS_IDLE, __LINE__); + + signal->theData[0] = DihContinueB::ZCHECK_TC_COUNTER; + signal->theData[1] = __LINE__; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 1 * 100, 2); + return; + }//if + }//if + c_lcpState.lcpStart = ZIDLE; + c_lcpState.immediateLcpStart = false; + /* ----------------------------------------------------------------------- + * Now the initial lcp is started, + * we can reset the delay to its orginal value + * --------------------------------------------------------------------- */ + CRASH_INSERTION(7010); + /* ----------------------------------------------------------------------- */ + /* IF MORE THAN 1 MILLION WORDS PASSED THROUGH THE TC'S THEN WE WILL */ + /* START A NEW LOCAL CHECKPOINT. CLEAR CTIMER. START CHECKPOINT */ + /* ACTIVITY BY CALCULATING THE KEEP GLOBAL CHECKPOINT. */ + // Also remember the current global checkpoint to ensure that we run at least + // one global checkpoints between each local checkpoint that we start up. + /* ----------------------------------------------------------------------- */ + c_lcpState.ctimer = 0; + c_lcpState.keepGci = coldgcp; + c_lcpState.lcpStartGcp = currentgcp; + /* ----------------------------------------------------------------------- */ + /* UPDATE THE NEW LATEST LOCAL CHECKPOINT ID. */ + /* ----------------------------------------------------------------------- */ + cnoOfActiveTables = 0; + c_lcpState.setLcpStatus(LCP_CALCULATE_KEEP_GCI, __LINE__); + c_lcpState.oldestRestorableGci = SYSFILE->oldestRestorableGCI; + ndbrequire(((int)c_lcpState.oldestRestorableGci) > 0); + + if (ERROR_INSERTED(7011)) { + signal->theData[0] = EventReport::LCPStoppedInCalcKeepGci; + signal->theData[1] = 0; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); + return; + }//if + signal->theData[0] = DihContinueB::ZCALCULATE_KEEP_GCI; + signal->theData[1] = 0; /* TABLE ID = 0 */ + signal->theData[2] = 0; /* FRAGMENT ID = 0 */ + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); + return; +}//Dbdih::execTCGETOPSIZECONF() + +/* ------------------------------------------------------------------------- */ +/* WE NEED TO CALCULATE THE OLDEST GLOBAL CHECKPOINT THAT WILL BE */ +/* COMPLETELY RESTORABLE AFTER EXECUTING THIS LOCAL CHECKPOINT. */ +/* ------------------------------------------------------------------------- */ +void Dbdih::calculateKeepGciLab(Signal* signal, Uint32 tableId, Uint32 fragId) +{ + TabRecordPtr tabPtr; + Uint32 TloopCount = 1; + tabPtr.i = tableId; + do { + if (tabPtr.i >= ctabFileSize) { + if (cnoOfActiveTables > 0) { + jam(); + signal->theData[0] = DihContinueB::ZSTORE_NEW_LCP_ID; + sendSignal(reference(), GSN_CONTINUEB, signal, 1, JBB); + return; + } else { + jam(); + /* ------------------------------------------------------------------ */ + /* THERE ARE NO TABLES TO CHECKPOINT. WE STOP THE CHECKPOINT ALREADY */ + /* HERE TO AVOID STRANGE PROBLEMS LATER. */ + /* ------------------------------------------------------------------ */ + c_lcpState.setLcpStatus(LCP_STATUS_IDLE, __LINE__); + checkLcpStart(signal, __LINE__); + return; + }//if + }//if + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + if (tabPtr.p->tabStatus != TabRecord::TS_ACTIVE || + tabPtr.p->storedTable == 0) { + if (TloopCount > 100) { + jam(); + signal->theData[0] = DihContinueB::ZCALCULATE_KEEP_GCI; + signal->theData[1] = tabPtr.i + 1; + signal->theData[2] = 0; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); + return; + } else { + jam(); + TloopCount++; + tabPtr.i++; + }//if + } else { + jam(); + TloopCount = 0; + }//if + } while (TloopCount != 0); + cnoOfActiveTables++; + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, fragId, fragPtr); + checkKeepGci(fragPtr.p->storedReplicas); + fragId++; + if (fragId >= tabPtr.p->totalfragments) { + jam(); + tabPtr.i++; + fragId = 0; + }//if + signal->theData[0] = DihContinueB::ZCALCULATE_KEEP_GCI; + signal->theData[1] = tabPtr.i; + signal->theData[2] = fragId; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); + return; +}//Dbdih::calculateKeepGciLab() + +/* ------------------------------------------------------------------------- */ +/* WE NEED TO STORE ON DISK THE FACT THAT WE ARE STARTING THIS LOCAL */ +/* CHECKPOINT ROUND. THIS WILL INVALIDATE ALL THE LOCAL CHECKPOINTS */ +/* THAT WILL EVENTUALLY BE OVERWRITTEN AS PART OF THIS LOCAL CHECKPOINT*/ +/* ------------------------------------------------------------------------- */ +void Dbdih::storeNewLcpIdLab(Signal* signal) +{ + /***************************************************************************/ + // Report the event that a local checkpoint has started. + /***************************************************************************/ + signal->theData[0] = EventReport::LocalCheckpointStarted; //Event type + signal->theData[1] = SYSFILE->latestLCP_ID + 1; + signal->theData[2] = c_lcpState.keepGci; + signal->theData[3] = c_lcpState.oldestRestorableGci; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 4, JBB); + + signal->setTrace(TestOrd::TraceLocalCheckpoint); + + CRASH_INSERTION(7013); + SYSFILE->keepGCI = c_lcpState.keepGci; + //Uint32 lcpId = SYSFILE->latestLCP_ID; + SYSFILE->latestLCP_ID++; + SYSFILE->oldestRestorableGCI = c_lcpState.oldestRestorableGci; + + const Uint32 oldestRestorableGCI = SYSFILE->oldestRestorableGCI; + //const Uint32 newestRestorableGCI = SYSFILE->newestRestorableGCI; + //ndbrequire(newestRestorableGCI >= oldestRestorableGCI); + + Int32 val = oldestRestorableGCI; + ndbrequire(val > 0); + + /* ----------------------------------------------------------------------- */ + /* SET BIT INDICATING THAT LOCAL CHECKPOINT IS ONGOING. THIS IS CLEARED */ + /* AT THE END OF A LOCAL CHECKPOINT. */ + /* ----------------------------------------------------------------------- */ + SYSFILE->setLCPOngoing(SYSFILE->systemRestartBits); + /* ---------------------------------------------------------------------- */ + /* CHECK IF ANY NODE MUST BE TAKEN OUT OF SERVICE AND REFILLED WITH */ + /* NEW FRESH DATA FROM AN ACTIVE NODE. */ + /* ---------------------------------------------------------------------- */ + setLcpActiveStatusStart(signal); + c_lcpState.setLcpStatus(LCP_COPY_GCI, __LINE__); + //#ifdef VM_TRACE + // infoEvent("LocalCheckpoint %d started", SYSFILE->latestLCP_ID); + // signal->theData[0] = 7012; + // execDUMP_STATE_ORD(signal); + //#endif + + copyGciLab(signal, CopyGCIReq::LOCAL_CHECKPOINT); +}//Dbdih::storeNewLcpIdLab() + +void Dbdih::startLcpRoundLab(Signal* signal) { + jam(); + + Mutex mutex(signal, c_mutexMgr, c_startLcpMutexHandle); + Callback c = { safe_cast(&Dbdih::startLcpMutex_locked), 0 }; + ndbrequire(mutex.lock(c)); +} + +void +Dbdih::startLcpMutex_locked(Signal* signal, Uint32 senderData, Uint32 retVal){ + jamEntry(); + ndbrequire(retVal == 0); + + StartLcpReq* req = (StartLcpReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + req->lcpId = SYSFILE->latestLCP_ID; + req->participatingLQH = c_lcpState.m_participatingLQH; + req->participatingDIH = c_lcpState.m_participatingDIH; + sendLoopMacro(START_LCP_REQ, sendSTART_LCP_REQ); +} +void +Dbdih::sendSTART_LCP_REQ(Signal* signal, Uint32 nodeId){ + BlockReference ref = calcDihBlockRef(nodeId); + sendSignal(ref, GSN_START_LCP_REQ, signal, StartLcpReq::SignalLength, JBB); +} + +void +Dbdih::execSTART_LCP_CONF(Signal* signal){ + StartLcpConf * conf = (StartLcpConf*)signal->getDataPtr(); + + Uint32 nodeId = refToNode(conf->senderRef); + receiveLoopMacro(START_LCP_REQ, nodeId); + + Mutex mutex(signal, c_mutexMgr, c_startLcpMutexHandle); + Callback c = { safe_cast(&Dbdih::startLcpMutex_unlocked), 0 }; + mutex.unlock(c); +} + +void +Dbdih::startLcpMutex_unlocked(Signal* signal, Uint32 data, Uint32 retVal){ + jamEntry(); + ndbrequire(retVal == 0); + + Mutex mutex(signal, c_mutexMgr, c_startLcpMutexHandle); + mutex.release(); + + CRASH_INSERTION(7014); + c_lcpState.setLcpStatus(LCP_TC_CLOPSIZE, __LINE__); + sendLoopMacro(TC_CLOPSIZEREQ, sendTC_CLOPSIZEREQ); +} + +void Dbdih::execTC_CLOPSIZECONF(Signal* signal) { + jamEntry(); + Uint32 senderNodeId = signal->theData[0]; + receiveLoopMacro(TC_CLOPSIZEREQ, senderNodeId); + + ndbrequire(c_lcpState.lcpStatus == LCP_TC_CLOPSIZE); + /* ----------------------------------------------------------------------- */ + /* ALL TC'S HAVE CLEARED THEIR OPERATION SIZE COUNTERS. NOW PROCEED BY */ + /* STARTING THE LOCAL CHECKPOINT IN EACH LQH. */ + /* ----------------------------------------------------------------------- */ + c_lcpState.m_LAST_LCP_FRAG_ORD = c_lcpState.m_participatingLQH; + + CRASH_INSERTION(7015); + c_lcpState.setLcpStatus(LCP_START_LCP_ROUND, __LINE__); + startLcpRoundLoopLab(signal, 0, 0); +}//Dbdih::execTC_CLOPSIZECONF() + +void Dbdih::startLcpRoundLoopLab(Signal* signal, + Uint32 startTableId, Uint32 startFragId) +{ + NodeRecordPtr nodePtr; + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + ptrAss(nodePtr, nodeRecord); + if (nodePtr.p->nodeStatus == NodeRecord::ALIVE) { + ndbrequire(nodePtr.p->noOfStartedChkpt == 0); + ndbrequire(nodePtr.p->noOfQueuedChkpt == 0); + }//if + }//if + c_lcpState.currentFragment.tableId = startTableId; + c_lcpState.currentFragment.fragmentId = startFragId; + startNextChkpt(signal); +}//Dbdih::startLcpRoundLoopLab() + +void Dbdih::startNextChkpt(Signal* signal) +{ + Uint32 lcpId = SYSFILE->latestLCP_ID; + + NdbNodeBitmask busyNodes; + busyNodes.clear(); + const Uint32 lcpNodes = c_lcpState.m_participatingLQH.count(); + + bool save = true; + LcpState::CurrentFragment curr = c_lcpState.currentFragment; + + while (curr.tableId < ctabFileSize) { + TabRecordPtr tabPtr; + tabPtr.i = curr.tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + if ((tabPtr.p->tabStatus != TabRecord::TS_ACTIVE) || + (tabPtr.p->tabLcpStatus != TabRecord::TLS_ACTIVE)) { + curr.tableId++; + curr.fragmentId = 0; + continue; + }//if + + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, curr.fragmentId, fragPtr); + + ReplicaRecordPtr replicaPtr; + for(replicaPtr.i = fragPtr.p->storedReplicas; + replicaPtr.i != RNIL ; + replicaPtr.i = replicaPtr.p->nextReplica){ + + jam(); + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + + NodeRecordPtr nodePtr; + nodePtr.i = replicaPtr.p->procNode; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + + if (replicaPtr.p->lcpOngoingFlag && + replicaPtr.p->lcpIdStarted < lcpId) { + jam(); + //------------------------------------------------------------------- + // We have found a replica on a node that performs local checkpoint + // that is alive and that have not yet been started. + //------------------------------------------------------------------- + + if (nodePtr.p->noOfStartedChkpt < 2) { + jam(); + /** + * Send LCP_FRAG_ORD to LQH + */ + + /** + * Mark the replica so with lcpIdStarted == true + */ + replicaPtr.p->lcpIdStarted = lcpId; + + Uint32 i = nodePtr.p->noOfStartedChkpt; + nodePtr.p->startedChkpt[i].tableId = tabPtr.i; + nodePtr.p->startedChkpt[i].fragId = curr.fragmentId; + nodePtr.p->startedChkpt[i].replicaPtr = replicaPtr.i; + nodePtr.p->noOfStartedChkpt = i + 1; + + sendLCP_FRAG_ORD(signal, nodePtr.p->startedChkpt[i]); + } else if (nodePtr.p->noOfQueuedChkpt < 2) { + jam(); + /** + * Put LCP_FRAG_ORD "in queue" + */ + + /** + * Mark the replica so with lcpIdStarted == true + */ + replicaPtr.p->lcpIdStarted = lcpId; + + Uint32 i = nodePtr.p->noOfQueuedChkpt; + nodePtr.p->queuedChkpt[i].tableId = tabPtr.i; + nodePtr.p->queuedChkpt[i].fragId = curr.fragmentId; + nodePtr.p->queuedChkpt[i].replicaPtr = replicaPtr.i; + nodePtr.p->noOfQueuedChkpt = i + 1; + } else { + jam(); + + if(save){ + /** + * Stop increasing value on first that was "full" + */ + c_lcpState.currentFragment = curr; + save = false; + } + + busyNodes.set(nodePtr.i); + if(busyNodes.count() == lcpNodes){ + /** + * There were no possibility to start the local checkpoint + * and it was not possible to queue it up. In this case we + * stop the start of local checkpoints until the nodes with a + * backlog have performed more checkpoints. We will return and + * will not continue the process of starting any more checkpoints. + */ + return; + }//if + }//if + } + }//while + curr.fragmentId++; + if (curr.fragmentId >= tabPtr.p->totalfragments) { + jam(); + curr.fragmentId = 0; + curr.tableId++; + }//if + }//while + + sendLastLCP_FRAG_ORD(signal); +}//Dbdih::startNextChkpt() + +void Dbdih::sendLastLCP_FRAG_ORD(Signal* signal) +{ + LcpFragOrd * const lcpFragOrd = (LcpFragOrd *)&signal->theData[0]; + lcpFragOrd->tableId = RNIL; + lcpFragOrd->fragmentId = 0; + lcpFragOrd->lcpId = SYSFILE->latestLCP_ID; + lcpFragOrd->lcpNo = 0; + lcpFragOrd->keepGci = c_lcpState.keepGci; + lcpFragOrd->lastFragmentFlag = true; + + NodeRecordPtr nodePtr; + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRecord); + + if(nodePtr.p->noOfQueuedChkpt == 0 && + nodePtr.p->noOfStartedChkpt == 0 && + c_lcpState.m_LAST_LCP_FRAG_ORD.isWaitingFor(nodePtr.i)){ + jam(); + + CRASH_INSERTION(7028); + + /** + * Nothing queued or started <=> Complete on that node + * + */ + c_lcpState.m_LAST_LCP_FRAG_ORD.clearWaitingFor(nodePtr.i); + if(ERROR_INSERTED(7075)){ + continue; + } + BlockReference ref = calcLqhBlockRef(nodePtr.i); + sendSignal(ref, GSN_LCP_FRAG_ORD, signal,LcpFragOrd::SignalLength, JBB); + } + } + if(ERROR_INSERTED(7075)){ + if(c_lcpState.m_LAST_LCP_FRAG_ORD.done()) + CRASH_INSERTION(7075); + } +}//Dbdih::sendLastLCP_FRAGORD() + +/* ------------------------------------------------------------------------- */ +/* A FRAGMENT REPLICA HAS COMPLETED EXECUTING ITS LOCAL CHECKPOINT. */ +/* CHECK IF ALL REPLICAS IN THE TABLE HAVE COMPLETED. IF SO STORE THE */ +/* THE TABLE DISTRIBUTION ON DISK. ALSO SEND LCP_REPORT TO ALL OTHER */ +/* NODES SO THAT THEY CAN STORE THE TABLE ONTO DISK AS WELL. */ +/* ------------------------------------------------------------------------- */ +void Dbdih::execLCP_FRAG_REP(Signal* signal) +{ + jamEntry(); + ndbrequire(c_lcpState.lcpStatus != LCP_STATUS_IDLE); + +#if 0 + printLCP_FRAG_REP(stdout, + signal->getDataPtr(), + signal->length(), number()); +#endif + + LcpFragRep * const lcpReport = (LcpFragRep *)&signal->theData[0]; + Uint32 nodeId = lcpReport->nodeId; + Uint32 tableId = lcpReport->tableId; + Uint32 fragId = lcpReport->fragId; + + jamEntry(); + + CRASH_INSERTION2(7025, isMaster()); + CRASH_INSERTION2(7016, !isMaster()); + + bool fromTimeQueue = (signal->senderBlockRef() == reference()); + + TabRecordPtr tabPtr; + tabPtr.i = tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + if(tabPtr.p->tabCopyStatus != TabRecord::CS_IDLE) { + jam(); + /*-----------------------------------------------------------------------*/ + // If the table is currently copied to disk we also + // stop already here to avoid strange half-way updates + // of the table data structures. + /*-----------------------------------------------------------------------*/ + /* + We need to send this signal without a delay since we have discovered + that we have run out of space in the short time queue. This problem + is very erunlikely to happen but it has and it results in a node crash. + This should be considered a "quick fix" and not a permanent solution. + A cleaner/better way would be to check the time queue if it is full or + not before sending this signal. + */ + sendSignal(reference(), GSN_LCP_FRAG_REP, signal, signal->length(), JBB); + /* Kept here for reference + sendSignalWithDelay(reference(), GSN_LCP_FRAG_REP, + signal, 20, signal->length()); + */ + + if(!fromTimeQueue){ + c_lcpState.noOfLcpFragRepOutstanding++; + } + + return; + }//if + + if(fromTimeQueue){ + jam(); + + ndbrequire(c_lcpState.noOfLcpFragRepOutstanding > 0); + c_lcpState.noOfLcpFragRepOutstanding--; + } + + bool tableDone = reportLcpCompletion(lcpReport); + + if(tableDone){ + jam(); + + if(tabPtr.p->tabStatus == TabRecord::TS_DROPPING){ + jam(); + ndbout_c("TS_DROPPING - Neglecting to save Table: %d Frag: %d - ", + tableId, + fragId); + } else { + jam(); + /** + * Write table description to file + */ + tabPtr.p->tabLcpStatus = TabRecord::TLS_WRITING_TO_FILE; + tabPtr.p->tabCopyStatus = TabRecord::CS_LCP_READ_TABLE; + tabPtr.p->tabUpdateState = TabRecord::US_LOCAL_CHECKPOINT; + signal->theData[0] = DihContinueB::ZPACK_TABLE_INTO_PAGES; + signal->theData[1] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + + checkLcpAllTablesDoneInLqh(); + } + } + +#ifdef VM_TRACE + /* --------------------------------------------------------------------- */ + // REPORT that local checkpoint have completed this fragment. + /* --------------------------------------------------------------------- */ + signal->theData[0] = EventReport::LCPFragmentCompleted; + signal->theData[1] = nodeId; + signal->theData[2] = tableId; + signal->theData[3] = fragId; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 4, JBB); +#endif + + bool ok = false; + switch(c_lcpMasterTakeOverState.state){ + case LMTOS_IDLE: + ok = true; + jam(); + /** + * Fall through + */ + break; + case LMTOS_WAIT_EMPTY_LCP: // LCP Take over waiting for EMPTY_LCPCONF + jam(); + return; + case LMTOS_WAIT_LCP_FRAG_REP: + jam(); + checkEmptyLcpComplete(signal); + return; + case LMTOS_INITIAL: + case LMTOS_ALL_IDLE: + case LMTOS_ALL_ACTIVE: + case LMTOS_LCP_CONCLUDING: + case LMTOS_COPY_ONGOING: + ndbrequire(false); + } + ndbrequire(ok); + + /* ----------------------------------------------------------------------- */ + // Check if there are more LCP's to start up. + /* ----------------------------------------------------------------------- */ + if(isMaster()){ + jam(); + + /** + * Remove from "running" array + */ + NodeRecordPtr nodePtr; + nodePtr.i = nodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + + const Uint32 outstanding = nodePtr.p->noOfStartedChkpt; + ndbrequire(outstanding > 0); + if(nodePtr.p->startedChkpt[0].tableId != tableId || + nodePtr.p->startedChkpt[0].fragId != fragId){ + jam(); + ndbrequire(outstanding > 1); + ndbrequire(nodePtr.p->startedChkpt[1].tableId == tableId); + ndbrequire(nodePtr.p->startedChkpt[1].fragId == fragId); + } else { + jam(); + nodePtr.p->startedChkpt[0] = nodePtr.p->startedChkpt[1]; + } + nodePtr.p->noOfStartedChkpt--; + checkStartMoreLcp(signal, nodeId); + } +} + +bool +Dbdih::checkLcpAllTablesDoneInLqh(){ + TabRecordPtr tabPtr; + + /** + * Check if finished with all tables + */ + for (tabPtr.i = 0; tabPtr.i < ctabFileSize; tabPtr.i++) { + jam(); + ptrAss(tabPtr, tabRecord); + if ((tabPtr.p->tabStatus == TabRecord::TS_ACTIVE) && + (tabPtr.p->tabLcpStatus == TabRecord::TLS_ACTIVE)) { + jam(); + /** + * Nope, not finished with all tables + */ + return false; + }//if + }//for + + CRASH_INSERTION2(7026, isMaster()); + CRASH_INSERTION2(7017, !isMaster()); + + c_lcpState.setLcpStatus(LCP_TAB_COMPLETED, __LINE__); + return true; +} + +void Dbdih::findReplica(ReplicaRecordPtr& replicaPtr, + Fragmentstore* fragPtrP, Uint32 nodeId) +{ + replicaPtr.i = fragPtrP->storedReplicas; + while(replicaPtr.i != RNIL){ + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + if (replicaPtr.p->procNode == nodeId) { + jam(); + return; + } else { + jam(); + replicaPtr.i = replicaPtr.p->nextReplica; + }//if + }; + +#ifdef VM_TRACE + ndbout_c("Fragment Replica(node=%d) not found", nodeId); + replicaPtr.i = fragPtrP->oldStoredReplicas; + while(replicaPtr.i != RNIL){ + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + if (replicaPtr.p->procNode == nodeId) { + jam(); + break; + } else { + jam(); + replicaPtr.i = replicaPtr.p->nextReplica; + }//if + }; + if(replicaPtr.i != RNIL){ + ndbout_c("...But was found in oldStoredReplicas"); + } else { + ndbout_c("...And wasn't found in oldStoredReplicas"); + } +#endif + ndbrequire(false); +}//Dbdih::findReplica() + +/** + * Return true if table is all fragment replicas have been checkpointed + * to disk (in all LQHs) + * false otherwise + */ +bool +Dbdih::reportLcpCompletion(const LcpFragRep* lcpReport) +{ + Uint32 lcpNo = lcpReport->lcpNo; + Uint32 lcpId = lcpReport->lcpId; + Uint32 maxGciStarted = lcpReport->maxGciStarted; + Uint32 maxGciCompleted = lcpReport->maxGciCompleted; + Uint32 tableId = lcpReport->tableId; + Uint32 fragId = lcpReport->fragId; + Uint32 nodeId = lcpReport->nodeId; + + TabRecordPtr tabPtr; + tabPtr.i = tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, fragId, fragPtr); + + ReplicaRecordPtr replicaPtr; + findReplica(replicaPtr, fragPtr.p, nodeId); + + ndbrequire(replicaPtr.p->lcpOngoingFlag == true); + if(lcpNo != replicaPtr.p->nextLcp){ + ndbout_c("lcpNo = %d replicaPtr.p->nextLcp = %d", + lcpNo, replicaPtr.p->nextLcp); + ndbrequire(false); + } + ndbrequire(lcpNo == replicaPtr.p->nextLcp); + ndbrequire(lcpNo < MAX_LCP_STORED); + ndbrequire(replicaPtr.p->lcpId[lcpNo] != lcpId); + + replicaPtr.p->lcpIdStarted = lcpId; + replicaPtr.p->lcpOngoingFlag = false; + + removeOldCrashedReplicas(replicaPtr); + replicaPtr.p->lcpId[lcpNo] = lcpId; + replicaPtr.p->lcpStatus[lcpNo] = ZVALID; + replicaPtr.p->maxGciStarted[lcpNo] = maxGciStarted; + gth(maxGciStarted + 1, 0); + replicaPtr.p->maxGciCompleted[lcpNo] = maxGciCompleted; + replicaPtr.p->nextLcp = nextLcpNo(replicaPtr.p->nextLcp); + + ndbrequire(fragPtr.p->noLcpReplicas > 0); + fragPtr.p->noLcpReplicas --; + + if(fragPtr.p->noLcpReplicas > 0){ + jam(); + return false; + } + + for (Uint32 fid = 0; fid < tabPtr.p->totalfragments; fid++) { + jam(); + getFragstore(tabPtr.p, fid, fragPtr); + if (fragPtr.p->noLcpReplicas > 0){ + jam(); + /* ----------------------------------------------------------------- */ + // Not all fragments in table have been checkpointed. + /* ----------------------------------------------------------------- */ + if(0) + ndbout_c("reportLcpCompletion: fragment %d not ready", fid); + return false; + }//if + }//for + return true; +}//Dbdih::reportLcpCompletion() + +void Dbdih::checkStartMoreLcp(Signal* signal, Uint32 nodeId) +{ + ndbrequire(isMaster()); + + NodeRecordPtr nodePtr; + nodePtr.i = nodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + + ndbrequire(nodePtr.p->noOfStartedChkpt < 2); + + if (nodePtr.p->noOfQueuedChkpt > 0) { + jam(); + nodePtr.p->noOfQueuedChkpt--; + Uint32 i = nodePtr.p->noOfStartedChkpt; + nodePtr.p->startedChkpt[i] = nodePtr.p->queuedChkpt[0]; + nodePtr.p->queuedChkpt[0] = nodePtr.p->queuedChkpt[1]; + //------------------------------------------------------------------- + // We can send a LCP_FRAGORD to the node ordering it to perform a + // local checkpoint on this fragment replica. + //------------------------------------------------------------------- + nodePtr.p->noOfStartedChkpt = i + 1; + + sendLCP_FRAG_ORD(signal, nodePtr.p->startedChkpt[i]); + } + + /* ----------------------------------------------------------------------- */ + // When there are no more outstanding LCP reports and there are no one queued + // in at least one node, then we are ready to make sure all nodes have at + // least two outstanding LCP requests per node and at least two queued for + // sending. + /* ----------------------------------------------------------------------- */ + startNextChkpt(signal); +}//Dbdih::checkStartMoreLcp() + +void +Dbdih::sendLCP_FRAG_ORD(Signal* signal, + NodeRecord::FragmentCheckpointInfo info){ + + ReplicaRecordPtr replicaPtr; + replicaPtr.i = info.replicaPtr; + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + + BlockReference ref = calcLqhBlockRef(replicaPtr.p->procNode); + + LcpFragOrd * const lcpFragOrd = (LcpFragOrd *)&signal->theData[0]; + lcpFragOrd->tableId = info.tableId; + lcpFragOrd->fragmentId = info.fragId; + lcpFragOrd->lcpId = SYSFILE->latestLCP_ID; + lcpFragOrd->lcpNo = replicaPtr.p->nextLcp; + lcpFragOrd->keepGci = c_lcpState.keepGci; + lcpFragOrd->lastFragmentFlag = false; + sendSignal(ref, GSN_LCP_FRAG_ORD, signal, LcpFragOrd::SignalLength, JBB); +} + +void Dbdih::checkLcpCompletedLab(Signal* signal) +{ + if(c_lcpState.lcpStatus < LCP_TAB_COMPLETED){ + jam(); + return; + } + + TabRecordPtr tabPtr; + for (tabPtr.i = 0; tabPtr.i < ctabFileSize; tabPtr.i++) { + jam(); + ptrAss(tabPtr, tabRecord); + if (tabPtr.p->tabStatus == TabRecord::TS_ACTIVE) { + if (tabPtr.p->tabLcpStatus != TabRecord::TLS_COMPLETED) { + jam(); + return; + }//if + }//if + }//for + + CRASH_INSERTION2(7027, isMaster()); + CRASH_INSERTION2(7018, !isMaster()); + + if(c_lcpState.lcpStatus == LCP_TAB_COMPLETED){ + /** + * We'r done + */ + c_lcpState.setLcpStatus(LCP_TAB_SAVED, __LINE__); + sendLCP_COMPLETE_REP(signal); + return; + } + + ndbrequire(c_lcpState.lcpStatus == LCP_TAB_SAVED); + allNodesLcpCompletedLab(signal); + return; +}//Dbdih::checkLcpCompletedLab() + +void +Dbdih::sendLCP_COMPLETE_REP(Signal* signal){ + jam(); + LcpCompleteRep * rep = (LcpCompleteRep*)signal->getDataPtrSend(); + rep->nodeId = getOwnNodeId(); + rep->lcpId = SYSFILE->latestLCP_ID; + rep->blockNo = DBDIH; + + sendSignal(c_lcpState.m_masterLcpDihRef, GSN_LCP_COMPLETE_REP, signal, + LcpCompleteRep::SignalLength, JBB); +} + +/*-------------------------------------------------------------------------- */ +/* COMP_LCP_ROUND A LQH HAS COMPLETED A LOCAL CHECKPOINT */ +/*------------------------------------------------------------------------- */ +void Dbdih::execLCP_COMPLETE_REP(Signal* signal) +{ + jamEntry(); + +#if 0 + ndbout_c("LCP_COMPLETE_REP"); + printLCP_COMPLETE_REP(stdout, + signal->getDataPtr(), + signal->length(), number()); +#endif + + LcpCompleteRep * rep = (LcpCompleteRep*)signal->getDataPtr(); + Uint32 lcpId = rep->lcpId; + Uint32 nodeId = rep->nodeId; + Uint32 blockNo = rep->blockNo; + + if(c_lcpMasterTakeOverState.state > LMTOS_WAIT_LCP_FRAG_REP){ + jam(); + /** + * Don't allow LCP_COMPLETE_REP to arrive during + * LCP master take over + */ + ndbrequire(isMaster()); + ndbrequire(blockNo == DBDIH); + sendSignalWithDelay(reference(), GSN_LCP_COMPLETE_REP, signal, 100, + signal->length()); + return; + } + + ndbrequire(c_lcpState.lcpStatus != LCP_STATUS_IDLE); + + switch(blockNo){ + case DBLQH: + jam(); + c_lcpState.m_LCP_COMPLETE_REP_Counter_LQH.clearWaitingFor(nodeId); + ndbrequire(!c_lcpState.m_LAST_LCP_FRAG_ORD.isWaitingFor(nodeId)); + break; + case DBDIH: + jam(); + ndbrequire(isMaster()); + c_lcpState.m_LCP_COMPLETE_REP_Counter_DIH.clearWaitingFor(nodeId); + break; + case 0: + jam(); + ndbrequire(!isMaster()); + ndbrequire(c_lcpState.m_LCP_COMPLETE_REP_From_Master_Received == false); + c_lcpState.m_LCP_COMPLETE_REP_From_Master_Received = true; + break; + default: + ndbrequire(false); + } + ndbrequire(lcpId == SYSFILE->latestLCP_ID); + + allNodesLcpCompletedLab(signal); + return; +} + +void Dbdih::allNodesLcpCompletedLab(Signal* signal) +{ + jam(); + + if (c_lcpState.lcpStatus != LCP_TAB_SAVED) { + jam(); + /** + * We have not sent LCP_COMPLETE_REP to master DIH yet + */ + return; + }//if + + if (!c_lcpState.m_LCP_COMPLETE_REP_Counter_LQH.done()){ + jam(); + return; + } + + if (!c_lcpState.m_LCP_COMPLETE_REP_Counter_DIH.done()){ + jam(); + return; + } + + if (!isMaster() && + c_lcpState.m_LCP_COMPLETE_REP_From_Master_Received == false){ + jam(); + /** + * Wait until master DIH has signaled lcp is complete + */ + return; + } + + if(c_lcpMasterTakeOverState.state != LMTOS_IDLE){ + jam(); +#ifdef VM_TRACE + ndbout_c("Exiting from allNodesLcpCompletedLab"); +#endif + return; + } + + + /*------------------------------------------------------------------------ */ + /* WE HAVE NOW COMPLETED A LOCAL CHECKPOINT. WE ARE NOW READY TO WAIT */ + /* FOR THE NEXT LOCAL CHECKPOINT. SEND WITHOUT TIME-OUT SINCE IT MIGHT */ + /* BE TIME TO START THE NEXT LOCAL CHECKPOINT IMMEDIATELY. */ + /* CLEAR BIT 3 OF SYSTEM RESTART BITS TO INDICATE THAT THERE IS NO */ + /* LOCAL CHECKPOINT ONGOING. THIS WILL BE WRITTEN AT SOME LATER TIME */ + /* DURING A GLOBAL CHECKPOINT. IT IS NOT NECESSARY TO WRITE IT */ + /* IMMEDIATELY. WE WILL ALSO CLEAR BIT 2 OF SYSTEM RESTART BITS IF ALL */ + /* CURRENTLY ACTIVE NODES COMPLETED THE LOCAL CHECKPOINT. */ + /*------------------------------------------------------------------------ */ + CRASH_INSERTION(7019); + signal->setTrace(0); + + c_lcpState.setLcpStatus(LCP_STATUS_IDLE, __LINE__); + setLcpActiveStatusEnd(); + Sysfile::clearLCPOngoing(SYSFILE->systemRestartBits); + + if(!isMaster()){ + jam(); + /** + * We're not master, be content + */ + return; + } + + // Send LCP_COMPLETE_REP to all other nodes + // allowing them to set their lcpStatus to LCP_STATUS_IDLE + LcpCompleteRep * rep = (LcpCompleteRep*)signal->getDataPtrSend(); + rep->nodeId = getOwnNodeId(); + rep->lcpId = SYSFILE->latestLCP_ID; + rep->blockNo = 0; // 0 = Sent from master + + NodeRecordPtr nodePtr; + nodePtr.i = cfirstAliveNode; + do { + jam(); + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + if (nodePtr.i != cownNodeId){ + BlockReference ref = calcDihBlockRef(nodePtr.i); + sendSignal(ref, GSN_LCP_COMPLETE_REP, signal, + LcpCompleteRep::SignalLength, JBB); + } + nodePtr.i = nodePtr.p->nextNode; + } while (nodePtr.i != RNIL); + + + jam(); + /***************************************************************************/ + // Report the event that a local checkpoint has completed. + /***************************************************************************/ + signal->theData[0] = EventReport::LocalCheckpointCompleted; //Event type + signal->theData[1] = SYSFILE->latestLCP_ID; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); + + /** + * Start checking for next LCP + */ + checkLcpStart(signal, __LINE__); + + if (cwaitLcpSr == true) { + jam(); + cwaitLcpSr = false; + ndbsttorry10Lab(signal, __LINE__); + return; + }//if + + if (c_nodeStartMaster.blockLcp == true) { + jam(); + lcpBlockedLab(signal); + return; + }//if + return; +}//Dbdih::allNodesLcpCompletedLab() + +/******************************************************************************/ +/* ********** TABLE UPDATE MODULE *************/ +/* ****************************************************************************/ +/* ------------------------------------------------------------------------- */ +/* THIS MODULE IS USED TO UPDATE THE TABLE DESCRIPTION. IT STARTS BY */ +/* CREATING THE FIRST TABLE FILE, THEN UPDATES THIS FILE AND CLOSES IT.*/ +/* AFTER THAT THE SAME HAPPENS WITH THE SECOND FILE. AFTER THAT THE */ +/* TABLE DISTRIBUTION HAS BEEN UPDATED. */ +/* */ +/* THE REASON FOR CREATING THE FILE AND NOT OPENING IT IS TO ENSURE */ +/* THAT WE DO NOT GET A MIX OF OLD AND NEW INFORMATION IN THE FILE IN */ +/* ERROR SITUATIONS. */ +/* ------------------------------------------------------------------------- */ +void Dbdih::tableUpdateLab(Signal* signal, TabRecordPtr tabPtr) { + FileRecordPtr filePtr; + filePtr.i = tabPtr.p->tabFile[0]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + createFileRw(signal, filePtr); + filePtr.p->reqStatus = FileRecord::TABLE_CREATE; + return; +}//Dbdih::tableUpdateLab() + +void Dbdih::tableCreateLab(Signal* signal, FileRecordPtr filePtr) +{ + TabRecordPtr tabPtr; + tabPtr.i = filePtr.p->tabRef; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + writeTabfile(signal, tabPtr.p, filePtr); + filePtr.p->reqStatus = FileRecord::TABLE_WRITE; + return; +}//Dbdih::tableCreateLab() + +void Dbdih::tableWriteLab(Signal* signal, FileRecordPtr filePtr) +{ + closeFile(signal, filePtr); + filePtr.p->reqStatus = FileRecord::TABLE_CLOSE; + return; +}//Dbdih::tableWriteLab() + +void Dbdih::tableCloseLab(Signal* signal, FileRecordPtr filePtr) +{ + TabRecordPtr tabPtr; + tabPtr.i = filePtr.p->tabRef; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + if (filePtr.i == tabPtr.p->tabFile[0]) { + jam(); + filePtr.i = tabPtr.p->tabFile[1]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + createFileRw(signal, filePtr); + filePtr.p->reqStatus = FileRecord::TABLE_CREATE; + return; + }//if + switch (tabPtr.p->tabUpdateState) { + case TabRecord::US_LOCAL_CHECKPOINT: + jam(); + releaseTabPages(tabPtr.i); + signal->theData[0] = DihContinueB::ZCHECK_LCP_COMPLETED; + sendSignal(reference(), GSN_CONTINUEB, signal, 1, JBB); + + tabPtr.p->tabCopyStatus = TabRecord::CS_IDLE; + tabPtr.p->tabUpdateState = TabRecord::US_IDLE; + tabPtr.p->tabLcpStatus = TabRecord::TLS_COMPLETED; + return; + break; + case TabRecord::US_REMOVE_NODE: + jam(); + releaseTabPages(tabPtr.i); + for (Uint32 fragId = 0; fragId < tabPtr.p->totalfragments; fragId++) { + jam(); + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, fragId, fragPtr); + updateNodeInfo(fragPtr); + }//for + tabPtr.p->tabCopyStatus = TabRecord::CS_IDLE; + tabPtr.p->tabUpdateState = TabRecord::US_IDLE; + if (tabPtr.p->tabLcpStatus == TabRecord::TLS_WRITING_TO_FILE) { + jam(); + tabPtr.p->tabLcpStatus = TabRecord::TLS_COMPLETED; + signal->theData[0] = DihContinueB::ZCHECK_LCP_COMPLETED; + sendSignal(reference(), GSN_CONTINUEB, signal, 1, JBB); + }//if + signal->theData[0] = DihContinueB::ZREMOVE_NODE_FROM_TABLE; + signal->theData[1] = tabPtr.p->tabRemoveNode; + signal->theData[2] = tabPtr.i + 1; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); + return; + break; + case TabRecord::US_INVALIDATE_NODE_LCP: + jam(); + releaseTabPages(tabPtr.i); + tabPtr.p->tabCopyStatus = TabRecord::CS_IDLE; + tabPtr.p->tabUpdateState = TabRecord::US_IDLE; + + signal->theData[0] = DihContinueB::ZINVALIDATE_NODE_LCP; + signal->theData[1] = tabPtr.p->tabRemoveNode; + signal->theData[2] = tabPtr.i + 1; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); + return; + case TabRecord::US_COPY_TAB_REQ: + jam(); + tabPtr.p->tabUpdateState = TabRecord::US_IDLE; + copyTabReq_complete(signal, tabPtr); + return; + break; + case TabRecord::US_ADD_TABLE_MASTER: + jam(); + releaseTabPages(tabPtr.i); + tabPtr.p->tabUpdateState = TabRecord::US_IDLE; + signal->theData[0] = DihContinueB::ZDIH_ADD_TABLE_MASTER; + signal->theData[1] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; + break; + case TabRecord::US_ADD_TABLE_SLAVE: + jam(); + releaseTabPages(tabPtr.i); + tabPtr.p->tabUpdateState = TabRecord::US_IDLE; + signal->theData[0] = DihContinueB::ZDIH_ADD_TABLE_SLAVE; + signal->theData[1] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + return; + break; + default: + ndbrequire(false); + return; + break; + }//switch +}//Dbdih::tableCloseLab() + +/** + * GCP stop detected, + * send SYSTEM_ERROR to all other alive nodes + */ +void Dbdih::crashSystemAtGcpStop(Signal* signal){ + NodeRecordPtr nodePtr; + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRecord); + if (nodePtr.p->nodeStatus == NodeRecord::ALIVE) { + jam(); + const BlockReference ref = + numberToRef(refToBlock(cntrlblockref), nodePtr.i); + SystemError * const sysErr = (SystemError*)&signal->theData[0]; + sysErr->errorCode = SystemError::GCPStopDetected; + sysErr->errorRef = reference(); + sysErr->data1 = cgcpStatus; + sysErr->data2 = cgcpOrderBlocked; + sendSignal(ref, GSN_SYSTEM_ERROR, signal, + SystemError::SignalLength, JBA); + }//if + }//for + return; +}//Dbdih::crashSystemAtGcpStop() + +/*************************************************************************/ +/* */ +/* MODULE: ALLOCPAGE */ +/* DESCRIPTION: THE SUBROUTINE IS CALLED WITH POINTER TO PAGE */ +/* RECORD. A PAGE RECORD IS TAKEN FROM */ +/* THE FREE PAGE LIST */ +/*************************************************************************/ +void Dbdih::allocpage(PageRecordPtr& pagePtr) +{ + ndbrequire(cfirstfreepage != RNIL); + pagePtr.i = cfirstfreepage; + ptrCheckGuard(pagePtr, cpageFileSize, pageRecord); + cfirstfreepage = pagePtr.p->nextfreepage; + pagePtr.p->nextfreepage = RNIL; +}//Dbdih::allocpage() + +/*************************************************************************/ +/* */ +/* MODULE: ALLOC_STORED_REPLICA */ +/* DESCRIPTION: THE SUBROUTINE IS CALLED TO GET A REPLICA RECORD, */ +/* TO INITIALISE IT AND TO LINK IT INTO THE FRAGMENT */ +/* STORE RECORD. USED FOR STORED REPLICAS. */ +/*************************************************************************/ +void Dbdih::allocStoredReplica(FragmentstorePtr fragPtr, + ReplicaRecordPtr& newReplicaPtr, + Uint32 nodeId) +{ + ReplicaRecordPtr arrReplicaPtr; + ReplicaRecordPtr arrPrevReplicaPtr; + + seizeReplicaRec(newReplicaPtr); + for (Uint32 i = 0; i < MAX_LCP_STORED; i++) { + newReplicaPtr.p->maxGciCompleted[i] = 0; + newReplicaPtr.p->maxGciStarted[i] = 0; + newReplicaPtr.p->lcpId[i] = 0; + newReplicaPtr.p->lcpStatus[i] = ZINVALID; + }//for + newReplicaPtr.p->noCrashedReplicas = 0; + newReplicaPtr.p->initialGci = currentgcp; + for (Uint32 i = 0; i < 8; i++) { + newReplicaPtr.p->replicaLastGci[i] = (Uint32)-1; + newReplicaPtr.p->createGci[i] = 0; + }//for + newReplicaPtr.p->createGci[0] = currentgcp; + ndbrequire(currentgcp != 0xF1F1F1F1); + newReplicaPtr.p->nextLcp = 0; + newReplicaPtr.p->procNode = nodeId; + newReplicaPtr.p->lcpOngoingFlag = false; + newReplicaPtr.p->lcpIdStarted = 0; + + arrPrevReplicaPtr.i = RNIL; + arrReplicaPtr.i = fragPtr.p->storedReplicas; + while (arrReplicaPtr.i != RNIL) { + jam(); + ptrCheckGuard(arrReplicaPtr, creplicaFileSize, replicaRecord); + arrPrevReplicaPtr = arrReplicaPtr; + arrReplicaPtr.i = arrReplicaPtr.p->nextReplica; + }//while + if (arrPrevReplicaPtr.i == RNIL) { + jam(); + fragPtr.p->storedReplicas = newReplicaPtr.i; + } else { + jam(); + arrPrevReplicaPtr.p->nextReplica = newReplicaPtr.i; + }//if + fragPtr.p->noStoredReplicas++; +}//Dbdih::allocStoredReplica() + +/*************************************************************************/ +/* CALCULATE HOW MANY HOT SPARES THAT ARE TO BE ASSIGNED IN THIS SYSTEM */ +/*************************************************************************/ +void Dbdih::calculateHotSpare() +{ + Uint32 tchsTmp; + Uint32 tchsNoNodes; + + switch (cnoReplicas) { + case 1: + jam(); + cnoHotSpare = 0; + break; + case 2: + case 3: + case 4: + jam(); + if (csystemnodes > cnoReplicas) { + jam(); + /* --------------------------------------------------------------------- */ + /* WITH MORE NODES THAN REPLICAS WE WILL ALWAYS USE AT LEAST ONE HOT */ + /* SPARE IF THAT HAVE BEEN REQUESTED BY THE CONFIGURATION FILE. THE */ + /* NUMBER OF NODES TO BE USED FOR NORMAL OPERATION IS ALWAYS */ + /* A MULTIPLE OF THE NUMBER OF REPLICAS SINCE WE WILL ORGANISE NODES */ + /* INTO NODE GROUPS. THE REMAINING NODES WILL BE HOT SPARE NODES. */ + /* --------------------------------------------------------------------- */ + if ((csystemnodes - cnoReplicas) >= cminHotSpareNodes) { + jam(); + /* --------------------------------------------------------------------- */ + // We set the minimum number of hot spares according to users request + // through the configuration file. + /* --------------------------------------------------------------------- */ + tchsNoNodes = csystemnodes - cminHotSpareNodes; + cnoHotSpare = cminHotSpareNodes; + } else if (cminHotSpareNodes > 0) { + jam(); + /* --------------------------------------------------------------------- */ + // The user requested at least one hot spare node and we will support him + // in that. + /* --------------------------------------------------------------------- */ + tchsNoNodes = csystemnodes - 1; + cnoHotSpare = 1; + } else { + jam(); + /* --------------------------------------------------------------------- */ + // The user did not request any hot spare nodes so in this case we will + // only use hot spare nodes if the number of nodes is such that we cannot + // use all nodes as normal nodes. + /* --------------------------------------------------------------------- */ + tchsNoNodes = csystemnodes; + cnoHotSpare = 0; + }//if + } else { + jam(); + /* --------------------------------------------------------------------- */ + // We only have enough to support the replicas. We will not have any hot + // spares. + /* --------------------------------------------------------------------- */ + tchsNoNodes = csystemnodes; + cnoHotSpare = 0; + }//if + tchsTmp = tchsNoNodes - (cnoReplicas * (tchsNoNodes / cnoReplicas)); + cnoHotSpare = cnoHotSpare + tchsTmp; + break; + default: + jam(); + progError(0, 0); + break; + }//switch +}//Dbdih::calculateHotSpare() + +/*************************************************************************/ +/* CHECK IF THE NODE CRASH IS TO ESCALATE INTO A SYSTEM CRASH. WE COULD */ +/* DO THIS BECAUSE ALL REPLICAS OF SOME FRAGMENT ARE LOST. WE COULD ALSO */ +/* DO IT AFTER MANY NODE FAILURES THAT MAKE IT VERY DIFFICULT TO RESTORE */ +/* DATABASE AFTER A SYSTEM CRASH. IT MIGHT EVEN BE IMPOSSIBLE AND THIS */ +/* MUST BE AVOIDED EVEN MORE THAN AVOIDING SYSTEM CRASHES. */ +/*************************************************************************/ +void Dbdih::checkEscalation() +{ + Uint32 TnodeGroup[MAX_NDB_NODES]; + NodeRecordPtr nodePtr; + for (Uint32 i = 0; i < MAX_NDB_NODES; i++) { + TnodeGroup[i] = ZFALSE; + }//for + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRecord); + if (nodePtr.p->nodeStatus == NodeRecord::ALIVE && + nodePtr.p->activeStatus == Sysfile::NS_Active){ + ndbrequire(nodePtr.p->nodeGroup < MAX_NDB_NODES); + TnodeGroup[nodePtr.p->nodeGroup] = ZTRUE; + } + } + for (Uint32 i = 0; i < cnoOfNodeGroups; i++) { + jam(); + if (TnodeGroup[i] == ZFALSE) { + jam(); + progError(__LINE__, ERR_SYSTEM_ERROR, "Lost node group"); + }//if + }//for +}//Dbdih::checkEscalation() + +/*************************************************************************/ +/* */ +/* MODULE: CHECK_KEEP_GCI */ +/* DESCRIPTION: CHECK FOR MINIMUM GCI RESTORABLE WITH NEW LOCAL */ +/* CHECKPOINT. */ +/*************************************************************************/ +void Dbdih::checkKeepGci(Uint32 replicaStartIndex) +{ + ReplicaRecordPtr ckgReplicaPtr; + ckgReplicaPtr.i = replicaStartIndex; + while (ckgReplicaPtr.i != RNIL) { + jam(); + ptrCheckGuard(ckgReplicaPtr, creplicaFileSize, replicaRecord); + Uint32 keepGci; + Uint32 oldestRestorableGci; + findMinGci(ckgReplicaPtr, keepGci, oldestRestorableGci); + if (keepGci < c_lcpState.keepGci) { + jam(); + /* ------------------------------------------------------------------- */ + /* WE MUST KEEP LOG RECORDS SO THAT WE CAN USE ALL LOCAL CHECKPOINTS */ + /* THAT ARE AVAILABLE. THUS WE NEED TO CALCULATE THE MINIMUM OVER ALL */ + /* FRAGMENTS. */ + /* ------------------------------------------------------------------- */ + c_lcpState.keepGci = keepGci; + }//if + if (oldestRestorableGci > c_lcpState.oldestRestorableGci) { + jam(); + c_lcpState.oldestRestorableGci = oldestRestorableGci; + ndbrequire(((int)c_lcpState.oldestRestorableGci) >= 0); + }//if + ckgReplicaPtr.i = ckgReplicaPtr.p->nextReplica; + }//while +}//Dbdih::checkKeepGci() + +void Dbdih::closeFile(Signal* signal, FileRecordPtr filePtr) +{ + signal->theData[0] = filePtr.p->fileRef; + signal->theData[1] = reference(); + signal->theData[2] = filePtr.i; + signal->theData[3] = ZCLOSE_NO_DELETE; + sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA); +}//Dbdih::closeFile() + +void Dbdih::closeFileDelete(Signal* signal, FileRecordPtr filePtr) +{ + signal->theData[0] = filePtr.p->fileRef; + signal->theData[1] = reference(); + signal->theData[2] = filePtr.i; + signal->theData[3] = ZCLOSE_DELETE; + sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA); +}//Dbdih::closeFileDelete() + +void Dbdih::createFileRw(Signal* signal, FileRecordPtr filePtr) +{ + signal->theData[0] = reference(); + signal->theData[1] = filePtr.i; + signal->theData[2] = filePtr.p->fileName[0]; + signal->theData[3] = filePtr.p->fileName[1]; + signal->theData[4] = filePtr.p->fileName[2]; + signal->theData[5] = filePtr.p->fileName[3]; + signal->theData[6] = ZCREATE_READ_WRITE; + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA); +}//Dbdih::createFileRw() + +void Dbdih::emptyverificbuffer(Signal* signal, bool aContinueB) +{ + if(cfirstVerifyQueue == RNIL){ + jam(); + return; + }//if + ApiConnectRecordPtr localApiConnectptr; + if(getBlockCommit() == false){ + jam(); + ndbrequire(cverifyQueueCounter > 0); + cverifyQueueCounter--; + localApiConnectptr.i = cfirstVerifyQueue; + ptrCheckGuard(localApiConnectptr, capiConnectFileSize, apiConnectRecord); + ndbrequire(localApiConnectptr.p->apiGci <= currentgcp); + cfirstVerifyQueue = localApiConnectptr.p->nextApi; + if (cfirstVerifyQueue == RNIL) { + jam(); + ndbrequire(cverifyQueueCounter == 0); + clastVerifyQueue = RNIL; + }//if + signal->theData[0] = localApiConnectptr.i; + signal->theData[1] = currentgcp; + sendSignal(clocaltcblockref, GSN_DIVERIFYCONF, signal, 2, JBB); + if (aContinueB == true) { + jam(); + //----------------------------------------------------------------------- + // This emptying happened as part of a take-out process by continueb signals. + // This ensures that we will empty the queue eventually. We will also empty + // one item every time we insert one item to ensure that the list doesn't + // grow when it is not blocked. + //----------------------------------------------------------------------- + signal->theData[0] = DihContinueB::ZEMPTY_VERIFY_QUEUE; + sendSignal(reference(), GSN_CONTINUEB, signal, 1, JBB); + }//if + } else { + jam(); + //----------------------------------------------------------------------- + // We are blocked so it is no use in continuing the emptying of the + // verify buffer. Whenever the block is removed the emptying will + // restart. + //----------------------------------------------------------------------- + } + return; +}//Dbdih::emptyverificbuffer() + +/*----------------------------------------------------------------*/ +/* FIND A FREE HOT SPARE IF AVAILABLE AND ALIVE. */ +/*----------------------------------------------------------------*/ +Uint32 Dbdih::findHotSpare() +{ + NodeRecordPtr nodePtr; + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRecord); + if (nodePtr.p->nodeStatus == NodeRecord::ALIVE) { + if (nodePtr.p->activeStatus == Sysfile::NS_HotSpare) { + jam(); + return nodePtr.i; + }//if + }//if + }//for + return RNIL; +}//Dbdih::findHotSpare() + +/*************************************************************************/ +/* FIND THE NODES FROM WHICH WE CAN EXECUTE THE LOG TO RESTORE THE */ +/* DATA NODE IN A SYSTEM RESTART. */ +/*************************************************************************/ +bool Dbdih::findLogNodes(CreateReplicaRecord* createReplica, + FragmentstorePtr fragPtr, + Uint32 startGci, + Uint32 stopGci) +{ + ConstPtr flnReplicaPtr; + flnReplicaPtr.i = createReplica->replicaRec; + ptrCheckGuard(flnReplicaPtr, creplicaFileSize, replicaRecord); + /* --------------------------------------------------------------------- */ + /* WE START BY CHECKING IF THE DATA NODE CAN HANDLE THE LOG ALL BY */ + /* ITSELF. THIS IS THE DESIRED BEHAVIOUR. IF THIS IS NOT POSSIBLE */ + /* THEN WE SEARCH FOR THE BEST POSSIBLE NODES AMONG THE NODES THAT */ + /* ARE PART OF THIS SYSTEM RESTART. */ + /* THIS CAN ONLY BE HANDLED BY THE LAST CRASHED REPLICA. */ + /* The condition is that the replica was created before or at the */ + /* time of the starting gci, in addition it must have been alive */ + /* at the time of the stopping gci. This is checked by two */ + /* conditions, the first checks replicaLastGci and the second */ + /* checks that it is also smaller than the last gci the node was */ + /* involved in. This is necessary to check since createGci is set */ + /* Last + 1 and sometimes startGci = stopGci + 1 and in that case */ + /* it could happen that replicaLastGci is set to -1 with CreateGci */ + /* set to LastGci + 1. */ + /* --------------------------------------------------------------------- */ + arrGuard(flnReplicaPtr.p->noCrashedReplicas, 8); + const Uint32 noCrashed = flnReplicaPtr.p->noCrashedReplicas; + + if (!(ERROR_INSERTED(7073) || ERROR_INSERTED(7074))&& + (startGci >= flnReplicaPtr.p->createGci[noCrashed]) && + (stopGci <= flnReplicaPtr.p->replicaLastGci[noCrashed]) && + (stopGci <= SYSFILE->lastCompletedGCI[flnReplicaPtr.p->procNode])) { + jam(); + /* --------------------------------------------------------------------- */ + /* WE FOUND ALL THE LOG RECORDS NEEDED IN THE DATA NODE. WE WILL */ + /* USE THOSE. */ + /* --------------------------------------------------------------------- */ + createReplica->noLogNodes = 1; + createReplica->logStartGci[0] = startGci; + createReplica->logStopGci[0] = stopGci; + createReplica->logNodeId[0] = flnReplicaPtr.p->procNode; + return true; + }//if + Uint32 logNode = 0; + do { + Uint32 fblStopGci; + jam(); + if(!findBestLogNode(createReplica, + fragPtr, + startGci, + stopGci, + logNode, + fblStopGci)){ + jam(); + return false; + } + + logNode++; + if (fblStopGci >= stopGci) { + jam(); + createReplica->noLogNodes = logNode; + return true; + }//if + startGci = fblStopGci + 1; + if (logNode >= 4) { // Why?? + jam(); + break; + }//if + } while (1); + /* --------------------------------------------------------------------- */ + /* IT WAS NOT POSSIBLE TO RESTORE THE REPLICA. THIS CAN EITHER BE */ + /* BECAUSE OF LACKING NODES OR BECAUSE OF A REALLY SERIOUS PROBLEM.*/ + /* --------------------------------------------------------------------- */ + return false; +}//Dbdih::findLogNodes() + +/*************************************************************************/ +/* FIND THE BEST POSSIBLE LOG NODE TO EXECUTE THE LOG AS SPECIFIED */ +/* BY THE INPUT PARAMETERS. WE SCAN THROUGH ALL ALIVE REPLICAS. */ +/* THIS MEANS STORED, OLD_STORED */ +/*************************************************************************/ +bool +Dbdih::findBestLogNode(CreateReplicaRecord* createReplica, + FragmentstorePtr fragPtr, + Uint32 startGci, + Uint32 stopGci, + Uint32 logNode, + Uint32& fblStopGci) +{ + ConstPtr fblFoundReplicaPtr; + ConstPtr fblReplicaPtr; + + /* --------------------------------------------------------------------- */ + /* WE START WITH ZERO AS FOUND TO ENSURE THAT FIRST HIT WILL BE */ + /* BETTER. */ + /* --------------------------------------------------------------------- */ + fblStopGci = 0; + fblReplicaPtr.i = fragPtr.p->storedReplicas; + while (fblReplicaPtr.i != RNIL) { + jam(); + ptrCheckGuard(fblReplicaPtr, creplicaFileSize, replicaRecord); + if (checkNodeAlive(fblReplicaPtr.p->procNode)) { + jam(); + Uint32 fliStopGci = findLogInterval(fblReplicaPtr, startGci); + if (fliStopGci > fblStopGci) { + jam(); + fblStopGci = fliStopGci; + fblFoundReplicaPtr = fblReplicaPtr; + }//if + }//if + fblReplicaPtr.i = fblReplicaPtr.p->nextReplica; + }//while + fblReplicaPtr.i = fragPtr.p->oldStoredReplicas; + while (fblReplicaPtr.i != RNIL) { + jam(); + ptrCheckGuard(fblReplicaPtr, creplicaFileSize, replicaRecord); + if (checkNodeAlive(fblReplicaPtr.p->procNode)) { + jam(); + Uint32 fliStopGci = findLogInterval(fblReplicaPtr, startGci); + if (fliStopGci > fblStopGci) { + jam(); + fblStopGci = fliStopGci; + fblFoundReplicaPtr = fblReplicaPtr; + }//if + }//if + fblReplicaPtr.i = fblReplicaPtr.p->nextReplica; + }//while + if (fblStopGci != 0) { + jam(); + ndbrequire(logNode < MAX_LOG_EXEC); + createReplica->logNodeId[logNode] = fblFoundReplicaPtr.p->procNode; + createReplica->logStartGci[logNode] = startGci; + if (fblStopGci >= stopGci) { + jam(); + createReplica->logStopGci[logNode] = stopGci; + } else { + jam(); + createReplica->logStopGci[logNode] = fblStopGci; + }//if + }//if + + return fblStopGci != 0; +}//Dbdih::findBestLogNode() + +Uint32 Dbdih::findLogInterval(ConstPtr replicaPtr, + Uint32 startGci) +{ + ndbrequire(replicaPtr.p->noCrashedReplicas <= 8); + Uint32 loopLimit = replicaPtr.p->noCrashedReplicas + 1; + for (Uint32 i = 0; i < loopLimit; i++) { + jam(); + if (replicaPtr.p->createGci[i] <= startGci) { + if (replicaPtr.p->replicaLastGci[i] >= startGci) { + jam(); + return replicaPtr.p->replicaLastGci[i]; + }//if + }//if + }//for + return 0; +}//Dbdih::findLogInterval() + +/*************************************************************************/ +/* */ +/* MODULE: FIND THE MINIMUM GCI THAT THIS NODE HAS LOG RECORDS FOR.*/ +/*************************************************************************/ +void Dbdih::findMinGci(ReplicaRecordPtr fmgReplicaPtr, + Uint32& keepGci, + Uint32& oldestRestorableGci) +{ + Uint32 nextLcpNo; + Uint32 lcpNo; + for (Uint32 i = 0; i < MAX_LCP_STORED; i++) { + jam(); + if ((fmgReplicaPtr.p->lcpStatus[i] == ZVALID) && + ((fmgReplicaPtr.p->lcpId[i] + MAX_LCP_STORED) <= (SYSFILE->latestLCP_ID + 1))) { + jam(); + /*--------------------------------------------------------------------*/ + // We invalidate the checkpoint we are preparing to overwrite. + // The LCP id is still the old lcp id, + // this is the reason of comparing with lcpId + 1. + /*---------------------------------------------------------------------*/ + fmgReplicaPtr.p->lcpStatus[i] = ZINVALID; + }//if + }//for + keepGci = (Uint32)-1; + oldestRestorableGci = 0; + nextLcpNo = fmgReplicaPtr.p->nextLcp; + lcpNo = fmgReplicaPtr.p->nextLcp; + do { + ndbrequire(lcpNo < MAX_LCP_STORED); + if (fmgReplicaPtr.p->lcpStatus[lcpNo] == ZVALID) { + jam(); + keepGci = fmgReplicaPtr.p->maxGciCompleted[lcpNo]; + oldestRestorableGci = fmgReplicaPtr.p->maxGciStarted[lcpNo]; + ndbrequire(((int)oldestRestorableGci) >= 0); + return; + } else { + jam(); + ndbrequire(fmgReplicaPtr.p->lcpStatus[lcpNo] == ZINVALID); + if (fmgReplicaPtr.p->createGci[0] == fmgReplicaPtr.p->initialGci) { + jam(); + /*------------------------------------------------------------------- + * WE CAN STILL RESTORE THIS REPLICA WITHOUT ANY LOCAL CHECKPOINTS BY + * ONLY USING THE LOG. IF THIS IS NOT POSSIBLE THEN WE REPORT THE LAST + * VALID LOCAL CHECKPOINT AS THE MINIMUM GCI RECOVERABLE. + *-----------------------------------------------------------------*/ + keepGci = fmgReplicaPtr.p->createGci[0]; + }//if + }//if + lcpNo = prevLcpNo(lcpNo); + } while (lcpNo != nextLcpNo); + return; +}//Dbdih::findMinGci() + +bool Dbdih::findStartGci(ConstPtr replicaPtr, + Uint32 stopGci, + Uint32& startGci, + Uint32& lcpNo) +{ + lcpNo = replicaPtr.p->nextLcp; + const Uint32 startLcpNo = lcpNo; + do { + lcpNo = prevLcpNo(lcpNo); + ndbrequire(lcpNo < MAX_LCP_STORED); + if (replicaPtr.p->lcpStatus[lcpNo] == ZVALID) { + if (replicaPtr.p->maxGciStarted[lcpNo] < stopGci) { + jam(); + /* ----------------------------------------------------------------- */ + /* WE HAVE FOUND A USEFUL LOCAL CHECKPOINT THAT CAN BE USED FOR */ + /* RESTARTING THIS FRAGMENT REPLICA. */ + /* ----------------------------------------------------------------- */ + startGci = replicaPtr.p->maxGciCompleted[lcpNo] + 1; + return true; + } + } + } while (lcpNo != startLcpNo); + /* --------------------------------------------------------------------- */ + /* NO VALID LOCAL CHECKPOINT WAS AVAILABLE. WE WILL ADD THE */ + /* FRAGMENT. THUS THE NEXT LCP MUST BE SET TO ZERO. */ + /* WE MUST EXECUTE THE LOG FROM THE INITIAL GLOBAL CHECKPOINT WHEN */ + /* THE TABLE WAS CREATED. */ + /* --------------------------------------------------------------------- */ + startGci = replicaPtr.p->initialGci; + ndbrequire(replicaPtr.p->nextLcp == 0); + return false; +}//Dbdih::findStartGci() + +/**************************************************************************/ +/* ---------------------------------------------------------------------- */ +/* FIND A TAKE OVER REPLICA WHICH IS TO BE STARTED OR COMMITTED WHEN*/ +/* TAKING OVER A FAILED NODE. */ +/* ---------------------------------------------------------------------- */ +/*************************************************************************/ +void Dbdih::findToReplica(TakeOverRecord* regTakeOver, + Uint32 replicaType, + FragmentstorePtr fragPtr, + ReplicaRecordPtr& ftrReplicaPtr) +{ + switch (replicaType) { + case CreateFragReq::STORED: + case CreateFragReq::COMMIT_STORED: + /* ----------------------------------------------------------------------*/ + /* HERE WE SEARCH FOR STORED REPLICAS. THE REPLICA MUST BE STORED IN THE */ + /* SECTION FOR OLD STORED REPLICAS SINCE WE HAVE NOT TAKEN OVER YET. */ + /* ----------------------------------------------------------------------*/ + ftrReplicaPtr.i = fragPtr.p->oldStoredReplicas; + while (ftrReplicaPtr.i != RNIL) { + ptrCheckGuard(ftrReplicaPtr, creplicaFileSize, replicaRecord); + if (ftrReplicaPtr.p->procNode == regTakeOver->toStartingNode) { + jam(); + return; + } else { + if (ftrReplicaPtr.p->procNode == regTakeOver->toFailedNode) { + jam(); + return; + } else { + jam(); + ftrReplicaPtr.i = ftrReplicaPtr.p->nextReplica; + }//if + }//if + }//while + break; + default: + ndbrequire(false); + break; + }//switch +}//Dbdih::findToReplica() + +void Dbdih::initCommonData() +{ + c_blockCommit = false; + c_blockCommitNo = 0; + c_createFragmentLock = RNIL; + c_endToLock = RNIL; + cfailurenr = 1; + cfirstAliveNode = RNIL; + cfirstDeadNode = RNIL; + cfirstVerifyQueue = RNIL; + cgckptflag = false; + cgcpDelay = 0; + cgcpMasterTakeOverState = GMTOS_IDLE; + cgcpOrderBlocked = 0; + cgcpParticipantState = GCP_PARTICIPANT_READY; + cgcpSameCounter = 0; + cgcpStartCounter = 0; + cgcpStatus = GCP_READY; + + clastVerifyQueue = RNIL; + c_lcpMasterTakeOverState.set(LMTOS_IDLE, __LINE__); + + c_lcpState.clcpDelay = 0; + c_lcpState.lcpStart = ZIDLE; + c_lcpState.lcpStartGcp = 0; + c_lcpState.setLcpStatus(LCP_STATUS_IDLE, __LINE__); + c_lcpState.currentFragment.tableId = 0; + c_lcpState.currentFragment.fragmentId = 0; + c_lcpState.noOfLcpFragRepOutstanding = 0; + c_lcpState.keepGci = 0; + c_lcpState.oldestRestorableGci = 0; + c_lcpState.ctcCounter = 0; + c_lcpState.ctimer = 0; + c_lcpState.immediateLcpStart = false; + c_lcpState.m_MASTER_LCPREQ_Received = false; + + cmasterdihref = 0; + cmasterNodeId = 0; + cmasterState = MASTER_IDLE; + cmasterTakeOverNode = 0; + cnewgcp = 0; + cnoHotSpare = 0; + cnoOfActiveTables = 0; + cnoOfNodeGroups = 0; + cnoReplicas = 0; + coldgcp = 0; + coldGcpId = 0; + coldGcpStatus = cgcpStatus; + con_lineNodes = 0; + creceivedfrag = 0; + crestartGci = 0; + crestartInfoFile[0] = RNIL; + crestartInfoFile[1] = RNIL; + cstartGcpNow = false; + cstartPhase = 0; + c_startToLock = RNIL; + cstarttype = (Uint32)-1; + csystemnodes = 0; + c_updateToLock = RNIL; + currentgcp = 0; + cverifyQueueCounter = 0; + cwaitLcpSr = false; + + nodeResetStart(); + c_nodeStartMaster.wait = ZFALSE; + + memset(&sysfileData[0], 0, sizeof(sysfileData)); +}//Dbdih::initCommonData() + +void Dbdih::initFragstore(FragmentstorePtr fragPtr) +{ + fragPtr.p->storedReplicas = RNIL; + fragPtr.p->oldStoredReplicas = RNIL; + + fragPtr.p->noStoredReplicas = 0; + fragPtr.p->noOldStoredReplicas = 0; + fragPtr.p->fragReplicas = 0; + fragPtr.p->preferredPrimary = 0; + + for (Uint32 i = 0; i < MAX_REPLICAS; i++) + fragPtr.p->activeNodes[i] = 0; + + fragPtr.p->noLcpReplicas = 0; + fragPtr.p->distributionKey = 0; +}//Dbdih::initFragstore() + +void Dbdih::initNodeState(NodeRecordPtr nodePtr) +{ + nodePtr.p->gcpstate = NodeRecord::READY; + + nodePtr.p->activeStatus = Sysfile::NS_NotDefined; + nodePtr.p->recNODE_FAILREP = ZFALSE; + nodePtr.p->nodeGroup = ZNIL; + nodePtr.p->dbtcFailCompleted = ZTRUE; + nodePtr.p->dbdictFailCompleted = ZTRUE; + nodePtr.p->dbdihFailCompleted = ZTRUE; + nodePtr.p->dblqhFailCompleted = ZTRUE; + nodePtr.p->noOfStartedChkpt = 0; + nodePtr.p->noOfQueuedChkpt = 0; + nodePtr.p->lcpStateAtTakeOver = (MasterLCPConf::State)255; + + nodePtr.p->activeTabptr = RNIL; + nodePtr.p->nodeStatus = NodeRecord::NOT_IN_CLUSTER; + nodePtr.p->useInTransactions = false; + nodePtr.p->copyCompleted = false; + nodePtr.p->ndbversion = 0xffff; +}//Dbdih::initNodeState() + +/*************************************************************************/ +/* */ +/* MODULE: INIT_RESTART_INFO */ +/* DESCRIPTION: INITIATE RESTART INFO VARIABLE AND VARIABLES FOR */ +/* GLOBAL CHECKPOINTS. */ +/*************************************************************************/ +void Dbdih::initRestartInfo() +{ + for (int i = 0; i < MAX_NDB_NODES; i++) { + SYSFILE->lastCompletedGCI[i] = 0; + }//for + NodeRecordPtr nodePtr; + nodePtr.i = cfirstAliveNode; + do { + jam(); + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + SYSFILE->lastCompletedGCI[nodePtr.i] = 1; + /* FIRST GCP = 1 ALREADY SET BY LQH */ + nodePtr.i = nodePtr.p->nextNode; + } while (nodePtr.i != RNIL); + coldgcp = 1; + currentgcp = 2; + cnewgcp = 2; + crestartGci = 1; + + SYSFILE->keepGCI = 1; + SYSFILE->oldestRestorableGCI = 1; + SYSFILE->newestRestorableGCI = 1; + SYSFILE->systemRestartBits = 0; + for (Uint32 i = 0; i < NodeBitmask::Size; i++) { + SYSFILE->lcpActive[0] = 0; + }//for + for (Uint32 i = 0; i < Sysfile::TAKE_OVER_SIZE; i++) { + SYSFILE->takeOver[i] = 0; + }//for + Sysfile::setInitialStartOngoing(SYSFILE->systemRestartBits); +}//Dbdih::initRestartInfo() + +/*--------------------------------------------------------------------*/ +/* NODE GROUP BITS ARE INITIALISED BEFORE THIS. */ +/* NODE ACTIVE BITS ARE INITIALISED BEFORE THIS. */ +/*--------------------------------------------------------------------*/ +/*************************************************************************/ +/* */ +/* MODULE: INIT_RESTORABLE_GCI_FILES */ +/* DESCRIPTION: THE SUBROUTINE SETS UP THE FILES THAT REFERS TO THE*/ +/* FILES THAT KEEP THE VARIABLE CRESTART_INFO */ +/*************************************************************************/ +void Dbdih::initRestorableGciFiles() +{ + Uint32 tirgTmp; + FileRecordPtr filePtr; + seizeFile(filePtr); + filePtr.p->tabRef = RNIL; + filePtr.p->fileType = FileRecord::GCP_FILE; + filePtr.p->reqStatus = FileRecord::IDLE; + filePtr.p->fileStatus = FileRecord::CLOSED; + crestartInfoFile[0] = filePtr.i; + filePtr.p->fileName[0] = (Uint32)-1; /* T DIRECTORY NOT USED */ + filePtr.p->fileName[1] = (Uint32)-1; /* F DIRECTORY NOT USED */ + filePtr.p->fileName[2] = (Uint32)-1; /* S PART IGNORED */ + tirgTmp = 1; /* FILE NAME VERSION 1 */ + tirgTmp = (tirgTmp << 8) + 6; /* .SYSFILE */ + tirgTmp = (tirgTmp << 8) + 1; /* D1 DIRECTORY */ + tirgTmp = (tirgTmp << 8) + 0; /* P0 FILE NAME */ + filePtr.p->fileName[3] = tirgTmp; + /* --------------------------------------------------------------------- */ + /* THE NAME BECOMES /D1/DBDICT/S0.SYSFILE */ + /* --------------------------------------------------------------------- */ + seizeFile(filePtr); + filePtr.p->tabRef = RNIL; + filePtr.p->fileType = FileRecord::GCP_FILE; + filePtr.p->reqStatus = FileRecord::IDLE; + filePtr.p->fileStatus = FileRecord::CLOSED; + crestartInfoFile[1] = filePtr.i; + filePtr.p->fileName[0] = (Uint32)-1; /* T DIRECTORY NOT USED */ + filePtr.p->fileName[1] = (Uint32)-1; /* F DIRECTORY NOT USED */ + filePtr.p->fileName[2] = (Uint32)-1; /* S PART IGNORED */ + tirgTmp = 1; /* FILE NAME VERSION 1 */ + tirgTmp = (tirgTmp << 8) + 6; /* .SYSFILE */ + tirgTmp = (tirgTmp << 8) + 2; /* D1 DIRECTORY */ + tirgTmp = (tirgTmp << 8) + 0; /* P0 FILE NAME */ + filePtr.p->fileName[3] = tirgTmp; + /* --------------------------------------------------------------------- */ + /* THE NAME BECOMES /D2/DBDICT/P0.SYSFILE */ + /* --------------------------------------------------------------------- */ +}//Dbdih::initRestorableGciFiles() + +void Dbdih::initTable(TabRecordPtr tabPtr) +{ + tabPtr.p->method = TabRecord::NOTDEFINED; + tabPtr.p->tabStatus = TabRecord::TS_IDLE; + tabPtr.p->noOfWords = 0; + tabPtr.p->noPages = 0; + tabPtr.p->tabLcpStatus = TabRecord::TLS_COMPLETED; + tabPtr.p->tabCopyStatus = TabRecord::CS_IDLE; + tabPtr.p->tabUpdateState = TabRecord::US_IDLE; + tabPtr.p->noOfBackups = 0; + tabPtr.p->kvalue = 0; + tabPtr.p->hashpointer = (Uint32)-1; + tabPtr.p->mask = 0; + tabPtr.p->storedTable = 1; + tabPtr.p->tabErrorCode = 0; + tabPtr.p->schemaVersion = (Uint32)-1; + tabPtr.p->tabRemoveNode = RNIL; + tabPtr.p->totalfragments = (Uint32)-1; + tabPtr.p->connectrec = RNIL; + tabPtr.p->tabFile[0] = RNIL; + tabPtr.p->tabFile[1] = RNIL; + tabPtr.p->m_dropTab.tabUserRef = 0; + tabPtr.p->m_dropTab.tabUserPtr = RNIL; + for (Uint32 i = 0; i < MAX_NDB_NODES; i++) { + tabPtr.p->startFid[i] = RNIL; + }//for + for (Uint32 i = 0; i < 8; i++) { + tabPtr.p->pageRef[i] = RNIL; + }//for + tabPtr.p->tableType = DictTabInfo::UndefTableType; +}//Dbdih::initTable() + +/*************************************************************************/ +/* */ +/* MODULE: INIT_TABLE_FILES */ +/* DESCRIPTION: THE SUBROUTINE SETS UP THE FILES THAT REFERS TO THE*/ +/* FILES THAT KEEP THE TABLE FRAGMENTATION DESCRIPTION. */ +/*************************************************************************/ +void Dbdih::initTableFile(TabRecordPtr tabPtr) +{ + Uint32 titfTmp; + FileRecordPtr filePtr; + seizeFile(filePtr); + filePtr.p->tabRef = tabPtr.i; + filePtr.p->fileType = FileRecord::TABLE_FILE; + filePtr.p->reqStatus = FileRecord::IDLE; + filePtr.p->fileStatus = FileRecord::CLOSED; + tabPtr.p->tabFile[0] = filePtr.i; + filePtr.p->fileName[0] = (Uint32)-1; /* T DIRECTORY NOT USED */ + filePtr.p->fileName[1] = (Uint32)-1; /* F DIRECTORY NOT USED */ + filePtr.p->fileName[2] = tabPtr.i; /* Stid FILE NAME */ + titfTmp = 1; /* FILE NAME VERSION 1 */ + titfTmp = (titfTmp << 8) + 3; /* .FRAGLIST */ + titfTmp = (titfTmp << 8) + 1; /* D1 DIRECTORY */ + titfTmp = (titfTmp << 8) + 255; /* P PART IGNORED */ + filePtr.p->fileName[3] = titfTmp; + /* --------------------------------------------------------------------- */ + /* THE NAME BECOMES /D1/DBDICT/Stid.FRAGLIST */ + /* --------------------------------------------------------------------- */ + seizeFile(filePtr); + filePtr.p->tabRef = tabPtr.i; + filePtr.p->fileType = FileRecord::TABLE_FILE; + filePtr.p->reqStatus = FileRecord::IDLE; + filePtr.p->fileStatus = FileRecord::CLOSED; + tabPtr.p->tabFile[1] = filePtr.i; + filePtr.p->fileName[0] = (Uint32)-1; /* T DIRECTORY NOT USED */ + filePtr.p->fileName[1] = (Uint32)-1; /* F DIRECTORY NOT USED */ + filePtr.p->fileName[2] = tabPtr.i; /* Stid FILE NAME */ + titfTmp = 1; /* FILE NAME VERSION 1 */ + titfTmp = (titfTmp << 8) + 3; /* .FRAGLIST */ + titfTmp = (titfTmp << 8) + 2; /* D2 DIRECTORY */ + titfTmp = (titfTmp << 8) + 255; /* P PART IGNORED */ + filePtr.p->fileName[3] = titfTmp; + /* --------------------------------------------------------------------- */ + /* THE NAME BECOMES /D2/DBDICT/Stid.FRAGLIST */ + /* --------------------------------------------------------------------- */ +}//Dbdih::initTableFile() + +void Dbdih::initialiseRecordsLab(Signal* signal, Uint32 stepNo) +{ + switch (stepNo) { + case 0: + jam(); + initCommonData(); + break; + case 1: + { + ApiConnectRecordPtr apiConnectptr; + jam(); + /******** INTIALIZING API CONNECT RECORDS ********/ + for (apiConnectptr.i = 0; apiConnectptr.i < capiConnectFileSize; apiConnectptr.i++) { + ptrAss(apiConnectptr, apiConnectRecord); + apiConnectptr.p->nextApi = RNIL; + }//for + jam(); + break; + } + case 2: + { + ConnectRecordPtr connectPtr; + jam(); + /****** CONNECT ******/ + for (connectPtr.i = 0; connectPtr.i < cconnectFileSize; connectPtr.i++) { + ptrAss(connectPtr, connectRecord); + connectPtr.p->userpointer = RNIL; + connectPtr.p->userblockref = ZNIL; + connectPtr.p->connectState = ConnectRecord::FREE; + connectPtr.p->table = RNIL; + connectPtr.p->nfConnect = connectPtr.i + 1; + }//for + connectPtr.i = cconnectFileSize - 1; + ptrAss(connectPtr, connectRecord); + connectPtr.p->nfConnect = RNIL; + cfirstconnect = 0; + break; + } + case 3: + { + FileRecordPtr filePtr; + jam(); + /******** INTIALIZING FILE RECORDS ********/ + for (filePtr.i = 0; filePtr.i < cfileFileSize; filePtr.i++) { + ptrAss(filePtr, fileRecord); + filePtr.p->nextFile = filePtr.i + 1; + filePtr.p->fileStatus = FileRecord::CLOSED; + filePtr.p->reqStatus = FileRecord::IDLE; + }//for + filePtr.i = cfileFileSize - 1; + ptrAss(filePtr, fileRecord); + filePtr.p->nextFile = RNIL; + cfirstfreeFile = 0; + initRestorableGciFiles(); + break; + } + case 4: + jam(); + initialiseFragstore(); + break; + case 5: + { + jam(); + /******* NODE GROUP RECORD ******/ + /******* NODE RECORD ******/ + NodeGroupRecordPtr loopNGPtr; + for (loopNGPtr.i = 0; loopNGPtr.i < MAX_NDB_NODES; loopNGPtr.i++) { + ptrAss(loopNGPtr, nodeGroupRecord); + loopNGPtr.p->nodesInGroup[0] = RNIL; + loopNGPtr.p->nodesInGroup[1] = RNIL; + loopNGPtr.p->nodesInGroup[2] = RNIL; + loopNGPtr.p->nodesInGroup[3] = RNIL; + loopNGPtr.p->nextReplicaNode = 0; + loopNGPtr.p->nodeCount = 0; + loopNGPtr.p->activeTakeOver = false; + }//for + NodeRecordPtr nodePtr; + for (nodePtr.i = 0; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + ptrAss(nodePtr, nodeRecord); + initNodeState(nodePtr); + }//for + break; + } + case 6: + { + PageRecordPtr pagePtr; + jam(); + /******* PAGE RECORD ******/ + for (pagePtr.i = 0; pagePtr.i < cpageFileSize; pagePtr.i++) { + ptrAss(pagePtr, pageRecord); + pagePtr.p->nextfreepage = pagePtr.i + 1; + }//for + pagePtr.i = cpageFileSize - 1; + ptrAss(pagePtr, pageRecord); + pagePtr.p->nextfreepage = RNIL; + cfirstfreepage = 0; + break; + } + case 7: + { + ReplicaRecordPtr initReplicaPtr; + jam(); + /******* REPLICA RECORD ******/ + for (initReplicaPtr.i = 0; initReplicaPtr.i < creplicaFileSize; + initReplicaPtr.i++) { + ptrAss(initReplicaPtr, replicaRecord); + initReplicaPtr.p->lcpIdStarted = 0; + initReplicaPtr.p->lcpOngoingFlag = false; + initReplicaPtr.p->nextReplica = initReplicaPtr.i + 1; + }//for + initReplicaPtr.i = creplicaFileSize - 1; + ptrAss(initReplicaPtr, replicaRecord); + initReplicaPtr.p->nextReplica = RNIL; + cnoFreeReplicaRec = creplicaFileSize; + cfirstfreeReplica = 0; + break; + } + case 8: + { + TabRecordPtr loopTabptr; + jam(); + /********* TAB-DESCRIPTOR ********/ + for (loopTabptr.i = 0; loopTabptr.i < ctabFileSize; loopTabptr.i++) { + ptrAss(loopTabptr, tabRecord); + initTable(loopTabptr); + }//for + break; + } + case 9: + { + TakeOverRecordPtr takeOverPtr; + jam(); + cfirstfreeTakeOver = RNIL; + for (takeOverPtr.i = 0; takeOverPtr.i < MAX_NDB_NODES; takeOverPtr.i++) { + ptrAss(takeOverPtr, takeOverRecord); + initTakeOver(takeOverPtr); + releaseTakeOver(takeOverPtr.i); + }//for + signal->theData[0] = DBDIH_REF; + sendSignal(CMVMI_REF, GSN_SIZEALT_ACK, signal, 2, JBB); + return; + break; + } + default: + ndbrequire(false); + break; + }//switch + jam(); + /* ------------------------------------------------------------------------- */ + /* SEND REAL-TIME BREAK DURING INIT OF VARIABLES DURING SYSTEM RESTART. */ + /* ------------------------------------------------------------------------- */ + signal->theData[0] = DihContinueB::ZINITIALISE_RECORDS; + signal->theData[1] = stepNo + 1; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); +}//Dbdih::initialiseRecordsLab() + +/*************************************************************************/ +/* INSERT THE NODE INTO THE LINKED LIST OF NODES INVOLVED ALL */ +/* DISTRIBUTED PROTOCOLS (EXCEPT GCP PROTOCOL THAT USES THE DIH */ +/* LINKED LIST INSTEAD). */ +/*************************************************************************/ +void Dbdih::insertAlive(NodeRecordPtr newNodePtr) +{ + NodeRecordPtr nodePtr; + + nodePtr.i = cfirstAliveNode; + if (nodePtr.i == RNIL) { + jam(); + cfirstAliveNode = newNodePtr.i; + } else { + do { + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + if (nodePtr.p->nextNode == RNIL) { + jam(); + nodePtr.p->nextNode = newNodePtr.i; + break; + } else { + jam(); + nodePtr.i = nodePtr.p->nextNode; + }//if + } while (1); + }//if + newNodePtr.p->nextNode = RNIL; +}//Dbdih::insertAlive() + +void Dbdih::insertBackup(FragmentstorePtr fragPtr, Uint32 nodeId) +{ + for (Uint32 i = fragPtr.p->fragReplicas; i > 1; i--) { + jam(); + ndbrequire(i < MAX_REPLICAS && i > 0); + fragPtr.p->activeNodes[i] = fragPtr.p->activeNodes[i - 1]; + }//for + fragPtr.p->activeNodes[1] = nodeId; + fragPtr.p->fragReplicas++; +}//Dbdih::insertBackup() + +void Dbdih::insertDeadNode(NodeRecordPtr newNodePtr) +{ + NodeRecordPtr nodePtr; + + nodePtr.i = cfirstDeadNode; + if (nodePtr.i == RNIL) { + jam(); + cfirstDeadNode = newNodePtr.i; + } else { + do { + jam(); + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + if (nodePtr.p->nextNode == RNIL) { + jam(); + nodePtr.p->nextNode = newNodePtr.i; + break; + } else { + jam(); + nodePtr.i = nodePtr.p->nextNode; + }//if + } while (1); + }//if + newNodePtr.p->nextNode = RNIL; +}//Dbdih::insertDeadNode() + +void Dbdih::linkOldStoredReplica(FragmentstorePtr fragPtr, + ReplicaRecordPtr replicatePtr) +{ + ReplicaRecordPtr losReplicaPtr; + + replicatePtr.p->nextReplica = RNIL; + fragPtr.p->noOldStoredReplicas++; + losReplicaPtr.i = fragPtr.p->oldStoredReplicas; + if (losReplicaPtr.i == RNIL) { + jam(); + fragPtr.p->oldStoredReplicas = replicatePtr.i; + return; + }//if + ptrCheckGuard(losReplicaPtr, creplicaFileSize, replicaRecord); + while (losReplicaPtr.p->nextReplica != RNIL) { + jam(); + losReplicaPtr.i = losReplicaPtr.p->nextReplica; + ptrCheckGuard(losReplicaPtr, creplicaFileSize, replicaRecord); + }//if + losReplicaPtr.p->nextReplica = replicatePtr.i; +}//Dbdih::linkOldStoredReplica() + +void Dbdih::linkStoredReplica(FragmentstorePtr fragPtr, + ReplicaRecordPtr replicatePtr) +{ + ReplicaRecordPtr lsrReplicaPtr; + + fragPtr.p->noStoredReplicas++; + replicatePtr.p->nextReplica = RNIL; + lsrReplicaPtr.i = fragPtr.p->storedReplicas; + if (fragPtr.p->storedReplicas == RNIL) { + jam(); + fragPtr.p->storedReplicas = replicatePtr.i; + return; + }//if + ptrCheckGuard(lsrReplicaPtr, creplicaFileSize, replicaRecord); + while (lsrReplicaPtr.p->nextReplica != RNIL) { + jam(); + lsrReplicaPtr.i = lsrReplicaPtr.p->nextReplica; + ptrCheckGuard(lsrReplicaPtr, creplicaFileSize, replicaRecord); + }//if + lsrReplicaPtr.p->nextReplica = replicatePtr.i; +}//Dbdih::linkStoredReplica() + +/*************************************************************************/ +/* MAKE NODE GROUPS BASED ON THE LIST OF NODES RECEIVED FROM CNTR */ +/*************************************************************************/ +void Dbdih::makeNodeGroups(Uint32 nodeArray[]) +{ + NodeRecordPtr mngNodeptr; + Uint32 tmngNode; + Uint32 tmngNodeGroup; + Uint32 tmngReplica; + Uint32 tmngLimit; + + /**----------------------------------------------------------------------- + * ASSIGN ALL ACTIVE NODES INTO NODE GROUPS. HOT SPARE NODES ARE ASSIGNED + * TO NODE GROUP ZNIL + *-----------------------------------------------------------------------*/ + tmngNodeGroup = 0; + tmngReplica = 0; + tmngLimit = csystemnodes - cnoHotSpare; + ndbrequire(tmngLimit < MAX_NDB_NODES); + for (Uint32 i = 0; i < tmngLimit; i++) { + NodeGroupRecordPtr NGPtr; + jam(); + tmngNode = nodeArray[i]; + mngNodeptr.i = tmngNode; + ptrCheckGuard(mngNodeptr, MAX_NDB_NODES, nodeRecord); + mngNodeptr.p->nodeGroup = tmngNodeGroup; + NGPtr.i = tmngNodeGroup; + ptrCheckGuard(NGPtr, MAX_NDB_NODES, nodeGroupRecord); + arrGuard(tmngReplica, MAX_REPLICAS); + NGPtr.p->nodesInGroup[tmngReplica] = mngNodeptr.i; + tmngReplica++; + if (tmngReplica == cnoReplicas) { + jam(); + tmngNodeGroup++; + tmngReplica = 0; + }//if + }//for + cnoOfNodeGroups = tmngNodeGroup; + ndbrequire(csystemnodes < MAX_NDB_NODES); + for (Uint32 i = tmngLimit + 1; i < csystemnodes; i++) { + jam(); + tmngNode = nodeArray[i]; + mngNodeptr.i = tmngNode; + ptrCheckGuard(mngNodeptr, MAX_NDB_NODES, nodeRecord); + mngNodeptr.p->nodeGroup = ZNIL; + }//for + for(int i = 0; i < MAX_NDB_NODES; i++){ + jam(); + Sysfile::setNodeGroup(i, SYSFILE->nodeGroups, NO_NODE_GROUP_ID); + }//for + for (mngNodeptr.i = 1; mngNodeptr.i < MAX_NDB_NODES; mngNodeptr.i++) { + jam(); + ptrAss(mngNodeptr, nodeRecord); + if (mngNodeptr.p->nodeGroup != ZNIL) { + jam(); + Sysfile::setNodeGroup(mngNodeptr.i, SYSFILE->nodeGroups, mngNodeptr.p->nodeGroup); + }//if + }//for +}//Dbdih::makeNodeGroups() + +/** + * On node failure QMGR asks DIH about node groups. This is + * a direct signal (function call in same process). Input is + * bitmask of surviving nodes. The routine is not concerned + * about node count. Reply is one of: + * 1) win - we can survive, and nobody else can + * 2) lose - we cannot survive + * 3) partition - we can survive but there could be others + */ +void Dbdih::execCHECKNODEGROUPSREQ(Signal* signal) +{ + jamEntry(); + CheckNodeGroups* sd = (CheckNodeGroups*)&signal->theData[0]; + + bool direct = (sd->requestType & CheckNodeGroups::Direct); + bool ok = false; + switch(sd->requestType & ~CheckNodeGroups::Direct){ + case CheckNodeGroups::ArbitCheck:{ + ok = true; + jam(); + unsigned missall = 0; + unsigned haveall = 0; + for (Uint32 i = 0; i < cnoOfNodeGroups; i++) { + jam(); + NodeGroupRecordPtr ngPtr; + ngPtr.i = i; + ptrAss(ngPtr, nodeGroupRecord); + Uint32 count = 0; + for (Uint32 j = 0; j < ngPtr.p->nodeCount; j++) { + jam(); + Uint32 nodeId = ngPtr.p->nodesInGroup[j]; + if (sd->mask.get(nodeId)) { + jam(); + count++; + }//if + }//for + if (count == 0) { + jam(); + missall++; + }//if + if (count == ngPtr.p->nodeCount) { + haveall++; + }//if + }//for + + if (missall) { + jam(); + sd->output = CheckNodeGroups::Lose; + } else if (haveall) { + jam(); + sd->output = CheckNodeGroups::Win; + } else { + jam(); + sd->output = CheckNodeGroups::Partitioning; + }//if + } + break; + case CheckNodeGroups::GetNodeGroup: + ok = true; + sd->output = Sysfile::getNodeGroup(getOwnNodeId(), SYSFILE->nodeGroups); + break; + case CheckNodeGroups::GetNodeGroupMembers: { + ok = true; + Uint32 ownNodeGoup = + Sysfile::getNodeGroup(sd->nodeId, SYSFILE->nodeGroups); + + sd->output = ownNodeGoup; + sd->mask.clear(); + + NodeGroupRecordPtr ngPtr; + ngPtr.i = ownNodeGoup; + ptrAss(ngPtr, nodeGroupRecord); + for (Uint32 j = 0; j < ngPtr.p->nodeCount; j++) { + jam(); + sd->mask.set(ngPtr.p->nodesInGroup[j]); + } +#if 0 + for (int i = 0; i < MAX_NDB_NODES; i++) { + if (ownNodeGoup == + Sysfile::getNodeGroup(i, SYSFILE->nodeGroups)) { + sd->mask.set(i); + } + } +#endif + } + break; + } + ndbrequire(ok); + + if (!direct) + sendSignal(sd->blockRef, GSN_CHECKNODEGROUPSCONF, signal, + CheckNodeGroups::SignalLength, JBB); +}//Dbdih::execCHECKNODEGROUPSREQ() + +void Dbdih::makePrnList(ReadNodesConf * readNodes, Uint32 nodeArray[]) +{ + cfirstAliveNode = RNIL; + ndbrequire(con_lineNodes > 0); + ndbrequire(csystemnodes < MAX_NDB_NODES); + for (Uint32 i = 0; i < csystemnodes; i++) { + NodeRecordPtr nodePtr; + jam(); + nodePtr.i = nodeArray[i]; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + initNodeState(nodePtr); + if (NodeBitmask::get(readNodes->inactiveNodes, nodePtr.i) == false){ + jam(); + nodePtr.p->nodeStatus = NodeRecord::ALIVE; + nodePtr.p->useInTransactions = true; + nodePtr.p->copyCompleted = true; + nodePtr.p->m_inclDihLcp = true; + insertAlive(nodePtr); + } else { + jam(); + nodePtr.p->nodeStatus = NodeRecord::DEAD; + insertDeadNode(nodePtr); + }//if + nodePtr.p->ndbversion = readNodes->getVersionId(nodePtr.i, + readNodes->theVersionIds); + }//for +}//Dbdih::makePrnList() + +/*************************************************************************/ +/* A NEW CRASHED REPLICA IS ADDED BY A NODE FAILURE. */ +/*************************************************************************/ +void Dbdih::newCrashedReplica(Uint32 nodeId, ReplicaRecordPtr ncrReplicaPtr) +{ + /*----------------------------------------------------------------------*/ + /* SET THE REPLICA_LAST_GCI OF THE CRASHED REPLICA TO LAST GCI */ + /* EXECUTED BY THE FAILED NODE. */ + /*----------------------------------------------------------------------*/ + /* WE HAVE A NEW CRASHED REPLICA. INITIATE CREATE GCI TO INDICATE */ + /* THAT THE NEW REPLICA IS NOT STARTED YET AND REPLICA_LAST_GCI IS*/ + /* SET TO -1 TO INDICATE THAT IT IS NOT DEAD YET. */ + /*----------------------------------------------------------------------*/ + arrGuard(ncrReplicaPtr.p->noCrashedReplicas + 1, 8); + ncrReplicaPtr.p->replicaLastGci[ncrReplicaPtr.p->noCrashedReplicas] = + SYSFILE->lastCompletedGCI[nodeId]; + ncrReplicaPtr.p->noCrashedReplicas = ncrReplicaPtr.p->noCrashedReplicas + 1; + ncrReplicaPtr.p->createGci[ncrReplicaPtr.p->noCrashedReplicas] = 0; + ncrReplicaPtr.p->replicaLastGci[ncrReplicaPtr.p->noCrashedReplicas] = + (Uint32)-1; +}//Dbdih::newCrashedReplica() + +/*************************************************************************/ +/* AT NODE FAILURE DURING START OF A NEW NODE WE NEED TO RESET A */ +/* SET OF VARIABLES CONTROLLING THE START AND INDICATING ONGOING */ +/* START OF A NEW NODE. */ +/*************************************************************************/ +void Dbdih::nodeResetStart() +{ + jam(); + c_nodeStartMaster.startNode = RNIL; + c_nodeStartMaster.failNr = cfailurenr; + c_nodeStartMaster.activeState = false; + c_nodeStartMaster.blockGcp = false; + c_nodeStartMaster.blockLcp = false; + c_nodeStartMaster.m_outstandingGsn = 0; +}//Dbdih::nodeResetStart() + +void Dbdih::openFileRw(Signal* signal, FileRecordPtr filePtr) +{ + signal->theData[0] = reference(); + signal->theData[1] = filePtr.i; + signal->theData[2] = filePtr.p->fileName[0]; + signal->theData[3] = filePtr.p->fileName[1]; + signal->theData[4] = filePtr.p->fileName[2]; + signal->theData[5] = filePtr.p->fileName[3]; + signal->theData[6] = ZOPEN_READ_WRITE; + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA); +}//Dbdih::openFileRw() + +/*************************************************************************/ +/* REMOVE A CRASHED REPLICA BY PACKING THE ARRAY OF CREATED GCI AND*/ +/* THE LAST GCI OF THE CRASHED REPLICA. */ +/*************************************************************************/ +void Dbdih::packCrashedReplicas(ReplicaRecordPtr replicaPtr) +{ + ndbrequire(replicaPtr.p->noCrashedReplicas > 0); + ndbrequire(replicaPtr.p->noCrashedReplicas <= 8); + for (Uint32 i = 0; i < replicaPtr.p->noCrashedReplicas; i++) { + jam(); + replicaPtr.p->createGci[i] = replicaPtr.p->createGci[i + 1]; + replicaPtr.p->replicaLastGci[i] = replicaPtr.p->replicaLastGci[i + 1]; + }//for + replicaPtr.p->noCrashedReplicas--; + +#ifdef VM_TRACE + for (Uint32 i = 0; i < replicaPtr.p->noCrashedReplicas; i++) { + jam(); + ndbrequire(replicaPtr.p->createGci[i] != 0xF1F1F1F1); + ndbrequire(replicaPtr.p->replicaLastGci[i] != 0xF1F1F1F1); + }//for +#endif +}//Dbdih::packCrashedReplicas() + +void Dbdih::prepareReplicas(FragmentstorePtr fragPtr) +{ + ReplicaRecordPtr prReplicaPtr; + Uint32 prevReplica = RNIL; + + /* --------------------------------------------------------------------- */ + /* BEGIN BY LINKING ALL REPLICA RECORDS ONTO THE OLD STORED REPLICA*/ + /* LIST. */ + /* AT A SYSTEM RESTART OBVIOUSLY ALL NODES ARE OLD. */ + /* --------------------------------------------------------------------- */ + prReplicaPtr.i = fragPtr.p->storedReplicas; + while (prReplicaPtr.i != RNIL) { + jam(); + prevReplica = prReplicaPtr.i; + ptrCheckGuard(prReplicaPtr, creplicaFileSize, replicaRecord); + prReplicaPtr.i = prReplicaPtr.p->nextReplica; + }//while + /* --------------------------------------------------------------------- */ + /* LIST OF STORED REPLICAS WILL BE EMPTY NOW. */ + /* --------------------------------------------------------------------- */ + if (prevReplica != RNIL) { + prReplicaPtr.i = prevReplica; + ptrCheckGuard(prReplicaPtr, creplicaFileSize, replicaRecord); + prReplicaPtr.p->nextReplica = fragPtr.p->oldStoredReplicas; + fragPtr.p->oldStoredReplicas = fragPtr.p->storedReplicas; + fragPtr.p->storedReplicas = RNIL; + fragPtr.p->noOldStoredReplicas += fragPtr.p->noStoredReplicas; + fragPtr.p->noStoredReplicas = 0; + }//if +}//Dbdih::prepareReplicas() + +void Dbdih::readFragment(RWFragment* rf, FragmentstorePtr fragPtr) +{ + Uint32 TreadFid = readPageWord(rf); + fragPtr.p->preferredPrimary = readPageWord(rf); + fragPtr.p->noStoredReplicas = readPageWord(rf); + fragPtr.p->noOldStoredReplicas = readPageWord(rf); + Uint32 TdistKey = readPageWord(rf); + + ndbrequire(fragPtr.p->noStoredReplicas > 0); + ndbrequire(TreadFid == rf->fragId); + ndbrequire(TdistKey < 256); + if ((cstarttype == NodeState::ST_NODE_RESTART) || + (cstarttype == NodeState::ST_INITIAL_NODE_RESTART)) { + jam(); + fragPtr.p->distributionKey = TdistKey; + }//if +}//Dbdih::readFragment() + +Uint32 Dbdih::readPageWord(RWFragment* rf) +{ + if (rf->wordIndex >= 2048) { + jam(); + ndbrequire(rf->wordIndex == 2048); + rf->pageIndex++; + ndbrequire(rf->pageIndex < 8); + rf->rwfPageptr.i = rf->rwfTabPtr.p->pageRef[rf->pageIndex]; + ptrCheckGuard(rf->rwfPageptr, cpageFileSize, pageRecord); + rf->wordIndex = 32; + }//if + Uint32 dataWord = rf->rwfPageptr.p->word[rf->wordIndex]; + rf->wordIndex++; + return dataWord; +}//Dbdih::readPageWord() + +void Dbdih::readReplica(RWFragment* rf, ReplicaRecordPtr readReplicaPtr) +{ + readReplicaPtr.p->procNode = readPageWord(rf); + readReplicaPtr.p->initialGci = readPageWord(rf); + readReplicaPtr.p->noCrashedReplicas = readPageWord(rf); + readReplicaPtr.p->nextLcp = readPageWord(rf); + + for (Uint32 i = 0; i < MAX_LCP_STORED; i++) { + readReplicaPtr.p->maxGciCompleted[i] = readPageWord(rf); + readReplicaPtr.p->maxGciStarted[i] = readPageWord(rf); + readReplicaPtr.p->lcpId[i] = readPageWord(rf); + readReplicaPtr.p->lcpStatus[i] = readPageWord(rf); + }//for + const Uint32 noCrashedReplicas = readReplicaPtr.p->noCrashedReplicas; + ndbrequire(noCrashedReplicas < 8); + for (Uint32 i = 0; i < noCrashedReplicas; i++) { + readReplicaPtr.p->createGci[i] = readPageWord(rf); + readReplicaPtr.p->replicaLastGci[i] = readPageWord(rf); + ndbrequire(readReplicaPtr.p->createGci[i] != 0xF1F1F1F1); + ndbrequire(readReplicaPtr.p->replicaLastGci[i] != 0xF1F1F1F1); + }//for + for(Uint32 i = noCrashedReplicas; i<8; i++){ + readReplicaPtr.p->createGci[i] = readPageWord(rf); + readReplicaPtr.p->replicaLastGci[i] = readPageWord(rf); + // They are not initialized... + readReplicaPtr.p->createGci[i] = 0; + readReplicaPtr.p->replicaLastGci[i] = ~0; + } + /* ---------------------------------------------------------------------- */ + /* IF THE LAST COMPLETED LOCAL CHECKPOINT IS VALID AND LARGER THAN */ + /* THE LAST COMPLETED CHECKPOINT THEN WE WILL INVALIDATE THIS LOCAL */ + /* CHECKPOINT FOR THIS REPLICA. */ + /* ---------------------------------------------------------------------- */ + Uint32 trraLcp = prevLcpNo(readReplicaPtr.p->nextLcp); + ndbrequire(trraLcp < MAX_LCP_STORED); + if ((readReplicaPtr.p->lcpStatus[trraLcp] == ZVALID) && + (readReplicaPtr.p->lcpId[trraLcp] > SYSFILE->latestLCP_ID)) { + jam(); + readReplicaPtr.p->lcpStatus[trraLcp] = ZINVALID; + }//if + /* ---------------------------------------------------------------------- */ + /* WE ALSO HAVE TO INVALIDATE ANY LOCAL CHECKPOINTS THAT HAVE BEEN */ + /* INVALIDATED BY MOVING BACK THE RESTART GCI. */ + /* ---------------------------------------------------------------------- */ + for (Uint32 i = 0; i < MAX_LCP_STORED; i++) { + jam(); + if ((readReplicaPtr.p->lcpStatus[i] == ZVALID) && + (readReplicaPtr.p->maxGciStarted[i] > SYSFILE->newestRestorableGCI)) { + jam(); + readReplicaPtr.p->lcpStatus[i] = ZINVALID; + }//if + }//for + /* ---------------------------------------------------------------------- */ + /* WE WILL REMOVE ANY OCCURRENCES OF REPLICAS THAT HAVE CRASHED */ + /* THAT ARE NO LONGER VALID DUE TO MOVING RESTART GCI BACKWARDS. */ + /* ---------------------------------------------------------------------- */ + removeTooNewCrashedReplicas(readReplicaPtr); + /* ---------------------------------------------------------------------- */ + /* WE WILL REMOVE ANY OCCURRENCES OF REPLICAS THAT HAVE CRASHED */ + /* THAT ARE NO LONGER VALID SINCE THEY ARE NO LONGER RESTORABLE. */ + /* ---------------------------------------------------------------------- */ + removeOldCrashedReplicas(readReplicaPtr); + /* --------------------------------------------------------------------- */ + // We set the last GCI of the replica that was alive before the node + // crashed last time. We set it to the last GCI which the node participated in. + /* --------------------------------------------------------------------- */ + ndbrequire(readReplicaPtr.p->noCrashedReplicas < 8); + readReplicaPtr.p->replicaLastGci[readReplicaPtr.p->noCrashedReplicas] = + SYSFILE->lastCompletedGCI[readReplicaPtr.p->procNode]; + /* ---------------------------------------------------------------------- */ + /* FIND PROCESSOR RECORD */ + /* ---------------------------------------------------------------------- */ +}//Dbdih::readReplica() + +void Dbdih::readReplicas(RWFragment* rf, FragmentstorePtr fragPtr) +{ + ReplicaRecordPtr newReplicaPtr; + Uint32 noStoredReplicas = fragPtr.p->noStoredReplicas; + Uint32 noOldStoredReplicas = fragPtr.p->noOldStoredReplicas; + /* ----------------------------------------------------------------------- */ + /* WE CLEAR THE NUMBER OF STORED REPLICAS SINCE IT WILL BE CALCULATED */ + /* BY THE LINKING SUBROUTINES. */ + /* ----------------------------------------------------------------------- */ + fragPtr.p->noStoredReplicas = 0; + fragPtr.p->noOldStoredReplicas = 0; + Uint32 replicaIndex = 0; + ndbrequire(noStoredReplicas + noOldStoredReplicas <= MAX_REPLICAS); + for (Uint32 i = 0; i < noStoredReplicas; i++) { + seizeReplicaRec(newReplicaPtr); + readReplica(rf, newReplicaPtr); + if (checkNodeAlive(newReplicaPtr.p->procNode)) { + jam(); + ndbrequire(replicaIndex < MAX_REPLICAS); + fragPtr.p->activeNodes[replicaIndex] = newReplicaPtr.p->procNode; + replicaIndex++; + linkStoredReplica(fragPtr, newReplicaPtr); + } else { + jam(); + linkOldStoredReplica(fragPtr, newReplicaPtr); + }//if + }//for + fragPtr.p->fragReplicas = noStoredReplicas; + for (Uint32 i = 0; i < noOldStoredReplicas; i++) { + jam(); + seizeReplicaRec(newReplicaPtr); + readReplica(rf, newReplicaPtr); + linkOldStoredReplica(fragPtr, newReplicaPtr); + }//for +}//Dbdih::readReplicas() + +void Dbdih::readRestorableGci(Signal* signal, FileRecordPtr filePtr) +{ + signal->theData[0] = filePtr.p->fileRef; + signal->theData[1] = reference(); + signal->theData[2] = filePtr.i; + signal->theData[3] = ZLIST_OF_PAIRS; + signal->theData[4] = ZVAR_NO_CRESTART_INFO; + signal->theData[5] = 1; + signal->theData[6] = 0; + signal->theData[7] = 0; + sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 8, JBA); +}//Dbdih::readRestorableGci() + +void Dbdih::readTabfile(Signal* signal, TabRecord* tab, FileRecordPtr filePtr) +{ + signal->theData[0] = filePtr.p->fileRef; + signal->theData[1] = reference(); + signal->theData[2] = filePtr.i; + signal->theData[3] = ZLIST_OF_PAIRS; + signal->theData[4] = ZVAR_NO_WORD; + signal->theData[5] = tab->noPages; + for (Uint32 i = 0; i < tab->noPages; i++) { + signal->theData[6 + (2 * i)] = tab->pageRef[i]; + signal->theData[7 + (2 * i)] = i; + }//for + sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 22, JBA); +}//Dbdih::readTabfile() + +void Dbdih::releasePage(Uint32 pageIndex) +{ + PageRecordPtr pagePtr; + pagePtr.i = pageIndex; + ptrCheckGuard(pagePtr, cpageFileSize, pageRecord); + pagePtr.p->nextfreepage = cfirstfreepage; + cfirstfreepage = pagePtr.i; +}//Dbdih::releasePage() + +void Dbdih::releaseTabPages(Uint32 tableId) +{ + TabRecordPtr tabPtr; + tabPtr.i = tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + ndbrequire(tabPtr.p->noPages <= 8); + for (Uint32 i = 0; i < tabPtr.p->noPages; i++) { + jam(); + releasePage(tabPtr.p->pageRef[i]); + }//for + tabPtr.p->noPages = 0; +}//Dbdih::releaseTabPages() + +/*************************************************************************/ +/* REMOVE NODE FROM SET OF ALIVE NODES. */ +/*************************************************************************/ +void Dbdih::removeAlive(NodeRecordPtr removeNodePtr) +{ + NodeRecordPtr nodePtr; + + nodePtr.i = cfirstAliveNode; + if (nodePtr.i == removeNodePtr.i) { + jam(); + cfirstAliveNode = removeNodePtr.p->nextNode; + return; + }//if + do { + jam(); + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + if (nodePtr.p->nextNode == removeNodePtr.i) { + jam(); + nodePtr.p->nextNode = removeNodePtr.p->nextNode; + break; + } else { + jam(); + nodePtr.i = nodePtr.p->nextNode; + }//if + } while (1); +}//Dbdih::removeAlive() + +/*************************************************************************/ +/* REMOVE NODE FROM SET OF DEAD NODES. */ +/*************************************************************************/ +void Dbdih::removeDeadNode(NodeRecordPtr removeNodePtr) +{ + NodeRecordPtr nodePtr; + + nodePtr.i = cfirstDeadNode; + if (nodePtr.i == removeNodePtr.i) { + jam(); + cfirstDeadNode = removeNodePtr.p->nextNode; + return; + }//if + do { + jam(); + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + if (nodePtr.p->nextNode == removeNodePtr.i) { + jam(); + nodePtr.p->nextNode = removeNodePtr.p->nextNode; + break; + } else { + jam(); + nodePtr.i = nodePtr.p->nextNode; + }//if + } while (1); +}//Dbdih::removeDeadNode() + +/*---------------------------------------------------------------*/ +/* REMOVE REPLICAS OF A FAILED NODE FROM LIST OF STORED */ +/* REPLICAS AND MOVE IT TO THE LIST OF OLD STORED REPLICAS.*/ +/* ALSO UPDATE THE CRASHED REPLICA INFORMATION. */ +/*---------------------------------------------------------------*/ +void Dbdih::removeNodeFromStored(Uint32 nodeId, + FragmentstorePtr fragPtr, + ReplicaRecordPtr replicatePtr) +{ + newCrashedReplica(nodeId, replicatePtr); + removeStoredReplica(fragPtr, replicatePtr); + linkOldStoredReplica(fragPtr, replicatePtr); + ndbrequire(fragPtr.p->storedReplicas != RNIL); +}//Dbdih::removeNodeFromStored() + +/*************************************************************************/ +/* REMOVE ANY OLD CRASHED REPLICAS THAT ARE NOT RESTORABLE ANY MORE*/ +/*************************************************************************/ +void Dbdih::removeOldCrashedReplicas(ReplicaRecordPtr rocReplicaPtr) +{ + while (rocReplicaPtr.p->noCrashedReplicas > 0) { + jam(); + /* --------------------------------------------------------------------- */ + /* ONLY IF THERE IS AT LEAST ONE REPLICA THEN CAN WE REMOVE ANY. */ + /* --------------------------------------------------------------------- */ + if (rocReplicaPtr.p->replicaLastGci[0] < SYSFILE->oldestRestorableGCI){ + jam(); + /* ------------------------------------------------------------------- */ + /* THIS CRASHED REPLICA HAS BECOME EXTINCT AND MUST BE REMOVED TO */ + /* GIVE SPACE FOR NEW CRASHED REPLICAS. */ + /* ------------------------------------------------------------------- */ + packCrashedReplicas(rocReplicaPtr); + } else { + break; + }//if + }//while + if (rocReplicaPtr.p->createGci[0] < SYSFILE->keepGCI){ + jam(); + /* --------------------------------------------------------------------- */ + /* MOVE FORWARD THE CREATE GCI TO A GCI THAT CAN BE USED. WE HAVE */ + /* NO CERTAINTY IN FINDING ANY LOG RECORDS FROM OLDER GCI'S. */ + /* --------------------------------------------------------------------- */ + rocReplicaPtr.p->createGci[0] = SYSFILE->keepGCI; + ndbrequire(SYSFILE->keepGCI != 0xF1F1F1F1); + }//if +}//Dbdih::removeOldCrashedReplicas() + +void Dbdih::removeOldStoredReplica(FragmentstorePtr fragPtr, + ReplicaRecordPtr replicatePtr) +{ + ReplicaRecordPtr rosTmpReplicaPtr; + ReplicaRecordPtr rosPrevReplicaPtr; + + fragPtr.p->noOldStoredReplicas--; + if (fragPtr.p->oldStoredReplicas == replicatePtr.i) { + jam(); + fragPtr.p->oldStoredReplicas = replicatePtr.p->nextReplica; + } else { + rosPrevReplicaPtr.i = fragPtr.p->oldStoredReplicas; + ptrCheckGuard(rosPrevReplicaPtr, creplicaFileSize, replicaRecord); + rosTmpReplicaPtr.i = rosPrevReplicaPtr.p->nextReplica; + while (rosTmpReplicaPtr.i != replicatePtr.i) { + jam(); + rosPrevReplicaPtr.i = rosTmpReplicaPtr.i; + ptrCheckGuard(rosPrevReplicaPtr, creplicaFileSize, replicaRecord); + ptrCheckGuard(rosTmpReplicaPtr, creplicaFileSize, replicaRecord); + rosTmpReplicaPtr.i = rosTmpReplicaPtr.p->nextReplica; + }//if + rosPrevReplicaPtr.p->nextReplica = replicatePtr.p->nextReplica; + }//if +}//Dbdih::removeOldStoredReplica() + +void Dbdih::removeStoredReplica(FragmentstorePtr fragPtr, + ReplicaRecordPtr replicatePtr) +{ + ReplicaRecordPtr rsrTmpReplicaPtr; + ReplicaRecordPtr rsrPrevReplicaPtr; + + fragPtr.p->noStoredReplicas--; + if (fragPtr.p->storedReplicas == replicatePtr.i) { + jam(); + fragPtr.p->storedReplicas = replicatePtr.p->nextReplica; + } else { + jam(); + rsrPrevReplicaPtr.i = fragPtr.p->storedReplicas; + rsrTmpReplicaPtr.i = fragPtr.p->storedReplicas; + ptrCheckGuard(rsrTmpReplicaPtr, creplicaFileSize, replicaRecord); + rsrTmpReplicaPtr.i = rsrTmpReplicaPtr.p->nextReplica; + while (rsrTmpReplicaPtr.i != replicatePtr.i) { + jam(); + rsrPrevReplicaPtr.i = rsrTmpReplicaPtr.i; + ptrCheckGuard(rsrTmpReplicaPtr, creplicaFileSize, replicaRecord); + rsrTmpReplicaPtr.i = rsrTmpReplicaPtr.p->nextReplica; + }//while + ptrCheckGuard(rsrPrevReplicaPtr, creplicaFileSize, replicaRecord); + rsrPrevReplicaPtr.p->nextReplica = replicatePtr.p->nextReplica; + }//if +}//Dbdih::removeStoredReplica() + +/*************************************************************************/ +/* REMOVE ALL TOO NEW CRASHED REPLICAS THAT IS IN THIS REPLICA. */ +/*************************************************************************/ +void Dbdih::removeTooNewCrashedReplicas(ReplicaRecordPtr rtnReplicaPtr) +{ + while (rtnReplicaPtr.p->noCrashedReplicas > 0) { + jam(); + /* --------------------------------------------------------------------- */ + /* REMOVE ALL REPLICAS THAT ONLY LIVED IN A PERIOD THAT HAVE BEEN */ + /* REMOVED FROM THE RESTART INFORMATION SINCE THE RESTART FAILED */ + /* TOO MANY TIMES. */ + /* --------------------------------------------------------------------- */ + arrGuard(rtnReplicaPtr.p->noCrashedReplicas - 1, 8); + if (rtnReplicaPtr.p->createGci[rtnReplicaPtr.p->noCrashedReplicas - 1] > + SYSFILE->newestRestorableGCI){ + jam(); + rtnReplicaPtr.p->createGci[rtnReplicaPtr.p->noCrashedReplicas - 1] = + (Uint32)-1; + rtnReplicaPtr.p->replicaLastGci[rtnReplicaPtr.p->noCrashedReplicas - 1] = + (Uint32)-1; + rtnReplicaPtr.p->noCrashedReplicas--; + } else { + break; + }//if + }//while +}//Dbdih::removeTooNewCrashedReplicas() + +/*************************************************************************/ +/* */ +/* MODULE: SEARCH FOR POSSIBLE REPLICAS THAT CAN HANDLE THE GLOBAL */ +/* CHECKPOINT WITHOUT NEEDING ANY EXTRA LOGGING FACILITIES.*/ +/* A MAXIMUM OF FOUR NODES IS RETRIEVED. */ +/*************************************************************************/ +void Dbdih::searchStoredReplicas(FragmentstorePtr fragPtr) +{ + Uint32 nextReplicaPtrI; + ConstPtr replicaPtr; + + replicaPtr.i = fragPtr.p->storedReplicas; + while (replicaPtr.i != RNIL) { + jam(); + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + nextReplicaPtrI = replicaPtr.p->nextReplica; + NodeRecordPtr nodePtr; + nodePtr.i = replicaPtr.p->procNode; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + if (nodePtr.p->nodeStatus == NodeRecord::ALIVE) { + jam(); + switch (nodePtr.p->activeStatus) { + case Sysfile::NS_Active: + case Sysfile::NS_ActiveMissed_1: + case Sysfile::NS_ActiveMissed_2:{ + /* ----------------------------------------------------------------- */ + /* INITIALISE THE CREATE REPLICA STRUCTURE THAT IS USED FOR SENDING*/ + /* TO LQH START_FRAGREQ. */ + /* SET THE DATA NODE WHERE THE LOCAL CHECKPOINT IS FOUND. ALSO */ + /* SET A REFERENCE TO THE REPLICA POINTER OF THAT. */ + /* ----------------------------------------------------------------- */ + CreateReplicaRecordPtr createReplicaPtr; + createReplicaPtr.i = cnoOfCreateReplicas; + ptrCheckGuard(createReplicaPtr, 4, createReplicaRecord); + cnoOfCreateReplicas++; + createReplicaPtr.p->dataNodeId = replicaPtr.p->procNode; + createReplicaPtr.p->replicaRec = replicaPtr.i; + /* ----------------------------------------------------------------- */ + /* WE NEED TO SEARCH FOR A PROPER LOCAL CHECKPOINT TO USE FOR THE */ + /* SYSTEM RESTART. */ + /* ----------------------------------------------------------------- */ + Uint32 startGci; + Uint32 startLcpNo; + Uint32 stopGci = SYSFILE->newestRestorableGCI; + bool result = findStartGci(replicaPtr, + stopGci, + startGci, + startLcpNo); + if (!result) { + jam(); + /* --------------------------------------------------------------- */ + /* WE COULD NOT FIND ANY LOCAL CHECKPOINT. THE FRAGMENT THUS DO NOT*/ + /* CONTAIN ANY VALID LOCAL CHECKPOINT. IT DOES HOWEVER CONTAIN A */ + /* VALID FRAGMENT LOG. THUS BY FIRST CREATING THE FRAGMENT AND THEN*/ + /* EXECUTING THE FRAGMENT LOG WE CAN CREATE THE FRAGMENT AS */ + /* DESIRED. THIS SHOULD ONLY OCCUR AFTER CREATING A FRAGMENT. */ + /* */ + /* TO INDICATE THAT NO LOCAL CHECKPOINT IS TO BE USED WE SET THE */ + /* LOCAL CHECKPOINT TO ZNIL. */ + /* --------------------------------------------------------------- */ + createReplicaPtr.p->lcpNo = ZNIL; + } else { + jam(); + /* --------------------------------------------------------------- */ + /* WE FOUND A PROPER LOCAL CHECKPOINT TO RESTART FROM. */ + /* SET LOCAL CHECKPOINT ID AND LOCAL CHECKPOINT NUMBER. */ + /* --------------------------------------------------------------- */ + createReplicaPtr.p->lcpNo = startLcpNo; + arrGuard(startLcpNo, MAX_LCP_STORED); + createReplicaPtr.p->createLcpId = replicaPtr.p->lcpId[startLcpNo]; + }//if + + if(ERROR_INSERTED(7073) || ERROR_INSERTED(7074)){ + jam(); + nodePtr.p->nodeStatus = NodeRecord::DEAD; + } + + /* ----------------------------------------------------------------- */ + /* WE HAVE EITHER FOUND A LOCAL CHECKPOINT OR WE ARE PLANNING TO */ + /* EXECUTE THE LOG FROM THE INITIAL CREATION OF THE TABLE. IN BOTH */ + /* CASES WE NEED TO FIND A SET OF LOGS THAT CAN EXECUTE SUCH THAT */ + /* WE RECOVER TO THE SYSTEM RESTART GLOBAL CHECKPOINT. */ + /* -_--------------------------------------------------------------- */ + if (!findLogNodes(createReplicaPtr.p, fragPtr, startGci, stopGci)) { + jam(); + /* --------------------------------------------------------------- */ + /* WE WERE NOT ABLE TO FIND ANY WAY OF RESTORING THIS REPLICA. */ + /* THIS IS A POTENTIAL SYSTEM ERROR. */ + /* --------------------------------------------------------------- */ + cnoOfCreateReplicas--; + return; + }//if + + if(ERROR_INSERTED(7073) || ERROR_INSERTED(7074)){ + jam(); + nodePtr.p->nodeStatus = NodeRecord::ALIVE; + } + + break; + } + default: + jam(); + /*empty*/; + break; + }//switch + } + replicaPtr.i = nextReplicaPtrI; + }//while +}//Dbdih::searchStoredReplicas() + +/*************************************************************************/ +/* */ +/* MODULE: SEIZE_FILE */ +/* DESCRIPTION: THE SUBROUTINE SEIZES A FILE RECORD FROM THE */ +/* FREE LIST. */ +/*************************************************************************/ +void Dbdih::seizeFile(FileRecordPtr& filePtr) +{ + filePtr.i = cfirstfreeFile; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + cfirstfreeFile = filePtr.p->nextFile; + filePtr.p->nextFile = RNIL; +}//Dbdih::seizeFile() + +/*************************************************************************/ +/* SEND CREATE_FRAGREQ TO ALL NODES IN THE NDB CLUSTER. */ +/*************************************************************************/ +/*************************************************************************/ +/* */ +/* MODULE: FIND THE START GCI AND LOCAL CHECKPOINT TO USE. */ +/*************************************************************************/ +void Dbdih::sendStartFragreq(Signal* signal, + TabRecordPtr tabPtr, Uint32 fragId) +{ + CreateReplicaRecordPtr replicaPtr; + for (replicaPtr.i = 0; replicaPtr.i < cnoOfCreateReplicas; replicaPtr.i++) { + jam(); + ptrAss(replicaPtr, createReplicaRecord); + BlockReference ref = calcLqhBlockRef(replicaPtr.p->dataNodeId); + StartFragReq * const startFragReq = (StartFragReq *)&signal->theData[0]; + startFragReq->userPtr = replicaPtr.p->replicaRec; + startFragReq->userRef = reference(); + startFragReq->lcpNo = replicaPtr.p->lcpNo; + startFragReq->lcpId = replicaPtr.p->createLcpId; + startFragReq->tableId = tabPtr.i; + startFragReq->fragId = fragId; + + if(ERROR_INSERTED(7072) || ERROR_INSERTED(7074)){ + jam(); + const Uint32 noNodes = replicaPtr.p->noLogNodes; + Uint32 start = replicaPtr.p->logStartGci[noNodes - 1]; + const Uint32 stop = replicaPtr.p->logStopGci[noNodes - 1]; + + for(Uint32 i = noNodes; i < 4 && (stop - start) > 0; i++){ + replicaPtr.p->noLogNodes++; + replicaPtr.p->logStopGci[i - 1] = start; + + replicaPtr.p->logNodeId[i] = replicaPtr.p->logNodeId[i-1]; + replicaPtr.p->logStartGci[i] = start + 1; + replicaPtr.p->logStopGci[i] = stop; + start += 1; + } + } + + startFragReq->noOfLogNodes = replicaPtr.p->noLogNodes; + + for (Uint32 i = 0; i < 4 ; i++) { + startFragReq->lqhLogNode[i] = replicaPtr.p->logNodeId[i]; + startFragReq->startGci[i] = replicaPtr.p->logStartGci[i]; + startFragReq->lastGci[i] = replicaPtr.p->logStopGci[i]; + }//for + + sendSignal(ref, GSN_START_FRAGREQ, signal, + StartFragReq::SignalLength, JBB); + }//for +}//Dbdih::sendStartFragreq() + +/*************************************************************************/ +/* SET THE INITIAL ACTIVE STATUS ON ALL NODES AND PUT INTO LISTS. */ +/*************************************************************************/ +void Dbdih::setInitialActiveStatus() +{ + NodeRecordPtr siaNodeptr; + Uint32 tsiaNodeActiveStatus; + Uint32 tsiaNoActiveNodes; + + tsiaNoActiveNodes = csystemnodes - cnoHotSpare; + for(Uint32 i = 0; inodeStatus[i] = 0; + for (siaNodeptr.i = 1; siaNodeptr.i < MAX_NDB_NODES; siaNodeptr.i++) { + ptrAss(siaNodeptr, nodeRecord); + if (siaNodeptr.p->nodeStatus == NodeRecord::ALIVE) { + if (tsiaNoActiveNodes == 0) { + jam(); + siaNodeptr.p->activeStatus = Sysfile::NS_HotSpare; + } else { + jam(); + tsiaNoActiveNodes = tsiaNoActiveNodes - 1; + siaNodeptr.p->activeStatus = Sysfile::NS_Active; + }//if + } else { + jam(); + siaNodeptr.p->activeStatus = Sysfile::NS_NotDefined; + }//if + switch (siaNodeptr.p->activeStatus) { + case Sysfile::NS_Active: + jam(); + tsiaNodeActiveStatus = Sysfile::NS_Active; + break; + case Sysfile::NS_HotSpare: + jam(); + tsiaNodeActiveStatus = Sysfile::NS_HotSpare; + break; + case Sysfile::NS_NotDefined: + jam(); + tsiaNodeActiveStatus = Sysfile::NS_NotDefined; + break; + default: + ndbrequire(false); + return; + break; + }//switch + Sysfile::setNodeStatus(siaNodeptr.i, SYSFILE->nodeStatus, + tsiaNodeActiveStatus); + }//for +}//Dbdih::setInitialActiveStatus() + +/*************************************************************************/ +/* SET LCP ACTIVE STATUS AT THE END OF A LOCAL CHECKPOINT. */ +/*************************************************************************/ +void Dbdih::setLcpActiveStatusEnd() +{ + NodeRecordPtr nodePtr; + + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRecord); + if (c_lcpState.m_participatingLQH.get(nodePtr.i)){ + switch (nodePtr.p->activeStatus) { + case Sysfile::NS_Active: + case Sysfile::NS_ActiveMissed_1: + case Sysfile::NS_ActiveMissed_2: + jam(); + /*-------------------------------------------------------------------*/ + /* THE NODE PARTICIPATED IN THIS CHECKPOINT. + * WE CAN SET ITS STATUS TO ACTIVE */ + /*-------------------------------------------------------------------*/ + nodePtr.p->activeStatus = Sysfile::NS_Active; + takeOverCompleted(nodePtr.i); + break; + case Sysfile::NS_TakeOver: + jam(); + /*-------------------------------------------------------------------*/ + /* THE NODE HAS COMPLETED A CHECKPOINT AFTER TAKE OVER. WE CAN NOW */ + /* SET ITS STATUS TO ACTIVE. WE CAN ALSO COMPLETE THE TAKE OVER */ + /* AND ALSO WE CLEAR THE TAKE OVER NODE IN THE RESTART INFO. */ + /*-------------------------------------------------------------------*/ + nodePtr.p->activeStatus = Sysfile::NS_Active; + takeOverCompleted(nodePtr.i); + break; + default: + ndbrequire(false); + return; + break; + }//switch + }//if + }//for + + if(getNodeState().getNodeRestartInProgress()){ + jam(); + if(c_lcpState.m_participatingLQH.get(getOwnNodeId())){ + nodePtr.i = getOwnNodeId(); + ptrAss(nodePtr, nodeRecord); + ndbrequire(nodePtr.p->activeStatus == Sysfile::NS_Active); + ndbout_c("NR: setLcpActiveStatusEnd - m_participatingLQH"); + } else { + ndbout_c("NR: setLcpActiveStatusEnd - !m_participatingLQH"); + } + } + + c_lcpState.m_participatingDIH.clear(); + c_lcpState.m_participatingLQH.clear(); + if (isMaster()) { + jam(); + setNodeRestartInfoBits(); + }//if +}//Dbdih::setLcpActiveStatusEnd() + +void Dbdih::takeOverCompleted(Uint32 aNodeId) +{ + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = findTakeOver(aNodeId); + if (takeOverPtr.i != RNIL) { + jam(); + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + if (takeOverPtr.p->toMasterStatus != TakeOverRecord::WAIT_LCP) { + jam(); + ndbrequire(!isMaster()); + return; + }//if + ndbrequire(isMaster()); + Sysfile::setTakeOverNode(aNodeId, SYSFILE->takeOver, 0); + takeOverPtr.p->toMasterStatus = TakeOverRecord::TO_END_COPY; + cstartGcpNow = true; + }//if +}//Dbdih::takeOverCompleted() + +/*************************************************************************/ +/* SET LCP ACTIVE STATUS BEFORE STARTING A LOCAL CHECKPOINT. */ +/*************************************************************************/ +void Dbdih::setLcpActiveStatusStart(Signal* signal) +{ + NodeRecordPtr nodePtr; + + c_lcpState.m_participatingLQH.clear(); + c_lcpState.m_participatingDIH.clear(); + + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + ptrAss(nodePtr, nodeRecord); +#if 0 + if(nodePtr.p->nodeStatus != NodeRecord::NOT_IN_CLUSTER){ + infoEvent("Node %d nodeStatus=%d activeStatus=%d copyCompleted=%d lcp=%d", + nodePtr.i, + nodePtr.p->nodeStatus, + nodePtr.p->activeStatus, + nodePtr.p->copyCompleted, + nodePtr.p->m_inclDihLcp); + } +#endif + if(nodePtr.p->nodeStatus == NodeRecord::ALIVE && nodePtr.p->m_inclDihLcp){ + jam(); + c_lcpState.m_participatingDIH.set(nodePtr.i); + } + + if ((nodePtr.p->nodeStatus == NodeRecord::ALIVE) && + (nodePtr.p->copyCompleted)) { + switch (nodePtr.p->activeStatus) { + case Sysfile::NS_Active: + jam(); + /*-------------------------------------------------------------------*/ + // The normal case. Starting a LCP for a started node which hasn't + // missed the previous LCP. + /*-------------------------------------------------------------------*/ + c_lcpState.m_participatingLQH.set(nodePtr.i); + break; + case Sysfile::NS_ActiveMissed_1: + jam(); + /*-------------------------------------------------------------------*/ + // The node is starting up and is participating in a local checkpoint + // as the final phase of the start-up. We can still use the checkpoints + // on the node after a system restart. + /*-------------------------------------------------------------------*/ + c_lcpState.m_participatingLQH.set(nodePtr.i); + break; + case Sysfile::NS_ActiveMissed_2: + jam(); + /*-------------------------------------------------------------------*/ + // The node is starting up and is participating in a local checkpoint + // as the final phase of the start-up. We have missed so + // many checkpoints that we no longer can use this node to + // recreate fragments from disk. + // It must be taken over with the copy fragment process after a system + // crash. We indicate this by setting the active status to TAKE_OVER. + /*-------------------------------------------------------------------*/ + nodePtr.p->activeStatus = Sysfile::NS_TakeOver; + //break; // Fall through + case Sysfile::NS_TakeOver:{ + TakeOverRecordPtr takeOverPtr; + jam(); + /*-------------------------------------------------------------------*/ + /* THIS NODE IS CURRENTLY TAKING OVER A FAILED NODE. */ + /*-------------------------------------------------------------------*/ + takeOverPtr.i = findTakeOver(nodePtr.i); + if (takeOverPtr.i != RNIL) { + jam(); + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + if (takeOverPtr.p->toMasterStatus == TakeOverRecord::WAIT_LCP) { + jam(); + /*--------------------------------------------------------------- + * ALL THE INFORMATION HAVE BEEN REPLICATED TO THE NEW + * NODE AND WE ARE ONLY WAITING FOR A LOCAL CHECKPOINT TO BE + * PERFORMED ON THE NODE TO SET ITS STATUS TO ACTIVE. + */ + infoEvent("Node %d is WAIT_LCP including in LCP", nodePtr.i); + c_lcpState.m_participatingLQH.set(nodePtr.i); + }//if + }//if + break; + } + default: + jam(); + /*empty*/; + break; + }//switch + } else { + switch (nodePtr.p->activeStatus) { + case Sysfile::NS_Active: + jam(); + nodePtr.p->activeStatus = Sysfile::NS_ActiveMissed_1; + break; + case Sysfile::NS_ActiveMissed_1: + jam(); + nodePtr.p->activeStatus = Sysfile::NS_ActiveMissed_2; + break; + case Sysfile::NS_ActiveMissed_2: + jam(); + if ((nodePtr.p->nodeStatus == NodeRecord::ALIVE) && + (!nodePtr.p->copyCompleted)) { + jam(); + /*-----------------------------------------------------------------*/ + // The node is currently starting up and has not completed the + // copy phase. + // It will thus be in the TAKE_OVER state. + /*-----------------------------------------------------------------*/ + ndbrequire(findTakeOver(nodePtr.i) != RNIL); + nodePtr.p->activeStatus = Sysfile::NS_TakeOver; + } else { + jam(); + /*-----------------------------------------------------------------*/ + /* THE NODE IS ACTIVE AND HAS NOT COMPLETED ANY OF THE LAST 3 + * CHECKPOINTS */ + /* WE MUST TAKE IT OUT OF ACTION AND START A NEW NODE TO TAKE OVER.*/ + /*-----------------------------------------------------------------*/ + nodePtr.p->activeStatus = Sysfile::NS_NotActive_NotTakenOver; + }//if + break; + case Sysfile::NS_TakeOver: + jam(); + break; + default: + jam(); + /*empty*/; + break; + }//switch + }//if + }//for + if (isMaster()) { + jam(); + checkStartTakeOver(signal); + setNodeRestartInfoBits(); + }//if +}//Dbdih::setLcpActiveStatusStart() + +/*************************************************************************/ +/* SET NODE ACTIVE STATUS AT SYSTEM RESTART AND WHEN UPDATED BY MASTER */ +/*************************************************************************/ +void Dbdih::setNodeActiveStatus() +{ + NodeRecordPtr snaNodeptr; + + for (snaNodeptr.i = 1; snaNodeptr.i < MAX_NDB_NODES; snaNodeptr.i++) { + ptrAss(snaNodeptr, nodeRecord); + const Uint32 tsnaNodeBits = Sysfile::getNodeStatus(snaNodeptr.i, + SYSFILE->nodeStatus); + switch (tsnaNodeBits) { + case Sysfile::NS_Active: + jam(); + snaNodeptr.p->activeStatus = Sysfile::NS_Active; + break; + case Sysfile::NS_ActiveMissed_1: + jam(); + snaNodeptr.p->activeStatus = Sysfile::NS_ActiveMissed_1; + break; + case Sysfile::NS_ActiveMissed_2: + jam(); + snaNodeptr.p->activeStatus = Sysfile::NS_ActiveMissed_2; + break; + case Sysfile::NS_TakeOver: + jam(); + snaNodeptr.p->activeStatus = Sysfile::NS_TakeOver; + break; + case Sysfile::NS_HotSpare: + jam(); + snaNodeptr.p->activeStatus = Sysfile::NS_HotSpare; + break; + case Sysfile::NS_NotActive_NotTakenOver: + jam(); + snaNodeptr.p->activeStatus = Sysfile::NS_NotActive_NotTakenOver; + break; + case Sysfile::NS_NotDefined: + jam(); + snaNodeptr.p->activeStatus = Sysfile::NS_NotDefined; + break; + default: + ndbrequire(false); + break; + }//switch + }//for +}//Dbdih::setNodeActiveStatus() + +/***************************************************************************/ +/* SET THE NODE GROUP BASED ON THE RESTART INFORMATION OR AS SET BY MASTER */ +/***************************************************************************/ +void Dbdih::setNodeGroups() +{ + NodeGroupRecordPtr NGPtr; + NodeRecordPtr sngNodeptr; + Uint32 Ti; + + for (Ti = 0; Ti < MAX_NDB_NODES; Ti++) { + NGPtr.i = Ti; + ptrAss(NGPtr, nodeGroupRecord); + NGPtr.p->nodeCount = 0; + }//for + for (sngNodeptr.i = 1; sngNodeptr.i < MAX_NDB_NODES; sngNodeptr.i++) { + ptrAss(sngNodeptr, nodeRecord); + switch (sngNodeptr.p->activeStatus) { + case Sysfile::NS_Active: + case Sysfile::NS_ActiveMissed_1: + case Sysfile::NS_ActiveMissed_2: + case Sysfile::NS_NotActive_NotTakenOver: + case Sysfile::NS_TakeOver: + jam(); + sngNodeptr.p->nodeGroup = Sysfile::getNodeGroup(sngNodeptr.i, + SYSFILE->nodeGroups); + NGPtr.i = sngNodeptr.p->nodeGroup; + ptrCheckGuard(NGPtr, MAX_NDB_NODES, nodeGroupRecord); + NGPtr.p->nodesInGroup[NGPtr.p->nodeCount] = sngNodeptr.i; + NGPtr.p->nodeCount++; + break; + case Sysfile::NS_HotSpare: + case Sysfile::NS_NotDefined: + jam(); + sngNodeptr.p->nodeGroup = ZNIL; + break; + default: + ndbrequire(false); + return; + break; + }//switch + }//for + cnoOfNodeGroups = 0; + for (Ti = 0; Ti < MAX_NDB_NODES; Ti++) { + jam(); + NGPtr.i = Ti; + ptrAss(NGPtr, nodeGroupRecord); + if (NGPtr.p->nodeCount != 0) { + jam(); + cnoOfNodeGroups++; + }//if + }//for + cnoHotSpare = csystemnodes - (cnoOfNodeGroups * cnoReplicas); +}//Dbdih::setNodeGroups() + +/*************************************************************************/ +/* SET NODE INFORMATION AFTER RECEIVING RESTART INFORMATION FROM MASTER. */ +/* WE TAKE THE OPPORTUNITY TO SYNCHRONISE OUR DATA WITH THE MASTER. IT */ +/* IS ONLY THE MASTER THAT WILL ACT ON THIS DATA. WE WILL KEEP THEM */ +/* UPDATED FOR THE CASE WHEN WE HAVE TO BECOME MASTER. */ +/*************************************************************************/ +void Dbdih::setNodeInfo(Signal* signal) +{ + setNodeActiveStatus(); + setNodeGroups(); + sendHOT_SPAREREP(signal); +}//Dbdih::setNodeInfo() + +/*************************************************************************/ +// Keep also DBDICT informed about the Hot Spare situation in the cluster. +/*************************************************************************/ +void Dbdih::sendHOT_SPAREREP(Signal* signal) +{ + NodeRecordPtr locNodeptr; + Uint32 Ti = 0; + HotSpareRep * const hotSpare = (HotSpareRep*)&signal->theData[0]; + NodeBitmask::clear(hotSpare->theHotSpareNodes); + for (locNodeptr.i = 1; locNodeptr.i < MAX_NDB_NODES; locNodeptr.i++) { + ptrAss(locNodeptr, nodeRecord); + switch (locNodeptr.p->activeStatus) { + case Sysfile::NS_HotSpare: + jam(); + NodeBitmask::set(hotSpare->theHotSpareNodes, locNodeptr.i); + Ti++; + break; + default: + jam(); + break; + }//switch + }//for + hotSpare->noHotSpareNodes = Ti; + sendSignal(DBDICT_REF, GSN_HOT_SPAREREP, + signal, HotSpareRep::SignalLength, JBB); +}//Dbdih::sendHOT_SPAREREP() + +/*************************************************************************/ +/* SET LCP ACTIVE STATUS FOR ALL NODES BASED ON THE INFORMATION IN */ +/* THE RESTART INFORMATION. */ +/*************************************************************************/ +#if 0 +void Dbdih::setNodeLcpActiveStatus() +{ + c_lcpState.m_lcpActiveStatus.clear(); + for (Uint32 i = 1; i < MAX_NDB_NODES; i++) { + if (NodeBitmask::get(SYSFILE->lcpActive, i)) { + jam(); + c_lcpState.m_lcpActiveStatus.set(i); + }//if + }//for +}//Dbdih::setNodeLcpActiveStatus() +#endif + +/*************************************************************************/ +/* SET THE RESTART INFO BITS BASED ON THE NODES ACTIVE STATUS. */ +/*************************************************************************/ +void Dbdih::setNodeRestartInfoBits() +{ + NodeRecordPtr nodePtr; + Uint32 tsnrNodeGroup; + Uint32 tsnrNodeActiveStatus; + + for(int i = 1; i < MAX_NDB_NODES; i++){ + Sysfile::setNodeStatus(i, SYSFILE->nodeStatus, Sysfile::NS_Active); + }//for + for(Uint32 i = 1; i < Sysfile::NODE_GROUPS_SIZE; i++){ + SYSFILE->nodeGroups[i] = 0; + }//for + NdbNodeBitmask::clear(SYSFILE->lcpActive); + + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + ptrAss(nodePtr, nodeRecord); + switch (nodePtr.p->activeStatus) { + case Sysfile::NS_Active: + jam(); + tsnrNodeActiveStatus = Sysfile::NS_Active; + break; + case Sysfile::NS_ActiveMissed_1: + jam(); + tsnrNodeActiveStatus = Sysfile::NS_ActiveMissed_1; + break; + case Sysfile::NS_ActiveMissed_2: + jam(); + tsnrNodeActiveStatus = Sysfile::NS_ActiveMissed_2; + break; + case Sysfile::NS_HotSpare: + jam(); + tsnrNodeActiveStatus = Sysfile::NS_HotSpare; + break; + case Sysfile::NS_TakeOver: + jam(); + tsnrNodeActiveStatus = Sysfile::NS_TakeOver; + break; + case Sysfile::NS_NotActive_NotTakenOver: + jam(); + tsnrNodeActiveStatus = Sysfile::NS_NotActive_NotTakenOver; + break; + case Sysfile::NS_NotDefined: + jam(); + tsnrNodeActiveStatus = Sysfile::NS_NotDefined; + break; + default: + ndbrequire(false); + break; + }//switch + Sysfile::setNodeStatus(nodePtr.i, SYSFILE->nodeStatus, + tsnrNodeActiveStatus); + if (nodePtr.p->nodeGroup == ZNIL) { + jam(); + tsnrNodeGroup = NO_NODE_GROUP_ID; + } else { + jam(); + tsnrNodeGroup = nodePtr.p->nodeGroup; + }//if + Sysfile::setNodeGroup(nodePtr.i, SYSFILE->nodeGroups, tsnrNodeGroup); + if (c_lcpState.m_participatingLQH.get(nodePtr.i)){ + jam(); + NodeBitmask::set(SYSFILE->lcpActive, nodePtr.i); + }//if + }//for +}//Dbdih::setNodeRestartInfoBits() + +/*************************************************************************/ +/* START THE GLOBAL CHECKPOINT PROTOCOL IN MASTER AT START-UP */ +/*************************************************************************/ +void Dbdih::startGcp(Signal* signal) +{ + cgcpStatus = GCP_READY; + coldGcpStatus = cgcpStatus; + coldGcpId = cnewgcp; + cgcpSameCounter = 0; + signal->theData[0] = DihContinueB::ZSTART_GCP; + signal->theData[1] = 0; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); + signal->theData[0] = DihContinueB::ZCHECK_GCP_STOP; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 1); +}//Dbdih::startGcp() + +void Dbdih::updateNodeInfo(FragmentstorePtr fragPtr) +{ + ReplicaRecordPtr replicatePtr; + Uint32 index = 0; + replicatePtr.i = fragPtr.p->storedReplicas; + do { + jam(); + ptrCheckGuard(replicatePtr, creplicaFileSize, replicaRecord); + ndbrequire(index < MAX_REPLICAS); + fragPtr.p->activeNodes[index] = replicatePtr.p->procNode; + index++; + replicatePtr.i = replicatePtr.p->nextReplica; + } while (replicatePtr.i != RNIL); + fragPtr.p->fragReplicas = index; + + /* ----------------------------------------------------------------------- */ + // We switch primary to the preferred primary if the preferred primary is + // in the list. + /* ----------------------------------------------------------------------- */ + const Uint32 prefPrim = fragPtr.p->preferredPrimary; + for (Uint32 i = 1; i < index; i++) { + jam(); + ndbrequire(i < MAX_REPLICAS); + if (fragPtr.p->activeNodes[i] == prefPrim){ + jam(); + Uint32 switchNode = fragPtr.p->activeNodes[0]; + fragPtr.p->activeNodes[0] = prefPrim; + fragPtr.p->activeNodes[i] = switchNode; + break; + }//if + }//for +}//Dbdih::updateNodeInfo() + +void Dbdih::writeFragment(RWFragment* wf, FragmentstorePtr fragPtr) +{ + writePageWord(wf, wf->fragId); + writePageWord(wf, fragPtr.p->preferredPrimary); + writePageWord(wf, fragPtr.p->noStoredReplicas); + writePageWord(wf, fragPtr.p->noOldStoredReplicas); + writePageWord(wf, fragPtr.p->distributionKey); +}//Dbdih::writeFragment() + +void Dbdih::writePageWord(RWFragment* wf, Uint32 dataWord) +{ + if (wf->wordIndex >= 2048) { + jam(); + ndbrequire(wf->wordIndex == 2048); + allocpage(wf->rwfPageptr); + wf->wordIndex = 32; + wf->pageIndex++; + ndbrequire(wf->pageIndex < 8); + wf->rwfTabPtr.p->pageRef[wf->pageIndex] = wf->rwfPageptr.i; + wf->rwfTabPtr.p->noPages++; + }//if + wf->rwfPageptr.p->word[wf->wordIndex] = dataWord; + wf->wordIndex++; +}//Dbdih::writePageWord() + +void Dbdih::writeReplicas(RWFragment* wf, Uint32 replicaStartIndex) +{ + ReplicaRecordPtr wfReplicaPtr; + wfReplicaPtr.i = replicaStartIndex; + while (wfReplicaPtr.i != RNIL) { + jam(); + ptrCheckGuard(wfReplicaPtr, creplicaFileSize, replicaRecord); + writePageWord(wf, wfReplicaPtr.p->procNode); + writePageWord(wf, wfReplicaPtr.p->initialGci); + writePageWord(wf, wfReplicaPtr.p->noCrashedReplicas); + writePageWord(wf, wfReplicaPtr.p->nextLcp); + for (Uint32 i = 0; i < MAX_LCP_STORED; i++) { + writePageWord(wf, wfReplicaPtr.p->maxGciCompleted[i]); + writePageWord(wf, wfReplicaPtr.p->maxGciStarted[i]); + writePageWord(wf, wfReplicaPtr.p->lcpId[i]); + writePageWord(wf, wfReplicaPtr.p->lcpStatus[i]); + }//if + for (Uint32 i = 0; i < 8; i++) { + writePageWord(wf, wfReplicaPtr.p->createGci[i]); + writePageWord(wf, wfReplicaPtr.p->replicaLastGci[i]); + }//if + + wfReplicaPtr.i = wfReplicaPtr.p->nextReplica; + }//while +}//Dbdih::writeReplicas() + +void Dbdih::writeRestorableGci(Signal* signal, FileRecordPtr filePtr) +{ + for (Uint32 i = 0; i < Sysfile::SYSFILE_SIZE32; i++) { + sysfileDataToFile[i] = sysfileData[i]; + }//for + signal->theData[0] = filePtr.p->fileRef; + signal->theData[1] = reference(); + signal->theData[2] = filePtr.i; + signal->theData[3] = ZLIST_OF_PAIRS_SYNCH; + signal->theData[4] = ZVAR_NO_CRESTART_INFO_TO_FILE; + signal->theData[5] = 1; /* AMOUNT OF PAGES */ + signal->theData[6] = 0; /* MEMORY PAGE = 0 SINCE COMMON STORED VARIABLE */ + signal->theData[7] = 0; + sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal, 8, JBA); +}//Dbdih::writeRestorableGci() + +void Dbdih::writeTabfile(Signal* signal, TabRecord* tab, FileRecordPtr filePtr) +{ + signal->theData[0] = filePtr.p->fileRef; + signal->theData[1] = reference(); + signal->theData[2] = filePtr.i; + signal->theData[3] = ZLIST_OF_PAIRS; + signal->theData[4] = ZVAR_NO_WORD; + signal->theData[5] = tab->noPages; + for (Uint32 i = 0; i < tab->noPages; i++) { + jam(); + signal->theData[6 + (2 * i)] = tab->pageRef[i]; + signal->theData[7 + (2 * i)] = i; + }//for + Uint32 length = 6 + (2 * tab->noPages); + sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal, length, JBA); +}//Dbdih::writeTabfile() + +void Dbdih::execDEBUG_SIG(Signal* signal) +{ + signal = signal; //Avoid compiler warnings +}//Dbdih::execDEBUG_SIG() + +void +Dbdih::execDUMP_STATE_ORD(Signal* signal) +{ + DumpStateOrd * const & dumpState = (DumpStateOrd *)&signal->theData[0]; + if (dumpState->args[0] == DumpStateOrd::DihDumpNodeRestartInfo) { + infoEvent("c_nodeStartMaster.blockLcp = %d, c_nodeStartMaster.blockGcp = %d, c_nodeStartMaster.wait = %d", + c_nodeStartMaster.blockLcp, c_nodeStartMaster.blockGcp, c_nodeStartMaster.wait); + infoEvent("cstartGcpNow = %d, cgcpStatus = %d", + cstartGcpNow, cgcpStatus); + infoEvent("cfirstVerifyQueue = %d, cverifyQueueCounter = %d", + cfirstVerifyQueue, cverifyQueueCounter); + infoEvent("cgcpOrderBlocked = %d, cgcpStartCounter = %d", + cgcpOrderBlocked, cgcpStartCounter); + }//if + if (dumpState->args[0] == DumpStateOrd::DihDumpNodeStatusInfo) { + NodeRecordPtr localNodePtr; + infoEvent("Printing nodeStatus of all nodes"); + for (localNodePtr.i = 1; localNodePtr.i < MAX_NDB_NODES; localNodePtr.i++) { + ptrAss(localNodePtr, nodeRecord); + if (localNodePtr.p->nodeStatus != NodeRecord::NOT_IN_CLUSTER) { + infoEvent("Node = %d has status = %d", + localNodePtr.i, localNodePtr.p->nodeStatus); + }//if + }//for + }//if + + if (dumpState->args[0] == DumpStateOrd::DihPrintFragmentation){ + infoEvent("Printing fragmentation of all tables --"); + for(Uint32 i = 0; itabStatus != TabRecord::TS_ACTIVE) + continue; + + for(Uint32 j = 0; j < tabPtr.p->totalfragments; j++){ + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, j, fragPtr); + + Uint32 nodeOrder[MAX_REPLICAS]; + const Uint32 noOfReplicas = extractNodeInfo(fragPtr.p, nodeOrder); + char buf[100]; + snprintf(buf, sizeof(buf), " Table %d Fragment %d - ", tabPtr.i, j); + for(Uint32 k = 0; k < noOfReplicas; k++){ + char tmp[100]; + snprintf(tmp, sizeof(tmp), "%d ", nodeOrder[k]); + strcat(buf, tmp); + } + infoEvent(buf); + } + } + } + + if (signal->theData[0] == 7000) { + infoEvent("ctimer = %d, cgcpParticipantState = %d, cgcpStatus = %d", + c_lcpState.ctimer, cgcpParticipantState, cgcpStatus); + infoEvent("coldGcpStatus = %d, coldGcpId = %d, cmasterState = %d", + coldGcpStatus, coldGcpId, cmasterState); + infoEvent("cmasterTakeOverNode = %d, ctcCounter = %d", + cmasterTakeOverNode, c_lcpState.ctcCounter); + }//if + if (signal->theData[0] == 7001) { + infoEvent("c_lcpState.keepGci = %d", + c_lcpState.keepGci); + infoEvent("c_lcpState.lcpStatus = %d, clcpStartGcp = %d", + c_lcpState.lcpStatus, + c_lcpState.lcpStartGcp); + infoEvent("cgcpStartCounter = %d, cimmediateLcpStart = %d", + cgcpStartCounter, c_lcpState.immediateLcpStart); + }//if + if (signal->theData[0] == 7002) { + infoEvent("cnoOfActiveTables = %d, cgcpDelay = %d", + cnoOfActiveTables, cgcpDelay); + infoEvent("cdictblockref = %d, cfailurenr = %d", + cdictblockref, cfailurenr); + infoEvent("con_lineNodes = %d, reference() = %d, creceivedfrag = %d", + con_lineNodes, reference(), creceivedfrag); + }//if + if (signal->theData[0] == 7003) { + infoEvent("cfirstAliveNode = %d, cgckptflag = %d", + cfirstAliveNode, cgckptflag); + infoEvent("clocallqhblockref = %d, clocaltcblockref = %d, cgcpOrderBlocked = %d", + clocallqhblockref, clocaltcblockref, cgcpOrderBlocked); + infoEvent("cstarttype = %d, csystemnodes = %d, currentgcp = %d", + cstarttype, csystemnodes, currentgcp); + }//if + if (signal->theData[0] == 7004) { + infoEvent("cmasterdihref = %d, cownNodeId = %d, cnewgcp = %d", + cmasterdihref, cownNodeId, cnewgcp); + infoEvent("cndbStartReqBlockref = %d, cremainingfrags = %d", + cndbStartReqBlockref, cremainingfrags); + infoEvent("cntrlblockref = %d, cgcpSameCounter = %d, coldgcp = %d", + cntrlblockref, cgcpSameCounter, coldgcp); + }//if + if (signal->theData[0] == 7005) { + infoEvent("crestartGci = %d", + crestartGci); + }//if + if (signal->theData[0] == 7006) { + infoEvent("clcpDelay = %d, cgcpMasterTakeOverState = %d", + c_lcpState.clcpDelay, cgcpMasterTakeOverState); + infoEvent("cmasterNodeId = %d", cmasterNodeId); + infoEvent("cnoHotSpare = %d, c_nodeStartMaster.startNode = %d, c_nodeStartMaster.wait = %d", + cnoHotSpare, c_nodeStartMaster.startNode, c_nodeStartMaster.wait); + }//if + if (signal->theData[0] == 7007) { + infoEvent("c_nodeStartMaster.failNr = %d, c_nodeStartMaster.ndbVersion = %d", + c_nodeStartMaster.failNr, c_nodeStartMaster.ndbVersion); + infoEvent("c_nodeStartMaster.startInfoErrorCode = %d", + c_nodeStartMaster.startInfoErrorCode); + infoEvent("c_nodeStartMaster.blockLcp = %d, c_nodeStartMaster.blockGcp = %d", + c_nodeStartMaster.blockLcp, c_nodeStartMaster.blockGcp); + }//if + if (signal->theData[0] == 7008) { + infoEvent("cfirstDeadNode = %d, cstartPhase = %d, cnoReplicas = %d", + cfirstDeadNode, cstartPhase, cnoReplicas); + infoEvent("cwaitLcpSr = %d",cwaitLcpSr); + }//if + if (signal->theData[0] == 7009) { + infoEvent("ccalcOldestRestorableGci = %d, cnoOfNodeGroups = %d", + c_lcpState.oldestRestorableGci, cnoOfNodeGroups); + infoEvent("cstartGcpNow = %d", + cstartGcpNow); + infoEvent("crestartGci = %d", + crestartGci); + }//if + if (signal->theData[0] == 7010) { + infoEvent("cminHotSpareNodes = %d, c_lcpState.lcpStatusUpdatedPlace = %d, cLcpStart = %d", + cminHotSpareNodes, c_lcpState.lcpStatusUpdatedPlace, c_lcpState.lcpStart); + infoEvent("c_blockCommit = %d, c_blockCommitNo = %d", + c_blockCommit, c_blockCommitNo); + }//if + if (signal->theData[0] == 7011){ + infoEvent("c_COPY_GCIREQ_Counter = %s", + c_COPY_GCIREQ_Counter.getText()); + infoEvent("c_COPY_TABREQ_Counter = %s", + c_COPY_TABREQ_Counter.getText()); + infoEvent("c_CREATE_FRAGREQ_Counter = %s", + c_CREATE_FRAGREQ_Counter.getText()); + infoEvent("c_DIH_SWITCH_REPLICA_REQ_Counter = %s", + c_DIH_SWITCH_REPLICA_REQ_Counter.getText()); + infoEvent("c_EMPTY_LCP_REQ_Counter = %s",c_EMPTY_LCP_REQ_Counter.getText()); + infoEvent("c_END_TOREQ_Counter = %s", c_END_TOREQ_Counter.getText()); + infoEvent("c_GCP_COMMIT_Counter = %s", c_GCP_COMMIT_Counter.getText()); + infoEvent("c_GCP_PREPARE_Counter = %s", c_GCP_PREPARE_Counter.getText()); + infoEvent("c_GCP_SAVEREQ_Counter = %s", c_GCP_SAVEREQ_Counter.getText()); + infoEvent("c_INCL_NODEREQ_Counter = %s", c_INCL_NODEREQ_Counter.getText()); + infoEvent("c_MASTER_GCPREQ_Counter = %s", + c_MASTER_GCPREQ_Counter.getText()); + infoEvent("c_MASTER_LCPREQ_Counter = %s", + c_MASTER_LCPREQ_Counter.getText()); + infoEvent("c_START_INFOREQ_Counter = %s", + c_START_INFOREQ_Counter.getText()); + infoEvent("c_START_RECREQ_Counter = %s", c_START_RECREQ_Counter.getText()); + infoEvent("c_START_TOREQ_Counter = %s", c_START_TOREQ_Counter.getText()); + infoEvent("c_STOP_ME_REQ_Counter = %s", c_STOP_ME_REQ_Counter.getText()); + infoEvent("c_TC_CLOPSIZEREQ_Counter = %s", + c_TC_CLOPSIZEREQ_Counter.getText()); + infoEvent("c_TCGETOPSIZEREQ_Counter = %s", + c_TCGETOPSIZEREQ_Counter.getText()); + infoEvent("c_UPDATE_TOREQ_Counter = %s", c_UPDATE_TOREQ_Counter.getText()); + } + + if(signal->theData[0] == 7012){ + char buf[c_lcpState.m_participatingDIH.TextLength+1]; + infoEvent("ParticipatingDIH = %s", c_lcpState.m_participatingDIH.getText(buf)); + infoEvent("ParticipatingLQH = %s", c_lcpState.m_participatingLQH.getText(buf)); + infoEvent("m_LCP_COMPLETE_REP_Counter_DIH = %s", + c_lcpState.m_LCP_COMPLETE_REP_Counter_DIH.getText()); + infoEvent("m_LCP_COMPLETE_REP_Counter_LQH = %s", + c_lcpState.m_LCP_COMPLETE_REP_Counter_LQH.getText()); + infoEvent("m_LAST_LCP_FRAG_ORD = %s", + c_lcpState.m_LAST_LCP_FRAG_ORD.getText()); + infoEvent("m_LCP_COMPLETE_REP_From_Master_Received = %d", + c_lcpState.m_LCP_COMPLETE_REP_From_Master_Received); + + NodeRecordPtr nodePtr; + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRecord); + if(nodePtr.p->nodeStatus == NodeRecord::ALIVE){ + + for(Uint32 i = 0; inoOfStartedChkpt; i++){ + infoEvent("Node %d: started: table=%d fragment=%d replica=%d", + nodePtr.i, + nodePtr.p->startedChkpt[i].tableId, + nodePtr.p->startedChkpt[i].fragId, + nodePtr.p->startedChkpt[i].replicaPtr); + } + + for(Uint32 i = 0; inoOfQueuedChkpt; i++){ + infoEvent("Node %d: queued: table=%d fragment=%d replica=%d", + nodePtr.i, + nodePtr.p->queuedChkpt[i].tableId, + nodePtr.p->queuedChkpt[i].fragId, + nodePtr.p->queuedChkpt[i].replicaPtr); + } + } + } + } + + if(dumpState->args[0] == DumpStateOrd::DihDumpLCPState){ + infoEvent("-- Node %d LCP STATE --", getOwnNodeId()); + infoEvent("lcpStatus = %d (update place = %d) ", + c_lcpState.lcpStatus, c_lcpState.lcpStatusUpdatedPlace); + infoEvent + ("lcpStart = %d lcpStartGcp = %d keepGci = %d oldestRestorable = %d", + c_lcpState.lcpStart, c_lcpState.lcpStartGcp, + c_lcpState.keepGci, c_lcpState.oldestRestorableGci); + + infoEvent + ("immediateLcpStart = %d masterLcpNodeId = %d", + c_lcpState.immediateLcpStart, + refToNode(c_lcpState.m_masterLcpDihRef)); + infoEvent("-- Node %d LCP STATE --", getOwnNodeId()); + } + + if(dumpState->args[0] == DumpStateOrd::DihDumpLCPMasterTakeOver){ + infoEvent("-- Node %d LCP MASTER TAKE OVER STATE --", getOwnNodeId()); + infoEvent + ("c_lcpMasterTakeOverState.state = %d updatePlace = %d failedNodeId = %d", + c_lcpMasterTakeOverState.state, + c_lcpMasterTakeOverState.updatePlace, + c_lcpMasterTakeOverState.failedNodeId); + + infoEvent("c_lcpMasterTakeOverState.minTableId = %u minFragId = %u", + c_lcpMasterTakeOverState.minTableId, + c_lcpMasterTakeOverState.minFragId); + + infoEvent("-- Node %d LCP MASTER TAKE OVER STATE --", getOwnNodeId()); + } + + if (signal->theData[0] == 7015){ + for(Uint32 i = 0; itabStatus != TabRecord::TS_ACTIVE) + continue; + + infoEvent + ("Table %d: TabCopyStatus: %d TabUpdateStatus: %d TabLcpStatus: %d", + tabPtr.i, + tabPtr.p->tabCopyStatus, + tabPtr.p->tabUpdateState, + tabPtr.p->tabLcpStatus); + + FragmentstorePtr fragPtr; + for (Uint32 fid = 0; fid < tabPtr.p->totalfragments; fid++) { + jam(); + getFragstore(tabPtr.p, fid, fragPtr); + + char buf[100], buf2[100]; + snprintf(buf, sizeof(buf), " Fragment %d: noLcpReplicas==%d ", + fid, fragPtr.p->noLcpReplicas); + + Uint32 num=0; + ReplicaRecordPtr replicaPtr; + replicaPtr.i = fragPtr.p->storedReplicas; + do { + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + snprintf(buf2, sizeof(buf2), "%s %d(on %d)=%d(%s)", + buf, num, + replicaPtr.p->procNode, + replicaPtr.p->lcpIdStarted, + replicaPtr.p->lcpOngoingFlag ? "Ongoing" : "Idle"); + snprintf(buf, sizeof(buf), "%s", buf2); + + num++; + replicaPtr.i = replicaPtr.p->nextReplica; + } while (replicaPtr.i != RNIL); + infoEvent(buf); + } + } + } + + if(dumpState->args[0] == DumpStateOrd::EnableUndoDelayDataWrite){ + ndbout << "Dbdih:: delay write of datapages for table = " + << dumpState->args[1]<< endl; + // Send this dump to ACC and TUP + EXECUTE_DIRECT(DBACC, GSN_DUMP_STATE_ORD, signal, 2); + EXECUTE_DIRECT(DBTUP, GSN_DUMP_STATE_ORD, signal, 2); + + // Start immediate LCP + c_lcpState.ctimer += (1 << c_lcpState.clcpDelay); + return; + } + + if (signal->theData[0] == DumpStateOrd::DihAllAllowNodeStart) { + for (Uint32 i = 1; i < MAX_NDB_NODES; i++) + setAllowNodeStart(i, true); + return; + }//if + if (signal->theData[0] == DumpStateOrd::DihMinTimeBetweenLCP) { + // Set time between LCP to min value + ndbout << "Set time between LCP to min value" << endl; + c_lcpState.clcpDelay = 0; // TimeBetweenLocalCheckpoints.min + return; + } + if (signal->theData[0] == DumpStateOrd::DihMaxTimeBetweenLCP) { + // Set time between LCP to max value + ndbout << "Set time between LCP to max value" << endl; + c_lcpState.clcpDelay = 31; // TimeBetweenLocalCheckpoints.max + return; + } + + if(dumpState->args[0] == 7098){ + if(signal->length() == 3){ + jam(); + infoEvent("startLcpRoundLoopLab(tabel=%d, fragment=%d)", + signal->theData[1], signal->theData[2]); + startLcpRoundLoopLab(signal, signal->theData[1], signal->theData[2]); + return; + } else { + infoEvent("Invalid no of arguments to 7098 - startLcpRoundLoopLab -" + " expected 2 (tableId, fragmentId)"); + } + } + + if(dumpState->args[0] == DumpStateOrd::DihStartLcpImmediately){ + c_lcpState.ctimer += (1 << c_lcpState.clcpDelay); + return; + } +}//Dbdih::execDUMP_STATE_ORD() + +void +Dbdih::execPREP_DROP_TAB_REQ(Signal* signal){ + jamEntry(); + + PrepDropTabReq* req = (PrepDropTabReq*)signal->getDataPtr(); + + TabRecordPtr tabPtr; + tabPtr.i = req->tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + + Uint32 senderRef = req->senderRef; + Uint32 senderData = req->senderData; + + PrepDropTabRef::ErrorCode err = PrepDropTabRef::OK; + { /** + * Check table state + */ + bool ok = false; + switch(tabPtr.p->tabStatus){ + case TabRecord::TS_IDLE: + ok = true; + jam(); + err = PrepDropTabRef::NoSuchTable; + break; + case TabRecord::TS_DROPPING: + ok = true; + jam(); + err = PrepDropTabRef::PrepDropInProgress; + break; + case TabRecord::TS_CREATING: + jam(); + ok = true; + break; + case TabRecord::TS_ACTIVE: + ok = true; + jam(); + break; + } + ndbrequire(ok); + } + + if(err != PrepDropTabRef::OK){ + jam(); + PrepDropTabRef* ref = (PrepDropTabRef*)signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = senderData; + ref->tableId = tabPtr.i; + ref->errorCode = err; + sendSignal(senderRef, GSN_PREP_DROP_TAB_REF, signal, + PrepDropTabRef::SignalLength, JBB); + return; + } + + tabPtr.p->tabStatus = TabRecord::TS_DROPPING; + tabPtr.p->m_prepDropTab.senderRef = senderRef; + tabPtr.p->m_prepDropTab.senderData = senderData; + + if(isMaster()){ + /** + * Remove from queue + */ + NodeRecordPtr nodePtr; + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRecord); + if (c_lcpState.m_participatingLQH.get(nodePtr.i)){ + + Uint32 index = 0; + Uint32 count = nodePtr.p->noOfQueuedChkpt; + while(index < count){ + if(nodePtr.p->queuedChkpt[index].tableId == tabPtr.i){ + jam(); + // ndbout_c("Unqueuing %d", index); + + count--; + for(Uint32 i = index; iqueuedChkpt[i] = nodePtr.p->queuedChkpt[i + 1]; + } + } else { + index++; + } + } + nodePtr.p->noOfQueuedChkpt = count; + } + } + } + + { /** + * Check table lcp state + */ + + bool ok = false; + switch(tabPtr.p->tabLcpStatus){ + case TabRecord::TLS_COMPLETED: + case TabRecord::TLS_WRITING_TO_FILE: + ok = true; + jam(); + break; + return; + case TabRecord::TLS_ACTIVE: + ok = true; + jam(); + + tabPtr.p->tabLcpStatus = TabRecord::TLS_COMPLETED; + + /** + * First check if all fragments are done + */ + if(checkLcpAllTablesDoneInLqh()){ + jam(); + + ndbout_c("This is the last table"); + + /** + * Then check if saving of tab info is done for all tables + */ + LcpStatus a = c_lcpState.lcpStatus; + checkLcpCompletedLab(signal); + + if(a != c_lcpState.lcpStatus){ + ndbout_c("And all tables are written to already written disk"); + } + } + break; + } + ndbrequire(ok); + } + + { /** + * Send WaitDropTabReq to all LQH + */ + WaitDropTabReq * req = (WaitDropTabReq*)signal->getDataPtrSend(); + req->tableId = tabPtr.i; + req->senderRef = reference(); + + NodeRecordPtr nodePtr; + nodePtr.i = cfirstAliveNode; + tabPtr.p->m_prepDropTab.waitDropTabCount.clearWaitingFor(); + while(nodePtr.i != RNIL){ + jam(); + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + + tabPtr.p->m_prepDropTab.waitDropTabCount.setWaitingFor(nodePtr.i); + sendSignal(calcLqhBlockRef(nodePtr.i), GSN_WAIT_DROP_TAB_REQ, + signal, WaitDropTabReq::SignalLength, JBB); + + nodePtr.i = nodePtr.p->nextNode; + } + } + + waitDropTabWritingToFile(signal, tabPtr); +} + +void +Dbdih::waitDropTabWritingToFile(Signal* signal, TabRecordPtr tabPtr){ + + if(tabPtr.p->tabLcpStatus == TabRecord::TLS_WRITING_TO_FILE){ + jam(); + signal->theData[0] = DihContinueB::WAIT_DROP_TAB_WRITING_TO_FILE; + signal->theData[1] = tabPtr.i; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 2); + return; + } + + ndbrequire(tabPtr.p->tabLcpStatus == TabRecord::TLS_COMPLETED); + checkPrepDropTabComplete(signal, tabPtr); +} + +void +Dbdih::checkPrepDropTabComplete(Signal* signal, TabRecordPtr tabPtr){ + + if(tabPtr.p->tabLcpStatus != TabRecord::TLS_COMPLETED){ + jam(); + return; + } + + if(!tabPtr.p->m_prepDropTab.waitDropTabCount.done()){ + jam(); + return; + } + + const Uint32 ref = tabPtr.p->m_prepDropTab.senderRef; + if(ref != 0){ + PrepDropTabConf* conf = (PrepDropTabConf*)signal->getDataPtrSend(); + conf->tableId = tabPtr.i; + conf->senderRef = reference(); + conf->senderData = tabPtr.p->m_prepDropTab.senderData; + sendSignal(tabPtr.p->m_prepDropTab.senderRef, GSN_PREP_DROP_TAB_CONF, + signal, PrepDropTabConf::SignalLength, JBB); + tabPtr.p->m_prepDropTab.senderRef = 0; + } +} + +void +Dbdih::execWAIT_DROP_TAB_CONF(Signal* signal){ + jamEntry(); + WaitDropTabConf * conf = (WaitDropTabConf*)signal->getDataPtr(); + + TabRecordPtr tabPtr; + tabPtr.i = conf->tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + + ndbrequire(tabPtr.p->tabStatus == TabRecord::TS_DROPPING); + Uint32 nodeId = refToNode(conf->senderRef); + tabPtr.p->m_prepDropTab.waitDropTabCount.clearWaitingFor(nodeId); + checkPrepDropTabComplete(signal, tabPtr); +} + +void +Dbdih::checkWaitDropTabFailedLqh(Signal* signal, Uint32 nodeId, Uint32 tableId){ + + TabRecordPtr tabPtr; + tabPtr.i = tableId; + + WaitDropTabConf * conf = (WaitDropTabConf*)signal->getDataPtr(); + conf->tableId = tableId; + + const Uint32 RT_BREAK = 16; + for(Uint32 i = 0; itabStatus == TabRecord::TS_DROPPING){ + if(tabPtr.p->m_prepDropTab.waitDropTabCount.isWaitingFor(nodeId)){ + conf->senderRef = calcLqhBlockRef(nodeId); + execWAIT_DROP_TAB_CONF(signal); + tabPtr.i++; + break; + } + } + } + + if(tabPtr.i == ctabFileSize){ + /** + * Finished + */ + jam(); + return; + } + + signal->theData[0] = DihContinueB::CHECK_WAIT_DROP_TAB_FAILED_LQH; + signal->theData[1] = nodeId; + signal->theData[2] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); +} + + +void +Dbdih::execNDB_TAMPER(Signal* signal) +{ + if ((ERROR_INSERTED(7011)) && + (signal->theData[0] == 7012)) { + CLEAR_ERROR_INSERT_VALUE; + calculateKeepGciLab(signal, 0, 0); + return; + }//if + SET_ERROR_INSERT_VALUE(signal->theData[0]); + return; +}//Dbdih::execNDB_TAMPER() + +void Dbdih::execSET_VAR_REQ(Signal* signal) { + + SetVarReq* const setVarReq = (SetVarReq*)&signal->theData[0]; + ConfigParamId var = setVarReq->variable(); + int val = setVarReq->value(); + + + switch (var) { + case TimeBetweenLocalCheckpoints: + c_lcpState.clcpDelay = val; + sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB); + break; + + case TimeBetweenGlobalCheckpoints: + cgcpDelay = val; + sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB); + break; + + default: + sendSignal(CMVMI_REF, GSN_SET_VAR_REF, signal, 1, JBB); + } // switch +} + +void Dbdih::execBLOCK_COMMIT_ORD(Signal* signal){ + BlockCommitOrd* const block = (BlockCommitOrd *)&signal->theData[0]; + + jamEntry(); +#if 0 + ndbrequire(c_blockCommit == false || + c_blockCommitNo == block->failNo); +#else + if(!(c_blockCommit == false || c_blockCommitNo == block->failNo)){ + infoEvent("Possible bug in Dbdih::execBLOCK_COMMIT_ORD c_blockCommit = %d c_blockCommitNo = %d" + " sig->failNo = %d", c_blockCommit, c_blockCommitNo, block->failNo); + } +#endif + c_blockCommit = true; + c_blockCommitNo = block->failNo; +} + +void Dbdih::execUNBLOCK_COMMIT_ORD(Signal* signal){ + UnblockCommitOrd* const unblock = (UnblockCommitOrd *)&signal->theData[0]; + (void)unblock; + + jamEntry(); + + if(c_blockCommit == true){ + jam(); + // ndbrequire(c_blockCommitNo == unblock->failNo); + + c_blockCommit = false; + emptyverificbuffer(signal, true); + } +} + +void Dbdih::execSTOP_PERM_REQ(Signal* signal){ + + jamEntry(); + + StopPermReq* const req = (StopPermReq*)&signal->theData[0]; + StopPermRef* const ref = (StopPermRef*)&signal->theData[0]; + + const Uint32 senderData = req->senderData; + const BlockReference senderRef = req->senderRef; + const NodeId nodeId = refToNode(senderRef); + + if (isMaster()) { + /** + * Master + */ + jam(); + CRASH_INSERTION(7065); + if (c_stopPermMaster.clientRef != 0) { + jam(); + + ref->senderData = senderData; + ref->errorCode = StopPermRef::NodeShutdownInProgress; + sendSignal(senderRef, GSN_STOP_PERM_REF, signal, + StopPermRef::SignalLength, JBB); + return; + }//if + + if (c_nodeStartMaster.activeState) { + jam(); + ref->senderData = senderData; + ref->errorCode = StopPermRef::NodeStartInProgress; + sendSignal(senderRef, GSN_STOP_PERM_REF, signal, + StopPermRef::SignalLength, JBB); + return; + }//if + + /** + * Lock + */ + c_nodeStartMaster.activeState = true; + c_stopPermMaster.clientRef = senderRef; + + c_stopPermMaster.clientData = senderData; + c_stopPermMaster.returnValue = 0; + c_switchReplicas.clear(); + + Mutex mutex(signal, c_mutexMgr, c_switchPrimaryMutexHandle); + Callback c = { safe_cast(&Dbdih::switch_primary_stop_node), nodeId }; + ndbrequire(mutex.lock(c)); + } else { + /** + * Proxy part + */ + jam(); + CRASH_INSERTION(7066); + if(c_stopPermProxy.clientRef != 0){ + jam(); + ref->senderData = senderData; + ref->errorCode = StopPermRef::NodeShutdownInProgress; + sendSignal(senderRef, GSN_STOP_PERM_REF, signal, 2, JBB); + return; + }//if + + c_stopPermProxy.clientRef = senderRef; + c_stopPermProxy.masterRef = cmasterdihref; + c_stopPermProxy.clientData = senderData; + + req->senderRef = reference(); + req->senderData = senderData; + sendSignal(cmasterdihref, GSN_STOP_PERM_REQ, signal, + StopPermReq::SignalLength, JBB); + }//if +}//Dbdih::execSTOP_PERM_REQ() + +void +Dbdih::switch_primary_stop_node(Signal* signal, Uint32 node_id, Uint32 ret_val) +{ + ndbrequire(ret_val == 0); + signal->theData[0] = DihContinueB::SwitchReplica; + signal->theData[1] = node_id; + signal->theData[2] = 0; // table id + signal->theData[3] = 0; // fragment id + sendSignal(reference(), GSN_CONTINUEB, signal, 4, JBB); +} + +void Dbdih::execSTOP_PERM_REF(Signal* signal) +{ + jamEntry(); + ndbrequire(c_stopPermProxy.clientRef != 0); + ndbrequire(c_stopPermProxy.masterRef == signal->senderBlockRef()); + sendSignal(c_stopPermProxy.clientRef, GSN_STOP_PERM_REF, signal, 2, JBB); + c_stopPermProxy.clientRef = 0; +}//Dbdih::execSTOP_PERM_REF() + +void Dbdih::execSTOP_PERM_CONF(Signal* signal) +{ + jamEntry(); + ndbrequire(c_stopPermProxy.clientRef != 0); + ndbrequire(c_stopPermProxy.masterRef == signal->senderBlockRef()); + sendSignal(c_stopPermProxy.clientRef, GSN_STOP_PERM_CONF, signal, 1, JBB); + c_stopPermProxy.clientRef = 0; +}//Dbdih::execSTOP_PERM_CONF() + +void Dbdih::execDIH_SWITCH_REPLICA_REQ(Signal* signal) +{ + jamEntry(); + DihSwitchReplicaReq* const req = (DihSwitchReplicaReq*)&signal->theData[0]; + const Uint32 tableId = req->tableId; + const Uint32 fragNo = req->fragNo; + const BlockReference senderRef = req->senderRef; + + CRASH_INSERTION(7067); + TabRecordPtr tabPtr; + tabPtr.i = tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + + ndbrequire(tabPtr.p->tabStatus == TabRecord::TS_ACTIVE); + if (tabPtr.p->tabCopyStatus != TabRecord::CS_IDLE) { + jam(); + sendSignal(reference(), GSN_DIH_SWITCH_REPLICA_REQ, signal, + DihSwitchReplicaReq::SignalLength, JBB); + return; + }//if + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, fragNo, fragPtr); + + /** + * Do funky stuff + */ + Uint32 oldOrder[MAX_REPLICAS]; + const Uint32 noOfReplicas = extractNodeInfo(fragPtr.p, oldOrder); + + if (noOfReplicas < req->noOfReplicas) { + jam(); + //--------------------------------------------------------------------- + // A crash occurred in the middle of our switch handling. + //--------------------------------------------------------------------- + DihSwitchReplicaRef* const ref = (DihSwitchReplicaRef*)&signal->theData[0]; + ref->senderNode = cownNodeId; + ref->errorCode = StopPermRef::NF_CausedAbortOfStopProcedure; + sendSignal(senderRef, GSN_DIH_SWITCH_REPLICA_REF, signal, + DihSwitchReplicaRef::SignalLength, JBB); + }//if + for (Uint32 i = 0; i < noOfReplicas; i++) { + jam(); + ndbrequire(i < MAX_REPLICAS); + fragPtr.p->activeNodes[i] = req->newNodeOrder[i]; + }//for + /** + * Reply + */ + DihSwitchReplicaConf* const conf = (DihSwitchReplicaConf*)&signal->theData[0]; + conf->senderNode = cownNodeId; + sendSignal(senderRef, GSN_DIH_SWITCH_REPLICA_CONF, signal, + DihSwitchReplicaConf::SignalLength, JBB); +}//Dbdih::execDIH_SWITCH_REPLICA_REQ() + +void Dbdih::execDIH_SWITCH_REPLICA_CONF(Signal* signal) +{ + jamEntry(); + /** + * Response to master + */ + CRASH_INSERTION(7068); + DihSwitchReplicaConf* const conf = (DihSwitchReplicaConf*)&signal->theData[0]; + switchReplicaReply(signal, conf->senderNode); +}//Dbdih::execDIH_SWITCH_REPLICA_CONF() + +void Dbdih::execDIH_SWITCH_REPLICA_REF(Signal* signal) +{ + jamEntry(); + DihSwitchReplicaRef* const ref = (DihSwitchReplicaRef*)&signal->theData[0]; + if(c_stopPermMaster.returnValue == 0){ + jam(); + c_stopPermMaster.returnValue = ref->errorCode; + }//if + switchReplicaReply(signal, ref->senderNode); +}//Dbdih::execDIH_SWITCH_REPLICA_REF() + +void Dbdih::switchReplicaReply(Signal* signal, + NodeId nodeId){ + jam(); + receiveLoopMacro(DIH_SWITCH_REPLICA_REQ, nodeId); + //------------------------------------------------------ + // We have received all responses from the nodes. Thus + // we have completed switching replica roles. Continue + // with the next fragment. + //------------------------------------------------------ + if(c_stopPermMaster.returnValue != 0){ + jam(); + c_switchReplicas.tableId = ctabFileSize + 1; + }//if + c_switchReplicas.fragNo++; + + signal->theData[0] = DihContinueB::SwitchReplica; + signal->theData[1] = c_switchReplicas.nodeId; + signal->theData[2] = c_switchReplicas.tableId; + signal->theData[3] = c_switchReplicas.fragNo; + sendSignal(reference(), GSN_CONTINUEB, signal, 4, JBB); +}//Dbdih::switchReplicaReply() + +void +Dbdih::switchReplica(Signal* signal, + Uint32 nodeId, + Uint32 tableId, + Uint32 fragNo){ + jam(); + DihSwitchReplicaReq* const req = (DihSwitchReplicaReq*)&signal->theData[0]; + + const Uint32 RT_BREAK = 64; + + for (Uint32 i = 0; i < RT_BREAK; i++) { + jam(); + if (tableId >= ctabFileSize) { + jam(); + StopPermConf* const conf = (StopPermConf*)&signal->theData[0]; + StopPermRef* const ref = (StopPermRef*)&signal->theData[0]; + /** + * Finished with all tables + */ + if(c_stopPermMaster.returnValue == 0) { + jam(); + conf->senderData = c_stopPermMaster.clientData; + sendSignal(c_stopPermMaster.clientRef, GSN_STOP_PERM_CONF, + signal, 1, JBB); + } else { + jam(); + ref->senderData = c_stopPermMaster.clientData; + ref->errorCode = c_stopPermMaster.returnValue; + sendSignal(c_stopPermMaster.clientRef, GSN_STOP_PERM_REF, signal, 2,JBB); + }//if + + /** + * UnLock + */ + c_nodeStartMaster.activeState = false; + c_stopPermMaster.clientRef = 0; + c_stopPermMaster.clientData = 0; + c_stopPermMaster.returnValue = 0; + Mutex mutex(signal, c_mutexMgr, c_switchPrimaryMutexHandle); + mutex.unlock(); // ignore result + return; + }//if + + TabRecordPtr tabPtr; + tabPtr.i = tableId; + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + + if (tabPtr.p->tabStatus != TabRecord::TS_ACTIVE) { + jam(); + tableId++; + fragNo = 0; + continue; + }//if + if (fragNo >= tabPtr.p->totalfragments) { + jam(); + tableId++; + fragNo = 0; + continue; + }//if + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, fragNo, fragPtr); + + Uint32 oldOrder[MAX_REPLICAS]; + const Uint32 noOfReplicas = extractNodeInfo(fragPtr.p, oldOrder); + + if(oldOrder[0] != nodeId) { + jam(); + fragNo++; + continue; + }//if + req->tableId = tableId; + req->fragNo = fragNo; + req->noOfReplicas = noOfReplicas; + for (Uint32 i = 0; i < (noOfReplicas - 1); i++) { + req->newNodeOrder[i] = oldOrder[i+1]; + }//for + req->newNodeOrder[noOfReplicas-1] = nodeId; + req->senderRef = reference(); + + /** + * Initialize struct + */ + c_switchReplicas.tableId = tableId; + c_switchReplicas.fragNo = fragNo; + c_switchReplicas.nodeId = nodeId; + + sendLoopMacro(DIH_SWITCH_REPLICA_REQ, sendDIH_SWITCH_REPLICA_REQ); + return; + }//for + + signal->theData[0] = DihContinueB::SwitchReplica; + signal->theData[1] = nodeId; + signal->theData[2] = tableId; + signal->theData[3] = fragNo; + sendSignal(reference(), GSN_CONTINUEB, signal, 4, JBB); +}//Dbdih::switchReplica() + +void Dbdih::execSTOP_ME_REQ(Signal* signal) +{ + jamEntry(); + StopMeReq* const req = (StopMeReq*)&signal->theData[0]; + const BlockReference senderRef = req->senderRef; + const Uint32 senderData = req->senderData; + const Uint32 nodeId = refToNode(senderRef); + { + /** + * Set node dead (remove from operations) + */ + NodeRecordPtr nodePtr; + nodePtr.i = nodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + nodePtr.p->useInTransactions = false; + } + if (nodeId != getOwnNodeId()) { + jam(); + StopMeConf * const stopMeConf = (StopMeConf *)&signal->theData[0]; + stopMeConf->senderData = senderData; + stopMeConf->senderRef = reference(); + sendSignal(senderRef, GSN_STOP_ME_CONF, signal, + StopMeConf::SignalLength, JBB); + return; + }//if + + /** + * Local signal + */ + jam(); + ndbrequire(c_stopMe.clientRef == 0); + + c_stopMe.clientData = senderData; + c_stopMe.clientRef = senderRef; + + req->senderData = senderData; + req->senderRef = reference(); + + sendLoopMacro(STOP_ME_REQ, sendSTOP_ME_REQ); + + /** + * Send conf to self + */ + StopMeConf * const stopMeConf = (StopMeConf *)&signal->theData[0]; + stopMeConf->senderData = senderData; + stopMeConf->senderRef = reference(); + sendSignal(reference(), GSN_STOP_ME_CONF, signal, + StopMeConf::SignalLength, JBB); +}//Dbdih::execSTOP_ME_REQ() + +void Dbdih::execSTOP_ME_REF(Signal* signal) +{ + ndbrequire(false); +} + +void Dbdih::execSTOP_ME_CONF(Signal* signal) +{ + jamEntry(); + StopMeConf * const stopMeConf = (StopMeConf *)&signal->theData[0]; + + const Uint32 senderRef = stopMeConf->senderRef; + const Uint32 senderData = stopMeConf->senderData; + const Uint32 nodeId = refToNode(senderRef); + + ndbrequire(c_stopMe.clientRef != 0); + ndbrequire(c_stopMe.clientData == senderData); + + receiveLoopMacro(STOP_ME_REQ, nodeId); + //--------------------------------------------------------- + // All STOP_ME_REQ have been received. We will send the + // confirmation back to the requesting block. + //--------------------------------------------------------- + + stopMeConf->senderRef = reference(); + stopMeConf->senderData = c_stopMe.clientData; + sendSignal(c_stopMe.clientRef, GSN_STOP_ME_CONF, signal, + StopMeConf::SignalLength, JBB); + c_stopMe.clientRef = 0; +}//Dbdih::execSTOP_ME_CONF() + +void Dbdih::execWAIT_GCP_REQ(Signal* signal) +{ + jamEntry(); + WaitGCPReq* const req = (WaitGCPReq*)&signal->theData[0]; + WaitGCPRef* const ref = (WaitGCPRef*)&signal->theData[0]; + WaitGCPConf* const conf = (WaitGCPConf*)&signal->theData[0]; + const Uint32 senderData = req->senderData; + const BlockReference senderRef = req->senderRef; + const Uint32 requestType = req->requestType; + + if(requestType == WaitGCPReq::CurrentGCI) { + jam(); + conf->senderData = senderData; + conf->gcp = cnewgcp; + sendSignal(senderRef, GSN_WAIT_GCP_CONF, signal, + WaitGCPConf::SignalLength, JBB); + return; + }//if + + if(isMaster()) { + /** + * Master + */ + jam(); + + if((requestType == WaitGCPReq::CompleteIfRunning) && + (cgcpStatus == GCP_READY)) { + jam(); + conf->senderData = senderData; + conf->gcp = coldgcp; + sendSignal(senderRef, GSN_WAIT_GCP_CONF, signal, + WaitGCPConf::SignalLength, JBB); + return; + }//if + + WaitGCPMasterPtr ptr; + if(c_waitGCPMasterList.seize(ptr) == false){ + jam(); + ref->senderData = senderData; + ref->errorCode = WaitGCPRef::NoWaitGCPRecords; + sendSignal(senderRef, GSN_WAIT_GCP_REF, signal, + WaitGCPRef::SignalLength, JBB); + return; + }//if + ptr.p->clientRef = senderRef; + ptr.p->clientData = senderData; + + if((requestType == WaitGCPReq::CompleteForceStart) && + (cgcpStatus == GCP_READY)) { + jam(); + cstartGcpNow = true; + }//if + return; + } else { + /** + * Proxy part + */ + jam(); + WaitGCPProxyPtr ptr; + if (c_waitGCPProxyList.seize(ptr) == false) { + jam(); + ref->senderData = senderData; + ref->errorCode = WaitGCPRef::NoWaitGCPRecords; + sendSignal(senderRef, GSN_WAIT_GCP_REF, signal, + WaitGCPRef::SignalLength, JBB); + return; + }//if + ptr.p->clientRef = senderRef; + ptr.p->clientData = senderData; + ptr.p->masterRef = cmasterdihref; + + req->senderData = ptr.i; + req->senderRef = reference(); + req->requestType = requestType; + + sendSignal(cmasterdihref, GSN_WAIT_GCP_REQ, signal, + WaitGCPReq::SignalLength, JBB); + return; + }//if +}//Dbdih::execWAIT_GCP_REQ() + +void Dbdih::execWAIT_GCP_REF(Signal* signal) +{ + jamEntry(); + ndbrequire(!isMaster()); + WaitGCPRef* const ref = (WaitGCPRef*)&signal->theData[0]; + + const Uint32 proxyPtr = ref->senderData; + const Uint32 errorCode = ref->errorCode; + + WaitGCPProxyPtr ptr; + ptr.i = proxyPtr; + c_waitGCPProxyList.getPtr(ptr); + + ref->senderData = ptr.p->clientData; + ref->errorCode = errorCode; + sendSignal(ptr.p->clientRef, GSN_WAIT_GCP_REF, signal, + WaitGCPRef::SignalLength, JBB); + + c_waitGCPProxyList.release(ptr); +}//Dbdih::execWAIT_GCP_REF() + +void Dbdih::execWAIT_GCP_CONF(Signal* signal) +{ + jamEntry(); + ndbrequire(!isMaster()); + WaitGCPConf* const conf = (WaitGCPConf*)&signal->theData[0]; + const Uint32 proxyPtr = conf->senderData; + const Uint32 gcp = conf->gcp; + WaitGCPProxyPtr ptr; + + ptr.i = proxyPtr; + c_waitGCPProxyList.getPtr(ptr); + + conf->senderData = ptr.p->clientData; + conf->gcp = gcp; + sendSignal(ptr.p->clientRef, GSN_WAIT_GCP_CONF, signal, + WaitGCPConf::SignalLength, JBB); + + c_waitGCPProxyList.release(ptr); +}//Dbdih::execWAIT_GCP_CONF() + +void Dbdih::checkWaitGCPProxy(Signal* signal, NodeId failedNodeId) +{ + jam(); + WaitGCPRef* const ref = (WaitGCPRef*)&signal->theData[0]; + ref->errorCode = WaitGCPRef::NF_CausedAbortOfProcedure; + + WaitGCPProxyPtr ptr; + c_waitGCPProxyList.first(ptr); + while(ptr.i != RNIL) { + jam(); + const Uint32 i = ptr.i; + const Uint32 clientData = ptr.p->clientData; + const BlockReference clientRef = ptr.p->clientRef; + const BlockReference masterRef = ptr.p->masterRef; + + c_waitGCPProxyList.next(ptr); + if(refToNode(masterRef) == failedNodeId) { + jam(); + c_waitGCPProxyList.release(i); + ref->senderData = clientData; + sendSignal(clientRef, GSN_WAIT_GCP_REF, signal, + WaitGCPRef::SignalLength, JBB); + }//if + }//while +}//Dbdih::checkWaitGCPProxy() + +void Dbdih::checkWaitGCPMaster(Signal* signal, NodeId failedNodeId) +{ + jam(); + WaitGCPMasterPtr ptr; + c_waitGCPMasterList.first(ptr); + + while (ptr.i != RNIL) { + jam(); + const Uint32 i = ptr.i; + const NodeId nodeId = refToNode(ptr.p->clientRef); + + c_waitGCPMasterList.next(ptr); + if (nodeId == failedNodeId) { + jam() + c_waitGCPMasterList.release(i); + }//if + }//while +}//Dbdih::checkWaitGCPMaster() + +void Dbdih::emptyWaitGCPMasterQueue(Signal* signal) +{ + jam(); + WaitGCPConf* const conf = (WaitGCPConf*)&signal->theData[0]; + conf->gcp = coldgcp; + + WaitGCPMasterPtr ptr; + c_waitGCPMasterList.first(ptr); + while(ptr.i != RNIL) { + jam(); + const Uint32 i = ptr.i; + const Uint32 clientData = ptr.p->clientData; + const BlockReference clientRef = ptr.p->clientRef; + + c_waitGCPMasterList.next(ptr); + conf->senderData = clientData; + sendSignal(clientRef, GSN_WAIT_GCP_CONF, signal, + WaitGCPConf::SignalLength, JBB); + + c_waitGCPMasterList.release(i); + }//while +}//Dbdih::emptyWaitGCPMasterQueue() + +void Dbdih::setNodeStatus(Uint32 nodeId, NodeRecord::NodeStatus newStatus) +{ + NodeRecordPtr nodePtr; + nodePtr.i = nodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + nodePtr.p->nodeStatus = newStatus; +}//Dbdih::setNodeStatus() + +Dbdih::NodeRecord::NodeStatus Dbdih::getNodeStatus(Uint32 nodeId) +{ + NodeRecordPtr nodePtr; + nodePtr.i = nodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + return nodePtr.p->nodeStatus; +}//Dbdih::getNodeStatus() + +Sysfile::ActiveStatus +Dbdih::getNodeActiveStatus(Uint32 nodeId) +{ + NodeRecordPtr nodePtr; + nodePtr.i = nodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + return nodePtr.p->activeStatus; +}//Dbdih::getNodeActiveStatus() + + +void +Dbdih::setNodeActiveStatus(Uint32 nodeId, Sysfile::ActiveStatus newStatus) +{ + NodeRecordPtr nodePtr; + nodePtr.i = nodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + nodePtr.p->activeStatus = newStatus; +}//Dbdih::setNodeActiveStatus() + +void Dbdih::setAllowNodeStart(Uint32 nodeId, bool newState) +{ + NodeRecordPtr nodePtr; + nodePtr.i = nodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + nodePtr.p->allowNodeStart = newState; +}//Dbdih::setAllowNodeStart() + +void Dbdih::setNodeCopyCompleted(Uint32 nodeId, bool newState) +{ + NodeRecordPtr nodePtr; + nodePtr.i = nodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + nodePtr.p->copyCompleted = newState; +}//Dbdih::setNodeCopyCompleted() + +bool Dbdih::getAllowNodeStart(Uint32 nodeId) +{ + NodeRecordPtr nodePtr; + nodePtr.i = nodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + return nodePtr.p->allowNodeStart; +}//Dbdih::getAllowNodeStart() + +bool Dbdih::getNodeCopyCompleted(Uint32 nodeId) +{ + NodeRecordPtr nodePtr; + nodePtr.i = nodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + return nodePtr.p->copyCompleted; +}//Dbdih::getNodeCopyCompleted() + +bool Dbdih::checkNodeAlive(Uint32 nodeId) +{ + NodeRecordPtr nodePtr; + nodePtr.i = nodeId; + ndbrequire(nodeId > 0); + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord); + if (nodePtr.p->nodeStatus != NodeRecord::ALIVE) { + return false; + } else { + return true; + }//if +}//Dbdih::checkNodeAlive() + +bool Dbdih::isMaster() +{ + return (reference() == cmasterdihref); +}//Dbdih::isMaster() + +bool Dbdih::isActiveMaster() +{ + return ((reference() == cmasterdihref) && (cmasterState == MASTER_ACTIVE)); +}//Dbdih::isActiveMaster() diff --git a/ndb/src/kernel/blocks/dbdih/LCP.txt b/ndb/src/kernel/blocks/dbdih/LCP.txt new file mode 100644 index 00000000000..500c82f6baf --- /dev/null +++ b/ndb/src/kernel/blocks/dbdih/LCP.txt @@ -0,0 +1,35 @@ + +Master DIH LQH +========== ========== + +1) TCGETOPSIZEREQ -> all TC + +2) If sum(operation size) < Threshold + Goto 1 + +3) For each table + Calc Keep GCI (local using CONTINUEB) + +4) COPY_GCIREQ -> all DIH + +5) TC_CLOPSIZEREQ -> all TC + +6) For each fragment + LCP_FRAG_ORD -> LQH + + Do LCP... + 1) LCP_FRAG_REP -> all DIH + 2) If last fragment + LCP_COMPLETE_REP -> all DIH + +7) When receiving LCP_COMPLETE_REP from DIH + 1) If all DIHs have completed + Goto 1 + +All DIHs +========== +1) When receiving LCP_FRAG_REP + If all fragments & replicas done in table + 1) Save Table descriptor + 2) If all tables done + LCP_COMPLETE_REP(from lqh) has arrived + LCP_COMPLETE_REP -> master DIH diff --git a/ndb/src/kernel/blocks/dbdih/Makefile b/ndb/src/kernel/blocks/dbdih/Makefile new file mode 100644 index 00000000000..83c1b95b5c4 --- /dev/null +++ b/ndb/src/kernel/blocks/dbdih/Makefile @@ -0,0 +1,13 @@ +include .defs.mk + +TYPE := kernel + +ARCHIVE_TARGET := dbdih + +DIRS := printSysfile + +SOURCES = \ + DbdihInit.cpp \ + DbdihMain.cpp + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/kernel/blocks/dbdih/Sysfile.hpp b/ndb/src/kernel/blocks/dbdih/Sysfile.hpp new file mode 100644 index 00000000000..a44992d6ad0 --- /dev/null +++ b/ndb/src/kernel/blocks/dbdih/Sysfile.hpp @@ -0,0 +1,275 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SYSFILE_HPP +#define SYSFILE_HPP + +#include +#include +#include + +/** + * No bits in Sysfile to represent nodeid + */ +#define NODEID_BITS 8 + +/** + * Constant representing that node do not belong to + * any node group + */ +#define NO_NODE_GROUP_ID ((1 << NODEID_BITS) - 1) + +/** + * Dummy macro to make emacs indent better + */ +#define _F(x) x + +/** + * No of 32 bits word in sysfile + * + * 5 + + * MAX_NDB_NODES + // lastCompletedGCI + * NODE_ARRAY_SIZE(MAX_NDB_NODES, 4) + // nodeStatus + * NODE_ARRAY_SIZE(MAX_NDB_NODES, NODEID_BITS) + // nodeGroups + * NODE_ARRAY_SIZE(MAX_NDB_NODES, NODEID_BITS) + // takeOver + * NodeBitmask::NDB_NODE_BITMASK_SIZE // Lcp Active + */ +#define _SYSFILE_SIZE32 (5 + \ + MAX_NDB_NODES + \ + NODE_ARRAY_SIZE(MAX_NDB_NODES, 4) + \ + NODE_ARRAY_SIZE(MAX_NDB_NODES, NODEID_BITS) + \ + NODE_ARRAY_SIZE(MAX_NDB_NODES, NODEID_BITS) + \ + _NDB_NODE_BITMASK_SIZE) + +/** + * This struct defines the format of P.sysfile + */ +struct Sysfile { +public: + + /** + * No of 32 bits words in the sysfile + */ + static const Uint32 SYSFILE_SIZE32 = _SYSFILE_SIZE32; + + Uint32 systemRestartBits; + + static bool getInitialStartOngoing(const Uint32 & systemRestartBits); + static void setInitialStartOngoing(Uint32 & systemRestartBits); + static void clearInitialStartOngoing(Uint32 & systemRestartBits); + + static bool getRestartOngoing(const Uint32 & systemRestartBits); + static void setRestartOngoing(Uint32 & systemRestartBits); + static void clearRestartOngoing(Uint32 & systemRestartBits); + + static bool getLCPOngoing(const Uint32 & systemRestartBits); + static void setLCPOngoing(Uint32 & systemRestartBits); + static void clearLCPOngoing(Uint32 & systemRestartBits); + + Uint32 keepGCI; + Uint32 oldestRestorableGCI; + Uint32 newestRestorableGCI; + Uint32 latestLCP_ID; + + /** + * Last completed GCI for each node + */ + Uint32 lastCompletedGCI[MAX_NDB_NODES]; + + /** + * Active status bits + * + * It takes 4 bits to represent it + */ + enum ActiveStatus { + NS_Active = 0 + ,NS_ActiveMissed_1 = 1 + ,NS_ActiveMissed_2 = 2 + ,NS_ActiveMissed_3 = 3 + ,NS_HotSpare = 4 + ,NS_NotActive_NotTakenOver = 5 + ,NS_TakeOver = 6 + ,NS_NotActive_TakenOver = 7 + ,NS_NotDefined = 8 + ,NS_Standby = 9 + }; + static const Uint32 NODE_STATUS_SIZE = NODE_ARRAY_SIZE(MAX_NDB_NODES, 4); + Uint32 nodeStatus[NODE_STATUS_SIZE]; + + static Uint32 getNodeStatus(NodeId, const Uint32 nodeStatus[]); + static void setNodeStatus(NodeId, Uint32 nodeStatus[], Uint32 status); + + /** + * The node group of each node + * Sizeof(NodeGroup) = 8 Bit + */ + static const Uint32 NODE_GROUPS_SIZE = NODE_ARRAY_SIZE(MAX_NDB_NODES, + NODEID_BITS); + Uint32 nodeGroups[NODE_GROUPS_SIZE]; + + static Uint16 getNodeGroup(NodeId, const Uint32 nodeGroups[]); + static void setNodeGroup(NodeId, Uint32 nodeGroups[], Uint16 group); + + /** + * Any node can take over for any node + */ + static const Uint32 TAKE_OVER_SIZE = NODE_ARRAY_SIZE(MAX_NDB_NODES, + NODEID_BITS); + Uint32 takeOver[TAKE_OVER_SIZE]; + + static NodeId getTakeOverNode(NodeId, const Uint32 takeOver[]); + static void setTakeOverNode(NodeId, Uint32 takeOver[], NodeId toNode); + + /** + * Is a node running a LCP + */ + Uint32 lcpActive[NdbNodeBitmask::Size]; +}; + +#if (MAX_NDB_NODES > (1<> 3; + const int shift = (nodeId & 7) << 2; + + return (nodeStatus[word] >> shift) & 15; +} + +inline +void +Sysfile::setNodeStatus(NodeId nodeId, Uint32 nodeStatus[], Uint32 status){ + const int word = nodeId >> 3; + const int shift = (nodeId & 7) << 2; + + const Uint32 mask = ~(((Uint32)15) << shift); + const Uint32 tmp = nodeStatus[word]; + + nodeStatus[word] = (tmp & mask) | ((status & 15) << shift); +} + +inline +Uint16 +Sysfile::getNodeGroup(NodeId nodeId, const Uint32 nodeGroups[]){ + const int word = nodeId >> 2; + const int shift = (nodeId & 3) << 3; + + return (nodeGroups[word] >> shift) & 255; +} + +inline +void +Sysfile::setNodeGroup(NodeId nodeId, Uint32 nodeGroups[], Uint16 group){ + const int word = nodeId >> 2; + const int shift = (nodeId & 3) << 3; + + const Uint32 mask = ~(((Uint32)255) << shift); + const Uint32 tmp = nodeGroups[word]; + + nodeGroups[word] = (tmp & mask) | ((group & 255) << shift); +} + +inline +NodeId +Sysfile::getTakeOverNode(NodeId nodeId, const Uint32 takeOver[]){ + const int word = nodeId >> 2; + const int shift = (nodeId & 3) << 3; + + return (takeOver[word] >> shift) & 255; +} + +inline +void +Sysfile::setTakeOverNode(NodeId nodeId, Uint32 takeOver[], NodeId toNode){ + const int word = nodeId >> 2; + const int shift = (nodeId & 3) << 3; + + const Uint32 mask = ~(((Uint32)255) << shift); + const Uint32 tmp = takeOver[word]; + + takeOver[word] = (tmp & mask) | ((toNode & 255) << shift); +} + + +#endif diff --git a/ndb/src/kernel/blocks/dbdih/printSysfile/Makefile b/ndb/src/kernel/blocks/dbdih/printSysfile/Makefile new file mode 100644 index 00000000000..4c4b1026aff --- /dev/null +++ b/ndb/src/kernel/blocks/dbdih/printSysfile/Makefile @@ -0,0 +1,12 @@ +include .defs.mk + +TYPE := ndbapi + +BIN_TARGET := printSysfile +BIN_TARGET_ARCHIVES := portlib general + +CCFLAGS_LOC += -I.. + +SOURCES := printSysfile.cpp + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/kernel/blocks/dbdih/printSysfile/printSysfile.cpp b/ndb/src/kernel/blocks/dbdih/printSysfile/printSysfile.cpp new file mode 100644 index 00000000000..4c55425bdd7 --- /dev/null +++ b/ndb/src/kernel/blocks/dbdih/printSysfile/printSysfile.cpp @@ -0,0 +1,160 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#include +#include +#include +#include +#include +#include + +void +usage(const char * prg){ + ndbout << "Usage " << prg + << " P[0-1].sysfile" << endl; +} + +struct NSString { + Sysfile::ActiveStatus NodeStatus; + const char * desc; +}; + +static const +NSString NodeStatusStrings[] = { + { Sysfile::NS_Active, "Active " }, + { Sysfile::NS_ActiveMissed_1, "Active missed 1" }, + { Sysfile::NS_ActiveMissed_2, "Active missed 2" }, + { Sysfile::NS_ActiveMissed_3, "Active missed 3" }, + { Sysfile::NS_HotSpare, "Hot spare " }, + { Sysfile::NS_NotActive_NotTakenOver, "Not active " }, + { Sysfile::NS_TakeOver, "Take over " }, + { Sysfile::NS_NotActive_TakenOver, "Taken over " }, + { Sysfile::NS_NotDefined, "Not defined " }, + { Sysfile::NS_Standby, "Stand by " } +}; + +const +char * getNSString(Uint32 ns){ + for(Uint32 i = 0; i<(sizeof(NodeStatusStrings)/sizeof(NSString)); i++) + if((Uint32)NodeStatusStrings[i].NodeStatus == ns) + return NodeStatusStrings[i].desc; + return ""; +} + +void +fill(const char * buf, int mod){ + int len = strlen(buf)+1; + ndbout << buf << " "; + while((len % mod) != 0){ + ndbout << " "; + len++; + } +} + +void +print(const char * filename, const Sysfile * sysfile){ + char buf[255]; + ndbout << "----- Sysfile: " << filename << " -----" << endl; + ndbout << "Initial start ongoing: " + << Sysfile::getInitialStartOngoing(sysfile->systemRestartBits) + << ", "; + + ndbout << "Restart Ongoing: " + << Sysfile::getRestartOngoing(sysfile->systemRestartBits) + << ", "; + + ndbout << "LCP Ongoing: " + << Sysfile::getLCPOngoing(sysfile->systemRestartBits) + << endl; + + + ndbout << "-- Global Checkpoint Identities: --" << endl; + sprintf(buf, "keepGCI = %u", sysfile->keepGCI); + fill(buf, 40); + ndbout << " -- Tail of REDO log" << endl; + + sprintf(buf, "oldestRestorableGCI = %u", sysfile->oldestRestorableGCI); + fill(buf, 40); + ndbout << " -- " << endl; + + sprintf(buf, "newestRestorableGCI = %u", sysfile->newestRestorableGCI); + fill(buf, 40); + ndbout << " -- " << endl; + + sprintf(buf, "latestLCP = %u", sysfile->latestLCP_ID); + fill(buf, 40); + ndbout << " -- " << endl; + + ndbout << "-- Node status: --" << endl; + for(int i = 1; i < MAX_NDB_NODES; i++){ + if(Sysfile::getNodeStatus(i, sysfile->nodeStatus) !=Sysfile::NS_NotDefined){ + sprintf(buf, + "Node %.2d -- %s GCP: %d, NodeGroup: %d, TakeOverNode: %d, " + "LCP Ongoing: %s", + i, + getNSString(Sysfile::getNodeStatus(i,sysfile->nodeStatus)), + sysfile->lastCompletedGCI[i], + Sysfile::getNodeGroup(i, sysfile->nodeGroups), + Sysfile::getTakeOverNode(i, sysfile->takeOver), + BitmaskImpl::get(NdbNodeBitmask::Size, + sysfile->lcpActive, i) != 0 ? "yes" : "no"); + ndbout << buf << endl; + } + } +} + +NDB_COMMAND(printSysfile, + "printSysfile", "printSysfile", "Prints a sysfile", 16384){ + if(argc < 2){ + usage(argv[0]); + return 0; + } + + for(int i = 1; i +#include +#include +#include + +#include +#include +#include +#include + +#ifdef DBLQH_C +// Constants +/* ------------------------------------------------------------------------- */ +/* CONSTANTS USED WHEN MASTER REQUESTS STATE OF COPY FRAGMENTS. */ +/* ------------------------------------------------------------------------- */ +#define ZCOPY_CLOSING 0 +#define ZCOPY_ONGOING 1 +#define ZCOPY_ACTIVATION 2 +/* ------------------------------------------------------------------------- */ +/* STATES FOR THE VARIABLE GCP_LOG_PART_STATE */ +/* ------------------------------------------------------------------------- */ +#define ZIDLE 0 +#define ZWAIT_DISK 1 +#define ZON_DISK 2 +#define ZACTIVE 1 +/* ------------------------------------------------------------------------- */ +/* STATES FOR THE VARIABLE CSR_PHASES_STARTED */ +/* ------------------------------------------------------------------------- */ +#define ZSR_NO_PHASE_STARTED 0 +#define ZSR_PHASE1_COMPLETED 1 +#define ZSR_PHASE2_COMPLETED 2 +#define ZSR_BOTH_PHASES_STARTED 3 +/* ------------------------------------------------------------------------- */ +/* THE NUMBER OF PAGES IN A MBYTE, THE TWO LOGARITHM OF THIS. */ +/* THE NUMBER OF MBYTES IN A LOG FILE. */ +/* THE MAX NUMBER OF PAGES READ/WRITTEN FROM/TO DISK DURING */ +/* A WRITE OR READ. */ +/* ------------------------------------------------------------------------- */ +#define ZNOT_DIRTY 0 +#define ZDIRTY 1 +#define ZREAD_AHEAD_SIZE 8 +/* ------------------------------------------------------------------------- */ +/* CONSTANTS OF THE LOG PAGES */ +/* ------------------------------------------------------------------------- */ +#define ZPAGE_HEADER_SIZE 32 +#if defined NDB_OSE +/** + * Set the fragment log file size to 2Mb in OSE + * This is done in order to speed up the initial start + */ +#define ZNO_MBYTES_IN_FILE 2 +#define ZPAGE_SIZE 2048 +#define ZPAGES_IN_MBYTE 128 +#define ZTWOLOG_NO_PAGES_IN_MBYTE 7 +#define ZTWOLOG_PAGE_SIZE 11 +#define ZMAX_MM_BUFFER_SIZE 32 // Main memory window during log execution +#else +#define ZNO_MBYTES_IN_FILE 16 +#define ZPAGE_SIZE 8192 +#define ZPAGES_IN_MBYTE 32 +#define ZTWOLOG_NO_PAGES_IN_MBYTE 5 +#define ZTWOLOG_PAGE_SIZE 13 +#define ZMAX_MM_BUFFER_SIZE 32 // Main memory window during log execution +#endif + +#define ZMAX_PAGES_WRITTEN 8 // Max pages before writing to disk (=> config) +#define ZMIN_READ_BUFFER_SIZE 2 // Minimum number of pages to execute log +#define ZMIN_LOG_PAGES_OPERATION 10 // Minimum no of pages before stopping + +#define ZPOS_CHECKSUM 0 +#define ZPOS_LOG_LAP 1 +#define ZPOS_MAX_GCI_COMPLETED 2 +#define ZPOS_MAX_GCI_STARTED 3 +#define ZNEXT_PAGE 4 +#define ZPREV_PAGE 5 +#define ZPOS_VERSION 6 +#define ZPOS_NO_LOG_FILES 7 +#define ZCURR_PAGE_INDEX 8 +#define ZLAST_LOG_PREP_REF 10 +#define ZPOS_DIRTY 11 +/* ------------------------------------------------------------------------- */ +/* CONSTANTS FOR THE VARIOUS REPLICA AND NODE TYPES. */ +/* ------------------------------------------------------------------------- */ +#define ZPRIMARY_NODE 0 +#define ZBACKUP_NODE 1 +#define ZSTANDBY_NODE 2 +#define ZTC_NODE 3 +#define ZLOG_NODE 3 +/* ------------------------------------------------------------------------- */ +/* VARIOUS CONSTANTS USED AS FLAGS TO THE FILE MANAGER. */ +/* ------------------------------------------------------------------------- */ +#define ZOPEN_READ 0 +#define ZOPEN_WRITE 1 +#define ZOPEN_READ_WRITE 2 +#define ZVAR_NO_LOG_PAGE_WORD 1 +#define ZLIST_OF_PAIRS 0 +#define ZLIST_OF_PAIRS_SYNCH 16 +#define ZARRAY_OF_PAGES 1 +#define ZLIST_OF_MEM_PAGES 2 +#define ZLIST_OF_MEM_PAGES_SYNCH 18 +#define ZCLOSE_NO_DELETE 0 +#define ZCLOSE_DELETE 1 +#define ZPAGE_ZERO 0 +/* ------------------------------------------------------------------------- */ +/* THE FOLLOWING CONSTANTS ARE USED TO DESCRIBE THE TYPES OF */ +/* LOG RECORDS, THE SIZE OF THE VARIOUS LOG RECORD TYPES AND */ +/* THE POSITIONS WITHIN THOSE LOG RECORDS. */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* THESE CONSTANTS DESCRIBE THE SIZES OF VARIOUS TYPES OF LOG REORDS. */ +/* NEXT_LOG_SIZE IS ACTUALLY ONE. THE REASON WE SET IT TO 2 IS TO */ +/* SIMPLIFY THE CODE SINCE OTHERWISE HAVE TO USE A SPECIAL VERSION */ +/* OF READ_LOGWORD WHEN READING LOG RECORD TYPE */ +/* SINCE NEXT MBYTE TYPE COULD BE THE VERY LAST WORD IN THE MBYTE. */ +/* BY SETTING IT TO 2 WE ENSURE IT IS NEVER THE VERY LAST WORD */ +/* IN THE MBYTE. */ +/* ------------------------------------------------------------------------- */ +#define ZFD_HEADER_SIZE 3 +#define ZFD_PART_SIZE 48 +#define ZLOG_HEAD_SIZE 6 +#define ZNEXT_LOG_SIZE 2 +#define ZABORT_LOG_SIZE 3 +#define ZCOMMIT_LOG_SIZE 9 +#define ZCOMPLETED_GCI_LOG_SIZE 2 +/* ------------------------------------------------------------------------- */ +/* THESE CONSTANTS DESCRIBE THE TYPE OF A LOG RECORD. */ +/* THIS IS THE FIRST WORD OF A LOG RECORD. */ +/* ------------------------------------------------------------------------- */ +#define ZNEW_PREP_OP_TYPE 0 +#define ZPREP_OP_TYPE 1 +#define ZCOMMIT_TYPE 2 +#define ZABORT_TYPE 3 +#define ZFD_TYPE 4 +#define ZFRAG_SPLIT_TYPE 5 +#define ZNEXT_LOG_RECORD_TYPE 6 +#define ZNEXT_MBYTE_TYPE 7 +#define ZCOMPLETED_GCI_TYPE 8 +#define ZINVALID_COMMIT_TYPE 9 +/* ------------------------------------------------------------------------- */ +/* THE POSITIONS OF LOGGED DATA IN A FILE DESCRIPTOR LOG RECORD HEADER.*/ +/* ALSO THE MAXIMUM NUMBER OF FILE DESCRIPTORS IN A LOG RECORD. */ +/* ------------------------------------------------------------------------- */ +#define ZPOS_LOG_TYPE 0 +#define ZPOS_NO_FD 1 +#define ZPOS_FILE_NO 2 +#define ZMAX_LOG_FILES_IN_PAGE_ZERO 40 +/* ------------------------------------------------------------------------- */ +/* THE POSITIONS WITHIN A PREPARE LOG RECORD AND A NEW PREPARE */ +/* LOG RECORD. */ +/* ------------------------------------------------------------------------- */ +#define ZPOS_HASH_VALUE 2 +#define ZPOS_SCHEMA_VERSION 3 +#define ZPOS_TRANS_TICKET 4 +#define ZPOS_OP_TYPE 5 +#define ZPOS_NO_ATTRINFO 6 +#define ZPOS_NO_KEYINFO 7 +/* ------------------------------------------------------------------------- */ +/* THE POSITIONS WITHIN A COMMIT LOG RECORD. */ +/* ------------------------------------------------------------------------- */ +#define ZPOS_COMMIT_TRANSID1 1 +#define ZPOS_COMMIT_TRANSID2 2 +#define ZPOS_COMMIT_GCI 3 +#define ZPOS_COMMIT_TABLE_REF 4 +#define ZPOS_COMMIT_FRAGID 5 +#define ZPOS_COMMIT_FILE_NO 6 +#define ZPOS_COMMIT_START_PAGE_NO 7 +#define ZPOS_COMMIT_START_PAGE_INDEX 8 +#define ZPOS_COMMIT_STOP_PAGE_NO 9 +/* ------------------------------------------------------------------------- */ +/* THE POSITIONS WITHIN A ABORT LOG RECORD. */ +/* ------------------------------------------------------------------------- */ +#define ZPOS_ABORT_TRANSID1 1 +#define ZPOS_ABORT_TRANSID2 2 +/* ------------------------------------------------------------------------- */ +/* THE POSITION WITHIN A COMPLETED GCI LOG RECORD. */ +/* ------------------------------------------------------------------------- */ +#define ZPOS_COMPLETED_GCI 1 +/* ------------------------------------------------------------------------- */ +/* THE POSITIONS WITHIN A NEW PREPARE LOG RECORD. */ +/* ------------------------------------------------------------------------- */ +#define ZPOS_NEW_PREP_FILE_NO 8 +#define ZPOS_NEW_PREP_PAGE_REF 9 + +#define ZLAST_WRITE_IN_FILE 1 +#define ZENFORCE_WRITE 2 +/* ------------------------------------------------------------------------- */ +/* CONSTANTS USED AS INPUT TO SUBROUTINE WRITE_LOG_PAGES AMONG OTHERS. */ +/* ------------------------------------------------------------------------- */ +#define ZNORMAL 0 +#define ZINIT 1 +/* ------------------------------------------------------------------------- */ +/* CONSTANTS USED BY CONTINUEB TO DEDUCE WHICH CONTINUE SIGNAL IS TO */ +/* BE EXECUTED AS A RESULT OF THIS CONTINUEB SIGNAL. */ +/* ------------------------------------------------------------------------- */ +#define ZLOG_LQHKEYREQ 0 +#define ZPACK_LQHKEYREQ 1 +#define ZSEND_ATTRINFO 2 +#define ZSR_GCI_LIMITS 3 +#define ZSR_LOG_LIMITS 4 +#define ZSEND_EXEC_CONF 5 +#define ZEXEC_SR 6 +#define ZSR_FOURTH_COMP 7 +#define ZINIT_FOURTH 8 +#define ZTIME_SUPERVISION 9 +#define ZSR_PHASE3_START 10 +#define ZLQH_TRANS_NEXT 11 +#define ZLQH_RELEASE_AT_NODE_FAILURE 12 +#define ZSCAN_TC_CONNECT 13 +#define ZINITIALISE_RECORDS 14 +#define ZINIT_GCP_REC 15 +#define ZRESTART_OPERATIONS_AFTER_STOP 16 +#define ZCHECK_LCP_STOP_BLOCKED 17 +#define ZSCAN_MARKERS 18 +#define ZOPERATION_EVENT_REP 19 +#define ZPREP_DROP_TABLE 20 + +/* ------------------------------------------------------------------------- */ +/* NODE STATE DURING SYSTEM RESTART, VARIABLES CNODES_SR_STATE */ +/* AND CNODES_EXEC_SR_STATE. */ +/* ------------------------------------------------------------------------- */ +#define ZSTART_SR 1 +#define ZEXEC_SR_COMPLETED 2 +/* ------------------------------------------------------------------------- */ +/* CONSTANTS USED BY NODE STATUS TO DEDUCE THE STATUS OF A NODE. */ +/* ------------------------------------------------------------------------- */ +#define ZNODE_UP 0 +#define ZNODE_DOWN 1 +/* ------------------------------------------------------------------------- */ +/* OPERATION TYPES */ +/* ------------------------------------------------------------------------- */ +#define ZSIMPLE_READ 1 +/* ------------------------------------------------------------------------- */ +/* START PHASES */ +/* ------------------------------------------------------------------------- */ +#define ZLAST_START_PHASE 255 +#define ZSTART_PHASE1 1 +#define ZSTART_PHASE2 2 +#define ZSTART_PHASE3 3 +#define ZSTART_PHASE4 4 +#define ZSTART_PHASE6 6 +/* ------------------------------------------------------------------------- */ +/* CONSTANTS USED BY SCAN AND COPY FRAGMENT PROCEDURES */ +/* ------------------------------------------------------------------------- */ +#define ZSTORED_PROC_SCAN 0 +#define ZSTORED_PROC_COPY 2 +#define ZDELETE_STORED_PROC_ID 3 +//#define ZSCAN_NEXT 1 +//#define ZSCAN_NEXT_COMMIT 2 +//#define ZSCAN_NEXT_ABORT 12 +#define ZCOPY_COMMIT 3 +#define ZCOPY_REPEAT 4 +#define ZCOPY_ABORT 5 +#define ZCOPY_CLOSE 6 +//#define ZSCAN_CLOSE 6 +//#define ZEMPTY_FRAGMENT 0 +#define ZWRITE_LOCK 1 +#define ZSCAN_FRAG_CLOSED 2 +/* ------------------------------------------------------------------------- */ +/* ERROR CODES ADDED IN VERSION 0.1 AND 0.2 */ +/* ------------------------------------------------------------------------- */ +#define ZNOT_FOUND 1 // Not an error code, a return value +#define ZNO_FREE_LQH_CONNECTION 414 +#define ZGET_DATAREC_ERROR 418 +#define ZGET_ATTRINBUF_ERROR 419 +#define ZNO_FREE_FRAGMENTREC 460 // Insert new fragment error code +#define ZTAB_FILE_SIZE 464 // Insert new fragment error code + Start kernel +#define ZNO_ADD_FRAGREC 465 // Insert new fragment error code +/* ------------------------------------------------------------------------- */ +/* ERROR CODES ADDED IN VERSION 0.3 */ +/* ------------------------------------------------------------------------- */ +#define ZTAIL_PROBLEM_IN_LOG_ERROR 410 +#define ZGCI_TOO_LOW_ERROR 429 // GCP_SAVEREF error code +#define ZTAB_STATE_ERROR 474 // Insert new fragment error code +#define ZTOO_NEW_GCI_ERROR 479 // LCP Start error +/* ------------------------------------------------------------------------- */ +/* ERROR CODES ADDED IN VERSION 0.4 */ +/* ------------------------------------------------------------------------- */ + +#define ZNO_FREE_FRAG_SCAN_REC_ERROR 490 // SCAN_FRAGREF error code +#define ZCOPY_NO_FRAGMENT_ERROR 491 // COPY_FRAGREF error code +#define ZTAKE_OVER_ERROR 499 +#define ZCOPY_NODE_ERROR 1204 +#define ZTOO_MANY_COPY_ACTIVE_ERROR 1208 // COPY_FRAG and COPY_ACTIVEREF code +#define ZCOPY_ACTIVE_ERROR 1210 // COPY_ACTIVEREF error code +#define ZNO_TC_CONNECT_ERROR 1217 // Simple Read + SCAN +/* ------------------------------------------------------------------------- */ +/* ERROR CODES ADDED IN VERSION 1.X */ +/* ------------------------------------------------------------------------- */ +//#define ZSCAN_BOOK_ACC_OP_ERROR 1219 // SCAN_FRAGREF error code +#define ZFILE_CHANGE_PROBLEM_IN_LOG_ERROR 1220 +#define ZTEMPORARY_REDO_LOG_FAILURE 1221 +#define ZNO_FREE_MARKER_RECORDS_ERROR 1222 +#define ZNODE_SHUTDOWN_IN_PROGESS 1223 +#define ZTOO_MANY_FRAGMENTS 1224 +#define ZTABLE_NOT_DEFINED 1225 +#define ZDROP_TABLE_IN_PROGRESS 1226 +#define ZINVALID_SCHEMA_VERSION 1227 + +/* ------------------------------------------------------------------------- */ +/* ERROR CODES ADDED IN VERSION 2.X */ +/* ------------------------------------------------------------------------- */ +#define ZNODE_FAILURE_ERROR 400 +/* ------------------------------------------------------------------------- */ +/* ERROR CODES FROM ACC */ +/* ------------------------------------------------------------------------- */ +#define ZNO_TUPLE_FOUND 626 +#define ZTUPLE_ALREADY_EXIST 630 +/* ------------------------------------------------------------------------- */ +/* ERROR CODES FROM TUP */ +/* ------------------------------------------------------------------------- */ +#define ZSEARCH_CONDITION_FALSE 899 +#define ZUSER_ERROR_CODE_LIMIT 6000 +#endif + +/** + * @class dblqh + * + * @section secIntro Introduction + * + * Dblqh is the coordinator of the LDM. Dblqh is responsible for + * performing operations on tuples. It does this job with help of + * Dbacc block (that manages the index structures) and Dbtup + * (that manages the tuples). + * + * Dblqh also keeps track of the participants and acts as a coordinator of + * 2-phase commits. Logical redo logging is also handled by the Dblqh + * block. + * + * @section secModules Modules + * + * The code is partitioned into the following modules: + * - START / RESTART + * - Start phase 1: Load our block reference and our processor id + * - Start phase 2: Initiate all records within the block + * Connect LQH with ACC and TUP. + * - Start phase 4: Connect LQH with LQH. Connect every LQH with + * every LQH in the database system. + * If initial start, then create the fragment log files. + * If system restart or node restart, + * then open the fragment log files and + * find the end of the log files. + * - ADD / DELETE FRAGMENT
    + * Used by dictionary to create new fragments and delete old fragments. + * - EXECUTION
    + * handles the reception of lqhkeyreq and all processing + * of operations on behalf of this request. + * This does also involve reception of various types of attrinfo + * and keyinfo. + * It also involves communication with ACC and TUP. + * - LOG
    + * The log module handles the reading and writing of the log. + * It is also responsible for handling system restart. + * It controls the system restart in TUP and ACC as well. + * - TRANSACTION
    + * This module handles the commit and the complete phases. + * - MODULE TO HANDLE TC FAILURE
    + * - SCAN
    + * This module contains the code that handles a scan of a particular + * fragment. + * It operates under the control of TC and orders ACC to + * perform a scan of all tuples in the fragment. + * TUP performs the necessary search conditions + * to ensure that only valid tuples are returned to the application. + * - NODE RECOVERY
    + * Used when a node has failed. + * It performs a copy of a fragment to a new replica of the fragment. + * It does also shut down all connections to the failed node. + * - LOCAL CHECKPOINT
    + * Handles execution and control of LCPs + * It controls the LCPs in TUP and ACC. + * It also interacts with DIH to control which GCPs are recoverable. + * - GLOBAL CHECKPOINT
    + * Helps DIH in discovering when GCPs are recoverable. + * It handles the request gcp_savereq that requests LQH to + * save a particular GCP to disk and respond when completed. + * - FILE HANDLING
    + * With submodules: + * - SIGNAL RECEPTION + * - NORMAL OPERATION + * - FILE CHANGE + * - INITIAL START + * - SYSTEM RESTART PHASE ONE + * - SYSTEM RESTART PHASE TWO, + * - SYSTEM RESTART PHASE THREE + * - SYSTEM RESTART PHASE FOUR + * - ERROR + * - TEST + * - LOG + */ +class Dblqh: public SimulatedBlock { +public: + + enum LcpCloseState { + LCP_IDLE = 0, + LCP_RUNNING = 1, // LCP is running + LCP_CLOSE_STARTED = 2, // Completion(closing of files) has started + ACC_LCP_CLOSE_COMPLETED = 3, + TUP_LCP_CLOSE_COMPLETED = 4 + }; + + enum ExecUndoLogState { + EULS_IDLE = 0, + EULS_STARTED = 1, + EULS_COMPLETED = 2, + EULS_ACC_COMPLETED = 3, + EULS_TUP_COMPLETED = 4 + }; + + struct AddFragRecord { + enum AddFragStatus { + FREE = 0, + ACC_ADDFRAG = 1, + WAIT_TWO_TUP = 2, + WAIT_ONE_TUP = 3, + WAIT_TWO_TUX = 4, + WAIT_ONE_TUX = 5, + WAIT_ADD_ATTR = 6, + TUP_ATTR_WAIT1 = 7, + TUP_ATTR_WAIT2 = 8, + TUX_ATTR_WAIT1 = 9, + TUX_ATTR_WAIT2 = 10 + }; + LqhAddAttrReq::Entry attributes[LqhAddAttrReq::MAX_ATTRIBUTES]; + UintR accConnectptr; + AddFragStatus addfragStatus; + UintR dictConnectptr; + UintR fragmentPtr; + UintR nextAddfragrec; + UintR noOfAllocPages; + UintR schemaVer; + UintR tup1Connectptr; + UintR tup2Connectptr; + UintR tux1Connectptr; + UintR tux2Connectptr; + UintR checksumIndicator; + UintR GCPIndicator; + BlockReference dictBlockref; + Uint32 m_senderAttrPtr; + Uint16 addfragErrorCode; + Uint16 attrSentToTup; + Uint16 attrReceived; + Uint16 addFragid; + Uint16 fragid1; + Uint16 fragid2; + Uint16 noOfAttr; + Uint16 noOfNull; + Uint16 tabId; + Uint16 totalAttrReceived; + Uint16 fragCopyCreation; + Uint16 noOfKeyAttr; + Uint16 noOfNewAttr; + Uint16 noOfAttributeGroups; + Uint16 lh3DistrBits; + Uint16 tableType; + Uint16 primaryTableId; + };// Size 108 bytes + typedef Ptr AddFragRecordPtr; + + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /* $$$$$$$ ATTRIBUTE INFORMATION RECORD $$$$$$$ */ + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /** + * Can contain one (1) attrinfo signal. + * One signal contains 24 attr. info words. + * But 32 elements are used to make plex happy. + * Some of the elements are used to the following things: + * - Data length in this record is stored in the + * element indexed by ZINBUF_DATA_LEN. + * - Next attrinbuf is pointed out by the element + * indexed by ZINBUF_NEXT. + */ + struct Attrbuf { + UintR attrbuf[32]; + }; // Size 128 bytes + typedef Ptr AttrbufPtr; + + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /* $$$$$$$ DATA BUFFER $$$$$$$ */ + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /** + * This buffer is used as a general data storage. + */ + struct Databuf { + UintR data[4]; + UintR nextDatabuf; + }; // size 20 bytes + typedef Ptr DatabufPtr; + + struct Fragrecord { + enum ExecSrStatus { + IDLE = 0, + ACTIVE_REMOVE_AFTER = 1, + ACTIVE = 2 + }; + /** + * Possible state transitions are: + * - FREE -> DEFINED Fragment record is allocated + * - DEFINED -> ACTIVE Add fragment is completed and + * fragment is ready to + * receive operations. + * - DEFINED -> ACTIVE_CREATION Add fragment is completed and + * fragment is ready to + * receive operations in parallel + * with a copy fragment + * which is performed from the + * primary replica + * - DEFINED -> CRASH_RECOVERING A fragment is ready to be + * recovered from a local + * checkpoint on disk + * - ACTIVE -> BLOCKED A local checkpoint is to be + * started. No more operations + * are allowed to be started until + * the local checkpoint + * has been started. + * - ACTIVE -> REMOVING A fragment is removed from the node + * - BLOCKED -> ACTIVE Operations are allowed again in + * the fragment. + * - CRASH_RECOVERING -> ACTIVE A fragment has been recovered and + * are now ready for + * operations again. + * - CRASH_RECOVERING -> REMOVING Fragment recovery failed or + * was cancelled. + * - ACTIVE_CREATION -> ACTIVE A fragment is now copied and now + * is a normal fragment + * - ACTIVE_CREATION -> REMOVING Copying of the fragment failed + * - REMOVING -> FREE Removing of the fragment is + * completed and the fragment + * is now free again. + */ + enum FragStatus { + FREE = 0, ///< Fragment record is currently not in use + FSACTIVE = 1, ///< Fragment is defined and usable for operations + DEFINED = 2, ///< Fragment is defined but not yet usable by + ///< operations + BLOCKED = 3, ///< LQH is waiting for all active operations to + ///< complete the current phase so that the + ///< local checkpoint can be started. + ACTIVE_CREATION = 4, ///< Fragment is defined and active but is under + ///< creation by the primary LQH. + CRASH_RECOVERING = 5, ///< Fragment is recovering after a crash by + ///< executing the fragment log and so forth. + ///< Will need further breakdown. + REMOVING = 6 ///< The fragment is currently removed. + ///< Operations are not allowed. + }; + enum LogFlag { + STATE_TRUE = 0, + STATE_FALSE = 1 + }; + enum SrStatus { + SS_IDLE = 0, + SS_STARTED = 1, + SS_COMPLETED = 2 + }; + enum LcpFlag { + LCP_STATE_TRUE = 0, + LCP_STATE_FALSE = 1 + }; + /** + * Last GCI for executing the fragment log in this phase. + */ + UintR execSrLastGci[4]; + /** + * Start GCI for executing the fragment log in this phase. + */ + UintR execSrStartGci[4]; + /** + * Requesting user pointer for executing the fragment log in + * this phase + */ + UintR execSrUserptr[4]; + /** + * The LCP identifier of the LCP's. + * =0 means that the LCP number has not been stored. + * The LCP identifier is supplied by DIH when starting the LCP. + */ + UintR lcpId[MAX_LCP_STORED]; + UintR maxGciInLcp; + /** + * This variable contains the maximum global checkpoint + * identifier that exists in a certain local checkpoint. + * Maximum 4 local checkpoints is possible in this release. + */ + UintR maxGciCompletedInLcp; + UintR srLastGci[4]; + UintR srStartGci[4]; + /** + * The fragment pointers in ACC + */ + UintR accFragptr[2]; + /** + * The EXEC_SR variables are used to keep track of which fragments + * that are interested in being executed as part of executing the + * fragment loop. + * It is initialised for every phase of executing the + * fragment log (the fragment log can be executed upto four times). + * + * Each execution is capable of executing the log records on four + * fragment replicas. + */ + /** + * Requesting block reference for executing the fragment log + * in this phase. + */ + BlockReference execSrBlockref[4]; + /** + * This variable contains references to active scan and copy + * fragment operations on the fragment. + * A maximum of four concurrently active is allowed. + */ + Uint16 fragScanRec[MAX_PARALLEL_SCANS_PER_FRAG + MAX_PARALLEL_INDEX_SCANS_PER_FRAG]; + Uint16 srLqhLognode[4]; + /** + * The fragment pointers in TUP and TUX + */ + UintR tupFragptr[2]; + UintR tuxFragptr[2]; + /** + * This queue is where operations are put when blocked in ACC + * during start of a local chkp. + */ + UintR accBlockedList; + /** + * This is the queue where all operations that are active on the + * fragment is put. + * This is used to deduct when the fragment do + * no longer contain any active operations. + * This is needed when starting a local checkpoint. + */ + UintR activeList; + /** + * This variable keeps track of how many operations that are + * active that have skipped writing the log but not yet committed + * or aborted. This is used during start of fragment. + */ + UintR activeTcCounter; + /** + * This status specifies whether this fragment is actively + * engaged in executing the fragment log. + */ + ExecSrStatus execSrStatus; + /** + * The fragment id of this fragment. + */ + UintR fragId; + /** + * Status of fragment + */ + FragStatus fragStatus; + /** + * Indicates a local checkpoint is active and thus can generate + * UNDO log records. + */ + UintR fragActiveStatus; + /** + * Reference to current LCP record. + * If no LCP is ongoing on the fragment then the value is RNIL. + * If LCP_REF /= RNIL then a local checkpoint is ongoing in the + * fragment. + * LCP_STATE in LCP_RECORD specifies the state of the + * local checkpoint. + */ + UintR lcpRef; + /** + * This flag indicates whether logging is currently activated at + * the fragment. + * During a system restart it is temporarily shut off. + * Some fragments have it permanently shut off. + */ + LogFlag logFlag; + UintR masterPtr; + /** + * This variable contains the maximum global checkpoint identifier + * which was completed when the local checkpoint was started. + */ + /** + * Reference to the next fragment record in a free list of fragment + * records. + */ + UintR nextFrag; + /** + * The newest GCI that has been committed on fragment + */ + UintR newestGci; + SrStatus srStatus; + UintR srUserptr; + /** + * The starting global checkpoint of this fragment. + */ + UintR startGci; + /** + * A reference to the table owning this fragment. + */ + UintR tabRef; + /** + * This is the queue to put operations that have been blocked + * during start of a local chkp. + */ + UintR firstWaitQueue; + UintR lastWaitQueue; + /** + * The block reference to ACC on the fragment makes it + * possible to have different ACC blocks for different + * fragments in the future. + */ + BlockReference accBlockref; + /** + * Ordered index block. + */ + BlockReference tuxBlockref; + /** + * The master block reference as sent in COPY_ACTIVEREQ. + */ + BlockReference masterBlockref; + /** + * These variables are used during system restart to recall + * from which node to execute the fragment log and which GCI's + * this node should start and stop from. Also to remember who + * to send the response to when system restart is completed. + */ + BlockReference srBlockref; + /** + * The block reference to TUP on the fragment makes it + * possible to have different TUP blocks for different + * fragments in the future. + */ + BlockReference tupBlockref; + /** + * This state indicates if the fragment will participate in a + * checkpoint. + * Temporary tables with Fragrecord::logFlag permanently off + * will also have Fragrecord::lcpFlag off. + */ + LcpFlag lcpFlag; + /** + * Used to ensure that updates started with old + * configuration do not arrive here after the copy fragment + * has started. + * If they are allowed to arrive after they + * could update a record that has already been replicated to + * the new node. This type of arrival should be extremely + * rare but we must anyway ensure that no harm is done. + */ + Uint16 copyNode; + /** + * This variable ensures that only one copy fragment is + * active at a time on the fragment. + */ + Uint8 copyFragState; + /** + * The number of fragment replicas that will execute the log + * records in this round of executing the fragment + * log. Maximum four is possible. + */ + Uint8 execSrNoReplicas; + /** + * This variable contains what type of replica this fragment + * is. Two types are possible: + * - Primary/Backup replica = 0 + * - Stand-by replica = 1 + * + * It is not possible to distinguish between primary and + * backup on a fragment. + * This can only be done per transaction. + * DIH can change from primary to backup without informing + * the various replicas about this change. + */ + Uint8 fragCopy; + /** + * This is the last fragment distribution key that we have + * heard of. + */ + Uint8 fragDistributionKey; + /** + * Used to calculate which local fragment to use. + */ + Uint8 hashCheckBit; + /** + * The identity of the next local checkpoint this fragment + * should perform. + */ + Uint8 nextLcp; + /** + * The number of active scans currently in the fragment + * replica. + */ + Uint8 noActiveScan; + /** + * How many local checkpoints does the fragment contain + */ + Uint8 srChkpnr; + Uint8 srNoLognodes; + /** + * Table type. + */ + Uint8 tableType; + /** + * For ordered index fragment, i-value of corresponding + * fragment in primary table. + */ + UintR tableFragptr; + }; + typedef Ptr FragrecordPtr; + + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /* $$$$$$$ GLOBAL CHECKPOINT RECORD $$$$$$ */ + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /** + * This record describes a global checkpoint that is + * completed. It waits for all log records belonging to this + * global checkpoint to be saved on disk. + */ + struct GcpRecord { + /** + * The file number within each log part where the log was + * located when gcp_savereq was received. The last record + * belonging to this global checkpoint is certainly before + * this place in the log. We could come even closer but it + * would cost performance and doesn't seem like a good + * idea. This is simple and it works. + */ + Uint16 gcpFilePtr[4]; + /** + * The page number within the file for each log part. + */ + Uint16 gcpPageNo[4]; + /** + * The word number within the last page that was written for + * each log part. + */ + Uint16 gcpWordNo[4]; + /** + * The identity of this global checkpoint. + */ + UintR gcpId; + /** + * The state of this global checkpoint, one for each log part. + */ + Uint8 gcpLogPartState[4]; + /** + * The sync state of this global checkpoint, one for each + * log part. + */ + Uint8 gcpSyncReady[4]; + /** + * User pointer of the sender of gcp_savereq (= master DIH). + */ + UintR gcpUserptr; + /** + * Block reference of the sender of gcp_savereq + * (= master DIH). + */ + BlockReference gcpBlockref; + }; // Size 44 bytes + typedef Ptr GcpRecordPtr; + + struct HostRecord { + bool inPackedList; + UintR noOfPackedWordsLqh; + UintR packedWordsLqh[30]; + UintR noOfPackedWordsTc; + UintR packedWordsTc[29]; + BlockReference hostLqhBlockRef; + BlockReference hostTcBlockRef; + };// Size 128 bytes + typedef Ptr HostRecordPtr; + + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /* $$$$$$$ LOCAL CHECKPOINT RECORD $$$$$$$ */ + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /** + * This record contains the information about a local + * checkpoint that is ongoing. This record is also used as a + * system restart record. + */ + struct LcpRecord { + LcpRecord() { m_EMPTY_LCP_REQ.clear(); } + + enum LcpState { + LCP_IDLE = 0, + LCP_STARTED = 1, + LCP_COMPLETED = 2, + LCP_WAIT_FRAGID = 3, + LCP_WAIT_TUP_PREPLCP = 4, + LCP_WAIT_HOLDOPS = 5, + LCP_WAIT_ACTIVE_FINISH = 6, + LCP_START_CHKP = 7, + LCP_BLOCKED_COMP = 8, + LCP_SR_WAIT_FRAGID = 9, + LCP_SR_STARTED = 10, + LCP_SR_COMPLETED = 11 + }; + Uint32 firstLcpLocAcc; + Uint32 firstLcpLocTup; + Uint32 lcpAccptr; + + LcpState lcpState; + bool lastFragmentFlag; + + struct FragOrd { + Uint32 fragPtrI; + LcpFragOrd lcpFragOrd; + }; + FragOrd currentFragment; + + bool lcpQueued; + FragOrd queuedFragment; + + bool reportEmpty; + NdbNodeBitmask m_EMPTY_LCP_REQ; + }; // Size 76 bytes + typedef Ptr LcpRecordPtr; + + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /* $$$$$$ LOCAL CHECKPOINT SUPPORT RECORD $$$$$$$ */ + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /** + * This record contains the information about an outstanding + * request to TUP or ACC. Used for both local checkpoints and + * system restart. + */ + struct LcpLocRecord { + enum LcpLocstate { + IDLE = 0, + WAIT_TUP_PREPLCP = 1, + WAIT_LCPHOLDOP = 2, + HOLDOP_READY = 3, + ACC_WAIT_STARTED = 4, + ACC_STARTED = 5, + ACC_COMPLETED = 6, + TUP_WAIT_STARTED = 7, + TUP_STARTED = 8, + TUP_COMPLETED = 9, + SR_ACC_STARTED = 10, + SR_TUP_STARTED = 11, + SR_ACC_COMPLETED = 12, + SR_TUP_COMPLETED = 13 + }; + enum WaitingBlock { + ACC = 0, + TUP = 1, + NONE = 2 + }; + + LcpLocstate lcpLocstate; + UintR locFragid; + UintR masterLcpRec; + UintR nextLcpLoc; + UintR tupRef; + WaitingBlock waitingBlock; + Uint32 accContCounter; + }; // 28 bytes + typedef Ptr LcpLocRecordPtr; + + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /* */ + /* THE RECORDS THAT START BY LOG_ ARE A PART OF THE LOG MANAGER. */ + /* THESE RECORDS ARE USED TO HANDLE THE FRAGMENT LOG. */ + /* */ + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /* $$$$$$$ LOG RECORD $$$$$$$ */ + /* */ + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /* THIS RECORD IS ALIGNED TO BE 256 BYTES. */ + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /** + * This record describes the current state of a log. + * A log consists of a number of log files. + * These log files are described by the log file record. + * + * There will be 4 sets of log files. + * Different tables will use different log files dependent + * on the table id. + * This ensures that more than one outstanding request can + * be sent to the file system. + * The log file to use is found by performing a very simple hash + * function. + */ + struct LogPartRecord { + enum LogPartState { + IDLE = 0, ///< Nothing happens at the moment + ACTIVE = 1, ///< An operation is active logging + SR_FIRST_PHASE = 2, ///< Finding the end of the log and + ///< the information about global + ///< checkpoints in the log is ongoing. + SR_FIRST_PHASE_COMPLETED = 3, ///< First phase completed + SR_THIRD_PHASE_STARTED = 4, ///< Executing fragment log is in 3rd ph + SR_THIRD_PHASE_COMPLETED = 5, + SR_FOURTH_PHASE_STARTED = 6, ///< Finding the log tail and head + ///< is the fourth phase. + SR_FOURTH_PHASE_COMPLETED = 7, + FILE_CHANGE_PROBLEM = 8, ///< For some reason the write to + ///< page zero in file zero have not + ///< finished after 15 mbyte of + ///< log data have been written + TAIL_PROBLEM = 9 ///< Only 1 mbyte of log left. + ///< No operations allowed to enter the + ///< log. Only special log records + ///< are allowed + }; + enum WaitWriteGciLog { + WWGL_TRUE = 0, + WWGL_FALSE = 1 + }; + enum LogExecState { + LES_IDLE = 0, + LES_SEARCH_STOP = 1, + LES_SEARCH_START = 2, + LES_EXEC_LOG = 3, + LES_EXEC_LOG_NEW_MBYTE = 4, + LES_EXEC_LOG_NEW_FILE = 5, + LES_EXEC_LOGREC_FROM_FILE = 6, + LES_EXEC_LOG_COMPLETED = 7, + LES_WAIT_READ_EXEC_SR_NEW_MBYTE = 8, + LES_WAIT_READ_EXEC_SR = 9, + LES_EXEC_LOG_INVALIDATE = 10 + }; + + /** + * Is a CONTINUEB(ZLOG_LQHKEYREQ) signal sent and + * outstanding. We do not want several instances of this + * signal out in the air since that would create multiple + * writers of the list. + */ + UintR LogLqhKeyReqSent; + /** + * Contains the current log file where log records are + * written. During system restart it is used to indicate the + * last log file. + */ + UintR currentLogfile; + /** + * The log file used to execute log records from far behind. + */ + UintR execSrExecLogFile; + /** + * The currently executing prepare record starts in this log + * page. This variable is used to enable that a log record is + * executed multiple times in execution of the log. + */ + UintR execSrLogPage; + /** + * This variable keeps track of the lfo record where the + * pages that were read from disk when an operations log + * record were not found in the main memory buffer for log + * pages. + */ + UintR execSrLfoRec; + /** + * The starting page number when reading log from far behind. + */ + UintR execSrStartPageNo; + /** + * The last page number when reading log from far behind. + */ + UintR execSrStopPageNo; + /** + * Contains a reference to the first log file, file number 0. + */ + UintR firstLogfile; + /** + * The head of the operations queued for logging. + */ + UintR firstLogQueue; + /** + * This variable contains the oldest operation in this log + * part which have not been committed yet. + */ + UintR firstLogTcrec; + /** + * The first reference to a set of 8 pages. These are used + * during execution of the log to keep track of which pages + * are in memory and which are not. + */ + UintR firstPageRef; + /** + * This variable contains the global checkpoint record + * waiting for disk writes to complete. + */ + UintR gcprec; + /** + * The last reference to a set of 8 pages. These are used + * during execution of the log to keep track of which pages + * are in memory and which are not. + */ + UintR lastPageRef; + /** + * The tail of the operations queued for logging. + */ + UintR lastLogQueue; + /** + * This variable contains the newest operation in this log + * part which have not been committed yet. + */ + UintR lastLogTcrec; + /** + * This variable indicates which was the last mbyte that was + * written before the system crashed. Discovered during + * system restart. + */ + UintR lastLogfile; + /** + * This variable is used to keep track of the state during + * the third phase of the system restart, i.e. when + * LogPartRecord::logPartState == + * LogPartRecord::SR_THIRD_PHASE_STARTED. + */ + LogExecState logExecState; + /** + * This variable contains the lap number of this log part. + */ + UintR logLap; + /** + * This variable contains the place to stop executing the log + * in this phase. + */ + UintR logLastGci; + /** + * This variable contains the place to start executing the + * log in this phase. + */ + UintR logStartGci; + /** + * The latest GCI completed in this log part. + */ + UintR logPartNewestCompletedGCI; + /** + * The current state of this log part. + */ + LogPartState logPartState; + /** + * A timer that is set every time a log page is sent to disk. + * Ensures that log pages are not kept in main memory for + * more than a certain time. + */ + UintR logPartTimer; + /** + * The current timer which is set by the periodic signal + * received by LQH + */ + UintR logTimer; + /** + * Contains the number of the log tail file and the mbyte + * reference within that file. This information ensures that + * the tail is not overwritten when writing new log records. + */ + UintR logTailFileNo; + /** + * The TcConnectionrec used during execution of this log part. + */ + UintR logTcConrec; + /** + * The number of pages that currently resides in the main + * memory buffer. It does not refer pages that are currently + * read from the log files. Only to pages already read + * from the log file. + */ + UintR mmBufferSize; + /** + * Contains the current number of log files in this log part. + */ + UintR noLogFiles; + /** + * This variable is used only during execution of a log + * record. It keeps track of in which page record a log + * record was started. It is used then to deduce which + * pages that are dirty after that the log records on the + * page have been executed. + * + * It is also used to find out where to write the invalidate + * command when that is needed. + */ + UintR prevLogpage; + /** + * The number of files remaining to gather GCI information + * for during system restart. Only used if number of files + * is larger than 60. + */ + UintR srRemainingFiles; + /** + * The log file where to start executing the log during + * system restart. + */ + UintR startLogfile; + /** + * The last log file in which to execute the log during system + * restart. + */ + UintR stopLogfile; + /** + * This variable keeps track of when we want to write a complete + * gci log record but have been blocked by an ongoing log operation. + */ + WaitWriteGciLog waitWriteGciLog; + /** + * The currently executing prepare record starts in this index + * in the log page. + */ + Uint16 execSrLogPageIndex; + /** + * Which of the four exec_sr's in the fragment is currently executing + */ + Uint16 execSrExecuteIndex; + /** + * The number of pages executed in the current mbyte. + */ + Uint16 execSrPagesExecuted; + /** + * The number of pages read from disk that have arrived and are + * currently awaiting execution of the log. + */ + Uint16 execSrPagesRead; + /** + * The number of pages read from disk and currently not arrived + * to the block. + */ + Uint16 execSrPagesReading; + /** + * This variable refers to the new header file where we will + * start writing the log after a system restart have been completed. + */ + Uint16 headFileNo; + /** + * This variable refers to the page number within the header file. + */ + Uint16 headPageNo; + /** + * This variable refers to the index within the new header + * page. + */ + Uint16 headPageIndex; + /** + * This variables indicates which was the last mbyte in the last + * logfile before a system crash. Discovered during system restart. + */ + Uint16 lastMbyte; + /** + * This variable is used only during execution of a log + * record. It keeps track of in which file page a log + * record was started. It is used if it is needed to write a + * dirty page to disk during log execution (this happens when + * commit records are invalidated). + */ + Uint16 prevFilepage; + /** + * This is used to save where we were in the execution of log + * records when we find a commit record that needs to be + * executed. + * + * This variable is also used to remember the index where the + * log type was in the log record. It is only used in this + * role when finding a commit record that needs to be + * invalidated. + */ + Uint16 savePageIndex; + Uint8 logTailMbyte; + /** + * The mbyte within the starting log file where to start + * executing the log. + */ + Uint8 startMbyte; + /** + * The last mbyte in which to execute the log during system + * restart. + */ + Uint8 stopMbyte; + /** + * This variable refers to the file where invalidation is + * occuring during system/node restart. + */ + Uint16 invalidateFileNo; + /** + * This variable refers to the page where invalidation is + * occuring during system/node restart. + */ + Uint16 invalidatePageNo; + }; // Size 164 Bytes + typedef Ptr LogPartRecordPtr; + + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /* $$$$$$$ LOG FILE RECORD $$$$$$$ */ + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /* THIS RECORD IS ALIGNED TO BE 288 (256 + 32) BYTES. */ + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /** + * This record contains information about a log file. + * A log file contains log records from several tables and + * fragments of a table. LQH can contain more than + * one log file to ensure faster log processing. + * + * The number of pages to write to disk at a time is + * configurable. + */ + struct LogFileRecord { + enum FileChangeState { + NOT_ONGOING = 0, + BOTH_WRITES_ONGOING = 1, + LAST_WRITE_ONGOING = 2, + FIRST_WRITE_ONGOING = 3, + WRITE_PAGE_ZERO_ONGOING = 4 + }; + enum LogFileStatus { + LFS_IDLE = 0, ///< Log file record not in use + CLOSED = 1, ///< Log file closed + OPENING_INIT = 2, + OPEN_SR_FRONTPAGE = 3, ///< Log file opened as part of system + ///< restart. Open file 0 to find + ///< the front page of the log part. + OPEN_SR_LAST_FILE = 4, ///< Open last log file that was written + ///< before the system restart. + OPEN_SR_NEXT_FILE = 5, ///< Open a log file which is 16 files + ///< backwards to find the next + ///< information about GCPs. + OPEN_EXEC_SR_START = 6, ///< Log file opened as part of + ///< executing + ///< log during system restart. + OPEN_EXEC_SR_NEW_MBYTE = 7, + OPEN_SR_FOURTH_PHASE = 8, + OPEN_SR_FOURTH_NEXT = 9, + OPEN_SR_FOURTH_ZERO = 10, + OPENING_WRITE_LOG = 11, ///< Log file opened as part of writing + ///< log during normal operation. + OPEN_EXEC_LOG = 12, + CLOSING_INIT = 13, + CLOSING_SR = 14, ///< Log file closed as part of system + ///< restart. Currently trying to + ///< find where to start executing the + ///< log + CLOSING_EXEC_SR = 15, ///< Log file closed as part of + ///< executing log during system restart + CLOSING_EXEC_SR_COMPLETED = 16, + CLOSING_WRITE_LOG = 17, ///< Log file closed as part of writing + ///< log during normal operation. + CLOSING_EXEC_LOG = 18, + OPEN_INIT = 19, + OPEN = 20, ///< Log file open + OPEN_SR_INVALIDATE_PAGES = 21, + CLOSE_SR_INVALIDATE_PAGES = 22 + }; + + /** + * When a new mbyte is started in the log we have to find out + * how far back in the log we still have prepared operations + * which have been neither committed or aborted. This variable + * keeps track of this value for each of the mbytes in this + * log file. This is used in writing down these values in the + * header of each log file. That information is used during + * system restart to find the tail of the log. + */ + UintR logLastPrepRef[16]; + /** + * The max global checkpoint completed before the mbyte in the + * log file was started. One variable per mbyte. + */ + UintR logMaxGciCompleted[16]; + /** + * The max global checkpoint started before the mbyte in the log + * file was started. One variable per mbyte. + */ + UintR logMaxGciStarted[16]; + /** + * This variable contains the file name as needed by the file + * system when opening the file. + */ + UintR fileName[4]; + /** + * This variable has a reference to the log page which is + * currently in use by the log. + */ + UintR currentLogpage; + /** + * The number of the current mbyte in the log file. + */ + UintR currentMbyte; + /** + * This variable is used when changing files. It is to find + * out when both the last write in the previous file and the + * first write in this file has been completed. After these + * writes have completed the variable keeps track of when the + * write to page zero in file zero is completed. + */ + FileChangeState fileChangeState; + /** + * The number of the file within this log part. + */ + UintR fileNo; + /** + * This variable shows where to read/write the next pages into + * the log. Used when writing the log during normal operation + * and when reading the log during system restart. It + * specifies the page position where each page is 8 kbyte. + */ + UintR filePosition; + /** + * This contains the file pointer needed by the file system + * when reading/writing/closing and synching. + */ + UintR fileRef; + /** + * The head of the pages waiting for shipment to disk. + * They are filled with log info. + */ + UintR firstFilledPage; + /** + * A list of active read/write operations on the log file. + * Operations are always put in last and the first should + * always complete first. + */ + UintR firstLfo; + UintR lastLfo; + /** + * The tail of the pages waiting for shipment to disk. + * They are filled with log info. + */ + UintR lastFilledPage; + /** + * This variable keeps track of the last written page in the + * file while writing page zero in file zero when changing log + * file. + */ + UintR lastPageWritten; + /** + * This variable keeps track of the last written word in the + * last page written in the file while writing page zero in + * file zero when changing log file. + */ + UintR lastWordWritten; + /** + * This variable contains the last word written in the last page. + */ + UintR logFilePagesToDiskWithoutSynch; + /** + * This variable keeps track of the number of pages written since + * last synch on this log file. + */ + LogFileStatus logFileStatus; + /** + * A reference to page zero in this file. + * This page is written before the file is closed. + */ + UintR logPageZero; + /** + * This variable contains a reference to the record describing + * this log part. One of four records (0,1,2 or 3). + */ + UintR logPartRec; + /** + * Next free log file record or next log file in this log. + */ + UintR nextLogFile; + /** + * The previous log file. + */ + UintR prevLogFile; + /** + * The number of remaining words in this mbyte of the log file. + */ + UintR remainingWordsInMbyte; + /** + * The current file page within the current log file. This is + * a reference within the file and not a reference to a log + * page record. It is used to deduce where log records are + * written. Particularly completed gcp records and prepare log + * records. + */ + Uint16 currentFilepage; + /** + * The number of pages in the list referenced by + * LOG_PAGE_BUFFER. + */ + Uint16 noLogpagesInBuffer; + }; // Size 288 bytes + typedef Ptr LogFileRecordPtr; + + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /* $$$$$$$ LOG OPERATION RECORD $$$$$$$ */ + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /** + * This record contains a currently active file operation + * that has started by the log module. + */ + struct LogFileOperationRecord { + enum LfoState { + IDLE = 0, ///< Operation is not used at the moment + INIT_WRITE_AT_END = 1, ///< Write in file so that it grows to + ///< 16 Mbyte + INIT_FIRST_PAGE = 2, ///< Initialise the first page in a file + WRITE_GCI_ZERO = 3, + WRITE_INIT_MBYTE = 4, + WRITE_DIRTY = 5, + READ_SR_FRONTPAGE = 6, ///< Read page zero in file zero during + ///< system restart + READ_SR_LAST_FILE = 7, ///< Read page zero in last file open + ///< before system crash + READ_SR_NEXT_FILE = 8, ///< Read 60 files backwards to find + ///< further information GCPs in page + ///< zero + READ_SR_LAST_MBYTE = 9, + READ_EXEC_SR = 10, + READ_EXEC_LOG = 11, + READ_SR_FOURTH_PHASE = 12, + READ_SR_FOURTH_ZERO = 13, + FIRST_PAGE_WRITE_IN_LOGFILE = 14, + LAST_WRITE_IN_FILE = 15, + WRITE_PAGE_ZERO = 16, + ACTIVE_WRITE_LOG = 17, ///< A write operation during + ///< writing of log + READ_SR_INVALIDATE_PAGES = 18, + WRITE_SR_INVALIDATE_PAGES = 19 + }; + /** + * We have to remember the log pages read. + * Otherwise we cannot build the linked list after the pages have + * arrived to main memory. + */ + UintR logPageArray[16]; + /** + * A list of the pages that are part of this active operation. + */ + UintR firstLfoPage; + /** + * A timer to ensure that records are not lost. + */ + UintR lfoTimer; + /** + * The word number of the last written word in the last during + * a file write. + */ + UintR lfoWordWritten; + /** + * This variable contains the state of the log file operation. + */ + LfoState lfoState; + /** + * The log file that the file operation affects. + */ + UintR logFileRec; + /** + * The log file operations on a file are kept in a linked list. + */ + UintR nextLfo; + /** + * The page number of the first read/written page during a file + * read/write. + */ + Uint16 lfoPageNo; + /** + * The number of pages written or read during an operation to + * the log file. + */ + Uint16 noPagesRw; + }; // 92 bytes + typedef Ptr LogFileOperationRecordPtr; + + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /* $$$$$$$ LOG PAGE RECORD $$$$$$$ */ + /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */ + /** + * These are the 8 k pages used to store log records before storing + * them in the file system. + * Since 64 kbyte is sent to disk at a time it is necessary to have + * at least 4*64 kbytes of log pages. + * To handle multiple outstanding requests we need some additional pages. + * Thus we allocate 1 mbyte to ensure that we do not get problems with + * insufficient number of pages. + */ + struct LogPageRecord { + /** + * This variable contains the pages that are sent to disk. + * + * All pages contain a header of 12 words: + * - WORD 0: CHECKSUM Calculated before storing on disk and + * checked when read from disk. + * - WORD 1: LAP How many wraparounds have the log + * experienced since initial start of the + * system. + * - WORD 2: MAX_GCI_COMPLETED Which is the maximum gci which have + * completed before this page. This + * gci will not be found in this + * page and hereafter in the log. + * - WORD 3: MAX_GCI_STARTED The maximum gci which have started + * before this page. + * - WORD 4: NEXT_PAGE Pointer to the next page. + * Only used in main memory + * - WORD 5: PREVIOUS_PAGE Pointer to the previous page. + * Currently not used. + * - WORD 6: VERSION NDB version that wrote the page. + * - WORD 7: NO_LOG_FILES Number of log files in this log part. + * - WORD 8: CURRENT PAGE INDEX This keeps track of where we are in the + * page. + * This is only used when pages is in + * memory. + * - WORD 9: OLD PREPARE FILE NO This keeps track of the oldest prepare + * operation still alive (not committed + * or aborted) when this mbyte started. + * - WORD 10: OLD PREPARE PAGE REF File page reference within this file + * number. + * Page no + Page index. + * If no prepare was alive then these + * values points this mbyte. + * - WORD 11: DIRTY FLAG = 0 means not dirty and + * = 1 means the page is dirty. + * Is used when executing log when + * a need to write invalid commit + * records arise. + * + * The remaining 2036 words are used for log information, i.e. + * log records. + * + * A log record on this page has the following layout: + * - WORD 0: LOG RECORD TYPE + * The following types are supported: + * - PREPARE OPERATION An operation not yet committed. + * - NEW PREPARE OPERATION A prepared operation already + * logged is inserted + * into the log again so that the + * log tail can be advanced. + * This can happen when a transaction is + * committed for a long time. + * - ABORT TRANSACTION A previously prepared transaction + * was aborted. + * - COMMIT TRANSACTION A previously prepared transaction + * was committed. + * - INVALID COMMIT A previous commit record was + * invalidated by a + * subsequent system restart. + * A log record must be invalidated + * in a system restart if it belongs + * to a global checkpoint id which + * is not included in the system + * restart. + * Otherwise it will be included in + * a subsequent system restart since + * it will then most likely belong + * to a global checkpoint id which + * is part of that system + * restart. + * This is not a correct behaviour + * since this operation is lost in a + * system restart and should not + * reappear at a later system + * restart. + * - COMPLETED GCI A GCI has now been completed. + * - FRAGMENT SPLIT A fragment has been split + * (not implemented yet) + * - FILE DESCRIPTOR This is always the first log record + * in a file. + * It is always placed on page 0 after + * the header. + * It is written when the file is + * opened and when the file is closed. + * - NEXT LOG RECORD This log record only records where + * the next log record starts. + * - NEXT MBYTE RECORD This log record specifies that there + * are no more log records in this mbyte. + * + * + * A FILE DESCRIPTOR log record continues as follows: + * - WORD 1: NO_LOG_DESCRIPTORS This defines the number of + * descriptors of log files that + * will follow hereafter (max 32). + * the log descriptor will describe + * information about + * max_gci_completed, + * max_gci_started and log_lap at + * every 1 mbyte of the log file + * since a log file is 16 mbyte + * always, i need 16 entries in the + * array with max_gci_completed, + * max_gci_started and log_lap. thus + * 32 entries per log file + * descriptor (max 32*48 = 1536, + * always fits in page 0). + * - WORD 2: LAST LOG FILE The number of the log file currently + * open. This is only valid in file 0. + * - WORD 3 - WORD 18: MAX_GCI_COMPLETED for every 1 mbyte + * in this log file. + * - WORD 19 - WORD 34: MAX_GCI_STARTED for every 1 mbyte + * in this log file. + * + * Then it continues for NO_LOG_DESCRIPTORS until all subsequent + * log files (max 32) have been properly described. + * + * + * A PREPARE OPERATION log record continues as follows: + * - WORD 1: LOG RECORD SIZE + * - WORD 2: HASH VALUE + * - WORD 3: SCHEMA VERSION + * - WORD 4: OPERATION TYPE + * = 0 READ, + * = 1 UPDATE, + * = 2 INSERT, + * = 3 DELETE + * - WORD 5: NUMBER OF WORDS IN ATTRINFO PART + * - WORD 6: KEY LENGTH IN WORDS + * - WORD 7 - (WORD 7 + KEY_LENGTH - 1) The tuple key + * - (WORD 7 + KEY_LENGTH) - + * (WORD 7 + KEY_LENGTH + ATTRINFO_LENGTH - 1) The attrinfo + * + * A log record can be spread in several pages in some cases. + * The next log record always starts immediately after this log record. + * A log record does however never traverse a 1 mbyte boundary. + * This is used to ensure that we can always come back if something + * strange occurs in the log file. + * To ensure this we also have log records which only records + * the next log record. + * + * + * A COMMIT TRANSACTION log record continues as follows: + * - WORD 1: TRANSACTION ID PART 1 + * - WORD 2: TRANSACTION ID PART 2 + * - WORD 3: FRAGMENT ID OF THE OPERATION + * - WORD 4: TABLE ID OF THE OPERATION + * - WORD 5: THE FILE NUMBER OF THE PREPARE RECORD + * - WORD 6: THE STARTING PAGE NUMBER OF THE PREPARE RECORD + * - WORD 7: THE STARTING PAGE INDEX OF THE PREPARE RECORD + * - WORD 8: THE STOP PAGE NUMBER OF THE PREPARE RECORD + * - WORD 9: GLOBAL CHECKPOINT OF THE TRANSACTION + * + * + * An ABORT TRANSACTION log record continues as follows: + * - WORD 1: TRANSACTION ID PART 1 + * - WORD 2: TRANSACTION ID PART 2 + * + * + * A COMPLETED CGI log record continues as follows: + * - WORD 1: THE COMPLETED GCI + * + * + * A NEXT LOG RECORD log record continues as follows: + * - There is no more information needed. + * The next log record will always refer to the start of the next page. + * + * A NEXT MBYTE RECORD log record continues as follows: + * - There is no more information needed. + * The next mbyte will always refer to the start of the next mbyte. + */ +#ifdef NDB_OSE + UintR logPageWord[2048]; // Size 8 kbytes +#else + UintR logPageWord[8192]; // Size 32 kbytes +#endif + }; + typedef Ptr LogPageRecordPtr; + + struct PageRefRecord { + UintR pageRef[8]; + UintR prNext; + UintR prPrev; + Uint16 prFileNo; + Uint16 prPageNo; + }; // size 44 bytes + typedef Ptr PageRefRecordPtr; + + struct ScanRecord { + enum ScanState { + SCAN_FREE = 0, + WAIT_STORED_PROC_COPY = 1, + WAIT_STORED_PROC_SCAN = 2, + WAIT_NEXT_SCAN_COPY = 3, + WAIT_NEXT_SCAN = 4, + WAIT_DELETE_STORED_PROC_ID_SCAN = 5, + WAIT_DELETE_STORED_PROC_ID_COPY = 6, + WAIT_ACC_COPY = 7, + WAIT_ACC_SCAN = 8, + WAIT_SCAN_KEYINFO = 9, + WAIT_SCAN_NEXTREQ = 10, + WAIT_COPY_KEYINFO = 11, + WAIT_CLOSE_SCAN = 12, + WAIT_CLOSE_COPY = 13, + WAIT_RELEASE_LOCK = 14, + WAIT_TUPKEY_COPY = 15, + WAIT_LQHKEY_COPY = 16 + }; + enum ScanType { + ST_IDLE = 0, + SCAN = 1, + COPY = 2 + }; + UintR scanAccOpPtr[MAX_PARALLEL_OP_PER_SCAN]; + UintR scanApiOpPtr[MAX_PARALLEL_OP_PER_SCAN]; + UintR scanOpLength[MAX_PARALLEL_OP_PER_SCAN]; + UintR scanLocalref[2]; + UintR copyPtr; + UintR nextScanrec; + UintR scanAccPtr; + UintR scanAiLength; + UintR scanCompletedOperations; + UintR scanConcurrentOperations; + UintR scanErrorCounter; + UintR scanLocalFragid; + UintR scanSchemaVersion; + UintR scanSearchCondFalseCount; + UintR scanStoredProcId; + ScanState scanState; + UintR scanTcrec; + ScanType scanType; + BlockReference scanApiBlockref; + NodeId scanNodeId; + Uint8 scanCompletedStatus; + Uint8 scanFlag; + Uint8 scanLockHold; + Uint8 scanLockMode; + Uint8 readCommitted; + Uint8 rangeScan; + Uint8 scanNumber; + Uint8 scanReleaseCounter; + Uint8 scanTcWaiting; + Uint8 scanKeyinfoFlag; + }; // Size 272 bytes + typedef Ptr ScanRecordPtr; + + struct Tablerec { + enum TableStatus { + TABLE_DEFINED = 0, + NOT_DEFINED = 1, + ADD_TABLE_ONGOING = 2, + PREP_DROP_TABLE_ONGOING = 3, + PREP_DROP_TABLE_DONE = 4 + }; + + UintR fragrec[NO_OF_FRAG_PER_NODE]; + Uint16 fragid[NO_OF_FRAG_PER_NODE]; + /** + * Status of the table + */ + TableStatus tableStatus; + /** + * Table type and target table of index. + */ + Uint16 tableType; + Uint16 primaryTableId; + Uint32 schemaVersion; + + Uint32 usageCount; + NdbNodeBitmask waitingTC; + NdbNodeBitmask waitingDIH; + }; // Size 100 bytes + typedef Ptr TablerecPtr; + + struct TcConnectionrec { + enum ListState { + NOT_IN_LIST = 0, + IN_ACTIVE_LIST = 1, + ACC_BLOCK_LIST = 2, + WAIT_QUEUE_LIST = 3 + }; + enum LogWriteState { + NOT_STARTED = 0, + NOT_WRITTEN = 1, + NOT_WRITTEN_WAIT = 2, + WRITTEN = 3 + }; + enum AbortState { + ABORT_IDLE = 0, + ABORT_ACTIVE = 1, + NEW_FROM_TC = 2, + REQ_FROM_TC = 3, + ABORT_FROM_TC = 4, + ABORT_FROM_LQH = 5 + }; + enum TransactionState { + IDLE = 0, + + /* -------------------------------------------------------------------- */ + // Transaction in progress states + /* -------------------------------------------------------------------- */ + WAIT_ACC = 1, + WAIT_TUPKEYINFO = 2, + WAIT_ATTR = 3, + WAIT_TUP = 4, + STOPPED = 5, + LOG_QUEUED = 6, + PREPARED = 7, + LOG_COMMIT_WRITTEN_WAIT_SIGNAL = 8, + LOG_COMMIT_QUEUED_WAIT_SIGNAL = 9, + + /* -------------------------------------------------------------------- */ + // Commit in progress states + /* -------------------------------------------------------------------- */ + COMMIT_STOPPED = 10, + LOG_COMMIT_QUEUED = 11, + COMMIT_QUEUED = 12, + COMMITTED = 13, + + /* -------------------------------------------------------------------- */ + // Abort in progress states + /* -------------------------------------------------------------------- */ + WAIT_ACC_ABORT = 14, + ABORT_QUEUED = 15, + ABORT_STOPPED = 16, + WAIT_AI_AFTER_ABORT = 17, + LOG_ABORT_QUEUED = 18, + WAIT_TUP_TO_ABORT = 19, + + /* -------------------------------------------------------------------- */ + // Scan in progress states + /* -------------------------------------------------------------------- */ + WAIT_SCAN_AI = 20, + SCAN_STATE_USED = 21, + SCAN_FIRST_STOPPED = 22, + SCAN_CHECK_STOPPED = 23, + SCAN_STOPPED = 24, + SCAN_RELEASE_STOPPED = 25, + SCAN_CLOSE_STOPPED = 26, + COPY_CLOSE_STOPPED = 27, + COPY_FIRST_STOPPED = 28, + COPY_STOPPED = 29, + SCAN_TUPKEY = 30, + COPY_TUPKEY = 31, + + TC_NOT_CONNECTED = 32, + PREPARED_RECEIVED_COMMIT = 33, // Temporary state in write commit log + LOG_COMMIT_WRITTEN = 34 // Temporary state in write commit log + }; + enum ConnectState { + DISCONNECTED = 0, + CONNECTED = 1, + COPY_CONNECTED = 2, + LOG_CONNECTED = 3 + }; + ConnectState connectState; + UintR copyCountWords; + UintR firstAttrinfo[5]; + UintR tupkeyData[4]; + UintR transid[2]; + AbortState abortState; + UintR accConnectrec; + UintR applOprec; + UintR clientConnectrec; + UintR tcTimer; + UintR currReclenAi; + UintR currTupAiLen; + UintR firstAttrinbuf; + UintR firstTupkeybuf; + UintR fragmentid; + UintR fragmentptr; + UintR gci; + UintR hashValue; + UintR lastTupkeybuf; + UintR lastAttrinbuf; + /** + * Each operation (TcConnectrec) can be stored in max one out of many + * lists. + * This variable keeps track of which list it is in. + */ + ListState listState; + + UintR logStartFileNo; + LogWriteState logWriteState; + UintR nextHashRec; + UintR nextLogTcrec; + UintR nextTcLogQueue; + UintR nextTc; + UintR nextTcConnectrec; + Uint16 nodeAfterNext[2]; + UintR prevHashRec; + UintR prevLogTcrec; + UintR prevTc; + UintR readlenAi; + UintR reqRef; + UintR reqinfo; + UintR schemaVersion; + UintR storedProcId; + UintR simpleTcConnect; + UintR tableref; + UintR tcOprec; + UintR tcScanInfo; + UintR tcScanRec; + UintR totReclenAi; + UintR totSendlenAi; + UintR tupConnectrec; + UintR savePointId; + TransactionState transactionState; + BlockReference applRef; + BlockReference clientBlockref; + + BlockReference reqBlockref; + BlockReference tcBlockref; + BlockReference tcAccBlockref; + BlockReference tcTuxBlockref; + BlockReference tcTupBlockref; + Uint32 commitAckMarker; + UintR noFiredTriggers; + + Uint16 errorCode; + Uint16 logStartPageIndex; + Uint16 logStartPageNo; + Uint16 logStopPageNo; + Uint16 nextReplica; + Uint16 primKeyLen; + Uint16 save1; + + Uint8 activeCreat; + Uint8 apiVersionNo; + Uint8 dirtyOp; + Uint8 indTakeOver; + Uint8 lastReplicaNo; + Uint8 localFragptr; + Uint8 lockType; + Uint8 nextSeqNoReplica; + Uint8 opSimple; + Uint8 opExec; + Uint8 operation; + Uint8 reclenAiLqhkey; + Uint8 replicaType; + Uint8 simpleRead; + Uint8 seqNoReplica; + Uint8 tcNodeFailrec; + }; /* p2c: size = 280 bytes */ + + typedef Ptr TcConnectionrecPtr; + + struct TcNodeFailRecord { + enum TcFailStatus { + TC_STATE_TRUE = 0, + TC_STATE_FALSE = 1, + TC_STATE_BREAK = 2 + }; + UintR lastNewTcRef; + UintR newTcRef; + TcFailStatus tcFailStatus; + UintR tcRecNow; + BlockReference lastNewTcBlockref; + BlockReference newTcBlockref; + Uint16 oldNodeId; + }; // Size 28 bytes + typedef Ptr TcNodeFailRecordPtr; + + struct CommitLogRecord { + Uint32 startPageNo; + Uint32 startPageIndex; + Uint32 stopPageNo; + Uint32 fileNo; + }; + +public: + Dblqh(const class Configuration &); + virtual ~Dblqh(); + +private: + BLOCK_DEFINES(Dblqh); + + void execPACKED_SIGNAL(Signal* signal); + void execDEBUG_SIG(Signal* signal); + void execATTRINFO(Signal* signal); + void execKEYINFO(Signal* signal); + void execLQHKEYREQ(Signal* signal); + void execLQHKEYREF(Signal* signal); + void execCOMMIT(Signal* signal); + void execCOMPLETE(Signal* signal); + void execLQHKEYCONF(Signal* signal); + void execTESTSIG(Signal* signal); + void execLQH_RESTART_OP(Signal* signal); + void execCONTINUEB(Signal* signal); + void execSTART_RECREQ(Signal* signal); + void execSTART_RECCONF(Signal* signal); + void execEXEC_FRAGREQ(Signal* signal); + void execEXEC_FRAGCONF(Signal* signal); + void execEXEC_FRAGREF(Signal* signal); + void execSTART_EXEC_SR(Signal* signal); + void execEXEC_SRREQ(Signal* signal); + void execEXEC_SRCONF(Signal* signal); + + void execDUMP_STATE_ORD(Signal* signal); + void execACC_COM_BLOCK(Signal* signal); + void execACC_COM_UNBLOCK(Signal* signal); + void execTUP_COM_BLOCK(Signal* signal); + void execTUP_COM_UNBLOCK(Signal* signal); + void execACC_ABORTCONF(Signal* signal); + void execNODE_FAILREP(Signal* signal); + void execCHECK_LCP_STOP(Signal* signal); + void execSEND_PACKED(Signal* signal); + void execTUP_ATTRINFO(Signal* signal); + void execSIZEALT_REP(Signal* signal); + void execLQHFRAGREQ(Signal* signal); + void execLQHADDATTREQ(Signal* signal); + void execTUP_ADD_ATTCONF(Signal* signal); + void execTUP_ADD_ATTRREF(Signal* signal); + void execACCFRAGCONF(Signal* signal); + void execACCFRAGREF(Signal* signal); + void execTUPFRAGCONF(Signal* signal); + void execTUPFRAGREF(Signal* signal); + void execTAB_COMMITREQ(Signal* signal); + void execACCSEIZECONF(Signal* signal); + void execACCSEIZEREF(Signal* signal); + void execREAD_NODESCONF(Signal* signal); + void execREAD_NODESREF(Signal* signal); + void execSTTOR(Signal* signal); + void execNDB_STTOR(Signal* signal); + void execTUPSEIZECONF(Signal* signal); + void execTUPSEIZEREF(Signal* signal); + void execACCKEYCONF(Signal* signal); + void execACCKEYREF(Signal* signal); + void execTUPKEYCONF(Signal* signal); + void execTUPKEYREF(Signal* signal); + void execABORT(Signal* signal); + void execABORTREQ(Signal* signal); + void execCOMMITREQ(Signal* signal); + void execCOMPLETEREQ(Signal* signal); + void execMEMCHECKREQ(Signal* signal); + void execSCAN_FRAGREQ(Signal* signal); + void execSCAN_NEXTREQ(Signal* signal); + void execACC_SCANCONF(Signal* signal); + void execACC_SCANREF(Signal* signal); + void execNEXT_SCANCONF(Signal* signal); + void execNEXT_SCANREF(Signal* signal); + void execACC_SCAN_INFO(Signal* signal); + void execACC_SCAN_INFO24(Signal* signal); + void execACC_TO_REF(Signal* signal); + void execSTORED_PROCCONF(Signal* signal); + void execSTORED_PROCREF(Signal* signal); + void execCOPY_FRAGREQ(Signal* signal); + void execCOPY_ACTIVEREQ(Signal* signal); + void execCOPY_STATEREQ(Signal* signal); + void execLQH_TRANSREQ(Signal* signal); + void execTRANSID_AI(Signal* signal); + void execINCL_NODEREQ(Signal* signal); + void execACC_LCPCONF(Signal* signal); + void execACC_LCPREF(Signal* signal); + void execACC_LCPSTARTED(Signal* signal); + void execACC_CONTOPCONF(Signal* signal); + void execLCP_FRAGIDCONF(Signal* signal); + void execLCP_FRAGIDREF(Signal* signal); + void execLCP_HOLDOPCONF(Signal* signal); + void execLCP_HOLDOPREF(Signal* signal); + void execTUP_PREPLCPCONF(Signal* signal); + void execTUP_PREPLCPREF(Signal* signal); + void execTUP_LCPCONF(Signal* signal); + void execTUP_LCPREF(Signal* signal); + void execTUP_LCPSTARTED(Signal* signal); + void execEND_LCPCONF(Signal* signal); + + void execLCP_FRAG_ORD(Signal* signal); + void execEMPTY_LCP_REQ(Signal* signal); + + void execSTART_FRAGREQ(Signal* signal); + void execSTART_RECREF(Signal* signal); + void execSR_FRAGIDCONF(Signal* signal); + void execSR_FRAGIDREF(Signal* signal); + void execACC_SRCONF(Signal* signal); + void execACC_SRREF(Signal* signal); + void execTUP_SRCONF(Signal* signal); + void execTUP_SRREF(Signal* signal); + void execGCP_SAVEREQ(Signal* signal); + void execFSOPENCONF(Signal* signal); + void execFSOPENREF(Signal* signal); + void execFSCLOSECONF(Signal* signal); + void execFSCLOSEREF(Signal* signal); + void execFSWRITECONF(Signal* signal); + void execFSWRITEREF(Signal* signal); + void execFSREADCONF(Signal* signal); + void execFSREADREF(Signal* signal); + void execSCAN_HBREP(Signal* signal); + void execSET_VAR_REQ(Signal* signal); + void execTIME_SIGNAL(Signal* signal); + void execFSSYNCCONF(Signal* signal); + void execFSSYNCREF(Signal* signal); + + void execALTER_TAB_REQ(Signal* signal); + void execALTER_TAB_CONF(Signal* signal); + + void execCREATE_TRIG_CONF(Signal* signal); + void execCREATE_TRIG_REF(Signal* signal); + void execCREATE_TRIG_REQ(Signal* signal); + + void execDROP_TRIG_CONF(Signal* signal); + void execDROP_TRIG_REF(Signal* signal); + void execDROP_TRIG_REQ(Signal* signal); + + void execPREP_DROP_TAB_REQ(Signal* signal); + void execWAIT_DROP_TAB_REQ(Signal* signal); + void execDROP_TAB_REQ(Signal* signal); + + void execLQH_ALLOCREQ(Signal* signal); + void execLQH_WRITELOG_REQ(Signal* signal); + + void execTUXFRAGCONF(Signal* signal); + void execTUXFRAGREF(Signal* signal); + void execTUX_ADD_ATTRCONF(Signal* signal); + void execTUX_ADD_ATTRREF(Signal* signal); + + // Statement blocks + void removeTable(Uint32 tableId); + void sendLCP_COMPLETE_REP(Signal* signal, Uint32 lcpId); + void sendEMPTY_LCP_CONF(Signal* signal, bool idle); + void sendLCP_FRAGIDREQ(Signal* signal); + void sendLCP_FRAG_REP(Signal * signal, const LcpRecord::FragOrd &) const; + + void updatePackedList(Signal* signal, HostRecord * ahostptr, Uint16 hostId); + void LQHKEY_abort(Signal* signal, int errortype); + void LQHKEY_error(Signal* signal, int errortype); + void nextRecordCopy(Signal* signal); + void calculateHash(Signal* signal); + void continueAfterCheckLcpStopBlocked(Signal* signal); + void checkLcpStopBlockedLab(Signal* signal); + void sendCommittedTc(Signal* signal, BlockReference atcBlockref); + void sendCompletedTc(Signal* signal, BlockReference atcBlockref); + void sendLqhkeyconfTc(Signal* signal, BlockReference atcBlockref); + void sendCommitLqh(Signal* signal, BlockReference alqhBlockref); + void sendCompleteLqh(Signal* signal, BlockReference alqhBlockref); + void sendPackedSignalLqh(Signal* signal, HostRecord * ahostptr); + void sendPackedSignalTc(Signal* signal, HostRecord * ahostptr); + Uint32 handleLongTupKey(Signal* signal, + Uint32 lenSofar, + Uint32 primKeyLen, + Uint32* dataPtr); + void cleanUp(Signal* signal); + void sendAttrinfoLoop(Signal* signal); + void sendAttrinfoSignal(Signal* signal); + void sendLqhAttrinfoSignal(Signal* signal); + void sendKeyinfoAcc(Signal* signal); + void initScanAccOp(Signal* signal); + Uint32 initScanrec(const class ScanFragReq *); + void initScanTc(Signal* signal, + Uint32 transid1, + Uint32 transid2, + Uint32 fragId, + Uint32 nodeId); + void finishScanrec(Signal* signal); + void releaseScanrec(Signal* signal); + void seizeScanrec(Signal* signal); + void sendKeyinfo20(Signal* signal, ScanRecord *, TcConnectionrec *); + void sendScanFragConf(Signal* signal, Uint32 scanCompleted); + void initCopyrec(Signal* signal); + void initCopyTc(Signal* signal); + void sendCopyActiveConf(Signal* signal,Uint32 tableId); + void checkLcpCompleted(Signal* signal); + void checkLcpHoldop(Signal* signal); + void checkLcpStarted(Signal* signal); + void checkLcpTupprep(Signal* signal); + void getNextFragForLcp(Signal* signal); + void initLcpLocAcc(Signal* signal, Uint32 fragId); + void initLcpLocTup(Signal* signal, Uint32 fragId); + void moveAccActiveFrag(Signal* signal); + void moveActiveToAcc(Signal* signal); + void releaseLocalLcps(Signal* signal); + void seizeLcpLoc(Signal* signal); + void sendAccContOp(Signal* signal); + void sendStartLcp(Signal* signal); + void setLogTail(Signal* signal, Uint32 keepGci); + Uint32 remainingLogSize(const LogFileRecordPtr &sltCurrLogFilePtr, + const LogPartRecordPtr &sltLogPartPtr); + void checkGcpCompleted(Signal* signal, Uint32 pageWritten, Uint32 wordWritten); + void initFsopenconf(Signal* signal); + void initFsrwconf(Signal* signal); + void initLfo(Signal* signal); + void initLogfile(Signal* signal, Uint32 fileNo); + void initLogpage(Signal* signal); + void openFileRw(Signal* signal, LogFileRecordPtr olfLogFilePtr); + void openLogfileInit(Signal* signal); + void openNextLogfile(Signal* signal); + void releaseLfo(Signal* signal); + void releaseLfoPages(Signal* signal); + void releaseLogpage(Signal* signal); + void seizeLfo(Signal* signal); + void seizeLogfile(Signal* signal); + void seizeLogpage(Signal* signal); + void writeFileDescriptor(Signal* signal); + void writeFileHeaderOpen(Signal* signal, Uint32 type); + void writeInitMbyte(Signal* signal); + void writeSinglePage(Signal* signal, Uint32 pageNo, Uint32 wordWritten); + void buildLinkedLogPageList(Signal* signal); + void changeMbyte(Signal* signal); + Uint32 checkIfExecLog(Signal* signal); + void checkNewMbyte(Signal* signal); + void checkReadExecSr(Signal* signal); + void checkScanTcCompleted(Signal* signal); + void checkSrCompleted(Signal* signal); + void closeFile(Signal* signal, LogFileRecordPtr logFilePtr); + void completedLogPage(Signal* signal, Uint32 clpType); + void deleteFragrec(Uint32 fragId); + void deleteTransidHash(Signal* signal); + void findLogfile(Signal* signal, + Uint32 fileNo, + LogPartRecordPtr flfLogPartPtr, + LogFileRecordPtr* parLogFilePtr); + void findPageRef(Signal* signal, CommitLogRecord* commitLogRecord); + int findTransaction(UintR Transid1, UintR Transid2, UintR TcOprec); + void getFirstInLogQueue(Signal* signal); + bool getFragmentrec(Signal* signal, Uint32 fragId); + void initialiseAddfragrec(Signal* signal); + void initialiseAttrbuf(Signal* signal); + void initialiseDatabuf(Signal* signal); + void initialiseFragrec(Signal* signal); + void initialiseGcprec(Signal* signal); + void initialiseLcpRec(Signal* signal); + void initialiseLcpLocrec(Signal* signal); + void initialiseLfo(Signal* signal); + void initialiseLogFile(Signal* signal); + void initialiseLogPage(Signal* signal); + void initialiseLogPart(Signal* signal); + void initialisePageRef(Signal* signal); + void sendInitialiseRecords(Signal* signal, Uint32 data); + void initialiseScanrec(Signal* signal); + void initialiseTabrec(Signal* signal); + void initialiseTcrec(Signal* signal); + void initialiseTcNodeFailRec(Signal* signal); + void initFragrec(Signal* signal, + Uint32 tableId, + Uint32 fragId, + Uint32 copyType); + void initFragrecSr(Signal* signal); + void initGciInLogFileRec(Signal* signal, Uint32 noFdDesc); + void initLcpSr(Signal* signal, + Uint32 lcpNo, + Uint32 lcpId, + Uint32 tableId, + Uint32 fragId, + Uint32 fragPtr); + void initLogpart(Signal* signal); + void initLogPointers(Signal* signal); + void initReqinfoExecSr(Signal* signal); + bool insertFragrec(Signal* signal, Uint32 fragId); + void linkActiveFrag(Signal* signal); + void linkFragQueue(Signal* signal); + void linkWaitLog(Signal* signal, LogPartRecordPtr regLogPartPtr); + void logNextStart(Signal* signal); + void moveToPageRef(Signal* signal); + void readAttrinfo(Signal* signal); + void readCommitLog(Signal* signal, CommitLogRecord* commitLogRecord); + void readExecLog(Signal* signal); + void readExecSrNewMbyte(Signal* signal); + void readExecSr(Signal* signal); + void readKey(Signal* signal); + void readLogData(Signal* signal, Uint32 noOfWords, Uint32* dataPtr); + void readLogHeader(Signal* signal); + Uint32 readLogword(Signal* signal); + Uint32 readLogwordExec(Signal* signal); + void readSinglePage(Signal* signal, Uint32 pageNo); + void releaseAccList(Signal* signal); + void releaseActiveCopy(Signal* signal); + void releaseActiveFrag(Signal* signal); + void releaseActiveList(Signal* signal); + void releaseAddfragrec(Signal* signal); + void releaseFragrec(); + void releaseLcpLoc(Signal* signal); + void releaseOprec(Signal* signal); + void releasePageRef(Signal* signal); + void releaseMmPages(Signal* signal); + void releasePrPages(Signal* signal); + void releaseTcrec(Signal* signal, TcConnectionrecPtr tcConnectptr); + void releaseTcrecLog(Signal* signal, TcConnectionrecPtr tcConnectptr); + void releaseWaitQueue(Signal* signal); + void removeLogTcrec(Signal* signal); + void removePageRef(Signal* signal); + Uint32 returnExecLog(Signal* signal); + int saveTupattrbuf(Signal* signal, Uint32* dataPtr, Uint32 length); + void seizeAddfragrec(Signal* signal); + void seizeAttrinbuf(Signal* signal); + void seizeFragmentrec(Signal* signal); + void seizePageRef(Signal* signal); + void seizeTcrec(); + void seizeTupkeybuf(Signal* signal); + void sendAborted(Signal* signal); + void sendLqhTransconf(Signal* signal, LqhTransConf::OperationStatus); + void sendTupkey(Signal* signal); + void startExecSr(Signal* signal); + void startNextExecSr(Signal* signal); + void startTimeSupervision(Signal* signal); + void stepAhead(Signal* signal, Uint32 stepAheadWords); + void systemError(Signal* signal); + void writeAbortLog(Signal* signal); + void writeCommitLog(Signal* signal, LogPartRecordPtr regLogPartPtr); + void writeCompletedGciLog(Signal* signal); + void writeDirty(Signal* signal); + void writeKey(Signal* signal); + void writeLogHeader(Signal* signal); + void writeLogWord(Signal* signal, Uint32 data); + void writeNextLog(Signal* signal); + void errorReport(Signal* signal, int place); + void warningReport(Signal* signal, int place); + void invalidateLogAfterLastGCI(Signal *signal); + void readFileInInvalidate(Signal *signal); + void exitFromInvalidate(Signal* signal); + Uint32 calcPageCheckSum(LogPageRecordPtr logP); + + // Generated statement blocks + void systemErrorLab(Signal* signal); + void initFourth(Signal* signal); + void packLqhkeyreqLab(Signal* signal); + void sendNdbSttorryLab(Signal* signal); + void execSrCompletedLab(Signal* signal); + void execLogRecord(Signal* signal); + void srPhase3Comp(Signal* signal); + void srLogLimits(Signal* signal); + void srGciLimits(Signal* signal); + void srPhase3Start(Signal* signal); + void warningHandlerLab(Signal* signal); + void checkStartCompletedLab(Signal* signal); + void continueAbortLab(Signal* signal); + void abortContinueAfterBlockedLab(Signal* signal, bool canBlock); + void abortCommonLab(Signal* signal); + void localCommitLab(Signal* signal); + void abortErrorLab(Signal* signal); + void continueAfterReceivingAllAiLab(Signal* signal); + void sendScanFragRefLateLab(Signal* signal); + void abortStateHandlerLab(Signal* signal); + void writeAttrinfoLab(Signal* signal); + void scanAttrinfoLab(Signal* signal, Uint32* dataPtr, Uint32 length); + void localAbortStateHandlerLab(Signal* signal); + void logLqhkeyreqLab(Signal* signal); + void lqhAttrinfoLab(Signal* signal, Uint32* dataPtr, Uint32 length); + void rwConcludedAiLab(Signal* signal); + void aiStateErrorCheckLab(Signal* signal, Uint32* dataPtr, Uint32 length); + void takeOverErrorLab(Signal* signal); + void endgettupkeyLab(Signal* signal); + void noFreeRecordLab(Signal* signal, + const class LqhKeyReq * lqhKeyReq, + Uint32 errorCode); + void logLqhkeyrefLab(Signal* signal); + void closeCopyLab(Signal* signal); + void commitReplyLab(Signal* signal); + void completeUnusualLab(Signal* signal); + void completeTransNotLastLab(Signal* signal); + void completedLab(Signal* signal); + void copyCompletedLab(Signal* signal); + void completeLcpRoundLab(Signal* signal); + void continueAfterLogAbortWriteLab(Signal* signal); + void sendAttrinfoLab(Signal* signal); + void sendExecConf(Signal* signal); + void execSr(Signal* signal); + void srFourthComp(Signal* signal); + void timeSup(Signal* signal); + void closeCopyRequestLab(Signal* signal); + void closeScanRequestLab(Signal* signal); + void scanTcConnectLab(Signal* signal, Uint32 startTcCon, Uint32 fragId); + void returnInitialiseRecordsLab(Signal* signal); + void initGcpRecLab(Signal* signal); + void prepareContinueAfterBlockedLab(Signal* signal); + void commitContinueAfterBlockedLab(Signal* signal); + void continueCopyAfterBlockedLab(Signal* signal); + void continueFirstCopyAfterBlockedLab(Signal* signal); + void continueFirstScanAfterBlockedLab(Signal* signal); + void continueScanAfterBlockedLab(Signal* signal); + void continueScanReleaseAfterBlockedLab(Signal* signal); + void continueCloseScanAfterBlockedLab(Signal* signal); + void continueCloseCopyAfterBlockedLab(Signal* signal); + void sendExecFragRefLab(Signal* signal); + void fragrefLab(Signal* signal, BlockReference retRef, + Uint32 retPtr, Uint32 errorCode); + void accFragRefLab(Signal* signal); + void rwConcludedLab(Signal* signal); + void sendsttorryLab(Signal* signal); + void initialiseRecordsLab(Signal* signal, Uint32 data); + void startphase2Lab(Signal* signal, Uint32 config); + void startphase3Lab(Signal* signal); + void startphase4Lab(Signal* signal); + void startphase6Lab(Signal* signal); + void moreconnectionsLab(Signal* signal); + void scanReleaseLocksLab(Signal* signal); + void closeScanLab(Signal* signal); + void nextScanConfLoopLab(Signal* signal); + void scanNextLoopLab(Signal* signal); + void commitReqLab(Signal* signal, Uint32 gci); + void completeTransLastLab(Signal* signal); + void tupScanCloseConfLab(Signal* signal); + void tupCopyCloseConfLab(Signal* signal); + void accScanCloseConfLab(Signal* signal); + void accCopyCloseConfLab(Signal* signal); + void nextScanConfScanLab(Signal* signal); + void nextScanConfCopyLab(Signal* signal); + void continueScanNextReqLab(Signal* signal); + bool keyinfoLab(Signal* signal, Uint32* dataPtr, Uint32 length); + void copySendTupkeyReqLab(Signal* signal); + void storedProcConfScanLab(Signal* signal); + void storedProcConfCopyLab(Signal* signal); + void copyStateFinishedLab(Signal* signal); + void lcpCompletedLab(Signal* signal); + void lcpStartedLab(Signal* signal); + void contChkpNextFragLab(Signal* signal); + void startLcpRoundLab(Signal* signal); + void startFragRefLab(Signal* signal); + void srCompletedLab(Signal* signal); + void openFileInitLab(Signal* signal); + void openSrFrontpageLab(Signal* signal); + void openSrLastFileLab(Signal* signal); + void openSrNextFileLab(Signal* signal); + void openExecSrStartLab(Signal* signal); + void openExecSrNewMbyteLab(Signal* signal); + void openSrFourthPhaseLab(Signal* signal); + void openSrFourthZeroSkipInitLab(Signal* signal); + void openSrFourthZeroLab(Signal* signal); + void openExecLogLab(Signal* signal); + void checkInitCompletedLab(Signal* signal); + void closingSrLab(Signal* signal); + void closeExecSrLab(Signal* signal); + void execLogComp(Signal* signal); + void closeWriteLogLab(Signal* signal); + void closeExecLogLab(Signal* signal); + void writePageZeroLab(Signal* signal); + void lastWriteInFileLab(Signal* signal); + void initWriteEndLab(Signal* signal); + void initFirstPageLab(Signal* signal); + void writeGciZeroLab(Signal* signal); + void writeDirtyLab(Signal* signal); + void writeInitMbyteLab(Signal* signal); + void writeLogfileLab(Signal* signal); + void firstPageWriteLab(Signal* signal); + void readSrLastMbyteLab(Signal* signal); + void readSrLastFileLab(Signal* signal); + void readSrNextFileLab(Signal* signal); + void readExecSrLab(Signal* signal); + void readExecLogLab(Signal* signal); + void readSrFourthPhaseLab(Signal* signal); + void readSrFourthZeroLab(Signal* signal); + void copyLqhKeyRefLab(Signal* signal); + void restartOperationsLab(Signal* signal); + void lqhTransNextLab(Signal* signal); + void restartOperationsAfterStopLab(Signal* signal); + void sttorStartphase1Lab(Signal* signal); + void startphase1Lab(Signal* signal, Uint32 config, Uint32 nodeId); + void tupkeyConfLab(Signal* signal); + void copyTupkeyConfLab(Signal* signal); + void scanTupkeyConfLab(Signal* signal); + void scanTupkeyRefLab(Signal* signal); + void accScanConfScanLab(Signal* signal); + void accScanConfCopyLab(Signal* signal); + void scanLockReleasedLab(Signal* signal); + void accScanInfoEnterLab(Signal* signal, Uint32* dataPtr, Uint32 length); + void openSrFourthNextLab(Signal* signal); + void closingInitLab(Signal* signal); + void closeExecSrCompletedLab(Signal* signal); + void readSrFrontpageLab(Signal* signal); + + void sendAddFragReq(Signal* signal); + void sendAddAttrReq(Signal* signal); + void checkDropTab(Signal*); + Uint32 checkDropTabState(Tablerec::TableStatus, Uint32) const; + + // Initialisation + void initData(); + void initRecords(); + +// ---------------------------------------------------------------- +// These are variables handling the records. For most records one +// pointer to the array of structs, one pointer-struct, a file size +// and a first free record variable. The pointer struct are temporary +// variables that are kept on the class object since there are often a +// great deal of those variables that exist simultaneously and +// thus no perfect solution of handling them is currently available. +// ---------------------------------------------------------------- +/* ------------------------------------------------------------------------- */ +/* POSITIONS WITHIN THE ATTRINBUF AND THE MAX SIZE OF DATA WITHIN AN */ +/* ATTRINBUF. */ +/* ------------------------------------------------------------------------- */ + + +#define ZADDFRAGREC_FILE_SIZE 1 + AddFragRecord *addFragRecord; + AddFragRecordPtr addfragptr; + UintR cfirstfreeAddfragrec; + UintR caddfragrecFileSize; + +#define ZATTRINBUF_FILE_SIZE 10000 // 1.25 MByte +#define ZINBUF_DATA_LEN 24 /* POSITION OF 'DATA LENGHT'-VARIABLE. */ +#define ZINBUF_NEXT 25 /* POSITION OF 'NEXT'-VARIABLE. */ + Attrbuf *attrbuf; + AttrbufPtr attrinbufptr; + UintR cfirstfreeAttrinbuf; + UintR cattrinbufFileSize; + +#define ZDATABUF_FILE_SIZE 10000 // 200 kByte + Databuf *databuf; + DatabufPtr databufptr; + UintR cfirstfreeDatabuf; + UintR cdatabufFileSize; + +// Configurable + Fragrecord *fragrecord; + FragrecordPtr fragptr; + UintR cfirstfreeFragrec; + UintR cfragrecFileSize; + +#define ZGCPREC_FILE_SIZE 1 + GcpRecord *gcpRecord; + GcpRecordPtr gcpPtr; + UintR cgcprecFileSize; + +// MAX_NDB_NODES is the size of this array + HostRecord *hostRecord; + UintR chostFileSize; + +#define ZNO_CONCURRENT_LCP 1 + LcpRecord *lcpRecord; + LcpRecordPtr lcpPtr; + UintR cfirstfreeLcpLoc; + UintR clcpFileSize; + +#define ZLCP_LOCREC_FILE_SIZE 4 + LcpLocRecord *lcpLocRecord; + LcpLocRecordPtr lcpLocptr; + UintR clcpLocrecFileSize; + +#define ZLOG_PART_FILE_SIZE 4 + LogPartRecord *logPartRecord; + LogPartRecordPtr logPartPtr; + UintR clogPartFileSize; + +// Configurable + LogFileRecord *logFileRecord; + LogFileRecordPtr logFilePtr; + UintR cfirstfreeLogFile; + UintR clogFileFileSize; + +#define ZLFO_FILE_SIZE 256 /* MAX 256 OUTSTANDING FILE OPERATIONS */ + LogFileOperationRecord *logFileOperationRecord; + LogFileOperationRecordPtr lfoPtr; + UintR cfirstfreeLfo; + UintR clfoFileSize; + +#define ZLOG_PAGE_FILE_SIZE 256 // 8 MByte + LogPageRecord *logPageRecord; + LogPageRecordPtr logPagePtr; + UintR cfirstfreeLogPage; + UintR clogPageFileSize; + +#define ZPAGE_REF_FILE_SIZE 20 + PageRefRecord *pageRefRecord; + PageRefRecordPtr pageRefPtr; + UintR cfirstfreePageRef; + UintR cpageRefFileSize; + +#define ZSCANREC_FILE_SIZE 100 + ScanRecord *scanRecord; + ScanRecordPtr scanptr; + UintR cfirstfreeScanrec; + UintR cscanrecFileSize; + UintR cscanNoFreeRec; + +// Configurable + Tablerec *tablerec; + TablerecPtr tabptr; + UintR ctabrecFileSize; + +// Configurable + TcConnectionrec *tcConnectionrec; + TcConnectionrecPtr tcConnectptr; + UintR cfirstfreeTcConrec; + UintR ctcConnectrecFileSize; + +// MAX_NDB_NODES is the size of this array + TcNodeFailRecord *tcNodeFailRecord; + TcNodeFailRecordPtr tcNodeFailptr; + UintR ctcNodeFailrecFileSize; + + Uint16 terrorCode; + + Uint32 c_firstInNodeGroup; + +// ------------------------------------------------------------------------ +// These variables are used to store block state which do not need arrays +// of struct's. +// ------------------------------------------------------------------------ + Uint32 c_lcpId; + Uint32 cnoOfFragsCheckpointed; + +/* ------------------------------------------------------------------------- */ +// cmaxWordsAtNodeRec keeps track of how many words that currently are +// outstanding in a node recovery situation. +// cbookedAccOps keeps track of how many operation records that have been +// booked in ACC for the scan processes. +// cmaxAccOps contains the maximum number of operation records which can be +// allocated for scan purposes in ACC. +/* ------------------------------------------------------------------------- */ + UintR cmaxWordsAtNodeRec; + UintR cbookedAccOps; + UintR cmaxAccOps; +/* ------------------------------------------------------------------------- */ +/*THIS STATE VARIABLE IS ZTRUE IF AN ADD NODE IS ONGOING. ADD NODE MEANS */ +/*THAT CONNECTIONS ARE SET-UP TO THE NEW NODE. */ +/* ------------------------------------------------------------------------- */ + Uint8 caddNodeState; +/* ------------------------------------------------------------------------- */ +/*THIS VARIABLE SPECIFIES WHICH TYPE OF RESTART THAT IS ONGOING */ +/* ------------------------------------------------------------------------- */ + Uint16 cstartType; +/* ------------------------------------------------------------------------- */ +/*THIS VARIABLE INDICATES WHETHER AN INITIAL RESTART IS ONGOING OR NOT. */ +/* ------------------------------------------------------------------------- */ + Uint8 cinitialStartOngoing; +/* ------------------------------------------------------------------------- */ +/*THIS VARIABLE KEEPS TRACK OF WHEN TUP AND ACC HAVE COMPLETED EXECUTING */ +/*THEIR UNDO LOG. */ +/* ------------------------------------------------------------------------- */ + ExecUndoLogState csrExecUndoLogState; +/* ------------------------------------------------------------------------- */ +/*THIS VARIABLE KEEPS TRACK OF WHEN TUP AND ACC HAVE CONFIRMED COMPLETION */ +/*OF A LOCAL CHECKPOINT ROUND. */ +/* ------------------------------------------------------------------------- */ + LcpCloseState clcpCompletedState; +/* ------------------------------------------------------------------------- */ +/*DURING CONNECTION PROCESSES IN SYSTEM RESTART THESE VARIABLES KEEP TRACK */ +/*OF HOW MANY CONNECTIONS AND RELEASES THAT ARE TO BE PERFORMED. */ +/* ------------------------------------------------------------------------- */ +/***************************************************************************>*/ +/*THESE VARIABLES CONTAIN INFORMATION USED DURING SYSTEM RESTART. */ +/***************************************************************************>*/ +/* ------------------------------------------------------------------------- */ +/*THIS VARIABLE IS ZTRUE IF THE SIGNAL START_REC_REQ HAVE BEEN RECEIVED. */ +/*RECEPTION OF THIS SIGNAL INDICATES THAT ALL FRAGMENTS THAT THIS NODE */ +/*SHOULD START HAVE BEEN RECEIVED. */ +/* ------------------------------------------------------------------------- */ + Uint8 cstartRecReq; +/* ------------------------------------------------------------------------- */ +/*THIS VARIABLE KEEPS TRACK OF HOW MANY FRAGMENTS THAT PARTICIPATE IN */ +/*EXECUTING THE LOG. IF ZERO WE DON'T NEED TO EXECUTE THE LOG AT ALL. */ +/* ------------------------------------------------------------------------- */ + UintR cnoFragmentsExecSr; +/* ------------------------------------------------------------------------- */ +/*THIS VARIABLE KEEPS TRACK OF WHICH OF THE FIRST TWO RESTART PHASES THAT */ +/*HAVE COMPLETED. */ +/* ------------------------------------------------------------------------- */ + Uint8 csrPhaseStarted; +/* ------------------------------------------------------------------------- */ +/*NUMBER OF PHASES COMPLETED OF EXECUTING THE FRAGMENT LOG. */ +/* ------------------------------------------------------------------------- */ + Uint8 csrPhasesCompleted; +/* ------------------------------------------------------------------------- */ +/*THE BLOCK REFERENCE OF THE MASTER DIH DURING SYSTEM RESTART. */ +/* ------------------------------------------------------------------------- */ + BlockReference cmasterDihBlockref; +/* ------------------------------------------------------------------------- */ +/*THIS VARIABLE IS THE HEAD OF A LINKED LIST OF FRAGMENTS WAITING TO BE */ +/*RESTORED FROM DISK. */ +/* ------------------------------------------------------------------------- */ + UintR cfirstWaitFragSr; +/* ------------------------------------------------------------------------- */ +/*THIS VARIABLE IS THE HEAD OF A LINKED LIST OF FRAGMENTS THAT HAVE BEEN */ +/*RESTORED FROM DISK THAT AWAITS EXECUTION OF THE FRAGMENT LOG. */ +/* ------------------------------------------------------------------------- */ + UintR cfirstCompletedFragSr; + +/* ------------------------------------------------------------------------- */ +/*USED DURING SYSTEM RESTART, INDICATES THE OLDEST GCI THAT CAN BE RESTARTED */ +/*FROM AFTER THIS SYSTEM RESTART. USED TO FIND THE LOG TAIL. */ +/* ------------------------------------------------------------------------- */ + UintR crestartOldestGci; +/* ------------------------------------------------------------------------- */ +/*USED DURING SYSTEM RESTART, INDICATES THE NEWEST GCI THAT CAN BE RESTARTED */ +/*AFTER THIS SYSTEM RESTART. USED TO FIND THE LOG HEAD. */ +/* ------------------------------------------------------------------------- */ + UintR crestartNewestGci; +/* ------------------------------------------------------------------------- */ +/*THE NUMBER OF LOG FILES. SET AS A PARAMETER WHEN NDB IS STARTED. */ +/* ------------------------------------------------------------------------- */ + UintR cnoLogFiles; +/* ------------------------------------------------------------------------- */ +/*THESE TWO VARIABLES CONTAIN THE NEWEST GCI RECEIVED IN THE BLOCK AND THE */ +/*NEWEST COMPLETED GCI IN THE BLOCK. */ +/* ------------------------------------------------------------------------- */ + UintR cnewestGci; + UintR cnewestCompletedGci; +/* ------------------------------------------------------------------------- */ +/*THIS VARIABLE ONLY PASSES INFORMATION FROM STTOR TO STTORRY = TEMPORARY */ +/* ------------------------------------------------------------------------- */ + Uint16 csignalKey; +/* ------------------------------------------------------------------------- */ +/*THIS VARIABLE CONTAINS THE CURRENT START PHASE IN THE BLOCK. IS ZNIL IF */ +/*NO SYSTEM RESTART IS ONGOING. */ +/* ------------------------------------------------------------------------- */ + Uint16 cstartPhase; +/* ------------------------------------------------------------------------- */ +/*THIS VARIABLE CONTAIN THE CURRENT GLOBAL CHECKPOINT RECORD. IT'S RNIL IF */ +/*NOT A GCP SAVE IS ONGOING. */ +/* ------------------------------------------------------------------------- */ + UintR ccurrentGcprec; +/* ------------------------------------------------------------------------- */ +/*THESE VARIABLES ARE USED TO KEEP TRACK OF ALL ACTIVE COPY FRAGMENTS IN LQH.*/ +/* ------------------------------------------------------------------------- */ + Uint8 cnoActiveCopy; + UintR cactiveCopy[4]; + +/* ------------------------------------------------------------------------- */ +/*THESE VARIABLES CONTAIN THE BLOCK REFERENCES OF THE OTHER NDB BLOCKS. */ +/*ALSO THE BLOCK REFERENCE OF MY OWN BLOCK = LQH */ +/* ------------------------------------------------------------------------- */ + BlockReference caccBlockref; + BlockReference ctupBlockref; + BlockReference ctuxBlockref; + BlockReference cownref; + UintR cLqhTimeOutCount; + UintR cLqhTimeOutCheckCount; + UintR cnoOfLogPages; + bool caccCommitBlocked; + bool ctupCommitBlocked; + bool cCommitBlocked; + UintR cCounterAccCommitBlocked; + UintR cCounterTupCommitBlocked; +/* ------------------------------------------------------------------------- */ +/*THIS VARIABLE CONTAINS MY OWN PROCESSOR ID. */ +/* ------------------------------------------------------------------------- */ + NodeId cownNodeid; + +/* ------------------------------------------------------------------------- */ +/*THESE VARIABLES CONTAIN INFORMATION ABOUT THE OTHER NODES IN THE SYSTEM */ +/*THESE VARIABLES ARE MOSTLY USED AT SYSTEM RESTART AND ADD NODE TO SET-UP */ +/*AND RELEASE CONNECTIONS TO OTHER NODES IN THE CLUSTER. */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/*THIS ARRAY CONTAINS THE PROCESSOR ID'S OF THE NODES THAT ARE ALIVE. */ +/*CNO_OF_NODES SPECIFIES HOW MANY NODES THAT ARE CURRENTLY ALIVE. */ +/*CNODE_VERSION SPECIFIES THE NDB VERSION EXECUTING ON THE NODE. */ +/* ------------------------------------------------------------------------- */ + UintR cpackedListIndex; + Uint16 cpackedList[MAX_NDB_NODES]; + UintR cnodeData[MAX_NDB_NODES]; + UintR cnodeStatus[MAX_NDB_NODES]; +/* ------------------------------------------------------------------------- */ +/*THIS VARIABLE INDICATES WHETHER A CERTAIN NODE HAS SENT ALL FRAGMENTS THAT */ +/*NEED TO HAVE THE LOG EXECUTED. */ +/* ------------------------------------------------------------------------- */ + Uint8 cnodeSrState[MAX_NDB_NODES]; +/* ------------------------------------------------------------------------- */ +/*THIS VARIABLE INDICATES WHETHER A CERTAIN NODE HAVE EXECUTED THE LOG */ +/* ------------------------------------------------------------------------- */ + Uint8 cnodeExecSrState[MAX_NDB_NODES]; + UintR cnoOfNodes; + +/* ------------------------------------------------------------------------- */ +/* THIS VARIABLE CONTAINS THE DIRECTORY OF A HASH TABLE OF ALL ACTIVE */ +/* OPERATION IN THE BLOCK. IT IS USED TO BE ABLE TO QUICKLY ABORT AN */ +/* OPERATION WHERE THE CONNECTION WAS LOST DUE TO NODE FAILURES. IT IS */ +/* ACTUALLY USED FOR ALL ABORTS COMMANDED BY TC. */ +/* ------------------------------------------------------------------------- */ + UintR preComputedRequestInfoMask; + UintR ctransidHash[1024]; + + +public: + /** + * + */ + struct CommitAckMarker { + Uint32 transid1; + Uint32 transid2; + + Uint32 apiRef; // Api block ref + Uint32 apiOprec; // Connection Object in NDB API + Uint32 tcNodeId; + union { Uint32 nextPool; Uint32 nextHash; }; + Uint32 prevHash; + + inline bool equal(const CommitAckMarker & p) const { + return ((p.transid1 == transid1) && (p.transid2 == transid2)); + } + + inline Uint32 hashValue() const { + return transid1; + } + }; + + typedef Ptr CommitAckMarkerPtr; + ArrayPool m_commitAckMarkerPool; + DLHashTable m_commitAckMarkerHash; + typedef DLHashTable::Iterator CommitAckMarkerIterator; + void execREMOVE_MARKER_ORD(Signal* signal); + void scanMarkers(Signal* signal, Uint32 tcNodeFail, Uint32 bucket, Uint32 i); + + struct Counters { + Uint32 operations; + + inline void clear(){ + operations = 0; + } + }; + + Counters c_Counters; + + inline bool getAllowRead() const { + return getNodeState().startLevel < NodeState::SL_STOPPING_3; + } + + +}; + +#endif diff --git a/ndb/src/kernel/blocks/dblqh/DblqhInit.cpp b/ndb/src/kernel/blocks/dblqh/DblqhInit.cpp new file mode 100644 index 00000000000..615cfa4ea0b --- /dev/null +++ b/ndb/src/kernel/blocks/dblqh/DblqhInit.cpp @@ -0,0 +1,416 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#include +#define DBLQH_C +#include "Dblqh.hpp" +#include +#include + +#define DEBUG(x) { ndbout << "LQH::" << x << endl; } + +void Dblqh::initData() +{ + caddfragrecFileSize = ZADDFRAGREC_FILE_SIZE; + cattrinbufFileSize = ZATTRINBUF_FILE_SIZE; + cdatabufFileSize = ZDATABUF_FILE_SIZE; + cfragrecFileSize = 0; + cgcprecFileSize = ZGCPREC_FILE_SIZE; + chostFileSize = MAX_NDB_NODES; + clcpFileSize = ZNO_CONCURRENT_LCP; + clcpLocrecFileSize = ZLCP_LOCREC_FILE_SIZE; + clogPageFileSize = ZLOG_PAGE_FILE_SIZE; + clfoFileSize = ZLFO_FILE_SIZE; + clogFileFileSize = 0; + clogPartFileSize = ZLOG_PART_FILE_SIZE; + cpageRefFileSize = ZPAGE_REF_FILE_SIZE; + cscanrecFileSize = ZSCANREC_FILE_SIZE; + ctabrecFileSize = 0; + ctcConnectrecFileSize = 0; + ctcNodeFailrecFileSize = MAX_NDB_NODES; + + addFragRecord = 0; + attrbuf = 0; + databuf = 0; + fragrecord = 0; + gcpRecord = 0; + hostRecord = 0; + lcpRecord = 0; + lcpLocRecord = 0; + logPartRecord = 0; + logFileRecord = 0; + logFileOperationRecord = 0; + logPageRecord = 0; + pageRefRecord = 0; + scanRecord = 0; + tablerec = 0; + tcConnectionrec = 0; + tcNodeFailRecord = 0; + + // Records with constant sizes + + cLqhTimeOutCount = 0; + cLqhTimeOutCheckCount = 0; + cbookedAccOps = 0; +}//Dblqh::initData() + +void Dblqh::initRecords() +{ + // Records with dynamic sizes + addFragRecord = (AddFragRecord*)allocRecord("AddFragRecord", + sizeof(AddFragRecord), + caddfragrecFileSize); + attrbuf = (Attrbuf*)allocRecord("Attrbuf", + sizeof(Attrbuf), + cattrinbufFileSize); + + databuf = (Databuf*)allocRecord("Databuf", + sizeof(Databuf), + cdatabufFileSize); + + fragrecord = (Fragrecord*)allocRecord("Fragrecord", + sizeof(Fragrecord), + cfragrecFileSize); + + gcpRecord = (GcpRecord*)allocRecord("GcpRecord", + sizeof(GcpRecord), + cgcprecFileSize); + + hostRecord = (HostRecord*)allocRecord("HostRecord", + sizeof(HostRecord), + chostFileSize); + + lcpRecord = (LcpRecord*)allocRecord("LcpRecord", + sizeof(LcpRecord), + clcpFileSize); + + for(Uint32 i = 0; i +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include + +#include + +// Use DEBUG to print messages that should be +// seen only when we debug the product +#ifdef VM_TRACE +#define DEBUG(x) ndbout << "DBLQH: "<< x << endl; +#else +#define DEBUG(x) +#endif + +const Uint32 NR_ScanNo = MAX_PARALLEL_SCANS_PER_FRAG - 1; +const Uint32 NR_MinRangeScanNo = MAX_PARALLEL_SCANS_PER_FRAG; +const Uint32 NR_MaxRangeScanNo = NR_MinRangeScanNo + MAX_PARALLEL_INDEX_SCANS_PER_FRAG; + +void Dblqh::execACC_COM_BLOCK(Signal* signal) +{ + jamEntry(); +/* ------------------------------------------------------------------------- */ +// Undo log buffer in ACC is in critical sector of being full. +/* ------------------------------------------------------------------------- */ + cCounterAccCommitBlocked++; + caccCommitBlocked = true; + cCommitBlocked = true; + return; +}//Dblqh::execACC_COM_BLOCK() + +void Dblqh::execACC_COM_UNBLOCK(Signal* signal) +{ + jamEntry(); +/* ------------------------------------------------------------------------- */ +// Undo log buffer in ACC ok again. +/* ------------------------------------------------------------------------- */ + caccCommitBlocked = false; + if (ctupCommitBlocked == false) { + jam(); + cCommitBlocked = false; + }//if + return; +}//Dblqh::execACC_COM_UNBLOCK() + +void Dblqh::execTUP_COM_BLOCK(Signal* signal) +{ + jamEntry(); +/* ------------------------------------------------------------------------- */ +// Undo log buffer in TUP is in critical sector of being full. +/* ------------------------------------------------------------------------- */ + cCounterTupCommitBlocked++; + ctupCommitBlocked = true; + cCommitBlocked = true; + return; +}//Dblqh::execTUP_COM_BLOCK() + +void Dblqh::execTUP_COM_UNBLOCK(Signal* signal) +{ + jamEntry(); +/* ------------------------------------------------------------------------- */ +// Undo log buffer in TUP ok again. +/* ------------------------------------------------------------------------- */ + ctupCommitBlocked = false; + if (caccCommitBlocked == false) { + jam(); + cCommitBlocked = false; + }//if + return; +}//Dblqh::execTUP_COM_UNBLOCK() + +/* ------------------------------------------------------------------------- */ +/* ------- SEND SYSTEM ERROR ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dblqh::systemError(Signal* signal) +{ + progError(0, 0); +}//Dblqh::systemError() + +/* *************** */ +/* ACCSEIZEREF > */ +/* *************** */ +void Dblqh::execACCSEIZEREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +}//Dblqh::execACCSEIZEREF() + +/* ******************************************************>> */ +/* THIS SIGNAL IS USED TO HANDLE REAL-TIME */ +/* BREAKS THAT ARE NECESSARY TO ENSURE REAL-TIME */ +/* OPERATION OF LQH. */ +/* This signal is also used for signal loops, for example */ +/* the timeout handling for writing logs every second. */ +/* ******************************************************>> */ +void Dblqh::execCONTINUEB(Signal* signal) +{ + jamEntry(); + Uint32 tcase = signal->theData[0]; + Uint32 data0 = signal->theData[1]; + Uint32 data1 = signal->theData[2]; + Uint32 data2 = signal->theData[3]; +#if 0 + if (tcase == RNIL) { + tcConnectptr.i = data0; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + ndbout << "State = " << tcConnectptr.p->transactionState; + ndbout << " seqNoReplica = " << tcConnectptr.p->seqNoReplica; + ndbout << " tcNodeFailrec = " << tcConnectptr.p->tcNodeFailrec; + ndbout << " activeCreat = " << tcConnectptr.p->activeCreat; + ndbout << endl; + ndbout << "tupkeyData0 = " << tcConnectptr.p->tupkeyData[0]; + ndbout << "tupkeyData1 = " << tcConnectptr.p->tupkeyData[1]; + ndbout << "tupkeyData2 = " << tcConnectptr.p->tupkeyData[2]; + ndbout << "tupkeyData3 = " << tcConnectptr.p->tupkeyData[3]; + ndbout << endl; + ndbout << "abortState = " << tcConnectptr.p->abortState; + ndbout << "listState = " << tcConnectptr.p->listState; + ndbout << endl; + return; + }//if +#endif + switch (tcase) { + case ZLOG_LQHKEYREQ: + if (cnoOfLogPages == 0) { + jam(); + sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 10, 2); + return; + }//if + logPartPtr.i = data0; + ptrCheckGuard(logPartPtr, clogPartFileSize, logPartRecord); + logFilePtr.i = logPartPtr.p->currentLogfile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + logPagePtr.i = logFilePtr.p->currentLogpage; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + + tcConnectptr.i = logPartPtr.p->firstLogQueue; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if ((cCommitBlocked == true) && + (fragptr.p->fragActiveStatus == ZTRUE)) { + jam(); + sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 10, 2); + return; + }//if + logPartPtr.p->LogLqhKeyReqSent = ZFALSE; + getFirstInLogQueue(signal); + + switch (tcConnectptr.p->transactionState) { + case TcConnectionrec::LOG_QUEUED: + if (tcConnectptr.p->abortState != TcConnectionrec::ABORT_IDLE) { + jam(); + logNextStart(signal); + abortCommonLab(signal); + return; + } else { + jam(); +/*------------------------------------------------------------*/ +/* WE MUST SET THE STATE OF THE LOG PART TO IDLE TO */ +/* ENSURE THAT WE ARE NOT QUEUED AGAIN ON THE LOG PART */ +/* WE WILL SET THE LOG PART STATE TO ACTIVE IMMEDIATELY */ +/* SO NO OTHER PROCESS WILL SEE THIS STATE. IT IS MERELY*/ +/* USED TO ENABLE REUSE OF CODE. */ +/*------------------------------------------------------------*/ + if (logPartPtr.p->logPartState == LogPartRecord::ACTIVE) { + jam(); + logPartPtr.p->logPartState = LogPartRecord::IDLE; + }//if + logLqhkeyreqLab(signal); + return; + }//if + break; + case TcConnectionrec::LOG_ABORT_QUEUED: + jam(); + writeAbortLog(signal); + removeLogTcrec(signal); + logNextStart(signal); + continueAfterLogAbortWriteLab(signal); + return; + break; + case TcConnectionrec::LOG_COMMIT_QUEUED: + case TcConnectionrec::LOG_COMMIT_QUEUED_WAIT_SIGNAL: + jam(); + writeCommitLog(signal, logPartPtr); + logNextStart(signal); + if (tcConnectptr.p->transactionState == TcConnectionrec::LOG_COMMIT_QUEUED) { + if (tcConnectptr.p->seqNoReplica != 0) { + jam(); + commitReplyLab(signal); + } else { + jam(); + localCommitLab(signal); + }//if + return; + } else { + jam(); + tcConnectptr.p->transactionState = TcConnectionrec::LOG_COMMIT_WRITTEN_WAIT_SIGNAL; + return; + }//if + break; + case TcConnectionrec::COMMIT_QUEUED: + jam(); + logNextStart(signal); + localCommitLab(signal); + break; + case TcConnectionrec::ABORT_QUEUED: + jam(); + logNextStart(signal); + abortCommonLab(signal); + break; + default: + ndbrequire(false); + break; + }//switch + return; + break; + case ZSR_GCI_LIMITS: + jam(); + signal->theData[0] = data0; + srGciLimits(signal); + return; + break; + case ZSR_LOG_LIMITS: + jam(); + signal->theData[0] = data0; + signal->theData[1] = data1; + signal->theData[2] = data2; + srLogLimits(signal); + return; + break; + case ZSEND_EXEC_CONF: + jam(); + signal->theData[0] = data0; + sendExecConf(signal); + return; + break; + case ZEXEC_SR: + jam(); + signal->theData[0] = data0; + execSr(signal); + return; + break; + case ZSR_FOURTH_COMP: + jam(); + signal->theData[0] = data0; + srFourthComp(signal); + return; + break; + case ZINIT_FOURTH: + jam(); + signal->theData[0] = data0; + initFourth(signal); + return; + break; + case ZTIME_SUPERVISION: + jam(); + signal->theData[0] = data0; + timeSup(signal); + return; + break; + case ZSR_PHASE3_START: + jam(); + signal->theData[0] = data0; + srPhase3Start(signal); + return; + break; + case ZLQH_TRANS_NEXT: + jam(); + tcNodeFailptr.i = data0; + ptrCheckGuard(tcNodeFailptr, ctcNodeFailrecFileSize, tcNodeFailRecord); + lqhTransNextLab(signal); + return; + break; + case ZSCAN_TC_CONNECT: + jam(); + tabptr.i = data1; + ptrCheckGuard(tabptr, ctabrecFileSize, tablerec); + scanTcConnectLab(signal, data0, data2); + return; + break; + case ZINITIALISE_RECORDS: + jam(); + initialiseRecordsLab(signal, data0); + return; + break; + case ZINIT_GCP_REC: + jam(); + gcpPtr.i = 0; + ptrAss(gcpPtr, gcpRecord); + initGcpRecLab(signal); + return; + break; + case ZRESTART_OPERATIONS_AFTER_STOP: + jam(); + tcConnectptr.i = data0; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + if (tcConnectptr.p->listState != TcConnectionrec::WAIT_QUEUE_LIST) { + jam(); + return; + }//if + releaseWaitQueue(signal); + linkActiveFrag(signal); + restartOperationsAfterStopLab(signal); + return; + break; + case ZCHECK_LCP_STOP_BLOCKED: + jam(); + scanptr.i = data0; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + tcConnectptr.i = scanptr.p->scanTcrec; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + checkLcpStopBlockedLab(signal); + return; + case ZSCAN_MARKERS: + jam(); + scanMarkers(signal, data0, data1, data2); + return; + break; + + case ZOPERATION_EVENT_REP: + jam(); + /* --------------------------------------------------------------------- */ + // Report information about transaction activity once per second. + /* --------------------------------------------------------------------- */ + if (signal->theData[1] == 0) { + signal->theData[0] = EventReport::OperationReportCounters; + signal->theData[1] = c_Counters.operations; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); + }//if + c_Counters.clear(); + signal->theData[0] = ZOPERATION_EVENT_REP; + signal->theData[1] = 0; + sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 5000, 2); + break; + case ZPREP_DROP_TABLE: + jam(); + checkDropTab(signal); + return; + break; + default: + ndbrequire(false); + break; + }//switch +}//Dblqh::execCONTINUEB() + +/* *********************************************************> */ +/* Request from DBDIH to include a new node in the node list */ +/* and so forth. */ +/* *********************************************************> */ +void Dblqh::execINCL_NODEREQ(Signal* signal) +{ + jamEntry(); + BlockReference retRef = signal->theData[0]; + Uint32 nodeId = signal->theData[1]; + cnewestGci = signal->theData[2]; + cnewestCompletedGci = signal->theData[2] - 1; + ndbrequire(cnoOfNodes < MAX_NDB_NODES); + for (Uint32 i = 0; i < cnoOfNodes; i++) { + jam(); + if (cnodeData[i] == nodeId) { + jam(); + cnodeStatus[i] = ZNODE_UP; + }//if + }//for + signal->theData[0] = cownref; + sendSignal(retRef, GSN_INCL_NODECONF, signal, 1, JBB); + return; +}//Dblqh::execINCL_NODEREQ() + +void Dblqh::execTUPSEIZEREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +}//Dblqh::execTUPSEIZEREF() + +/* ########################################################################## */ +/* ####### START / RESTART MODULE ####### */ +/* ########################################################################## */ +/* ************************************************************************>> */ +/* This is first signal that arrives in a start / restart. Sender is NDBCNTR_REF. */ +/* ************************************************************************>> */ +void Dblqh::execSTTOR(Signal* signal) +{ + UintR tstartPhase; + + jamEntry(); + /* START CASE */ + tstartPhase = signal->theData[1]; + /* SYSTEM RESTART RANK */ + csignalKey = signal->theData[6]; + switch (tstartPhase) { + case ZSTART_PHASE1: + jam(); + cstartPhase = tstartPhase; + sttorStartphase1Lab(signal); + return; + break; + default: + jam(); + /*empty*/; + sendsttorryLab(signal); + return; + break; + }//switch +}//Dblqh::execSTTOR() + +/* ***************************************> */ +/* Restart phases 1 - 6, sender is Ndbcntr */ +/* ***************************************> */ +void Dblqh::execNDB_STTOR(Signal* signal) +{ + jamEntry(); + Uint32 ownNodeId = signal->theData[1]; /* START PHASE*/ + cstartPhase = signal->theData[2]; /* MY NODE ID */ + cstartType = signal->theData[3]; /* START TYPE */ + Uint32 config1 = signal->theData[10]; /* CONFIG INFO LQH */ + + switch (cstartPhase) { + case ZSTART_PHASE1: + jam(); + preComputedRequestInfoMask = 0; + LqhKeyReq::setKeyLen(preComputedRequestInfoMask, RI_KEYLEN_MASK); + LqhKeyReq::setLastReplicaNo(preComputedRequestInfoMask, RI_LAST_REPL_MASK); + LqhKeyReq::setLockType(preComputedRequestInfoMask, RI_LOCK_TYPE_MASK); + // Dont LqhKeyReq::setApplicationAddressFlag + LqhKeyReq::setDirtyFlag(preComputedRequestInfoMask, 1); + // Dont LqhKeyReq::setInterpretedFlag + LqhKeyReq::setSimpleFlag(preComputedRequestInfoMask, 1); + LqhKeyReq::setOperation(preComputedRequestInfoMask, RI_OPERATION_MASK); + // Dont setAIInLqhKeyReq + // Dont setSeqNoReplica + // Dont setSameClientAndTcFlag + // Dont setReturnedReadLenAIFlag + // Dont setAPIVersion + LqhKeyReq::setMarkerFlag(preComputedRequestInfoMask, 1); + //preComputedRequestInfoMask = 0x003d7fff; + startphase1Lab(signal, config1, ownNodeId); + + signal->theData[0] = ZOPERATION_EVENT_REP; + signal->theData[1] = 1; + sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 10, 2); + return; + break; + case ZSTART_PHASE2: + jam(); + startphase2Lab(signal, config1); + return; + break; + case ZSTART_PHASE3: + jam(); + startphase3Lab(signal); + return; + break; + case ZSTART_PHASE4: + jam(); + startphase4Lab(signal); + return; + break; + case ZSTART_PHASE6: + jam(); + startphase6Lab(signal); + return; + break; + default: + jam(); + /*empty*/; + sendNdbSttorryLab(signal); + return; + break; + }//switch +}//Dblqh::execNDB_STTOR() + +/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */ +/* +++++++ START PHASE 1 +++++++ */ +/* LOAD OUR BLOCK REFERENCE AND OUR PROCESSOR ID */ +/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */ +void Dblqh::sttorStartphase1Lab(Signal* signal) +{ + sendsttorryLab(signal); + return; +}//Dblqh::sttorStartphase1Lab() + +/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */ +/* +++++++ START PHASE 2 +++++++ */ +/* */ +/* INITIATE ALL RECORDS WITHIN THE BLOCK */ +/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */ +void Dblqh::startphase1Lab(Signal* signal, Uint32 config, Uint32 ownNodeId) +{ + UintR Ti; + HostRecordPtr ThostPtr; + +/* ------- INITIATE ALL RECORDS ------- */ + if (config == 0) { + jam(); + config = 1; + }//if + cnoLogFiles = config; + cownNodeid = ownNodeId; + caccBlockref = calcAccBlockRef (cownNodeid); + ctupBlockref = calcTupBlockRef (cownNodeid); + ctuxBlockref = calcTuxBlockRef (cownNodeid); + cownref = calcLqhBlockRef (cownNodeid); + for (Ti = 0; Ti < chostFileSize; Ti++) { + ThostPtr.i = Ti; + ptrCheckGuard(ThostPtr, chostFileSize, hostRecord); + ThostPtr.p->hostLqhBlockRef = calcLqhBlockRef(ThostPtr.i); + ThostPtr.p->hostTcBlockRef = calcTcBlockRef(ThostPtr.i); + ThostPtr.p->inPackedList = false; + ThostPtr.p->noOfPackedWordsLqh = 0; + ThostPtr.p->noOfPackedWordsTc = 0; + }//for + cpackedListIndex = 0; + sendNdbSttorryLab(signal); + return; +}//Dblqh::startphase1Lab() + +/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */ +/* +++++++ START PHASE 2 +++++++ */ +/* */ +/* CONNECT LQH WITH ACC AND TUP. */ +/* EVERY CONNECTION RECORD IN LQH IS ASSIGNED TO ONE ACC CONNECTION RECORD */ +/* AND ONE TUP CONNECTION RECORD. */ +/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */ +void Dblqh::startphase2Lab(Signal* signal, Uint32 config) +{ + if (config == 0) { + jam(); + config = 1; + } else if (config > 4) { + jam(); + config = 4; + }//if + cmaxWordsAtNodeRec = MAX_NO_WORDS_OUTSTANDING_COPY_FRAGMENT; +/* -- ACC AND TUP CONNECTION PROCESS -- */ + tcConnectptr.i = 0; + ptrAss(tcConnectptr, tcConnectionrec); + moreconnectionsLab(signal); + return; +}//Dblqh::startphase2Lab() + +void Dblqh::moreconnectionsLab(Signal* signal) +{ + tcConnectptr.p->tcAccBlockref = caccBlockref; + // set TUX block here (no operation is seized in TUX) + tcConnectptr.p->tcTuxBlockref = ctuxBlockref; +/* NO STATE CHECKING IS PERFORMED, ASSUMED TO WORK */ +/* *************** */ +/* ACCSEIZEREQ < */ +/* *************** */ + signal->theData[0] = tcConnectptr.i; + signal->theData[1] = cownref; + sendSignal(caccBlockref, GSN_ACCSEIZEREQ, signal, 2, JBB); + return; +}//Dblqh::moreconnectionsLab() + +/* ***************> */ +/* ACCSEIZECONF > */ +/* ***************> */ +void Dblqh::execACCSEIZECONF(Signal* signal) +{ + jamEntry(); + tcConnectptr.i = signal->theData[0]; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + tcConnectptr.p->accConnectrec = signal->theData[1]; +/* *************** */ +/* TUPSEIZEREQ < */ +/* *************** */ + tcConnectptr.p->tcTupBlockref = ctupBlockref; + signal->theData[0] = tcConnectptr.i; + signal->theData[1] = cownref; + sendSignal(ctupBlockref, GSN_TUPSEIZEREQ, signal, 2, JBB); + return; +}//Dblqh::execACCSEIZECONF() + +/* ***************> */ +/* TUPSEIZECONF > */ +/* ***************> */ +void Dblqh::execTUPSEIZECONF(Signal* signal) +{ + jamEntry(); + tcConnectptr.i = signal->theData[0]; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + tcConnectptr.p->tupConnectrec = signal->theData[1]; +/* ------- CHECK IF THERE ARE MORE CONNECTIONS TO BE CONNECTED ------- */ + tcConnectptr.i = tcConnectptr.p->nextTcConnectrec; + if (tcConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + moreconnectionsLab(signal); + return; + }//if +/* ALL LQH_CONNECT RECORDS ARE CONNECTED TO ACC AND TUP ---- */ + sendNdbSttorryLab(signal); + return; +}//Dblqh::execTUPSEIZECONF() + +/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */ +/* +++++++ START PHASE 4 +++++++ */ +/* */ +/* CONNECT LQH WITH LQH. */ +/* CONNECT EACH LQH WITH EVERY LQH IN THE DATABASE SYSTEM. */ +/* IF INITIAL START THEN CREATE THE FRAGMENT LOG FILES */ +/*IF SYSTEM RESTART OR NODE RESTART THEN OPEN THE FRAGMENT LOG FILES AND */ +/*FIND THE END OF THE LOG FILES. */ +/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */ +/* WAIT UNTIL ADD NODE PROCESSES ARE COMPLETED */ +/* IF INITIAL START ALSO WAIT FOR LOG FILES TO INITIALISED */ +/*START TIME SUPERVISION OF LOG FILES. WE HAVE TO WRITE LOG PAGES TO DISK */ +/*EVEN IF THE PAGES ARE NOT FULL TO ENSURE THAT THEY COME TO DISK ASAP. */ +/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */ +void Dblqh::startphase3Lab(Signal* signal) +{ + LogFileRecordPtr prevLogFilePtr; + LogFileRecordPtr zeroLogFilePtr; + + caddNodeState = ZTRUE; +/* ***************<< */ +/* READ_NODESREQ < */ +/* ***************<< */ + cinitialStartOngoing = ZTRUE; + ndbrequire(cnoLogFiles != 0); + + for (logPartPtr.i = 0; logPartPtr.i < 4; logPartPtr.i++) { + jam(); + ptrAss(logPartPtr, logPartRecord); + initLogpart(signal); + for (Uint32 fileNo = 0; fileNo < cnoLogFiles; fileNo++) { + seizeLogfile(signal); + if (fileNo != 0) { + jam(); + prevLogFilePtr.p->nextLogFile = logFilePtr.i; + logFilePtr.p->prevLogFile = prevLogFilePtr.i; + } else { + jam(); + logPartPtr.p->firstLogfile = logFilePtr.i; + logPartPtr.p->currentLogfile = logFilePtr.i; + zeroLogFilePtr.i = logFilePtr.i; + zeroLogFilePtr.p = logFilePtr.p; + }//if + prevLogFilePtr.i = logFilePtr.i; + prevLogFilePtr.p = logFilePtr.p; + initLogfile(signal, fileNo); + if ((cstartType == NodeState::ST_INITIAL_START) || + (cstartType == NodeState::ST_INITIAL_NODE_RESTART)) { + if (logFilePtr.i == zeroLogFilePtr.i) { + jam(); +/* ------------------------------------------------------------------------- */ +/*IN AN INITIAL START WE START BY CREATING ALL LOG FILES AND SETTING THEIR */ +/*PROPER SIZE AND INITIALISING PAGE ZERO IN ALL FILES. */ +/*WE START BY CREATING FILE ZERO IN EACH LOG PART AND THEN PROCEED */ +/*SEQUENTIALLY THROUGH ALL LOG FILES IN THE LOG PART. */ +/* ------------------------------------------------------------------------- */ + openLogfileInit(signal); + }//if + }//if + }//for + zeroLogFilePtr.p->prevLogFile = logFilePtr.i; + logFilePtr.p->nextLogFile = zeroLogFilePtr.i; + }//for + if (cstartType != NodeState::ST_INITIAL_START && + cstartType != NodeState::ST_INITIAL_NODE_RESTART) { + jam(); + ndbrequire(cstartType == NodeState::ST_NODE_RESTART || + cstartType == NodeState::ST_SYSTEM_RESTART); + /** -------------------------------------------------------------------- + * THIS CODE KICKS OFF THE SYSTEM RESTART AND NODE RESTART. IT STARTS UP + * THE RESTART BY FINDING THE END OF THE LOG AND FROM THERE FINDING THE + * INFO ABOUT THE GLOBAL CHECKPOINTS IN THE FRAGMENT LOG. + --------------------------------------------------------------------- */ + for (logPartPtr.i = 0; logPartPtr.i < 4; logPartPtr.i++) { + jam(); + LogFileRecordPtr locLogFilePtr; + ptrAss(logPartPtr, logPartRecord); + locLogFilePtr.i = logPartPtr.p->firstLogfile; + ptrCheckGuard(locLogFilePtr, clogFileFileSize, logFileRecord); + locLogFilePtr.p->logFileStatus = LogFileRecord::OPEN_SR_FRONTPAGE; + openFileRw(signal, locLogFilePtr); + }//for + }//if + + signal->theData[0] = cownref; + sendSignal(NDBCNTR_REF, GSN_READ_NODESREQ, signal, 1, JBB); + return; +}//Dblqh::startphase3Lab() + +/* ****************** */ +/* READ_NODESCONF > */ +/* ****************** */ +void Dblqh::execREAD_NODESCONF(Signal* signal) +{ + jamEntry(); + + ReadNodesConf * const readNodes = (ReadNodesConf *)&signal->theData[0]; + cnoOfNodes = readNodes->noOfNodes; + + unsigned ind = 0; + unsigned i = 0; + for (i = 1; i < MAX_NDB_NODES; i++) { + jam(); + if (NodeBitmask::get(readNodes->allNodes, i)) { + jam(); + cnodeData[ind] = i; + cnodeStatus[ind] = NodeBitmask::get(readNodes->inactiveNodes, i); + //readNodes->getVersionId(i, readNodes->theVersionIds) not used + ind++; + }//if + }//for + ndbrequire(ind == cnoOfNodes); + ndbrequire(cnoOfNodes >= 1 && cnoOfNodes < MAX_NDB_NODES); + ndbrequire(!(cnoOfNodes == 1 && cstartType == NodeState::ST_NODE_RESTART)); + + caddNodeState = ZFALSE; + if (cstartType == NodeState::ST_SYSTEM_RESTART) { + jam(); + sendNdbSttorryLab(signal); + return; + }//if + checkStartCompletedLab(signal); + return; +}//Dblqh::execREAD_NODESCONF() + +void Dblqh::checkStartCompletedLab(Signal* signal) +{ + if (caddNodeState == ZFALSE) { + if (cinitialStartOngoing == ZFALSE) { + jam(); + sendNdbSttorryLab(signal); + return; + }//if + }//if + return; +}//Dblqh::checkStartCompletedLab() + +void Dblqh::startphase4Lab(Signal* signal) +{ + sendNdbSttorryLab(signal); + return; +}//Dblqh::startphase4Lab() + +/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */ +/* SET CONCURRENCY OF LOCAL CHECKPOINTS TO BE USED AFTER SYSTEM RESTART. */ +/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */ +void Dblqh::startphase6Lab(Signal* signal) +{ + cstartPhase = ZNIL; + cstartType = ZNIL; + sendNdbSttorryLab(signal); + return; +}//Dblqh::startphase6Lab() + +void Dblqh::sendNdbSttorryLab(Signal* signal) +{ + signal->theData[0] = cownref; + sendSignal(NDBCNTR_REF, GSN_NDB_STTORRY, signal, 1, JBB); + return; +}//Dblqh::sendNdbSttorryLab() + +void Dblqh::sendsttorryLab(Signal* signal) +{ +/* *********<< */ +/* STTORRY < */ +/* *********<< */ + signal->theData[0] = csignalKey; /* SIGNAL KEY */ + signal->theData[1] = 3; /* BLOCK CATEGORY */ + signal->theData[2] = 2; /* SIGNAL VERSION NUMBER */ + signal->theData[3] = ZSTART_PHASE1; + signal->theData[4] = 255; + sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 5, JBB); + return; +}//Dblqh::sendsttorryLab() + +/* ***************>> */ +/* READ_NODESREF > */ +/* ***************>> */ +void Dblqh::execREAD_NODESREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +}//Dblqh::execREAD_NODESREF() + +/* *************** */ +/* SIZEALT_REP > */ +/* *************** */ +void Dblqh::execSIZEALT_REP(Signal* signal) +{ + jamEntry(); + cfragrecFileSize = signal->theData[LqhSizeAltReq::IND_FRAG]; + ctabrecFileSize = signal->theData[LqhSizeAltReq::IND_TABLE]; + ctcConnectrecFileSize = signal->theData[LqhSizeAltReq::IND_TC_CONNECT]; + clogFileFileSize = signal->theData[LqhSizeAltReq::IND_LOG_FILES]; + cscanrecFileSize = signal->theData[LqhSizeAltReq::IND_SCAN]; + cmaxAccOps = cscanrecFileSize * MAX_PARALLEL_SCANS_PER_FRAG; + initRecords(); + initialiseRecordsLab(signal, 0); + + return; +}//Dblqh::execSIZEALT_REP() + +void Dblqh::returnInitialiseRecordsLab(Signal* signal) +{ + signal->theData[0] = DBLQH_REF; + sendSignal(CMVMI_REF, GSN_SIZEALT_ACK, signal, 2, JBB); + + + return; +}//Dblqh::returnInitialiseRecordsLab() + +/* ########################################################################## */ +/* ####### ADD/DELETE FRAGMENT MODULE ####### */ +/* THIS MODULE IS USED BY DICTIONARY TO CREATE NEW FRAGMENTS AND DELETE */ +/* OLD FRAGMENTS. */ +/* */ +/* ########################################################################## */ +/* -------------------------------------------------------------- */ +/* FRAG REQ */ +/* -------------------------------------------------------------- */ +/* *********************************************************> */ +/* LQHFRAGREQ: Create new fragments for a table. Sender DICT */ +/* *********************************************************> */ +void Dblqh::execLQHFRAGREQ(Signal* signal) +{ + jamEntry(); + LqhFragReq * req = (LqhFragReq*)signal->getDataPtr(); + + Uint32 retPtr = req->senderData; + BlockReference retRef = req->senderRef; + Uint32 fragId = req->fragmentId; + Uint32 reqinfo = req->requestInfo; + tabptr.i = req->tableId; + Uint16 tlocalKeylen = req->localKeyLength; + Uint32 tmaxLoadFactor = req->maxLoadFactor; + Uint32 tminLoadFactor = req->minLoadFactor; + Uint8 tk = req->kValue; + Uint8 tlhstar = req->lh3DistrBits; + Uint8 tlh = req->lh3PageBits; + Uint32 tnoOfAttr = req->noOfAttributes; + Uint32 tnoOfNull = req->noOfNullAttributes; + Uint32 noOfAlloc = req->noOfPagesToPreAllocate; + Uint32 tschemaVersion = req->schemaVersion; + Uint32 ttupKeyLength = req->keyLength; + Uint32 nextLcp = req->nextLCP; + Uint32 noOfKeyAttr = req->noOfKeyAttr; + Uint32 noOfNewAttr = req->noOfNewAttr; + Uint32 checksumIndicator = req->checksumIndicator; + Uint32 noOfAttributeGroups = req->noOfAttributeGroups; + Uint32 gcpIndicator = req->GCPIndicator; + Uint32 startGci = req->startGci; + Uint32 tableType = req->tableType; + Uint32 primaryTableId = req->primaryTableId; + + ptrCheckGuard(tabptr, ctabrecFileSize, tablerec); + bool tempTable = ((reqinfo & LqhFragReq::TemporaryTable) != 0); + + /* Temporary tables set to defined in system restart */ + if (tabptr.p->tableStatus == Tablerec::NOT_DEFINED){ + tabptr.p->tableStatus = Tablerec::ADD_TABLE_ONGOING; + tabptr.p->tableType = tableType; + tabptr.p->primaryTableId = primaryTableId; + tabptr.p->schemaVersion = tschemaVersion; + }//if + + if (tabptr.p->tableStatus != Tablerec::ADD_TABLE_ONGOING){ + jam(); + fragrefLab(signal, retRef, retPtr, ZTAB_STATE_ERROR); + return; + }//if + //-------------------------------------------------------------------- + // We could arrive here if we create the fragment as part of a take + // over by a hot spare node. The table is then is already created + // and bit 31 is set, thus indicating that we are creating a fragment + // by copy creation. Also since the node has already been started we + // know that it is not a node restart ongoing. + //-------------------------------------------------------------------- + + if (getFragmentrec(signal, fragId)) { + jam(); + fragrefLab(signal, retRef, retPtr, terrorCode); + return; + }//if + if (!insertFragrec(signal, fragId)) { + jam(); + fragrefLab(signal, retRef, retPtr, terrorCode); + return; + }//if + Uint32 copyType = reqinfo & 3; + initFragrec(signal, tabptr.i, fragId, copyType); + fragptr.p->startGci = startGci; + fragptr.p->newestGci = startGci; + fragptr.p->tableType = tableType; + + if (DictTabInfo::isOrderedIndex(tableType)) { + jam(); + // find corresponding primary table fragment + TablerecPtr tTablePtr; + tTablePtr.i = primaryTableId; + ptrCheckGuard(tTablePtr, ctabrecFileSize, tablerec); + FragrecordPtr tFragPtr; + tFragPtr.i = RNIL; + for (Uint32 i = 0; i < NO_OF_FRAG_PER_NODE; i++) { + if (tTablePtr.p->fragid[i] == fragptr.p->fragId) { + jam(); + tFragPtr.i = tTablePtr.p->fragrec[i]; + break; + } + } + ndbrequire(tFragPtr.i != RNIL); + // store it + fragptr.p->tableFragptr = tFragPtr.i; + } + + if (tempTable) { +//-------------------------------------------- +// reqinfo bit 3-4 = 2 means temporary table +// without logging or checkpointing. +//-------------------------------------------- + jam(); + fragptr.p->logFlag = Fragrecord::STATE_FALSE; + fragptr.p->lcpFlag = Fragrecord::LCP_STATE_FALSE; + }//if + + fragptr.p->nextLcp = nextLcp; +//---------------------------------------------- +// For node restarts it is not necessarily zero +//---------------------------------------------- + if (cfirstfreeAddfragrec == RNIL) { + jam(); + deleteFragrec(fragId); + fragrefLab(signal, retRef, retPtr, ZNO_ADD_FRAGREC); + return; + }//if + seizeAddfragrec(signal); + addfragptr.p->addFragid = fragId; + addfragptr.p->fragmentPtr = fragptr.i; + addfragptr.p->dictBlockref = retRef; + addfragptr.p->dictConnectptr = retPtr; + addfragptr.p->m_senderAttrPtr = RNIL; + addfragptr.p->noOfAttr = tnoOfAttr; + addfragptr.p->noOfNull = tnoOfNull; + addfragptr.p->noOfAllocPages = noOfAlloc; + addfragptr.p->tabId = tabptr.i; + addfragptr.p->totalAttrReceived = 0; + addfragptr.p->attrSentToTup = ZNIL;/* TO FIND PROGRAMMING ERRORS QUICKLY */ + addfragptr.p->schemaVer = tschemaVersion; + Uint32 tmp = (reqinfo & LqhFragReq::CreateInRunning); + addfragptr.p->fragCopyCreation = (tmp == 0 ? 0 : 1); + addfragptr.p->addfragErrorCode = 0; + addfragptr.p->noOfKeyAttr = noOfKeyAttr; + addfragptr.p->noOfNewAttr = noOfNewAttr; + addfragptr.p->checksumIndicator = checksumIndicator; + addfragptr.p->noOfAttributeGroups = noOfAttributeGroups; + addfragptr.p->GCPIndicator = gcpIndicator; + addfragptr.p->lh3DistrBits = tlhstar; + addfragptr.p->tableType = tableType; + addfragptr.p->primaryTableId = primaryTableId; + + if (DictTabInfo::isTable(tableType) || + DictTabInfo::isHashIndex(tableType)) { + jam(); + AccFragReq* const accreq = (AccFragReq*)signal->getDataPtrSend(); + accreq->userPtr = addfragptr.i; + accreq->userRef = cownref; + accreq->tableId = tabptr.i; + accreq->reqInfo = copyType << 4; + accreq->fragId = fragId; + accreq->localKeyLen = tlocalKeylen; + accreq->maxLoadFactor = tmaxLoadFactor; + accreq->minLoadFactor = tminLoadFactor; + accreq->kValue = tk; + accreq->lhFragBits = tlhstar; + accreq->lhDirBits = tlh; + accreq->keyLength = ttupKeyLength; + /* ----------------------------------------------------------------------- */ + /* Send ACCFRAGREQ, when confirmation is received send 2 * TUPFRAGREQ to */ + /* create 2 tuple fragments on this node. */ + /* ----------------------------------------------------------------------- */ + addfragptr.p->addfragStatus = AddFragRecord::ACC_ADDFRAG; + sendSignal(fragptr.p->accBlockref, GSN_ACCFRAGREQ, + signal, AccFragReq::SignalLength, JBB); + return; + } + if (DictTabInfo::isOrderedIndex(tableType)) { + jam(); + // NOTE: next 2 lines stolen from ACC + addfragptr.p->fragid1 = (0 << tlhstar) | fragId; + addfragptr.p->fragid2 = (1 << tlhstar) | fragId; + addfragptr.p->addfragStatus = AddFragRecord::WAIT_TWO_TUP; + sendAddFragReq(signal); + return; + } + ndbrequire(false); +}//Dblqh::execLQHFRAGREQ() + +/* *************** */ +/* ACCFRAGCONF > */ +/* *************** */ +void Dblqh::execACCFRAGCONF(Signal* signal) +{ + jamEntry(); + addfragptr.i = signal->theData[0]; + Uint32 taccConnectptr = signal->theData[1]; + Uint32 fragId1 = signal->theData[2]; + Uint32 fragId2 = signal->theData[3]; + Uint32 accFragPtr1 = signal->theData[4]; + Uint32 accFragPtr2 = signal->theData[5]; + Uint32 hashCheckBit = signal->theData[6]; + ptrCheckGuard(addfragptr, caddfragrecFileSize, addFragRecord); + ndbrequire(addfragptr.p->addfragStatus == AddFragRecord::ACC_ADDFRAG); + + addfragptr.p->accConnectptr = taccConnectptr; + addfragptr.p->fragid1 = fragId1; + addfragptr.p->fragid2 = fragId2; + fragptr.i = addfragptr.p->fragmentPtr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + fragptr.p->accFragptr[0] = accFragPtr1; + fragptr.p->accFragptr[1] = accFragPtr2; + fragptr.p->hashCheckBit = hashCheckBit; + + addfragptr.p->addfragStatus = AddFragRecord::WAIT_TWO_TUP; + sendAddFragReq(signal); +}//Dblqh::execACCFRAGCONF() + +/* *************** */ +/* TUPFRAGCONF > */ +/* *************** */ +void Dblqh::execTUPFRAGCONF(Signal* signal) +{ + jamEntry(); + addfragptr.i = signal->theData[0]; + Uint32 tupConnectptr = signal->theData[1]; + Uint32 tupFragPtr = signal->theData[2]; /* TUP FRAGMENT POINTER */ + Uint32 localFragId = signal->theData[3]; /* LOCAL FRAGMENT ID */ + ptrCheckGuard(addfragptr, caddfragrecFileSize, addFragRecord); + fragptr.i = addfragptr.p->fragmentPtr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if (localFragId == addfragptr.p->fragid1) { + jam(); + fragptr.p->tupFragptr[0] = tupFragPtr; + } else if (localFragId == addfragptr.p->fragid2) { + jam(); + fragptr.p->tupFragptr[1] = tupFragPtr; + } else { + ndbrequire(false); + return; + }//if + switch (addfragptr.p->addfragStatus) { + case AddFragRecord::WAIT_TWO_TUP: + jam(); + fragptr.p->tupFragptr[0] = tupFragPtr; + addfragptr.p->tup1Connectptr = tupConnectptr; + addfragptr.p->addfragStatus = AddFragRecord::WAIT_ONE_TUP; + sendAddFragReq(signal); + break; + case AddFragRecord::WAIT_ONE_TUP: + jam(); + fragptr.p->tupFragptr[1] = tupFragPtr; + addfragptr.p->tup2Connectptr = tupConnectptr; + if (DictTabInfo::isOrderedIndex(addfragptr.p->tableType)) { + addfragptr.p->addfragStatus = AddFragRecord::WAIT_TWO_TUX; + sendAddFragReq(signal); + break; + } + goto done_with_frag; + break; + case AddFragRecord::WAIT_TWO_TUX: + jam(); + fragptr.p->tuxFragptr[0] = tupFragPtr; + addfragptr.p->tux1Connectptr = tupConnectptr; + addfragptr.p->addfragStatus = AddFragRecord::WAIT_ONE_TUX; + sendAddFragReq(signal); + break; + case AddFragRecord::WAIT_ONE_TUX: + jam(); + fragptr.p->tuxFragptr[1] = tupFragPtr; + addfragptr.p->tux2Connectptr = tupConnectptr; + goto done_with_frag; + break; + done_with_frag: + /* ---------------------------------------------------------------- */ + /* Finished create of fragments. Now ready for creating attributes. */ + /* ---------------------------------------------------------------- */ + addfragptr.p->addfragStatus = AddFragRecord::WAIT_ADD_ATTR; + { + LqhFragConf* conf = (LqhFragConf*)signal->getDataPtrSend(); + conf->senderData = addfragptr.p->dictConnectptr; + conf->lqhFragPtr = addfragptr.i; + sendSignal(addfragptr.p->dictBlockref, GSN_LQHFRAGCONF, + signal, LqhFragConf::SignalLength, JBB); + } + break; + default: + ndbrequire(false); + break; + } +}//Dblqh::execTUPFRAGCONF() + +/* *************** */ +/* TUXFRAGCONF > */ +/* *************** */ +void Dblqh::execTUXFRAGCONF(Signal* signal) +{ + jamEntry(); + execTUPFRAGCONF(signal); +}//Dblqh::execTUXFRAGCONF + +/* + * Add fragment in TUP or TUX. Called up to 4 times. + */ +void +Dblqh::sendAddFragReq(Signal* signal) +{ + fragptr.i = addfragptr.p->fragmentPtr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if (addfragptr.p->addfragStatus == AddFragRecord::WAIT_TWO_TUP || + addfragptr.p->addfragStatus == AddFragRecord::WAIT_ONE_TUP) { + if (DictTabInfo::isTable(addfragptr.p->tableType) || + DictTabInfo::isHashIndex(addfragptr.p->tableType)) { + jam(); + signal->theData[0] = addfragptr.i; + signal->theData[1] = cownref; + signal->theData[2] = 0; /* ADD TABLE */ + signal->theData[3] = addfragptr.p->tabId; + signal->theData[4] = addfragptr.p->noOfAttr; + signal->theData[5] = + addfragptr.p->addfragStatus == AddFragRecord::WAIT_TWO_TUP + ? addfragptr.p->fragid1 : addfragptr.p->fragid2; + signal->theData[6] = (addfragptr.p->noOfAllocPages >> 1) + 1; + signal->theData[7] = addfragptr.p->noOfNull; + signal->theData[8] = addfragptr.p->schemaVer; + signal->theData[9] = addfragptr.p->noOfKeyAttr; + signal->theData[10] = addfragptr.p->noOfNewAttr; + signal->theData[11] = addfragptr.p->checksumIndicator; + signal->theData[12] = addfragptr.p->noOfAttributeGroups; + signal->theData[13] = addfragptr.p->GCPIndicator; + sendSignal(fragptr.p->tupBlockref, GSN_TUPFRAGREQ, + signal, TupFragReq::SignalLength, JBB); + return; + } + if (DictTabInfo::isOrderedIndex(addfragptr.p->tableType)) { + jam(); + signal->theData[0] = addfragptr.i; + signal->theData[1] = cownref; + signal->theData[2] = 0; /* ADD TABLE */ + signal->theData[3] = addfragptr.p->tabId; + signal->theData[4] = 1; /* ordered index: one array attr */ + signal->theData[5] = + addfragptr.p->addfragStatus == AddFragRecord::WAIT_TWO_TUP + ? addfragptr.p->fragid1 : addfragptr.p->fragid2; + signal->theData[6] = (addfragptr.p->noOfAllocPages >> 1) + 1; + signal->theData[7] = 0; /* ordered index: no nullable */ + signal->theData[8] = addfragptr.p->schemaVer; + signal->theData[9] = 1; /* ordered index: one key */ + signal->theData[10] = addfragptr.p->noOfNewAttr; + signal->theData[11] = addfragptr.p->checksumIndicator; + signal->theData[12] = addfragptr.p->noOfAttributeGroups; + signal->theData[13] = addfragptr.p->GCPIndicator; + sendSignal(fragptr.p->tupBlockref, GSN_TUPFRAGREQ, + signal, TupFragReq::SignalLength, JBB); + return; + } + } + if (addfragptr.p->addfragStatus == AddFragRecord::WAIT_TWO_TUX || + addfragptr.p->addfragStatus == AddFragRecord::WAIT_ONE_TUX) { + if (DictTabInfo::isOrderedIndex(addfragptr.p->tableType)) { + jam(); + TuxFragReq* const tuxreq = (TuxFragReq*)signal->getDataPtrSend(); + tuxreq->userPtr = addfragptr.i; + tuxreq->userRef = cownref; + tuxreq->reqInfo = 0; /* ADD TABLE */ + tuxreq->tableId = addfragptr.p->tabId; + ndbrequire(addfragptr.p->noOfAttr >= 2); + tuxreq->noOfAttr = addfragptr.p->noOfAttr - 1; /* skip NDB$TNODE */ + tuxreq->fragId = + addfragptr.p->addfragStatus == AddFragRecord::WAIT_TWO_TUX + ? addfragptr.p->fragid1 : addfragptr.p->fragid2; + tuxreq->fragOff = addfragptr.p->lh3DistrBits; + tuxreq->tableType = addfragptr.p->tableType; + tuxreq->primaryTableId = addfragptr.p->primaryTableId; + sendSignal(fragptr.p->tuxBlockref, GSN_TUXFRAGREQ, + signal, TuxFragReq::SignalLength, JBB); + return; + } + } + ndbrequire(false); +}//Dblqh::sendAddFragReq + +/* ************************************************************************> */ +/* LQHADDATTRREQ: Request from DICT to create attributes for the new table. */ +/* ************************************************************************> */ +void Dblqh::execLQHADDATTREQ(Signal* signal) +{ + jamEntry(); + LqhAddAttrReq * const req = (LqhAddAttrReq*)signal->getDataPtr(); + + addfragptr.i = req->lqhFragPtr; + const Uint32 tnoOfAttr = req->noOfAttributes; + const Uint32 senderData = req->senderData; + const Uint32 senderAttrPtr = req->senderAttrPtr; + + ptrCheckGuard(addfragptr, caddfragrecFileSize, addFragRecord); + ndbrequire(addfragptr.p->addfragStatus == AddFragRecord::WAIT_ADD_ATTR); + ndbrequire((tnoOfAttr != 0) && (tnoOfAttr <= LqhAddAttrReq::MAX_ATTRIBUTES)); + addfragptr.p->totalAttrReceived += tnoOfAttr; + ndbrequire(addfragptr.p->totalAttrReceived <= addfragptr.p->noOfAttr); + + addfragptr.p->attrReceived = tnoOfAttr; + for (Uint32 i = 0; i < tnoOfAttr; i++) { + addfragptr.p->attributes[i] = req->attributes[i]; + }//for + addfragptr.p->attrSentToTup = 0; + ndbrequire(addfragptr.p->dictConnectptr == senderData); + addfragptr.p->m_senderAttrPtr = senderAttrPtr; + addfragptr.p->addfragStatus = AddFragRecord::TUP_ATTR_WAIT1; + sendAddAttrReq(signal); +}//Dblqh::execLQHADDATTREQ() + +/* *********************>> */ +/* TUP_ADD_ATTCONF > */ +/* *********************>> */ +void Dblqh::execTUP_ADD_ATTCONF(Signal* signal) +{ + jamEntry(); + addfragptr.i = signal->theData[0]; + ptrCheckGuard(addfragptr, caddfragrecFileSize, addFragRecord); + switch (addfragptr.p->addfragStatus) { + case AddFragRecord::TUP_ATTR_WAIT1: + jam(); + addfragptr.p->addfragStatus = AddFragRecord::TUP_ATTR_WAIT2; + sendAddAttrReq(signal); + break; + case AddFragRecord::TUP_ATTR_WAIT2: + jam(); + if (DictTabInfo::isOrderedIndex(addfragptr.p->tableType)) { + addfragptr.p->addfragStatus = AddFragRecord::TUX_ATTR_WAIT1; + sendAddAttrReq(signal); + break; + } + goto done_with_attr; + break; + case AddFragRecord::TUX_ATTR_WAIT1: + jam(); + addfragptr.p->addfragStatus = AddFragRecord::TUX_ATTR_WAIT2; + sendAddAttrReq(signal); + break; + case AddFragRecord::TUX_ATTR_WAIT2: + jam(); + goto done_with_attr; + break; + done_with_attr: + addfragptr.p->attrSentToTup = addfragptr.p->attrSentToTup + 1; + ndbrequire(addfragptr.p->attrSentToTup <= addfragptr.p->attrReceived); + ndbrequire(addfragptr.p->totalAttrReceived <= addfragptr.p->noOfAttr); + if (addfragptr.p->attrSentToTup < addfragptr.p->attrReceived) { + // more in this batch + jam(); + addfragptr.p->addfragStatus = AddFragRecord::TUP_ATTR_WAIT1; + sendAddAttrReq(signal); + } else if (addfragptr.p->totalAttrReceived < addfragptr.p->noOfAttr) { + // more batches to receive + jam(); + addfragptr.p->addfragStatus = AddFragRecord::WAIT_ADD_ATTR; + LqhAddAttrConf *const conf = (LqhAddAttrConf*)signal->getDataPtrSend(); + conf->senderData = addfragptr.p->dictConnectptr; + conf->senderAttrPtr = addfragptr.p->m_senderAttrPtr; + conf->fragId = addfragptr.p->addFragid; + sendSignal(addfragptr.p->dictBlockref, GSN_LQHADDATTCONF, + signal, LqhAddAttrConf::SignalLength, JBB); + } else { + fragptr.i = addfragptr.p->fragmentPtr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + /* ------------------------------------------------------------------ + * WE HAVE NOW COMPLETED ADDING THIS FRAGMENT. WE NOW NEED TO SET THE + * PROPER STATE IN FRAG_STATUS DEPENDENT ON IF WE ARE CREATING A NEW + * REPLICA OR IF WE ARE CREATING A TABLE. FOR FRAGMENTS IN COPY + * PROCESS WE DO NOT WANT LOGGING ACTIVATED. + * ----------------------------------------------------------------- */ + if (addfragptr.p->fragCopyCreation == 1) { + jam(); + if (! DictTabInfo::isOrderedIndex(addfragptr.p->tableType)) + fragptr.p->fragStatus = Fragrecord::ACTIVE_CREATION; + else + fragptr.p->fragStatus = Fragrecord::FSACTIVE; + fragptr.p->logFlag = Fragrecord::STATE_FALSE; + } else { + jam(); + fragptr.p->fragStatus = Fragrecord::FSACTIVE; + }//if + LqhAddAttrConf *const conf = (LqhAddAttrConf*)signal->getDataPtrSend(); + conf->senderData = addfragptr.p->dictConnectptr; + conf->senderAttrPtr = addfragptr.p->m_senderAttrPtr; + conf->fragId = addfragptr.p->addFragid; + sendSignal(addfragptr.p->dictBlockref, GSN_LQHADDATTCONF, signal, + LqhAddAttrConf::SignalLength, JBB); + releaseAddfragrec(signal); + }//if + break; + default: + ndbrequire(false); + break; + } +} + +/* **********************>> */ +/* TUX_ADD_ATTRCONF > */ +/* **********************>> */ +void Dblqh::execTUX_ADD_ATTRCONF(Signal* signal) +{ + jamEntry(); + execTUP_ADD_ATTCONF(signal); +}//Dblqh::execTUX_ADD_ATTRCONF + +/* + * Add attribute in TUP or TUX. Called up to 4 times. + */ +void +Dblqh::sendAddAttrReq(Signal* signal) +{ + arrGuard(addfragptr.p->attrSentToTup, LqhAddAttrReq::MAX_ATTRIBUTES); + LqhAddAttrReq::Entry& entry = + addfragptr.p->attributes[addfragptr.p->attrSentToTup]; + const Uint32 attrId = entry.attrId & 0xffff; + const Uint32 primaryAttrId = entry.attrId >> 16; + fragptr.i = addfragptr.p->fragmentPtr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if (addfragptr.p->addfragStatus == AddFragRecord::TUP_ATTR_WAIT1 || + addfragptr.p->addfragStatus == AddFragRecord::TUP_ATTR_WAIT2) { + if (DictTabInfo::isTable(addfragptr.p->tableType) || + DictTabInfo::isHashIndex(addfragptr.p->tableType) || + (DictTabInfo::isOrderedIndex(addfragptr.p->tableType) && + primaryAttrId == ZNIL)) { + jam(); + TupAddAttrReq* const tupreq = (TupAddAttrReq*)signal->getDataPtrSend(); + tupreq->tupConnectPtr = + addfragptr.p->addfragStatus == AddFragRecord::TUP_ATTR_WAIT1 + ? addfragptr.p->tup1Connectptr : addfragptr.p->tup2Connectptr; + tupreq->notused1 = 0; + tupreq->attrId = attrId; + tupreq->attrDescriptor = entry.attrDescriptor; + sendSignal(fragptr.p->tupBlockref, GSN_TUP_ADD_ATTRREQ, + signal, TupAddAttrReq::SignalLength, JBB); + return; + } + if (DictTabInfo::isOrderedIndex(addfragptr.p->tableType) && + primaryAttrId != ZNIL) { + // this attribute is not for TUP + jam(); + TupAddAttrConf* tupconf = (TupAddAttrConf*)signal->getDataPtrSend(); + tupconf->userPtr = addfragptr.i; + sendSignal(reference(), GSN_TUP_ADD_ATTCONF, + signal, TupAddAttrConf::SignalLength, JBB); + return; + } + } + if (addfragptr.p->addfragStatus == AddFragRecord::TUX_ATTR_WAIT1 || + addfragptr.p->addfragStatus == AddFragRecord::TUX_ATTR_WAIT2) { + jam(); + if (DictTabInfo::isOrderedIndex(addfragptr.p->tableType) && + primaryAttrId != ZNIL) { + jam(); + TuxAddAttrReq* const tuxreq = (TuxAddAttrReq*)signal->getDataPtrSend(); + tuxreq->tuxConnectPtr = + addfragptr.p->addfragStatus == AddFragRecord::TUX_ATTR_WAIT1 + ? addfragptr.p->tux1Connectptr : addfragptr.p->tux2Connectptr; + tuxreq->notused1 = 0; + tuxreq->attrId = attrId; + tuxreq->attrDescriptor = entry.attrDescriptor; + tuxreq->extTypeInfo = entry.extTypeInfo; + tuxreq->primaryAttrId = primaryAttrId; + sendSignal(fragptr.p->tuxBlockref, GSN_TUX_ADD_ATTRREQ, + signal, TuxAddAttrReq::SignalLength, JBB); + return; + } + if (DictTabInfo::isOrderedIndex(addfragptr.p->tableType) && + primaryAttrId == ZNIL) { + // this attribute is not for TUX + jam(); + TuxAddAttrConf* tuxconf = (TuxAddAttrConf*)signal->getDataPtrSend(); + tuxconf->userPtr = addfragptr.i; + sendSignal(reference(), GSN_TUX_ADD_ATTRCONF, + signal, TuxAddAttrConf::SignalLength, JBB); + return; + } + } + ndbrequire(false); +}//Dblqh::sendAddAttrReq + +/* ************************************************************************>> */ +/* TAB_COMMITREQ: Commit the new table for use in transactions. Sender DICT. */ +/* ************************************************************************>> */ +void Dblqh::execTAB_COMMITREQ(Signal* signal) +{ + jamEntry(); + Uint32 dihPtr = signal->theData[0]; + BlockReference dihBlockref = signal->theData[1]; + tabptr.i = signal->theData[2]; + + if (tabptr.i >= ctabrecFileSize) { + jam(); + terrorCode = ZTAB_FILE_SIZE; + signal->theData[0] = dihPtr; + signal->theData[1] = cownNodeid; + signal->theData[2] = tabptr.i; + signal->theData[3] = terrorCode; + sendSignal(dihBlockref, GSN_TAB_COMMITREF, signal, 4, JBB); + return; + }//if + ptrAss(tabptr, tablerec); + if (tabptr.p->tableStatus != Tablerec::ADD_TABLE_ONGOING) { + jam(); + terrorCode = ZTAB_STATE_ERROR; + signal->theData[0] = dihPtr; + signal->theData[1] = cownNodeid; + signal->theData[2] = tabptr.i; + signal->theData[3] = terrorCode; + signal->theData[4] = tabptr.p->tableStatus; + sendSignal(dihBlockref, GSN_TAB_COMMITREF, signal, 5, JBB); + ndbrequire(false); + return; + }//if + tabptr.p->usageCount = 0; + tabptr.p->tableStatus = Tablerec::TABLE_DEFINED; + signal->theData[0] = dihPtr; + signal->theData[1] = cownNodeid; + signal->theData[2] = tabptr.i; + sendSignal(dihBlockref, GSN_TAB_COMMITCONF, signal, 3, JBB); + return; +}//Dblqh::execTAB_COMMITREQ() + + +void Dblqh::fragrefLab(Signal* signal, + BlockReference fragBlockRef, + Uint32 fragConPtr, + Uint32 errorCode) +{ + LqhFragRef * ref = (LqhFragRef*)signal->getDataPtrSend(); + ref->senderData = fragConPtr; + ref->errorCode = errorCode; + sendSignal(fragBlockRef, GSN_LQHFRAGREF, signal, + LqhFragRef::SignalLength, JBB); + return; +}//Dblqh::fragrefLab() + +/* ************>> */ +/* ACCFRAGREF > */ +/* ************>> */ +void Dblqh::execACCFRAGREF(Signal* signal) +{ + jamEntry(); + addfragptr.i = signal->theData[0]; + ptrCheckGuard(addfragptr, caddfragrecFileSize, addFragRecord); + terrorCode = signal->theData[1]; + ndbrequire(addfragptr.p->addfragStatus == AddFragRecord::ACC_ADDFRAG); + addfragptr.p->addfragErrorCode = terrorCode; + + const Uint32 ref = addfragptr.p->dictBlockref; + const Uint32 senderData = addfragptr.p->dictConnectptr; + const Uint32 errorCode = addfragptr.p->addfragErrorCode; + releaseAddfragrec(signal); + fragrefLab(signal, ref, senderData, errorCode); + + return; +}//Dblqh::execACCFRAGREF() + +/* ************>> */ +/* TUPFRAGREF > */ +/* ************>> */ +void Dblqh::execTUPFRAGREF(Signal* signal) +{ + jamEntry(); + addfragptr.i = signal->theData[0]; + ptrCheckGuard(addfragptr, caddfragrecFileSize, addFragRecord); + terrorCode = signal->theData[1]; + fragptr.i = addfragptr.p->fragmentPtr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + addfragptr.p->addfragErrorCode = terrorCode; + const Uint32 ref = addfragptr.p->dictBlockref; + const Uint32 senderData = addfragptr.p->dictConnectptr; + const Uint32 errorCode = addfragptr.p->addfragErrorCode; + releaseAddfragrec(signal); + fragrefLab(signal, ref, senderData, errorCode); + +}//Dblqh::execTUPFRAGREF() + +/* ************>> */ +/* TUXFRAGREF > */ +/* ************>> */ +void Dblqh::execTUXFRAGREF(Signal* signal) +{ + jamEntry(); + execTUPFRAGREF(signal); +}//Dblqh::execTUXFRAGREF + +/* *********************> */ +/* TUP_ADD_ATTREF > */ +/* *********************> */ +void Dblqh::execTUP_ADD_ATTRREF(Signal* signal) +{ + jamEntry(); + + addfragptr.i = signal->theData[0]; + ptrCheckGuard(addfragptr, caddfragrecFileSize, addFragRecord); + terrorCode = signal->theData[1]; + addfragptr.p->addfragErrorCode = terrorCode; + + const Uint32 Ref = addfragptr.p->dictBlockref; + const Uint32 senderData = addfragptr.p->dictConnectptr; + const Uint32 errorCode = addfragptr.p->addfragErrorCode; + releaseAddfragrec(signal); + + LqhAddAttrRef *const ref = (LqhAddAttrRef*)signal->getDataPtrSend(); + ref->senderData = senderData; + ref->errorCode = errorCode; + sendSignal(Ref, GSN_LQHADDATTREF, signal, + LqhAddAttrRef::SignalLength, JBB); + +}//Dblqh::execTUP_ADD_ATTRREF() + +/* **********************> */ +/* TUX_ADD_ATTRREF > */ +/* **********************> */ +void Dblqh::execTUX_ADD_ATTRREF(Signal* signal) +{ + jamEntry(); + execTUP_ADD_ATTRREF(signal); +}//Dblqh::execTUX_ADD_ATTRREF + +void +Dblqh::execPREP_DROP_TAB_REQ(Signal* signal){ + jamEntry(); + + PrepDropTabReq* req = (PrepDropTabReq*)signal->getDataPtr(); + + Uint32 senderRef = req->senderRef; + Uint32 senderData = req->senderData; + + TablerecPtr tabPtr; + tabPtr.i = req->tableId; + ptrCheckGuard(tabPtr, ctabrecFileSize, tablerec); + + Uint32 errCode = 0; + errCode = checkDropTabState(tabPtr.p->tableStatus, GSN_PREP_DROP_TAB_REQ); + if(errCode != 0){ + jam(); + + PrepDropTabRef* ref = (PrepDropTabRef*)signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = senderData; + ref->tableId = tabPtr.i; + ref->errorCode = errCode; + sendSignal(senderRef, GSN_PREP_DROP_TAB_REF, signal, + PrepDropTabRef::SignalLength, JBB); + return; + } + + tabPtr.p->tableStatus = Tablerec::PREP_DROP_TABLE_ONGOING; + tabPtr.p->waitingTC.clear(); + tabPtr.p->waitingDIH.clear(); + + PrepDropTabConf * conf = (PrepDropTabConf*)signal->getDataPtrSend(); + conf->tableId = tabPtr.i; + conf->senderRef = reference(); + conf->senderData = senderData; + sendSignal(senderRef, GSN_PREP_DROP_TAB_CONF, signal, + PrepDropTabConf::SignalLength, JBB); + + signal->theData[0] = ZPREP_DROP_TABLE; + signal->theData[1] = tabPtr.i; + signal->theData[2] = senderRef; + signal->theData[3] = senderData; + checkDropTab(signal); +} + +void +Dblqh::checkDropTab(Signal* signal){ + + TablerecPtr tabPtr; + tabPtr.i = signal->theData[1]; + ptrCheckGuard(tabPtr, ctabrecFileSize, tablerec); + + ndbrequire(tabPtr.p->tableStatus == Tablerec::PREP_DROP_TABLE_ONGOING); + + if(tabPtr.p->usageCount > 0){ + jam(); + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 4); + return; + } + + bool lcpDone = true; + lcpPtr.i = 0; + ptrAss(lcpPtr, lcpRecord); + if(lcpPtr.p->lcpState != LcpRecord::LCP_IDLE){ + jam(); + + if(lcpPtr.p->currentFragment.lcpFragOrd.tableId == tabPtr.i){ + jam(); + lcpDone = false; + } + + if(lcpPtr.p->lcpQueued && + lcpPtr.p->queuedFragment.lcpFragOrd.tableId == tabPtr.i){ + jam(); + lcpDone = false; + } + } + + if(!lcpDone){ + jam(); + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 4); + return; + } + + tabPtr.p->tableStatus = Tablerec::PREP_DROP_TABLE_DONE; + + WaitDropTabConf * conf = (WaitDropTabConf*)signal->getDataPtrSend(); + conf->tableId = tabPtr.i; + conf->senderRef = reference(); + for(Uint32 i = 1; iwaitingTC.get(i)){ + tabPtr.p->waitingTC.clear(i); + sendSignal(calcTcBlockRef(i), GSN_WAIT_DROP_TAB_CONF, signal, + WaitDropTabConf::SignalLength, JBB); + } + if(tabPtr.p->waitingDIH.get(i)){ + tabPtr.p->waitingDIH.clear(i); + sendSignal(calcDihBlockRef(i), GSN_WAIT_DROP_TAB_CONF, signal, + WaitDropTabConf::SignalLength, JBB); + } + } +} + +void +Dblqh::execWAIT_DROP_TAB_REQ(Signal* signal){ + jamEntry(); + WaitDropTabReq * req = (WaitDropTabReq*)signal->getDataPtr(); + + TablerecPtr tabPtr; + tabPtr.i = req->tableId; + ptrCheckGuard(tabPtr, ctabrecFileSize, tablerec); + + Uint32 senderRef = req->senderRef; + Uint32 nodeId = refToNode(senderRef); + Uint32 blockNo = refToBlock(senderRef); + + if(tabPtr.p->tableStatus == Tablerec::PREP_DROP_TABLE_ONGOING){ + jam(); + switch(blockNo){ + case DBTC: + tabPtr.p->waitingTC.set(nodeId); + break; + case DBDIH: + tabPtr.p->waitingDIH.set(nodeId); + break; + default: + ndbrequire(false); + } + return; + } + + if(tabPtr.p->tableStatus == Tablerec::PREP_DROP_TABLE_DONE){ + jam(); + WaitDropTabConf * conf = (WaitDropTabConf*)signal->getDataPtrSend(); + conf->tableId = tabPtr.i; + conf->senderRef = reference(); + sendSignal(senderRef, GSN_WAIT_DROP_TAB_CONF, signal, + WaitDropTabConf::SignalLength, JBB); + return; + } + + WaitDropTabRef * ref = (WaitDropTabRef*)signal->getDataPtrSend(); + ref->tableId = tabPtr.i; + ref->senderRef = reference(); + + bool ok = false; + switch(tabPtr.p->tableStatus){ + case Tablerec::TABLE_DEFINED: + ok = true; + ref->errorCode = WaitDropTabRef::IllegalTableState; + break; + case Tablerec::NOT_DEFINED: + ok = true; + ref->errorCode = WaitDropTabRef::NoSuchTable; + break; + case Tablerec::ADD_TABLE_ONGOING: + ok = true; + ref->errorCode = WaitDropTabRef::IllegalTableState; + break; + case Tablerec::PREP_DROP_TABLE_ONGOING: + case Tablerec::PREP_DROP_TABLE_DONE: + // Should have been take care of above + ndbrequire(false); + } + ndbrequire(ok); + ref->tableStatus = tabPtr.p->tableStatus; + sendSignal(senderRef, GSN_WAIT_DROP_TAB_REF, signal, + WaitDropTabRef::SignalLength, JBB); + return; +} + +void +Dblqh::execDROP_TAB_REQ(Signal* signal){ + jamEntry(); + + DropTabReq* req = (DropTabReq*)signal->getDataPtr(); + + Uint32 senderRef = req->senderRef; + Uint32 senderData = req->senderData; + + TablerecPtr tabPtr; + tabPtr.i = req->tableId; + ptrCheckGuard(tabPtr, ctabrecFileSize, tablerec); + + do { + if(req->requestType == DropTabReq::RestartDropTab){ + jam(); + break; + } + + if(req->requestType == DropTabReq::OnlineDropTab){ + jam(); + Uint32 errCode = 0; + errCode = checkDropTabState(tabPtr.p->tableStatus, GSN_DROP_TAB_REQ); + if(errCode != 0){ + jam(); + + DropTabRef* ref = (DropTabRef*)signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = senderData; + ref->tableId = tabPtr.i; + ref->errorCode = errCode; + sendSignal(senderRef, GSN_DROP_TAB_REF, signal, + DropTabRef::SignalLength, JBB); + return; + } + } + + removeTable(tabPtr.i); + + } while(false); + + ndbrequire(tabPtr.p->usageCount == 0); + tabPtr.p->tableStatus = Tablerec::NOT_DEFINED; + + DropTabConf * const dropConf = (DropTabConf *)signal->getDataPtrSend(); + dropConf->senderRef = reference(); + dropConf->senderData = senderData; + dropConf->tableId = tabPtr.i; + sendSignal(senderRef, GSN_DROP_TAB_CONF, + signal, DropTabConf::SignalLength, JBB); +} + +Uint32 +Dblqh::checkDropTabState(Tablerec::TableStatus status, Uint32 gsn) const{ + + if(gsn == GSN_PREP_DROP_TAB_REQ){ + switch(status){ + case Tablerec::NOT_DEFINED: + jam(); + // Fall through + case Tablerec::ADD_TABLE_ONGOING: + jam(); + return PrepDropTabRef::NoSuchTable; + break; + case Tablerec::PREP_DROP_TABLE_ONGOING: + jam(); + return PrepDropTabRef::PrepDropInProgress; + break; + case Tablerec::PREP_DROP_TABLE_DONE: + jam(); + return PrepDropTabRef::DropInProgress; + break; + case Tablerec::TABLE_DEFINED: + jam(); + return 0; + break; + } + ndbrequire(0); + } + + if(gsn == GSN_DROP_TAB_REQ){ + switch(status){ + case Tablerec::NOT_DEFINED: + jam(); + // Fall through + case Tablerec::ADD_TABLE_ONGOING: + jam(); + return DropTabRef::NoSuchTable; + break; + case Tablerec::PREP_DROP_TABLE_ONGOING: + jam(); + return DropTabRef::PrepDropInProgress; + break; + case Tablerec::PREP_DROP_TABLE_DONE: + jam(); + return 0; + break; + case Tablerec::TABLE_DEFINED: + jam(); + return DropTabRef::DropWoPrep; + } + ndbrequire(0); + } + ndbrequire(0); + return RNIL; +} + +void Dblqh::removeTable(Uint32 tableId) +{ + tabptr.i = tableId; + ptrCheckGuard(tabptr, ctabrecFileSize, tablerec); + + for (Uint32 i = (NO_OF_FRAG_PER_NODE - 1); (Uint32)~i; i--) { + jam(); + if (tabptr.p->fragid[i] != ZNIL) { + jam(); + deleteFragrec(tabptr.p->fragid[i]); + }//if + }//for +}//Dblqh::removeTable() + +void +Dblqh::execALTER_TAB_REQ(Signal* signal) +{ + jamEntry(); + AlterTabReq* const req = (AlterTabReq*)signal->getDataPtr(); + const Uint32 senderRef = req->senderRef; + const Uint32 senderData = req->senderData; + const Uint32 changeMask = req->changeMask; + const Uint32 tableId = req->tableId; + const Uint32 tableVersion = req->tableVersion; + const Uint32 gci = req->gci; + AlterTabReq::RequestType requestType = + (AlterTabReq::RequestType) req->requestType; + + TablerecPtr tablePtr; + tablePtr.i = tableId; + ptrCheckGuard(tablePtr, ctabrecFileSize, tablerec); + tablePtr.p->schemaVersion = tableVersion; + + // Request handled successfully + AlterTabConf * conf = (AlterTabConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = senderData; + conf->changeMask = changeMask; + conf->tableId = tableId; + conf->tableVersion = tableVersion; + conf->gci = gci; + conf->requestType = requestType; + sendSignal(senderRef, GSN_ALTER_TAB_CONF, signal, + AlterTabConf::SignalLength, JBB); +} + +/* ************************************************************************>> + * TIME_SIGNAL: Handles time-out of local operations. This is a clean-up + * handler. If no other measure has succeeded in cleaning up after time-outs + * or else then this routine will remove the transaction after 120 seconds of + * inactivity. The check is performed once per 10 second. Sender is QMGR. + * ************************************************************************>> */ +void Dblqh::execTIME_SIGNAL(Signal* signal) +{ + jamEntry(); + cLqhTimeOutCount++; + cLqhTimeOutCheckCount++; + if ((cCounterAccCommitBlocked > 0) || + (cCounterTupCommitBlocked > 0)) { + jam(); + signal->theData[0] = EventReport::UndoLogBlocked; + signal->theData[1] = cCounterTupCommitBlocked; + signal->theData[2] = cCounterAccCommitBlocked; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB); + + cCounterTupCommitBlocked = 0; + cCounterAccCommitBlocked = 0; + }//if + if (cLqhTimeOutCheckCount < 10) { + jam(); + return; + }//if + cLqhTimeOutCheckCount = 0; +#ifdef VM_TRACE + TcConnectionrecPtr tTcConptr; + + for (tTcConptr.i = 0; tTcConptr.i < ctcConnectrecFileSize; + tTcConptr.i++) { + jam(); + ptrAss(tTcConptr, tcConnectionrec); + if ((tTcConptr.p->tcTimer != 0) && + ((tTcConptr.p->tcTimer + 120) < cLqhTimeOutCount)) { + ndbout << "Dblqh::execTIME_SIGNAL"<tcTimer = 0; + }//if + }//for +#endif +#ifdef VM_TRACE + for (lfoPtr.i = 0; lfoPtr.i < clfoFileSize; lfoPtr.i++) { + ptrAss(lfoPtr, logFileOperationRecord); + if ((lfoPtr.p->lfoTimer != 0) && + ((lfoPtr.p->lfoTimer + 120) < cLqhTimeOutCount)) { + ndbout << "We have lost LFO record" << endl; + ndbout << "index = " << lfoPtr.i; + ndbout << "State = " << lfoPtr.p->lfoState; + ndbout << " Page No = " << lfoPtr.p->lfoPageNo; + ndbout << " noPagesRw = " << lfoPtr.p->noPagesRw; + ndbout << "lfoWordWritten = " << lfoPtr.p->lfoWordWritten << endl; + lfoPtr.p->lfoTimer = cLqhTimeOutCount; + }//if + }//for + +#endif + +#if 0 + LcpRecordPtr TlcpPtr; + // Print information about the current local checkpoint + TlcpPtr.i = 0; + ptrAss(TlcpPtr, lcpRecord); + ndbout << "Information about LCP in this LQH" << endl + << " lcpState="<lcpState<> + * COMMIT: Start commit request from TC. This signal is originally sent as a + * packed signal and this function is called from execPACKED_SIGNAL. + * This is the normal commit protocol where TC first send this signal to the + * backup node which then will send COMMIT to the primary node. If + * everything is ok the primary node send COMMITTED back to TC. + * ************************************************************************>> */ +void Dblqh::execCOMMIT(Signal* signal) +{ + TcConnectionrec *regTcConnectionrec = tcConnectionrec; + Uint32 ttcConnectrecFileSize = ctcConnectrecFileSize; + Uint32 tcIndex = signal->theData[0]; + Uint32 gci = signal->theData[1]; + Uint32 transid1 = signal->theData[2]; + Uint32 transid2 = signal->theData[3]; + jamEntry(); + if (tcIndex >= ttcConnectrecFileSize) { + errorReport(signal, 0); + return; + }//if + if (ERROR_INSERTED(5011)) { + CLEAR_ERROR_INSERT_VALUE; + sendSignalWithDelay(cownref, GSN_COMMIT, signal, 2000, 4); + return; + }//if + if (ERROR_INSERTED(5012)) { + SET_ERROR_INSERT_VALUE(5017); + sendSignalWithDelay(cownref, GSN_COMMIT, signal, 2000, 4); + return; + }//if + tcConnectptr.i = tcIndex; + ptrAss(tcConnectptr, regTcConnectionrec); + if ((tcConnectptr.p->transid[0] == transid1) && + (tcConnectptr.p->transid[1] == transid2)) { + commitReqLab(signal, gci); + return; + }//if + warningReport(signal, 1); + return; +}//Dblqh::execCOMMIT() + +/* ************************************************************************>> + * COMMITREQ: Commit request from TC. This is the commit protocol used if + * one of the nodes is not behaving correctly. TC explicitly sends COMMITREQ + * to both the backup and primary node and gets a COMMITCONF back if the + * COMMIT was ok. + * ************************************************************************>> */ +void Dblqh::execCOMMITREQ(Signal* signal) +{ + jamEntry(); + Uint32 reqPtr = signal->theData[0]; + BlockReference reqBlockref = signal->theData[1]; + Uint32 gci = signal->theData[2]; + Uint32 transid1 = signal->theData[3]; + Uint32 transid2 = signal->theData[4]; + Uint32 tcOprec = signal->theData[6]; + if (ERROR_INSERTED(5004)) { + systemErrorLab(signal); + } + if (ERROR_INSERTED(5017)) { + CLEAR_ERROR_INSERT_VALUE; + sendSignalWithDelay(cownref, GSN_COMMITREQ, signal, 2000, 7); + return; + }//if + if (findTransaction(transid1, + transid2, + tcOprec) != ZOK) { + warningReport(signal, 5); + return; + }//if + TcConnectionrec * const regTcPtr = tcConnectptr.p; + switch (regTcPtr->transactionState) { + case TcConnectionrec::PREPARED: + case TcConnectionrec::LOG_COMMIT_QUEUED_WAIT_SIGNAL: + case TcConnectionrec::LOG_COMMIT_WRITTEN_WAIT_SIGNAL: + jam(); +/*-------------------------------------------------------*/ +/* THE NORMAL CASE. */ +/*-------------------------------------------------------*/ + regTcPtr->reqBlockref = reqBlockref; + regTcPtr->reqRef = reqPtr; + regTcPtr->abortState = TcConnectionrec::REQ_FROM_TC; + commitReqLab(signal, gci); + return; + break; + case TcConnectionrec::COMMITTED: + jam(); +/*---------------------------------------------------------*/ +/* FOR SOME REASON THE COMMIT PHASE HAVE BEEN */ +/* FINISHED AFTER A TIME OUT. WE NEED ONLY SEND A */ +/* COMMITCONF SIGNAL. */ +/*---------------------------------------------------------*/ + regTcPtr->reqBlockref = reqBlockref; + regTcPtr->reqRef = reqPtr; + regTcPtr->abortState = TcConnectionrec::REQ_FROM_TC; + signal->theData[0] = regTcPtr->reqRef; + signal->theData[1] = cownNodeid; + signal->theData[2] = regTcPtr->transid[0]; + signal->theData[3] = regTcPtr->transid[1]; + sendSignal(regTcPtr->reqBlockref, GSN_COMMITCONF, signal, 4, JBB); + break; + case TcConnectionrec::COMMIT_STOPPED: + jam(); + regTcPtr->reqBlockref = reqBlockref; + regTcPtr->reqRef = reqPtr; + regTcPtr->abortState = TcConnectionrec::REQ_FROM_TC; + /*empty*/; + break; + default: + jam(); + warningReport(signal, 4); + return; + break; + }//switch + return; +}//Dblqh::execCOMMITREQ() + +/* ************************************************************************>> + * COMPLETE : Complete the transaction. Sent as a packed signal from TC. + * Works the same way as COMMIT protocol. This is the normal case with both + * primary and backup working (See COMMIT). + * ************************************************************************>> */ +void Dblqh::execCOMPLETE(Signal* signal) +{ + TcConnectionrec *regTcConnectionrec = tcConnectionrec; + Uint32 ttcConnectrecFileSize = ctcConnectrecFileSize; + Uint32 tcIndex = signal->theData[0]; + Uint32 transid1 = signal->theData[1]; + Uint32 transid2 = signal->theData[2]; + jamEntry(); + if (tcIndex >= ttcConnectrecFileSize) { + errorReport(signal, 1); + return; + }//if + if (ERROR_INSERTED(5013)) { + CLEAR_ERROR_INSERT_VALUE; + sendSignalWithDelay(cownref, GSN_COMPLETE, signal, 2000, 3); + return; + }//if + if (ERROR_INSERTED(5014)) { + SET_ERROR_INSERT_VALUE(5018); + sendSignalWithDelay(cownref, GSN_COMPLETE, signal, 2000, 3); + return; + }//if + tcConnectptr.i = tcIndex; + ptrAss(tcConnectptr, regTcConnectionrec); + if ((tcConnectptr.p->transactionState == TcConnectionrec::COMMITTED) && + (tcConnectptr.p->transid[0] == transid1) && + (tcConnectptr.p->transid[1] == transid2)) { + if (tcConnectptr.p->seqNoReplica != 0) { + jam(); + localCommitLab(signal); + return; + } else { + jam(); + completeTransLastLab(signal); + return; + }//if + }//if + if (tcConnectptr.p->transactionState != TcConnectionrec::COMMITTED) { + warningReport(signal, 2); + } else { + warningReport(signal, 3); + }//if +}//Dblqh::execCOMPLETE() + +/* ************************************************************************>> + * COMPLETEREQ: Complete request from TC. Same as COMPLETE but used if one + * node is not working ok (See COMMIT). + * ************************************************************************>> */ +void Dblqh::execCOMPLETEREQ(Signal* signal) +{ + jamEntry(); + Uint32 reqPtr = signal->theData[0]; + BlockReference reqBlockref = signal->theData[1]; + Uint32 transid1 = signal->theData[2]; + Uint32 transid2 = signal->theData[3]; + Uint32 tcOprec = signal->theData[5]; + if (ERROR_INSERTED(5005)) { + systemErrorLab(signal); + } + if (ERROR_INSERTED(5018)) { + CLEAR_ERROR_INSERT_VALUE; + sendSignalWithDelay(cownref, GSN_COMPLETEREQ, signal, 2000, 6); + return; + }//if + if (findTransaction(transid1, + transid2, + tcOprec) != ZOK) { + jam(); +/*---------------------------------------------------------*/ +/* FOR SOME REASON THE COMPLETE PHASE STARTED AFTER */ +/* A TIME OUT. THE TRANSACTION IS GONE. WE NEED TO */ +/* REPORT COMPLETION ANYWAY. */ +/*---------------------------------------------------------*/ + signal->theData[0] = reqPtr; + signal->theData[1] = cownNodeid; + signal->theData[2] = transid1; + signal->theData[3] = transid2; + sendSignal(reqBlockref, GSN_COMPLETECONF, signal, 4, JBB); + warningReport(signal, 7); + return; + }//if + TcConnectionrec * const regTcPtr = tcConnectptr.p; + switch (regTcPtr->transactionState) { + case TcConnectionrec::COMMITTED: + jam(); + regTcPtr->reqBlockref = reqBlockref; + regTcPtr->reqRef = reqPtr; + regTcPtr->abortState = TcConnectionrec::REQ_FROM_TC; + /*empty*/; + break; +/*---------------------------------------------------------*/ +/* THE NORMAL CASE. */ +/*---------------------------------------------------------*/ + case TcConnectionrec::COMMIT_STOPPED: + jam(); +/*---------------------------------------------------------*/ +/* FOR SOME REASON THE COMPLETE PHASE STARTED AFTER */ +/* A TIME OUT. WE HAVE SET THE PROPER VARIABLES SUCH */ +/* THAT A COMPLETECONF WILL BE SENT WHEN COMPLETE IS */ +/* FINISHED. */ +/*---------------------------------------------------------*/ + regTcPtr->reqBlockref = reqBlockref; + regTcPtr->reqRef = reqPtr; + regTcPtr->abortState = TcConnectionrec::REQ_FROM_TC; + return; + break; + default: + jam(); + warningReport(signal, 6); + return; + break; + }//switch + if (regTcPtr->seqNoReplica != 0) { + jam(); + localCommitLab(signal); + return; + } else { + jam(); + completeTransLastLab(signal); + return; + }//if +}//Dblqh::execCOMPLETEREQ() + +/* ************> */ +/* COMPLETED > */ +/* ************> */ +void Dblqh::execLQHKEYCONF(Signal* signal) +{ + LqhKeyConf * const lqhKeyConf = (LqhKeyConf *)signal->getDataPtr(); + Uint32 tcIndex = lqhKeyConf->opPtr; + Uint32 ttcConnectrecFileSize = ctcConnectrecFileSize; + TcConnectionrec *regTcConnectionrec = tcConnectionrec; + jamEntry(); + if (tcIndex >= ttcConnectrecFileSize) { + errorReport(signal, 2); + return; + }//if + tcConnectptr.i = tcIndex; + ptrAss(tcConnectptr, regTcConnectionrec); + switch (tcConnectptr.p->connectState) { + case TcConnectionrec::LOG_CONNECTED: + jam(); + completedLab(signal); + return; + break; + case TcConnectionrec::COPY_CONNECTED: + jam(); + copyCompletedLab(signal); + return; + break; + default: + jam(); + ndbrequire(false); + break; + }//switch + return; +}//Dblqh::execLQHKEYCONF() + +/* ------------------------------------------------------------------------- */ +/* ------- COMMIT PHASE ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dblqh::commitReqLab(Signal* signal, Uint32 gci) +{ + TcConnectionrec * const regTcPtr = tcConnectptr.p; + TcConnectionrec::LogWriteState logWriteState = regTcPtr->logWriteState; + TcConnectionrec::TransactionState transState = regTcPtr->transactionState; + regTcPtr->gci = gci; + if (transState == TcConnectionrec::PREPARED) { + if (logWriteState == TcConnectionrec::WRITTEN) { + jam(); + regTcPtr->transactionState = TcConnectionrec::PREPARED_RECEIVED_COMMIT; + TcConnectionrecPtr saveTcPtr = tcConnectptr; + Uint32 blockNo = refToBlock(regTcPtr->tcTupBlockref); + signal->theData[0] = regTcPtr->tupConnectrec; + signal->theData[1] = gci; + EXECUTE_DIRECT(blockNo, GSN_TUP_WRITELOG_REQ, signal, 2); + jamEntry(); + if (regTcPtr->transactionState == TcConnectionrec::LOG_COMMIT_QUEUED) { + jam(); + return; + }//if + ndbrequire(regTcPtr->transactionState == TcConnectionrec::LOG_COMMIT_WRITTEN); + tcConnectptr = saveTcPtr; + } else if (logWriteState == TcConnectionrec::NOT_STARTED) { + jam(); + } else if (logWriteState == TcConnectionrec::NOT_WRITTEN) { + jam(); +/*---------------------------------------------------------------------------*/ +/* IT IS A READ OPERATION OR OTHER OPERATION THAT DO NOT USE THE LOG. */ +/*---------------------------------------------------------------------------*/ +/*---------------------------------------------------------------------------*/ +/* THE LOG HAS NOT BEEN WRITTEN SINCE THE LOG FLAG WAS FALSE. THIS CAN OCCUR */ +/* WHEN WE ARE STARTING A NEW FRAGMENT. */ +/*---------------------------------------------------------------------------*/ + regTcPtr->logWriteState = TcConnectionrec::NOT_STARTED; + } else { + ndbrequire(logWriteState == TcConnectionrec::NOT_WRITTEN_WAIT); + jam(); +/*---------------------------------------------------------------------------*/ +/* THE STATE WAS SET TO NOT_WRITTEN BY THE OPERATION BUT LATER A SCAN OF ALL */ +/* OPERATION RECORD CHANGED IT INTO NOT_WRITTEN_WAIT. THIS INDICATES THAT WE */ +/* ARE WAITING FOR THIS OPERATION TO COMMIT OR ABORT SO THAT WE CAN FIND THE */ +/* STARTING GLOBAL CHECKPOINT OF THIS NEW FRAGMENT. */ +/*---------------------------------------------------------------------------*/ + checkScanTcCompleted(signal); + }//if + } else if (transState == TcConnectionrec::LOG_COMMIT_QUEUED_WAIT_SIGNAL) { + jam(); + regTcPtr->transactionState = TcConnectionrec::LOG_COMMIT_QUEUED; + return; + } else if (transState == TcConnectionrec::LOG_COMMIT_WRITTEN_WAIT_SIGNAL) { + jam(); + } else { + warningReport(signal, 0); + return; + }//if + if (regTcPtr->seqNoReplica != 0) { + jam(); + commitReplyLab(signal); + return; + }//if + localCommitLab(signal); + return; +}//Dblqh::commitReqLab() + +void Dblqh::execLQH_WRITELOG_REQ(Signal* signal) +{ + jamEntry(); + tcConnectptr.i = signal->theData[0]; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + TcConnectionrec * const regTcPtr = tcConnectptr.p; + Uint32 gci = signal->theData[1]; + Uint32 newestGci = cnewestGci; + TcConnectionrec::LogWriteState logWriteState = regTcPtr->logWriteState; + TcConnectionrec::TransactionState transState = regTcPtr->transactionState; + regTcPtr->gci = gci; + if (gci > newestGci) { + jam(); +/* ------------------------------------------------------------------------- */ +/* KEEP TRACK OF NEWEST GLOBAL CHECKPOINT THAT LQH HAS HEARD OF. */ +/* ------------------------------------------------------------------------- */ + cnewestGci = gci; + }//if + if (logWriteState == TcConnectionrec::WRITTEN) { +/*---------------------------------------------------------------------------*/ +/* I NEED TO INSERT A COMMIT LOG RECORD SINCE WE ARE WRITING LOG IN THIS */ +/* TRANSACTION. */ +/*---------------------------------------------------------------------------*/ + jam(); + LogPartRecordPtr regLogPartPtr; + Uint32 noOfLogPages = cnoOfLogPages; + jam(); + regLogPartPtr.i = regTcPtr->hashValue & 3; + ptrCheckGuard(regLogPartPtr, clogPartFileSize, logPartRecord); + if ((regLogPartPtr.p->logPartState == LogPartRecord::ACTIVE) || + (noOfLogPages == 0)) { + jam(); +/*---------------------------------------------------------------------------*/ +/* THIS LOG PART WAS CURRENTLY ACTIVE WRITING ANOTHER LOG RECORD. WE MUST */ +/* WAIT UNTIL THIS PART HAS COMPLETED ITS OPERATION. */ +/*---------------------------------------------------------------------------*/ +// We must delay the write of commit info to the log to safe-guard against +// a crash due to lack of log pages. We temporary stop all log writes to this +// log part to ensure that we don't get a buffer explosion in the delayed +// signal buffer instead. +/*---------------------------------------------------------------------------*/ + linkWaitLog(signal, regLogPartPtr); + if (transState == TcConnectionrec::PREPARED) { + jam(); + regTcPtr->transactionState = TcConnectionrec::LOG_COMMIT_QUEUED_WAIT_SIGNAL; + } else { + jam(); + ndbrequire(transState == TcConnectionrec::PREPARED_RECEIVED_COMMIT); + regTcPtr->transactionState = TcConnectionrec::LOG_COMMIT_QUEUED; + }//if + if (regLogPartPtr.p->logPartState == LogPartRecord::IDLE) { + jam(); + regLogPartPtr.p->logPartState = LogPartRecord::ACTIVE; + }//if + return; + }//if + writeCommitLog(signal, regLogPartPtr); + if (transState == TcConnectionrec::PREPARED) { + jam(); + regTcPtr->transactionState = TcConnectionrec::LOG_COMMIT_WRITTEN_WAIT_SIGNAL; + } else { + jam(); + ndbrequire(transState == TcConnectionrec::PREPARED_RECEIVED_COMMIT); + regTcPtr->transactionState = TcConnectionrec::LOG_COMMIT_WRITTEN; + }//if + }//if +}//Dblqh::execLQH_WRITELOG_REQ() + +void Dblqh::localCommitLab(Signal* signal) +{ + FragrecordPtr regFragptr; + regFragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(regFragptr, cfragrecFileSize, fragrecord); + Fragrecord::FragStatus status = regFragptr.p->fragStatus; + fragptr = regFragptr; + switch (status) { + case Fragrecord::FSACTIVE: + case Fragrecord::CRASH_RECOVERING: + case Fragrecord::ACTIVE_CREATION: + jam(); + commitContinueAfterBlockedLab(signal); + return; + break; + case Fragrecord::BLOCKED: + jam(); + linkFragQueue(signal); + tcConnectptr.p->transactionState = TcConnectionrec::COMMIT_STOPPED; + break; + case Fragrecord::FREE: + jam(); + case Fragrecord::DEFINED: + jam(); + case Fragrecord::REMOVING: + jam(); + default: + ndbrequire(false); + break; + }//switch +}//Dblqh::localCommitLab() + +void Dblqh::commitContinueAfterBlockedLab(Signal* signal) +{ +/* ------------------------------------------------------------------------- */ +/*INPUT: TC_CONNECTPTR ACTIVE OPERATION RECORD */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/*CONTINUE HERE AFTER BEING BLOCKED FOR A WHILE DURING LOCAL CHECKPOINT. */ +/*The operation is already removed from the active list since there is no */ +/*chance for any real-time breaks before we need to release it. */ +/* ------------------------------------------------------------------------- */ +/*ALSO AFTER NORMAL PROCEDURE WE CONTINUE */ +/*WE MUST COMMIT TUP BEFORE ACC TO ENSURE THAT NO ONE RACES IN AND SEES A */ +/*DIRTY STATE IN TUP. */ +/* ------------------------------------------------------------------------- */ + TcConnectionrec * const regTcPtr = tcConnectptr.p; + Fragrecord * const regFragptr = fragptr.p; + Uint32 operation = regTcPtr->operation; + if (regTcPtr->activeCreat == ZFALSE) { + if ((cCommitBlocked == true) && + (regFragptr->fragActiveStatus == ZTRUE)) { + jam(); +/* ------------------------------------------------------------------------- */ +// TUP and/or ACC have problems in writing the undo log to disk fast enough. +// We must avoid the commit at this time and try later instead. The fragment +// is also active with a local checkpoint and this commit can generate UNDO +// log records that overflow the UNDO log buffer. +/* ------------------------------------------------------------------------- */ +/*---------------------------------------------------------------------------*/ +// We must delay the write of commit info to the log to safe-guard against +// a crash due to lack of log pages. We temporary stop all log writes to this +// log part to ensure that we don't get a buffer explosion in the delayed +// signal buffer instead. +/*---------------------------------------------------------------------------*/ + logPartPtr.i = regTcPtr->hashValue & 3; + ptrCheckGuard(logPartPtr, clogPartFileSize, logPartRecord); + linkWaitLog(signal, logPartPtr); + regTcPtr->transactionState = TcConnectionrec::COMMIT_QUEUED; + if (logPartPtr.p->logPartState == LogPartRecord::IDLE) { + jam(); + logPartPtr.p->logPartState = LogPartRecord::ACTIVE; + }//if + return; + }//if + if (operation != ZREAD) { + TupCommitReq * const tupCommitReq = + (TupCommitReq *)signal->getDataPtrSend(); + Uint32 sig0 = regTcPtr->tupConnectrec; + Uint32 tup = refToBlock(regTcPtr->tcTupBlockref); + jam(); + tupCommitReq->opPtr = sig0; + tupCommitReq->gci = regTcPtr->gci; + tupCommitReq->hashValue = regTcPtr->hashValue; + EXECUTE_DIRECT(tup, GSN_TUP_COMMITREQ, signal, + TupCommitReq::SignalLength); + }//if + Uint32 acc = refToBlock(regTcPtr->tcAccBlockref); + signal->theData[0] = regTcPtr->accConnectrec; + EXECUTE_DIRECT(acc, GSN_ACC_COMMITREQ, signal, 1); + Uint32 simpleRead = regTcPtr->simpleRead; + jamEntry(); + if (simpleRead == ZSIMPLE_READ) { + jam(); +/* ------------------------------------------------------------------------- */ +/*THE OPERATION WAS A SIMPLE READ THUS THE COMMIT PHASE IS ONLY NEEDED TO */ +/*RELEASE THE LOCKS. AT THIS POINT IN THE CODE THE LOCKS ARE RELEASED AND WE */ +/*ARE IN A POSITION TO SEND LQHKEYCONF TO TC. WE WILL ALSO RELEASE ALL */ +/*RESOURCES BELONGING TO THIS OPERATION SINCE NO MORE WORK WILL BE */ +/*PERFORMED. */ +/* ------------------------------------------------------------------------- */ + cleanUp(signal); + return; + }//if + }//if + Uint32 dirtyOp = regTcPtr->dirtyOp; + Uint32 seqNoReplica = regTcPtr->seqNoReplica; + if (regTcPtr->gci > regFragptr->newestGci) { + jam(); +/* ------------------------------------------------------------------------- */ +/*IT IS THE FIRST TIME THIS GLOBAL CHECKPOINT IS INVOLVED IN UPDATING THIS */ +/*FRAGMENT. UPDATE THE VARIABLE THAT KEEPS TRACK OF NEWEST GCI IN FRAGMENT */ +/* ------------------------------------------------------------------------- */ + regFragptr->newestGci = regTcPtr->gci; + }//if + if (dirtyOp != ZTRUE) { + if (seqNoReplica != 0) { + jam(); + completeTransNotLastLab(signal); + return; + }//if + commitReplyLab(signal); + return; + } else { +/* ------------------------------------------------------------------------- */ +/*WE MUST HANDLE DIRTY WRITES IN A SPECIAL WAY. THESE OPERATIONS WILL NOT */ +/*SEND ANY COMMIT OR COMPLETE MESSAGES TO OTHER NODES. THEY WILL MERELY SEND */ +/*THOSE SIGNALS INTERNALLY. */ +/* ------------------------------------------------------------------------- */ + if (regTcPtr->abortState == TcConnectionrec::ABORT_IDLE) { + jam(); + packLqhkeyreqLab(signal); + } else { + ndbrequire(regTcPtr->abortState != TcConnectionrec::NEW_FROM_TC); + jam(); + sendLqhTransconf(signal, LqhTransConf::Committed); + cleanUp(signal); + }//if + }//if +}//Dblqh::commitContinueAfterBlockedLab() + +void Dblqh::commitReplyLab(Signal* signal) +{ +/* -------------------------------------------------------------- */ +/* BACKUP AND STAND-BY REPLICAS ONLY UPDATE THE TRANSACTION STATE */ +/* -------------------------------------------------------------- */ + TcConnectionrec * const regTcPtr = tcConnectptr.p; + TcConnectionrec::AbortState abortState = regTcPtr->abortState; + regTcPtr->transactionState = TcConnectionrec::COMMITTED; + if (abortState == TcConnectionrec::ABORT_IDLE) { + Uint32 clientBlockref = regTcPtr->clientBlockref; + if (regTcPtr->seqNoReplica == 0) { + jam(); + sendCommittedTc(signal, clientBlockref); + return; + } else { + jam(); + sendCommitLqh(signal, clientBlockref); + return; + }//if + } else if (regTcPtr->abortState == TcConnectionrec::REQ_FROM_TC) { + jam(); + signal->theData[0] = regTcPtr->reqRef; + signal->theData[1] = cownNodeid; + signal->theData[2] = regTcPtr->transid[0]; + signal->theData[3] = regTcPtr->transid[1]; + sendSignal(tcConnectptr.p->reqBlockref, GSN_COMMITCONF, signal, 4, JBB); + } else { + ndbrequire(regTcPtr->abortState == TcConnectionrec::NEW_FROM_TC); + jam(); + sendLqhTransconf(signal, LqhTransConf::Committed); + }//if + return; +}//Dblqh::commitReplyLab() + +/* ------------------------------------------------------------------------- */ +/* ------- COMPLETE PHASE ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dblqh::completeTransNotLastLab(Signal* signal) +{ + TcConnectionrec * const regTcPtr = tcConnectptr.p; + if (regTcPtr->abortState == TcConnectionrec::ABORT_IDLE) { + Uint32 clientBlockref = regTcPtr->clientBlockref; + jam(); + sendCompleteLqh(signal, clientBlockref); + cleanUp(signal); + return; + } else { + jam(); + completeUnusualLab(signal); + return; + }//if +}//Dblqh::completeTransNotLastLab() + +void Dblqh::completeTransLastLab(Signal* signal) +{ + TcConnectionrec * const regTcPtr = tcConnectptr.p; + if (regTcPtr->abortState == TcConnectionrec::ABORT_IDLE) { + Uint32 clientBlockref = regTcPtr->clientBlockref; + jam(); +/* ------------------------------------------------------------------------- */ +/*DIRTY WRITES WHICH ARE LAST IN THE CHAIN OF REPLICAS WILL SEND COMPLETED */ +/*INSTEAD OF SENDING PREPARED TO THE TC (OR OTHER INITIATOR OF OPERATION). */ +/* ------------------------------------------------------------------------- */ + sendCompletedTc(signal, clientBlockref); + cleanUp(signal); + return; + } else { + jam(); + completeUnusualLab(signal); + return; + }//if +}//Dblqh::completeTransLastLab() + +void Dblqh::completeUnusualLab(Signal* signal) +{ + TcConnectionrec * const regTcPtr = tcConnectptr.p; + if (regTcPtr->abortState == TcConnectionrec::ABORT_FROM_TC) { + jam(); + sendAborted(signal); + } else if (regTcPtr->abortState == TcConnectionrec::NEW_FROM_TC) { + jam(); + sendLqhTransconf(signal, LqhTransConf::Committed); + } else { + ndbrequire(regTcPtr->abortState == TcConnectionrec::REQ_FROM_TC); + jam(); + signal->theData[0] = regTcPtr->reqRef; + signal->theData[1] = cownNodeid; + signal->theData[2] = regTcPtr->transid[0]; + signal->theData[3] = regTcPtr->transid[1]; + sendSignal(regTcPtr->reqBlockref, + GSN_COMPLETECONF, signal, 4, JBB); + }//if + cleanUp(signal); + return; +}//Dblqh::completeUnusualLab() + +/* ========================================================================= */ +/* ======= RELEASE TC CONNECT RECORD ======= */ +/* */ +/* RELEASE A TC CONNECT RECORD TO THE FREELIST. */ +/* ========================================================================= */ +void Dblqh::releaseTcrec(Signal* signal, TcConnectionrecPtr locTcConnectptr) +{ + jam(); + locTcConnectptr.p->tcTimer = 0; + locTcConnectptr.p->transactionState = TcConnectionrec::TC_NOT_CONNECTED; + locTcConnectptr.p->nextTcConnectrec = cfirstfreeTcConrec; + cfirstfreeTcConrec = locTcConnectptr.i; + + TablerecPtr tabPtr; + tabPtr.i = locTcConnectptr.p->tableref; + if(tabPtr.i == RNIL) + return; + + ptrCheckGuard(tabPtr, ctabrecFileSize, tablerec); + + /** + * Normal case + */ + ndbrequire(tabPtr.p->usageCount > 0); + tabPtr.p->usageCount--; +}//Dblqh::releaseTcrec() + +void Dblqh::releaseTcrecLog(Signal* signal, TcConnectionrecPtr locTcConnectptr) +{ + jam(); + locTcConnectptr.p->tcTimer = 0; + locTcConnectptr.p->transactionState = TcConnectionrec::TC_NOT_CONNECTED; + locTcConnectptr.p->nextTcConnectrec = cfirstfreeTcConrec; + cfirstfreeTcConrec = locTcConnectptr.i; + + TablerecPtr tabPtr; + tabPtr.i = locTcConnectptr.p->tableref; + if(tabPtr.i == RNIL) + return; + +}//Dblqh::releaseTcrecLog() + +/* ------------------------------------------------------------------------- */ +/* ------- ABORT PHASE ------- */ +/* */ +/*THIS PART IS USED AT ERRORS THAT CAUSE ABORT OF TRANSACTION. */ +/* ------------------------------------------------------------------------- */ +/* ***************************************************>> */ +/* ABORT: Abort transaction in connection. Sender TC. */ +/* This is the normal protocol (See COMMIT) */ +/* ***************************************************>> */ +void Dblqh::execABORT(Signal* signal) +{ + jamEntry(); + Uint32 tcOprec = signal->theData[0]; + BlockReference tcBlockref = signal->theData[1]; + Uint32 transid1 = signal->theData[2]; + Uint32 transid2 = signal->theData[3]; + if (ERROR_INSERTED(5003)) { + systemErrorLab(signal); + } + if (ERROR_INSERTED(5015)) { + CLEAR_ERROR_INSERT_VALUE; + sendSignalWithDelay(cownref, GSN_ABORT, signal, 2000, 4); + return; + }//if + if (findTransaction(transid1, + transid2, + tcOprec) != ZOK) { + jam(); +/* ------------------------------------------------------------------------- */ +// SEND ABORTED EVEN IF NOT FOUND. +//THE TRANSACTION MIGHT NEVER HAVE ARRIVED HERE. +/* ------------------------------------------------------------------------- */ + signal->theData[0] = tcOprec; + signal->theData[1] = transid1; + signal->theData[2] = transid2; + signal->theData[3] = cownNodeid; + signal->theData[4] = ZTRUE; + sendSignal(tcBlockref, GSN_ABORTED, signal, 5, JBB); + warningReport(signal, 8); + return; + }//if +/* ------------------------------------------------------------------------- */ +/*A GUIDING DESIGN PRINCIPLE IN HANDLING THESE ERROR SITUATIONS HAVE BEEN */ +/*KEEP IT SIMPLE. THUS WE RATHER INSERT A WAIT AND SET THE ABORT_STATE TO */ +/*ACTIVE RATHER THAN WRITE NEW CODE TO HANDLE EVERY SPECIAL SITUATION. */ +/* ------------------------------------------------------------------------- */ + TcConnectionrec * const regTcPtr = tcConnectptr.p; + if (regTcPtr->nextReplica != ZNIL) { +/* ------------------------------------------------------------------------- */ +// We will immediately send the ABORT message also to the next LQH node in line. +/* ------------------------------------------------------------------------- */ + BlockReference TLqhRef = calcLqhBlockRef(regTcPtr->nextReplica); + signal->theData[0] = regTcPtr->tcOprec; + signal->theData[1] = regTcPtr->tcBlockref; + signal->theData[2] = regTcPtr->transid[0]; + signal->theData[3] = regTcPtr->transid[1]; + sendSignal(TLqhRef, GSN_ABORT, signal, 4, JBB); + }//if + regTcPtr->abortState = TcConnectionrec::ABORT_FROM_TC; + regTcPtr->activeCreat = ZFALSE; + abortStateHandlerLab(signal); + return; +}//Dblqh::execABORT() + +/* ************************************************************************>> + * ABORTREQ: Same as ABORT but used in case one node isn't working ok. + * (See COMMITREQ) + * ************************************************************************>> */ +void Dblqh::execABORTREQ(Signal* signal) +{ + jamEntry(); + Uint32 reqPtr = signal->theData[0]; + BlockReference reqBlockref = signal->theData[1]; + Uint32 transid1 = signal->theData[2]; + Uint32 transid2 = signal->theData[3]; + Uint32 tcOprec = signal->theData[5]; + if (ERROR_INSERTED(5006)) { + systemErrorLab(signal); + } + if (ERROR_INSERTED(5016)) { + CLEAR_ERROR_INSERT_VALUE; + sendSignalWithDelay(cownref, GSN_ABORTREQ, signal, 2000, 6); + return; + }//if + if (findTransaction(transid1, + transid2, + tcOprec) != ZOK) { + signal->theData[0] = reqPtr; + signal->theData[2] = cownNodeid; + signal->theData[3] = transid1; + signal->theData[4] = transid2; + sendSignal(reqBlockref, GSN_ABORTCONF, signal, 5, JBB); + warningReport(signal, 9); + return; + }//if + TcConnectionrec * const regTcPtr = tcConnectptr.p; + if (regTcPtr->transactionState != TcConnectionrec::PREPARED) { + warningReport(signal, 10); + return; + }//if + regTcPtr->reqBlockref = reqBlockref; + regTcPtr->reqRef = reqPtr; + regTcPtr->abortState = TcConnectionrec::REQ_FROM_TC; + regTcPtr->activeCreat = ZFALSE; + abortCommonLab(signal); + return; +}//Dblqh::execABORTREQ() + +/* ************>> */ +/* ACC_TO_REF > */ +/* ************>> */ +void Dblqh::execACC_TO_REF(Signal* signal) +{ + jamEntry(); + terrorCode = signal->theData[1]; + releaseActiveFrag(signal); + abortErrorLab(signal); + return; +}//Dblqh::execACC_TO_REF() + +/* ************> */ +/* ACCKEYREF > */ +/* ************> */ +void Dblqh::execACCKEYREF(Signal* signal) +{ + jamEntry(); + tcConnectptr.i = signal->theData[0]; + terrorCode = signal->theData[1]; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + TcConnectionrec * const tcPtr = tcConnectptr.p; + switch (tcPtr->transactionState) { + case TcConnectionrec::WAIT_ACC: + jam(); + releaseActiveFrag(signal); + break; + case TcConnectionrec::WAIT_ACC_ABORT: + case TcConnectionrec::ABORT_STOPPED: + case TcConnectionrec::ABORT_QUEUED: + jam(); +/* ------------------------------------------------------------------------- */ +/*IGNORE SINCE ABORT OF THIS OPERATION IS ONGOING ALREADY. */ +/* ------------------------------------------------------------------------- */ + return; + break; + default: + ndbrequire(false); + break; + }//switch + const Uint32 errCode = terrorCode; + tcPtr->errorCode = errCode; +/* ------------------------------------------------------------------------- */ +/*WHEN AN ABORT FROM TC ARRIVES IT COULD ACTUALLY BE A CORRECT BEHAVIOUR */ +/*SINCE THE TUPLE MIGHT NOT HAVE ARRIVED YET OR ALREADY HAVE BEEN INSERTED. */ +/* ------------------------------------------------------------------------- */ + if (tcPtr->activeCreat == ZTRUE) { + jam(); +/* ------------------------------------------------------------------------- */ +/*THIS IS A NORMAL EVENT DURING CREATION OF A FRAGMENT. PERFORM ABORT IN */ +/*TUP AND ACC AND THEN CONTINUE WITH NORMAL COMMIT PROCESSING. IF THE ERROR */ +/*HAPPENS TO BE A SERIOUS ERROR THEN PERFORM ABORT PROCESSING AS NORMAL. */ +/* ------------------------------------------------------------------------- */ + switch (tcPtr->operation) { + case ZUPDATE: + case ZDELETE: + jam(); + if (errCode != ZNO_TUPLE_FOUND) { + jam(); +/* ------------------------------------------------------------------------- */ +/*A NORMAL ERROR WILL BE TREATED AS A NORMAL ABORT AND WILL ABORT THE */ +/*TRANSACTION. NO SPECIAL HANDLING IS NEEDED. */ +/* ------------------------------------------------------------------------- */ + tcPtr->activeCreat = ZFALSE; + }//if + break; + case ZINSERT: + jam(); + if (errCode != ZTUPLE_ALREADY_EXIST) { + jam(); +/* ------------------------------------------------------------------------- */ +/*A NORMAL ERROR WILL BE TREATED AS A NORMAL ABORT AND WILL ABORT THE */ +/*TRANSACTION. NO SPECIAL HANDLING IS NEEDED. */ +/* ------------------------------------------------------------------------- */ + tcPtr->activeCreat = ZFALSE; + }//if + break; + default: + jam(); +/* ------------------------------------------------------------------------- */ +/*A NORMAL ERROR WILL BE TREATED AS A NORMAL ABORT AND WILL ABORT THE */ +/*TRANSACTION. NO SPECIAL HANDLING IS NEEDED. */ +/* ------------------------------------------------------------------------- */ + tcPtr->activeCreat = ZFALSE; + break; + }//switch + } else { + /** + * Only primary replica can get ZTUPLE_ALREADY_EXIST || ZNO_TUPLE_FOUND + * + * Unless it's a simple or dirty read + */ + ndbrequire + (tcPtr->seqNoReplica == 0 || + (errCode != ZTUPLE_ALREADY_EXIST && errCode != ZNO_TUPLE_FOUND) || + (tcPtr->operation == ZREAD && (tcPtr->dirtyOp || tcPtr->opSimple))); + } + tcPtr->abortState = TcConnectionrec::ABORT_FROM_LQH; + abortCommonLab(signal); + return; +}//Dblqh::execACCKEYREF() + +void Dblqh::localAbortStateHandlerLab(Signal* signal) +{ + TcConnectionrec * const regTcPtr = tcConnectptr.p; + if (regTcPtr->abortState != TcConnectionrec::ABORT_IDLE) { + jam(); + return; + }//if + regTcPtr->activeCreat = ZFALSE; + regTcPtr->abortState = TcConnectionrec::ABORT_FROM_LQH; + regTcPtr->errorCode = terrorCode; + abortStateHandlerLab(signal); + return; +}//Dblqh::localAbortStateHandlerLab() + +void Dblqh::abortStateHandlerLab(Signal* signal) +{ + TcConnectionrec * const regTcPtr = tcConnectptr.p; + switch (regTcPtr->transactionState) { + case TcConnectionrec::PREPARED: + jam(); +/* ------------------------------------------------------------------------- */ +/*THE OPERATION IS ALREADY PREPARED AND SENT TO THE NEXT LQH OR BACK TO TC. */ +/*WE CAN SIMPLY CONTINUE WITH THE ABORT PROCESS. */ +/*IF IT WAS A CHECK FOR TRANSACTION STATUS THEN WE REPORT THE STATUS TO THE */ +/*NEW TC AND CONTINUE WITH THE NEXT OPERATION IN LQH. */ +/* ------------------------------------------------------------------------- */ + if (regTcPtr->abortState == TcConnectionrec::NEW_FROM_TC) { + jam(); + sendLqhTransconf(signal, LqhTransConf::Prepared); + return; + }//if + break; + case TcConnectionrec::LOG_COMMIT_WRITTEN_WAIT_SIGNAL: + case TcConnectionrec::LOG_COMMIT_QUEUED_WAIT_SIGNAL: + jam(); +/* ------------------------------------------------------------------------- */ +// We can only reach these states for multi-updates on a record in a transaction. +// We know that at least one of those has received the COMMIT signal, thus we +// declare us only prepared since we then receive the expected COMMIT signal. +/* ------------------------------------------------------------------------- */ + ndbrequire(regTcPtr->abortState == TcConnectionrec::NEW_FROM_TC); + sendLqhTransconf(signal, LqhTransConf::Prepared); + break; + case TcConnectionrec::WAIT_TUPKEYINFO: + case TcConnectionrec::WAIT_ATTR: + jam(); +/* ------------------------------------------------------------------------- */ +/* WE ARE CURRENTLY WAITING FOR MORE INFORMATION. WE CAN START THE ABORT */ +/* PROCESS IMMEDIATELY. THE KEYINFO AND ATTRINFO SIGNALS WILL BE DROPPED */ +/* SINCE THE ABORT STATE WILL BE SET. */ +/* ------------------------------------------------------------------------- */ + break; + case TcConnectionrec::WAIT_TUP: + jam(); +/* ------------------------------------------------------------------------- */ +// TUP is currently active. We have to wait for the TUPKEYREF or TUPKEYCONF +// to arrive since we might otherwise jeopardise the local checkpoint +// consistency in overload situations. +/* ------------------------------------------------------------------------- */ + regTcPtr->transactionState = TcConnectionrec::WAIT_TUP_TO_ABORT; + return; + case TcConnectionrec::WAIT_ACC: + jam(); + if (regTcPtr->listState == TcConnectionrec::ACC_BLOCK_LIST) { + jam(); +/* ------------------------------------------------------------------------- */ +// If the operation is in the ACC Blocked list the operation is not allowed +// to start yet. We release it from the ACC Blocked list and will go through +// the gate in abortCommonLab(..) where it will be blocked. +/* ------------------------------------------------------------------------- */ + fragptr.i = regTcPtr->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + releaseAccList(signal); + } else { + jam(); +/* ------------------------------------------------------------------------- */ +// We start the abort immediately since the operation is still in the active +// list and the fragment cannot have been frozen yet. By sending LCP_HOLDOPCONF +// as direct signals we avoid the problem that we might find the operation +// in an unexpected list in ACC. +// We cannot accept being blocked before aborting ACC here since that would +// lead to seriously complex issues. +/* ------------------------------------------------------------------------- */ + abortContinueAfterBlockedLab(signal, false); + return; + }//if + break; + case TcConnectionrec::LOG_QUEUED: + jam(); +/* ------------------------------------------------------------------------- */ +/*CURRENTLY QUEUED FOR LOGGING. WAIT UNTIL THE LOG RECORD HAVE BEEN INSERTED */ +/*AND THEN CONTINUE THE ABORT PROCESS. */ +//Could also be waiting for an overloaded log disk. In this case it is easy +//to abort when CONTINUEB arrives. +/* ------------------------------------------------------------------------- */ + return; + break; + case TcConnectionrec::STOPPED: + jam(); +/* ------------------------------------------------------------------------- */ +/*WE ARE CURRENTLY QUEUED FOR ACCESS TO THE FRAGMENT BY A LOCAL CHECKPOINT. */ +/* ------------------------------------------------------------------------- */ + releaseWaitQueue(signal); + break; + case TcConnectionrec::WAIT_AI_AFTER_ABORT: + jam(); +/* ------------------------------------------------------------------------- */ +/* ABORT OF ACC AND TUP ALREADY COMPLETED. THIS STATE IS ONLY USED WHEN */ +/* CREATING A NEW FRAGMENT. */ +/* ------------------------------------------------------------------------- */ + continueAbortLab(signal); + return; + break; + case TcConnectionrec::WAIT_TUP_TO_ABORT: + case TcConnectionrec::ABORT_STOPPED: + case TcConnectionrec::LOG_ABORT_QUEUED: + case TcConnectionrec::WAIT_ACC_ABORT: + case TcConnectionrec::ABORT_QUEUED: + jam(); +/* ------------------------------------------------------------------------- */ +/*ABORT IS ALREADY ONGOING DUE TO SOME ERROR. WE HAVE ALREADY SET THE STATE */ +/*OF THE ABORT SO THAT WE KNOW THAT TC EXPECTS A REPORT. WE CAN THUS SIMPLY */ +/*EXIT. */ +/* ------------------------------------------------------------------------- */ + return; + break; + case TcConnectionrec::COMMIT_STOPPED: + case TcConnectionrec::LOG_COMMIT_QUEUED: + case TcConnectionrec::COMMIT_QUEUED: + jam(); +/* ------------------------------------------------------------------------- */ +/*THIS IS ONLY AN ALLOWED STATE IF A DIRTY WRITE OR SIMPLE READ IS PERFORMED.*/ +/*IF WE ARE MERELY CHECKING THE TRANSACTION STATE IT IS ALSO AN ALLOWED STATE*/ +/* ------------------------------------------------------------------------- */ + if (regTcPtr->dirtyOp == ZTRUE) { + jam(); +/* ------------------------------------------------------------------------- */ +/*COMPLETE THE DIRTY WRITE AND THEN REPORT COMPLETED BACK TO TC. SINCE IT IS */ +/*A DIRTY WRITE IT IS ALLOWED TO COMMIT EVEN IF THE TRANSACTION ABORTS. */ +/* ------------------------------------------------------------------------- */ + return; + }//if + if (regTcPtr->simpleRead == ZSIMPLE_READ) { + jam(); +/* ------------------------------------------------------------------------- */ +/*A SIMPLE READ IS CURRENTLY RELEASING THE LOCKS OR WAITING FOR ACCESS TO */ +/*ACC TO CLEAR THE LOCKS. COMPLETE THIS PROCESS AND THEN RETURN AS NORMAL. */ +/*NO DATA HAS CHANGED DUE TO THIS SIMPLE READ ANYWAY. */ +/* ------------------------------------------------------------------------- */ + return; + }//if + ndbrequire(regTcPtr->abortState == TcConnectionrec::NEW_FROM_TC); + jam(); +/* ------------------------------------------------------------------------- */ +/*WE ARE ONLY CHECKING THE STATUS OF THE TRANSACTION. IT IS COMMITTING. */ +/*COMPLETE THE COMMIT LOCALLY AND THEN SEND REPORT OF COMMITTED TO THE NEW TC*/ +/* ------------------------------------------------------------------------- */ + return; + break; + case TcConnectionrec::COMMITTED: + jam(); + ndbrequire(regTcPtr->abortState == TcConnectionrec::NEW_FROM_TC); +/* ------------------------------------------------------------------------- */ +/*WE ARE CHECKING TRANSACTION STATUS. REPORT COMMITTED AND CONTINUE WITH THE */ +/*NEXT OPERATION. */ +/* ------------------------------------------------------------------------- */ + sendLqhTransconf(signal, LqhTransConf::Committed); + return; + break; + default: + ndbrequire(false); +/* ------------------------------------------------------------------------- */ +/*THE STATE WAS NOT AN ALLOWED STATE ON A NORMAL OPERATION. SCANS AND COPY */ +/*FRAGMENT OPERATIONS SHOULD HAVE EXECUTED IN ANOTHER PATH. */ +/* ------------------------------------------------------------------------- */ + break; + }//switch + abortCommonLab(signal); + return; +}//Dblqh::abortStateHandlerLab() + +void Dblqh::abortErrorLab(Signal* signal) +{ + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + TcConnectionrec * const regTcPtr = tcConnectptr.p; + if (regTcPtr->abortState == TcConnectionrec::ABORT_IDLE) { + jam(); + regTcPtr->abortState = TcConnectionrec::ABORT_FROM_LQH; + regTcPtr->errorCode = terrorCode; + }//if + /* ----------------------------------------------------------------------- + * ACTIVE CREATION IS RESET FOR ALL ERRORS WHICH SHOULD BE HANDLED + * WITH NORMAL ABORT HANDLING. + * ----------------------------------------------------------------------- */ + regTcPtr->activeCreat = ZFALSE; + abortCommonLab(signal); + return; +}//Dblqh::abortErrorLab() + +void Dblqh::abortCommonLab(Signal* signal) +{ + TcConnectionrec * const regTcPtr = tcConnectptr.p; + const Uint32 commitAckMarker = regTcPtr->commitAckMarker; + if(regTcPtr->activeCreat != ZTRUE && commitAckMarker != RNIL){ + /** + * There is no NR ongoing and we have a marker + */ + jam(); + + m_commitAckMarkerHash.release(commitAckMarker); + regTcPtr->commitAckMarker = RNIL; + } + + fragptr.i = regTcPtr->fragmentptr; + if (fragptr.i != RNIL) { + jam(); + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + switch (fragptr.p->fragStatus) { + case Fragrecord::FSACTIVE: + case Fragrecord::CRASH_RECOVERING: + case Fragrecord::ACTIVE_CREATION: + jam(); + linkActiveFrag(signal); + abortContinueAfterBlockedLab(signal, true); + return; + break; + case Fragrecord::BLOCKED: + jam(); + linkFragQueue(signal); + regTcPtr->transactionState = TcConnectionrec::ABORT_STOPPED; + return; + break; + case Fragrecord::FREE: + jam(); + case Fragrecord::DEFINED: + jam(); + case Fragrecord::REMOVING: + jam(); + default: + ndbrequire(false); + break; + }//switch + } else { + jam(); + continueAbortLab(signal); + }//if +}//Dblqh::abortCommonLab() + +void Dblqh::abortContinueAfterBlockedLab(Signal* signal, bool canBlock) +{ + /* ------------------------------------------------------------------------ + * INPUT: TC_CONNECTPTR ACTIVE OPERATION RECORD + * ------------------------------------------------------------------------ + * ------------------------------------------------------------------------ + * CAN COME HERE AS RESTART AFTER BEING BLOCKED BY A LOCAL CHECKPOINT. + * ------------------------------------------------------------------------ + * ALSO AS PART OF A NORMAL ABORT WITHOUT BLOCKING. + * WE MUST ABORT TUP BEFORE ACC TO ENSURE THAT NO ONE RACES IN + * AND SEES A STATE IN TUP. + * ------------------------------------------------------------------------ */ + TcConnectionrec * const regTcPtr = tcConnectptr.p; + fragptr.i = regTcPtr->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if ((cCommitBlocked == true) && + (fragptr.p->fragActiveStatus == ZTRUE) && + (canBlock == true) && + (regTcPtr->operation != ZREAD)) { + jam(); +/* ------------------------------------------------------------------------- */ +// TUP and/or ACC have problems in writing the undo log to disk fast enough. +// We must avoid the abort at this time and try later instead. The fragment +// is also active with a local checkpoint and this commit can generate UNDO +// log records that overflow the UNDO log buffer. +// +// In certain situations it is simply too complex to insert a wait state here +// since ACC is active and we cannot release the operation from the active +// list without causing great complexity. +/* ------------------------------------------------------------------------- */ +/*---------------------------------------------------------------------------*/ +// We must delay the write of abort info to the log to safe-guard against +// a crash due to lack of log pages. We temporary stop all log writes to this +// log part to ensure that we don't get a buffer explosion in the delayed +// signal buffer instead. +/*---------------------------------------------------------------------------*/ + releaseActiveFrag(signal); + logPartPtr.i = regTcPtr->hashValue & 3; + ptrCheckGuard(logPartPtr, clogPartFileSize, logPartRecord); + linkWaitLog(signal, logPartPtr); + regTcPtr->transactionState = TcConnectionrec::ABORT_QUEUED; + if (logPartPtr.p->logPartState == LogPartRecord::IDLE) { + jam(); + logPartPtr.p->logPartState = LogPartRecord::ACTIVE; + }//if + return; + }//if + signal->theData[0] = regTcPtr->tupConnectrec; + EXECUTE_DIRECT(DBTUP, GSN_TUP_ABORTREQ, signal, 1); + regTcPtr->transactionState = TcConnectionrec::WAIT_ACC_ABORT; + signal->theData[0] = regTcPtr->accConnectrec; + EXECUTE_DIRECT(DBACC, GSN_ACC_ABORTREQ, signal, 1); + /* ------------------------------------------------------------------------ + * We need to insert a real-time break by sending ACC_ABORTCONF through the + * job buffer to ensure that we catch any ACCKEYCONF or TUPKEYCONF or + * TUPKEYREF that are in the job buffer but not yet processed. Doing + * everything without that would race and create a state error when they + * are executed. + * ----------------------------------------------------------------------- */ + return; +}//Dblqh::abortContinueAfterBlockedLab() + +/* ******************>> */ +/* ACC_ABORTCONF > */ +/* ******************>> */ +void Dblqh::execACC_ABORTCONF(Signal* signal) +{ + jamEntry(); + tcConnectptr.i = signal->theData[0]; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + TcConnectionrec * const regTcPtr = tcConnectptr.p; + ndbrequire(regTcPtr->transactionState == TcConnectionrec::WAIT_ACC_ABORT); + if (regTcPtr->activeCreat == ZTRUE) { + /* ---------------------------------------------------------------------- + * A NORMAL EVENT DURING CREATION OF A FRAGMENT. WE NOW NEED TO CONTINUE + * WITH NORMAL COMMIT PROCESSING. + * ---------------------------------------------------------------------- */ + if (regTcPtr->currTupAiLen == regTcPtr->totReclenAi) { + jam(); + regTcPtr->abortState = TcConnectionrec::ABORT_IDLE; + rwConcludedLab(signal); + return; + } else { + ndbrequire(regTcPtr->currTupAiLen < regTcPtr->totReclenAi); + jam(); + releaseActiveFrag(signal); + regTcPtr->transactionState = TcConnectionrec::WAIT_AI_AFTER_ABORT; + return; + }//if + }//if + releaseActiveFrag(signal); + continueAbortLab(signal); + return; +}//Dblqh::execACC_ABORTCONF() + +void Dblqh::continueAbortLab(Signal* signal) +{ + TcConnectionrec * const regTcPtr = tcConnectptr.p; + /* ------------------------------------------------------------------------ + * AN ERROR OCCURED IN THE ACTIVE CREATION AFTER THE ABORT PHASE. + * WE NEED TO CONTINUE WITH A NORMAL ABORT. + * ------------------------------------------------------------------------ + * ALSO USED FOR NORMAL CLEAN UP AFTER A NORMAL ABORT. + * ------------------------------------------------------------------------ + * ALSO USED WHEN NO FRAGMENT WAS SET UP ON OPERATION. + * ------------------------------------------------------------------------ */ + if (regTcPtr->logWriteState == TcConnectionrec::WRITTEN) { + jam(); + /* ---------------------------------------------------------------------- + * I NEED TO INSERT A ABORT LOG RECORD SINCE WE ARE WRITING LOG IN THIS + * TRANSACTION. + * ---------------------------------------------------------------------- */ + initLogPointers(signal); + if (logPartPtr.p->logPartState == LogPartRecord::ACTIVE) { + jam(); + /* -------------------------------------------------------------------- + * A PREPARE OPERATION IS CURRENTLY WRITING IN THE LOG. + * WE MUST WAIT ON OUR TURN TO WRITE THE LOG. + * IT IS NECESSARY TO WRITE ONE LOG RECORD COMPLETELY + * AT A TIME OTHERWISE WE WILL SCRAMBLE THE LOG. + * -------------------------------------------------------------------- */ + linkWaitLog(signal, logPartPtr); + regTcPtr->transactionState = TcConnectionrec::LOG_ABORT_QUEUED; + return; + }//if + if (cnoOfLogPages == 0) { + jam(); +/*---------------------------------------------------------------------------*/ +// We must delay the write of commit info to the log to safe-guard against +// a crash due to lack of log pages. We temporary stop all log writes to this +// log part to ensure that we don't get a buffer explosion in the delayed +// signal buffer instead. +/*---------------------------------------------------------------------------*/ + linkWaitLog(signal, logPartPtr); + regTcPtr->transactionState = TcConnectionrec::LOG_ABORT_QUEUED; + if (logPartPtr.p->logPartState == LogPartRecord::IDLE) { + jam(); + logPartPtr.p->logPartState = LogPartRecord::ACTIVE; + }//if + return; + }//if + writeAbortLog(signal); + removeLogTcrec(signal); + } else if (regTcPtr->logWriteState == TcConnectionrec::NOT_STARTED) { + jam(); + } else if (regTcPtr->logWriteState == TcConnectionrec::NOT_WRITTEN) { + jam(); + /* ------------------------------------------------------------------ + * IT IS A READ OPERATION OR OTHER OPERATION THAT DO NOT USE THE LOG. + * ------------------------------------------------------------------ */ + /* ------------------------------------------------------------------ + * THE LOG HAS NOT BEEN WRITTEN SINCE THE LOG FLAG WAS FALSE. + * THIS CAN OCCUR WHEN WE ARE STARTING A NEW FRAGMENT. + * ------------------------------------------------------------------ */ + regTcPtr->logWriteState = TcConnectionrec::NOT_STARTED; + } else { + ndbrequire(regTcPtr->logWriteState == TcConnectionrec::NOT_WRITTEN_WAIT); + jam(); + /* ---------------------------------------------------------------- + * THE STATE WAS SET TO NOT_WRITTEN BY THE OPERATION BUT LATER + * A SCAN OF ALL OPERATION RECORD CHANGED IT INTO NOT_WRITTEN_WAIT. + * THIS INDICATES THAT WE ARE WAITING FOR THIS OPERATION TO COMMIT + * OR ABORT SO THAT WE CAN FIND THE + * STARTING GLOBAL CHECKPOINT OF THIS NEW FRAGMENT. + * ---------------------------------------------------------------- */ + checkScanTcCompleted(signal); + }//if + continueAfterLogAbortWriteLab(signal); + return; +}//Dblqh::continueAbortLab() + +void Dblqh::continueAfterLogAbortWriteLab(Signal* signal) +{ + TcConnectionrec * const regTcPtr = tcConnectptr.p; + if (regTcPtr->simpleRead == ZSIMPLE_READ) { + jam(); + TcKeyRef * const tcKeyRef = (TcKeyRef *) signal->getDataPtrSend(); + + tcKeyRef->connectPtr = regTcPtr->applOprec; + tcKeyRef->transId[0] = regTcPtr->transid[0]; + tcKeyRef->transId[1] = regTcPtr->transid[1]; + tcKeyRef->errorCode = regTcPtr->errorCode; + sendSignal(regTcPtr->applRef, + GSN_TCKEYREF, signal, TcKeyRef::SignalLength, JBB); + cleanUp(signal); + return; + }//if + if (regTcPtr->abortState == TcConnectionrec::ABORT_FROM_LQH) { + LqhKeyRef * const lqhKeyRef = (LqhKeyRef *)signal->getDataPtrSend(); + + jam(); + lqhKeyRef->userRef = regTcPtr->clientConnectrec; + lqhKeyRef->connectPtr = regTcPtr->tcOprec; + lqhKeyRef->errorCode = regTcPtr->errorCode; + lqhKeyRef->transId1 = regTcPtr->transid[0]; + lqhKeyRef->transId2 = regTcPtr->transid[1]; + sendSignal(regTcPtr->clientBlockref, GSN_LQHKEYREF, signal, + LqhKeyRef::SignalLength, JBB); + } else if (regTcPtr->abortState == TcConnectionrec::ABORT_FROM_TC) { + jam(); + sendAborted(signal); + } else if (regTcPtr->abortState == TcConnectionrec::NEW_FROM_TC) { + jam(); + sendLqhTransconf(signal, LqhTransConf::Aborted); + } else { + ndbrequire(regTcPtr->abortState == TcConnectionrec::REQ_FROM_TC); + jam(); + signal->theData[0] = regTcPtr->reqRef; + signal->theData[1] = tcConnectptr.i; + signal->theData[2] = cownNodeid; + signal->theData[3] = regTcPtr->transid[0]; + signal->theData[4] = regTcPtr->transid[1]; + sendSignal(regTcPtr->reqBlockref, GSN_ABORTCONF, + signal, 5, JBB); + }//if + cleanUp(signal); +}//Dblqh::continueAfterLogAbortWriteLab() + +/* ########################################################################## + * ####### MODULE TO HANDLE TC FAILURE ####### + * + * ########################################################################## */ + +/* ************************************************************************>> + * NODE_FAILREP: Node failure report. Sender Ndbcntr. Set status of failed + * node to down and reply with NF_COMPLETEREP to DIH which will report that + * LQH has completed failure handling. + * ************************************************************************>> */ +void Dblqh::execNODE_FAILREP(Signal* signal) +{ + UintR TfoundNodes = 0; + UintR TnoOfNodes; + UintR Tdata[MAX_NDB_NODES]; + + NodeFailRep * const nodeFail = (NodeFailRep *)&signal->theData[0]; + + TnoOfNodes = nodeFail->noOfNodes; + UintR index = 0; + for (Uint32 i = 1; i < MAX_NDB_NODES; i++) { + jam(); + if(NodeBitmask::get(nodeFail->theNodes, i)){ + jam(); + Tdata[index] = i; + index++; + }//if + }//for + + lcpPtr.i = 0; + ptrAss(lcpPtr, lcpRecord); + + ndbrequire(index == TnoOfNodes); + ndbrequire(cnoOfNodes - 1 < MAX_NDB_NODES); + for (Uint32 i = 0; i < TnoOfNodes; i++) { + const Uint32 nodeId = Tdata[i]; + lcpPtr.p->m_EMPTY_LCP_REQ.clear(nodeId); + + for (Uint32 j = 0; j < cnoOfNodes; j++) { + jam(); + if (cnodeData[j] == nodeId){ + jam(); + cnodeStatus[j] = ZNODE_DOWN; + + TfoundNodes++; + }//if + }//for + NFCompleteRep * const nfCompRep = (NFCompleteRep *)&signal->theData[0]; + nfCompRep->blockNo = DBLQH; + nfCompRep->nodeId = cownNodeid; + nfCompRep->failedNodeId = Tdata[i]; + sendSignal(DBDIH_REF, GSN_NF_COMPLETEREP, signal, + NFCompleteRep::SignalLength, JBB); + }//for + ndbrequire(TnoOfNodes == TfoundNodes); +}//Dblqh::execNODE_FAILREP() + +/* ************************************************************************>> + * LQH_TRANSREQ: Report status of all transactions where TC was coordinated + * by a crashed TC + * ************************************************************************>> */ +/* ************************************************************************>> + * THIS SIGNAL IS RECEIVED AFTER A NODE CRASH. + * THE NODE HAD A TC AND COORDINATED A NUMBER OF TRANSACTIONS. + * NOW THE MASTER NODE IS PICKING UP THOSE TRANSACTIONS + * TO COMPLETE THEM. EITHER ABORT THEM OR COMMIT THEM. + * ************************************************************************>> */ +void Dblqh::execLQH_TRANSREQ(Signal* signal) +{ + jamEntry(); + Uint32 newTcPtr = signal->theData[0]; + BlockReference newTcBlockref = signal->theData[1]; + Uint32 oldNodeId = signal->theData[2]; + tcNodeFailptr.i = oldNodeId; + ptrCheckGuard(tcNodeFailptr, ctcNodeFailrecFileSize, tcNodeFailRecord); + if ((tcNodeFailptr.p->tcFailStatus == TcNodeFailRecord::TC_STATE_TRUE) || + (tcNodeFailptr.p->tcFailStatus == TcNodeFailRecord::TC_STATE_BREAK)) { + jam(); + tcNodeFailptr.p->lastNewTcBlockref = newTcBlockref; + /* ------------------------------------------------------------------------ + * WE HAVE RECEIVED A SIGNAL SPECIFYING THAT WE NEED TO HANDLE THE FAILURE + * OF A TC. NOW WE RECEIVE ANOTHER SIGNAL WITH THE SAME ORDER. THIS CAN + * OCCUR IF THE NEW TC FAILS. WE MUST BE CAREFUL IN THIS CASE SO THAT WE DO + * NOT START PARALLEL ACTIVITIES TRYING TO DO THE SAME THING. WE SAVE THE + * NEW BLOCK REFERENCE TO THE LAST NEW TC IN A VARIABLE AND ASSIGN TO IT TO + * NEW_TC_BLOCKREF WHEN THE OLD PROCESS RETURNS TO LQH_TRANS_NEXT. IT IS + * CERTAIN TO COME THERE SINCE THIS IS THE ONLY PATH TO TAKE CARE OF THE + * NEXT TC CONNECT RECORD. WE SET THE STATUS TO BREAK TO INDICATE TO THE OLD + * PROCESS WHAT IS HAPPENING. + * ------------------------------------------------------------------------ */ + tcNodeFailptr.p->lastNewTcRef = newTcPtr; + tcNodeFailptr.p->tcFailStatus = TcNodeFailRecord::TC_STATE_BREAK; + return; + }//if + tcNodeFailptr.p->oldNodeId = oldNodeId; + tcNodeFailptr.p->newTcBlockref = newTcBlockref; + tcNodeFailptr.p->newTcRef = newTcPtr; + tcNodeFailptr.p->tcRecNow = 0; + tcNodeFailptr.p->tcFailStatus = TcNodeFailRecord::TC_STATE_TRUE; + signal->theData[0] = ZLQH_TRANS_NEXT; + signal->theData[1] = tcNodeFailptr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + return; +}//Dblqh::execLQH_TRANSREQ() + +void Dblqh::lqhTransNextLab(Signal* signal) +{ + UintR tend; + UintR tstart; + UintR guard0; + + if (tcNodeFailptr.p->tcFailStatus == TcNodeFailRecord::TC_STATE_BREAK) { + jam(); + /* ---------------------------------------------------------------------- + * AN INTERRUPTION TO THIS NODE FAIL HANDLING WAS RECEIVED AND A NEW + * TC HAVE BEEN ASSIGNED TO TAKE OVER THE FAILED TC. PROBABLY THE OLD + * NEW TC HAVE FAILED. + * ---------------------------------------------------------------------- */ + tcNodeFailptr.p->newTcBlockref = tcNodeFailptr.p->lastNewTcBlockref; + tcNodeFailptr.p->newTcRef = tcNodeFailptr.p->lastNewTcRef; + tcNodeFailptr.p->tcRecNow = 0; + tcNodeFailptr.p->tcFailStatus = TcNodeFailRecord::TC_STATE_TRUE; + }//if + tstart = tcNodeFailptr.p->tcRecNow; + tend = tstart + 200; + guard0 = tend; + for (tcConnectptr.i = tstart; tcConnectptr.i <= guard0; tcConnectptr.i++) { + jam(); + if (tcConnectptr.i >= ctcConnectrecFileSize) { + jam(); + /** + * Finished with scanning operation record + * + * now scan markers + */ + scanMarkers(signal, tcNodeFailptr.i, 0, RNIL); + return; + }//if + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + if (tcConnectptr.p->transactionState != TcConnectionrec::IDLE) { + if (tcConnectptr.p->transactionState != TcConnectionrec::TC_NOT_CONNECTED) { + if (tcConnectptr.p->tcScanRec == RNIL) { + if (refToNode(tcConnectptr.p->tcBlockref) == tcNodeFailptr.p->oldNodeId) { + if (tcConnectptr.p->operation != ZREAD) { + jam(); + tcConnectptr.p->tcNodeFailrec = tcNodeFailptr.i; + tcConnectptr.p->abortState = TcConnectionrec::NEW_FROM_TC; + abortStateHandlerLab(signal); + return; + } else { + jam(); + if (tcConnectptr.p->opSimple != ZTRUE) { + jam(); + tcConnectptr.p->tcNodeFailrec = tcNodeFailptr.i; + tcConnectptr.p->abortState = TcConnectionrec::NEW_FROM_TC; + abortStateHandlerLab(signal); + return; + }//if + }//if + }//if + } else { + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + if (scanptr.p->scanType == ScanRecord::COPY) { + jam(); + if (scanptr.p->scanNodeId == tcNodeFailptr.p->oldNodeId) { + jam(); + /* ------------------------------------------------------------ + * THE RECEIVER OF THE COPY HAVE FAILED. + * WE HAVE TO CLOSE THE COPY PROCESS. + * ------------------------------------------------------------ */ + tcConnectptr.p->tcNodeFailrec = tcNodeFailptr.i; + tcConnectptr.p->abortState = TcConnectionrec::NEW_FROM_TC; + closeCopyRequestLab(signal); + return; + }//if + } else { + if (scanptr.p->scanType == ScanRecord::SCAN) { + jam(); + if (refToNode(tcConnectptr.p->tcBlockref) == + tcNodeFailptr.p->oldNodeId) { + jam(); + tcConnectptr.p->tcNodeFailrec = tcNodeFailptr.i; + tcConnectptr.p->abortState = TcConnectionrec::NEW_FROM_TC; + closeScanRequestLab(signal); + return; + }//if + } else { + jam(); + /* ------------------------------------------------------------ + * THIS IS AN ERROR THAT SHOULD NOT OCCUR. WE CRASH THE SYSTEM. + * ------------------------------------------------------------ */ + systemErrorLab(signal); + return; + }//if + }//if + }//if + }//if + }//if + }//for + tcNodeFailptr.p->tcRecNow = tend + 1; + signal->theData[0] = ZLQH_TRANS_NEXT; + signal->theData[1] = tcNodeFailptr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + return; +}//Dblqh::lqhTransNextLab() + +void +Dblqh::scanMarkers(Signal* signal, + Uint32 tcNodeFail, + Uint32 startBucket, + Uint32 i){ + + jam(); + + TcNodeFailRecordPtr tcNodeFailPtr; + tcNodeFailPtr.i = tcNodeFail; + ptrCheckGuard(tcNodeFailPtr, ctcNodeFailrecFileSize, tcNodeFailRecord); + const Uint32 crashedTcNodeId = tcNodeFailPtr.p->oldNodeId; + + CommitAckMarkerIterator iter; + if(i == RNIL){ + m_commitAckMarkerHash.next(startBucket, iter); + } else { + jam(); + iter.curr.i = i; + iter.bucket = startBucket; + m_commitAckMarkerHash.getPtr(iter.curr); + m_commitAckMarkerHash.next(iter); + } + + const Uint32 RT_BREAK = 256; + for(Uint32 i = 0; itcFailStatus = TcNodeFailRecord::TC_STATE_FALSE; + signal->theData[0] = tcNodeFailPtr.p->newTcRef; + signal->theData[1] = cownNodeid; + signal->theData[2] = LqhTransConf::LastTransConf; + sendSignal(tcNodeFailPtr.p->newTcBlockref, GSN_LQH_TRANSCONF, + signal, 3, JBB); + return; + } + + if(iter.curr.p->tcNodeId == crashedTcNodeId){ + jam(); + + /** + * Found marker belonging to crashed node + */ + LqhTransConf * const lqhTransConf = (LqhTransConf *)&signal->theData[0]; + lqhTransConf->tcRef = tcNodeFailPtr.p->newTcRef; + lqhTransConf->lqhNodeId = cownNodeid; + lqhTransConf->operationStatus = LqhTransConf::Marker; + lqhTransConf->transId1 = iter.curr.p->transid1; + lqhTransConf->transId2 = iter.curr.p->transid2; + lqhTransConf->apiRef = iter.curr.p->apiRef; + lqhTransConf->apiOpRec = iter.curr.p->apiOprec; + sendSignal(tcNodeFailPtr.p->newTcBlockref, GSN_LQH_TRANSCONF, + signal, 7, JBB); + + signal->theData[0] = ZSCAN_MARKERS; + signal->theData[1] = tcNodeFailPtr.i; + signal->theData[2] = iter.bucket; + signal->theData[3] = iter.curr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 4, JBB); + return; + } + + m_commitAckMarkerHash.next(iter); + } + + signal->theData[0] = ZSCAN_MARKERS; + signal->theData[1] = tcNodeFailPtr.i; + signal->theData[2] = iter.bucket; + signal->theData[3] = RNIL; + sendSignal(cownref, GSN_CONTINUEB, signal, 4, JBB); +} + +/* ######################################################################### + * ####### SCAN MODULE ####### + * + * ######################################################################### + * ------------------------------------------------------------------------- + * THIS MODULE CONTAINS THE CODE THAT HANDLES A SCAN OF A PARTICULAR FRAGMENT + * IT OPERATES UNDER THE CONTROL OF TC AND ORDERS ACC TO PERFORM A SCAN OF + * ALL TUPLES IN THE FRAGMENT. TUP PERFORMS THE NECESSARY SEARCH CONDITIONS + * TO ENSURE THAT ONLY VALID TUPLES ARE RETURNED TO THE APPLICATION. + * ------------------------------------------------------------------------- */ + +void Dblqh::execACC_SCAN_INFO(Signal* signal) +{ + jamEntry(); + scanptr.i = signal->theData[0]; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + Uint32 length = signal->theData[3]; + ndbrequire(length <= 4); + accScanInfoEnterLab(signal, &signal->theData[4], length); +}//Dblqh::execACC_SCAN_INFO() + + +void Dblqh::execACC_SCAN_INFO24(Signal* signal) +{ + jamEntry(); + scanptr.i = signal->theData[0]; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + Uint32 length = signal->theData[3]; + ndbrequire(length <= 20); + accScanInfoEnterLab(signal, &signal->theData[4], length); +}//Dblqh::execACC_SCAN_INFO24() + +void Dblqh::accScanInfoEnterLab(Signal* signal, + Uint32* dataPtr, + Uint32 length) +{ + ndbrequire(length != 0); + if (scanptr.p->scanState == ScanRecord::WAIT_SCAN_KEYINFO) { + jam(); + if (keyinfoLab(signal, dataPtr, length)) { + jam(); + nextScanConfLoopLab(signal); + }//if + } else { + ndbrequire(scanptr.p->scanState == ScanRecord::WAIT_COPY_KEYINFO); + jam(); + if (keyinfoLab(signal, dataPtr, length)) { + jam(); + copySendTupkeyReqLab(signal); + }//if + }//if +}//Dblqh::accScanInfoEnterLab() + +/* *************** */ +/* ACC_SCANCONF > */ +/* *************** */ +void Dblqh::execACC_SCANCONF(Signal* signal) +{ + AccScanConf * const accScanConf = (AccScanConf *)&signal->theData[0]; + jamEntry(); + scanptr.i = accScanConf->scanPtr; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + if (scanptr.p->scanState == ScanRecord::WAIT_ACC_SCAN) { + accScanConfScanLab(signal); + } else { + ndbrequire(scanptr.p->scanState == ScanRecord::WAIT_ACC_COPY); + accScanConfCopyLab(signal); + }//if +}//Dblqh::execACC_SCANCONF() + +/* ************>> */ +/* ACC_SCANREF > */ +/* ************>> */ +void Dblqh::execACC_SCANREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +}//Dblqh::execACC_SCANREF() + +/* ***************>> */ +/* NEXT_SCANCONF > */ +/* ***************>> */ +void Dblqh::execNEXT_SCANCONF(Signal* signal) +{ + NextScanConf * const nextScanConf = (NextScanConf *)&signal->theData[0]; + jamEntry(); + scanptr.i = nextScanConf->scanPtr; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + if (nextScanConf->localKeyLength == 1) { + jam(); + nextScanConf->localKey[1] = + nextScanConf->localKey[0] & MAX_TUPLES_PER_PAGE; + nextScanConf->localKey[0] = nextScanConf->localKey[0] >> MAX_TUPLES_BITS; + }//if + switch (scanptr.p->scanState) { + case ScanRecord::WAIT_CLOSE_SCAN: + jam(); + accScanCloseConfLab(signal); + break; + case ScanRecord::WAIT_CLOSE_COPY: + jam(); + accCopyCloseConfLab(signal); + break; + case ScanRecord::WAIT_NEXT_SCAN: + jam(); + nextScanConfScanLab(signal); + break; + case ScanRecord::WAIT_NEXT_SCAN_COPY: + jam(); + nextScanConfCopyLab(signal); + break; + case ScanRecord::WAIT_RELEASE_LOCK: + jam(); + ndbrequire(signal->length() == 1); + scanLockReleasedLab(signal); + break; + default: + ndbrequire(false); + }//switch +}//Dblqh::execNEXT_SCANCONF() + +/* ***************> */ +/* NEXT_SCANREF > */ +/* ***************> */ +void Dblqh::execNEXT_SCANREF(Signal* signal) +{ + jamEntry(); + systemErrorLab(signal); + return; +}//Dblqh::execNEXT_SCANREF() + +/* ******************> */ +/* STORED_PROCCONF > */ +/* ******************> */ +void Dblqh::execSTORED_PROCCONF(Signal* signal) +{ + jamEntry(); + tcConnectptr.i = signal->theData[0]; + Uint32 storedProcId = signal->theData[1]; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + switch (scanptr.p->scanState) { + case ScanRecord::WAIT_STORED_PROC_SCAN: + jam(); + scanptr.p->scanStoredProcId = storedProcId; + storedProcConfScanLab(signal); + break; + case ScanRecord::WAIT_DELETE_STORED_PROC_ID_SCAN: + jam(); + releaseActiveFrag(signal); + tupScanCloseConfLab(signal); + break; + case ScanRecord::WAIT_STORED_PROC_COPY: + jam(); + scanptr.p->scanStoredProcId = storedProcId; + storedProcConfCopyLab(signal); + break; + case ScanRecord::WAIT_DELETE_STORED_PROC_ID_COPY: + jam(); + releaseActiveFrag(signal); + tupCopyCloseConfLab(signal); + break; + default: + ndbrequire(false); + }//switch +}//Dblqh::execSTORED_PROCCONF() + +/* ****************** */ +/* STORED_PROCREF > */ +/* ****************** */ +void Dblqh::execSTORED_PROCREF(Signal* signal) +{ + jamEntry(); + tcConnectptr.i = signal->theData[0]; + Uint32 errorCode = signal->theData[1]; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + switch (scanptr.p->scanState) { + case ScanRecord::WAIT_STORED_PROC_SCAN: + jam(); + scanptr.p->scanStoredProcId = signal->theData[2]; + tcConnectptr.p->errorCode = errorCode; + closeScanLab(signal); + break; + default: + ndbrequire(false); + }//switch +}//Dblqh::execSTORED_PROCREF() + +/* -------------------------------------------------------------------------- + * ENTER SCAN_NEXTREQ + * -------------------------------------------------------------------------- + * PRECONDITION: + * TRANSACTION_STATE = SCAN_STATE + * SCAN_STATE = WAIT_SCAN_NEXTREQ + * + * Case scanLockHold: ZTRUE = Unlock previous round of + * scanned row(s) and fetch next set of rows. + * ZFALSE = Fetch new set of rows. + * Number of rows to read depends on parallelism and how many rows + * left to scan in the fragment. SCAN_NEXTREQ can also be sent with + * closeFlag == ZTRUE to close the scan. + * ------------------------------------------------------------------------- */ +void Dblqh::execSCAN_NEXTREQ(Signal* signal) +{ + jamEntry(); + const ScanFragNextReq * const nextReq = + (ScanFragNextReq*)&signal->theData[0]; + const Uint32 transid1 = nextReq->transId1; + const Uint32 transid2 = nextReq->transId2; + const Uint32 senderData = nextReq->senderData; + + if (findTransaction(transid1, transid2, senderData) != ZOK){ + jam(); + DEBUG("Received SCAN_NEXTREQ in LQH with close flag when closed"); + ndbrequire(nextReq->closeFlag == ZTRUE); + return; + } + + // Crash node if signal sender is same node + CRASH_INSERTION2(5021, refToNode(signal->senderBlockRef()) == cownNodeid); + // Crash node if signal sender is NOT same node + CRASH_INSERTION2(5022, refToNode(signal->senderBlockRef()) != cownNodeid); + + if (ERROR_INSERTED(5023)){ + // Drop signal if sender is same node + if (refToNode(signal->senderBlockRef()) == cownNodeid) { + CLEAR_ERROR_INSERT_VALUE; + return; + } + }//if + if (ERROR_INSERTED(5024)){ + // Drop signal if sender is NOT same node + if (refToNode(signal->senderBlockRef()) != cownNodeid) { + CLEAR_ERROR_INSERT_VALUE; + return; + } + }//if + if (ERROR_INSERTED(5025)){ + // Delay signal if sender is NOT same node + if (refToNode(signal->senderBlockRef()) != cownNodeid) { + CLEAR_ERROR_INSERT_VALUE; + sendSignalWithDelay(cownref, GSN_SCAN_NEXTREQ, signal, 1000, + signal->length()); + return; + } + }//if + if (ERROR_INSERTED(5030)){ + ndbout << "ERROR 5030" << endl; + // Drop signal + return; + }//if + + scanptr.i = tcConnectptr.p->tcScanRec; + ndbrequire(scanptr.i != RNIL); + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + scanptr.p->scanTcWaiting = ZTRUE; + + /* ------------------------------------------------------------------ + * If close flag is set this scan should be closed + * If we are waiting for SCAN_NEXTREQ set flag to stop scanning and + * continue execution else set flags and wait until the scan + * completes itself + * ------------------------------------------------------------------ */ + if (nextReq->closeFlag == ZTRUE){ + jam(); + closeScanRequestLab(signal); + return; + }//if + + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + + /* -------------------------------------------------------------------- + * If scanLockHold = TRUE we need to unlock previous round of + * scanned records. + * scanReleaseLocks will set states for this and send a NEXT_SCANREQ. + * When confirm signal NEXT_SCANCONF arrives we call + * continueScanNextReqLab to continue scanning new rows and + * acquiring new locks. + * -------------------------------------------------------------------- */ + if ((scanptr.p->scanLockHold == ZTRUE) && + (scanptr.p->scanCompletedOperations > 0)) { + jam(); + scanptr.p->scanReleaseCounter = 1; + scanReleaseLocksLab(signal); + return; + }//if + + /* ----------------------------------------------------------------------- + * We end up here when scanLockHold = FALSE or no rows was locked from + * previous round. + * Simply continue scanning. + * ----------------------------------------------------------------------- */ + continueScanNextReqLab(signal); +}//Dblqh::execSCAN_NEXTREQ() + +void Dblqh::continueScanNextReqLab(Signal* signal) +{ + if (scanptr.p->scanCompletedStatus == ZTRUE) { + jam(); + closeScanLab(signal); + return; + }//if + + // Update timer on tcConnectRecord + tcConnectptr.p->tcTimer = cLqhTimeOutCount; + + initScanAccOp(signal); + scanptr.p->scanCompletedOperations = 0; + scanptr.p->scanFlag = NextScanReq::ZSCAN_NEXT; + scanNextLoopLab(signal); +}//Dblqh::continueScanNextReqLab() + +/* ------------------------------------------------------------------------- + * WE NEED TO RELEASE LOCKS BEFORE CONTINUING + * ------------------------------------------------------------------------- */ +void Dblqh::scanReleaseLocksLab(Signal* signal) +{ + switch (fragptr.p->fragStatus) { + case Fragrecord::FSACTIVE: + jam(); + linkActiveFrag(signal); + break; + case Fragrecord::BLOCKED: + jam(); + linkFragQueue(signal); + tcConnectptr.p->transactionState = TcConnectionrec::SCAN_RELEASE_STOPPED; + return; + break; + case Fragrecord::FREE: + jam(); + case Fragrecord::ACTIVE_CREATION: + jam(); + case Fragrecord::CRASH_RECOVERING: + jam(); + case Fragrecord::DEFINED: + jam(); + case Fragrecord::REMOVING: + jam(); + default: + ndbrequire(false); + }//switch + continueScanReleaseAfterBlockedLab(signal); +}//Dblqh::scanReleaseLocksLab() + +void Dblqh::continueScanReleaseAfterBlockedLab(Signal* signal) +{ + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + scanptr.p->scanState = ScanRecord::WAIT_RELEASE_LOCK; + signal->theData[0] = scanptr.p->scanAccPtr; + ndbrequire((scanptr.p->scanReleaseCounter -1) < MAX_PARALLEL_OP_PER_SCAN); + signal->theData[1] = + scanptr.p->scanAccOpPtr[scanptr.p->scanReleaseCounter -1]; + signal->theData[2] = NextScanReq::ZSCAN_COMMIT; + if (! scanptr.p->rangeScan) + sendSignal(tcConnectptr.p->tcAccBlockref, GSN_NEXT_SCANREQ, signal, 3, JBB); + else + sendSignal(tcConnectptr.p->tcTuxBlockref, GSN_NEXT_SCANREQ, signal, 3, JBB); +}//Dblqh::continueScanReleaseAfterBlockedLab() + +/* ------------------------------------------------------------------------- + * ENTER SCAN_NEXTREQ + * ------------------------------------------------------------------------- + * SCAN_NEXT_REQ SIGNAL ARRIVED IN THE MIDDLE OF EXECUTION OF THE SCAN. + * IT WAS A REQUEST TO CLOSE THE SCAN. WE WILL CLOSE THE SCAN IN A + * CAREFUL MANNER TO ENSURE THAT NO ERROR OCCURS. + * ------------------------------------------------------------------------- + * PRECONDITION: + * TRANSACTION_STATE = SCAN_STATE_USED + * TSCAN_COMPLETED = ZTRUE + * ------------------------------------------------------------------------- + * WE CAN ALSO ARRIVE AT THIS LABEL AFTER A NODE CRASH OF THE SCAN + * COORDINATOR. + * ------------------------------------------------------------------------- */ +void Dblqh::closeScanRequestLab(Signal* signal) +{ + DEBUG("transactionState = " << tcConnectptr.p->transactionState); + switch (tcConnectptr.p->transactionState) { + case TcConnectionrec::SCAN_STATE_USED: + DEBUG("scanState = " << scanptr.p->scanState); + switch (scanptr.p->scanState) { + case ScanRecord::WAIT_SCAN_KEYINFO: + case ScanRecord::WAIT_NEXT_SCAN: + jam(); + /* ------------------------------------------------------------------- + * SET COMPLETION STATUS AND WAIT FOR OPPORTUNITY TO STOP THE SCAN. + * ------------------------------------------------------------------- */ + scanptr.p->scanCompletedStatus = ZTRUE; + break; + case ScanRecord::WAIT_ACC_SCAN: + case ScanRecord::WAIT_STORED_PROC_SCAN: + jam(); + /* ------------------------------------------------------------------- + * WE ARE CURRENTLY STARTING UP THE SCAN. SET COMPLETED STATUS + * AND WAIT FOR COMPLETION OF STARTUP. + * ------------------------------------------------------------------- */ + scanptr.p->scanCompletedStatus = ZTRUE; + break; + case ScanRecord::WAIT_CLOSE_SCAN: + case ScanRecord::WAIT_DELETE_STORED_PROC_ID_SCAN: + jam(); + /*empty*/; + break; + /* ------------------------------------------------------------------- + * CLOSE IS ALREADY ONGOING. WE NEED NOT DO ANYTHING. + * ------------------------------------------------------------------- */ + case ScanRecord::WAIT_RELEASE_LOCK: + jam(); + /* ------------------------------------------------------------------- + * WE ARE CURRENTLY RELEASING RECORD LOCKS. AFTER COMPLETING THIS + * WE WILL START TO CLOSE THE SCAN. + * ------------------------------------------------------------------- */ + scanptr.p->scanCompletedStatus = ZTRUE; + break; + case ScanRecord::WAIT_SCAN_NEXTREQ: + jam(); + /* ------------------------------------------------------------------- + * WE ARE WAITING FOR A SCAN_NEXTREQ FROM SCAN COORDINATOR(TC) + * WICH HAVE CRASHED. CLOSE THE SCAN + * ------------------------------------------------------------------- */ + scanptr.p->scanCompletedStatus = ZTRUE; + + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + + if (scanptr.p->scanLockHold == ZTRUE) { + if (scanptr.p->scanCompletedOperations > 0) { + jam(); + scanptr.p->scanReleaseCounter = 1; + scanReleaseLocksLab(signal); + return; + }//if + }//if + closeScanLab(signal); + break; + default: + ndbrequire(false); + }//switch + break; + case TcConnectionrec::WAIT_SCAN_AI: + jam(); + /* --------------------------------------------------------------------- + * WE ARE STILL WAITING FOR THE ATTRIBUTE INFORMATION THAT + * OBVIOUSLY WILL NOT ARRIVE. WE CAN QUIT IMMEDIATELY HERE. + * --------------------------------------------------------------------- */ + releaseOprec(signal); + if (tcConnectptr.p->abortState == TcConnectionrec::NEW_FROM_TC) { + jam(); + tcNodeFailptr.i = tcConnectptr.p->tcNodeFailrec; + ptrCheckGuard(tcNodeFailptr, ctcNodeFailrecFileSize, tcNodeFailRecord); + tcNodeFailptr.p->tcRecNow = tcConnectptr.i + 1; + signal->theData[0] = ZLQH_TRANS_NEXT; + signal->theData[1] = tcNodeFailptr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + return; + }//if + tcConnectptr.p->abortState = TcConnectionrec::ABORT_ACTIVE; + scanptr.p->scanCompletedOperations = 0; + sendScanFragConf(signal, ZTRUE); + break; + case TcConnectionrec::SCAN_TUPKEY: + case TcConnectionrec::SCAN_FIRST_STOPPED: + case TcConnectionrec::SCAN_CHECK_STOPPED: + case TcConnectionrec::SCAN_STOPPED: + jam(); + /* --------------------------------------------------------------------- + * SET COMPLETION STATUS AND WAIT FOR OPPORTUNITY TO STOP THE SCAN. + * --------------------------------------------------------------------- */ + scanptr.p->scanCompletedStatus = ZTRUE; + break; + case TcConnectionrec::SCAN_RELEASE_STOPPED: + jam(); + /* --------------------------------------------------------------------- + * WE ARE CURRENTLY RELEASING RECORD LOCKS. AFTER COMPLETING + * THIS WE WILL START TO CLOSE THE SCAN. + * --------------------------------------------------------------------- */ + scanptr.p->scanCompletedStatus = ZTRUE; + break; + case TcConnectionrec::SCAN_CLOSE_STOPPED: + jam(); + /* --------------------------------------------------------------------- + * CLOSE IS ALREADY ONGOING. WE NEED NOT DO ANYTHING. + * --------------------------------------------------------------------- */ + /*empty*/; + break; + default: + ndbrequire(false); + }//switch +}//Dblqh::closeScanRequestLab() + +/* ------------------------------------------------------------------------- + * ENTER NEXT_SCANCONF + * ------------------------------------------------------------------------- + * PRECONDITION: SCAN_STATE = WAIT_RELEASE_LOCK + * ------------------------------------------------------------------------- */ +void Dblqh::scanLockReleasedLab(Signal* signal) +{ + tcConnectptr.i = scanptr.p->scanTcrec; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + releaseActiveFrag(signal); + if (scanptr.p->scanReleaseCounter == scanptr.p->scanCompletedOperations) { + if ((scanptr.p->scanErrorCounter > 0) || + (scanptr.p->scanCompletedStatus == ZTRUE)) { + jam(); + closeScanLab(signal); + } else if ((scanptr.p->scanConcurrentOperations == + scanptr.p->scanCompletedOperations) && + scanptr.p->scanLockHold != ZTRUE) { + jam(); + scanptr.p->scanState = ScanRecord::WAIT_SCAN_NEXTREQ; + sendScanFragConf(signal, ZFALSE); + } else { + jam(); + continueScanNextReqLab(signal); + }//if + } else { + ndbrequire(scanptr.p->scanReleaseCounter <= + scanptr.p->scanCompletedOperations); + jam(); + scanptr.p->scanReleaseCounter++; + scanReleaseLocksLab(signal); + }//if +}//Dblqh::scanLockReleasedLab() + +/* ------------------------------------------------------------------------- + * SCAN_FRAGREQ: Request to start scanning the specified fragment of a table. + * ------------------------------------------------------------------------- */ +void Dblqh::execSCAN_FRAGREQ(Signal* signal) +{ + const ScanFragReq * const scanFragReq = (ScanFragReq *)&signal->theData[0]; + ScanFragRef * ref; + const Uint32 transid1 = scanFragReq->transId1; + const Uint32 transid2 = scanFragReq->transId2; + Uint32 errorCode; + Uint32 senderData; + Uint32 hashIndex; + TcConnectionrecPtr nextHashptr; + + jamEntry(); + const Uint32 reqinfo = scanFragReq->requestInfo; + const Uint32 fragId = scanFragReq->fragmentNo; + tabptr.i = scanFragReq->tableId; + const Uint32 scanConcurrentOperations = ScanFragReq::getConcurrency(reqinfo); + const Uint32 scanLockMode = ScanFragReq::getLockMode(reqinfo); + const Uint8 keyinfo = ScanFragReq::getKeyinfoFlag(reqinfo); + const Uint8 rangeScan = ScanFragReq::getRangeScanFlag(reqinfo); + + ptrCheckGuard(tabptr, ctabrecFileSize, tablerec); + if(tabptr.p->tableStatus != Tablerec::TABLE_DEFINED){ + senderData = scanFragReq->senderData; + goto error_handler_early_1; + } + + if (cfirstfreeTcConrec != RNIL) { + seizeTcrec(); + tcConnectptr.p->clientConnectrec = scanFragReq->senderData; + tcConnectptr.p->clientBlockref = signal->senderBlockRef(); + tcConnectptr.p->savePointId = scanFragReq->savePointId; + } else { + jam(); + /* --------------------------------------------------------------------- + * NO FREE TC RECORD AVAILABLE, THUS WE CANNOT HANDLE THE REQUEST. + * --------------------------------------------------------------------- */ + errorCode = ZNO_TC_CONNECT_ERROR; + senderData = scanFragReq->senderData; + goto error_handler_early; + }//if + /** + * A write allways have to get keyinfo + */ + ndbrequire(scanLockMode == 0 || keyinfo); + + ndbrequire(scanConcurrentOperations <= MAX_PARALLEL_OP_PER_SCAN); + ndbrequire(scanConcurrentOperations != 0); + if (!getFragmentrec(signal, fragId)) { + errorCode = __LINE__; + goto error_handler; + }//if + + // Verify scan type vs table type (both sides are boolean) + if (rangeScan != DictTabInfo::isOrderedIndex(fragptr.p->tableType)) { + errorCode = __LINE__; // XXX fix + goto error_handler; + }//if + + // 1 table scan is reserved for node recovery + if (! rangeScan && fragptr.p->noActiveScan >= NR_ScanNo){ + jam(); + errorCode = ScanFragRef::ZTOO_MANY_ACTIVE_SCAN_ERROR; + goto error_handler; + } + // count is actually not used in range scans + fragptr.p->noActiveScan++; + + // 1 scan record is reserved for node recovery + if (cscanNoFreeRec < 2) { + jam(); + errorCode = ScanFragRef::ZNO_FREE_SCANREC_ERROR; + goto error_handler1; + } + + // XXX adjust cmaxAccOps for range scans and remove this comment + if ((cbookedAccOps + scanConcurrentOperations) > cmaxAccOps) { + jam(); + errorCode = ScanFragRef::ZSCAN_BOOK_ACC_OP_ERROR; + goto error_handler1; + }//if + + seizeScanrec(signal); + initScanTc(signal, + transid1, + transid2, + fragId, + ZNIL); + errorCode = initScanrec(scanFragReq); + if (errorCode != ZOK) { + jam(); + goto error_handler2; + }//if + cbookedAccOps += scanConcurrentOperations; + + hashIndex = (tcConnectptr.p->transid[0] ^ tcConnectptr.p->tcOprec) & 1023; + nextHashptr.i = ctransidHash[hashIndex]; + ctransidHash[hashIndex] = tcConnectptr.i; + tcConnectptr.p->prevHashRec = RNIL; + tcConnectptr.p->nextHashRec = nextHashptr.i; + if (nextHashptr.i != RNIL) { + jam(); + /* --------------------------------------------------------------------- + * ENSURE THAT THE NEXT RECORD HAS SET PREVIOUS TO OUR RECORD + * IF IT EXISTS + * --------------------------------------------------------------------- */ + ptrCheckGuard(nextHashptr, ctcConnectrecFileSize, tcConnectionrec); + nextHashptr.p->prevHashRec = tcConnectptr.i; + }//if + if (scanptr.p->scanAiLength > 0) { + jam(); + tcConnectptr.p->transactionState = TcConnectionrec::WAIT_SCAN_AI; + return; + }//if + continueAfterReceivingAllAiLab(signal); + return; + +error_handler2: + // no scan number allocated + releaseScanrec(signal); +error_handler1: + fragptr.p->noActiveScan--; +error_handler: + ref = (ScanFragRef*)&signal->theData[0]; + tcConnectptr.p->abortState = TcConnectionrec::ABORT_ACTIVE; + ref->senderData = tcConnectptr.p->clientConnectrec; + ref->transId1 = transid1; + ref->transId2 = transid2; + ref->errorCode = errorCode; + sendSignal(tcConnectptr.p->clientBlockref, GSN_SCAN_FRAGREF, signal, + ScanFragRef::SignalLength, JBB); + releaseOprec(signal); + releaseTcrec(signal, tcConnectptr); + return; + + error_handler_early_1: + if(tabptr.p->tableStatus == Tablerec::NOT_DEFINED){ + jam(); + errorCode = ZTABLE_NOT_DEFINED; + } else if (tabptr.p->tableStatus == Tablerec::PREP_DROP_TABLE_ONGOING || + tabptr.p->tableStatus == Tablerec::PREP_DROP_TABLE_DONE){ + jam(); + errorCode = ZDROP_TABLE_IN_PROGRESS; + } else { + ndbrequire(0); + } + error_handler_early: + ref = (ScanFragRef*)&signal->theData[0]; + ref->senderData = senderData; + ref->transId1 = transid1; + ref->transId2 = transid2; + ref->errorCode = errorCode; + sendSignal(signal->senderBlockRef(), GSN_SCAN_FRAGREF, signal, + ScanFragRef::SignalLength, JBB); +}//Dblqh::execSCAN_FRAGREQ() + +void Dblqh::continueAfterReceivingAllAiLab(Signal* signal) +{ + tcConnectptr.p->transactionState = TcConnectionrec::SCAN_STATE_USED; + scanptr.p->scanState = ScanRecord::WAIT_ACC_SCAN; + AccScanReq * req = (AccScanReq*)&signal->theData[0]; + req->senderData = scanptr.i; + req->senderRef = cownref; + req->tableId = tcConnectptr.p->tableref; + req->fragmentNo = tcConnectptr.p->fragmentid; + req->requestInfo = 0; + AccScanReq::setLockMode(req->requestInfo, scanptr.p->scanLockMode); + AccScanReq::setKeyinfoFlag(req->requestInfo, scanptr.p->scanKeyinfoFlag); + AccScanReq::setReadCommittedFlag(req->requestInfo, scanptr.p->readCommitted); + req->transId1 = tcConnectptr.p->transid[0]; + req->transId2 = tcConnectptr.p->transid[1]; + req->savePointId = tcConnectptr.p->savePointId; + // always use if-stmt to switch (instead of setting a "scan block ref") + if (! scanptr.p->rangeScan) + sendSignal(tcConnectptr.p->tcAccBlockref, GSN_ACC_SCANREQ, signal, + AccScanReq::SignalLength, JBB); + else + sendSignal(tcConnectptr.p->tcTuxBlockref, GSN_ACC_SCANREQ, signal, + AccScanReq::SignalLength, JBB); +}//Dblqh::continueAfterReceivingAllAiLab() + +void Dblqh::scanAttrinfoLab(Signal* signal, Uint32* dataPtr, Uint32 length) +{ + if (saveTupattrbuf(signal, dataPtr, length) == ZOK) { + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + if (tcConnectptr.p->currTupAiLen < scanptr.p->scanAiLength) { + jam(); + } else { + jam(); + ndbrequire(tcConnectptr.p->currTupAiLen == scanptr.p->scanAiLength); + continueAfterReceivingAllAiLab(signal); + }//if + return; + }//if + terrorCode = ZGET_ATTRINBUF_ERROR; + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + finishScanrec(signal); + releaseScanrec(signal); + fragptr.p->noActiveScan--; + tcConnectptr.p->transactionState = TcConnectionrec::IDLE; + sendScanFragRefLateLab(signal); +}//Dblqh::scanAttrinfoLab() + +/*---------------------------------------------------------------------*/ +/* Send this 'I am alive' signal to TC when it is received from ACC */ +/* We include the scanPtr.i that comes from ACC in signalData[1], this */ +/* tells TC which fragment record to check for a timeout. */ +/*---------------------------------------------------------------------*/ +void Dblqh::execSCAN_HBREP(Signal* signal) +{ + jamEntry(); + scanptr.i = signal->theData[0]; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + switch(scanptr.p->scanType){ + case ScanRecord::SCAN: + if (scanptr.p->scanTcWaiting == ZTRUE) { + jam(); + tcConnectptr.i = scanptr.p->scanTcrec; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + const Uint32 transid1 = signal->theData[1]; + const Uint32 transid2 = signal->theData[2]; + ndbrequire(transid1 == tcConnectptr.p->transid[0] && + transid2 == tcConnectptr.p->transid[1]); + + // Update counter on tcConnectPtr + if (tcConnectptr.p->tcTimer != 0){ + tcConnectptr.p->tcTimer = cLqhTimeOutCount; + } else { + jam(); + //ndbout << "SCAN_HBREP when tcTimer was off" << endl; + } + + signal->theData[0] = tcConnectptr.p->clientConnectrec; + signal->theData[1] = tcConnectptr.p->transid[0]; + signal->theData[2] = tcConnectptr.p->transid[1]; + sendSignal(tcConnectptr.p->clientBlockref, + GSN_SCAN_HBREP, signal, 3, JBB); + }//if + break; + case ScanRecord::COPY: + // ndbout << "Dblqh::execSCAN_HBREP Dropping SCAN_HBREP" << endl; + break; + default: + ndbrequire(false); + } +} + +void Dblqh::sendScanFragRefLateLab(Signal* signal) +{ + tcConnectptr.p->abortState = TcConnectionrec::ABORT_ACTIVE; + ScanFragRef * ref = (ScanFragRef*)&signal->theData[0]; + ref->senderData = tcConnectptr.p->clientConnectrec; + ref->transId1 = tcConnectptr.p->transid[0]; + ref->transId2 = tcConnectptr.p->transid[1]; + ref->errorCode = terrorCode; + sendSignal(tcConnectptr.p->clientBlockref, GSN_SCAN_FRAGREF, signal, + ScanFragRef::SignalLength, JBB); + deleteTransidHash(signal); + releaseOprec(signal); + releaseTcrec(signal, tcConnectptr); +}//Dblqh::sendScanFragRefLateLab() + + +void Dblqh::accScanConfScanLab(Signal* signal) +{ + AccScanConf * const accScanConf = (AccScanConf *)&signal->theData[0]; + tcConnectptr.i = scanptr.p->scanTcrec; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + /* ----------------------------------------------------------------------- + * PRECONDITION: SCAN_STATE = WAIT_ACC_SCAN + * ----------------------------------------------------------------------- */ + if (accScanConf->flag == AccScanConf::ZEMPTY_FRAGMENT) { + jam(); + /* --------------------------------------------------------------------- + * THE FRAGMENT WAS EMPTY. + * REPORT SUCCESSFUL COPYING. + * --------------------------------------------------------------------- */ + tupScanCloseConfLab(signal); + return; + }//if + scanptr.p->scanAccPtr = accScanConf->accPtr; + AttrbufPtr regAttrinbufptr; + regAttrinbufptr.i = tcConnectptr.p->firstAttrinbuf; + Uint32 boundAiLength = 0; + if (scanptr.p->rangeScan) { + jam(); + // bound info length is in first of the 5 header words + ptrCheckGuard(regAttrinbufptr, cattrinbufFileSize, attrbuf); + boundAiLength = regAttrinbufptr.p->attrbuf[0]; + TuxBoundInfo* const req = (TuxBoundInfo*)signal->getDataPtrSend(); + req->errorCode = RNIL; + req->tuxScanPtrI = scanptr.p->scanAccPtr; + req->boundAiLength = boundAiLength; + Uint32* out = (Uint32*)req + TuxBoundInfo::SignalLength; + Uint32 sz = 0; + while (sz < boundAiLength) { + jam(); + ptrCheckGuard(regAttrinbufptr, cattrinbufFileSize, attrbuf); + Uint32 dataLen = regAttrinbufptr.p->attrbuf[ZINBUF_DATA_LEN]; + MEMCOPY_NO_WORDS(&out[sz], + ®Attrinbufptr.p->attrbuf[0], + dataLen); + sz += dataLen; + regAttrinbufptr.i = regAttrinbufptr.p->attrbuf[ZINBUF_NEXT]; + ptrCheckGuard(regAttrinbufptr, cattrinbufFileSize, attrbuf); + } + ndbrequire(sz == boundAiLength); + EXECUTE_DIRECT(DBTUX, GSN_TUX_BOUND_INFO, + signal, TuxBoundInfo::SignalLength + boundAiLength); + if (req->errorCode != 0) { + jam(); + /* + * Cannot use STORED_PROCREF to abort since even the REF + * returns a stored proc id. So record error and continue. + * The scan is already Invalid in TUX and returns empty set. + */ + tcConnectptr.p->errorCode = req->errorCode; + } + } + scanptr.p->scanState = ScanRecord::WAIT_STORED_PROC_SCAN; + signal->theData[0] = tcConnectptr.p->tupConnectrec; + signal->theData[1] = tcConnectptr.p->tableref; + signal->theData[2] = scanptr.p->scanSchemaVersion; + signal->theData[3] = ZSTORED_PROC_SCAN; + ndbrequire(boundAiLength <= scanptr.p->scanAiLength); + signal->theData[4] = scanptr.p->scanAiLength - boundAiLength; + sendSignal(tcConnectptr.p->tcTupBlockref, + GSN_STORED_PROCREQ, signal, 5, JBB); + + signal->theData[0] = tcConnectptr.p->tupConnectrec; + while (regAttrinbufptr.i != RNIL) { + ptrCheckGuard(regAttrinbufptr, cattrinbufFileSize, attrbuf); + jam(); + Uint32 dataLen = regAttrinbufptr.p->attrbuf[ZINBUF_DATA_LEN]; + ndbrequire(dataLen != 0); + // first 3 words already set in STORED_PROCREQ + MEMCOPY_NO_WORDS(&signal->theData[3], + ®Attrinbufptr.p->attrbuf[0], + dataLen); + sendSignal(tcConnectptr.p->tcTupBlockref, + GSN_ATTRINFO, signal, dataLen + 3, JBB); + regAttrinbufptr.i = regAttrinbufptr.p->attrbuf[ZINBUF_NEXT]; + }//while + releaseOprec(signal); +}//Dblqh::accScanConfScanLab() + +/* ------------------------------------------------------------------------- + * ENTER STORED_PROCCONF WITH + * TC_CONNECTPTR, + * TSTORED_PROC_ID + * ------------------------------------------------------------------------- + * PRECONDITION: SCAN_STATE = WAIT_STORED_PROC_SCAN + * ------------------------------------------------------------------------- */ +void Dblqh::storedProcConfScanLab(Signal* signal) +{ + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if (scanptr.p->scanCompletedStatus == ZTRUE) { + jam(); + // STOP THE SCAN PROCESS IF THIS HAS BEEN REQUESTED. + closeScanLab(signal); + return; + }//if + switch (fragptr.p->fragStatus) { + case Fragrecord::FSACTIVE: + jam(); + linkActiveFrag(signal); + break; + case Fragrecord::BLOCKED: + jam(); + linkFragQueue(signal); + tcConnectptr.p->transactionState = TcConnectionrec::SCAN_FIRST_STOPPED; + return; + break; + case Fragrecord::FREE: + jam(); + case Fragrecord::ACTIVE_CREATION: + jam(); + case Fragrecord::CRASH_RECOVERING: + jam(); + case Fragrecord::DEFINED: + jam(); + case Fragrecord::REMOVING: + jam(); + default: + ndbrequire(false); + break; + }//switch + continueFirstScanAfterBlockedLab(signal); +}//Dblqh::storedProcConfScanLab() + +void Dblqh::continueFirstScanAfterBlockedLab(Signal* signal) +{ + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + scanptr.p->scanState = ScanRecord::WAIT_NEXT_SCAN; + initScanAccOp(signal); + signal->theData[0] = scanptr.p->scanAccPtr; + signal->theData[1] = RNIL; + signal->theData[2] = NextScanReq::ZSCAN_NEXT; + if (! scanptr.p->rangeScan) + sendSignal(tcConnectptr.p->tcAccBlockref, GSN_NEXT_SCANREQ, signal, 3, JBB); + else + sendSignal(tcConnectptr.p->tcTuxBlockref, GSN_NEXT_SCANREQ, signal, 3, JBB); + return; +}//Dblqh::continueFirstScanAfterBlockedLab() + +/* ------------------------------------------------------------------------- + * When executing a scan we must come up to the surface at times to make + * sure we can quickly start local checkpoints. + * ------------------------------------------------------------------------- */ +void Dblqh::execCHECK_LCP_STOP(Signal* signal) +{ + jamEntry(); + scanptr.i = signal->theData[0]; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + tcConnectptr.i = scanptr.p->scanTcrec; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if (signal->theData[1] == ZTRUE) { + jam(); + releaseActiveFrag(signal); + signal->theData[0] = ZCHECK_LCP_STOP_BLOCKED; + signal->theData[1] = scanptr.i; + sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 10, 2); + signal->theData[0] = RNIL; + return; + }//if + if (fragptr.p->fragStatus != Fragrecord::FSACTIVE) { + ndbrequire(fragptr.p->fragStatus == Fragrecord::BLOCKED); + releaseActiveFrag(signal); + linkFragQueue(signal); + tcConnectptr.p->transactionState = TcConnectionrec::SCAN_CHECK_STOPPED; + signal->theData[0] = RNIL; + }//if +}//Dblqh::execCHECK_LCP_STOP() + +void Dblqh::checkLcpStopBlockedLab(Signal* signal) +{ + switch (fragptr.p->fragStatus) { + case Fragrecord::FSACTIVE: + jam(); + linkActiveFrag(signal); + continueAfterCheckLcpStopBlocked(signal); + break; + case Fragrecord::BLOCKED: + jam(); + linkFragQueue(signal); + tcConnectptr.p->transactionState = TcConnectionrec::SCAN_CHECK_STOPPED; + return; + break; + case Fragrecord::FREE: + jam(); + case Fragrecord::ACTIVE_CREATION: + jam(); + case Fragrecord::CRASH_RECOVERING: + jam(); + case Fragrecord::DEFINED: + jam(); + case Fragrecord::REMOVING: + jam(); + default: + ndbrequire(false); + }//switch +}//Dblqh::checkLcpStopBlockedLab() + +void Dblqh::continueAfterCheckLcpStopBlocked(Signal* signal) +{ + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + signal->theData[0] = scanptr.p->scanAccPtr; + signal->theData[1] = AccCheckScan::ZNOT_CHECK_LCP_STOP; + if (! scanptr.p->rangeScan) + EXECUTE_DIRECT(DBACC, GSN_ACC_CHECK_SCAN, signal, 2); + else + EXECUTE_DIRECT(DBTUX, GSN_ACC_CHECK_SCAN, signal, 2); +}//Dblqh::continueAfterCheckLcpStopBlocked() + +/* ------------------------------------------------------------------------- + * ENTER NEXT_SCANCONF + * ------------------------------------------------------------------------- + * PRECONDITION: SCAN_STATE = WAIT_NEXT_SCAN + * ------------------------------------------------------------------------- */ +void Dblqh::nextScanConfScanLab(Signal* signal) +{ + NextScanConf * const nextScanConf = (NextScanConf *)&signal->theData[0]; + tcConnectptr.i = scanptr.p->scanTcrec; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + if (nextScanConf->fragId == RNIL) { + jam(); + /* --------------------------------------------------------------------- + * THERE ARE NO MORE TUPLES TO FETCH. IF WE HAVE ANY + * OPERATIONS STILL NEEDING A LOCK WE REPORT TO THE + * APPLICATION AND CLOSE THE SCAN WHEN THE NEXT SCAN + * REQUEST IS RECEIVED. IF WE DO NOT HAVE ANY NEED FOR + * LOCKS WE CAN CLOSE THE SCAN IMMEDIATELY. + * --------------------------------------------------------------------- */ + releaseActiveFrag(signal); + /************************************************************* + * STOP THE SCAN PROCESS IF THIS HAS BEEN REQUESTED. + ************************************************************ */ + if (scanptr.p->scanCompletedStatus == ZTRUE) { + if ((scanptr.p->scanLockHold == ZTRUE) && + (scanptr.p->scanCompletedOperations > 0)) { + jam(); + scanptr.p->scanReleaseCounter = 1; + scanReleaseLocksLab(signal); + return; + }//if + jam(); + closeScanLab(signal); + return; + }//if + + if (scanptr.p->scanCompletedOperations > 0) { + jam(); + scanptr.p->scanCompletedStatus = ZTRUE; + scanptr.p->scanState = ScanRecord::WAIT_SCAN_NEXTREQ; + sendScanFragConf(signal, ZFALSE); + return; + }//if + closeScanLab(signal); + return; + }//if + + // If accOperationPtr == RNIL no record was returned by ACC + if (nextScanConf->accOperationPtr == RNIL) { + jam(); + /************************************************************* + * STOP THE SCAN PROCESS IF THIS HAS BEEN REQUESTED. + ************************************************************ */ + if (scanptr.p->scanCompletedStatus == ZTRUE) { + releaseActiveFrag(signal); + if ((scanptr.p->scanLockHold == ZTRUE) && + (scanptr.p->scanCompletedOperations > 0)) { + jam(); + scanptr.p->scanReleaseCounter = 1; + scanReleaseLocksLab(signal); + return; + }//if + jam(); + closeScanLab(signal); + return; + }//if + + if (scanptr.p->scanCompletedOperations > 0) { + jam(); + releaseActiveFrag(signal); + scanptr.p->scanState = ScanRecord::WAIT_SCAN_NEXTREQ; + sendScanFragConf(signal, ZFALSE); + return; + }//if + + signal->theData[0] = scanptr.p->scanAccPtr; + signal->theData[1] = AccCheckScan::ZCHECK_LCP_STOP; + if (! scanptr.p->rangeScan) + sendSignal(tcConnectptr.p->tcAccBlockref, + GSN_ACC_CHECK_SCAN, signal, 2, JBB); + else + sendSignal(tcConnectptr.p->tcTuxBlockref, + GSN_ACC_CHECK_SCAN, signal, 2, JBB); + return; + }//if + + ndbrequire(scanptr.p->scanCompletedOperations < MAX_PARALLEL_OP_PER_SCAN); + scanptr.p->scanAccOpPtr[scanptr.p->scanCompletedOperations] = + nextScanConf->accOperationPtr; + scanptr.p->scanLocalref[0] = nextScanConf->localKey[0]; + scanptr.p->scanLocalref[1] = nextScanConf->localKey[1]; + scanptr.p->scanLocalFragid = nextScanConf->fragId; + if (scanptr.p->scanKeyinfoFlag) { + jam(); + tcConnectptr.p->primKeyLen = nextScanConf->keyLength; + seizeTupkeybuf(signal); + databufptr.p->data[0] = nextScanConf->key[0]; + databufptr.p->data[1] = nextScanConf->key[1]; + databufptr.p->data[2] = nextScanConf->key[2]; + databufptr.p->data[3] = nextScanConf->key[3]; + if (nextScanConf->keyLength > 4) { + jam(); + tcConnectptr.p->save1 = 4; + scanptr.p->scanState = ScanRecord::WAIT_SCAN_KEYINFO; + return; + }//if + }//if + nextScanConfLoopLab(signal); +}//Dblqh::nextScanConfScanLab() + +void Dblqh::nextScanConfLoopLab(Signal* signal) +{ + /* ---------------------------------------------------------------------- + * STOP THE SCAN PROCESS IF THIS HAS BEEN REQUESTED. + * ---------------------------------------------------------------------- */ + if (scanptr.p->scanCompletedStatus == ZTRUE) { + jam(); + releaseActiveFrag(signal); + releaseOprec(signal); + if ((scanptr.p->scanLockHold == ZTRUE) && + (scanptr.p->scanCompletedOperations > 0)) { + jam(); + scanptr.p->scanReleaseCounter = 1; + scanReleaseLocksLab(signal); + return; + }//if + closeScanLab(signal); + return; + }//if + + Uint32 tableRef; + Uint32 tupFragPtr; + Uint32 reqinfo = (scanptr.p->scanLockHold == ZFALSE); + reqinfo = reqinfo + (tcConnectptr.p->operation << 6); + reqinfo = reqinfo + (tcConnectptr.p->opExec << 10); + tcConnectptr.p->transactionState = TcConnectionrec::SCAN_TUPKEY; + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if (! scanptr.p->rangeScan) { + tableRef = tcConnectptr.p->tableref; + if (fragptr.p->fragId == scanptr.p->scanLocalFragid) { + jam(); + tupFragPtr = fragptr.p->tupFragptr[0]; + } else { + jam(); + tupFragPtr = fragptr.p->tupFragptr[1]; + }//if + } else { + jam(); + // for ordered index use primary table + FragrecordPtr tFragPtr; + tFragPtr.i = fragptr.p->tableFragptr; + ptrCheckGuard(tFragPtr, cfragrecFileSize, fragrecord); + tableRef = tFragPtr.p->tabRef; + if (tFragPtr.p->fragId == scanptr.p->scanLocalFragid) { + jam(); + tupFragPtr = tFragPtr.p->tupFragptr[0]; + } else { + jam(); + tupFragPtr = tFragPtr.p->tupFragptr[1]; + }//if + } + { + TupKeyReq * const tupKeyReq = (TupKeyReq *)signal->getDataPtrSend(); + + tupKeyReq->connectPtr = tcConnectptr.p->tupConnectrec; + tupKeyReq->request = reqinfo; + tupKeyReq->tableRef = tableRef; + tupKeyReq->fragId = scanptr.p->scanLocalFragid; + tupKeyReq->keyRef1 = scanptr.p->scanLocalref[0]; + tupKeyReq->keyRef2 = scanptr.p->scanLocalref[1]; + tupKeyReq->attrBufLen = 0; + ndbrequire(scanptr.p->scanCompletedOperations < MAX_PARALLEL_OP_PER_SCAN); + tupKeyReq->opRef = + scanptr.p->scanApiOpPtr[scanptr.p->scanCompletedOperations]; + tupKeyReq->applRef = scanptr.p->scanApiBlockref; + tupKeyReq->schemaVersion = scanptr.p->scanSchemaVersion; + tupKeyReq->storedProcedure = scanptr.p->scanStoredProcId; + tupKeyReq->transId1 = tcConnectptr.p->transid[0]; + tupKeyReq->transId2 = tcConnectptr.p->transid[1]; + tupKeyReq->fragPtr = tupFragPtr; + tupKeyReq->primaryReplica = (tcConnectptr.p->seqNoReplica == 0)?true:false; + tupKeyReq->coordinatorTC = tcConnectptr.p->tcBlockref; + tupKeyReq->tcOpIndex = tcConnectptr.p->tcOprec; + tupKeyReq->savePointId = tcConnectptr.p->savePointId; + Uint32 blockNo = refToBlock(tcConnectptr.p->tcTupBlockref); + EXECUTE_DIRECT(blockNo, GSN_TUPKEYREQ, signal, + TupKeyReq::SignalLength); + } +}//Dblqh::nextScanConfLoopLab() + +/* ------------------------------------------------------------------------- + * RECEPTION OF FURTHER KEY INFORMATION WHEN KEY SIZE > 16 BYTES. + * ------------------------------------------------------------------------- + * PRECONDITION: SCAN_STATE = WAIT_SCAN_KEYINFO + * ------------------------------------------------------------------------- */ +bool Dblqh::keyinfoLab(Signal* signal, Uint32* dataPtr, Uint32 length) +{ + tcConnectptr.i = scanptr.p->scanTcrec; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + Uint32 index = 0; + do { + jam(); + seizeTupkeybuf(signal); + databufptr.p->data[0] = dataPtr[index]; + databufptr.p->data[1] = dataPtr[index + 1]; + databufptr.p->data[2] = dataPtr[index + 2]; + databufptr.p->data[3] = dataPtr[index + 3]; + index += 4; + tcConnectptr.p->save1 = tcConnectptr.p->save1 + 4; + if (tcConnectptr.p->save1 >= tcConnectptr.p->primKeyLen) { + jam(); + return true; + }//if + if (index >= length) { + jam(); + return false; + }//if + } while (index < 20); + ndbrequire(false); + return false; +}//Dblqh::keyinfoLab() + +/* ------------------------------------------------------------------------- + * ENTER TUPKEYCONF + * ------------------------------------------------------------------------- + * PRECONDITION: TRANSACTION_STATE = SCAN_TUPKEY + * ------------------------------------------------------------------------- */ +void Dblqh::scanTupkeyConfLab(Signal* signal) +{ + UintR tdata3; + UintR tdata4; + UintR tdata5; + + tdata3 = signal->theData[2]; + tdata4 = signal->theData[3]; + tdata5 = signal->theData[4]; + tcConnectptr.p->transactionState = TcConnectionrec::SCAN_STATE_USED; + scanptr.i = tcConnectptr.p->tcScanRec; + releaseActiveFrag(signal); + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + if (scanptr.p->scanCompletedStatus == ZTRUE) { + /* --------------------------------------------------------------------- + * STOP THE SCAN PROCESS IF THIS HAS BEEN REQUESTED. + * --------------------------------------------------------------------- */ + releaseOprec(signal); + if ((scanptr.p->scanLockHold == ZTRUE) && + (scanptr.p->scanCompletedOperations > 0)) { + jam(); + scanptr.p->scanReleaseCounter = 1; + scanReleaseLocksLab(signal); + return; + }//if + jam(); + closeScanLab(signal); + return; + }//if + if (scanptr.p->scanKeyinfoFlag) { + jam(); + DatabufPtr TdataBuf; + TdataBuf.i = tcConnectptr.p->firstTupkeybuf; + const Uint32 keyLen = tcConnectptr.p->primKeyLen; + const Uint32 dataBufSz = cdatabufFileSize; + + /** + * Note that this code requires signal->theData to be big enough for + * a entire key + */ + ndbrequire(keyLen * 4 <= sizeof(signal->theData)); + KeyInfo20 * keyInfo = (KeyInfo20*)&signal->theData[0]; + for(Uint32 i = 0; i < keyLen; i += 4){ + ptrCheckGuard(TdataBuf, dataBufSz, databuf); + keyInfo->keyData[i + 0] = TdataBuf.p->data[0]; + keyInfo->keyData[i + 1] = TdataBuf.p->data[1]; + keyInfo->keyData[i + 2] = TdataBuf.p->data[2]; + keyInfo->keyData[i + 3] = TdataBuf.p->data[3]; + TdataBuf.i = TdataBuf.p->nextDatabuf; + } + sendKeyinfo20(signal, scanptr.p, tcConnectptr.p); + releaseOprec(signal); + }//if + ndbrequire(scanptr.p->scanCompletedOperations < MAX_PARALLEL_OP_PER_SCAN); + scanptr.p->scanOpLength[scanptr.p->scanCompletedOperations] = tdata4; + scanptr.p->scanCompletedOperations++; + if ((scanptr.p->scanCompletedOperations == + scanptr.p->scanConcurrentOperations) && + (scanptr.p->scanLockHold == ZTRUE)) { + jam(); + scanptr.p->scanState = ScanRecord::WAIT_SCAN_NEXTREQ; + sendScanFragConf(signal, ZFALSE); + return; + } else if (scanptr.p->scanCompletedOperations == + scanptr.p->scanConcurrentOperations) { + jam(); + scanptr.p->scanReleaseCounter = scanptr.p->scanCompletedOperations; + scanReleaseLocksLab(signal); + return; + } else if (scanptr.p->scanLockHold == ZTRUE) { + jam(); + scanptr.p->scanFlag = NextScanReq::ZSCAN_NEXT; + } else { + jam(); + scanptr.p->scanFlag = NextScanReq::ZSCAN_NEXT_COMMIT; + }//if + scanNextLoopLab(signal); +}//Dblqh::scanTupkeyConfLab() + +void Dblqh::scanNextLoopLab(Signal* signal) +{ + switch (fragptr.p->fragStatus) { + case Fragrecord::FSACTIVE: + jam(); + linkActiveFrag(signal); + break; + case Fragrecord::BLOCKED: + jam(); + linkFragQueue(signal); + tcConnectptr.p->transactionState = TcConnectionrec::SCAN_STOPPED; + return; + break; + case Fragrecord::FREE: + jam(); + case Fragrecord::ACTIVE_CREATION: + jam(); + case Fragrecord::CRASH_RECOVERING: + jam(); + case Fragrecord::DEFINED: + jam(); + case Fragrecord::REMOVING: + jam(); + default: + ndbrequire(false); + }//switch + continueScanAfterBlockedLab(signal); +}//Dblqh::scanNextLoopLab() + +void Dblqh::continueScanAfterBlockedLab(Signal* signal) +{ + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + Uint32 accOpPtr; + if (scanptr.p->scanFlag == NextScanReq::ZSCAN_NEXT_ABORT) { + jam(); + scanptr.p->scanFlag = NextScanReq::ZSCAN_NEXT_COMMIT; + accOpPtr = scanptr.p->scanAccOpPtr[scanptr.p->scanCompletedOperations]; + } else if (scanptr.p->scanFlag == NextScanReq::ZSCAN_NEXT_COMMIT) { + jam(); + accOpPtr = scanptr.p->scanAccOpPtr[scanptr.p->scanCompletedOperations - 1]; + } else { + jam(); + accOpPtr = RNIL; // The value is not used in ACC + }//if + scanptr.p->scanState = ScanRecord::WAIT_NEXT_SCAN; + signal->theData[0] = scanptr.p->scanAccPtr; + signal->theData[1] = accOpPtr; + signal->theData[2] = scanptr.p->scanFlag; + if (! scanptr.p->rangeScan) + sendSignal(tcConnectptr.p->tcAccBlockref, GSN_NEXT_SCANREQ, signal, 3, JBB); + else + sendSignal(tcConnectptr.p->tcTuxBlockref, GSN_NEXT_SCANREQ, signal, 3, JBB); +}//Dblqh::continueScanAfterBlockedLab() + +/* ------------------------------------------------------------------------- + * ENTER TUPKEYREF WITH + * TC_CONNECTPTR, + * TERROR_CODE + * ------------------------------------------------------------------------- + * PRECONDITION: TRANSACTION_STATE = SCAN_TUPKEY + * ------------------------------------------------------------------------- */ +void Dblqh::scanTupkeyRefLab(Signal* signal) +{ + tcConnectptr.p->transactionState = TcConnectionrec::SCAN_STATE_USED; + scanptr.i = tcConnectptr.p->tcScanRec; + releaseActiveFrag(signal); + releaseOprec(signal); + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + if (scanptr.p->scanCompletedStatus == ZTRUE) { + /* --------------------------------------------------------------------- + * STOP THE SCAN PROCESS IF THIS HAS BEEN REQUESTED. + * --------------------------------------------------------------------- */ + if ((scanptr.p->scanLockHold == ZTRUE) && + (scanptr.p->scanCompletedOperations > 0)) { + jam(); + scanptr.p->scanReleaseCounter = 1; + scanReleaseLocksLab(signal); + return; + }//if + jam(); + closeScanLab(signal); + return; + }//if + if ((terrorCode != ZSEARCH_CONDITION_FALSE) && + (terrorCode != ZNO_TUPLE_FOUND) && + (terrorCode >= ZUSER_ERROR_CODE_LIMIT)) { + scanptr.p->scanErrorCounter++; + tcConnectptr.p->errorCode = terrorCode; + + if (scanptr.p->scanLockHold == ZTRUE) { + jam(); + scanptr.p->scanReleaseCounter = 1; + } else { + jam(); + scanptr.p->scanCompletedOperations++; + scanptr.p->scanReleaseCounter = scanptr.p->scanCompletedOperations; + }//if + /* -------------------------------------------------------------------- + * WE NEED TO RELEASE ALL LOCKS CURRENTLY + * HELD BY THIS SCAN. + * -------------------------------------------------------------------- */ + scanReleaseLocksLab(signal); + return; + }//if + /* ----------------------------------------------------------------------- + * WE NEED TO ENSURE THAT WE DO NOT SEARCH FOR THE NEXT TUPLE FOR A + * LONG TIME WHILE WE KEEP A LOCK ON A FOUND TUPLE. WE RATHER REPORT + * THE FOUND TUPLE IF FOUND TUPLES ARE RARE. WE SELECT 20 TUPLES + * WHICH SHOULD BE ROUGHLY 10 MS OF LOCK HOLD TIME. + * ----------------------------------------------------------------------- */ + scanptr.p->scanSearchCondFalseCount++; +#if 0 + // MASV Uncomment this feature since it forgets + // to release on operation record in DBACC + // This is the quick fix and should be changed in + // the future + if (scanptr.p->scanSearchCondFalseCount > 20) { + if (scanptr.p->scanCompletedOperations > 0) { + jam(); + scanptr.p->scanState = ScanRecord::WAIT_SCAN_NEXTREQ; + sendScanFragConf(signal, ZFALSE); + return; + }//if + }//if +#endif + + scanptr.p->scanFlag = NextScanReq::ZSCAN_NEXT_ABORT; + scanNextLoopLab(signal); +}//Dblqh::scanTupkeyRefLab() + +/* ------------------------------------------------------------------------- + * THE SCAN HAS BEEN COMPLETED. EITHER BY REACHING THE END OR BY COMMAND + * FROM THE APPLICATION OR BY SOME SORT OF ERROR CONDITION. + * ------------------------------------------------------------------------- */ +void Dblqh::closeScanLab(Signal* signal) +{ + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + switch (fragptr.p->fragStatus) { + case Fragrecord::FSACTIVE: + jam(); + linkActiveFrag(signal); + break; + case Fragrecord::BLOCKED: + jam(); + linkFragQueue(signal); + tcConnectptr.p->transactionState = TcConnectionrec::SCAN_CLOSE_STOPPED; + return; + break; + case Fragrecord::FREE: + jam(); + case Fragrecord::ACTIVE_CREATION: + jam(); + case Fragrecord::CRASH_RECOVERING: + jam(); + case Fragrecord::DEFINED: + jam(); + case Fragrecord::REMOVING: + jam(); + default: + ndbrequire(false); + }//switch + continueCloseScanAfterBlockedLab(signal); +}//Dblqh::closeScanLab() + +void Dblqh::continueCloseScanAfterBlockedLab(Signal* signal) +{ + tcConnectptr.p->transactionState = TcConnectionrec::SCAN_STATE_USED; + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + scanptr.p->scanState = ScanRecord::WAIT_CLOSE_SCAN; + signal->theData[0] = scanptr.p->scanAccPtr; + signal->theData[1] = RNIL; + signal->theData[2] = NextScanReq::ZSCAN_CLOSE; + if (! scanptr.p->rangeScan) + sendSignal(tcConnectptr.p->tcAccBlockref, GSN_NEXT_SCANREQ, signal, 3, JBB); + else + sendSignal(tcConnectptr.p->tcTuxBlockref, GSN_NEXT_SCANREQ, signal, 3, JBB); +}//Dblqh::continueCloseScanAfterBlockedLab() + +/* ------------------------------------------------------------------------- + * ENTER NEXT_SCANCONF + * ------------------------------------------------------------------------- + * PRECONDITION: SCAN_STATE = WAIT_CLOSE_SCAN + * ------------------------------------------------------------------------- */ +void Dblqh::accScanCloseConfLab(Signal* signal) +{ + tcConnectptr.i = scanptr.p->scanTcrec; + scanptr.p->scanState = ScanRecord::WAIT_DELETE_STORED_PROC_ID_SCAN; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + signal->theData[0] = tcConnectptr.p->tupConnectrec; + signal->theData[1] = tcConnectptr.p->tableref; + signal->theData[2] = scanptr.p->scanSchemaVersion; + signal->theData[3] = ZDELETE_STORED_PROC_ID; + signal->theData[4] = scanptr.p->scanStoredProcId; + sendSignal(tcConnectptr.p->tcTupBlockref, + GSN_STORED_PROCREQ, signal, 5, JBB); +}//Dblqh::accScanCloseConfLab() + +/* ------------------------------------------------------------------------- + * ENTER STORED_PROCCONF WITH + * ------------------------------------------------------------------------- + * PRECONDITION: SCAN_STATE = WAIT_DELETE_STORED_PROC_ID_SCAN + * ------------------------------------------------------------------------- */ +void Dblqh::tupScanCloseConfLab(Signal* signal) +{ + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if (tcConnectptr.p->abortState == TcConnectionrec::NEW_FROM_TC) { + jam(); + tcNodeFailptr.i = tcConnectptr.p->tcNodeFailrec; + ptrCheckGuard(tcNodeFailptr, ctcNodeFailrecFileSize, tcNodeFailRecord); + tcNodeFailptr.p->tcRecNow = tcConnectptr.i + 1; + signal->theData[0] = ZLQH_TRANS_NEXT; + signal->theData[1] = tcNodeFailptr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + } else if (tcConnectptr.p->errorCode != 0) { + jam(); + ScanFragRef * ref = (ScanFragRef*)&signal->theData[0]; + ref->senderData = tcConnectptr.p->clientConnectrec; + ref->transId1 = tcConnectptr.p->transid[0]; + ref->transId2 = tcConnectptr.p->transid[1]; + ref->errorCode = tcConnectptr.p->errorCode; + sendSignal(tcConnectptr.p->clientBlockref, GSN_SCAN_FRAGREF, signal, + ScanFragRef::SignalLength, JBB); + } else { + jam(); + scanptr.p->scanCompletedOperations = 0; + sendScanFragConf(signal, ZSCAN_FRAG_CLOSED); + }//if + finishScanrec(signal); + releaseScanrec(signal); + tcConnectptr.p->tcScanRec = RNIL; + fragptr.p->noActiveScan = fragptr.p->noActiveScan - 1; + deleteTransidHash(signal); + releaseOprec(signal); + releaseTcrec(signal, tcConnectptr); +}//Dblqh::tupScanCloseConfLab() + +/* ========================================================================= + * ======= INITIATE SCAN_ACC_OP_PTR TO RNIL IN SCAN RECORD ======= + * + * SUBROUTINE SHORT NAME = ISA + * ========================================================================= */ +void Dblqh::initScanAccOp(Signal* signal) +{ + UintR tisaIndex; + + for (tisaIndex = 0; tisaIndex < MAX_PARALLEL_OP_PER_SCAN; tisaIndex++) { + scanptr.p->scanAccOpPtr[tisaIndex] = RNIL; + }//for +}//Dblqh::initScanAccOp() + +/* ========================================================================= + * ======= INITIATE SCAN RECORD ======= + * + * SUBROUTINE SHORT NAME = ISC + * ========================================================================= */ +Uint32 Dblqh::initScanrec(const ScanFragReq* scanFragReq) +{ + const Uint32 reqinfo = scanFragReq->requestInfo; + const Uint32 scanConcurrentOperations = ScanFragReq::getConcurrency(reqinfo); + const Uint32 scanLockMode = ScanFragReq::getLockMode(reqinfo); + const Uint32 scanLockHold = ScanFragReq::getHoldLockFlag(reqinfo); + const Uint32 keyinfo = ScanFragReq::getKeyinfoFlag(reqinfo); + const Uint32 readCommitted = ScanFragReq::getReadCommittedFlag(reqinfo); + const Uint32 rangeScan = ScanFragReq::getRangeScanFlag(reqinfo); + const Uint32 attrLen = ScanFragReq::getAttrLen(reqinfo); + + scanptr.p->scanKeyinfoFlag = keyinfo; + scanptr.p->scanLockHold = scanLockHold; + scanptr.p->scanCompletedStatus = ZFALSE; + scanptr.p->scanType = ScanRecord::SCAN; + scanptr.p->scanApiBlockref = scanFragReq->resultRef; + scanptr.p->scanAiLength = attrLen; + scanptr.p->scanTcrec = tcConnectptr.i; + scanptr.p->scanSchemaVersion = scanFragReq->schemaVersion; + scanptr.p->scanCompletedOperations = 0; + scanptr.p->scanConcurrentOperations = scanConcurrentOperations; + scanptr.p->scanErrorCounter = 0; + scanptr.p->scanLockMode = scanLockMode; + scanptr.p->readCommitted = readCommitted; + scanptr.p->rangeScan = rangeScan; + scanptr.p->scanSearchCondFalseCount = 0; + scanptr.p->scanState = ScanRecord::SCAN_FREE; + scanptr.p->scanFlag = ZFALSE; + scanptr.p->scanLocalref[0] = 0; + scanptr.p->scanLocalref[1] = 0; + scanptr.p->scanLocalFragid = 0; + scanptr.p->scanTcWaiting = ZTRUE; + + for (Uint32 i = 0; i < scanConcurrentOperations; i++) { + jam(); + scanptr.p->scanApiOpPtr[i] = scanFragReq->clientOpPtr[i]; + scanptr.p->scanOpLength[i] = 0; + scanptr.p->scanAccOpPtr[i] = 0; + }//for + if (! rangeScan) { + jam(); + for (Int32 i = NR_ScanNo - 1; i >= 0; i--) { + jam(); + if (fragptr.p->fragScanRec[i] == ZNIL) { + jam(); + scanptr.p->scanNumber = i; + fragptr.p->fragScanRec[i] = scanptr.i; + return ZOK; + }//if + }//for + } else { + jam(); + // put in second half of fragScanRec of primary table fragment + FragrecordPtr tFragPtr; + tFragPtr.i = fragptr.p->tableFragptr; + ptrCheckGuard(tFragPtr, cfragrecFileSize, fragrecord); + for (Uint32 i = NR_MinRangeScanNo; i < NR_MaxRangeScanNo; i++) { + if (tFragPtr.p->fragScanRec[i] == ZNIL) { + jam(); + scanptr.p->scanNumber = i; + tFragPtr.p->fragScanRec[i] = scanptr.i; + return ZOK; + } + } + } + return ZNO_FREE_FRAG_SCAN_REC_ERROR; +}//Dblqh::initScanrec() + +/* ========================================================================= + * ======= INITIATE TC RECORD AT SCAN ======= + * + * SUBROUTINE SHORT NAME = IST + * ========================================================================= */ +void Dblqh::initScanTc(Signal* signal, + Uint32 transid1, + Uint32 transid2, + Uint32 fragId, + Uint32 nodeId) +{ + tcConnectptr.p->transid[0] = transid1; + tcConnectptr.p->transid[1] = transid2; + tcConnectptr.p->tcScanRec = scanptr.i; + tcConnectptr.p->tableref = tabptr.i; + tcConnectptr.p->fragmentid = fragId; + tcConnectptr.p->fragmentptr = fragptr.i; + tcConnectptr.p->tcOprec = tcConnectptr.p->clientConnectrec; + tcConnectptr.p->tcBlockref = tcConnectptr.p->clientBlockref; + tcConnectptr.p->errorCode = 0; + tcConnectptr.p->reclenAiLqhkey = 0; + tcConnectptr.p->abortState = TcConnectionrec::ABORT_IDLE; + tcConnectptr.p->nextReplica = nodeId; + tcConnectptr.p->currTupAiLen = 0; + tcConnectptr.p->opExec = 1; + tcConnectptr.p->operation = ZREAD; + tcConnectptr.p->listState = TcConnectionrec::NOT_IN_LIST; + + tabptr.p->usageCount++; +}//Dblqh::initScanTc() + +/* ========================================================================= + * ======= FINISH SCAN RECORD ======= + * + * REMOVE SCAN RECORD FROM PER FRAGMENT LIST. + * ========================================================================= */ +void Dblqh::finishScanrec(Signal* signal) +{ + if (! scanptr.p->rangeScan) { + ndbrequire(scanptr.p->scanNumber < NR_ScanNo); + fragptr.p->fragScanRec[scanptr.p->scanNumber] = ZNIL; + } else { + jam(); + ndbrequire(NR_MinRangeScanNo <= scanptr.p->scanNumber && scanptr.p->scanNumber < NR_MaxRangeScanNo); + FragrecordPtr tFragPtr; + tFragPtr.i = fragptr.p->tableFragptr; + ptrCheckGuard(tFragPtr, cfragrecFileSize, fragrecord); + tFragPtr.p->fragScanRec[scanptr.p->scanNumber] = ZNIL; + } +}//Dblqh::finishScanrec() + +/* ========================================================================= + * ======= RELEASE SCAN RECORD ======= + * + * RELEASE A SCAN RECORD TO THE FREELIST. + * ========================================================================= */ +void Dblqh::releaseScanrec(Signal* signal) +{ + scanptr.p->nextScanrec = cfirstfreeScanrec; + cfirstfreeScanrec = scanptr.i; + scanptr.p->scanState = ScanRecord::SCAN_FREE; + scanptr.p->scanType = ScanRecord::ST_IDLE; + scanptr.p->scanTcWaiting = ZFALSE; + cbookedAccOps -= scanptr.p->scanConcurrentOperations; + cscanNoFreeRec++; +}//Dblqh::releaseScanrec() + +/* ========================================================================= + * ======= SEIZE SCAN RECORD ======= + * + * GETS A NEW SCAN RECORD FROM FREELIST. + * ========================================================================= */ +void Dblqh::seizeScanrec(Signal* signal) +{ + scanptr.i = cfirstfreeScanrec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + cfirstfreeScanrec = scanptr.p->nextScanrec; + scanptr.p->nextScanrec = RNIL; + cscanNoFreeRec--; +}//Dblqh::seizeScanrec() + +/* ------------------------------------------------------------------------ + * ------- SEND KEYINFO20 TO API ------- + * + * ------------------------------------------------------------------------ */ +void Dblqh::sendKeyinfo20(Signal* signal, + ScanRecord * scanP, + TcConnectionrec * tcConP) +{ + ndbrequire(scanP->scanCompletedOperations < MAX_PARALLEL_OP_PER_SCAN); + KeyInfo20 * keyInfo = (KeyInfo20 *)&signal->theData[0]; + + const Uint32 scanOp = scanP->scanCompletedOperations; + keyInfo->clientOpPtr = scanP->scanApiOpPtr[scanOp]; + keyInfo->keyLen = tcConP->primKeyLen; + keyInfo->scanInfo_Node = KeyInfo20::setScanInfo(scanOp, + scanP->scanNumber)+ + (getOwnNodeId() << 16); + + keyInfo->transId1 = tcConP->transid[0]; + keyInfo->transId2 = tcConP->transid[1]; + + const BlockReference ref = scanP->scanApiBlockref; + const Uint32 keyLen = tcConP->primKeyLen; + if(refToNode(ref) == getOwnNodeId()){ + jam(); + EXECUTE_DIRECT(refToBlock(ref), GSN_KEYINFO20, signal, 5 + keyLen); + jamEntry(); + return; + } + + bool connectedToNode = getNodeInfo(refToNode(ref)).m_connected; + + if (ERROR_INSERTED(5029)){ + // Use error insert to turn routing on + jam(); + connectedToNode = false; + } + + if (connectedToNode){ + jam(); + Uint32 keyLenLeft = keyLen; + Uint32 keyDataIndex = 20; + for(; keyLenLeft > 20; keyLenLeft -= 20, keyDataIndex += 20){ + jam(); + sendSignal(ref, GSN_KEYINFO20, signal, 25, JBB); + for(Uint32 i = 0; i<20; i++) + keyInfo->keyData[i] = keyInfo->keyData[keyDataIndex + i]; + }//for + sendSignal(ref, GSN_KEYINFO20, signal, 5 + keyLenLeft, JBB); + } else { + /** + * If this node does not have a direct connection + * to the receiving node we want to send the signals + * routed via the control node + */ + jam(); + Uint32 keyLenLeft = keyLen; + Uint32 keyDataIndex = 19; + BlockReference routeBlockref = tcConP->clientBlockref; + + for(; keyLenLeft > 19; keyLenLeft -= 19, keyDataIndex += 19){ + jam(); + // store final destination, but save original value + Uint32 saveOne = keyInfo->keyData[19]; + keyInfo->keyData[19] = ref; + sendSignal(routeBlockref, GSN_KEYINFO20_R, signal, 25, JBB); + keyInfo->keyData[19] = saveOne; + for(Uint32 i = 0; i<19; i++){ + keyInfo->keyData[i] = keyInfo->keyData[keyDataIndex + i]; + } + }//for + keyInfo->keyData[keyLenLeft] = ref; + sendSignal(routeBlockref, GSN_KEYINFO20_R, signal, 5 + keyLenLeft + 1, JBB); + } + +}//Dblqh::sendKeyinfo20() + +/* ------------------------------------------------------------------------ + * ------- SEND SCAN_FRAGCONF TO TC THAT CONTROLS THE SCAN ------- + * + * ------------------------------------------------------------------------ */ +void Dblqh::sendScanFragConf(Signal* signal, Uint32 scanCompleted) +{ + scanptr.p->scanSearchCondFalseCount = 0; + scanptr.p->scanTcWaiting = ZFALSE; + ScanFragConf * conf = (ScanFragConf*)&signal->theData[0]; + + conf->senderData = tcConnectptr.p->clientConnectrec; + conf->completedOps = scanptr.p->scanCompletedOperations; + conf->fragmentCompleted = scanCompleted; + for(Uint32 i = 0; iopReturnDataLen[i] = scanptr.p->scanOpLength[i]; + conf->transId1 = tcConnectptr.p->transid[0]; + conf->transId2 = tcConnectptr.p->transid[1]; + sendSignal(tcConnectptr.p->clientBlockref, GSN_SCAN_FRAGCONF, + signal, ScanFragConf::SignalLength, JBB); +}//Dblqh::sendScanFragConf() + +/* ######################################################################### */ +/* ####### NODE RECOVERY MODULE ####### */ +/* */ +/* ######################################################################### */ +/*---------------------------------------------------------------------------*/ +/* */ +/* THIS MODULE IS USED WHEN A NODE HAS FAILED. IT PERFORMS A COPY OF A */ +/* FRAGMENT TO A NEW REPLICA OF THE FRAGMENT. IT DOES ALSO SHUT DOWN ALL */ +/* CONNECTIONS TO THE FAILED NODE. */ +/*---------------------------------------------------------------------------*/ +void Dblqh::calculateHash(Signal* signal) +{ + DatabufPtr locDatabufptr; + UintR Ti; + UintR Tdata0; + UintR Tdata1; + UintR Tdata2; + UintR Tdata3; + UintR* Tdata32; + Uint64 Tdata[512]; + + Tdata32 = (UintR*)&Tdata[0]; + + Tdata0 = tcConnectptr.p->tupkeyData[0]; + Tdata1 = tcConnectptr.p->tupkeyData[1]; + Tdata2 = tcConnectptr.p->tupkeyData[2]; + Tdata3 = tcConnectptr.p->tupkeyData[3]; + Tdata32[0] = Tdata0; + Tdata32[1] = Tdata1; + Tdata32[2] = Tdata2; + Tdata32[3] = Tdata3; + locDatabufptr.i = tcConnectptr.p->firstTupkeybuf; + Ti = 4; + while (locDatabufptr.i != RNIL) { + ptrCheckGuard(locDatabufptr, cdatabufFileSize, databuf); + Tdata0 = locDatabufptr.p->data[0]; + Tdata1 = locDatabufptr.p->data[1]; + Tdata2 = locDatabufptr.p->data[2]; + Tdata3 = locDatabufptr.p->data[3]; + Tdata32[Ti ] = Tdata0; + Tdata32[Ti + 1] = Tdata1; + Tdata32[Ti + 2] = Tdata2; + Tdata32[Ti + 3] = Tdata3; + locDatabufptr.i = locDatabufptr.p->nextDatabuf; + Ti += 4; + }//while + tcConnectptr.p->hashValue = + md5_hash((Uint64*)&Tdata32[0], (UintR)tcConnectptr.p->primKeyLen); +}//Dblqh::calculateHash() + +/* *************************************** */ +/* COPY_FRAGREQ: Start copying a fragment */ +/* *************************************** */ +void Dblqh::execCOPY_FRAGREQ(Signal* signal) +{ + jamEntry(); + const CopyFragReq * const copyFragReq = (CopyFragReq *)&signal->theData[0]; + tabptr.i = copyFragReq->tableId; + ptrCheckGuard(tabptr, ctabrecFileSize, tablerec); + const Uint32 fragId = copyFragReq->fragId; + const Uint32 copyPtr = copyFragReq->userPtr; + const Uint32 userRef = copyFragReq->userRef; + const Uint32 nodeId = copyFragReq->nodeId; + + ndbrequire(cnoActiveCopy < 3); + ndbrequire(getFragmentrec(signal, fragId)); + ndbrequire(fragptr.p->copyFragState == ZIDLE); + ndbrequire(fragptr.p->noActiveScan < MAX_PARALLEL_SCANS_PER_FRAG); + ndbrequire(cfirstfreeScanrec != RNIL); + ndbrequire(cfirstfreeTcConrec != RNIL); + ndbrequire(fragptr.p->fragScanRec[NR_ScanNo] == ZNIL); + + fragptr.p->fragDistributionKey = copyFragReq->distributionKey; + + if (DictTabInfo::isOrderedIndex(tabptr.p->tableType)) { + jam(); + /** + * Ordered index doesn't need to be copied + */ + CopyFragConf * const conf = (CopyFragConf *)&signal->theData[0]; + conf->userPtr = copyPtr; + conf->sendingNodeId = cownNodeid; + conf->startingNodeId = nodeId; + conf->tableId = tabptr.i; + conf->fragId = fragId; + sendSignal(userRef, GSN_COPY_FRAGCONF, signal, + CopyFragConf::SignalLength, JBB); + return; + }//if + + seizeScanrec(signal); +/* ------------------------------------------------------------------------- */ +// We keep track of how many operation records in ACC that has been booked. +// Copy fragment has records always booked and thus need not book any. The +// most operations in parallel use is the scanConcurrentOperations. +// This variable has to be set-up here since it is used by releaseScanrec +// to unbook operation records in ACC. +/* ------------------------------------------------------------------------- */ + scanptr.p->scanConcurrentOperations = 0; + scanptr.p->rangeScan = 0; + seizeTcrec(); + + /** + * Remove implicit cast/usage of CopyFragReq + */ + //initCopyrec(signal); + scanptr.p->copyPtr = copyPtr; + scanptr.p->scanType = ScanRecord::COPY; + scanptr.p->scanApiBlockref = userRef; + scanptr.p->scanNodeId = nodeId; + scanptr.p->scanTcrec = tcConnectptr.i; + scanptr.p->scanSchemaVersion = copyFragReq->schemaVersion; + scanptr.p->scanCompletedStatus = ZFALSE; + scanptr.p->scanErrorCounter = 0; + scanptr.p->scanNumber = NR_ScanNo; + fragptr.p->fragScanRec[NR_ScanNo] = scanptr.i; + fragptr.p->noActiveScan++; + + initScanTc(signal, + 0, + (DBLQH << 20) + (cownNodeid << 8), + fragId, + copyFragReq->nodeId); + cactiveCopy[cnoActiveCopy] = fragptr.i; + cnoActiveCopy++; + + tcConnectptr.p->copyCountWords = 0; + tcConnectptr.p->tcOprec = tcConnectptr.i; + tcConnectptr.p->schemaVersion = scanptr.p->scanSchemaVersion; + scanptr.p->scanState = ScanRecord::WAIT_ACC_COPY; + AccScanReq * req = (AccScanReq*)&signal->theData[0]; + req->senderData = scanptr.i; + req->senderRef = cownref; + req->tableId = tabptr.i; + req->fragmentNo = fragId; + req->requestInfo = 0; + AccScanReq::setLockMode(req->requestInfo, 0); + AccScanReq::setKeyinfoFlag(req->requestInfo, 1); + AccScanReq::setReadCommittedFlag(req->requestInfo, 0); + req->transId1 = tcConnectptr.p->transid[0]; + req->transId2 = tcConnectptr.p->transid[1]; + req->savePointId = tcConnectptr.p->savePointId; + sendSignal(tcConnectptr.p->tcAccBlockref, GSN_ACC_SCANREQ, signal, + AccScanReq::SignalLength, JBB); + return; +}//Dblqh::execCOPY_FRAGREQ() + +void Dblqh::accScanConfCopyLab(Signal* signal) +{ + AccScanConf * const accScanConf = (AccScanConf *)&signal->theData[0]; + tcConnectptr.i = scanptr.p->scanTcrec; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); +/*--------------------------------------------------------------------------*/ +/* PRECONDITION: SCAN_STATE = WAIT_ACC_COPY */ +/*--------------------------------------------------------------------------*/ + if (accScanConf->flag == AccScanConf::ZEMPTY_FRAGMENT) { + jam(); +/*---------------------------------------------------------------------------*/ +/* THE FRAGMENT WAS EMPTY. */ +/* REPORT SUCCESSFUL COPYING. */ +/*---------------------------------------------------------------------------*/ + tupCopyCloseConfLab(signal); + return; + }//if + scanptr.p->scanAccPtr = accScanConf->accPtr; + scanptr.p->scanState = ScanRecord::WAIT_STORED_PROC_COPY; + signal->theData[0] = tcConnectptr.p->tupConnectrec; + signal->theData[1] = tcConnectptr.p->tableref; + signal->theData[2] = scanptr.p->scanSchemaVersion; + signal->theData[3] = ZSTORED_PROC_COPY; +// theData[4] is not used in TUP with ZSTORED_PROC_COPY + sendSignal(tcConnectptr.p->tcTupBlockref, GSN_STORED_PROCREQ, signal, 5, JBB); + return; +}//Dblqh::accScanConfCopyLab() + +/*---------------------------------------------------------------------------*/ +/* ENTER STORED_PROCCONF WITH */ +/* TC_CONNECTPTR, */ +/* TSTORED_PROC_ID */ +/*---------------------------------------------------------------------------*/ +void Dblqh::storedProcConfCopyLab(Signal* signal) +{ +/*---------------------------------------------------------------------------*/ +/* PRECONDITION: SCAN_STATE = WAIT_STORED_PROC_COPY */ +/*---------------------------------------------------------------------------*/ + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if (scanptr.p->scanCompletedStatus == ZTRUE) { + jam(); +/*---------------------------------------------------------------------------*/ +/* THE COPY PROCESS HAVE BEEN COMPLETED, MOST LIKELY DUE TO A NODE FAILURE.*/ +/*---------------------------------------------------------------------------*/ + closeCopyLab(signal); + return; + }//if + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + scanptr.p->scanState = ScanRecord::WAIT_NEXT_SCAN_COPY; + switch (fragptr.p->fragStatus) { + case Fragrecord::FSACTIVE: + jam(); + linkActiveFrag(signal); + break; + case Fragrecord::BLOCKED: + jam(); + linkFragQueue(signal); + tcConnectptr.p->transactionState = TcConnectionrec::COPY_FIRST_STOPPED; + return; + break; + case Fragrecord::FREE: + jam(); + case Fragrecord::ACTIVE_CREATION: + jam(); + case Fragrecord::CRASH_RECOVERING: + jam(); + case Fragrecord::DEFINED: + jam(); + case Fragrecord::REMOVING: + jam(); + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch + continueFirstCopyAfterBlockedLab(signal); + return; +}//Dblqh::storedProcConfCopyLab() + +void Dblqh::continueFirstCopyAfterBlockedLab(Signal* signal) +{ + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + signal->theData[0] = scanptr.p->scanAccPtr; + signal->theData[1] = RNIL; + signal->theData[2] = NextScanReq::ZSCAN_NEXT; + sendSignal(tcConnectptr.p->tcAccBlockref, GSN_NEXT_SCANREQ, signal, 3, JBB); + return; +}//Dblqh::continueFirstCopyAfterBlockedLab() + +/*---------------------------------------------------------------------------*/ +/* ENTER NEXT_SCANCONF WITH */ +/* SCANPTR, */ +/* TFRAGID, */ +/* TACC_OPPTR, */ +/* TLOCAL_KEY1, */ +/* TLOCAL_KEY2, */ +/* TKEY_LENGTH, */ +/* TKEY1, */ +/* TKEY2, */ +/* TKEY3, */ +/* TKEY4 */ +/*---------------------------------------------------------------------------*/ +/* PRECONDITION: SCAN_STATE = WAIT_NEXT_SCAN_COPY */ +/*---------------------------------------------------------------------------*/ +void Dblqh::nextScanConfCopyLab(Signal* signal) +{ + NextScanConf * const nextScanConf = (NextScanConf *)&signal->theData[0]; + tcConnectptr.i = scanptr.p->scanTcrec; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + if (nextScanConf->fragId == RNIL) { + jam(); +/*---------------------------------------------------------------------------*/ +/* THERE ARE NO MORE TUPLES TO FETCH. WE NEED TO CLOSE */ +/* THE COPY IN ACC AND DELETE THE STORED PROCEDURE IN TUP */ +/*---------------------------------------------------------------------------*/ + releaseActiveFrag(signal); + if (tcConnectptr.p->copyCountWords == 0) { + closeCopyLab(signal); + return; + }//if +/*---------------------------------------------------------------------------*/ +// Wait until copying is completed also at the starting node before reporting +// completion. Signal completion through scanCompletedStatus-flag. +/*---------------------------------------------------------------------------*/ + scanptr.p->scanCompletedStatus = ZTRUE; + return; + }//if + + // If accOperationPtr == RNIL no record was returned by ACC + if (nextScanConf->accOperationPtr == RNIL) { + jam(); + signal->theData[0] = scanptr.p->scanAccPtr; + signal->theData[1] = AccCheckScan::ZCHECK_LCP_STOP; + sendSignal(tcConnectptr.p->tcAccBlockref, GSN_ACC_CHECK_SCAN, signal, 2, JBB); + return; + } + + scanptr.p->scanAccOpPtr[0] = nextScanConf->accOperationPtr; + initCopyTc(signal); + if (tcConnectptr.p->primKeyLen > 4) { + jam(); + tcConnectptr.p->save1 = 4; + scanptr.p->scanState = ScanRecord::WAIT_COPY_KEYINFO; + return; + }//if + copySendTupkeyReqLab(signal); + return; +}//Dblqh::nextScanConfCopyLab() + +void Dblqh::copySendTupkeyReqLab(Signal* signal) +{ + Uint32 reqinfo = 0; + Uint32 tupFragPtr; + + reqinfo = reqinfo + (tcConnectptr.p->operation << 6); + reqinfo = reqinfo + (tcConnectptr.p->opExec << 10); + tcConnectptr.p->transactionState = TcConnectionrec::COPY_TUPKEY; + scanptr.p->scanState = ScanRecord::WAIT_TUPKEY_COPY; + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if (fragptr.p->fragId == scanptr.p->scanLocalFragid) { + jam(); + tupFragPtr = fragptr.p->tupFragptr[0]; + } else { + jam(); + tupFragPtr = fragptr.p->tupFragptr[1]; + }//if + { + TupKeyReq * const tupKeyReq = (TupKeyReq *)signal->getDataPtrSend(); + + tupKeyReq->connectPtr = tcConnectptr.p->tupConnectrec; + tupKeyReq->request = reqinfo; + tupKeyReq->tableRef = tcConnectptr.p->tableref; + tupKeyReq->fragId = scanptr.p->scanLocalFragid; + tupKeyReq->keyRef1 = scanptr.p->scanLocalref[0]; + tupKeyReq->keyRef2 = scanptr.p->scanLocalref[1]; + tupKeyReq->attrBufLen = 0; + tupKeyReq->opRef = tcConnectptr.i; + tupKeyReq->applRef = cownref; + tupKeyReq->schemaVersion = scanptr.p->scanSchemaVersion; + tupKeyReq->storedProcedure = scanptr.p->scanStoredProcId; + tupKeyReq->transId1 = tcConnectptr.p->transid[0]; + tupKeyReq->transId2 = tcConnectptr.p->transid[1]; + tupKeyReq->fragPtr = tupFragPtr; + tupKeyReq->primaryReplica = (tcConnectptr.p->seqNoReplica == 0)?true:false; + tupKeyReq->coordinatorTC = tcConnectptr.p->tcBlockref; + tupKeyReq->tcOpIndex = tcConnectptr.p->tcOprec; + tupKeyReq->savePointId = tcConnectptr.p->savePointId; + Uint32 blockNo = refToBlock(tcConnectptr.p->tcTupBlockref); + EXECUTE_DIRECT(blockNo, GSN_TUPKEYREQ, signal, + TupKeyReq::SignalLength); + } +}//Dblqh::copySendTupkeyReqLab() + +/*---------------------------------------------------------------------------*/ +/* USED IN COPYING OPERATION TO RECEIVE ATTRINFO FROM TUP. */ +/*---------------------------------------------------------------------------*/ +/* ************>> */ +/* TRANSID_AI > */ +/* ************>> */ +void Dblqh::execTRANSID_AI(Signal* signal) +{ + jamEntry(); + tcConnectptr.i = signal->theData[0]; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + Uint32 length = signal->length() - 3; + ndbrequire(tcConnectptr.p->transactionState == TcConnectionrec::COPY_TUPKEY); + Uint32 * src = &signal->theData[3]; + while(length > 22){ + if (saveTupattrbuf(signal, &signal->theData[3], 22) == ZOK) { + ; + } else { + jam(); + tcConnectptr.p->errorCode = ZGET_ATTRINBUF_ERROR; + return; + }//if + src += 22; + length -= 22; + } + if (saveTupattrbuf(signal, src, length) == ZOK) { + return; + } + jam(); + tcConnectptr.p->errorCode = ZGET_ATTRINBUF_ERROR; +}//Dblqh::execTRANSID_AI() + +/*--------------------------------------------------------------------------*/ +/* ENTER TUPKEYCONF WITH */ +/* TC_CONNECTPTR, */ +/* TDATA2, */ +/* TDATA3, */ +/* TDATA4, */ +/* TDATA5 */ +/*--------------------------------------------------------------------------*/ +/* PRECONDITION: TRANSACTION_STATE = COPY_TUPKEY */ +/*--------------------------------------------------------------------------*/ +void Dblqh::copyTupkeyConfLab(Signal* signal) +{ + const TupKeyConf * const tupKeyConf = (TupKeyConf *)signal->getDataPtr(); + + UintR readLength = tupKeyConf->readLength; + + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + releaseActiveFrag(signal); + if (tcConnectptr.p->errorCode != 0) { + jam(); + closeCopyLab(signal); + return; + }//if + if (scanptr.p->scanCompletedStatus == ZTRUE) { + jam(); +/*---------------------------------------------------------------------------*/ +/* THE COPY PROCESS HAVE BEEN CLOSED. MOST LIKELY A NODE FAILURE. */ +/*---------------------------------------------------------------------------*/ + closeCopyLab(signal); + return; + }//if + tcConnectptr.p->totSendlenAi = readLength; + tcConnectptr.p->connectState = TcConnectionrec::COPY_CONNECTED; + calculateHash(signal); +/*---------------------------------------------------------------------------*/ +// To avoid using up to many operation records in ACC we will increase the +// constant to ensure that we never send more than 40 records at a time. +// This is where the constant 56 comes from. For long records this constant +// will not matter that much. The current maximum is 6000 words outstanding +// (including a number of those 56 words not really sent). We also have to +// ensure that there are never more simultaneous usage of these operation +// records to ensure that node recovery does not fail because of simultaneous +// scanning. +/*---------------------------------------------------------------------------*/ + UintR TnoOfWords = readLength + tcConnectptr.p->primKeyLen; + TnoOfWords = TnoOfWords + MAGIC_CONSTANT; + TnoOfWords = TnoOfWords + (TnoOfWords >> 2); + + /*----------------------------------------------------------------- + * NOTE for transid1! + * Transid1 in the tcConnection record is used load regulate the + * copy(node recovery) process. + * The number of outstanding words are written in the transid1 + * variable. This will be sent to the starting node in the + * LQHKEYREQ signal and when the answer is returned in the LQHKEYCONF + * we can reduce the number of outstanding words and check to see + * if more LQHKEYREQ signals should be sent. + * + * However efficient this method is rather unsafe in such way that + * it overwrites the transid1 original data. + * + * Also see TR 587. + *----------------------------------------------------------------*/ + tcConnectptr.p->transid[0] = TnoOfWords; // Data overload, see note! + packLqhkeyreqLab(signal); + tcConnectptr.p->copyCountWords += TnoOfWords; + scanptr.p->scanState = ScanRecord::WAIT_LQHKEY_COPY; + if (tcConnectptr.p->copyCountWords < cmaxWordsAtNodeRec) { + nextRecordCopy(signal); + return; + }//if + return; +}//Dblqh::copyTupkeyConfLab() + +/*---------------------------------------------------------------------------*/ +/* ENTER LQHKEYCONF */ +/*---------------------------------------------------------------------------*/ +/* PRECONDITION: CONNECT_STATE = COPY_CONNECTED */ +/*---------------------------------------------------------------------------*/ +void Dblqh::copyCompletedLab(Signal* signal) +{ + const LqhKeyConf * const lqhKeyConf = (LqhKeyConf *)signal->getDataPtr(); + + ndbrequire(tcConnectptr.p->transid[1] == lqhKeyConf->transId2); + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + if (tcConnectptr.p->copyCountWords >= cmaxWordsAtNodeRec) { + tcConnectptr.p->copyCountWords -= lqhKeyConf->transId1; // Data overload, see note! + if (scanptr.p->scanCompletedStatus == ZTRUE) { + jam(); +/*---------------------------------------------------------------------------*/ +// Copy to complete, we will not start any new copying. +/*---------------------------------------------------------------------------*/ + closeCopyLab(signal); + return; + }//if + if (tcConnectptr.p->copyCountWords < cmaxWordsAtNodeRec) { + jam(); + nextRecordCopy(signal); + }//if + return; + }//if + tcConnectptr.p->copyCountWords -= lqhKeyConf->transId1; // Data overload, see note! + ndbrequire(tcConnectptr.p->copyCountWords <= cmaxWordsAtNodeRec); + if (tcConnectptr.p->copyCountWords > 0) { + jam(); + return; + }//if +/*---------------------------------------------------------------------------*/ +// No more outstanding copies. We will only start new ones from here if it was +// stopped before and this only happens when copyCountWords is bigger than the +// threshold value. Since this did not occur we must be waiting for completion. +// Check that this is so. If not we crash to find out what is going on. +/*---------------------------------------------------------------------------*/ + if (scanptr.p->scanCompletedStatus == ZTRUE) { + jam(); + closeCopyLab(signal); + return; + }//if + if (scanptr.p->scanState == ScanRecord::WAIT_LQHKEY_COPY) { + jam(); +/*---------------------------------------------------------------------------*/ +// Make sure that something is in progress. Otherwise we will simply stop +// and nothing more will happen. +/*---------------------------------------------------------------------------*/ + systemErrorLab(signal); + return; + }//if + return; +}//Dblqh::copyCompletedLab() + +void Dblqh::nextRecordCopy(Signal* signal) +{ + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + if (scanptr.p->scanState != ScanRecord::WAIT_LQHKEY_COPY) { + jam(); +/*---------------------------------------------------------------------------*/ +// Make sure that nothing is in progress. Otherwise we will have to simultaneous +// scans on the same record and this will certainly lead to unexpected +// behaviour. +/*---------------------------------------------------------------------------*/ + systemErrorLab(signal); + return; + }//if + scanptr.p->scanState = ScanRecord::WAIT_NEXT_SCAN_COPY; + switch (fragptr.p->fragStatus) { + case Fragrecord::FSACTIVE: + jam(); + linkActiveFrag(signal); + break; + case Fragrecord::BLOCKED: + jam(); + linkFragQueue(signal); + tcConnectptr.p->transactionState = TcConnectionrec::COPY_STOPPED; + return; + break; + case Fragrecord::FREE: + jam(); + case Fragrecord::ACTIVE_CREATION: + jam(); + case Fragrecord::CRASH_RECOVERING: + jam(); + case Fragrecord::DEFINED: + jam(); + case Fragrecord::REMOVING: + jam(); + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch + continueCopyAfterBlockedLab(signal); + return; +}//Dblqh::nextRecordCopy() + +void Dblqh::continueCopyAfterBlockedLab(Signal* signal) +{ + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + tcConnectptr.p->errorCode = 0; + signal->theData[0] = scanptr.p->scanAccPtr; + signal->theData[1] = scanptr.p->scanAccOpPtr[0]; + signal->theData[2] = NextScanReq::ZSCAN_NEXT_COMMIT; + sendSignal(tcConnectptr.p->tcAccBlockref, GSN_NEXT_SCANREQ, signal, 3, JBB); + return; +}//Dblqh::continueCopyAfterBlockedLab() + +void Dblqh::copyLqhKeyRefLab(Signal* signal) +{ + ndbrequire(tcConnectptr.p->transid[1] == signal->theData[4]); + tcConnectptr.p->copyCountWords -= signal->theData[3]; + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + scanptr.p->scanErrorCounter++; + tcConnectptr.p->errorCode = terrorCode; + closeCopyLab(signal); + return; +}//Dblqh::copyLqhKeyRefLab() + +void Dblqh::closeCopyLab(Signal* signal) +{ + if (tcConnectptr.p->copyCountWords > 0) { +/*---------------------------------------------------------------------------*/ +// We are still waiting for responses from the starting node. +// Wait until all of those have arrived until we start the +// close process. +/*---------------------------------------------------------------------------*/ + jam(); + return; + }//if + tcConnectptr.p->transid[0] = 0; + tcConnectptr.p->transid[1] = 0; + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + scanptr.p->scanState = ScanRecord::WAIT_CLOSE_COPY; + switch (fragptr.p->fragStatus) { + case Fragrecord::FSACTIVE: + jam(); + linkActiveFrag(signal); + break; + case Fragrecord::BLOCKED: + jam(); + linkFragQueue(signal); + tcConnectptr.p->transactionState = TcConnectionrec::COPY_CLOSE_STOPPED; + return; + break; + case Fragrecord::FREE: + jam(); + case Fragrecord::ACTIVE_CREATION: + jam(); + case Fragrecord::CRASH_RECOVERING: + jam(); + case Fragrecord::DEFINED: + jam(); + case Fragrecord::REMOVING: + jam(); + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch + continueCloseCopyAfterBlockedLab(signal); + return; +}//Dblqh::closeCopyLab() + +void Dblqh::continueCloseCopyAfterBlockedLab(Signal* signal) +{ + scanptr.i = tcConnectptr.p->tcScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + signal->theData[0] = scanptr.p->scanAccPtr; + signal->theData[1] = RNIL; + signal->theData[2] = ZCOPY_CLOSE; + sendSignal(tcConnectptr.p->tcAccBlockref, GSN_NEXT_SCANREQ, signal, 3, JBB); + return; +}//Dblqh::continueCloseCopyAfterBlockedLab() + +/*---------------------------------------------------------------------------*/ +/* ENTER NEXT_SCANCONF WITH */ +/* SCANPTR, */ +/* TFRAGID, */ +/* TACC_OPPTR, */ +/* TLOCAL_KEY1, */ +/* TLOCAL_KEY2, */ +/* TKEY_LENGTH, */ +/* TKEY1, */ +/* TKEY2, */ +/* TKEY3, */ +/* TKEY4 */ +/*---------------------------------------------------------------------------*/ +/* PRECONDITION: SCAN_STATE = WAIT_CLOSE_COPY */ +/*---------------------------------------------------------------------------*/ +void Dblqh::accCopyCloseConfLab(Signal* signal) +{ + tcConnectptr.i = scanptr.p->scanTcrec; + scanptr.p->scanState = ScanRecord::WAIT_DELETE_STORED_PROC_ID_COPY; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + signal->theData[0] = tcConnectptr.p->tupConnectrec; + signal->theData[1] = tcConnectptr.p->tableref; + signal->theData[2] = scanptr.p->scanSchemaVersion; + signal->theData[3] = ZDELETE_STORED_PROC_ID; + signal->theData[4] = scanptr.p->scanStoredProcId; + sendSignal(tcConnectptr.p->tcTupBlockref, GSN_STORED_PROCREQ, signal, 5, JBB); + return; +}//Dblqh::accCopyCloseConfLab() + +/*---------------------------------------------------------------------------*/ +/* ENTER STORED_PROCCONF WITH */ +/* TC_CONNECTPTR, */ +/* TSTORED_PROC_ID */ +/*---------------------------------------------------------------------------*/ +/* PRECONDITION: SCAN_STATE = WAIT_DELETE_STORED_PROC_ID_COPY */ +/*---------------------------------------------------------------------------*/ +void Dblqh::tupCopyCloseConfLab(Signal* signal) +{ + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if (tcConnectptr.p->abortState == TcConnectionrec::NEW_FROM_TC) { + jam(); + tcNodeFailptr.i = tcConnectptr.p->tcNodeFailrec; + ptrCheckGuard(tcNodeFailptr, ctcNodeFailrecFileSize, tcNodeFailRecord); + tcNodeFailptr.p->tcRecNow = tcConnectptr.i + 1; + signal->theData[0] = ZLQH_TRANS_NEXT; + signal->theData[1] = tcNodeFailptr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + + CopyFragRef * const ref = (CopyFragRef *)&signal->theData[0]; + ref->userPtr = scanptr.p->copyPtr; + ref->sendingNodeId = cownNodeid; + ref->startingNodeId = scanptr.p->scanNodeId; + ref->tableId = fragptr.p->tabRef; + ref->fragId = fragptr.p->fragId; + ref->errorCode = ZNODE_FAILURE_ERROR; + sendSignal(scanptr.p->scanApiBlockref, GSN_COPY_FRAGREF, signal, + CopyFragRef::SignalLength, JBB); + } else { + if (scanptr.p->scanErrorCounter > 0) { + jam(); + CopyFragRef * const ref = (CopyFragRef *)&signal->theData[0]; + ref->userPtr = scanptr.p->copyPtr; + ref->sendingNodeId = cownNodeid; + ref->startingNodeId = scanptr.p->scanNodeId; + ref->tableId = fragptr.p->tabRef; + ref->fragId = fragptr.p->fragId; + ref->errorCode = tcConnectptr.p->errorCode; + sendSignal(scanptr.p->scanApiBlockref, GSN_COPY_FRAGREF, signal, + CopyFragRef::SignalLength, JBB); + } else { + jam(); + CopyFragConf * const conf = (CopyFragConf *)&signal->theData[0]; + conf->userPtr = scanptr.p->copyPtr; + conf->sendingNodeId = cownNodeid; + conf->startingNodeId = scanptr.p->scanNodeId; + conf->tableId = tcConnectptr.p->tableref; + conf->fragId = tcConnectptr.p->fragmentid; + sendSignal(scanptr.p->scanApiBlockref, GSN_COPY_FRAGCONF, signal, + CopyFragConf::SignalLength, JBB); + }//if + }//if + releaseActiveCopy(signal); + tcConnectptr.p->tcScanRec = RNIL; + ndbrequire(scanptr.p->scanNumber < MAX_PARALLEL_SCANS_PER_FRAG); + fragptr.p->fragScanRec[scanptr.p->scanNumber] = ZNIL; + ndbrequire(fragptr.p->noActiveScan > 0); + fragptr.p->noActiveScan--; + fragptr.p->copyFragState = ZIDLE; + releaseOprec(signal); + releaseTcrec(signal, tcConnectptr); + releaseScanrec(signal); +}//Dblqh::tupCopyCloseConfLab() + +/*---------------------------------------------------------------------------*/ +/* A NODE FAILURE OCCURRED DURING THE COPY PROCESS. WE NEED TO CLOSE THE */ +/* COPY PROCESS SINCE A NODE FAILURE DURING THE COPY PROCESS WILL ALSO */ +/* FAIL THE NODE THAT IS TRYING TO START-UP. */ +/*---------------------------------------------------------------------------*/ +void Dblqh::closeCopyRequestLab(Signal* signal) +{ + scanptr.p->scanErrorCounter++; + switch (scanptr.p->scanState) { + case ScanRecord::WAIT_TUPKEY_COPY: + case ScanRecord::WAIT_COPY_KEYINFO: + case ScanRecord::WAIT_NEXT_SCAN_COPY: + jam(); +/*---------------------------------------------------------------------------*/ +/* SET COMPLETION STATUS AND WAIT FOR OPPORTUNITY TO STOP THE SCAN. */ +// ALSO SET NO OF WORDS OUTSTANDING TO ZERO TO AVOID ETERNAL WAIT. +/*---------------------------------------------------------------------------*/ + scanptr.p->scanCompletedStatus = ZTRUE; + tcConnectptr.p->copyCountWords = 0; + break; + case ScanRecord::WAIT_ACC_COPY: + case ScanRecord::WAIT_STORED_PROC_COPY: + jam(); +/*---------------------------------------------------------------------------*/ +/* WE ARE CURRENTLY STARTING UP THE SCAN. SET COMPLETED STATUS AND WAIT FOR*/ +/* COMPLETION OF STARTUP. */ +/*---------------------------------------------------------------------------*/ + scanptr.p->scanCompletedStatus = ZTRUE; + break; + case ScanRecord::WAIT_CLOSE_COPY: + case ScanRecord::WAIT_DELETE_STORED_PROC_ID_COPY: + jam(); +/*---------------------------------------------------------------------------*/ +/* CLOSE IS ALREADY ONGOING. WE NEED NOT DO ANYTHING. */ +/*---------------------------------------------------------------------------*/ + break; + case ScanRecord::WAIT_LQHKEY_COPY: + jam(); +/*---------------------------------------------------------------------------*/ +/* WE ARE WAITING FOR THE FAILED NODE. THE NODE WILL NEVER COME BACK. */ +// WE NEED TO START THE FAILURE HANDLING IMMEDIATELY. +// ALSO SET NO OF WORDS OUTSTANDING TO ZERO TO AVOID ETERNAL WAIT. +/*---------------------------------------------------------------------------*/ + tcConnectptr.p->copyCountWords = 0; + closeCopyLab(signal); + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dblqh::closeCopyRequestLab() + +/* ****************************************************** */ +/* COPY_ACTIVEREQ: Change state of a fragment to ACTIVE. */ +/* ****************************************************** */ +void Dblqh::execCOPY_ACTIVEREQ(Signal* signal) +{ + CRASH_INSERTION(5026); + + const CopyActiveReq * const req = (CopyActiveReq *)&signal->theData[0]; + jamEntry(); + Uint32 masterPtr = req->userPtr; + BlockReference masterRef = req->userRef; + tabptr.i = req->tableId; + ptrCheckGuard(tabptr, ctabrecFileSize, tablerec); + Uint32 fragId = req->fragId; + ndbrequire(getFragmentrec(signal, fragId)); + + fragptr.p->fragDistributionKey = req->distributionKey; + + ndbrequire(cnoActiveCopy < 3); + cactiveCopy[cnoActiveCopy] = fragptr.i; + cnoActiveCopy++; + fragptr.p->masterBlockref = masterRef; + fragptr.p->masterPtr = masterPtr; + if (fragptr.p->fragStatus == Fragrecord::FSACTIVE) { + jam(); +/*------------------------------------------------------*/ +/* PROCESS HAVE ALREADY BEEN STARTED BY PREVIOUS */ +/* MASTER. WE HAVE ALREADY SET THE PROPER MASTER */ +/* BLOCK REFERENCE. */ +/*------------------------------------------------------*/ + if (fragptr.p->activeTcCounter == 0) { + jam(); +/*------------------------------------------------------*/ +/* PROCESS WAS EVEN COMPLETED. */ +/*------------------------------------------------------*/ + sendCopyActiveConf(signal, tabptr.i); + }//if + return; + }//if + fragptr.p->fragStatus = Fragrecord::FSACTIVE; + if (fragptr.p->lcpFlag == Fragrecord::LCP_STATE_TRUE) { + jam(); + fragptr.p->logFlag = Fragrecord::STATE_TRUE; + }//if + fragptr.p->activeTcCounter = 1; +/*------------------------------------------------------*/ +/* SET IT TO ONE TO ENSURE THAT IT IS NOT POSSIBLE*/ +/* TO DECREASE IT TO ZERO UNTIL WE HAVE COMPLETED */ +/* THE SCAN. */ +/*------------------------------------------------------*/ + signal->theData[0] = ZSCAN_TC_CONNECT; + signal->theData[1] = 0; + signal->theData[2] = tabptr.i; + signal->theData[3] = fragId; + sendSignal(cownref, GSN_CONTINUEB, signal, 4, JBB); + return; +}//Dblqh::execCOPY_ACTIVEREQ() + +void Dblqh::scanTcConnectLab(Signal* signal, Uint32 tstartTcConnect, Uint32 fragId) +{ + Uint32 tendTcConnect; + + ndbrequire(getFragmentrec(signal, fragId)); + if ((tstartTcConnect + 200) >= ctcConnectrecFileSize) { + jam(); + tendTcConnect = ctcConnectrecFileSize - 1; + } else { + jam(); + tendTcConnect = tstartTcConnect + 200; + }//if + for (tcConnectptr.i = tstartTcConnect; + tcConnectptr.i <= tendTcConnect; + tcConnectptr.i++) { + jam(); + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + if (tcConnectptr.p->transactionState != TcConnectionrec::IDLE) { + switch (tcConnectptr.p->logWriteState) { + case TcConnectionrec::NOT_WRITTEN: + jam(); + if (fragptr.i == tcConnectptr.p->fragmentptr) { + jam(); + fragptr.p->activeTcCounter = fragptr.p->activeTcCounter + 1; + tcConnectptr.p->logWriteState = TcConnectionrec::NOT_WRITTEN_WAIT; + }//if + break; + default: + jam(); + /*empty*/; + break; + }//switch + }//if + }//for + if (tendTcConnect < (ctcConnectrecFileSize - 1)) { + jam(); + signal->theData[0] = ZSCAN_TC_CONNECT; + signal->theData[1] = tendTcConnect + 1; + signal->theData[2] = tabptr.i; + signal->theData[3] = fragId; + sendSignal(cownref, GSN_CONTINUEB, signal, 4, JBB); + } else { + jam(); +/*------------------------------------------------------*/ +/* THE SCAN HAVE BEEN COMPLETED. WE CHECK IF ALL */ +/* OPERATIONS HAVE ALREADY BEEN COMPLETED. */ +/*------------------------------------------------------*/ + ndbrequire(fragptr.p->activeTcCounter > 0); + fragptr.p->activeTcCounter--; + if (fragptr.p->activeTcCounter == 0) { + jam(); +/*------------------------------------------------------*/ +/* SET START GLOBAL CHECKPOINT TO THE NEXT */ +/* CHECKPOINT WE HAVE NOT YET HEARD ANYTHING ABOUT*/ +/* THIS GCP WILL BE COMPLETELY COVERED BY THE LOG.*/ +/*------------------------------------------------------*/ + fragptr.p->startGci = cnewestGci + 1; + sendCopyActiveConf(signal, tabptr.i); + }//if + }//if + return; +}//Dblqh::scanTcConnectLab() + +/*---------------------------------------------------------------------------*/ +/* A NEW MASTER IS REQUESTING THE STATE IN LQH OF THE COPY FRAGMENT PARTS. */ +/*---------------------------------------------------------------------------*/ +/* ***************>> */ +/* COPY_STATEREQ > */ +/* ***************>> */ +void Dblqh::execCOPY_STATEREQ(Signal* signal) +{ + Uint32* dataPtr = &signal->theData[2]; + jamEntry(); + BlockReference tmasterBlockref = signal->theData[0]; + Uint32 tnoCopy = 0; + do { + jam(); + arrGuard(tnoCopy, 4); + fragptr.i = cactiveCopy[tnoCopy]; + if (fragptr.i == RNIL) { + jam(); + break; + }//if + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if (fragptr.p->copyFragState != ZIDLE) { + jam(); +/*---------------------------------------------------------------------------*/ +/* THIS FRAGMENT IS CURRENTLY ACTIVE IN COPYING THE FRAGMENT. */ +/*---------------------------------------------------------------------------*/ + scanptr.i = fragptr.p->fragScanRec[NR_ScanNo]; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + if (scanptr.p->scanCompletedStatus == ZTRUE) { + jam(); + dataPtr[3 + (tnoCopy << 2)] = ZCOPY_CLOSING; + } else { + jam(); + dataPtr[3 + (tnoCopy << 2)] = ZCOPY_ONGOING; + }//if + dataPtr[2 + (tnoCopy << 2)] = scanptr.p->scanSchemaVersion; + scanptr.p->scanApiBlockref = tmasterBlockref; + } else { + ndbrequire(fragptr.p->activeTcCounter != 0); +/*---------------------------------------------------------------------------*/ +/* COPY FRAGMENT IS COMPLETED AND WE ARE CURRENTLY GETTING THE STARTING */ +/* GCI OF THE NEW REPLICA OF THIS FRAGMENT. */ +/*---------------------------------------------------------------------------*/ + fragptr.p->masterBlockref = tmasterBlockref; + dataPtr[3 + (tnoCopy << 2)] = ZCOPY_ACTIVATION; + }//if + dataPtr[tnoCopy << 2] = fragptr.p->tabRef; + dataPtr[1 + (tnoCopy << 2)] = fragptr.p->fragId; + tnoCopy++; + } while (tnoCopy < cnoActiveCopy); + signal->theData[0] = cownNodeid; + signal->theData[1] = tnoCopy; + sendSignal(tmasterBlockref, GSN_COPY_STATECONF, signal, 18, JBB); + return; +}//Dblqh::execCOPY_STATEREQ() + +/* ========================================================================= */ +/* ======= INITIATE TC RECORD AT COPY FRAGMENT ======= */ +/* */ +/* SUBROUTINE SHORT NAME = ICT */ +/* ========================================================================= */ +void Dblqh::initCopyTc(Signal* signal) +{ + const NextScanConf * const nextScanConf = (NextScanConf *)&signal->theData[0]; + tcConnectptr.p->primKeyLen = nextScanConf->keyLength; + tcConnectptr.p->tupkeyData[0] = nextScanConf->key[0]; + tcConnectptr.p->tupkeyData[1] = nextScanConf->key[1]; + tcConnectptr.p->tupkeyData[2] = nextScanConf->key[2]; + tcConnectptr.p->tupkeyData[3] = nextScanConf->key[3]; + scanptr.p->scanLocalref[0] = nextScanConf->localKey[0]; + scanptr.p->scanLocalref[1] = nextScanConf->localKey[1]; + scanptr.p->scanLocalFragid = nextScanConf->fragId; + tcConnectptr.p->operation = ZREAD; + tcConnectptr.p->apiVersionNo = 0; + tcConnectptr.p->opExec = 0; /* NOT INTERPRETED MODE */ + tcConnectptr.p->schemaVersion = scanptr.p->scanSchemaVersion; + Uint32 reqinfo = 0; + LqhKeyReq::setKeyLen(reqinfo, nextScanConf->keyLength); + LqhKeyReq::setLockType(reqinfo, ZINSERT); + LqhKeyReq::setDirtyFlag(reqinfo, 1); + LqhKeyReq::setSimpleFlag(reqinfo, 1); + LqhKeyReq::setOperation(reqinfo, ZWRITE); + /* AILen in LQHKEYREQ IS ZERO */ + tcConnectptr.p->reqinfo = reqinfo; +/* ------------------------------------------------------------------------ */ +/* THE RECEIVING NODE WILL EXPECT THAT IT IS THE LAST NODE AND WILL */ +/* SEND COMPLETED AS THE RESPONSE SIGNAL SINCE DIRTY_OP BIT IS SET. */ +/* ------------------------------------------------------------------------ */ + tcConnectptr.p->nodeAfterNext[0] = ZNIL; + tcConnectptr.p->nodeAfterNext[1] = ZNIL; + tcConnectptr.p->tcBlockref = cownref; + tcConnectptr.p->readlenAi = 0; + tcConnectptr.p->storedProcId = ZNIL; + tcConnectptr.p->opExec = 0; + tcConnectptr.p->nextSeqNoReplica = 0; + tcConnectptr.p->dirtyOp = ZFALSE; + tcConnectptr.p->lastReplicaNo = 0; + tcConnectptr.p->currTupAiLen = 0; + tcConnectptr.p->tcTimer = cLqhTimeOutCount; +}//Dblqh::initCopyTc() + +/* ------------------------------------------------------------------------- */ +/* ------- SEND COPY_ACTIVECONF TO MASTER DIH ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dblqh::sendCopyActiveConf(Signal* signal, Uint32 tableId) +{ + releaseActiveCopy(signal); + CopyActiveConf * const conf = (CopyActiveConf *)&signal->theData[0]; + conf->userPtr = fragptr.p->masterPtr; + conf->tableId = tableId; + conf->fragId = fragptr.p->fragId; + conf->startingNodeId = cownNodeid; + conf->startGci = fragptr.p->startGci; + sendSignal(fragptr.p->masterBlockref, GSN_COPY_ACTIVECONF, signal, + CopyActiveConf::SignalLength, JBB); +}//Dblqh::sendCopyActiveConf() + +/* ########################################################################## + * ####### LOCAL CHECKPOINT MODULE ####### + * + * ########################################################################## + * -------------------------------------------------------------------------- + * THIS MODULE HANDLES THE EXECUTION AND CONTROL OF LOCAL CHECKPOINTS + * IT CONTROLS THE LOCAL CHECKPOINTS IN TUP AND ACC. IT DOES ALSO INTERACT + * WITH DIH TO CONTROL WHICH GLOBAL CHECKPOINTS THAT ARE RECOVERABLE + * ------------------------------------------------------------------------- */ +void Dblqh::execEMPTY_LCP_REQ(Signal* signal) +{ + jamEntry(); + CRASH_INSERTION(5008); + EmptyLcpReq * const emptyLcpOrd = (EmptyLcpReq*)&signal->theData[0]; + + lcpPtr.i = 0; + ptrAss(lcpPtr, lcpRecord); + + Uint32 nodeId = refToNode(emptyLcpOrd->senderRef); + + lcpPtr.p->m_EMPTY_LCP_REQ.set(nodeId); + lcpPtr.p->reportEmpty = true; + + if (lcpPtr.p->lcpState == LcpRecord::LCP_IDLE){ + jam(); + bool ok = false; + switch(clcpCompletedState){ + case LCP_IDLE: + ok = true; + sendEMPTY_LCP_CONF(signal, true); + break; + case LCP_RUNNING: + ok = true; + sendEMPTY_LCP_CONF(signal, false); + break; + case LCP_CLOSE_STARTED: + jam(); + case ACC_LCP_CLOSE_COMPLETED: + jam(); + case TUP_LCP_CLOSE_COMPLETED: + jam(); + ok = true; + break; + } + ndbrequire(ok); + + }//if + + return; +}//Dblqh::execEMPTY_LCPREQ() + +void Dblqh::execLCP_FRAG_ORD(Signal* signal) +{ + jamEntry(); + CRASH_INSERTION(5010); + LcpFragOrd * const lcpFragOrd = (LcpFragOrd *)&signal->theData[0]; + Uint32 lcpId = lcpFragOrd->lcpId; + + lcpPtr.i = 0; + ptrAss(lcpPtr, lcpRecord); + + lcpPtr.p->lastFragmentFlag = lcpFragOrd->lastFragmentFlag; + if (lcpFragOrd->lastFragmentFlag) { + jam(); + if (lcpPtr.p->lcpState == LcpRecord::LCP_IDLE) { + jam(); + /* ---------------------------------------------------------- + * NOW THE COMPLETE LOCAL CHECKPOINT ROUND IS COMPLETED. + * -------------------------------------------------------- */ + if (cnoOfFragsCheckpointed > 0) { + jam(); + completeLcpRoundLab(signal); + } else { + jam(); + sendLCP_COMPLETE_REP(signal, lcpId); + }//if + } + return; + }//if + tabptr.i = lcpFragOrd->tableId; + ptrCheckGuard(tabptr, ctabrecFileSize, tablerec); + + ndbrequire(tabptr.p->tableStatus == Tablerec::PREP_DROP_TABLE_ONGOING || + tabptr.p->tableStatus == Tablerec::PREP_DROP_TABLE_DONE || + tabptr.p->tableStatus == Tablerec::TABLE_DEFINED); + + ndbrequire(getFragmentrec(signal, lcpFragOrd->fragmentId)); + + lcpPtr.i = 0; + ptrAss(lcpPtr, lcpRecord); + ndbrequire(!lcpPtr.p->lcpQueued); + if (c_lcpId < lcpFragOrd->lcpId) { + jam(); + /** + * A new LCP + */ + c_lcpId = lcpFragOrd->lcpId; + ndbrequire(lcpPtr.p->lcpState == LcpRecord::LCP_IDLE); + setLogTail(signal, lcpFragOrd->keepGci); + ndbrequire(clcpCompletedState == LCP_IDLE); + clcpCompletedState = LCP_RUNNING; + }//if + cnoOfFragsCheckpointed++; + + if(tabptr.p->tableStatus == Tablerec::PREP_DROP_TABLE_DONE){ + jam(); + LcpRecord::FragOrd fragOrd; + fragOrd.fragPtrI = fragptr.i; + fragOrd.lcpFragOrd = * lcpFragOrd; + sendLCP_FRAG_REP(signal, fragOrd); + return; + } + + if (lcpPtr.p->lcpState != LcpRecord::LCP_IDLE) { + ndbrequire(lcpPtr.p->lcpQueued == false); + lcpPtr.p->lcpQueued = true; + lcpPtr.p->queuedFragment.fragPtrI = fragptr.i; + lcpPtr.p->queuedFragment.lcpFragOrd = * lcpFragOrd; + return; + }//if + + lcpPtr.p->currentFragment.fragPtrI = fragptr.i; + lcpPtr.p->currentFragment.lcpFragOrd = * lcpFragOrd; + + sendLCP_FRAGIDREQ(signal); +}//Dblqh::execLCP_FRAGORD() + +/* -------------------------------------------------------------------------- + * PRECONDITION: LCP_PTR:LCP_STATE = WAIT_FRAGID + * -------------------------------------------------------------------------- + * WE NOW HAVE THE LOCAL FRAGMENTS THAT THE LOCAL CHECKPOINT WILL USE. + * -------------------------------------------------------------------------- */ +void Dblqh::execLCP_FRAGIDCONF(Signal* signal) +{ + UintR Tfragid[4]; + + jamEntry(); + + lcpPtr.i = signal->theData[0]; + + Uint32 TaccPtr = signal->theData[1]; + Uint32 noLocfrag = signal->theData[2]; + Tfragid[0] = signal->theData[3]; + Tfragid[1] = signal->theData[4]; + + ptrCheckGuard(lcpPtr, clcpFileSize, lcpRecord); + ndbrequire(lcpPtr.p->lcpState == LcpRecord::LCP_WAIT_FRAGID); + /* ------------------------------------------------------------------------ + * NO ERROR CHECKING OF TNO_LOCFRAG VALUE. OUT OF BOUND WILL IMPLY THAT AN + * INDEX OUT OF RANGE WILL CAUSE A SYSTEM RESTART WHICH IS DESIRED. + * ------------------------------------------------------------------------ */ + lcpPtr.p->lcpAccptr = TaccPtr; + fragptr.i = lcpPtr.p->currentFragment.fragPtrI; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + ndbrequire(noLocfrag - 1 < 2); + for (Uint32 Tindex = 0; Tindex < noLocfrag; Tindex++) { + jam(); + Uint32 fragId = Tfragid[Tindex]; + /* ---------------------------------------------------------------------- + * THERE IS NO ERROR CHECKING ON PURPOSE. IT IS POSSIBLE TO CALCULATE HOW + * MANY LOCAL LCP RECORDS THERE SHOULD BE. IT SHOULD NEVER HAPPEN THAT + * THERE IS NO ONE FREE. IF THERE IS NO ONE IT WILL ALSO BE A POINTER + * OUT OF RANGE WHICH IS AN ERROR CODE IN ITSELF. REUSES ERROR HANDLING + * IN AXE VM. + * ---------------------------------------------------------------------- */ + seizeLcpLoc(signal); + initLcpLocAcc(signal, fragId); + seizeLcpLoc(signal); + initLcpLocTup(signal, fragId); + signal->theData[0] = lcpLocptr.i; + signal->theData[1] = cownref; + signal->theData[2] = lcpPtr.p->currentFragment.lcpFragOrd.tableId; + signal->theData[3] = lcpLocptr.p->locFragid; + signal->theData[4] = lcpPtr.p->currentFragment.lcpFragOrd.lcpNo; + signal->theData[5] = lcpPtr.p->currentFragment.lcpFragOrd.lcpId % MAX_LCP_STORED; + sendSignal(fragptr.p->tupBlockref, GSN_TUP_PREPLCPREQ, signal, 6, JBB); + }//for + lcpPtr.p->lcpState = LcpRecord::LCP_WAIT_TUP_PREPLCP; + return; +}//Dblqh::execLCP_FRAGIDCONF() + +/* -------------------------------------------------------------------------- + * PRECONDITION: LCP_LOCPTR:LCP_STATE = WAIT_TUPPREPLCP + * -------------------------------------------------------------------------- + * WE HAVE NOW PREPARED A LOCAL FRAGMENT IN TUP FOR LCP EXECUTION. + * -------------------------------------------------------------------------- */ +void Dblqh::execTUP_PREPLCPCONF(Signal* signal) +{ + UintR ttupPtr; + + jamEntry(); + lcpLocptr.i = signal->theData[0]; + ttupPtr = signal->theData[1]; + ptrCheckGuard(lcpLocptr, clcpLocrecFileSize, lcpLocRecord); + + lcpPtr.i = lcpLocptr.p->masterLcpRec; + ptrCheckGuard(lcpPtr, clcpFileSize, lcpRecord); + ndbrequire(lcpLocptr.p->lcpLocstate == LcpLocRecord::WAIT_TUP_PREPLCP); + + lcpLocptr.p->tupRef = ttupPtr; + lcpLocptr.p->lcpLocstate = LcpLocRecord::IDLE; + checkLcpTupprep(signal); + if (lcpPtr.p->lcpState != LcpRecord::LCP_WAIT_HOLDOPS) { + jam(); + return; + }//if + fragptr.i = lcpPtr.p->currentFragment.fragPtrI; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + lcpLocptr.i = lcpPtr.p->firstLcpLocAcc; + do { + jam(); + ptrCheckGuard(lcpLocptr, clcpLocrecFileSize, lcpLocRecord); + lcpLocptr.p->lcpLocstate = LcpLocRecord::WAIT_LCPHOLDOP; + signal->theData[0] = lcpPtr.p->lcpAccptr; + signal->theData[1] = lcpLocptr.p->locFragid; + signal->theData[2] = 0; + signal->theData[3] = lcpLocptr.i; + sendSignal(fragptr.p->accBlockref, GSN_LCP_HOLDOPREQ, signal, 4, JBA); + lcpLocptr.i = lcpLocptr.p->nextLcpLoc; + } while (lcpLocptr.i != RNIL); + /* ------------------------------------------------------------------------ + * SET STATE ON FRAGMENT TO BLOCKED TO ENSURE THAT NO MORE OPERATIONS ARE + * STARTED FROM LQH IN TUP AND ACC UNTIL THE START CHECKPOINT HAS BEEN + * COMPLETED. ALSO SET THE LOCAL CHECKPOINT STATE TO WAIT FOR + * LCP_HOLDOPCONF + * ----------------------------------------------------------------------- */ + fragptr.p->fragStatus = Fragrecord::BLOCKED; + fragptr.p->fragActiveStatus = ZTRUE; + lcpPtr.p->lcpState = LcpRecord::LCP_WAIT_HOLDOPS; + return; +}//Dblqh::execTUP_PREPLCPCONF() + +void Dblqh::execTUP_PREPLCPREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +}//Dblqh::execTUP_PREPLCPREF() + +void Dblqh::execLCP_FRAGIDREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +}//Dblqh::execLCP_FRAGIDREF() + +/* -------------------------------------------------------------------------- + * A NUMBER OF OPERATIONS THAT HAVE BEEN SET ON HOLD IN ACC. MOVE THOSE TO + * LIST OF BLOCKED ACC OPERATIONS. IF MORE OPERATIONS ARE BLOCKED GET THOSE + * OTHERWISE CONTINUE THE LOCAL CHECKPOINT BY REQUESTING TUP AND ACC TO + * WRITE THEIR START CHECKPOINT. + * -------------------------------------------------------------------------- + * PRECONDITION: LCP_LOCPTR:LCP_LOCSTATE = WAIT_LCPHOLDOP + * ------------------------------------------------------------------------- */ +/* ***************>> */ +/* LCP_HOLDOPCONF > */ +/* ***************>> */ +void Dblqh::execLCP_HOLDOPCONF(Signal* signal) +{ + UintR tnoHoldops; + Uint32 Tdata[23]; + Uint32 Tlength; + + jamEntry(); + lcpLocptr.i = signal->theData[0]; + Tlength = signal->theData[1]; + for (Uint32 i = 0; i < 23; i++) + Tdata[i] = signal->theData[i + 2]; + ptrCheckGuard(lcpLocptr, clcpLocrecFileSize, lcpLocRecord); + ndbrequire(lcpLocptr.p->lcpLocstate == LcpLocRecord::WAIT_LCPHOLDOP); + + lcpPtr.i = lcpLocptr.p->masterLcpRec; + /* ------------------------------------------------------------------------ + * NO ERROR CHECK ON USING VALUE IN MASTER_LCP_REC. ERROR IN THIS + * REFERENCE WILL CAUSE POINTER OUT OF RANGE WHICH CAUSES A SYSTEM RESTART. + * ----------------------------------------------------------------------- */ + tnoHoldops = Tlength & 65535; + ptrCheckGuard(lcpPtr, clcpFileSize, lcpRecord); + fragptr.i = lcpPtr.p->currentFragment.fragPtrI; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + ndbrequire(tnoHoldops <= 23); + for (Uint32 Tindex = 0; Tindex < tnoHoldops; Tindex++) { + jam(); + tcConnectptr.i = Tdata[Tindex]; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + moveActiveToAcc(signal); + }//for + if ((Tlength >> 16) == 1) { + jam(); + /* MORE HOLDOPS NEEDED */ + signal->theData[0] = lcpPtr.p->lcpAccptr; + signal->theData[1] = lcpLocptr.p->locFragid; + signal->theData[2] = 1; + signal->theData[3] = lcpLocptr.i; + sendSignal(fragptr.p->accBlockref, GSN_LCP_HOLDOPREQ, signal, 4, JBA); + return; + } else { + jam(); + /* NO MORE HOLDOPS NEEDED */ + lcpLocptr.p->lcpLocstate = LcpLocRecord::HOLDOP_READY; + checkLcpHoldop(signal); + if (lcpPtr.p->lcpState == LcpRecord::LCP_WAIT_ACTIVE_FINISH) { + if (fragptr.p->activeList == RNIL) { + jam(); + /* ------------------------------------------------------------------ + * THERE ARE NO MORE ACTIVE OPERATIONS. IT IS NOW OK TO START THE + * LOCAL CHECKPOINT IN BOTH TUP AND ACC. + * ----------------------------------------------------------------- */ + sendStartLcp(signal); + lcpPtr.p->lcpState = LcpRecord::LCP_START_CHKP; + } else { + jam(); + // Set this to signal releaseActiveFrag + // that it should check to see if itäs time to call sendStartLcp + fragptr.p->lcpRef = lcpPtr.i; + }//if + }//if + }//if + /* ----------------------- */ + /* ELSE */ + /* ------------------------------------------------------------------------ + * THERE ARE STILL MORE ACTIVE OPERATIONS. WAIT UNTIL THEY ARE FINSIHED. + * THIS IS DISCOVERED WHEN RELEASE_ACTIVE_FRAG IS EXECUTED. + * ------------------------------------------------------------------------ + * DO NOTHING, EXIT IS EXECUTED BELOW + * ----------------------------------------------------------------------- */ + return; +}//Dblqh::execLCP_HOLDOPCONF() + +/* ***************> */ +/* LCP_HOLDOPREF > */ +/* ***************> */ +void Dblqh::execLCP_HOLDOPREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +}//Dblqh::execLCP_HOLDOPREF() + +/* ************************************************************************>> + * ACC_LCPSTARTED: Confirm that ACC started local checkpoint and undo + * logging is on. + * ************************************************************************>> + * -------------------------------------------------------------------------- + * PRECONDITION: LCP_LOCPTR:LCP_LOCSTATE = ACC_WAIT_STARTED + * ------------------------------------------------------------------------- */ +void Dblqh::execACC_LCPSTARTED(Signal* signal) +{ + jamEntry(); + lcpLocptr.i = signal->theData[0]; + ptrCheckGuard(lcpLocptr, clcpLocrecFileSize, lcpLocRecord); + ndbrequire(lcpLocptr.p->lcpLocstate == LcpLocRecord::ACC_WAIT_STARTED); + + lcpPtr.i = lcpLocptr.p->masterLcpRec; + ptrCheckGuard(lcpPtr, clcpFileSize, lcpRecord); + /* ------------------------------------------------------------------------ + * NO ERROR CHECK ON USING VALUE IN MASTER_LCP_REC. ERROR IN THIS + * REFERENCE WILL CAUSE POINTER OUT OF RANGE WHICH CAUSES A SYSTEM RESTART. + * ----------------------------------------------------------------------- */ + lcpLocptr.p->lcpLocstate = LcpLocRecord::ACC_STARTED; + lcpStartedLab(signal); + return; +}//Dblqh::execACC_LCPSTARTED() + +/* ******************************************> */ +/* TUP_LCPSTARTED: Same as above but for TUP. */ +/* ******************************************> */ +/* -------------------------------------------------------------------------- + * PRECONDITION: LCP_LOCPTR:LCP_LOCSTATE = TUP_WAIT_STARTED + * ------------------------------------------------------------------------- */ +void Dblqh::execTUP_LCPSTARTED(Signal* signal) +{ + jamEntry(); + lcpLocptr.i = signal->theData[0]; + ptrCheckGuard(lcpLocptr, clcpLocrecFileSize, lcpLocRecord); + ndbrequire(lcpLocptr.p->lcpLocstate == LcpLocRecord::TUP_WAIT_STARTED); + + lcpPtr.i = lcpLocptr.p->masterLcpRec; + ptrCheckGuard(lcpPtr, clcpFileSize, lcpRecord); + /* ------------------------------------------------------------------------ + * NO ERROR CHECK ON USING VALUE IN MASTER_LCP_REC. ERROR IN THIS REFERENCE + * WILL CAUSE POINTER OUT OF RANGE WHICH CAUSES A SYSTEM RESTART. + * ----------------------------------------------------------------------- */ + lcpLocptr.p->lcpLocstate = LcpLocRecord::TUP_STARTED; + lcpStartedLab(signal); + return; +}//Dblqh::execTUP_LCPSTARTED() + +void Dblqh::lcpStartedLab(Signal* signal) +{ + checkLcpStarted(signal); + + if (lcpPtr.p->lcpState == LcpRecord::LCP_STARTED) { + jam(); + /* ---------------------------------------------------------------------- + * THE LOCAL CHECKPOINT HAS BEEN STARTED. IT IS NOW TIME TO + * RESTART THE TRANSACTIONS WHICH HAVE BEEN BLOCKED. + * --------------------------------------------------------------------- */ + fragptr.i = lcpPtr.p->currentFragment.fragPtrI; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + /* ---------------------------------------------------------------------- + * UPDATE THE MAX_GCI_IN_LCP AND MAX_GCI_COMPLETED_IN_LCP NOW BEFORE + * ACTIVATING THE FRAGMENT AGAIN. + * --------------------------------------------------------------------- */ + ndbrequire(lcpPtr.p->currentFragment.lcpFragOrd.lcpNo < MAX_LCP_STORED); + fragptr.p->maxGciInLcp = fragptr.p->newestGci; + fragptr.p->maxGciCompletedInLcp = cnewestCompletedGci; + sendAccContOp(signal); /* START OPERATIONS IN ACC */ + moveAccActiveFrag(signal); /* MOVE FROM ACC BLOCKED LIST TO ACTIVE LIST + ON FRAGMENT */ + }//if + /*---------------*/ + /* ELSE */ + /*-------------------------------------------------------------------------*/ + /* THE LOCAL CHECKPOINT HAS NOT BEEN STARTED. EXIT AND WAIT FOR + * MORE SIGNALS */ + /*-------------------------------------------------------------------------*/ + /* DO NOTHING, EXIT IS EXECUTED BELOW */ + /*-------------------------------------------------------------------------*/ + return; +}//Dblqh::lcpStartedLab() + +/*--------------------------------------------------------------------------- + * ACC HAVE RESTARTED THE BLOCKED OPERATIONS AGAIN IN ONE FRAGMENT PART. + * IT IS NOW OUR TURN TO RESTART ALL OPERATIONS QUEUED IN LQH IF ALL + * FRAGMENT PARTS ARE COMPLETED. + *-------------------------------------------------------------------------- */ +void Dblqh::execACC_CONTOPCONF(Signal* signal) +{ + jamEntry(); + lcpLocptr.i = signal->theData[0]; + ptrCheckGuard(lcpLocptr, clcpLocrecFileSize, lcpLocRecord); + lcpLocptr.p->accContCounter = 1; + + lcpPtr.i = lcpLocptr.p->masterLcpRec; + ptrCheckGuard(lcpPtr, clcpFileSize, lcpRecord); + lcpLocptr.i = lcpPtr.p->firstLcpLocAcc; + do { + ptrCheckGuard(lcpLocptr, clcpLocrecFileSize, lcpLocRecord); + if (lcpLocptr.p->accContCounter == 0) { + jam(); + return; + }//if + lcpLocptr.i = lcpLocptr.p->nextLcpLoc; + } while (lcpLocptr.i != RNIL); + fragptr.i = lcpPtr.p->currentFragment.fragPtrI; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + restartOperationsLab(signal); + return; +}//Dblqh::execACC_CONTOPCONF() + +/* ********************************************************* */ +/* LQH_RESTART_OP: Restart operations after beeing blocked. */ +/* ********************************************************* */ +/*---------------------------------------------------------------------------*/ +/* PRECONDITION: FRAG_STATUS = BLOCKED AND LCP_STATE = STARTED */ +/*---------------------------------------------------------------------------*/ +void Dblqh::execLQH_RESTART_OP(Signal* signal) +{ + jamEntry(); + fragptr.i = signal->theData[0]; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + + lcpPtr.i = signal->theData[1]; + ptrCheckGuard(lcpPtr, clcpFileSize, lcpRecord); + if (fragptr.p->fragStatus == Fragrecord::BLOCKED) { + if (lcpPtr.p->lcpState == LcpRecord::LCP_STARTED) { + jam(); + /***********************************************************************/ + /* THIS SIGNAL CAN ONLY BE RECEIVED WHEN FRAGMENT IS BLOCKED AND + * THE LOCAL CHECKPOINT HAS BEEN STARTED. THE BLOCKING WILL BE + * REMOVED AS SOON AS ALL OPERATIONS HAVE BEEN STARTED. + ***********************************************************************/ + restartOperationsLab(signal); + return; + } else { + jam(); + if (lcpPtr.p->lcpState == LcpRecord::LCP_BLOCKED_COMP) { + jam(); + /*******************************************************************> + * THE CHECKPOINT IS COMPLETED BUT HAS NOT YET STARTED UP + * ALL OPERATIONS AGAIN. + * WE PERFORM THIS START-UP BEFORE CONTINUING WITH THE NEXT + * FRAGMENT OF THE LOCAL CHECKPOINT TO AVOID ANY STRANGE ERRORS. + *******************************************************************> */ + restartOperationsLab(signal); + return; + }//if + }//if + }//if + ndbrequire(false); +}//Dblqh::execLQH_RESTART_OP() + +void Dblqh::restartOperationsLab(Signal* signal) +{ + Uint32 loopCount = 0; + tcConnectptr.i = fragptr.p->firstWaitQueue; + do { + if (tcConnectptr.i != RNIL) { + jam(); +/*---------------------------------------------------------------------------*/ +/* START UP THE TRANSACTION AGAIN. WE START IT AS A SEPARATE SIGNAL. */ +/*---------------------------------------------------------------------------*/ + signal->theData[0] = ZRESTART_OPERATIONS_AFTER_STOP; + signal->theData[1] = tcConnectptr.i; + signal->theData[2] = fragptr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB); + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + tcConnectptr.i = tcConnectptr.p->nextTc; + } else { + jam(); +/*--------------------------------------------------------------------------*/ +/* NO MORE OPERATIONS TO RESTART. WE CAN NOW RESET THE STATE TO ACTIVE AND */ +/* RESTART NORMAL ACTIVITIES ON THE FRAGMENT WHILE THE FUZZY PART OF THE */ +/* LOCAL CHECKPOINT IS COMPLETING. */ +/* IF THE CHECKPOINT WAS COMPLETED ALREADY ON THIS FRAGMENT WE PROCEED WITH */ +/* THE NEXT FRAGMENT NOW THAT WE HAVE COMPLETED THIS CHECKPOINT. */ +/*--------------------------------------------------------------------------*/ + fragptr.p->fragStatus = Fragrecord::FSACTIVE; + if (lcpPtr.p->lcpState == LcpRecord::LCP_BLOCKED_COMP) { + jam(); + contChkpNextFragLab(signal); + return; + }//if + return; + }//if + loopCount++; + if (loopCount > 16) { + jam(); + signal->theData[0] = fragptr.i; + signal->theData[1] = lcpPtr.i; + sendSignal(cownref, GSN_LQH_RESTART_OP, signal, 2, JBB); + return; + }//if + } while (1); +}//Dblqh::restartOperationsLab() + +void Dblqh::restartOperationsAfterStopLab(Signal* signal) +{ + /*------------------------------------------------------------------------- + * WHEN ARRIVING HERE THE OPERATION IS ALREADY SET IN THE ACTIVE LIST. + * THUS WE CAN IMMEDIATELY CALL THE METHODS THAT EXECUTE FROM WHERE + * THE OPERATION WAS STOPPED. + *------------------------------------------------------------------------- */ + switch (tcConnectptr.p->transactionState) { + case TcConnectionrec::STOPPED: + jam(); + /*----------------------------------------------------------------------- + * STOPPED BEFORE TRYING TO SEND ACCKEYREQ + *----------------------------------------------------------------------- */ + prepareContinueAfterBlockedLab(signal); + return; + break; + case TcConnectionrec::COMMIT_STOPPED: + jam(); + /* ---------------------------------------------------------------------- + * STOPPED BEFORE TRYING TO SEND ACC_COMMITREQ + * ---------------------------------------------------------------------- */ + releaseActiveFrag(signal); + commitContinueAfterBlockedLab(signal); + return; + break; + case TcConnectionrec::ABORT_STOPPED: + jam(); + /* ---------------------------------------------------------------------- + * STOPPED BEFORE TRYING TO SEND ACC_ABORTREQ + * ---------------------------------------------------------------------- */ + abortContinueAfterBlockedLab(signal, true); + return; + break; + case TcConnectionrec::COPY_STOPPED: + jam(); + /* ---------------------------------------------------------------------- + * STOPPED BEFORE TRYING TO SEND NEXT_SCANREQ DURING COPY FRAGMENT + * ---------------------------------------------------------------------- */ + continueCopyAfterBlockedLab(signal); + return; + break; + case TcConnectionrec::COPY_FIRST_STOPPED: + jam(); + /* ---------------------------------------------------------------------- + * STOPPED BEFORE TRYING TO SEND NEXT_SCANREQ DURING COPY FRAGMENT + * ---------------------------------------------------------------------- */ + continueFirstCopyAfterBlockedLab(signal); + return; + break; + case TcConnectionrec::SCAN_FIRST_STOPPED: + jam(); + /* ---------------------------------------------------------------------- + * STOPPED BEFORE TRYING TO SEND NEXT_SCANREQ DURING SCAN + * ---------------------------------------------------------------------- */ + tcConnectptr.p->transactionState = TcConnectionrec::SCAN_STATE_USED; + continueFirstScanAfterBlockedLab(signal); + return; + break; + case TcConnectionrec::SCAN_CHECK_STOPPED: + jam(); + /* ---------------------------------------------------------------------- + * STOPPED BEFORE TRYING TO SEND NEXT_SCANREQ DURING SCAN + * ---------------------------------------------------------------------- */ + tcConnectptr.p->transactionState = TcConnectionrec::SCAN_STATE_USED; + continueAfterCheckLcpStopBlocked(signal); + return; + break; + case TcConnectionrec::SCAN_STOPPED: + jam(); + /* ---------------------------------------------------------------------- + * STOPPED BEFORE TRYING TO SEND NEXT_SCANREQ DURING SCAN + * ---------------------------------------------------------------------- */ + tcConnectptr.p->transactionState = TcConnectionrec::SCAN_STATE_USED; + continueScanAfterBlockedLab(signal); + return; + break; + case TcConnectionrec::SCAN_RELEASE_STOPPED: + jam(); + /* ---------------------------------------------------------------------- + * STOPPED BEFORE TRYING TO SEND NEXT_SCANREQ DURING RELEASE + * LOCKS IN SCAN + * ---------------------------------------------------------------------- */ + tcConnectptr.p->transactionState = TcConnectionrec::SCAN_STATE_USED; + continueScanReleaseAfterBlockedLab(signal); + return; + break; + case TcConnectionrec::SCAN_CLOSE_STOPPED: + jam(); + /* ---------------------------------------------------------------------- + * STOPPED BEFORE TRYING TO SEND NEXT_SCANREQ DURING CLOSE OF SCAN + * ---------------------------------------------------------------------- */ + continueCloseScanAfterBlockedLab(signal); + return; + break; + case TcConnectionrec::COPY_CLOSE_STOPPED: + jam(); + /* ---------------------------------------------------------------------- + * STOPPED BEFORE TRYING TO SEND NEXT_SCANREQ DURING CLOSE OF COPY + * ---------------------------------------------------------------------- */ + continueCloseCopyAfterBlockedLab(signal); + return; + break; + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch +}//Dblqh::restartOperationsAfterStopLab() + +/* *************** */ +/* ACC_LCPCONF > */ +/* *************** */ +/*--------------------------------------------------------------------------- + * PRECONDITION: LCP_LOCPTR:LCP_LOCSTATE = ACC_STARTED + *-------------------------------------------------------------------------- */ +void Dblqh::execACC_LCPCONF(Signal* signal) +{ + jamEntry(); + lcpLocptr.i = signal->theData[0]; + ptrCheckGuard(lcpLocptr, clcpLocrecFileSize, lcpLocRecord); + ndbrequire(lcpLocptr.p->lcpLocstate == LcpLocRecord::ACC_STARTED); + + lcpPtr.i = lcpLocptr.p->masterLcpRec; + ptrCheckGuard(lcpPtr, clcpFileSize, lcpRecord); + /* ------------------------------------------------------------------------ + * NO ERROR CHECK ON USING VALUE IN MASTER_LCP_REC. ERROR IN + * THIS REFERENCE WILL CAUSE POINTER OUT OF RANGE WHICH CAUSES A + * SYSTEM RESTART. + * ----------------------------------------------------------------------- */ + lcpLocptr.p->lcpLocstate = LcpLocRecord::ACC_COMPLETED; + lcpCompletedLab(signal); + return; +}//Dblqh::execACC_LCPCONF() + +/* *************** */ +/* TUP_LCPCONF > */ +/* *************** */ +/* -------------------------------------------------------------------------- + * PRECONDITION: LCP_LOCPTR:LCP_LOCSTATE = TUP_STARTED + * ------------------------------------------------------------------------- */ +void Dblqh::execTUP_LCPCONF(Signal* signal) +{ + jamEntry(); + lcpLocptr.i = signal->theData[0]; + ptrCheckGuard(lcpLocptr, clcpLocrecFileSize, lcpLocRecord); + ndbrequire(lcpLocptr.p->lcpLocstate == LcpLocRecord::TUP_STARTED); + + lcpPtr.i = lcpLocptr.p->masterLcpRec; + ptrCheckGuard(lcpPtr, clcpFileSize, lcpRecord); + /* ------------------------------------------------------------------------ + * NO ERROR CHECK ON USING VALUE IN MASTER_LCP_REC. ERROR IN THIS + * REFERENCE WILL CAUSE POINTER OUT OF RANGE WHICH CAUSES A SYSTEM RESTART. + * ----------------------------------------------------------------------- */ + lcpLocptr.p->lcpLocstate = LcpLocRecord::TUP_COMPLETED; + lcpCompletedLab(signal); + return; +}//Dblqh::execTUP_LCPCONF() + +void Dblqh::lcpCompletedLab(Signal* signal) +{ + checkLcpCompleted(signal); + if (lcpPtr.p->lcpState != LcpRecord::LCP_COMPLETED) { + jam(); + /* ---------------------------------------------------------------------- + * THE LOCAL CHECKPOINT HAS NOT BEEN COMPLETED, EXIT & WAIT + * FOR MORE SIGNALS + * --------------------------------------------------------------------- */ + return; + }//if + /* ------------------------------------------------------------------------ + * THE LOCAL CHECKPOINT HAS BEEN COMPLETED. IT IS NOW TIME TO START + * A LOCAL CHECKPOINT ON THE NEXT FRAGMENT OR COMPLETE THIS LCP ROUND. + * ------------------------------------------------------------------------ + * WE START BY SENDING LCP_REPORT TO DIH TO REPORT THE COMPLETED LCP. + * TO CATER FOR NODE CRASHES WE SEND IT IN PARALLEL TO ALL NODES. + * ----------------------------------------------------------------------- */ + sendLCP_FRAG_REP(signal, lcpPtr.p->currentFragment); + + fragptr.i = lcpPtr.p->currentFragment.fragPtrI; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + fragptr.p->fragActiveStatus = ZFALSE; + + contChkpNextFragLab(signal); + return; +}//Dblqh::lcpCompletedLab() + +void +Dblqh::sendLCP_FRAG_REP(Signal * signal, + const LcpRecord::FragOrd & fragOrd) const { + + FragrecordPtr fragPtr; + fragPtr.i = fragOrd.fragPtrI; + ptrCheckGuard(fragPtr, cfragrecFileSize, fragrecord); + + ndbrequire(fragOrd.lcpFragOrd.lcpNo < MAX_LCP_STORED); + LcpFragRep * const lcpReport = (LcpFragRep *)&signal->theData[0]; + lcpReport->nodeId = cownNodeid; + lcpReport->lcpId = fragOrd.lcpFragOrd.lcpId; + lcpReport->lcpNo = fragOrd.lcpFragOrd.lcpNo; + lcpReport->tableId = fragOrd.lcpFragOrd.tableId; + lcpReport->fragId = fragOrd.lcpFragOrd.fragmentId; + lcpReport->maxGciCompleted = fragPtr.p->maxGciCompletedInLcp; + lcpReport->maxGciStarted = fragPtr.p->maxGciInLcp; + + for (Uint32 i = 0; i < cnoOfNodes; i++) { + jam(); + Uint32 nodeId = cnodeData[i]; + if(cnodeStatus[i] == ZNODE_UP){ + jam(); + BlockReference Tblockref = calcDihBlockRef(nodeId); + sendSignal(Tblockref, GSN_LCP_FRAG_REP, signal, + LcpFragRep::SignalLength, JBB); + }//if + }//for +} + +void Dblqh::contChkpNextFragLab(Signal* signal) +{ + /* ------------------------------------------------------------------------ + * UPDATE THE LATEST LOCAL CHECKPOINT COMPLETED ON FRAGMENT. + * UPDATE THE LCP_ID OF THIS CHECKPOINT. + * REMOVE THE LINK BETWEEN THE FRAGMENT RECORD AND THE LCP RECORD. + * ----------------------------------------------------------------------- */ + if (fragptr.p->fragStatus == Fragrecord::BLOCKED) { + jam(); + lcpPtr.p->lcpState = LcpRecord::LCP_BLOCKED_COMP; + return; + }//if + /* ------------------------------------------------------------------------ + * WE ALSO RELEASE THE LOCAL LCP RECORDS. + * ----------------------------------------------------------------------- */ + releaseLocalLcps(signal); + if (lcpPtr.p->lcpQueued) { + jam(); + /* ---------------------------------------------------------------------- + * Transfer the state from the queued to the active LCP. + * --------------------------------------------------------------------- */ + lcpPtr.p->lcpQueued = false; + lcpPtr.p->currentFragment = lcpPtr.p->queuedFragment; + + /* ---------------------------------------------------------------------- + * START THE QUEUED LOCAL CHECKPOINT. + * --------------------------------------------------------------------- */ + sendLCP_FRAGIDREQ(signal); + return; + }//if + + lcpPtr.p->lcpState = LcpRecord::LCP_IDLE; + if (lcpPtr.p->lastFragmentFlag){ + jam(); + /* ---------------------------------------------------------------------- + * NOW THE COMPLETE LOCAL CHECKPOINT ROUND IS COMPLETED. + * --------------------------------------------------------------------- */ + completeLcpRoundLab(signal); + return; + }//if + + if (lcpPtr.p->reportEmpty) { + jam(); + sendEMPTY_LCP_CONF(signal, false); + }//if + return; +}//Dblqh::contChkpNextFragLab() + +void Dblqh::sendLCP_FRAGIDREQ(Signal* signal) +{ + ndbrequire(lcpPtr.p->firstLcpLocTup == RNIL); + ndbrequire(lcpPtr.p->firstLcpLocAcc == RNIL); + + TablerecPtr tabPtr; + tabPtr.i = lcpPtr.p->currentFragment.lcpFragOrd.tableId; + ptrAss(tabPtr, tablerec); + if(tabPtr.p->tableStatus == Tablerec::PREP_DROP_TABLE_ONGOING || + tabPtr.p->tableStatus == Tablerec::PREP_DROP_TABLE_DONE){ + jam(); + /** + * Fake that the fragment is done + */ + lcpCompletedLab(signal); + return; + } + + ndbrequire(tabPtr.p->tableStatus == Tablerec::TABLE_DEFINED); + + lcpPtr.p->lcpState = LcpRecord::LCP_WAIT_FRAGID; + signal->theData[0] = lcpPtr.i; + signal->theData[1] = cownref; + signal->theData[2] = lcpPtr.p->currentFragment.lcpFragOrd.lcpNo; + signal->theData[3] = lcpPtr.p->currentFragment.lcpFragOrd.tableId; + signal->theData[4] = lcpPtr.p->currentFragment.lcpFragOrd.fragmentId; + signal->theData[5] = lcpPtr.p->currentFragment.lcpFragOrd.lcpId % MAX_LCP_STORED; + sendSignal(fragptr.p->accBlockref, GSN_LCP_FRAGIDREQ, signal, 6, JBB); +}//Dblqh::sendLCP_FRAGIDREQ() + +void Dblqh::sendEMPTY_LCP_CONF(Signal* signal, bool idle) +{ + + EmptyLcpConf * const rep = (EmptyLcpConf*)&signal->theData[0]; + /* ---------------------------------------------------------------------- + * We have been requested to report when there are no more local + * waiting to be started or ongoing. In this signal we also report + * the last completed fragments state. + * ---------------------------------------------------------------------- */ + rep->senderNodeId = getOwnNodeId(); + if(!idle){ + jam(); + rep->idle = 0 ; + rep->tableId = lcpPtr.p->currentFragment.lcpFragOrd.tableId; + rep->fragmentId = lcpPtr.p->currentFragment.lcpFragOrd.fragmentId; + rep->lcpNo = lcpPtr.p->currentFragment.lcpFragOrd.lcpNo; + rep->lcpId = lcpPtr.p->currentFragment.lcpFragOrd.lcpId; + } else { + jam(); + rep->idle = 1; + rep->tableId = ~0; + rep->fragmentId = ~0; + rep->lcpNo = ~0; + rep->lcpId = c_lcpId; + } + + for (Uint32 i = 0; i < cnoOfNodes; i++) { + jam(); + Uint32 nodeId = cnodeData[i]; + if (lcpPtr.p->m_EMPTY_LCP_REQ.get(nodeId)) { + jam(); + + BlockReference blockref = calcDihBlockRef(nodeId); + sendSignal(blockref, GSN_EMPTY_LCP_CONF, signal, + EmptyLcpConf::SignalLength, JBB); + }//if + }//for + + lcpPtr.p->reportEmpty = false; + lcpPtr.p->m_EMPTY_LCP_REQ.clear(); +}//Dblqh::sendEMPTY_LCPCONF() + +void Dblqh::execACC_LCPREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +}//Dblqh::execACC_LCPREF() + +void Dblqh::execTUP_LCPREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +}//Dblqh::execTUP_LCPREF() + +/* -------------------------------------------------------------------------- + * THE LOCAL CHECKPOINT ROUND IS NOW COMPLETED. SEND COMPLETED MESSAGE + * TO THE MASTER DIH. + * ------------------------------------------------------------------------- */ +void Dblqh::completeLcpRoundLab(Signal* signal) +{ + clcpCompletedState = LCP_CLOSE_STARTED; + signal->theData[0] = caccBlockref; + signal->theData[1] = cownref; + sendSignal(caccBlockref, GSN_END_LCPREQ, signal, 2, JBB); + signal->theData[0] = ctupBlockref; + signal->theData[1] = cownref; + sendSignal(ctupBlockref, GSN_END_LCPREQ, signal, 2, JBB); + return; +}//Dblqh::completeLcpRoundLab() + +void Dblqh::execEND_LCPCONF(Signal* signal) +{ + jamEntry(); + BlockReference userpointer = signal->theData[0]; + if (userpointer == caccBlockref) { + if (clcpCompletedState == LCP_CLOSE_STARTED) { + jam(); + clcpCompletedState = ACC_LCP_CLOSE_COMPLETED; + return; + } else { + jam(); + ndbrequire(clcpCompletedState == TUP_LCP_CLOSE_COMPLETED); + clcpCompletedState = LCP_IDLE; + }//if + } else { + ndbrequire(userpointer == ctupBlockref); + if (clcpCompletedState == LCP_CLOSE_STARTED) { + jam(); + clcpCompletedState = TUP_LCP_CLOSE_COMPLETED; + return; + } else { + jam(); + ndbrequire(clcpCompletedState == ACC_LCP_CLOSE_COMPLETED); + clcpCompletedState = LCP_IDLE; + }//if + }//if + sendLCP_COMPLETE_REP(signal, lcpPtr.p->currentFragment.lcpFragOrd.lcpId); +}//Dblqh::execEND_LCPCONF() + +void Dblqh::sendLCP_COMPLETE_REP(Signal* signal, Uint32 lcpId) +{ + cnoOfFragsCheckpointed = 0; + ndbrequire((cnoOfNodes - 1) < (MAX_NDB_NODES - 1)); + /* ------------------------------------------------------------------------ + * WE SEND COMP_LCP_ROUND TO ALL NODES TO PREPARE FOR NODE CRASHES. + * ----------------------------------------------------------------------- */ + lcpPtr.i = 0; + ptrAss(lcpPtr, lcpRecord); + lcpPtr.p->lastFragmentFlag = false; + + LcpCompleteRep* rep = (LcpCompleteRep*)signal->getDataPtrSend(); + rep->nodeId = getOwnNodeId(); + rep->lcpId = lcpId; + rep->blockNo = DBLQH; + + for (Uint32 i = 0; i < cnoOfNodes; i++) { + jam(); + Uint32 nodeId = cnodeData[i]; + if(cnodeStatus[i] == ZNODE_UP){ + jam(); + + BlockReference blockref = calcDihBlockRef(nodeId); + sendSignal(blockref, GSN_LCP_COMPLETE_REP, signal, + LcpCompleteRep::SignalLength, JBB); + }//if + }//for + + if(lcpPtr.p->reportEmpty){ + jam(); + sendEMPTY_LCP_CONF(signal, true); + } + return; +}//Dblqh::sendCOMP_LCP_ROUND() + +/* ========================================================================== + * ======= CHECK IF ALL PARTS OF A LOCAL CHECKPOINT ARE COMPLETED ======= + * + * SUBROUTINE SHORT NAME = CLC + * ========================================================================= */ +void Dblqh::checkLcpCompleted(Signal* signal) +{ + LcpLocRecordPtr clcLcpLocptr; + + clcLcpLocptr.i = lcpPtr.p->firstLcpLocAcc; + while (clcLcpLocptr.i != RNIL) { + ptrCheckGuard(clcLcpLocptr, clcpLocrecFileSize, lcpLocRecord); + if (clcLcpLocptr.p->lcpLocstate != LcpLocRecord::ACC_COMPLETED) { + jam(); + ndbrequire((clcLcpLocptr.p->lcpLocstate == LcpLocRecord::ACC_WAIT_STARTED) || + (clcLcpLocptr.p->lcpLocstate == LcpLocRecord::ACC_STARTED)); + return; + }//if + clcLcpLocptr.i = clcLcpLocptr.p->nextLcpLoc; + } + + clcLcpLocptr.i = lcpPtr.p->firstLcpLocTup; + while (clcLcpLocptr.i != RNIL){ + ptrCheckGuard(clcLcpLocptr, clcpLocrecFileSize, lcpLocRecord); + if (clcLcpLocptr.p->lcpLocstate != LcpLocRecord::TUP_COMPLETED) { + jam(); + ndbrequire((clcLcpLocptr.p->lcpLocstate==LcpLocRecord::TUP_WAIT_STARTED) + ||(clcLcpLocptr.p->lcpLocstate == LcpLocRecord::TUP_STARTED)); + return; + }//if + clcLcpLocptr.i = clcLcpLocptr.p->nextLcpLoc; + } + + lcpPtr.p->lcpState = LcpRecord::LCP_COMPLETED; +}//Dblqh::checkLcpCompleted() + +/* ========================================================================== + * ======= CHECK IF ALL HOLD OPERATIONS ARE COMPLETED ======= + * + * SUBROUTINE SHORT NAME = CHO + * ========================================================================= */ +void Dblqh::checkLcpHoldop(Signal* signal) +{ + LcpLocRecordPtr choLcpLocptr; + + choLcpLocptr.i = lcpPtr.p->firstLcpLocAcc; + do { + ptrCheckGuard(choLcpLocptr, clcpLocrecFileSize, lcpLocRecord); + if (choLcpLocptr.p->lcpLocstate != LcpLocRecord::HOLDOP_READY) { + ndbrequire(choLcpLocptr.p->lcpLocstate == LcpLocRecord::WAIT_LCPHOLDOP); + return; + }//if + choLcpLocptr.i = choLcpLocptr.p->nextLcpLoc; + } while (choLcpLocptr.i != RNIL); + lcpPtr.p->lcpState = LcpRecord::LCP_WAIT_ACTIVE_FINISH; +}//Dblqh::checkLcpHoldop() + +/* ========================================================================== + * ======= CHECK IF ALL PARTS OF A LOCAL CHECKPOINT ARE STARTED ======= + * + * SUBROUTINE SHORT NAME = CLS + * ========================================================================== */ +void Dblqh::checkLcpStarted(Signal* signal) +{ + LcpLocRecordPtr clsLcpLocptr; + + terrorCode = ZOK; + clsLcpLocptr.i = lcpPtr.p->firstLcpLocAcc; + do { + ptrCheckGuard(clsLcpLocptr, clcpLocrecFileSize, lcpLocRecord); + if (clsLcpLocptr.p->lcpLocstate != LcpLocRecord::ACC_STARTED) { + ndbrequire((clsLcpLocptr.p->lcpLocstate == LcpLocRecord::ACC_COMPLETED) || + (clsLcpLocptr.p->lcpLocstate == LcpLocRecord::ACC_WAIT_STARTED)); + return; + }//if + clsLcpLocptr.i = clsLcpLocptr.p->nextLcpLoc; + } while (clsLcpLocptr.i != RNIL); + + clsLcpLocptr.i = lcpPtr.p->firstLcpLocTup; + do { + ptrCheckGuard(clsLcpLocptr, clcpLocrecFileSize, lcpLocRecord); + if (clsLcpLocptr.p->lcpLocstate != LcpLocRecord::TUP_STARTED) { + ndbrequire((clsLcpLocptr.p->lcpLocstate == LcpLocRecord::TUP_COMPLETED) || + (clsLcpLocptr.p->lcpLocstate == LcpLocRecord::TUP_WAIT_STARTED)); + return; + }//if + clsLcpLocptr.i = clsLcpLocptr.p->nextLcpLoc; + } while (clsLcpLocptr.i != RNIL); + lcpPtr.p->lcpState = LcpRecord::LCP_STARTED; +}//Dblqh::checkLcpStarted() + +/* ========================================================================== + * ======= CHECK IF ALL PREPARE TUP OPERATIONS ARE COMPLETED ======= + * + * SUBROUTINE SHORT NAME = CLT + * ========================================================================== */ +void Dblqh::checkLcpTupprep(Signal* signal) +{ + LcpLocRecordPtr cltLcpLocptr; + cltLcpLocptr.i = lcpPtr.p->firstLcpLocTup; + do { + ptrCheckGuard(cltLcpLocptr, clcpLocrecFileSize, lcpLocRecord); + if (cltLcpLocptr.p->lcpLocstate != LcpLocRecord::IDLE) { + ndbrequire(cltLcpLocptr.p->lcpLocstate == LcpLocRecord::WAIT_TUP_PREPLCP); + return; + }//if + cltLcpLocptr.i = cltLcpLocptr.p->nextLcpLoc; + } while (cltLcpLocptr.i != RNIL); + lcpPtr.p->lcpState = LcpRecord::LCP_WAIT_HOLDOPS; +}//Dblqh::checkLcpTupprep() + +/* ========================================================================== + * ======= INITIATE LCP LOCAL RECORD USED TOWARDS ACC ======= + * + * ========================================================================== */ +void Dblqh::initLcpLocAcc(Signal* signal, Uint32 fragId) +{ + lcpLocptr.p->nextLcpLoc = lcpPtr.p->firstLcpLocAcc; + lcpPtr.p->firstLcpLocAcc = lcpLocptr.i; + lcpLocptr.p->locFragid = fragId; + lcpLocptr.p->waitingBlock = LcpLocRecord::ACC; + lcpLocptr.p->lcpLocstate = LcpLocRecord::IDLE; + lcpLocptr.p->masterLcpRec = lcpPtr.i; + lcpLocptr.p->tupRef = RNIL; +}//Dblqh::initLcpLocAcc() + +/* ========================================================================== + * ======= INITIATE LCP LOCAL RECORD USED TOWARDS TUP ======= + * + * ========================================================================== */ +void Dblqh::initLcpLocTup(Signal* signal, Uint32 fragId) +{ + lcpLocptr.p->nextLcpLoc = lcpPtr.p->firstLcpLocTup; + lcpPtr.p->firstLcpLocTup = lcpLocptr.i; + lcpLocptr.p->locFragid = fragId; + lcpLocptr.p->waitingBlock = LcpLocRecord::TUP; + lcpLocptr.p->lcpLocstate = LcpLocRecord::WAIT_TUP_PREPLCP; + lcpLocptr.p->masterLcpRec = lcpPtr.i; + lcpLocptr.p->tupRef = RNIL; +}//Dblqh::initLcpLocTup() + +/* -------------------------------------------------------------------------- + * ------- MOVE OPERATION FROM ACC WAITING LIST ON FRAGMENT ------- + * ------- TO ACTIVE LIST ON FRAGMENT ------- + * + * SUBROUTINE SHORT NAME = MAA + * -------------------------------------------------------------------------- */ +void Dblqh::moveAccActiveFrag(Signal* signal) +{ + UintR maaTcNextConnectptr; + + tcConnectptr.i = fragptr.p->accBlockedList; + fragptr.p->accBlockedList = RNIL; + /* ------------------------------------------------------------------------ + * WE WILL MOVE ALL RECORDS FROM THE ACC BLOCKED LIST AT ONCE. + * ------------------------------------------------------------------------ */ + while (tcConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + maaTcNextConnectptr = tcConnectptr.p->nextTc; + ndbrequire(tcConnectptr.p->listState == TcConnectionrec::ACC_BLOCK_LIST); + tcConnectptr.p->listState = TcConnectionrec::NOT_IN_LIST; + linkActiveFrag(signal); + tcConnectptr.i = maaTcNextConnectptr; + }//while +}//Dblqh::moveAccActiveFrag() + +/* -------------------------------------------------------------------------- + * ------- MOVE OPERATION FROM ACTIVE LIST ON FRAGMENT ------- + * ------- TO ACC BLOCKED LIST ON FRAGMENT ------- + * + * SUBROUTINE SHORT NAME = MAT + * -------------------------------------------------------------------------- */ +void Dblqh::moveActiveToAcc(Signal* signal) +{ + TcConnectionrecPtr matTcNextConnectptr; + + releaseActiveList(signal); + /* ------------------------------------------------------------------------ + * PUT OPERATION RECORD FIRST IN ACC BLOCKED LIST. + * ------------------------------------------------------------------------ */ + matTcNextConnectptr.i = fragptr.p->accBlockedList; + tcConnectptr.p->nextTc = matTcNextConnectptr.i; + tcConnectptr.p->prevTc = RNIL; + tcConnectptr.p->listState = TcConnectionrec::ACC_BLOCK_LIST; + fragptr.p->accBlockedList = tcConnectptr.i; + if (matTcNextConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(matTcNextConnectptr, ctcConnectrecFileSize, tcConnectionrec); + matTcNextConnectptr.p->prevTc = tcConnectptr.i; + }//if +}//Dblqh::moveActiveToAcc() + +/* ------------------------------------------------------------------------- */ +/* ---- RELEASE LOCAL LCP RECORDS AFTER COMPLETION OF A LOCAL CHECKPOINT---- */ +/* */ +/* SUBROUTINE SHORT NAME = RLL */ +/* ------------------------------------------------------------------------- */ +void Dblqh::releaseLocalLcps(Signal* signal) +{ + lcpLocptr.i = lcpPtr.p->firstLcpLocAcc; + while (lcpLocptr.i != RNIL){ + ptrCheckGuard(lcpLocptr, clcpLocrecFileSize, lcpLocRecord); + Uint32 tmp = lcpLocptr.p->nextLcpLoc; + releaseLcpLoc(signal); + lcpLocptr.i = tmp; + } + lcpPtr.p->firstLcpLocAcc = RNIL; + + lcpLocptr.i = lcpPtr.p->firstLcpLocTup; + while (lcpLocptr.i != RNIL){ + ptrCheckGuard(lcpLocptr, clcpLocrecFileSize, lcpLocRecord); + Uint32 tmp = lcpLocptr.p->nextLcpLoc; + releaseLcpLoc(signal); + lcpLocptr.i = tmp; + } + lcpPtr.p->firstLcpLocTup = RNIL; + +}//Dblqh::releaseLocalLcps() + +/* ------------------------------------------------------------------------- */ +/* ------- SEIZE LCP LOCAL RECORD ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dblqh::seizeLcpLoc(Signal* signal) +{ + lcpLocptr.i = cfirstfreeLcpLoc; + ptrCheckGuard(lcpLocptr, clcpLocrecFileSize, lcpLocRecord); + cfirstfreeLcpLoc = lcpLocptr.p->nextLcpLoc; + lcpLocptr.p->nextLcpLoc = RNIL; +}//Dblqh::seizeLcpLoc() + +/* ------------------------------------------------------------------------- */ +/* ------- SEND ACC_CONT_OP ------- */ +/* */ +/* INPUT: LCP_PTR LOCAL CHECKPOINT RECORD */ +/* FRAGPTR FRAGMENT RECORD */ +/* */ +/* SUBROUTINE SHORT NAME = SAC */ +/* ------------------------------------------------------------------------- */ +void Dblqh::sendAccContOp(Signal* signal) +{ + LcpLocRecordPtr sacLcpLocptr; + + sacLcpLocptr.i = lcpPtr.p->firstLcpLocAcc; + do { + ptrCheckGuard(sacLcpLocptr, clcpLocrecFileSize, lcpLocRecord); + sacLcpLocptr.p->accContCounter = 0; +/* ------------------------------------------------------------------------- */ +/*SEND START OPERATIONS TO ACC AGAIN */ +/* ------------------------------------------------------------------------- */ + signal->theData[0] = lcpPtr.p->lcpAccptr; + signal->theData[1] = sacLcpLocptr.p->locFragid; + sendSignal(fragptr.p->accBlockref, GSN_ACC_CONTOPREQ, signal, 2, JBA); + sacLcpLocptr.i = sacLcpLocptr.p->nextLcpLoc; + } while (sacLcpLocptr.i != RNIL); +}//Dblqh::sendAccContOp() + +/* ------------------------------------------------------------------------- */ +/* ------- SEND ACC_LCPREQ AND TUP_LCPREQ ------- */ +/* */ +/* INPUT: LCP_PTR LOCAL CHECKPOINT RECORD */ +/* FRAGPTR FRAGMENT RECORD */ +/* SUBROUTINE SHORT NAME = STL */ +/* ------------------------------------------------------------------------- */ +void Dblqh::sendStartLcp(Signal* signal) +{ + LcpLocRecordPtr stlLcpLocptr; + stlLcpLocptr.i = lcpPtr.p->firstLcpLocAcc; + do { + jam(); + ptrCheckGuard(stlLcpLocptr, clcpLocrecFileSize, lcpLocRecord); + stlLcpLocptr.p->lcpLocstate = LcpLocRecord::ACC_WAIT_STARTED; + signal->theData[0] = lcpPtr.p->lcpAccptr; + signal->theData[1] = stlLcpLocptr.i; + signal->theData[2] = stlLcpLocptr.p->locFragid; + sendSignal(fragptr.p->accBlockref, GSN_ACC_LCPREQ, signal, 3, JBA); + stlLcpLocptr.i = stlLcpLocptr.p->nextLcpLoc; + } while (stlLcpLocptr.i != RNIL); + + stlLcpLocptr.i = lcpPtr.p->firstLcpLocTup; + do { + jam(); + ptrCheckGuard(stlLcpLocptr, clcpLocrecFileSize, lcpLocRecord); + stlLcpLocptr.p->lcpLocstate = LcpLocRecord::TUP_WAIT_STARTED; + signal->theData[0] = stlLcpLocptr.i; + signal->theData[1] = cownref; + signal->theData[2] = stlLcpLocptr.p->tupRef; + sendSignal(fragptr.p->tupBlockref, GSN_TUP_LCPREQ, signal, 3, JBA); + stlLcpLocptr.i = stlLcpLocptr.p->nextLcpLoc; + } while (stlLcpLocptr.i != RNIL); +}//Dblqh::sendStartLcp() + +/* ------------------------------------------------------------------------- */ +/* ------- SET THE LOG TAIL IN THE LOG FILES ------- */ +/* */ +/*THIS SUBROUTINE HAVE BEEN BUGGY AND IS RATHER COMPLEX. IT IS IMPORTANT TO */ +/*REMEMBER THAT WE SEARCH FROM THE TAIL UNTIL WE REACH THE HEAD (CURRENT). */ +/*THE TAIL AND HEAD CAN BE ON THE SAME MBYTE. WE SEARCH UNTIL WE FIND A MBYTE*/ +/*THAT WE NEED TO KEEP. WE THEN SET THE TAIL TO BE THE PREVIOUS. IF WE DO */ +/*NOT FIND A MBYTE THAT WE NEED TO KEEP UNTIL WE REACH THE HEAD THEN WE USE */ +/*THE HEAD AS TAIL. FINALLY WE HAVE TO MOVE BACK THE TAIL TO ALSO INCLUDE */ +/*ALL PREPARE RECORDS. THIS MEANS THAT LONG-LIVED TRANSACTIONS ARE DANGEROUS */ +/*FOR SHORT LOGS. */ +/* ------------------------------------------------------------------------- */ + +// this function has not been verified yet +Uint32 Dblqh::remainingLogSize(const LogFileRecordPtr &sltCurrLogFilePtr, + const LogPartRecordPtr &sltLogPartPtr) +{ + Uint32 hf = sltCurrLogFilePtr.p->fileNo*ZNO_MBYTES_IN_FILE+sltCurrLogFilePtr.p->currentMbyte; + Uint32 tf = sltLogPartPtr.p->logTailFileNo*ZNO_MBYTES_IN_FILE+sltLogPartPtr.p->logTailMbyte; + Uint32 sz = sltLogPartPtr.p->noLogFiles*ZNO_MBYTES_IN_FILE; + if (tf > hf) hf += sz; + return sz-(hf-tf); +} + +void Dblqh::setLogTail(Signal* signal, Uint32 keepGci) +{ + LogPartRecordPtr sltLogPartPtr; + LogFileRecordPtr sltLogFilePtr; +#if 0 + LogFileRecordPtr sltCurrLogFilePtr; +#endif + UintR tsltMbyte; + UintR tsltStartMbyte; + UintR tsltIndex; + UintR tsltFlag; + + for (sltLogPartPtr.i = 0; sltLogPartPtr.i < 4; sltLogPartPtr.i++) { + jam(); + ptrAss(sltLogPartPtr, logPartRecord); + findLogfile(signal, sltLogPartPtr.p->logTailFileNo, + sltLogPartPtr, &sltLogFilePtr); + +#if 0 + sltCurrLogFilePtr.i = sltLogPartPtr.p->currentLogfile; + ptrCheckGuard(sltCurrLogFilePtr, clogFileFileSize, logFileRecord); + infoEvent("setLogTail: Available log file %d size = %d[mbytes]+%d[words]", sltLogPartPtr.i, + remainingLogSize(sltCurrLogFilePtr, sltLogPartPtr), sltCurrLogFilePtr.p->remainingWordsInMbyte); +#endif + + tsltMbyte = sltLogPartPtr.p->logTailMbyte; + tsltStartMbyte = tsltMbyte; + tsltFlag = ZFALSE; + if (sltLogFilePtr.i == sltLogPartPtr.p->currentLogfile) { +/* ------------------------------------------------------------------------- */ +/*THE LOG AND THE TAIL IS ALREADY IN THE SAME FILE. */ +/* ------------------------------------------------------------------------- */ + if (sltLogFilePtr.p->currentMbyte >= sltLogPartPtr.p->logTailMbyte) { + jam(); +/* ------------------------------------------------------------------------- */ +/*THE CURRENT MBYTE IS AHEAD OF OR AT THE TAIL. THUS WE WILL ONLY LOOK FOR */ +/*THE TAIL UNTIL WE REACH THE CURRENT MBYTE WHICH IS IN THIS LOG FILE. */ +/*IF THE LOG TAIL IS AHEAD OF THE CURRENT MBYTE BUT IN THE SAME LOG FILE */ +/*THEN WE HAVE TO SEARCH THROUGH ALL FILES BEFORE WE COME TO THE CURRENT */ +/*MBYTE. WE ALWAYS STOP WHEN WE COME TO THE CURRENT MBYTE SINCE THE TAIL */ +/*CAN NEVER BE BEFORE THE HEAD. */ +/* ------------------------------------------------------------------------- */ + tsltFlag = ZTRUE; + }//if + }//if + +/* ------------------------------------------------------------------------- */ +/*NOW START SEARCHING FOR THE NEW TAIL, STARTING AT THE CURRENT TAIL AND */ +/*PROCEEDING UNTIL WE FIND A MBYTE WHICH IS NEEDED TO KEEP OR UNTIL WE REACH */ +/*CURRENT MBYTE (THE HEAD). */ +/* ------------------------------------------------------------------------- */ + SLT_LOOP: + for (tsltIndex = tsltStartMbyte; + tsltIndex <= ZNO_MBYTES_IN_FILE - 1; + tsltIndex++) { + if (sltLogFilePtr.p->logMaxGciStarted[tsltIndex] >= keepGci) { +/* ------------------------------------------------------------------------- */ +/*WE ARE NOT ALLOWED TO STEP THE LOG ANY FURTHER AHEAD */ +/*SET THE NEW LOG TAIL AND CONTINUE WITH NEXT LOG PART. */ +/*THIS MBYTE IS NOT TO BE INCLUDED SO WE NEED TO STEP BACK ONE MBYTE. */ +/* ------------------------------------------------------------------------- */ + if (tsltIndex != 0) { + jam(); + tsltMbyte = tsltIndex - 1; + } else { + jam(); +/* ------------------------------------------------------------------------- */ +/*STEPPING BACK INCLUDES ALSO STEPPING BACK TO THE PREVIOUS LOG FILE. */ +/* ------------------------------------------------------------------------- */ + tsltMbyte = ZNO_MBYTES_IN_FILE - 1; + sltLogFilePtr.i = sltLogFilePtr.p->prevLogFile; + ptrCheckGuard(sltLogFilePtr, clogFileFileSize, logFileRecord); + }//if + goto SLT_BREAK; + } else { + jam(); + if (tsltFlag == ZTRUE) { +/* ------------------------------------------------------------------------- */ +/*WE ARE IN THE SAME FILE AS THE CURRENT MBYTE AND WE CAN REACH THE CURRENT */ +/*MBYTE BEFORE WE REACH A NEW TAIL. */ +/* ------------------------------------------------------------------------- */ + if (tsltIndex == sltLogFilePtr.p->currentMbyte) { + jam(); +/* ------------------------------------------------------------------------- */ +/*THE TAIL OF THE LOG IS ACTUALLY WITHIN THE CURRENT MBYTE. THUS WE SET THE */ +/*LOG TAIL TO BE THE CURRENT MBYTE. */ +/* ------------------------------------------------------------------------- */ + tsltMbyte = sltLogFilePtr.p->currentMbyte; + goto SLT_BREAK; + }//if + }//if + }//if + }//for + sltLogFilePtr.i = sltLogFilePtr.p->nextLogFile; + ptrCheckGuard(sltLogFilePtr, clogFileFileSize, logFileRecord); + if (sltLogFilePtr.i == sltLogPartPtr.p->currentLogfile) { + jam(); + tsltFlag = ZTRUE; + }//if + tsltStartMbyte = 0; + goto SLT_LOOP; + SLT_BREAK: + jam(); + { + UintR ToldTailFileNo = sltLogPartPtr.p->logTailFileNo; + UintR ToldTailMByte = sltLogPartPtr.p->logTailMbyte; + + arrGuard(tsltMbyte, 16); + sltLogPartPtr.p->logTailFileNo = + sltLogFilePtr.p->logLastPrepRef[tsltMbyte] >> 16; +/* ------------------------------------------------------------------------- */ +/*SINCE LOG_MAX_GCI_STARTED ONLY KEEP TRACK OF COMMIT LOG RECORDS WE ALSO */ +/*HAVE TO STEP BACK THE TAIL SO THAT WE INCLUDE ALL PREPARE RECORDS */ +/*NEEDED FOR THOSE COMMIT RECORDS IN THIS MBYTE. THIS IS A RATHER */ +/*CONSERVATIVE APPROACH BUT IT WORKS. */ +/* ------------------------------------------------------------------------- */ + sltLogPartPtr.p->logTailMbyte = + sltLogFilePtr.p->logLastPrepRef[tsltMbyte] & 65535; + if ((ToldTailFileNo != sltLogPartPtr.p->logTailFileNo) || + (ToldTailMByte != sltLogPartPtr.p->logTailMbyte)) { + jam(); + if (sltLogPartPtr.p->logPartState == LogPartRecord::TAIL_PROBLEM) { + if (sltLogPartPtr.p->firstLogQueue == RNIL) { + jam(); + sltLogPartPtr.p->logPartState = LogPartRecord::IDLE; + } else { + jam(); + sltLogPartPtr.p->logPartState = LogPartRecord::ACTIVE; + }//if + }//if + }//if + } +#if 0 + infoEvent("setLogTail: Available log file %d size = %d[mbytes]+%d[words]", sltLogPartPtr.i, + remainingLogSize(sltCurrLogFilePtr, sltLogPartPtr), sltCurrLogFilePtr.p->remainingWordsInMbyte); +#endif + }//for + +}//Dblqh::setLogTail() + +/* ######################################################################### */ +/* ####### GLOBAL CHECKPOINT MODULE ####### */ +/* */ +/* ######################################################################### */ +/*---------------------------------------------------------------------------*/ +/* THIS MODULE HELPS DIH IN DISCOVERING WHEN GLOBAL CHECKPOINTS ARE */ +/* RECOVERABLE. IT HANDLES THE REQUEST GCP_SAVEREQ THAT REQUESTS LQH TO */ +/* SAVE A PARTICULAR GLOBAL CHECKPOINT TO DISK AND RESPOND WHEN COMPLETED. */ +/*---------------------------------------------------------------------------*/ +/* *************** */ +/* GCP_SAVEREQ > */ +/* *************** */ +void Dblqh::execGCP_SAVEREQ(Signal* signal) +{ + jamEntry(); + const GCPSaveReq * const saveReq = (GCPSaveReq *)&signal->theData[0]; + + if (ERROR_INSERTED(5000)) { + systemErrorLab(signal); + } + + if (ERROR_INSERTED(5007)){ + CLEAR_ERROR_INSERT_VALUE; + sendSignalWithDelay(cownref, GSN_GCP_SAVEREQ, signal, 10000, + signal->length()); + return; + } + + const Uint32 dihBlockRef = saveReq->dihBlockRef; + const Uint32 dihPtr = saveReq->dihPtr; + const Uint32 gci = saveReq->gci; + + ndbrequire(gci >= cnewestCompletedGci); + + if (gci == cnewestCompletedGci) { +/*---------------------------------------------------------------------------*/ +/* GLOBAL CHECKPOINT HAVE ALREADY BEEN HANDLED. REQUEST MUST HAVE BEEN SENT */ +/* FROM NEW MASTER DIH. */ +/*---------------------------------------------------------------------------*/ + if (ccurrentGcprec == RNIL) { + jam(); +/*---------------------------------------------------------------------------*/ +/* THIS INDICATES THAT WE HAVE ALREADY SENT GCP_SAVECONF TO PREVIOUS MASTER. */ +/* WE SIMPLY SEND IT ALSO TO THE NEW MASTER. */ +/*---------------------------------------------------------------------------*/ + GCPSaveConf * const saveConf = (GCPSaveConf*)&signal->theData[0]; + saveConf->dihPtr = dihPtr; + saveConf->nodeId = getOwnNodeId(); + saveConf->gci = cnewestCompletedGci; + sendSignal(dihBlockRef, GSN_GCP_SAVECONF, signal, + GCPSaveConf::SignalLength, JBA); + return; + } + jam(); +/*---------------------------------------------------------------------------*/ +/* WE HAVE NOT YET SENT THE RESPONSE TO THE OLD MASTER. WE WILL SET THE NEW */ +/* RECEIVER OF THE RESPONSE AND THEN EXIT SINCE THE PROCESS IS ALREADY */ +/* STARTED. */ +/*---------------------------------------------------------------------------*/ + gcpPtr.i = ccurrentGcprec; + ptrCheckGuard(gcpPtr, cgcprecFileSize, gcpRecord); + gcpPtr.p->gcpUserptr = dihPtr; + gcpPtr.p->gcpBlockref = dihBlockRef; + return; + }//if + + ndbrequire(ccurrentGcprec == RNIL); + + + if(getNodeState().startLevel >= NodeState::SL_STOPPING_4){ + GCPSaveRef * const saveRef = (GCPSaveRef*)&signal->theData[0]; + saveRef->dihPtr = dihPtr; + saveRef->nodeId = getOwnNodeId(); + saveRef->gci = gci; + saveRef->errorCode = GCPSaveRef::NodeShutdownInProgress; + sendSignal(dihBlockRef, GSN_GCP_SAVEREF, signal, + GCPSaveRef::SignalLength, JBB); + return; + } + + if(getNodeState().getNodeRestartInProgress()){ + GCPSaveRef * const saveRef = (GCPSaveRef*)&signal->theData[0]; + saveRef->dihPtr = dihPtr; + saveRef->nodeId = getOwnNodeId(); + saveRef->gci = gci; + saveRef->errorCode = GCPSaveRef::NodeRestartInProgress; + sendSignal(dihBlockRef, GSN_GCP_SAVEREF, signal, + GCPSaveRef::SignalLength, JBB); + return; + } + + ccurrentGcprec = 0; + gcpPtr.i = ccurrentGcprec; + ptrCheckGuard(gcpPtr, cgcprecFileSize, gcpRecord); + + cnewestCompletedGci = gci; + if (gci > cnewestGci) { + jam(); + cnewestGci = gci; + }//if + + gcpPtr.p->gcpBlockref = dihBlockRef; + gcpPtr.p->gcpUserptr = dihPtr; + gcpPtr.p->gcpId = gci; + bool tlogActive = false; + for (logPartPtr.i = 0; logPartPtr.i <= 3; logPartPtr.i++) { + ptrAss(logPartPtr, logPartRecord); + if (logPartPtr.p->logPartState == LogPartRecord::ACTIVE) { + jam(); + logPartPtr.p->waitWriteGciLog = LogPartRecord::WWGL_TRUE; + tlogActive = true; + } else { + jam(); + logPartPtr.p->waitWriteGciLog = LogPartRecord::WWGL_FALSE; + logFilePtr.i = logPartPtr.p->currentLogfile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + logPagePtr.i = logFilePtr.p->currentLogpage; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + writeCompletedGciLog(signal); + }//if + }//for + if (tlogActive == true) { + jam(); + return; + }//if + initGcpRecLab(signal); + startTimeSupervision(signal); + return; +}//Dblqh::execGCP_SAVEREQ() + +/* ------------------------------------------------------------------------- */ +/* START TIME SUPERVISION OF THE LOG PARTS. */ +/* ------------------------------------------------------------------------- */ +void Dblqh::startTimeSupervision(Signal* signal) +{ + for (logPartPtr.i = 0; logPartPtr.i <= 3; logPartPtr.i++) { + jam(); + ptrAss(logPartPtr, logPartRecord); +/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */ +/* WE HAVE TO START CHECKING IF THE LOG IS TO BE WRITTEN EVEN IF PAGES ARE */ +/* FULL. INITIALISE THE VALUES OF WHERE WE ARE IN THE LOG CURRENTLY. */ +/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */ + logPartPtr.p->logPartTimer = 0; + logPartPtr.p->logTimer = 1; + signal->theData[0] = ZTIME_SUPERVISION; + signal->theData[1] = logPartPtr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + }//for +}//Dblqh::startTimeSupervision() + +/*---------------------------------------------------------------------------*/ +/* WE SET THE GLOBAL CHECKPOINT VARIABLES AFTER WRITING THE COMPLETED GCI LOG*/ +/* RECORD. THIS ENSURES THAT WE WILL ENCOUNTER THE COMPLETED GCI RECORD WHEN */ +/* WE EXECUTE THE FRAGMENT LOG. */ +/*---------------------------------------------------------------------------*/ +void Dblqh::initGcpRecLab(Signal* signal) +{ +/* ======================================================================== */ +/* ======= INITIATE GCP RECORD ======= */ +/* */ +/* SUBROUTINE SHORT NAME = IGR */ +/* ======================================================================== */ + for (logPartPtr.i = 0; logPartPtr.i <= 3; logPartPtr.i++) { + jam(); + ptrAss(logPartPtr, logPartRecord); +/*--------------------------------------------------*/ +/* BY SETTING THE GCPREC = 0 WE START THE */ +/* CHECKING BY CHECK_GCP_COMPLETED. THIS */ +/* CHECKING MUST NOT BE STARTED UNTIL WE HAVE */ +/* INSERTED ALL COMPLETE GCI LOG RECORDS IN */ +/* ALL LOG PARTS. */ +/*--------------------------------------------------*/ + logPartPtr.p->gcprec = 0; + gcpPtr.p->gcpLogPartState[logPartPtr.i] = ZWAIT_DISK; + gcpPtr.p->gcpSyncReady[logPartPtr.i] = ZFALSE; + logFilePtr.i = logPartPtr.p->currentLogfile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + gcpPtr.p->gcpFilePtr[logPartPtr.i] = logFilePtr.i; + logPagePtr.i = logFilePtr.p->currentLogpage; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + if (logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] == ZPAGE_HEADER_SIZE) { + jam(); +/*--------------------------------------------------*/ +/* SINCE THE CURRENT FILEPAGE POINTS AT THE */ +/* NEXT WORD TO BE WRITTEN WE HAVE TO ADJUST */ +/* FOR THIS BY DECREASING THE FILE PAGE BY ONE*/ +/* IF NO WORD HAS BEEN WRITTEN ON THE CURRENT */ +/* FILEPAGE. */ +/*--------------------------------------------------*/ + gcpPtr.p->gcpPageNo[logPartPtr.i] = logFilePtr.p->currentFilepage - 1; + gcpPtr.p->gcpWordNo[logPartPtr.i] = ZPAGE_SIZE - 1; + } else { + jam(); + gcpPtr.p->gcpPageNo[logPartPtr.i] = logFilePtr.p->currentFilepage; + gcpPtr.p->gcpWordNo[logPartPtr.i] = + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] - 1; + }//if + }//for + return; +}//Dblqh::initGcpRecLab() + +/* ========================================================================= */ +/* ==== CHECK IF ANY GLOBAL CHECKPOINTS ARE COMPLETED AFTER A COMPLETED===== */ +/* DISK WRITE. */ +/* */ +/* SUBROUTINE SHORT NAME = CGC */ +/* ========================================================================= */ +void Dblqh::checkGcpCompleted(Signal* signal, + Uint32 tcgcPageWritten, + Uint32 tcgcWordWritten) +{ + UintR tcgcFlag; + UintR tcgcJ; + + gcpPtr.i = logPartPtr.p->gcprec; + if (gcpPtr.i != RNIL) { + jam(); +/* ------------------------------------------------------------------------- */ +/* IF THE GLOBAL CHECKPOINT IS NOT WAITING FOR COMPLETION THEN WE CAN QUIT */ +/* THE SEARCH IMMEDIATELY. */ +/* ------------------------------------------------------------------------- */ + ptrCheckGuard(gcpPtr, cgcprecFileSize, gcpRecord); + if (gcpPtr.p->gcpFilePtr[logPartPtr.i] == logFilePtr.i) { +/* ------------------------------------------------------------------------- */ +/* IF THE COMPLETED DISK OPERATION WAS ON ANOTHER FILE THAN THE ONE WE ARE */ +/* WAITING FOR, THEN WE CAN ALSO QUIT THE SEARCH IMMEDIATELY. */ +/* ------------------------------------------------------------------------- */ + if (tcgcPageWritten < gcpPtr.p->gcpPageNo[logPartPtr.i]) { + jam(); +/* ------------------------------------------------------------------------- */ +/* THIS LOG PART HAVE NOT YET WRITTEN THE GLOBAL CHECKPOINT TO DISK. */ +/* ------------------------------------------------------------------------- */ + return; + } else { + if (tcgcPageWritten == gcpPtr.p->gcpPageNo[logPartPtr.i]) { + if (tcgcWordWritten < gcpPtr.p->gcpWordNo[logPartPtr.i]) { + jam(); +/* ------------------------------------------------------------------------- */ +/* THIS LOG PART HAVE NOT YET WRITTEN THE GLOBAL CHECKPOINT TO DISK. */ +/* ------------------------------------------------------------------------- */ + return; + }//if + }//if + }//if +/* ------------------------------------------------------------------------- */ +/* THIS LOG PART HAVE WRITTEN THE GLOBAL CHECKPOINT TO DISK. */ +/* ------------------------------------------------------------------------- */ + logPartPtr.p->gcprec = RNIL; + gcpPtr.p->gcpLogPartState[logPartPtr.i] = ZON_DISK; + tcgcFlag = ZTRUE; + for (tcgcJ = 0; tcgcJ <= 3; tcgcJ++) { + jam(); + if (gcpPtr.p->gcpLogPartState[tcgcJ] != ZON_DISK) { + jam(); +/* ------------------------------------------------------------------------- */ +/*ALL LOG PARTS HAVE NOT SAVED THIS GLOBAL CHECKPOINT TO DISK YET. WAIT FOR */ +/*THEM TO COMPLETE. */ +/* ------------------------------------------------------------------------- */ + tcgcFlag = ZFALSE; + }//if + }//for + if (tcgcFlag == ZTRUE) { + jam(); +/* ------------------------------------------------------------------------- */ +/*WE HAVE FOUND A COMPLETED GLOBAL CHECKPOINT OPERATION. WE NOW NEED TO SEND */ +/*GCP_SAVECONF, REMOVE THE GCP RECORD FROM THE LIST OF WAITING GCP RECORDS */ +/*ON THIS LOG PART AND RELEASE THE GCP RECORD. */ +// After changing the log implementation we need to perform a FSSYNCREQ on all +// log files where the last log word resided first before proceeding. +/* ------------------------------------------------------------------------- */ + UintR Ti; + for (Ti = 0; Ti < 4; Ti++) { + LogFileRecordPtr loopLogFilePtr; + loopLogFilePtr.i = gcpPtr.p->gcpFilePtr[Ti]; + ptrCheckGuard(loopLogFilePtr, clogFileFileSize, logFileRecord); + if (loopLogFilePtr.p->logFileStatus == LogFileRecord::OPEN) { + jam(); + signal->theData[0] = loopLogFilePtr.p->fileRef; + signal->theData[1] = cownref; + signal->theData[2] = gcpPtr.p->gcpFilePtr[Ti]; + sendSignal(NDBFS_REF, GSN_FSSYNCREQ, signal, 3, JBA); + } else { + ndbrequire((loopLogFilePtr.p->logFileStatus == + LogFileRecord::CLOSED) || + (loopLogFilePtr.p->logFileStatus == + LogFileRecord::CLOSING_WRITE_LOG) || + (loopLogFilePtr.p->logFileStatus == + LogFileRecord::OPENING_WRITE_LOG)); + signal->theData[0] = loopLogFilePtr.i; + execFSSYNCCONF(signal); + }//if + }//for + return; + }//if + }//if + }//if +}//Dblqh::checkGcpCompleted() + +void +Dblqh::execFSSYNCCONF(Signal* signal) +{ + GcpRecordPtr localGcpPtr; + LogFileRecordPtr localLogFilePtr; + LogPartRecordPtr localLogPartPtr; + localLogFilePtr.i = signal->theData[0]; + ptrCheckGuard(localLogFilePtr, clogFileFileSize, logFileRecord); + localLogPartPtr.i = localLogFilePtr.p->logPartRec; + localGcpPtr.i = ccurrentGcprec; + ptrCheckGuard(localGcpPtr, cgcprecFileSize, gcpRecord); + localGcpPtr.p->gcpSyncReady[localLogPartPtr.i] = ZTRUE; + UintR Ti; + for (Ti = 0; Ti < 4; Ti++) { + jam(); + if (localGcpPtr.p->gcpSyncReady[Ti] == ZFALSE) { + jam(); + return; + }//if + }//for + GCPSaveConf * const saveConf = (GCPSaveConf *)&signal->theData[0]; + saveConf->dihPtr = localGcpPtr.p->gcpUserptr; + saveConf->nodeId = getOwnNodeId(); + saveConf->gci = localGcpPtr.p->gcpId; + sendSignal(localGcpPtr.p->gcpBlockref, GSN_GCP_SAVECONF, signal, + GCPSaveConf::SignalLength, JBA); + ccurrentGcprec = RNIL; +}//Dblqh::execFSSYNCCONF() + +void +Dblqh::execFSSYNCREF(Signal* signal) +{ + jamEntry(); + systemErrorLab(signal); + return; +}//Dblqh::execFSSYNCREF() + + +/* ######################################################################### */ +/* ####### FILE HANDLING MODULE ####### */ +/* */ +/* ######################################################################### */ +/* THIS MODULE HANDLES RESPONSE MESSAGES FROM THE FILE SYSTEM */ +/* ######################################################################### */ +/* ######################################################################### */ +/* SIGNAL RECEPTION MODULE */ +/* THIS MODULE IS A SUB-MODULE OF THE FILE SYSTEM HANDLING. */ +/* */ +/* THIS MODULE CHECKS THE STATE AND JUMPS TO THE PROPER PART OF THE FILE */ +/* HANDLING MODULE. */ +/* ######################################################################### */ +/* *************** */ +/* FSCLOSECONF > */ +/* *************** */ +void Dblqh::execFSCLOSECONF(Signal* signal) +{ + jamEntry(); + logFilePtr.i = signal->theData[0]; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + switch (logFilePtr.p->logFileStatus) { + case LogFileRecord::CLOSE_SR_INVALIDATE_PAGES: + jam(); + logFilePtr.p->logFileStatus = LogFileRecord::CLOSED; + // Set the prev file to check if we shall close it. + logFilePtr.i = logFilePtr.p->prevLogFile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + exitFromInvalidate(signal); + return; + break; + case LogFileRecord::CLOSING_INIT: + jam(); + closingInitLab(signal); + return; + break; + case LogFileRecord::CLOSING_SR: + jam(); + closingSrLab(signal); + return; + break; + case LogFileRecord::CLOSING_EXEC_SR: + jam(); + closeExecSrLab(signal); + return; + break; + case LogFileRecord::CLOSING_EXEC_SR_COMPLETED: + jam(); + closeExecSrCompletedLab(signal); + return; + break; + case LogFileRecord::CLOSING_WRITE_LOG: + jam(); + closeWriteLogLab(signal); + return; + break; + case LogFileRecord::CLOSING_EXEC_LOG: + jam(); + closeExecLogLab(signal); + return; + break; + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch +}//Dblqh::execFSCLOSECONF() + +/* ************>> */ +/* FSCLOSEREF > */ +/* ************>> */ +void Dblqh::execFSCLOSEREF(Signal* signal) +{ + jamEntry(); + terrorCode = signal->theData[1]; + systemErrorLab(signal); + return; +}//Dblqh::execFSCLOSEREF() + +/* ************>> */ +/* FSOPENCONF > */ +/* ************>> */ +void Dblqh::execFSOPENCONF(Signal* signal) +{ + jamEntry(); + initFsopenconf(signal); + switch (logFilePtr.p->logFileStatus) { + case LogFileRecord::OPEN_SR_INVALIDATE_PAGES: + jam(); + logFilePtr.p->logFileStatus = LogFileRecord::OPEN; + readFileInInvalidate(signal); + return; + break; + case LogFileRecord::OPENING_INIT: + jam(); + logFilePtr.p->logFileStatus = LogFileRecord::OPEN; + openFileInitLab(signal); + return; + break; + case LogFileRecord::OPEN_SR_FRONTPAGE: + jam(); + logFilePtr.p->logFileStatus = LogFileRecord::OPEN; + openSrFrontpageLab(signal); + return; + break; + case LogFileRecord::OPEN_SR_LAST_FILE: + jam(); + logFilePtr.p->logFileStatus = LogFileRecord::OPEN; + openSrLastFileLab(signal); + return; + break; + case LogFileRecord::OPEN_SR_NEXT_FILE: + jam(); + logFilePtr.p->logFileStatus = LogFileRecord::OPEN; + openSrNextFileLab(signal); + return; + break; + case LogFileRecord::OPEN_EXEC_SR_START: + jam(); + logFilePtr.p->logFileStatus = LogFileRecord::OPEN; + openExecSrStartLab(signal); + return; + break; + case LogFileRecord::OPEN_EXEC_SR_NEW_MBYTE: + jam(); + logFilePtr.p->logFileStatus = LogFileRecord::OPEN; + openExecSrNewMbyteLab(signal); + return; + break; + case LogFileRecord::OPEN_SR_FOURTH_PHASE: + jam(); + logFilePtr.p->logFileStatus = LogFileRecord::OPEN; + openSrFourthPhaseLab(signal); + return; + break; + case LogFileRecord::OPEN_SR_FOURTH_NEXT: + jam(); + logFilePtr.p->logFileStatus = LogFileRecord::OPEN; + openSrFourthNextLab(signal); + return; + break; + case LogFileRecord::OPEN_SR_FOURTH_ZERO: + jam(); + logFilePtr.p->logFileStatus = LogFileRecord::OPEN; + openSrFourthZeroLab(signal); + return; + break; + case LogFileRecord::OPENING_WRITE_LOG: + jam(); + logFilePtr.p->logFileStatus = LogFileRecord::OPEN; + return; + break; + case LogFileRecord::OPEN_EXEC_LOG: + jam(); + logFilePtr.p->logFileStatus = LogFileRecord::OPEN; + openExecLogLab(signal); + return; + break; + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch +}//Dblqh::execFSOPENCONF() + +/* ************> */ +/* FSOPENREF > */ +/* ************> */ +void Dblqh::execFSOPENREF(Signal* signal) +{ + jamEntry(); + terrorCode = signal->theData[1]; + systemErrorLab(signal); + return; +}//Dblqh::execFSOPENREF() + +/* ************>> */ +/* FSREADCONF > */ +/* ************>> */ +void Dblqh::execFSREADCONF(Signal* signal) +{ + jamEntry(); + initFsrwconf(signal); + + switch (lfoPtr.p->lfoState) { + case LogFileOperationRecord::READ_SR_LAST_MBYTE: + jam(); + releaseLfo(signal); + readSrLastMbyteLab(signal); + return; + break; + case LogFileOperationRecord::READ_SR_FRONTPAGE: + jam(); + releaseLfo(signal); + readSrFrontpageLab(signal); + return; + break; + case LogFileOperationRecord::READ_SR_LAST_FILE: + jam(); + releaseLfo(signal); + readSrLastFileLab(signal); + return; + break; + case LogFileOperationRecord::READ_SR_NEXT_FILE: + jam(); + releaseLfo(signal); + readSrNextFileLab(signal); + return; + break; + case LogFileOperationRecord::READ_EXEC_SR: + jam(); + readExecSrLab(signal); + return; + break; + case LogFileOperationRecord::READ_EXEC_LOG: + jam(); + readExecLogLab(signal); + return; + break; + case LogFileOperationRecord::READ_SR_INVALIDATE_PAGES: + jam(); + invalidateLogAfterLastGCI(signal); + return; + break; + case LogFileOperationRecord::READ_SR_FOURTH_PHASE: + jam(); + releaseLfo(signal); + readSrFourthPhaseLab(signal); + return; + break; + case LogFileOperationRecord::READ_SR_FOURTH_ZERO: + jam(); + releaseLfo(signal); + readSrFourthZeroLab(signal); + return; + break; + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch +}//Dblqh::execFSREADCONF() + +/* ************>> */ +/* FSREADCONF > */ +/* ************>> */ +void Dblqh::execFSREADREF(Signal* signal) +{ + jamEntry(); + lfoPtr.i = signal->theData[0]; + ptrCheckGuard(lfoPtr, clfoFileSize, logFileOperationRecord); + terrorCode = signal->theData[1]; + switch (lfoPtr.p->lfoState) { + case LogFileOperationRecord::READ_SR_LAST_MBYTE: + jam(); + systemErrorLab(signal); + return; + break; + case LogFileOperationRecord::READ_SR_FRONTPAGE: + jam(); + systemErrorLab(signal); + return; + break; + case LogFileOperationRecord::READ_SR_LAST_FILE: + jam(); + systemErrorLab(signal); + return; + break; + case LogFileOperationRecord::READ_SR_NEXT_FILE: + jam(); + systemErrorLab(signal); + return; + break; + case LogFileOperationRecord::READ_EXEC_SR: + jam(); + systemErrorLab(signal); + return; + break; + case LogFileOperationRecord::READ_EXEC_LOG: + jam(); + systemErrorLab(signal); + return; + break; + case LogFileOperationRecord::READ_SR_FOURTH_PHASE: + jam(); + systemErrorLab(signal); + return; + break; + case LogFileOperationRecord::READ_SR_FOURTH_ZERO: + jam(); + systemErrorLab(signal); + return; + break; + case LogFileOperationRecord::READ_SR_INVALIDATE_PAGES: + jam() + systemErrorLab(signal); + return; + break; + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch + return; +}//Dblqh::execFSREADREF() + +/* *************** */ +/* FSWRITECONF > */ +/* *************** */ +void Dblqh::execFSWRITECONF(Signal* signal) +{ + jamEntry(); + initFsrwconf(signal); + switch (lfoPtr.p->lfoState) { + case LogFileOperationRecord::WRITE_SR_INVALIDATE_PAGES: + jam(); + invalidateLogAfterLastGCI(signal); + return; + break; + case LogFileOperationRecord::WRITE_PAGE_ZERO: + jam(); + writePageZeroLab(signal); + return; + break; + case LogFileOperationRecord::LAST_WRITE_IN_FILE: + jam(); + lastWriteInFileLab(signal); + return; + break; + case LogFileOperationRecord::INIT_WRITE_AT_END: + jam(); + initWriteEndLab(signal); + return; + break; + case LogFileOperationRecord::INIT_FIRST_PAGE: + jam(); + initFirstPageLab(signal); + return; + break; + case LogFileOperationRecord::WRITE_GCI_ZERO: + jam(); + writeGciZeroLab(signal); + return; + break; + case LogFileOperationRecord::WRITE_DIRTY: + jam(); + writeDirtyLab(signal); + return; + break; + case LogFileOperationRecord::WRITE_INIT_MBYTE: + jam(); + writeInitMbyteLab(signal); + return; + break; + case LogFileOperationRecord::ACTIVE_WRITE_LOG: + jam(); + writeLogfileLab(signal); + return; + break; + case LogFileOperationRecord::FIRST_PAGE_WRITE_IN_LOGFILE: + jam(); + firstPageWriteLab(signal); + return; + break; + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch +}//Dblqh::execFSWRITECONF() + +/* ************>> */ +/* FSWRITEREF > */ +/* ************>> */ +void Dblqh::execFSWRITEREF(Signal* signal) +{ + jamEntry(); + lfoPtr.i = signal->theData[0]; + ptrCheckGuard(lfoPtr, clfoFileSize, logFileOperationRecord); + terrorCode = signal->theData[1]; + switch (lfoPtr.p->lfoState) { + case LogFileOperationRecord::WRITE_PAGE_ZERO: + jam(); + systemErrorLab(signal); + break; + case LogFileOperationRecord::LAST_WRITE_IN_FILE: + jam(); + systemErrorLab(signal); + break; + case LogFileOperationRecord::INIT_WRITE_AT_END: + jam(); + systemErrorLab(signal); + break; + case LogFileOperationRecord::INIT_FIRST_PAGE: + jam(); + systemErrorLab(signal); + break; + case LogFileOperationRecord::WRITE_GCI_ZERO: + jam(); + systemErrorLab(signal); + break; + case LogFileOperationRecord::WRITE_DIRTY: + jam(); + systemErrorLab(signal); + break; + case LogFileOperationRecord::WRITE_INIT_MBYTE: + jam(); + systemErrorLab(signal); + break; + case LogFileOperationRecord::ACTIVE_WRITE_LOG: + jam(); + systemErrorLab(signal); + break; + case LogFileOperationRecord::FIRST_PAGE_WRITE_IN_LOGFILE: + jam(); + systemErrorLab(signal); + break; + case LogFileOperationRecord::WRITE_SR_INVALIDATE_PAGES: + jam(); + systemErrorLab(signal); + break; + default: + jam(); + systemErrorLab(signal); + break; + }//switch +}//Dblqh::execFSWRITEREF() + + +/* ========================================================================= */ +/* ======= INITIATE WHEN RECEIVING FSOPENCONF ======= */ +/* */ +/* ========================================================================= */ +void Dblqh::initFsopenconf(Signal* signal) +{ + logFilePtr.i = signal->theData[0]; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + logFilePtr.p->fileRef = signal->theData[1]; + logPartPtr.i = logFilePtr.p->logPartRec; + ptrCheckGuard(logPartPtr, clogPartFileSize, logPartRecord); + logFilePtr.p->currentMbyte = 0; + logFilePtr.p->filePosition = 0; + logFilePtr.p->logFilePagesToDiskWithoutSynch = 0; +}//Dblqh::initFsopenconf() + +/* ========================================================================= */ +/* ======= INITIATE WHEN RECEIVING FSREADCONF AND FSWRITECONF ======= */ +/* */ +/* ========================================================================= */ +void Dblqh::initFsrwconf(Signal* signal) +{ + lfoPtr.i = signal->theData[0]; + ptrCheckGuard(lfoPtr, clfoFileSize, logFileOperationRecord); + logFilePtr.i = lfoPtr.p->logFileRec; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + logPartPtr.i = logFilePtr.p->logPartRec; + ptrCheckGuard(logPartPtr, clogPartFileSize, logPartRecord); + logPagePtr.i = lfoPtr.p->firstLfoPage; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); +}//Dblqh::initFsrwconf() + +/* ######################################################################### */ +/* NORMAL OPERATION MODULE */ +/* THIS MODULE IS A SUB-MODULE OF THE FILE SYSTEM HANDLING. */ +/* */ +/* THIS PART HANDLES THE NORMAL OPENING, CLOSING AND WRITING OF LOG FILES */ +/* DURING NORMAL OPERATION. */ +/* ######################################################################### */ +/*---------------------------------------------------------------------------*/ +/* THIS SIGNAL IS USED TO SUPERVISE THAT THE LOG RECORDS ARE NOT KEPT IN MAIN*/ +/* MEMORY FOR MORE THAN 1 SECOND TO ACHIEVE THE PROPER RELIABILITY. */ +/*---------------------------------------------------------------------------*/ +void Dblqh::timeSup(Signal* signal) +{ + LogPageRecordPtr origLogPagePtr; + Uint32 wordWritten; + + jamEntry(); + logPartPtr.i = signal->theData[0]; + ptrCheckGuard(logPartPtr, clogPartFileSize, logPartRecord); + logFilePtr.i = logPartPtr.p->currentLogfile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + logPagePtr.i = logFilePtr.p->currentLogpage; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + if (logPartPtr.p->logPartTimer != logPartPtr.p->logTimer) { + jam(); +/*--------------------------------------------------------------------------*/ +/* THIS LOG PART HAS NOT WRITTEN TO DISK DURING THE LAST SECOND. */ +/*--------------------------------------------------------------------------*/ + switch (logPartPtr.p->logPartState) { + case LogPartRecord::FILE_CHANGE_PROBLEM: + jam(); +/*--------------------------------------------------------------------------*/ +/* THIS LOG PART HAS PROBLEMS IN CHANGING FILES MAKING IT IMPOSSIBLE */ +// TO WRITE TO THE FILE CURRENTLY. WE WILL COMEBACK LATER AND SEE IF +// THE PROBLEM HAS BEEN FIXED. +/*--------------------------------------------------------------------------*/ + case LogPartRecord::ACTIVE: + jam(); +/*---------------------------------------------------------------------------*/ +/* AN OPERATION IS CURRENTLY ACTIVE IN WRITING THIS LOG PART. WE THUS CANNOT */ +/* WRITE ANYTHING TO DISK AT THIS MOMENT. WE WILL SEND A SIGNAL DELAYED FOR */ +/* 10 MS AND THEN TRY AGAIN. POSSIBLY THE LOG PART WILL HAVE BEEN WRITTEN */ +/* UNTIL THEN OR ELSE IT SHOULD BE FREE TO WRITE AGAIN. */ +/*---------------------------------------------------------------------------*/ + signal->theData[0] = ZTIME_SUPERVISION; + signal->theData[1] = logPartPtr.i; + sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 10, 2); + return; + break; + case LogPartRecord::IDLE: + case LogPartRecord::TAIL_PROBLEM: + jam(); +/*---------------------------------------------------------------------------*/ +/* IDLE AND NOT WRITTEN TO DISK IN A SECOND. ALSO WHEN WE HAVE A TAIL PROBLEM*/ +/* WE HAVE TO WRITE TO DISK AT TIMES. WE WILL FIRST CHECK WHETHER ANYTHING */ +/* AT ALL HAVE BEEN WRITTEN TO THE PAGES BEFORE WRITING TO DISK. */ +/*---------------------------------------------------------------------------*/ +/* WE HAVE TO WRITE TO DISK IN ALL CASES SINCE THERE COULD BE INFORMATION */ +/* STILL IN THE LOG THAT WAS GENERATED BEFORE THE PREVIOUS TIME SUPERVISION */ +/* BUT AFTER THE LAST DISK WRITE. THIS PREVIOUSLY STOPPED ALL DISK WRITES */ +/* WHEN NO MORE LOG WRITES WERE PERFORMED (THIS HAPPENED WHEN LOG GOT FULL */ +/* AND AFTER LOADING THE INITIAL RECORDS IN INITIAL START). */ +/*---------------------------------------------------------------------------*/ + if (((logFilePtr.p->currentFilepage + 1) & (ZPAGES_IN_MBYTE -1)) == 0) { + jam(); +/*---------------------------------------------------------------------------*/ +/* THIS IS THE LAST PAGE IN THIS MBYTE. WRITE NEXT LOG AND SWITCH TO NEXT */ +/* MBYTE. */ +/*---------------------------------------------------------------------------*/ + changeMbyte(signal); + } else { +/*---------------------------------------------------------------------------*/ +/* WRITE THE LOG PAGE TO DISK EVEN IF IT IS NOT FULL. KEEP PAGE AND WRITE A */ +/* COPY. THE ORIGINAL PAGE WILL BE WRITTEN AGAIN LATER ON. */ +/*---------------------------------------------------------------------------*/ + wordWritten = logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] - 1; + origLogPagePtr.i = logPagePtr.i; + origLogPagePtr.p = logPagePtr.p; + seizeLogpage(signal); + MEMCOPY_NO_WORDS(&logPagePtr.p->logPageWord[0], + &origLogPagePtr.p->logPageWord[0], + wordWritten + 1); + ndbrequire(wordWritten < ZPAGE_SIZE); + if (logFilePtr.p->noLogpagesInBuffer > 0) { + jam(); + completedLogPage(signal, ZENFORCE_WRITE); +/*---------------------------------------------------------------------------*/ +/*SINCE WE ARE ONLY WRITING PART OF THE LAST PAGE WE HAVE TO UPDATE THE WORD */ +/*WRITTEN TO REFLECT THE REAL LAST WORD WRITTEN. WE ALSO HAVE TO MOVE THE */ +/*FILE POSITION ONE STEP BACKWARDS SINCE WE ARE NOT WRITING THE LAST PAGE */ +/*COMPLETELY. IT WILL BE WRITTEN AGAIN. */ +/*---------------------------------------------------------------------------*/ + lfoPtr.p->lfoWordWritten = wordWritten; + logFilePtr.p->filePosition = logFilePtr.p->filePosition - 1; + } else { + if (wordWritten == (ZPAGE_HEADER_SIZE - 1)) { +/*---------------------------------------------------------------------------*/ +/*THIS IS POSSIBLE BUT VERY UNLIKELY. IF THE PAGE WAS COMPLETED AFTER THE LAST*/ +/*WRITE TO DISK THEN NO_LOG_PAGES_IN_BUFFER > 0 AND IF NOT WRITTEN SINCE LAST*/ +/*WRITE TO DISK THEN THE PREVIOUS PAGE MUST HAVE BEEN WRITTEN BY SOME */ +/*OPERATION AND THAT BECAME COMPLETELY FULL. IN ANY CASE WE NEED NOT WRITE AN*/ +/*EMPTY PAGE TO DISK. */ +/*---------------------------------------------------------------------------*/ + jam(); + releaseLogpage(signal); + } else { + jam(); + writeSinglePage(signal, logFilePtr.p->currentFilepage, wordWritten); + lfoPtr.p->lfoState = LogFileOperationRecord::ACTIVE_WRITE_LOG; + }//if + }//if + }//if + break; + default: + ndbrequire(false); + break; + }//switch + }//if + logPartPtr.p->logTimer++; + return; +}//Dblqh::timeSup() + +void Dblqh::writeLogfileLab(Signal* signal) +{ +/*---------------------------------------------------------------------------*/ +/* CHECK IF ANY GLOBAL CHECKPOINTS ARE COMPLETED DUE TO THIS COMPLETED DISK */ +/* WRITE. */ +/*---------------------------------------------------------------------------*/ + switch (logFilePtr.p->fileChangeState) { + case LogFileRecord::NOT_ONGOING: + jam(); + checkGcpCompleted(signal, + ((lfoPtr.p->lfoPageNo + lfoPtr.p->noPagesRw) - 1), + lfoPtr.p->lfoWordWritten); + break; + case LogFileRecord::WRITE_PAGE_ZERO_ONGOING: + case LogFileRecord::LAST_WRITE_ONGOING: + jam(); + logFilePtr.p->lastPageWritten = (lfoPtr.p->lfoPageNo + lfoPtr.p->noPagesRw) - 1; + logFilePtr.p->lastWordWritten = lfoPtr.p->lfoWordWritten; + break; + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch + releaseLfoPages(signal); + releaseLfo(signal); + return; +}//Dblqh::writeLogfileLab() + +void Dblqh::closeWriteLogLab(Signal* signal) +{ + logFilePtr.p->logFileStatus = LogFileRecord::CLOSED; + return; +}//Dblqh::closeWriteLogLab() + +/* ######################################################################### */ +/* FILE CHANGE MODULE */ +/* THIS MODULE IS A SUB-MODULE OF THE FILE SYSTEM HANDLING. */ +/* */ +/*THIS PART OF THE FILE MODULE HANDLES WHEN WE ARE CHANGING LOG FILE DURING */ +/*NORMAL OPERATION. WE HAVE TO BE CAREFUL WHEN WE ARE CHANGING LOG FILE SO */ +/*THAT WE DO NOT COMPLICATE THE SYSTEM RESTART PROCESS TOO MUCH. */ +/*THE IDEA IS THAT WE START BY WRITING THE LAST WRITE IN THE OLD FILE AND WE */ +/*ALSO WRITE THE FIRST PAGE OF THE NEW FILE CONCURRENT WITH THAT. THIS FIRST */ +/*PAGE IN THE NEW FILE DO NOT CONTAIN ANY LOG RECORDS OTHER THAN A DESCRIPTOR*/ +/*CONTAINING INFORMATION ABOUT GCI'S NEEDED AT SYSTEM RESTART AND A NEXT LOG */ +/*RECORD. */ +/* */ +/*WHEN BOTH OF THOSE WRITES HAVE COMPLETED WE ALSO WRITE PAGE ZERO IN FILE */ +/*ZERO. THE ONLY INFORMATION WHICH IS INTERESTING HERE IS THE NEW FILE NUMBER*/ +/* */ +/*IF OPTIMISATIONS ARE NEEDED OF THE LOG HANDLING THEN IT IS POSSIBLE TO */ +/*AVOID WRITING THE FIRST PAGE OF THE NEW PAGE IMMEDIATELY. THIS COMPLICATES */ +/*THE SYSTEM RESTART AND ONE HAS TO TAKE SPECIAL CARE WITH FILE ZERO. IT IS */ +/*HOWEVER NO LARGE PROBLEM TO CHANGE INTO THIS SCENARIO. TO AVOID ALSO THE */ +/*WRITING OF PAGE ZERO IS ALSO POSSIBLE BUT COMPLICATES THE DESIGN EVEN */ +/*FURTHER. IT GETS FAIRLY COMPLEX TO FIND THE END OF THE LOG. SOME SORT OF */ +/*BINARY SEARCH IS HOWEVER MOST LIKELY A GOOD METHODOLOGY FOR THIS. */ +/* ######################################################################### */ +void Dblqh::firstPageWriteLab(Signal* signal) +{ + releaseLfo(signal); +/*---------------------------------------------------------------------------*/ +/* RELEASE PAGE ZERO IF THE FILE IS NOT FILE 0. */ +/*---------------------------------------------------------------------------*/ + Uint32 fileNo = logFilePtr.p->fileNo; + if (fileNo != 0) { + jam(); + releaseLogpage(signal); + }//if +/*---------------------------------------------------------------------------*/ +/* IF A NEW FILE HAS BEEN OPENED WE SHALL ALWAYS ALSO WRITE TO PAGE O IN */ +/* FILE 0. THE AIM IS TO MAKE RESTARTS EASIER BY SPECIFYING WHICH IS THE */ +/* LAST FILE WHERE LOGGING HAS STARTED. */ +/*---------------------------------------------------------------------------*/ +/* FIRST CHECK WHETHER THE LAST WRITE IN THE PREVIOUS FILE HAVE COMPLETED */ +/*---------------------------------------------------------------------------*/ + if (logFilePtr.p->fileChangeState == LogFileRecord::BOTH_WRITES_ONGOING) { + jam(); +/*---------------------------------------------------------------------------*/ +/* THE LAST WRITE WAS STILL ONGOING. */ +/*---------------------------------------------------------------------------*/ + logFilePtr.p->fileChangeState = LogFileRecord::LAST_WRITE_ONGOING; + return; + } else { + jam(); + ndbrequire(logFilePtr.p->fileChangeState == LogFileRecord::FIRST_WRITE_ONGOING); +/*---------------------------------------------------------------------------*/ +/* WRITE TO PAGE 0 IN IN FILE 0 NOW. */ +/*---------------------------------------------------------------------------*/ + logFilePtr.p->fileChangeState = LogFileRecord::WRITE_PAGE_ZERO_ONGOING; + if (fileNo == 0) { + jam(); +/*---------------------------------------------------------------------------*/ +/* IF THE NEW FILE WAS 0 THEN WE HAVE ALREADY WRITTEN PAGE ZERO IN FILE 0. */ +/*---------------------------------------------------------------------------*/ + logFilePtr.p->fileChangeState = LogFileRecord::NOT_ONGOING; + return; + } else { + jam(); +/*---------------------------------------------------------------------------*/ +/* WRITE PAGE ZERO IN FILE ZERO. LOG_FILE_REC WILL REFER TO THE LOG FILE WE */ +/* HAVE JUST WRITTEN PAGE ZERO IN TO GET HOLD OF LOG_FILE_PTR FOR THIS */ +/* RECORD QUICKLY. THIS IS NEEDED TO GET HOLD OF THE FILE_CHANGE_STATE. */ +/* THE ONLY INFORMATION WE WANT TO CHANGE IS THE LAST FILE NUMBER IN THE */ +/* FILE DESCRIPTOR. THIS IS USED AT SYSTEM RESTART TO FIND THE END OF THE */ +/* LOG PART. */ +/*---------------------------------------------------------------------------*/ + Uint32 currLogFile = logFilePtr.i; + logFilePtr.i = logPartPtr.p->firstLogfile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + logPagePtr.i = logFilePtr.p->logPageZero; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + logPagePtr.p->logPageWord[ZPAGE_HEADER_SIZE + ZPOS_FILE_NO] = fileNo; + writeSinglePage(signal, 0, ZPAGE_SIZE - 1); + lfoPtr.p->logFileRec = currLogFile; + lfoPtr.p->lfoState = LogFileOperationRecord::WRITE_PAGE_ZERO; + return; + }//if + }//if +}//Dblqh::firstPageWriteLab() + +void Dblqh::lastWriteInFileLab(Signal* signal) +{ + LogFileRecordPtr locLogFilePtr; +/*---------------------------------------------------------------------------*/ +/* CHECK IF ANY GLOBAL CHECKPOINTS ARE COMPLETED DUE TO THIS COMPLETED DISK */ +/* WRITE. */ +/*---------------------------------------------------------------------------*/ + checkGcpCompleted(signal, + ((lfoPtr.p->lfoPageNo + lfoPtr.p->noPagesRw) - 1), + (ZPAGE_SIZE - 1)); + releaseLfoPages(signal); + releaseLfo(signal); +/*---------------------------------------------------------------------------*/ +/* IF THE FILE IS NOT IN USE OR THE NEXT FILE TO BE USED WE WILL CLOSE IT. */ +/*---------------------------------------------------------------------------*/ + locLogFilePtr.i = logPartPtr.p->currentLogfile; + ptrCheckGuard(locLogFilePtr, clogFileFileSize, logFileRecord); + if (logFilePtr.i != locLogFilePtr.i) { + if (logFilePtr.i != locLogFilePtr.p->nextLogFile) { + if (logFilePtr.p->fileNo != 0) { + jam(); +/*---------------------------------------------------------------------------*/ +/* THE FILE IS NOT FILE ZERO EITHER. WE WILL NOT CLOSE FILE ZERO SINCE WE */ +/* USE IT TO KEEP TRACK OF THE CURRENT LOG FILE BY WRITING PAGE ZERO IN */ +/* FILE ZERO. */ +/*---------------------------------------------------------------------------*/ +/* WE WILL CLOSE THE FILE. */ +/*---------------------------------------------------------------------------*/ + logFilePtr.p->logFileStatus = LogFileRecord::CLOSING_WRITE_LOG; + closeFile(signal, logFilePtr); + }//if + }//if + }//if +/*---------------------------------------------------------------------------*/ +/* IF A NEW FILE HAS BEEN OPENED WE SHALL ALWAYS ALSO WRITE TO PAGE O IN */ +/* FILE 0. THE AIM IS TO MAKE RESTARTS EASIER BY SPECIFYING WHICH IS THE */ +/* LAST FILE WHERE LOGGING HAS STARTED. */ +/*---------------------------------------------------------------------------*/ +/* FIRST CHECK WHETHER THE FIRST WRITE IN THE NEW FILE HAVE COMPLETED */ +/* THIS STATE INFORMATION IS IN THE NEW LOG FILE AND THUS WE HAVE TO MOVE */ +/* THE LOG FILE POINTER TO THIS LOG FILE. */ +/*---------------------------------------------------------------------------*/ + logFilePtr.i = logFilePtr.p->nextLogFile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + if (logFilePtr.p->fileChangeState == LogFileRecord::BOTH_WRITES_ONGOING) { + jam(); +/*---------------------------------------------------------------------------*/ +/* THE FIRST WRITE WAS STILL ONGOING. */ +/*---------------------------------------------------------------------------*/ + logFilePtr.p->fileChangeState = LogFileRecord::FIRST_WRITE_ONGOING; + return; + } else { + ndbrequire(logFilePtr.p->fileChangeState == LogFileRecord::LAST_WRITE_ONGOING); +/*---------------------------------------------------------------------------*/ +/* WRITE TO PAGE 0 IN IN FILE 0 NOW. */ +/*---------------------------------------------------------------------------*/ + logFilePtr.p->fileChangeState = LogFileRecord::WRITE_PAGE_ZERO_ONGOING; + Uint32 fileNo = logFilePtr.p->fileNo; + if (fileNo == 0) { + jam(); +/*---------------------------------------------------------------------------*/ +/* IF THE NEW FILE WAS 0 THEN WE HAVE ALREADY WRITTEN PAGE ZERO IN FILE 0. */ +/*---------------------------------------------------------------------------*/ + logFilePtr.p->fileChangeState = LogFileRecord::NOT_ONGOING; + return; + } else { + jam(); +/*---------------------------------------------------------------------------*/ +/* WRITE PAGE ZERO IN FILE ZERO. LOG_FILE_REC WILL REFER TO THE LOG FILE WE */ +/* HAVE JUST WRITTEN PAGE ZERO IN TO GET HOLD OF LOG_FILE_PTR FOR THIS */ +/* RECORD QUICKLY. THIS IS NEEDED TO GET HOLD OF THE FILE_CHANGE_STATE. */ +/* THE ONLY INFORMATION WE WANT TO CHANGE IS THE LAST FILE NUMBER IN THE */ +/* FILE DESCRIPTOR. THIS IS USED AT SYSTEM RESTART TO FIND THE END OF THE */ +/* LOG PART. */ +/*---------------------------------------------------------------------------*/ + Uint32 currLogFile = logFilePtr.i; + logFilePtr.i = logPartPtr.p->firstLogfile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + logPagePtr.i = logFilePtr.p->logPageZero; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + logPagePtr.p->logPageWord[ZPAGE_HEADER_SIZE + ZPOS_FILE_NO] = fileNo; + writeSinglePage(signal, 0, ZPAGE_SIZE - 1); + lfoPtr.p->logFileRec = currLogFile; + lfoPtr.p->lfoState = LogFileOperationRecord::WRITE_PAGE_ZERO; + return; + }//if + }//if +}//Dblqh::lastWriteInFileLab() + +void Dblqh::writePageZeroLab(Signal* signal) +{ + logFilePtr.p->fileChangeState = LogFileRecord::NOT_ONGOING; +/*---------------------------------------------------------------------------*/ +/* IT COULD HAVE ARRIVED PAGE WRITES TO THE CURRENT FILE WHILE WE WERE */ +/* WAITING FOR THIS DISK WRITE TO COMPLETE. THEY COULD NOT CHECK FOR */ +/* COMPLETED GLOBAL CHECKPOINTS. THUS WE SHOULD DO THAT NOW INSTEAD. */ +/*---------------------------------------------------------------------------*/ + checkGcpCompleted(signal, + logFilePtr.p->lastPageWritten, + logFilePtr.p->lastWordWritten); + releaseLfo(signal); + return; +}//Dblqh::writePageZeroLab() + +/* ######################################################################### */ +/* INITIAL START MODULE */ +/* THIS MODULE IS A SUB-MODULE OF THE FILE SYSTEM HANDLING. */ +/* */ +/*THIS MODULE INITIALISES ALL THE LOG FILES THAT ARE NEEDED AT A SYSTEM */ +/*RESTART AND WHICH ARE USED DURING NORMAL OPERATIONS. IT CREATES THE FILES */ +/*AND SETS A PROPER SIZE OF THEM AND INITIALISES THE FIRST PAGE IN EACH FILE */ +/* ######################################################################### */ +void Dblqh::openFileInitLab(Signal* signal) +{ + logFilePtr.p->logFileStatus = LogFileRecord::OPEN_INIT; + seizeLogpage(signal); + writeSinglePage(signal, (ZNO_MBYTES_IN_FILE * ZPAGES_IN_MBYTE) - 1, ZPAGE_SIZE - 1); + lfoPtr.p->lfoState = LogFileOperationRecord::INIT_WRITE_AT_END; + return; +}//Dblqh::openFileInitLab() + +void Dblqh::initWriteEndLab(Signal* signal) +{ + releaseLfo(signal); + initLogpage(signal); + if (logFilePtr.p->fileNo == 0) { + jam(); +/*---------------------------------------------------------------------------*/ +/* PAGE ZERO IN FILE ZERO MUST SET LOG LAP TO ONE SINCE IT HAS STARTED */ +/* WRITING TO THE LOG, ALSO GLOBAL CHECKPOINTS ARE SET TO ZERO. */ +/*---------------------------------------------------------------------------*/ + logPagePtr.p->logPageWord[ZPOS_LOG_LAP] = 1; + logPagePtr.p->logPageWord[ZPOS_MAX_GCI_STARTED] = 0; + logPagePtr.p->logPageWord[ZPOS_MAX_GCI_COMPLETED] = 0; + logFilePtr.p->logMaxGciStarted[0] = 0; + logFilePtr.p->logMaxGciCompleted[0] = 0; + }//if +/*---------------------------------------------------------------------------*/ +/* REUSE CODE FOR INITIALISATION OF FIRST PAGE IN ALL LOG FILES. */ +/*---------------------------------------------------------------------------*/ + writeFileHeaderOpen(signal, ZINIT); + return; +}//Dblqh::initWriteEndLab() + +void Dblqh::initFirstPageLab(Signal* signal) +{ + releaseLfo(signal); + if (logFilePtr.p->fileNo == 0) { + jam(); +/*---------------------------------------------------------------------------*/ +/* IN FILE ZERO WE WILL INSERT A PAGE ONE WHERE WE WILL INSERT A COMPLETED */ +/* GCI RECORD FOR GCI = 0. */ +/*---------------------------------------------------------------------------*/ + initLogpage(signal); + logPagePtr.p->logPageWord[ZPOS_LOG_LAP] = 1; + logPagePtr.p->logPageWord[ZPAGE_HEADER_SIZE] = ZCOMPLETED_GCI_TYPE; + logPagePtr.p->logPageWord[ZPAGE_HEADER_SIZE + 1] = 1; + writeSinglePage(signal, 1, ZPAGE_SIZE - 1); + lfoPtr.p->lfoState = LogFileOperationRecord::WRITE_GCI_ZERO; + return; + }//if + logFilePtr.p->currentMbyte = 1; + writeInitMbyte(signal); + return; +}//Dblqh::initFirstPageLab() + +void Dblqh::writeGciZeroLab(Signal* signal) +{ + releaseLfo(signal); + logFilePtr.p->currentMbyte = 1; + writeInitMbyte(signal); + return; +}//Dblqh::writeGciZeroLab() + +void Dblqh::writeInitMbyteLab(Signal* signal) +{ + releaseLfo(signal); + logFilePtr.p->currentMbyte = logFilePtr.p->currentMbyte + 1; + if (logFilePtr.p->currentMbyte == ZNO_MBYTES_IN_FILE) { + jam(); + releaseLogpage(signal); + logFilePtr.p->logFileStatus = LogFileRecord::CLOSING_INIT; + closeFile(signal, logFilePtr); + return; + }//if + writeInitMbyte(signal); + return; +}//Dblqh::writeInitMbyteLab() + +void Dblqh::closingInitLab(Signal* signal) +{ + logFilePtr.p->logFileStatus = LogFileRecord::CLOSED; + logPartPtr.i = logFilePtr.p->logPartRec; + ptrCheckGuard(logPartPtr, clogPartFileSize, logPartRecord); + if (logFilePtr.p->nextLogFile == logPartPtr.p->firstLogfile) { + jam(); + checkInitCompletedLab(signal); + return; + } else { + jam(); + logFilePtr.i = logFilePtr.p->nextLogFile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + openLogfileInit(signal); + }//if + return; +}//Dblqh::closingInitLab() + +void Dblqh::checkInitCompletedLab(Signal* signal) +{ + logPartPtr.p->logPartState = LogPartRecord::SR_FIRST_PHASE_COMPLETED; +/*---------------------------------------------------------------------------*/ +/* WE HAVE NOW INITIALISED ALL FILES IN THIS LOG PART. WE CAN NOW SET THE */ +/* THE LOG LAP TO ONE SINCE WE WILL START WITH LOG LAP ONE. LOG LAP = ZERO */ +/* MEANS THIS PART OF THE LOG IS NOT WRITTEN YET. */ +/*---------------------------------------------------------------------------*/ + logPartPtr.p->logLap = 1; + logPartPtr.i = 0; +CHECK_LOG_PARTS_LOOP: + ptrAss(logPartPtr, logPartRecord); + if (logPartPtr.p->logPartState != LogPartRecord::SR_FIRST_PHASE_COMPLETED) { + jam(); +/*---------------------------------------------------------------------------*/ +/* THIS PART HAS STILL NOT COMPLETED. WAIT FOR THIS TO OCCUR. */ +/*---------------------------------------------------------------------------*/ + return; + }//if + if (logPartPtr.i == 3) { + jam(); +/*---------------------------------------------------------------------------*/ +/* ALL LOG PARTS ARE COMPLETED. NOW WE CAN CONTINUE WITH THE RESTART */ +/* PROCESSING. THE NEXT STEP IS TO PREPARE FOR EXECUTING OPERATIONS. THUS WE */ +/* NEED TO INITIALISE ALL NEEDED DATA AND TO OPEN FILE ZERO AND THE NEXT AND */ +/* TO SET THE CURRENT LOG PAGE TO BE PAGE 1 IN FILE ZERO. */ +/*---------------------------------------------------------------------------*/ + for (logPartPtr.i = 0; logPartPtr.i <= 3; logPartPtr.i++) { + ptrAss(logPartPtr, logPartRecord); + signal->theData[0] = ZINIT_FOURTH; + signal->theData[1] = logPartPtr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + }//for + return; + } else { + jam(); + logPartPtr.i = logPartPtr.i + 1; + goto CHECK_LOG_PARTS_LOOP; + }//if +}//Dblqh::checkInitCompletedLab() + +/* ========================================================================= */ +/* ======= INITIATE LOG FILE OPERATION RECORD WHEN ALLOCATED ======= */ +/* */ +/* ========================================================================= */ +void Dblqh::initLfo(Signal* signal) +{ + lfoPtr.p->firstLfoPage = RNIL; + lfoPtr.p->lfoState = LogFileOperationRecord::IDLE; + lfoPtr.p->logFileRec = logFilePtr.i; + lfoPtr.p->noPagesRw = 0; + lfoPtr.p->lfoPageNo = ZNIL; +}//Dblqh::initLfo() + +/* ========================================================================= */ +/* ======= INITIATE LOG FILE WHEN ALLOCATED ======= */ +/* */ +/* INPUT: TFILE_NO NUMBER OF THE FILE INITIATED */ +/* LOG_PART_PTR NUMBER OF LOG PART */ +/* SUBROUTINE SHORT NAME = IL */ +/* ========================================================================= */ +void Dblqh::initLogfile(Signal* signal, Uint32 fileNo) +{ + UintR tilTmp; + UintR tilIndex; + + logFilePtr.p->currentFilepage = 0; + logFilePtr.p->currentLogpage = RNIL; + logFilePtr.p->fileName[0] = (UintR)-1; + logFilePtr.p->fileName[1] = (UintR)-1; /* = H'FFFFFFFF = -1 */ + logFilePtr.p->fileName[2] = fileNo; /* Sfile_no */ + tilTmp = 1; /* VERSION 1 OF FILE NAME */ + tilTmp = (tilTmp << 8) + 1; /* FRAGMENT LOG => .FRAGLOG AS EXTENSION */ + tilTmp = (tilTmp << 8) + (8 + logPartPtr.i); /* DIRECTORY = D(8+Part)/DBLQH */ + tilTmp = (tilTmp << 8) + 255; /* IGNORE Pxx PART OF FILE NAME */ + logFilePtr.p->fileName[3] = tilTmp; +/* ========================================================================= */ +/* FILE NAME BECOMES /D2/DBLQH/Tpart_no/Sfile_no.FRAGLOG */ +/* ========================================================================= */ + logFilePtr.p->fileNo = fileNo; + logFilePtr.p->filePosition = 0; + logFilePtr.p->firstLfo = RNIL; + logFilePtr.p->lastLfo = RNIL; + logFilePtr.p->logFileStatus = LogFileRecord::CLOSED; + logFilePtr.p->logPartRec = logPartPtr.i; + logFilePtr.p->noLogpagesInBuffer = 0; + logFilePtr.p->firstFilledPage = RNIL; + logFilePtr.p->lastFilledPage = RNIL; + logFilePtr.p->lastPageWritten = 0; + logFilePtr.p->logPageZero = RNIL; + logFilePtr.p->currentMbyte = 0; + for (tilIndex = 0; tilIndex <= 15; tilIndex++) { + logFilePtr.p->logMaxGciCompleted[tilIndex] = (UintR)-1; + logFilePtr.p->logMaxGciStarted[tilIndex] = (UintR)-1; + logFilePtr.p->logLastPrepRef[tilIndex] = 0; + }//for +}//Dblqh::initLogfile() + +/* ========================================================================= */ +/* ======= INITIATE LOG PAGE WHEN ALLOCATED ======= */ +/* */ +/* ========================================================================= */ +void Dblqh::initLogpage(Signal* signal) +{ + TcConnectionrecPtr ilpTcConnectptr; + + logPagePtr.p->logPageWord[ZPOS_LOG_LAP] = logPartPtr.p->logLap; + logPagePtr.p->logPageWord[ZPOS_MAX_GCI_COMPLETED] = + logPartPtr.p->logPartNewestCompletedGCI; + logPagePtr.p->logPageWord[ZPOS_MAX_GCI_STARTED] = cnewestGci; + logPagePtr.p->logPageWord[ZPOS_VERSION] = NDB_VERSION; + logPagePtr.p->logPageWord[ZPOS_NO_LOG_FILES] = logPartPtr.p->noLogFiles; + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = ZPAGE_HEADER_SIZE; + ilpTcConnectptr.i = logPartPtr.p->firstLogTcrec; + if (ilpTcConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(ilpTcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + logPagePtr.p->logPageWord[ZLAST_LOG_PREP_REF] = + (ilpTcConnectptr.p->logStartFileNo << 16) + + (ilpTcConnectptr.p->logStartPageNo >> ZTWOLOG_NO_PAGES_IN_MBYTE); + } else { + jam(); + logPagePtr.p->logPageWord[ZLAST_LOG_PREP_REF] = + (logFilePtr.p->fileNo << 16) + + (logFilePtr.p->currentFilepage >> ZTWOLOG_NO_PAGES_IN_MBYTE); + }//if +}//Dblqh::initLogpage() + +/* ------------------------------------------------------------------------- */ +/* ------- OPEN LOG FILE FOR READ AND WRITE ------- */ +/* */ +/* SUBROUTINE SHORT NAME = OFR */ +/* ------------------------------------------------------------------------- */ +void Dblqh::openFileRw(Signal* signal, LogFileRecordPtr olfLogFilePtr) +{ + signal->theData[0] = cownref; + signal->theData[1] = olfLogFilePtr.i; + signal->theData[2] = olfLogFilePtr.p->fileName[0]; + signal->theData[3] = olfLogFilePtr.p->fileName[1]; + signal->theData[4] = olfLogFilePtr.p->fileName[2]; + signal->theData[5] = olfLogFilePtr.p->fileName[3]; + signal->theData[6] = ZOPEN_READ_WRITE; + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA); +}//Dblqh::openFileRw() + +/* ------------------------------------------------------------------------- */ +/* ------- OPEN LOG FILE DURING INITIAL START ------- */ +/* */ +/* SUBROUTINE SHORT NAME = OLI */ +/* ------------------------------------------------------------------------- */ +void Dblqh::openLogfileInit(Signal* signal) +{ + logFilePtr.p->logFileStatus = LogFileRecord::OPENING_INIT; + signal->theData[0] = cownref; + signal->theData[1] = logFilePtr.i; + signal->theData[2] = logFilePtr.p->fileName[0]; + signal->theData[3] = logFilePtr.p->fileName[1]; + signal->theData[4] = logFilePtr.p->fileName[2]; + signal->theData[5] = logFilePtr.p->fileName[3]; + signal->theData[6] = 0x302; + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA); +}//Dblqh::openLogfileInit() + +/* OPEN FOR READ/WRITE, DO CREATE AND DO TRUNCATE FILE */ +/* ------------------------------------------------------------------------- */ +/* ------- OPEN NEXT LOG FILE ------- */ +/* */ +/* SUBROUTINE SHORT NAME = ONL */ +/* ------------------------------------------------------------------------- */ +void Dblqh::openNextLogfile(Signal* signal) +{ + LogFileRecordPtr onlLogFilePtr; + + if (logPartPtr.p->noLogFiles > 2) { + jam(); +/* -------------------------------------------------- */ +/* IF ONLY 1 OR 2 LOG FILES EXIST THEN THEY ARE */ +/* ALWAYS OPEN AND THUS IT IS NOT NECESSARY TO */ +/* OPEN THEM NOW. */ +/* -------------------------------------------------- */ + onlLogFilePtr.i = logFilePtr.p->nextLogFile; + ptrCheckGuard(onlLogFilePtr, clogFileFileSize, logFileRecord); + if (onlLogFilePtr.p->logFileStatus != LogFileRecord::CLOSED) { + ndbrequire(onlLogFilePtr.p->fileNo == 0); + return; + }//if + onlLogFilePtr.p->logFileStatus = LogFileRecord::OPENING_WRITE_LOG; + signal->theData[0] = cownref; + signal->theData[1] = onlLogFilePtr.i; + signal->theData[2] = onlLogFilePtr.p->fileName[0]; + signal->theData[3] = onlLogFilePtr.p->fileName[1]; + signal->theData[4] = onlLogFilePtr.p->fileName[2]; + signal->theData[5] = onlLogFilePtr.p->fileName[3]; + signal->theData[6] = 2; + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA); + }//if +}//Dblqh::openNextLogfile() + + /* OPEN FOR READ/WRITE, DON'T CREATE AND DON'T TRUNCATE FILE */ +/* ------------------------------------------------------------------------- */ +/* ------- RELEASE LFO RECORD ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dblqh::releaseLfo(Signal* signal) +{ +#ifdef VM_TRACE + // Check that lfo record isn't already in free list + LogFileOperationRecordPtr TlfoPtr; + TlfoPtr.i = cfirstfreeLfo; + while (TlfoPtr.i != RNIL){ + ptrCheckGuard(TlfoPtr, clfoFileSize, logFileOperationRecord); + ndbrequire(TlfoPtr.i != lfoPtr.i); + TlfoPtr.i = TlfoPtr.p->nextLfo; + } +#endif + lfoPtr.p->nextLfo = cfirstfreeLfo; + lfoPtr.p->lfoTimer = 0; + cfirstfreeLfo = lfoPtr.i; + lfoPtr.p->lfoState = LogFileOperationRecord::IDLE; +}//Dblqh::releaseLfo() + +/* ------------------------------------------------------------------------- */ +/* ------- RELEASE ALL LOG PAGES CONNECTED TO A LFO RECORD ------- */ +/* */ +/* SUBROUTINE SHORT NAME = RLP */ +/* ------------------------------------------------------------------------- */ +void Dblqh::releaseLfoPages(Signal* signal) +{ + LogPageRecordPtr rlpLogPagePtr; + + logPagePtr.i = lfoPtr.p->firstLfoPage; +RLP_LOOP: + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + rlpLogPagePtr.i = logPagePtr.p->logPageWord[ZNEXT_PAGE]; + releaseLogpage(signal); + if (rlpLogPagePtr.i != RNIL) { + jam(); + logPagePtr.i = rlpLogPagePtr.i; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + goto RLP_LOOP; + }//if + lfoPtr.p->firstLfoPage = RNIL; +}//Dblqh::releaseLfoPages() + +/* ------------------------------------------------------------------------- */ +/* ------- RELEASE LOG PAGE ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dblqh::releaseLogpage(Signal* signal) +{ +#ifdef VM_TRACE + // Check that log page isn't already in free list + LogPageRecordPtr TlogPagePtr; + TlogPagePtr.i = cfirstfreeLogPage; + while (TlogPagePtr.i != RNIL){ + ptrCheckGuard(TlogPagePtr, clogPageFileSize, logPageRecord); + ndbrequire(TlogPagePtr.i != logPagePtr.i); + TlogPagePtr.i = TlogPagePtr.p->logPageWord[ZNEXT_PAGE]; + } +#endif + + cnoOfLogPages++; + logPagePtr.p->logPageWord[ZNEXT_PAGE] = cfirstfreeLogPage; + cfirstfreeLogPage = logPagePtr.i; +}//Dblqh::releaseLogpage() + +/* ------------------------------------------------------------------------- */ +/* ------- SEIZE LFO RECORD ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dblqh::seizeLfo(Signal* signal) +{ + lfoPtr.i = cfirstfreeLfo; + ptrCheckGuard(lfoPtr, clfoFileSize, logFileOperationRecord); + cfirstfreeLfo = lfoPtr.p->nextLfo; + lfoPtr.p->nextLfo = RNIL; + lfoPtr.p->lfoTimer = cLqhTimeOutCount; +}//Dblqh::seizeLfo() + +/* ------------------------------------------------------------------------- */ +/* ------- SEIZE LOG FILE RECORD ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dblqh::seizeLogfile(Signal* signal) +{ + logFilePtr.i = cfirstfreeLogFile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); +/* ------------------------------------------------------------------------- */ +/*IF LIST IS EMPTY THEN A SYSTEM CRASH IS INVOKED SINCE LOG_FILE_PTR = RNIL */ +/* ------------------------------------------------------------------------- */ + cfirstfreeLogFile = logFilePtr.p->nextLogFile; + logFilePtr.p->nextLogFile = RNIL; +}//Dblqh::seizeLogfile() + +/* ------------------------------------------------------------------------- */ +/* ------- SEIZE LOG PAGE RECORD ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dblqh::seizeLogpage(Signal* signal) +{ + cnoOfLogPages--; + logPagePtr.i = cfirstfreeLogPage; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); +/* ------------------------------------------------------------------------- */ +/*IF LIST IS EMPTY THEN A SYSTEM CRASH IS INVOKED SINCE LOG_PAGE_PTR = RNIL */ +/* ------------------------------------------------------------------------- */ + cfirstfreeLogPage = logPagePtr.p->logPageWord[ZNEXT_PAGE]; + logPagePtr.p->logPageWord[ZNEXT_PAGE] = RNIL; +}//Dblqh::seizeLogpage() + +/* ------------------------------------------------------------------------- */ +/* ------- WRITE FILE DESCRIPTOR INFORMATION ------- */ +/* */ +/* SUBROUTINE SHORT NAME: WFD */ +// Pointer handling: +// logFilePtr in +// logPartPtr in +/* ------------------------------------------------------------------------- */ +void Dblqh::writeFileDescriptor(Signal* signal) +{ + TcConnectionrecPtr wfdTcConnectptr; + UintR twfdFileNo; + UintR twfdMbyte; + +/* -------------------------------------------------- */ +/* START BY WRITING TO LOG FILE RECORD */ +/* -------------------------------------------------- */ + arrGuard(logFilePtr.p->currentMbyte, 16); + logFilePtr.p->logMaxGciCompleted[logFilePtr.p->currentMbyte] = + logPartPtr.p->logPartNewestCompletedGCI; + logFilePtr.p->logMaxGciStarted[logFilePtr.p->currentMbyte] = cnewestGci; + wfdTcConnectptr.i = logPartPtr.p->firstLogTcrec; + if (wfdTcConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(wfdTcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + twfdFileNo = wfdTcConnectptr.p->logStartFileNo; + twfdMbyte = wfdTcConnectptr.p->logStartPageNo >> ZTWOLOG_NO_PAGES_IN_MBYTE; + logFilePtr.p->logLastPrepRef[logFilePtr.p->currentMbyte] = + (twfdFileNo << 16) + twfdMbyte; + } else { + jam(); + logFilePtr.p->logLastPrepRef[logFilePtr.p->currentMbyte] = + (logFilePtr.p->fileNo << 16) + logFilePtr.p->currentMbyte; + }//if +}//Dblqh::writeFileDescriptor() + +/* ------------------------------------------------------------------------- */ +/* ------- WRITE THE HEADER PAGE OF A NEW FILE ------- */ +/* */ +/* SUBROUTINE SHORT NAME: WMO */ +/* ------------------------------------------------------------------------- */ +void Dblqh::writeFileHeaderOpen(Signal* signal, Uint32 wmoType) +{ + LogFileRecordPtr wmoLogFilePtr; + UintR twmoNoLogDescriptors; + UintR twmoLoop; + UintR twmoIndex; + +/* -------------------------------------------------- */ +/* WRITE HEADER INFORMATION IN THE NEW FILE. */ +/* -------------------------------------------------- */ + logPagePtr.p->logPageWord[ZPAGE_HEADER_SIZE + ZPOS_LOG_TYPE] = ZFD_TYPE; + logPagePtr.p->logPageWord[ZPAGE_HEADER_SIZE + ZPOS_FILE_NO] = + logFilePtr.p->fileNo; + if (logPartPtr.p->noLogFiles > ZMAX_LOG_FILES_IN_PAGE_ZERO) { + jam(); + twmoNoLogDescriptors = ZMAX_LOG_FILES_IN_PAGE_ZERO; + } else { + jam(); + twmoNoLogDescriptors = logPartPtr.p->noLogFiles; + }//if + logPagePtr.p->logPageWord[ZPAGE_HEADER_SIZE + ZPOS_NO_FD] = + twmoNoLogDescriptors; + wmoLogFilePtr.i = logFilePtr.i; + twmoLoop = 0; +WMO_LOOP: + jam(); + if (twmoLoop < twmoNoLogDescriptors) { + jam(); + ptrCheckGuard(wmoLogFilePtr, clogFileFileSize, logFileRecord); + for (twmoIndex = 0; twmoIndex <= ZNO_MBYTES_IN_FILE - 1; twmoIndex++) { + jam(); + arrGuard(((ZPAGE_HEADER_SIZE + ZFD_HEADER_SIZE) + + (twmoLoop * ZFD_PART_SIZE)) + twmoIndex, ZPAGE_SIZE); + logPagePtr.p->logPageWord[((ZPAGE_HEADER_SIZE + ZFD_HEADER_SIZE) + + (twmoLoop * ZFD_PART_SIZE)) + twmoIndex] = + wmoLogFilePtr.p->logMaxGciCompleted[twmoIndex]; + arrGuard((((ZPAGE_HEADER_SIZE + ZFD_HEADER_SIZE) + + (twmoLoop * ZFD_PART_SIZE)) + ZNO_MBYTES_IN_FILE) + + twmoIndex, ZPAGE_SIZE); + logPagePtr.p->logPageWord[(((ZPAGE_HEADER_SIZE + ZFD_HEADER_SIZE) + + (twmoLoop * ZFD_PART_SIZE)) + ZNO_MBYTES_IN_FILE) + twmoIndex] = + wmoLogFilePtr.p->logMaxGciStarted[twmoIndex]; + arrGuard((((ZPAGE_HEADER_SIZE + ZFD_HEADER_SIZE) + + (twmoLoop * ZFD_PART_SIZE)) + (2 * ZNO_MBYTES_IN_FILE)) + + twmoIndex, ZPAGE_SIZE); + logPagePtr.p->logPageWord[(((ZPAGE_HEADER_SIZE + ZFD_HEADER_SIZE) + + (twmoLoop * ZFD_PART_SIZE)) + (2 * ZNO_MBYTES_IN_FILE)) + twmoIndex] = + wmoLogFilePtr.p->logLastPrepRef[twmoIndex]; + }//for + wmoLogFilePtr.i = wmoLogFilePtr.p->prevLogFile; + twmoLoop = twmoLoop + 1; + goto WMO_LOOP; + }//if + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = + (ZPAGE_HEADER_SIZE + ZFD_HEADER_SIZE) + + (ZFD_PART_SIZE * twmoNoLogDescriptors); + arrGuard(logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX], ZPAGE_SIZE); + logPagePtr.p->logPageWord[logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]] = + ZNEXT_LOG_RECORD_TYPE; +/* ------------------------------------------------------- */ +/* THIS IS A SPECIAL WRITE OF THE FIRST PAGE IN THE */ +/* LOG FILE. THIS HAS SPECIAL SIGNIFANCE TO FIND */ +/* THE END OF THE LOG AT SYSTEM RESTART. */ +/* ------------------------------------------------------- */ + writeSinglePage(signal, 0, ZPAGE_SIZE - 1); + if (wmoType == ZINIT) { + jam(); + lfoPtr.p->lfoState = LogFileOperationRecord::INIT_FIRST_PAGE; + } else { + jam(); + lfoPtr.p->lfoState = LogFileOperationRecord::FIRST_PAGE_WRITE_IN_LOGFILE; + }//if + logFilePtr.p->filePosition = 1; + if (wmoType == ZNORMAL) { + jam(); +/* -------------------------------------------------- */ +/* ALLOCATE A NEW PAGE SINCE THE CURRENT IS */ +/* WRITTEN. */ +/* -------------------------------------------------- */ + seizeLogpage(signal); + initLogpage(signal); + logFilePtr.p->currentLogpage = logPagePtr.i; + logFilePtr.p->currentFilepage = logFilePtr.p->currentFilepage + 1; + }//if +}//Dblqh::writeFileHeaderOpen() + +/* -------------------------------------------------- */ +/* THE NEW FILE POSITION WILL ALWAYS BE 1 SINCE */ +/* WE JUST WROTE THE FIRST PAGE IN THE LOG FILE */ +/* -------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* ------- WRITE A MBYTE HEADER DURING INITIAL START ------- */ +/* */ +/* SUBROUTINE SHORT NAME: WIM */ +/* ------------------------------------------------------------------------- */ +void Dblqh::writeInitMbyte(Signal* signal) +{ + initLogpage(signal); + writeSinglePage(signal, logFilePtr.p->currentMbyte * ZPAGES_IN_MBYTE, ZPAGE_SIZE - 1); + lfoPtr.p->lfoState = LogFileOperationRecord::WRITE_INIT_MBYTE; +}//Dblqh::writeInitMbyte() + +/* ------------------------------------------------------------------------- */ +/* ------- WRITE A SINGLE PAGE INTO A FILE ------- */ +/* */ +/* INPUT: TWSP_PAGE_NO THE PAGE NUMBER WRITTEN */ +/* SUBROUTINE SHORT NAME: WSP */ +/* ------------------------------------------------------------------------- */ +void Dblqh::writeSinglePage(Signal* signal, Uint32 pageNo, Uint32 wordWritten) +{ + seizeLfo(signal); + initLfo(signal); + lfoPtr.p->firstLfoPage = logPagePtr.i; + logPagePtr.p->logPageWord[ZNEXT_PAGE] = RNIL; + + // Calculate checksum for page + logPagePtr.p->logPageWord[ZPOS_CHECKSUM] = calcPageCheckSum(logPagePtr); + + lfoPtr.p->lfoPageNo = pageNo; + lfoPtr.p->lfoWordWritten = wordWritten; + lfoPtr.p->noPagesRw = 1; +/* -------------------------------------------------- */ +/* SET TIMER ON THIS LOG PART TO SIGNIFY THAT A */ +/* LOG RECORD HAS BEEN SENT AT THIS TIME. */ +/* -------------------------------------------------- */ + logPartPtr.p->logPartTimer = logPartPtr.p->logTimer; + signal->theData[0] = logFilePtr.p->fileRef; + signal->theData[1] = cownref; + signal->theData[2] = lfoPtr.i; + signal->theData[3] = ZLIST_OF_PAIRS_SYNCH; + signal->theData[4] = ZVAR_NO_LOG_PAGE_WORD; + signal->theData[5] = 1; /* ONE PAGE WRITTEN */ + signal->theData[6] = logPagePtr.i; + signal->theData[7] = pageNo; + sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal, 8, JBA); +}//Dblqh::writeSinglePage() + +/* ########################################################################## + * SYSTEM RESTART PHASE ONE MODULE + * THIS MODULE IS A SUB-MODULE OF THE FILE SYSTEM HANDLING. + * + * THIS MODULE CONTAINS THE CODE FOR THE FIRST PHASE OF THE SYSTEM RESTART. + * THE AIM OF THIS PHASE IS TO FIND THE END OF THE LOG AND TO FIND + * INFORMATION ABOUT WHERE GLOBAL CHECKPOINTS ARE COMPLETED AND STARTED + * IN THE LOG. THIS INFORMATION IS NEEDED TO START PHASE THREE OF + * THE SYSTEM RESTART. + * ########################################################################## */ +/* -------------------------------------------------------------------------- + * A SYSTEM RESTART OR NODE RESTART IS ONGOING. WE HAVE NOW OPENED FILE 0 + * NOW WE NEED TO READ PAGE 0 TO FIND WHICH LOG FILE THAT WAS OPEN AT + * CRASH TIME. + * -------------------------------------------------------------------------- */ +void Dblqh::openSrFrontpageLab(Signal* signal) +{ + readSinglePage(signal, 0); + lfoPtr.p->lfoState = LogFileOperationRecord::READ_SR_FRONTPAGE; + return; +}//Dblqh::openSrFrontpageLab() + +/* ------------------------------------------------------------------------- + * WE HAVE NOW READ PAGE 0 IN FILE 0. CHECK THE LAST OPEN FILE. ACTUALLY THE + * LAST OPEN FILE COULD BE THE NEXT AFTER THAT. CHECK THAT FIRST. WHEN THE + * LAST WAS FOUND WE CAN FIND ALL THE NEEDED INFORMATION WHERE TO START AND + * STOP READING THE LOG. + * -------------------------------------------------------------------------- */ +void Dblqh::readSrFrontpageLab(Signal* signal) +{ + Uint32 fileNo = logPagePtr.p->logPageWord[ZPAGE_HEADER_SIZE + ZPOS_FILE_NO]; + if (fileNo == 0) { + jam(); + /* ---------------------------------------------------------------------- + * FILE 0 WAS ALSO LAST FILE SO WE DO NOT NEED TO READ IT AGAIN. + * ---------------------------------------------------------------------- */ + readSrLastFileLab(signal); + return; + }//if + /* ------------------------------------------------------------------------ + * CLOSE FILE 0 SO THAT WE HAVE CLOSED ALL FILES WHEN STARTING TO READ + * THE FRAGMENT LOG. ALSO RELEASE PAGE ZERO. + * ------------------------------------------------------------------------ */ + releaseLogpage(signal); + logFilePtr.p->logFileStatus = LogFileRecord::CLOSING_SR; + closeFile(signal, logFilePtr); + LogFileRecordPtr locLogFilePtr; + findLogfile(signal, fileNo, logPartPtr, &locLogFilePtr); + locLogFilePtr.p->logFileStatus = LogFileRecord::OPEN_SR_LAST_FILE; + openFileRw(signal, locLogFilePtr); + return; +}//Dblqh::readSrFrontpageLab() + +void Dblqh::openSrLastFileLab(Signal* signal) +{ + readSinglePage(signal, 0); + lfoPtr.p->lfoState = LogFileOperationRecord::READ_SR_LAST_FILE; + return; +}//Dblqh::openSrLastFileLab() + +void Dblqh::readSrLastFileLab(Signal* signal) +{ + logPartPtr.p->logLap = logPagePtr.p->logPageWord[ZPOS_LOG_LAP]; + if (logPartPtr.p->noLogFiles > ZMAX_LOG_FILES_IN_PAGE_ZERO) { + jam(); + initGciInLogFileRec(signal, ZMAX_LOG_FILES_IN_PAGE_ZERO); + } else { + jam(); + initGciInLogFileRec(signal, logPartPtr.p->noLogFiles); + }//if + releaseLogpage(signal); + /* ------------------------------------------------------------------------ + * NOW WE HAVE FOUND THE LAST LOG FILE. WE ALSO NEED TO FIND THE LAST + * MBYTE THAT WAS LAST WRITTEN BEFORE THE SYSTEM CRASH. + * ------------------------------------------------------------------------ */ + logPartPtr.p->lastLogfile = logFilePtr.i; + readSinglePage(signal, 0); + lfoPtr.p->lfoState = LogFileOperationRecord::READ_SR_LAST_MBYTE; + logFilePtr.p->currentMbyte = 0; + return; +}//Dblqh::readSrLastFileLab() + +void Dblqh::readSrLastMbyteLab(Signal* signal) +{ + if (logPartPtr.p->lastMbyte == ZNIL) { + if (logPagePtr.p->logPageWord[ZPOS_LOG_LAP] < logPartPtr.p->logLap) { + jam(); + logPartPtr.p->lastMbyte = logFilePtr.p->currentMbyte - 1; + }//if + }//if + arrGuard(logFilePtr.p->currentMbyte, 16); + logFilePtr.p->logMaxGciCompleted[logFilePtr.p->currentMbyte] = + logPagePtr.p->logPageWord[ZPOS_MAX_GCI_COMPLETED]; + logFilePtr.p->logMaxGciStarted[logFilePtr.p->currentMbyte] = + logPagePtr.p->logPageWord[ZPOS_MAX_GCI_STARTED]; + logFilePtr.p->logLastPrepRef[logFilePtr.p->currentMbyte] = + logPagePtr.p->logPageWord[ZLAST_LOG_PREP_REF]; + releaseLogpage(signal); + if (logFilePtr.p->currentMbyte < (ZNO_MBYTES_IN_FILE - 1)) { + jam(); + logFilePtr.p->currentMbyte++; + readSinglePage(signal, ZPAGES_IN_MBYTE * logFilePtr.p->currentMbyte); + lfoPtr.p->lfoState = LogFileOperationRecord::READ_SR_LAST_MBYTE; + return; + } else { + jam(); + /* ---------------------------------------------------------------------- + * THE LOG WAS IN THE LAST MBYTE WHEN THE CRASH OCCURRED SINCE ALL + * LOG LAPS ARE EQUAL TO THE CURRENT LOG LAP. + * ---------------------------------------------------------------------- */ + if (logPartPtr.p->lastMbyte == ZNIL) { + jam(); + logPartPtr.p->lastMbyte = ZNO_MBYTES_IN_FILE - 1; + }//if + }//if + logFilePtr.p->logFileStatus = LogFileRecord::CLOSING_SR; + closeFile(signal, logFilePtr); + if (logPartPtr.p->noLogFiles > ZMAX_LOG_FILES_IN_PAGE_ZERO) { + Uint32 fileNo; + if (logFilePtr.p->fileNo >= ZMAX_LOG_FILES_IN_PAGE_ZERO) { + jam(); + fileNo = logFilePtr.p->fileNo - ZMAX_LOG_FILES_IN_PAGE_ZERO; + } else { + jam(); + fileNo = + (logPartPtr.p->noLogFiles + logFilePtr.p->fileNo) - + ZMAX_LOG_FILES_IN_PAGE_ZERO; + }//if + if (fileNo == 0) { + jam(); + /* -------------------------------------------------------------------- + * AVOID USING FILE 0 AGAIN SINCE THAT IS PROBABLY CLOSING AT THE + * MOMENT. + * -------------------------------------------------------------------- */ + fileNo = 1; + logPartPtr.p->srRemainingFiles = + logPartPtr.p->noLogFiles - (ZMAX_LOG_FILES_IN_PAGE_ZERO - 1); + } else { + jam(); + logPartPtr.p->srRemainingFiles = + logPartPtr.p->noLogFiles - ZMAX_LOG_FILES_IN_PAGE_ZERO; + }//if + LogFileRecordPtr locLogFilePtr; + findLogfile(signal, fileNo, logPartPtr, &locLogFilePtr); + locLogFilePtr.p->logFileStatus = LogFileRecord::OPEN_SR_NEXT_FILE; + openFileRw(signal, locLogFilePtr); + return; + }//if + /* ------------------------------------------------------------------------ + * THERE WERE NO NEED TO READ ANY MORE PAGE ZERO IN OTHER FILES. + * WE NOW HAVE ALL THE NEEDED INFORMATION ABOUT THE GCI'S THAT WE NEED. + * NOW JUST WAIT FOR CLOSE OPERATIONS TO COMPLETE. + * ------------------------------------------------------------------------ */ + return; +}//Dblqh::readSrLastMbyteLab() + +void Dblqh::openSrNextFileLab(Signal* signal) +{ + readSinglePage(signal, 0); + lfoPtr.p->lfoState = LogFileOperationRecord::READ_SR_NEXT_FILE; + return; +}//Dblqh::openSrNextFileLab() + +void Dblqh::readSrNextFileLab(Signal* signal) +{ + if (logPartPtr.p->srRemainingFiles > ZMAX_LOG_FILES_IN_PAGE_ZERO) { + jam(); + initGciInLogFileRec(signal, ZMAX_LOG_FILES_IN_PAGE_ZERO); + } else { + jam(); + initGciInLogFileRec(signal, logPartPtr.p->srRemainingFiles); + }//if + releaseLogpage(signal); + logFilePtr.p->logFileStatus = LogFileRecord::CLOSING_SR; + closeFile(signal, logFilePtr); + if (logPartPtr.p->srRemainingFiles > ZMAX_LOG_FILES_IN_PAGE_ZERO) { + Uint32 fileNo; + if (logFilePtr.p->fileNo >= ZMAX_LOG_FILES_IN_PAGE_ZERO) { + jam(); + fileNo = logFilePtr.p->fileNo - ZMAX_LOG_FILES_IN_PAGE_ZERO; + } else { + jam(); + fileNo = + (logPartPtr.p->noLogFiles + logFilePtr.p->fileNo) - + ZMAX_LOG_FILES_IN_PAGE_ZERO; + }//if + if (fileNo == 0) { + jam(); + /* -------------------------------------------------------------------- + * AVOID USING FILE 0 AGAIN SINCE THAT IS PROBABLY CLOSING AT THE MOMENT. + * -------------------------------------------------------------------- */ + fileNo = 1; + logPartPtr.p->srRemainingFiles = + logPartPtr.p->srRemainingFiles - (ZMAX_LOG_FILES_IN_PAGE_ZERO - 1); + } else { + jam(); + logPartPtr.p->srRemainingFiles = + logPartPtr.p->srRemainingFiles - ZMAX_LOG_FILES_IN_PAGE_ZERO; + }//if + LogFileRecordPtr locLogFilePtr; + findLogfile(signal, fileNo, logPartPtr, &locLogFilePtr); + locLogFilePtr.p->logFileStatus = LogFileRecord::OPEN_SR_NEXT_FILE; + openFileRw(signal, locLogFilePtr); + }//if + /* ------------------------------------------------------------------------ + * THERE WERE NO NEED TO READ ANY MORE PAGE ZERO IN OTHER FILES. + * WE NOW HAVE ALL THE NEEDED INFORMATION ABOUT THE GCI'S THAT WE NEED. + * NOW JUST WAIT FOR CLOSE OPERATIONS TO COMPLETE. + * ------------------------------------------------------------------------ */ + return; +}//Dblqh::readSrNextFileLab() + +void Dblqh::closingSrLab(Signal* signal) +{ + logFilePtr.p->logFileStatus = LogFileRecord::CLOSED; + logPartPtr.i = logFilePtr.p->logPartRec; + ptrCheckGuard(logPartPtr, clogPartFileSize, logPartRecord); + logFilePtr.i = logPartPtr.p->firstLogfile; + do { + jam(); + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + if (logFilePtr.p->logFileStatus != LogFileRecord::CLOSED) { + jam(); + /* -------------------------------------------------------------------- + * EXIT AND WAIT FOR REMAINING LOG FILES TO COMPLETE THEIR WORK. + * -------------------------------------------------------------------- */ + return; + }//if + logFilePtr.i = logFilePtr.p->nextLogFile; + } while (logFilePtr.i != logPartPtr.p->firstLogfile); + /* ------------------------------------------------------------------------ + * ALL FILES IN THIS PART HAVE BEEN CLOSED. THIS INDICATES THAT THE FIRST + * PHASE OF THE SYSTEM RESTART HAVE BEEN CONCLUDED FOR THIS LOG PART. + * CHECK IF ALL OTHER LOG PARTS ARE ALSO COMPLETED. + * ------------------------------------------------------------------------ */ + logPartPtr.p->logPartState = LogPartRecord::SR_FIRST_PHASE_COMPLETED; + for (logPartPtr.i = 0; logPartPtr.i <= 3; logPartPtr.i++) { + jam(); + ptrAss(logPartPtr, logPartRecord); + if (logPartPtr.p->logPartState != LogPartRecord::SR_FIRST_PHASE_COMPLETED) { + jam(); + /* -------------------------------------------------------------------- + * EXIT AND WAIT FOR THE REST OF THE LOG PARTS TO COMPLETE. + * -------------------------------------------------------------------- */ + return; + }//if + }//for + /* ------------------------------------------------------------------------ + * THE FIRST PHASE HAVE BEEN COMPLETED. + * ------------------------------------------------------------------------ */ + signal->theData[0] = ZSR_PHASE3_START; + signal->theData[1] = ZSR_PHASE1_COMPLETED; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + return; +}//Dblqh::closingSrLab() + +/* ########################################################################## + * ####### SYSTEM RESTART PHASE TWO MODULE ####### + * + * THIS MODULE HANDLES THE SYSTEM RESTART WHERE LQH CONTROLS TUP AND ACC TO + * ENSURE THAT THEY HAVE KNOWLEDGE OF ALL FRAGMENTS AND HAVE DONE THE NEEDED + * READING OF DATA FROM FILE AND EXECUTION OF LOCAL LOGS. THIS PROCESS + * EXECUTES CONCURRENTLY WITH PHASE ONE OF THE SYSTEM RESTART. THIS PHASE + * FINDS THE INFORMATION ABOUT THE FRAGMENT LOG NEEDED TO EXECUTE THE FRAGMENT + * LOG. + * WHEN TUP AND ACC HAVE PREPARED ALL FRAGMENTS THEN LQH ORDERS THOSE LQH'S + * THAT ARE RESPONSIBLE TO EXECUTE THE FRAGMENT LOGS TO DO SO. IT IS POSSIBLE + * THAT ANOTHER NODE EXECUTES THE LOG FOR A FRAGMENT RESIDING AT THIS NODE. + * ########################################################################## */ +/* ***************>> */ +/* START_FRAGREQ > */ +/* ***************>> */ +void Dblqh::execSTART_FRAGREQ(Signal* signal) +{ + const StartFragReq * const startFragReq = (StartFragReq *)&signal->theData[0]; + jamEntry(); + + tabptr.i = startFragReq->tableId; + Uint32 fragId = startFragReq->fragId; + + ptrCheckGuard(tabptr, ctabrecFileSize, tablerec); + if (!getFragmentrec(signal, fragId)) { + jam(); + /* ---------------------------------------------------------------------- + * FRAGMENT WAS NOT DEFINED YET. PUT IT IN. IF NO LOCAL CHECKPOINT EXISTED + * THEN THE FRAGMENT HAS ALREADY BEEN ADDED. + * ---------------------------------------------------------------------- */ + if (!insertFragrec(signal, fragId)) { + jam(); + startFragRefLab(signal); + return; + }//if + }//if + tabptr.p->tableStatus = Tablerec::TABLE_DEFINED; + + initFragrec(signal, tabptr.i, fragId, ZPRIMARY_NODE); + initFragrecSr(signal); + if (startFragReq->lcpNo == ZNIL) { + jam(); + /* ---------------------------------------------------------------------- + * THERE WAS NO LOCAL CHECKPOINT AVAILABLE FOR THIS FRAGMENT. WE DO + * NOT NEED TO READ IN THE LOCAL FRAGMENT. WE HAVE ALREADY ADDED THE + * FRAGMENT AS AN EMPTY FRAGMENT AT THIS POINT. THUS WE CAN SIMPLY + * EXIT AND THE FRAGMENT WILL PARTICIPATE IN THE EXECUTION OF THE LOG. + * PUT FRAGMENT ON LIST OF COMPLETED FRAGMENTS FOR EXECUTION OF LOG. + * ---------------------------------------------------------------------- */ + fragptr.p->nextFrag = cfirstCompletedFragSr; + cfirstCompletedFragSr = fragptr.i; + return; + }//if + if (cfirstWaitFragSr == RNIL) { + jam(); + lcpPtr.i = 0; + ptrAss(lcpPtr, lcpRecord); + if (lcpPtr.p->lcpState == LcpRecord::LCP_IDLE) { + jam(); + initLcpSr(signal, startFragReq->lcpNo, + startFragReq->lcpId, tabptr.i, + fragId, fragptr.i); + signal->theData[0] = lcpPtr.i; + signal->theData[1] = cownref; + signal->theData[2] = lcpPtr.p->currentFragment.lcpFragOrd.lcpNo; + signal->theData[3] = lcpPtr.p->currentFragment.lcpFragOrd.tableId; + signal->theData[4] = lcpPtr.p->currentFragment.lcpFragOrd.fragmentId; + sendSignal(fragptr.p->accBlockref, GSN_SR_FRAGIDREQ, signal, 5, JBB); + return; + }//if + }//if + fragptr.p->nextFrag = cfirstWaitFragSr; + cfirstWaitFragSr = fragptr.i; +}//Dblqh::execSTART_FRAGREQ() + +void Dblqh::startFragRefLab(Signal* signal) +{ + const StartFragReq * const startFragReq = (StartFragReq *)&signal->theData[0]; + BlockReference userRef = startFragReq->userRef; + Uint32 userPtr = startFragReq->userPtr; + signal->theData[0] = userPtr; + signal->theData[1] = terrorCode; + signal->theData[2] = cownNodeid; + sendSignal(userRef, GSN_START_FRAGREF, signal, 3, JBB); + return; +}//Dblqh::startFragRefLab() + +/* ***************>> */ +/* SR_FRAGIDCONF > */ +/* ***************>> */ +/* -------------------------------------------------------------------------- + * PRECONDITION: LCP_PTR:LCP_STATE = SR_WAIT_FRAGID + * -------------------------------------------------------------------------- */ +void Dblqh::execSR_FRAGIDCONF(Signal* signal) +{ + SrFragidConf * const srFragidConf = (SrFragidConf *)&signal->theData[0]; + jamEntry(); + + lcpPtr.i = srFragidConf->lcpPtr; + ptrCheckGuard(lcpPtr, clcpFileSize, lcpRecord); + ndbrequire(lcpPtr.p->lcpState == LcpRecord::LCP_SR_WAIT_FRAGID); + /* ------------------------------------------------------------------------ + * NO ERROR CHECKING OF TNO_LOCFRAG VALUE. OUT OF BOUND WILL IMPLY THAT AN + * INDEX OUT OF RANGE WILL CAUSE A SYSTEM RESTART WHICH IS DESIRED. + * ------------------------------------------------------------------------ */ + lcpPtr.p->lcpAccptr = srFragidConf->accPtr; + fragptr.i = lcpPtr.p->currentFragment.fragPtrI; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + fragptr.p->accFragptr[0] = srFragidConf->fragPtr[0]; + fragptr.p->accFragptr[1] = srFragidConf->fragPtr[1]; + fragptr.p->hashCheckBit = srFragidConf->hashCheckBit; + Uint32 noLocFrag = srFragidConf->noLocFrag; + ndbrequire(noLocFrag == 2); + Uint32 fragid[2]; + for (Uint32 i = 0; i < noLocFrag; i++) { + fragid[i] = srFragidConf->fragId[i]; + }//for + + for (Uint32 i = 0; i < noLocFrag; i++) { + jam(); + Uint32 fragId = fragid[i]; + /* ---------------------------------------------------------------------- + * THERE IS NO ERROR CHECKING ON PURPOSE. IT IS POSSIBLE TO CALCULATE HOW + * MANY LOCAL LCP RECORDS THERE SHOULD BE. IT SHOULD NEVER HAPPEN THAT + * THERE IS NO ONE FREE. IF THERE IS NO ONE IT WILL ALSO BE A POINTER + * OUT OF RANGE WHICH IS AN ERROR CODE IN ITSELF. REUSES ERROR + * HANDLING IN AXE VM. + * ---------------------------------------------------------------------- */ + seizeLcpLoc(signal); + initLcpLocAcc(signal, fragId); + lcpLocptr.p->lcpLocstate = LcpLocRecord::SR_ACC_STARTED; + signal->theData[0] = lcpPtr.p->lcpAccptr; + signal->theData[1] = lcpLocptr.i; + signal->theData[2] = lcpLocptr.p->locFragid; + signal->theData[3] = lcpPtr.p->currentFragment.lcpFragOrd.lcpId % MAX_LCP_STORED; + sendSignal(fragptr.p->accBlockref, GSN_ACC_SRREQ, signal, 4, JBB); + seizeLcpLoc(signal); + initLcpLocTup(signal, fragId); + lcpLocptr.p->lcpLocstate = LcpLocRecord::SR_TUP_STARTED; + signal->theData[0] = lcpLocptr.i; + signal->theData[1] = cownref; + signal->theData[2] = lcpPtr.p->currentFragment.lcpFragOrd.tableId; + signal->theData[3] = lcpLocptr.p->locFragid; + signal->theData[4] = lcpPtr.p->currentFragment.lcpFragOrd.lcpNo; + sendSignal(fragptr.p->tupBlockref, GSN_TUP_SRREQ, signal, 5, JBB); + }//for + lcpPtr.p->lcpState = LcpRecord::LCP_SR_STARTED; + return; +}//Dblqh::execSR_FRAGIDCONF() + +/* ***************> */ +/* SR_FRAGIDREF > */ +/* ***************> */ +void Dblqh::execSR_FRAGIDREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +}//Dblqh::execSR_FRAGIDREF() + +/* ************>> */ +/* ACC_SRCONF > */ +/* ************>> */ +/* -------------------------------------------------------------------------- + * PRECONDITION: LCP_LOCPTR:LCP_LOCSTATE = SR_ACC_STARTED + * -------------------------------------------------------------------------- */ +void Dblqh::execACC_SRCONF(Signal* signal) +{ + jamEntry(); + lcpLocptr.i = signal->theData[0]; + ptrCheckGuard(lcpLocptr, clcpLocrecFileSize, lcpLocRecord); + if (lcpLocptr.p->lcpLocstate != LcpLocRecord::SR_ACC_STARTED) { + jam(); + systemErrorLab(signal); + return; + }//if + + lcpPtr.i = lcpLocptr.p->masterLcpRec; + ptrCheckGuard(lcpPtr, clcpFileSize, lcpRecord); + /* ------------------------------------------------------------------------ + * NO ERROR CHECK ON USING VALUE IN MASTER_LCP_REC. ERROR IN THIS REFERENCE + * WILL CAUSE POINTER OUT OF RANGE WHICH CAUSES A SYSTEM RESTART. + * ------------------------------------------------------------------------ */ + lcpLocptr.p->lcpLocstate = LcpLocRecord::SR_ACC_COMPLETED; + srCompletedLab(signal); + return; +}//Dblqh::execACC_SRCONF() + +/* ************> */ +/* ACC_SRREF > */ +/* ************> */ +void Dblqh::execACC_SRREF(Signal* signal) +{ + jamEntry(); + terrorCode = signal->theData[1]; + systemErrorLab(signal); + return; +}//Dblqh::execACC_SRREF() + +/* ************>> */ +/* TUP_SRCONF > */ +/* ************>> */ +/* -------------------------------------------------------------------------- + * PRECONDITION: LCP_LOCPTR:LCP_LOCSTATE = SR_TUP_STARTED + * -------------------------------------------------------------------------- */ +void Dblqh::execTUP_SRCONF(Signal* signal) +{ + jamEntry(); + lcpLocptr.i = signal->theData[0]; + ptrCheckGuard(lcpLocptr, clcpLocrecFileSize, lcpLocRecord); + Uint32 tupFragPtr = signal->theData[1]; + ndbrequire(lcpLocptr.p->lcpLocstate == LcpLocRecord::SR_TUP_STARTED); + + lcpPtr.i = lcpLocptr.p->masterLcpRec; + ptrCheckGuard(lcpPtr, clcpFileSize, lcpRecord); + /* ------------------------------------------------------------------------ + * NO ERROR CHECK ON USING VALUE IN MASTER_LCP_REC. ERROR IN THIS REFERENCE + * WILL CAUSE POINTER OUT OF RANGE WHICH CAUSES A SYSTEM RESTART. + * ------------------------------------------------------------------------ */ + lcpLocptr.p->lcpLocstate = LcpLocRecord::SR_TUP_COMPLETED; + fragptr.i = lcpPtr.p->currentFragment.fragPtrI; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if (lcpLocptr.i == lcpPtr.p->firstLcpLocTup) { + jam(); + fragptr.p->tupFragptr[1] = tupFragPtr; + } else { + jam(); + fragptr.p->tupFragptr[0] = tupFragPtr; + }//if + srCompletedLab(signal); + return; +}//Dblqh::execTUP_SRCONF() + +void Dblqh::srCompletedLab(Signal* signal) +{ + checkSrCompleted(signal); + if (lcpPtr.p->lcpState == LcpRecord::LCP_SR_COMPLETED) { + jam(); + /* ---------------------------------------------------------------------- + * THE SYSTEM RESTART OF THIS FRAGMENT HAS BEEN COMPLETED. IT IS NOW + * TIME TO START A SYSTEM RESTART ON THE NEXT FRAGMENT OR CONTINUE + * WITH THE NEXT STEP OF THE SYSTEM RESTART. THIS STEP IS TO EXECUTE + * THE FRAGMENT LOGS. + * ---------------------------------------------------------------------- + * WE RELEASE THE LOCAL LCP RECORDS. + * --------------------------------------------------------------------- */ + releaseLocalLcps(signal); + /* ---------------------------------------------------------------------- + * PUT FRAGMENT ON LIST OF FRAGMENTS WHICH HAVE BEEN STARTED AS PART OF + * THE SYSTEM RESTART. THEY ARE NOW WAITING TO EXECUTE THE FRAGMENT LOG. + * --------------------------------------------------------------------- */ + fragptr.i = lcpPtr.p->currentFragment.fragPtrI; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + fragptr.p->nextFrag = cfirstCompletedFragSr; + cfirstCompletedFragSr = fragptr.i; + if (cfirstWaitFragSr != RNIL) { + jam(); + /* -------------------------------------------------------------------- + * ANOTHER FRAGMENT IS WAITING FOR SYSTEM RESTART. RESTART THIS + * FRAGMENT AS WELL. + * -------------------------------------------------------------------- */ + fragptr.i = cfirstWaitFragSr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + cfirstWaitFragSr = fragptr.p->nextFrag; + /* -------------------------------------------------------------------- + * RETRIEVE DATA FROM THE FRAGMENT RECORD. + * -------------------------------------------------------------------- */ + ndbrequire(fragptr.p->srChkpnr < MAX_LCP_STORED); + initLcpSr(signal, + fragptr.p->srChkpnr, + fragptr.p->lcpId[fragptr.p->srChkpnr], + fragptr.p->tabRef, + fragptr.p->fragId, + fragptr.i); + signal->theData[0] = lcpPtr.i; + signal->theData[1] = cownref; + signal->theData[2] = lcpPtr.p->currentFragment.lcpFragOrd.lcpNo; + signal->theData[3] = lcpPtr.p->currentFragment.lcpFragOrd.tableId; + signal->theData[4] = lcpPtr.p->currentFragment.lcpFragOrd.fragmentId; + sendSignal(fragptr.p->accBlockref, GSN_SR_FRAGIDREQ, signal, 5, JBB); + return; + } else { + jam(); + /* -------------------------------------------------------------------- + * NO MORE FRAGMENTS ARE WAITING FOR SYSTEM RESTART. + * -------------------------------------------------------------------- */ + lcpPtr.p->lcpState = LcpRecord::LCP_IDLE; + if (cstartRecReq == ZTRUE) { + jam(); + /* ---------------------------------------------------------------- + * WE HAVE ALSO RECEIVED AN INDICATION THAT NO MORE FRAGMENTS + * NEEDS RESTART. + * NOW IT IS TIME TO START EXECUTING THE UNDO LOG. + * ---------------------------------------------------------------- + * WE ARE NOW IN A POSITION TO ORDER TUP AND ACC TO START + * EXECUTING THEIR UNDO LOGS. THIS MUST BE DONE BEFORE THE + * FRAGMENT LOGS CAN BE EXECUTED. + * ---------------------------------------------------------------- */ + csrExecUndoLogState = EULS_STARTED; + signal->theData[0] = caccBlockref; + signal->theData[1] = cownref; + sendSignal(caccBlockref, GSN_START_RECREQ, signal, 2, JBB); + signal->theData[0] = ctupBlockref; + signal->theData[1] = cownref; + sendSignal(ctupBlockref, GSN_START_RECREQ, signal, 2, JBB); + return; + } else { + jam(); + /* ---------------------------------------------------------------- + * WE HAVE NOT RECEIVED ALL FRAGMENTS YET OR AT LEAST NOT WE + * HAVE NOT RECEIVED THE START_RECREQ SIGNAL. EXIT AND WAIT + * FOR MORE. + * ---------------------------------------------------------------- */ + return; + }//if + }//if + }//if + /*---------------*/ + /* ELSE */ + /*------------------------------------------------------------------------- + * THE SYSTEM RESTART ON THIS FRAGMENT HAS NOT BEEN COMPLETED, + * EXIT AND WAIT FOR MORE SIGNALS + *------------------------------------------------------------------------- + * DO NOTHING, EXIT IS EXECUTED BELOW + *------------------------------------------------------------------------- */ + return; +}//Dblqh::srCompletedLab() + +/* ************> */ +/* TUP_SRREF > */ +/* ************> */ +void Dblqh::execTUP_SRREF(Signal* signal) +{ + jamEntry(); + terrorCode = signal->theData[1]; + systemErrorLab(signal); + return; +}//Dblqh::execTUP_SRREF() + +/* ***************> */ +/* START_RECREQ > */ +/* ***************> */ +void Dblqh::execSTART_RECREQ(Signal* signal) +{ + CRASH_INSERTION(5027); + + jamEntry(); + StartRecReq * const req = (StartRecReq*)&signal->theData[0]; + cmasterDihBlockref = req->senderRef; + + crestartOldestGci = req->keepGci; + crestartNewestGci = req->lastCompletedGci; + cnewestGci = req->newestGci; + + ndbrequire(req->receivingNodeId == cownNodeid); + + cnewestCompletedGci = cnewestGci; + cstartRecReq = ZTRUE; + for (logPartPtr.i = 0; logPartPtr.i < 4; logPartPtr.i++) { + ptrAss(logPartPtr, logPartRecord); + logPartPtr.p->logPartNewestCompletedGCI = cnewestCompletedGci; + }//for + /* ------------------------------------------------------------------------ + * WE HAVE TO SET THE OLDEST AND THE NEWEST GLOBAL CHECKPOINT IDENTITY + * THAT WILL SURVIVE THIS SYSTEM RESTART. THIS IS NEEDED SO THAT WE CAN + * SET THE LOG HEAD AND LOG TAIL PROPERLY BEFORE STARTING THE SYSTEM AGAIN. + * WE ALSO NEED TO SET CNEWEST_GCI TO ENSURE THAT LOG RECORDS ARE EXECUTED + * WITH A PROPER GCI. + *------------------------------------------------------------------------ */ + if (cstartType == NodeState::ST_NODE_RESTART) { + jam(); + signal->theData[0] = ZSR_PHASE3_START; + signal->theData[1] = ZSR_PHASE2_COMPLETED; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + return; + }//if + if(cstartType == NodeState::ST_INITIAL_NODE_RESTART){ + jam(); + StartRecConf * conf = (StartRecConf*)signal->getDataPtrSend(); + conf->startingNodeId = getOwnNodeId(); + sendSignal(cmasterDihBlockref, GSN_START_RECCONF, signal, + StartRecConf::SignalLength, JBB); + return; + }//if + if (cfirstWaitFragSr == RNIL) { + /* ---------------------------------------------------------------------- + * THERE ARE NO FRAGMENTS WAITING TO BE RESTARTED. + * --------------------------------------------------------------------- */ + lcpPtr.i = 0; + ptrAss(lcpPtr, lcpRecord); + if (lcpPtr.p->lcpState == LcpRecord::LCP_IDLE) { + jam(); + /* -------------------------------------------------------------------- + * THERE ARE NO FRAGMENTS THAT ARE CURRENTLY PERFORMING THEIR + * SYSTEM RESTART. + * -------------------------------------------------------------------- + * WE ARE NOW IN A POSITION TO ORDER TUP AND ACC TO START EXECUTING + * THEIR UNDO LOGS. THIS MUST BE DONE BEFORE THE FRAGMENT LOGS + * CAN BE EXECUTED. + * ------------------------------------------------------------------- */ + csrExecUndoLogState = EULS_STARTED; + signal->theData[0] = caccBlockref; + signal->theData[1] = cownref; + sendSignal(caccBlockref, GSN_START_RECREQ, signal, 2, JBB); + signal->theData[0] = ctupBlockref; + signal->theData[1] = cownref; + sendSignal(ctupBlockref, GSN_START_RECREQ, signal, 2, JBB); + }//if + }//if + /* ----------------------------------------------------------------------- + * EXIT AND WAIT FOR COMPLETION OF ALL FRAGMENTS. + * ----------------------------------------------------------------------- */ + return; +}//Dblqh::execSTART_RECREQ() + +/* ***************>> */ +/* START_RECCONF > */ +/* ***************>> */ +void Dblqh::execSTART_RECCONF(Signal* signal) +{ + jamEntry(); + BlockReference userRef = signal->theData[0]; + if (userRef == caccBlockref) { + if (csrExecUndoLogState == EULS_STARTED) { + jam(); + csrExecUndoLogState = EULS_ACC_COMPLETED; + } else { + ndbrequire(csrExecUndoLogState == EULS_TUP_COMPLETED); + jam(); + csrExecUndoLogState = EULS_COMPLETED; + /* -------------------------------------------------------------------- + * START THE FIRST PHASE OF EXECUTION OF THE LOG. + * ------------------------------------------------------------------- */ + startExecSr(signal); + }//if + } else { + ndbrequire(userRef == ctupBlockref); + if (csrExecUndoLogState == EULS_STARTED) { + jam(); + csrExecUndoLogState = EULS_TUP_COMPLETED; + } else { + ndbrequire(csrExecUndoLogState == EULS_ACC_COMPLETED); + jam(); + csrExecUndoLogState = EULS_COMPLETED; + /* -------------------------------------------------------------------- + * START THE FIRST PHASE OF EXECUTION OF THE LOG. + * ------------------------------------------------------------------- */ + startExecSr(signal); + }//if + }//if + return; +}//Dblqh::execSTART_RECCONF() + +/* ***************> */ +/* START_RECREF > */ +/* ***************> */ +void Dblqh::execSTART_RECREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +}//Dblqh::execSTART_RECREF() + +/* ***************>> */ +/* START_EXEC_SR > */ +/* ***************>> */ +void Dblqh::execSTART_EXEC_SR(Signal* signal) +{ + FragrecordPtr prevFragptr; + jamEntry(); + fragptr.i = signal->theData[0]; + prevFragptr.i = signal->theData[1]; + if (fragptr.i == RNIL) { + jam(); + ndbrequire(cnoOfNodes < MAX_NDB_NODES); + /* ---------------------------------------------------------------------- + * NO MORE FRAGMENTS TO START EXECUTING THE LOG ON. + * SEND EXEC_SRREQ TO ALL LQH TO INDICATE THAT THIS NODE WILL + * NOT REQUEST ANY MORE FRAGMENTS TO EXECUTE THE FRAGMENT LOG ON. + * ---------------------------------------------------------------------- + * WE NEED TO SEND THOSE SIGNALS EVEN IF WE HAVE NOT REQUESTED + * ANY FRAGMENTS PARTICIPATE IN THIS PHASE. + * --------------------------------------------------------------------- */ + for (Uint32 i = 0; i < cnoOfNodes; i++) { + jam(); + if (cnodeStatus[i] == ZNODE_UP) { + jam(); + ndbrequire(cnodeData[i] < MAX_NDB_NODES); + BlockReference ref = calcLqhBlockRef(cnodeData[i]); + signal->theData[0] = cownNodeid; + sendSignal(ref, GSN_EXEC_SRREQ, signal, 1, JBB); + }//if + }//for + } else { + jam(); + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if (fragptr.p->srNoLognodes > csrPhasesCompleted) { + jam(); + Uint32 index = csrPhasesCompleted; + arrGuard(index, 4); + BlockReference ref = calcLqhBlockRef(fragptr.p->srLqhLognode[index]); + fragptr.p->srStatus = Fragrecord::SS_STARTED; + /* -------------------------------------------------------------------- + * SINCE WE CAN HAVE SEVERAL LQH NODES PER FRAGMENT WE CALCULATE + * THE LQH POINTER IN SUCH A WAY THAT WE CAN DEDUCE WHICH OF THE + * LQH NODES THAT HAS RESPONDED WHEN EXEC_FRAGCONF IS RECEIVED. + * ------------------------------------------------------------------- */ + ExecFragReq * const execFragReq = (ExecFragReq *)&signal->theData[0]; + execFragReq->userPtr = fragptr.i; + execFragReq->userRef = cownref; + execFragReq->tableId = fragptr.p->tabRef; + execFragReq->fragId = fragptr.p->fragId; + execFragReq->startGci = fragptr.p->srStartGci[index]; + execFragReq->lastGci = fragptr.p->srLastGci[index]; + sendSignal(ref, GSN_EXEC_FRAGREQ, signal, ExecFragReq::SignalLength, JBB); + prevFragptr.i = fragptr.i; + fragptr.i = fragptr.p->nextFrag; + } else { + jam(); + /* -------------------------------------------------------------------- + * THIS FRAGMENT IS NOW FINISHED WITH THE SYSTEM RESTART. IT DOES + * NOT NEED TO PARTICIPATE IN ANY MORE PHASES. REMOVE IT FROM THE + * LIST OF COMPLETED FRAGMENTS TO EXECUTE THE LOG ON. + * ALSO SEND START_FRAGCONF TO DIH AND SET THE STATE TO ACTIVE ON THE + * FRAGMENT. + * ------------------------------------------------------------------- */ + if (prevFragptr.i != RNIL) { + jam(); + ptrCheckGuard(prevFragptr, cfragrecFileSize, fragrecord); + prevFragptr.p->nextFrag = fragptr.p->nextFrag; + } else { + jam(); + cfirstCompletedFragSr = fragptr.p->nextFrag; + }//if + fragptr.p->fragStatus = Fragrecord::FSACTIVE; + fragptr.p->logFlag = Fragrecord::STATE_TRUE; + signal->theData[0] = fragptr.p->srUserptr; + signal->theData[1] = cownNodeid; + sendSignal(fragptr.p->srBlockref, GSN_START_FRAGCONF, signal, 2, JBB); + /* -------------------------------------------------------------------- + * WE HAVE TO ENSURE THAT THIS FRAGMENT IS NOT PUT BACK ON THE LIST BY + * MISTAKE. WE DO THIS BY ALSO REMOVING IT AS PREVIOUS IN START_EXEC_SR + * THIS IS PERFORMED BY KEEPING PREV_FRAGPTR AS PREV_FRAGPTR BUT MOVING + * FRAGPTR TO THE NEXT FRAGMENT IN THE LIST. + * ------------------------------------------------------------------- */ + fragptr.i = fragptr.p->nextFrag; + }//if + signal->theData[0] = fragptr.i; + signal->theData[1] = prevFragptr.i; + sendSignal(cownref, GSN_START_EXEC_SR, signal, 2, JBB); + }//if + return; +}//Dblqh::execSTART_EXEC_SR() + +/* ***************> */ +/* EXEC_FRAGREQ > */ +/* ***************> */ +/* -------------------------------------------------------------------------- + * THIS SIGNAL IS USED TO REQUEST THAT A FRAGMENT PARTICIPATES IN EXECUTING + * THE LOG IN THIS NODE. + * ------------------------------------------------------------------------- */ +void Dblqh::execEXEC_FRAGREQ(Signal* signal) +{ + ExecFragReq * const execFragReq = (ExecFragReq *)&signal->theData[0]; + jamEntry(); + tabptr.i = execFragReq->tableId; + Uint32 fragId = execFragReq->fragId; + ptrCheckGuard(tabptr, ctabrecFileSize, tablerec); + if (!getFragmentrec(signal, fragId)) { + jam(); + if (!insertFragrec(signal, fragId)) { + jam(); + sendExecFragRefLab(signal); + return; + }//if + initFragrec(signal, tabptr.i, fragId, ZLOG_NODE); + fragptr.p->execSrStatus = Fragrecord::ACTIVE_REMOVE_AFTER; + } else { + jam(); + if (fragptr.p->execSrStatus == Fragrecord::ACTIVE_REMOVE_AFTER) { + jam(); + fragptr.p->execSrStatus = Fragrecord::ACTIVE_REMOVE_AFTER; + } else { + jam(); + }//if + }//if + ndbrequire(fragptr.p->execSrNoReplicas < 4); + fragptr.p->execSrBlockref[fragptr.p->execSrNoReplicas] = execFragReq->userRef; + fragptr.p->execSrUserptr[fragptr.p->execSrNoReplicas] = execFragReq->userPtr; + fragptr.p->execSrStartGci[fragptr.p->execSrNoReplicas] = execFragReq->startGci; + fragptr.p->execSrLastGci[fragptr.p->execSrNoReplicas] = execFragReq->lastGci; + fragptr.p->execSrStatus = Fragrecord::ACTIVE; + fragptr.p->execSrNoReplicas++; + cnoFragmentsExecSr++; + return; +}//Dblqh::execEXEC_FRAGREQ() + +void Dblqh::sendExecFragRefLab(Signal* signal) +{ + ExecFragReq * const execFragReq = (ExecFragReq *)&signal->theData[0]; + BlockReference retRef = execFragReq->userRef; + Uint32 retPtr = execFragReq->userPtr; + + signal->theData[0] = retPtr; + signal->theData[1] = terrorCode; + sendSignal(retRef, GSN_EXEC_FRAGREF, signal, 2, JBB); + return; +}//Dblqh::sendExecFragRefLab() + +/* ***************>> */ +/* EXEC_FRAGCONF > */ +/* ***************>> */ +void Dblqh::execEXEC_FRAGCONF(Signal* signal) +{ + jamEntry(); + fragptr.i = signal->theData[0]; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + fragptr.p->srStatus = Fragrecord::SS_COMPLETED; + return; +}//Dblqh::execEXEC_FRAGCONF() + +/* ***************> */ +/* EXEC_FRAGREF > */ +/* ***************> */ +void Dblqh::execEXEC_FRAGREF(Signal* signal) +{ + jamEntry(); + terrorCode = signal->theData[1]; + systemErrorLab(signal); + return; +}//Dblqh::execEXEC_FRAGREF() + +/* *************** */ +/* EXEC_SRCONF > */ +/* *************** */ +void Dblqh::execEXEC_SRCONF(Signal* signal) +{ + jamEntry(); + Uint32 nodeId = signal->theData[0]; + arrGuard(nodeId, MAX_NDB_NODES); + cnodeExecSrState[nodeId] = ZEXEC_SR_COMPLETED; + ndbrequire(cnoOfNodes < MAX_NDB_NODES); + for (Uint32 i = 0; i < cnoOfNodes; i++) { + jam(); + if (cnodeStatus[i] == ZNODE_UP) { + jam(); + nodeId = cnodeData[i]; + arrGuard(nodeId, MAX_NDB_NODES); + if (cnodeExecSrState[nodeId] != ZEXEC_SR_COMPLETED) { + jam(); + /* ------------------------------------------------------------------ + * ALL NODES HAVE NOT REPORTED COMPLETION OF EXECUTING FRAGMENT + * LOGS YET. + * ----------------------------------------------------------------- */ + return; + }//if + }//if + }//for + /* ------------------------------------------------------------------------ + * CLEAR NODE SYSTEM RESTART EXECUTION STATE TO PREPARE FOR NEXT PHASE OF + * LOG EXECUTION. + * ----------------------------------------------------------------------- */ + for (nodeId = 0; nodeId < MAX_NDB_NODES; nodeId++) { + cnodeExecSrState[nodeId] = ZSTART_SR; + }//for + /* ------------------------------------------------------------------------ + * NOW CHECK IF ALL FRAGMENTS IN THIS PHASE HAVE COMPLETED. IF SO START THE + * NEXT PHASE. + * ----------------------------------------------------------------------- */ + fragptr.i = cfirstCompletedFragSr; + if (fragptr.i == RNIL) { + jam(); + execSrCompletedLab(signal); + return; + }//if + do { + jam(); + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + ndbrequire(fragptr.p->srStatus == Fragrecord::SS_COMPLETED); + fragptr.i = fragptr.p->nextFrag; + } while (fragptr.i != RNIL); + execSrCompletedLab(signal); + return; +}//Dblqh::execEXEC_SRCONF() + +void Dblqh::execSrCompletedLab(Signal* signal) +{ + csrPhasesCompleted++; + /* ------------------------------------------------------------------------ + * ALL FRAGMENTS WERE COMPLETED. THIS PHASE IS COMPLETED. IT IS NOW TIME TO + * START THE NEXT PHASE. + * ----------------------------------------------------------------------- */ + if (csrPhasesCompleted >= 4) { + jam(); + /* ---------------------------------------------------------------------- + * THIS WAS THE LAST PHASE. WE HAVE NOW COMPLETED THE EXECUTION THE + * FRAGMENT LOGS IN ALL NODES. BEFORE WE SEND START_RECCONF TO THE + * MASTER DIH TO INDICATE A COMPLETED SYSTEM RESTART IT IS NECESSARY + * TO FIND THE HEAD AND THE TAIL OF THE LOG WHEN NEW OPERATIONS START + * TO COME AGAIN. + * + * THE FIRST STEP IS TO FIND THE HEAD AND TAIL MBYTE OF EACH LOG PART. + * TO DO THIS WE REUSE THE CONTINUEB SIGNAL SR_LOG_LIMITS. THEN WE + * HAVE TO FIND THE ACTUAL PAGE NUMBER AND PAGE INDEX WHERE TO + * CONTINUE WRITING THE LOG AFTER THE SYSTEM RESTART. + * --------------------------------------------------------------------- */ + for (logPartPtr.i = 0; logPartPtr.i < 4; logPartPtr.i++) { + jam(); + ptrAss(logPartPtr, logPartRecord); + logPartPtr.p->logPartState = LogPartRecord::SR_FOURTH_PHASE_STARTED; + logPartPtr.p->logLastGci = crestartNewestGci; + logPartPtr.p->logStartGci = crestartOldestGci; + logPartPtr.p->logExecState = LogPartRecord::LES_SEARCH_STOP; + if (logPartPtr.p->headFileNo == ZNIL) { + jam(); + /* ----------------------------------------------------------------- + * IF WE HAVEN'T FOUND ANY HEAD OF THE LOG THEN WE ARE IN SERIOUS + * PROBLEM. THIS SHOULD NOT OCCUR. IF IT OCCURS ANYWAY THEN WE + * HAVE TO FIND A CURE FOR THIS PROBLEM. + * ----------------------------------------------------------------- */ + systemErrorLab(signal); + return; + }//if + signal->theData[0] = ZSR_LOG_LIMITS; + signal->theData[1] = logPartPtr.i; + signal->theData[2] = logPartPtr.p->lastLogfile; + signal->theData[3] = logPartPtr.p->lastMbyte; + sendSignal(cownref, GSN_CONTINUEB, signal, 4, JBB); + }//for + return; + } else { + jam(); + /* ---------------------------------------------------------------------- + * THERE ARE YET MORE PHASES TO RESTART. + * WE MUST INITIALISE DATA FOR NEXT PHASE AND SEND START SIGNAL. + * --------------------------------------------------------------------- */ + startExecSr(signal); + }//if + return; +}//Dblqh::execSrCompletedLab() + +/* ************>> */ +/* EXEC_SRREQ > */ +/* ************>> */ +void Dblqh::execEXEC_SRREQ(Signal* signal) +{ + jamEntry(); + Uint32 nodeId = signal->theData[0]; + ndbrequire(nodeId < MAX_NDB_NODES); + cnodeSrState[nodeId] = ZEXEC_SR_COMPLETED; + ndbrequire(cnoOfNodes < MAX_NDB_NODES); + for (Uint32 i = 0; i < cnoOfNodes; i++) { + jam(); + if (cnodeStatus[i] == ZNODE_UP) { + jam(); + nodeId = cnodeData[i]; + if (cnodeSrState[nodeId] != ZEXEC_SR_COMPLETED) { + jam(); + /* ------------------------------------------------------------------ + * ALL NODES HAVE NOT REPORTED COMPLETION OF SENDING EXEC_FRAGREQ YET. + * ----------------------------------------------------------------- */ + return; + }//if + }//if + }//for + /* ------------------------------------------------------------------------ + * CLEAR NODE SYSTEM RESTART STATE TO PREPARE FOR NEXT PHASE OF LOG + * EXECUTION + * ----------------------------------------------------------------------- */ + for (nodeId = 0; nodeId < MAX_NDB_NODES; nodeId++) { + cnodeSrState[nodeId] = ZSTART_SR; + }//for + if (csrPhasesCompleted != 0) { + /* ---------------------------------------------------------------------- + * THE FIRST PHASE MUST ALWAYS EXECUTE THE LOG. + * --------------------------------------------------------------------- */ + if (cnoFragmentsExecSr == 0) { + jam(); + /* -------------------------------------------------------------------- + * THERE WERE NO FRAGMENTS THAT NEEDED TO EXECUTE THE LOG IN THIS PHASE. + * ------------------------------------------------------------------- */ + srPhase3Comp(signal); + return; + }//if + }//if + /* ------------------------------------------------------------------------ + * NOW ALL NODES HAVE SENT ALL EXEC_FRAGREQ. NOW WE CAN START EXECUTING THE + * LOG FROM THE MINIMUM GCI NEEDED UNTIL THE MAXIMUM GCI NEEDED. + * + * WE MUST FIRST CHECK IF THE FIRST PHASE OF THE SYSTEM RESTART HAS BEEN + * COMPLETED. THIS HANDLING IS PERFORMED IN THE FILE SYSTEM MODULE + * ----------------------------------------------------------------------- */ + signal->theData[0] = ZSR_PHASE3_START; + signal->theData[1] = ZSR_PHASE2_COMPLETED; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + return; +}//Dblqh::execEXEC_SRREQ() + +/* ######################################################################### */ +/* SYSTEM RESTART PHASE THREE MODULE */ +/* THIS MODULE IS A SUB-MODULE OF THE FILE SYSTEM HANDLING. */ +/* */ +/* THIS MODULE IS CONCERNED WITH EXECUTING THE FRAGMENT LOG. IT DOES ALSO */ +/* CONTAIN SIGNAL RECEPTIONS LQHKEYCONF AND LQHKEYREF SINCE LQHKEYREQ IS USED*/ +/* TO EXECUTE THE LOG RECORDS. */ +/* */ +/* BEFORE IT STARTS IT HAS BEEN DECIDED WHERE TO START AND WHERE TO STOP */ +/* READING THE FRAGMENT LOG BY USING THE INFORMATION ABOUT GCI DISCOVERED IN */ +/* PHASE ONE OF THE SYSTEM RESTART. */ +/* ######################################################################### */ +/*---------------------------------------------------------------------------*/ +/* PHASE THREE OF THE SYSTEM RESTART CAN NOW START. ONE OF THE PHASES HAVE */ +/* COMPLETED. */ +/*---------------------------------------------------------------------------*/ +void Dblqh::srPhase3Start(Signal* signal) +{ + UintR tsrPhaseStarted; + + jamEntry(); + tsrPhaseStarted = signal->theData[0]; + if (csrPhaseStarted == ZSR_NO_PHASE_STARTED) { + jam(); + csrPhaseStarted = tsrPhaseStarted; + if (cstartType == NodeState::ST_NODE_RESTART) { + ndbrequire(cinitialStartOngoing == ZTRUE); + cinitialStartOngoing = ZFALSE; + checkStartCompletedLab(signal); + }//if + return; + }//if + ndbrequire(csrPhaseStarted != tsrPhaseStarted); + ndbrequire(csrPhaseStarted != ZSR_BOTH_PHASES_STARTED); + + csrPhaseStarted = ZSR_BOTH_PHASES_STARTED; + for (logPartPtr.i = 0; logPartPtr.i < 4; logPartPtr.i++) { + jam(); + ptrAss(logPartPtr, logPartRecord); + logPartPtr.p->logPartState = LogPartRecord::SR_THIRD_PHASE_STARTED; + logPartPtr.p->logStartGci = (UintR)-1; + if (csrPhasesCompleted == 0) { + jam(); + /* -------------------------------------------------------------------- + * THE FIRST PHASE WE MUST ENSURE THAT IT REACHES THE END OF THE LOG. + * ------------------------------------------------------------------- */ + logPartPtr.p->logLastGci = crestartNewestGci; + } else { + jam(); + logPartPtr.p->logLastGci = 2; + }//if + }//for + if (cstartType == NodeState::ST_NODE_RESTART) { + jam(); + /* ---------------------------------------------------------------------- + * FOR A NODE RESTART WE HAVE NO FRAGMENTS DEFINED YET. + * THUS WE CAN SKIP THAT PART + * --------------------------------------------------------------------- */ + signal->theData[0] = ZSR_GCI_LIMITS; + signal->theData[1] = RNIL; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + } else { + jam(); + signal->theData[0] = ZSR_GCI_LIMITS; + signal->theData[1] = 0; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + }//if + return; +}//Dblqh::srPhase3Start() + +/* -------------------------------------------------------------------------- + * WE NOW WE NEED TO FIND THE LIMITS WITHIN WHICH TO EXECUTE + * THE FRAGMENT LOG + * ------------------------------------------------------------------------- */ +void Dblqh::srGciLimits(Signal* signal) +{ + LogPartRecordPtr tmpLogPartPtr; + + jamEntry(); + fragptr.i = signal->theData[0]; + Uint32 loopCount = 0; + logPartPtr.i = 0; + ptrAss(logPartPtr, logPartRecord); + while (fragptr.i < cfragrecFileSize) { + jam(); + ptrAss(fragptr, fragrecord); + if (fragptr.p->execSrStatus != Fragrecord::IDLE) { + jam(); + ndbrequire(fragptr.p->execSrNoReplicas - 1 < 4); + for (Uint32 i = 0; i < fragptr.p->execSrNoReplicas; i++) { + jam(); + if (fragptr.p->execSrStartGci[i] < logPartPtr.p->logStartGci) { + jam(); + logPartPtr.p->logStartGci = fragptr.p->execSrStartGci[i]; + }//if + if (fragptr.p->execSrLastGci[i] > logPartPtr.p->logLastGci) { + jam(); + logPartPtr.p->logLastGci = fragptr.p->execSrLastGci[i]; + }//if + }//for + }//if + loopCount++; + if (loopCount > 20) { + jam(); + signal->theData[0] = ZSR_GCI_LIMITS; + signal->theData[1] = fragptr.i + 1; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + return; + } else { + jam(); + fragptr.i++; + }//if + }//while + if (logPartPtr.p->logStartGci == (UintR)-1) { + jam(); + /* -------------------------------------------------------------------- + * THERE WERE NO FRAGMENTS TO INSTALL WE WILL EXECUTE THE LOG AS + * SHORT AS POSSIBLE TO REACH THE END OF THE LOG. THIS WE DO BY + * STARTING AT THE STOP GCI. + * ------------------------------------------------------------------- */ + logPartPtr.p->logStartGci = logPartPtr.p->logLastGci; + }//if + for (tmpLogPartPtr.i = 1; tmpLogPartPtr.i < 4; tmpLogPartPtr.i++) { + ptrAss(tmpLogPartPtr, logPartRecord); + tmpLogPartPtr.p->logStartGci = logPartPtr.p->logStartGci; + tmpLogPartPtr.p->logLastGci = logPartPtr.p->logLastGci; + }//for + for (logPartPtr.i = 0; logPartPtr.i < 4; logPartPtr.i++) { + jam(); + ptrAss(logPartPtr, logPartRecord); + logPartPtr.p->logExecState = LogPartRecord::LES_SEARCH_STOP; + signal->theData[0] = ZSR_LOG_LIMITS; + signal->theData[1] = logPartPtr.i; + signal->theData[2] = logPartPtr.p->lastLogfile; + signal->theData[3] = logPartPtr.p->lastMbyte; + sendSignal(cownref, GSN_CONTINUEB, signal, 4, JBB); + }//for +}//Dblqh::srGciLimits() + +/* -------------------------------------------------------------------------- + * IT IS NOW TIME TO FIND WHERE TO START EXECUTING THE LOG. + * THIS SIGNAL IS SENT FOR EACH LOG PART AND STARTS THE EXECUTION + * OF THE LOG FOR THIS PART. + *-------------------------------------------------------------------------- */ +void Dblqh::srLogLimits(Signal* signal) +{ + Uint32 tlastPrepRef; + Uint32 tmbyte; + + jamEntry(); + logPartPtr.i = signal->theData[0]; + ptrCheckGuard(logPartPtr, clogPartFileSize, logPartRecord); + logFilePtr.i = signal->theData[1]; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + tmbyte = signal->theData[2]; + Uint32 loopCount = 0; + /* ------------------------------------------------------------------------ + * WE ARE SEARCHING FOR THE START AND STOP MBYTE OF THE LOG THAT IS TO BE + * EXECUTED. + * ----------------------------------------------------------------------- */ + while(true) { + ndbrequire(tmbyte < 16); + if (logPartPtr.p->logExecState == LogPartRecord::LES_SEARCH_STOP) { + if (logFilePtr.p->logMaxGciCompleted[tmbyte] < logPartPtr.p->logLastGci) { + jam(); + /* -------------------------------------------------------------------- + * WE ARE STEPPING BACKWARDS FROM MBYTE TO MBYTE. THIS IS THE FIRST + * MBYTE WHICH IS TO BE INCLUDED IN THE LOG EXECUTION. THE STOP GCI + * HAS NOT BEEN COMPLETED BEFORE THIS MBYTE. THUS THIS MBYTE HAVE + * TO BE EXECUTED. + * ------------------------------------------------------------------- */ + logPartPtr.p->stopLogfile = logFilePtr.i; + logPartPtr.p->stopMbyte = tmbyte; + logPartPtr.p->logExecState = LogPartRecord::LES_SEARCH_START; + }//if + }//if + /* ------------------------------------------------------------------------ + * WHEN WE HAVEN'T FOUND THE STOP MBYTE IT IS NOT NECESSARY TO LOOK FOR THE + * START MBYTE. THE REASON IS THE FOLLOWING LOGIC CHAIN: + * MAX_GCI_STARTED >= MAX_GCI_COMPLETED >= LAST_GCI >= START_GCI + * THUS MAX_GCI_STARTED >= START_GCI. THUS MAX_GCI_STARTED < START_GCI CAN + * NOT BE TRUE AS WE WILL CHECK OTHERWISE. + * ----------------------------------------------------------------------- */ + if (logPartPtr.p->logExecState == LogPartRecord::LES_SEARCH_START) { + if (logFilePtr.p->logMaxGciStarted[tmbyte] < logPartPtr.p->logStartGci) { + jam(); + /* -------------------------------------------------------------------- + * WE HAVE NOW FOUND THE START OF THE EXECUTION OF THE LOG. + * WE STILL HAVE TO MOVE IT BACKWARDS TO ALSO INCLUDE THE + * PREPARE RECORDS WHICH WERE STARTED IN A PREVIOUS MBYTE. + * ------------------------------------------------------------------- */ + tlastPrepRef = logFilePtr.p->logLastPrepRef[tmbyte]; + logPartPtr.p->startMbyte = tlastPrepRef & 65535; + LogFileRecordPtr locLogFilePtr; + findLogfile(signal, tlastPrepRef >> 16, logPartPtr, &locLogFilePtr); + logPartPtr.p->startLogfile = locLogFilePtr.i; + logPartPtr.p->logExecState = LogPartRecord::LES_EXEC_LOG; + }//if + }//if + if (logPartPtr.p->logExecState != LogPartRecord::LES_EXEC_LOG) { + if (tmbyte == 0) { + jam(); + tmbyte = ZNO_MBYTES_IN_FILE - 1; + logFilePtr.i = logFilePtr.p->prevLogFile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + } else { + jam(); + tmbyte--; + }//if + if (logPartPtr.p->lastLogfile == logFilePtr.i) { + ndbrequire(logPartPtr.p->lastMbyte != tmbyte); + }//if + if (loopCount > 20) { + jam(); + signal->theData[0] = ZSR_LOG_LIMITS; + signal->theData[1] = logPartPtr.i; + signal->theData[2] = logFilePtr.i; + signal->theData[3] = tmbyte; + sendSignal(cownref, GSN_CONTINUEB, signal, 4, JBB); + return; + }//if + loopCount++; + } else { + jam(); + break; + }//if + }//while + /* ------------------------------------------------------------------------ + * WE HAVE NOW FOUND BOTH THE START AND THE STOP OF THE LOG. NOW START + * EXECUTING THE LOG. THE FIRST ACTION IS TO OPEN THE LOG FILE WHERE TO + * START EXECUTING THE LOG. + * ----------------------------------------------------------------------- */ + if (logPartPtr.p->logPartState == LogPartRecord::SR_THIRD_PHASE_STARTED) { + jam(); + logFilePtr.i = logPartPtr.p->startLogfile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + logFilePtr.p->logFileStatus = LogFileRecord::OPEN_EXEC_SR_START; + openFileRw(signal, logFilePtr); + } else { + jam(); + ndbrequire(logPartPtr.p->logPartState == LogPartRecord::SR_FOURTH_PHASE_STARTED); + /* -------------------------------------------------------------------- + * WE HAVE NOW FOUND THE TAIL MBYTE IN THE TAIL FILE. + * SET THOSE PARAMETERS IN THE LOG PART. + * WE HAVE ALSO FOUND THE HEAD MBYTE. WE STILL HAVE TO SEARCH + * FOR THE PAGE NUMBER AND PAGE INDEX WHERE TO SET THE HEAD. + * ------------------------------------------------------------------- */ + logFilePtr.i = logPartPtr.p->startLogfile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + logPartPtr.p->logTailFileNo = logFilePtr.p->fileNo; + logPartPtr.p->logTailMbyte = logPartPtr.p->startMbyte; + /* -------------------------------------------------------------------- + * THE HEAD WE ACTUALLY FOUND DURING EXECUTION OF LOG SO WE USE + * THIS INFO HERE RATHER THAN THE MBYTE WE FOUND TO BE THE HEADER. + * ------------------------------------------------------------------- */ + LogFileRecordPtr locLogFilePtr; + findLogfile(signal, logPartPtr.p->headFileNo, logPartPtr, &locLogFilePtr); + locLogFilePtr.p->logFileStatus = LogFileRecord::OPEN_SR_FOURTH_PHASE; + openFileRw(signal, locLogFilePtr); + }//if + return; +}//Dblqh::srLogLimits() + +void Dblqh::openExecSrStartLab(Signal* signal) +{ + logPartPtr.p->currentLogfile = logFilePtr.i; + logFilePtr.p->currentMbyte = logPartPtr.p->startMbyte; + /* ------------------------------------------------------------------------ + * WE NEED A TC CONNECT RECORD TO HANDLE EXECUTION OF LOG RECORDS. + * ------------------------------------------------------------------------ */ + seizeTcrec(); + logPartPtr.p->logTcConrec = tcConnectptr.i; + /* ------------------------------------------------------------------------ + * THE FIRST LOG RECORD TO EXECUTE IS ALWAYS AT A NEW MBYTE. + * SET THE NUMBER OF PAGES IN THE MAIN MEMORY BUFFER TO ZERO AS AN INITIAL + * VALUE. THIS VALUE WILL BE UPDATED AND ENSURED THAT IT RELEASES PAGES IN + * THE SUBROUTINE READ_EXEC_SR. + * ----------------------------------------------------------------------- */ + logPartPtr.p->mmBufferSize = 0; + readExecSrNewMbyte(signal); + return; +}//Dblqh::openExecSrStartLab() + +/* --------------------------------------------------------------------------- + * WE WILL ALWAYS ENSURE THAT WE HAVE AT LEAST 16 KBYTE OF LOG PAGES WHEN WE + * START READING A LOG RECORD. THE ONLY EXCEPTION IS WHEN WE COME CLOSE TO A + * MBYTE BOUNDARY. SINCE WE KNOW THAT LOG RECORDS ARE NEVER WRITTEN ACROSS A + * MBYTE BOUNDARY THIS IS NOT A PROBLEM. + * + * WE START BY READING 64 KBYTE BEFORE STARTING TO EXECUTE THE LOG RECORDS. + * WHEN WE COME BELOW 64 KBYTE WE READ ANOTHER SET OF LOG PAGES. WHEN WE + * GO BELOW 16 KBYTE WE WAIT UNTIL THE READ PAGES HAVE ENTERED THE BLOCK. + * ------------------------------------------------------------------------- */ +/* -------------------------------------------------------------------------- + * NEW PAGES FROM LOG FILE DURING EXECUTION OF LOG HAS ARRIVED. + * ------------------------------------------------------------------------- */ +void Dblqh::readExecSrLab(Signal* signal) +{ + buildLinkedLogPageList(signal); + /* ------------------------------------------------------------------------ + * WE NEED TO SET THE CURRENT PAGE INDEX OF THE FIRST PAGE SINCE IT CAN BE + * USED IMMEDIATELY WITHOUT ANY OTHER INITIALISATION. THE REST OF THE PAGES + * WILL BE INITIALISED BY READ_LOGWORD. + * ----------------------------------------------------------------------- */ + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = ZPAGE_HEADER_SIZE; + if (logPartPtr.p->logExecState == + LogPartRecord::LES_WAIT_READ_EXEC_SR_NEW_MBYTE) { + jam(); + /* ---------------------------------------------------------------------- + * THIS IS THE FIRST READ DURING THE EXECUTION OF THIS MBYTE. SET THE + * NEW CURRENT LOG PAGE TO THE FIRST OF THESE PAGES. CHANGE + * LOG_EXEC_STATE TO ENSURE THAT WE START EXECUTION OF THE LOG. + * --------------------------------------------------------------------- */ + logFilePtr.p->currentFilepage = logFilePtr.p->currentMbyte * + ZPAGES_IN_MBYTE; + logPartPtr.p->prevFilepage = logFilePtr.p->currentFilepage; + logFilePtr.p->currentLogpage = lfoPtr.p->firstLfoPage; + logPartPtr.p->prevLogpage = logFilePtr.p->currentLogpage; + }//if + moveToPageRef(signal); + releaseLfo(signal); + /* ------------------------------------------------------------------------ + * NOW WE HAVE COMPLETED THE RECEPTION OF THESE PAGES. + * NOW CHECK IF WE NEED TO READ MORE PAGES. + * ----------------------------------------------------------------------- */ + checkReadExecSr(signal); + if (logPartPtr.p->logExecState == LogPartRecord::LES_EXEC_LOG) { + jam(); + signal->theData[0] = ZEXEC_SR; + signal->theData[1] = logPartPtr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + return; + }//if + return; +}//Dblqh::readExecSrLab() + +void Dblqh::openExecSrNewMbyteLab(Signal* signal) +{ + readExecSrNewMbyte(signal); + return; +}//Dblqh::openExecSrNewMbyteLab() + +void Dblqh::closeExecSrLab(Signal* signal) +{ + LogFileRecordPtr locLogFilePtr; + logFilePtr.p->logFileStatus = LogFileRecord::CLOSED; + logPartPtr.i = logFilePtr.p->logPartRec; + ptrCheckGuard(logPartPtr, clogPartFileSize, logPartRecord); + locLogFilePtr.i = logPartPtr.p->currentLogfile; + ptrCheckGuard(locLogFilePtr, clogFileFileSize, logFileRecord); + locLogFilePtr.p->logFileStatus = LogFileRecord::OPEN_EXEC_SR_NEW_MBYTE; + openFileRw(signal, locLogFilePtr); + return; +}//Dblqh::closeExecSrLab() + +void Dblqh::writeDirtyLab(Signal* signal) +{ + releaseLfo(signal); + signal->theData[0] = logPartPtr.i; + execSr(signal); + return; +}//Dblqh::writeDirtyLab() + +/* -------------------------------------------------------------------------- + * EXECUTE A LOG RECORD WITHIN THE CURRENT MBYTE. + * ------------------------------------------------------------------------- */ +void Dblqh::execSr(Signal* signal) +{ + LogFileRecordPtr nextLogFilePtr; + LogPageRecordPtr tmpLogPagePtr; + Uint32 logWord; + + jamEntry(); + logPartPtr.i = signal->theData[0]; + ptrCheckGuard(logPartPtr, clogPartFileSize, logPartRecord); + + do { + jam(); + logFilePtr.i = logPartPtr.p->currentLogfile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + logPagePtr.i = logPartPtr.p->prevLogpage; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + if (logPagePtr.p->logPageWord[ZPOS_DIRTY] == ZDIRTY) { + jam(); + switch (logPartPtr.p->logExecState) { + case LogPartRecord::LES_EXEC_LOG_COMPLETED: + case LogPartRecord::LES_EXEC_LOG_NEW_FILE: + case LogPartRecord::LES_EXEC_LOG_NEW_MBYTE: + jam(); + /* ------------------------------------------------------------------ + * IN THIS WE HAVE COMPLETED EXECUTION OF THE CURRENT LOG PAGE + * AND CAN WRITE IT TO DISK SINCE IT IS DIRTY. + * ----------------------------------------------------------------- */ + writeDirty(signal); + return; + break; + case LogPartRecord::LES_EXEC_LOG: + jam(); + /* -------------------------------------------------------------------- + * IN THIS CASE WE ONLY WRITE THE PAGE TO DISK IF WE HAVE COMPLETED + * EXECUTION OF LOG RECORDS BELONGING TO THIS LOG PAGE. + * ------------------------------------------------------------------- */ + if (logFilePtr.p->currentLogpage != logPartPtr.p->prevLogpage) { + jam(); + writeDirty(signal); + return; + }//if + break; + default: + ndbrequire(false); + break; + }//switch + }//if + if (logFilePtr.p->currentLogpage != logPartPtr.p->prevLogpage) { + jam(); + logPartPtr.p->prevLogpage = logPagePtr.p->logPageWord[ZNEXT_PAGE]; + logPartPtr.p->prevFilepage++; + continue; + }//if + switch (logPartPtr.p->logExecState) { + case LogPartRecord::LES_EXEC_LOG_COMPLETED: + jam(); + releaseMmPages(signal); + logFilePtr.p->logFileStatus = LogFileRecord::CLOSING_EXEC_SR_COMPLETED; + closeFile(signal, logFilePtr); + return; + break; + case LogPartRecord::LES_EXEC_LOG_NEW_MBYTE: + jam(); + logFilePtr.p->currentMbyte++; + readExecSrNewMbyte(signal); + return; + break; + case LogPartRecord::LES_EXEC_LOG_NEW_FILE: + jam(); + nextLogFilePtr.i = logFilePtr.p->nextLogFile; + logPartPtr.p->currentLogfile = nextLogFilePtr.i; + ptrCheckGuard(nextLogFilePtr, clogFileFileSize, logFileRecord); + nextLogFilePtr.p->currentMbyte = 0; + logFilePtr.p->logFileStatus = LogFileRecord::CLOSING_EXEC_SR; + closeFile(signal, logFilePtr); + return; + break; + case LogPartRecord::LES_EXEC_LOG: + jam(); + /*empty*/; + break; + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch + logPagePtr.i = logFilePtr.p->currentLogpage; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + logPartPtr.p->savePageIndex = logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]; + if (logPartPtr.p->execSrPagesRead < ZMIN_READ_BUFFER_SIZE) { + /* -------------------------------------------------------------------- + * THERE WERE LESS THAN 16 KBYTE OF LOG PAGES REMAINING. WE WAIT UNTIL + * THE NEXT 64 KBYTE ARRIVES UNTIL WE CONTINUE AGAIN. + * ------------------------------------------------------------------- */ + if ((logPartPtr.p->execSrPagesRead + + logPartPtr.p->execSrPagesExecuted) < ZPAGES_IN_MBYTE) { + jam(); + /* ------------------------------------------------------------------ + * WE ONLY STOP AND WAIT IF THERE MORE PAGES TO READ. IF IT IS NOT + * THEN IT IS THE END OF THE MBYTE AND WE WILL CONTINUE. IT IS NO + * RISK THAT A LOG RECORD WE FIND WILL NOT BE READ AT THIS TIME + * SINCE THE LOG RECORDS NEVER SPAN OVER A MBYTE BOUNDARY. + * ----------------------------------------------------------------- */ + readExecSr(signal); + logPartPtr.p->logExecState = LogPartRecord::LES_WAIT_READ_EXEC_SR; + return; + }//if + }//if + logWord = readLogword(signal); + switch (logWord) { +/* ========================================================================= */ +/* ========================================================================= */ + case ZPREP_OP_TYPE: + { + logWord = readLogword(signal); + stepAhead(signal, logWord - 2); + break; + } +/* ========================================================================= */ +/* ========================================================================= */ + case ZINVALID_COMMIT_TYPE: + jam(); + stepAhead(signal, ZCOMMIT_LOG_SIZE - 1); + break; +/* ========================================================================= */ +/* ========================================================================= */ + case ZCOMMIT_TYPE: + { + CommitLogRecord commitLogRecord; + jam(); + tcConnectptr.i = logPartPtr.p->logTcConrec; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + readCommitLog(signal, &commitLogRecord); + if (tcConnectptr.p->gci > crestartNewestGci) { + jam(); +/*---------------------------------------------------------------------------*/ +/* THIS LOG RECORD MUST BE IGNORED. IT IS PART OF A GLOBAL CHECKPOINT WHICH */ +/* WILL BE INVALIDATED BY THE SYSTEM RESTART. IF NOT INVALIDATED IT MIGHT BE */ +/* EXECUTED IN A FUTURE SYSTEM RESTART. */ +/*---------------------------------------------------------------------------*/ + tmpLogPagePtr.i = logPartPtr.p->prevLogpage; + ptrCheckGuard(tmpLogPagePtr, clogPageFileSize, logPageRecord); + arrGuard(logPartPtr.p->savePageIndex, ZPAGE_SIZE); + tmpLogPagePtr.p->logPageWord[logPartPtr.p->savePageIndex] = + ZINVALID_COMMIT_TYPE; + tmpLogPagePtr.p->logPageWord[ZPOS_DIRTY] = ZDIRTY; + } else { + jam(); +/*---------------------------------------------------------------------------*/ +/* CHECK IF I AM SUPPOSED TO EXECUTE THIS LOG RECORD. IF I AM THEN SAVE PAGE */ +/* INDEX IN CURRENT LOG PAGE SINCE IT WILL BE OVERWRITTEN WHEN EXECUTING THE */ +/* LOG RECORD. */ +/*---------------------------------------------------------------------------*/ + logPartPtr.p->execSrExecuteIndex = 0; + Uint32 result = checkIfExecLog(signal); + if (result == ZOK) { + jam(); +//*---------------------------------------------------------------------------*/ +/* IN A NODE RESTART WE WILL NEVER END UP HERE SINCE NO FRAGMENTS HAVE BEEN */ +/* DEFINED YET. THUS NO EXTRA CHECKING FOR NODE RESTART IS NECESSARY. */ +/*---------------------------------------------------------------------------*/ + logPartPtr.p->savePageIndex = + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]; + tcConnectptr.p->fragmentptr = fragptr.i; + findPageRef(signal, &commitLogRecord); + logPartPtr.p->execSrLogPageIndex = commitLogRecord.startPageIndex; + if (logPagePtr.i != RNIL) { + jam(); + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = commitLogRecord.startPageIndex; + logPartPtr.p->execSrLogPage = logPagePtr.i; + execLogRecord(signal); + return; + }//if + logPartPtr.p->execSrStartPageNo = commitLogRecord.startPageNo; + logPartPtr.p->execSrStopPageNo = commitLogRecord.stopPageNo; + findLogfile(signal, commitLogRecord.fileNo, logPartPtr, &logFilePtr); + logPartPtr.p->execSrExecLogFile = logFilePtr.i; + if (logFilePtr.i == logPartPtr.p->currentLogfile) { + jam(); + readExecLog(signal); + lfoPtr.p->lfoState = LogFileOperationRecord::READ_EXEC_LOG; + return; + } else { + jam(); +/*---------------------------------------------------------------------------*/ +/* THE FILE IS CURRENTLY NOT OPEN. WE MUST OPEN IT BEFORE WE CAN READ FROM */ +/* THE FILE. */ +/*---------------------------------------------------------------------------*/ + logFilePtr.p->logFileStatus = LogFileRecord::OPEN_EXEC_LOG; + openFileRw(signal, logFilePtr); + return; + }//if + }//if + }//if + break; + } +/* ========================================================================= */ +/* ========================================================================= */ + case ZABORT_TYPE: + jam(); + stepAhead(signal, ZABORT_LOG_SIZE - 1); + break; +/* ========================================================================= */ +/* ========================================================================= */ + case ZFD_TYPE: + jam(); +/*---------------------------------------------------------------------------*/ +/* THIS IS THE FIRST ITEM WE ENCOUNTER IN A NEW FILE. AT THIS MOMENT WE SHALL*/ +/* SIMPLY BYPASS IT. IT HAS NO SIGNIFANCE WHEN EXECUTING THE LOG. IT HAS ITS */ +/* SIGNIFANCE WHEN FINDING THE START END THE END OF THE LOG. */ +/* WE HARDCODE THE PAGE INDEX SINCE THIS SHOULD NEVER BE FOUND AT ANY OTHER */ +/* PLACE THAN IN THE FIRST PAGE OF A NEW FILE IN THE FIRST POSITION AFTER THE*/ +/* HEADER. */ +/*---------------------------------------------------------------------------*/ + ndbrequire(logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] == + (ZPAGE_HEADER_SIZE + ZPOS_NO_FD)); + { + Uint32 noFdDescriptors = + logPagePtr.p->logPageWord[ZPAGE_HEADER_SIZE + ZPOS_NO_FD]; + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = + (ZPAGE_HEADER_SIZE + ZFD_HEADER_SIZE) + + (noFdDescriptors * ZFD_PART_SIZE); + } + break; +/* ========================================================================= */ +/* ========================================================================= */ + case ZNEXT_LOG_RECORD_TYPE: + jam(); + stepAhead(signal, ZPAGE_SIZE - logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]); + break; +/* ========================================================================= */ +/* ========================================================================= */ + case ZNEXT_MBYTE_TYPE: +/*---------------------------------------------------------------------------*/ +/* WE WILL SKIP A PART OF THE LOG FILE. ACTUALLY THE NEXT POINTER IS TO */ +/* A NEW MBYTE. THEREFORE WE WILL START UP A NEW MBYTE. THIS NEW MBYTE IS */ +/* HOWEVER ONLY STARTED IF IT IS NOT AFTER THE STOP MBYTE. */ +/* IF WE HAVE REACHED THE END OF THE STOP MBYTE THEN THE EXECUTION OF THE LOG*/ +/* IS COMPLETED. */ +/*---------------------------------------------------------------------------*/ + if (logPartPtr.p->currentLogfile == logPartPtr.p->stopLogfile) { + if (logFilePtr.p->currentMbyte == logPartPtr.p->stopMbyte) { + jam(); +/*---------------------------------------------------------------------------*/ +/* THIS WAS THE LAST MBYTE TO EXECUTE IN THIS LOG PART. WE SHOULD HAVE FOUND */ +/* A COMPLETED GCI RECORD OF THE LAST GCI BEFORE THIS. FOR SOME REASON THIS */ +/* RECORD WAS NOT AVAILABLE ON THE LOG. CRASH THE SYSTEM, A VERY SERIOUS */ +/* ERROR WHICH WE MUST REALLY WORK HARD TO AVOID. */ +/*---------------------------------------------------------------------------*/ +/*---------------------------------------------------------------------------*/ +/* SEND A SIGNAL TO THE SIGNAL LOG AND THEN CRASH THE SYSTEM. */ +/*---------------------------------------------------------------------------*/ + signal->theData[0] = RNIL; + signal->theData[1] = logPartPtr.i; + Uint32 tmp = logFilePtr.p->fileName[3]; + tmp = (tmp >> 8) & 0xff;// To get the Directory, DXX. + signal->theData[2] = tmp; + signal->theData[3] = logFilePtr.p->fileNo; + signal->theData[4] = logFilePtr.p->currentFilepage; + signal->theData[5] = logFilePtr.p->currentMbyte; + signal->theData[6] = logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]; + sendSignal(cownref, GSN_DEBUG_SIG, signal, 7, JBA); + return; + }//if + }//if +/*---------------------------------------------------------------------------*/ +/* START EXECUTION OF A NEW MBYTE IN THE LOG. */ +/*---------------------------------------------------------------------------*/ + if (logFilePtr.p->currentMbyte < (ZNO_MBYTES_IN_FILE - 1)) { + jam(); + logPartPtr.p->logExecState = LogPartRecord::LES_EXEC_LOG_NEW_MBYTE; + } else { + ndbrequire(logFilePtr.p->currentMbyte == (ZNO_MBYTES_IN_FILE - 1)); + jam(); +/*---------------------------------------------------------------------------*/ +/* WE HAVE TO CHANGE FILE. CLOSE THIS ONE AND THEN OPEN THE NEXT. */ +/*---------------------------------------------------------------------------*/ + logPartPtr.p->logExecState = LogPartRecord::LES_EXEC_LOG_NEW_FILE; + }//if + break; +/* ========================================================================= */ +/* ========================================================================= */ + case ZCOMPLETED_GCI_TYPE: + jam(); + logWord = readLogword(signal); + if (logWord == logPartPtr.p->logLastGci) { + jam(); +/*---------------------------------------------------------------------------*/ +/* IF IT IS THE LAST GCI TO LIVE AFTER SYSTEM RESTART THEN WE RECORD THE NEXT*/ +/* WORD AS THE NEW HEADER OF THE LOG FILE. OTHERWISE WE SIMPLY IGNORE THIS */ +/* LOG RECORD. */ +/*---------------------------------------------------------------------------*/ + if (csrPhasesCompleted == 0) { + jam(); +/*---------------------------------------------------------------------------*/ +/*WE ONLY RECORD THE HEAD OF THE LOG IN THE FIRST LOG ROUND OF LOG EXECUTION.*/ +/*---------------------------------------------------------------------------*/ + logPartPtr.p->headFileNo = logFilePtr.p->fileNo; + logPartPtr.p->headPageNo = logFilePtr.p->currentFilepage; + logPartPtr.p->headPageIndex = + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]; + }//if +/*---------------------------------------------------------------------------*/ +/* THERE IS NO NEED OF EXECUTING PAST THIS LINE SINCE THERE WILL ONLY BE LOG */ +/* RECORDS THAT WILL BE OF NO INTEREST. THUS CLOSE THE FILE AND START THE */ +/* NEXT PHASE OF THE SYSTEM RESTART. */ +/*---------------------------------------------------------------------------*/ + logPartPtr.p->logExecState = LogPartRecord::LES_EXEC_LOG_COMPLETED; + }//if + break; + default: + jam(); +/* ========================================================================= */ +/* ========================================================================= */ +/*---------------------------------------------------------------------------*/ +/* SEND A SIGNAL TO THE SIGNAL LOG AND THEN CRASH THE SYSTEM. */ +/*---------------------------------------------------------------------------*/ + signal->theData[0] = RNIL; + signal->theData[1] = logPartPtr.i; + Uint32 tmp = logFilePtr.p->fileName[3]; + tmp = (tmp >> 8) & 0xff;// To get the Directory, DXX. + signal->theData[2] = tmp; + signal->theData[3] = logFilePtr.p->fileNo; + signal->theData[4] = logFilePtr.p->currentMbyte; + signal->theData[5] = logFilePtr.p->currentFilepage; + signal->theData[6] = logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]; + signal->theData[7] = logWord; + sendSignal(cownref, GSN_DEBUG_SIG, signal, 8, JBA); + return; + break; + }//switch +/*---------------------------------------------------------------------------*/ +// We continue to execute log records until we find a proper one to execute or +// that we reach a new page. +/*---------------------------------------------------------------------------*/ + } while (1); +}//Dblqh::execSr() + +/*---------------------------------------------------------------------------*/ +/* THIS SIGNAL IS ONLY RECEIVED TO BE CAPTURED IN THE SIGNAL LOG. IT IS */ +/* ALSO USED TO CRASH THE SYSTEM AFTER SENDING A SIGNAL TO THE LOG. */ +/*---------------------------------------------------------------------------*/ +void Dblqh::execDEBUG_SIG(Signal* signal) +{ +/* +2.5 TEMPORARY VARIABLES +----------------------- +*/ + UintR tdebug; + + jamEntry(); + logPagePtr.i = signal->theData[0]; + tdebug = logPagePtr.p->logPageWord[0]; + + char buf[100]; + snprintf(buf, 100, + "Error while reading REDO log.\n" + "D=%d, F=%d Mb=%d FP=%d W1=%d W2=%d", + signal->theData[2], signal->theData[3], signal->theData[4], + signal->theData[5], signal->theData[6], signal->theData[7]); + + progError(__LINE__, ERR_SR_REDOLOG, buf); + + return; +}//Dblqh::execDEBUG_SIG() + +/*---------------------------------------------------------------------------*/ +/*---------------------------------------------------------------------------*/ +void Dblqh::closeExecLogLab(Signal* signal) +{ + logFilePtr.p->logFileStatus = LogFileRecord::CLOSED; + signal->theData[0] = ZEXEC_SR; + signal->theData[1] = logFilePtr.p->logPartRec; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + return; +}//Dblqh::closeExecLogLab() + +void Dblqh::openExecLogLab(Signal* signal) +{ + readExecLog(signal); + lfoPtr.p->lfoState = LogFileOperationRecord::READ_EXEC_LOG; + return; +}//Dblqh::openExecLogLab() + +void Dblqh::readExecLogLab(Signal* signal) +{ + buildLinkedLogPageList(signal); + logPartPtr.p->logExecState = LogPartRecord::LES_EXEC_LOGREC_FROM_FILE; + logPartPtr.p->execSrLfoRec = lfoPtr.i; + logPartPtr.p->execSrLogPage = logPagePtr.i; + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = + logPartPtr.p->execSrLogPageIndex; + execLogRecord(signal); + return; +}//Dblqh::readExecLogLab() + +/*---------------------------------------------------------------------------*/ +/* THIS CODE IS USED TO EXECUTE A LOG RECORD WHEN IT'S DATA HAVE BEEN LOCATED*/ +/* AND TRANSFERRED INTO MEMORY. */ +/*---------------------------------------------------------------------------*/ +void Dblqh::execLogRecord(Signal* signal) +{ + jamEntry(); + + tcConnectptr.i = logPartPtr.p->logTcConrec; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + // Read a log record and prepare it for execution + readLogHeader(signal); + readKey(signal); + readAttrinfo(signal); + initReqinfoExecSr(signal); + arrGuard(logPartPtr.p->execSrExecuteIndex, 4); + BlockReference ref = fragptr.p->execSrBlockref[logPartPtr.p->execSrExecuteIndex]; + tcConnectptr.p->nextReplica = refToNode(ref); + tcConnectptr.p->connectState = TcConnectionrec::LOG_CONNECTED; + tcConnectptr.p->tcOprec = tcConnectptr.i; + packLqhkeyreqLab(signal); + return; +}//Dblqh::execLogRecord() + +//---------------------------------------------------------------------------- +// This function invalidates log pages after the last GCI record in a +// system/node restart. This is to ensure that the end of the log is +// consistent. This function is executed last in start phase 3. +// RT 450. EDTJAMO. +//---------------------------------------------------------------------------- +void Dblqh::invalidateLogAfterLastGCI(Signal* signal) { + + jam(); + if (logPartPtr.p->logExecState != LogPartRecord::LES_EXEC_LOG_INVALIDATE) { + jam(); + systemError(signal); + } + + if (logFilePtr.p->fileNo != logPartPtr.p->invalidateFileNo) { + jam(); + systemError(signal); + } + + switch (lfoPtr.p->lfoState) { + case LogFileOperationRecord::WRITE_SR_INVALIDATE_PAGES: + jam(); + releaseLfo(signal); + releaseLogpage(signal); + if (logPartPtr.p->invalidatePageNo < (ZNO_MBYTES_IN_FILE * ZPAGES_IN_MBYTE - 1)) { + // We continue in this file. + logPartPtr.p->invalidatePageNo++; + } else { + // We continue in the next file. + logFilePtr.i = logFilePtr.p->nextLogFile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + logPartPtr.p->invalidateFileNo = logFilePtr.p->fileNo; + // Page 0 is used for file descriptors. + logPartPtr.p->invalidatePageNo = 1; + if (logFilePtr.p->logFileStatus != LogFileRecord::OPEN) { + jam(); + logFilePtr.p->logFileStatus = LogFileRecord::OPEN_SR_INVALIDATE_PAGES; + openFileRw(signal, logFilePtr); + return; + break; + } + } + // Read a page from the log file. + readFileInInvalidate(signal); + return; + break; + + case LogFileOperationRecord::READ_SR_INVALIDATE_PAGES: + jam(); + releaseLfo(signal); + // Check if this page must be invalidated. + // If the log lap number on a page after the head of the tail is the same + // as the actual log lap number we must invalidate this page. Otherwise it + // could be impossible to find the end of the log in a later system/node + // restart. + if (logPagePtr.p->logPageWord[ZPOS_LOG_LAP] == logPartPtr.p->logLap) { + // This page must be invalidated. + logPagePtr.p->logPageWord[ZPOS_LOG_LAP] = 0; + // Contact NDBFS. Real time break. + writeSinglePage(signal, logPartPtr.p->invalidatePageNo, ZPAGE_SIZE - 1); + lfoPtr.p->lfoState = LogFileOperationRecord::WRITE_SR_INVALIDATE_PAGES; + } else { + // We are done with invalidating. Finish start phase 3.4. + exitFromInvalidate(signal); + } + return; + break; + + default: + jam(); + systemError(signal); + return; + break; + } + + return; +}//Dblqh::invalidateLogAfterLastGCI + +void Dblqh::readFileInInvalidate(Signal* signal) { + jam(); + // Contact NDBFS. Real time break. + readSinglePage(signal, logPartPtr.p->invalidatePageNo); + lfoPtr.p->lfoState = LogFileOperationRecord::READ_SR_INVALIDATE_PAGES; +} + +void Dblqh::exitFromInvalidate(Signal* signal) { + jam(); + // Close files if necessary. Current file and the next file should be + // left open. + if (logFilePtr.i != logPartPtr.p->currentLogfile) { + LogFileRecordPtr currentLogFilePtr; + LogFileRecordPtr nextAfterCurrentLogFilePtr; + + currentLogFilePtr.i = logPartPtr.p->currentLogfile; + ptrCheckGuard(currentLogFilePtr, clogFileFileSize, logFileRecord); + + nextAfterCurrentLogFilePtr.i = currentLogFilePtr.p->nextLogFile; + + if (logFilePtr.i != nextAfterCurrentLogFilePtr.i) { + // This file should be closed. + logFilePtr.p->logFileStatus = LogFileRecord::CLOSE_SR_INVALIDATE_PAGES; + closeFile(signal, logFilePtr); + // Return from this function and wait for close confirm. Then come back + // and test the previous file for closing. + return; + } + } + + // We are done with closing files, send completed signal and exit this phase. + signal->theData[0] = ZSR_FOURTH_COMP; + signal->theData[1] = logPartPtr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + return; +} + + +/*---------------------------------------------------------------------------*/ +/* THE EXECUTION OF A LOG RECORD IS COMPLETED. RELEASE PAGES IF THEY WERE */ +/* READ FROM DISK FOR THIS PARTICULAR OPERATION. */ +/*---------------------------------------------------------------------------*/ +void Dblqh::completedLab(Signal* signal) +{ + Uint32 result = returnExecLog(signal); +/*---------------------------------------------------------------------------*/ +/* ENTER COMPLETED WITH */ +/* LQH_CONNECTPTR */ +/*---------------------------------------------------------------------------*/ + if (result == ZOK) { + jam(); + execLogRecord(signal); + return; + } else if (result == ZNOT_OK) { + jam(); + signal->theData[0] = ZEXEC_SR; + signal->theData[1] = logPartPtr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + } else { + jam(); + /*empty*/; + }//if +/*---------------------------------------------------------------------------*/ +/* WE HAVE TO WAIT FOR CLOSING OF THE EXECUTED LOG FILE BEFORE PROCEEDING IN */ +/* RARE CASES. */ +/*---------------------------------------------------------------------------*/ + return; +}//Dblqh::completedLab() + +/*---------------------------------------------------------------------------*/ +/* EXECUTION OF LOG RECORD WAS NOT SUCCESSFUL. CHECK IF IT IS OK ANYWAY, */ +/* THEN EXECUTE THE NEXT LOG RECORD. */ +/*---------------------------------------------------------------------------*/ +void Dblqh::logLqhkeyrefLab(Signal* signal) +{ + Uint32 result = returnExecLog(signal); + switch (tcConnectptr.p->operation) { + case ZUPDATE: + case ZDELETE: + jam(); + ndbrequire(terrorCode == ZNO_TUPLE_FOUND); + break; + case ZINSERT: + jam(); + ndbrequire(terrorCode == ZTUPLE_ALREADY_EXIST); + break; + default: + ndbrequire(false); + return; + break; + }//switch + if (result == ZOK) { + jam(); + execLogRecord(signal); + return; + } else if (result == ZNOT_OK) { + jam(); + signal->theData[0] = ZEXEC_SR; + signal->theData[1] = logPartPtr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + } else { + jam(); + /*empty*/; + }//if + /* ------------------------------------------------------------------------ + * WE HAVE TO WAIT FOR CLOSING OF THE EXECUTED LOG FILE BEFORE + * PROCEEDING IN RARE CASES. + * ----------------------------------------------------------------------- */ + return; +}//Dblqh::logLqhkeyrefLab() + +void Dblqh::closeExecSrCompletedLab(Signal* signal) +{ + logFilePtr.p->logFileStatus = LogFileRecord::CLOSED; + signal->theData[0] = logFilePtr.p->logPartRec; + execLogComp(signal); + return; +}//Dblqh::closeExecSrCompletedLab() + +/* -------------------------------------------------------------------------- + * ONE OF THE LOG PARTS HAVE COMPLETED EXECUTING THE LOG. CHECK IF ALL LOG + * PARTS ARE COMPLETED. IF SO START SENDING EXEC_FRAGCONF AND EXEC_SRCONF. + * ------------------------------------------------------------------------- */ +void Dblqh::execLogComp(Signal* signal) +{ + logPartPtr.i = signal->theData[0]; + ptrCheckGuard(logPartPtr, clogPartFileSize, logPartRecord); + logPartPtr.p->logPartState = LogPartRecord::SR_THIRD_PHASE_COMPLETED; + /* ------------------------------------------------------------------------ + * WE MUST RELEASE THE TC CONNECT RECORD HERE SO THAT IT CAN BE REUSED. + * ----------------------------------------------------------------------- */ + tcConnectptr.i = logPartPtr.p->logTcConrec; + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + releaseTcrecLog(signal, tcConnectptr); + for (logPartPtr.i = 0; logPartPtr.i <= 3; logPartPtr.i++) { + jam(); + ptrAss(logPartPtr, logPartRecord); + if (logPartPtr.p->logPartState != LogPartRecord::SR_THIRD_PHASE_COMPLETED) { + if (logPartPtr.p->logPartState != LogPartRecord::SR_THIRD_PHASE_STARTED) { + jam(); + systemErrorLab(signal); + return; + } else { + jam(); + /* ------------------------------------------------------------------ + * THIS LOG PART WAS NOT COMPLETED YET. EXIT AND WAIT FOR IT + * TO COMPLETE + * ----------------------------------------------------------------- */ + return; + }//if + }//if + }//for + /* ------------------------------------------------------------------------ + * ALL LOG PARTS HAVE COMPLETED THE EXECUTION OF THE LOG. WE CAN NOW START + * SENDING THE EXEC_FRAGCONF SIGNALS TO ALL INVOLVED FRAGMENTS. + * ----------------------------------------------------------------------- */ + if (cstartType != NodeState::ST_NODE_RESTART) { + jam(); + signal->theData[0] = ZSEND_EXEC_CONF; + signal->theData[1] = 0; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + } else { + jam(); + /* ---------------------------------------------------------------------- + * FOR NODE RESTART WE CAN SKIP A NUMBER OF STEPS SINCE WE HAVE NO + * FRAGMENTS DEFINED AT THIS POINT. OBVIOUSLY WE WILL NOT NEED TO + * EXECUTE ANY MORE LOG STEPS EITHER AND THUS WE CAN IMMEDIATELY + * START FINDING THE END AND THE START OF THE LOG. + * --------------------------------------------------------------------- */ + csrPhasesCompleted = 3; + execSrCompletedLab(signal); + return; + }//if + return; +}//Dblqh::execLogComp() + +/* -------------------------------------------------------------------------- + * GO THROUGH THE FRAGMENT RECORDS TO DEDUCE TO WHICH SHALL BE SENT + * EXEC_FRAGCONF AFTER COMPLETING THE EXECUTION OF THE LOG. + * ------------------------------------------------------------------------- */ +void Dblqh::sendExecConf(Signal* signal) +{ + jamEntry(); + fragptr.i = signal->theData[0]; + Uint32 loopCount = 0; + while (fragptr.i < cfragrecFileSize) { + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + if (fragptr.p->execSrStatus != Fragrecord::IDLE) { + jam(); + ndbrequire(fragptr.p->execSrNoReplicas - 1 < 4); + for (Uint32 i = 0; i < fragptr.p->execSrNoReplicas; i++) { + jam(); + signal->theData[0] = fragptr.p->execSrUserptr[i]; + sendSignal(fragptr.p->execSrBlockref[i], GSN_EXEC_FRAGCONF, + signal, 1, JBB); + }//for + if (fragptr.p->execSrStatus == Fragrecord::ACTIVE) { + jam(); + fragptr.p->execSrStatus = Fragrecord::IDLE; + } else { + ndbrequire(fragptr.p->execSrStatus == Fragrecord::ACTIVE_REMOVE_AFTER); + jam(); + Uint32 fragId = fragptr.p->fragId; + tabptr.i = fragptr.p->tabRef; + ptrCheckGuard(tabptr, ctabrecFileSize, tablerec); + deleteFragrec(fragId); + }//if + fragptr.p->execSrNoReplicas = 0; + }//if + loopCount++; + if (loopCount > 20) { + jam(); + signal->theData[0] = ZSEND_EXEC_CONF; + signal->theData[1] = fragptr.i + 1; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + return; + } else { + jam(); + fragptr.i++; + }//if + }//while + /* ---------------------------------------------------------------------- + * WE HAVE NOW SENT ALL EXEC_FRAGCONF. NOW IT IS TIME TO SEND + * EXEC_SRCONF TO ALL NODES. + * --------------------------------------------------------------------- */ + srPhase3Comp(signal); +}//Dblqh::sendExecConf() + +/* -------------------------------------------------------------------------- + * PHASE 3 HAS NOW COMPLETED. INFORM ALL OTHER NODES OF THIS EVENT. + * ------------------------------------------------------------------------- */ +void Dblqh::srPhase3Comp(Signal* signal) +{ + jamEntry(); + ndbrequire(cnoOfNodes < MAX_NDB_NODES); + for (Uint32 i = 0; i < cnoOfNodes; i++) { + jam(); + if (cnodeStatus[i] == ZNODE_UP) { + jam(); + ndbrequire(cnodeData[i] < MAX_NDB_NODES); + BlockReference ref = calcLqhBlockRef(cnodeData[i]); + signal->theData[0] = cownNodeid; + sendSignal(ref, GSN_EXEC_SRCONF, signal, 1, JBB); + }//if + }//for + return; +}//Dblqh::srPhase3Comp() + +/* ########################################################################## + * SYSTEM RESTART PHASE FOUR MODULE + * THIS MODULE IS A SUB-MODULE OF THE FILE SYSTEM HANDLING. + * + * THIS MODULE SETS UP THE HEAD AND TAIL POINTERS OF THE LOG PARTS IN THE + * FRAGMENT LOG. WHEN IT IS COMPLETED IT REPORTS TO THE MASTER DIH THAT + * IT HAS COMPLETED THE PART OF THE SYSTEM RESTART WHERE THE DATABASE IS + * LOADED. + * IT ALSO OPENS THE CURRENT LOG FILE AND THE NEXT AND SETS UP THE FIRST + * LOG PAGE WHERE NEW LOG DATA IS TO BE INSERTED WHEN THE SYSTEM STARTS + * AGAIN. + * + * THIS PART IS ACTUALLY EXECUTED FOR ALL RESTART TYPES. + * ######################################################################### */ +void Dblqh::initFourth(Signal* signal) +{ + LogFileRecordPtr locLogFilePtr; + jamEntry(); + logPartPtr.i = signal->theData[0]; + ptrCheckGuard(logPartPtr, clogPartFileSize, logPartRecord); + crestartNewestGci = 1; + crestartOldestGci = 1; + /* ------------------------------------------------------------------------ + * INITIALISE LOG PART AND LOG FILES AS NEEDED. + * ----------------------------------------------------------------------- */ + logPartPtr.p->headFileNo = 0; + logPartPtr.p->headPageNo = 1; + logPartPtr.p->headPageIndex = ZPAGE_HEADER_SIZE + 2; + logPartPtr.p->logPartState = LogPartRecord::SR_FOURTH_PHASE_STARTED; + logPartPtr.p->logTailFileNo = 0; + logPartPtr.p->logTailMbyte = 0; + locLogFilePtr.i = logPartPtr.p->firstLogfile; + ptrCheckGuard(locLogFilePtr, clogFileFileSize, logFileRecord); + locLogFilePtr.p->logFileStatus = LogFileRecord::OPEN_SR_FOURTH_PHASE; + openFileRw(signal, locLogFilePtr); + return; +}//Dblqh::initFourth() + +void Dblqh::openSrFourthPhaseLab(Signal* signal) +{ + /* ------------------------------------------------------------------------ + * WE HAVE NOW OPENED THE HEAD LOG FILE WE WILL NOW START READING IT + * FROM THE HEAD MBYTE TO FIND THE NEW HEAD OF THE LOG. + * ----------------------------------------------------------------------- */ + readSinglePage(signal, logPartPtr.p->headPageNo); + lfoPtr.p->lfoState = LogFileOperationRecord::READ_SR_FOURTH_PHASE; + return; +}//Dblqh::openSrFourthPhaseLab() + +void Dblqh::readSrFourthPhaseLab(Signal* signal) +{ + /* ------------------------------------------------------------------------ + * INITIALISE ALL LOG PART INFO AND LOG FILE INFO THAT IS NEEDED TO + * START UP THE SYSTEM. + * ------------------------------------------------------------------------ + * INITIALISE THE NEWEST GLOBAL CHECKPOINT IDENTITY AND THE NEWEST + * COMPLETED GLOBAL CHECKPOINT IDENITY AS THE NEWEST THAT WAS RESTARTED. + * ------------------------------------------------------------------------ + * INITIALISE THE HEAD PAGE INDEX IN THIS PAGE. + * ASSIGN IT AS THE CURRENT LOGPAGE. + * ASSIGN THE FILE AS THE CURRENT LOG FILE. + * ASSIGN THE CURRENT FILE NUMBER FROM THE CURRENT LOG FILE AND THE NEXT + * FILE NUMBER FROM THE NEXT LOG FILE. + * ASSIGN THE CURRENT FILEPAGE FROM HEAD PAGE NUMBER. + * ASSIGN THE CURRENT MBYTE BY DIVIDING PAGE NUMBER BY 128. + * INITIALISE LOG LAP TO BE THE LOG LAP AS FOUND IN THE HEAD PAGE. + * WE HAVE TO CALCULATE THE NUMBER OF REMAINING WORDS IN THIS MBYTE. + * ----------------------------------------------------------------------- */ + cnewestGci = crestartNewestGci; + cnewestCompletedGci = crestartNewestGci; + logPartPtr.p->logPartNewestCompletedGCI = cnewestCompletedGci; + logPartPtr.p->currentLogfile = logFilePtr.i; + logFilePtr.p->filePosition = logPartPtr.p->headPageNo; + logFilePtr.p->currentMbyte = + logPartPtr.p->headPageNo >> ZTWOLOG_NO_PAGES_IN_MBYTE; + logFilePtr.p->fileChangeState = LogFileRecord::NOT_ONGOING; + logPartPtr.p->logLap = logPagePtr.p->logPageWord[ZPOS_LOG_LAP]; + logFilePtr.p->currentFilepage = logPartPtr.p->headPageNo; + logFilePtr.p->currentLogpage = logPagePtr.i; + initLogpage(signal); + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = logPartPtr.p->headPageIndex; + logFilePtr.p->remainingWordsInMbyte = + (( + ((logFilePtr.p->currentMbyte + 1) * ZPAGES_IN_MBYTE) - + logFilePtr.p->currentFilepage) * + (ZPAGE_SIZE - ZPAGE_HEADER_SIZE)) - + (logPartPtr.p->headPageIndex - ZPAGE_HEADER_SIZE); + /* ------------------------------------------------------------------------ + * THE NEXT STEP IS TO OPEN THE NEXT LOG FILE (IF THERE IS ONE). + * ----------------------------------------------------------------------- */ + if (logFilePtr.p->nextLogFile != logFilePtr.i) { + LogFileRecordPtr locLogFilePtr; + jam(); + locLogFilePtr.i = logFilePtr.p->nextLogFile; + ptrCheckGuard(locLogFilePtr, clogFileFileSize, logFileRecord); + locLogFilePtr.p->logFileStatus = LogFileRecord::OPEN_SR_FOURTH_NEXT; + openFileRw(signal, locLogFilePtr); + } else { + jam(); + /* ---------------------------------------------------------------------- + * THIS CAN ONLY OCCUR IF WE HAVE ONLY ONE LOG FILE. THIS LOG FILE MUST + * BE LOG FILE ZERO AND THAT IS THE FILE WE CURRENTLY HAVE READ. + * THUS WE CAN CONTINUE IMMEDIATELY TO READ PAGE ZERO IN FILE ZERO. + * --------------------------------------------------------------------- */ + openSrFourthZeroSkipInitLab(signal); + return; + }//if + return; +}//Dblqh::readSrFourthPhaseLab() + +void Dblqh::openSrFourthNextLab(Signal* signal) +{ + /* ------------------------------------------------------------------------ + * WE MUST ALSO HAVE FILE 0 OPEN ALL THE TIME. + * ----------------------------------------------------------------------- */ + logFilePtr.i = logPartPtr.p->firstLogfile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + if (logFilePtr.p->logFileStatus == LogFileRecord::OPEN) { + jam(); + openSrFourthZeroSkipInitLab(signal); + return; + } else { + jam(); + logFilePtr.p->logFileStatus = LogFileRecord::OPEN_SR_FOURTH_ZERO; + openFileRw(signal, logFilePtr); + }//if + return; +}//Dblqh::openSrFourthNextLab() + +void Dblqh::openSrFourthZeroLab(Signal* signal) +{ + openSrFourthZeroSkipInitLab(signal); + return; +}//Dblqh::openSrFourthZeroLab() + +void Dblqh::openSrFourthZeroSkipInitLab(Signal* signal) +{ + if (logFilePtr.i == logPartPtr.p->currentLogfile) { + if (logFilePtr.p->currentFilepage == 0) { + jam(); + /* ------------------------------------------------------------------- + * THE HEADER PAGE IN THE LOG IS PAGE ZERO IN FILE ZERO. + * THIS SHOULD NEVER OCCUR. + * ------------------------------------------------------------------- */ + systemErrorLab(signal); + return; + }//if + }//if + readSinglePage(signal, 0); + lfoPtr.p->lfoState = LogFileOperationRecord::READ_SR_FOURTH_ZERO; + return; +}//Dblqh::openSrFourthZeroSkipInitLab() + +void Dblqh::readSrFourthZeroLab(Signal* signal) +{ + logFilePtr.p->logPageZero = logPagePtr.i; + // -------------------------------------------------------------------- + // This is moved to invalidateLogAfterLastGCI(), RT453. + // signal->theData[0] = ZSR_FOURTH_COMP; + // signal->theData[1] = logPartPtr.i; + // sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + // -------------------------------------------------------------------- + + // Need to invalidate log pages after the head of the log. RT 453. EDTJAMO. + // Set the start of the invalidation. + logFilePtr.i = logPartPtr.p->currentLogfile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + logPartPtr.p->invalidateFileNo = logPartPtr.p->headFileNo; + logPartPtr.p->invalidatePageNo = logPartPtr.p->headPageNo; + + logPartPtr.p->logExecState = LogPartRecord::LES_EXEC_LOG_INVALIDATE; + seizeLfo(signal); + initLfo(signal); + // The state here is a little confusing, but simulates that we return + // to invalidateLogAfterLastGCI() from an invalidate write and are ready + // to read a page from file. + lfoPtr.p->lfoState = LogFileOperationRecord::WRITE_SR_INVALIDATE_PAGES; + + invalidateLogAfterLastGCI(signal); + return; +}//Dblqh::readSrFourthZeroLab() + +/* -------------------------------------------------------------------------- + * ONE OF THE LOG PARTS HAVE COMPLETED PHASE FOUR OF THE SYSTEM RESTART. + * CHECK IF ALL LOG PARTS ARE COMPLETED. IF SO SEND START_RECCONF + * ------------------------------------------------------------------------- */ +void Dblqh::srFourthComp(Signal* signal) +{ + jamEntry(); + logPartPtr.i = signal->theData[0]; + ptrCheckGuard(logPartPtr, clogPartFileSize, logPartRecord); + logPartPtr.p->logPartState = LogPartRecord::SR_FOURTH_PHASE_COMPLETED; + for (logPartPtr.i = 0; logPartPtr.i <= 3; logPartPtr.i++) { + jam(); + ptrAss(logPartPtr, logPartRecord); + if (logPartPtr.p->logPartState != LogPartRecord::SR_FOURTH_PHASE_COMPLETED) { + if (logPartPtr.p->logPartState != LogPartRecord::SR_FOURTH_PHASE_STARTED) { + jam(); + systemErrorLab(signal); + return; + } else { + jam(); + /* ------------------------------------------------------------------ + * THIS LOG PART WAS NOT COMPLETED YET. + * EXIT AND WAIT FOR IT TO COMPLETE + * ----------------------------------------------------------------- */ + return; + }//if + }//if + }//for + /* ------------------------------------------------------------------------ + * ALL LOG PARTS HAVE COMPLETED PHASE FOUR OF THE SYSTEM RESTART. + * WE CAN NOW SEND START_RECCONF TO THE MASTER DIH IF IT WAS A + * SYSTEM RESTART. OTHERWISE WE WILL CONTINUE WITH AN INITIAL START. + * SET LOG PART STATE TO IDLE TO + * INDICATE THAT NOTHING IS GOING ON IN THE LOG PART. + * ----------------------------------------------------------------------- */ + for (logPartPtr.i = 0; logPartPtr.i <= 3; logPartPtr.i++) { + ptrAss(logPartPtr, logPartRecord); + logPartPtr.p->logPartState = LogPartRecord::IDLE; + }//for + + if ((cstartType == NodeState::ST_INITIAL_START) || + (cstartType == NodeState::ST_INITIAL_NODE_RESTART)) { + jam(); + + ndbrequire(cinitialStartOngoing == ZTRUE); + cinitialStartOngoing = ZFALSE; + + checkStartCompletedLab(signal); + return; + } else if ((cstartType == NodeState::ST_NODE_RESTART) || + (cstartType == NodeState::ST_SYSTEM_RESTART)) { + jam(); + StartRecConf * conf = (StartRecConf*)signal->getDataPtrSend(); + conf->startingNodeId = getOwnNodeId(); + sendSignal(cmasterDihBlockref, GSN_START_RECCONF, signal, + StartRecConf::SignalLength, JBB); + } else { + ndbrequire(false); + }//if + return; +}//Dblqh::srFourthComp() + +/* ######################################################################### */ +/* ####### ERROR MODULE ####### */ +/* */ +/* ######################################################################### */ +void Dblqh::warningHandlerLab(Signal* signal) +{ + systemErrorLab(signal); + return; +}//Dblqh::warningHandlerLab() + +/*---------------------------------------------------------------------------*/ +/* AN ERROR OCCURRED THAT WE WILL NOT TREAT AS SYSTEM ERROR. MOST OFTEN THIS */ +/* WAS CAUSED BY AN ERRONEUS SIGNAL SENT BY ANOTHER NODE. WE DO NOT WISH TO */ +/* CRASH BECAUSE OF FAULTS IN OTHER NODES. THUS WE ONLY REPORT A WARNING. */ +/* THIS IS CURRENTLY NOT IMPLEMENTED AND FOR THE MOMENT WE GENERATE A SYSTEM */ +/* ERROR SINCE WE WANT TO FIND FAULTS AS QUICKLY AS POSSIBLE IN A TEST PHASE.*/ +/* IN A LATER PHASE WE WILL CHANGE THIS TO BE A WARNING MESSAGE INSTEAD. */ +/*---------------------------------------------------------------------------*/ +/*---------------------------------------------------------------------------*/ +/* THIS TYPE OF ERROR SHOULD NOT GENERATE A SYSTEM ERROR IN A PRODUCT */ +/* RELEASE. THIS IS A TEMPORARY SOLUTION DURING TEST PHASE TO QUICKLY */ +/* FIND ERRORS. NORMALLY THIS SHOULD GENERATE A WARNING MESSAGE ONTO */ +/* SOME ERROR LOGGER. THIS WILL LATER BE IMPLEMENTED BY SOME SIGNAL. */ +/*---------------------------------------------------------------------------*/ +/* ------ SYSTEM ERROR SITUATIONS ------- */ +/* IN SITUATIONS WHERE THE STATE IS ERRONEOUS OR IF THE ERROR OCCURS IN */ +/* THE COMMIT, COMPLETE OR ABORT PHASE, WE PERFORM A CRASH OF THE AXE VM*/ +/*---------------------------------------------------------------------------*/ + +void Dblqh::systemErrorLab(Signal* signal) +{ + progError(0, 0); +/*************************************************************************>*/ +/* WE WANT TO INVOKE AN IMMEDIATE ERROR HERE SO WE GET THAT BY */ +/* INSERTING A CERTAIN POINTER OUT OF RANGE. */ +/*************************************************************************>*/ +}//Dblqh::systemErrorLab() + +/* ------- ERROR SITUATIONS ------- */ + +void Dblqh::aiStateErrorCheckLab(Signal* signal, Uint32* dataPtr, Uint32 length) +{ + ndbrequire(tcConnectptr.p->abortState != TcConnectionrec::ABORT_IDLE); + if (tcConnectptr.p->transactionState != TcConnectionrec::IDLE) { + jam(); +/*************************************************************************>*/ +/* TRANSACTION ABORT IS ONGOING. IT CAN STILL BE A PART OF AN */ +/* OPERATION THAT SHOULD CONTINUE SINCE THE TUPLE HAS NOT ARRIVED */ +/* YET. THIS IS POSSIBLE IF ACTIVE CREATION OF THE FRAGMENT IS */ +/* ONGOING. */ +/*************************************************************************>*/ + if (tcConnectptr.p->activeCreat == ZTRUE) { + jam(); +/*************************************************************************>*/ +/* ONGOING ABORTS DURING ACTIVE CREATION MUST SAVE THE ATTRIBUTE INFO*/ +/* SO THAT IT CAN BE SENT TO THE NEXT NODE IN THE COMMIT CHAIN. THIS */ +/* IS NEEDED SINCE ALL ABORTS DURING CREATION OF A FRAGMENT ARE NOT */ +/* REALLY ERRORS. A MISSING TUPLE TO BE UPDATED SIMPLY MEANS THAT */ +/* IT HASN'T BEEN TRANSFERRED TO THE NEW REPLICA YET. */ +/*************************************************************************>*/ +/*************************************************************************>*/ +/* AFTER THIS ERROR THE ABORT MUST BE COMPLETED. TO ENSURE THIS SET */ +/* ACTIVE CREATION TO FALSE. THIS WILL ENSURE THAT THE ABORT IS */ +/* COMPLETED. */ +/*************************************************************************>*/ + if (saveTupattrbuf(signal, dataPtr, length) == ZOK) { + jam(); + if (tcConnectptr.p->transactionState == + TcConnectionrec::WAIT_AI_AFTER_ABORT) { + if (tcConnectptr.p->currTupAiLen == tcConnectptr.p->totReclenAi) { + jam(); +/*************************************************************************>*/ +/* WE WERE WAITING FOR MORE ATTRIBUTE INFO AFTER A SUCCESSFUL ABORT */ +/* IN ACTIVE CREATION STATE. THE TRANSACTION SHOULD CONTINUE AS IF */ +/* IT WAS COMMITTED. NOW ALL INFO HAS ARRIVED AND WE CAN CONTINUE */ +/* WITH NORMAL PROCESSING AS IF THE TRANSACTION WAS PREPARED. */ +/* SINCE THE FRAGMENT IS UNDER CREATION WE KNOW THAT LOGGING IS */ +/* DISABLED. WE STILL HAVE TO CATER FOR DIRTY OPERATION OR NOT. */ +/*************************************************************************>*/ + tcConnectptr.p->abortState = TcConnectionrec::ABORT_IDLE; + rwConcludedAiLab(signal); + return; + } else { + ndbrequire(tcConnectptr.p->currTupAiLen < tcConnectptr.p->totReclenAi); + jam(); + return; /* STILL WAITING FOR MORE ATTRIBUTE INFO */ + }//if + }//if + } else { + jam(); +/*************************************************************************>*/ +/* AFTER THIS ERROR THE ABORT MUST BE COMPLETED. TO ENSURE THIS SET */ +/* ACTIVE CREATION TO ABORT. THIS WILL ENSURE THAT THE ABORT IS */ +/* COMPLETED AND THAT THE ERROR CODE IS PROPERLY SET */ +/*************************************************************************>*/ + tcConnectptr.p->errorCode = terrorCode; + tcConnectptr.p->activeCreat = ZFALSE; + if (tcConnectptr.p->transactionState == + TcConnectionrec::WAIT_AI_AFTER_ABORT) { + jam(); +/*************************************************************************>*/ +/* ABORT IS ALREADY COMPLETED. WE NEED TO RESTART IT FROM WHERE IT */ +/* WAS INTERRUPTED. */ +/*************************************************************************>*/ + continueAbortLab(signal); + return; + } else { + jam(); + return; +/*************************************************************************>*/ +// Abort is ongoing. It will complete since we set the activeCreat = ZFALSE +/*************************************************************************>*/ + }//if + }//if + }//if + }//if +/*************************************************************************>*/ +/* TRANSACTION HAVE BEEN ABORTED. THUS IGNORE ALL SIGNALS BELONGING TO IT. */ +/*************************************************************************>*/ + return; +}//Dblqh::aiStateErrorCheckLab() + +void Dblqh::takeOverErrorLab(Signal* signal) +{ + terrorCode = ZTAKE_OVER_ERROR; + abortErrorLab(signal); + return; +}//Dblqh::takeOverErrorLab() + +/* ########################################################################## + * TEST MODULE + * ######################################################################### */ +#ifdef VM_TRACE +void Dblqh::execTESTSIG(Signal* signal) +{ + jamEntry(); + Uint32 userpointer = signal->theData[0]; + BlockReference userblockref = signal->theData[1]; + Uint32 testcase = signal->theData[2]; + + signal->theData[0] = userpointer; + signal->theData[1] = cownref; + signal->theData[2] = testcase; + sendSignal(userblockref, GSN_TESTSIG, signal, 25, JBB); + return; +}//Dblqh::execTESTSIG() + +/* *************** */ +/* MEMCHECKREQ > */ +/* *************** */ +/* ************************************************************************>> + * THIS SIGNAL IS PURELY FOR TESTING PURPOSES. IT CHECKS THE FREE LIST + * AND REPORTS THE NUMBER OF FREE RECORDS. + * THIS CAN BE DONE TO ENSURE THAT NO RECORDS HAS BEEN LOST + * ************************************************************************> */ +void Dblqh::execMEMCHECKREQ(Signal* signal) +{ + Uint32* dataPtr = &signal->theData[0]; + jamEntry(); + BlockReference userblockref = signal->theData[0]; + Uint32 index = 0; + for (Uint32 i = 0; i < 7; i++) + dataPtr[i] = 0; + addfragptr.i = cfirstfreeAddfragrec; + while (addfragptr.i != RNIL) { + ptrCheckGuard(addfragptr, caddfragrecFileSize, addFragRecord); + addfragptr.i = addfragptr.p->nextAddfragrec; + dataPtr[index]++; + }//while + index++; + attrinbufptr.i = cfirstfreeAttrinbuf; + while (attrinbufptr.i != RNIL) { + ptrCheckGuard(attrinbufptr, cattrinbufFileSize, attrbuf); + attrinbufptr.i = attrinbufptr.p->attrbuf[ZINBUF_NEXT]; + dataPtr[index]++; + }//while + index++; + databufptr.i = cfirstfreeDatabuf; + while (databufptr.i != RNIL) { + ptrCheckGuard(databufptr, cdatabufFileSize, databuf); + databufptr.i = databufptr.p->nextDatabuf; + dataPtr[index]++; + }//while + index++; + fragptr.i = cfirstfreeFragrec; + while (fragptr.i != RNIL) { + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + fragptr.i = fragptr.p->nextFrag; + dataPtr[index]++; + }//while + index++; + for (tabptr.i = 0; + tabptr.i < ctabrecFileSize; + tabptr.i++) { + ptrAss(tabptr, tablerec); + if (tabptr.p->tableStatus == Tablerec::NOT_DEFINED) { + dataPtr[index]++; + }//if + }//for + index++; + tcConnectptr.i = cfirstfreeTcConrec; + while (tcConnectptr.i != RNIL) { + ptrCheckGuard(tcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + tcConnectptr.i = tcConnectptr.p->nextTcConnectrec; + dataPtr[index]++; + }//while + sendSignal(userblockref, GSN_MEMCHECKCONF, signal, 10, JBB); + return; +}//Dblqh::execMEMCHECKREQ() + +#endif + +/* ************************************************************************* */ +/* ************************* STATEMENT BLOCKS ****************************** */ +/* ************************************************************************* */ +/* ========================================================================= */ +/* ====== BUILD LINKED LIST OF LOG PAGES AFTER RECEIVING FSREADCONF ======= */ +/* */ +/* ========================================================================= */ +void Dblqh::buildLinkedLogPageList(Signal* signal) +{ + LogPageRecordPtr bllLogPagePtr; + + arrGuard(lfoPtr.p->noPagesRw - 1, 16); + arrGuard(lfoPtr.p->noPagesRw, 16); + for (UintR tbllIndex = 0; tbllIndex < lfoPtr.p->noPagesRw; tbllIndex++) { + jam(); + /* ---------------------------------------------------------------------- + * BUILD LINKED LIST BUT ALSO ENSURE THAT PAGE IS NOT SEEN AS DIRTY + * INITIALLY. + * --------------------------------------------------------------------- */ + bllLogPagePtr.i = lfoPtr.p->logPageArray[tbllIndex]; + ptrCheckGuard(bllLogPagePtr, clogPageFileSize, logPageRecord); + +// #if VM_TRACE +// // Check logPage checksum before modifying it +// Uint32 calcCheckSum = calcPageCheckSum(bllLogPagePtr); +// Uint32 checkSum = bllLogPagePtr.p->logPageWord[ZPOS_CHECKSUM]; +// if (checkSum != calcCheckSum) { +// ndbout << "Redolog: Checksum failure." << endl; +// progError(__LINE__, ERR_NDBREQUIRE, "Redolog: Checksum failure."); +// } +// #endif + + bllLogPagePtr.p->logPageWord[ZNEXT_PAGE] = + lfoPtr.p->logPageArray[tbllIndex + 1]; + bllLogPagePtr.p->logPageWord[ZPOS_DIRTY] = ZNOT_DIRTY; + }//for + bllLogPagePtr.i = lfoPtr.p->logPageArray[lfoPtr.p->noPagesRw - 1]; + ptrCheckGuard(bllLogPagePtr, clogPageFileSize, logPageRecord); + bllLogPagePtr.p->logPageWord[ZNEXT_PAGE] = RNIL; +}//Dblqh::buildLinkedLogPageList() + +/* ========================================================================= + * ======= CHANGE TO NEXT MBYTE IN LOG ======= + * + * ========================================================================= */ +void Dblqh::changeMbyte(Signal* signal) +{ + writeNextLog(signal); + writeFileDescriptor(signal); +}//Dblqh::changeMbyte() + +/* ========================================================================= */ +/* ====== CHECK IF THIS COMMIT LOG RECORD IS TO BE EXECUTED ======= */ +/* */ +/* SUBROUTINE SHORT NAME = CEL */ +/* ========================================================================= */ +Uint32 Dblqh::checkIfExecLog(Signal* signal) +{ + tabptr.i = tcConnectptr.p->tableref; + ptrCheckGuard(tabptr, ctabrecFileSize, tablerec); + if (getFragmentrec(signal, tcConnectptr.p->fragmentid) && + (tabptr.p->schemaVersion == tcConnectptr.p->schemaVersion)) { + if (fragptr.p->execSrStatus != Fragrecord::IDLE) { + if (fragptr.p->execSrNoReplicas > logPartPtr.p->execSrExecuteIndex) { + ndbrequire((fragptr.p->execSrNoReplicas - 1) < 4); + for (Uint32 i = logPartPtr.p->execSrExecuteIndex; + i < fragptr.p->execSrNoReplicas; + i++) { + jam(); + if (tcConnectptr.p->gci >= fragptr.p->execSrStartGci[i]) { + if (tcConnectptr.p->gci <= fragptr.p->execSrLastGci[i]) { + jam(); + logPartPtr.p->execSrExecuteIndex = i; + return ZOK; + }//if + }//if + }//for + }//if + }//if + }//if + return ZNOT_OK; +}//Dblqh::checkIfExecLog() + +/* ========================================================================= */ +/* == CHECK IF THERE IS LESS THAN 192 KBYTE IN THE BUFFER PLUS INCOMING === */ +/* READS ALREADY STARTED. IF SO IS THE CASE THEN START ANOTHER READ IF */ +/* THERE ARE MORE PAGES IN THIS MBYTE. */ +/* */ +/* ========================================================================= */ +void Dblqh::checkReadExecSr(Signal* signal) +{ + logPartPtr.p->logExecState = LogPartRecord::LES_EXEC_LOG; + logPartPtr.p->execSrPagesRead = logPartPtr.p->execSrPagesRead + 8; + logPartPtr.p->execSrPagesReading = logPartPtr.p->execSrPagesReading - 8; + if ((logPartPtr.p->execSrPagesRead + logPartPtr.p->execSrPagesReading) < + ZREAD_AHEAD_SIZE) { + jam(); + /* ---------------------------------------------------------------------- + * WE HAVE LESS THAN 64 KBYTE OF LOG PAGES REMAINING IN MEMORY OR ON + * ITS WAY TO MAIN MEMORY. READ IN 8 MORE PAGES. + * --------------------------------------------------------------------- */ + if ((logPartPtr.p->execSrPagesRead + logPartPtr.p->execSrPagesExecuted) < + ZPAGES_IN_MBYTE) { + jam(); + /* -------------------------------------------------------------------- + * THERE ARE MORE PAGES TO READ IN THIS MBYTE. READ THOSE FIRST + * IF >= ZPAGES_IN_MBYTE THEN THERE ARE NO MORE PAGES TO READ. THUS + * WE PROCEED WITH EXECUTION OF THE LOG. + * ------------------------------------------------------------------- */ + readExecSr(signal); + logPartPtr.p->logExecState = LogPartRecord::LES_WAIT_READ_EXEC_SR; + }//if + }//if +}//Dblqh::checkReadExecSr() + +/* ========================================================================= */ +/* ==== CHECK IF START OF NEW FRAGMENT IS COMPLETED AND WE CAN ======= */ +/* ==== GET THE START GCI ======= */ +/* */ +/* SUBROUTINE SHORT NAME = CTC */ +/* ========================================================================= */ +void Dblqh::checkScanTcCompleted(Signal* signal) +{ + tcConnectptr.p->logWriteState = TcConnectionrec::NOT_STARTED; + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + fragptr.p->activeTcCounter = fragptr.p->activeTcCounter - 1; + if (fragptr.p->activeTcCounter == 0) { + jam(); + fragptr.p->startGci = cnewestGci + 1; + tabptr.i = tcConnectptr.p->tableref; + ptrCheckGuard(tabptr, ctabrecFileSize, tablerec); + sendCopyActiveConf(signal, tcConnectptr.p->tableref); + }//if +}//Dblqh::checkScanTcCompleted() + +/* ========================================================================== + * === CHECK IF ALL PARTS OF A SYSTEM RESTART ON A FRAGMENT ARE COMPLETED === + * + * SUBROUTINE SHORT NAME = CSC + * ========================================================================= */ +void Dblqh::checkSrCompleted(Signal* signal) +{ + LcpLocRecordPtr cscLcpLocptr; + + terrorCode = ZOK; + ptrGuard(lcpPtr); + cscLcpLocptr.i = lcpPtr.p->firstLcpLocAcc; +CSC_ACC_DOWHILE: + ptrCheckGuard(cscLcpLocptr, clcpLocrecFileSize, lcpLocRecord); + if (cscLcpLocptr.p->lcpLocstate != LcpLocRecord::SR_ACC_COMPLETED) { + jam(); + if (cscLcpLocptr.p->lcpLocstate != LcpLocRecord::SR_ACC_STARTED) { + jam(); + systemErrorLab(signal); + return; + }//if + return; + }//if + cscLcpLocptr.i = cscLcpLocptr.p->nextLcpLoc; + if (cscLcpLocptr.i != RNIL) { + jam(); + goto CSC_ACC_DOWHILE; + }//if + cscLcpLocptr.i = lcpPtr.p->firstLcpLocTup; +CSC_TUP_DOWHILE: + ptrCheckGuard(cscLcpLocptr, clcpLocrecFileSize, lcpLocRecord); + if (cscLcpLocptr.p->lcpLocstate != LcpLocRecord::SR_TUP_COMPLETED) { + jam(); + if (cscLcpLocptr.p->lcpLocstate != LcpLocRecord::SR_TUP_STARTED) { + jam(); + systemErrorLab(signal); + return; + }//if + return; + }//if + cscLcpLocptr.i = cscLcpLocptr.p->nextLcpLoc; + if (cscLcpLocptr.i != RNIL) { + jam(); + goto CSC_TUP_DOWHILE; + }//if + lcpPtr.p->lcpState = LcpRecord::LCP_SR_COMPLETED; +}//Dblqh::checkSrCompleted() + +/* ------------------------------------------------------------------------- */ +/* ------ CLOSE A FILE DURING EXECUTION OF FRAGMENT LOG ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dblqh::closeFile(Signal* signal, LogFileRecordPtr clfLogFilePtr) +{ + signal->theData[0] = clfLogFilePtr.p->fileRef; + signal->theData[1] = cownref; + signal->theData[2] = clfLogFilePtr.i; + signal->theData[3] = ZCLOSE_NO_DELETE; + sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA); +}//Dblqh::closeFile() + + +/* ---------------------------------------------------------------- */ +/* ---------------- A LOG PAGE HAVE BEEN COMPLETED ---------------- */ +/* */ +/* SUBROUTINE SHORT NAME = CLP */ +// Input Pointers: +// logFilePtr +// logPagePtr +// logPartPtr +// Defines lfoPtr +/* ---------------------------------------------------------------- */ +void Dblqh::completedLogPage(Signal* signal, Uint32 clpType) +{ + LogPageRecordPtr clpLogPagePtr; + LogPageRecordPtr wlpLogPagePtr; + UintR twlpNoPages; + UintR twlpType; + + if (logFilePtr.p->firstFilledPage == RNIL) { + jam(); + logFilePtr.p->firstFilledPage = logPagePtr.i; + } else { + jam(); + clpLogPagePtr.i = logFilePtr.p->lastFilledPage; + ptrCheckGuard(clpLogPagePtr, clogPageFileSize, logPageRecord); + clpLogPagePtr.p->logPageWord[ZNEXT_PAGE] = logPagePtr.i; + }//if + logFilePtr.p->lastFilledPage = logPagePtr.i; + logPagePtr.p->logPageWord[ZNEXT_PAGE] = RNIL; + logFilePtr.p->noLogpagesInBuffer = logFilePtr.p->noLogpagesInBuffer + 1; + if (logFilePtr.p->noLogpagesInBuffer != ZMAX_PAGES_WRITTEN) { + if (clpType != ZLAST_WRITE_IN_FILE) { + if (clpType != ZENFORCE_WRITE) { + jam(); + return; + }//if + }//if + }//if + twlpType = clpType; +/* ------------------------------------------------------------------------- */ +/* ------ WRITE A SET OF LOG PAGES TO DISK ------- */ +/* */ +/* SUBROUTINE SHORT NAME: WLP */ +/* ------------------------------------------------------------------------- */ + seizeLfo(signal); + initLfo(signal); + Uint32* dataPtr = &signal->theData[6]; + twlpNoPages = 0; + wlpLogPagePtr.i = logFilePtr.p->firstFilledPage; + do { + dataPtr[twlpNoPages] = wlpLogPagePtr.i; + twlpNoPages++; + ptrCheckGuard(wlpLogPagePtr, clogPageFileSize, logPageRecord); + + // Calculate checksum for page + wlpLogPagePtr.p->logPageWord[ZPOS_CHECKSUM] = calcPageCheckSum(wlpLogPagePtr); + wlpLogPagePtr.i = wlpLogPagePtr.p->logPageWord[ZNEXT_PAGE]; + } while (wlpLogPagePtr.i != RNIL); + ndbrequire(twlpNoPages < 9); + dataPtr[twlpNoPages] = logFilePtr.p->filePosition; +/* -------------------------------------------------- */ +/* SET TIMER ON THIS LOG PART TO SIGNIFY THAT A */ +/* LOG RECORD HAS BEEN SENT AT THIS TIME. */ +/* -------------------------------------------------- */ + logPartPtr.p->logPartTimer = logPartPtr.p->logTimer; + signal->theData[0] = logFilePtr.p->fileRef; + signal->theData[1] = cownref; + signal->theData[2] = lfoPtr.i; + logFilePtr.p->logFilePagesToDiskWithoutSynch += twlpNoPages; + if (twlpType == ZLAST_WRITE_IN_FILE) { + jam(); + logFilePtr.p->logFilePagesToDiskWithoutSynch = 0; + signal->theData[3] = ZLIST_OF_MEM_PAGES_SYNCH; + } else if (logFilePtr.p->logFilePagesToDiskWithoutSynch > + MAX_REDO_PAGES_WITHOUT_SYNCH) { + jam(); + logFilePtr.p->logFilePagesToDiskWithoutSynch = 0; + signal->theData[3] = ZLIST_OF_MEM_PAGES_SYNCH; + } else { + jam(); + signal->theData[3] = ZLIST_OF_MEM_PAGES; + }//if + signal->theData[4] = ZVAR_NO_LOG_PAGE_WORD; + signal->theData[5] = twlpNoPages; + sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal, 15, JBA); + if (twlpType == ZNORMAL) { + jam(); + lfoPtr.p->lfoState = LogFileOperationRecord::ACTIVE_WRITE_LOG; + } else if (twlpType == ZLAST_WRITE_IN_FILE) { + jam(); + lfoPtr.p->lfoState = LogFileOperationRecord::LAST_WRITE_IN_FILE; + } else { + ndbrequire(twlpType == ZENFORCE_WRITE); + jam(); + lfoPtr.p->lfoState = LogFileOperationRecord::ACTIVE_WRITE_LOG; + }//if + /* ----------------------------------------------------------------------- */ + /* ------ MOVE PAGES FROM LOG FILE TO LFO RECORD ------- */ + /* */ + /* ----------------------------------------------------------------------- */ + /* -------------------------------------------------- */ + /* MOVE PAGES TO LFO RECORD AND REMOVE THEM */ + /* FROM LOG FILE RECORD. */ + /* -------------------------------------------------- */ + lfoPtr.p->firstLfoPage = logFilePtr.p->firstFilledPage; + logFilePtr.p->firstFilledPage = RNIL; + logFilePtr.p->lastFilledPage = RNIL; + logFilePtr.p->noLogpagesInBuffer = 0; + + lfoPtr.p->noPagesRw = twlpNoPages; + lfoPtr.p->lfoPageNo = logFilePtr.p->filePosition; + lfoPtr.p->lfoWordWritten = ZPAGE_SIZE - 1; + logFilePtr.p->filePosition += twlpNoPages; +}//Dblqh::completedLogPage() + +/* ---------------------------------------------------------------- */ +/* ---------------- DELETE FRAGMENT RECORD ------------------------ */ +/* */ +/* SUBROUTINE SHORT NAME = DFR */ +/* ---------------------------------------------------------------- */ +void Dblqh::deleteFragrec(Uint32 fragId) +{ + Uint32 indexFound; + fragptr.i = RNIL; + for (Uint32 i = (NO_OF_FRAG_PER_NODE - 1); (Uint32)~i; i--) { + jam(); + if (tabptr.p->fragid[i] == fragId) { + fragptr.i = tabptr.p->fragrec[i]; + indexFound = i; + break; + }//if + }//for + if (fragptr.i != RNIL) { + jam(); + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + tabptr.p->fragid[indexFound] = ZNIL; + tabptr.p->fragrec[indexFound] = RNIL; + releaseFragrec(); + }//if +}//Dblqh::deleteFragrec() + +/* ------------------------------------------------------------------------- */ +/* ------- FIND LOG FILE RECORD GIVEN FILE NUMBER ------- */ +/* */ +/* INPUT: TFLF_FILE_NO THE FILE NUMBER */ +/* FLF_LOG_PART_PTR THE LOG PART RECORD */ +/* OUTPUT: FLF_LOG_FILE_PTR THE FOUND LOG FILE RECORD */ +/* SUBROUTINE SHORT NAME = FLF */ +/* ------------------------------------------------------------------------- */ +void Dblqh::findLogfile(Signal* signal, + Uint32 fileNo, + LogPartRecordPtr flfLogPartPtr, + LogFileRecordPtr* parLogFilePtr) +{ + LogFileRecordPtr locLogFilePtr; + locLogFilePtr.i = flfLogPartPtr.p->firstLogfile; + Uint32 loopCount = 0; + while (true) { + ptrCheckGuard(locLogFilePtr, clogFileFileSize, logFileRecord); + if (locLogFilePtr.p->fileNo == fileNo) { + jam(); + ndbrequire(loopCount == fileNo); + parLogFilePtr->i = locLogFilePtr.i; + parLogFilePtr->p = locLogFilePtr.p; + return; + }//if + locLogFilePtr.i = locLogFilePtr.p->nextLogFile; + loopCount++; + ndbrequire(loopCount < flfLogPartPtr.p->noLogFiles); + }//while +}//Dblqh::findLogfile() + +/* ------------------------------------------------------------------------- */ +/* ------ FIND PAGE REFERENCE IN MEMORY BUFFER AT LOG EXECUTION ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dblqh::findPageRef(Signal* signal, CommitLogRecord* commitLogRecord) +{ + UintR tfprIndex; + + logPagePtr.i = RNIL; + if (ERROR_INSERTED(5020)) { + // Force system to read page from disk + return; + } + pageRefPtr.i = logPartPtr.p->lastPageRef; + do { + ptrCheckGuard(pageRefPtr, cpageRefFileSize, pageRefRecord); + if (commitLogRecord->fileNo == pageRefPtr.p->prFileNo) { + if (commitLogRecord->startPageNo >= pageRefPtr.p->prPageNo) { + if (commitLogRecord->startPageNo < (Uint16) (pageRefPtr.p->prPageNo + 8)) { + jam(); + tfprIndex = commitLogRecord->startPageNo - pageRefPtr.p->prPageNo; + logPagePtr.i = pageRefPtr.p->pageRef[tfprIndex]; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + return; + }//if + }//if + }//if + pageRefPtr.i = pageRefPtr.p->prPrev; + } while (pageRefPtr.i != RNIL); +}//Dblqh::findPageRef() + +/* ------------------------------------------------------------------------- */ +/* ------ GET FIRST OPERATION QUEUED FOR LOGGING ------- */ +/* */ +/* SUBROUTINE SHORT NAME = GFL */ +/* ------------------------------------------------------------------------- */ +void Dblqh::getFirstInLogQueue(Signal* signal) +{ + TcConnectionrecPtr gflTcConnectptr; +/* -------------------------------------------------- */ +/* GET THE FIRST FROM THE LOG QUEUE AND REMOVE */ +/* IT FROM THE QUEUE. */ +/* -------------------------------------------------- */ + gflTcConnectptr.i = logPartPtr.p->firstLogQueue; + ptrCheckGuard(gflTcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + logPartPtr.p->firstLogQueue = gflTcConnectptr.p->nextTcLogQueue; + if (logPartPtr.p->firstLogQueue == RNIL) { + jam(); + logPartPtr.p->lastLogQueue = RNIL; + }//if +}//Dblqh::getFirstInLogQueue() + +/* ---------------------------------------------------------------- */ +/* ---------------- GET FRAGMENT RECORD --------------------------- */ +/* INPUT: TFRAGID FRAGMENT ID LOOKING FOR */ +/* TABPTR TABLE ID */ +/* SUBROUTINE SHORT NAME = GFR */ +/* ---------------------------------------------------------------- */ +bool Dblqh::getFragmentrec(Signal* signal, Uint32 fragId) +{ + for (Uint32 i = (NO_OF_FRAG_PER_NODE - 1); (UintR)~i; i--) { + jam(); + if (tabptr.p->fragid[i] == fragId) { + fragptr.i = tabptr.p->fragrec[i]; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + return true; + }//if + }//for + return false; +}//Dblqh::getFragmentrec() + +/* ========================================================================= */ +/* ====== INITIATE FRAGMENT RECORD ======= */ +/* */ +/* ========================================================================= */ +void Dblqh::initialiseAddfragrec(Signal* signal) +{ + if (caddfragrecFileSize != 0) { + for (addfragptr.i = 0; addfragptr.i < caddfragrecFileSize; addfragptr.i++) { + ptrAss(addfragptr, addFragRecord); + addfragptr.p->addfragStatus = AddFragRecord::FREE; + addfragptr.p->nextAddfragrec = addfragptr.i + 1; + }//for + addfragptr.i = caddfragrecFileSize - 1; + ptrAss(addfragptr, addFragRecord); + addfragptr.p->nextAddfragrec = RNIL; + cfirstfreeAddfragrec = 0; + } else { + jam(); + cfirstfreeAddfragrec = RNIL; + }//if +}//Dblqh::initialiseAddfragrec() + +/* ========================================================================= */ +/* ====== INITIATE ATTRIBUTE IN AND OUT DATA BUFFER ======= */ +/* */ +/* ========================================================================= */ +void Dblqh::initialiseAttrbuf(Signal* signal) +{ + if (cattrinbufFileSize != 0) { + for (attrinbufptr.i = 0; + attrinbufptr.i < cattrinbufFileSize; + attrinbufptr.i++) { + ptrAss(attrinbufptr, attrbuf); + attrinbufptr.p->attrbuf[ZINBUF_NEXT] = attrinbufptr.i + 1; + }//for + /* NEXT ATTRINBUF */ + attrinbufptr.i = cattrinbufFileSize - 1; + ptrAss(attrinbufptr, attrbuf); + attrinbufptr.p->attrbuf[ZINBUF_NEXT] = RNIL; /* NEXT ATTRINBUF */ + cfirstfreeAttrinbuf = 0; + } else { + jam(); + cfirstfreeAttrinbuf = RNIL; + }//if +}//Dblqh::initialiseAttrbuf() + +/* ========================================================================= */ +/* ====== INITIATE DATA BUFFER ======= */ +/* */ +/* ========================================================================= */ +void Dblqh::initialiseDatabuf(Signal* signal) +{ + if (cdatabufFileSize != 0) { + for (databufptr.i = 0; databufptr.i < cdatabufFileSize; databufptr.i++) { + ptrAss(databufptr, databuf); + databufptr.p->nextDatabuf = databufptr.i + 1; + }//for + databufptr.i = cdatabufFileSize - 1; + ptrAss(databufptr, databuf); + databufptr.p->nextDatabuf = RNIL; + cfirstfreeDatabuf = 0; + } else { + jam(); + cfirstfreeDatabuf = RNIL; + }//if +}//Dblqh::initialiseDatabuf() + +/* ========================================================================= */ +/* ====== INITIATE FRAGMENT RECORD ======= */ +/* */ +/* ========================================================================= */ +void Dblqh::initialiseFragrec(Signal* signal) +{ + if (cfragrecFileSize != 0) { + for (fragptr.i = 0; fragptr.i < cfragrecFileSize; fragptr.i++) { + ptrAss(fragptr, fragrecord); + fragptr.p->fragStatus = Fragrecord::FREE; + fragptr.p->fragActiveStatus = ZFALSE; + fragptr.p->execSrStatus = Fragrecord::IDLE; + fragptr.p->srStatus = Fragrecord::SS_IDLE; + fragptr.p->nextFrag = fragptr.i + 1; + }//for + fragptr.i = cfragrecFileSize - 1; + ptrAss(fragptr, fragrecord); + fragptr.p->nextFrag = RNIL; + cfirstfreeFragrec = 0; + } else { + jam(); + cfirstfreeFragrec = RNIL; + }//if +}//Dblqh::initialiseFragrec() + +/* ========================================================================= */ +/* ====== INITIATE FRAGMENT RECORD ======= */ +/* */ +/* ========================================================================= */ +void Dblqh::initialiseGcprec(Signal* signal) +{ + UintR tigpIndex; + + if (cgcprecFileSize != 0) { + for (gcpPtr.i = 0; gcpPtr.i < cgcprecFileSize; gcpPtr.i++) { + ptrAss(gcpPtr, gcpRecord); + for (tigpIndex = 0; tigpIndex <= 3; tigpIndex++) { + gcpPtr.p->gcpLogPartState[tigpIndex] = ZIDLE; + gcpPtr.p->gcpSyncReady[tigpIndex] = ZFALSE; + }//for + }//for + }//if +}//Dblqh::initialiseGcprec() + +/* ========================================================================= */ +/* ====== INITIATE LCP RECORD ======= */ +/* */ +/* ========================================================================= */ +void Dblqh::initialiseLcpRec(Signal* signal) +{ + if (clcpFileSize != 0) { + for (lcpPtr.i = 0; lcpPtr.i < clcpFileSize; lcpPtr.i++) { + ptrAss(lcpPtr, lcpRecord); + lcpPtr.p->lcpState = LcpRecord::LCP_IDLE; + lcpPtr.p->lcpQueued = false; + lcpPtr.p->firstLcpLocAcc = RNIL; + lcpPtr.p->firstLcpLocTup = RNIL; + lcpPtr.p->reportEmpty = false; + lcpPtr.p->lastFragmentFlag = false; + }//for + }//if +}//Dblqh::initialiseLcpRec() + +/* ========================================================================= */ +/* ====== INITIATE LCP LOCAL RECORD ======= */ +/* */ +/* ========================================================================= */ +void Dblqh::initialiseLcpLocrec(Signal* signal) +{ + if (clcpLocrecFileSize != 0) { + for (lcpLocptr.i = 0; lcpLocptr.i < clcpLocrecFileSize; lcpLocptr.i++) { + ptrAss(lcpLocptr, lcpLocRecord); + lcpLocptr.p->nextLcpLoc = lcpLocptr.i + 1; + lcpLocptr.p->lcpLocstate = LcpLocRecord::IDLE; + lcpLocptr.p->masterLcpRec = RNIL; + lcpLocptr.p->waitingBlock = LcpLocRecord::NONE; + }//for + lcpLocptr.i = clcpLocrecFileSize - 1; + ptrAss(lcpLocptr, lcpLocRecord); + lcpLocptr.p->nextLcpLoc = RNIL; + cfirstfreeLcpLoc = 0; + } else { + jam(); + cfirstfreeLcpLoc = RNIL; + }//if +}//Dblqh::initialiseLcpLocrec() + +/* ========================================================================= */ +/* ====== INITIATE LOG FILE OPERATION RECORD ======= */ +/* */ +/* ========================================================================= */ +void Dblqh::initialiseLfo(Signal* signal) +{ + if (clfoFileSize != 0) { + for (lfoPtr.i = 0; lfoPtr.i < clfoFileSize; lfoPtr.i++) { + ptrAss(lfoPtr, logFileOperationRecord); + lfoPtr.p->lfoState = LogFileOperationRecord::IDLE; + lfoPtr.p->lfoTimer = 0; + lfoPtr.p->nextLfo = lfoPtr.i + 1; + }//for + lfoPtr.i = clfoFileSize - 1; + ptrAss(lfoPtr, logFileOperationRecord); + lfoPtr.p->nextLfo = RNIL; + cfirstfreeLfo = 0; + } else { + jam(); + cfirstfreeLfo = RNIL; + }//if +}//Dblqh::initialiseLfo() + +/* ========================================================================= */ +/* ====== INITIATE LOG FILE RECORD ======= */ +/* */ +/* ========================================================================= */ +void Dblqh::initialiseLogFile(Signal* signal) +{ + if (clogFileFileSize != 0) { + for (logFilePtr.i = 0; logFilePtr.i < clogFileFileSize; logFilePtr.i++) { + ptrAss(logFilePtr, logFileRecord); + logFilePtr.p->nextLogFile = logFilePtr.i + 1; + logFilePtr.p->logFileStatus = LogFileRecord::LFS_IDLE; + }//for + logFilePtr.i = clogFileFileSize - 1; + ptrAss(logFilePtr, logFileRecord); + logFilePtr.p->nextLogFile = RNIL; + cfirstfreeLogFile = 0; + } else { + jam(); + cfirstfreeLogFile = RNIL; + }//if +}//Dblqh::initialiseLogFile() + +/* ========================================================================= */ +/* ====== INITIATE LOG PAGES ======= */ +/* */ +/* ========================================================================= */ +void Dblqh::initialiseLogPage(Signal* signal) +{ + if (clogPageFileSize != 0) { + for (logPagePtr.i = 0; logPagePtr.i < clogPageFileSize; logPagePtr.i++) { + ptrAss(logPagePtr, logPageRecord); + logPagePtr.p->logPageWord[ZNEXT_PAGE] = logPagePtr.i + 1; + }//for + logPagePtr.i = clogPageFileSize - 1; + ptrAss(logPagePtr, logPageRecord); + logPagePtr.p->logPageWord[ZNEXT_PAGE] = RNIL; + cfirstfreeLogPage = 0; + } else { + jam(); + cfirstfreeLogPage = RNIL; + }//if + cnoOfLogPages = clogPageFileSize; +}//Dblqh::initialiseLogPage() + +/* ========================================================================= + * ====== INITIATE LOG PART RECORD ======= + * + * ========================================================================= */ +void Dblqh::initialiseLogPart(Signal* signal) +{ + for (logPartPtr.i = 0; logPartPtr.i <= 3; logPartPtr.i++) { + ptrAss(logPartPtr, logPartRecord); + logPartPtr.p->waitWriteGciLog = LogPartRecord::WWGL_FALSE; + logPartPtr.p->LogLqhKeyReqSent = ZFALSE; + logPartPtr.p->logPartNewestCompletedGCI = (UintR)-1; + }//for +}//Dblqh::initialiseLogPart() + +void Dblqh::initialisePageRef(Signal* signal) +{ + if (cpageRefFileSize != 0) { + for (pageRefPtr.i = 0; + pageRefPtr.i < cpageRefFileSize; + pageRefPtr.i++) { + ptrAss(pageRefPtr, pageRefRecord); + pageRefPtr.p->prNext = pageRefPtr.i + 1; + }//for + pageRefPtr.i = cpageRefFileSize - 1; + ptrAss(pageRefPtr, pageRefRecord); + pageRefPtr.p->prNext = RNIL; + cfirstfreePageRef = 0; + } else { + jam(); + cfirstfreePageRef = RNIL; + }//if +}//Dblqh::initialisePageRef() + +/* ========================================================================== + * ======= INITIATE RECORDS ======= + * + * TAKES CARE OF INITIATION OF ALL RECORDS IN THIS BLOCK. + * ========================================================================= */ +void Dblqh::initialiseRecordsLab(Signal* signal, Uint32 data) +{ + switch (data) { + case 0: + jam(); + for (Uint32 i = 0; i < MAX_NDB_NODES; i++) { + cnodeSrState[i] = ZSTART_SR; + cnodeExecSrState[i] = ZSTART_SR; + }//for + for (Uint32 i = 0; i < 1024; i++) { + ctransidHash[i] = RNIL; + }//for + for (Uint32 i = 0; i < 4; i++) { + cactiveCopy[i] = RNIL; + }//for + cnoActiveCopy = 0; + cCounterAccCommitBlocked = 0; + cCounterTupCommitBlocked = 0; + caccCommitBlocked = false; + ctupCommitBlocked = false; + cCommitBlocked = false; + ccurrentGcprec = RNIL; + caddNodeState = ZFALSE; + cstartRecReq = ZFALSE; + cnewestGci = (UintR)-1; + cnewestCompletedGci = (UintR)-1; + crestartOldestGci = 0; + crestartNewestGci = 0; + cfirstWaitFragSr = RNIL; + cfirstCompletedFragSr = RNIL; + csrPhaseStarted = ZSR_NO_PHASE_STARTED; + csrPhasesCompleted = 0; + cmasterDihBlockref = 0; + cnoFragmentsExecSr = 0; + clcpCompletedState = LCP_IDLE; + csrExecUndoLogState = EULS_IDLE; + c_lcpId = 0; + cnoOfFragsCheckpointed = 0; + sendInitialiseRecords(signal, data); + break; + case 1: + jam(); + initialiseAddfragrec(signal); + sendInitialiseRecords(signal, data); + break; + case 2: + jam(); + initialiseAttrbuf(signal); + sendInitialiseRecords(signal, data); + break; + case 3: + jam(); + initialiseDatabuf(signal); + sendInitialiseRecords(signal, data); + break; + case 4: + jam(); + initialiseFragrec(signal); + sendInitialiseRecords(signal,data); + break; + case 5: + jam(); + initialiseGcprec(signal); + initialiseLcpRec(signal); + initialiseLcpLocrec(signal); + sendInitialiseRecords(signal, data); + break; + case 6: + jam(); + initialiseLogPage(signal); + sendInitialiseRecords(signal, data); + break; + case 7: + jam(); + initialiseLfo(signal); + sendInitialiseRecords(signal, data); + break; + case 8: + jam(); + initialiseLogFile(signal); + initialiseLogPart(signal); + sendInitialiseRecords(signal, data); + break; + case 9: + jam(); + initialisePageRef(signal); + sendInitialiseRecords(signal, data); + break; + case 10: + jam(); + initialiseScanrec(signal); + sendInitialiseRecords(signal, data); + break; + case 11: + jam(); + initialiseTabrec(signal); + sendInitialiseRecords(signal, data); + break; + case 12: + jam(); + initialiseTcNodeFailRec(signal); + initialiseTcrec(signal); + returnInitialiseRecordsLab(signal); + return; + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dblqh::initialiseRecordsLab() + +/* -------------------------------------------------------------------------- + * SEND REAL-TIME BREAK SIGNAL DURING INITIALISATION IN SYSTEM RESTART. + * ------------------------------------------------------------------------- */ +void Dblqh::sendInitialiseRecords(Signal* signal, Uint32 data) +{ + signal->theData[0] = ZINITIALISE_RECORDS; + signal->theData[1] = data + 1; + signal->theData[2] = 0; + sendSignal(DBLQH_REF, GSN_CONTINUEB, signal, 3, JBB); +}//Dblqh::sendInitialiseRecords() + +/* ========================================================================== + * ======= INITIATE TC CONNECTION RECORD ======= + * + * ========================================================================= */ +void Dblqh::initialiseScanrec(Signal* signal) +{ + ndbrequire(cscanrecFileSize > 1); + for (scanptr.i = 0; scanptr.i < cscanrecFileSize; scanptr.i++) { + ptrAss(scanptr, scanRecord); + scanptr.p->nextScanrec = scanptr.i + 1; + scanptr.p->scanType = ScanRecord::ST_IDLE; + scanptr.p->scanState = ScanRecord::SCAN_FREE; + scanptr.p->scanTcWaiting = ZFALSE; + }//for + scanptr.i = cscanrecFileSize - 1; + ptrAss(scanptr, scanRecord); + scanptr.p->nextScanrec = RNIL; + cfirstfreeScanrec = 0; + cscanNoFreeRec = cscanrecFileSize; +}//Dblqh::initialiseScanrec() + +/* ========================================================================== + * ======= INITIATE TABLE RECORD ======= + * + * ========================================================================= */ +void Dblqh::initialiseTabrec(Signal* signal) +{ + if (ctabrecFileSize != 0) { + for (tabptr.i = 0; tabptr.i < ctabrecFileSize; tabptr.i++) { + ptrAss(tabptr, tablerec); + tabptr.p->tableStatus = Tablerec::NOT_DEFINED; + tabptr.p->usageCount = 0; + for (Uint32 i = 0; i <= (NO_OF_FRAG_PER_NODE - 1); i++) { + tabptr.p->fragid[i] = ZNIL; + tabptr.p->fragrec[i] = RNIL; + }//for + }//for + }//if +}//Dblqh::initialiseTabrec() + +/* ========================================================================== + * ======= INITIATE TC CONNECTION RECORD ======= + * + * ========================================================================= */ +void Dblqh::initialiseTcrec(Signal* signal) +{ + if (ctcConnectrecFileSize != 0) { + for (tcConnectptr.i = 0; + tcConnectptr.i < ctcConnectrecFileSize; + tcConnectptr.i++) { + ptrAss(tcConnectptr, tcConnectionrec); + tcConnectptr.p->transactionState = TcConnectionrec::TC_NOT_CONNECTED; + tcConnectptr.p->tcScanRec = RNIL; + tcConnectptr.p->logWriteState = TcConnectionrec::NOT_STARTED; + tcConnectptr.p->firstAttrinbuf = RNIL; + tcConnectptr.p->lastAttrinbuf = RNIL; + tcConnectptr.p->firstTupkeybuf = RNIL; + tcConnectptr.p->lastTupkeybuf = RNIL; + tcConnectptr.p->tcTimer = 0; + tcConnectptr.p->nextTcConnectrec = tcConnectptr.i + 1; + }//for + tcConnectptr.i = ctcConnectrecFileSize - 1; + ptrAss(tcConnectptr, tcConnectionrec); + tcConnectptr.p->nextTcConnectrec = RNIL; + cfirstfreeTcConrec = 0; + } else { + jam(); + cfirstfreeTcConrec = RNIL; + }//if +}//Dblqh::initialiseTcrec() + +/* ========================================================================== + * ======= INITIATE TC CONNECTION RECORD ======= + * + * ========================================================================= */ +void Dblqh::initialiseTcNodeFailRec(Signal* signal) +{ + if (ctcNodeFailrecFileSize != 0) { + for (tcNodeFailptr.i = 0; + tcNodeFailptr.i < ctcNodeFailrecFileSize; + tcNodeFailptr.i++) { + ptrAss(tcNodeFailptr, tcNodeFailRecord); + tcNodeFailptr.p->tcFailStatus = TcNodeFailRecord::TC_STATE_FALSE; + }//for + }//if +}//Dblqh::initialiseTcNodeFailRec() + +/* ========================================================================== + * ======= INITIATE FRAGMENT RECORD ======= + * + * SUBROUTINE SHORT NAME = IF + * ========================================================================= */ +void Dblqh::initFragrec(Signal* signal, + Uint32 tableId, + Uint32 fragId, + Uint32 copyType) +{ + fragptr.p->accBlockref = caccBlockref; + fragptr.p->accBlockedList = RNIL; + fragptr.p->activeList = RNIL; + fragptr.p->firstWaitQueue = RNIL; + fragptr.p->lastWaitQueue = RNIL; + fragptr.p->fragStatus = Fragrecord::DEFINED; + fragptr.p->fragCopy = copyType; + fragptr.p->tupBlockref = ctupBlockref; + fragptr.p->tuxBlockref = ctuxBlockref; + fragptr.p->lcpRef = RNIL; + fragptr.p->logFlag = Fragrecord::STATE_TRUE; + fragptr.p->lcpFlag = Fragrecord::LCP_STATE_TRUE; + for (Uint32 i = 0; i < MAX_LCP_STORED; i++) { + fragptr.p->lcpId[i] = 0; + }//for + for (Uint32 i = 0; i < NR_MaxRangeScanNo; i++) { + fragptr.p->fragScanRec[i] = ZNIL; + }//for + fragptr.p->maxGciCompletedInLcp = 0; + fragptr.p->maxGciInLcp = 0; + fragptr.p->noActiveScan = 0; + fragptr.p->copyFragState = ZIDLE; + fragptr.p->nextFrag = RNIL; + fragptr.p->newestGci = cnewestGci; + fragptr.p->nextLcp = 0; + fragptr.p->tabRef = tableId; + fragptr.p->fragId = fragId; + fragptr.p->srStatus = Fragrecord::SS_IDLE; + fragptr.p->execSrStatus = Fragrecord::IDLE; + fragptr.p->execSrNoReplicas = 0; + fragptr.p->fragDistributionKey = 0; + fragptr.p->activeTcCounter = 0; +}//Dblqh::initFragrec() + +/* ========================================================================== + * ======= INITIATE FRAGMENT RECORD FOR SYSTEM RESTART ======= + * + * SUBROUTINE SHORT NAME = IFS + * ========================================================================= */ +void Dblqh::initFragrecSr(Signal* signal) +{ + const StartFragReq * const startFragReq = (StartFragReq *)&signal->theData[0]; + Uint32 lcpNo = startFragReq->lcpNo; + Uint32 noOfLogNodes = startFragReq->noOfLogNodes; + ndbrequire(noOfLogNodes <= 4); + fragptr.p->fragStatus = Fragrecord::CRASH_RECOVERING; + fragptr.p->srBlockref = startFragReq->userRef; + fragptr.p->srUserptr = startFragReq->userPtr; + fragptr.p->srChkpnr = lcpNo; + if (lcpNo == (MAX_LCP_STORED - 1)) { + jam(); + fragptr.p->lcpId[lcpNo] = startFragReq->lcpId; + fragptr.p->nextLcp = 0; + } else if (lcpNo < (MAX_LCP_STORED - 1)) { + jam(); + fragptr.p->lcpId[lcpNo] = startFragReq->lcpId; + fragptr.p->nextLcp = lcpNo + 1; + } else { + ndbrequire(lcpNo == ZNIL); + jam(); + fragptr.p->nextLcp = 0; + }//if + fragptr.p->srNoLognodes = noOfLogNodes; + fragptr.p->logFlag = Fragrecord::STATE_FALSE; + fragptr.p->srStatus = Fragrecord::SS_IDLE; + if (noOfLogNodes > 0) { + jam(); + for (Uint32 i = 0; i < noOfLogNodes; i++) { + jam(); + fragptr.p->srStartGci[i] = startFragReq->startGci[i]; + fragptr.p->srLastGci[i] = startFragReq->lastGci[i]; + fragptr.p->srLqhLognode[i] = startFragReq->lqhLogNode[i]; + }//for + fragptr.p->newestGci = startFragReq->lastGci[noOfLogNodes - 1]; + } else { + fragptr.p->newestGci = cnewestGci; + }//if +}//Dblqh::initFragrecSr() + +/* ========================================================================== + * ======= INITIATE INFORMATION ABOUT GLOBAL CHECKPOINTS ======= + * IN LOG FILE RECORDS + * + * INPUT: LOG_FILE_PTR CURRENT LOG FILE + * TNO_FD_DESCRIPTORS THE NUMBER OF FILE DESCRIPTORS + * TO READ FROM THE LOG PAGE + * LOG_PAGE_PTR PAGE ZERO IN LOG FILE + * SUBROUTINE SHORT NAME = IGL + * ========================================================================= */ +void Dblqh::initGciInLogFileRec(Signal* signal, Uint32 noFdDescriptors) +{ + LogFileRecordPtr iglLogFilePtr; + UintR tiglLoop; + UintR tiglIndex; + + tiglLoop = 0; + iglLogFilePtr.i = logFilePtr.i; + iglLogFilePtr.p = logFilePtr.p; +IGL_LOOP: + for (tiglIndex = 0; tiglIndex <= ZNO_MBYTES_IN_FILE - 1; tiglIndex++) { + arrGuard(((ZPAGE_HEADER_SIZE + ZFD_HEADER_SIZE) + + (tiglLoop * ZFD_PART_SIZE)) + tiglIndex, ZPAGE_SIZE); + iglLogFilePtr.p->logMaxGciCompleted[tiglIndex] = + logPagePtr.p->logPageWord[((ZPAGE_HEADER_SIZE + ZFD_HEADER_SIZE) + + (tiglLoop * ZFD_PART_SIZE)) + tiglIndex]; + arrGuard((((ZPAGE_HEADER_SIZE + ZFD_HEADER_SIZE) + ZNO_MBYTES_IN_FILE) + + (tiglLoop * ZFD_PART_SIZE)) + tiglIndex, ZPAGE_SIZE); + iglLogFilePtr.p->logMaxGciStarted[tiglIndex] = + logPagePtr.p->logPageWord[(((ZPAGE_HEADER_SIZE + ZFD_HEADER_SIZE) + + ZNO_MBYTES_IN_FILE) + + (tiglLoop * ZFD_PART_SIZE)) + tiglIndex]; + arrGuard((((ZPAGE_HEADER_SIZE + ZFD_HEADER_SIZE) + + (2 * ZNO_MBYTES_IN_FILE)) + (tiglLoop * ZFD_PART_SIZE)) + + tiglIndex, ZPAGE_SIZE); + iglLogFilePtr.p->logLastPrepRef[tiglIndex] = + logPagePtr.p->logPageWord[(((ZPAGE_HEADER_SIZE + ZFD_HEADER_SIZE) + + (2 * ZNO_MBYTES_IN_FILE)) + + (tiglLoop * ZFD_PART_SIZE)) + tiglIndex]; + }//for + tiglLoop = tiglLoop + 1; + if (tiglLoop < noFdDescriptors) { + jam(); + iglLogFilePtr.i = iglLogFilePtr.p->prevLogFile; + ptrCheckGuard(iglLogFilePtr, clogFileFileSize, logFileRecord); + goto IGL_LOOP; + }//if +}//Dblqh::initGciInLogFileRec() + +/* ========================================================================== + * ======= INITIATE LCP RECORD WHEN USED FOR SYSTEM RESTART ======= + * + * SUBROUTINE SHORT NAME = ILS + * ========================================================================= */ +void Dblqh::initLcpSr(Signal* signal, + Uint32 lcpNo, + Uint32 lcpId, + Uint32 tableId, + Uint32 fragId, + Uint32 fragPtr) +{ + lcpPtr.p->lcpQueued = false; + lcpPtr.p->currentFragment.fragPtrI = fragPtr; + lcpPtr.p->currentFragment.lcpFragOrd.lcpNo = lcpNo; + lcpPtr.p->currentFragment.lcpFragOrd.lcpId = lcpId; + lcpPtr.p->currentFragment.lcpFragOrd.tableId = tableId; + lcpPtr.p->currentFragment.lcpFragOrd.fragmentId = fragId; + lcpPtr.p->lcpState = LcpRecord::LCP_SR_WAIT_FRAGID; + lcpPtr.p->firstLcpLocAcc = RNIL; + lcpPtr.p->firstLcpLocTup = RNIL; + lcpPtr.p->lcpAccptr = RNIL; +}//Dblqh::initLcpSr() + +/* ========================================================================== + * ======= INITIATE LOG PART ======= + * + * ========================================================================= */ +void Dblqh::initLogpart(Signal* signal) +{ + logPartPtr.p->execSrLogPage = RNIL; + logPartPtr.p->execSrLogPageIndex = ZNIL; + logPartPtr.p->execSrExecuteIndex = 0; + logPartPtr.p->noLogFiles = cnoLogFiles; + logPartPtr.p->logLap = 0; + logPartPtr.p->logTailFileNo = 0; + logPartPtr.p->logTailMbyte = 0; + logPartPtr.p->lastMbyte = ZNIL; + logPartPtr.p->logPartState = LogPartRecord::SR_FIRST_PHASE; + logPartPtr.p->logExecState = LogPartRecord::LES_IDLE; + logPartPtr.p->firstLogTcrec = RNIL; + logPartPtr.p->lastLogTcrec = RNIL; + logPartPtr.p->firstLogQueue = RNIL; + logPartPtr.p->lastLogQueue = RNIL; + logPartPtr.p->gcprec = RNIL; + logPartPtr.p->firstPageRef = RNIL; + logPartPtr.p->lastPageRef = RNIL; + logPartPtr.p->headFileNo = ZNIL; + logPartPtr.p->headPageNo = ZNIL; + logPartPtr.p->headPageIndex = ZNIL; +}//Dblqh::initLogpart() + +/* ========================================================================== + * ======= INITIATE LOG POINTERS ======= + * + * ========================================================================= */ +void Dblqh::initLogPointers(Signal* signal) +{ + logPartPtr.i = tcConnectptr.p->hashValue & 3; + ptrCheckGuard(logPartPtr, clogPartFileSize, logPartRecord); + logFilePtr.i = logPartPtr.p->currentLogfile; + ptrCheckGuard(logFilePtr, clogFileFileSize, logFileRecord); + logPagePtr.i = logFilePtr.p->currentLogpage; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); +}//Dblqh::initLogPointers() + +/* ------------------------------------------------------------------------- */ +/* ------- INIT REQUEST INFO BEFORE EXECUTING A LOG RECORD ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dblqh::initReqinfoExecSr(Signal* signal) +{ + UintR Treqinfo = 0; + TcConnectionrec * const regTcPtr = tcConnectptr.p; + LqhKeyReq::setKeyLen(Treqinfo, regTcPtr->primKeyLen); +/* ------------------------------------------------------------------------- */ +/* NUMBER OF BACKUPS AND STANDBYS ARE ZERO AND NEED NOT BE SET. */ +/* REPLICA TYPE IS CLEARED BY SEND_LQHKEYREQ. */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* SET LAST REPLICA NUMBER TO ZERO (BIT 10-11) */ +/* ------------------------------------------------------------------------- */ +/* ------------------------------------------------------------------------- */ +/* SET DIRTY FLAG */ +/* ------------------------------------------------------------------------- */ + LqhKeyReq::setDirtyFlag(Treqinfo, 1); +/* ------------------------------------------------------------------------- */ +/* SET SIMPLE TRANSACTION */ +/* ------------------------------------------------------------------------- */ + LqhKeyReq::setSimpleFlag(Treqinfo, 1); +/* ------------------------------------------------------------------------- */ +/* SET OPERATION TYPE AND LOCK MODE (NEVER READ OPERATION OR SCAN IN LOG) */ +/* ------------------------------------------------------------------------- */ + LqhKeyReq::setLockType(Treqinfo, regTcPtr->operation); + LqhKeyReq::setOperation(Treqinfo, regTcPtr->operation); + regTcPtr->reqinfo = Treqinfo; +/* ------------------------------------------------------------------------ */ +/* NO OF BACKUP IS SET TO ONE AND NUMBER OF STANDBY NODES IS SET TO ZERO. */ +/* THUS THE RECEIVING NODE WILL EXPECT THAT IT IS THE LAST NODE AND WILL */ +/* SEND COMPLETED AS THE RESPONSE SIGNAL SINCE DIRTY_OP BIT IS SET. */ +/* ------------------------------------------------------------------------ */ +/* ------------------------------------------------------------------------- */ +/* SET REPLICA TYPE TO PRIMARY AND NUMBER OF REPLICA TO ONE */ +/* ------------------------------------------------------------------------- */ + regTcPtr->lastReplicaNo = 0; + regTcPtr->apiVersionNo = 0; + regTcPtr->nextSeqNoReplica = 0; + regTcPtr->opExec = 0; + regTcPtr->storedProcId = ZNIL; + regTcPtr->readlenAi = 0; + regTcPtr->nodeAfterNext[0] = ZNIL; + regTcPtr->nodeAfterNext[1] = ZNIL; + regTcPtr->dirtyOp = ZFALSE; + regTcPtr->tcBlockref = cownref; +}//Dblqh::initReqinfoExecSr() + +/* -------------------------------------------------------------------------- + * ------- INSERT FRAGMENT ------- + * + * ------------------------------------------------------------------------- */ +bool Dblqh::insertFragrec(Signal* signal, Uint32 fragId) +{ + terrorCode = ZOK; + if (cfirstfreeFragrec == RNIL) { + jam(); + terrorCode = ZNO_FREE_FRAGMENTREC; + return false; + }//if + seizeFragmentrec(signal); + for (Uint32 i = (NO_OF_FRAG_PER_NODE - 1); (Uint32)~i; i--) { + jam(); + if (tabptr.p->fragid[i] == ZNIL) { + jam(); + tabptr.p->fragid[i] = fragId; + tabptr.p->fragrec[i] = fragptr.i; + return true; + }//if + }//for + terrorCode = ZTOO_MANY_FRAGMENTS; + return false; +}//Dblqh::insertFragrec() + +/* -------------------------------------------------------------------------- + * ------- LINK OPERATION IN ACTIVE LIST ON FRAGMENT ------- + * + * SUBROUTINE SHORT NAME: LFQ +// Input Pointers: +// tcConnectptr +// fragptr +* ------------------------------------------------------------------------- */ +void Dblqh::linkFragQueue(Signal* signal) +{ + TcConnectionrecPtr lfqTcConnectptr; + TcConnectionrec * const regTcPtr = tcConnectptr.p; + Fragrecord * const regFragPtr = fragptr.p; + Uint32 tcIndex = tcConnectptr.i; + + lfqTcConnectptr.i = regFragPtr->lastWaitQueue; + regTcPtr->nextTc = RNIL; + regFragPtr->lastWaitQueue = tcIndex; + regTcPtr->prevTc = lfqTcConnectptr.i; + ndbrequire(regTcPtr->listState == TcConnectionrec::NOT_IN_LIST); + regTcPtr->listState = TcConnectionrec::WAIT_QUEUE_LIST; + if (lfqTcConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(lfqTcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + lfqTcConnectptr.p->nextTc = tcIndex; + } else { + regFragPtr->firstWaitQueue = tcIndex; + }//if + return; +}//Dblqh::linkFragQueue() + +/* ------------------------------------------------------------------------- + * ------- LINK OPERATION INTO WAITING FOR LOGGING ------- + * + * SUBROUTINE SHORT NAME = LWL +// Input Pointers: +// tcConnectptr +// logPartPtr + * ------------------------------------------------------------------------- */ +void Dblqh::linkWaitLog(Signal* signal, LogPartRecordPtr regLogPartPtr) +{ + TcConnectionrecPtr lwlTcConnectptr; + +/* -------------------------------------------------- */ +/* LINK ACTIVE OPERATION INTO QUEUE WAITING FOR */ +/* ACCESS TO THE LOG PART. */ +/* -------------------------------------------------- */ + lwlTcConnectptr.i = regLogPartPtr.p->lastLogQueue; + if (lwlTcConnectptr.i == RNIL) { + jam(); + regLogPartPtr.p->firstLogQueue = tcConnectptr.i; + } else { + jam(); + ptrCheckGuard(lwlTcConnectptr, ctcConnectrecFileSize, tcConnectionrec); + lwlTcConnectptr.p->nextTcLogQueue = tcConnectptr.i; + }//if + regLogPartPtr.p->lastLogQueue = tcConnectptr.i; + tcConnectptr.p->nextTcLogQueue = RNIL; + if (regLogPartPtr.p->LogLqhKeyReqSent == ZFALSE) { + jam(); + regLogPartPtr.p->LogLqhKeyReqSent = ZTRUE; + signal->theData[0] = ZLOG_LQHKEYREQ; + signal->theData[1] = regLogPartPtr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + }//if +}//Dblqh::linkWaitLog() + +/* -------------------------------------------------------------------------- + * ------- START THE NEXT OPERATION ON THIS LOG PART IF ANY ------- + * ------- OPERATIONS ARE QUEUED. ------- + * + * SUBROUTINE SHORT NAME = LNS +// Input Pointers: +// tcConnectptr +// logPartPtr + * ------------------------------------------------------------------------- */ +void Dblqh::logNextStart(Signal* signal) +{ + LogPartRecordPtr lnsLogPartPtr; + UintR tlnsStillWaiting; + LogPartRecord * const regLogPartPtr = logPartPtr.p; + + if ((regLogPartPtr->firstLogQueue == RNIL) && + (regLogPartPtr->logPartState == LogPartRecord::ACTIVE) && + (regLogPartPtr->waitWriteGciLog != LogPartRecord::WWGL_TRUE)) { +// -------------------------------------------------------------------------- +// Optimised route for the common case +// -------------------------------------------------------------------------- + regLogPartPtr->logPartState = LogPartRecord::IDLE; + return; + }//if + if (regLogPartPtr->firstLogQueue != RNIL) { + jam(); + if (regLogPartPtr->LogLqhKeyReqSent == ZFALSE) { + jam(); + regLogPartPtr->LogLqhKeyReqSent = ZTRUE; + signal->theData[0] = ZLOG_LQHKEYREQ; + signal->theData[1] = logPartPtr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + }//if + } else { + if (regLogPartPtr->logPartState == LogPartRecord::ACTIVE) { + jam(); + regLogPartPtr->logPartState = LogPartRecord::IDLE; + } else { + jam(); + }//if + }//if + if (regLogPartPtr->waitWriteGciLog != LogPartRecord::WWGL_TRUE) { + jam(); + return; + } else { + jam(); +/* -------------------------------------------------------------------------- + * A COMPLETE GCI LOG RECORD IS WAITING TO BE WRITTEN. WE GIVE THIS HIGHEST + * PRIORITY AND WRITE IT IMMEDIATELY. AFTER WRITING IT WE CHECK IF ANY MORE + * LOG PARTS ARE WAITING. IF NOT WE SEND A SIGNAL THAT INITIALISES THE GCP + * RECORD TO WAIT UNTIL ALL COMPLETE GCI LOG RECORDS HAVE REACHED TO DISK. + * -------------------------------------------------------------------------- */ + writeCompletedGciLog(signal); + logPartPtr.p->waitWriteGciLog = LogPartRecord::WWGL_FALSE; + tlnsStillWaiting = ZFALSE; + for (lnsLogPartPtr.i = 0; lnsLogPartPtr.i < 4; lnsLogPartPtr.i++) { + jam(); + ptrAss(lnsLogPartPtr, logPartRecord); + if (lnsLogPartPtr.p->waitWriteGciLog == LogPartRecord::WWGL_TRUE) { + jam(); + tlnsStillWaiting = ZTRUE; + }//if + }//for + if (tlnsStillWaiting == ZFALSE) { + jam(); + signal->theData[0] = ZINIT_GCP_REC; + sendSignal(cownref, GSN_CONTINUEB, signal, 1, JBB); + }//if + }//if +}//Dblqh::logNextStart() + +/* -------------------------------------------------------------------------- + * ------- MOVE PAGES FROM LFO RECORD TO PAGE REFERENCE RECORD ------- + * WILL ALWAYS MOVE 8 PAGES TO A PAGE REFERENCE RECORD. + * + * SUBROUTINE SHORT NAME = MPR + * ------------------------------------------------------------------------- */ +void Dblqh::moveToPageRef(Signal* signal) +{ + LogPageRecordPtr mprLogPagePtr; + PageRefRecordPtr mprPageRefPtr; + UintR tmprIndex; + +/* -------------------------------------------------------------------------- + * ------- INSERT PAGE REFERENCE RECORD ------- + * + * INPUT: LFO_PTR LOG FILE OPERATION RECORD + * LOG_PART_PTR LOG PART RECORD + * PAGE_REF_PTR THE PAGE REFERENCE RECORD TO BE INSERTED. + * ------------------------------------------------------------------------- */ + PageRefRecordPtr iprPageRefPtr; + + if ((logPartPtr.p->mmBufferSize + 8) >= ZMAX_MM_BUFFER_SIZE) { + jam(); + pageRefPtr.i = logPartPtr.p->firstPageRef; + ptrCheckGuard(pageRefPtr, cpageRefFileSize, pageRefRecord); + releasePrPages(signal); + removePageRef(signal); + } else { + jam(); + logPartPtr.p->mmBufferSize = logPartPtr.p->mmBufferSize + 8; + }//if + seizePageRef(signal); + if (logPartPtr.p->firstPageRef == RNIL) { + jam(); + logPartPtr.p->firstPageRef = pageRefPtr.i; + } else { + jam(); + iprPageRefPtr.i = logPartPtr.p->lastPageRef; + ptrCheckGuard(iprPageRefPtr, cpageRefFileSize, pageRefRecord); + iprPageRefPtr.p->prNext = pageRefPtr.i; + }//if + pageRefPtr.p->prPrev = logPartPtr.p->lastPageRef; + logPartPtr.p->lastPageRef = pageRefPtr.i; + + pageRefPtr.p->prFileNo = logFilePtr.p->fileNo; + pageRefPtr.p->prPageNo = lfoPtr.p->lfoPageNo; + tmprIndex = 0; + mprLogPagePtr.i = lfoPtr.p->firstLfoPage; +MPR_LOOP: + arrGuard(tmprIndex, 8); + pageRefPtr.p->pageRef[tmprIndex] = mprLogPagePtr.i; + tmprIndex = tmprIndex + 1; + ptrCheckGuard(mprLogPagePtr, clogPageFileSize, logPageRecord); + mprLogPagePtr.i = mprLogPagePtr.p->logPageWord[ZNEXT_PAGE]; + if (mprLogPagePtr.i != RNIL) { + jam(); + goto MPR_LOOP; + }//if + mprPageRefPtr.i = pageRefPtr.p->prPrev; + if (mprPageRefPtr.i != RNIL) { + jam(); + ptrCheckGuard(mprPageRefPtr, cpageRefFileSize, pageRefRecord); + mprLogPagePtr.i = mprPageRefPtr.p->pageRef[7]; + ptrCheckGuard(mprLogPagePtr, clogPageFileSize, logPageRecord); + mprLogPagePtr.p->logPageWord[ZNEXT_PAGE] = pageRefPtr.p->pageRef[0]; + }//if +}//Dblqh::moveToPageRef() + +/* ------------------------------------------------------------------------- */ +/* ------- READ THE ATTRINFO FROM THE LOG ------- */ +/* */ +/* SUBROUTINE SHORT NAME = RA */ +/* ------------------------------------------------------------------------- */ +void Dblqh::readAttrinfo(Signal* signal) +{ + Uint32 remainingLen = tcConnectptr.p->totSendlenAi; + if (remainingLen == 0) { + jam(); + tcConnectptr.p->reclenAiLqhkey = 0; + return; + }//if + Uint32 dataLen = remainingLen; + if (remainingLen > 5) + dataLen = 5; + readLogData(signal, dataLen, &tcConnectptr.p->firstAttrinfo[0]); + tcConnectptr.p->reclenAiLqhkey = dataLen; + remainingLen -= dataLen; + while (remainingLen > 0) { + jam(); + dataLen = remainingLen; + if (remainingLen > 22) + dataLen = 22; + seizeAttrinbuf(signal); + readLogData(signal, dataLen, &attrinbufptr.p->attrbuf[0]); + attrinbufptr.p->attrbuf[ZINBUF_DATA_LEN] = dataLen; + remainingLen -= dataLen; + }//while +}//Dblqh::readAttrinfo() + +/* ------------------------------------------------------------------------- */ +/* ------- READ COMMIT LOG ------- */ +/* */ +/* SUBROUTINE SHORT NAME = RCL */ +/* ------------------------------------------------------------------------- */ +void Dblqh::readCommitLog(Signal* signal, CommitLogRecord* commitLogRecord) +{ + Uint32 trclPageIndex = logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]; + if ((trclPageIndex + (ZCOMMIT_LOG_SIZE - 1)) < ZPAGE_SIZE) { + jam(); + tcConnectptr.p->tableref = logPagePtr.p->logPageWord[trclPageIndex + 0]; + tcConnectptr.p->schemaVersion = logPagePtr.p->logPageWord[trclPageIndex + 1]; + tcConnectptr.p->fragmentid = logPagePtr.p->logPageWord[trclPageIndex + 2]; + commitLogRecord->fileNo = logPagePtr.p->logPageWord[trclPageIndex + 3]; + commitLogRecord->startPageNo = logPagePtr.p->logPageWord[trclPageIndex + 4]; + commitLogRecord->startPageIndex = logPagePtr.p->logPageWord[trclPageIndex + 5]; + commitLogRecord->stopPageNo = logPagePtr.p->logPageWord[trclPageIndex + 6]; + tcConnectptr.p->gci = logPagePtr.p->logPageWord[trclPageIndex + 7]; + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = + (trclPageIndex + ZCOMMIT_LOG_SIZE) - 1; + } else { + jam(); + tcConnectptr.p->tableref = readLogword(signal); + tcConnectptr.p->schemaVersion = readLogword(signal); + tcConnectptr.p->fragmentid = readLogword(signal); + commitLogRecord->fileNo = readLogword(signal); + commitLogRecord->startPageNo = readLogword(signal); + commitLogRecord->startPageIndex = readLogword(signal); + commitLogRecord->stopPageNo = readLogword(signal); + tcConnectptr.p->gci = readLogword(signal); + }//if + tcConnectptr.p->transid[0] = logPartPtr.i + 65536; + tcConnectptr.p->transid[1] = (DBLQH << 20) + (cownNodeid << 8); +}//Dblqh::readCommitLog() + +/* ------------------------------------------------------------------------- */ +/* ------- READ LOG PAGES FROM DISK IN ORDER TO EXECUTE A LOG ------- */ +/* RECORD WHICH WAS NOT FOUND IN MAIN MEMORY. */ +/* */ +/* SUBROUTINE SHORT NAME = REL */ +/* ------------------------------------------------------------------------- */ +void Dblqh::readExecLog(Signal* signal) +{ + UintR trelIndex; + UintR trelI; + + seizeLfo(signal); + initLfo(signal); + trelI = logPartPtr.p->execSrStopPageNo - logPartPtr.p->execSrStartPageNo; + arrGuard(trelI + 1, 16); + lfoPtr.p->logPageArray[trelI + 1] = logPartPtr.p->execSrStartPageNo; + for (trelIndex = logPartPtr.p->execSrStopPageNo; (trelIndex >= logPartPtr.p->execSrStartPageNo) && + (UintR)~trelIndex; trelIndex--) { + jam(); + seizeLogpage(signal); + arrGuard(trelI, 16); + lfoPtr.p->logPageArray[trelI] = logPagePtr.i; + trelI--; + }//for + lfoPtr.p->lfoPageNo = logPartPtr.p->execSrStartPageNo; + lfoPtr.p->noPagesRw = (logPartPtr.p->execSrStopPageNo - + logPartPtr.p->execSrStartPageNo) + 1; + lfoPtr.p->firstLfoPage = lfoPtr.p->logPageArray[0]; + signal->theData[0] = logFilePtr.p->fileRef; + signal->theData[1] = cownref; + signal->theData[2] = lfoPtr.i; + signal->theData[3] = ZLIST_OF_MEM_PAGES; // edtjamo TR509 //ZLIST_OF_PAIRS; + signal->theData[4] = ZVAR_NO_LOG_PAGE_WORD; + signal->theData[5] = lfoPtr.p->noPagesRw; + signal->theData[6] = lfoPtr.p->logPageArray[0]; + signal->theData[7] = lfoPtr.p->logPageArray[1]; + signal->theData[8] = lfoPtr.p->logPageArray[2]; + signal->theData[9] = lfoPtr.p->logPageArray[3]; + signal->theData[10] = lfoPtr.p->logPageArray[4]; + signal->theData[11] = lfoPtr.p->logPageArray[5]; + signal->theData[12] = lfoPtr.p->logPageArray[6]; + signal->theData[13] = lfoPtr.p->logPageArray[7]; + signal->theData[14] = lfoPtr.p->logPageArray[8]; + signal->theData[15] = lfoPtr.p->logPageArray[9]; + sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 16, JBA); +}//Dblqh::readExecLog() + +/* ------------------------------------------------------------------------- */ +/* ------- READ 64 KBYTES WHEN EXECUTING THE FRAGMENT LOG ------- */ +/* */ +/* SUBROUTINE SHORT NAME = RES */ +/* ------------------------------------------------------------------------- */ +void Dblqh::readExecSrNewMbyte(Signal* signal) +{ + logFilePtr.p->currentFilepage = logFilePtr.p->currentMbyte * ZPAGES_IN_MBYTE; + logFilePtr.p->filePosition = logFilePtr.p->currentMbyte * ZPAGES_IN_MBYTE; + logPartPtr.p->execSrPagesRead = 0; + logPartPtr.p->execSrPagesReading = 0; + logPartPtr.p->execSrPagesExecuted = 0; + readExecSr(signal); + logPartPtr.p->logExecState = LogPartRecord::LES_WAIT_READ_EXEC_SR_NEW_MBYTE; +}//Dblqh::readExecSrNewMbyte() + +/* ------------------------------------------------------------------------- */ +/* ------- READ 64 KBYTES WHEN EXECUTING THE FRAGMENT LOG ------- */ +/* */ +/* SUBROUTINE SHORT NAME = RES */ +/* ------------------------------------------------------------------------- */ +void Dblqh::readExecSr(Signal* signal) +{ + UintR tresPageid; + UintR tresIndex; + + tresPageid = logFilePtr.p->filePosition; + seizeLfo(signal); + initLfo(signal); + for (tresIndex = 7; (UintR)~tresIndex; tresIndex--) { + jam(); +/* ------------------------------------------------------------------------- */ +/* GO BACKWARDS SINCE WE INSERT AT THE BEGINNING AND WE WANT THAT FIRST PAGE */ +/* SHALL BE FIRST AND LAST PAGE LAST. */ +/* ------------------------------------------------------------------------- */ + seizeLogpage(signal); + lfoPtr.p->logPageArray[tresIndex] = logPagePtr.i; + }//for + lfoPtr.p->lfoState = LogFileOperationRecord::READ_EXEC_SR; + lfoPtr.p->lfoPageNo = tresPageid; + logFilePtr.p->filePosition = logFilePtr.p->filePosition + 8; + logPartPtr.p->execSrPagesReading = logPartPtr.p->execSrPagesReading + 8; + lfoPtr.p->noPagesRw = 8; + lfoPtr.p->firstLfoPage = lfoPtr.p->logPageArray[0]; + signal->theData[0] = logFilePtr.p->fileRef; + signal->theData[1] = cownref; + signal->theData[2] = lfoPtr.i; + signal->theData[3] = ZLIST_OF_MEM_PAGES; + signal->theData[4] = ZVAR_NO_LOG_PAGE_WORD; + signal->theData[5] = 8; + signal->theData[6] = lfoPtr.p->logPageArray[0]; + signal->theData[7] = lfoPtr.p->logPageArray[1]; + signal->theData[8] = lfoPtr.p->logPageArray[2]; + signal->theData[9] = lfoPtr.p->logPageArray[3]; + signal->theData[10] = lfoPtr.p->logPageArray[4]; + signal->theData[11] = lfoPtr.p->logPageArray[5]; + signal->theData[12] = lfoPtr.p->logPageArray[6]; + signal->theData[13] = lfoPtr.p->logPageArray[7]; + signal->theData[14] = tresPageid; + sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 15, JBA); +}//Dblqh::readExecSr() + +/* ------------------------------------------------------------------------- */ +/* ------------ READ THE PRIMARY KEY FROM THE LOG ---------------- */ +/* */ +/* SUBROUTINE SHORT NAME = RK */ +/* --------------------------------------------------------------------------*/ +void Dblqh::readKey(Signal* signal) +{ + Uint32 remainingLen = tcConnectptr.p->primKeyLen; + ndbrequire(remainingLen != 0); + Uint32 dataLen = remainingLen; + if (remainingLen > 4) + dataLen = 4; + readLogData(signal, dataLen, &tcConnectptr.p->tupkeyData[0]); + remainingLen -= dataLen; + while (remainingLen > 0) { + jam(); + seizeTupkeybuf(signal); + dataLen = remainingLen; + if (dataLen > 4) + dataLen = 4; + readLogData(signal, dataLen, &databufptr.p->data[0]); + remainingLen -= dataLen; + }//while +}//Dblqh::readKey() + +/* ------------------------------------------------------------------------- */ +/* ------------ READ A NUMBER OF WORDS FROM LOG INTO CDATA ---------------- */ +/* */ +/* SUBROUTINE SHORT NAME = RLD */ +/* --------------------------------------------------------------------------*/ +void Dblqh::readLogData(Signal* signal, Uint32 noOfWords, Uint32* dataPtr) +{ + ndbrequire(noOfWords < 32); + Uint32 logPos = logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]; + if ((logPos + noOfWords) >= ZPAGE_SIZE) { + for (Uint32 i = 0; i < noOfWords; i++) + dataPtr[i] = readLogwordExec(signal); + } else { + MEMCOPY_NO_WORDS(dataPtr, &logPagePtr.p->logPageWord[logPos], noOfWords); + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = logPos + noOfWords; + }//if +}//Dblqh::readLogData() + +/* ------------------------------------------------------------------------- */ +/* ------------ READ THE LOG HEADER OF A PREPARE LOG HEADER ---------------- */ +/* */ +/* SUBROUTINE SHORT NAME = RLH */ +/* --------------------------------------------------------------------------*/ +void Dblqh::readLogHeader(Signal* signal) +{ + Uint32 logPos = logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]; + if ((logPos + ZLOG_HEAD_SIZE) < ZPAGE_SIZE) { + jam(); + tcConnectptr.p->hashValue = logPagePtr.p->logPageWord[logPos + 2]; + tcConnectptr.p->operation = logPagePtr.p->logPageWord[logPos + 3]; + tcConnectptr.p->totSendlenAi = logPagePtr.p->logPageWord[logPos + 4]; + tcConnectptr.p->primKeyLen = logPagePtr.p->logPageWord[logPos + 5]; + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = logPos + ZLOG_HEAD_SIZE; + } else { + jam(); + readLogwordExec(signal); /* IGNORE PREPARE LOG RECORD TYPE */ + readLogwordExec(signal); /* IGNORE LOG RECORD SIZE */ + tcConnectptr.p->hashValue = readLogwordExec(signal); + tcConnectptr.p->operation = readLogwordExec(signal); + tcConnectptr.p->totSendlenAi = readLogwordExec(signal); + tcConnectptr.p->primKeyLen = readLogwordExec(signal); + }//if +}//Dblqh::readLogHeader() + +/* ------------------------------------------------------------------------- */ +/* ------- READ A WORD FROM THE LOG ------- */ +/* */ +/* OUTPUT: TLOG_WORD */ +/* SUBROUTINE SHORT NAME = RLW */ +/* ------------------------------------------------------------------------- */ +Uint32 Dblqh::readLogword(Signal* signal) +{ + Uint32 logPos = logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]; + ndbrequire(logPos < ZPAGE_SIZE); + Uint32 logWord = logPagePtr.p->logPageWord[logPos]; + logPos++; + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = logPos; + if (logPos >= ZPAGE_SIZE) { + jam(); + logPagePtr.i = logPagePtr.p->logPageWord[ZNEXT_PAGE]; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = ZPAGE_HEADER_SIZE; + logFilePtr.p->currentLogpage = logPagePtr.i; + logFilePtr.p->currentFilepage++; + logPartPtr.p->execSrPagesRead--; + logPartPtr.p->execSrPagesExecuted++; + }//if + return logWord; +}//Dblqh::readLogword() + +/* ------------------------------------------------------------------------- */ +/* ------- READ A WORD FROM THE LOG WHEN EXECUTING A LOG RECORD ------- */ +/* */ +/* OUTPUT: TLOG_WORD */ +/* SUBROUTINE SHORT NAME = RWE */ +/* ------------------------------------------------------------------------- */ +Uint32 Dblqh::readLogwordExec(Signal* signal) +{ + Uint32 logPos = logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]; + ndbrequire(logPos < ZPAGE_SIZE); + Uint32 logWord = logPagePtr.p->logPageWord[logPos]; + logPos++; + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = logPos; + if (logPos >= ZPAGE_SIZE) { + jam(); + logPagePtr.i = logPagePtr.p->logPageWord[ZNEXT_PAGE]; + if (logPagePtr.i != RNIL){ + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = ZPAGE_HEADER_SIZE; + } else { + // Reading word at the last pos in the last page + // Don't step forward to next page! + jam(); + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]++; + } + }//if + return logWord; +}//Dblqh::readLogwordExec() + +/* ------------------------------------------------------------------------- */ +/* ------- READ A SINGLE PAGE FROM THE LOG ------- */ +/* */ +/* INPUT: TRSP_PAGE_NO */ +/* SUBROUTINE SHORT NAME = RSP */ +/* ------------------------------------------------------------------------- */ +void Dblqh::readSinglePage(Signal* signal, Uint32 pageNo) +{ + seizeLfo(signal); + initLfo(signal); + seizeLogpage(signal); + lfoPtr.p->firstLfoPage = logPagePtr.i; + lfoPtr.p->lfoPageNo = pageNo; + lfoPtr.p->noPagesRw = 1; + signal->theData[0] = logFilePtr.p->fileRef; + signal->theData[1] = cownref; + signal->theData[2] = lfoPtr.i; + signal->theData[3] = ZLIST_OF_PAIRS; + signal->theData[4] = ZVAR_NO_LOG_PAGE_WORD; + signal->theData[5] = 1; + signal->theData[6] = logPagePtr.i; + signal->theData[7] = pageNo; + sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 8, JBA); +}//Dblqh::readSinglePage() + +/* -------------------------------------------------------------------------- + * ------- RELEASE OPERATION FROM ACTIVE LIST ON FRAGMENT ------- + * + * SUBROUTINE SHORT NAME = RAC + * ------------------------------------------------------------------------- */ +void Dblqh::releaseAccList(Signal* signal) +{ + TcConnectionrecPtr racTcNextConnectptr; + TcConnectionrecPtr racTcPrevConnectptr; + + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + racTcPrevConnectptr.i = tcConnectptr.p->prevTc; + racTcNextConnectptr.i = tcConnectptr.p->nextTc; + if (tcConnectptr.p->listState != TcConnectionrec::ACC_BLOCK_LIST) { + jam(); + systemError(signal); + }//if + tcConnectptr.p->listState = TcConnectionrec::NOT_IN_LIST; + if (racTcNextConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(racTcNextConnectptr, ctcConnectrecFileSize, tcConnectionrec); + racTcNextConnectptr.p->prevTc = racTcPrevConnectptr.i; + }//if + if (racTcPrevConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(racTcPrevConnectptr, ctcConnectrecFileSize, tcConnectionrec); + racTcPrevConnectptr.p->nextTc = tcConnectptr.p->nextTc; + } else { + jam(); + /* --------------------------------------------------------------------- + * OPERATION RECORD IS FIRST IN ACTIVE LIST + * THIS MEANS THAT THERE EXISTS NO PREVIOUS TC THAT NEEDS TO BE UPDATED. + * --------------------------------------------------------------------- */ + fragptr.p->accBlockedList = racTcNextConnectptr.i; + }//if +}//Dblqh::releaseAccList() + +/* -------------------------------------------------------------------------- + * ------- REMOVE COPY FRAGMENT FROM ACTIVE COPY LIST ------- + * + * ------------------------------------------------------------------------- */ +void Dblqh::releaseActiveCopy(Signal* signal) +{ + /* MUST BE 8 BIT */ + UintR tracFlag; + UintR tracIndex; + + tracFlag = ZFALSE; + for (tracIndex = 0; tracIndex < 4; tracIndex++) { + if (tracFlag == ZFALSE) { + jam(); + if (cactiveCopy[tracIndex] == fragptr.i) { + jam(); + tracFlag = ZTRUE; + }//if + } else { + if (tracIndex < 3) { + jam(); + cactiveCopy[tracIndex - 1] = cactiveCopy[tracIndex]; + } else { + jam(); + cactiveCopy[3] = RNIL; + }//if + }//if + }//for + ndbrequire(tracFlag == ZTRUE); + cnoActiveCopy--; +}//Dblqh::releaseActiveCopy() + +/* -------------------------------------------------------------------------- + * ------- RELEASE OPERATION FROM ACTIVE LIST ON FRAGMENT ------- + * + * SUBROUTINE SHORT NAME = RAL + * ------------------------------------------------------------------------- */ +void Dblqh::releaseActiveList(Signal* signal) +{ + TcConnectionrecPtr ralTcNextConnectptr; + TcConnectionrecPtr ralTcPrevConnectptr; + ralTcPrevConnectptr.i = tcConnectptr.p->prevTc; + ralTcNextConnectptr.i = tcConnectptr.p->nextTc; + ndbrequire(tcConnectptr.p->listState == TcConnectionrec::IN_ACTIVE_LIST); + tcConnectptr.p->listState = TcConnectionrec::NOT_IN_LIST; + if (ralTcNextConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(ralTcNextConnectptr, ctcConnectrecFileSize, tcConnectionrec); + ralTcNextConnectptr.p->prevTc = ralTcPrevConnectptr.i; + }//if + if (ralTcPrevConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(ralTcPrevConnectptr, ctcConnectrecFileSize, tcConnectionrec); + ralTcPrevConnectptr.p->nextTc = tcConnectptr.p->nextTc; + } else { + jam(); + /* ---------------------------------------------------------------------- + * OPERATION RECORD IS FIRST IN ACTIVE LIST + * THIS MEANS THAT THERE EXISTS NO PREVIOUS TC THAT NEEDS TO BE UPDATED. + * --------------------------------------------------------------------- */ + fragptr.p->activeList = ralTcNextConnectptr.i; + }//if +}//Dblqh::releaseActiveList() + +/* -------------------------------------------------------------------------- + * ------- RELEASE ADD FRAGMENT RECORD ------- + * + * ------------------------------------------------------------------------- */ +void Dblqh::releaseAddfragrec(Signal* signal) +{ + addfragptr.p->addfragStatus = AddFragRecord::FREE; + addfragptr.p->nextAddfragrec = cfirstfreeAddfragrec; + cfirstfreeAddfragrec = addfragptr.i; +}//Dblqh::releaseAddfragrec() + +/* -------------------------------------------------------------------------- + * ------- RELEASE FRAGMENT RECORD ------- + * + * ------------------------------------------------------------------------- */ +void Dblqh::releaseFragrec() +{ + fragptr.p->fragStatus = Fragrecord::FREE; + fragptr.p->nextFrag = cfirstfreeFragrec; + cfirstfreeFragrec = fragptr.i; +}//Dblqh::releaseFragrec() + +/* -------------------------------------------------------------------------- + * ------- RELEASE LCP LOCAL RECORD ------- + * + * ------------------------------------------------------------------------- */ +void Dblqh::releaseLcpLoc(Signal* signal) +{ + lcpLocptr.p->lcpLocstate = LcpLocRecord::IDLE; + lcpLocptr.p->nextLcpLoc = cfirstfreeLcpLoc; + cfirstfreeLcpLoc = lcpLocptr.i; +}//Dblqh::releaseLcpLoc() + +/* -------------------------------------------------------------------------- + * ------- RELEASE A PAGE REFERENCE RECORD. ------- + * + * ------------------------------------------------------------------------- */ +void Dblqh::releasePageRef(Signal* signal) +{ + pageRefPtr.p->prNext = cfirstfreePageRef; + cfirstfreePageRef = pageRefPtr.i; +}//Dblqh::releasePageRef() + +/* -------------------------------------------------------------------------- + * --- RELEASE ALL PAGES IN THE MM BUFFER AFTER EXECUTING THE LOG ON IT. ---- + * + * ------------------------------------------------------------------------- */ +void Dblqh::releaseMmPages(Signal* signal) +{ +RMP_LOOP: + jam(); + pageRefPtr.i = logPartPtr.p->firstPageRef; + if (pageRefPtr.i != RNIL) { + jam(); + ptrCheckGuard(pageRefPtr, cpageRefFileSize, pageRefRecord); + releasePrPages(signal); + removePageRef(signal); + goto RMP_LOOP; + }//if +}//Dblqh::releaseMmPages() + +/* -------------------------------------------------------------------------- + * ------- RELEASE A SET OF PAGES AFTER EXECUTING THE LOG ON IT. ------- + * + * ------------------------------------------------------------------------- */ +void Dblqh::releasePrPages(Signal* signal) +{ + UintR trppIndex; + + for (trppIndex = 0; trppIndex <= 7; trppIndex++) { + jam(); + logPagePtr.i = pageRefPtr.p->pageRef[trppIndex]; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + releaseLogpage(signal); + }//for +}//Dblqh::releasePrPages() + +/* -------------------------------------------------------------------------- + * ------- RELEASE OPERATION FROM WAIT QUEUE LIST ON FRAGMENT ------- + * + * SUBROUTINE SHORT NAME : RWA + * ------------------------------------------------------------------------- */ +void Dblqh::releaseWaitQueue(Signal* signal) +{ + TcConnectionrecPtr rwaTcNextConnectptr; + TcConnectionrecPtr rwaTcPrevConnectptr; + + fragptr.i = tcConnectptr.p->fragmentptr; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + rwaTcPrevConnectptr.i = tcConnectptr.p->prevTc; + rwaTcNextConnectptr.i = tcConnectptr.p->nextTc; + if (tcConnectptr.p->listState != TcConnectionrec::WAIT_QUEUE_LIST) { + jam(); + systemError(signal); + }//if + tcConnectptr.p->listState = TcConnectionrec::NOT_IN_LIST; + if (rwaTcNextConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(rwaTcNextConnectptr, ctcConnectrecFileSize, tcConnectionrec); + rwaTcNextConnectptr.p->prevTc = rwaTcPrevConnectptr.i; + } else { + jam(); + fragptr.p->lastWaitQueue = rwaTcPrevConnectptr.i; + }//if + if (rwaTcPrevConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(rwaTcPrevConnectptr, ctcConnectrecFileSize, tcConnectionrec); + rwaTcPrevConnectptr.p->nextTc = rwaTcNextConnectptr.i; + } else { + jam(); + fragptr.p->firstWaitQueue = rwaTcNextConnectptr.i; + }//if +}//Dblqh::releaseWaitQueue() + +/* -------------------------------------------------------------------------- + * ------- REMOVE OPERATION RECORD FROM LIST ON LOG PART OF NOT ------- + * COMPLETED OPERATIONS IN THE LOG. + * + * SUBROUTINE SHORT NAME = RLO + * ------------------------------------------------------------------------- */ +void Dblqh::removeLogTcrec(Signal* signal) +{ + TcConnectionrecPtr rloTcNextConnectptr; + TcConnectionrecPtr rloTcPrevConnectptr; + rloTcPrevConnectptr.i = tcConnectptr.p->prevLogTcrec; + rloTcNextConnectptr.i = tcConnectptr.p->nextLogTcrec; + if (rloTcNextConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(rloTcNextConnectptr, ctcConnectrecFileSize, tcConnectionrec); + rloTcNextConnectptr.p->prevLogTcrec = rloTcPrevConnectptr.i; + } else { + jam(); + logPartPtr.p->lastLogTcrec = rloTcPrevConnectptr.i; + }//if + if (rloTcPrevConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(rloTcPrevConnectptr, ctcConnectrecFileSize, tcConnectionrec); + rloTcPrevConnectptr.p->nextLogTcrec = rloTcNextConnectptr.i; + } else { + jam(); + logPartPtr.p->firstLogTcrec = rloTcNextConnectptr.i; + }//if +}//Dblqh::removeLogTcrec() + +/* -------------------------------------------------------------------------- + * ------- REMOVE PAGE REFERENCE RECORD FROM LIST IN THIS LOG PART ------- + * + * SUBROUTINE SHORT NAME = RPR + * ------------------------------------------------------------------------- */ +void Dblqh::removePageRef(Signal* signal) +{ + PageRefRecordPtr rprPageRefPtr; + + pageRefPtr.i = logPartPtr.p->firstPageRef; + if (pageRefPtr.i != RNIL) { + jam(); + ptrCheckGuard(pageRefPtr, cpageRefFileSize, pageRefRecord); + if (pageRefPtr.p->prNext == RNIL) { + jam(); + logPartPtr.p->lastPageRef = RNIL; + logPartPtr.p->firstPageRef = RNIL; + } else { + jam(); + logPartPtr.p->firstPageRef = pageRefPtr.p->prNext; + rprPageRefPtr.i = pageRefPtr.p->prNext; + ptrCheckGuard(rprPageRefPtr, cpageRefFileSize, pageRefRecord); + rprPageRefPtr.p->prPrev = RNIL; + }//if + releasePageRef(signal); + }//if +}//Dblqh::removePageRef() + +/* ------------------------------------------------------------------------- */ +/* ------- RETURN FROM EXECUTION OF LOG ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +Uint32 Dblqh::returnExecLog(Signal* signal) +{ + tcConnectptr.p->connectState = TcConnectionrec::CONNECTED; + initLogPointers(signal); + logPartPtr.p->execSrExecuteIndex++; + Uint32 result = checkIfExecLog(signal); + if (result == ZOK) { + jam(); +/* ------------------------------------------------------------------------- */ +/* THIS LOG RECORD WILL BE EXECUTED AGAIN TOWARDS ANOTHER NODE. */ +/* ------------------------------------------------------------------------- */ + logPagePtr.i = logPartPtr.p->execSrLogPage; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = + logPartPtr.p->execSrLogPageIndex; + } else { + jam(); +/* ------------------------------------------------------------------------- */ +/* NO MORE EXECUTION OF THIS LOG RECORD. */ +/* ------------------------------------------------------------------------- */ + if (logPartPtr.p->logExecState == + LogPartRecord::LES_EXEC_LOGREC_FROM_FILE) { + jam(); +/* ------------------------------------------------------------------------- */ +/* THE LOG RECORD WAS READ FROM DISK. RELEASE ITS PAGES IMMEDIATELY. */ +/* ------------------------------------------------------------------------- */ + lfoPtr.i = logPartPtr.p->execSrLfoRec; + ptrCheckGuard(lfoPtr, clfoFileSize, logFileOperationRecord); + releaseLfoPages(signal); + releaseLfo(signal); + logPartPtr.p->logExecState = LogPartRecord::LES_EXEC_LOG; + if (logPartPtr.p->execSrExecLogFile != logPartPtr.p->currentLogfile) { + jam(); + LogFileRecordPtr clfLogFilePtr; + clfLogFilePtr.i = logPartPtr.p->execSrExecLogFile; + ptrCheckGuard(clfLogFilePtr, clogFileFileSize, logFileRecord); + clfLogFilePtr.p->logFileStatus = LogFileRecord::CLOSING_EXEC_LOG; + closeFile(signal, clfLogFilePtr); + result = ZCLOSE_FILE; + }//if + }//if + logPartPtr.p->execSrExecuteIndex = 0; + logPartPtr.p->execSrLogPage = RNIL; + logPartPtr.p->execSrLogPageIndex = ZNIL; + logPagePtr.i = logFilePtr.p->currentLogpage; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = logPartPtr.p->savePageIndex; + }//if + return result; +}//Dblqh::returnExecLog() + +/* -------------------------------------------------------------------------- + * ------- SEIZE ADD FRAGMENT RECORD ------ + * + * ------------------------------------------------------------------------- */ +void Dblqh::seizeAddfragrec(Signal* signal) +{ + addfragptr.i = cfirstfreeAddfragrec; + ptrCheckGuard(addfragptr, caddfragrecFileSize, addFragRecord); + cfirstfreeAddfragrec = addfragptr.p->nextAddfragrec; +}//Dblqh::seizeAddfragrec() + +/* -------------------------------------------------------------------------- + * ------- SEIZE FRAGMENT RECORD ------- + * + * ------------------------------------------------------------------------- */ +void Dblqh::seizeFragmentrec(Signal* signal) +{ + fragptr.i = cfirstfreeFragrec; + ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord); + cfirstfreeFragrec = fragptr.p->nextFrag; + fragptr.p->nextFrag = RNIL; +}//Dblqh::seizeFragmentrec() + +/* ------------------------------------------------------------------------- */ +/* ------- SEIZE A PAGE REFERENCE RECORD. ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dblqh::seizePageRef(Signal* signal) +{ + pageRefPtr.i = cfirstfreePageRef; + ptrCheckGuard(pageRefPtr, cpageRefFileSize, pageRefRecord); + cfirstfreePageRef = pageRefPtr.p->prNext; + pageRefPtr.p->prNext = RNIL; +}//Dblqh::seizePageRef() + +/* -------------------------------------------------------------------------- + * ------- SEND ABORTED ------- + * + * ------------------------------------------------------------------------- */ +void Dblqh::sendAborted(Signal* signal) +{ + UintR TlastInd; + if (tcConnectptr.p->nextReplica == ZNIL) { + TlastInd = ZTRUE; + } else { + TlastInd = ZFALSE; + }//if + signal->theData[0] = tcConnectptr.p->tcOprec; + signal->theData[1] = tcConnectptr.p->transid[0]; + signal->theData[2] = tcConnectptr.p->transid[1]; + signal->theData[3] = cownNodeid; + signal->theData[4] = TlastInd; + sendSignal(tcConnectptr.p->tcBlockref, GSN_ABORTED, signal, 5, JBB); + return; +}//Dblqh::sendAborted() + +/* -------------------------------------------------------------------------- + * ------- SEND LQH_TRANSCONF ------- + * + * ------------------------------------------------------------------------- */ +void Dblqh::sendLqhTransconf(Signal* signal, LqhTransConf::OperationStatus stat) +{ + tcNodeFailptr.i = tcConnectptr.p->tcNodeFailrec; + ptrCheckGuard(tcNodeFailptr, ctcNodeFailrecFileSize, tcNodeFailRecord); + + Uint32 reqInfo = 0; + LqhTransConf::setReplicaType(reqInfo, tcConnectptr.p->replicaType); + LqhTransConf::setReplicaNo(reqInfo, tcConnectptr.p->seqNoReplica); + LqhTransConf::setLastReplicaNo(reqInfo, tcConnectptr.p->lastReplicaNo); + LqhTransConf::setSimpleFlag(reqInfo, tcConnectptr.p->opSimple); + LqhTransConf::setDirtyFlag(reqInfo, tcConnectptr.p->dirtyOp); + LqhTransConf::setOperation(reqInfo, tcConnectptr.p->operation); + + LqhTransConf * const lqhTransConf = (LqhTransConf *)&signal->theData[0]; + lqhTransConf->tcRef = tcNodeFailptr.p->newTcRef; + lqhTransConf->lqhNodeId = cownNodeid; + lqhTransConf->operationStatus = stat; + lqhTransConf->lqhConnectPtr = tcConnectptr.i; + lqhTransConf->transId1 = tcConnectptr.p->transid[0]; + lqhTransConf->transId2 = tcConnectptr.p->transid[1]; + lqhTransConf->oldTcOpRec = tcConnectptr.p->tcOprec; + lqhTransConf->requestInfo = reqInfo; + lqhTransConf->gci = tcConnectptr.p->gci; + lqhTransConf->nextNodeId1 = tcConnectptr.p->nextReplica; + lqhTransConf->nextNodeId2 = tcConnectptr.p->nodeAfterNext[0]; + lqhTransConf->nextNodeId3 = tcConnectptr.p->nodeAfterNext[1]; + lqhTransConf->apiRef = tcConnectptr.p->applRef; + lqhTransConf->apiOpRec = tcConnectptr.p->applOprec; + lqhTransConf->tableId = tcConnectptr.p->tableref; + sendSignal(tcNodeFailptr.p->newTcBlockref, GSN_LQH_TRANSCONF, + signal, LqhTransConf::SignalLength, JBB); + tcNodeFailptr.p->tcRecNow = tcConnectptr.i + 1; + signal->theData[0] = ZLQH_TRANS_NEXT; + signal->theData[1] = tcNodeFailptr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); +}//Dblqh::sendLqhTransconf() + +/* -------------------------------------------------------------------------- + * ------- START ANOTHER PHASE OF LOG EXECUTION ------- + * RESET THE VARIABLES NEEDED BY THIS PROCESS AND SEND THE START SIGNAL + * + * ------------------------------------------------------------------------- */ +void Dblqh::startExecSr(Signal* signal) +{ + cnoFragmentsExecSr = 0; + signal->theData[0] = cfirstCompletedFragSr; + signal->theData[1] = RNIL; + sendSignal(cownref, GSN_START_EXEC_SR, signal, 2, JBB); +}//Dblqh::startExecSr() + +/* ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ + * ¤¤¤¤¤¤¤ LOG MODULE ¤¤¤¤¤¤¤ + * ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ */ +/* -------------------------------------------------------------------------- + * ------- STEP FORWARD IN FRAGMENT LOG DURING LOG EXECUTION ------- + * + * ------------------------------------------------------------------------- */ +void Dblqh::stepAhead(Signal* signal, Uint32 stepAheadWords) +{ + UintR tsaPos; + + tsaPos = logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]; + while ((stepAheadWords + tsaPos) >= ZPAGE_SIZE) { + jam(); + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = ZPAGE_SIZE; + stepAheadWords = stepAheadWords - (ZPAGE_SIZE - tsaPos); + logFilePtr.p->currentLogpage = logPagePtr.p->logPageWord[ZNEXT_PAGE]; + logPagePtr.i = logPagePtr.p->logPageWord[ZNEXT_PAGE]; + logFilePtr.p->currentFilepage++; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = ZPAGE_HEADER_SIZE; + logPartPtr.p->execSrPagesRead--; + logPartPtr.p->execSrPagesExecuted++; + tsaPos = ZPAGE_HEADER_SIZE; + }//while + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = stepAheadWords + tsaPos; +}//Dblqh::stepAhead() + +/* -------------------------------------------------------------------------- + * ------- WRITE A ABORT LOG RECORD ------- + * + * SUBROUTINE SHORT NAME: WAL + * ------------------------------------------------------------------------- */ +void Dblqh::writeAbortLog(Signal* signal) +{ + if ((ZABORT_LOG_SIZE + ZNEXT_LOG_SIZE) > + logFilePtr.p->remainingWordsInMbyte) { + jam(); + changeMbyte(signal); + }//if + logFilePtr.p->remainingWordsInMbyte = + logFilePtr.p->remainingWordsInMbyte - ZABORT_LOG_SIZE; + writeLogWord(signal, ZABORT_TYPE); + writeLogWord(signal, tcConnectptr.p->transid[0]); + writeLogWord(signal, tcConnectptr.p->transid[1]); +}//Dblqh::writeAbortLog() + +/* -------------------------------------------------------------------------- + * ------- WRITE A COMMIT LOG RECORD ------- + * + * SUBROUTINE SHORT NAME: WCL + * ------------------------------------------------------------------------- */ +void Dblqh::writeCommitLog(Signal* signal, LogPartRecordPtr regLogPartPtr) +{ + LogFileRecordPtr regLogFilePtr; + LogPageRecordPtr regLogPagePtr; + TcConnectionrec * const regTcPtr = tcConnectptr.p; + regLogFilePtr.i = regLogPartPtr.p->currentLogfile; + ptrCheckGuard(regLogFilePtr, clogFileFileSize, logFileRecord); + regLogPagePtr.i = regLogFilePtr.p->currentLogpage; + Uint32 twclTmp = regLogFilePtr.p->remainingWordsInMbyte; + ptrCheckGuard(regLogPagePtr, clogPageFileSize, logPageRecord); + logPartPtr = regLogPartPtr; + logFilePtr = regLogFilePtr; + logPagePtr = regLogPagePtr; + if ((ZCOMMIT_LOG_SIZE + ZNEXT_LOG_SIZE) > twclTmp) { + jam(); + changeMbyte(signal); + twclTmp = logFilePtr.p->remainingWordsInMbyte; + }//if + + Uint32 twclLogPos = logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]; + Uint32 tableId = regTcPtr->tableref; + Uint32 schemaVersion = regTcPtr->schemaVersion; + Uint32 fragId = regTcPtr->fragmentid; + Uint32 fileNo = regTcPtr->logStartFileNo; + Uint32 startPageNo = regTcPtr->logStartPageNo; + Uint32 pageIndex = regTcPtr->logStartPageIndex; + Uint32 stopPageNo = regTcPtr->logStopPageNo; + Uint32 gci = regTcPtr->gci; + logFilePtr.p->remainingWordsInMbyte = twclTmp - ZCOMMIT_LOG_SIZE; + + if ((twclLogPos + ZCOMMIT_LOG_SIZE) >= ZPAGE_SIZE) { + writeLogWord(signal, ZCOMMIT_TYPE); + writeLogWord(signal, tableId); + writeLogWord(signal, schemaVersion); + writeLogWord(signal, fragId); + writeLogWord(signal, fileNo); + writeLogWord(signal, startPageNo); + writeLogWord(signal, pageIndex); + writeLogWord(signal, stopPageNo); + writeLogWord(signal, gci); + } else { + Uint32* dataPtr = &logPagePtr.p->logPageWord[twclLogPos]; + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = twclLogPos + ZCOMMIT_LOG_SIZE; + dataPtr[0] = ZCOMMIT_TYPE; + dataPtr[1] = tableId; + dataPtr[2] = schemaVersion; + dataPtr[3] = fragId; + dataPtr[4] = fileNo; + dataPtr[5] = startPageNo; + dataPtr[6] = pageIndex; + dataPtr[7] = stopPageNo; + dataPtr[8] = gci; + }//if + TcConnectionrecPtr rloTcNextConnectptr; + TcConnectionrecPtr rloTcPrevConnectptr; + rloTcPrevConnectptr.i = regTcPtr->prevLogTcrec; + rloTcNextConnectptr.i = regTcPtr->nextLogTcrec; + if (rloTcNextConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(rloTcNextConnectptr, ctcConnectrecFileSize, tcConnectionrec); + rloTcNextConnectptr.p->prevLogTcrec = rloTcPrevConnectptr.i; + } else { + regLogPartPtr.p->lastLogTcrec = rloTcPrevConnectptr.i; + }//if + if (rloTcPrevConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(rloTcPrevConnectptr, ctcConnectrecFileSize, tcConnectionrec); + rloTcPrevConnectptr.p->nextLogTcrec = rloTcNextConnectptr.i; + } else { + regLogPartPtr.p->firstLogTcrec = rloTcNextConnectptr.i; + }//if +}//Dblqh::writeCommitLog() + +/* -------------------------------------------------------------------------- + * ------- WRITE A COMPLETED GCI LOG RECORD ------- + * + * SUBROUTINE SHORT NAME: WCG +// Input Pointers: +// logFilePtr +// logPartPtr + * ------------------------------------------------------------------------- */ +void Dblqh::writeCompletedGciLog(Signal* signal) +{ + if ((ZCOMPLETED_GCI_LOG_SIZE + ZNEXT_LOG_SIZE) > + logFilePtr.p->remainingWordsInMbyte) { + jam(); + changeMbyte(signal); + }//if + logFilePtr.p->remainingWordsInMbyte = + logFilePtr.p->remainingWordsInMbyte - ZCOMPLETED_GCI_LOG_SIZE; + writeLogWord(signal, ZCOMPLETED_GCI_TYPE); + writeLogWord(signal, cnewestCompletedGci); + logPartPtr.p->logPartNewestCompletedGCI = cnewestCompletedGci; +}//Dblqh::writeCompletedGciLog() + +/* -------------------------------------------------------------------------- + * ------- WRITE A DIRTY PAGE DURING LOG EXECUTION ------- + * + * SUBROUTINE SHORT NAME: WD + * ------------------------------------------------------------------------- */ +void Dblqh::writeDirty(Signal* signal) +{ + logPagePtr.p->logPageWord[ZPOS_DIRTY] = ZNOT_DIRTY; + + // Calculate checksum for page + logPagePtr.p->logPageWord[ZPOS_CHECKSUM] = calcPageCheckSum(logPagePtr); + + seizeLfo(signal); + initLfo(signal); + lfoPtr.p->lfoPageNo = logPartPtr.p->prevFilepage; + lfoPtr.p->noPagesRw = 1; + lfoPtr.p->lfoState = LogFileOperationRecord::WRITE_DIRTY; + lfoPtr.p->firstLfoPage = logPagePtr.i; + signal->theData[0] = logFilePtr.p->fileRef; + signal->theData[1] = cownref; + signal->theData[2] = lfoPtr.i; + signal->theData[3] = ZLIST_OF_PAIRS_SYNCH; + signal->theData[4] = ZVAR_NO_LOG_PAGE_WORD; + signal->theData[5] = 1; + signal->theData[6] = logPagePtr.i; + signal->theData[7] = logPartPtr.p->prevFilepage; + sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal, 8, JBA); +}//Dblqh::writeDirty() + +/* -------------------------------------------------------------------------- + * ------- WRITE A WORD INTO THE LOG, CHECK FOR NEW PAGE ------- + * + * SUBROUTINE SHORT NAME: WLW + * ------------------------------------------------------------------------- */ +void Dblqh::writeLogWord(Signal* signal, Uint32 data) +{ + Uint32 logPos = logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]; + ndbrequire(logPos < ZPAGE_SIZE); + logPagePtr.p->logPageWord[logPos] = data; + logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] = logPos + 1; + if ((logPos + 1) == ZPAGE_SIZE) { + jam(); + completedLogPage(signal, ZNORMAL); + seizeLogpage(signal); + initLogpage(signal); + logFilePtr.p->currentLogpage = logPagePtr.i; + logFilePtr.p->currentFilepage++; + }//if +}//Dblqh::writeLogWord() + +/* -------------------------------------------------------------------------- + * ------- WRITE A NEXT LOG RECORD AND CHANGE TO NEXT MBYTE ------- + * + * SUBROUTINE SHORT NAME: WNL +// Input Pointers: +// logFilePtr(Redefines) +// logPagePtr (Redefines) +// logPartPtr + * ------------------------------------------------------------------------- */ +void Dblqh::writeNextLog(Signal* signal) +{ + LogFileRecordPtr wnlNextLogFilePtr; + UintR twnlNextFileNo; + UintR twnlNewMbyte; + UintR twnlRemWords; + UintR twnlNextMbyte; + +/* -------------------------------------------------- */ +/* CALCULATE THE NEW NUMBER OF REMAINING WORDS */ +/* AS 128*2036 WHERE 128 * 8 KBYTE = 1 MBYTE */ +/* AND 2036 IS THE NUMBER OF WORDS IN A PAGE */ +/* THAT IS USED FOR LOG INFORMATION. */ +/* -------------------------------------------------- */ + twnlRemWords = ZPAGE_SIZE - ZPAGE_HEADER_SIZE; + twnlRemWords = twnlRemWords * ZPAGES_IN_MBYTE; + wnlNextLogFilePtr.i = logFilePtr.p->nextLogFile; + ptrCheckGuard(wnlNextLogFilePtr, clogFileFileSize, logFileRecord); +/* -------------------------------------------------- */ +/* WRITE THE NEXT LOG RECORD. */ +/* -------------------------------------------------- */ + ndbrequire(logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX] < ZPAGE_SIZE); + logPagePtr.p->logPageWord[logPagePtr.p->logPageWord[ZCURR_PAGE_INDEX]] = + ZNEXT_MBYTE_TYPE; + if (logFilePtr.p->currentMbyte == (ZNO_MBYTES_IN_FILE - 1)) { + jam(); +/* -------------------------------------------------- */ +/* CALCULATE THE NEW REMAINING WORDS WHEN */ +/* CHANGING LOG FILE IS PERFORMED */ +/* -------------------------------------------------- */ + twnlRemWords = twnlRemWords - (ZPAGE_SIZE - ZPAGE_HEADER_SIZE); +/* -------------------------------------------------- */ +/* ENSURE THAT THE LOG PAGES ARE WRITTEN AFTER */ +/* WE HAVE CHANGED MBYTE. */ +/* -------------------------------------------------- */ +/* ENSURE LAST PAGE IN PREVIOUS MBYTE IS */ +/* WRITTEN AND THAT THE STATE OF THE WRITE IS */ +/* PROPERLY SET. */ +/* -------------------------------------------------- */ +/* WE HAVE TO CHANGE LOG FILE */ +/* -------------------------------------------------- */ + completedLogPage(signal, ZLAST_WRITE_IN_FILE); + if (wnlNextLogFilePtr.p->fileNo == 0) { + jam(); +/* -------------------------------------------------- */ +/* WE HAVE FINALISED A LOG LAP, START FROM LOG */ +/* FILE 0 AGAIN */ +/* -------------------------------------------------- */ + logPartPtr.p->logLap++; + }//if + logPartPtr.p->currentLogfile = wnlNextLogFilePtr.i; + logFilePtr.i = wnlNextLogFilePtr.i; + logFilePtr.p = wnlNextLogFilePtr.p; + twnlNewMbyte = 0; + } else { + jam(); +/* -------------------------------------------------- */ +/* INCREMENT THE CURRENT MBYTE */ +/* SET PAGE INDEX TO PAGE HEADER SIZE */ +/* -------------------------------------------------- */ + completedLogPage(signal, ZENFORCE_WRITE); + twnlNewMbyte = logFilePtr.p->currentMbyte + 1; + }//if +/* -------------------------------------------------- */ +/* CHANGE TO NEW LOG FILE IF NECESSARY */ +/* UPDATE THE FILE POSITION TO THE NEW MBYTE */ +/* FOUND IN PAGE PART OF TNEXT_LOG_PTR */ +/* ALLOCATE AND INITIATE A NEW PAGE SINCE WE */ +/* HAVE SENT THE PREVIOUS PAGE TO DISK. */ +/* SET THE NEW NUMBER OF REMAINING WORDS IN THE */ +/* NEW MBYTE ALLOCATED. */ +/* -------------------------------------------------- */ + logFilePtr.p->currentMbyte = twnlNewMbyte; + logFilePtr.p->filePosition = twnlNewMbyte * ZPAGES_IN_MBYTE; + logFilePtr.p->currentFilepage = twnlNewMbyte * ZPAGES_IN_MBYTE; + logFilePtr.p->remainingWordsInMbyte = twnlRemWords; + seizeLogpage(signal); + if (logFilePtr.p->currentMbyte == 0) { + jam(); + logFilePtr.p->lastPageWritten = 0; + if (logFilePtr.p->fileNo == 0) { + jam(); + releaseLogpage(signal); + logPagePtr.i = logFilePtr.p->logPageZero; + ptrCheckGuard(logPagePtr, clogPageFileSize, logPageRecord); + }//if + }//if + initLogpage(signal); + logFilePtr.p->currentLogpage = logPagePtr.i; + if (logFilePtr.p->currentMbyte == 0) { + jam(); +/* -------------------------------------------------- */ +/* THIS IS A NEW FILE, WRITE THE FILE DESCRIPTOR*/ +/* ALSO OPEN THE NEXT LOG FILE TO ENSURE THAT */ +/* THIS FILE IS OPEN WHEN ITS TURN COMES. */ +/* -------------------------------------------------- */ + writeFileHeaderOpen(signal, ZNORMAL); + openNextLogfile(signal); + logFilePtr.p->fileChangeState = LogFileRecord::BOTH_WRITES_ONGOING; + }//if + if (logFilePtr.p->fileNo == logPartPtr.p->logTailFileNo) { + if (logFilePtr.p->currentMbyte == logPartPtr.p->logTailMbyte) { + jam(); +/* -------------------------------------------------- */ +/* THE HEAD AND TAIL HAS MET. THIS SHOULD NEVER */ +/* OCCUR. CAN HAPPEN IF THE LOCAL CHECKPOINTS */ +/* TAKE FAR TOO LONG TIME. SO TIMING PROBLEMS */ +/* CAN INVOKE THIS SYSTEM CRASH. HOWEVER ONLY */ +/* VERY SERIOUS TIMING PROBLEMS. */ +/* -------------------------------------------------- */ + systemError(signal); + }//if + }//if + if (logFilePtr.p->currentMbyte == (ZNO_MBYTES_IN_FILE - 1)) { + jam(); + twnlNextMbyte = 0; + if (logFilePtr.p->fileChangeState != LogFileRecord::NOT_ONGOING) { + jam(); + logPartPtr.p->logPartState = LogPartRecord::FILE_CHANGE_PROBLEM; + }//if + twnlNextFileNo = wnlNextLogFilePtr.p->fileNo; + } else { + jam(); + twnlNextMbyte = logFilePtr.p->currentMbyte + 1; + twnlNextFileNo = logFilePtr.p->fileNo; + }//if + if (twnlNextFileNo == logPartPtr.p->logTailFileNo) { + if (logPartPtr.p->logTailMbyte == twnlNextMbyte) { + jam(); +/* -------------------------------------------------- */ +/* THE NEXT MBYTE WILL BE THE TAIL. WE MUST */ +/* STOP LOGGING NEW OPERATIONS. THIS OPERATION */ +/* ALLOWED TO PASS. ALSO COMMIT, NEXT, COMPLETED*/ +/* GCI, ABORT AND FRAGMENT SPLIT IS ALLOWED. */ +/* OPERATIONS ARE ALLOWED AGAIN WHEN THE TAIL */ +/* IS MOVED FORWARD AS A RESULT OF A START_LCP */ +/* _ROUND SIGNAL ARRIVING FROM DBDIH. */ +/* -------------------------------------------------- */ + logPartPtr.p->logPartState = LogPartRecord::TAIL_PROBLEM; + }//if + }//if +}//Dblqh::writeNextLog() + +void +Dblqh::execDUMP_STATE_ORD(Signal* signal) +{ + DumpStateOrd * const dumpState = (DumpStateOrd *)&signal->theData[0]; + if(dumpState->args[0] == DumpStateOrd::CommitAckMarkersSize){ + infoEvent("LQH: m_commitAckMarkerPool: %d free size: %d", + m_commitAckMarkerPool.getNoOfFree(), + m_commitAckMarkerPool.getSize()); + } + if(dumpState->args[0] == DumpStateOrd::CommitAckMarkersDump){ + infoEvent("LQH: m_commitAckMarkerPool: %d free size: %d", + m_commitAckMarkerPool.getNoOfFree(), + m_commitAckMarkerPool.getSize()); + + CommitAckMarkerIterator iter; + for(m_commitAckMarkerHash.first(iter); iter.curr.i != RNIL; + m_commitAckMarkerHash.next(iter)){ + infoEvent("CommitAckMarker: i = %d (0x%x, 0x%x)" + " ApiRef: 0x%x apiOprec: 0x%x TcNodeId: %d", + iter.curr.i, + iter.curr.p->transid1, + iter.curr.p->transid2, + iter.curr.p->apiRef, + iter.curr.p->apiOprec, + iter.curr.p->tcNodeId); + } + } + + // Dump info about number of log pages + if(dumpState->args[0] == DumpStateOrd::LqhDumpNoLogPages){ + infoEvent("LQH: Log pages : %d Free: %d", + clogPageFileSize, + cnoOfLogPages); + } + + // Dump all defined tables that LQH knowns about + if(dumpState->args[0] == DumpStateOrd::LqhDumpAllDefinedTabs){ + for(Uint32 i = 0; itableStatus != Tablerec::NOT_DEFINED){ + infoEvent("Table %d Status: %d Usage: %d", + i, tabPtr.p->tableStatus, tabPtr.p->usageCount); + } + } + return; + } + + // Dump all ScanRecords + if (dumpState->args[0] == DumpStateOrd::LqhDumpAllScanRec){ + Uint32 recordNo = 0; + if (signal->length() == 1) + infoEvent("LQH: Dump all ScanRecords - size: %d", + cscanrecFileSize); + else if (signal->length() == 2) + recordNo = dumpState->args[1]; + else + return; + + dumpState->args[0] = DumpStateOrd::LqhDumpOneScanRec; + dumpState->args[1] = recordNo; + execDUMP_STATE_ORD(signal); + + if (recordNo < cscanrecFileSize-1){ + dumpState->args[0] = DumpStateOrd::LqhDumpAllScanRec; + dumpState->args[1] = recordNo+1; + sendSignal(reference(), GSN_DUMP_STATE_ORD, signal, 2, JBB); + } + return; + } + + // Dump all active ScanRecords + if (dumpState->args[0] == DumpStateOrd::LqhDumpAllActiveScanRec){ + Uint32 recordNo = 0; + if (signal->length() == 1) + infoEvent("LQH: Dump active ScanRecord - size: %d", + cscanrecFileSize); + else if (signal->length() == 2) + recordNo = dumpState->args[1]; + else + return; + + ScanRecordPtr sp; + sp.i = recordNo; + ptrAss(sp, scanRecord); + if (sp.p->scanState != ScanRecord::SCAN_FREE){ + dumpState->args[0] = DumpStateOrd::LqhDumpOneScanRec; + dumpState->args[1] = recordNo; + execDUMP_STATE_ORD(signal); + } + + if (recordNo < cscanrecFileSize-1){ + dumpState->args[0] = DumpStateOrd::LqhDumpAllActiveScanRec; + dumpState->args[1] = recordNo+1; + sendSignal(reference(), GSN_DUMP_STATE_ORD, signal, 2, JBB); + } + return; + } + + if(dumpState->args[0] == DumpStateOrd::LqhDumpOneScanRec){ + Uint32 recordNo = RNIL; + if (signal->length() == 2) + recordNo = dumpState->args[1]; + else + return; + + if (recordNo >= cscanrecFileSize) + return; + + ScanRecordPtr sp; + sp.i = recordNo; + ptrAss(sp, scanRecord); + infoEvent("Dblqh::ScanRecord[%d]: state=%d, type=%d, " + "complStatus=%d, scanNodeId=%d", + sp.i, + sp.p->scanState, + sp.p->scanType, + sp.p->scanCompletedStatus, + sp.p->scanNodeId); + infoEvent(" apiBref=0x%x, scanAccPtr=%d", + sp.p->scanApiBlockref, + sp.p->scanAccPtr); + infoEvent(" copyptr=%d, ailen=%d, complOps=%d, concurrOps=%d", + sp.p->copyPtr, + sp.p->scanAiLength, + sp.p->scanCompletedOperations, + sp.p->scanConcurrentOperations); + infoEvent(" errCnt=%d, localFid=%d, schV=%d, searcCondFalseC=%d", + sp.p->scanErrorCounter, + sp.p->scanLocalFragid, + sp.p->scanSchemaVersion, + sp.p->scanSearchCondFalseCount); + infoEvent(" stpid=%d, flag=%d, lhold=%d, lmode=%d, num=%d", + sp.p->scanStoredProcId, + sp.p->scanFlag, + sp.p->scanLockHold, + sp.p->scanLockMode, + sp.p->scanNumber); + infoEvent(" relCount=%d, TCwait=%d, TCRec=%d, KIflag=%d", + sp.p->scanReleaseCounter, + sp.p->scanTcWaiting, + sp.p->scanTcrec, + sp.p->scanKeyinfoFlag); + infoEvent(" next=%d", + sp.p->nextScanrec); + return; + } + if(dumpState->args[0] == DumpStateOrd::LqhDumpLcpState){ + + infoEvent("== LQH LCP STATE =="); + infoEvent(" clcpCompletedState=%d, c_lcpId=%d, cnoOfFragsCheckpointed=%d", + clcpCompletedState, + c_lcpId, + cnoOfFragsCheckpointed); + + LcpRecordPtr TlcpPtr; + // Print information about the current local checkpoint + TlcpPtr.i = 0; + ptrAss(TlcpPtr, lcpRecord); + infoEvent(" lcpState=%d firstLcpLocTup=%d firstLcpLocAcc=%d", + TlcpPtr.p->lcpState, + TlcpPtr.p->firstLcpLocTup, + TlcpPtr.p->firstLcpLocAcc); + infoEvent(" lcpAccptr=%d lastFragmentFlag=%d", + TlcpPtr.p->lcpAccptr, + TlcpPtr.p->lastFragmentFlag); + infoEvent("currentFragment.fragPtrI=%d", + TlcpPtr.p->currentFragment.fragPtrI); + infoEvent("currentFragment.lcpFragOrd.tableId=%d", + TlcpPtr.p->currentFragment.lcpFragOrd.tableId); + infoEvent(" lcpQueued=%d reportEmpty=%d", + TlcpPtr.p->lcpQueued, + TlcpPtr.p->reportEmpty); + char buf[TlcpPtr.p->m_EMPTY_LCP_REQ.TextLength+1]; + infoEvent(" m_EMPTY_LCP_REQ=%d", + TlcpPtr.p->m_EMPTY_LCP_REQ.getText(buf)); + + return; + } + + + +}//Dblqh::execDUMP_STATE_ORD() + +void Dblqh::execSET_VAR_REQ(Signal* signal) +{ + + SetVarReq* const setVarReq = (SetVarReq*)&signal->theData[0]; + ConfigParamId var = setVarReq->variable(); + + switch (var) { + + case NoOfConcurrentCheckpointsAfterRestart: + sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB); + break; + + case NoOfConcurrentCheckpointsDuringRestart: + // Valid only during start so value not set. + sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB); + break; + + default: + sendSignal(CMVMI_REF, GSN_SET_VAR_REF, signal, 1, JBB); + } // switch + +}//execSET_VAR_REQ() + + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* ---------------------- TRIGGER HANDLING ------------------------ */ +/* ---------------------------------------------------------------- */ +/* */ +/* All trigger signals from TRIX are forwarded top TUP */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ + +// Trigger signals +void +Dblqh::execCREATE_TRIG_REQ(Signal* signal) +{ + jamEntry(); + NodeId myNodeId = getOwnNodeId(); + BlockReference tupref = calcTupBlockRef(myNodeId); + + sendSignal(tupref, GSN_CREATE_TRIG_REQ, signal, CreateTrigReq::SignalLength, JBB); +} + +void +Dblqh::execCREATE_TRIG_CONF(Signal* signal) +{ + jamEntry(); + NodeId myNodeId = getOwnNodeId(); + BlockReference dictref = calcDictBlockRef(myNodeId); + + sendSignal(dictref, GSN_CREATE_TRIG_CONF, signal, CreateTrigConf::SignalLength, JBB); +} + +void +Dblqh::execCREATE_TRIG_REF(Signal* signal) +{ + jamEntry(); + NodeId myNodeId = getOwnNodeId(); + BlockReference dictref = calcDictBlockRef(myNodeId); + + sendSignal(dictref, GSN_CREATE_TRIG_REF, signal, CreateTrigRef::SignalLength, JBB); +} + +void +Dblqh::execDROP_TRIG_REQ(Signal* signal) +{ + jamEntry(); + NodeId myNodeId = getOwnNodeId(); + BlockReference tupref = calcTupBlockRef(myNodeId); + + sendSignal(tupref, GSN_DROP_TRIG_REQ, signal, DropTrigReq::SignalLength, JBB); +} + +void +Dblqh::execDROP_TRIG_CONF(Signal* signal) +{ + jamEntry(); + NodeId myNodeId = getOwnNodeId(); + BlockReference dictref = calcDictBlockRef(myNodeId); + + sendSignal(dictref, GSN_DROP_TRIG_CONF, signal, DropTrigConf::SignalLength, JBB); +} + +void +Dblqh::execDROP_TRIG_REF(Signal* signal) +{ + jamEntry(); + NodeId myNodeId = getOwnNodeId(); + BlockReference dictref = calcDictBlockRef(myNodeId); + + sendSignal(dictref, GSN_DROP_TRIG_REF, signal, DropTrigRef::SignalLength, JBB); +} + +Uint32 Dblqh::calcPageCheckSum(LogPageRecordPtr logP){ + Uint32 checkSum = 37; +#ifdef VM_TRACE + for (Uint32 i = (ZPOS_CHECKSUM+1); ilogPageWord[i] ^ checkSum; +#endif + return checkSum; + } + diff --git a/ndb/src/kernel/blocks/dblqh/Makefile b/ndb/src/kernel/blocks/dblqh/Makefile new file mode 100644 index 00000000000..520486d8058 --- /dev/null +++ b/ndb/src/kernel/blocks/dblqh/Makefile @@ -0,0 +1,12 @@ +include .defs.mk + +TYPE := kernel + +ARCHIVE_TARGET := dblqh +DIRS := redoLogReader + +SOURCES = \ + DblqhInit.cpp \ + DblqhMain.cpp + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/kernel/blocks/dblqh/redoLogReader/Makefile b/ndb/src/kernel/blocks/dblqh/redoLogReader/Makefile new file mode 100644 index 00000000000..a89b648de77 --- /dev/null +++ b/ndb/src/kernel/blocks/dblqh/redoLogReader/Makefile @@ -0,0 +1,9 @@ +include .defs.mk + +BIN_TARGET := redoLogFileReader + +SOURCES := records.cpp redoLogFileReader.cpp + +TYPE := util + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/kernel/blocks/dblqh/redoLogReader/records.cpp b/ndb/src/kernel/blocks/dblqh/redoLogReader/records.cpp new file mode 100644 index 00000000000..092b7840c20 --- /dev/null +++ b/ndb/src/kernel/blocks/dblqh/redoLogReader/records.cpp @@ -0,0 +1,312 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "records.hpp" + +void printOut(const char *string, Uint32 value) { + ndbout_c("%-30s%-12u%-12x", string, value, value); +} + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +bool AbortTransactionRecord::check() { + // Not implemented yet. + return true; +} + +Uint32 AbortTransactionRecord::getLogRecordSize() { + return ABORTTRANSACTIONRECORDSIZE; +} + +NdbOut& operator<<(NdbOut& no, const AbortTransactionRecord& atr) { + no << "----------ABORT TRANSACTION RECORD-------------" << endl << endl; + printOut("Record type:", atr.m_recordType); + printOut("TransactionId1:", atr.m_transactionId1); + printOut("TransactionId2:", atr.m_transactionId2); + no << endl; + return no; +} + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +bool NextMbyteRecord::check() { + // Not implemented yet. + return true; +} + +Uint32 NextMbyteRecord::getLogRecordSize() { + return NEXTMBYTERECORDSIZE; +} + +NdbOut& operator<<(NdbOut& no, const NextMbyteRecord& nmr) { + no << "----------NEXT MBYTE RECORD--------------------" << endl << endl; + printOut("Record type:", nmr.m_recordType); + no << endl; + return no; +} + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +bool CommitTransactionRecord::check() { + // Not implemented yet. + return true; +} + +Uint32 CommitTransactionRecord::getLogRecordSize() { + return COMMITTRANSACTIONRECORDSIZE; +} + +NdbOut& operator<<(NdbOut& no, const CommitTransactionRecord& ctr) { + no << "----------COMMIT TRANSACTION RECORD------------" << endl << endl; + printOut("Record type:", ctr.m_recordType); + printOut("TableId", ctr.m_tableId); + printOut("FfragmentId", ctr.m_fragmentId); + printOut("File no. of Prep. Op.", ctr.m_fileNumberOfPrepareOperation); + printOut("Start page no. of Prep. Op.", ctr.m_startPageNumberOfPrepareOperation); + printOut("Start page index of Prep. Op.", ctr.m_startPageIndexOfPrepareOperation); + printOut("Stop page no. of Prep. Op.", ctr.m_stopPageNumberOfPrepareOperation); + printOut("GlobalCheckpoint", ctr.m_globalCheckpoint); + + no << endl; + return no; +} + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +bool InvalidCommitTransactionRecord::check() { + // Not implemented yet. + return true; +} + +Uint32 InvalidCommitTransactionRecord::getLogRecordSize() { + return COMMITTRANSACTIONRECORDSIZE; +} + +NdbOut& operator<<(NdbOut& no, const InvalidCommitTransactionRecord& ictr) { + no << "------INVALID COMMIT TRANSACTION RECORD--------" << endl << endl; + printOut("Record type:", ictr.m_recordType); + printOut("TableId", ictr.m_tableId); + printOut("FfragmentId", ictr.m_fragmentId); + printOut("File no. of Prep. Op.", ictr.m_fileNumberOfPrepareOperation); + printOut("Start page no. of Prep. Op.", ictr.m_startPageNumberOfPrepareOperation); + printOut("Start page index of Prep. Op.", ictr.m_startPageIndexOfPrepareOperation); + printOut("Stop page no. of Prep. Op.", ictr.m_stopPageNumberOfPrepareOperation); + printOut("GlobalCheckpoint", ictr.m_globalCheckpoint); + + no << endl; + return no; +} + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +bool PrepareOperationRecord::check() { + // Not fully implemented. + if (m_operationType == 3 && m_attributeLength != 0) + return false; + + if (m_logRecordSize != (m_attributeLength + m_keyLength + 7)) + return false; + + return true; +} + +Uint32 PrepareOperationRecord::getLogRecordSize() { + return m_logRecordSize; +} + +NdbOut& operator<<(NdbOut& no, const PrepareOperationRecord& por) { + no << "-----------PREPARE OPERATION RECORD------------" << endl << endl; + printOut("Record type:", por.m_recordType); + printOut("logRecordSize:", por.m_logRecordSize); + printOut("hashValue:", por.m_hashValue); + printOut("schemaVersion:", por.m_schemaVersion); + switch (por.m_operationType) { + case 0: + ndbout_c("%-30s%-12u%-6s", "operationType:", + por.m_operationType, "read"); + break; + case 1: + ndbout_c("%-30s%-12u%-6s", "operationType:", + por.m_operationType, "update"); + break; + case 2: + ndbout_c("%-30s%-12u%-6s", "operationType:", + por.m_operationType, "insert"); + break; + case 3: + ndbout_c("%-30s%-12u%-6s", "operationType:", + por.m_operationType, "delete"); + break; + default: + printOut("operationType:", por.m_operationType); + } + printOut("attributeLength:", por.m_attributeLength); + printOut("keyLength:", por.m_keyLength); + +#if 1 + // Print keydata + Uint32* p = (Uint32*)&por.m_keyInfo; + for(Uint32 i=0; i < por.m_keyLength; i++){ + printOut("keydata:", *p); + p++; + } + + // Print attrdata + for(Uint32 i=0; i < por.m_attributeLength; i++){ + printOut("attrdata:", *p); + p++; + } +#endif + + no << endl; + return no; +} + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +bool CompletedGCIRecord::check() { + // Not implemented yet. + return true; +} + +Uint32 CompletedGCIRecord::getLogRecordSize() { + return COMPLETEDGCIRECORDSIZE; +} + +NdbOut& operator<<(NdbOut& no, const CompletedGCIRecord& cGCIr) { + no << "-----------COMPLETED GCI RECORD----------------" << endl << endl; + printOut("Record type:", cGCIr.m_recordType); + printOut("Completed GCI:", cGCIr.m_theCompletedGCI); + no << endl; + return no; +} + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +bool NextLogRecord::check() { + // Not implemented yet. + return true; +} + +Uint32 NextLogRecord::getLogRecordSize(Uint32 pageIndex) { + return PAGESIZE - pageIndex; +} + +NdbOut& operator<<(NdbOut& no, const NextLogRecord& nl) { + no << "-----------NEXT LOG RECORD --------------------" << endl << endl; + printOut("Record type:", nl.m_recordType); + no << endl; + return no; +} + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +Uint32 PageHeader::getLogRecordSize() { + return PAGEHEADERSIZE; +} + +bool PageHeader::check() { + // Not implemented yet. + return true; +} + +NdbOut& operator<<(NdbOut& no, const PageHeader& ph) { + no << "------------PAGE HEADER------------------------" << endl << endl; + ndbout_c("%-30s%-12s%-12s\n", "", "Decimal", "Hex"); + printOut("Checksum:", ph.m_checksum); + printOut("Laps since initial start:", ph.m_lap); + printOut("Max gci completed:", ph.m_max_gci_completed); + printOut("Max gci started:", ph.m_max_gci_started); + printOut("Ptr to next page:", ph.m_next_page); + printOut("Ptr to previous page:", ph.m_previous_page); + printOut("Ndb version:", ph.m_ndb_version); + printOut("Number of log files:", ph.m_number_of_logfiles); + printOut("Current page index:", ph.m_current_page_index); + printOut("Oldest prepare op. file No.:", ph.m_old_prepare_file_number); + printOut("Oldest prepare op. page ref.:", ph.m_old_prepare_page_reference); + printOut("Dirty flag:", ph.m_dirty_flag); + no << endl; + return no; +} + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +Uint32 FileDescriptor::getLogRecordSize() { + return FILEDESCRIPTORHEADERSIZE + + m_fdHeader.m_noOfDescriptors * FILEDESCRIPTORRECORDSIZE; +} + +NdbOut& operator<<(NdbOut& no, const FileDescriptor& fd) { + no << "-------FILE DESCRIPTOR HEADER------------------" << endl << endl; + printOut("Record type:", fd.m_fdHeader.m_recordType); + printOut("Number of file descriptors:", fd.m_fdHeader.m_noOfDescriptors); + printOut("File number:", fd.m_fdHeader.m_fileNo); + ndbout << endl; + for(Uint32 i = 0; i < fd.m_fdHeader.m_noOfDescriptors; i++) { + fd.printARecord(i); + } + return no; +} + +void FileDescriptor::printARecord( Uint32 recordIndex ) const { + ndbout << "------------------FILE DESCRIPTOR " << recordIndex + <<" ---------------------" << endl << endl; + ndbout_c("%-30s%-12s%-12s\n", "", "Decimal", "Hex"); + + for(int i = 1; i <= NO_MBYTE_IN_FILE; i++) { + ndbout_c("%s%2d%s%-12u%-12x", "Max GCI completed, mbyte ", i, ": ", + m_fdRecord[recordIndex].m_maxGciCompleted[i-1], + m_fdRecord[recordIndex].m_maxGciCompleted[i-1]); + } + for(int i = 1; i <= NO_MBYTE_IN_FILE; i++) { + ndbout_c("%s%2d%s%-12u%-12x", "Max GCI started, mbyte ", i, ": ", + m_fdRecord[recordIndex].m_maxGciStarted[i-1], + m_fdRecord[recordIndex].m_maxGciStarted[i-1]); + } + for(int i = 1; i <= NO_MBYTE_IN_FILE; i++) { + ndbout_c("%s%2d%s%-12u%-12x", "Last prepared ref, mbyte ", i, ": ", + m_fdRecord[recordIndex].m_lastPreparedReference[i-1], + m_fdRecord[recordIndex].m_lastPreparedReference[i-1]); + } + ndbout << endl; +} + +bool FileDescriptor::check() { + // Not implemented yet. + return true; +} + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- diff --git a/ndb/src/kernel/blocks/dblqh/redoLogReader/records.hpp b/ndb/src/kernel/blocks/dblqh/redoLogReader/records.hpp new file mode 100644 index 00000000000..e73986e4d73 --- /dev/null +++ b/ndb/src/kernel/blocks/dblqh/redoLogReader/records.hpp @@ -0,0 +1,235 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include + +#define ZNEW_PREP_OP_TYPE 0 +#define ZPREP_OP_TYPE 1 +#define ZCOMMIT_TYPE 2 +#define ZABORT_TYPE 3 +#define ZFD_TYPE 4 +#define ZFRAG_SPLIT_TYPE 5 +#define ZNEXT_LOG_RECORD_TYPE 6 +#define ZNEXT_MBYTE_TYPE 7 +#define ZCOMPLETED_GCI_TYPE 8 +#define ZINVALID_COMMIT_TYPE 9 + +#define MAX_FILE_DESCRIPTORS 40 +#define NO_MBYTE_IN_FILE 16 + +#define PAGESIZE 8192 +#define NO_PAGES_IN_MBYTE 32 +#define NO_MBYTE_IN_FILE 16 + +#define COMMITTRANSACTIONRECORDSIZE 8 +#define COMPLETEDGCIRECORDSIZE 2 +#define PAGEHEADERSIZE 32 +#define FILEDESCRIPTORHEADERSIZE 3 +#define FILEDESCRIPTORRECORDSIZE 48 +#define NEXTMBYTERECORDSIZE 1 +#define ABORTTRANSACTIONRECORDSIZE 3 + + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +class AbortTransactionRecord { + friend NdbOut& operator<<(NdbOut&, const AbortTransactionRecord&); +public: + bool check(); + Uint32 getLogRecordSize(); +protected: + Uint32 m_recordType; + Uint32 m_transactionId1; + Uint32 m_transactionId2; +}; + + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +class NextMbyteRecord { + friend NdbOut& operator<<(NdbOut&, const NextMbyteRecord&); +public: + bool check(); + Uint32 getLogRecordSize(); +protected: + Uint32 m_recordType; +}; + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + + +class PrepareOperationRecord { + friend NdbOut& operator<<(NdbOut&, const PrepareOperationRecord&); +public: + bool check(); + Uint32 getLogRecordSize(); + +protected: + Uint32 m_recordType; + Uint32 m_logRecordSize; + Uint32 m_hashValue; + Uint32 m_schemaVersion; + Uint32 m_operationType; // 0 READ, 1 UPDATE, 2 INSERT, 3 DELETE + Uint32 m_attributeLength; + Uint32 m_keyLength; + Uint32 *m_keyInfo; // In this order + Uint32 *m_attrInfo;// In this order +}; + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +class CompletedGCIRecord { + friend NdbOut& operator<<(NdbOut&, const CompletedGCIRecord&); +public: + bool check(); + Uint32 getLogRecordSize(); +protected: + Uint32 m_recordType; + Uint32 m_theCompletedGCI; +}; + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +class NextLogRecord { + friend NdbOut& operator<<(NdbOut&, const NextLogRecord&); +public: + bool check(); + Uint32 getLogRecordSize(Uint32); +protected: + Uint32 m_recordType; +}; + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +class PageHeader { + friend NdbOut& operator<<(NdbOut&, const PageHeader&); +public: + bool check(); + Uint32 getLogRecordSize(); +protected: + Uint32 m_checksum; + Uint32 m_lap; + Uint32 m_max_gci_completed; + Uint32 m_max_gci_started; + Uint32 m_next_page; + Uint32 m_previous_page; + Uint32 m_ndb_version; + Uint32 m_number_of_logfiles; + Uint32 m_current_page_index; + Uint32 m_old_prepare_file_number; + Uint32 m_old_prepare_page_reference; + Uint32 m_dirty_flag; +}; + +//---------------------------------------------------------------- +// File descriptor. +//---------------------------------------------------------------- + +class FileDescriptorHeader { +public: + Uint32 m_recordType; + Uint32 m_noOfDescriptors; + Uint32 m_fileNo; +}; + +class FileDescriptorRecord { +public: + Uint32 m_maxGciCompleted[16]; + Uint32 m_maxGciStarted[16]; + Uint32 m_lastPreparedReference[16]; +}; + +class FileDescriptor { + friend NdbOut& operator<<(NdbOut&, const FileDescriptor&); +public: + bool check(); + Uint32 getLogRecordSize(); +protected: + void printARecord( Uint32 ) const; + FileDescriptorHeader m_fdHeader; + FileDescriptorRecord m_fdRecord[1]; +}; + + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +class CommitTransactionRecord { + friend NdbOut& operator<<(NdbOut&, const CommitTransactionRecord&); +public: + bool check(); + Uint32 getLogRecordSize(); +protected: + Uint32 m_recordType; + Uint32 m_tableId; + Uint32 m_fragmentId; + Uint32 m_fileNumberOfPrepareOperation; + Uint32 m_startPageNumberOfPrepareOperation; + Uint32 m_startPageIndexOfPrepareOperation; + Uint32 m_stopPageNumberOfPrepareOperation; + Uint32 m_globalCheckpoint; +}; + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +class InvalidCommitTransactionRecord { + friend NdbOut& operator<<(NdbOut&, const InvalidCommitTransactionRecord&); +public: + bool check(); + Uint32 getLogRecordSize(); +protected: + Uint32 m_recordType; + Uint32 m_tableId; + Uint32 m_fragmentId; + Uint32 m_fileNumberOfPrepareOperation; + Uint32 m_startPageNumberOfPrepareOperation; + Uint32 m_startPageIndexOfPrepareOperation; + Uint32 m_stopPageNumberOfPrepareOperation; + Uint32 m_globalCheckpoint; +}; + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +struct NextLogRec { + +}; + +struct NewPrepareOperation { + +}; + +struct FragmentSplit { + +}; diff --git a/ndb/src/kernel/blocks/dblqh/redoLogReader/redoLogFileReader.cpp b/ndb/src/kernel/blocks/dblqh/redoLogReader/redoLogFileReader.cpp new file mode 100644 index 00000000000..d2d166fa03e --- /dev/null +++ b/ndb/src/kernel/blocks/dblqh/redoLogReader/redoLogFileReader.cpp @@ -0,0 +1,465 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +//---------------------------------------------------------------- +// REDOLOGFILEREADER +// Reads a redo log file and checks it for errors and/or prints +// the file in a human readable format. +// +// Usage: redoLogFileReader [-noprint] [-nocheck] +// [-mbyte <0-15>] [-mbyteHeaders] [-pageHeaders] +// +//---------------------------------------------------------------- + + +#include "records.hpp" +#include +#include +#include +#include +#define RETURN_ERROR 1 +#define RETURN_OK 0 + +#define FROM_BEGINNING 0 + +void usage(const char * prg); +Uint32 readRecordOverPageBoundary (Uint32 *, Uint32 , Uint32 , Uint32); +Uint32 readFromFile(FILE * f, Uint32 *toPtr, Uint32 sizeInWords); +void readArguments(int argc, const char** argv); +void doExit(); + +FILE * f; +char fileName[256]; +bool thePrintFlag = true; +bool theCheckFlag = true; +bool onlyPageHeaders = false; +bool onlyMbyteHeaders = false; +bool onlyFileDesc = false; +bool firstLap = true; +Uint32 startAtMbyte = 0; +Uint32 startAtPage = 0; +Uint32 startAtPageIndex = 0; +Uint32 *redoLogPage; + +NDB_COMMAND(redoLogFileReader, "redoLogFileReader", "redoLogFileReader", "Read a redo log file", 16384) { + Uint32 pageIndex = 0; + Uint32 oldPageIndex = 0; + Uint32 recordType = 1234567890; + + PageHeader *thePageHeader; + CompletedGCIRecord *cGCIrecord; + PrepareOperationRecord *poRecord; + NextLogRecord *nlRecord; + FileDescriptor *fdRecord; + CommitTransactionRecord *ctRecord; + InvalidCommitTransactionRecord *ictRecord; + NextMbyteRecord *nmRecord; + AbortTransactionRecord *atRecord; + + readArguments(argc, argv); + + f = fopen(fileName, "rb"); + if(!f){ + perror("Error: open file"); + exit(RETURN_ERROR); + } + + Uint32 tmpFileOffset = startAtMbyte * PAGESIZE * NO_PAGES_IN_MBYTE * sizeof(Uint32); + if (fseek(f, tmpFileOffset, FROM_BEGINNING)) { + perror("Error: Move in file"); + exit(RETURN_ERROR); + } + + redoLogPage = new Uint32[PAGESIZE*NO_PAGES_IN_MBYTE]; + + // Loop for every mbyte. + for (Uint32 j = startAtMbyte; j < NO_MBYTE_IN_FILE; j++) { + readFromFile(f, redoLogPage, PAGESIZE*NO_PAGES_IN_MBYTE); + + if (firstLap) { + pageIndex = startAtPageIndex; + firstLap = false; + } else + pageIndex = 0; + + // Loop for every page. + for (int i = startAtPage; i < NO_PAGES_IN_MBYTE; i++) { + + if (pageIndex == 0) { + thePageHeader = (PageHeader *) &redoLogPage[i*PAGESIZE]; + // Print out mbyte number, page number and page index. + ndbout << j << ":" << i << ":" << pageIndex << endl + << " " << j*32 + i << ":" << pageIndex << " "; + if (thePrintFlag) ndbout << (*thePageHeader); + if (theCheckFlag) { + if(!thePageHeader->check()) { + doExit(); + } + + Uint32 checkSum = 37; + for (int ps = 1; ps < PAGESIZE; ps++) + checkSum = redoLogPage[i*PAGESIZE+ps] ^ checkSum; + + if (checkSum != redoLogPage[i*PAGESIZE]){ + ndbout << "WRONG CHECKSUM: checksum = " << redoLogPage[i*PAGESIZE] + << " expected = " << checkSum << endl; + doExit(); + } + else + ndbout << "expected checksum: " << checkSum << endl; + + } + pageIndex += thePageHeader->getLogRecordSize(); + } + + if (onlyMbyteHeaders) { + // Show only the first page header in every mbyte of the file. + break; + } + + if (onlyPageHeaders) { + // Show only page headers. Continue with the next page in this for loop. + pageIndex = 0; + continue; + } + + do { + // Print out mbyte number, page number and page index. + ndbout << j << ":" << i << ":" << pageIndex << endl + << " " << j*32 + i << ":" << pageIndex << " "; + recordType = redoLogPage[i*PAGESIZE + pageIndex]; + switch(recordType) { + case ZFD_TYPE: + fdRecord = (FileDescriptor *) &redoLogPage[i*PAGESIZE + pageIndex]; + if (thePrintFlag) ndbout << (*fdRecord); + if (theCheckFlag) { + if(!fdRecord->check()) { + doExit(); + } + } + if (onlyFileDesc) { + delete [] redoLogPage; + exit(RETURN_OK); + } + pageIndex += fdRecord->getLogRecordSize(); + break; + + case ZNEXT_LOG_RECORD_TYPE: + nlRecord = (NextLogRecord *) (&redoLogPage[i*PAGESIZE] + pageIndex); + pageIndex += nlRecord->getLogRecordSize(pageIndex); + if (pageIndex <= PAGESIZE) { + if (thePrintFlag) ndbout << (*nlRecord); + if (theCheckFlag) { + if(!nlRecord->check()) { + doExit(); + } + } + } + break; + + case ZCOMPLETED_GCI_TYPE: + cGCIrecord = (CompletedGCIRecord *) &redoLogPage[i*PAGESIZE + pageIndex]; + pageIndex += cGCIrecord->getLogRecordSize(); + if (pageIndex <= PAGESIZE) { + if (thePrintFlag) ndbout << (*cGCIrecord); + if (theCheckFlag) { + if(!cGCIrecord->check()) { + doExit(); + } + } + } + break; + + case ZPREP_OP_TYPE: + poRecord = (PrepareOperationRecord *) &redoLogPage[i*PAGESIZE + pageIndex]; + pageIndex += poRecord->getLogRecordSize(); + if (pageIndex <= PAGESIZE) { + if (thePrintFlag) ndbout << (*poRecord); + if (theCheckFlag) { + if(!poRecord->check()) { + doExit(); + } + } + } + else { + oldPageIndex = pageIndex - poRecord->getLogRecordSize(); + } + break; + + case ZCOMMIT_TYPE: + ctRecord = (CommitTransactionRecord *) &redoLogPage[i*PAGESIZE + pageIndex]; + pageIndex += ctRecord->getLogRecordSize(); + if (pageIndex <= PAGESIZE) { + if (thePrintFlag) ndbout << (*ctRecord); + if (theCheckFlag) { + if(!ctRecord->check()) { + doExit(); + } + } + } + else { + oldPageIndex = pageIndex - ctRecord->getLogRecordSize(); + } + break; + + case ZINVALID_COMMIT_TYPE: + ictRecord = (InvalidCommitTransactionRecord *) &redoLogPage[i*PAGESIZE + pageIndex]; + pageIndex += ictRecord->getLogRecordSize(); + if (pageIndex <= PAGESIZE) { + if (thePrintFlag) ndbout << (*ictRecord); + if (theCheckFlag) { + if(!ictRecord->check()) { + doExit(); + } + } + } + else { + oldPageIndex = pageIndex - ictRecord->getLogRecordSize(); + } + break; + + case ZNEXT_MBYTE_TYPE: + nmRecord = (NextMbyteRecord *) &redoLogPage[i*PAGESIZE + pageIndex]; + if (thePrintFlag) ndbout << (*nmRecord); + i = NO_PAGES_IN_MBYTE; + break; + + case ZABORT_TYPE: + atRecord = (AbortTransactionRecord *) &redoLogPage[i*PAGESIZE + pageIndex]; + pageIndex += atRecord->getLogRecordSize(); + if (pageIndex <= PAGESIZE) { + if (thePrintFlag) ndbout << (*atRecord); + if (theCheckFlag) { + if(!atRecord->check()) { + doExit(); + } + } + } + break; + + case ZNEW_PREP_OP_TYPE: + case ZFRAG_SPLIT_TYPE: + ndbout << endl << "Record type = " << recordType << " not implemented." << endl; + doExit(); + + default: + ndbout << " ------ERROR: UNKNOWN RECORD TYPE------" << endl; + + // Print out remaining data in this page + for (int j = pageIndex; j < PAGESIZE; j++){ + Uint32 unknown = redoLogPage[i*PAGESIZE + j]; + + ndbout_c("%-30d%-12u%-12x", j, unknown, unknown); + } + + doExit(); + } + } while(pageIndex < PAGESIZE && i < NO_PAGES_IN_MBYTE); + + if (pageIndex > PAGESIZE) { + // The last record overlapped page boundary. Must redo that record. + pageIndex = readRecordOverPageBoundary(&redoLogPage[i*PAGESIZE], + pageIndex, oldPageIndex, recordType); + } else { + pageIndex = 0; + } + ndbout << endl; + }//for + ndbout << endl; + if (startAtMbyte != 0) { + break; + } + }//for + fclose(f); + delete [] redoLogPage; + exit(RETURN_OK); +} + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +Uint32 readFromFile(FILE * f, Uint32 *toPtr, Uint32 sizeInWords) { + Uint32 noOfReadWords; + if ( !(noOfReadWords = fread(toPtr, sizeof(Uint32), sizeInWords, f)) ) { + ndbout << "Error reading file" << endl; + doExit(); + } + + return noOfReadWords; +} + + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + +Uint32 readRecordOverPageBoundary(Uint32 *pagePtr, Uint32 pageIndex, Uint32 oldPageIndex, Uint32 recordType) { + Uint32 pageHeader[PAGEHEADERSIZE]; + Uint32 tmpPages[PAGESIZE*10]; + PageHeader *thePageHeader; + Uint32 recordSize = 0; + + PrepareOperationRecord *poRecord; + CommitTransactionRecord *ctRecord; + InvalidCommitTransactionRecord *ictRecord; + + memcpy(pageHeader, pagePtr + PAGESIZE, PAGEHEADERSIZE*sizeof(Uint32)); + memcpy(tmpPages, pagePtr + oldPageIndex, (PAGESIZE - oldPageIndex)*sizeof(Uint32)); + memcpy(tmpPages + PAGESIZE - oldPageIndex , + (pagePtr + PAGESIZE + PAGEHEADERSIZE), + (PAGESIZE - PAGEHEADERSIZE)*sizeof(Uint32)); + + switch(recordType) { + case ZPREP_OP_TYPE: + poRecord = (PrepareOperationRecord *) tmpPages; + recordSize = poRecord->getLogRecordSize(); + if (recordSize < (PAGESIZE - PAGEHEADERSIZE)) { + if (theCheckFlag) { + if(!poRecord->check()) { + doExit(); + } + } + if (thePrintFlag) ndbout << (*poRecord); + } else { + ndbout << "Error: Record greater than a Page" << endl; + } + break; + + case ZCOMMIT_TYPE: + ctRecord = (CommitTransactionRecord *) tmpPages; + recordSize = ctRecord->getLogRecordSize(); + if (recordSize < (PAGESIZE - PAGEHEADERSIZE)) { + if (theCheckFlag) { + if(!ctRecord->check()) { + doExit(); + } + } + if (thePrintFlag) ndbout << (*ctRecord); + } else { + ndbout << endl << "Error: Record greater than a Page" << endl; + } + break; + + case ZINVALID_COMMIT_TYPE: + ictRecord = (InvalidCommitTransactionRecord *) tmpPages; + recordSize = ictRecord->getLogRecordSize(); + if (recordSize < (PAGESIZE - PAGEHEADERSIZE)) { + if (theCheckFlag) { + if(!ictRecord->check()) { + doExit(); + } + } + if (thePrintFlag) ndbout << (*ictRecord); + } else { + ndbout << endl << "Error: Record greater than a Page" << endl; + } + break; + + case ZNEW_PREP_OP_TYPE: + case ZABORT_TYPE: + case ZFRAG_SPLIT_TYPE: + case ZNEXT_MBYTE_TYPE: + ndbout << endl << "Record type = " << recordType << " not implemented." << endl; + return 0; + + default: + ndbout << endl << "Error: Unknown record type. Record type = " << recordType << endl; + return 0; + } + + thePageHeader = (PageHeader *) (pagePtr + PAGESIZE); + if (thePrintFlag) ndbout << (*thePageHeader); + + return PAGEHEADERSIZE - PAGESIZE + oldPageIndex + recordSize; +} + +//---------------------------------------------------------------- +// +//---------------------------------------------------------------- + + +void usage(const char * prg){ + ndbout << endl << "Usage: " << endl << prg + << " [-noprint] [-nocheck] [-mbyte <0-15>] " + << "[-mbyteheaders] [-pageheaders] [-filedescriptors] [-page <0-31>] " + << "[-pageindex <12-8191>]" + << endl << endl; + +} +void readArguments(int argc, const char** argv) +{ + if(argc < 2 || argc > 9){ + usage(argv[0]); + doExit(); + } + + strcpy(fileName, argv[1]); + argc--; + + int i = 2; + while (argc > 1) + { + if (strcmp(argv[i], "-noprint") == 0) { + thePrintFlag = false; + } else if (strcmp(argv[i], "-nocheck") == 0) { + theCheckFlag = false; + } else if (strcmp(argv[i], "-mbyteheaders") == 0) { + onlyMbyteHeaders = true; + } else if (strcmp(argv[i], "-pageheaders") == 0) { + onlyPageHeaders = true; + } else if (strcmp(argv[i], "-filedescriptors") == 0) { + onlyFileDesc = true; + } else if (strcmp(argv[i], "-mbyte") == 0) { + startAtMbyte = atoi(argv[i+1]); + if (startAtMbyte > 15) { + usage(argv[0]); + doExit(); + } + argc--; + i++; + } else if (strcmp(argv[i], "-page") == 0) { + startAtPage = atoi(argv[i+1]); + if (startAtPage > 31) { + usage(argv[0]); + doExit(); + } + argc--; + i++; + } else if (strcmp(argv[i], "-pageindex") == 0) { + startAtPageIndex = atoi(argv[i+1]); + if (startAtPageIndex > 8191 || startAtPageIndex < 12) { + usage(argv[0]); + doExit(); + } + argc--; + i++; + } else { + usage(argv[0]); + doExit(); + } + argc--; + i++; + } + +} + +void doExit() { + ndbout << "Error in redoLogReader(). Exiting!" << endl; + fclose(f); + delete [] redoLogPage; + exit(RETURN_ERROR); +} diff --git a/ndb/src/kernel/blocks/dbtc/Dbtc.hpp b/ndb/src/kernel/blocks/dbtc/Dbtc.hpp new file mode 100644 index 00000000000..a3a01065429 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtc/Dbtc.hpp @@ -0,0 +1,1947 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DBTC_H +#define DBTC_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef DBTC_C +/* + * 2.2 LOCAL SYMBOLS + * ----------------- + */ +#define Z8NIL 255 +#define ZAPI_CONNECT_FILESIZE 20 +#define ZATTRBUF_FILESIZE 4000 +#define ZCLOSED 2 +#define ZCOMMITING 0 /* VALUE FOR TRANSTATUS */ +#define ZCOMMIT_SETUP 2 +#define ZCONTINUE_ABORT_080 4 +#define ZDATABUF_FILESIZE 4000 +#define ZGCP_FILESIZE 10 +#define ZINBUF_DATA_LEN 24 /* POSITION OF 'DATA LENGHT'-VARIABLE. */ +#define ZINBUF_NEXT 27 /* POSITION OF 'NEXT'-VARIABLE. */ +#define ZINBUF_PREV 26 /* POSITION OF 'PREVIOUS'-VARIABLE. */ +#define ZINTSPH1 1 +#define ZINTSPH2 2 +#define ZINTSPH3 3 +#define ZINTSPH6 6 +#define ZLASTPHASE 255 +#define ZMAX_DATA_IN_LQHKEYREQ 12 +#define ZNODEBUF_FILESIZE 2000 +#define ZNR_OF_SEIZE 10 +#define ZSCANREC_FILE_SIZE 100 +#define ZSCAN_FRAGREC_FILE_SIZE 400 +#define ZSCAN_OPREC_FILE_SIZE 400 +#define ZSEND_ATTRINFO 0 +#define ZSPH1 1 +#define ZTABREC_FILESIZE 16 +#define ZTAKE_OVER_ACTIVE 1 +#define ZTAKE_OVER_IDLE 0 +#define ZTC_CONNECT_FILESIZE 200 +#define ZTCOPCONF_SIZE 6 + +// ---------------------------------------- +// Error Codes for Scan +// ---------------------------------------- +#define ZNO_CONCURRENCY_ERROR 242 +#define ZTOO_HIGH_CONCURRENCY_ERROR 244 +#define ZNO_SCANREC_ERROR 245 +#define ZNO_FRAGMENT_ERROR 246 +#define ZSCAN_AI_LEN_ERROR 269 +#define ZSCAN_LQH_ERROR 270 +#define ZSCAN_FRAG_LQH_ERROR 274 + +#define ZSCANTIME_OUT_ERROR 296 +#define ZSCANTIME_OUT_ERROR2 297 + +// ---------------------------------------- +// Error Codes for transactions +// ---------------------------------------- +#define ZSTATE_ERROR 202 +#define ZLENGTH_ERROR 207 // Also Scan +#define ZERO_KEYLEN_ERROR 208 +#define ZSIGNAL_ERROR 209 +#define ZGET_ATTRBUF_ERROR 217 // Also Scan +#define ZGET_DATAREC_ERROR 218 +#define ZMORE_AI_IN_TCKEYREQ_ERROR 220 +#define ZCOMMITINPROGRESS 230 +#define ZROLLBACKNOTALLOWED 232 +#define ZNO_FREE_TC_CONNECTION 233 // Also Scan +#define ZABORTINPROGRESS 237 +#define ZPREPAREINPROGRESS 238 +#define ZWRONG_SCHEMA_VERSION_ERROR 241 // Also Scan +#define ZSCAN_NODE_ERROR 250 +#define ZTRANS_STATUS_ERROR 253 +#define ZTIME_OUT_ERROR 266 +#define ZSIMPLE_READ_WITHOUT_AI 271 +#define ZNO_AI_WITH_UPDATE 272 +#define ZSEIZE_API_COPY_ERROR 275 +#define ZSCANINPROGRESS 276 +#define ZABORT_ERROR 277 +#define ZCOMMIT_TYPE_ERROR 278 + +#define ZNO_FREE_TC_MARKER 279 +#define ZNODE_SHUTDOWN_IN_PROGRESS 280 +#define ZCLUSTER_SHUTDOWN_IN_PROGRESS 281 +#define ZWRONG_STATE 282 +#define ZCLUSTER_IN_SINGLEUSER_MODE 299 + +#define ZDROP_TABLE_IN_PROGRESS 283 +#define ZNO_SUCH_TABLE 284 +#define ZUNKNOWN_TABLE_ERROR 285 +#define ZNODEFAIL_BEFORE_COMMIT 286 +#define ZINDEX_CORRUPT_ERROR 287 + +// ---------------------------------------- +// Seize error +// ---------------------------------------- +#define ZNO_FREE_API_CONNECTION 219 +#define ZSYSTEM_NOT_STARTED_ERROR 203 + +// ---------------------------------------- +// Release errors +// ---------------------------------------- +#define ZINVALID_CONNECTION 229 + + +#define ZNOT_FOUND 626 +#define ZALREADYEXIST 630 +#define ZINCONSISTENTHASHINDEX 892 +#endif + +class Dbtc: public SimulatedBlock { +public: + enum ConnectionState { + CS_CONNECTED = 0, + CS_DISCONNECTED = 1, + CS_STARTED = 2, + CS_RECEIVING = 3, + CS_PREPARED = 4, + CS_START_PREPARING = 5, + CS_REC_PREPARING = 6, + CS_RESTART = 7, + CS_ABORTING = 8, + CS_COMPLETING = 9, + CS_COMPLETE_SENT = 10, + CS_PREPARE_TO_COMMIT = 11, + CS_COMMIT_SENT = 12, + CS_START_COMMITTING = 13, + CS_COMMITTING = 14, + CS_REC_COMMITTING = 15, + CS_WAIT_ABORT_CONF = 16, + CS_WAIT_COMPLETE_CONF = 17, + CS_WAIT_COMMIT_CONF = 18, + CS_FAIL_ABORTING = 19, + CS_FAIL_ABORTED = 20, + CS_FAIL_PREPARED = 21, + CS_FAIL_COMMITTING = 22, + CS_FAIL_COMMITTED = 23, + CS_FAIL_COMPLETED = 24, + CS_START_SCAN = 25 + }; + + enum OperationState { + OS_CONNECTING_DICT = 0, + OS_CONNECTED = 1, + OS_OPERATING = 2, + OS_PREPARED = 3, + OS_COMMITTING = 4, + OS_COMMITTED = 5, + OS_COMPLETING = 6, + OS_COMPLETED = 7, + OS_RESTART = 8, + OS_ABORTING = 9, + OS_ABORT_SENT = 10, + OS_TAKE_OVER = 11, + OS_WAIT_DIH = 12, + OS_WAIT_KEYINFO = 13, + OS_WAIT_ATTR = 14, + OS_WAIT_COMMIT_CONF = 15, + OS_WAIT_ABORT_CONF = 16, + OS_WAIT_COMPLETE_CONF = 17 + }; + + enum AbortState { + AS_IDLE = 0, + AS_ACTIVE = 1 + }; + + enum HostState { + HS_ALIVE = 0, + HS_DEAD = 1 + }; + + enum LqhTransState { + LTS_IDLE = 0, + LTS_ACTIVE = 1 + }; + + enum TakeOverState { + TOS_NOT_DEFINED = 0, + TOS_IDLE = 1, + TOS_ACTIVE = 2, + TOS_COMPLETED = 3, + TOS_NODE_FAILED = 4 + }; + + enum FailState { + FS_IDLE = 0, + FS_LISTENING = 1, + FS_COMPLETING = 2 + }; + + enum SystemStartState { + SSS_TRUE = 0, + SSS_FALSE = 1 + }; + + enum TimeOutCheckState { + TOCS_TRUE = 0, + TOCS_FALSE = 1 + }; + + enum ReturnSignal { + RS_NO_RETURN = 0, + RS_TCKEYCONF = 1, + RS_TCKEYREF = 2, + RS_TC_COMMITCONF = 3, + RS_TCROLLBACKCONF = 4, + RS_TCROLLBACKREP = 5 + }; + + enum IndexOperationState { + IOS_NOOP = 0, + IOS_INDEX_ACCESS = 1, + IOS_INDEX_ACCESS_WAIT_FOR_TCKEYCONF = 2, + IOS_INDEX_ACCESS_WAIT_FOR_TRANSID_AI = 3, + IOS_INDEX_OPERATION = 4 + }; + + enum IndexState { + IS_BUILDING = 0, // build in progress, start state at create + IS_ONLINE = 1 // ready to use + }; + + + /**-------------------------------------------------------------------------- + * LOCAL SYMBOLS PER 'SYMBOL-VALUED' VARIABLE + * + * + * NSYMB ZAPI_CONNECT_FILESIZE = 20 + * NSYMB ZTC_CONNECT_FILESIZE = 200 + * NSYMB ZHOST_FILESIZE = 16 + * NSYMB ZDATABUF_FILESIZE = 4000 + * NSYMB ZATTRBUF_FILESIZE = 4000 + * NSYMB ZGCP_FILESIZE = 10 + * + * + * ABORTED CODES + * TPHASE NSYMB ZSPH1 = 1 + * NSYMB ZLASTPHASE = 255 + * + * + * LQH_TRANS + * NSYMB ZTRANS_ABORTED = 1 + * NSYMB ZTRANS_PREPARED = 2 + * NSYMB ZTRANS_COMMITTED = 3 + * NSYMB ZCOMPLETED_LQH_TRANS = 4 + * NSYMB ZTRANS_COMPLETED = 5 + * + * + * TAKE OVER + * NSYMB ZTAKE_OVER_IDLE = 0 + * NSYMB ZTAKE_OVER_ACTIVE = 1 + * + * ATTRBUF (ATTRBUF_RECORD) + * NSYMB ZINBUF_DATA_LEN = 24 + * NSYMB ZINBUF_NEXTFREE = 25 (NOT USED ) + * NSYMB ZINBUF_PREV = 26 + * NSYMB ZINBUF_NEXT = 27 + -------------------------------------------------------------------------*/ + /* + 2.3 RECORDS AND FILESIZES + ------------------------- + */ + /* **************************************************************** */ + /* ---------------------------------------------------------------- */ + /* ------------------- TRIGGER AND INDEX DATA --------------------- */ + /* ---------------------------------------------------------------- */ + /* **************************************************************** */ + /* ********* DEFINED TRIGGER DATA ********* */ + /* THIS RECORD FORMS LISTS OF ACTIVE */ + /* TRIGGERS FOR EACH TABLE. */ + /* THE RECORDS ARE MANAGED BY A TRIGGER */ + /* POOL WHERE A TRIGGER RECORD IS SEIZED */ + /* WHEN A TRIGGER IS ACTIVATED AND RELEASED */ + /* WHEN THE TRIGGER IS DEACTIVATED. */ + /* **************************************** */ + struct TcDefinedTriggerData { + /** + * Trigger id, used to identify the trigger + */ + UintR triggerId; + + /** + * Trigger type, defines what the trigger is used for + */ + TriggerType::Value triggerType; + + /** + * Trigger type, defines what the trigger is used for + */ + TriggerEvent::Value triggerEvent; + + /** + * Attribute mask, defines what attributes are to be monitored + * Can be seen as a compact representation of SQL column name list + */ + Bitmask attributeMask; + + /** + * Next ptr (used in pool/list) + */ + union { + Uint32 nextPool; + Uint32 nextList; + }; + + /** + * Index id, only used by secondary_index triggers. This is same as + * index table id in DICT. + **/ + Uint32 indexId; + + /** + * Prev pointer (used in list) + */ + Uint32 prevList; + + inline void print(NdbOut & s) const { + s << "[DefinedTriggerData = " << triggerId << "]"; + } + }; + typedef Ptr DefinedTriggerPtr; + + /** + * Pool of trigger data record + */ + ArrayPool c_theDefinedTriggerPool; + + /** + * The list of active triggers + */ + DLList c_theDefinedTriggers; + + typedef DataBuffer<11> AttributeBuffer; + + AttributeBuffer::DataBufferPool c_theAttributeBufferPool; + + UintR c_transactionBufferSpace; + + + /* ********** FIRED TRIGGER DATA ********** */ + /* THIS RECORD FORMS LISTS OF FIRED */ + /* TRIGGERS FOR A TRANSACTION. */ + /* THE RECORDS ARE MANAGED BY A TRIGGER */ + /* POOL WHERE A TRIGGER RECORD IS SEIZED */ + /* WHEN A TRIGGER IS ACTIVATED AND RELEASED */ + /* WHEN THE TRIGGER IS DEACTIVATED. */ + /* **************************************** */ + struct TcFiredTriggerData { + TcFiredTriggerData(AttributeBuffer::DataBufferPool & abp): + keyValues(abp), + beforeValues(abp), + afterValues(abp) + {} + /** + * Trigger id, used to identify the trigger + **/ + Uint32 triggerId; + + /** + * The operation that fired the trigger + */ + Uint32 fireingOperation; + + /** + * Trigger attribute info, primary key value(s) + */ + AttributeBuffer keyValues; + + /** + * Trigger attribute info, attribute value(s) before operation + */ + AttributeBuffer beforeValues; + + /** + * Trigger attribute info, attribute value(s) after operation + */ + AttributeBuffer afterValues; + + /** + * Next ptr (used in pool/list) + */ + union { + Uint32 nextPool; + Uint32 nextList; + }; + + /** + * Prev pointer (used in list) + */ + Uint32 prevList; + + inline void print(NdbOut & s) const { + s << "[FiredTriggerData = " << triggerId << "]"; + } + }; + typedef Ptr FiredTriggerPtr; + + /** + * Pool of trigger data record + */ + ArrayPool c_theFiredTriggerPool; + AttributeBuffer::DataBufferPool c_theTriggerAttrInfoPool; + + Uint32 c_maxNumberOfDefinedTriggers; + Uint32 c_maxNumberOfFiredTriggers; + + struct AttrInfoRecord { + /** + * Pre-allocated AttrInfo signal + */ + AttrInfo attrInfo; + + /** + * Next ptr (used in pool/list) + */ + union { + Uint32 nextPool; + Uint32 nextList; + }; + /** + * Prev pointer (used in list) + */ + Uint32 prevList; + }; + + + /* ************* INDEX DATA *************** */ + /* THIS RECORD FORMS LISTS OF ACTIVE */ + /* INDEX FOR EACH TABLE. */ + /* THE RECORDS ARE MANAGED BY A INDEX */ + /* POOL WHERE AN INDEX RECORD IS SEIZED */ + /* WHEN AN INDEX IS CREATED AND RELEASED */ + /* WHEN THE INDEX IS DROPPED. */ + /* **************************************** */ + struct TcIndexData { + /** + * IndexState + */ + IndexState indexState; + + /** + * Index id, same as index table id in DICT + */ + Uint32 indexId; + + /** + * Index attribute list. Only the length is used in v21x. + */ + AttributeList attributeList; + + /** + * Primary table id, the primary table to be indexed + */ + Uint32 primaryTableId; + + /** + * Primary key position in secondary table + */ + Uint32 primaryKeyPos; + + /** + * Next ptr (used in pool/list) + */ + union { + Uint32 nextPool; + Uint32 nextList; + }; + /** + * Prev pointer (used in list) + */ + Uint32 prevList; + }; + + typedef Ptr TcIndexDataPtr; + + /** + * Pool of index data record + */ + ArrayPool c_theIndexPool; + + /** + * The list of defined indexes + */ + ArrayList c_theIndexes; + UintR c_maxNumberOfIndexes; + + struct TcIndexOperation { + TcIndexOperation(AttributeBuffer::DataBufferPool & abp) : + indexOpState(IOS_NOOP), + expectedKeyInfo(0), + keyInfo(abp), + expectedAttrInfo(0), + attrInfo(abp), + expectedTransIdAI(0), + transIdAI(abp), + tcIndxReq(new TcIndxReq()), + indexReadTcConnect(RNIL) + {} + + ~TcIndexOperation() + { + delete tcIndxReq; + } + + // Index data + Uint32 indexOpId; + IndexOperationState indexOpState; // Used to mark on-going TcKeyReq + Uint32 expectedKeyInfo; + AttributeBuffer keyInfo; // For accumulating IndxKeyInfo + Uint32 expectedAttrInfo; + AttributeBuffer attrInfo; // For accumulating IndxAttrInfo + Uint32 expectedTransIdAI; + AttributeBuffer transIdAI; // For accumulating TransId_AI + + TcIndxReq* tcIndxReq; + UintR connectionIndex; + UintR indexReadTcConnect; // + + /** + * Next ptr (used in pool/list) + */ + union { + Uint32 nextPool; + Uint32 nextList; + }; + /** + * Prev pointer (used in list) + */ + Uint32 prevList; + }; + + typedef Ptr TcIndexOperationPtr; + + /** + * Pool of index data record + */ + ArrayPool c_theIndexOperationPool; + + /** + * The list of index operations + */ + ArrayList c_theIndexOperations; + + UintR c_maxNumberOfIndexOperations; + + struct TcSeizedIndexOperation { + /** + * Next ptr (used in pool/list) + */ + union { + Uint32 nextPool; + Uint32 nextList; + }; + /** + * Prev pointer (used in list) + */ + Uint32 prevList; + }; + + /** + * Pool of seized index operations + */ + ArrayPool c_theSeizedIndexOperationPool; + + typedef Ptr TcSeizedIndexOperationPtr; + + /************************** API CONNECT RECORD *********************** + * The API connect record contains the connection record to which the + * application connects. + * + * The application can send one operation at a time. It can send a + * new operation immediately after sending the previous operation. + * Thereby several operations can be active in one transaction within TC. + * This is achieved by using the API connect record. + * Each active operation is handled by the TC connect record. + * As soon as the TC connect record has sent the + * request to the LQH it is ready to receive new operations. + * The LQH connect record takes care of waiting for an operation to + * complete. + * When an operation has completed on the LQH connect record, + * a new operation can be started on this LQH connect record. + ******************************************************************* + * + * API CONNECT RECORD ALIGNED TO BE 256 BYTES + ********************************************************************/ + + /*******************************************************************>*/ + // We break out the API Timer for optimisation on scanning rather than + // on fast access. + /*******************************************************************>*/ + inline void setApiConTimer(Uint32 apiConPtrI, Uint32 value, Uint32 line){ + c_apiConTimer[apiConPtrI] = value; + c_apiConTimer_line[apiConPtrI] = line; + } + + inline Uint32 getApiConTimer(Uint32 apiConPtrI) const { + return c_apiConTimer[apiConPtrI]; + } + UintR* c_apiConTimer; + UintR* c_apiConTimer_line; + + struct ApiConnectRecord { + ApiConnectRecord(ArrayPool & firedTriggerPool, + ArrayPool & seizedIndexOpPool): + theFiredTriggers(firedTriggerPool), + isIndexOp(false), + theSeizedIndexOperations(seizedIndexOpPool) + {} + + //--------------------------------------------------- + // First 16 byte cache line. Hot variables. + //--------------------------------------------------- + ConnectionState apiConnectstate; + UintR transid[2]; + UintR firstTcConnect; + + //--------------------------------------------------- + // Second 16 byte cache line. Hot variables. + //--------------------------------------------------- + UintR lqhkeyconfrec; + UintR cachePtr; + UintR currSavePointId; + UintR counter; + + //--------------------------------------------------- + // Third 16 byte cache line. First and second cache + // line plus this will be enough for copy API records. + // Variables used in late phases. + //--------------------------------------------------- + UintR nextGcpConnect; + UintR prevGcpConnect; + UintR gcpPointer; + UintR ndbapiConnect; + + //--------------------------------------------------- + // Fourth 16 byte cache line. Only used in late phases. + // Plus 4 bytes of error handling. + //--------------------------------------------------- + UintR nextApiConnect; + BlockReference ndbapiBlockref; + UintR apiCopyRecord; + UintR globalcheckpointid; + + //--------------------------------------------------- + // Second 64 byte cache line starts. First 16 byte + // cache line in this one. Variables primarily used + // in early phase. + //--------------------------------------------------- + UintR lastTcConnect; + UintR lqhkeyreqrec; + AbortState abortState; + Uint32 buddyPtr; + Uint8 unused; + Uint8 unused2; + Uint8 takeOverRec; + Uint8 currentReplicaNo; + + //--------------------------------------------------- + // Error Handling variables. If cache line 32 bytes + // ensures that cache line is still only read in + // early phases. + //--------------------------------------------------- + union { + UintR apiScanRec; + UintR commitAckMarker; + }; + UintR currentTcConnect; + BlockReference tcBlockref; + Uint16 returncode; + Uint16 takeOverInd; + + //--------------------------------------------------- + // Second 64 byte cache line. Third 16 byte cache line + // in this one. Variables primarily used in early phase + // and checked in late phase. + // Fourth cache line is the tcSendArray that is used + // when two and three operations are responded to in + // parallel. The first two entries in tcSendArray is + // part of the third cache line. + //--------------------------------------------------- + //--------------------------------------------------- + // timeOutCounter is used waiting for ABORTCONF, COMMITCONF + // and COMPLETECONF + //--------------------------------------------------- + UintR failureNr; + Uint8 tckeyrec; // Ändrad från R + Uint8 tcindxrec; + Uint8 apiFailState; // Ändrad från R + ReturnSignal returnsignal; + Uint8 timeOutCounter; + + UintR tcSendArray[6]; + + // Trigger data + + /** + * The list of fired triggers + */ + DLFifoList theFiredTriggers; + + bool triggerPending; // Used to mark waiting for a CONTINUEB + + // Index data + + bool isIndexOp; // Used to mark on-going TcKeyReq as indx table access + bool indexOpReturn; + UintR noIndexOp; // No outstanding index ops + + // Index op return context + UintR indexOp; + UintR clientData; + UintR attrInfoLen; + + UintR accumulatingIndexOp; + UintR executingIndexOp; + UintR tcIndxSendArray[6]; + ArrayList theSeizedIndexOperations; + }; + + typedef Ptr ApiConnectRecordPtr; + + + /************************** TC CONNECT RECORD ************************/ + /* *******************************************************************/ + /* TC CONNECT RECORD KEEPS ALL INFORMATION TO CARRY OUT A TRANSACTION*/ + /* THE TRANSACTION CONTROLLER ESTABLISHES CONNECTIONS TO DIFFERENT */ + /* BLOCKS TO CARRY OUT THE TRANSACTION. THERE CAN BE SEVERAL RECORDS */ + /* PER ACTIVE TRANSACTION. THE TC CONNECT RECORD COOPERATES WITH THE */ + /* API CONNECT RECORD FOR COMMUNICATION WITH THE API AND WITH THE */ + /* LQH CONNECT RECORD FOR COMMUNICATION WITH THE LQH'S INVOLVED IN */ + /* THE TRANSACTION. TC CONNECT RECORD IS PERMANENTLY CONNECTED TO A */ + /* RECORD IN DICT AND ONE IN DIH. IT CONTAINS A LIST OF ACTIVE LQH */ + /* CONNECT RECORDS AND A LIST OF STARTED BUT NOT ACTIVE LQH CONNECT */ + /* RECORDS. IT DOES ALSO CONTAIN A LIST OF ALL OPERATIONS THAT ARE */ + /* EXECUTED WITH THE TC CONNECT RECORD. */ + /*******************************************************************>*/ + /* TC_CONNECT RECORD ALIGNED TO BE 128 BYTES */ + /*******************************************************************>*/ + struct TcConnectRecord { + //--------------------------------------------------- + // First 16 byte cache line. Those variables are only + // used in error cases. + //--------------------------------------------------- + UintR tcOprec; /* TC OPREC of operation being taken over */ + Uint16 failData[4]; /* Failed nodes when taking over an operation */ + UintR nextTcFailHash; + + //--------------------------------------------------- + // Second 16 byte cache line. Those variables are used + // from LQHKEYCONF to sending COMMIT and COMPLETED. + //--------------------------------------------------- + UintR lastLqhCon; /* Connect record in last replicas Lqh record */ + Uint16 lastLqhNodeId; /* Node id of last replicas Lqh */ + Uint16 m_execAbortOption;/* TcKeyReq::ExecuteAbortOption */ + UintR commitAckMarker; /* CommitMarker I value */ + + //--------------------------------------------------- + // Third 16 byte cache line. The hottest variables. + //--------------------------------------------------- + OperationState tcConnectstate; /* THE STATE OF THE CONNECT*/ + UintR apiConnect; /* POINTER TO API CONNECT RECORD */ + UintR nextTcConnect; /* NEXT TC RECORD*/ + Uint8 dirtyOp; + Uint8 lastReplicaNo; /* NUMBER OF THE LAST REPLICA IN THE OPERATION */ + Uint8 noOfNodes; /* TOTAL NUMBER OF NODES IN OPERATION */ + Uint8 operation; /* OPERATION TYPE */ + /* 0 = READ REQUEST */ + /* 1 = UPDATE REQUEST */ + /* 2 = INSERT REQUEST */ + /* 3 = DELETE REQUEST */ + + //--------------------------------------------------- + // Fourth 16 byte cache line. The mildly hot variables. + // tcNodedata expands 4 Bytes into the next cache line + // with indexes almost never used. + //--------------------------------------------------- + UintR clientData; /* SENDERS OPERATION POINTER */ + UintR dihConnectptr; /* CONNECTION TO DIH BLOCK ON THIS NODE */ + UintR prevTcConnect; /* DOUBLY LINKED LIST OF TC CONNECT RECORDS*/ + UintR savePointId; + + Uint16 tcNodedata[4]; + + // Trigger data + FiredTriggerPtr accumulatingTriggerData; + UintR noFiredTriggers; + UintR noReceivedTriggers; + UintR triggerExecutionCount; + UintR triggeringOperation; + UintR savedState[LqhKeyConf::SignalLength]; + UintR triggerError; + + // Index data + bool isIndexOp; // Used to mark on-going TcKeyReq as index table access + UintR indexOp; + UintR currentIndexId; + UintR attrInfoLen; + }; + + friend struct TcConnectRecord; + + typedef Ptr TcConnectRecordPtr; + + // ********************** CACHE RECORD ************************************** + //--------------------------------------------------------------------------- + // This record is used between reception of TCKEYREQ and sending of LQHKEYREQ + // It is separatedso as to improve the cache hit rate and also to minimise + // the necessary memory storage in NDB Cluster. + //--------------------------------------------------------------------------- + + struct CacheRecord { + //--------------------------------------------------- + // First 16 byte cache line. Variables used by + // ATTRINFO processing. + //--------------------------------------------------- + UintR firstAttrbuf; /* POINTER TO LINKED LIST OF ATTRIBUTE BUFFERS */ + UintR lastAttrbuf; /* POINTER TO LINKED LIST OF ATTRIBUTE BUFFERS */ + UintR currReclenAi; + Uint16 attrlength; /* ATTRIBUTE INFORMATION LENGTH */ + Uint16 save1; + + //--------------------------------------------------- + // Second 16 byte cache line. Variables initiated by + // TCKEYREQ and used in LQHKEYREQ. + //--------------------------------------------------- + UintR attrinfo15[4]; + + //--------------------------------------------------- + // Third 16 byte cache line. Variables initiated by + // TCKEYREQ and used in LQHKEYREQ. + //--------------------------------------------------- + UintR attrinfo0; + UintR schemaVersion;/* SCHEMA VERSION USED IN TRANSACTION */ + UintR tableref; /* POINTER TO THE TABLE IN WHICH THE FRAGMENT EXISTS*/ + Uint16 apiVersionNo; + Uint16 keylen; /* KEY LENGTH SENT BY REQUEST SIGNAL */ + + //--------------------------------------------------- + // Fourth 16 byte cache line. Variables initiated by + // TCKEYREQ and used in LQHKEYREQ. + //--------------------------------------------------- + UintR keydata[4]; /* RECEIVES FIRST 16 BYTES OF TUPLE KEY */ + + //--------------------------------------------------- + // First 16 byte cache line in second 64 byte cache + // line. Diverse use. + //--------------------------------------------------- + UintR fragmentid; /* THE COMPUTED FRAGMENT ID */ + UintR hashValue; /* THE HASH VALUE USED TO LOCATE FRAGMENT */ + + Uint8 distributionKeyIndicator; + Uint8 distributionGroupIndicator; + Uint8 distributionGroupType; + Uint8 lenAiInTckeyreq; /* LENGTH OF ATTRIBUTE INFORMATION IN TCKEYREQ */ + + Uint8 distributionKey; + + /** + * EXECUTION MODE OF OPERATION + * 0 = NORMAL EXECUTION, 1 = INTERPRETED EXECUTION + */ + Uint8 opExec; + + /** + * LOCK TYPE OF OPERATION IF READ OPERATION + * 0 = READ LOCK, 1 = WRITE LOCK + */ + Uint8 opLock; + + /** + * IS THE OPERATION A SIMPLE TRANSACTION + * 0 = NO, 1 = YES + */ + Uint8 opSimple; + + //--------------------------------------------------- + // Second 16 byte cache line in second 64 byte cache + // line. Diverse use. + //--------------------------------------------------- + UintR distributionGroup; + UintR nextCacheRec; + UintR distributionKeySize; + Uint16 scanNode; + unsigned scanTakeOverInd : 1; + unsigned scanInfo : 15; // 12 bits used currently + + //--------------------------------------------------- + // Third and fourth 16 byte cache line in second 64 + // byte cache line. Not used currently. + //--------------------------------------------------- + UintR firstKeybuf; /* POINTER THE LINKED LIST OF KEY BUFFERS */ + UintR lastKeybuf; /* VARIABLE POINTING TO THE LAST KEY BUFFER */ + UintR packedCacheVar[6]; + }; + + typedef Ptr CacheRecordPtr; + + /* ************************ HOST RECORD ********************************** */ + /********************************************************/ + /* THIS RECORD CONTAINS ALIVE-STATUS ON ALL NODES IN THE*/ + /* SYSTEM */ + /********************************************************/ + /* THIS RECORD IS ALIGNED TO BE 128 BYTES. */ + /********************************************************/ + struct HostRecord { + HostState hostStatus; + LqhTransState lqhTransStatus; + TakeOverState takeOverStatus; + bool inPackedList; + UintR ndbVersion; + UintR noOfPackedWordsLqh; + UintR packedWordsLqh[26]; + UintR noOfWordsTCKEYCONF; + UintR packedWordsTCKEYCONF[30]; + UintR noOfWordsTCINDXCONF; + UintR packedWordsTCINDXCONF[30]; + BlockReference hostLqhBlockRef; + }; /* p2c: size = 128 bytes */ + + typedef Ptr HostRecordPtr; + + /* *********** TABLE RECORD ********************************************* */ + /********************************************************/ + /* THIS RECORD CONTAINS THE CURRENT SCHEMA VERSION OF */ + /* ALL TABLES IN THE SYSTEM. */ + /********************************************************/ + struct TableRecord { + Uint32 currentSchemaVersion; + Uint8 enabled; + Uint8 dropping; + Uint8 tableType; + Uint8 storedTable; + + bool checkTable(Uint32 schemaVersion) const { + return enabled && !dropping && (schemaVersion == currentSchemaVersion); + } + + Uint32 getErrorCode(Uint32 schemaVersion) const; + + struct DropTable { + Uint32 senderRef; + Uint32 senderData; + SignalCounter waitDropTabCount; + } dropTable; + }; + typedef Ptr TableRecordPtr; + + /** + * Each scan allocates one ScanRecord to store information + * about the current scan + * + */ + struct ScanRecord { + /** NOTE! This is the old comment for ScanState. - MASV + * STATE TRANSITIONS OF SCAN_STATE. SCAN_STATE IS THE STATE + * VARIABLE OF THE RECEIVE AND DELIVERY PROCESS. + * THE PROCESS HAS THREE STEPS IT GOES THROUGH. + * 1) THE INITIAL STATES WHEN RECEIVING DATA FOR THE SCAN. + * - WAIT_SCAN_TAB_INFO + * - WAIT_AI + * - WAIT_FRAGMENT_COUNT + * 2) THE EXECUTION STATES WHEN THE SCAN IS PERFORMED. + * - SCAN_NEXT_ORDERED + * - DELIVERED + * - QUEUED_DELIVERED + * 3) THE CLOSING STATE WHEN THE SCAN PROCESS IS CLOSING UP + * EVERYTHING. + * - CLOSING_SCAN + * INITIAL START WHEN SCAN_TABREQ RECEIVED + * -> WAIT_SCAN_TAB_INFO (IF ANY SCAN_TABINFO TO BE RECEIVED) + * -> WAIT_AI (IF NO SCAN_TAB_INFO BUT ATTRINFO IS RECEIVED) + * -> WAIT_FRAGMENT_COUNT (IF NEITHER SCAN_TABINFO OR ATTRINFO + * RECEIVED) + * + * WAIT_SCAN_TAB_INFO TRANSITIONS: + * -> WAIT_SCAN_TABINFO (WHEN MORE SCAN_TABINFO RECEIVED) + * -> WAIT_AI (WHEN ATTRINFO RECEIVED AFTER RECEIVING ALL + * SCAN_TABINFO) + * -> WAIT_FRAGMENT_COUNT (WHEN NO ATTRINFO RECEIVED AFTER + * RECEIVING ALL SCAN_TABINFO ) + * WAIT_AI TRANSITIONS: + * -> WAIT_AI (WHEN MORE ATTRINFO RECEIVED) + * -> WAIT_FRAGMENT_COUNT (WHEN ALL ATTRINFO RECEIVED) + * + * WAIT_FRAGMENT_COUNT TRANSITIONS: + * -> SCAN_NEXT_ORDERED + * + * SCAN_NEXT_ORDERED TRANSITIONS: + * -> DELIVERED (WHEN FIRST SCAN_FRAGCONF ARRIVES WITH OPERATIONS + * TO REPORT IN IT) + * -> CLOSING_SCAN (WHEN SCAN IS CLOSED BY SCAN_NEXTREQ OR BY SOME + * ERROR) + * + * DELIVERED TRANSITIONS: + * -> SCAN_NEXT_ORDERED (IF SCAN_NEXTREQ ARRIVES BEFORE ANY NEW + * OPERATIONS TO REPORT ARRIVES) + * -> QUEUED_DELIVERED (IF NEW OPERATION TO REPORT ARRIVES BEFORE + * SCAN_NEXTREQ) + * -> CLOSING_SCAN (WHEN SCAN IS CLOSED BY SCAN_NEXTREQ OR BY SOME + * ERROR) + * + * QUEUED_DELIVERED TRANSITIONS: + * -> DELIVERED (WHEN SCAN_NEXTREQ ARRIVES AND QUEUED OPERATIONS + * TO REPORT ARE SENT TO THE APPLICATION) + * -> CLOSING_SCAN (WHEN SCAN IS CLOSED BY SCAN_NEXTREQ OR BY + * SOME ERROR) + */ + enum ScanState { + IDLE = 0, + WAIT_SCAN_TAB_INFO = 1, + WAIT_AI = 2, + WAIT_FRAGMENT_COUNT = 3, + SCAN_NEXT_ORDERED = 4, + QUEUED_DELIVERED = 5, + DELIVERED = 6, + CLOSING_SCAN = 7 + }; + // State of this scan + ScanState scanState; + // References to ScanFragRecs + Uint32 scanFragrec[16]; + // Refrences to ScanOperationRecords + Uint32 scanOprec[16]; + // Number of ScanOperationRecords allocated + Uint32 noScanOprec; + // Id of the next fragment to be scanned. Used by scan fragment + // processes when they are ready for the next fragment + Uint32 scanNextFragId; + // Total number of fragments in the table we are scanning + Uint32 scanNoFrag; + // Index of next ScanRecords when in free list + Uint32 nextScan; + // Length of expected attribute information + Uint32 scanAiLength; + // Reference to ApiConnectRecord + Uint32 scanApiRec; + // Reference to TcConnectRecord + Uint32 scanTcrec; + // Number of scan frag processes that belong to this scan + Uint32 scanParallel; + // The number of recieved operations so far + Uint32 scanReceivedOperations; + // Schema version used by this scan + Uint32 scanSchemaVersion; + // Index of stored procedure belonging to this scan + Uint32 scanStoredProcId; + // The index of table that is scanned + Uint32 scanTableref; + // Number of operation records per scanned fragment + Uint16 noOprecPerFrag; + // The number of SCAN_TABINFO to receive + Uint16 noScanTabInfo; + // The number of SCAN_TABINFO received so far + Uint16 scanTabInfoReceived; + // apiIsClosed indicates if it's ok to release all resources + // and send a response to the API + // If it's false resources should not be released wait for API + // to close the scan + bool apiIsClosed; + // The number of scan frag processes that have completed their task + Uint8 scanProcessesCompleted; + // This variable is ZFALSE as long as any scan process is still alive + // It is ZTRUE as soon as all scan processes have been stopped + Uint8 scanCompletedStatus; + // Shall the locks be held until the application have read the + // records + Uint8 scanLockHold; + // Shall the locks be read or write locks + Uint8 scanLockMode; + // Skip locks by other transactions and read latest committed + Uint8 readCommitted; + // Scan is on ordered index + Uint8 rangeScan; + }; + typedef Ptr ScanRecordPtr; + + /** + * Each scan has max 16 ScanOperationRecords + * they are used for storing data to be sent to the api + */ + struct ScanOperationRecord { + // Reference to the scan operation in api + Uint32 apiOpptr[16]; + // Index and length of all recieved operations + // They will be cached here until SCAN_TABCONF is sent to api + Uint32 scanOpLength[16]; + // Next ScanOperationRecord when in free list + Uint32 nextScanOp; + }; /* p2c: size = 132 bytes */ + + typedef Ptr ScanOperationRecordPtr; + + /** + * There is max 16 ScanFragRec's for + * each scan started in TC. Each ScanFragRec is used by + * a scan fragment "process" that scans one fragment at a time. + * It will receive max 16 tuples in each request + */ + struct ScanFragRec { + /** + * ScanFragState + * WAIT_GET_PRIMCONF : Waiting for DIGETPRIMCONF when starting a new + * fragment scan + * LQH_ACTIVE : The scan process has sent a command to LQH and is + * waiting for the response + * LQH_ACTIVE_CLOSE : The scan process has sent close to LQH and is + * waiting for the response + * DELIVERED : The result have been delivered, this scan frag process + * are waiting for a SCAN_NEXTREQ to tell us to continue scanning + * RETURNING_FROM_DELIVERY : SCAN_NEXTREQ received and continuing scan + * soon + * QUEUED_FOR_DELIVERY : Result queued in TC and waiting for delivery + * to API + * COMPLETED : The fragment scan processes has completed and finally + * sent a SCAN_PROCCONF + */ + enum ScanFragState { + IDLE = 0, + WAIT_GET_PRIMCONF = 1, + LQH_ACTIVE = 2, + LQH_ACTIVE_CLOSE = 3, + DELIVERED = 4, + RETURNING_FROM_DELIVERY = 5, + QUEUED_FOR_DELIVERY = 6, + COMPLETED = 7 + }; + // Timer for checking timeout of this fragment scan + Uint32 scanFragTimer; + // Id of the current scanned fragment + Uint32 scanFragId; + // Blockreference of LQH + BlockReference lqhBlockref; + // getNodeInfo.m_connectCount, set at seize used so that + // I don't accidently kill a starting node + Uint32 m_connectCount; + // State of this fragment scan + ScanFragState scanFragState; + // Id of the ScanRecord this fragment scan belongs to + Uint32 scanRec; + // Index of next ScanFragRec, when in list of + // free ScanFragRec's + Uint32 nextScanFrag; + // Process id of this scan process within the total scan + Uint32 scanFragProcId; + // Node where current fragment resides + NodeId scanFragNodeId; + // Index of where to store the result in ScanRecord + Uint16 scanIndividual; + // The maximum number of operations that can be scanned before + // returning to TC + Uint16 scanFragConcurrency; + // Current status of the fragment scan + // * 0 = NOT COMPLETED + // * 1 = COMPLETED + // * 2 = CLOSED + Uint8 scanFragCompletedStatus; + + inline void startFragTimer(Uint32 timeVal){ + scanFragTimer = timeVal; + } + inline void stopFragTimer(void){ + scanFragTimer = 0; + } + }; + + typedef Ptr ScanFragRecPtr; + + /* **********************************************************************$ */ + /* ******$ DATA BUFFER ******$ */ + /* */ + /* THIS BUFFER IS USED AS A GENERAL DATA STORAGE. */ + /* **********************************************************************$ */ + struct DatabufRecord { + UintR data[4]; + /* 4 * 1 WORD = 4 WORD */ + UintR nextDatabuf; + }; /* p2c: size = 20 bytes */ + + typedef Ptr DatabufRecordPtr; + + /* **********************************************************************$ */ + /* ******$ ATTRIBUTE INFORMATION RECORD ******$ */ + /* + * CAN CONTAIN ONE (1) ATTRINFO SIGNAL. ONE SIGNAL CONTAINS 24 ATTR. + * INFO WORDS. BUT 32 ELEMENTS ARE USED TO MAKE PLEX HAPPY. + * SOME OF THE ELEMENTS ARE USED TO THE FOLLOWING THINGS: + * DATA LENGHT IN THIS RECORD IS STORED IN THE ELEMENT INDEXED BY + * ZINBUF_DATA_LEN. + * NEXT FREE ATTRBUF IS POINTED OUT BY THE ELEMENT INDEXED BY + * PREVIOUS ATTRBUF IS POINTED OUT BY THE ELEMENT INDEXED BY ZINBUF_PREV + * (NOT USED YET). + * NEXT ATTRBUF IS POINTED OUT BY THE ELEMENT INDEXED BY ZINBUF_NEXT. */ + /* ******************************************************************** */ + struct AttrbufRecord { + UintR attrbuf[32]; + }; /* p2c: size = 128 bytes */ + + typedef Ptr AttrbufRecordPtr; + + /*************************************************************************>*/ + /* GLOBAL CHECKPOINT INFORMATION RECORD */ + /* */ + /* THIS RECORD IS USED TO STORE THE GLOBALCHECKPOINT NUMBER AND A + * COUNTER DURING THE COMPLETION PHASE OF THE TRANSACTION */ + /*************************************************************************>*/ + /* */ + /* GCP RECORD ALIGNED TO BE 32 BYTES */ + /*************************************************************************>*/ + struct GcpRecord { + UintR gcpUnused1[2]; /* p2c: Not used */ + UintR firstApiConnect; + UintR lastApiConnect; + UintR gcpId; + UintR nextGcp; + UintR gcpUnused2; /* p2c: Not used */ + Uint16 gcpNomoretransRec; + }; /* p2c: size = 32 bytes */ + + typedef Ptr GcpRecordPtr; + + /*************************************************************************>*/ + /* TC_FAIL_RECORD */ + /* THIS RECORD IS USED WHEN HANDLING TAKE OVER OF ANOTHER FAILED + * TC NODE. */ + /*************************************************************************>*/ + struct TcFailRecord { + Uint16 queueList[MAX_NDB_NODES]; + Uint8 takeOverProcState[MAX_NDB_NODES]; + UintR completedTakeOver; + UintR currentHashIndexTakeOver; + FailState failStatus; + Uint16 queueIndex; + Uint16 takeOverNode; + }; /* p2c: size = 64 bytes */ + + typedef Ptr TcFailRecordPtr; + +public: + Dbtc(const class Configuration &); + virtual ~Dbtc(); + +private: + BLOCK_DEFINES(Dbtc); + + // Transit signals + void execPACKED_SIGNAL(Signal* signal); + void execABORTED(Signal* signal); + void execATTRINFO(Signal* signal); + void execCONTINUEB(Signal* signal); + void execKEYINFO(Signal* signal); + void execSCAN_NEXTREQ(Signal* signal); + void execSCAN_PROCREQ(Signal* signal); + void execSCAN_PROCCONF(Signal* signal); + void execTAKE_OVERTCREQ(Signal* signal); + void execTAKE_OVERTCCONF(Signal* signal); + void execLQHKEYREF(Signal* signal); + void execTRANSID_AI_R(Signal* signal); + void execKEYINFO20_R(Signal* signal); + + // Received signals + void execDUMP_STATE_ORD(Signal* signal); + void execSEND_PACKED(Signal* signal); + void execCOMPLETED(Signal* signal); + void execCOMMITTED(Signal* signal); + void execDIGETNODESREF(Signal* signal); + void execDIGETPRIMCONF(Signal* signal); + void execDIGETPRIMREF(Signal* signal); + void execDISEIZECONF(Signal* signal); + void execDIVERIFYCONF(Signal* signal); + void execDI_FCOUNTCONF(Signal* signal); + void execDI_FCOUNTREF(Signal* signal); + void execGCP_NOMORETRANS(Signal* signal); + void execLQHKEYCONF(Signal* signal); + void execNDB_STTOR(Signal* signal); + void execREAD_NODESCONF(Signal* signal); + void execREAD_NODESREF(Signal* signal); + void execSTTOR(Signal* signal); + void execTC_COMMITREQ(Signal* signal); + void execTC_CLOPSIZEREQ(Signal* signal); + void execTCGETOPSIZEREQ(Signal* signal); + void execTCKEYREQ(Signal* signal); + void execTCRELEASEREQ(Signal* signal); + void execTCSEIZEREQ(Signal* signal); + void execTCROLLBACKREQ(Signal* signal); + void execTC_HBREP(Signal* signal); + void execTC_SCHVERREQ(Signal* signal); + void execSCAN_TABREQ(Signal* signal); + void execSCAN_TABINFO(Signal* signal); + void execSCAN_FRAGCONF(Signal* signal); + void execSCAN_FRAGREF(Signal* signal); + void execSIZEALT_REP(Signal* signal); + void execLQH_TRANSCONF(Signal* signal); + void execCOMPLETECONF(Signal* signal); + void execCOMMITCONF(Signal* signal); + void execABORTCONF(Signal* signal); + void execNODE_FAILREP(Signal* signal); + void execINCL_NODEREQ(Signal* signal); + void execTIME_SIGNAL(Signal* signal); + void execAPI_FAILREQ(Signal* signal); + void execSCAN_HBREP(Signal* signal); + void execSET_VAR_REQ(Signal* signal); + + void execABORT_ALL_REQ(Signal* signal); + + void execCREATE_TRIG_REQ(Signal* signal); + void execDROP_TRIG_REQ(Signal* signal); + void execFIRE_TRIG_ORD(Signal* signal); + void execTRIG_ATTRINFO(Signal* signal); + void execCREATE_INDX_REQ(Signal* signal); + void execDROP_INDX_REQ(Signal* signal); + void execTCINDXREQ(Signal* signal); + void execINDXKEYINFO(Signal* signal); + void execINDXATTRINFO(Signal* signal); + void execALTER_INDX_REQ(Signal* signal); + + // Index table lookup + void execTCKEYCONF(Signal* signal); + void execTCKEYREF(Signal* signal); + void execTRANSID_AI(Signal* signal); + void execTCROLLBACKREP(Signal* signal); + + void execCREATE_TAB_REQ(Signal* signal); + void execPREP_DROP_TAB_REQ(Signal* signal); + void execDROP_TAB_REQ(Signal* signal); + void execWAIT_DROP_TAB_CONF(Signal* signal); + void checkWaitDropTabFailedLqh(Signal*, Uint32 nodeId, Uint32 tableId); + void execALTER_TAB_REQ(Signal* signal); + void set_timeout_value(Uint32 timeOut); + void set_appl_timeout_value(Uint32 timeOut); + void set_no_parallel_takeover(Uint32); + void updateBuddyTimer(ApiConnectRecordPtr); + + // Statement blocks + void updatePackedList(Signal* signal, HostRecord* ahostptr, + Uint16 ahostIndex); + void clearTcNodeData(Signal* signal, + UintR TLastLqhIndicator, + UintR Tstart); + void errorReport(Signal* signal, int place); + void warningReport(Signal* signal, int place); + void printState(Signal* signal, int place); + int seizeTcRecord(Signal* signal); + int seizeCacheRecord(Signal* signal); + void TCKEY_abort(Signal* signal, int place); + void copyFromToLen(UintR* sourceBuffer, UintR* destBuffer, UintR copyLen); + void reportNodeFailed(Signal* signal, Uint32 nodeId); + void sendPackedTCKEYCONF(Signal* signal, + HostRecord * ahostptr, + UintR hostId); + void sendPackedTCINDXCONF(Signal* signal, + HostRecord * ahostptr, + UintR hostId); + void sendPackedSignalLqh(Signal* signal, HostRecord * ahostptr); + void sendCommitLqh(Signal* signal, + TcConnectRecord * const regTcPtr); + void sendCompleteLqh(Signal* signal, + TcConnectRecord * const regTcPtr); + void sendTCKEY_FAILREF(Signal* signal, const ApiConnectRecord *); + void sendTCKEY_FAILCONF(Signal* signal, const ApiConnectRecord *); + void checkStartTimeout(Signal* signal); + void checkStartFragTimeout(Signal* signal); + void timeOutFoundFragLab(Signal* signal, Uint32 TscanConPtr); + void timeOutLoopStartFragLab(Signal* signal, Uint32 TscanConPtr); + int releaseAndAbort(Signal* signal); + void findApiConnectFail(Signal* signal); + void findTcConnectFail(Signal* signal); + void initApiConnectFail(Signal* signal); + void initTcConnectFail(Signal* signal); + void initTcFail(Signal* signal); + void releaseTakeOver(Signal* signal); + void setupFailData(Signal* signal); + void updateApiStateFail(Signal* signal); + void updateTcStateFail(Signal* signal); + void handleApiFailState(Signal* signal, UintR anApiConnectptr); + void handleFailedApiNode(Signal* signal, + UintR aFailedNode, + UintR anApiConnectPtr); + void handleScanStop(Signal* signal, UintR aFailedNode); + void initScanTcrec(Signal* signal); + void initScanApirec(Signal* signal, + Uint32 buddyPtr, + UintR transid1, + UintR transid2); + void initScanOprec(Signal* signal); + void initScanrec(Signal* signal, + const UintR scanParallel, + const UintR noOprecPerFrag); + void initScanfragrec(Signal* signal); + void releaseScanrec(Signal* signal); + void releaseScanResources(Signal* signal); + void releaseScanFragrec(Signal* signal); + void releaseScanOprec(Signal* signal); + void seizeScanrec(Signal* signal); + void seizeScanFragrec(Signal* signal); + void seizeScanOprec(Signal* signal); + void sendScanFragReq(Signal* signal); + void sendScanTabConf(Signal* signal); + void sendScanProcConf(Signal* signal); + void setScanReceived(Signal* signal, Uint32 noCompletedOps); + + void checkGcp(Signal* signal); + void commitGciHandling(Signal* signal, UintR Tgci); + void copyApi(Signal* signal); + void DIVER_node_fail_handling(Signal* signal, UintR Tgci); + void gcpTcfinished(Signal* signal); + void handleGcp(Signal* signal); + void hash(Signal* signal); + void initApiConnect(Signal* signal); + void initApiConnectRec(Signal* signal, + ApiConnectRecord * const regApiPtr, + bool releaseIndexOperations = false); + void initattrbuf(Signal* signal); + void initdatabuf(Signal* signal); + void initgcp(Signal* signal); + void inithost(Signal* signal); + void initialiseScanrec(Signal* signal); + void initialiseScanFragrec(Signal* signal); + void initialiseScanOprec(Signal* signal); + void initTable(Signal* signal); + void initialiseTcConnect(Signal* signal); + void linkApiToGcp(Signal* signal); + void linkGciInGcilist(Signal* signal); + void linkKeybuf(Signal* signal); + void linkTcInConnectionlist(Signal* signal); + void releaseAbortResources(Signal* signal); + void releaseApiCon(Signal* signal, UintR aApiConnectPtr); + void releaseApiConCopy(Signal* signal); + void releaseApiConnectFail(Signal* signal); + void releaseAttrinfo(Signal* signal); + void releaseGcp(Signal* signal); + void releaseKeys(Signal* signal); + void releaseSimpleRead(Signal* signal); + void releaseDirtyWrite(Signal* signal); + void releaseTcCon(Signal* signal); + void releaseTcConnectFail(Signal* signal); + void releaseTransResources(Signal* signal); + void saveAttrbuf(Signal* signal); + void seizeApiConnect(Signal* signal); + void seizeApiConnectCopy(Signal* signal); + void seizeApiConnectFail(Signal* signal); + void seizeDatabuf(Signal* signal); + void seizeGcp(Signal* signal); + void seizeTcConnect(Signal* signal); + void seizeTcConnectFail(Signal* signal); + void sendApiCommit(Signal* signal); + void sendAttrinfo(Signal* signal, + UintR TattrinfoPtr, + AttrbufRecord * const regAttrPtr, + UintR TBref); + void sendContinueTimeOutControl(Signal* signal, Uint32 TapiConPtr); + void sendInitialiseRecords(Signal* signal, UintR Tnext); + void sendKeyinfo(Signal* signal, BlockReference TBRef, Uint32 len); + void sendlqhkeyreq(Signal* signal, BlockReference TBRef); + void sendSystemError(Signal* signal); + void sendtckeyconf(Signal* signal, UintR TcommitFlag); + void sendTcIndxConf(Signal* signal, UintR TcommitFlag); + void unlinkApiConnect(Signal* signal); + void unlinkGcp(Signal* signal); + void unlinkReadyTcCon(Signal* signal); + void handleFailedOperation(Signal* signal, + const LqhKeyRef * const lqhKeyRef, + bool gotLqhKeyRef); + void markOperationAborted(ApiConnectRecord * const regApiPtr, + TcConnectRecord * const regTcPtr); + void clearCommitAckMarker(ApiConnectRecord * const regApiPtr, + TcConnectRecord * const regTcPtr); + // Trigger and index handling + bool saveINDXKEYINFO(Signal* signal, + TcIndexOperation* indexOp, + const Uint32 *src, + Uint32 len); + bool receivedAllINDXKEYINFO(TcIndexOperation* indexOp); + bool saveINDXATTRINFO(Signal* signal, + TcIndexOperation* indexOp, + const Uint32 *src, + Uint32 len); + bool receivedAllINDXATTRINFO(TcIndexOperation* indexOp); + bool saveTRANSID_AI(Signal* signal, + TcIndexOperation* indexOp, + const Uint32 *src, + Uint32 len); + bool receivedAllTRANSID_AI(TcIndexOperation* indexOp); + void readIndexTable(Signal* signal, + ApiConnectRecord* regApiPtr, + TcIndexOperation* indexOp); + void executeIndexOperation(Signal* signal, + ApiConnectRecord* regApiPtr, + TcIndexOperation* indexOp); + bool seizeIndexOperation(ApiConnectRecord* regApiPtr, + TcIndexOperationPtr& indexOpPtr); + void releaseIndexOperation(ApiConnectRecord* regApiPtr, + TcIndexOperation* indexOp); + void releaseAllSeizedIndexOperations(ApiConnectRecord* regApiPtr); + void setupIndexOpReturn(ApiConnectRecord* regApiPtr, + TcConnectRecord* regTcPtr); + + void saveTriggeringOpState(Signal* signal, + TcConnectRecord* trigOp); + void restoreTriggeringOpState(Signal* signal, + TcConnectRecord* trigOp); + void continueTriggeringOp(Signal* signal, + TcConnectRecord* trigOp); + + void scheduleFiredTrigger(ApiConnectRecordPtr* transPtr, + TcConnectRecordPtr* opPtr); + void executeTriggers(Signal* signal, ApiConnectRecordPtr* transPtr); + void executeTrigger(Signal* signal, + TcFiredTriggerData* firedTriggerData, + ApiConnectRecordPtr* transPtr, + TcConnectRecordPtr* opPtr); + void executeIndexTrigger(Signal* signal, + TcDefinedTriggerData* definedTriggerData, + TcFiredTriggerData* firedTriggerData, + ApiConnectRecordPtr* transPtr, + TcConnectRecordPtr* opPtr); + void insertIntoIndexTable(Signal* signal, + TcFiredTriggerData* firedTriggerData, + ApiConnectRecordPtr* transPtr, + TcConnectRecordPtr* opPtr, + TcIndexData* indexData, + bool holdOperation = false); + void deleteFromIndexTable(Signal* signal, + TcFiredTriggerData* firedTriggerData, + ApiConnectRecordPtr* transPtr, + TcConnectRecordPtr* opPtr, + TcIndexData* indexData, + bool holdOperation = false); + void releaseFiredTriggerData(DLFifoList* triggers); + // Generated statement blocks + void warningHandlerLab(Signal* signal); + void systemErrorLab(Signal* signal); + void sendSignalErrorRefuseLab(Signal* signal); + void scanTabRefLab(Signal* signal, Uint32 errCode); + void diFcountReqLab(Signal* signal); + void signalErrorRefuseLab(Signal* signal); + void abort080Lab(Signal* signal); + void packKeyData000Lab(Signal* signal, BlockReference TBRef); + void abortScanLab(Signal* signal, Uint32 errCode); + void sendAbortedAfterTimeout(Signal* signal, int Tcheck); + void abort010Lab(Signal* signal); + void abort015Lab(Signal* signal); + void packLqhkeyreq(Signal* signal, BlockReference TBRef); + void packLqhkeyreq040Lab(Signal* signal, + UintR anAttrBufIndex, + BlockReference TBRef); + void packLqhkeyreq040Lab(Signal* signal); + void returnFromQueuedDeliveryLab(Signal* signal); + void startTakeOverLab(Signal* signal); + void toCompleteHandlingLab(Signal* signal); + void toCommitHandlingLab(Signal* signal); + void toAbortHandlingLab(Signal* signal); + void abortErrorLab(Signal* signal); + void nodeTakeOverCompletedLab(Signal* signal); + void ndbsttorry010Lab(Signal* signal); + void commit020Lab(Signal* signal); + void complete010Lab(Signal* signal); + void releaseAtErrorLab(Signal* signal); + void seizeDatabuferrorLab(Signal* signal); + void scanAttrinfoLab(Signal* signal, UintR Tlen); + void seizeAttrbuferrorLab(Signal* signal); + void attrinfoDihReceivedLab(Signal* signal); + void aiErrorLab(Signal* signal); + void attrinfo020Lab(Signal* signal); + void scanReleaseResourcesLab(Signal* signal); + void scanCompletedLab(Signal* signal); + void scanFragError(Signal* signal, Uint32 errorCode); + void diverify010Lab(Signal* signal); + void returnInitialiseRecordsLab(Signal* signal); + void intstartphase2x010Lab(Signal* signal); + void intstartphase3x010Lab(Signal* signal); + void sttorryLab(Signal* signal); + void abortBeginErrorLab(Signal* signal); + void tabStateErrorLab(Signal* signal); + void wrongSchemaVersionErrorLab(Signal* signal); + void noFreeConnectionErrorLab(Signal* signal); + void tckeyreq050Lab(Signal* signal); + void timeOutFoundLab(Signal* signal, UintR anAdd); + void completeTransAtTakeOverLab(Signal* signal, UintR TtakeOverInd); + void completeTransAtTakeOverDoLast(Signal* signal, UintR TtakeOverInd); + void completeTransAtTakeOverDoOne(Signal* signal, UintR TtakeOverInd); + void timeOutLoopStartLab(Signal* signal, Uint32 apiConnectPtr); + void initialiseRecordsLab(Signal* signal, UintR Tdata0); + void tckeyreq020Lab(Signal* signal); + void intstartphase2x020Lab(Signal* signal); + void intstartphase1x010Lab(Signal* signal); + void startphase1x010Lab(Signal* signal); + + void lqhKeyConf_checkTransactionState(Signal * signal, + ApiConnectRecord * const regApiPtr); + + void checkDropTab(Signal* signal); + + void checkScanActiveInFailedLqh(Signal* signal, + Uint32 scanPtrI, + Uint32 failedNodeId); + + // Initialisation + void initData(); + void initRecords(); + + // Transit signals + + + ApiConnectRecord *apiConnectRecord; + ApiConnectRecordPtr apiConnectptr; + UintR capiConnectFilesize; + + TcConnectRecord *tcConnectRecord; + TcConnectRecordPtr tcConnectptr; + UintR ctcConnectFilesize; + + CacheRecord *cacheRecord; + CacheRecordPtr cachePtr; + UintR ccacheFilesize; + + AttrbufRecord *attrbufRecord; + AttrbufRecordPtr attrbufptr; + UintR cattrbufFilesize; + + HostRecord *hostRecord; + HostRecordPtr hostptr; + UintR chostFilesize; + + GcpRecord *gcpRecord; + GcpRecordPtr gcpPtr; + UintR cgcpFilesize; + + TableRecord *tableRecord; + UintR ctabrecFilesize; + + UintR thashValue; + UintR tdistrHashValue; + + UintR ttransid_ptr; + UintR cfailure_nr; + UintR coperationsize; + UintR ctcTimer; + + ApiConnectRecordPtr tmpApiConnectptr; + UintR tcheckGcpId; + UintR cconcurrentOp; + + UintR cattrinfoCount; + UintR ctransCount; + UintR ccommitCount; + UintR creadCount; + + UintR csimpleReadCount; + UintR cwriteCount; + UintR cabortCount; + Uint16 cownNodeid; + Uint16 terrorCode; + + UintR cfirstfreeAttrbuf; + UintR cfirstfreeTcConnect; + UintR cfirstfreeApiConnectCopy; + UintR cfirstfreeCacheRec; + + UintR cfirstgcp; + UintR clastgcp; + UintR cfirstfreeGcp; + UintR cfirstfreeScanrec; + + TableRecordPtr tabptr; + UintR cfirstfreeApiConnectFail; + UintR cfirstfreeApiConnect; + + UintR cfirstfreeDatabuf; + BlockReference cdihblockref; + BlockReference cownref; /* OWN BLOCK REFERENCE */ + + ApiConnectRecordPtr timeOutptr; + + ScanRecord *scanRecord; + ScanRecordPtr scanptr; + UintR cscanrecFileSize; + + ScanOperationRecord *scanOperationRecord; + ScanOperationRecordPtr scanOpptr; + UintR cscanOprecFileSize; + + ScanFragRec *scanFragmentRecord; + ScanFragRecPtr scanFragptr; + UintR cscanFragrecFileSize; + + UintR cfirstfreeScanOprec; + UintR cnoFreeScanOprec; + UintR cfirstfreeScanFragrec; + UintR cdatabufFilesize; + + BlockReference cdictblockref; + BlockReference cerrorBlockref; + BlockReference clqhblockref; + BlockReference cndbcntrblockref; + + Uint16 csignalKey; + Uint16 csystemnodes; + Uint16 cnodes[4]; + NodeId cmasterNodeId; + UintR cnoParallelTakeOver; + TimeOutCheckState ctimeOutCheckFragActive; + + UintR ctimeOutCheckFragCounter; + UintR ctimeOutCheckCounter; + UintR ctimeOutValue; + UintR ctimeOutCheckDelay; + Uint32 ctimeOutCheckHeartbeat; + Uint32 ctimeOutCheckLastHeartbeat; + Uint32 ctimeOutMissedHeartbeats; + Uint32 c_appl_timeout_value; + + SystemStartState csystemStart; + TimeOutCheckState ctimeOutCheckActive; + + BlockReference capiFailRef; + UintR cpackedListIndex; + Uint16 cpackedList[MAX_NODES]; + UintR capiConnectClosing[MAX_NODES]; + UintR con_lineNodes; + + DatabufRecord *databufRecord; + DatabufRecordPtr databufptr; + DatabufRecordPtr tmpDatabufptr; + + UintR treqinfo; + UintR ttransid1; + UintR ttransid2; + + UintR tabortInd; + + NodeId tnodeid; + BlockReference tblockref; + + LqhTransConf::OperationStatus ttransStatus; + UintR ttcOprec; + NodeId tfailedNodeId; + Uint8 tcurrentReplicaNo; + Uint8 tpad1; + + UintR tgci; + UintR tapplRef; + UintR tapplOprec; + + UintR tindex; + UintR tmaxData; + UintR tmp; + + UintR tnodes; + BlockReference tusersblkref; + UintR tuserpointer; + UintR tloadCode; + + UintR tconfig1; + UintR tconfig2; + + UintR cdata[32]; + UintR ctransidFailHash[512]; + UintR ctcConnectFailHash[1024]; + + /** + * Commit Ack handling + */ +public: + struct CommitAckMarker { + Uint32 transid1; + Uint32 transid2; + union { Uint32 nextPool; Uint32 nextHash; }; + Uint32 prevHash; + Uint32 apiConnectPtr; + Uint16 apiNodeId; + Uint16 noOfLqhs; + Uint16 lqhNodeId[MAX_REPLICAS]; + + inline bool equal(const CommitAckMarker & p) const { + return ((p.transid1 == transid1) && (p.transid2 == transid2)); + } + + inline Uint32 hashValue() const { + return transid1; + } + }; +private: + typedef Ptr CommitAckMarkerPtr; + typedef DLHashTable::Iterator CommitAckMarkerIterator; + + ArrayPool m_commitAckMarkerPool; + DLHashTable m_commitAckMarkerHash; + + void execTC_COMMIT_ACK(Signal* signal); + void sendRemoveMarkers(Signal*, const CommitAckMarker *); + void sendRemoveMarker(Signal* signal, + NodeId nodeId, + Uint32 transid1, + Uint32 transid2); + void removeMarkerForFailedAPI(Signal* signal, Uint32 nodeId, Uint32 bucket); + + bool getAllowStartTransaction() const { + if(getNodeState().getSingleUserMode()) + return true; + return getNodeState().startLevel < NodeState::SL_STOPPING_2; + } + + void checkAbortAllTimeout(Signal* signal, Uint32 sleepTime); + struct AbortAllRecord { + AbortAllRecord(){ clientRef = 0; } + Uint32 clientData; + BlockReference clientRef; + + Uint32 oldTimeOutValue; + }; + AbortAllRecord c_abortRec; + + /************************** API CONNECT RECORD ***********************/ + /* *******************************************************************/ + /* THE API CONNECT RECORD CONTAINS THE CONNECTION RECORD TO WHICH THE*/ + /* APPLICATION CONNECTS. THE APPLICATION CAN SEND ONE OPERATION AT A */ + /* TIME. IT CAN SEND A NEW OPERATION IMMEDIATELY AFTER SENDING THE */ + /* PREVIOUS OPERATION. THEREBY SEVERAL OPERATIONS CAN BE ACTIVE IN */ + /* ONE TRANSACTION WITHIN TC. THIS IS ACHIEVED BY USING THE API */ + /* CONNECT RECORD. EACH ACTIVE OPERATION IS HANDLED BY THE TC */ + /* CONNECT RECORD. AS SOON AS THE TC CONNECT RECORD HAS SENT THE */ + /* REQUEST TO THE LQH IT IS READY TO RECEIVE NEW OPERATIONS. THE */ + /* LQH CONNECT RECORD TAKES CARE OF WAITING FOR AN OPERATION TO */ + /* COMPLETE. WHEN AN OPERATION HAS COMPLETED ON THE LQH CONNECT */ + /* RECORD A NEW OPERATION CAN BE STARTED ON THIS LQH CONNECT RECORD. */ + /*******************************************************************>*/ + /* */ + /* API CONNECT RECORD ALIGNED TO BE 256 BYTES */ + /*******************************************************************>*/ + /************************** TC CONNECT RECORD ************************/ + /* *******************************************************************/ + /* TC CONNECT RECORD KEEPS ALL INFORMATION TO CARRY OUT A TRANSACTION*/ + /* THE TRANSACTION CONTROLLER ESTABLISHES CONNECTIONS TO DIFFERENT */ + /* BLOCKS TO CARRY OUT THE TRANSACTION. THERE CAN BE SEVERAL RECORDS */ + /* PER ACTIVE TRANSACTION. THE TC CONNECT RECORD COOPERATES WITH THE */ + /* API CONNECT RECORD FOR COMMUNICATION WITH THE API AND WITH THE */ + /* LQH CONNECT RECORD FOR COMMUNICATION WITH THE LQH'S INVOLVED IN */ + /* THE TRANSACTION. TC CONNECT RECORD IS PERMANENTLY CONNECTED TO A */ + /* RECORD IN DICT AND ONE IN DIH. IT CONTAINS A LIST OF ACTIVE LQH */ + /* CONNECT RECORDS AND A LIST OF STARTED BUT NOT ACTIVE LQH CONNECT */ + /* RECORDS. IT DOES ALSO CONTAIN A LIST OF ALL OPERATIONS THAT ARE */ + /* EXECUTED WITH THE TC CONNECT RECORD. */ + /*******************************************************************>*/ + /* TC_CONNECT RECORD ALIGNED TO BE 128 BYTES */ + /*******************************************************************>*/ + UintR cfirstfreeTcConnectFail; + + /* POINTER FOR THE LQH RECORD*/ + /* ************************ HOST RECORD ********************************* */ + /********************************************************/ + /* THIS RECORD CONTAINS ALIVE-STATUS ON ALL NODES IN THE*/ + /* SYSTEM */ + /********************************************************/ + /* THIS RECORD IS ALIGNED TO BE 8 BYTES. */ + /********************************************************/ + /* ************************ TABLE RECORD ******************************** */ + /********************************************************/ + /* THIS RECORD CONTAINS THE CURRENT SCHEMA VERSION OF */ + /* ALL TABLES IN THE SYSTEM. */ + /********************************************************/ + /*-------------------------------------------------------------------------*/ + /* THE TC CONNECTION USED BY THIS SCAN. */ + /*-------------------------------------------------------------------------*/ + /*-------------------------------------------------------------------------*/ + /* LENGTH READ FOR A PARTICULAR SCANNED OPERATION. */ + /*-------------------------------------------------------------------------*/ + /*-------------------------------------------------------------------------*/ + /* REFERENCE TO THE SCAN RECORD FOR THIS SCAN PROCESS. */ + /*-------------------------------------------------------------------------*/ + /* *********************************************************************** */ + /* ******$ DATA BUFFER ******$ */ + /* */ + /* THIS BUFFER IS USED AS A GENERAL DATA STORAGE. */ + /* *********************************************************************** */ + /* *********************************************************************** */ + /* ******$ ATTRIBUTE INFORMATION RECORD ******$ */ + /* + CAN CONTAIN ONE (1) ATTRINFO SIGNAL. ONE SIGNAL CONTAINS 24 ATTR. + INFO WORDS. BUT 32 ELEMENTS ARE USED TO MAKE PLEX HAPPY. + SOME OF THE ELEMENTS ARE USED TO THE FOLLOWING THINGS: + DATA LENGHT IN THIS RECORD IS STORED IN THE ELEMENT INDEXED BY + ZINBUF_DATA_LEN. + NEXT FREE ATTRBUF IS POINTED OUT BY THE ELEMENT INDEXED BY + PREVIOUS ATTRBUF IS POINTED OUT BY THE ELEMENT INDEXED BY ZINBUF_PREV + (NOT USED YET). + NEXT ATTRBUF IS POINTED OUT BY THE ELEMENT INDEXED BY ZINBUF_NEXT. + */ + /* ********************************************************************** */ + /**************************************************************************/ + /* GLOBAL CHECKPOINT INFORMATION RECORD */ + /* */ + /* THIS RECORD IS USED TO STORE THE GCP NUMBER AND A COUNTER */ + /* DURING THE COMPLETION PHASE OF THE TRANSACTION */ + /**************************************************************************/ + /* */ + /* GCP RECORD ALIGNED TO BE 32 BYTES */ + /**************************************************************************/ + /**************************************************************************/ + /* TC_FAIL_RECORD */ + /* THIS RECORD IS USED WHEN HANDLING TAKE OVER OF ANOTHER FAILED TC NODE.*/ + /**************************************************************************/ + TcFailRecord *tcFailRecord; + TcFailRecordPtr tcNodeFailptr; + /**************************************************************************/ + // Temporary variables that are not allowed to use for storage between + // signals. They + // can only be used in a signal to transfer values between subroutines. + // In the long run + // those variables should be removed and exchanged for stack + // variable communication. + /**************************************************************************/ +}; +#endif diff --git a/ndb/src/kernel/blocks/dbtc/DbtcInit.cpp b/ndb/src/kernel/blocks/dbtc/DbtcInit.cpp new file mode 100644 index 00000000000..1ac5273188c --- /dev/null +++ b/ndb/src/kernel/blocks/dbtc/DbtcInit.cpp @@ -0,0 +1,357 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTC_C +#include "Dbtc.hpp" +#include +#include +#include +#include +#include + +#define DEBUG(x) { ndbout << "TC::" << x << endl; } + + +void Dbtc::initData() +{ + cattrbufFilesize = ZATTRBUF_FILESIZE; + capiConnectFilesize = ZAPI_CONNECT_FILESIZE; + ccacheFilesize = ZAPI_CONNECT_FILESIZE; + chostFilesize = MAX_NODES; + cdatabufFilesize = ZDATABUF_FILESIZE; + cgcpFilesize = ZGCP_FILESIZE; + cscanrecFileSize = ZSCANREC_FILE_SIZE; + cscanFragrecFileSize = ZSCAN_FRAGREC_FILE_SIZE; + cscanOprecFileSize = ZSCAN_OPREC_FILE_SIZE; + ctabrecFilesize = ZTABREC_FILESIZE; + ctcConnectFilesize = ZTC_CONNECT_FILESIZE; + cdihblockref = DBDIH_REF; + cdictblockref = DBDICT_REF; + clqhblockref = DBLQH_REF; + cerrorBlockref = NDBCNTR_REF; + + cacheRecord = 0; + apiConnectRecord = 0; + tcConnectRecord = 0; + hostRecord = 0; + tableRecord = 0; + scanRecord = 0; + scanOperationRecord = 0; + scanFragmentRecord = 0; + databufRecord = 0; + attrbufRecord = 0; + gcpRecord = 0; + tcFailRecord = 0; + c_apiConTimer = 0; + c_apiConTimer_line = 0; + // Records with constant sizes + tcFailRecord = (TcFailRecord*)allocRecord("TcFailRecord", + sizeof(TcFailRecord), 1); + + // Variables + ctcTimer = 0; + + // Trigger and index pools + c_theDefinedTriggerPool.setSize(c_maxNumberOfDefinedTriggers); + c_theFiredTriggerPool.setSize(c_maxNumberOfFiredTriggers); + c_theIndexPool.setSize(c_maxNumberOfIndexes); + c_theIndexOperationPool.setSize(c_maxNumberOfIndexOperations); + c_theSeizedIndexOperationPool.setSize(c_maxNumberOfIndexOperations); + c_theAttributeBufferPool.setSize(c_transactionBufferSpace); +}//Dbtc::initData() + +void Dbtc::initRecords() +{ + // Records with dynamic sizes + cacheRecord = (CacheRecord*)allocRecord("CacheRecord", + sizeof(CacheRecord), + ccacheFilesize); + + apiConnectRecord = (ApiConnectRecord*)allocRecord("ApiConnectRecord", + sizeof(ApiConnectRecord), + capiConnectFilesize); + + for(unsigned i = 0; i triggers(c_theFiredTriggerPool); + FiredTriggerPtr tptr; + while(triggers.seize(tptr) == true) { + new (tptr.p) TcFiredTriggerData(c_theAttributeBufferPool); + } + triggers.release(); + + /* + // Init all index records + ArrayList indexes(c_theIndexPool); + TcIndexDataPtr iptr; + while(indexes.seize(iptr) == true) { + new (iptr.p) TcIndexData(c_theAttrInfoListPool); + } + indexes.release(); + */ + + // Init all index operation records + ArrayList indexOps(c_theIndexOperationPool); + TcIndexOperationPtr ioptr; + while(indexOps.seize(ioptr) == true) { + new (ioptr.p) TcIndexOperation(c_theAttributeBufferPool); + } + indexOps.release(); + + c_apiConTimer = (UintR*)allocRecord("ApiConTimer", + sizeof(UintR), + capiConnectFilesize); + + c_apiConTimer_line = (UintR*)allocRecord("ApiConTimer_line", + sizeof(UintR), + capiConnectFilesize); + + tcConnectRecord = (TcConnectRecord*)allocRecord("TcConnectRecord", + sizeof(TcConnectRecord), + ctcConnectFilesize); + + m_commitAckMarkerPool.setSize(capiConnectFilesize); + m_commitAckMarkerHash.setSize(512); + + hostRecord = (HostRecord*)allocRecord("HostRecord", + sizeof(HostRecord), + chostFilesize); + + tableRecord = (TableRecord*)allocRecord("TableRecord", + sizeof(TableRecord), + ctabrecFilesize); + + scanRecord = (ScanRecord*)allocRecord("ScanRecord", + sizeof(ScanRecord), + cscanrecFileSize); + + scanOperationRecord = (ScanOperationRecord*) + allocRecord("ScanOperationRecord", + sizeof(ScanOperationRecord), + cscanOprecFileSize); + + scanFragmentRecord = (ScanFragRec*) + allocRecord("ScanFragRec", + sizeof(ScanFragRec), + cscanFragrecFileSize); + + databufRecord = (DatabufRecord*)allocRecord("DatabufRecord", + sizeof(DatabufRecord), + cdatabufFilesize); + + attrbufRecord = (AttrbufRecord*)allocRecord("AttrbufRecord", + sizeof(AttrbufRecord), + cattrbufFilesize); + + gcpRecord = (GcpRecord*)allocRecord("GcpRecord", + sizeof(GcpRecord), + cgcpFilesize); + +}//Dbtc::initRecords() + +Dbtc::Dbtc(const class Configuration & conf): + SimulatedBlock(DBTC, conf), + c_theDefinedTriggers(c_theDefinedTriggerPool), + c_maxNumberOfDefinedTriggers(0), + c_maxNumberOfFiredTriggers(0), + c_theIndexes(c_theIndexPool), + c_maxNumberOfIndexes(0), + c_theIndexOperations(c_theIndexOperationPool), + c_maxNumberOfIndexOperations(0), + m_commitAckMarkerHash(m_commitAckMarkerPool) +{ + + BLOCK_CONSTRUCTOR(Dbtc); + + const Properties * p = conf.getOwnProperties(); + ndbrequire(p != 0); + + Uint32 transactionBufferMemory = 0; + Uint32 maxNoOfIndexes = 0, maxNoOfConcurrentIndexOperations = 0; + Uint32 maxNoOfTriggers = 0, maxNoOfFiredTriggers = 0; + + p->get("TransactionBufferMemory", &transactionBufferMemory); + p->get("MaxNoOfIndexes", &maxNoOfIndexes); + p->get("MaxNoOfConcurrentIndexOperations", &maxNoOfConcurrentIndexOperations); + p->get("MaxNoOfTriggers", &maxNoOfTriggers); + p->get("MaxNoOfFiredTriggers", &maxNoOfFiredTriggers); + + c_transactionBufferSpace = + transactionBufferMemory / AttributeBuffer::getSegmentSize(); + c_maxNumberOfIndexes = maxNoOfIndexes; + c_maxNumberOfIndexOperations = maxNoOfConcurrentIndexOperations; + c_maxNumberOfDefinedTriggers = maxNoOfTriggers; + c_maxNumberOfFiredTriggers = maxNoOfFiredTriggers; + + // Transit signals + addRecSignal(GSN_PACKED_SIGNAL, &Dbtc::execPACKED_SIGNAL); + addRecSignal(GSN_ABORTED, &Dbtc::execABORTED); + addRecSignal(GSN_ATTRINFO, &Dbtc::execATTRINFO); + addRecSignal(GSN_CONTINUEB, &Dbtc::execCONTINUEB); + addRecSignal(GSN_KEYINFO, &Dbtc::execKEYINFO); + addRecSignal(GSN_SCAN_TABINFO, &Dbtc::execSCAN_TABINFO); + addRecSignal(GSN_SCAN_NEXTREQ, &Dbtc::execSCAN_NEXTREQ); + addRecSignal(GSN_SCAN_PROCREQ, &Dbtc::execSCAN_PROCREQ); + addRecSignal(GSN_SCAN_PROCCONF, &Dbtc::execSCAN_PROCCONF); + addRecSignal(GSN_TAKE_OVERTCREQ, &Dbtc::execTAKE_OVERTCREQ); + addRecSignal(GSN_TAKE_OVERTCCONF, &Dbtc::execTAKE_OVERTCCONF); + addRecSignal(GSN_LQHKEYREF, &Dbtc::execLQHKEYREF); + + // Received signals + + addRecSignal(GSN_DUMP_STATE_ORD, &Dbtc::execDUMP_STATE_ORD); + addRecSignal(GSN_SEND_PACKED, &Dbtc::execSEND_PACKED); + addRecSignal(GSN_SCAN_HBREP, &Dbtc::execSCAN_HBREP); + addRecSignal(GSN_COMPLETED, &Dbtc::execCOMPLETED); + addRecSignal(GSN_COMMITTED, &Dbtc::execCOMMITTED); + addRecSignal(GSN_DIGETPRIMCONF, &Dbtc::execDIGETPRIMCONF); + addRecSignal(GSN_DIGETPRIMREF, &Dbtc::execDIGETPRIMREF); + addRecSignal(GSN_DISEIZECONF, &Dbtc::execDISEIZECONF); + addRecSignal(GSN_DIVERIFYCONF, &Dbtc::execDIVERIFYCONF); + addRecSignal(GSN_DI_FCOUNTCONF, &Dbtc::execDI_FCOUNTCONF); + addRecSignal(GSN_DI_FCOUNTREF, &Dbtc::execDI_FCOUNTREF); + addRecSignal(GSN_GCP_NOMORETRANS, &Dbtc::execGCP_NOMORETRANS); + addRecSignal(GSN_LQHKEYCONF, &Dbtc::execLQHKEYCONF); + addRecSignal(GSN_NDB_STTOR, &Dbtc::execNDB_STTOR); + addRecSignal(GSN_READ_NODESCONF, &Dbtc::execREAD_NODESCONF); + addRecSignal(GSN_READ_NODESREF, &Dbtc::execREAD_NODESREF); + addRecSignal(GSN_STTOR, &Dbtc::execSTTOR); + addRecSignal(GSN_TC_COMMITREQ, &Dbtc::execTC_COMMITREQ); + addRecSignal(GSN_TC_CLOPSIZEREQ, &Dbtc::execTC_CLOPSIZEREQ); + addRecSignal(GSN_TCGETOPSIZEREQ, &Dbtc::execTCGETOPSIZEREQ); + addRecSignal(GSN_TCKEYREQ, &Dbtc::execTCKEYREQ); + addRecSignal(GSN_TCRELEASEREQ, &Dbtc::execTCRELEASEREQ); + addRecSignal(GSN_TCSEIZEREQ, &Dbtc::execTCSEIZEREQ); + addRecSignal(GSN_TCROLLBACKREQ, &Dbtc::execTCROLLBACKREQ); + addRecSignal(GSN_TC_HBREP, &Dbtc::execTC_HBREP); + addRecSignal(GSN_TC_SCHVERREQ, &Dbtc::execTC_SCHVERREQ); + addRecSignal(GSN_SCAN_TABREQ, &Dbtc::execSCAN_TABREQ); + addRecSignal(GSN_SCAN_FRAGCONF, &Dbtc::execSCAN_FRAGCONF); + addRecSignal(GSN_SCAN_FRAGREF, &Dbtc::execSCAN_FRAGREF); + addRecSignal(GSN_SIZEALT_REP, &Dbtc::execSIZEALT_REP); + addRecSignal(GSN_LQH_TRANSCONF, &Dbtc::execLQH_TRANSCONF); + addRecSignal(GSN_COMPLETECONF, &Dbtc::execCOMPLETECONF); + addRecSignal(GSN_COMMITCONF, &Dbtc::execCOMMITCONF); + addRecSignal(GSN_ABORTCONF, &Dbtc::execABORTCONF); + addRecSignal(GSN_NODE_FAILREP, &Dbtc::execNODE_FAILREP); + addRecSignal(GSN_INCL_NODEREQ, &Dbtc::execINCL_NODEREQ); + addRecSignal(GSN_TIME_SIGNAL, &Dbtc::execTIME_SIGNAL); + addRecSignal(GSN_API_FAILREQ, &Dbtc::execAPI_FAILREQ); + addRecSignal(GSN_SET_VAR_REQ, &Dbtc::execSET_VAR_REQ); + + addRecSignal(GSN_TC_COMMIT_ACK, &Dbtc::execTC_COMMIT_ACK); + addRecSignal(GSN_ABORT_ALL_REQ, &Dbtc::execABORT_ALL_REQ); + + addRecSignal(GSN_CREATE_TRIG_REQ, &Dbtc::execCREATE_TRIG_REQ); + addRecSignal(GSN_DROP_TRIG_REQ, &Dbtc::execDROP_TRIG_REQ); + addRecSignal(GSN_FIRE_TRIG_ORD, &Dbtc::execFIRE_TRIG_ORD); + addRecSignal(GSN_TRIG_ATTRINFO, &Dbtc::execTRIG_ATTRINFO); + + addRecSignal(GSN_CREATE_INDX_REQ, &Dbtc::execCREATE_INDX_REQ); + addRecSignal(GSN_DROP_INDX_REQ, &Dbtc::execDROP_INDX_REQ); + addRecSignal(GSN_TCINDXREQ, &Dbtc::execTCINDXREQ); + addRecSignal(GSN_INDXKEYINFO, &Dbtc::execINDXKEYINFO); + addRecSignal(GSN_INDXATTRINFO, &Dbtc::execINDXATTRINFO); + addRecSignal(GSN_ALTER_INDX_REQ, &Dbtc::execALTER_INDX_REQ); + + addRecSignal(GSN_TRANSID_AI_R, &Dbtc::execTRANSID_AI_R); + addRecSignal(GSN_KEYINFO20_R, &Dbtc::execKEYINFO20_R); + + // Index table lookup + addRecSignal(GSN_TCKEYCONF, &Dbtc::execTCKEYCONF); + addRecSignal(GSN_TCKEYREF, &Dbtc::execTCKEYREF); + addRecSignal(GSN_TRANSID_AI, &Dbtc::execTRANSID_AI); + addRecSignal(GSN_TCROLLBACKREP, &Dbtc::execTCROLLBACKREP); + + //addRecSignal(GSN_CREATE_TAB_REQ, &Dbtc::execCREATE_TAB_REQ); + addRecSignal(GSN_DROP_TAB_REQ, &Dbtc::execDROP_TAB_REQ); + addRecSignal(GSN_PREP_DROP_TAB_REQ, &Dbtc::execPREP_DROP_TAB_REQ); + addRecSignal(GSN_WAIT_DROP_TAB_CONF, &Dbtc::execWAIT_DROP_TAB_CONF); + + addRecSignal(GSN_ALTER_TAB_REQ, &Dbtc::execALTER_TAB_REQ); + + initData(); +}//Dbtc::Dbtc() + +Dbtc::~Dbtc() +{ + // Records with dynamic sizes + deallocRecord((void **)&cacheRecord, "CacheRecord", + sizeof(CacheRecord), + ccacheFilesize); + + deallocRecord((void **)&apiConnectRecord, "ApiConnectRecord", + sizeof(ApiConnectRecord), + capiConnectFilesize); + + deallocRecord((void **)&tcConnectRecord, "TcConnectRecord", + sizeof(TcConnectRecord), + ctcConnectFilesize); + + deallocRecord((void **)&hostRecord, "HostRecord", + sizeof(HostRecord), + chostFilesize); + + deallocRecord((void **)&tableRecord, "TableRecord", + sizeof(TableRecord), + ctabrecFilesize); + + deallocRecord((void **)&scanRecord, "ScanRecord", + sizeof(ScanRecord), + cscanrecFileSize); + + deallocRecord((void **)&scanOperationRecord, + "ScanOperationRecord", + sizeof(ScanOperationRecord), + cscanOprecFileSize); + + deallocRecord((void **)&scanFragmentRecord, + "ScanFragRec", + sizeof(ScanFragRec), + cscanFragrecFileSize); + + deallocRecord((void **)&databufRecord, "DatabufRecord", + sizeof(DatabufRecord), + cdatabufFilesize); + + deallocRecord((void **)&attrbufRecord, "AttrbufRecord", + sizeof(AttrbufRecord), + cattrbufFilesize); + + deallocRecord((void **)&gcpRecord, "GcpRecord", + sizeof(GcpRecord), + cgcpFilesize); + + deallocRecord((void **)&tcFailRecord, "TcFailRecord", + sizeof(TcFailRecord), 1); + + deallocRecord((void **)&c_apiConTimer, "ApiConTimer", + sizeof(UintR), + capiConnectFilesize); + + deallocRecord((void **)&c_apiConTimer_line, "ApiConTimer", + sizeof(UintR), + capiConnectFilesize); +}//Dbtc::~Dbtc() + +BLOCK_FUNCTIONS(Dbtc); + + + diff --git a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp new file mode 100644 index 00000000000..ac8a130eb83 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp @@ -0,0 +1,13111 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTC_C + +#include "Dbtc.hpp" +#include "md5_hash.hpp" +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +// Use DEBUG to print messages that should be +// seen only when we debug the product +#ifdef VM_TRACE +#define DEBUG(x) ndbout << "DBTC: "<< x << endl; +#else +#define DEBUG(x) +#endif + +#define INTERNAL_TRIGGER_TCKEYREQ_JBA 0 + +void +Dbtc::updateBuddyTimer(ApiConnectRecordPtr apiPtr) +{ + if (apiPtr.p->buddyPtr != RNIL) { + jam(); + ApiConnectRecordPtr buddyApiPtr; + buddyApiPtr.i = apiPtr.p->buddyPtr; + ptrCheckGuard(buddyApiPtr, capiConnectFilesize, apiConnectRecord); + if (getApiConTimer(buddyApiPtr.i) != 0) { + if ((apiPtr.p->transid[0] == buddyApiPtr.p->transid[0]) && + (apiPtr.p->transid[1] == buddyApiPtr.p->transid[1])) { + jam(); + setApiConTimer(buddyApiPtr.i, ctcTimer, __LINE__); + } else { + jam(); + // Not a buddy anymore since not the same transid + apiPtr.p->buddyPtr = RNIL; + }//if + }//if + }//if +} + +void Dbtc::execCONTINUEB(Signal* signal) +{ + UintR tcase; + + jamEntry(); + tcase = signal->theData[0]; + UintR Tdata0 = signal->theData[1]; + UintR Tdata1 = signal->theData[2]; + switch (tcase) { + case TcContinueB::ZRETURN_FROM_QUEUED_DELIVERY: + jam(); + scanptr.i = Tdata0; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + scanFragptr.i = Tdata1; + ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord); + ndbrequire(scanFragptr.p->scanFragState == + ScanFragRec::RETURNING_FROM_DELIVERY); + returnFromQueuedDeliveryLab(signal); + return; + case TcContinueB::ZCOMPLETE_TRANS_AT_TAKE_OVER: + jam(); + tcNodeFailptr.i = Tdata0; + ptrCheckGuard(tcNodeFailptr, 1, tcFailRecord); + completeTransAtTakeOverLab(signal, Tdata1); + return; + case TcContinueB::ZCONTINUE_TIME_OUT_CONTROL: + jam(); + timeOutLoopStartLab(signal, Tdata0); + return; + case TcContinueB::ZNODE_TAKE_OVER_COMPLETED: + jam(); + tnodeid = Tdata0; + tcNodeFailptr.i = 0; + ptrAss(tcNodeFailptr, tcFailRecord); + nodeTakeOverCompletedLab(signal); + return; + case TcContinueB::ZINITIALISE_RECORDS: + jam(); + initialiseRecordsLab(signal, Tdata0); + return; + case TcContinueB::ZSEND_COMMIT_LOOP: + jam(); + apiConnectptr.i = Tdata0; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + tcConnectptr.i = Tdata1; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + commit020Lab(signal); + return; + case TcContinueB::ZSEND_COMPLETE_LOOP: + jam(); + apiConnectptr.i = Tdata0; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + tcConnectptr.i = Tdata1; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + complete010Lab(signal); + return; + case TcContinueB::ZHANDLE_FAILED_API_NODE: + jam(); + handleFailedApiNode(signal, Tdata0, Tdata1); + return; + case TcContinueB::ZTRANS_EVENT_REP: + jam(); + /* -------------------------------------------------------------------- */ + // Report information about transaction activity once per second. + /* -------------------------------------------------------------------- */ + if (signal->theData[1] == 0) { + signal->theData[0] = EventReport::TransReportCounters; + signal->theData[1] = ctransCount; + signal->theData[2] = ccommitCount; + signal->theData[3] = creadCount; + signal->theData[4] = csimpleReadCount; + signal->theData[5] = cwriteCount; + signal->theData[6] = cattrinfoCount; + signal->theData[7] = cconcurrentOp; + signal->theData[8] = cabortCount; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 9, JBB); + }//if + ctransCount = 0; + ccommitCount = 0; + creadCount = 0; + csimpleReadCount = 0; + cwriteCount = 0; + cattrinfoCount = 0; + cabortCount = 0; + signal->theData[0] = TcContinueB::ZTRANS_EVENT_REP; + signal->theData[1] = 0; + sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 5000, 2); + return; + case TcContinueB::ZCONTINUE_TIME_OUT_FRAG_CONTROL: + jam(); + timeOutLoopStartFragLab(signal, Tdata0); + return; + case TcContinueB::ZABORT_BREAK: + jam(); + tcConnectptr.i = Tdata0; + apiConnectptr.i = Tdata1; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + apiConnectptr.p->counter--; + abort015Lab(signal); + return; + case TcContinueB::ZABORT_TIMEOUT_BREAK: + jam(); + tcConnectptr.i = Tdata0; + apiConnectptr.i = Tdata1; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + sendAbortedAfterTimeout(signal, 1); + return; + case TcContinueB::ZHANDLE_FAILED_API_NODE_REMOVE_MARKERS: + jam(); + removeMarkerForFailedAPI(signal, Tdata0, Tdata1); + return; + case TcContinueB::ZWAIT_ABORT_ALL: + jam(); + checkAbortAllTimeout(signal, Tdata0); + return; + case TcContinueB::ZCHECK_SCAN_ACTIVE_FAILED_LQH: + jam(); + checkScanActiveInFailedLqh(signal, Tdata0, Tdata1); + return; + case TcContinueB::CHECK_WAIT_DROP_TAB_FAILED_LQH: + jam(); + checkWaitDropTabFailedLqh(signal, Tdata0, Tdata1); + return; + case TcContinueB::TRIGGER_PENDING: + jam(); + ApiConnectRecordPtr transPtr; + transPtr.i = Tdata0; + ptrCheckGuard(transPtr, capiConnectFilesize, apiConnectRecord); + transPtr.p->triggerPending = false; + executeTriggers(signal, &transPtr); + return; + default: + ndbrequire(false); + }//switch +} + +void Dbtc::execDIGETNODESREF(Signal* signal) +{ + jamEntry(); + terrorCode = signal->theData[1]; + releaseAtErrorLab(signal); +} + +void Dbtc::execINCL_NODEREQ(Signal* signal) +{ + jamEntry(); + tblockref = signal->theData[0]; + hostptr.i = signal->theData[1]; + ptrCheckGuard(hostptr, chostFilesize, hostRecord); + hostptr.p->hostStatus = HS_ALIVE; + hostptr.p->takeOverStatus = TOS_IDLE; + signal->theData[0] = cownref; + sendSignal(tblockref, GSN_INCL_NODECONF, signal, 1, JBB); +} + +void Dbtc::execREAD_NODESREF(Signal* signal) +{ + jamEntry(); + ndbrequire(false); +} + +void Dbtc::execTC_SCHVERREQ(Signal* signal) +{ + jamEntry(); + tabptr.i = signal->theData[0]; + ptrCheckGuard(tabptr, ctabrecFilesize, tableRecord); + tabptr.p->currentSchemaVersion = signal->theData[1]; + tabptr.p->storedTable = (bool)signal->theData[2]; + BlockReference retRef = signal->theData[3]; + tabptr.p->tableType = (Uint8)signal->theData[4]; + BlockReference retPtr = signal->theData[5]; + + ndbrequire(tabptr.p->enabled == false); + tabptr.p->enabled = true; + tabptr.p->dropping = false; + + signal->theData[0] = tabptr.i; + signal->theData[1] = retPtr; + sendSignal(retRef, GSN_TC_SCHVERCONF, signal, 2, JBB); +}//Dbtc::execTC_SCHVERREQ() + +void +Dbtc::execPREP_DROP_TAB_REQ(Signal* signal) +{ + jamEntry(); + + PrepDropTabReq* req = (PrepDropTabReq*)signal->getDataPtr(); + + TableRecordPtr tabPtr; + tabPtr.i = req->tableId; + ptrCheckGuard(tabPtr, ctabrecFilesize, tableRecord); + + Uint32 senderRef = req->senderRef; + Uint32 senderData = req->senderData; + + if(!tabPtr.p->enabled){ + jam(); + PrepDropTabRef* ref = (PrepDropTabRef*)signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = senderData; + ref->tableId = tabPtr.i; + ref->errorCode = PrepDropTabRef::NoSuchTable; + sendSignal(senderRef, GSN_PREP_DROP_TAB_REF, signal, + PrepDropTabRef::SignalLength, JBB); + return; + } + + if(tabPtr.p->dropping){ + jam(); + PrepDropTabRef* ref = (PrepDropTabRef*)signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = senderData; + ref->tableId = tabPtr.i; + ref->errorCode = PrepDropTabRef::DropInProgress; + sendSignal(senderRef, GSN_PREP_DROP_TAB_REF, signal, + PrepDropTabRef::SignalLength, JBB); + return; + } + + tabPtr.p->dropping = true; + tabPtr.p->dropTable.senderRef = senderRef; + tabPtr.p->dropTable.senderData = senderData; + + { + WaitDropTabReq * req = (WaitDropTabReq*)signal->getDataPtrSend(); + req->tableId = tabPtr.i; + req->senderRef = reference(); + + HostRecordPtr hostPtr; + tabPtr.p->dropTable.waitDropTabCount.clearWaitingFor(); + for (hostPtr.i = 1; hostPtr.i < MAX_NDB_NODES; hostPtr.i++) { + jam(); + ptrAss(hostPtr, hostRecord); + if (hostPtr.p->hostStatus == HS_ALIVE) { + jam(); + tabPtr.p->dropTable.waitDropTabCount.setWaitingFor(hostPtr.i); + sendSignal(calcLqhBlockRef(hostPtr.i), GSN_WAIT_DROP_TAB_REQ, + signal, WaitDropTabReq::SignalLength, JBB); + }//for + }//if + + ndbrequire(tabPtr.p->dropTable.waitDropTabCount.done() != true); + } +} + +void +Dbtc::execWAIT_DROP_TAB_CONF(Signal* signal) +{ + jamEntry(); + WaitDropTabConf * conf = (WaitDropTabConf*)signal->getDataPtr(); + + TableRecordPtr tabPtr; + tabPtr.i = conf->tableId; + ptrCheckGuard(tabPtr, ctabrecFilesize, tableRecord); + + ndbrequire(tabPtr.p->dropping == true); + Uint32 nodeId = refToNode(conf->senderRef); + tabPtr.p->dropTable.waitDropTabCount.clearWaitingFor(nodeId); + + if(!tabPtr.p->dropTable.waitDropTabCount.done()){ + jam(); + return; + } + + { + PrepDropTabConf* conf = (PrepDropTabConf*)signal->getDataPtrSend(); + conf->tableId = tabPtr.i; + conf->senderRef = reference(); + conf->senderData = tabPtr.p->dropTable.senderData; + sendSignal(tabPtr.p->dropTable.senderRef, GSN_PREP_DROP_TAB_CONF, signal, + PrepDropTabConf::SignalLength, JBB); + tabPtr.p->dropTable.senderRef = 0; + } +} + +void +Dbtc::checkWaitDropTabFailedLqh(Signal* signal, Uint32 nodeId, Uint32 tableId) +{ + + TableRecordPtr tabPtr; + tabPtr.i = tableId; + + WaitDropTabConf * conf = (WaitDropTabConf*)signal->getDataPtr(); + conf->tableId = tableId; + + const Uint32 RT_BREAK = 16; + for(Uint32 i = 0; ienabled && tabPtr.p->dropping){ + if(tabPtr.p->dropTable.waitDropTabCount.isWaitingFor(nodeId)){ + jam(); + conf->senderRef = calcLqhBlockRef(nodeId); + execWAIT_DROP_TAB_CONF(signal); + tabPtr.i++; + break; + } + } + } + + if(tabPtr.i == ctabrecFilesize){ + /** + * Finished + */ + jam(); + return; + } + + signal->theData[0] = TcContinueB::CHECK_WAIT_DROP_TAB_FAILED_LQH; + signal->theData[1] = nodeId; + signal->theData[2] = tabPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); +} + +void +Dbtc::execDROP_TAB_REQ(Signal* signal) +{ + jamEntry(); + + DropTabReq* req = (DropTabReq*)signal->getDataPtr(); + + TableRecordPtr tabPtr; + tabPtr.i = req->tableId; + ptrCheckGuard(tabPtr, ctabrecFilesize, tableRecord); + + Uint32 senderRef = req->senderRef; + Uint32 senderData = req->senderData; + DropTabReq::RequestType rt = (DropTabReq::RequestType)req->requestType; + + if(!tabPtr.p->enabled && rt == DropTabReq::OnlineDropTab){ + jam(); + DropTabRef* ref = (DropTabRef*)signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = senderData; + ref->tableId = tabPtr.i; + ref->errorCode = DropTabRef::NoSuchTable; + sendSignal(senderRef, GSN_DROP_TAB_REF, signal, + DropTabRef::SignalLength, JBB); + return; + } + + if(!tabPtr.p->dropping && rt == DropTabReq::OnlineDropTab){ + jam(); + DropTabRef* ref = (DropTabRef*)signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = senderData; + ref->tableId = tabPtr.i; + ref->errorCode = DropTabRef::DropWoPrep; + sendSignal(senderRef, GSN_DROP_TAB_REF, signal, + DropTabRef::SignalLength, JBB); + return; + } + + tabPtr.p->enabled = false; + tabPtr.p->dropping = false; + + DropTabConf * conf = (DropTabConf*)signal->getDataPtrSend(); + conf->tableId = tabPtr.i; + conf->senderRef = reference(); + conf->senderData = senderData; + sendSignal(senderRef, GSN_DROP_TAB_CONF, signal, + PrepDropTabConf::SignalLength, JBB); +} + +void Dbtc::execALTER_TAB_REQ(Signal * signal) +{ + AlterTabReq* const req = (AlterTabReq*)signal->getDataPtr(); + const Uint32 senderRef = req->senderRef; + const Uint32 senderData = req->senderData; + const Uint32 changeMask = req->changeMask; + const Uint32 tableId = req->tableId; + const Uint32 tableVersion = req->tableVersion; + const Uint32 gci = req->gci; + AlterTabReq::RequestType requestType = + (AlterTabReq::RequestType) req->requestType; + + TableRecordPtr tabPtr; + tabPtr.i = req->tableId; + ptrCheckGuard(tabPtr, ctabrecFilesize, tableRecord); + tabPtr.p->currentSchemaVersion = tableVersion; + + // Request handled successfully + AlterTabConf * conf = (AlterTabConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = senderData; + conf->changeMask = changeMask; + conf->tableId = tableId; + conf->tableVersion = tableVersion; + conf->gci = gci; + conf->requestType = requestType; + sendSignal(senderRef, GSN_ALTER_TAB_CONF, signal, + AlterTabConf::SignalLength, JBB); +} + +/* ***************************************************************************/ +/* START / RESTART */ +/* ***************************************************************************/ +void Dbtc::execSIZEALT_REP(Signal* signal) +{ + jamEntry(); + tblockref = signal->theData[TcSizeAltReq::IND_BLOCK_REF]; + const UintR apiConnect = signal->theData[TcSizeAltReq::IND_API_CONNECT]; + const UintR tcConnect = signal->theData[TcSizeAltReq::IND_TC_CONNECT]; + const UintR tables = signal->theData[TcSizeAltReq::IND_TABLE]; + const UintR localScan = signal->theData[TcSizeAltReq::IND_LOCAL_SCAN]; + const UintR tcScan = signal->theData[TcSizeAltReq::IND_TC_SCAN]; + + ccacheFilesize = (apiConnect/3) + 1; + capiConnectFilesize = apiConnect; + ctcConnectFilesize = tcConnect; + ctabrecFilesize = tables; + cscanrecFileSize = tcScan; + cscanOprecFileSize = localScan; + cscanFragrecFileSize = localScan; + + initRecords(); + initialiseRecordsLab(signal, (UintR)0); +}//Dbtc::execSIZEALT_REP() + +void Dbtc::returnInitialiseRecordsLab(Signal* signal) +{ + signal->theData[0] = DBTC_REF; + sendSignal(CMVMI_REF, GSN_SIZEALT_ACK, signal, 2, JBB); +}//Dbtc::returnInitialiseRecordsLab() + +void Dbtc::execSTTOR(Signal* signal) +{ + Uint16 tphase; + + jamEntry(); + /* START CASE */ + tphase = signal->theData[1]; + csignalKey = signal->theData[6]; + switch (tphase) { + case ZSPH1: + jam(); + startphase1x010Lab(signal); + return; + default: + jam(); + sttorryLab(signal); /* START PHASE 255 */ + return; + }//switch +}//Dbtc::execSTTOR() + +void Dbtc::sttorryLab(Signal* signal) +{ + signal->theData[0] = csignalKey; + signal->theData[1] = 3; /* BLOCK CATEGORY */ + signal->theData[2] = 2; /* SIGNAL VERSION NUMBER */ + signal->theData[3] = ZSPH1; + signal->theData[4] = 255; + sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 5, JBB); +}//Dbtc::sttorryLab() + +/* ***************************************************************************/ +/* INTERNAL START / RESTART */ +/*****************************************************************************/ +void Dbtc::execNDB_STTOR(Signal* signal) +{ + Uint16 tndbstartphase; + Uint16 tstarttype; + + jamEntry(); + tusersblkref = signal->theData[0]; + tnodeid = signal->theData[1]; + tndbstartphase = signal->theData[2]; /* START PHASE */ + tstarttype = signal->theData[3]; /* START TYPE */ + Uint32 config1 = signal->theData[12]; /* CONFIG INFO TC */ + Uint32 config2 = signal->theData[13]; /* CONFIG INFO TC */ + switch (tndbstartphase) { + case ZINTSPH1: + jam(); + ctimeOutCheckDelay = 50; // 500ms + set_timeout_value(config1); + set_no_parallel_takeover(config2); + intstartphase1x010Lab(signal); + return; + case ZINTSPH2: + jam(); + set_appl_timeout_value(config2); + intstartphase2x010Lab(signal); + return; + case ZINTSPH3: + jam(); + intstartphase3x010Lab(signal); /* SEIZE CONNECT RECORD IN EACH LQH*/ +// Start transaction event reporting. + signal->theData[0] = TcContinueB::ZTRANS_EVENT_REP; + signal->theData[1] = 1; + sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 10, 2); + return; + case ZINTSPH6: + jam(); + csystemStart = SSS_TRUE; + break; + default: + jam(); + break; + }//switch + ndbsttorry010Lab(signal); + return; +}//Dbtc::execNDB_STTOR() + +void Dbtc::ndbsttorry010Lab(Signal* signal) +{ + signal->theData[0] = cownref; + sendSignal(cndbcntrblockref, GSN_NDB_STTORRY, signal, 1, JBB); +}//Dbtc::ndbsttorry010Lab() + +void +Dbtc::set_timeout_value(Uint32 timeOut) +{ + timeOut = timeOut / 10; + if (timeOut < 2) { + jam(); + timeOut = 100; + }//if + ctimeOutValue = timeOut; +} + +void +Dbtc::set_appl_timeout_value(Uint32 timeOut) +{ + timeOut /= 10; + if (timeOut < ctimeOutValue) { + jam(); + c_appl_timeout_value = ctimeOutValue; + }//if + c_appl_timeout_value = timeOut; +} + +void +Dbtc::set_no_parallel_takeover(Uint32 noParallelTakeOver) +{ + if (noParallelTakeOver == 0) { + jam(); + noParallelTakeOver = 1; + } else if (noParallelTakeOver > MAX_NDB_NODES) { + jam(); + noParallelTakeOver = MAX_NDB_NODES; + }//if + cnoParallelTakeOver = noParallelTakeOver; +} + +/* ***************************************************************************/ +/* S T A R T P H A S E 1 X */ +/* INITIALISE BLOCKREF AND BLOCKNUMBERS */ +/* ***************************************************************************/ +void Dbtc::startphase1x010Lab(Signal* signal) +{ + csystemStart = SSS_FALSE; + ctimeOutCheckCounter = 0; + ctimeOutCheckFragCounter = 0; + ctimeOutMissedHeartbeats = 0; + ctimeOutCheckHeartbeat = 0; + ctimeOutCheckLastHeartbeat = 0; + ctimeOutCheckActive = TOCS_FALSE; + ctimeOutCheckFragActive = TOCS_FALSE; + sttorryLab(signal); +}//Dbtc::startphase1x010Lab() + +/*****************************************************************************/ +/* I N T S T A R T P H A S E 1 X */ +/* INITIALISE ALL RECORDS. */ +/*****************************************************************************/ +void Dbtc::intstartphase1x010Lab(Signal* signal) +{ + cownNodeid = tnodeid; + cownref = calcTcBlockRef(cownNodeid); + clqhblockref = calcLqhBlockRef(cownNodeid); + cdihblockref = calcDihBlockRef(cownNodeid); + cdictblockref = calcDictBlockRef(cownNodeid); + cndbcntrblockref = calcNdbCntrBlockRef(cownNodeid); + cerrorBlockref = calcNdbCntrBlockRef(cownNodeid); + coperationsize = 0; + cfailure_nr = 0; + ndbsttorry010Lab(signal); +}//Dbtc::intstartphase1x010Lab() + +/*****************************************************************************/ +/* I N T S T A R T P H A S E 2 X */ +/* SET-UP LOCAL CONNECTIONS. */ +/*****************************************************************************/ +void Dbtc::intstartphase2x010Lab(Signal* signal) +{ + tcConnectptr.i = cfirstfreeTcConnect; + intstartphase2x020Lab(signal); +}//Dbtc::intstartphase2x010Lab() + +void Dbtc::intstartphase2x020Lab(Signal* signal) +{ + if (tcConnectptr.i == RNIL) { + jam(); + ndbsttorry010Lab(signal); + return; + }//if + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + tcConnectptr.p->tcConnectstate = OS_CONNECTING_DICT; +/* ****************** */ +/* DISEIZEREQ < */ +/* ****************** */ + signal->theData[0] = tcConnectptr.i; + signal->theData[1] = cownref; + sendSignal(cdihblockref, GSN_DISEIZEREQ, signal, 2, JBB); +}//Dbtc::intstartphase2x020Lab() + +void Dbtc::execDISEIZECONF(Signal* signal) +{ + jamEntry(); + tcConnectptr.i = signal->theData[0]; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + tcConnectptr.p->dihConnectptr = signal->theData[1]; + tcConnectptr.i = tcConnectptr.p->nextTcConnect; + intstartphase2x020Lab(signal); +}//Dbtc::execDISEIZECONF() + +/*****************************************************************************/ +/* I N T S T A R T P H A S E 3 X */ +/* PREPARE DISTRIBUTED CONNECTIONS */ +/*****************************************************************************/ +void Dbtc::intstartphase3x010Lab(Signal* signal) +{ + signal->theData[0] = cownref; + sendSignal(cndbcntrblockref, GSN_READ_NODESREQ, signal, 1, JBB); +}//Dbtc::intstartphase3x010Lab() + +void Dbtc::execREAD_NODESCONF(Signal* signal) +{ + UintR guard0; + + jamEntry(); + + ReadNodesConf * const readNodes = (ReadNodesConf *)&signal->theData[0]; + + csystemnodes = readNodes->noOfNodes; + cmasterNodeId = readNodes->masterNodeId; + + con_lineNodes = 0; + arrGuard(csystemnodes, MAX_NDB_NODES); + guard0 = csystemnodes - 1; + arrGuard(guard0, MAX_NDB_NODES); // Check not zero nodes + + for (unsigned i = 1; i < MAX_NDB_NODES; i++) { + jam(); + if (NodeBitmask::get(readNodes->allNodes, i)) { + hostptr.i = i; + ptrCheckGuard(hostptr, chostFilesize, hostRecord); + + hostptr.p->takeOverStatus = TOS_IDLE; + hostptr.p->ndbVersion = ReadNodesConf::getVersionId + (i, readNodes->theVersionIds); + + if (NodeBitmask::get(readNodes->inactiveNodes, i)) { + jam(); + hostptr.p->hostStatus = HS_DEAD; + } else { + jam(); + con_lineNodes++; + hostptr.p->hostStatus = HS_ALIVE; + }//if + }//if + }//for + ndbsttorry010Lab(signal); +}//Dbtc::execREAD_NODESCONF() + +/*****************************************************************************/ +/* A P I _ F A I L R E Q */ +// An API node has failed for some reason. We need to disconnect all API +// connections to the API node. This also includes +/*****************************************************************************/ +void Dbtc::execAPI_FAILREQ(Signal* signal) +{ + /*************************************************************************** + * Set the block reference to return API_FAILCONF to. Set the number of api + * connects currently closing to one to indicate that we are still in the + * process of going through the api connect records. Thus checking for zero + * can only be true after all api connect records have been checked. + **************************************************************************/ + jamEntry(); + capiFailRef = signal->theData[1]; + arrGuard(signal->theData[0], MAX_NODES); + capiConnectClosing[signal->theData[0]] = 1; + handleFailedApiNode(signal, signal->theData[0], (UintR)0); +} + +void +Dbtc::handleFailedApiNode(Signal* signal, + UintR TapiFailedNode, + UintR TapiConnectPtr) +{ + UintR TloopCount = 0; + arrGuard(TapiFailedNode, MAX_NODES); + apiConnectptr.i = TapiConnectPtr; + do { + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + const UintR TapiNode = refToNode(apiConnectptr.p->ndbapiBlockref); + if (TapiNode == TapiFailedNode) { +#ifdef VM_TRACE + if (apiConnectptr.p->apiFailState != ZFALSE) { + ndbout << "Error in previous API fail handling discovered" << endl + << " apiConnectptr.i = " << apiConnectptr.i << endl + << " apiConnectstate = " << apiConnectptr.p->apiConnectstate + << endl + << " ndbapiBlockref = " << hex + << apiConnectptr.p->ndbapiBlockref << endl + << " apiNode = " << refToNode(apiConnectptr.p->ndbapiBlockref) + << endl; + if (apiConnectptr.p->lastTcConnect != RNIL){ + jam(); + tcConnectptr.i = apiConnectptr.p->lastTcConnect; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + ndbout << " tcConnectptr.i = " << tcConnectptr.i << endl + << " tcConnectstate = " << tcConnectptr.p->tcConnectstate + << endl; + } + }//if +#endif + + apiConnectptr.p->returnsignal = RS_NO_RETURN; + /***********************************************************************/ + // The connected node is the failed node. + /**********************************************************************/ + switch(apiConnectptr.p->apiConnectstate) { + case CS_DISCONNECTED: + /*********************************************************************/ + // These states do not need any special handling. + // Simply continue with the next. + /*********************************************************************/ + jam(); + break; + case CS_ABORTING: + /*********************************************************************/ + // This could actually mean that the API connection is already + // ready to release if the abortState is IDLE. + /*********************************************************************/ + if (apiConnectptr.p->abortState == AS_IDLE) { + jam(); + releaseApiCon(signal, apiConnectptr.i); + } else { + jam(); + capiConnectClosing[TapiFailedNode]++; + apiConnectptr.p->apiFailState = ZTRUE; + }//if + break; + case CS_WAIT_ABORT_CONF: + case CS_WAIT_COMMIT_CONF: + case CS_START_COMMITTING: + case CS_PREPARE_TO_COMMIT: + case CS_COMMITTING: + case CS_COMMIT_SENT: + /*********************************************************************/ + // These states indicate that an abort process or commit process is + // already ongoing. We will set a state in the api record indicating + // that the API node has failed. + // Also we will increase the number of outstanding api records to + // wait for before we can respond with API_FAILCONF. + /*********************************************************************/ + jam(); + capiConnectClosing[TapiFailedNode]++; + apiConnectptr.p->apiFailState = ZTRUE; + break; + case CS_START_SCAN: + /*********************************************************************/ + // The api record was performing a scan operation. We need to check + // on the scan state. Since completing a scan process might involve + // sending several signals we will increase the loop count by 64. + /*********************************************************************/ + jam(); + handleScanStop(signal, TapiFailedNode); + TloopCount += 64; + break; + case CS_CONNECTED: + /*********************************************************************/ + // The api record is connected to failed node. We need to release the + // connection and set it in a disconnected state. + /*********************************************************************/ + jam(); + releaseApiCon(signal, apiConnectptr.i); + break; + case CS_REC_COMMITTING: + case CS_RECEIVING: + case CS_STARTED: + /*********************************************************************/ + // The api record was in the process of performing a transaction but + // had not yet sent all information. + // We need to initiate an ABORT since the API will not provide any + // more information. + // Since the abort can send many signals we will insert a real-time + // break after checking this record. + /*********************************************************************/ + jam(); + apiConnectptr.p->apiFailState = ZTRUE; + capiConnectClosing[TapiFailedNode]++; + abort010Lab(signal); + TloopCount = 256; + break; + case CS_PREPARED: + jam(); + case CS_REC_PREPARING: + jam(); + case CS_START_PREPARING: + jam(); + /*********************************************************************/ + // Not implemented yet. + /*********************************************************************/ + systemErrorLab(signal); + break; + case CS_RESTART: + jam(); + case CS_COMPLETING: + jam(); + case CS_COMPLETE_SENT: + jam(); + case CS_WAIT_COMPLETE_CONF: + jam(); + case CS_FAIL_ABORTING: + jam(); + case CS_FAIL_ABORTED: + jam(); + case CS_FAIL_PREPARED: + jam(); + case CS_FAIL_COMMITTING: + jam(); + case CS_FAIL_COMMITTED: + /*********************************************************************/ + // These states are only valid on copy and fail API connections. + /*********************************************************************/ + default: + jam(); + systemErrorLab(signal); + break; + }//switch + } else { + jam(); + }//if + apiConnectptr.i++; + if (apiConnectptr.i > ((capiConnectFilesize / 3) - 1)) { + jam(); + capiConnectClosing[TapiFailedNode]--; + /** + * Finished with scanning connection record + * + * Now scan markers + */ + removeMarkerForFailedAPI(signal, TapiFailedNode, RNIL); // RNIL = first + return; + }//if + } while (TloopCount++ < 256); + signal->theData[0] = TcContinueB::ZHANDLE_FAILED_API_NODE; + signal->theData[1] = TapiFailedNode; + signal->theData[2] = apiConnectptr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB); +}//Dbtc::handleFailedApiNode() + +void +Dbtc::removeMarkerForFailedAPI(Signal* signal, + Uint32 nodeId, + Uint32 startBucket) +{ + CommitAckMarkerIterator iter; + if(startBucket == RNIL){ + jam(); + capiConnectClosing[nodeId]++; + m_commitAckMarkerHash.next(0, iter); + } else { + jam(); + m_commitAckMarkerHash.next(startBucket, iter); + } + + const Uint32 RT_BREAK = 256; + for(Uint32 i = 0; itheData[0] = nodeId; + signal->theData[1] = cownref; + sendSignal(capiFailRef, GSN_API_FAILCONF, signal, 2, JBB); + } + return; + } + + if(iter.curr.p->apiNodeId == nodeId){ + jam(); + + /** + * Check so that the record is not still in use + * + * (This can happen when NF and API Fail happens at the same time) + */ + ApiConnectRecordPtr apiConnectPtr; + apiConnectPtr.i = iter.curr.p->apiConnectPtr; + ptrCheckGuard(apiConnectPtr, capiConnectFilesize, apiConnectRecord); + if(apiConnectPtr.p->commitAckMarker == iter.curr.i){ + jam(); + /** + * The record is still active + * + * Don't remove it, but continueb instead + */ + break; + } + + sendRemoveMarkers(signal, iter.curr.p); + m_commitAckMarkerHash.release(iter.curr); + + break; + } + m_commitAckMarkerHash.next(iter); + } + + signal->theData[0] = TcContinueB::ZHANDLE_FAILED_API_NODE_REMOVE_MARKERS; + signal->theData[1] = nodeId; + signal->theData[2] = iter.bucket; + sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB); +} + +void Dbtc::handleApiFailState(Signal* signal, UintR TapiConnectptr) +{ + ApiConnectRecordPtr TlocalApiConnectptr; + UintR TfailedApiNode; + + TlocalApiConnectptr.i = TapiConnectptr; + ptrCheckGuard(TlocalApiConnectptr, capiConnectFilesize, apiConnectRecord); + TfailedApiNode = refToNode(TlocalApiConnectptr.p->ndbapiBlockref); + arrGuard(TfailedApiNode, MAX_NODES); + capiConnectClosing[TfailedApiNode]--; + releaseApiCon(signal, TapiConnectptr); + TlocalApiConnectptr.p->apiFailState = ZFALSE; + if (capiConnectClosing[TfailedApiNode] == 0) { + jam(); + signal->theData[0] = TfailedApiNode; + signal->theData[1] = cownref; + sendSignal(capiFailRef, GSN_API_FAILCONF, signal, 2, JBB); + }//if +}//Dbtc::handleApiFailState() + +/** + * Dbtc::handleScanStop + * This function is called when an entire scan should be stopped + * Check state of the scan and take appropriate action. + * The parameter TapiFailedNode indicates if the scan is stopped + * because an API node has failed or if it has been stopped because + * the scan has timed out. + * + */ +void Dbtc::handleScanStop(Signal* signal, UintR TapiFailedNode) +{ + arrGuard(TapiFailedNode, MAX_NODES); + + scanptr.i = apiConnectptr.p->apiScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + + // If api has failed we must release all resources + bool apiNodeHasFailed = (TapiFailedNode != 0); + + DEBUG("handleScanStop: scanState = "<< scanptr.p->scanState); + + switch (scanptr.p->scanState) { + case ScanRecord::WAIT_SCAN_TAB_INFO: + case ScanRecord::WAIT_AI: + jam(); + /** + * The scan process is still in the definition phase. + * We will release the resources and then release the connection + * to the failed API. + */ + releaseScanResources(signal); + if (apiNodeHasFailed) { + jam(); + releaseApiCon(signal, apiConnectptr.i); + }//if + break; + + case ScanRecord::WAIT_FRAGMENT_COUNT: + jam(); + if (!apiNodeHasFailed) { + jam(); + /** + * Time-out waiting for a local signal can only happen + * if we have a serious problem. + */ + systemErrorLab(signal); + }//if + capiConnectClosing[TapiFailedNode]++; + apiConnectptr.p->apiFailState = ZTRUE; + scanptr.p->apiIsClosed = true; + break; + + case ScanRecord::CLOSING_SCAN: + jam(); + /** + * With CLOSING_SCAN it is enough to set the + * fail state such that the connection is released at the end of the + * closing process. The close process is already ongoing. + * Set apiIsClosed to true to indicate that resources should be released + * at the end of the close process. + **/ + + if (apiNodeHasFailed) { + jam(); + capiConnectClosing[TapiFailedNode]++; + apiConnectptr.p->apiFailState = ZTRUE; + scanptr.p->apiIsClosed = true; + }//if + if (apiConnectptr.p->apiFailState == ZTRUE) { + jam(); + handleApiFailState(signal, apiConnectptr.i); + return; + }//if + break; + + case ScanRecord::SCAN_NEXT_ORDERED: + /** + * In the SCAN_NEXT_ORDERED state we will wait for the next natural place + * to receive some action from the API and instead of waiting for the + * API here we will start the abort process. + + * After the abort process is completed we will release the connection. + */ + if (apiNodeHasFailed) { + jam(); + capiConnectClosing[TapiFailedNode]++; + apiConnectptr.p->apiFailState = ZTRUE; + }//if + // Release resources and send a response to API + scanptr.p->apiIsClosed = true; + scanCompletedLab(signal); + break; + + case ScanRecord::DELIVERED: + case ScanRecord::QUEUED_DELIVERED: + /** + * A response has been sent to the api but it has not responded + */ + + if (apiNodeHasFailed) { + jam(); + capiConnectClosing[TapiFailedNode]++; + apiConnectptr.p->apiFailState = ZTRUE; + scanptr.p->apiIsClosed = true; + } else { + jam(); + /* + In this case we have received a time-out caused by the application + waiting too long to continue the scan. We will check the application + time-out instead of the deadlock detetection time-out. If the + application time-out hasn't fired we will simply ignore the condition. + */ + if ((ctcTimer - getApiConTimer(apiConnectptr.i)) <= c_appl_timeout_value) { + jam(); + return; + }//if + // Dont' release, wait until api responds or fails + scanptr.p->apiIsClosed = false; + } + scanCompletedLab(signal); + break; + + default: + jam(); + systemErrorLab(signal); + break; + + }//switch +}//Dbtc::handleScanStop() + +/**************************************************************************** + * T C S E I Z E R E Q + * THE APPLICATION SENDS A REQUEST TO SEIZE A CONNECT RECORD TO CARRY OUT A + * TRANSACTION + * TC BLOCK TAKE OUT A CONNECT RECORD FROM THE FREE LIST AND ESTABLISHES ALL + * NECESSARY CONNECTION BEFORE REPLYING TO THE APPLICATION BLOCK + ****************************************************************************/ +void Dbtc::execTCSEIZEREQ(Signal* signal) +{ + UintR tapiPointer; + BlockReference tapiBlockref; /* SENDER BLOCK REFERENCE*/ + + jamEntry(); + tapiPointer = signal->theData[0]; /* REQUEST SENDERS CONNECT RECORD POINTER*/ + tapiBlockref = signal->theData[1]; /* SENDERS BLOCK REFERENCE*/ + + const NodeState::StartLevel sl = + (NodeState::StartLevel)getNodeState().startLevel; + + const NodeId senderNodeId = refToNode(tapiBlockref); + const bool local = senderNodeId == getOwnNodeId() || senderNodeId == 0; + + if(!(senderNodeId == getNodeState().getSingleUserApi()) && + !getNodeState().getSingleUserMode()) { + if(!(sl==NodeState::SL_SINGLEUSER && + senderNodeId == getNodeState().getSingleUserApi())) { + if (!(sl == NodeState::SL_STARTED || + (sl == NodeState::SL_STARTING && local == true))) { + jam(); + + Uint32 errCode; + if(!(sl == NodeState::SL_SINGLEUSER && local)) + { + switch(sl){ + case NodeState::SL_STARTING: + errCode = ZSYSTEM_NOT_STARTED_ERROR; + break; + case NodeState::SL_STOPPING_1: + case NodeState::SL_STOPPING_2: + case NodeState::SL_STOPPING_3: + case NodeState::SL_STOPPING_4: + if(getNodeState().stopping.systemShutdown) + errCode = ZCLUSTER_SHUTDOWN_IN_PROGRESS; + else + errCode = ZNODE_SHUTDOWN_IN_PROGRESS; + break; + case NodeState::SL_SINGLEUSER: + errCode = ZCLUSTER_IN_SINGLEUSER_MODE; + break; + default: + errCode = ZWRONG_STATE; + break; + } + signal->theData[0] = tapiPointer; + signal->theData[1] = errCode; + sendSignal(tapiBlockref, GSN_TCSEIZEREF, signal, 2, JBB); + return; + }//if (!(sl == SL_SINGLEUSER)) + } //if + } + } + + seizeApiConnect(signal); + if (terrorCode == ZOK) { + jam(); + apiConnectptr.p->ndbapiConnect = tapiPointer; + apiConnectptr.p->ndbapiBlockref = tapiBlockref; + signal->theData[0] = apiConnectptr.p->ndbapiConnect; + signal->theData[1] = apiConnectptr.i; + sendSignal(tapiBlockref, GSN_TCSEIZECONF, signal, 2, JBB); + return; + } + + signal->theData[0] = tapiPointer; + signal->theData[1] = terrorCode; + sendSignal(tapiBlockref, GSN_TCSEIZEREF, signal, 2, JBB); +}//Dbtc::execTCSEIZEREQ() + +/****************************************************************************/ +/* T C R E L E A S E Q */ +/* REQUEST TO RELEASE A CONNECT RECORD */ +/****************************************************************************/ +void Dbtc::execTCRELEASEREQ(Signal* signal) +{ + UintR tapiPointer; + BlockReference tapiBlockref; /* SENDER BLOCK REFERENCE*/ + + jamEntry(); + tapiPointer = signal->theData[0]; /* REQUEST SENDERS CONNECT RECORD POINTER*/ + tapiBlockref = signal->theData[1];/* SENDERS BLOCK REFERENCE*/ + tuserpointer = signal->theData[2]; + if (tapiPointer >= capiConnectFilesize) { + jam(); + signal->theData[0] = tuserpointer; + signal->theData[1] = ZINVALID_CONNECTION; + sendSignal(tapiBlockref, GSN_TCRELEASEREF, signal, 2, JBB); + return; + } else { + jam(); + apiConnectptr.i = tapiPointer; + }//if + ptrAss(apiConnectptr, apiConnectRecord); + if (apiConnectptr.p->apiConnectstate == CS_DISCONNECTED) { + jam(); + signal->theData[0] = tuserpointer; + sendSignal(tapiBlockref, GSN_TCRELEASECONF, signal, 1, JBB); + } else { + if (tapiBlockref == apiConnectptr.p->ndbapiBlockref) { + if (apiConnectptr.p->apiConnectstate == CS_CONNECTED) { + jam(); /* JUST REPLY OK */ + releaseApiCon(signal, apiConnectptr.i); + signal->theData[0] = tuserpointer; + sendSignal(apiConnectptr.p->ndbapiBlockref, + GSN_TCRELEASECONF, signal, 1, JBB); + } else { + jam(); + signal->theData[0] = tuserpointer; + signal->theData[1] = ZINVALID_CONNECTION; + sendSignal(apiConnectptr.p->ndbapiBlockref, + GSN_TCRELEASEREF, signal, 2, JBB); + } + } else { + jam(); + signal->theData[0] = tuserpointer; + signal->theData[1] = ZINVALID_CONNECTION; + sendSignal(tapiBlockref, GSN_TCRELEASEREF, signal, 2, JBB); + }//if + }//if +}//Dbtc::execTCRELEASEREQ() + +/****************************************************************************/ +// Error Handling for TCKEYREQ messages +/****************************************************************************/ +void Dbtc::signalErrorRefuseLab(Signal* signal) +{ + ptrGuard(apiConnectptr); + if (apiConnectptr.p->apiConnectstate != CS_DISCONNECTED) { + jam(); + apiConnectptr.p->abortState = AS_IDLE; + apiConnectptr.p->apiConnectstate = CS_ABORTING; + }//if + sendSignalErrorRefuseLab(signal); +}//Dbtc::signalErrorRefuseLab() + +void Dbtc::sendSignalErrorRefuseLab(Signal* signal) +{ + ndbassert(false); + ptrGuard(apiConnectptr); + if (apiConnectptr.p->apiConnectstate != CS_DISCONNECTED) { + jam(); + signal->theData[0] = apiConnectptr.p->ndbapiConnect; + signal->theData[1] = signal->theData[ttransid_ptr]; + signal->theData[2] = signal->theData[ttransid_ptr + 1]; + signal->theData[3] = ZSIGNAL_ERROR; + sendSignal(apiConnectptr.p->ndbapiBlockref, GSN_TCROLLBACKREP, + signal, 4, JBB); + } +}//Dbtc::sendSignalErrorRefuseLab() + +void Dbtc::abortBeginErrorLab(Signal* signal) +{ + apiConnectptr.p->transid[0] = signal->theData[ttransid_ptr]; + apiConnectptr.p->transid[1] = signal->theData[ttransid_ptr + 1]; + abortErrorLab(signal); +}//Dbtc::abortBeginErrorLab() + +void Dbtc::printState(Signal* signal, int place) +{ +#ifdef VM_TRACE // Change to if 0 to disable these printouts + ndbout << "-- Dbtc::printState -- " << endl; + ndbout << "Received from place = " << place + << " apiConnectptr.i = " << apiConnectptr.i + << " apiConnectstate = " << apiConnectptr.p->apiConnectstate << endl; + ndbout << "ctcTimer = " << ctcTimer + << " ndbapiBlockref = " << hex <ndbapiBlockref + << " Transid = " << apiConnectptr.p->transid[0] + << " " << apiConnectptr.p->transid[1] << endl; + ndbout << " apiTimer = " << getApiConTimer(apiConnectptr.i) + << " counter = " << apiConnectptr.p->counter + << " lqhkeyconfrec = " << apiConnectptr.p->lqhkeyconfrec + << " lqhkeyreqrec = " << apiConnectptr.p->lqhkeyreqrec << endl; + ndbout << "abortState = " << (int)apiConnectptr.p->abortState + << " apiScanRec = " << apiConnectptr.p->apiScanRec + << " returncode = " << apiConnectptr.p->returncode << endl; + ndbout << "tckeyrec = " << apiConnectptr.p->tckeyrec + << " returnsignal = " << apiConnectptr.p->returnsignal + << " apiFailState = " << apiConnectptr.p->apiFailState << endl; + if (apiConnectptr.p->cachePtr != RNIL) { + jam(); + CacheRecord *localCacheRecord = cacheRecord; + UintR TcacheFilesize = ccacheFilesize; + UintR TcachePtr = apiConnectptr.p->cachePtr; + if (TcachePtr < TcacheFilesize) { + jam(); + CacheRecord * const regCachePtr = &localCacheRecord[TcachePtr]; + ndbout << "currReclenAi = " << regCachePtr->currReclenAi + << " attrlength = " << regCachePtr->attrlength + << " tableref = " << regCachePtr->tableref + << " keylen = " << regCachePtr->keylen << endl; + } else { + jam(); + systemErrorLab(signal); + }//if + }//if +#endif + return; +}//Dbtc::printState() + +void +Dbtc::TCKEY_abort(Signal* signal, int place) +{ + switch (place) { + case 0: + jam(); + terrorCode = ZSTATE_ERROR; + apiConnectptr.p->firstTcConnect = RNIL; + printState(signal, 4); + abortBeginErrorLab(signal); + return; + case 1: + jam(); + printState(signal, 3); + sendSignalErrorRefuseLab(signal); + return; + case 2:{ + printState(signal, 6); + const TcKeyReq * const tcKeyReq = (TcKeyReq *)&signal->theData[0]; + const Uint32 t1 = tcKeyReq->transId1; + const Uint32 t2 = tcKeyReq->transId2; + signal->theData[0] = apiConnectptr.p->ndbapiConnect; + signal->theData[1] = t1; + signal->theData[2] = t2; + signal->theData[3] = ZABORT_ERROR; + sendSignal(apiConnectptr.p->ndbapiBlockref, GSN_TCROLLBACKREP, + signal, 4, JBB); + return; + } + case 3: + jam(); + printState(signal, 7); + noFreeConnectionErrorLab(signal); + return; + case 4: + jam(); + terrorCode = ZERO_KEYLEN_ERROR; + releaseAtErrorLab(signal); + return; + case 5: + jam(); + terrorCode = ZNO_AI_WITH_UPDATE; + releaseAtErrorLab(signal); + return; + case 6: + jam(); + warningHandlerLab(signal); + return; + + case 7: + jam(); + tabStateErrorLab(signal); + return; + + case 8: + jam(); + wrongSchemaVersionErrorLab(signal); + return; + + case 9: + jam(); + terrorCode = ZSTATE_ERROR; + releaseAtErrorLab(signal); + return; + + case 10: + jam(); + systemErrorLab(signal); + return; + + case 11: + jam(); + terrorCode = ZMORE_AI_IN_TCKEYREQ_ERROR; + releaseAtErrorLab(signal); + return; + + case 12: + jam(); + terrorCode = ZSIMPLE_READ_WITHOUT_AI; + releaseAtErrorLab(signal); + return; + + case 13: + jam(); + switch (tcConnectptr.p->tcConnectstate) { + case OS_WAIT_KEYINFO: + jam(); + printState(signal, 8); + terrorCode = ZSTATE_ERROR; + abortErrorLab(signal); + return; + default: + jam(); + /********************************************************************/ + /* MISMATCH BETWEEN STATE ON API CONNECTION AND THIS */ + /* PARTICULAR TC CONNECT RECORD. THIS MUST BE CAUSED BY NDB */ + /* INTERNAL ERROR. */ + /********************************************************************/ + systemErrorLab(signal); + return; + }//switch + return; + + case 15: + jam(); + terrorCode = ZSCAN_NODE_ERROR; + releaseAtErrorLab(signal); + return; + + case 16: + jam(); + systemErrorLab(signal); + return; + + case 17: + jam(); + systemErrorLab(signal); + return; + + case 18: + jam(); + warningHandlerLab(signal); + return; + + case 19: + jam(); + return; + + case 20: + jam(); + warningHandlerLab(signal); + return; + + case 21: + jam(); + systemErrorLab(signal); + return; + + case 22: + jam(); + systemErrorLab(signal); + return; + + case 23: + jam(); + systemErrorLab(signal); + return; + + case 24: + jam(); + seizeAttrbuferrorLab(signal); + return; + + case 25: + jam(); + warningHandlerLab(signal); + return; + + case 26: + jam(); + return; + + case 27: + systemErrorLab(signal); + jam(); + return; + + case 28: + jam(); + // NOT USED + return; + + case 29: + jam(); + systemErrorLab(signal); + return; + + case 30: + jam(); + systemErrorLab(signal); + return; + + case 31: + jam(); + systemErrorLab(signal); + return; + + case 32: + jam(); + systemErrorLab(signal); + return; + + case 33: + jam(); + systemErrorLab(signal); + return; + + case 34: + jam(); + systemErrorLab(signal); + return; + + case 35: + jam(); + systemErrorLab(signal); + return; + + case 36: + jam(); + systemErrorLab(signal); + return; + + case 37: + jam(); + systemErrorLab(signal); + return; + + case 38: + jam(); + systemErrorLab(signal); + return; + + case 39: + jam(); + systemErrorLab(signal); + return; + + case 40: + jam(); + systemErrorLab(signal); + return; + + case 41: + jam(); + systemErrorLab(signal); + return; + + case 42: + jam(); + systemErrorLab(signal); + return; + + case 43: + jam(); + systemErrorLab(signal); + return; + + case 44: + jam(); + systemErrorLab(signal); + return; + + case 45: + jam(); + systemErrorLab(signal); + return; + + case 46: + jam(); + systemErrorLab(signal); + return; + + case 47: + jam(); + terrorCode = apiConnectptr.p->returncode; + releaseAtErrorLab(signal); + return; + + case 48: + jam(); + terrorCode = ZCOMMIT_TYPE_ERROR; + releaseAtErrorLab(signal); + return; + + case 49: + jam(); + abortErrorLab(signal); + return; + + case 50: + jam(); + systemErrorLab(signal); + return; + + case 51: + jam(); + abortErrorLab(signal); + return; + + case 52: + jam(); + abortErrorLab(signal); + return; + + case 53: + jam(); + abortErrorLab(signal); + return; + + case 54: + jam(); + abortErrorLab(signal); + return; + + case 55: + jam(); + printState(signal, 5); + sendSignalErrorRefuseLab(signal); + return; + + case 56:{ + jam(); + terrorCode = ZNO_FREE_TC_MARKER; + abortErrorLab(signal); + return; + } + case 57:{ + jam(); + /** + * Initialize object before starting error handling + */ + initApiConnectRec(signal, apiConnectptr.p, true); + switch(getNodeState().startLevel){ + case NodeState::SL_STOPPING_2: + case NodeState::SL_STOPPING_3: + case NodeState::SL_STOPPING_4: + if(getNodeState().stopping.systemShutdown) + terrorCode = ZCLUSTER_SHUTDOWN_IN_PROGRESS; + else + terrorCode = ZNODE_SHUTDOWN_IN_PROGRESS; + break; + case NodeState::SL_SINGLEUSER: + terrorCode = ZCLUSTER_IN_SINGLEUSER_MODE; + break; + default: + terrorCode = ZWRONG_STATE; + break; + } + abortErrorLab(signal); + return; + } + + case 58:{ + jam(); + releaseAtErrorLab(signal); + return; + } + + default: + jam(); + systemErrorLab(signal); + return; + }//switch +} + +void Dbtc::execKEYINFO(Signal* signal) +{ + UintR compare_transid1, compare_transid2; + jamEntry(); + apiConnectptr.i = signal->theData[0]; + tmaxData = 20; + if (apiConnectptr.i >= capiConnectFilesize) { + jam(); + warningHandlerLab(signal); + return; + }//if + ptrAss(apiConnectptr, apiConnectRecord); + ttransid_ptr = 1; + compare_transid1 = apiConnectptr.p->transid[0] ^ signal->theData[1]; + compare_transid2 = apiConnectptr.p->transid[1] ^ signal->theData[2]; + compare_transid1 = compare_transid1 | compare_transid2; + if (compare_transid1 != 0) { + jam(); + printState(signal, 10); + sendSignalErrorRefuseLab(signal); + return; + }//if + switch (apiConnectptr.p->apiConnectstate) { + case CS_RECEIVING: + case CS_REC_COMMITTING: + jam(); + /*empty*/; + break; + /* OK */ + case CS_ABORTING: + jam(); + return; /* IGNORE */ + case CS_CONNECTED: + jam(); + /****************************************************************>*/ + /* MOST LIKELY CAUSED BY A MISSED SIGNAL. SEND REFUSE AND */ + /* SET STATE TO ABORTING. */ + /****************************************************************>*/ + printState(signal, 11); + signalErrorRefuseLab(signal); + return; + case CS_STARTED: + jam(); + /****************************************************************>*/ + /* MOST LIKELY CAUSED BY A MISSED SIGNAL. SEND REFUSE AND */ + /* SET STATE TO ABORTING. SINCE A TRANSACTION WAS STARTED */ + /* WE ALSO NEED TO ABORT THIS TRANSACTION. */ + /****************************************************************>*/ + terrorCode = ZSIGNAL_ERROR; + printState(signal, 2); + abortErrorLab(signal); + return; + default: + jam(); + warningHandlerLab(signal); + return; + }//switch + + CacheRecord *localCacheRecord = cacheRecord; + UintR TcacheFilesize = ccacheFilesize; + UintR TcachePtr = apiConnectptr.p->cachePtr; + UintR TtcTimer = ctcTimer; + CacheRecord * const regCachePtr = &localCacheRecord[TcachePtr]; + if (TcachePtr >= TcacheFilesize) { + TCKEY_abort(signal, 42); + return; + }//if + setApiConTimer(apiConnectptr.i, TtcTimer, __LINE__); + cachePtr.i = TcachePtr; + cachePtr.p = regCachePtr; + + tcConnectptr.i = apiConnectptr.p->lastTcConnect; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + switch (tcConnectptr.p->tcConnectstate) { + case OS_WAIT_KEYINFO: + jam(); + tckeyreq020Lab(signal); + return; + default: + jam(); + terrorCode = ZSTATE_ERROR; + abortErrorLab(signal); + return; + }//switch +}//Dbtc::execKEYINFO() + +/*---------------------------------------------------------------------------*/ +/* */ +/* MORE THAN FOUR WORDS OF KEY DATA. WE NEED TO PACK THIS IN KEYINFO SIGNALS.*/ +/* WE WILL ALWAYS PACK 4 WORDS AT A TIME. */ +/*---------------------------------------------------------------------------*/ +void Dbtc::packKeyData000Lab(Signal* signal, + BlockReference TBRef) +{ + CacheRecord * const regCachePtr = cachePtr.p; + UintR Tmp; + Uint16 tdataPos; + + jam(); + tdataPos = 0; + Tmp = regCachePtr->keylen; + databufptr.i = regCachePtr->firstKeybuf; + do { + jam(); + if (tdataPos == 20) { + jam(); + /*---------------------------------------------------------------------*/ + /* 4 MORE WORDS WILL NOT FIT IN THE 24 DATA WORDS IN A SIGNAL */ + /*---------------------------------------------------------------------*/ + sendKeyinfo(signal, TBRef, 20); + tdataPos = 0; + }//if + Tmp = Tmp - 4; + ptrCheckGuard(databufptr, cdatabufFilesize, databufRecord); + cdata[tdataPos ] = databufptr.p->data[0]; + cdata[tdataPos + 1] = databufptr.p->data[1]; + cdata[tdataPos + 2] = databufptr.p->data[2]; + cdata[tdataPos + 3] = databufptr.p->data[3]; + tdataPos = tdataPos + 4; + if (Tmp <= 4) { + jam(); + /*---------------------------------------------------------------------*/ + /* LAST PACK OF KEY DATA HAVE BEEN SENT */ + /*---------------------------------------------------------------------*/ + /* THERE WERE UNSENT INFORMATION, SEND IT. */ + /*---------------------------------------------------------------------*/ + sendKeyinfo(signal, TBRef, tdataPos); + releaseKeys(signal); + return; + }//if + databufptr.i = databufptr.p->nextDatabuf; + } while (1); +}//Dbtc::packKeyData000Lab() + +void Dbtc::tckeyreq020Lab(Signal* signal) +{ + CacheRecord * const regCachePtr = cachePtr.p; + UintR TdataPos = 0; + UintR TkeyLen = regCachePtr->keylen; + UintR Tlen = regCachePtr->save1; + + do { + if (cfirstfreeDatabuf == RNIL) { + jam(); + seizeDatabuferrorLab(signal); + return; + }//if + linkKeybuf(signal); + arrGuard(TdataPos, 19); + databufptr.p->data[0] = signal->theData[TdataPos + 3]; + databufptr.p->data[1] = signal->theData[TdataPos + 4]; + databufptr.p->data[2] = signal->theData[TdataPos + 5]; + databufptr.p->data[3] = signal->theData[TdataPos + 6]; + Tlen = Tlen + 4; + TdataPos = TdataPos + 4; + if (Tlen < TkeyLen) { + jam(); + if (TdataPos >= tmaxData) { + jam(); + /*----------------------------------------------------*/ + /** EXIT AND WAIT FOR SIGNAL KEYINFO OR KEYINFO9 **/ + /** WHEN EITHER OF THE SIGNALS IS RECEIVED A JUMP **/ + /** TO LABEL "KEYINFO_LABEL" IS DONE. THEN THE **/ + /** PROGRAM RETURNS TO LABEL TCKEYREQ020 **/ + /*----------------------------------------------------*/ + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + regCachePtr->save1 = Tlen; + tcConnectptr.p->tcConnectstate = OS_WAIT_KEYINFO; + return; + }//if + } else { + jam(); + tckeyreq050Lab(signal); + return; + }//if + } while (1); + return; +}//Dbtc::tckeyreq020Lab() + +/* ------------------------------------------------------------------------- */ +/* ------- SAVE ATTRIBUTE INFORMATION IN OPERATION RECORD ------- */ +/* ------------------------------------------------------------------------- */ +void Dbtc::saveAttrbuf(Signal* signal) +{ + CacheRecord * const regCachePtr = cachePtr.p; + UintR TfirstfreeAttrbuf = cfirstfreeAttrbuf; + UintR TattrbufFilesize = cattrbufFilesize; + UintR TTcfirstAttrbuf = regCachePtr->firstAttrbuf; + UintR Tlen = signal->length() - 3; + AttrbufRecord *localAttrbufRecord = attrbufRecord; + + AttrbufRecord * const regAttrPtr = &localAttrbufRecord[TfirstfreeAttrbuf]; + if (TfirstfreeAttrbuf >= TattrbufFilesize) { + TCKEY_abort(signal, 21); + return; + }//if + UintR Tnext = regAttrPtr->attrbuf[ZINBUF_NEXT]; + if (TTcfirstAttrbuf == RNIL) { + jam(); + regCachePtr->firstAttrbuf = TfirstfreeAttrbuf; + } else { + AttrbufRecordPtr saAttrbufptr; + + saAttrbufptr.i = regCachePtr->lastAttrbuf; + jam(); + if (saAttrbufptr.i >= TattrbufFilesize) { + TCKEY_abort(signal, 22); + return; + }//if + saAttrbufptr.p = &localAttrbufRecord[saAttrbufptr.i]; + saAttrbufptr.p->attrbuf[ZINBUF_NEXT] = TfirstfreeAttrbuf; + }//if + + cfirstfreeAttrbuf = Tnext; + regAttrPtr->attrbuf[ZINBUF_NEXT] = RNIL; + regCachePtr->lastAttrbuf = TfirstfreeAttrbuf; + regAttrPtr->attrbuf[ZINBUF_DATA_LEN] = Tlen; + + UintR Tdata1 = signal->theData[3]; + UintR Tdata2 = signal->theData[4]; + UintR Tdata3 = signal->theData[5]; + UintR Tdata4 = signal->theData[6]; + UintR Tdata5 = signal->theData[7]; + UintR Tdata6 = signal->theData[8]; + UintR Tdata7 = signal->theData[9]; + UintR Tdata8 = signal->theData[10]; + + regAttrPtr->attrbuf[0] = Tdata1; + regAttrPtr->attrbuf[1] = Tdata2; + regAttrPtr->attrbuf[2] = Tdata3; + regAttrPtr->attrbuf[3] = Tdata4; + regAttrPtr->attrbuf[4] = Tdata5; + regAttrPtr->attrbuf[5] = Tdata6; + regAttrPtr->attrbuf[6] = Tdata7; + regAttrPtr->attrbuf[7] = Tdata8; + + if (Tlen > 8) { + + Tdata1 = signal->theData[11]; + Tdata2 = signal->theData[12]; + Tdata3 = signal->theData[13]; + Tdata4 = signal->theData[14]; + Tdata5 = signal->theData[15]; + Tdata6 = signal->theData[16]; + Tdata7 = signal->theData[17]; + + regAttrPtr->attrbuf[8] = Tdata1; + regAttrPtr->attrbuf[9] = Tdata2; + regAttrPtr->attrbuf[10] = Tdata3; + regAttrPtr->attrbuf[11] = Tdata4; + regAttrPtr->attrbuf[12] = Tdata5; + regAttrPtr->attrbuf[13] = Tdata6; + regAttrPtr->attrbuf[14] = Tdata7; + jam(); + if (Tlen > 15) { + + Tdata1 = signal->theData[18]; + Tdata2 = signal->theData[19]; + Tdata3 = signal->theData[20]; + Tdata4 = signal->theData[21]; + Tdata5 = signal->theData[22]; + Tdata6 = signal->theData[23]; + Tdata7 = signal->theData[24]; + + jam(); + regAttrPtr->attrbuf[15] = Tdata1; + regAttrPtr->attrbuf[16] = Tdata2; + regAttrPtr->attrbuf[17] = Tdata3; + regAttrPtr->attrbuf[18] = Tdata4; + regAttrPtr->attrbuf[19] = Tdata5; + regAttrPtr->attrbuf[20] = Tdata6; + regAttrPtr->attrbuf[21] = Tdata7; + }//if + }//if +}//Dbtc::saveAttrbuf() + +void Dbtc::execATTRINFO(Signal* signal) +{ + UintR compare_transid1, compare_transid2; + UintR Tdata1 = signal->theData[0]; + UintR Tlength = signal->length(); + UintR TapiConnectFilesize = capiConnectFilesize; + ApiConnectRecord *localApiConnectRecord = apiConnectRecord; + + jamEntry(); + apiConnectptr.i = Tdata1; + ttransid_ptr = 1; + if (Tdata1 >= TapiConnectFilesize) { + DEBUG("Drop ATTRINFO, wrong apiConnectptr"); + TCKEY_abort(signal, 18); + return; + }//if + + UintR Tdata2 = signal->theData[1]; + UintR Tdata3 = signal->theData[2]; + ApiConnectRecord * const regApiPtr = &localApiConnectRecord[Tdata1]; + compare_transid1 = regApiPtr->transid[0] ^ Tdata2; + compare_transid2 = regApiPtr->transid[1] ^ Tdata3; + apiConnectptr.p = regApiPtr; + compare_transid1 = compare_transid1 | compare_transid2; + + if (compare_transid1 != 0) { + DEBUG("Drop ATTRINFO, wrong transid, lenght="<*/ + /* HERE WE HAVE FOUND THAT THE LAST SIGNAL BELONGING TO THIS */ + /* OPERATION HAVE BEEN RECEIVED. THIS MEANS THAT WE CAN NOW REUSE */ + /* THE API CONNECT RECORD. HOWEVER IF PREPARE OR COMMIT HAVE BEEN */ + /* RECEIVED THEN IT IS NOT ALLOWED TO RECEIVE ANY FURTHER */ + /* OPERATIONS. */ + /****************************************************************>*/ + UintR TlastConnect = regApiPtr->lastTcConnect; + if (TcompRECEIVING) { + jam(); + regApiPtr->apiConnectstate = CS_STARTED; + } else { + jam(); + regApiPtr->apiConnectstate = CS_START_COMMITTING; + }//if + tcConnectptr.i = TlastConnect; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + attrinfoDihReceivedLab(signal); + } else if (TattrlengthRemain < 0) { + jam(); + DEBUG("ATTRINFO wrong total length="<*/ + /* MOST LIKELY CAUSED BY A MISSED SIGNAL. SEND REFUSE AND */ + /* SET STATE TO ABORTING. SINCE A TRANSACTION WAS STARTED */ + /* WE ALSO NEED TO ABORT THIS TRANSACTION. */ + /****************************************************************>*/ + terrorCode = ZSIGNAL_ERROR; + printState(signal, 1); + abortErrorLab(signal); + return; + default: + jam(); + /****************************************************************>*/ + /* SIGNAL RECEIVED IN AN UNEXPECTED STATE. WE IGNORE SIGNAL */ + /* SINCE WE DO NOT REALLY KNOW WHERE THE ERROR OCCURRED. */ + /****************************************************************>*/ + DEBUG("Drop ATTRINFO, illegal state="<apiConnectstate); + printState(signal, 9); + return; + }//switch + }//if +}//Dbtc::execATTRINFO() + +/* *********************************************************************>> */ +/* */ +/* MODULE: HASH MODULE */ +/* DESCRIPTION: CONTAINS THE HASH VALUE CALCULATION */ +/* *********************************************************************> */ +void Dbtc::hash(Signal* signal) +{ + DatabufRecordPtr locDatabufptr; + UintR ti; + UintR Tdata0; + UintR Tdata1; + UintR Tdata2; + UintR Tdata3; + UintR* Tdata32; + Uint64 Tdata[512]; + + CacheRecord * const regCachePtr = cachePtr.p; + Tdata32 = (UintR*)&Tdata[0]; + + Tdata0 = regCachePtr->keydata[0]; + Tdata1 = regCachePtr->keydata[1]; + Tdata2 = regCachePtr->keydata[2]; + Tdata3 = regCachePtr->keydata[3]; + Tdata32[0] = Tdata0; + Tdata32[1] = Tdata1; + Tdata32[2] = Tdata2; + Tdata32[3] = Tdata3; + if (regCachePtr->keylen > 4) { + locDatabufptr.i = regCachePtr->firstKeybuf; + ti = 4; + while (locDatabufptr.i != RNIL) { + ptrCheckGuard(locDatabufptr, cdatabufFilesize, databufRecord); + Tdata0 = locDatabufptr.p->data[0]; + Tdata1 = locDatabufptr.p->data[1]; + Tdata2 = locDatabufptr.p->data[2]; + Tdata3 = locDatabufptr.p->data[3]; + Tdata32[ti ] = Tdata0; + Tdata32[ti + 1] = Tdata1; + Tdata32[ti + 2] = Tdata2; + Tdata32[ti + 3] = Tdata3; + locDatabufptr.i = locDatabufptr.p->nextDatabuf; + ti += 4; + }//while + }//if + UintR ThashValue; + UintR TdistrHashValue; + ThashValue = md5_hash((Uint64*)&Tdata32[0], (UintR)regCachePtr->keylen); + + if (regCachePtr->distributionGroupIndicator == 1) { + if (regCachePtr->distributionGroupType == 1) { + jam(); + TdistrHashValue = (regCachePtr->distributionGroup << 6); + } else { + jam(); + Tdata32[0] = regCachePtr->distributionGroup; + TdistrHashValue = md5_hash((Uint64*)&Tdata32[0], (UintR)1); + }//if + } else if (regCachePtr->distributionKeyIndicator == 1) { + jam(); + TdistrHashValue = md5_hash((Uint64*)&Tdata32[0], + (UintR)regCachePtr->distributionKeySize); + } else { + jam(); + TdistrHashValue = ThashValue; + }//if + thashValue = ThashValue; + tdistrHashValue = TdistrHashValue; +}//Dbtc::hash() + +/* +INIT_API_CONNECT_REC +--------------------------- +*/ +/* ========================================================================= */ +/* ======= INIT_API_CONNECT_REC ======= */ +/* */ +/* ========================================================================= */ +void Dbtc::initApiConnectRec(Signal* signal, + ApiConnectRecord * const regApiPtr, + bool releaseIndexOperations) +{ + const TcKeyReq * const tcKeyReq = (TcKeyReq *)&signal->theData[0]; + UintR TfailureNr = cfailure_nr; + UintR TtransCount = ctransCount; + UintR Ttransid0 = tcKeyReq->transId1; + UintR Ttransid1 = tcKeyReq->transId2; + + regApiPtr->returnsignal = RS_TCKEYCONF; + regApiPtr->firstTcConnect = RNIL; + regApiPtr->lastTcConnect = RNIL; + regApiPtr->globalcheckpointid = 0; + regApiPtr->lqhkeyconfrec = 0; + regApiPtr->lqhkeyreqrec = 0; + regApiPtr->tckeyrec = 0; + regApiPtr->tcindxrec = 0; + regApiPtr->failureNr = TfailureNr; + regApiPtr->transid[0] = Ttransid0; + regApiPtr->transid[1] = Ttransid1; + regApiPtr->commitAckMarker = RNIL; + regApiPtr->buddyPtr = RNIL; + regApiPtr->currSavePointId = 0; + // Trigger data + releaseFiredTriggerData(®ApiPtr->theFiredTriggers), + // Index data + regApiPtr->indexOpReturn = false; + regApiPtr->noIndexOp = 0; + if(releaseIndexOperations) + releaseAllSeizedIndexOperations(regApiPtr); + + ctransCount = TtransCount + 1; +}//Dbtc::initApiConnectRec() + +int +Dbtc::seizeTcRecord(Signal* signal) +{ + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + TcConnectRecord *localTcConnectRecord = tcConnectRecord; + UintR TfirstfreeTcConnect = cfirstfreeTcConnect; + UintR TtcConnectFilesize = ctcConnectFilesize; + tcConnectptr.i = TfirstfreeTcConnect; + if (TfirstfreeTcConnect >= TtcConnectFilesize) { + int place = 3; + if (TfirstfreeTcConnect != RNIL) { + place = 10; + }//if + TCKEY_abort(signal, place); + return 1; + }//if + //-------------------------------------------------------------------------- + // Optimised version of ptrAss(tcConnectptr, tcConnectRecord) + //-------------------------------------------------------------------------- + TcConnectRecord * const regTcPtr = + &localTcConnectRecord[TfirstfreeTcConnect]; + + UintR TconcurrentOp = cconcurrentOp; + UintR TlastTcConnect = regApiPtr->lastTcConnect; + UintR TtcConnectptrIndex = tcConnectptr.i; + TcConnectRecordPtr tmpTcConnectptr; + + cfirstfreeTcConnect = regTcPtr->nextTcConnect; + tcConnectptr.p = regTcPtr; + + cconcurrentOp = TconcurrentOp + 1; + regTcPtr->prevTcConnect = TlastTcConnect; + regTcPtr->nextTcConnect = RNIL; + regTcPtr->accumulatingTriggerData.i = RNIL; + regTcPtr->accumulatingTriggerData.p = NULL; + regTcPtr->noFiredTriggers = 0; + regTcPtr->noReceivedTriggers = 0; + regTcPtr->triggerExecutionCount = 0; + regTcPtr->triggeringOperation = RNIL; + regTcPtr->triggerError = 0; + regTcPtr->isIndexOp = false; + regTcPtr->indexOp = RNIL; + regTcPtr->currentIndexId = RNIL; + + regApiPtr->lastTcConnect = TtcConnectptrIndex; + + if (TlastTcConnect == RNIL) { + jam(); + regApiPtr->firstTcConnect = TtcConnectptrIndex; + } else { + tmpTcConnectptr.i = TlastTcConnect; + jam(); + ptrCheckGuard(tmpTcConnectptr, TtcConnectFilesize, localTcConnectRecord); + tmpTcConnectptr.p->nextTcConnect = TtcConnectptrIndex; + }//if + return 0; +}//Dbtc::seizeTcRecord() + +int +Dbtc::seizeCacheRecord(Signal* signal) +{ + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + UintR TfirstfreeCacheRec = cfirstfreeCacheRec; + UintR TcacheFilesize = ccacheFilesize; + CacheRecord *localCacheRecord = cacheRecord; + if (TfirstfreeCacheRec >= TcacheFilesize) { + TCKEY_abort(signal, 41); + return 1; + }//if + CacheRecord * const regCachePtr = &localCacheRecord[TfirstfreeCacheRec]; + + regApiPtr->cachePtr = TfirstfreeCacheRec; + cfirstfreeCacheRec = regCachePtr->nextCacheRec; + cachePtr.i = TfirstfreeCacheRec; + cachePtr.p = regCachePtr; + +#ifdef VM_TRACE + // This is a good place to check that resources have + // been properly released from CacheRecord + ndbrequire(regCachePtr->firstKeybuf == RNIL); + ndbrequire(regCachePtr->lastKeybuf == RNIL); +#endif + regCachePtr->firstKeybuf = RNIL; + regCachePtr->lastKeybuf = RNIL; + regCachePtr->firstAttrbuf = RNIL; + regCachePtr->lastAttrbuf = RNIL; + regCachePtr->currReclenAi = 0; + return 0; +}//Dbtc::seizeCacheRecord() + +/*****************************************************************************/ +/* T C K E Y R E Q */ +/* AFTER HAVING ESTABLISHED THE CONNECT, THE APPLICATION BLOCK SENDS AN */ +/* OPERATION REQUEST TO TC. ALL NECESSARY INFORMATION TO CARRY OUT REQUEST */ +/* IS FURNISHED IN PARAMETERS. TC STORES THIS INFORMATION AND ENQUIRES */ +/* FROM DIH ABOUT THE NODES WHICH MAY HAVE THE REQUESTED DATA */ +/*****************************************************************************/ +void Dbtc::execTCKEYREQ(Signal* signal) +{ + UintR compare_transid1, compare_transid2; + UintR titcLenAiInTckeyreq; + UintR TkeyLength; + const TcKeyReq * const tcKeyReq = (TcKeyReq *)signal->getDataPtr(); + UintR Treqinfo; + + jamEntry(); + /*------------------------------------------------------------------------- + * Common error routines are used for several signals, they need to know + * where to find the transaction identifier in the signal. + *-------------------------------------------------------------------------*/ + const UintR TapiIndex = tcKeyReq->apiConnectPtr; + const UintR TapiMaxIndex = capiConnectFilesize; + const UintR TtabIndex = tcKeyReq->tableId; + const UintR TtabMaxIndex = ctabrecFilesize; + ApiConnectRecord *localApiConnectRecord = apiConnectRecord; + + ttransid_ptr = 6; + apiConnectptr.i = TapiIndex; + if (TapiIndex >= TapiMaxIndex) { + TCKEY_abort(signal, 6); + return; + }//if + if (TtabIndex >= TtabMaxIndex) { + TCKEY_abort(signal, 7); + return; + }//if + + Treqinfo = tcKeyReq->requestInfo; + //-------------------------------------------------------------------------- + // Optimised version of ptrAss(tabptr, tableRecord) + // Optimised version of ptrAss(apiConnectptr, apiConnectRecord) + //-------------------------------------------------------------------------- + ApiConnectRecord * const regApiPtr = &localApiConnectRecord[TapiIndex]; + apiConnectptr.p = regApiPtr; + + Uint32 TstartFlag = tcKeyReq->getStartFlag(Treqinfo); + bool isIndexOp = regApiPtr->isIndexOp; + bool isIndexOpReturn = regApiPtr->indexOpReturn; + regApiPtr->isIndexOp = false; // Reset marker + switch (regApiPtr->apiConnectstate) { + case CS_CONNECTED:{ + if (TstartFlag == 1 && getAllowStartTransaction() == true){ + //--------------------------------------------------------------------- + // Initialise API connect record if transaction is started. + //--------------------------------------------------------------------- + jam(); + initApiConnectRec(signal, regApiPtr); + } else { + if(getAllowStartTransaction() == true){ + /*------------------------------------------------------------------ + * WE EXPECTED A START TRANSACTION. SINCE NO OPERATIONS HAVE BEEN + * RECEIVED WE INDICATE THIS BY SETTING FIRST_TC_CONNECT TO RNIL TO + * ENSURE PROPER OPERATION OF THE COMMON ABORT HANDLING. + *-----------------------------------------------------------------*/ + TCKEY_abort(signal, 0); + return; + } else { + /** + * getAllowStartTransaction() == false + */ + TCKEY_abort(signal, 57); + return; + }//if + } + } + break; + case CS_STARTED: + //------------------------------------------------------------------------ + // Transaction is started already. Check that the operation is on the same + // transaction. + //------------------------------------------------------------------------ + compare_transid1 = regApiPtr->transid[0] ^ tcKeyReq->transId1; + compare_transid2 = regApiPtr->transid[1] ^ tcKeyReq->transId2; + jam(); + compare_transid1 = compare_transid1 | compare_transid2; + if (compare_transid1 != 0) { + TCKEY_abort(signal, 1); + return; + }//if + break; + case CS_ABORTING: + if (regApiPtr->abortState == AS_IDLE) { + if (TstartFlag == 1) { + //-------------------------------------------------------------------- + // Previous transaction had been aborted and the abort was completed. + // It is then OK to start a new transaction again. + //-------------------------------------------------------------------- + jam(); + initApiConnectRec(signal, regApiPtr); + } else { + //-------------------------------------------------------------------- + // The current transaction was aborted successfully. + // We will not do anything before we receive an operation + // with a start indicator. We will ignore this signal. + //-------------------------------------------------------------------- + jam(); + // DEBUG("Drop TCKEYREQ - apiConnectState=CS_ABORTING, ==AS_IDLE"); + return; + }//if + } else { + //---------------------------------------------------------------------- + // Previous transaction is still aborting + //---------------------------------------------------------------------- + jam(); + if (TstartFlag == 1) { + //-------------------------------------------------------------------- + // If a new transaction tries to start while the old is + // still aborting, we will report this to the starting API. + //-------------------------------------------------------------------- + TCKEY_abort(signal, 2); + return; + }//if + //---------------------------------------------------------------------- + // Ignore signals without start indicator set when aborting transaction. + //---------------------------------------------------------------------- + // DEBUG("Drop TCKEYREQ - apiConnectState=CS_ABORTING, !=AS_IDLE"); + return; + }//if + break; + case CS_START_COMMITTING: + jam(); + if(isIndexOpReturn || TcKeyReq::getExecutingTrigger(Treqinfo)){ + break; + } + default: + jam(); + /*---------------------------------------------------------------------- + * IN THIS CASE THE NDBAPI IS AN UNTRUSTED ENTITY THAT HAS SENT A SIGNAL + * WHEN IT WAS NOT EXPECTED TO. + * WE MIGHT BE IN A PROCESS TO RECEIVE, PREPARE, + * COMMIT OR COMPLETE AND OBVIOUSLY THIS IS NOT A DESIRED EVENT. + * WE WILL ALWAYS COMPLETE THE ABORT HANDLING BEFORE WE ALLOW + * ANYTHING TO HAPPEN ON THIS CONNECTION AGAIN. + * THUS THERE IS NO ACTION FROM THE API THAT CAN SPEED UP THIS PROCESS. + *---------------------------------------------------------------------*/ + TCKEY_abort(signal, 55); + return; + }//switch + + TableRecordPtr localTabptr; + localTabptr.i = TtabIndex; + localTabptr.p = &tableRecord[TtabIndex]; + if (localTabptr.p->checkTable(tcKeyReq->tableSchemaVersion)) { + ; + } else { + /*-----------------------------------------------------------------------*/ + /* THE API IS WORKING WITH AN OLD SCHEMA VERSION. IT NEEDS REPLACEMENT. */ + /* COULD ALSO BE THAT THE TABLE IS NOT DEFINED. */ + /*-----------------------------------------------------------------------*/ + TCKEY_abort(signal, 8); + return; + }//if + + //------------------------------------------------------------------------- + // Error Insertion for testing purposes. Test to see what happens when no + // more TC records available. + //------------------------------------------------------------------------- + if (ERROR_INSERTED(8032)) { + TCKEY_abort(signal, 3); + return; + }//if + + if (seizeTcRecord(signal) != 0) { + return; + }//if + + if (seizeCacheRecord(signal) != 0) { + return; + }//if + + TcConnectRecord * const regTcPtr = tcConnectptr.p; + CacheRecord * const regCachePtr = cachePtr.p; + + /* + INIT_TC_CONNECT_REC + ------------------------- + */ + /* ---------------------------------------------------------------------- */ + /* ------- INIT OPERATION RECORD WITH SIGNAL DATA AND RNILS ------- */ + /* */ + /* ---------------------------------------------------------------------- */ + + UintR TapiVersionNo = tcKeyReq->getAPIVersion(tcKeyReq->attrLen); + UintR Tlqhkeyreqrec = regApiPtr->lqhkeyreqrec; + regApiPtr->lqhkeyreqrec = Tlqhkeyreqrec + 1; + regCachePtr->apiVersionNo = TapiVersionNo; + + UintR TapiConnectptrIndex = apiConnectptr.i; + UintR TsenderData = tcKeyReq->senderData; + UintR TattrLen = tcKeyReq->getAttrinfoLen(tcKeyReq->attrLen); + UintR TattrinfoCount = cattrinfoCount; + + regTcPtr->apiConnect = TapiConnectptrIndex; + regTcPtr->clientData = TsenderData; + regTcPtr->commitAckMarker = RNIL; + regTcPtr->isIndexOp = isIndexOp; + regTcPtr->indexOp = regApiPtr->executingIndexOp; + regTcPtr->savePointId = regApiPtr->currSavePointId; + regApiPtr->executingIndexOp = RNIL; + + if (TcKeyReq::getExecutingTrigger(Treqinfo)) { + // Save the TcOperationPtr for fireing operation + regTcPtr->triggeringOperation = TsenderData; + } + + if (TcKeyReq::getExecuteFlag(Treqinfo)){ + Uint32 currSPId = regApiPtr->currSavePointId; + regApiPtr->currSavePointId = ++currSPId; + } + + regCachePtr->attrlength = TattrLen; + cattrinfoCount = TattrinfoCount + TattrLen; + + UintR TtabptrIndex = localTabptr.i; + UintR TtableSchemaVersion = tcKeyReq->tableSchemaVersion; + Uint8 TOperationType = tcKeyReq->getOperationType(Treqinfo); + regCachePtr->tableref = TtabptrIndex; + regCachePtr->schemaVersion = TtableSchemaVersion; + regTcPtr->operation = TOperationType; + + // Uint8 TSimpleFlag = tcKeyReq->getSimpleFlag(Treqinfo); + Uint8 TDirtyFlag = tcKeyReq->getDirtyFlag(Treqinfo); + Uint8 TInterpretedFlag = tcKeyReq->getInterpretedFlag(Treqinfo); + Uint8 TDistrGroupFlag = tcKeyReq->getDistributionGroupFlag(Treqinfo); + Uint8 TDistrGroupTypeFlag = tcKeyReq->getDistributionGroupTypeFlag(Treqinfo); + Uint8 TDistrKeyFlag = tcKeyReq->getDistributionKeyFlag(Treqinfo); + Uint8 TexecuteFlag = tcKeyReq->getExecuteFlag(Treqinfo); + + //RONM_TEST Disable simple reads temporarily + regCachePtr->opSimple = 0; + // regCachePtr->opSimple = TSimpleFlag; + regTcPtr->dirtyOp = TDirtyFlag; + regCachePtr->opExec = TInterpretedFlag; + + regCachePtr->distributionGroupIndicator = TDistrGroupFlag; + regCachePtr->distributionGroupType = TDistrGroupTypeFlag; + regCachePtr->distributionKeyIndicator = TDistrKeyFlag; + + //------------------------------------------------------------- + // The next step is to read the upto three conditional words. + //------------------------------------------------------------- + Uint32 TkeyIndex; + Uint32* TOptionalDataPtr = (Uint32*)&tcKeyReq->scanInfo; + { + Uint32 TDistrGHIndex = tcKeyReq->getScanIndFlag(Treqinfo); + Uint32 TDistrKeyIndex = TDistrGHIndex + TDistrGroupFlag; + Uint32 TscanNode = tcKeyReq->getTakeOverScanNode(TOptionalDataPtr[0]); + Uint32 TscanInfo = tcKeyReq->getTakeOverScanInfo(TOptionalDataPtr[0]); + + regCachePtr->scanTakeOverInd = TDistrGHIndex; + regCachePtr->scanNode = TscanNode; + regCachePtr->scanInfo = TscanInfo; + + regCachePtr->distributionGroup = TOptionalDataPtr[TDistrGHIndex]; + regCachePtr->distributionKeySize = TOptionalDataPtr[TDistrKeyIndex]; + + TkeyIndex = TDistrKeyIndex + TDistrKeyFlag; + } + Uint32* TkeyDataPtr = &TOptionalDataPtr[TkeyIndex]; + + UintR Tdata1 = TkeyDataPtr[0]; + UintR Tdata2 = TkeyDataPtr[1]; + UintR Tdata3 = TkeyDataPtr[2]; + UintR Tdata4 = TkeyDataPtr[3]; + UintR Tdata5; + + regCachePtr->keydata[0] = Tdata1; + regCachePtr->keydata[1] = Tdata2; + regCachePtr->keydata[2] = Tdata3; + regCachePtr->keydata[3] = Tdata4; + + TkeyLength = tcKeyReq->getKeyLength(Treqinfo); + Uint32 TAIDataIndex; + if (TkeyLength > 8) { + TAIDataIndex = TkeyIndex + 8; + } else { + if (TkeyLength == 0) { + TCKEY_abort(signal, 4); + return; + }//if + TAIDataIndex = TkeyIndex + TkeyLength; + }//if + Uint32* TAIDataPtr = &TOptionalDataPtr[TAIDataIndex]; + + titcLenAiInTckeyreq = tcKeyReq->getAIInTcKeyReq(Treqinfo); + regCachePtr->keylen = TkeyLength; + regCachePtr->lenAiInTckeyreq = titcLenAiInTckeyreq; + regCachePtr->currReclenAi = titcLenAiInTckeyreq; + + Tdata1 = TAIDataPtr[0]; + Tdata2 = TAIDataPtr[1]; + Tdata3 = TAIDataPtr[2]; + Tdata4 = TAIDataPtr[3]; + Tdata5 = TAIDataPtr[4]; + + regCachePtr->attrinfo0 = Tdata1; + regCachePtr->attrinfo15[0] = Tdata2; + regCachePtr->attrinfo15[1] = Tdata3; + regCachePtr->attrinfo15[2] = Tdata4; + regCachePtr->attrinfo15[3] = Tdata5; + + if (TOperationType == ZREAD) { + Uint8 TreadCount = creadCount; + jam(); + regCachePtr->opLock = 0; + creadCount = TreadCount + 1; + } else if(TOperationType == ZREAD_EX){ + Uint8 TreadCount = creadCount; + jam(); + TOperationType = ZREAD; + regTcPtr->operation = ZREAD; + regCachePtr->opLock = ZUPDATE; + creadCount = TreadCount + 1; + } else { + if(regApiPtr->commitAckMarker == RNIL){ + jam(); + CommitAckMarkerPtr tmp; + if(!m_commitAckMarkerHash.seize(tmp)){ + TCKEY_abort(signal, 56); + return; + } else { + regTcPtr->commitAckMarker = tmp.i; + regApiPtr->commitAckMarker = tmp.i; + tmp.p->transid1 = tcKeyReq->transId1; + tmp.p->transid2 = tcKeyReq->transId2; + tmp.p->apiNodeId = refToNode(regApiPtr->ndbapiBlockref); + tmp.p->apiConnectPtr = TapiIndex; + tmp.p->noOfLqhs = 0; + m_commitAckMarkerHash.add(tmp); + } + } + + UintR Tattrlength = regCachePtr->attrlength; + UintR TwriteCount = cwriteCount; + UintR Toperationsize = coperationsize; + /* -------------------------------------------------------------------- + * THIS IS A TEMPORARY TABLE, DON'T UPDATE coperationsize. + * THIS VARIABLE CONTROLS THE INTERVAL BETWEEN LCP'S AND + * TEMP TABLES DON'T PARTICIPATE. + * -------------------------------------------------------------------- */ + if (localTabptr.p->storedTable) { + coperationsize = ((Toperationsize + Tattrlength) + TkeyLength) + 17; + } + cwriteCount = TwriteCount + 1; + switch (TOperationType) { + case ZUPDATE: + jam(); + if (Tattrlength == 0) { + TCKEY_abort(signal, 5); + return; + }//if + /*---------------------------------------------------------------------*/ + // The missing break is intentional since we also want to set the opLock + // variable also for updates + /*---------------------------------------------------------------------*/ + case ZINSERT: + case ZDELETE: + jam(); + regCachePtr->opLock = TOperationType; + break; + case ZWRITE: + jam(); + // A write operation is originally an insert operation. + regCachePtr->opLock = ZINSERT; + break; + default: + TCKEY_abort(signal, 9); + return; + }//switch + }//if + + Uint32 TabortOption = tcKeyReq->getAbortOption(Treqinfo); + regTcPtr->m_execAbortOption = TabortOption; + + /*------------------------------------------------------------------------- + * Check error handling per operation + * If CommitFlag is set state accordingly and check for early abort + *------------------------------------------------------------------------*/ + if (tcKeyReq->getCommitFlag(Treqinfo) == 1) { + ndbrequire(TexecuteFlag); + regApiPtr->apiConnectstate = CS_REC_COMMITTING; + } else { + /* --------------------------------------------------------------------- + * PREPARE TRANSACTION IS NOT IMPLEMENTED YET. + * --------------------------------------------------------------------- + * ELSIF (TREQINFO => 3) (*) 1 = 1 THEN + * IF PREPARE TRANSACTION THEN + * API_CONNECTPTR:API_CONNECTSTATE = REC_PREPARING + * SET STATE TO PREPARING + * --------------------------------------------------------------------- */ + if (regApiPtr->apiConnectstate == CS_START_COMMITTING) { + jam(); + // Trigger execution at commit + + regApiPtr->apiConnectstate = CS_REC_COMMITTING; + } else { + jam(); + regApiPtr->apiConnectstate = CS_RECEIVING; + }//if + }//if + if (TkeyLength <= 4) { + tckeyreq050Lab(signal); + return; + } else { + if (cfirstfreeDatabuf != RNIL) { + jam(); + linkKeybuf(signal); + Tdata1 = TkeyDataPtr[4]; + Tdata2 = TkeyDataPtr[5]; + Tdata3 = TkeyDataPtr[6]; + Tdata4 = TkeyDataPtr[7]; + + DatabufRecord * const regDataPtr = databufptr.p; + regDataPtr->data[0] = Tdata1; + regDataPtr->data[1] = Tdata2; + regDataPtr->data[2] = Tdata3; + regDataPtr->data[3] = Tdata4; + } else { + jam(); + seizeDatabuferrorLab(signal); + return; + }//if + if (TkeyLength <= 8) { + jam(); + tckeyreq050Lab(signal); + return; + } else { + jam(); + /* -------------------------------------------------------------------- + * THE TCKEYREQ DIDN'T CONTAIN ALL KEY DATA, + * SAVE STATE AND WAIT FOR KEYINFO + * --------------------------------------------------------------------*/ + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + regCachePtr->save1 = 8; + regTcPtr->tcConnectstate = OS_WAIT_KEYINFO; + return; + }//if + }//if + return; +}//Dbtc::execTCKEYREQ() + +void Dbtc::tckeyreq050Lab(Signal* signal) +{ + UintR tnoOfBackup; + UintR tnoOfStandby; + UintR tnodeinfo; + + hash(signal); /* NOW IT IS TIME TO CALCULATE THE HASH VALUE*/ + + CacheRecord * const regCachePtr = cachePtr.p; + TcConnectRecord * const regTcPtr = tcConnectptr.p; + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + + UintR TtcTimer = ctcTimer; + UintR ThashValue = thashValue; + UintR TdistrHashValue = tdistrHashValue; + UintR TdihConnectptr = regTcPtr->dihConnectptr; + UintR Ttableref = regCachePtr->tableref; + + TableRecordPtr localTabptr; + localTabptr.i = Ttableref; + localTabptr.p = &tableRecord[localTabptr.i]; + Uint32 schemaVersion = regCachePtr->schemaVersion; + if(localTabptr.p->checkTable(schemaVersion)){ + ; + } else { + terrorCode = localTabptr.p->getErrorCode(schemaVersion); + TCKEY_abort(signal, 58); + return; + } + + setApiConTimer(apiConnectptr.i, TtcTimer, __LINE__); + regCachePtr->hashValue = ThashValue; + + signal->theData[0] = TdihConnectptr; + signal->theData[1] = Ttableref; + signal->theData[2] = TdistrHashValue; + + /*-------------------------------------------------------------*/ + /* FOR EFFICIENCY REASONS WE AVOID THE SIGNAL SENDING HERE AND */ + /* PROCEED IMMEDIATELY TO DIH. IN MULTI-THREADED VERSIONS WE */ + /* HAVE TO INSERT A MUTEX ON DIH TO ENSURE PROPER OPERATION. */ + /* SINCE THIS SIGNAL AND DIVERIFYREQ ARE THE ONLY SIGNALS SENT */ + /* TO DIH IN TRAFFIC IT SHOULD BE OK (3% OF THE EXECUTION TIME */ + /* IS SPENT IN DIH AND EVEN LESS IN REPLICATED NDB. */ + /*-------------------------------------------------------------*/ + EXECUTE_DIRECT(DBDIH, GSN_DIGETNODESREQ, signal, 3); + UintR TerrorIndicator = signal->theData[0]; + jamEntry(); + if (TerrorIndicator != 0) { + execDIGETNODESREF(signal); + return; + } + /****************>>*/ + /* DIGETNODESCONF >*/ + /* ***************>*/ + + UintR Tdata1 = signal->theData[1]; + UintR Tdata2 = signal->theData[2]; + UintR Tdata3 = signal->theData[3]; + UintR Tdata4 = signal->theData[4]; + UintR Tdata5 = signal->theData[5]; + UintR Tdata6 = signal->theData[6]; + + regCachePtr->fragmentid = Tdata1; + tnodeinfo = Tdata2; + + regTcPtr->tcNodedata[0] = Tdata3; + regTcPtr->tcNodedata[1] = Tdata4; + regTcPtr->tcNodedata[2] = Tdata5; + regTcPtr->tcNodedata[3] = Tdata6; + + Uint8 Toperation = regTcPtr->operation; + tnoOfBackup = tnodeinfo & 3; + tnoOfStandby = (tnodeinfo >> 8) & 3; + + regCachePtr->distributionKey = (tnodeinfo >> 16) & 255; + if (Toperation == ZREAD) { + if (regCachePtr->opSimple == 1) { + jam(); + /*-------------------------------------------------------------*/ + /* A SIMPLE READ CAN SELECT ANY OF THE PRIMARY AND */ + /* BACKUP NODES TO READ. WE WILL TRY TO SELECT THIS */ + /* NODE IF POSSIBLE TO AVOID UNNECESSARY COMMUNICATION */ + /* WITH SIMPLE READS. */ + /*-------------------------------------------------------------*/ + arrGuard(tnoOfBackup, 4); + UintR Tindex; + for (Tindex = 1; Tindex <= tnoOfBackup; Tindex++) { + UintR Tnode = regTcPtr->tcNodedata[Tindex]; + UintR TownNode = cownNodeid; + jam(); + if (Tnode == TownNode) { + jam(); + regTcPtr->tcNodedata[0] = Tnode; + }//if + }//for + if (regCachePtr->attrlength == 0) { + /*-------------------------------------------------------------*/ + // A simple read which does not read anything is a strange + // creature and we abort rather than continue. + /*-------------------------------------------------------------*/ + TCKEY_abort(signal, 12); + return; + }//if + }//if + jam(); + regTcPtr->lastReplicaNo = 0; + regTcPtr->noOfNodes = 1; + } else { + UintR TlastReplicaNo; + jam(); + TlastReplicaNo = tnoOfBackup + tnoOfStandby; + regTcPtr->lastReplicaNo = (Uint8)TlastReplicaNo; + regTcPtr->noOfNodes = (Uint8)(TlastReplicaNo + 1); + }//if + if (regCachePtr->lenAiInTckeyreq == regCachePtr->attrlength) { + /****************************************************************>*/ + /* HERE WE HAVE FOUND THAT THE LAST SIGNAL BELONGING TO THIS */ + /* OPERATION HAVE BEEN RECEIVED. THIS MEANS THAT WE CAN NOW REUSE */ + /* THE API CONNECT RECORD. HOWEVER IF PREPARE OR COMMIT HAVE BEEN */ + /* RECEIVED THEN IT IS NOT ALLOWED TO RECEIVE ANY FURTHER */ + /* OPERATIONS. WE KNOW THAT WE WILL WAIT FOR DICT NEXT. IT IS NOT */ + /* POSSIBLE FOR THE TC CONNECTION TO BE READY YET. */ + /****************************************************************>*/ + switch (regApiPtr->apiConnectstate) { + case CS_RECEIVING: + jam(); + regApiPtr->apiConnectstate = CS_STARTED; + break; + case CS_REC_COMMITTING: + jam(); + regApiPtr->apiConnectstate = CS_START_COMMITTING; + break; + default: + jam(); + systemErrorLab(signal); + return; + }//switch + attrinfoDihReceivedLab(signal); + return; + } else { + if (regCachePtr->lenAiInTckeyreq < regCachePtr->attrlength) { + TtcTimer = ctcTimer; + jam(); + setApiConTimer(apiConnectptr.i, TtcTimer, __LINE__); + regTcPtr->tcConnectstate = OS_WAIT_ATTR; + return; + } else { + TCKEY_abort(signal, 11); + return; + }//if + }//if + return; +}//Dbtc::tckeyreq050Lab() + +void Dbtc::attrinfoDihReceivedLab(Signal* signal) +{ + CacheRecord * const regCachePtr = cachePtr.p; + TcConnectRecord * const regTcPtr = tcConnectptr.p; + Uint16 Tnode = regTcPtr->tcNodedata[0]; + Uint16 TscanTakeOverInd = regCachePtr->scanTakeOverInd; + Uint16 TscanNode = regCachePtr->scanNode; + + TableRecordPtr localTabptr; + localTabptr.i = regCachePtr->tableref; + localTabptr.p = &tableRecord[localTabptr.i]; + + if(localTabptr.p->checkTable(regCachePtr->schemaVersion)){ + ; + } else { + terrorCode = localTabptr.p->getErrorCode(regCachePtr->schemaVersion); + TCKEY_abort(signal, 58); + return; + } + if ((TscanTakeOverInd == 1) && + (Tnode != TscanNode)) { + TCKEY_abort(signal, 15); + return; + }//if + arrGuard(Tnode, MAX_NDB_NODES); + packLqhkeyreq(signal, calcLqhBlockRef(Tnode)); +}//Dbtc::attrinfoDihReceivedLab() + +void Dbtc::packLqhkeyreq(Signal* signal, + BlockReference TBRef) +{ + CacheRecord * const regCachePtr = cachePtr.p; + UintR Tkeylen = regCachePtr->keylen; + UintR TfirstAttrbuf = regCachePtr->firstAttrbuf; + sendlqhkeyreq(signal, TBRef); + if (Tkeylen > 4) { + packKeyData000Lab(signal, TBRef); + }//if + packLqhkeyreq040Lab(signal, + TfirstAttrbuf, + TBRef); +}//Dbtc::packLqhkeyreq() + +void Dbtc::sendlqhkeyreq(Signal* signal, + BlockReference TBRef) +{ + UintR tslrAttrLen; + UintR Tdata10; + TcConnectRecord * const regTcPtr = tcConnectptr.p; + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + CacheRecord * const regCachePtr = cachePtr.p; +#ifdef ERROR_INSERT + if (ERROR_INSERTED(8002)) { + systemErrorLab(signal); + }//if + if (ERROR_INSERTED(8007)) { + if (apiConnectptr.p->apiConnectstate == CS_STARTED) { + CLEAR_ERROR_INSERT_VALUE; + return; + }//if + }//if + if (ERROR_INSERTED(8008)) { + if (apiConnectptr.p->apiConnectstate == CS_START_COMMITTING) { + CLEAR_ERROR_INSERT_VALUE; + return; + }//if + }//if + if (ERROR_INSERTED(8009)) { + if (apiConnectptr.p->apiConnectstate == CS_STARTED) { + return; + }//if + }//if + if (ERROR_INSERTED(8010)) { + if (apiConnectptr.p->apiConnectstate == CS_START_COMMITTING) { + return; + }//if + }//if +#endif + + tslrAttrLen = 0; + LqhKeyReq::setAttrLen(tslrAttrLen, regCachePtr->attrlength); + /* ---------------------------------------------------------------------- */ + // Bit16 == 0 since StoredProcedures are not yet supported. + /* ---------------------------------------------------------------------- */ + LqhKeyReq::setDistributionKey(tslrAttrLen, regCachePtr->distributionKey); + LqhKeyReq::setScanTakeOverFlag(tslrAttrLen, regCachePtr->scanTakeOverInd); + + Tdata10 = 0; + LqhKeyReq::setKeyLen(Tdata10, regCachePtr->keylen); + LqhKeyReq::setLastReplicaNo(Tdata10, regTcPtr->lastReplicaNo); + LqhKeyReq::setLockType(Tdata10, regCachePtr->opLock); + /* ---------------------------------------------------------------------- */ + // Indicate Application Reference is present in bit 15 + /* ---------------------------------------------------------------------- */ + LqhKeyReq::setApplicationAddressFlag(Tdata10, 1); + LqhKeyReq::setDirtyFlag(Tdata10, regTcPtr->dirtyOp); + LqhKeyReq::setInterpretedFlag(Tdata10, regCachePtr->opExec); + LqhKeyReq::setSimpleFlag(Tdata10, regCachePtr->opSimple); + LqhKeyReq::setOperation(Tdata10, regTcPtr->operation); + /* ----------------------------------------------------------------------- + * Sequential Number of first LQH = 0, bit 22-23 + * IF ATTRIBUTE INFORMATION IS SENT IN TCKEYREQ, + * IT IS ALSO SENT IN LQHKEYREQ + * ----------------------------------------------------------------------- */ + LqhKeyReq::setAIInLqhKeyReq(Tdata10, regCachePtr->lenAiInTckeyreq); + /* ----------------------------------------------------------------------- + * Bit 27 == 0 since TC record is the same as the client record. + * Bit 28 == 0 since readLenAi can only be set after reading in LQH. + * ----------------------------------------------------------------------- */ + //LqhKeyReq::setAPIVersion(Tdata10, regCachePtr->apiVersionNo); + Uint32 commitAckMarker = regTcPtr->commitAckMarker; + if(commitAckMarker != RNIL){ + jam(); + + LqhKeyReq::setMarkerFlag(Tdata10, 1); + + CommitAckMarker * tmp; + tmp = m_commitAckMarkerHash.getPtr(commitAckMarker); + + /** + * Populate LQH array + */ + const Uint32 noOfLqhs = regTcPtr->noOfNodes; + tmp->noOfLqhs = noOfLqhs; + for(Uint32 i = 0; ilqhNodeId[i] = regTcPtr->tcNodedata[i]; + } + } + + /* ************************************************************> */ + /* NO READ LENGTH SENT FROM TC. SEQUENTIAL NUMBER IS 1 AND IT */ + /* IS SENT TO A PRIMARY NODE. */ + /* ************************************************************> */ + UintR sig0, sig1, sig2, sig3, sig4, sig5, sig6; + + LqhKeyReq * const lqhKeyReq = (LqhKeyReq *)signal->getDataPtrSend(); + + sig0 = tcConnectptr.i; + sig2 = regCachePtr->hashValue; + sig4 = cownref; + sig5 = regTcPtr->savePointId; + + lqhKeyReq->clientConnectPtr = sig0; + lqhKeyReq->attrLen = tslrAttrLen; + lqhKeyReq->hashValue = sig2; + lqhKeyReq->requestInfo = Tdata10; + lqhKeyReq->tcBlockref = sig4; + lqhKeyReq->savePointId = sig5; + + sig0 = regCachePtr->tableref + (regCachePtr->schemaVersion << 16); + sig1 = regCachePtr->fragmentid + (regTcPtr->tcNodedata[1] << 16); + sig2 = regApiPtr->transid[0]; + sig3 = regApiPtr->transid[1]; + sig4 = regApiPtr->ndbapiBlockref; + sig5 = regTcPtr->clientData; + sig6 = regCachePtr->scanInfo; + + lqhKeyReq->tableSchemaVersion = sig0; + lqhKeyReq->fragmentData = sig1; + lqhKeyReq->transId1 = sig2; + lqhKeyReq->transId2 = sig3; + lqhKeyReq->scanInfo = sig6; + + lqhKeyReq->variableData[0] = sig4; + lqhKeyReq->variableData[1] = sig5; + + UintR nextPos = 2; + + if (regTcPtr->lastReplicaNo > 1) { + sig0 = (UintR)regTcPtr->tcNodedata[2] + + (UintR)(regTcPtr->tcNodedata[3] << 16); + lqhKeyReq->variableData[nextPos] = sig0; + nextPos++; + }//if + + sig0 = regCachePtr->keydata[0]; + sig1 = regCachePtr->keydata[1]; + sig2 = regCachePtr->keydata[2]; + sig3 = regCachePtr->keydata[3]; + UintR Tkeylen = regCachePtr->keylen; + + lqhKeyReq->variableData[nextPos + 0] = sig0; + lqhKeyReq->variableData[nextPos + 1] = sig1; + lqhKeyReq->variableData[nextPos + 2] = sig2; + lqhKeyReq->variableData[nextPos + 3] = sig3; + + if (Tkeylen < 4) { + nextPos += Tkeylen; + } else { + nextPos += 4; + }//if + + sig0 = regCachePtr->attrinfo0; + sig1 = regCachePtr->attrinfo15[0]; + sig2 = regCachePtr->attrinfo15[1]; + sig3 = regCachePtr->attrinfo15[2]; + sig4 = regCachePtr->attrinfo15[3]; + UintR TlenAi = regCachePtr->lenAiInTckeyreq; + + lqhKeyReq->variableData[nextPos + 0] = sig0; + lqhKeyReq->variableData[nextPos + 1] = sig1; + lqhKeyReq->variableData[nextPos + 2] = sig2; + lqhKeyReq->variableData[nextPos + 3] = sig3; + lqhKeyReq->variableData[nextPos + 4] = sig4; + + nextPos += TlenAi; + + // Reset trigger count + regTcPtr->accumulatingTriggerData.i = RNIL; + regTcPtr->accumulatingTriggerData.p = NULL; + regTcPtr->noFiredTriggers = 0; + regTcPtr->triggerExecutionCount = 0; + + sendSignal(TBRef, GSN_LQHKEYREQ, signal, + nextPos + LqhKeyReq::FixedSignalLength, JBB); +}//Dbtc::sendlqhkeyreq() + +void Dbtc::packLqhkeyreq040Lab(Signal* signal, + UintR anAttrBufIndex, + BlockReference TBRef) +{ + TcConnectRecord * const regTcPtr = tcConnectptr.p; + CacheRecord * const regCachePtr = cachePtr.p; +#ifdef ERROR_INSERT + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + if (ERROR_INSERTED(8009)) { + if (regApiPtr->apiConnectstate == CS_STARTED) { + attrbufptr.i = RNIL; + CLEAR_ERROR_INSERT_VALUE; + return; + }//if + }//if + if (ERROR_INSERTED(8010)) { + if (regApiPtr->apiConnectstate == CS_START_COMMITTING) { + attrbufptr.i = RNIL; + CLEAR_ERROR_INSERT_VALUE; + return; + }//if + }//if +#endif + + UintR TattrbufFilesize = cattrbufFilesize; + AttrbufRecord *localAttrbufRecord = attrbufRecord; + while (1) { + if (anAttrBufIndex == RNIL) { + UintR TtcTimer = ctcTimer; + UintR Tread = (regTcPtr->operation == ZREAD); + UintR Tsimple = (regCachePtr->opSimple == ZTRUE); + UintR Tboth = Tread & Tsimple; + setApiConTimer(apiConnectptr.i, TtcTimer, __LINE__); + jam(); + /*-------------------------------------------------------------------- + * WE HAVE SENT ALL THE SIGNALS OF THIS OPERATION. SET STATE AND EXIT. + *---------------------------------------------------------------------*/ + releaseAttrinfo(signal); + if (Tboth) { + jam(); + releaseSimpleRead(signal); + return; + }//if + regTcPtr->tcConnectstate = OS_OPERATING; + return; + }//if + if (anAttrBufIndex < TattrbufFilesize) { + AttrbufRecord * const regAttrPtr = &localAttrbufRecord[anAttrBufIndex]; + anAttrBufIndex = regAttrPtr->attrbuf[ZINBUF_NEXT]; + sendAttrinfo(signal, + tcConnectptr.i, + regAttrPtr, + TBRef); + } else { + TCKEY_abort(signal, 17); + return; + }//if + }//while +}//Dbtc::packLqhkeyreq040Lab() + +/* ========================================================================= */ +/* ------- RELEASE ALL ATTRINFO RECORDS IN AN OPERATION RECORD ------- */ +/* ========================================================================= */ +void Dbtc::releaseAttrinfo(Signal* signal) +{ + UintR Tmp; + AttrbufRecordPtr Tattrbufptr; + CacheRecord * const regCachePtr = cachePtr.p; + UintR TattrbufFilesize = cattrbufFilesize; + UintR TfirstfreeAttrbuf = cfirstfreeAttrbuf; + Tattrbufptr.i = regCachePtr->firstAttrbuf; + AttrbufRecord *localAttrbufRecord = attrbufRecord; + + while (Tattrbufptr.i < TattrbufFilesize) { + Tattrbufptr.p = &localAttrbufRecord[Tattrbufptr.i]; + Tmp = Tattrbufptr.p->attrbuf[ZINBUF_NEXT]; + Tattrbufptr.p->attrbuf[ZINBUF_NEXT] = TfirstfreeAttrbuf; + TfirstfreeAttrbuf = Tattrbufptr.i; + Tattrbufptr.i = Tmp; + jam(); + }//while + if (Tattrbufptr.i == RNIL) { +//--------------------------------------------------- +// Now we will release the cache record at the same +// time as releasing the attrinfo records. +//--------------------------------------------------- + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + UintR TfirstfreeCacheRec = cfirstfreeCacheRec; + UintR TCacheIndex = cachePtr.i; + cfirstfreeAttrbuf = TfirstfreeAttrbuf; + regCachePtr->nextCacheRec = TfirstfreeCacheRec; + cfirstfreeCacheRec = TCacheIndex; + regApiPtr->cachePtr = RNIL; + return; + }//if + systemErrorLab(signal); + return; +}//Dbtc::releaseAttrinfo() + +/* ========================================================================= */ +/* ------- RELEASE ALL RECORDS CONNECTED TO A SIMPLE OPERATION ------- */ +/* ========================================================================= */ +void Dbtc::releaseSimpleRead(Signal* signal) +{ + unlinkReadyTcCon(signal); + releaseTcCon(signal); + + /** + * No LQHKEYCONF in Simple/Dirty read + * Therefore decrese no LQHKEYCONF(REF) we are waiting for + */ + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + UintR TsimpleReadCount = csimpleReadCount; + UintR Tlqhkeyreqrec = regApiPtr->lqhkeyreqrec; + + csimpleReadCount = TsimpleReadCount + 1; + regApiPtr->lqhkeyreqrec = Tlqhkeyreqrec - 1; + + /** + * If start committing and no operation in lists + * simply return + */ + if (regApiPtr->apiConnectstate == CS_START_COMMITTING && + regApiPtr->firstTcConnect == RNIL) { + + jam(); + setApiConTimer(apiConnectptr.i, 0, __LINE__); + regApiPtr->apiConnectstate = CS_CONNECTED; + return; + }//if + + /** + * Else Emulate LQHKEYCONF + */ + lqhKeyConf_checkTransactionState(signal, regApiPtr); + +}//Dbtc::releaseSimpleRead() + +/* ------------------------------------------------------------------------- */ +/* ------- CHECK IF ALL TC CONNECTIONS ARE COMPLETED ------- */ +/* ------------------------------------------------------------------------- */ +void Dbtc::unlinkReadyTcCon(Signal* signal) +{ + TcConnectRecordPtr urtTcConnectptr; + + TcConnectRecord * const regTcPtr = tcConnectptr.p; + TcConnectRecord *localTcConnectRecord = tcConnectRecord; + UintR TtcConnectFilesize = ctcConnectFilesize; + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + if (regTcPtr->prevTcConnect != RNIL) { + jam(); + urtTcConnectptr.i = regTcPtr->prevTcConnect; + ptrCheckGuard(urtTcConnectptr, TtcConnectFilesize, localTcConnectRecord); + urtTcConnectptr.p->nextTcConnect = regTcPtr->nextTcConnect; + } else { + jam(); + regApiPtr->firstTcConnect = regTcPtr->nextTcConnect; + }//if + if (regTcPtr->nextTcConnect != RNIL) { + jam(); + urtTcConnectptr.i = regTcPtr->nextTcConnect; + ptrCheckGuard(urtTcConnectptr, TtcConnectFilesize, localTcConnectRecord); + urtTcConnectptr.p->prevTcConnect = regTcPtr->prevTcConnect; + } else { + jam(); + regApiPtr->lastTcConnect = tcConnectptr.p->prevTcConnect; + }//if +}//Dbtc::unlinkReadyTcCon() + +void Dbtc::releaseTcCon(Signal* signal) +{ + TcConnectRecord * const regTcPtr = tcConnectptr.p; + UintR TfirstfreeTcConnect = cfirstfreeTcConnect; + UintR TconcurrentOp = cconcurrentOp; + UintR TtcConnectptrIndex = tcConnectptr.i; + + regTcPtr->tcConnectstate = OS_CONNECTED; + regTcPtr->nextTcConnect = TfirstfreeTcConnect; + regTcPtr->apiConnect = RNIL; + regTcPtr->isIndexOp = false; + regTcPtr->indexOp = RNIL; + cfirstfreeTcConnect = TtcConnectptrIndex; + cconcurrentOp = TconcurrentOp - 1; +}//Dbtc::releaseTcCon() + +void Dbtc::execPACKED_SIGNAL(Signal* signal) +{ + LqhKeyConf * const lqhKeyConf = (LqhKeyConf *)signal->getDataPtr(); + + UintR Ti; + UintR Tstep = 0; + UintR Tlength; + UintR TpackedData[28]; + UintR Tdata1, Tdata2, Tdata3, Tdata4; + + jamEntry(); + Tlength = signal->length(); + if (Tlength > 25) { + jam(); + systemErrorLab(signal); + return; + }//if + Uint32* TpackDataPtr; + for (Ti = 0; Ti < Tlength; Ti += 4) { + Uint32* TsigDataPtr = &signal->theData[Ti]; + Tdata1 = TsigDataPtr[0]; + Tdata2 = TsigDataPtr[1]; + Tdata3 = TsigDataPtr[2]; + Tdata4 = TsigDataPtr[3]; + + TpackDataPtr = &TpackedData[Ti]; + TpackDataPtr[0] = Tdata1; + TpackDataPtr[1] = Tdata2; + TpackDataPtr[2] = Tdata3; + TpackDataPtr[3] = Tdata4; + }//for + while (Tlength > Tstep) { + + TpackDataPtr = &TpackedData[Tstep]; + Tdata1 = TpackDataPtr[0]; + Tdata2 = TpackDataPtr[1]; + Tdata3 = TpackDataPtr[2]; + + lqhKeyConf->connectPtr = Tdata1 & 0x0FFFFFFF; + lqhKeyConf->opPtr = Tdata2; + lqhKeyConf->userRef = Tdata3; + + switch (Tdata1 >> 28) { + case ZCOMMITTED: + signal->header.theLength = 3; + execCOMMITTED(signal); + Tstep += 3; + break; + case ZCOMPLETED: + signal->header.theLength = 3; + execCOMPLETED(signal); + Tstep += 3; + break; + case ZLQHKEYCONF: + jam(); + Tdata1 = TpackDataPtr[3]; + Tdata2 = TpackDataPtr[4]; + Tdata3 = TpackDataPtr[5]; + Tdata4 = TpackDataPtr[6]; + + lqhKeyConf->readLen = Tdata1; + lqhKeyConf->transId1 = Tdata2; + lqhKeyConf->transId2 = Tdata3; + lqhKeyConf->noFiredTriggers = Tdata4; + signal->header.theLength = LqhKeyConf::SignalLength; + execLQHKEYCONF(signal); + Tstep += LqhKeyConf::SignalLength; + break; + default: + systemErrorLab(signal); + return; + }//switch + }//while + return; +}//Dbtc::execPACKED_SIGNAL() + +void Dbtc::execLQHKEYCONF(Signal* signal) +{ + const LqhKeyConf * const lqhKeyConf = (LqhKeyConf *)signal->getDataPtr(); + UintR compare_transid1, compare_transid2; + BlockReference tlastLqhBlockref; + UintR tlastLqhConnect; + UintR treadlenAi; + UintR TtcConnectptrIndex; + UintR TtcConnectFilesize = ctcConnectFilesize; + + tlastLqhConnect = lqhKeyConf->connectPtr; + TtcConnectptrIndex = lqhKeyConf->opPtr; + tlastLqhBlockref = lqhKeyConf->userRef; + treadlenAi = lqhKeyConf->readLen; + TcConnectRecord *localTcConnectRecord = tcConnectRecord; + + /*------------------------------------------------------------------------ + * NUMBER OF EXTERNAL TRIGGERS FIRED IN DATA[6] + * OPERATION IS NOW COMPLETED. CHECK FOR CORRECT OPERATION POINTER + * TO ENSURE NO CRASHES BECAUSE OF ERRONEUS NODES. CHECK STATE OF + * OPERATION. THEN SET OPERATION STATE AND RETRIEVE ALL POINTERS + * OF THIS OPERATION. PUT COMPLETED OPERATION IN LIST OF COMPLETED + * OPERATIONS ON THE LQH CONNECT RECORD. + *------------------------------------------------------------------------ + * THIS SIGNAL ALWAYS ARRIVE BEFORE THE ABORTED SIGNAL ARRIVES SINCE IT USES + * THE SAME PATH BACK TO TC AS THE ABORTED SIGNAL DO. WE DO HOWEVER HAVE A + * PROBLEM WHEN WE ENCOUNTER A TIME-OUT WAITING FOR THE ABORTED SIGNAL. + * THEN THIS SIGNAL MIGHT ARRIVE WHEN THE TC CONNECT RECORD HAVE BEEN REUSED + * BY OTHER TRANSACTION THUS WE CHECK THE TRANSACTION ID OF THE SIGNAL + * BEFORE ACCEPTING THIS SIGNAL. + * Due to packing of LQHKEYCONF the ABORTED signal can now arrive before + * this. + * This is more reason to ignore the signal if not all states are correct. + *------------------------------------------------------------------------*/ + if (TtcConnectptrIndex >= TtcConnectFilesize) { + TCKEY_abort(signal, 25); + return; + }//if + TcConnectRecord* const regTcPtr = &localTcConnectRecord[TtcConnectptrIndex]; + OperationState TtcConnectstate = regTcPtr->tcConnectstate; + tcConnectptr.i = TtcConnectptrIndex; + tcConnectptr.p = regTcPtr; + if (TtcConnectstate != OS_OPERATING) { + warningReport(signal, 23); + return; + }//if + ApiConnectRecord *localApiConnectRecord = apiConnectRecord; + UintR TapiConnectptrIndex = regTcPtr->apiConnect; + UintR TapiConnectFilesize = capiConnectFilesize; + UintR Ttrans1 = lqhKeyConf->transId1; + UintR Ttrans2 = lqhKeyConf->transId2; + regTcPtr->noFiredTriggers = lqhKeyConf->noFiredTriggers; + + if (TapiConnectptrIndex >= TapiConnectFilesize) { + TCKEY_abort(signal, 29); + return; + }//if + ApiConnectRecord * const regApiPtr = + &localApiConnectRecord[TapiConnectptrIndex]; + apiConnectptr.i = TapiConnectptrIndex; + apiConnectptr.p = regApiPtr; + compare_transid1 = regApiPtr->transid[0] ^ Ttrans1; + compare_transid2 = regApiPtr->transid[1] ^ Ttrans2; + compare_transid1 = compare_transid1 | compare_transid2; + if (compare_transid1 != 0) { + warningReport(signal, 24); + return; + }//if + +#ifdef ERROR_INSERT + if (ERROR_INSERTED(8029)) { + systemErrorLab(signal); + }//if + if (ERROR_INSERTED(8003)) { + if (regApiPtr->apiConnectstate == CS_STARTED) { + CLEAR_ERROR_INSERT_VALUE; + return; + }//if + }//if + if (ERROR_INSERTED(8004)) { + if (regApiPtr->apiConnectstate == CS_RECEIVING) { + CLEAR_ERROR_INSERT_VALUE; + return; + }//if + }//if + if (ERROR_INSERTED(8005)) { + if (regApiPtr->apiConnectstate == CS_REC_COMMITTING) { + CLEAR_ERROR_INSERT_VALUE; + return; + }//if + }//if + if (ERROR_INSERTED(8006)) { + if (regApiPtr->apiConnectstate == CS_START_COMMITTING) { + CLEAR_ERROR_INSERT_VALUE; + return; + }//if + }//if + if (ERROR_INSERTED(8023)) { + SET_ERROR_INSERT_VALUE(8024); + return; + }//if +#endif + UintR TtcTimer = ctcTimer; + regTcPtr->lastLqhCon = tlastLqhConnect; + regTcPtr->lastLqhNodeId = refToNode(tlastLqhBlockref); + + UintR Ttckeyrec = (UintR)regApiPtr->tckeyrec; + UintR TclientData = regTcPtr->clientData; + UintR TdirtyOp = regTcPtr->dirtyOp; + ConnectionState TapiConnectstate = regApiPtr->apiConnectstate; + if (Ttckeyrec > (ZTCOPCONF_SIZE - 2)) { + TCKEY_abort(signal, 30); + return; + } + if (TapiConnectstate == CS_ABORTING) { + warningReport(signal, 27); + return; + }//if + + setApiConTimer(apiConnectptr.i, TtcTimer, __LINE__); + + if (regTcPtr->isIndexOp) { + jam(); + // This was an internal TCKEYREQ + // will be returned unpacked + regTcPtr->attrInfoLen = treadlenAi; + } else { + jam(); + regApiPtr->tcSendArray[Ttckeyrec] = TclientData; + regApiPtr->tcSendArray[Ttckeyrec + 1] = treadlenAi; + if ((regTcPtr->noFiredTriggers == 0) && + (regTcPtr->triggeringOperation == RNIL)) { + jam(); + /* + Skip counting triggering operations the first round + since they will enter execLQHKEYCONF a second time + Skip counting internally generated TcKeyReq + */ + regApiPtr->tckeyrec += 2; + }//if + }//if + if (TdirtyOp == ZTRUE) { + UintR Tlqhkeyreqrec = regApiPtr->lqhkeyreqrec; + jam(); + releaseDirtyWrite(signal); + regApiPtr->lqhkeyreqrec = Tlqhkeyreqrec - 1; + } else { + jam(); + if (regTcPtr->noFiredTriggers == 0) { + jam(); + // No triggers to execute + UintR Tlqhkeyconfrec = regApiPtr->lqhkeyconfrec; + regApiPtr->lqhkeyconfrec = Tlqhkeyconfrec + 1; + regTcPtr->tcConnectstate = OS_PREPARED; + } + }//if + + /** + * And now decide what to do next + */ + if (regTcPtr->triggeringOperation != RNIL) { + jam(); + // This operation was created by a trigger execting operation + // Restart it if we have executed all it's triggers + TcConnectRecordPtr opPtr; + + opPtr.i = regTcPtr->triggeringOperation; + ptrCheckGuard(opPtr, ctcConnectFilesize, localTcConnectRecord); + opPtr.p->triggerExecutionCount--; + if (opPtr.p->triggerExecutionCount == 0) { + /* + We have completed current trigger execution + Continue triggering operation + */ + jam(); + regTcPtr->triggeringOperation = RNIL; + continueTriggeringOp(signal, opPtr.p); + } + } else if (regTcPtr->noFiredTriggers == 0) { + // This operation did not fire any triggers, finish operation + jam(); + if (regTcPtr->isIndexOp) { + jam(); + setupIndexOpReturn(regApiPtr, regTcPtr); + } + lqhKeyConf_checkTransactionState(signal, regApiPtr); + } else { + // We have fired triggers + jam(); + saveTriggeringOpState(signal, regTcPtr); + if (regTcPtr->noReceivedTriggers == regTcPtr->noFiredTriggers) { + ApiConnectRecordPtr transPtr; + + // We have received all data + jam(); + transPtr.i = TapiConnectptrIndex; + transPtr.p = regApiPtr; + executeTriggers(signal, &transPtr); + } + // else wait for more trigger data + } +}//Dbtc::execLQHKEYCONF() + + +void Dbtc::setupIndexOpReturn(ApiConnectRecord* regApiPtr, + TcConnectRecord* regTcPtr) +{ + regApiPtr->indexOpReturn = true; + regApiPtr->indexOp = regTcPtr->indexOp; + regApiPtr->clientData = regTcPtr->clientData; + regApiPtr->attrInfoLen = regTcPtr->attrInfoLen; +} + +/** + * lqhKeyConf_checkTransactionState + * + * This functions checks state variables, and + * decides if it should wait for more LQHKEYCONF signals + * or if it should start commiting + */ +void +Dbtc::lqhKeyConf_checkTransactionState(Signal * signal, + ApiConnectRecord * const apiConnectPtrP) +{ +/*---------------------------------------------------------------*/ +/* IF THE COMMIT FLAG IS SET IN SIGNAL TCKEYREQ THEN DBTC HAS TO */ +/* SEND TCKEYCONF FOR ALL OPERATIONS EXCEPT THE LAST ONE. WHEN */ +/* THE TRANSACTION THEN IS COMMITTED TCKEYCONF IS SENT FOR THE */ +/* WHOLE TRANSACTION */ +/* IF THE COMMIT FLAG IS NOT RECECIVED DBTC WILL SEND TCKEYCONF */ +/* FOR ALL OPERATIONS, AND THEN WAIT FOR THE API TO CONCLUDE THE */ +/* TRANSACTION */ +/*---------------------------------------------------------------*/ + ConnectionState TapiConnectstate = apiConnectPtrP->apiConnectstate; + UintR Tlqhkeyconfrec = apiConnectPtrP->lqhkeyconfrec; + UintR Tlqhkeyreqrec = apiConnectPtrP->lqhkeyreqrec; + int TnoOfOutStanding = Tlqhkeyreqrec - Tlqhkeyconfrec; + + switch (TapiConnectstate) { + case CS_START_COMMITTING: + if (TnoOfOutStanding == 0) { + jam(); + diverify010Lab(signal); + return; + } else if (TnoOfOutStanding > 0) { + if (apiConnectPtrP->tckeyrec == ZTCOPCONF_SIZE) { + jam(); + sendtckeyconf(signal, 0); + return; + } else if (apiConnectPtrP->indexOpReturn) { + jam(); + sendtckeyconf(signal, 0); + return; + }//if + jam(); + return; + } else { + TCKEY_abort(signal, 44); + return; + }//if + return; + case CS_STARTED: + case CS_RECEIVING: + if (TnoOfOutStanding == 0) { + jam(); + sendtckeyconf(signal, 0); + return; + } else { + if (apiConnectPtrP->tckeyrec == ZTCOPCONF_SIZE) { + jam(); + sendtckeyconf(signal, 0); + return; + } else if (apiConnectPtrP->indexOpReturn) { + jam(); + sendtckeyconf(signal, 0); + return; + }//if + jam(); + }//if + return; + case CS_REC_COMMITTING: + if (TnoOfOutStanding > 0) { + if (apiConnectPtrP->tckeyrec == ZTCOPCONF_SIZE) { + jam(); + sendtckeyconf(signal, 0); + return; + } else if (apiConnectPtrP->indexOpReturn) { + jam(); + sendtckeyconf(signal, 0); + return; + }//if + jam(); + return; + }//if + TCKEY_abort(signal, 45); + return; + case CS_CONNECTED: + jam(); +/*---------------------------------------------------------------*/ +/* WE HAVE CONCLUDED THE TRANSACTION SINCE IT WAS ONLY */ +/* CONSISTING OF DIRTY WRITES AND ALL OF THOSE WERE */ +/* COMPLETED. ENSURE TCKEYREC IS ZERO TO PREVENT ERRORS. */ +/*---------------------------------------------------------------*/ + apiConnectPtrP->tckeyrec = 0; + return; + default: + TCKEY_abort(signal, 46); + return; + }//switch +}//Dbtc::lqhKeyConf_checkTransactionState() + +void Dbtc::sendtckeyconf(Signal* signal, UintR TcommitFlag) +{ + HostRecordPtr localHostptr; + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + const UintR TopWords = (UintR)regApiPtr->tckeyrec; + localHostptr.i = refToNode(regApiPtr->ndbapiBlockref); + const Uint32 type = getNodeInfo(localHostptr.i).m_type; + const bool is_api = (type >= NodeInfo::API && type <= NodeInfo::REP); + const BlockNumber TblockNum = refToBlock(regApiPtr->ndbapiBlockref); + const Uint32 Tmarker = (regApiPtr->commitAckMarker == RNIL) ? 0 : 1; + ptrAss(localHostptr, hostRecord); + UintR TcurrLen = localHostptr.p->noOfWordsTCKEYCONF; + UintR confInfo = 0; + TcKeyConf::setCommitFlag(confInfo, TcommitFlag); + TcKeyConf::setMarkerFlag(confInfo, Tmarker); + const UintR TpacketLen = 6 + TopWords; + regApiPtr->tckeyrec = 0; + + if (regApiPtr->indexOpReturn) { + jam(); + // Return internally generated TCKEY + TcKeyConf * const tcKeyConf = (TcKeyConf *)signal->getDataPtrSend(); + TcKeyConf::setNoOfOperations(confInfo, 1); + tcKeyConf->apiConnectPtr = regApiPtr->indexOp; + tcKeyConf->gci = regApiPtr->globalcheckpointid; + tcKeyConf->confInfo = confInfo; + tcKeyConf->transId1 = regApiPtr->transid[0]; + tcKeyConf->transId2 = regApiPtr->transid[1]; + tcKeyConf->operations[0].apiOperationPtr = regApiPtr->clientData; + tcKeyConf->operations[0].attrInfoLen = regApiPtr->attrInfoLen; + Uint32 sigLen = TcKeyConf::StaticLength + TcKeyConf::OperationLength; + EXECUTE_DIRECT(DBTC, GSN_TCKEYCONF, signal, sigLen); + regApiPtr->indexOpReturn = false; + if (TopWords == 0) { + jam(); + return; // No queued TcKeyConf + }//if + }//if + + TcKeyConf::setNoOfOperations(confInfo, (TopWords >> 1)); + if ((TpacketLen > 25) || !is_api){ + TcKeyConf * const tcKeyConf = (TcKeyConf *)signal->getDataPtrSend(); + + jam(); + tcKeyConf->apiConnectPtr = regApiPtr->ndbapiConnect; + tcKeyConf->gci = regApiPtr->globalcheckpointid;; + tcKeyConf->confInfo = confInfo; + tcKeyConf->transId1 = regApiPtr->transid[0]; + tcKeyConf->transId2 = regApiPtr->transid[1]; + copyFromToLen(®ApiPtr->tcSendArray[0], + (UintR*)&tcKeyConf->operations, + (UintR)ZTCOPCONF_SIZE); + sendSignal(regApiPtr->ndbapiBlockref, + GSN_TCKEYCONF, signal, (TpacketLen - 1), JBB); + return; + } else if (((TcurrLen + TpacketLen) > 25) && (TcurrLen > 0)) { + jam(); + sendPackedTCKEYCONF(signal, localHostptr.p, localHostptr.i); + TcurrLen = 0; + } else { + jam(); + updatePackedList(signal, localHostptr.p, localHostptr.i); + }//if + // ------------------------------------------------------------------------- + // The header contains the block reference of receiver plus the real signal + // length - 3, since we have the real signal length plus one additional word + // for the header we have to do - 4. + // ------------------------------------------------------------------------- + UintR Tpack0 = (TblockNum << 16) + (TpacketLen - 4); + UintR Tpack1 = regApiPtr->ndbapiConnect; + UintR Tpack2 = regApiPtr->globalcheckpointid; + UintR Tpack3 = confInfo; + UintR Tpack4 = regApiPtr->transid[0]; + UintR Tpack5 = regApiPtr->transid[1]; + + localHostptr.p->noOfWordsTCKEYCONF = TcurrLen + TpacketLen; + + localHostptr.p->packedWordsTCKEYCONF[TcurrLen + 0] = Tpack0; + localHostptr.p->packedWordsTCKEYCONF[TcurrLen + 1] = Tpack1; + localHostptr.p->packedWordsTCKEYCONF[TcurrLen + 2] = Tpack2; + localHostptr.p->packedWordsTCKEYCONF[TcurrLen + 3] = Tpack3; + localHostptr.p->packedWordsTCKEYCONF[TcurrLen + 4] = Tpack4; + localHostptr.p->packedWordsTCKEYCONF[TcurrLen + 5] = Tpack5; + + UintR Ti; + for (Ti = 6; Ti < TpacketLen; Ti++) { + localHostptr.p->packedWordsTCKEYCONF[TcurrLen + Ti] = + regApiPtr->tcSendArray[Ti - 6]; + }//for +}//Dbtc::sendtckeyconf() + +void Dbtc::copyFromToLen(UintR* sourceBuffer, UintR* destBuffer, UintR Tlen) +{ + UintR Tindex = 0; + UintR Ti; + while (Tlen >= 4) { + UintR Tdata0 = sourceBuffer[Tindex + 0]; + UintR Tdata1 = sourceBuffer[Tindex + 1]; + UintR Tdata2 = sourceBuffer[Tindex + 2]; + UintR Tdata3 = sourceBuffer[Tindex + 3]; + Tlen -= 4; + destBuffer[Tindex + 0] = Tdata0; + destBuffer[Tindex + 1] = Tdata1; + destBuffer[Tindex + 2] = Tdata2; + destBuffer[Tindex + 3] = Tdata3; + Tindex += 4; + }//while + for (Ti = 0; Ti < Tlen; Ti++, Tindex++) { + destBuffer[Tindex] = sourceBuffer[Tindex]; + }//for +}//Dbtc::copyFromToLen() + +void Dbtc::execSEND_PACKED(Signal* signal) +{ + HostRecordPtr Thostptr; + HostRecord *localHostRecord = hostRecord; + UintR i; + UintR TpackedListIndex = cpackedListIndex; + jamEntry(); + for (i = 0; i < TpackedListIndex; i++) { + Thostptr.i = cpackedList[i]; + ptrAss(Thostptr, localHostRecord); + arrGuard(Thostptr.i - 1, MAX_NODES - 1); + UintR TnoOfPackedWordsLqh = Thostptr.p->noOfPackedWordsLqh; + UintR TnoOfWordsTCKEYCONF = Thostptr.p->noOfWordsTCKEYCONF; + UintR TnoOfWordsTCINDXCONF = Thostptr.p->noOfWordsTCINDXCONF; + jam(); + if (TnoOfPackedWordsLqh > 0) { + jam(); + sendPackedSignalLqh(signal, Thostptr.p); + }//if + if (TnoOfWordsTCKEYCONF > 0) { + jam(); + sendPackedTCKEYCONF(signal, Thostptr.p, (Uint32)Thostptr.i); + }//if + if (TnoOfWordsTCINDXCONF > 0) { + jam(); + sendPackedTCINDXCONF(signal, Thostptr.p, (Uint32)Thostptr.i); + }//if + Thostptr.p->inPackedList = false; + }//for + cpackedListIndex = 0; + return; +}//Dbtc::execSEND_PACKED() + +void +Dbtc::updatePackedList(Signal* signal, HostRecord* ahostptr, Uint16 ahostIndex) +{ + if (ahostptr->inPackedList == false) { + UintR TpackedListIndex = cpackedListIndex; + jam(); + ahostptr->inPackedList = true; + cpackedList[TpackedListIndex] = ahostIndex; + cpackedListIndex = TpackedListIndex + 1; + }//if +}//Dbtc::updatePackedList() + +void Dbtc::sendPackedSignalLqh(Signal* signal, HostRecord * ahostptr) +{ + UintR Tj; + UintR TnoOfWords = ahostptr->noOfPackedWordsLqh; + for (Tj = 0; Tj < TnoOfWords; Tj += 4) { + UintR sig0 = ahostptr->packedWordsLqh[Tj + 0]; + UintR sig1 = ahostptr->packedWordsLqh[Tj + 1]; + UintR sig2 = ahostptr->packedWordsLqh[Tj + 2]; + UintR sig3 = ahostptr->packedWordsLqh[Tj + 3]; + signal->theData[Tj + 0] = sig0; + signal->theData[Tj + 1] = sig1; + signal->theData[Tj + 2] = sig2; + signal->theData[Tj + 3] = sig3; + }//for + ahostptr->noOfPackedWordsLqh = 0; + sendSignal(ahostptr->hostLqhBlockRef, + GSN_PACKED_SIGNAL, + signal, + TnoOfWords, + JBB); +}//Dbtc::sendPackedSignalLqh() + +void Dbtc::sendPackedTCKEYCONF(Signal* signal, + HostRecord * ahostptr, + UintR hostId) +{ + UintR Tj; + UintR TnoOfWords = ahostptr->noOfWordsTCKEYCONF; + BlockReference TBref = numberToRef(API_PACKED, hostId); + for (Tj = 0; Tj < ahostptr->noOfWordsTCKEYCONF; Tj += 4) { + UintR sig0 = ahostptr->packedWordsTCKEYCONF[Tj + 0]; + UintR sig1 = ahostptr->packedWordsTCKEYCONF[Tj + 1]; + UintR sig2 = ahostptr->packedWordsTCKEYCONF[Tj + 2]; + UintR sig3 = ahostptr->packedWordsTCKEYCONF[Tj + 3]; + signal->theData[Tj + 0] = sig0; + signal->theData[Tj + 1] = sig1; + signal->theData[Tj + 2] = sig2; + signal->theData[Tj + 3] = sig3; + }//for + ahostptr->noOfWordsTCKEYCONF = 0; + sendSignal(TBref, GSN_TCKEYCONF, signal, TnoOfWords, JBB); +}//Dbtc::sendPackedTCKEYCONF() + +void Dbtc::sendPackedTCINDXCONF(Signal* signal, + HostRecord * ahostptr, + UintR hostId) +{ + UintR Tj; + UintR TnoOfWords = ahostptr->noOfWordsTCINDXCONF; + BlockReference TBref = numberToRef(API_PACKED, hostId); + for (Tj = 0; Tj < ahostptr->noOfWordsTCINDXCONF; Tj += 4) { + UintR sig0 = ahostptr->packedWordsTCINDXCONF[Tj + 0]; + UintR sig1 = ahostptr->packedWordsTCINDXCONF[Tj + 1]; + UintR sig2 = ahostptr->packedWordsTCINDXCONF[Tj + 2]; + UintR sig3 = ahostptr->packedWordsTCINDXCONF[Tj + 3]; + signal->theData[Tj + 0] = sig0; + signal->theData[Tj + 1] = sig1; + signal->theData[Tj + 2] = sig2; + signal->theData[Tj + 3] = sig3; + }//for + ahostptr->noOfWordsTCINDXCONF = 0; + sendSignal(TBref, GSN_TCINDXCONF, signal, TnoOfWords, JBB); +}//Dbtc::sendPackedTCINDXCONF() + +/* +4.3.11 DIVERIFY +--------------- +*/ +/*****************************************************************************/ +/* D I V E R I F Y */ +/* */ +/*****************************************************************************/ +void Dbtc::diverify010Lab(Signal* signal) +{ + UintR TfirstfreeApiConnectCopy = cfirstfreeApiConnectCopy; + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + signal->theData[0] = apiConnectptr.i; + if (ERROR_INSERTED(8022)) { + jam(); + systemErrorLab(signal); + }//if + if (TfirstfreeApiConnectCopy != RNIL) { + seizeApiConnectCopy(signal); + regApiPtr->apiConnectstate = CS_PREPARE_TO_COMMIT; + /*----------------------------------------------------------------------- + * WE COME HERE ONLY IF THE TRANSACTION IS PREPARED ON ALL TC CONNECTIONS. + * THUS WE CAN START THE COMMIT PHASE BY SENDING DIVERIFY ON ALL TC + * CONNECTIONS AND THEN WHEN ALL DIVERIFYCONF HAVE BEEN RECEIVED THE + * COMMIT MESSAGE CAN BE SENT TO ALL INVOLVED PARTS. + *-----------------------------------------------------------------------*/ + EXECUTE_DIRECT(DBDIH, GSN_DIVERIFYREQ, signal, 1); + if (signal->theData[2] == 0) { + execDIVERIFYCONF(signal); + } + return; + } else { + /*----------------------------------------------------------------------- + * There were no free copy connections available. We must abort the + * transaction since otherwise we will have a problem with the report + * to the application. + * This should more or less not happen but if it happens we do not want to + * crash and we do not want to create code to handle it properly since + * it is difficult to test it and will be complex to handle a problem + * more or less not occurring. + *-----------------------------------------------------------------------*/ + terrorCode = ZSEIZE_API_COPY_ERROR; + abortErrorLab(signal); + return; + }//if +}//Dbtc::diverify010Lab() + +/* ------------------------------------------------------------------------- */ +/* ------- SEIZE_API_CONNECT ------- */ +/* SEIZE CONNECT RECORD FOR A REQUEST */ +/* ------------------------------------------------------------------------- */ +void Dbtc::seizeApiConnectCopy(Signal* signal) +{ + ApiConnectRecordPtr locApiConnectptr; + + ApiConnectRecord *localApiConnectRecord = apiConnectRecord; + UintR TapiConnectFilesize = capiConnectFilesize; + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + + locApiConnectptr.i = cfirstfreeApiConnectCopy; + ptrCheckGuard(locApiConnectptr, TapiConnectFilesize, localApiConnectRecord); + cfirstfreeApiConnectCopy = locApiConnectptr.p->nextApiConnect; + locApiConnectptr.p->nextApiConnect = RNIL; + regApiPtr->apiCopyRecord = locApiConnectptr.i; + regApiPtr->triggerPending = false; + regApiPtr->isIndexOp = false; +}//Dbtc::seizeApiConnectCopy() + +void Dbtc::execDIVERIFYCONF(Signal* signal) +{ + UintR TapiConnectptrIndex = signal->theData[0]; + UintR TapiConnectFilesize = capiConnectFilesize; + UintR Tgci = signal->theData[1]; + ApiConnectRecord *localApiConnectRecord = apiConnectRecord; + + jamEntry(); + if (ERROR_INSERTED(8017)) { + CLEAR_ERROR_INSERT_VALUE; + return; + }//if + if (TapiConnectptrIndex >= TapiConnectFilesize) { + TCKEY_abort(signal, 31); + return; + }//if + ApiConnectRecord * const regApiPtr = + &localApiConnectRecord[TapiConnectptrIndex]; + ConnectionState TapiConnectstate = regApiPtr->apiConnectstate; + UintR TApifailureNr = regApiPtr->failureNr; + UintR Tfailure_nr = cfailure_nr; + apiConnectptr.i = TapiConnectptrIndex; + apiConnectptr.p = regApiPtr; + if (TapiConnectstate != CS_PREPARE_TO_COMMIT) { + TCKEY_abort(signal, 32); + return; + }//if + /*-------------------------------------------------------------------------- + * THIS IS THE COMMIT POINT. IF WE ARRIVE HERE THE TRANSACTION IS COMMITTED + * UNLESS EVERYTHING CRASHES BEFORE WE HAVE BEEN ABLE TO REPORT THE COMMIT + * DECISION. THERE IS NO TURNING BACK FROM THIS DECISION FROM HERE ON. + * WE WILL INSERT THE TRANSACTION INTO ITS PROPER QUEUE OF + * TRANSACTIONS FOR ITS GLOBAL CHECKPOINT. + *-------------------------------------------------------------------------*/ + if (TApifailureNr != Tfailure_nr) { + DIVER_node_fail_handling(signal, Tgci); + return; + }//if + commitGciHandling(signal, Tgci); + + /************************************************************************** + * C O M M I T + * THE TRANSACTION HAVE NOW BEEN VERIFIED AND NOW THE COMMIT PHASE CAN START + **************************************************************************/ + + UintR TtcConnectptrIndex = regApiPtr->firstTcConnect; + UintR TtcConnectFilesize = ctcConnectFilesize; + TcConnectRecord *localTcConnectRecord = tcConnectRecord; + + regApiPtr->counter = regApiPtr->lqhkeyconfrec; + regApiPtr->apiConnectstate = CS_COMMITTING; + if (TtcConnectptrIndex >= TtcConnectFilesize) { + TCKEY_abort(signal, 33); + return; + }//if + TcConnectRecord* const regTcPtr = &localTcConnectRecord[TtcConnectptrIndex]; + tcConnectptr.i = TtcConnectptrIndex; + tcConnectptr.p = regTcPtr; + commit020Lab(signal); +}//Dbtc::execDIVERIFYCONF() + +/*--------------------------------------------------------------------------*/ +/* COMMIT_GCI_HANDLING */ +/* SET UP GLOBAL CHECKPOINT DATA STRUCTURE AT THE COMMIT POINT. */ +/*--------------------------------------------------------------------------*/ +void Dbtc::commitGciHandling(Signal* signal, UintR Tgci) +{ + GcpRecordPtr localGcpPointer; + + UintR TgcpFilesize = cgcpFilesize; + UintR Tfirstgcp = cfirstgcp; + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + GcpRecord *localGcpRecord = gcpRecord; + + regApiPtr->globalcheckpointid = Tgci; + if (Tfirstgcp != RNIL) { + /* IF THIS GLOBAL CHECKPOINT ALREADY EXISTS */ + localGcpPointer.i = Tfirstgcp; + ptrCheckGuard(localGcpPointer, TgcpFilesize, localGcpRecord); + do { + if (regApiPtr->globalcheckpointid == localGcpPointer.p->gcpId) { + jam(); + gcpPtr.i = localGcpPointer.i; + gcpPtr.p = localGcpPointer.p; + linkApiToGcp(signal); + return; + } else { + localGcpPointer.i = localGcpPointer.p->nextGcp; + jam(); + if (localGcpPointer.i != RNIL) { + jam(); + ptrCheckGuard(localGcpPointer, TgcpFilesize, localGcpRecord); + continue; + }//if + }//if + seizeGcp(signal); + linkApiToGcp(signal); + return; + } while (1); + } else { + jam(); + seizeGcp(signal); + linkApiToGcp(signal); + }//if +}//Dbtc::commitGciHandling() + +/* --------------------------------------------------------------------------*/ +/* -LINK AN API CONNECT RECORD IN STATE PREPARED INTO THE LIST WITH GLOBAL - */ +/* CHECKPOINTS. WHEN THE TRANSACTION I COMPLETED THE API CONNECT RECORD IS */ +/* LINKED OUT OF THE LIST. */ +/*---------------------------------------------------------------------------*/ +void Dbtc::linkApiToGcp(Signal* signal) +{ + ApiConnectRecordPtr localApiConnectptr; + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + GcpRecord * const regGcpPtr = gcpPtr.p; + UintR TapiConnectptrIndex = apiConnectptr.i; + ApiConnectRecord *localApiConnectRecord = apiConnectRecord; + + regApiPtr->nextGcpConnect = RNIL; + if (regGcpPtr->firstApiConnect == RNIL) { + regGcpPtr->firstApiConnect = TapiConnectptrIndex; + jam(); + } else { + UintR TapiConnectFilesize = capiConnectFilesize; + localApiConnectptr.i = regGcpPtr->lastApiConnect; + jam(); + ptrCheckGuard(localApiConnectptr, + TapiConnectFilesize, localApiConnectRecord); + localApiConnectptr.p->nextGcpConnect = TapiConnectptrIndex; + }//if + UintR TlastApiConnect = regGcpPtr->lastApiConnect; + regApiPtr->gcpPointer = gcpPtr.i; + regApiPtr->prevGcpConnect = TlastApiConnect; + regGcpPtr->lastApiConnect = TapiConnectptrIndex; +}//Dbtc::linkApiToGcp() + +void Dbtc::seizeGcp(Signal* signal) +{ + GcpRecordPtr tmpGcpPointer; + GcpRecordPtr localGcpPointer; + + UintR Tfirstgcp = cfirstgcp; + UintR Tglobalcheckpointid = apiConnectptr.p->globalcheckpointid; + UintR TgcpFilesize = cgcpFilesize; + GcpRecord *localGcpRecord = gcpRecord; + + localGcpPointer.i = cfirstfreeGcp; + ptrCheckGuard(localGcpPointer, TgcpFilesize, localGcpRecord); + UintR TfirstfreeGcp = localGcpPointer.p->nextGcp; + localGcpPointer.p->gcpId = Tglobalcheckpointid; + localGcpPointer.p->nextGcp = RNIL; + localGcpPointer.p->firstApiConnect = RNIL; + localGcpPointer.p->lastApiConnect = RNIL; + localGcpPointer.p->gcpNomoretransRec = ZFALSE; + cfirstfreeGcp = TfirstfreeGcp; + + if (Tfirstgcp == RNIL) { + jam(); + cfirstgcp = localGcpPointer.i; + } else { + tmpGcpPointer.i = clastgcp; + jam(); + ptrCheckGuard(tmpGcpPointer, TgcpFilesize, localGcpRecord); + tmpGcpPointer.p->nextGcp = localGcpPointer.i; + }//if + clastgcp = localGcpPointer.i; + gcpPtr = localGcpPointer; +}//Dbtc::seizeGcp() + +/*---------------------------------------------------------------------------*/ +// Send COMMIT messages to all LQH operations involved in the transaction. +/*---------------------------------------------------------------------------*/ +void Dbtc::commit020Lab(Signal* signal) +{ + TcConnectRecordPtr localTcConnectptr; + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + UintR TtcConnectFilesize = ctcConnectFilesize; + TcConnectRecord *localTcConnectRecord = tcConnectRecord; + + localTcConnectptr.p = tcConnectptr.p; + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + UintR Tcount = 0; + do { + /*----------------------------------------------------------------------- + * WE ARE NOW READY TO RELEASE ALL OPERATIONS ON THE LQH + *-----------------------------------------------------------------------*/ + /* *********< */ + /* COMMIT < */ + /* *********< */ + localTcConnectptr.i = localTcConnectptr.p->nextTcConnect; + localTcConnectptr.p->tcConnectstate = OS_COMMITTING; + sendCommitLqh(signal, localTcConnectptr.p); + + if (localTcConnectptr.i != RNIL) { + Tcount = Tcount + 1; + if (Tcount < 16) { + ptrCheckGuard(localTcConnectptr, + TtcConnectFilesize, localTcConnectRecord); + jam(); + continue; + } else { + jam(); + if (ERROR_INSERTED(8014)) { + CLEAR_ERROR_INSERT_VALUE; + return; + }//if + signal->theData[0] = TcContinueB::ZSEND_COMMIT_LOOP; + signal->theData[1] = apiConnectptr.i; + signal->theData[2] = localTcConnectptr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB); + return; + }//if + } else { + jam(); + regApiPtr->apiConnectstate = CS_COMMIT_SENT; + return; + }//if + } while (1); +}//Dbtc::commit020Lab() + +void Dbtc::sendCommitLqh(Signal* signal, + TcConnectRecord * const regTcPtr) +{ + HostRecordPtr Thostptr; + UintR ThostFilesize = chostFilesize; + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + Thostptr.i = regTcPtr->lastLqhNodeId; + ptrCheckGuard(Thostptr, ThostFilesize, hostRecord); + if (Thostptr.p->noOfPackedWordsLqh > 21) { + jam(); + sendPackedSignalLqh(signal, Thostptr.p); + } else { + jam(); + updatePackedList(signal, Thostptr.p, Thostptr.i); + }//if + UintR Tindex = Thostptr.p->noOfPackedWordsLqh; + UintR* TDataPtr = &Thostptr.p->packedWordsLqh[Tindex]; + UintR Tdata1 = regTcPtr->lastLqhCon; + UintR Tdata2 = regApiPtr->globalcheckpointid; + UintR Tdata3 = regApiPtr->transid[0]; + UintR Tdata4 = regApiPtr->transid[1]; + + TDataPtr[0] = Tdata1 | (ZCOMMIT << 28); + TDataPtr[1] = Tdata2; + TDataPtr[2] = Tdata3; + TDataPtr[3] = Tdata4; + Thostptr.p->noOfPackedWordsLqh = Tindex + 4; +}//Dbtc::sendCommitLqh() + +void +Dbtc::DIVER_node_fail_handling(Signal* signal, UintR Tgci) +{ + /*------------------------------------------------------------------------ + * AT LEAST ONE NODE HAS FAILED DURING THE TRANSACTION. WE NEED TO CHECK IF + * THIS IS SO SERIOUS THAT WE NEED TO ABORT THE TRANSACTION. IN BOTH THE + * ABORT AND THE COMMIT CASES WE NEED TO SET-UP THE DATA FOR THE + * ABORT/COMMIT/COMPLETE HANDLING AS ALSO USED BY TAKE OVER FUNCTIONALITY. + *------------------------------------------------------------------------*/ + tabortInd = ZFALSE; + setupFailData(signal); + if (tabortInd == ZFALSE) { + jam(); + commitGciHandling(signal, Tgci); + toCommitHandlingLab(signal); + } else { + jam(); + apiConnectptr.p->returnsignal = RS_TCROLLBACKREP; + apiConnectptr.p->returncode = ZNODEFAIL_BEFORE_COMMIT; + toAbortHandlingLab(signal); + }//if + return; +}//Dbtc::DIVER_node_fail_handling() + + +/* ------------------------------------------------------------------------- */ +/* ------- ENTER COMMITTED ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dbtc::execCOMMITTED(Signal* signal) +{ + TcConnectRecordPtr localTcConnectptr; + ApiConnectRecordPtr localApiConnectptr; + + UintR TtcConnectFilesize = ctcConnectFilesize; + UintR TapiConnectFilesize = capiConnectFilesize; + TcConnectRecord *localTcConnectRecord = tcConnectRecord; + ApiConnectRecord *localApiConnectRecord = apiConnectRecord; + +#ifdef ERROR_INSERT + if (ERROR_INSERTED(8018)) { + CLEAR_ERROR_INSERT_VALUE; + return; + }//if + if (ERROR_INSERTED(8030)) { + systemErrorLab(signal); + }//if + if (ERROR_INSERTED(8025)) { + SET_ERROR_INSERT_VALUE(8026); + return; + }//if + if (ERROR_INSERTED(8041)) { + CLEAR_ERROR_INSERT_VALUE; + sendSignalWithDelay(cownref, GSN_COMMITTED, signal, 2000, 3); + return; + }//if + if (ERROR_INSERTED(8042)) { + SET_ERROR_INSERT_VALUE(8046); + sendSignalWithDelay(cownref, GSN_COMMITTED, signal, 2000, 4); + return; + }//if +#endif + localTcConnectptr.i = signal->theData[0]; + jamEntry(); + ptrCheckGuard(localTcConnectptr, TtcConnectFilesize, localTcConnectRecord); + localApiConnectptr.i = localTcConnectptr.p->apiConnect; + if (localTcConnectptr.p->tcConnectstate != OS_COMMITTING) { + warningReport(signal, 4); + return; + }//if + ptrCheckGuard(localApiConnectptr, TapiConnectFilesize, + localApiConnectRecord); + UintR Tcounter = localApiConnectptr.p->counter - 1; + ConnectionState TapiConnectstate = localApiConnectptr.p->apiConnectstate; + UintR Tdata1 = localApiConnectptr.p->transid[0] - signal->theData[1]; + UintR Tdata2 = localApiConnectptr.p->transid[1] - signal->theData[2]; + Tdata1 = Tdata1 | Tdata2; + bool TcheckCondition = + (TapiConnectstate != CS_COMMIT_SENT) || (Tcounter != 0); + + setApiConTimer(localApiConnectptr.i, ctcTimer, __LINE__); + localApiConnectptr.p->counter = Tcounter; + localTcConnectptr.p->tcConnectstate = OS_COMMITTED; + if (Tdata1 != 0) { + warningReport(signal, 5); + return; + }//if + if (TcheckCondition) { + jam(); + /*-------------------------------------------------------*/ + // We have not sent all COMMIT requests yet. We could be + // in the state that all sent are COMMITTED but we are + // still waiting for a CONTINUEB to send the rest of the + // COMMIT requests. + /*-------------------------------------------------------*/ + return; + }//if + if (ERROR_INSERTED(8020)) { + jam(); + systemErrorLab(signal); + }//if + /*-------------------------------------------------------*/ + /* THE ENTIRE TRANSACTION IS NOW COMMITED */ + /* NOW WE NEED TO SEND THE RESPONSE TO THE APPLICATION. */ + /* THE APPLICATION CAN THEN REUSE THE API CONNECTION AND */ + /* THEREFORE WE NEED TO MOVE THE API CONNECTION TO A */ + /* NEW API CONNECT RECORD. */ + /*-------------------------------------------------------*/ + + apiConnectptr = localApiConnectptr; + sendApiCommit(signal); + + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + localTcConnectptr.i = regApiPtr->firstTcConnect; + UintR Tlqhkeyconfrec = regApiPtr->lqhkeyconfrec; + ptrCheckGuard(localTcConnectptr, TtcConnectFilesize, localTcConnectRecord); + regApiPtr->counter = Tlqhkeyconfrec; + + tcConnectptr = localTcConnectptr; + complete010Lab(signal); + return; + +}//Dbtc::execCOMMITTED() + +/*-------------------------------------------------------*/ +/* SEND_API_COMMIT */ +/* SEND COMMIT DECISION TO THE API. */ +/*-------------------------------------------------------*/ +void Dbtc::sendApiCommit(Signal* signal) +{ + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + + if (regApiPtr->returnsignal == RS_TCKEYCONF) { + sendtckeyconf(signal, 1); + } else if (regApiPtr->returnsignal == RS_TC_COMMITCONF) { + jam(); + TcCommitConf * const commitConf = (TcCommitConf *)&signal->theData[0]; + if(regApiPtr->commitAckMarker == RNIL){ + jam(); + commitConf->apiConnectPtr = regApiPtr->ndbapiConnect; + } else { + jam(); + commitConf->apiConnectPtr = regApiPtr->ndbapiConnect | 1; + } + commitConf->transId1 = regApiPtr->transid[0]; + commitConf->transId2 = regApiPtr->transid[1]; + + sendSignal(regApiPtr->ndbapiBlockref, GSN_TC_COMMITCONF, signal, 3, JBB); + } else if (regApiPtr->returnsignal == RS_NO_RETURN) { + jam(); + } else { + TCKEY_abort(signal, 37); + return; + }//if + UintR TapiConnectFilesize = capiConnectFilesize; + UintR TcommitCount = ccommitCount; + UintR TapiIndex = apiConnectptr.i; + UintR TnewApiIndex = regApiPtr->apiCopyRecord; + UintR TapiFailState = regApiPtr->apiFailState; + ApiConnectRecord *localApiConnectRecord = apiConnectRecord; + + tmpApiConnectptr.p = apiConnectptr.p; + tmpApiConnectptr.i = TapiIndex; + ccommitCount = TcommitCount + 1; + apiConnectptr.i = TnewApiIndex; + ptrCheckGuard(apiConnectptr, TapiConnectFilesize, localApiConnectRecord); + copyApi(signal); + if (TapiFailState != ZTRUE) { + return; + } else { + jam(); + handleApiFailState(signal, tmpApiConnectptr.i); + return; + }//if +}//Dbtc::sendApiCommit() + +/* ========================================================================= */ +/* ======= COPY_API ======= */ +/* COPY API RECORD ALSO RESET THE OLD API RECORD SO THAT IT */ +/* IS PREPARED TO RECEIVE A NEW TRANSACTION. */ +/*===========================================================================*/ +void Dbtc::copyApi(Signal* signal) +{ + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + ApiConnectRecord * const regTmpApiPtr = tmpApiConnectptr.p; + + UintR TndbapiConnect = regTmpApiPtr->ndbapiConnect; + UintR TfirstTcConnect = regTmpApiPtr->firstTcConnect; + UintR Ttransid1 = regTmpApiPtr->transid[0]; + UintR Ttransid2 = regTmpApiPtr->transid[1]; + UintR Tlqhkeyconfrec = regTmpApiPtr->lqhkeyconfrec; + UintR TgcpPointer = regTmpApiPtr->gcpPointer; + UintR TgcpFilesize = cgcpFilesize; + UintR TcommitAckMarker = regTmpApiPtr->commitAckMarker; + GcpRecord *localGcpRecord = gcpRecord; + + regApiPtr->ndbapiBlockref = regTmpApiPtr->ndbapiBlockref; + regApiPtr->ndbapiConnect = TndbapiConnect; + regApiPtr->firstTcConnect = TfirstTcConnect; + regApiPtr->apiConnectstate = CS_COMPLETING; + regApiPtr->transid[0] = Ttransid1; + regApiPtr->transid[1] = Ttransid2; + regApiPtr->lqhkeyconfrec = Tlqhkeyconfrec; + regApiPtr->commitAckMarker = TcommitAckMarker; + + gcpPtr.i = TgcpPointer; + ptrCheckGuard(gcpPtr, TgcpFilesize, localGcpRecord); + unlinkApiConnect(signal); + linkApiToGcp(signal); + setApiConTimer(tmpApiConnectptr.i, 0, __LINE__); + regTmpApiPtr->apiConnectstate = CS_CONNECTED; + regTmpApiPtr->commitAckMarker = RNIL; +}//Dbtc::copyApi() + +void Dbtc::unlinkApiConnect(Signal* signal) +{ + ApiConnectRecordPtr localApiConnectptr; + ApiConnectRecord * const regTmpApiPtr = tmpApiConnectptr.p; + UintR TapiConnectFilesize = capiConnectFilesize; + UintR TprevGcpConnect = regTmpApiPtr->prevGcpConnect; + UintR TnextGcpConnect = regTmpApiPtr->nextGcpConnect; + ApiConnectRecord *localApiConnectRecord = apiConnectRecord; + + if (TprevGcpConnect == RNIL) { + gcpPtr.p->firstApiConnect = TnextGcpConnect; + jam(); + } else { + localApiConnectptr.i = TprevGcpConnect; + jam(); + ptrCheckGuard(localApiConnectptr, + TapiConnectFilesize, localApiConnectRecord); + localApiConnectptr.p->nextGcpConnect = TnextGcpConnect; + }//if + if (TnextGcpConnect == RNIL) { + gcpPtr.p->lastApiConnect = TprevGcpConnect; + jam(); + } else { + localApiConnectptr.i = TnextGcpConnect; + jam(); + ptrCheckGuard(localApiConnectptr, + TapiConnectFilesize, localApiConnectRecord); + localApiConnectptr.p->prevGcpConnect = TprevGcpConnect; + }//if +}//Dbtc::unlinkApiConnect() + +void Dbtc::complete010Lab(Signal* signal) +{ + TcConnectRecordPtr localTcConnectptr; + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + UintR TtcConnectFilesize = ctcConnectFilesize; + TcConnectRecord *localTcConnectRecord = tcConnectRecord; + + localTcConnectptr.p = tcConnectptr.p; + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + UintR TapiConnectptrIndex = apiConnectptr.i; + UintR Tcount = 0; + do { + localTcConnectptr.p->apiConnect = TapiConnectptrIndex; + localTcConnectptr.p->tcConnectstate = OS_COMPLETING; + + /* ************ */ + /* COMPLETE < */ + /* ************ */ + const Uint32 nextTcConnect = localTcConnectptr.p->nextTcConnect; + sendCompleteLqh(signal, localTcConnectptr.p); + localTcConnectptr.i = nextTcConnect; + if (localTcConnectptr.i != RNIL) { + Tcount++; + if (Tcount < 16) { + ptrCheckGuard(localTcConnectptr, + TtcConnectFilesize, localTcConnectRecord); + jam(); + continue; + } else { + jam(); + if (ERROR_INSERTED(8013)) { + CLEAR_ERROR_INSERT_VALUE; + return; + }//if + signal->theData[0] = TcContinueB::ZSEND_COMPLETE_LOOP; + signal->theData[1] = apiConnectptr.i; + signal->theData[2] = localTcConnectptr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB); + return; + }//if + } else { + jam(); + regApiPtr->apiConnectstate = CS_COMPLETE_SENT; + return; + }//if + } while (1); +}//Dbtc::complete010Lab() + +void Dbtc::sendCompleteLqh(Signal* signal, + TcConnectRecord * const regTcPtr) +{ + HostRecordPtr Thostptr; + UintR ThostFilesize = chostFilesize; + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + Thostptr.i = regTcPtr->lastLqhNodeId; + ptrCheckGuard(Thostptr, ThostFilesize, hostRecord); + if (Thostptr.p->noOfPackedWordsLqh > 22) { + jam(); + sendPackedSignalLqh(signal, Thostptr.p); + } else { + jam(); + updatePackedList(signal, Thostptr.p, Thostptr.i); + }//if + + UintR Tindex = Thostptr.p->noOfPackedWordsLqh; + UintR* TDataPtr = &Thostptr.p->packedWordsLqh[Tindex]; + UintR Tdata1 = regTcPtr->lastLqhCon | (ZCOMPLETE << 28); + UintR Tdata2 = regApiPtr->transid[0]; + UintR Tdata3 = regApiPtr->transid[1]; + + TDataPtr[0] = Tdata1; + TDataPtr[1] = Tdata2; + TDataPtr[2] = Tdata3; + Thostptr.p->noOfPackedWordsLqh = Tindex + 3; +}//Dbtc::sendCompleteLqh() + +void +Dbtc::execTC_COMMIT_ACK(Signal* signal){ + jamEntry(); + + CommitAckMarker key; + key.transid1 = signal->theData[0]; + key.transid2 = signal->theData[1]; + + CommitAckMarkerPtr removedMarker; + m_commitAckMarkerHash.release(removedMarker, key); + if (removedMarker.i == RNIL) { + jam(); + warningHandlerLab(signal); + return; + }//if + sendRemoveMarkers(signal, removedMarker.p); +} + +void +Dbtc::sendRemoveMarkers(Signal* signal, const CommitAckMarker * marker){ + jam(); + const Uint32 noOfLqhs = marker->noOfLqhs; + const Uint32 transId1 = marker->transid1; + const Uint32 transId2 = marker->transid2; + + for(Uint32 i = 0; ilqhNodeId[i]; + sendRemoveMarker(signal, nodeId, transId1, transId2); + } +} + +void +Dbtc::sendRemoveMarker(Signal* signal, + NodeId nodeId, + Uint32 transid1, + Uint32 transid2){ + /** + * Seize host ptr + */ + HostRecordPtr hostPtr; + const UintR ThostFilesize = chostFilesize; + hostPtr.i = nodeId; + ptrCheckGuard(hostPtr, ThostFilesize, hostRecord); + + if (hostPtr.p->noOfPackedWordsLqh > (25 - 3)){ + jam(); + sendPackedSignalLqh(signal, hostPtr.p); + } else { + jam(); + updatePackedList(signal, hostPtr.p, hostPtr.i); + }//if + + UintR numWord = hostPtr.p->noOfPackedWordsLqh; + UintR* dataPtr = &hostPtr.p->packedWordsLqh[numWord]; + + dataPtr[0] = (ZREMOVE_MARKER << 28); + dataPtr[1] = transid1; + dataPtr[2] = transid2; + hostPtr.p->noOfPackedWordsLqh = numWord + 3; +} + +void Dbtc::execCOMPLETED(Signal* signal) +{ + TcConnectRecordPtr localTcConnectptr; + ApiConnectRecordPtr localApiConnectptr; + + UintR TtcConnectFilesize = ctcConnectFilesize; + UintR TapiConnectFilesize = capiConnectFilesize; + TcConnectRecord *localTcConnectRecord = tcConnectRecord; + ApiConnectRecord *localApiConnectRecord = apiConnectRecord; + +#ifdef ERROR_INSERT + if (ERROR_INSERTED(8031)) { + systemErrorLab(signal); + }//if + if (ERROR_INSERTED(8019)) { + CLEAR_ERROR_INSERT_VALUE; + return; + }//if + if (ERROR_INSERTED(8027)) { + SET_ERROR_INSERT_VALUE(8028); + return; + }//if + if (ERROR_INSERTED(8043)) { + CLEAR_ERROR_INSERT_VALUE; + sendSignalWithDelay(cownref, GSN_COMPLETED, signal, 2000, 3); + return; + }//if + if (ERROR_INSERTED(8044)) { + SET_ERROR_INSERT_VALUE(8047); + sendSignalWithDelay(cownref, GSN_COMPLETED, signal, 2000, 3); + return; + }//if +#endif + localTcConnectptr.i = signal->theData[0]; + jamEntry(); + ptrCheckGuard(localTcConnectptr, TtcConnectFilesize, localTcConnectRecord); + bool Tcond1 = (localTcConnectptr.p->tcConnectstate != OS_COMPLETING); + localApiConnectptr.i = localTcConnectptr.p->apiConnect; + if (Tcond1) { + warningReport(signal, 6); + return; + }//if + ptrCheckGuard(localApiConnectptr, TapiConnectFilesize, + localApiConnectRecord); + UintR Tdata1 = localApiConnectptr.p->transid[0] - signal->theData[1]; + UintR Tdata2 = localApiConnectptr.p->transid[1] - signal->theData[2]; + UintR Tcounter = localApiConnectptr.p->counter - 1; + ConnectionState TapiConnectstate = localApiConnectptr.p->apiConnectstate; + Tdata1 = Tdata1 | Tdata2; + bool TcheckCondition = + (TapiConnectstate != CS_COMPLETE_SENT) || (Tcounter != 0); + if (Tdata1 != 0) { + warningReport(signal, 7); + return; + }//if + setApiConTimer(localApiConnectptr.i, ctcTimer, __LINE__); + localApiConnectptr.p->counter = Tcounter; + localTcConnectptr.p->tcConnectstate = OS_COMPLETED; + localTcConnectptr.p->noOfNodes = 0; // == releaseNodes(signal) + if (TcheckCondition) { + jam(); + /*-------------------------------------------------------*/ + // We have not sent all COMPLETE requests yet. We could be + // in the state that all sent are COMPLETED but we are + // still waiting for a CONTINUEB to send the rest of the + // COMPLETE requests. + /*-------------------------------------------------------*/ + return; + }//if + if (ERROR_INSERTED(8021)) { + jam(); + systemErrorLab(signal); + }//if + apiConnectptr = localApiConnectptr; + releaseTransResources(signal); +}//Dbtc::execCOMPLETED() + +/*---------------------------------------------------------------------------*/ +/* RELEASE_TRANS_RESOURCES */ +/* RELEASE ALL RESOURCES THAT ARE CONNECTED TO THIS TRANSACTION. */ +/*---------------------------------------------------------------------------*/ +void Dbtc::releaseTransResources(Signal* signal) +{ + TcConnectRecordPtr localTcConnectptr; + UintR TtcConnectFilesize = ctcConnectFilesize; + TcConnectRecord *localTcConnectRecord = tcConnectRecord; + + localTcConnectptr.i = apiConnectptr.p->firstTcConnect; + do { + jam(); + ptrCheckGuard(localTcConnectptr, TtcConnectFilesize, localTcConnectRecord); + UintR rtrTcConnectptrIndex = localTcConnectptr.p->nextTcConnect; + tcConnectptr.i = localTcConnectptr.i; + tcConnectptr.p = localTcConnectptr.p; + localTcConnectptr.i = rtrTcConnectptrIndex; + releaseTcCon(signal); + } while (localTcConnectptr.i != RNIL); + handleGcp(signal); + releaseFiredTriggerData(&apiConnectptr.p->theFiredTriggers); + releaseAllSeizedIndexOperations(apiConnectptr.p); + releaseApiConCopy(signal); +}//Dbtc::releaseTransResources() + +/* *********************************************************************>> */ +/* MODULE: HANDLE_GCP */ +/* DESCRIPTION: HANDLES GLOBAL CHECKPOINT HANDLING AT THE COMPLETION */ +/* OF THE COMMIT PHASE AND THE ABORT PHASE. WE MUST ENSURE THAT TC */ +/* SENDS GCP_TCFINISHED WHEN ALL TRANSACTIONS BELONGING TO A CERTAIN */ +/* GLOBAL CHECKPOINT HAVE COMPLETED. */ +/* *********************************************************************>> */ +void Dbtc::handleGcp(Signal* signal) +{ + GcpRecord *localGcpRecord = gcpRecord; + GcpRecordPtr localGcpPtr; + UintR TapiConnectptrIndex = apiConnectptr.i; + UintR TgcpFilesize = cgcpFilesize; + localGcpPtr.i = apiConnectptr.p->gcpPointer; + tmpApiConnectptr.i = TapiConnectptrIndex; + tmpApiConnectptr.p = apiConnectptr.p; + ptrCheckGuard(localGcpPtr, TgcpFilesize, localGcpRecord); + gcpPtr.i = localGcpPtr.i; + gcpPtr.p = localGcpPtr.p; + unlinkApiConnect(signal); + if (localGcpPtr.p->firstApiConnect == RNIL) { + if (localGcpPtr.p->gcpNomoretransRec == ZTRUE) { + jam(); + tcheckGcpId = localGcpPtr.p->gcpId; + gcpTcfinished(signal); + unlinkGcp(signal); + }//if + }//if +}//Dbtc::handleGcp() + +void Dbtc::releaseApiConCopy(Signal* signal) +{ + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + UintR TfirstfreeApiConnectCopyOld = cfirstfreeApiConnectCopy; + cfirstfreeApiConnectCopy = apiConnectptr.i; + regApiPtr->nextApiConnect = TfirstfreeApiConnectCopyOld; + setApiConTimer(apiConnectptr.i, 0, __LINE__); + regApiPtr->apiConnectstate = CS_RESTART; +}//Dbtc::releaseApiConCopy() + +/* ========================================================================= */ +/* ------- RELEASE ALL RECORDS CONNECTED TO A DIRTY WRITE OPERATION ------- */ +/* ========================================================================= */ +void Dbtc::releaseDirtyWrite(Signal* signal) +{ + unlinkReadyTcCon(signal); + releaseTcCon(signal); + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + if (regApiPtr->apiConnectstate == CS_START_COMMITTING) { + if (regApiPtr->firstTcConnect == RNIL) { + jam(); + regApiPtr->apiConnectstate = CS_CONNECTED; + setApiConTimer(apiConnectptr.i, 0, __LINE__); + sendtckeyconf(signal, 1); + }//if + }//if +}//Dbtc::releaseDirtyWrite() + +/***************************************************************************** + * L Q H K E Y R E F + * WHEN LQHKEYREF IS RECEIVED DBTC WILL CHECK IF COMMIT FLAG WAS SENT FROM THE + * APPLICATION. IF SO, THE WHOLE TRANSACTION WILL BE ROLLED BACK AND SIGNAL + * TCROLLBACKREP WILL BE SENT TO THE API. + * + * OTHERWISE TC WILL CHECK THE ERRORCODE. IF THE ERRORCODE IS INDICATING THAT + * THE "ROW IS NOT FOUND" FOR UPDATE/READ/DELETE OPERATIONS AND "ROW ALREADY + * EXISTS" FOR INSERT OPERATIONS, DBTC WILL RELEASE THE OPERATION AND THEN + * SEND RETURN SIGNAL TCKEYREF TO THE USER. THE USER THEN HAVE TO SEND + * SIGNAL TC_COMMITREQ OR TC_ROLLBACKREQ TO CONCLUDE THE TRANSACTION. + * IF ANY TCKEYREQ WITH COMMIT IS RECEIVED AND API_CONNECTSTATE EQUALS + * "REC_LQHREFUSE", + * THE OPERATION WILL BE TREATED AS AN OPERATION WITHOUT COMMIT. WHEN ANY + * OTHER FAULTCODE IS RECEIVED THE WHOLE TRANSACTION MUST BE ROLLED BACK + *****************************************************************************/ +void Dbtc::execLQHKEYREF(Signal* signal) +{ + const LqhKeyRef * const lqhKeyRef = (LqhKeyRef *)signal->getDataPtr(); + jamEntry(); + + handleFailedOperation(signal, lqhKeyRef, true); +} + +void Dbtc::handleFailedOperation(Signal* signal, + const LqhKeyRef * const lqhKeyRef, + bool gotLqhKeyRef) +{ + UintR compare_transid1, compare_transid2; + + UintR TtcConnectFilesize = ctcConnectFilesize; + /*------------------------------------------------------------------------- + * + * RELEASE NODE BUFFER(S) TO INDICATE THAT THIS OPERATION HAVE NO + * TRANSACTION PARTS ACTIVE ANYMORE. + * LQHKEYREF HAVE CLEARED ALL PARTS ON ITS PATH BACK TO TC. + *-------------------------------------------------------------------------*/ + if (lqhKeyRef->connectPtr < TtcConnectFilesize) { + /*----------------------------------------------------------------------- + * WE HAVE TO CHECK THAT THE TRANSACTION IS STILL VALID. FIRST WE CHECK + * THAT THE LQH IS STILL CONNECTED TO A TC, IF THIS HOLDS TRUE THEN THE + * TC MUST BE CONNECTED TO AN API CONNECT RECORD. + * WE MUST ENSURE THAT THE TRANSACTION ID OF THIS API CONNECT + * RECORD IS STILL THE SAME AS THE ONE LQHKEYREF REFERS TO. + * IF NOT SIMPLY EXIT AND FORGET THE SIGNAL SINCE THE TRANSACTION IS + * ALREADY COMPLETED (ABORTED). + *-----------------------------------------------------------------------*/ + tcConnectptr.i = lqhKeyRef->connectPtr; + terrorCode = lqhKeyRef->errorCode; + ptrAss(tcConnectptr, tcConnectRecord); + TcConnectRecord * const regTcPtr = tcConnectptr.p; + if (regTcPtr->tcConnectstate == OS_OPERATING) { + apiConnectptr.i = regTcPtr->apiConnect; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + compare_transid1 = regApiPtr->transid[0] ^ lqhKeyRef->transId1; + compare_transid2 = regApiPtr->transid[1] ^ lqhKeyRef->transId2; + compare_transid1 = compare_transid1 | compare_transid2; + if (compare_transid1 != 0) { + warningReport(signal, 25); + return; + }//if + + if (regTcPtr->triggeringOperation != RNIL) { + jam(); + // This operation was created by a trigger execting operation + TcConnectRecordPtr opPtr; + TcConnectRecord *localTcConnectRecord = tcConnectRecord; + + const Uint32 currentIndexId = regTcPtr->currentIndexId; + + opPtr.i = regTcPtr->triggeringOperation; + ptrCheckGuard(opPtr, ctcConnectFilesize, localTcConnectRecord); + if (currentIndexId != RNIL) + { + jam(); + // The operation executed an index trigger + TcIndexData* indexData = NULL; + indexData = c_theIndexes.getPtr(currentIndexId); + if (regTcPtr->operation == ZDELETE) { + if (lqhKeyRef->errorCode == ZNOT_FOUND) { + if (indexData->indexState == IS_BUILDING) { + jam(); + /* + If an index trigger fail with delete during index + build phase it just means that the index build has not + yet inserted that tuple + Check if operation was a delete and part of trigger execution + */ + } else { + jam(); + ndbassert(false); + terrorCode = ZINDEX_CORRUPT_ERROR; + abortErrorLab(signal); + return; + }//if + } else { + terrorCode = lqhKeyRef->errorCode; + abortErrorLab(signal); + return; + } + } else if (regTcPtr->operation == ZINSERT) { + if (lqhKeyRef->errorCode == ZALREADYEXIST) { + terrorCode = 893; //Constraint violation + abortErrorLab(signal); + return; + } else { + terrorCode = lqhKeyRef->errorCode; + abortErrorLab(signal); + } + } else { + ndbrequire(false); + return; + } + markOperationAborted(regApiPtr, regTcPtr); + if (regApiPtr->apiConnectstate == CS_ABORTING) { + jam(); + return; + } + unlinkReadyTcCon(signal); + releaseTcCon(signal); + // Decrease counter as if NOOP + regApiPtr->lqhkeyreqrec--; + opPtr.p->triggerExecutionCount--; + if (opPtr.p->triggerExecutionCount == 0) { + jam(); + /* + We have completed current trigger execution + continue triggering operation + */ + continueTriggeringOp(signal, opPtr.p); + }//if + if (!regApiPtr->theFiredTriggers.isEmpty()) { + jam(); + /* + There are more triggers + Continue with next trigger + */ + executeTriggers(signal, &apiConnectptr); + }//if + return; + } else { + /** + * Currently the index id is always set for triggering operations + since we only support them for unique hash indexes at the moment. + */ + ndbrequire(false); + return; + } + } + if (gotLqhKeyRef) { + jam(); + markOperationAborted(regApiPtr, regTcPtr); + }//if + + if(regApiPtr->apiConnectstate == CS_ABORTING){ + /** + * We're already aborting' so don't send an "extra" TCKEYREF + */ + jam(); + return; + } + + const Uint32 abortOption = regTcPtr->m_execAbortOption; + if (abortOption == TcKeyReq::AbortOnError) { + /** + * No error is allowed on this operation + */ + TCKEY_abort(signal, 49); + return; + }//if + + if (regTcPtr->commitAckMarker != RNIL){ + /** + * This was an insert/update/delete/write which failed + * that contained the marker + * Currently unsupported to place new marker + */ + TCKEY_abort(signal, 49); + return; + } + + /* *************** */ + /* TCKEYREF < */ + /* *************** */ + TcKeyRef * const tcKeyRef = (TcKeyRef *) signal->getDataPtrSend(); + tcKeyRef->transId[0] = regApiPtr->transid[0]; + tcKeyRef->transId[1] = regApiPtr->transid[1]; + tcKeyRef->errorCode = terrorCode; + bool isIndexOp = regTcPtr->isIndexOp; + Uint32 indexOp = tcConnectptr.p->indexOp; + Uint32 clientData = regTcPtr->clientData; + if (gotLqhKeyRef) { + unlinkReadyTcCon(signal); /* LINK TC CONNECT RECORD OUT OF */ + releaseTcCon(signal); /* RELEASE THE TC CONNECT RECORD */ + } + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + if (isIndexOp) { + jam(); + tcKeyRef->connectPtr = indexOp; + EXECUTE_DIRECT(DBTC, GSN_TCKEYREF, signal, TcKeyRef::SignalLength); + } else { + jam(); + tcKeyRef->connectPtr = clientData; + sendSignal(regApiPtr->ndbapiBlockref, + GSN_TCKEYREF, signal, TcKeyRef::SignalLength, JBB); + }//if + + /*--------------------------------------------------------------------- + * SINCE WE ARE NOT ABORTING WE NEED TO UPDATE THE COUNT OF HOW MANY + * LQHKEYREQ THAT HAVE RETURNED. + * IF NO MORE OUTSTANDING LQHKEYREQ'S THEN WE NEED TO + * TCKEYCONF (IF THERE IS ANYTHING TO SEND). + *---------------------------------------------------------------------*/ + if (gotLqhKeyRef) { + jam(); + regApiPtr->lqhkeyreqrec = regApiPtr->lqhkeyreqrec - 1; + } else { + jam(); + regApiPtr->lqhkeyconfrec = regApiPtr->lqhkeyconfrec + 1; + }//if + if (regApiPtr->lqhkeyconfrec == regApiPtr->lqhkeyreqrec) { + if ((regApiPtr->lqhkeyconfrec == 0) && + (regApiPtr->apiConnectstate == CS_START_COMMITTING)) { + + if(abortOption == TcKeyReq::IgnoreError){ + jam(); + regApiPtr->returnsignal = RS_NO_RETURN; + abort010Lab(signal); + return; + } + + /*---------------------------------------------------------------- + * Not a single operation was successful. + * This we report as an aborted transaction + * to avoid performing a commit of zero operations. + *----------------------------------------------------------------*/ + TCKEY_abort(signal, 54); + return; + }//if + if (regApiPtr->apiConnectstate == CS_START_COMMITTING) { + jam(); + diverify010Lab(signal); + return; + } else if (regApiPtr->tckeyrec > 0) { + jam(); + sendtckeyconf(signal, 0); + return; + }//if + }//if + return; + + } else { + warningReport(signal, 26); + }//if + } else { + errorReport(signal, 6); + }//if + return; +}//Dbtc::execLQHKEYREF() + +void Dbtc::clearCommitAckMarker(ApiConnectRecord * const regApiPtr, + TcConnectRecord * const regTcPtr) +{ + const Uint32 commitAckMarker = regTcPtr->commitAckMarker; + if (regApiPtr->commitAckMarker == RNIL) + ndbassert(commitAckMarker == RNIL); + if (commitAckMarker != RNIL) + ndbassert(regApiPtr->commitAckMarker != RNIL); + if(commitAckMarker != RNIL){ + jam(); + m_commitAckMarkerHash.release(commitAckMarker); + regTcPtr->commitAckMarker = RNIL; + regApiPtr->commitAckMarker = RNIL; + } +} + +void Dbtc::markOperationAborted(ApiConnectRecord * const regApiPtr, + TcConnectRecord * const regTcPtr) +{ + /*------------------------------------------------------------------------ + * RELEASE NODES TO INDICATE THAT THE OPERATION IS ALREADY ABORTED IN THE + * LQH'S ALSO SET STATE TO ABORTING TO INDICATE THE ABORT IS + * ALREADY COMPLETED. + *------------------------------------------------------------------------*/ + regTcPtr->noOfNodes = 0; // == releaseNodes(signal) + regTcPtr->tcConnectstate = OS_ABORTING; + clearCommitAckMarker(regApiPtr, regTcPtr); +} + +/*--------------------------------------*/ +/* EXIT AND WAIT FOR SIGNAL TCOMMITREQ */ +/* OR TCROLLBACKREQ FROM THE USER TO */ +/* CONTINUE THE TRANSACTION */ +/*--------------------------------------*/ +void Dbtc::execTC_COMMITREQ(Signal* signal) +{ + UintR compare_transid1, compare_transid2; + + jamEntry(); + apiConnectptr.i = signal->theData[0]; + if (apiConnectptr.i < capiConnectFilesize) { + ptrAss(apiConnectptr, apiConnectRecord); + compare_transid1 = apiConnectptr.p->transid[0] ^ signal->theData[1]; + compare_transid2 = apiConnectptr.p->transid[1] ^ signal->theData[2]; + compare_transid1 = compare_transid1 | compare_transid2; + if (compare_transid1 != 0) { + jam(); + return; + }//if + + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + + const Uint32 apiConnectPtr = regApiPtr->ndbapiConnect; + const Uint32 apiBlockRef = regApiPtr->ndbapiBlockref; + const Uint32 transId1 = regApiPtr->transid[0]; + const Uint32 transId2 = regApiPtr->transid[1]; + Uint32 errorCode = 0; + + switch (regApiPtr->apiConnectstate) { + case CS_STARTED: + tcConnectptr.i = regApiPtr->firstTcConnect; + if (tcConnectptr.i != RNIL) { + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + if (regApiPtr->lqhkeyconfrec == regApiPtr->lqhkeyreqrec) { + jam(); + /*******************************************************************/ + // The proper case where the application is waiting for commit or + // abort order. + // Start the commit order. + /*******************************************************************/ + regApiPtr->returnsignal = RS_TC_COMMITCONF; + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + diverify010Lab(signal); + return; + } else { + jam(); + /*******************************************************************/ + // The transaction is started but not all operations are completed. + // It is not possible to commit the transaction in this state. + // We will abort it instead. + /*******************************************************************/ + regApiPtr->returnsignal = RS_NO_RETURN; + abort010Lab(signal); + errorCode = ZTRANS_STATUS_ERROR; + }//if + } else { + jam(); + /** + * No operations, accept commit + */ + TcCommitConf * const commitConf = (TcCommitConf *)&signal->theData[0]; + commitConf->apiConnectPtr = apiConnectPtr; + commitConf->transId1 = transId1; + commitConf->transId2 = transId2; + + sendSignal(apiBlockRef, GSN_TC_COMMITCONF, signal, 3, JBB); + + regApiPtr->returnsignal = RS_NO_RETURN; + releaseAbortResources(signal); + return; + }//if + break; + case CS_RECEIVING: + jam(); + /***********************************************************************/ + // A transaction is still receiving data. We cannot commit an unfinished + // transaction. We will abort it instead. + /***********************************************************************/ + regApiPtr->returnsignal = RS_NO_RETURN; + abort010Lab(signal); + errorCode = ZPREPAREINPROGRESS; + break; + + case CS_START_COMMITTING: + case CS_COMMITTING: + case CS_COMMIT_SENT: + case CS_COMPLETING: + case CS_COMPLETE_SENT: + case CS_REC_COMMITTING: + case CS_PREPARE_TO_COMMIT: + jam(); + /***********************************************************************/ + // The transaction is already performing a commit but it is not concluded + // yet. + /***********************************************************************/ + errorCode = ZCOMMITINPROGRESS; + break; + case CS_ABORTING: + jam(); + errorCode = ZABORTINPROGRESS; + break; + case CS_START_SCAN: + jam(); + /***********************************************************************/ + // The transaction is a scan. Scans cannot commit + /***********************************************************************/ + errorCode = ZSCANINPROGRESS; + break; + case CS_PREPARED: + jam(); + return; + case CS_START_PREPARING: + jam(); + return; + case CS_REC_PREPARING: + jam(); + return; + break; + default: + warningHandlerLab(signal); + return; + }//switch + TcCommitRef * const commitRef = (TcCommitRef*)&signal->theData[0]; + commitRef->apiConnectPtr = apiConnectPtr; + commitRef->transId1 = transId1; + commitRef->transId2 = transId2; + commitRef->errorCode = errorCode; + sendSignal(apiBlockRef, GSN_TC_COMMITREF, signal, + TcCommitRef::SignalLength, JBB); + return; + } else /** apiConnectptr.i < capiConnectFilesize */ { + jam(); + warningHandlerLab(signal); + return; + } +}//Dbtc::execTC_COMMITREQ() + +void Dbtc::execTCROLLBACKREQ(Signal* signal) +{ + UintR compare_transid1, compare_transid2; + + jamEntry(); + apiConnectptr.i = signal->theData[0]; + if (apiConnectptr.i >= capiConnectFilesize) { + goto TC_ROLL_warning; + }//if + ptrAss(apiConnectptr, apiConnectRecord); + compare_transid1 = apiConnectptr.p->transid[0] ^ signal->theData[1]; + compare_transid2 = apiConnectptr.p->transid[1] ^ signal->theData[2]; + compare_transid1 = compare_transid1 | compare_transid2; + if (compare_transid1 != 0) { + jam(); + return; + }//if + + switch (apiConnectptr.p->apiConnectstate) { + case CS_STARTED: + case CS_RECEIVING: + jam(); + apiConnectptr.p->returnsignal = RS_TCROLLBACKCONF; + abort010Lab(signal); + return; + case CS_CONNECTED: + jam(); + signal->theData[0] = apiConnectptr.p->ndbapiConnect; + signal->theData[1] = apiConnectptr.p->transid[0]; + signal->theData[2] = apiConnectptr.p->transid[1]; + sendSignal(apiConnectptr.p->ndbapiBlockref, GSN_TCROLLBACKCONF, + signal, 3, JBB); + break; + case CS_START_SCAN: + case CS_PREPARE_TO_COMMIT: + case CS_COMMITTING: + case CS_COMMIT_SENT: + case CS_COMPLETING: + case CS_COMPLETE_SENT: + case CS_WAIT_COMMIT_CONF: + case CS_WAIT_COMPLETE_CONF: + case CS_RESTART: + case CS_DISCONNECTED: + case CS_START_COMMITTING: + case CS_REC_COMMITTING: + jam(); + /* ***************< */ + /* TC_ROLLBACKREF < */ + /* ***************< */ + signal->theData[0] = apiConnectptr.p->ndbapiConnect; + signal->theData[1] = apiConnectptr.p->transid[0]; + signal->theData[2] = apiConnectptr.p->transid[1]; + signal->theData[3] = ZROLLBACKNOTALLOWED; + sendSignal(apiConnectptr.p->ndbapiBlockref, GSN_TCROLLBACKREF, + signal, 4, JBB); + break; + /* SEND A REFUSAL SIGNAL*/ + case CS_ABORTING: + jam(); + if (apiConnectptr.p->abortState == AS_IDLE) { + jam(); + signal->theData[0] = apiConnectptr.p->ndbapiConnect; + signal->theData[1] = apiConnectptr.p->transid[0]; + signal->theData[2] = apiConnectptr.p->transid[1]; + sendSignal(apiConnectptr.p->ndbapiBlockref, GSN_TCROLLBACKCONF, + signal, 3, JBB); + } else { + jam(); + apiConnectptr.p->returnsignal = RS_TCROLLBACKCONF; + }//if + break; + case CS_WAIT_ABORT_CONF: + jam(); + apiConnectptr.p->returnsignal = RS_TCROLLBACKCONF; + break; + case CS_START_PREPARING: + jam(); + case CS_PREPARED: + jam(); + case CS_REC_PREPARING: + jam(); + default: + goto TC_ROLL_system_error; + break; + }//switch + return; + +TC_ROLL_warning: + jam(); + warningHandlerLab(signal); + return; + +TC_ROLL_system_error: + jam(); + systemErrorLab(signal); + return; +}//Dbtc::execTCROLLBACKREQ() + +void Dbtc::execTC_HBREP(Signal* signal) +{ + const TcHbRep * const tcHbRep = + (TcHbRep *)signal->getDataPtr(); + + jamEntry(); + apiConnectptr.i = tcHbRep->apiConnectPtr; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + + if (apiConnectptr.p->transid[0] == tcHbRep->transId1 && + apiConnectptr.p->transid[1] == tcHbRep->transId2){ + + if (getApiConTimer(apiConnectptr.i) != 0){ + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + } else { + DEBUG("TCHBREP received when timer was off apiConnectptr.i=" + << apiConnectptr.i); + } + } +}//Dbtc::execTCHBREP() + +/* +4.3.15 ABORT +----------- +*/ +/*****************************************************************************/ +/* A B O R T */ +/* */ +/*****************************************************************************/ +void Dbtc::warningReport(Signal* signal, int place) +{ + switch (place) { + case 0: + jam(); +#ifdef ABORT_TRACE + ndbout << "ABORTED to not active TC record" << endl; +#endif + break; + case 1: + jam(); +#ifdef ABORT_TRACE + ndbout << "ABORTED to TC record active with new transaction" << endl; +#endif + break; + case 2: + jam(); +#ifdef ABORT_TRACE + ndbout << "ABORTED to active TC record not expecting ABORTED" << endl; +#endif + break; + case 3: + jam(); +#ifdef ABORT_TRACE + ndbout << "ABORTED to TC rec active with trans but wrong node" << endl; + ndbout << "This is ok when aborting in node failure situations" << endl; +#endif + break; + case 4: + jam(); +#ifdef ABORT_TRACE + ndbout << "Received COMMITTED in wrong state in Dbtc" << endl; +#endif + break; + case 5: + jam(); +#ifdef ABORT_TRACE + ndbout << "Received COMMITTED with wrong transid in Dbtc" << endl; +#endif + break; + case 6: + jam(); +#ifdef ABORT_TRACE + ndbout << "Received COMPLETED in wrong state in Dbtc" << endl; +#endif + break; + case 7: + jam(); +#ifdef ABORT_TRACE + ndbout << "Received COMPLETED with wrong transid in Dbtc" << endl; +#endif + break; + case 8: + jam(); +#ifdef ABORT_TRACE + ndbout << "Received COMMITCONF with tc-rec in wrong state in Dbtc" << endl; +#endif + break; + case 9: + jam(); +#ifdef ABORT_TRACE + ndbout << "Received COMMITCONF with api-rec in wrong state in Dbtc" <theData[0]; + UintR Tnodeid = signal->theData[3]; + UintR TlastLqhInd = signal->theData[4]; + + if (ERROR_INSERTED(8040)) { + CLEAR_ERROR_INSERT_VALUE; + sendSignalWithDelay(cownref, GSN_ABORTED, signal, 2000, 5); + return; + }//if + /*------------------------------------------------------------------------ + * ONE PARTICIPANT IN THE TRANSACTION HAS REPORTED THAT IT IS ABORTED. + *------------------------------------------------------------------------*/ + if (tcConnectptr.i >= ctcConnectFilesize) { + errorReport(signal, 0); + return; + }//if + /*------------------------------------------------------------------------- + * WE HAVE TO CHECK THAT THIS IS NOT AN OLD SIGNAL BELONGING TO A + * TRANSACTION ALREADY ABORTED. THIS CAN HAPPEN WHEN TIME-OUT OCCURS + * IN TC WAITING FOR ABORTED. + *-------------------------------------------------------------------------*/ + ptrAss(tcConnectptr, tcConnectRecord); + if (tcConnectptr.p->tcConnectstate != OS_ABORT_SENT) { + warningReport(signal, 2); + return; + /*-----------------------------------------------------------------------*/ + // ABORTED reported on an operation not expecting ABORT. + /*-----------------------------------------------------------------------*/ + }//if + apiConnectptr.i = tcConnectptr.p->apiConnect; + if (apiConnectptr.i >= capiConnectFilesize) { + warningReport(signal, 0); + return; + }//if + ptrAss(apiConnectptr, apiConnectRecord); + compare_transid1 = apiConnectptr.p->transid[0] ^ signal->theData[1]; + compare_transid2 = apiConnectptr.p->transid[1] ^ signal->theData[2]; + compare_transid1 = compare_transid1 | compare_transid2; + if (compare_transid1 != 0) { + warningReport(signal, 1); + return; + }//if + if (ERROR_INSERTED(8024)) { + jam(); + systemErrorLab(signal); + }//if + + /** + * Release marker + */ + clearCommitAckMarker(apiConnectptr.p, tcConnectptr.p); + + Uint32 i; + Uint32 Tfound = 0; + for (i = 0; i < tcConnectptr.p->noOfNodes; i++) { + jam(); + if (tcConnectptr.p->tcNodedata[i] == Tnodeid) { + /*--------------------------------------------------------------------- + * We have received ABORTED from one of the participants in this + * operation in this aborted transaction. + * Record all nodes that have completed abort. + * If last indicator is set it means that no more replica has + * heard of the operation and are thus also aborted. + *---------------------------------------------------------------------*/ + jam(); + Tfound = 1; + clearTcNodeData(signal, TlastLqhInd, i); + }//if + }//for + if (Tfound == 0) { + warningReport(signal, 3); + return; + } + for (i = 0; i < tcConnectptr.p->noOfNodes; i++) { + if (tcConnectptr.p->tcNodedata[i] != 0) { + /*-------------------------------------------------------------------- + * There are still outstanding ABORTED's to wait for. + *--------------------------------------------------------------------*/ + jam(); + return; + }//if + }//for + tcConnectptr.p->noOfNodes = 0; + tcConnectptr.p->tcConnectstate = OS_ABORTING; + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + apiConnectptr.p->counter--; + if (apiConnectptr.p->counter > 0) { + jam(); + /*---------------------------------------------------------------------- + * WE ARE STILL WAITING FOR MORE PARTICIPANTS TO SEND ABORTED. + *----------------------------------------------------------------------*/ + return; + }//if + /*------------------------------------------------------------------------*/ + /* */ + /* WE HAVE NOW COMPLETED THE ABORT PROCESS. WE HAVE RECEIVED ABORTED */ + /* FROM ALL PARTICIPANTS IN THE TRANSACTION. WE CAN NOW RELEASE ALL */ + /* RESOURCES CONNECTED TO THE TRANSACTION AND SEND THE ABORT RESPONSE */ + /*------------------------------------------------------------------------*/ + releaseAbortResources(signal); +}//Dbtc::execABORTED() + +void Dbtc::clearTcNodeData(Signal* signal, + UintR TLastLqhIndicator, + UintR Tstart) +{ + UintR Ti; + if (TLastLqhIndicator == ZTRUE) { + for (Ti = Tstart ; Ti < tcConnectptr.p->noOfNodes; Ti++) { + jam(); + tcConnectptr.p->tcNodedata[Ti] = 0; + }//for + } else { + jam(); + tcConnectptr.p->tcNodedata[Tstart] = 0; + }//for +}//clearTcNodeData() + +void Dbtc::abortErrorLab(Signal* signal) +{ + ptrGuard(apiConnectptr); + ApiConnectRecord * transP = apiConnectptr.p; + if (transP->apiConnectstate == CS_ABORTING && transP->abortState != AS_IDLE){ + jam(); + return; + } + transP->returnsignal = RS_TCROLLBACKREP; + transP->returncode = terrorCode; + abort010Lab(signal); +}//Dbtc::abortErrorLab() + +void Dbtc::abort010Lab(Signal* signal) +{ + ApiConnectRecord * transP = apiConnectptr.p; + if (transP->apiConnectstate == CS_ABORTING && transP->abortState != AS_IDLE){ + jam(); + return; + } + transP->apiConnectstate = CS_ABORTING; + /*------------------------------------------------------------------------*/ + /* AN ABORT DECISION HAS BEEN TAKEN FOR SOME REASON. WE NEED TO ABORT */ + /* ALL PARTICIPANTS IN THE TRANSACTION. */ + /*------------------------------------------------------------------------*/ + transP->abortState = AS_ACTIVE; + transP->counter = 0; + + if (transP->firstTcConnect == RNIL) { + jam(); + /*-----------------------------------------------------------------------*/ + /* WE HAVE NO PARTICIPANTS IN THE TRANSACTION. */ + /*-----------------------------------------------------------------------*/ + releaseAbortResources(signal); + return; + }//if + tcConnectptr.i = transP->firstTcConnect; + abort015Lab(signal); +}//Dbtc::abort010Lab() + +/*--------------------------------------------------------------------------*/ +/* */ +/* WE WILL ABORT ONE NODE PER OPERATION AT A TIME. THIS IS TO KEEP */ +/* ERROR HANDLING OF THIS PROCESS FAIRLY SIMPLE AND TRACTABLE. */ +/* EVEN IF NO NODE OF THIS PARTICULAR NODE NUMBER NEEDS ABORTION WE */ +/* MUST ENSURE THAT ALL NODES ARE CHECKED. THUS A FAULTY NODE DOES */ +/* NOT MEAN THAT ALL NODES IN AN OPERATION IS ABORTED. FOR THIS REASON*/ +/* WE SET THE TCONTINUE_ABORT TO TRUE WHEN A FAULTY NODE IS DETECTED. */ +/*--------------------------------------------------------------------------*/ +void Dbtc::abort015Lab(Signal* signal) +{ + Uint32 TloopCount = 0; +ABORT020: + jam(); + TloopCount++; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + switch (tcConnectptr.p->tcConnectstate) { + case OS_WAIT_DIH: + case OS_WAIT_KEYINFO: + case OS_WAIT_ATTR: + jam(); + /*----------------------------------------------------------------------*/ + /* WE ARE STILL WAITING FOR MORE KEYINFO/ATTRINFO. WE HAVE NOT CONTACTED*/ + /* ANY LQH YET AND SO WE CAN SIMPLY SET STATE TO ABORTING. */ + /*----------------------------------------------------------------------*/ + tcConnectptr.p->noOfNodes = 0; // == releaseAbort(signal) + tcConnectptr.p->tcConnectstate = OS_ABORTING; + break; + case OS_CONNECTED: + jam(); + /*----------------------------------------------------------------------- + * WE ARE STILL IN THE INITIAL PHASE OF THIS OPERATION. + * NEED NOT BOTHER ABOUT ANY LQH ABORTS. + *-----------------------------------------------------------------------*/ + tcConnectptr.p->noOfNodes = 0; // == releaseAbort(signal) + tcConnectptr.p->tcConnectstate = OS_ABORTING; + break; + case OS_PREPARED: + jam(); + case OS_OPERATING: + jam(); + /*---------------------------------------------------------------------- + * WE HAVE SENT LQHKEYREQ AND ARE IN SOME STATE OF EITHER STILL + * SENDING THE OPERATION, WAITING FOR REPLIES, WAITING FOR MORE + * ATTRINFO OR OPERATION IS PREPARED. WE NEED TO ABORT ALL LQH'S. + *----------------------------------------------------------------------*/ + releaseAndAbort(signal); + tcConnectptr.p->tcConnectstate = OS_ABORT_SENT; + TloopCount += 127; + break; + case OS_ABORTING: + jam(); + break; + case OS_ABORT_SENT: + jam(); + DEBUG("ABORT_SENT state in abort015Lab(), not expected"); + systemErrorLab(signal); + return; + default: + jam(); + DEBUG("tcConnectstate = " << tcConnectptr.p->tcConnectstate); + systemErrorLab(signal); + return; + }//switch + + if (tcConnectptr.p->nextTcConnect != RNIL) { + jam(); + tcConnectptr.i = tcConnectptr.p->nextTcConnect; + if (TloopCount < 1024) { + goto ABORT020; + } else { + jam(); + /*--------------------------------------------------------------------- + * Reset timer to avoid time-out in real-time break. + * Increase counter to ensure that we don't think that all ABORTED have + * been received before all have been sent. + *---------------------------------------------------------------------*/ + apiConnectptr.p->counter++; + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + signal->theData[0] = TcContinueB::ZABORT_BREAK; + signal->theData[1] = tcConnectptr.i; + signal->theData[2] = apiConnectptr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB); + return; + }//if + }//if + if (apiConnectptr.p->counter > 0) { + jam(); + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + return; + }//if + /*----------------------------------------------------------------------- + * WE HAVE NOW COMPLETED THE ABORT PROCESS. WE HAVE RECEIVED ABORTED + * FROM ALL PARTICIPANTS IN THE TRANSACTION. WE CAN NOW RELEASE ALL + * RESOURCES CONNECTED TO THE TRANSACTION AND SEND THE ABORT RESPONSE + *------------------------------------------------------------------------*/ + releaseAbortResources(signal); +}//Dbtc::abort015Lab() + +/*--------------------------------------------------------------------------*/ +/* RELEASE KEY AND ATTRINFO OBJECTS AND SEND ABORT TO THE LQH BLOCK. */ +/*--------------------------------------------------------------------------*/ +int Dbtc::releaseAndAbort(Signal* signal) +{ + HostRecordPtr localHostptr; + UintR TnoLoops = tcConnectptr.p->noOfNodes; + + apiConnectptr.p->counter++; + for (Uint32 Ti = 0; Ti < TnoLoops ; Ti++) { + localHostptr.i = tcConnectptr.p->tcNodedata[Ti]; + ptrCheckGuard(localHostptr, chostFilesize, hostRecord); + if (localHostptr.p->hostStatus == HS_ALIVE) { + jam(); + /* ************< */ + /* ABORT < */ + /* ************< */ + tblockref = calcLqhBlockRef(localHostptr.i); + signal->theData[0] = tcConnectptr.i; + signal->theData[1] = cownref; + signal->theData[2] = apiConnectptr.p->transid[0]; + signal->theData[3] = apiConnectptr.p->transid[1]; + sendSignal(tblockref, GSN_ABORT, signal, 4, JBB); + return 1; + } else { + jam(); + signal->theData[0] = tcConnectptr.i; + signal->theData[1] = apiConnectptr.p->transid[0]; + signal->theData[2] = apiConnectptr.p->transid[1]; + signal->theData[3] = hostptr.i; + signal->theData[4] = ZFALSE; + sendSignal(cownref, GSN_ABORTED, signal, 5, JBB); + }//if + }//for + return 1; +}//Dbtc::releaseAndAbort() + +/* ------------------------------------------------------------------------- */ +/* ------- ENTER TIME_SIGNAL ------- */ +/* */ +/* ------------------------------------------------------------------------- */ +void Dbtc::execTIME_SIGNAL(Signal* signal) +{ + + jamEntry(); + ctcTimer++; + if (csystemStart != SSS_TRUE) { + jam(); + return; + }//if + checkStartTimeout(signal); + checkStartFragTimeout(signal); +}//Dbtc::execTIME_SIGNAL() + +/*------------------------------------------------*/ +/* Start timeout handling if not already going on */ +/*------------------------------------------------*/ +void Dbtc::checkStartTimeout(Signal* signal) +{ + ctimeOutCheckCounter++; + if (ctimeOutCheckActive == TOCS_TRUE) { + jam(); + // Check heartbeat of timeout loop + if(ctimeOutCheckHeartbeat > ctimeOutCheckLastHeartbeat){ + jam(); + ctimeOutMissedHeartbeats = 0; + }else{ + jam(); + ctimeOutMissedHeartbeats++; + if (ctimeOutMissedHeartbeats > 100){ + jam(); + systemErrorLab(signal); + } + } + ctimeOutCheckLastHeartbeat = ctimeOutCheckHeartbeat; + return; + }//if + if (ctimeOutCheckCounter < ctimeOutCheckDelay) { + jam(); + /*------------------------------------------------------------------*/ + /* */ + /* NO TIME-OUT CHECKED THIS TIME. WAIT MORE. */ + /*------------------------------------------------------------------*/ + return; + }//if + ctimeOutCheckActive = TOCS_TRUE; + ctimeOutCheckCounter = 0; + timeOutLoopStartLab(signal, 0); // 0 is first api connect record + return; +}//Dbtc::execTIME_SIGNAL() + +/*----------------------------------------------------------------*/ +/* Start fragment (scan) timeout handling if not already going on */ +/*----------------------------------------------------------------*/ +void Dbtc::checkStartFragTimeout(Signal* signal) +{ + ctimeOutCheckFragCounter++; + if (ctimeOutCheckFragActive == TOCS_TRUE) { + jam(); + return; + }//if + if (ctimeOutCheckFragCounter < ctimeOutCheckDelay) { + jam(); + /*------------------------------------------------------------------*/ + /* NO TIME-OUT CHECKED THIS TIME. WAIT MORE. */ + /*------------------------------------------------------------------*/ + return; + }//if + + // Go through the fragment records and look for timeout in a scan. + ctimeOutCheckFragActive = TOCS_TRUE; + ctimeOutCheckFragCounter = 0; + timeOutLoopStartFragLab(signal, 0); // 0 means first scan record +}//checkStartFragTimeout() + +/*------------------------------------------------------------------*/ +/* IT IS NOW TIME TO CHECK WHETHER ANY TRANSACTIONS HAVE */ +/* BEEN DELAYED FOR SO LONG THAT WE ARE FORCED TO PERFORM */ +/* SOME ACTION, EITHER ABORT OR RESEND OR REMOVE A NODE FROM */ +/* THE WAITING PART OF A PROTOCOL. */ +/*------------------------------------------------------------------*/ +void Dbtc::timeOutLoopStartLab(Signal* signal, Uint32 TapiConPtr) +{ + UintR texpiredTime[8]; + UintR TloopCount = 0; + + ctimeOutCheckHeartbeat = ctcTimer; + + const Uint32 TapiConSz = capiConnectFilesize; + const Uint32 TtcTimer = ctcTimer; + const Uint32 TtimeOutValue = ctimeOutValue; + + while ((TapiConPtr + 8) < TapiConSz) { + jam(); + texpiredTime[0] = TtcTimer - getApiConTimer(TapiConPtr + 0); + texpiredTime[1] = TtcTimer - getApiConTimer(TapiConPtr + 1); + texpiredTime[2] = TtcTimer - getApiConTimer(TapiConPtr + 2); + texpiredTime[3] = TtcTimer - getApiConTimer(TapiConPtr + 3); + texpiredTime[4] = TtcTimer - getApiConTimer(TapiConPtr + 4); + texpiredTime[5] = TtcTimer - getApiConTimer(TapiConPtr + 5); + texpiredTime[6] = TtcTimer - getApiConTimer(TapiConPtr + 6); + texpiredTime[7] = TtcTimer - getApiConTimer(TapiConPtr + 7); + for (Uint32 Ti = 0; Ti < 8; Ti++) { + if (getApiConTimer(TapiConPtr + Ti) != 0) { + if (texpiredTime[Ti] > TtimeOutValue) { + jam(); + timeOutFoundLab(signal, TapiConPtr + Ti); + return; + }//if + }//if + }//for + TapiConPtr += 8; + if (TloopCount++ > 128) { + jam(); + sendContinueTimeOutControl(signal, TapiConPtr); + return; + }//if + }//while + for ( ; TapiConPtr < TapiConSz; TapiConPtr++) { + jam(); + if (getApiConTimer(TapiConPtr) != 0) { + texpiredTime[0] = TtcTimer - getApiConTimer(TapiConPtr); + if (texpiredTime[0] > TtimeOutValue) { + jam(); + timeOutFoundLab(signal, TapiConPtr); + return; + }//if + }//if + }//for + /*------------------------------------------------------------------*/ + /* */ + /* WE HAVE NOW CHECKED ALL TRANSACTIONS FOR TIME-OUT AND ALSO */ + /* STARTED TIME-OUT HANDLING OF THOSE WE FOUND. WE ARE NOW */ + /* READY AND CAN WAIT FOR THE NEXT TIME-OUT CHECK. */ + /*------------------------------------------------------------------*/ + ctimeOutCheckActive = TOCS_FALSE; +}//Dbtc::timeOutLoopStartLab() + +void Dbtc::timeOutFoundLab(Signal* signal, Uint32 TapiConPtr) +{ + sendContinueTimeOutControl(signal, TapiConPtr + 1); + + apiConnectptr.i = TapiConPtr; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + /*------------------------------------------------------------------*/ + /* */ + /* THIS TRANSACTION HAVE EXPERIENCED A TIME-OUT AND WE NEED TO*/ + /* FIND OUT WHAT WE NEED TO DO BASED ON THE STATE INFORMATION.*/ + /*------------------------------------------------------------------*/ + DEBUG("Time-out in state = " << apiConnectptr.p->apiConnectstate + << " apiConnectptr.i = " << apiConnectptr.i); + switch (apiConnectptr.p->apiConnectstate) { + case CS_STARTED: + if(apiConnectptr.p->lqhkeyreqrec == apiConnectptr.p->lqhkeyconfrec){ + jam(); + /* + We are waiting for application to continue the transaction. In this + particular state we will use the application timeout parameter rather + than the shorter Deadlock detection timeout. + */ + if ((ctcTimer - getApiConTimer(apiConnectptr.i)) <= c_appl_timeout_value) { + jam(); + return; + }//if + apiConnectptr.p->returnsignal = RS_NO_RETURN; + } else { + jam(); + apiConnectptr.p->returnsignal = RS_TCROLLBACKREP; + } + apiConnectptr.p->returncode = ZTIME_OUT_ERROR; + abort010Lab(signal); + return; + case CS_RECEIVING: + case CS_REC_COMMITTING: + case CS_START_COMMITTING: + jam(); + /*------------------------------------------------------------------*/ + /* WE ARE STILL IN THE PREPARE PHASE AND THE TRANSACTION HAS */ + /* NOT YET REACHED ITS COMMIT POINT. THUS IT IS NOW OK TO */ + /* START ABORTING THE TRANSACTION. ALSO START CHECKING THE */ + /* REMAINING TRANSACTIONS. */ + /*------------------------------------------------------------------*/ + terrorCode = ZTIME_OUT_ERROR; + abortErrorLab(signal); + return; + case CS_COMMITTING: + jam(); + /*------------------------------------------------------------------*/ + // We are simply waiting for a signal in the job buffer. Only extreme + // conditions should get us here. We ignore it. + /*------------------------------------------------------------------*/ + case CS_COMPLETING: + jam(); + /*------------------------------------------------------------------*/ + // We are simply waiting for a signal in the job buffer. Only extreme + // conditions should get us here. We ignore it. + /*------------------------------------------------------------------*/ + case CS_PREPARE_TO_COMMIT: + jam(); + /*------------------------------------------------------------------*/ + /* WE ARE WAITING FOR DIH TO COMMIT THE TRANSACTION. WE SIMPLY*/ + /* KEEP WAITING SINCE THERE IS NO BETTER IDEA ON WHAT TO DO. */ + /* IF IT IS BLOCKED THEN NO TRANSACTION WILL PASS THIS GATE. */ + // To ensure against strange bugs we crash the system if we have passed + // time-out period by a factor of 10 and it is also at least 5 seconds. + /*------------------------------------------------------------------*/ + if (((ctcTimer - getApiConTimer(apiConnectptr.i)) > (10 * ctimeOutValue)) && + ((ctcTimer - getApiConTimer(apiConnectptr.i)) > 500)) { + jam(); + systemErrorLab(signal); + }//if + break; + case CS_COMMIT_SENT: + jam(); + /*------------------------------------------------------------------*/ + /* WE HAVE SENT COMMIT TO A NUMBER OF NODES. WE ARE CURRENTLY */ + /* WAITING FOR THEIR REPLY. WITH NODE RECOVERY SUPPORTED WE */ + /* WILL CHECK FOR CRASHED NODES AND RESEND THE COMMIT SIGNAL */ + /* TO THOSE NODES THAT HAVE MISSED THE COMMIT SIGNAL DUE TO */ + /* A NODE FAILURE. */ + /*------------------------------------------------------------------*/ + tabortInd = ZCOMMIT_SETUP; + setupFailData(signal); + toCommitHandlingLab(signal); + return; + case CS_COMPLETE_SENT: + jam(); + /*--------------------------------------------------------------------*/ + /* WE HAVE SENT COMPLETE TO A NUMBER OF NODES. WE ARE CURRENTLY */ + /* WAITING FOR THEIR REPLY. WITH NODE RECOVERY SUPPORTED WE */ + /* WILL CHECK FOR CRASHED NODES AND RESEND THE COMPLETE SIGNAL */ + /* TO THOSE NODES THAT HAVE MISSED THE COMPLETE SIGNAL DUE TO */ + /* A NODE FAILURE. */ + /*--------------------------------------------------------------------*/ + tabortInd = ZCOMMIT_SETUP; + setupFailData(signal); + toCompleteHandlingLab(signal); + return; + case CS_ABORTING: + jam(); + /*------------------------------------------------------------------*/ + /* TIME-OUT DURING ABORT. WE NEED TO SEND ABORTED FOR ALL */ + /* NODES THAT HAVE FAILED BEFORE SENDING ABORTED. */ + /*------------------------------------------------------------------*/ + tcConnectptr.i = apiConnectptr.p->firstTcConnect; + sendAbortedAfterTimeout(signal, 0); + break; + case CS_START_SCAN: + jam(); + apiConnectptr.p->returncode = ZSCANTIME_OUT_ERROR; + handleScanStop(signal, 0); + break; + case CS_WAIT_ABORT_CONF: + jam(); + tcConnectptr.i = apiConnectptr.p->currentTcConnect; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + arrGuard(apiConnectptr.p->currentReplicaNo, 4); + hostptr.i = tcConnectptr.p->tcNodedata[apiConnectptr.p->currentReplicaNo]; + ptrCheckGuard(hostptr, chostFilesize, hostRecord); + if (hostptr.p->hostStatus == HS_ALIVE) { + /*------------------------------------------------------------------*/ + // Time-out waiting for ABORTCONF. We will resend the ABORTREQ just in + // case. + /*------------------------------------------------------------------*/ + warningReport(signal, 20); + apiConnectptr.p->timeOutCounter++; + if (apiConnectptr.p->timeOutCounter > 3) { + /*------------------------------------------------------------------*/ + // 100 time-outs are not acceptable. We will shoot down the node + // not responding. + /*------------------------------------------------------------------*/ + reportNodeFailed(signal, hostptr.i); + }//if + apiConnectptr.p->currentReplicaNo++; + }//if + tcurrentReplicaNo = (Uint8)Z8NIL; + toAbortHandlingLab(signal); + return; + case CS_WAIT_COMMIT_CONF: + jam(); + tcConnectptr.i = apiConnectptr.p->currentTcConnect; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + arrGuard(apiConnectptr.p->currentReplicaNo, 4); + hostptr.i = tcConnectptr.p->tcNodedata[apiConnectptr.p->currentReplicaNo]; + ptrCheckGuard(hostptr, chostFilesize, hostRecord); + if (hostptr.p->hostStatus == HS_ALIVE) { + /*------------------------------------------------------------------*/ + // Time-out waiting for COMMITCONF. We will resend the COMMITREQ just in + // case. + /*------------------------------------------------------------------*/ + warningReport(signal, 21); + apiConnectptr.p->timeOutCounter++; + if (apiConnectptr.p->timeOutCounter > 3) { + /*------------------------------------------------------------------*/ + // 100 time-outs are not acceptable. We will shoot down the node + // not responding. + /*------------------------------------------------------------------*/ + reportNodeFailed(signal, hostptr.i); + }//if + apiConnectptr.p->currentReplicaNo++; + }//if + tcurrentReplicaNo = (Uint8)Z8NIL; + toCommitHandlingLab(signal); + return; + case CS_WAIT_COMPLETE_CONF: + jam(); + tcConnectptr.i = apiConnectptr.p->currentTcConnect; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + arrGuard(apiConnectptr.p->currentReplicaNo, 4); + hostptr.i = tcConnectptr.p->tcNodedata[apiConnectptr.p->currentReplicaNo]; + ptrCheckGuard(hostptr, chostFilesize, hostRecord); + if (hostptr.p->hostStatus == HS_ALIVE) { + /*------------------------------------------------------------------*/ + // Time-out waiting for COMPLETECONF. We will resend the COMPLETEREQ + // just in case. + /*------------------------------------------------------------------*/ + warningReport(signal, 22); + apiConnectptr.p->timeOutCounter++; + if (apiConnectptr.p->timeOutCounter > 100) { + /*------------------------------------------------------------------*/ + // 100 time-outs are not acceptable. We will shoot down the node + // not responding. + /*------------------------------------------------------------------*/ + reportNodeFailed(signal, hostptr.i); + }//if + apiConnectptr.p->currentReplicaNo++; + }//if + tcurrentReplicaNo = (Uint8)Z8NIL; + toCompleteHandlingLab(signal); + return; + case CS_FAIL_PREPARED: + jam(); + case CS_FAIL_COMMITTING: + jam(); + case CS_FAIL_COMMITTED: + jam(); + case CS_REC_PREPARING: + jam(); + case CS_START_PREPARING: + jam(); + case CS_PREPARED: + jam(); + case CS_RESTART: + jam(); + case CS_FAIL_ABORTED: + jam(); + case CS_DISCONNECTED: + jam(); + default: + jam(); + /*------------------------------------------------------------------*/ + /* AN IMPOSSIBLE STATE IS SET. CRASH THE SYSTEM. */ + /*------------------------------------------------------------------*/ + DEBUG("State = " << apiConnectptr.p->apiConnectstate); + systemErrorLab(signal); + return; + }//switch + return; +}//Dbtc::timeOutFoundLab() + +void Dbtc::sendAbortedAfterTimeout(Signal* signal, int Tcheck) +{ + ApiConnectRecord * transP = apiConnectptr.p; + if(transP->abortState == AS_IDLE){ + jam(); + warningEvent("TC: %d: %d state=%d abort==IDLE place: %d fop=%d t: %d", + __LINE__, + apiConnectptr.i, + transP->apiConnectstate, + c_apiConTimer_line[apiConnectptr.i], + transP->firstTcConnect, + c_apiConTimer[apiConnectptr.i] + ); + setApiConTimer(apiConnectptr.i, 0, __LINE__); + return; + } + + OperationState tmp[16]; + + Uint32 TloopCount = 0; + do { + jam(); + if (tcConnectptr.i == RNIL) { + jam(); + if (Tcheck == 0) { + jam(); + /*------------------------------------------------------------------ + * All nodes had already reported ABORTED for all tcConnect records. + * Crash since it is an error situation that we then received a + * time-out. + *------------------------------------------------------------------*/ + char buf[96]; buf[0] = 0; + char buf2[96]; + snprintf(buf, sizeof(buf), "TC %d: %d ops:", + __LINE__, apiConnectptr.i); + for(Uint32 i = 0; i= 1024) { + jam(); + /*------------------------------------------------------------------*/ + // Insert a real-time break for large transactions to avoid blowing + // away the job buffer. + /*------------------------------------------------------------------*/ + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + signal->theData[0] = TcContinueB::ZABORT_TIMEOUT_BREAK; + signal->theData[1] = tcConnectptr.i; + signal->theData[2] = apiConnectptr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB); + return; + }//if + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + if(TloopCount < 16){ + jam(); + tmp[TloopCount-1] = tcConnectptr.p->tcConnectstate; + } + + if (tcConnectptr.p->tcConnectstate == OS_ABORT_SENT) { + jam(); + /*------------------------------------------------------------------*/ + // We have sent an ABORT signal to this node but not yet received any + // reply. We have to send an ABORTED signal on our own in some cases. + // If the node is declared as up and running and still do not respond + // in time to the ABORT signal we will declare it as dead. + /*------------------------------------------------------------------*/ + UintR Ti = 0; + arrGuard(tcConnectptr.p->noOfNodes, 4); + for (Ti = 0; Ti < tcConnectptr.p->noOfNodes; Ti++) { + jam(); + if (tcConnectptr.p->tcNodedata[Ti] != 0) { + TloopCount += 31; + Tcheck = 1; + hostptr.i = tcConnectptr.p->tcNodedata[Ti]; + ptrCheckGuard(hostptr, chostFilesize, hostRecord); + if (hostptr.p->hostStatus == HS_ALIVE) { + jam(); + /*--------------------------------------------------------------- + * A backup replica has not sent ABORTED. + * Could be that a node before him has crashed. + * Send an ABORT signal specifically to this node. + * We will not send to any more nodes after this + * to avoid race problems. + * To also ensure that we use this message also as a heartbeat + * we will move this node to the primary replica seat. + * The primary replica and any failed node after it will + * be removed from the node list. Update also number of nodes. + * Finally break the loop to ensure we don't mess + * things up by executing another loop. + * We also update the timer to ensure we don't get time-out + * too early. + *--------------------------------------------------------------*/ + BlockReference TBRef = calcLqhBlockRef(hostptr.i); + signal->theData[0] = tcConnectptr.i; + signal->theData[1] = cownref; + signal->theData[2] = apiConnectptr.p->transid[0]; + signal->theData[3] = apiConnectptr.p->transid[1]; + sendSignal(TBRef, GSN_ABORT, signal, 4, JBB); + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + break; + } else { + jam(); + /*-------------------------------------------------------------- + * The node we are waiting for is dead. We will send ABORTED to + * ourselves vicarious for the failed node. + *--------------------------------------------------------------*/ + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + signal->theData[0] = tcConnectptr.i; + signal->theData[1] = apiConnectptr.p->transid[0]; + signal->theData[2] = apiConnectptr.p->transid[1]; + signal->theData[3] = hostptr.i; + signal->theData[4] = ZFALSE; + sendSignal(cownref, GSN_ABORTED, signal, 5, JBB); + }//if + }//if + }//for + }//if + tcConnectptr.i = tcConnectptr.p->nextTcConnect; + } while (1); +}//Dbtc::sendAbortedAfterTimeout() + +void Dbtc::reportNodeFailed(Signal* signal, Uint32 nodeId) +{ + DisconnectRep * const rep = (DisconnectRep *)&signal->theData[0]; + rep->nodeId = nodeId; + rep->err = DisconnectRep::TcReportNodeFailed; + sendSignal(QMGR_REF, GSN_DISCONNECT_REP, signal, + DisconnectRep::SignalLength, JBB); +}//Dbtc::reportNodeFailed() + +/*-------------------------------------------------*/ +/* Timeout-loop for scanned fragments. */ +/*-------------------------------------------------*/ +void Dbtc::timeOutLoopStartFragLab(Signal* signal, Uint32 TscanConPtr) +{ + ScanFragRecPtr timeOutPtr[8]; + UintR tfragTimer[8]; + UintR texpiredTime[8]; + UintR TloopCount = 0; + Uint32 TtcTimer = ctcTimer; + + while ((TscanConPtr + 8) < cscanFragrecFileSize) { + jam(); + timeOutPtr[0].i = TscanConPtr + 0; + timeOutPtr[1].i = TscanConPtr + 1; + timeOutPtr[2].i = TscanConPtr + 2; + timeOutPtr[3].i = TscanConPtr + 3; + timeOutPtr[4].i = TscanConPtr + 4; + timeOutPtr[5].i = TscanConPtr + 5; + timeOutPtr[6].i = TscanConPtr + 6; + timeOutPtr[7].i = TscanConPtr + 7; + + ptrAss(timeOutPtr[0], scanFragmentRecord); + ptrAss(timeOutPtr[1], scanFragmentRecord); + ptrAss(timeOutPtr[2], scanFragmentRecord); + ptrAss(timeOutPtr[3], scanFragmentRecord); + ptrAss(timeOutPtr[4], scanFragmentRecord); + ptrAss(timeOutPtr[5], scanFragmentRecord); + ptrAss(timeOutPtr[6], scanFragmentRecord); + ptrAss(timeOutPtr[7], scanFragmentRecord); + + tfragTimer[0] = timeOutPtr[0].p->scanFragTimer; + tfragTimer[1] = timeOutPtr[1].p->scanFragTimer; + tfragTimer[2] = timeOutPtr[2].p->scanFragTimer; + tfragTimer[3] = timeOutPtr[3].p->scanFragTimer; + tfragTimer[4] = timeOutPtr[4].p->scanFragTimer; + tfragTimer[5] = timeOutPtr[5].p->scanFragTimer; + tfragTimer[6] = timeOutPtr[6].p->scanFragTimer; + tfragTimer[7] = timeOutPtr[7].p->scanFragTimer; + + texpiredTime[0] = TtcTimer - tfragTimer[0]; + texpiredTime[1] = TtcTimer - tfragTimer[1]; + texpiredTime[2] = TtcTimer - tfragTimer[2]; + texpiredTime[3] = TtcTimer - tfragTimer[3]; + texpiredTime[4] = TtcTimer - tfragTimer[4]; + texpiredTime[5] = TtcTimer - tfragTimer[5]; + texpiredTime[6] = TtcTimer - tfragTimer[6]; + texpiredTime[7] = TtcTimer - tfragTimer[7]; + + for (Uint32 Ti = 0; Ti < 8; Ti++) { + jam(); + if (tfragTimer[Ti] != 0) { + + if (texpiredTime[Ti] > ctimeOutValue) { + jam(); + DEBUG("Fragment timeout found:"<< + " ctimeOutValue=" <theData[3]<<", "<theData[4]<<")"); + return; + }//if + + // Update timer on ScanFragRec + if (scanFragptr.p->scanFragTimer != 0){ + updateBuddyTimer(apiConnectptr); + scanFragptr.p->startFragTimer(ctcTimer); + } else { + DEBUG("SCAN_HBREP when scanFragTimer was turned off"); + } +}//execSCAN_HBREP() + +/*--------------------------------------------------------------------------*/ +/* Timeout has occured on a fragment which means a scan has timed out. */ +/* If this is true we have an error in LQH/ACC. */ +/*--------------------------------------------------------------------------*/ +void Dbtc::timeOutFoundFragLab(Signal* signal, UintR TscanConPtr) +{ + scanFragptr.i = TscanConPtr; + ptrAss(scanFragptr, scanFragmentRecord); + DEBUG("timeOutFoundFragLab: scanFragState = "<scanFragState); + + /*-------------------------------------------------------------------------*/ + // The scan fragment has expired its timeout. Check its state to decide + // what to do. + /*-------------------------------------------------------------------------*/ + switch (scanFragptr.p->scanFragState) { + + case ScanFragRec::WAIT_GET_PRIMCONF: + jam(); + // Crash the system if we do not return from DIGETPRIMREQ in time. + systemErrorLab(signal); + break; + + case ScanFragRec::LQH_ACTIVE: + jam(); + /** + * The LQH expired it's timeout, try to close it + */ + scanFragError(signal, ZSCAN_FRAG_LQH_ERROR); + DEBUG(" LQH_ACTIVE - closing the fragment scan in node " + <scanFragNodeId); + break; + + case ScanFragRec::LQH_ACTIVE_CLOSE:{ + jam(); + /** + * The close of LQH expired its time-out. This is not + * acceptable behaviour from LQH and thus we will shoot + * it down. + */ + Uint32 nodeId = scanFragptr.p->scanFragNodeId; + Uint32 cc = scanFragptr.p->m_connectCount; + if(getNodeInfo(nodeId).m_connectCount == cc){ + const BlockReference errRef = calcNdbCntrBlockRef(nodeId); + SystemError * const sysErr = (SystemError*)&signal->theData[0]; + sysErr->errorCode = SystemError::ScanfragTimeout; + sysErr->errorRef = reference(); + sysErr->data1 = scanFragptr.i; + sysErr->data2 = scanFragptr.p->scanRec; + sendSignal(errRef, GSN_SYSTEM_ERROR, signal, + SystemError::SignalLength, JBA); + DEBUG(" node " << nodeId << " killed"); + } else { + DEBUG(" node " << nodeId << " not killed as it has restarted"); + } + scanFragptr.p->stopFragTimer(); + break; + } + + case ScanFragRec::DELIVERED: + jam(); + case ScanFragRec::RETURNING_FROM_DELIVERY: + jam(); + case ScanFragRec::IDLE: + jam(); + case ScanFragRec::QUEUED_FOR_DELIVERY: + jam(); + /*----------------------------------------------------------------------- + * Should never occur. We will simply report set the timer to zero and + * continue. In a debug version we should crash here but not in a release + * version. In a release version we will simply set the time-out to zero. + *-----------------------------------------------------------------------*/ +#ifdef VM_TRACE + systemErrorLab(signal); +#endif + scanFragptr.p->stopFragTimer(); + break; + default: + jam(); + /*----------------------------------------------------------------------- + * Non-existent state. Crash. + *-----------------------------------------------------------------------*/ + systemErrorLab(signal); + break; + }//switch + + signal->theData[0] = TcContinueB::ZCONTINUE_TIME_OUT_FRAG_CONTROL; + signal->theData[1] = TscanConPtr + 1; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + return; +}//timeOutFoundFragLab() + + +/* + 4.3.16 GCP_NOMORETRANS + ---------------------- +*/ +/***************************************************************************** + * G C P _ N O M O R E T R A N S + * + * WHEN DBTC RECEIVES SIGNAL GCP_NOMORETRANS A CHECK IS DONE TO FIND OUT IF + * THERE ARE ANY GLOBAL CHECKPOINTS GOING ON - CFIRSTGCP /= RNIL. DBTC THEN + * SEARCHES THE GCP_RECORD FILE TO FIND OUT IF THERE ARE ANY TRANSACTIONS NOT + * CONCLUDED WITH THIS SPECIFIC CHECKPOINT - GCP_PTR:GCP_ID = TCHECK_GCP_ID. + * FOR EACH TRANSACTION WHERE API_CONNECTSTATE EQUALS PREPARED, COMMITTING, + * COMMITTED OR COMPLETING SIGNAL CONTINUEB IS SENT WITH A DELAY OF 100 MS, + * THE COUNTER GCP_PTR:OUTSTANDINGAPI IS INCREASED. WHEN CONTINUEB IS RECEIVED + * THE COUNTER IS DECREASED AND A CHECK IS DONE TO FIND OUT IF ALL + * TRANSACTIONS ARE CONCLUDED. IF SO, SIGNAL GCP_TCFINISHED IS SENT. + *****************************************************************************/ +void Dbtc::execGCP_NOMORETRANS(Signal* signal) +{ + jamEntry(); + tcheckGcpId = signal->theData[1]; + if (cfirstgcp != RNIL) { + jam(); + /* A GLOBAL CHECKPOINT IS GOING ON */ + gcpPtr.i = cfirstgcp; /* SET POINTER TO FIRST GCP IN QUEUE*/ + ptrCheckGuard(gcpPtr, cgcpFilesize, gcpRecord); + if (gcpPtr.p->gcpId == tcheckGcpId) { + jam(); + if (gcpPtr.p->firstApiConnect != RNIL) { + jam(); + gcpPtr.p->gcpNomoretransRec = ZTRUE; + } else { + jam(); + gcpTcfinished(signal); + unlinkGcp(signal); + }//if + } else { + jam(); + /*------------------------------------------------------------*/ + /* IF IT IS NOT THE FIRST THEN THERE SHOULD BE NO */ + /* RECORD FOR THIS GLOBAL CHECKPOINT. WE ALWAYS REMOVE */ + /* THE GLOBAL CHECKPOINTS IN ORDER. */ + /*------------------------------------------------------------*/ + gcpTcfinished(signal); + }//if + } else { + jam(); + gcpTcfinished(signal); + }//if + return; +}//Dbtc::execGCP_NOMORETRANS() + +/*****************************************************************************/ +/* */ +/* TAKE OVER MODULE */ +/* */ +/*****************************************************************************/ +/* */ +/* THIS PART OF TC TAKES OVER THE COMMIT/ABORT OF TRANSACTIONS WHERE THE */ +/* NODE ACTING AS TC HAVE FAILED. IT STARTS BY QUERYING ALL NODES ABOUT */ +/* ANY OPERATIONS PARTICIPATING IN A TRANSACTION WHERE THE TC NODE HAVE */ +/* FAILED. */ +/* */ +/* AFTER RECEIVING INFORMATION FROM ALL NODES ABOUT OPERATION STATUS THIS */ +/* CODE WILL ENSURE THAT ALL AFFECTED TRANSACTIONS ARE PROPERLY ABORTED OR*/ +/* COMMITTED. THE ORIGINATING APPLICATION NODE WILL ALSO BE CONTACTED. */ +/* IF THE ORIGINATING APPLICATION ALSO FAILED THEN THERE IS CURRENTLY NO */ +/* WAY TO FIND OUT WHETHER A TRANSACTION WAS PERFORMED OR NOT. */ +/*****************************************************************************/ +void Dbtc::execNODE_FAILREP(Signal* signal) +{ + HostRecordPtr tmpHostptr; + jamEntry(); + + NodeFailRep * const nodeFail = (NodeFailRep *)&signal->theData[0]; + + cfailure_nr = nodeFail->failNo; + const Uint32 tnoOfNodes = nodeFail->noOfNodes; + const Uint32 tnewMasterId = nodeFail->masterNodeId; + + arrGuard(tnoOfNodes, MAX_NDB_NODES); + int index = 0; + for (unsigned i = 1; i< MAX_NDB_NODES; i++) { + if(NodeBitmask::get(nodeFail->theNodes, i)){ + cdata[index] = i; + index++; + }//if + }//for + + tcNodeFailptr.i = 0; + ptrAss(tcNodeFailptr, tcFailRecord); + for (Uint32 tindex = 0; tindex < tnoOfNodes; tindex++) { + jam(); + hostptr.i = cdata[tindex]; + ptrCheckGuard(hostptr, chostFilesize, hostRecord); + /*------------------------------------------------------------*/ + /* SET STATUS OF THE FAILED NODE TO DEAD SINCE IT HAS */ + /* FAILED. */ + /*------------------------------------------------------------*/ + hostptr.p->hostStatus = HS_DEAD; + + if (hostptr.p->takeOverStatus == TOS_COMPLETED) { + jam(); + /*------------------------------------------------------------*/ + /* A VERY UNUSUAL SITUATION. THE TAKE OVER WAS COMPLETED*/ + /* EVEN BEFORE WE HEARD ABOUT THE NODE FAILURE REPORT. */ + /* HOWEVER UNUSUAL THIS SITUATION IS POSSIBLE. */ + /*------------------------------------------------------------*/ + /* RELEASE THE CURRENTLY UNUSED LQH CONNECTIONS. THE */ + /* REMAINING WILL BE RELEASED WHEN THE TRANSACTION THAT */ + /* USED THEM IS COMPLETED. */ + /*------------------------------------------------------------*/ + { + NFCompleteRep * const nfRep = (NFCompleteRep *)&signal->theData[0]; + nfRep->blockNo = DBTC; + nfRep->nodeId = cownNodeid; + nfRep->failedNodeId = hostptr.i; + } + sendSignal(cdihblockref, GSN_NF_COMPLETEREP, signal, + NFCompleteRep::SignalLength, JBB); + } else { + ndbrequire(hostptr.p->takeOverStatus == TOS_IDLE); + hostptr.p->takeOverStatus = TOS_NODE_FAILED; + }//if + + if (tcNodeFailptr.p->failStatus == FS_LISTENING) { + jam(); + /*------------------------------------------------------------*/ + /* THE CURRENT TAKE OVER CAN BE AFFECTED BY THIS NODE */ + /* FAILURE. */ + /*------------------------------------------------------------*/ + if (hostptr.p->lqhTransStatus == LTS_ACTIVE) { + jam(); + /*------------------------------------------------------------*/ + /* WE WERE WAITING FOR THE FAILED NODE IN THE TAKE OVER */ + /* PROTOCOL FOR TC. */ + /*------------------------------------------------------------*/ + signal->theData[0] = TcContinueB::ZNODE_TAKE_OVER_COMPLETED; + signal->theData[1] = hostptr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + }//if + }//if + + }//for + + const bool masterFailed = (cmasterNodeId != tnewMasterId); + cmasterNodeId = tnewMasterId; + + if(getOwnNodeId() == cmasterNodeId && masterFailed){ + /** + * Master has failed and I'm the new master + */ + jam(); + + for (hostptr.i = 1; hostptr.i < MAX_NDB_NODES; hostptr.i++) { + jam(); + ptrAss(hostptr, hostRecord); + if (hostptr.p->hostStatus != HS_ALIVE) { + jam(); + if (hostptr.p->takeOverStatus == TOS_COMPLETED) { + jam(); + /*------------------------------------------------------------*/ + /* SEND TAKE OVER CONFIRMATION TO ALL ALIVE NODES IF */ + /* TAKE OVER IS COMPLETED. THIS IS PERFORMED TO ENSURE */ + /* THAT ALL NODES AGREE ON THE IDLE STATE OF THE TAKE */ + /* OVER. THIS MIGHT BE MISSED IN AN ERROR SITUATION IF */ + /* MASTER FAILS AFTER SENDING CONFIRMATION TO NEW */ + /* MASTER BUT FAILING BEFORE SENDING TO ANOTHER NODE */ + /* WHICH WAS NOT MASTER. IF THIS NODE LATER BECOMES */ + /* MASTER IT MIGHT START A NEW TAKE OVER EVEN AFTER THE */ + /* CRASHED NODE HAVE ALREADY RECOVERED. */ + /*------------------------------------------------------------*/ + for(tmpHostptr.i = 1; tmpHostptr.i < MAX_NDB_NODES;tmpHostptr.i++) { + jam(); + ptrAss(tmpHostptr, hostRecord); + if (tmpHostptr.p->hostStatus == HS_ALIVE) { + jam(); + tblockref = calcTcBlockRef(tmpHostptr.i); + signal->theData[0] = hostptr.i; + sendSignal(tblockref, GSN_TAKE_OVERTCCONF, signal, 1, JBB); + }//if + }//for + }//if + }//if + }//for + } + + if(getOwnNodeId() == cmasterNodeId){ + jam(); + for (hostptr.i = 1; hostptr.i < MAX_NDB_NODES; hostptr.i++) { + jam(); + ptrAss(hostptr, hostRecord); + if (hostptr.p->hostStatus != HS_ALIVE) { + jam(); + if (hostptr.p->takeOverStatus == TOS_NODE_FAILED) { + jam(); + /*------------------------------------------------------------*/ + /* CONCLUDE ALL ACTIVITIES THE FAILED TC DID CONTROL */ + /* SINCE WE ARE THE MASTER. THIS COULD HAVE BEEN STARTED*/ + /* BY A PREVIOUS MASTER BUT HAVE NOT BEEN CONCLUDED YET.*/ + /*------------------------------------------------------------*/ + hostptr.p->takeOverStatus = TOS_ACTIVE; + signal->theData[0] = hostptr.i; + sendSignal(cownref, GSN_TAKE_OVERTCREQ, signal, 1, JBB); + }//if + }//if + }//for + }//if + + for (Uint32 tindex = 0; tindex < tnoOfNodes; tindex++) { + jam(); + hostptr.i = cdata[tindex]; + ptrCheckGuard(hostptr, chostFilesize, hostRecord); + /*------------------------------------------------------------*/ + /* LOOP THROUGH AND ABORT ALL SCANS THAT WHERE */ + /* CONTROLLED BY THIS TC AND ACTIVE IN THE FAILED */ + /* NODE'S LQH */ + /*------------------------------------------------------------*/ + checkScanActiveInFailedLqh(signal, 0, hostptr.i); + checkWaitDropTabFailedLqh(signal, hostptr.i, 0); // nodeid, tableid + }//for + +}//Dbtc::execNODE_FAILREP() + +void Dbtc::checkScanActiveInFailedLqh(Signal* signal, + Uint32 scanPtrI, + Uint32 failedNodeId){ + + for (scanptr.i = scanPtrI; scanptr.i < cscanrecFileSize; scanptr.i++) { + jam(); + ptrAss(scanptr, scanRecord); + if (scanptr.p->scanState != ScanRecord::IDLE){ + for (Uint32 i=0; i<16; i++) { + jam(); + scanFragptr.i = scanptr.p->scanFragrec[i]; + if (scanFragptr.i != RNIL) { + jam(); + ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord); + if (scanFragptr.p->scanFragNodeId == failedNodeId){ + switch (scanFragptr.p->scanFragState){ + case ScanFragRec::LQH_ACTIVE: + case ScanFragRec::LQH_ACTIVE_CLOSE: + jam(); + apiConnectptr.i = scanptr.p->scanApiRec; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, + apiConnectRecord); + + // The connection to this LQH is closed + scanFragptr.p->lqhBlockref = RNIL; + + DEBUG("checkScanActiveInFailedLqh: scanFragError"); + scanFragError(signal, ZSCAN_LQH_ERROR); + + break; + + default: + /* empty */ + jam(); + break; + }// switch + + } //if + } //if + } //for + } //if + + // Send CONTINUEB to continue later + signal->theData[0] = TcContinueB::ZCHECK_SCAN_ACTIVE_FAILED_LQH; + signal->theData[1] = scanptr.i + 1; // Check next scanptr + signal->theData[2] = failedNodeId; + sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB); + return; + }//for +} + +void Dbtc::execTAKE_OVERTCCONF(Signal* signal) +{ + jamEntry(); + tfailedNodeId = signal->theData[0]; + hostptr.i = tfailedNodeId; + ptrCheckGuard(hostptr, chostFilesize, hostRecord); + switch (hostptr.p->takeOverStatus) { + case TOS_IDLE: + jam(); + /*------------------------------------------------------------*/ + /* THIS MESSAGE ARRIVED EVEN BEFORE THE NODE_FAILREP */ + /* MESSAGE. THIS IS POSSIBLE IN EXTREME SITUATIONS. */ + /* WE SET THE STATE TO TAKE_OVER_COMPLETED AND WAIT */ + /* FOR THE NODE_FAILREP MESSAGE. */ + /*------------------------------------------------------------*/ + hostptr.p->takeOverStatus = TOS_COMPLETED; + break; + case TOS_NODE_FAILED: + case TOS_ACTIVE: + jam(); + /*------------------------------------------------------------*/ + /* WE ARE NOT MASTER AND THE TAKE OVER IS ACTIVE OR WE */ + /* ARE MASTER AND THE TAKE OVER IS ACTIVE. IN BOTH */ + /* WE SET THE STATE TO TAKE_OVER_COMPLETED. */ + /*------------------------------------------------------------*/ + /* RELEASE THE CURRENTLY UNUSED LQH CONNECTIONS. THE */ + /* REMAINING WILL BE RELEASED WHEN THE TRANSACTION THAT */ + /* USED THEM IS COMPLETED. */ + /*------------------------------------------------------------*/ + hostptr.p->takeOverStatus = TOS_COMPLETED; + { + NFCompleteRep * const nfRep = (NFCompleteRep *)&signal->theData[0]; + nfRep->blockNo = DBTC; + nfRep->nodeId = cownNodeid; + nfRep->failedNodeId = hostptr.i; + } + sendSignal(cdihblockref, GSN_NF_COMPLETEREP, signal, + NFCompleteRep::SignalLength, JBB); + break; + case TOS_COMPLETED: + jam(); + /*------------------------------------------------------------*/ + /* WE HAVE ALREADY RECEIVED THE CONF SIGNAL. IT IS MOST */ + /* LIKELY SENT FROM A NEW MASTER WHICH WASN'T SURE IF */ + /* THIS NODE HEARD THE CONF SIGNAL FROM THE OLD MASTER. */ + /* WE SIMPLY IGNORE THE MESSAGE. */ + /*------------------------------------------------------------*/ + /*empty*/; + break; + default: + jam(); + systemErrorLab(signal); + return; + }//switch +}//Dbtc::execTAKE_OVERTCCONF() + +void Dbtc::execTAKE_OVERTCREQ(Signal* signal) +{ + jamEntry(); + tfailedNodeId = signal->theData[0]; + tcNodeFailptr.i = 0; + ptrAss(tcNodeFailptr, tcFailRecord); + if (tcNodeFailptr.p->failStatus != FS_IDLE) { + jam(); + /*------------------------------------------------------------*/ + /* WE CAN CURRENTLY ONLY HANDLE ONE TAKE OVER AT A TIME */ + /*------------------------------------------------------------*/ + /* IF MORE THAN ONE TAKE OVER IS REQUESTED WE WILL */ + /* QUEUE THE TAKE OVER AND START IT AS SOON AS THE */ + /* PREVIOUS ARE COMPLETED. */ + /*------------------------------------------------------------*/ + arrGuard(tcNodeFailptr.p->queueIndex, MAX_NDB_NODES); + tcNodeFailptr.p->queueList[tcNodeFailptr.p->queueIndex] = tfailedNodeId; + tcNodeFailptr.p->queueIndex = tcNodeFailptr.p->queueIndex + 1; + return; + }//if + startTakeOverLab(signal); +}//Dbtc::execTAKE_OVERTCREQ() + +/*------------------------------------------------------------*/ +/* INITIALISE THE HASH TABLES FOR STORING TRANSACTIONS */ +/* AND OPERATIONS DURING TC TAKE OVER. */ +/*------------------------------------------------------------*/ +void Dbtc::startTakeOverLab(Signal* signal) +{ + for (tindex = 0; tindex <= 511; tindex++) { + ctransidFailHash[tindex] = RNIL; + }//for + for (tindex = 0; tindex <= 1023; tindex++) { + ctcConnectFailHash[tindex] = RNIL; + }//for + tcNodeFailptr.p->failStatus = FS_LISTENING; + tcNodeFailptr.p->takeOverNode = tfailedNodeId; + for (hostptr.i = 1; hostptr.i < MAX_NDB_NODES; hostptr.i++) { + jam(); + ptrAss(hostptr, hostRecord); + if (hostptr.p->hostStatus == HS_ALIVE) { + jam(); + tblockref = calcLqhBlockRef(hostptr.i); + hostptr.p->lqhTransStatus = LTS_ACTIVE; + signal->theData[0] = tcNodeFailptr.i; + signal->theData[1] = cownref; + signal->theData[2] = tfailedNodeId; + sendSignal(tblockref, GSN_LQH_TRANSREQ, signal, 3, JBB); + }//if + }//for +}//Dbtc::startTakeOverLab() + +/*------------------------------------------------------------*/ +/* A REPORT OF AN OPERATION WHERE TC FAILED HAS ARRIVED.*/ +/*------------------------------------------------------------*/ +void Dbtc::execLQH_TRANSCONF(Signal* signal) +{ + jamEntry(); + LqhTransConf * const lqhTransConf = (LqhTransConf *)&signal->theData[0]; + + tcNodeFailptr.i = lqhTransConf->tcRef; + ptrCheckGuard(tcNodeFailptr, 1, tcFailRecord); + tnodeid = lqhTransConf->lqhNodeId; + ttransStatus = (LqhTransConf::OperationStatus)lqhTransConf->operationStatus; + ttransid1 = lqhTransConf->transId1; + ttransid2 = lqhTransConf->transId2; + ttcOprec = lqhTransConf->oldTcOpRec; + treqinfo = lqhTransConf->requestInfo; + tgci = lqhTransConf->gci; + cnodes[0] = lqhTransConf->nextNodeId1; + cnodes[1] = lqhTransConf->nextNodeId2; + cnodes[2] = lqhTransConf->nextNodeId3; + const Uint32 ref = tapplRef = lqhTransConf->apiRef; + tapplOprec = lqhTransConf->apiOpRec; + const Uint32 tableId = lqhTransConf->tableId; + + if (ttransStatus == LqhTransConf::LastTransConf){ + jam(); + /*------------------------------------------------------------*/ + /* A NODE HAS REPORTED COMPLETION OF TAKE OVER REPORTING*/ + /*------------------------------------------------------------*/ + nodeTakeOverCompletedLab(signal); + return; + }//if + if (ttransStatus == LqhTransConf::Marker){ + jam(); + treqinfo = 0; + LqhTransConf::setMarkerFlag(treqinfo, 1); + } else { + TableRecordPtr tabPtr; + tabPtr.i = tableId; + ptrCheckGuard(tabPtr, ctabrecFilesize, tableRecord); + switch((DictTabInfo::TableType)tabPtr.p->tableType){ + case DictTabInfo::SystemTable: + case DictTabInfo::UserTable: + break; + default: + tapplRef = 0; + tapplOprec = 0; + } + } + + findApiConnectFail(signal); + + if(apiConnectptr.p->ndbapiBlockref == 0 && tapplRef != 0){ + apiConnectptr.p->ndbapiBlockref = ref; + apiConnectptr.p->ndbapiConnect = tapplOprec; + } + + if (ttransStatus != LqhTransConf::Marker){ + jam(); + findTcConnectFail(signal); + } +}//Dbtc::execLQH_TRANSCONF() + +/*------------------------------------------------------------*/ +/* A NODE HAS REPORTED COMPLETION OF TAKE OVER REPORTING*/ +/*------------------------------------------------------------*/ +void Dbtc::nodeTakeOverCompletedLab(Signal* signal) +{ + Uint32 guard0; + + hostptr.i = tnodeid; + ptrCheckGuard(hostptr, chostFilesize, hostRecord); + hostptr.p->lqhTransStatus = LTS_IDLE; + for (hostptr.i = 1; hostptr.i < MAX_NDB_NODES; hostptr.i++) { + jam(); + ptrAss(hostptr, hostRecord); + if (hostptr.p->hostStatus == HS_ALIVE) { + if (hostptr.p->lqhTransStatus == LTS_ACTIVE) { + jam(); + /*------------------------------------------------------------*/ + /* NOT ALL NODES ARE COMPLETED WITH REPORTING IN THE */ + /* TAKE OVER. */ + /*------------------------------------------------------------*/ + return; + }//if + }//if + }//for + /*------------------------------------------------------------*/ + /* ALL NODES HAVE REPORTED ON THE STATUS OF THE VARIOUS */ + /* OPERATIONS THAT WAS CONTROLLED BY THE FAILED TC. WE */ + /* ARE NOW IN A POSITION TO COMPLETE ALL OF THOSE */ + /* TRANSACTIONS EITHER IN A SUCCESSFUL WAY OR IN AN */ + /* UNSUCCESSFUL WAY. WE WILL ALSO REPORT THIS CONCLUSION*/ + /* TO THE APPLICATION IF THAT IS STILL ALIVE. */ + /*------------------------------------------------------------*/ + tcNodeFailptr.p->currentHashIndexTakeOver = 0; + tcNodeFailptr.p->completedTakeOver = 0; + tcNodeFailptr.p->failStatus = FS_COMPLETING; + guard0 = cnoParallelTakeOver - 1; + /*------------------------------------------------------------*/ + /* WE WILL COMPLETE THE TRANSACTIONS BY STARTING A */ + /* NUMBER OF PARALLEL ACTIVITIES. EACH ACTIVITY WILL */ + /* COMPLETE ONE TRANSACTION AT A TIME AND IN THAT */ + /* TRANSACTION IT WILL COMPLETE ONE OPERATION AT A TIME.*/ + /* WHEN ALL ACTIVITIES ARE COMPLETED THEN THE TAKE OVER */ + /* IS COMPLETED. */ + /*------------------------------------------------------------*/ + arrGuard(guard0, MAX_NDB_NODES); + for (tindex = 0; tindex <= guard0; tindex++) { + jam(); + tcNodeFailptr.p->takeOverProcState[tindex] = ZTAKE_OVER_ACTIVE; + signal->theData[0] = TcContinueB::ZCOMPLETE_TRANS_AT_TAKE_OVER; + signal->theData[1] = tcNodeFailptr.i; + signal->theData[2] = tindex; + sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB); + }//for +}//Dbtc::nodeTakeOverCompletedLab() + +/*------------------------------------------------------------*/ +/* COMPLETE A NEW TRANSACTION FROM THE HASH TABLE OF */ +/* TRANSACTIONS TO COMPLETE. */ +/*------------------------------------------------------------*/ +void Dbtc::completeTransAtTakeOverLab(Signal* signal, UintR TtakeOverInd) +{ + jam(); + while (tcNodeFailptr.p->currentHashIndexTakeOver < 512){ + jam(); + apiConnectptr.i = + ctransidFailHash[tcNodeFailptr.p->currentHashIndexTakeOver]; + if (apiConnectptr.i != RNIL) { + jam(); + /*------------------------------------------------------------*/ + /* WE HAVE FOUND A TRANSACTION THAT NEEDS TO BE */ + /* COMPLETED. REMOVE IT FROM THE HASH TABLE SUCH THAT */ + /* NOT ANOTHER ACTIVITY ALSO TRIES TO COMPLETE THIS */ + /* TRANSACTION. */ + /*------------------------------------------------------------*/ + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + ctransidFailHash[tcNodeFailptr.p->currentHashIndexTakeOver] = + apiConnectptr.p->nextApiConnect; + + completeTransAtTakeOverDoOne(signal, TtakeOverInd); + // One transaction taken care of, return from this function + // and wait for the next CONTINUEB to continue processing + break; + + } else { + if (tcNodeFailptr.p->currentHashIndexTakeOver < 511){ + jam(); + tcNodeFailptr.p->currentHashIndexTakeOver++; + } else { + jam(); + completeTransAtTakeOverDoLast(signal, TtakeOverInd); + tcNodeFailptr.p->currentHashIndexTakeOver++; + }//if + }//if + }//while +}//Dbtc::completeTransAtTakeOverLab() + + + + +void Dbtc::completeTransAtTakeOverDoLast(Signal* signal, UintR TtakeOverInd) +{ + Uint32 guard0; + /*------------------------------------------------------------*/ + /* THERE ARE NO MORE TRANSACTIONS TO COMPLETE. THIS */ + /* ACTIVITY IS COMPLETED. */ + /*------------------------------------------------------------*/ + arrGuard(TtakeOverInd, MAX_NDB_NODES); + if (tcNodeFailptr.p->takeOverProcState[TtakeOverInd] != ZTAKE_OVER_ACTIVE) { + jam(); + systemErrorLab(signal); + return; + }//if + tcNodeFailptr.p->takeOverProcState[TtakeOverInd] = ZTAKE_OVER_IDLE; + tcNodeFailptr.p->completedTakeOver++; + + if (tcNodeFailptr.p->completedTakeOver == cnoParallelTakeOver) { + jam(); + /*------------------------------------------------------------*/ + /* WE WERE THE LAST ACTIVITY THAT WAS COMPLETED. WE NEED*/ + /* TO REPORT THE COMPLETION OF THE TAKE OVER TO ALL */ + /* NODES THAT ARE ALIVE. */ + /*------------------------------------------------------------*/ + for (hostptr.i = 1; hostptr.i < MAX_NDB_NODES; hostptr.i++) { + jam(); + ptrAss(hostptr, hostRecord); + if (hostptr.p->hostStatus == HS_ALIVE) { + jam(); + tblockref = calcTcBlockRef(hostptr.i); + signal->theData[0] = tcNodeFailptr.p->takeOverNode; + sendSignal(tblockref, GSN_TAKE_OVERTCCONF, signal, 1, JBB); + }//if + }//for + if (tcNodeFailptr.p->queueIndex > 0) { + jam(); + /*------------------------------------------------------------*/ + /* THERE ARE MORE NODES TO TAKE OVER. WE NEED TO START */ + /* THE TAKE OVER. */ + /*------------------------------------------------------------*/ + tfailedNodeId = tcNodeFailptr.p->queueList[0]; + guard0 = tcNodeFailptr.p->queueIndex - 1; + arrGuard(guard0 + 1, MAX_NDB_NODES); + for (tindex = 0; tindex <= guard0; tindex++) { + jam(); + tcNodeFailptr.p->queueList[tindex] = + tcNodeFailptr.p->queueList[tindex + 1]; + }//for + tcNodeFailptr.p->queueIndex--; + startTakeOverLab(signal); + return; + } else { + jam(); + tcNodeFailptr.p->failStatus = FS_IDLE; + }//if + }//if + return; +}//Dbtc::completeTransAtTakeOverDoLast() + +void Dbtc::completeTransAtTakeOverDoOne(Signal* signal, UintR TtakeOverInd) +{ + apiConnectptr.p->takeOverRec = (Uint8)tcNodeFailptr.i; + apiConnectptr.p->takeOverInd = TtakeOverInd; + + switch (apiConnectptr.p->apiConnectstate) { + case CS_FAIL_COMMITTED: + jam(); + /*------------------------------------------------------------*/ + /* ALL PARTS OF THE TRANSACTIONS REPORTED COMMITTED. WE */ + /* HAVE THUS COMPLETED THE COMMIT PHASE. WE CAN REPORT */ + /* COMMITTED TO THE APPLICATION AND CONTINUE WITH THE */ + /* COMPLETE PHASE. */ + /*------------------------------------------------------------*/ + sendTCKEY_FAILCONF(signal, apiConnectptr.p); + tcConnectptr.i = apiConnectptr.p->firstTcConnect; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + apiConnectptr.p->currentTcConnect = tcConnectptr.i; + apiConnectptr.p->currentReplicaNo = tcConnectptr.p->lastReplicaNo; + tcurrentReplicaNo = tcConnectptr.p->lastReplicaNo; + toCompleteHandlingLab(signal); + return; + case CS_FAIL_COMMITTING: + jam(); + /*------------------------------------------------------------*/ + /* AT LEAST ONE PART WAS ONLY PREPARED AND AT LEAST ONE */ + /* PART WAS COMMITTED. COMPLETE THE COMMIT PHASE FIRST. */ + /* THEN CONTINUE AS AFTER COMMITTED. */ + /*------------------------------------------------------------*/ + tcConnectptr.i = apiConnectptr.p->firstTcConnect; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + apiConnectptr.p->currentTcConnect = tcConnectptr.i; + apiConnectptr.p->currentReplicaNo = tcConnectptr.p->lastReplicaNo; + tcurrentReplicaNo = tcConnectptr.p->lastReplicaNo; + toCommitHandlingLab(signal); + return; + case CS_FAIL_ABORTING: + case CS_FAIL_PREPARED: + jam(); + /*------------------------------------------------------------*/ + /* WE WILL ABORT THE TRANSACTION IF IT IS IN A PREPARED */ + /* STATE IN THIS VERSION. IN LATER VERSIONS WE WILL */ + /* HAVE TO ADD CODE FOR HANDLING OF PREPARED-TO-COMMIT */ + /* TRANSACTIONS. THESE ARE NOT ALLOWED TO ABORT UNTIL WE*/ + /* HAVE HEARD FROM THE TRANSACTION COORDINATOR. */ + /* */ + /* IT IS POSSIBLE TO COMMIT TRANSACTIONS THAT ARE */ + /* PREPARED ACTUALLY. WE WILL LEAVE THIS PROBLEM UNTIL */ + /* LATER VERSIONS. */ + /*------------------------------------------------------------*/ + tcConnectptr.i = apiConnectptr.p->firstTcConnect; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + apiConnectptr.p->currentTcConnect = tcConnectptr.i; + apiConnectptr.p->currentReplicaNo = tcConnectptr.p->lastReplicaNo; + tcurrentReplicaNo = tcConnectptr.p->lastReplicaNo; + toAbortHandlingLab(signal); + return; + case CS_FAIL_ABORTED: + jam(); + sendTCKEY_FAILREF(signal, apiConnectptr.p); + + signal->theData[0] = TcContinueB::ZCOMPLETE_TRANS_AT_TAKE_OVER; + signal->theData[1] = (UintR)apiConnectptr.p->takeOverRec; + signal->theData[2] = apiConnectptr.p->takeOverInd; + sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB); + releaseTakeOver(signal); + break; + case CS_FAIL_COMPLETED: + jam(); + sendTCKEY_FAILCONF(signal, apiConnectptr.p); + + signal->theData[0] = TcContinueB::ZCOMPLETE_TRANS_AT_TAKE_OVER; + signal->theData[1] = (UintR)apiConnectptr.p->takeOverRec; + signal->theData[2] = apiConnectptr.p->takeOverInd; + sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB); + releaseApiConnectFail(signal); + break; + default: + jam(); + systemErrorLab(signal); + return; + }//switch +}//Dbtc::completeTransAtTakeOverDoOne() + +void +Dbtc::sendTCKEY_FAILREF(Signal* signal, const ApiConnectRecord * regApiPtr){ + jam(); + + const Uint32 ref = regApiPtr->ndbapiBlockref; + if(ref != 0){ + signal->theData[0] = regApiPtr->ndbapiConnect; + signal->theData[1] = regApiPtr->transid[0]; + signal->theData[2] = regApiPtr->transid[1]; + + sendSignal(ref, GSN_TCKEY_FAILREF, signal, 3, JBB); + } +} + +void +Dbtc::sendTCKEY_FAILCONF(Signal* signal, const ApiConnectRecord * regApiPtr){ + jam(); + TcKeyFailConf * const failConf = (TcKeyFailConf *)&signal->theData[0]; + + if(regApiPtr->commitAckMarker == RNIL){ + jam(); + failConf->apiConnectPtr = regApiPtr->ndbapiConnect; + } else { + jam(); + failConf->apiConnectPtr = regApiPtr->ndbapiConnect | 1; + } + failConf->transId1 = regApiPtr->transid[0]; + failConf->transId2 = regApiPtr->transid[1]; + + sendSignal(regApiPtr->ndbapiBlockref, + GSN_TCKEY_FAILCONF, signal, TcKeyFailConf::SignalLength, JBB); +} + + +/*------------------------------------------------------------*/ +/* THIS PART HANDLES THE ABORT PHASE IN THE CASE OF A */ +/* NODE FAILURE BEFORE THE COMMIT DECISION. */ +/*------------------------------------------------------------*/ +/* ABORT REQUEST SUCCESSFULLY COMPLETED ON TNODEID */ +/*------------------------------------------------------------*/ +void Dbtc::execABORTCONF(Signal* signal) +{ + UintR compare_transid1, compare_transid2; + + jamEntry(); + tcConnectptr.i = signal->theData[0]; + tnodeid = signal->theData[2]; + if (ERROR_INSERTED(8045)) { + CLEAR_ERROR_INSERT_VALUE; + sendSignalWithDelay(cownref, GSN_ABORTCONF, signal, 2000, 5); + return; + }//if + if (tcConnectptr.i >= ctcConnectFilesize) { + errorReport(signal, 5); + return; + }//if + ptrAss(tcConnectptr, tcConnectRecord); + if (tcConnectptr.p->tcConnectstate != OS_WAIT_ABORT_CONF) { + warningReport(signal, 16); + return; + }//if + apiConnectptr.i = tcConnectptr.p->apiConnect; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + if (apiConnectptr.p->apiConnectstate != CS_WAIT_ABORT_CONF) { + warningReport(signal, 17); + return; + }//if + compare_transid1 = apiConnectptr.p->transid[0] ^ signal->theData[3]; + compare_transid2 = apiConnectptr.p->transid[1] ^ signal->theData[4]; + compare_transid1 = compare_transid1 | compare_transid2; + if (compare_transid1 != 0) { + warningReport(signal, 18); + return; + }//if + arrGuard(apiConnectptr.p->currentReplicaNo, 4); + if (tcConnectptr.p->tcNodedata[apiConnectptr.p->currentReplicaNo] != + tnodeid) { + warningReport(signal, 19); + return; + }//if + tcurrentReplicaNo = (Uint8)Z8NIL; + tcConnectptr.p->tcConnectstate = OS_ABORTING; + toAbortHandlingLab(signal); +}//Dbtc::execABORTCONF() + +void Dbtc::toAbortHandlingLab(Signal* signal) +{ + do { + if (tcurrentReplicaNo != (Uint8)Z8NIL) { + jam(); + arrGuard(tcurrentReplicaNo, 4); + const LqhTransConf::OperationStatus stat = + (LqhTransConf::OperationStatus) + tcConnectptr.p->failData[tcurrentReplicaNo]; + switch(stat){ + case LqhTransConf::InvalidStatus: + case LqhTransConf::Aborted: + jam(); + /*empty*/; + break; + case LqhTransConf::Prepared: + jam(); + hostptr.i = tcConnectptr.p->tcNodedata[tcurrentReplicaNo]; + ptrCheckGuard(hostptr, chostFilesize, hostRecord); + if (hostptr.p->hostStatus == HS_ALIVE) { + jam(); + tblockref = calcLqhBlockRef(hostptr.i); + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + tcConnectptr.p->tcConnectstate = OS_WAIT_ABORT_CONF; + apiConnectptr.p->apiConnectstate = CS_WAIT_ABORT_CONF; + apiConnectptr.p->timeOutCounter = 0; + signal->theData[0] = tcConnectptr.i; + signal->theData[1] = cownref; + signal->theData[2] = apiConnectptr.p->transid[0]; + signal->theData[3] = apiConnectptr.p->transid[1]; + signal->theData[4] = apiConnectptr.p->tcBlockref; + signal->theData[5] = tcConnectptr.p->tcOprec; + sendSignal(tblockref, GSN_ABORTREQ, signal, 6, JBB); + return; + }//if + break; + default: + jam(); + systemErrorLab(signal); + return; + }//switch + }//if + if (apiConnectptr.p->currentReplicaNo > 0) { + jam(); + /*------------------------------------------------------------*/ + /* THERE IS STILL ANOTHER REPLICA THAT NEEDS TO BE */ + /* ABORTED. */ + /*------------------------------------------------------------*/ + apiConnectptr.p->currentReplicaNo--; + tcurrentReplicaNo = apiConnectptr.p->currentReplicaNo; + } else { + /*------------------------------------------------------------*/ + /* THE LAST REPLICA IN THIS OPERATION HAVE COMMITTED. */ + /*------------------------------------------------------------*/ + tcConnectptr.i = tcConnectptr.p->nextTcConnect; + if (tcConnectptr.i == RNIL) { + /*------------------------------------------------------------*/ + /* WE HAVE COMPLETED THE ABORT PHASE. WE CAN NOW REPORT */ + /* THE ABORT STATUS TO THE APPLICATION AND CONTINUE */ + /* WITH THE NEXT TRANSACTION. */ + /*------------------------------------------------------------*/ + if (apiConnectptr.p->takeOverRec != (Uint8)Z8NIL) { + jam(); + sendTCKEY_FAILREF(signal, apiConnectptr.p); + const Uint32 marker = apiConnectptr.p->commitAckMarker; + if(marker != RNIL){ + jam(); + + CommitAckMarkerPtr tmp; + tmp.i = marker; + tmp.p = m_commitAckMarkerHash.getPtr(tmp.i); + + m_commitAckMarkerHash.release(tmp); + apiConnectptr.p->commitAckMarker = RNIL; + } + + /*------------------------------------------------------------*/ + /* WE HAVE COMPLETED THIS TRANSACTION NOW AND CAN */ + /* CONTINUE THE PROCESS WITH THE NEXT TRANSACTION. */ + /*------------------------------------------------------------*/ + signal->theData[0] = TcContinueB::ZCOMPLETE_TRANS_AT_TAKE_OVER; + signal->theData[1] = (UintR)apiConnectptr.p->takeOverRec; + signal->theData[2] = apiConnectptr.p->takeOverInd; + sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB); + releaseTakeOver(signal); + } else { + jam(); + releaseAbortResources(signal); + }//if + return; + }//if + apiConnectptr.p->currentTcConnect = tcConnectptr.i; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + apiConnectptr.p->currentReplicaNo = tcConnectptr.p->lastReplicaNo; + tcurrentReplicaNo = tcConnectptr.p->lastReplicaNo; + }//if + } while (1); +}//Dbtc::toAbortHandlingLab() + +/*------------------------------------------------------------*/ +/* THIS PART HANDLES THE COMMIT PHASE IN THE CASE OF A */ +/* NODE FAILURE IN THE MIDDLE OF THE COMMIT PHASE. */ +/*------------------------------------------------------------*/ +/* COMMIT REQUEST SUCCESSFULLY COMPLETED ON TNODEID */ +/*------------------------------------------------------------*/ +void Dbtc::execCOMMITCONF(Signal* signal) +{ + UintR compare_transid1, compare_transid2; + + jamEntry(); + tcConnectptr.i = signal->theData[0]; + tnodeid = signal->theData[1]; + if (ERROR_INSERTED(8046)) { + CLEAR_ERROR_INSERT_VALUE; + sendSignalWithDelay(cownref, GSN_COMMITCONF, signal, 2000, 4); + return; + }//if + if (tcConnectptr.i >= ctcConnectFilesize) { + errorReport(signal, 4); + return; + }//if + ptrAss(tcConnectptr, tcConnectRecord); + if (tcConnectptr.p->tcConnectstate != OS_WAIT_COMMIT_CONF) { + warningReport(signal, 8); + return; + }//if + apiConnectptr.i = tcConnectptr.p->apiConnect; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + if (apiConnectptr.p->apiConnectstate != CS_WAIT_COMMIT_CONF) { + warningReport(signal, 9); + return; + }//if + compare_transid1 = apiConnectptr.p->transid[0] ^ signal->theData[2]; + compare_transid2 = apiConnectptr.p->transid[1] ^ signal->theData[3]; + compare_transid1 = compare_transid1 | compare_transid2; + if (compare_transid1 != 0) { + warningReport(signal, 10); + return; + }//if + arrGuard(apiConnectptr.p->currentReplicaNo, 4); + if (tcConnectptr.p->tcNodedata[apiConnectptr.p->currentReplicaNo] != + tnodeid) { + warningReport(signal, 11); + return; + }//if + if (ERROR_INSERTED(8026)) { + jam(); + systemErrorLab(signal); + }//if + tcurrentReplicaNo = (Uint8)Z8NIL; + tcConnectptr.p->tcConnectstate = OS_COMMITTED; + toCommitHandlingLab(signal); +}//Dbtc::execCOMMITCONF() + +void Dbtc::toCommitHandlingLab(Signal* signal) +{ + do { + if (tcurrentReplicaNo != (Uint8)Z8NIL) { + jam(); + arrGuard(tcurrentReplicaNo, 4); + switch (tcConnectptr.p->failData[tcurrentReplicaNo]) { + case LqhTransConf::InvalidStatus: + jam(); + /*empty*/; + break; + case LqhTransConf::Committed: + jam(); + /*empty*/; + break; + case LqhTransConf::Prepared: + jam(); + /*------------------------------------------------------------*/ + /* THE NODE WAS PREPARED AND IS WAITING FOR ABORT OR */ + /* COMMIT REQUEST FROM TC. */ + /*------------------------------------------------------------*/ + hostptr.i = tcConnectptr.p->tcNodedata[tcurrentReplicaNo]; + ptrCheckGuard(hostptr, chostFilesize, hostRecord); + if (hostptr.p->hostStatus == HS_ALIVE) { + jam(); + tblockref = calcLqhBlockRef(hostptr.i); + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + apiConnectptr.p->apiConnectstate = CS_WAIT_COMMIT_CONF; + apiConnectptr.p->timeOutCounter = 0; + tcConnectptr.p->tcConnectstate = OS_WAIT_COMMIT_CONF; + signal->theData[0] = tcConnectptr.i; + signal->theData[1] = cownref; + signal->theData[2] = apiConnectptr.p->globalcheckpointid; + signal->theData[3] = apiConnectptr.p->transid[0]; + signal->theData[4] = apiConnectptr.p->transid[1]; + signal->theData[5] = apiConnectptr.p->tcBlockref; + signal->theData[6] = tcConnectptr.p->tcOprec; + sendSignal(tblockref, GSN_COMMITREQ, signal, 7, JBB); + return; + }//if + break; + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch + }//if + if (apiConnectptr.p->currentReplicaNo > 0) { + jam(); + /*------------------------------------------------------------*/ + /* THERE IS STILL ANOTHER REPLICA THAT NEEDS TO BE */ + /* COMMITTED. */ + /*------------------------------------------------------------*/ + apiConnectptr.p->currentReplicaNo--; + tcurrentReplicaNo = apiConnectptr.p->currentReplicaNo; + } else { + /*------------------------------------------------------------*/ + /* THE LAST REPLICA IN THIS OPERATION HAVE COMMITTED. */ + /*------------------------------------------------------------*/ + tcConnectptr.i = tcConnectptr.p->nextTcConnect; + if (tcConnectptr.i == RNIL) { + /*------------------------------------------------------------*/ + /* WE HAVE COMPLETED THE COMMIT PHASE. WE CAN NOW REPORT*/ + /* THE COMMIT STATUS TO THE APPLICATION AND CONTINUE */ + /* WITH THE COMPLETE PHASE. */ + /*------------------------------------------------------------*/ + if (apiConnectptr.p->takeOverRec != (Uint8)Z8NIL) { + jam(); + sendTCKEY_FAILCONF(signal, apiConnectptr.p); + } else { + jam(); + sendApiCommit(signal); + }//if + apiConnectptr.p->currentTcConnect = apiConnectptr.p->firstTcConnect; + tcConnectptr.i = apiConnectptr.p->firstTcConnect; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + tcurrentReplicaNo = tcConnectptr.p->lastReplicaNo; + apiConnectptr.p->currentReplicaNo = tcurrentReplicaNo; + toCompleteHandlingLab(signal); + return; + }//if + apiConnectptr.p->currentTcConnect = tcConnectptr.i; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + apiConnectptr.p->currentReplicaNo = tcConnectptr.p->lastReplicaNo; + tcurrentReplicaNo = tcConnectptr.p->lastReplicaNo; + }//if + } while (1); +}//Dbtc::toCommitHandlingLab() + +/*------------------------------------------------------------*/ +/* COMMON PART TO HANDLE COMPLETE PHASE WHEN ANY NODE */ +/* HAVE FAILED. */ +/*------------------------------------------------------------*/ +/* THE NODE WITH TNODEID HAVE COMPLETED THE OPERATION */ +/*------------------------------------------------------------*/ +void Dbtc::execCOMPLETECONF(Signal* signal) +{ + UintR compare_transid1, compare_transid2; + + jamEntry(); + tcConnectptr.i = signal->theData[0]; + tnodeid = signal->theData[1]; + if (ERROR_INSERTED(8047)) { + CLEAR_ERROR_INSERT_VALUE; + sendSignalWithDelay(cownref, GSN_COMPLETECONF, signal, 2000, 4); + return; + }//if + if (tcConnectptr.i >= ctcConnectFilesize) { + errorReport(signal, 3); + return; + }//if + ptrAss(tcConnectptr, tcConnectRecord); + if (tcConnectptr.p->tcConnectstate != OS_WAIT_COMPLETE_CONF) { + warningReport(signal, 12); + return; + }//if + apiConnectptr.i = tcConnectptr.p->apiConnect; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + if (apiConnectptr.p->apiConnectstate != CS_WAIT_COMPLETE_CONF) { + warningReport(signal, 13); + return; + }//if + compare_transid1 = apiConnectptr.p->transid[0] ^ signal->theData[2]; + compare_transid2 = apiConnectptr.p->transid[1] ^ signal->theData[3]; + compare_transid1 = compare_transid1 | compare_transid2; + if (compare_transid1 != 0) { + warningReport(signal, 14); + return; + }//if + arrGuard(apiConnectptr.p->currentReplicaNo, 4); + if (tcConnectptr.p->tcNodedata[apiConnectptr.p->currentReplicaNo] != + tnodeid) { + warningReport(signal, 15); + return; + }//if + if (ERROR_INSERTED(8028)) { + jam(); + systemErrorLab(signal); + }//if + tcConnectptr.p->tcConnectstate = OS_COMPLETED; + tcurrentReplicaNo = (Uint8)Z8NIL; + toCompleteHandlingLab(signal); +}//Dbtc::execCOMPLETECONF() + +void Dbtc::toCompleteHandlingLab(Signal* signal) +{ + do { + if (tcurrentReplicaNo != (Uint8)Z8NIL) { + jam(); + arrGuard(tcurrentReplicaNo, 4); + switch (tcConnectptr.p->failData[tcurrentReplicaNo]) { + case LqhTransConf::InvalidStatus: + jam(); + /*empty*/; + break; + default: + jam(); + /*------------------------------------------------------------*/ + /* THIS NODE DID NOT REPORT ANYTHING FOR THIS OPERATION */ + /* IT MUST HAVE FAILED. */ + /*------------------------------------------------------------*/ + /*------------------------------------------------------------*/ + /* SEND COMPLETEREQ TO THE NEXT REPLICA. */ + /*------------------------------------------------------------*/ + hostptr.i = tcConnectptr.p->tcNodedata[tcurrentReplicaNo]; + ptrCheckGuard(hostptr, chostFilesize, hostRecord); + if (hostptr.p->hostStatus == HS_ALIVE) { + jam(); + tblockref = calcLqhBlockRef(hostptr.i); + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + tcConnectptr.p->tcConnectstate = OS_WAIT_COMPLETE_CONF; + apiConnectptr.p->apiConnectstate = CS_WAIT_COMPLETE_CONF; + apiConnectptr.p->timeOutCounter = 0; + tcConnectptr.p->apiConnect = apiConnectptr.i; + signal->theData[0] = tcConnectptr.i; + signal->theData[1] = cownref; + signal->theData[2] = apiConnectptr.p->transid[0]; + signal->theData[3] = apiConnectptr.p->transid[1]; + signal->theData[4] = apiConnectptr.p->tcBlockref; + signal->theData[5] = tcConnectptr.p->tcOprec; + sendSignal(tblockref, GSN_COMPLETEREQ, signal, 6, JBB); + return; + }//if + break; + }//switch + }//if + if (apiConnectptr.p->currentReplicaNo != 0) { + jam(); + /*------------------------------------------------------------*/ + /* THERE ARE STILL MORE REPLICAS IN THIS OPERATION. WE */ + /* NEED TO CONTINUE WITH THOSE REPLICAS. */ + /*------------------------------------------------------------*/ + apiConnectptr.p->currentReplicaNo--; + tcurrentReplicaNo = apiConnectptr.p->currentReplicaNo; + } else { + tcConnectptr.i = tcConnectptr.p->nextTcConnect; + if (tcConnectptr.i == RNIL) { + /*------------------------------------------------------------*/ + /* WE HAVE COMPLETED THIS TRANSACTION NOW AND CAN */ + /* CONTINUE THE PROCESS WITH THE NEXT TRANSACTION. */ + /*------------------------------------------------------------*/ + if (apiConnectptr.p->takeOverRec != (Uint8)Z8NIL) { + jam(); + signal->theData[0] = TcContinueB::ZCOMPLETE_TRANS_AT_TAKE_OVER; + signal->theData[1] = (UintR)apiConnectptr.p->takeOverRec; + signal->theData[2] = apiConnectptr.p->takeOverInd; + sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB); + releaseTakeOver(signal); + } else { + jam(); + releaseTransResources(signal); + }//if + return; + }//if + /*------------------------------------------------------------*/ + /* WE HAVE COMPLETED AN OPERATION AND THERE ARE MORE TO */ + /* COMPLETE. TAKE THE NEXT OPERATION AND START WITH THE */ + /* FIRST REPLICA SINCE IT IS THE COMPLETE PHASE. */ + /*------------------------------------------------------------*/ + apiConnectptr.p->currentTcConnect = tcConnectptr.i; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + tcurrentReplicaNo = tcConnectptr.p->lastReplicaNo; + apiConnectptr.p->currentReplicaNo = tcurrentReplicaNo; + }//if + } while (1); +}//Dbtc::toCompleteHandlingLab() + +/*------------------------------------------------------------*/ +/* */ +/* FIND THE API CONNECT RECORD FOR THIS TRANSACTION */ +/* DURING TAKE OVER FROM A FAILED TC. IF NONE EXISTS */ +/* YET THEN SEIZE A NEW API CONNECT RECORD AND LINK IT */ +/* INTO THE HASH TABLE. */ +/*------------------------------------------------------------*/ +void Dbtc::findApiConnectFail(Signal* signal) +{ + ApiConnectRecordPtr fafPrevApiConnectptr; + ApiConnectRecordPtr fafNextApiConnectptr; + UintR tfafHashNumber; + + tfafHashNumber = ttransid1 & 511; + fafPrevApiConnectptr.i = RNIL; + ptrNull(fafPrevApiConnectptr); + arrGuard(tfafHashNumber, 512); + fafNextApiConnectptr.i = ctransidFailHash[tfafHashNumber]; + ptrCheck(fafNextApiConnectptr, capiConnectFilesize, apiConnectRecord); +FAF_LOOP: + jam(); + if (fafNextApiConnectptr.i == RNIL) { + jam(); + if (cfirstfreeApiConnectFail == RNIL) { + jam(); + systemErrorLab(signal); + return; + }//if + seizeApiConnectFail(signal); + if (fafPrevApiConnectptr.i == RNIL) { + jam(); + ctransidFailHash[tfafHashNumber] = apiConnectptr.i; + } else { + jam(); + ptrGuard(fafPrevApiConnectptr); + fafPrevApiConnectptr.p->nextApiConnect = apiConnectptr.i; + }//if + apiConnectptr.p->nextApiConnect = RNIL; + initApiConnectFail(signal); + } else { + jam(); + fafPrevApiConnectptr.i = fafNextApiConnectptr.i; + fafPrevApiConnectptr.p = fafNextApiConnectptr.p; + apiConnectptr.i = fafNextApiConnectptr.i; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + fafNextApiConnectptr.i = apiConnectptr.p->nextApiConnect; + ptrCheck(fafNextApiConnectptr, capiConnectFilesize, apiConnectRecord); + if ((apiConnectptr.p->transid[1] != ttransid2) || + (apiConnectptr.p->transid[0] != ttransid1)) { + goto FAF_LOOP; + }//if + updateApiStateFail(signal); + }//if +}//Dbtc::findApiConnectFail() + +/*----------------------------------------------------------*/ +/* FIND THE TC CONNECT AND IF NOT FOUND ALLOCATE A NEW */ +/*----------------------------------------------------------*/ +void Dbtc::findTcConnectFail(Signal* signal) +{ + UintR tftfHashNumber; + + tftfHashNumber = (ttransid1 ^ ttcOprec) & 1023; + tcConnectptr.i = ctcConnectFailHash[tftfHashNumber]; + do { + if (tcConnectptr.i == RNIL) { + jam(); + if (cfirstfreeTcConnectFail == RNIL) { + jam(); + systemErrorLab(signal); + return; + }//if + seizeTcConnectFail(signal); + linkTcInConnectionlist(signal); + tcConnectptr.p->nextTcFailHash = ctcConnectFailHash[tftfHashNumber]; + ctcConnectFailHash[tftfHashNumber] = tcConnectptr.i; + initTcConnectFail(signal); + return; + } else { + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + if (tcConnectptr.p->tcOprec != ttcOprec) { + jam(); /* FRAGMENTID = TC_OPREC HERE, LOOP ANOTHER TURN */ + tcConnectptr.i = tcConnectptr.p->nextTcFailHash; + } else { + updateTcStateFail(signal); + return; + }//if + }//if + } while (1); +}//Dbtc::findTcConnectFail() + +/*----------------------------------------------------------*/ +/* INITIALISE AN API CONNECT FAIL RECORD */ +/*----------------------------------------------------------*/ +void Dbtc::initApiConnectFail(Signal* signal) +{ + apiConnectptr.p->transid[0] = ttransid1; + apiConnectptr.p->transid[1] = ttransid2; + apiConnectptr.p->firstTcConnect = RNIL; + apiConnectptr.p->currSavePointId = 0; + apiConnectptr.p->lastTcConnect = RNIL; + tblockref = calcTcBlockRef(tcNodeFailptr.p->takeOverNode); + + apiConnectptr.p->tcBlockref = tblockref; + apiConnectptr.p->ndbapiBlockref = tapplRef; + apiConnectptr.p->ndbapiConnect = tapplOprec; + apiConnectptr.p->buddyPtr = RNIL; + setApiConTimer(apiConnectptr.i, 0, __LINE__); + switch(ttransStatus){ + case LqhTransConf::Committed: + jam(); + apiConnectptr.p->globalcheckpointid = tgci; + apiConnectptr.p->apiConnectstate = CS_FAIL_COMMITTED; + break; + case LqhTransConf::Prepared: + jam(); + apiConnectptr.p->apiConnectstate = CS_FAIL_PREPARED; + break; + case LqhTransConf::Aborted: + jam(); + apiConnectptr.p->apiConnectstate = CS_FAIL_ABORTED; + break; + case LqhTransConf::Marker: + jam(); + apiConnectptr.p->apiConnectstate = CS_FAIL_COMPLETED; + break; + default: + jam(); + systemErrorLab(signal); + }//if + apiConnectptr.p->commitAckMarker = RNIL; + if(LqhTransConf::getMarkerFlag(treqinfo)){ + jam(); + CommitAckMarkerPtr tmp; + m_commitAckMarkerHash.seize(tmp); + + ndbrequire(tmp.i != RNIL); + + apiConnectptr.p->commitAckMarker = tmp.i; + tmp.p->transid1 = ttransid1; + tmp.p->transid2 = ttransid2; + tmp.p->apiNodeId = refToNode(tapplRef); + tmp.p->noOfLqhs = 1; + tmp.p->lqhNodeId[0] = tnodeid; + tmp.p->apiConnectPtr = apiConnectptr.i; + m_commitAckMarkerHash.add(tmp); + } +}//Dbtc::initApiConnectFail() + +/*------------------------------------------------------------*/ +/* INITIALISE AT TC CONNECT AT TAKE OVER WHEN ALLOCATING*/ +/* THE TC CONNECT RECORD. */ +/*------------------------------------------------------------*/ +void Dbtc::initTcConnectFail(Signal* signal) +{ + tcConnectptr.p->apiConnect = apiConnectptr.i; + tcConnectptr.p->tcOprec = ttcOprec; + Uint32 treplicaNo = LqhTransConf::getReplicaNo(treqinfo); + for (Uint32 i = 0; i < MAX_REPLICAS; i++) { + tcConnectptr.p->failData[i] = LqhTransConf::InvalidStatus; + }//for + tcConnectptr.p->tcNodedata[treplicaNo] = tnodeid; + tcConnectptr.p->failData[treplicaNo] = ttransStatus; + tcConnectptr.p->lastReplicaNo = LqhTransConf::getLastReplicaNo(treqinfo); + tcConnectptr.p->dirtyOp = LqhTransConf::getDirtyFlag(treqinfo); + +}//Dbtc::initTcConnectFail() + +/*----------------------------------------------------------*/ +/* INITIALISE TC NODE FAIL RECORD. */ +/*----------------------------------------------------------*/ +void Dbtc::initTcFail(Signal* signal) +{ + tcNodeFailptr.i = 0; + ptrAss(tcNodeFailptr, tcFailRecord); + tcNodeFailptr.p->queueIndex = 0; + tcNodeFailptr.p->failStatus = FS_IDLE; +}//Dbtc::initTcFail() + +/*----------------------------------------------------------*/ +/* RELEASE_TAKE_OVER */ +/*----------------------------------------------------------*/ +void Dbtc::releaseTakeOver(Signal* signal) +{ + TcConnectRecordPtr rtoNextTcConnectptr; + + rtoNextTcConnectptr.i = apiConnectptr.p->firstTcConnect; + do { + jam(); + tcConnectptr.i = rtoNextTcConnectptr.i; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + rtoNextTcConnectptr.i = tcConnectptr.p->nextTcConnect; + releaseTcConnectFail(signal); + } while (rtoNextTcConnectptr.i != RNIL); + releaseApiConnectFail(signal); +}//Dbtc::releaseTakeOver() + +/*---------------------------------------------------------------------------*/ +/* SETUP_FAIL_DATA */ +/* SETUP DATA TO REUSE TAKE OVER CODE FOR HANDLING ABORT/COMMIT IN NODE */ +/* FAILURE SITUATIONS. */ +/*---------------------------------------------------------------------------*/ +void Dbtc::setupFailData(Signal* signal) +{ + tcConnectptr.i = apiConnectptr.p->firstTcConnect; + do { + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + switch (tcConnectptr.p->tcConnectstate) { + case OS_PREPARED: + case OS_COMMITTING: + jam(); + for (tindex = 0; tindex <= tcConnectptr.p->lastReplicaNo; tindex++) { + jam(); + /*------------------------------------------------------------------- + * KEYDATA IS USED TO KEEP AN INDICATION OF STATE IN LQH. + * IN THIS CASE ALL LQH'S ARE PREPARED AND WAITING FOR + * COMMIT/ABORT DECISION. + *------------------------------------------------------------------*/ + arrGuard(tindex, 4); + tcConnectptr.p->failData[tindex] = LqhTransConf::Prepared; + }//for + break; + case OS_COMMITTED: + case OS_COMPLETING: + jam(); + for (tindex = 0; tindex <= tcConnectptr.p->lastReplicaNo; tindex++) { + jam(); + /*------------------------------------------------------------------- + * KEYDATA IS USED TO KEEP AN INDICATION OF STATE IN LQH. + * IN THIS CASE ALL LQH'S ARE COMMITTED AND WAITING FOR + * COMPLETE MESSAGE. + *------------------------------------------------------------------*/ + arrGuard(tindex, 4); + tcConnectptr.p->failData[tindex] = LqhTransConf::Committed; + }//for + break; + case OS_COMPLETED: + jam(); + for (tindex = 0; tindex <= tcConnectptr.p->lastReplicaNo; tindex++) { + jam(); + /*------------------------------------------------------------------- + * KEYDATA IS USED TO KEEP AN INDICATION OF STATE IN LQH. + * IN THIS CASE ALL LQH'S ARE COMPLETED. + *-------------------------------------------------------------------*/ + arrGuard(tindex, 4); + tcConnectptr.p->failData[tindex] = LqhTransConf::InvalidStatus; + }//for + break; + default: + jam(); + sendSystemError(signal); + break; + }//switch + if (tabortInd != ZCOMMIT_SETUP) { + jam(); + for (UintR Ti = 0; Ti <= tcConnectptr.p->lastReplicaNo; Ti++) { + hostptr.i = tcConnectptr.p->tcNodedata[Ti]; + ptrCheckGuard(hostptr, chostFilesize, hostRecord); + if (hostptr.p->hostStatus != HS_ALIVE) { + jam(); + /*----------------------------------------------------------------- + * FAILURE OF ANY INVOLVED NODE ALWAYS INVOKES AN ABORT DECISION. + *-----------------------------------------------------------------*/ + tabortInd = ZTRUE; + }//if + }//for + }//if + tcConnectptr.p->tcConnectstate = OS_TAKE_OVER; + tcConnectptr.p->tcOprec = tcConnectptr.i; + tcConnectptr.i = tcConnectptr.p->nextTcConnect; + } while (tcConnectptr.i != RNIL); + apiConnectptr.p->tcBlockref = cownref; + apiConnectptr.p->currentTcConnect = apiConnectptr.p->firstTcConnect; + tcConnectptr.i = apiConnectptr.p->firstTcConnect; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + apiConnectptr.p->currentReplicaNo = tcConnectptr.p->lastReplicaNo; + tcurrentReplicaNo = tcConnectptr.p->lastReplicaNo; +}//Dbtc::setupFailData() + +/*----------------------------------------------------------*/ +/* UPDATE THE STATE OF THE API CONNECT FOR THIS PART. */ +/*----------------------------------------------------------*/ +void Dbtc::updateApiStateFail(Signal* signal) +{ + if(LqhTransConf::getMarkerFlag(treqinfo)){ + jam(); + const Uint32 marker = apiConnectptr.p->commitAckMarker; + if(marker == RNIL){ + jam(); + + CommitAckMarkerPtr tmp; + m_commitAckMarkerHash.seize(tmp); + ndbrequire(tmp.i != RNIL); + + apiConnectptr.p->commitAckMarker = tmp.i; + tmp.p->transid1 = ttransid1; + tmp.p->transid2 = ttransid2; + tmp.p->apiNodeId = refToNode(tapplRef); + tmp.p->noOfLqhs = 1; + tmp.p->lqhNodeId[0] = tnodeid; + tmp.p->apiConnectPtr = apiConnectptr.i; + m_commitAckMarkerHash.add(tmp); + } else { + jam(); + + CommitAckMarkerPtr tmp; + tmp.i = marker; + tmp.p = m_commitAckMarkerHash.getPtr(marker); + + const Uint32 noOfLqhs = tmp.p->noOfLqhs; + ndbrequire(noOfLqhs < MAX_REPLICAS); + tmp.p->lqhNodeId[noOfLqhs] = tnodeid; + tmp.p->noOfLqhs = (noOfLqhs + 1); + } + } + + switch (ttransStatus) { + case LqhTransConf::Committed: + jam(); + switch (apiConnectptr.p->apiConnectstate) { + case CS_FAIL_COMMITTING: + case CS_FAIL_COMMITTED: + jam(); + ndbrequire(tgci == apiConnectptr.p->globalcheckpointid); + break; + case CS_FAIL_PREPARED: + jam(); + apiConnectptr.p->apiConnectstate = CS_FAIL_COMMITTING; + apiConnectptr.p->globalcheckpointid = tgci; + break; + case CS_FAIL_COMPLETED: + jam(); + apiConnectptr.p->globalcheckpointid = tgci; + apiConnectptr.p->apiConnectstate = CS_FAIL_COMMITTED; + break; + default: + jam(); + systemErrorLab(signal); + break; + }//switch + break; + case LqhTransConf::Prepared: + jam(); + switch (apiConnectptr.p->apiConnectstate) { + case CS_FAIL_COMMITTED: + jam(); + apiConnectptr.p->apiConnectstate = CS_FAIL_COMMITTING; + break; + case CS_FAIL_ABORTED: + jam(); + apiConnectptr.p->apiConnectstate = CS_FAIL_ABORTING; + break; + case CS_FAIL_COMMITTING: + case CS_FAIL_PREPARED: + case CS_FAIL_ABORTING: + jam(); + /*empty*/; + break; + default: + jam(); + systemErrorLab(signal); + break; + }//switch + break; + case LqhTransConf::Aborted: + jam(); + switch (apiConnectptr.p->apiConnectstate) { + case CS_FAIL_COMMITTING: + case CS_FAIL_COMMITTED: + jam(); + systemErrorLab(signal); + break; + case CS_FAIL_PREPARED: + jam(); + apiConnectptr.p->apiConnectstate = CS_FAIL_ABORTING; + break; + case CS_FAIL_ABORTING: + case CS_FAIL_ABORTED: + jam(); + /*empty*/; + break; + default: + jam(); + systemErrorLab(signal); + break; + }//switch + break; + case LqhTransConf::Marker: + jam(); + break; + default: + jam(); + systemErrorLab(signal); + break; + }//switch +}//Dbtc::updateApiStateFail() + +/*------------------------------------------------------------*/ +/* UPDATE_TC_STATE_FAIL */ +/* */ +/* WE NEED TO UPDATE THE STATUS OF TC_CONNECT RECORD AND*/ +/* WE ALSO NEED TO CHECK THAT THERE IS CONSISTENCY */ +/* BETWEEN THE DIFFERENT REPLICAS. */ +/*------------------------------------------------------------*/ +void Dbtc::updateTcStateFail(Signal* signal) +{ + const Uint8 treplicaNo = LqhTransConf::getReplicaNo(treqinfo); + const Uint8 tlastReplicaNo = LqhTransConf::getLastReplicaNo(treqinfo); + const Uint8 tdirtyOp = LqhTransConf::getDirtyFlag(treqinfo); + + TcConnectRecord * regTcPtr = tcConnectptr.p; + + ndbrequire(regTcPtr->apiConnect == apiConnectptr.i); + ndbrequire(regTcPtr->failData[treplicaNo] == LqhTransConf::InvalidStatus); + ndbrequire(regTcPtr->lastReplicaNo == tlastReplicaNo); + ndbrequire(regTcPtr->dirtyOp == tdirtyOp); + + regTcPtr->tcNodedata[treplicaNo] = tnodeid; + regTcPtr->failData[treplicaNo] = ttransStatus; +}//Dbtc::updateTcStateFail() + +void Dbtc::execTCGETOPSIZEREQ(Signal* signal) +{ + jamEntry(); + CRASH_INSERTION(8000); + + UintR Tuserpointer = signal->theData[0]; /* DBDIH POINTER */ + BlockReference Tusersblkref = signal->theData[1];/* DBDIH BLOCK REFERENCE */ + signal->theData[0] = Tuserpointer; + signal->theData[1] = coperationsize; + sendSignal(Tusersblkref, GSN_TCGETOPSIZECONF, signal, 2, JBB); +}//Dbtc::execTCGETOPSIZEREQ() + +void Dbtc::execTC_CLOPSIZEREQ(Signal* signal) +{ + jamEntry(); + CRASH_INSERTION(8001); + + tuserpointer = signal->theData[0]; + tusersblkref = signal->theData[1]; + /* DBDIH BLOCK REFERENCE */ + coperationsize = 0; + signal->theData[0] = tuserpointer; + sendSignal(tusersblkref, GSN_TC_CLOPSIZECONF, signal, 1, JBB); +}//Dbtc::execTC_CLOPSIZEREQ() + +/* ######################################################################### */ +/* ####### ERROR MODULE ####### */ +/* ######################################################################### */ +void Dbtc::tabStateErrorLab(Signal* signal) +{ + terrorCode = ZSTATE_ERROR; + releaseAtErrorLab(signal); +}//Dbtc::tabStateErrorLab() + +void Dbtc::wrongSchemaVersionErrorLab(Signal* signal) +{ + const TcKeyReq * const tcKeyReq = (TcKeyReq *)&signal->theData[0]; + + TableRecordPtr tabPtr; + tabPtr.i = tcKeyReq->tableId; + const Uint32 schemVer = tcKeyReq->tableSchemaVersion; + ptrCheckGuard(tabPtr, ctabrecFilesize, tableRecord); + + terrorCode = tabPtr.p->getErrorCode(schemVer); + + abortErrorLab(signal); +}//Dbtc::wrongSchemaVersionErrorLab() + +void Dbtc::noFreeConnectionErrorLab(Signal* signal) +{ + terrorCode = ZNO_FREE_TC_CONNECTION; + abortErrorLab(signal); /* RECORD. OTHERWISE GOTO ERRORHANDLING */ +}//Dbtc::noFreeConnectionErrorLab() + +void Dbtc::aiErrorLab(Signal* signal) +{ + terrorCode = ZLENGTH_ERROR; + abortErrorLab(signal); +}//Dbtc::aiErrorLab() + +void Dbtc::seizeAttrbuferrorLab(Signal* signal) +{ + terrorCode = ZGET_ATTRBUF_ERROR; + abortErrorLab(signal); +}//Dbtc::seizeAttrbuferrorLab() + +void Dbtc::seizeDatabuferrorLab(Signal* signal) +{ + terrorCode = ZGET_DATAREC_ERROR; + releaseAtErrorLab(signal); +}//Dbtc::seizeDatabuferrorLab() + +void Dbtc::releaseAtErrorLab(Signal* signal) +{ + ptrGuard(tcConnectptr); + tcConnectptr.p->tcConnectstate = OS_ABORTING; + /*-------------------------------------------------------------------------* + * A FAILURE OF THIS OPERATION HAS OCCURRED. THIS FAILURE WAS EITHER A + * FAULTY PARAMETER OR A RESOURCE THAT WAS NOT AVAILABLE. + * WE WILL ABORT THE ENTIRE TRANSACTION SINCE THIS IS THE SAFEST PATH + * TO HANDLE THIS PROBLEM. + * SINCE WE HAVE NOT YET CONTACTED ANY LQH WE SET NUMBER OF NODES TO ZERO + * WE ALSO SET THE STATE TO ABORTING TO INDICATE THAT WE ARE NOT EXPECTING + * ANY SIGNALS. + *-------------------------------------------------------------------------*/ + tcConnectptr.p->noOfNodes = 0; + abortErrorLab(signal); +}//Dbtc::releaseAtErrorLab() + +void Dbtc::warningHandlerLab(Signal* signal) +{ + ndbassert(false); +}//Dbtc::warningHandlerLab() + +void Dbtc::systemErrorLab(Signal* signal) +{ + progError(0, 0); +}//Dbtc::systemErrorLab() + + +/* ######################################################################### * + * ####### SCAN MODULE ####### * + * ######################################################################### * + + The application orders a scan of a table. We divide the scan into a scan on + each fragment. The scan uses the primary replicas since the scan might be + used for an update in a separate transaction. + + Scans are always done as a separate transaction. Locks from the scan + can be overtaken by another transaction. Scans can never lock the entire + table. Locks are released immediately after the read has been verified + by the application. There is not even an option to leave the locks. + The reason is that this would hurt real-time behaviour too much. + + -# The first step in handling a scan of a table is to receive all signals + defining the scan. If failures occur during this step we release all + resource and reply with SCAN_TABREF providing the error code. + If system load is too high, the request will not be allowed. + + -# The second step retrieves the number of fragments that exist in the + table. It also ensures that the table actually exist. After this, + the scan is ready to be parallelised. The idea is that the receiving + process (hereafter called delivery process) will start up a number + of scan processes. Each of these scan processes will + independently scan one fragment at a time. The delivery + process object is the scan record and the scan process object is + the scan fragment record plus the scan operation record. + + -# The third step is thus performed in parallel. In the third step each + scan process retrieves the primary replica of the fragment it will + scan. Then it starts the scan as soon as the load on that node permits. + + The LQH returns either when it retrieved the maximum number of tuples or + when it has retrived at least one tuple and is hindered by a lock to + retrieve the next tuple. This is to ensure that a scan process never + can be involved in a deadlock situation. + + When the scan process receives a number of tuples to report to the + application it checks the state of the delivery process. Only one delivery + at a time is handled by the application. Thus if the delivery process + has already sent a number of tuples to the application this set of tuples + are queued. + + When the application requests the next set of tuples it is immediately + delivered if any are queued, otherwise it waits for the next scan + process that is ready to deliver. + + + ERROR HANDLING + + As already mentioned it is rather easy to handle errors before the scan + processes have started. In this case it is enough to release the resources + and send SCAN_TAB_REF. + + If an error occurs in any of the scan processes then we have to stop all + scan processes. We do however only stop the delivery process and ask + the api to order us to close the scan. The reason is that we can easily + enter into difficult timing problems since the application and this + block is out of synch we will thus always start by report the error to + the application and wait for a close request. This error report uses the + SCAN_TABREF signal with a special error code that the api must check for. + + + CLOSING AN ACTIVE SCAN + + The application can close a scan for several reasons before it is completed. + One reason was mentioned above where an error in a scan process led to a + request to close the scan. Another reason could simply be that the + application found what it looked for and is thus not interested in the + rest of the scan. + + IT COULD ALSO BE DEPENDENT ON INTERNAL ERRORS IN THE API. + + When a close scan request is received, all scan processes are stopped and all + resources belonging to those scan processes are released. Stopping the scan + processes most often includes communication with an LQH where the local scan + is controlled. Finally all resources belonging to the scan is released and + the SCAN_TABCONF is sent with an indication of that the scan is closed. + + + CLOSING A COMPLETED SCAN + + When all scan processes are completed then a report is sent to the + application which indicates that no more tuples can be fetched. + The application will send a close scan and the same action as when + closing an active scan is performed. + In this case it will of course not find any active scan processes. + It will even find all scan processes already released. + + The reason for requiring the api to close the scan is the same as above. + It is to avoid any timing problems due to that the api and this block + is out of synch. + + * ######################################################################## */ +void Dbtc::execSCAN_TABREQ(Signal* signal) +{ + const ScanTabReq * const scanTabReq = (ScanTabReq *)&signal->theData[0]; + const UintR reqinfo = scanTabReq->requestInfo; + const Uint32 aiLength = scanTabReq->attrLen; + const Uint32 schemaVersion = scanTabReq->tableSchemaVersion; + const UintR transid1 = scanTabReq->transId1; + const UintR transid2 = scanTabReq->transId2; + const Uint32 tmpXX = scanTabReq->buddyConPtr; + const Uint32 buddyPtr = (tmpXX == 0xFFFFFFFF ? RNIL : tmpXX); + Uint32 currSavePointId = 0; + + Uint8 scanConcurrency = scanTabReq->getParallelism(reqinfo); + Uint32 scanParallel; + Uint32 noOprecPerFrag; + Uint32 errCode; + + jamEntry(); + apiConnectptr.i = scanTabReq->apiConnectPtr; + tabptr.i = scanTabReq->tableId; + for(int i=0; i<16; i++) + cdata[i] = scanTabReq->apiOperationPtr[i]; + + if (apiConnectptr.i >= capiConnectFilesize || + tabptr.i >= ctabrecFilesize) { + jam(); + warningHandlerLab(signal); + return; + }//if + ptrAss(apiConnectptr, apiConnectRecord); + + if (apiConnectptr.p->apiConnectstate != CS_CONNECTED) { + jam(); + // could be left over from TCKEYREQ rollback + if (apiConnectptr.p->apiConnectstate == CS_ABORTING && + apiConnectptr.p->abortState == AS_IDLE) { + jam(); + } else { + jam(); + errCode = ZSTATE_ERROR; + goto SCAN_TAB_error; + } + } + ptrAss(tabptr, tableRecord); + + if (aiLength == 0) { + jam() + errCode = ZSCAN_AI_LEN_ERROR; + goto SCAN_TAB_error; + }//if + if (!tabptr.p->checkTable(schemaVersion)){ + jam(); + goto SCAN_TAB_schema_error; + }//if + /***************************************************************** + * THE CONCURRENCY LEVEL SPECIFIED BY THE APPLICATION. IT MUST BE + * BETWEEN 1 AND 240. IF IT IS 16 OR GREATER IT MUST BE A MULTIPLE + * OF 16. CONCURRENCY LEVELS UPTO 16 ONLY SCAN ONE FRAGMENT AT A + * TIME. IF WE SPECIFY 32 IT WILL SCAN TWO FRAGMENTS AT A TIME AND + * SO FORTH. MAXIMUM 15 PARALLEL SCANS ARE ALLOWED + ******************************************************************/ + if (scanConcurrency == 0) { + jam(); + errCode = ZNO_CONCURRENCY_ERROR; + goto SCAN_TAB_error; + }//if + if (scanConcurrency <= 16) { + jam(); + noOprecPerFrag = scanConcurrency; + } else { + if (scanConcurrency <= 240) { + jam(); + //If scanConcurrency > 16 it must be a multiple of 16 + if (((scanConcurrency >> 4) << 4) < scanConcurrency) { + scanConcurrency = ((scanConcurrency >> 4) << 4) + 16; + }//if + } else { + jam(); + errCode = ZTOO_HIGH_CONCURRENCY_ERROR; + goto SCAN_TAB_error; + }//if + noOprecPerFrag = 16; + }//if + + scanParallel = ((scanConcurrency - 1) >> 4) + 1; + /********************************************************** + * CALCULATE THE NUMBER OF SCAN_TABINFO SIGNALS THAT WILL + * ARRIVE TO DEFINE THIS SCAN. THIS ALSO DEFINES THE NUMBER + * OF PARALLEL SCANS AND IT ALSO DEFINES THE NUMBER OF SCAN + * OPERATION POINTER RECORDS TO ALLOCATE. + **********************************************************/ + if (cnoFreeScanOprec < scanParallel) { + jam(); + errCode = ZNO_SCANREC_ERROR; + goto SCAN_TAB_error; + // WE DID NOT HAVE ENOUGH OF FREE SCAN OPERATION POINTER RECORDS. + // THUS WE REFUSE THE SCAN OPERATION. + }//if + if (cfirstfreeTcConnect == RNIL) { + jam(); + errCode = ZNO_FREE_TC_CONNECTION; + goto SCAN_TAB_error; + }//if + if (cfirstfreeScanrec == RNIL) { + jam(); + errCode = ZNO_SCANREC_ERROR; + goto SCAN_TAB_error; + }//if + + if (buddyPtr != RNIL) { + jam(); + + ApiConnectRecordPtr buddyApiPtr; + buddyApiPtr.i = buddyPtr; + ptrCheckGuard(buddyApiPtr, capiConnectFilesize, apiConnectRecord); + if ((transid1 == buddyApiPtr.p->transid[0]) && + (transid2 == buddyApiPtr.p->transid[1])) { + jam(); + currSavePointId = buddyApiPtr.p->currSavePointId; + buddyApiPtr.p->currSavePointId++; + } + } + + seizeTcConnect(signal); + seizeCacheRecord(signal); + seizeScanrec(signal); + initScanrec(signal, scanParallel, noOprecPerFrag); + initScanTcrec(signal); + initScanApirec(signal, buddyPtr, transid1, transid2); + cnoFreeScanOprec = cnoFreeScanOprec - scanParallel; + + // The scan is started + apiConnectptr.p->apiConnectstate = CS_START_SCAN; + apiConnectptr.p->currSavePointId = currSavePointId; + + /********************************************************** + * We start the timer on scanRec to be able to discover a + * timeout in the API the API now is in charge! + ***********************************************************/ + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + updateBuddyTimer(apiConnectptr); + if (scanptr.p->noScanTabInfo > 1) { + jam(); + scanptr.p->scanState = ScanRecord::WAIT_SCAN_TAB_INFO; + return; + }//if + /*********************************************************** + * WE HAVE NOW RECEIVED ALL REFERENCES TO SCAN OBJECTS IN + * THE API. WE ARE NOW READY TO RECEIVE THE ATTRIBUTE INFO + * IF ANY TO RECEIVE. + **********************************************************/ + scanptr.p->scanState = ScanRecord::WAIT_AI; + return; + + SCAN_TAB_schema_error: + jam(); + errCode = tabptr.p->getErrorCode(schemaVersion); + + SCAN_TAB_error: + jam(); + ScanTabRef * ref = (ScanTabRef*)&signal->theData[0]; + ref->apiConnectPtr = apiConnectptr.p->ndbapiConnect; + ref->transId1 = transid1; + ref->transId2 = transid2; + ref->errorCode = errCode; + sendSignal(apiConnectptr.p->ndbapiBlockref, GSN_SCAN_TABREF, + signal, ScanTabRef::SignalLength, JBB); + + return; +}//Dbtc::execSCAN_TABREQ() + +void Dbtc::initScanTcrec(Signal* signal) +{ + tcConnectptr.p->apiConnect = apiConnectptr.i; +}//Dbtc::initScanTcrec() + +void Dbtc::initScanApirec(Signal* signal, + Uint32 buddyPtr, UintR transid1, UintR transid2) +{ + ApiConnectRecord * apiPtr = apiConnectptr.p; + apiPtr->apiScanRec = scanptr.i; + apiPtr->returncode = 0; + apiPtr->transid[0] = transid1; + apiPtr->transid[1] = transid2; + apiPtr->buddyPtr = buddyPtr; + +}//Dbtc::initScanApirec() + +void Dbtc::initScanOprec(Signal* signal) +{ + UintR tisoIndex; + + for (tisoIndex = 0; tisoIndex < 16; tisoIndex++) { + scanOpptr.p->apiOpptr[tisoIndex] = cdata[tisoIndex]; + scanOpptr.p->scanOpLength[tisoIndex] = RNIL; + }//for +}//Dbtc::initScanOprec() + +void Dbtc::initScanrec(Signal* signal, + UintR scanParallel, + UintR noOprecPerFrag) +{ + const ScanTabReq * const scanTabReq = (ScanTabReq *)&signal->theData[0]; + const UintR reqinfo = scanTabReq->requestInfo; + ndbrequire(scanParallel < 16); + + scanptr.p->scanTcrec = tcConnectptr.i; + scanptr.p->scanApiRec = apiConnectptr.i; + scanptr.p->scanAiLength = scanTabReq->attrLen; + scanptr.p->scanTableref = tabptr.i; + scanptr.p->scanSchemaVersion = scanTabReq->tableSchemaVersion; + scanptr.p->scanParallel = scanParallel; + scanptr.p->noScanOprec = scanParallel; + scanptr.p->noScanTabInfo = scanParallel; + scanptr.p->scanTabInfoReceived = 1; + scanptr.p->scanProcessesCompleted = 0; + scanptr.p->scanLockMode = ScanTabReq::getLockMode(reqinfo); + scanptr.p->scanLockHold = ScanTabReq::getHoldLockFlag(reqinfo); + scanptr.p->readCommitted = ScanTabReq::getReadCommittedFlag(reqinfo); + scanptr.p->rangeScan = ScanTabReq::getRangeScanFlag(reqinfo); + scanptr.p->scanStoredProcId = scanTabReq->storedProcId; + scanptr.p->scanReceivedOperations = 0; + scanptr.p->noOprecPerFrag = noOprecPerFrag; + scanptr.p->apiIsClosed = false; + scanptr.p->scanCompletedStatus = ZFALSE; + scanptr.p->scanState = ScanRecord::SCAN_NEXT_ORDERED; + for (Uint32 i = 0; i < 16; i++) { + if (i < scanParallel){ + jam(); + seizeScanOprec(signal); + scanptr.p->scanOprec[i] = scanOpptr.i; + } else { + jam(); + scanptr.p->scanOprec[i] = RNIL; + } + scanptr.p->scanFragrec[i] = RNIL; + }//for + scanOpptr.i = scanptr.p->scanOprec[0]; + ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord); + initScanOprec(signal); +}//Dbtc::initScanrec() + +void Dbtc::scanTabRefLab(Signal* signal, Uint32 errCode) +{ + ScanTabRef * ref = (ScanTabRef*)&signal->theData[0]; + ref->apiConnectPtr = apiConnectptr.p->ndbapiConnect; + ref->transId1 = apiConnectptr.p->transid[0]; + ref->transId2 = apiConnectptr.p->transid[1]; + ref->errorCode = errCode; + sendSignal(apiConnectptr.p->ndbapiBlockref, GSN_SCAN_TABREF, + signal, ScanTabRef::SignalLength, JBB); +}//Dbtc::scanTabRefLab() + +/****************************************************** + * execSCAN_TABINFO + ******************************************************/ +void Dbtc::execSCAN_TABINFO(Signal* signal) +{ + jamEntry(); + apiConnectptr.i = signal->theData[0]; + for(int i=0; i<16; i++) + cdata[i] = signal->theData[i+1]; + + if (apiConnectptr.i >= capiConnectFilesize) { + jam(); + warningHandlerLab(signal); + return; + }//if + ptrAss(apiConnectptr, apiConnectRecord); + + if (apiConnectptr.p->apiConnectstate != CS_START_SCAN){ + jam(); + DEBUG("apiPtr(" << apiConnectptr.i << ") Dropping SCAN_TABINFO, wrong state: " << apiConnectptr.p->apiConnectstate); + return; + } + + scanptr.i = apiConnectptr.p->apiScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + + const Uint32 tscanOprec = scanptr.p->scanTabInfoReceived; + scanptr.p->scanTabInfoReceived++; + arrGuard(tscanOprec, 16); + scanOpptr.i = scanptr.p->scanOprec[tscanOprec]; + ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord); + // Start timer and wait for response from API node. + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + updateBuddyTimer(apiConnectptr); + + initScanOprec(signal); + // Start timer and wait for response from API node. + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + updateBuddyTimer(apiConnectptr); + + if (scanptr.p->scanTabInfoReceived == scanptr.p->noScanTabInfo) { + jam(); + /****************************************************************** + * WE HAVE NOW RECEIVED ALL REFERENCES TO SCAN OBJECTS IN THE API. + * WE ARE NOW READY TO RECEIVE THE ATTRIBUTE INFO IF ANY TO RECEIVE. + ******************************************************************/ + scanptr.p->scanState = ScanRecord::WAIT_AI; + return; + } + ndbrequire(scanptr.p->scanTabInfoReceived <= scanptr.p->noScanTabInfo); +}//Dbtc::execSCAN_TABINFO() + +/*---------------------------------------------------------------------------*/ +/* */ +/* RECEPTION OF ATTRINFO FOR SCAN TABLE REQUEST. */ +/*---------------------------------------------------------------------------*/ +void Dbtc::scanAttrinfoLab(Signal* signal, UintR Tlen) +{ + scanptr.i = apiConnectptr.p->apiScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + tcConnectptr.i = scanptr.p->scanTcrec; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + cachePtr.i = apiConnectptr.p->cachePtr; + ptrCheckGuard(cachePtr, ccacheFilesize, cacheRecord); + CacheRecord * const regCachePtr = cachePtr.p; + ndbrequire(scanptr.p->scanState == ScanRecord::WAIT_AI); + + regCachePtr->currReclenAi = regCachePtr->currReclenAi + Tlen; + if (regCachePtr->currReclenAi < scanptr.p->scanAiLength) { + if (cfirstfreeAttrbuf == RNIL) { + goto scanAttrinfo_attrbuf_error; + }//if + saveAttrbuf(signal); + } else { + if (regCachePtr->currReclenAi > scanptr.p->scanAiLength) { + goto scanAttrinfo_len_error; + } else { + /* CURR_RECLEN_AI = SCAN_AI_LENGTH */ + if (cfirstfreeAttrbuf == RNIL) { + goto scanAttrinfo_attrbuf2_error; + }//if + saveAttrbuf(signal); + /************************************************** + * WE HAVE NOW RECEIVED ALL INFORMATION CONCERNING + * THIS SCAN. WE ARE READY TO START THE ACTUAL + * EXECUTION OF THE SCAN QUERY + **************************************************/ + diFcountReqLab(signal); + return; + }//if + }//if + return; + +scanAttrinfo_attrbuf_error: + jam(); + abortScanLab(signal, ZGET_ATTRBUF_ERROR); + return; + +scanAttrinfo_attrbuf2_error: + jam(); + abortScanLab(signal, ZGET_ATTRBUF_ERROR); + return; + +scanAttrinfo_len_error: + jam(); + abortScanLab(signal, ZLENGTH_ERROR); + return; +}//Dbtc::scanAttrinfoLab() + +void Dbtc::diFcountReqLab(Signal* signal) +{ + /** + * Check so that the table is not being dropped + */ + TableRecordPtr tabPtr; + tabPtr.i = scanptr.p->scanTableref; + tabPtr.p = &tableRecord[tabPtr.i]; + if (tabPtr.p->checkTable(scanptr.p->scanSchemaVersion)){ + ; + } else { + abortScanLab(signal, tabPtr.p->getErrorCode(scanptr.p->scanSchemaVersion)); + return; + } + + scanptr.p->scanState = ScanRecord::WAIT_FRAGMENT_COUNT; + /************************************************* + * THE FIRST STEP TO RECEIVE IS SUCCESSFULLY COMPLETED. + * WE MUST FIRST GET THE NUMBER OF FRAGMENTS IN THE TABLE. + ***************************************************/ + signal->theData[0] = tcConnectptr.p->dihConnectptr; + signal->theData[1] = scanptr.p->scanTableref; + sendSignal(cdihblockref, GSN_DI_FCOUNTREQ, signal, 2, JBB); + return; +}//Dbtc::diFcountReqLab() + +/******************************************************************** + * execDI_FCOUNTCONF + * + * WE HAVE ASKED DIH ABOUT THE NUMBER OF FRAGMENTS IN THIS TABLE. + * WE WILL NOW START A NUMBER OF PARALLEL SCAN PROCESSES. EACH OF + * THESE WILL SCAN ONE FRAGMENT AT A TIME. THEY WILL CONTINUE THIS + * UNTIL THERE ARE NO MORE FRAGMENTS TO SCAN OR UNTIL THE APPLICATION + * CLOSES THE SCAN. + ********************************************************************/ +void Dbtc::execDI_FCOUNTCONF(Signal* signal) +{ + jamEntry(); + tcConnectptr.i = signal->theData[0]; + const UintR tfragCount = signal->theData[1]; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + apiConnectptr.i = tcConnectptr.p->apiConnect; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + scanptr.i = apiConnectptr.p->apiScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + ndbrequire(scanptr.p->scanState == ScanRecord::WAIT_FRAGMENT_COUNT); + if (apiConnectptr.p->apiFailState == ZTRUE) { + jam(); + releaseScanResources(signal); + handleApiFailState(signal, apiConnectptr.i); + return; + }//if + if (tfragCount == 0) { + jam(); + abortScanLab(signal, ZNO_FRAGMENT_ERROR); + return; + }//if + + /** + * Check so that the table is not being dropped + */ + TableRecordPtr tabPtr; + tabPtr.i = scanptr.p->scanTableref; + tabPtr.p = &tableRecord[tabPtr.i]; + if (tabPtr.p->checkTable(scanptr.p->scanSchemaVersion)){ + ; + } else { + abortScanLab(signal, tabPtr.p->getErrorCode(scanptr.p->scanSchemaVersion)); + return; + } + + if (tfragCount < scanptr.p->scanParallel) { + jam(); + for (Uint32 i = tfragCount; i < scanptr.p->scanParallel; i++) { + jam(); + arrGuard(i, 16); + scanOpptr.i = scanptr.p->scanOprec[i]; + ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord); + releaseScanOprec(signal); + scanptr.p->scanOprec[i] = RNIL; + }//for + scanptr.p->scanParallel = tfragCount; + }//if + scanptr.p->scanNoFrag = tfragCount; + for (UintR i = 0; i < scanptr.p->scanParallel; i++) { + jam(); + // START EACH OF THE PARALLEL SCAN PROCESSES + signal->theData[0] = scanptr.i; + signal->theData[1] = i; + signal->theData[2] = scanptr.p->noOprecPerFrag; + sendSignal(cownref, GSN_SCAN_PROCREQ, signal, 3, JBB); + }//for + // We don't need the timer for checking API anymore, control goes to LQH. + setApiConTimer(apiConnectptr.i, 0, __LINE__); + scanptr.p->scanNextFragId = scanptr.p->scanParallel; + scanptr.p->scanState = ScanRecord::SCAN_NEXT_ORDERED; +}//Dbtc::execDI_FCOUNTCONF() + +/****************************************************** + * execDI_FCOUNTREF + ******************************************************/ +void Dbtc::execDI_FCOUNTREF(Signal* signal) +{ + jamEntry(); + tcConnectptr.i = signal->theData[0]; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + const Uint32 errCode = signal->theData[1]; + apiConnectptr.i = tcConnectptr.p->apiConnect; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + scanptr.i = apiConnectptr.p->apiScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + ndbrequire(scanptr.p->scanState == ScanRecord::WAIT_FRAGMENT_COUNT); + if (apiConnectptr.p->apiFailState == ZTRUE) { + jam(); + releaseScanResources(signal); + handleApiFailState(signal, apiConnectptr.i); + return; + }//if + abortScanLab(signal, errCode); +}//Dbtc::execDI_FCOUNTREF() + +void Dbtc::abortScanLab(Signal* signal, Uint32 errCode) +{ + releaseScanResources(signal); + scanTabRefLab(signal, errCode); +}//Dbtc::abortScanLab() + +void Dbtc::scanReleaseResourcesLab(Signal* signal) +{ + apiConnectptr.i = scanptr.p->scanApiRec; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + if (apiConnectptr.p->returncode != 0) { + jam(); + ScanTabRef * ref = (ScanTabRef*)&signal->theData[0]; + ref->apiConnectPtr = apiConnectptr.p->ndbapiConnect; + ref->transId1 = apiConnectptr.p->transid[0]; + ref->transId2 = apiConnectptr.p->transid[1]; + ref->errorCode = apiConnectptr.p->returncode; + sendSignal(apiConnectptr.p->ndbapiBlockref, + GSN_SCAN_TABREF, signal, ScanTabRef::SignalLength, JBB); + } else { + jam(); + sendScanTabConf(signal); + }//if + releaseScanResources(signal); + if (apiConnectptr.p->apiFailState == ZTRUE) { + jam(); + handleApiFailState(signal, apiConnectptr.i); + return; + }//if +}//Dbtc::scanReleaseResourcesLab() + +void Dbtc::releaseScanResources(Signal* signal) +{ + if (apiConnectptr.p->cachePtr != RNIL) { + cachePtr.i = apiConnectptr.p->cachePtr; + ptrCheckGuard(cachePtr, ccacheFilesize, cacheRecord); + releaseAttrinfo(signal); + }//if + cnoFreeScanOprec = cnoFreeScanOprec + scanptr.p->noScanOprec; + scanptr.p->scanCompletedStatus = ZCLOSED; + tcConnectptr.i = scanptr.p->scanTcrec; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + releaseTcCon(signal); + for (Uint32 i = 0; i < 16; i++) { + jam(); + scanFragptr.i = scanptr.p->scanFragrec[i]; + scanptr.p->scanFragrec[i] = RNIL; + if (scanFragptr.i != RNIL) { + jam(); + ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord); + releaseScanFragrec(signal); + }//if + scanOpptr.i = scanptr.p->scanOprec[i]; + scanptr.p->scanOprec[i] = RNIL; + if (scanOpptr.i != RNIL) { + jam(); + ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord); + releaseScanOprec(signal); + }//if + }//for + releaseScanrec(signal); + apiConnectptr.p->apiScanRec = RNIL; + apiConnectptr.p->apiConnectstate = CS_CONNECTED; + setApiConTimer(apiConnectptr.i, 0, __LINE__); +}//Dbtc::releaseScanResources() + + +/****************************************************** + * execSCAN_PROCREQ + ******************************************************/ +void Dbtc::execSCAN_PROCREQ(Signal* signal) +{ + jamEntry(); + scanptr.i = signal->theData[0]; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + + const UintR tscanFragId = signal->theData[1]; + ndbrequire(tscanFragId < 16); + const UintR tscanNoOprec = signal->theData[2]; + + ndbrequire(cfirstfreeScanFragrec != RNIL); + seizeScanFragrec(signal); + + apiConnectptr.i = scanptr.p->scanApiRec; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + setApiConTimer(apiConnectptr.i, 0, __LINE__); + + scanptr.p->scanFragrec[tscanFragId] = scanFragptr.i; + scanFragptr.p->scanRec = scanptr.i; + scanFragptr.p->scanIndividual = tscanFragId * tscanNoOprec; + scanFragptr.p->scanFragProcId = tscanFragId; + scanFragptr.p->scanFragId = tscanFragId; + scanFragptr.p->scanFragConcurrency = tscanNoOprec; + scanFragptr.p->scanFragCompletedStatus = ZFALSE; + tcConnectptr.i = scanptr.p->scanTcrec; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + + { + /** + * Check table + */ + TableRecordPtr tabPtr; + tabPtr.i = scanptr.p->scanTableref; + ptrAss(tabPtr, tableRecord); + Uint32 schemaVersion = scanptr.p->scanSchemaVersion; + if(tabPtr.p->checkTable(schemaVersion) == false){ + jam(); + scanFragError(signal, tabPtr.p->getErrorCode(schemaVersion)); + return; + } + } + + signal->theData[0] = tcConnectptr.p->dihConnectptr; + signal->theData[1] = scanFragptr.i; + signal->theData[2] = scanptr.p->scanTableref; + signal->theData[3] = tscanFragId; + sendSignal(cdihblockref, GSN_DIGETPRIMREQ, signal, 4, JBB); + scanFragptr.p->scanFragState = ScanFragRec::WAIT_GET_PRIMCONF; + updateBuddyTimer(apiConnectptr); + scanFragptr.p->startFragTimer(ctcTimer); +}//Dbtc::execSCAN_PROCREQ() + +/**************************************************************** + * execDIGETPRIMCONF + * + * WE HAVE RECEIVED THE PRIMARY NODE OF THIS FRAGMENT. + * WE ARE NOW READY TO ASK FOR PERMISSION TO LOAD THIS + * SPECIFIC NODE WITH A SCAN OPERATION. + ****************************************************************/ +void Dbtc::execDIGETPRIMCONF(Signal* signal) +{ + jamEntry(); + // tcConnectptr.i in theData[0] is not used + scanFragptr.i = signal->theData[1]; + ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord); + + tnodeid = signal->theData[2]; + arrGuard(tnodeid, MAX_NDB_NODES); + + ndbrequire(scanFragptr.p->scanFragState == ScanFragRec::WAIT_GET_PRIMCONF); + scanFragptr.p->stopFragTimer(); + scanFragptr.p->lqhBlockref = RNIL; + + scanptr.i = scanFragptr.p->scanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + + { + /** + * Check table + */ + TableRecordPtr tabPtr; + tabPtr.i = scanptr.p->scanTableref; + ptrAss(tabPtr, tableRecord); + Uint32 schemaVersion = scanptr.p->scanSchemaVersion; + if(tabPtr.p->checkTable(schemaVersion) == false){ + jam(); + scanFragError(signal, tabPtr.p->getErrorCode(schemaVersion)); + return; + } + } + + tcConnectptr.i = scanptr.p->scanTcrec; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + apiConnectptr.i = scanptr.p->scanApiRec; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + cachePtr.i = apiConnectptr.p->cachePtr; + ptrCheckGuard(cachePtr, ccacheFilesize, cacheRecord); + switch (scanptr.p->scanState) { + case ScanRecord::CLOSING_SCAN: + jam(); + updateBuddyTimer(apiConnectptr); + scanFragptr.p->startFragTimer(ctcTimer); + sendScanProcConf(signal); + return; + default: + jam(); + /*empty*/; + break; + }//switch + scanFragptr.p->scanFragNodeId = tnodeid; + scanFragptr.p->lqhBlockref = calcLqhBlockRef(tnodeid); + scanFragptr.p->m_connectCount = getNodeInfo(tnodeid).m_connectCount; + sendScanFragReq(signal); + attrbufptr.i = cachePtr.p->firstAttrbuf; + while (attrbufptr.i != RNIL) { + jam(); + ptrCheckGuard(attrbufptr, cattrbufFilesize, attrbufRecord); + sendAttrinfo(signal, + scanFragptr.i, + attrbufptr.p, + scanFragptr.p->lqhBlockref); + attrbufptr.i = attrbufptr.p->attrbuf[ZINBUF_NEXT]; + }//while + scanFragptr.p->scanFragState = ScanFragRec::LQH_ACTIVE; + updateBuddyTimer(apiConnectptr); + scanFragptr.p->startFragTimer(ctcTimer); + /********************************************* + * WE HAVE NOW STARTED A FRAGMENT SCAN. NOW + * WAIT FOR THE FIRST SCANNED RECORDS + *********************************************/ +}//Dbtc::execDIGETPRIMCONF + +/*************************************************** + * execDIGETPRIMREF + * + * WE ARE NOW FORCED TO STOP THE SCAN. THIS ERROR + * IS NOT RECOVERABLE SINCE THERE IS A PROBLEM WITH + * FINDING A PRIMARY REPLICA OF A CERTAIN FRAGMENT. + ***************************************************/ +void Dbtc::execDIGETPRIMREF(Signal* signal) +{ + jamEntry(); + // tcConnectptr.i in theData[0] is not used. + scanFragptr.i = signal->theData[1]; + const Uint32 errCode = signal->theData[2]; + ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord); + ndbrequire(scanFragptr.p->scanFragState == ScanFragRec::WAIT_GET_PRIMCONF); + scanFragError(signal, errCode); +}//Dbtc::execDIGETPRIMREF() + +/** + * Dbtc::execSCAN_FRAGREF + * Our attempt to scan a fragment was refused + * set error code and close all other fragment + * scan's belonging to this scan + */ +void Dbtc::execSCAN_FRAGREF(Signal* signal) +{ + const ScanFragRef * const ref = (ScanFragRef *)&signal->theData[0]; + + jamEntry(); + const Uint32 errCode = ref->errorCode; + + scanFragptr.i = ref->senderData; + ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord); + + scanptr.i = scanFragptr.p->scanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + + apiConnectptr.i = scanptr.p->scanApiRec; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + + Uint32 transid1 = apiConnectptr.p->transid[0] ^ ref->transId1; + Uint32 transid2 = apiConnectptr.p->transid[1] ^ ref->transId2; + transid1 = transid1 | transid2; + if (transid1 != 0) { + jam(); + systemErrorLab(signal); + }//if + + /** + * Set errorcode, close connection to this lqh fragment, + * stop fragment timer and call scanFragError to start + * close of the other fragment scans + */ + scanFragptr.p->lqhBlockref = RNIL; + scanFragError(signal, errCode); +}//Dbtc::execSCAN_FRAGREF() + +/** + * Dbtc::scanFragError + * + * Called when an error occurs during + * a scan of a fragment. + * NOTE that one scan may consist of several fragment scans. + * + */ +void Dbtc::scanFragError(Signal* signal, Uint32 errorCode) +{ + jam(); + scanptr.i = scanFragptr.p->scanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + DEBUG("scanFragError, errorCode = "<< errorCode + << ", scanState = " << scanptr.p->scanState); + + scanFragptr.p->stopFragTimer(); + + apiConnectptr.i = scanptr.p->scanApiRec; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + if (scanFragptr.p->lqhBlockref == RNIL){ + // Since the lqh is closed, this scan process should be reported + // as completed immediately + jam(); + updateBuddyTimer(apiConnectptr); + scanFragptr.p->startFragTimer(ctcTimer); + sendScanProcConf(signal); + }//if + + // If close of the scan is not already started + if (scanptr.p->scanState != ScanRecord::CLOSING_SCAN) { + jam(); + apiConnectptr.p->returncode = errorCode; + + /** + * Only set apiIsClosed if API is waiting for an answer + */ + if (scanptr.p->scanState == ScanRecord::SCAN_NEXT_ORDERED){ + jam(); + scanptr.p->apiIsClosed = true; + } + scanCompletedLab(signal); + return; + }//if +}//Dbtc::scanFragError() + + +/************************************************************ + * execSCAN_FRAGCONF + * + * A NUMBER OF OPERATIONS HAVE BEEN COMPLETED IN THIS + * FRAGMENT. TAKE CARE OF AND ISSUE FURTHER ACTIONS. + ************************************************************/ +void Dbtc::execSCAN_FRAGCONF(Signal* signal) +{ + jamEntry(); + + const ScanFragConf * const conf = (ScanFragConf*)&signal->theData[0]; + const Uint32 noCompletedOps = conf->completedOps; + + for(Uint32 i = 0; iopReturnDataLen[i]; + scanFragptr.i = conf->senderData; + ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord); + + scanptr.i = scanFragptr.p->scanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + + apiConnectptr.i = scanptr.p->scanApiRec; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + + Uint32 transid1 = apiConnectptr.p->transid[0] ^ conf->transId1; + Uint32 transid2 = apiConnectptr.p->transid[1] ^ conf->transId2; + transid1 = transid1 | transid2; + if (transid1 != 0) { + jam(); + systemErrorLab(signal); + }//if + + scanFragptr.p->scanFragCompletedStatus = conf->fragmentCompleted; + scanFragptr.p->stopFragTimer(); + + switch (scanFragptr.p->scanFragCompletedStatus) { + case ZFALSE: + case ZTRUE: + jam(); + /* empty */ + break; + + case ZCLOSED: + /* The scan has finished this fragment. */ + jam(); + returnFromQueuedDeliveryLab(signal); + return; + break; + + default: + jam(); + systemErrorLab(signal); + break; + }//switch + + // CHECK THE STATE OF THE DELIVERY PROCESS TO THE APPLICATION. + switch (scanptr.p->scanState) { + case ScanRecord::SCAN_NEXT_ORDERED: + jam(); + /** + * THE APPLICATION HAVE ISSUED A SCAN_NEXTREQ AND IS WAITING + * FOR MORE OPERATIONS. SEND OPERATIONS DIRECTLY + */ + if (noCompletedOps > 0) { + jam(); + setScanReceived(signal, noCompletedOps); + sendScanTabConf(signal); + scanptr.p->scanState = ScanRecord::DELIVERED; + scanFragptr.p->scanFragState = ScanFragRec::DELIVERED; + return; + }//if + break; + + case ScanRecord::DELIVERED: + case ScanRecord::QUEUED_DELIVERED: + jam(); + /** + * THE APPLICATION HAVE ALREADY RECEIVED A DELIVERY. + * QUEUE THE RECEIVED SCAN OPERATIONS AND ISSUE THEM + * WHEN THE APPLICATION ASKS FOR MORE. + */ + if (noCompletedOps > 0) { + jam(); + setScanReceived(signal, noCompletedOps); + scanptr.p->scanState = ScanRecord::QUEUED_DELIVERED; + scanFragptr.p->scanFragState = ScanFragRec::QUEUED_FOR_DELIVERY; + return; + }//if + break; + + case ScanRecord::CLOSING_SCAN: + jam(); + /************************************************* + * WE ARE CURRENTLY CLOSING THE SCAN. + * + * WE HAVE ALREADY ORDERED THE FRAGMENT TO CLOSE ITS + * SCAN. THIS SIGNAL MUST HAVE BEEN SENT BEFORE THIS + * CLOSE SIGNAL ARRIVED. SIMPLY IGNORE THIS SIGNAL. + **************************************************/ + return; + break; + + default: + jam(); + systemErrorLab(signal); + break; + + }//switch + + /** + * THERE WAS NO TUPLES LEFT TO REPORT IN THIS FRAGMENT. CLOSE SCAN + * HAVE NOT BEEN ORDERED. WE CAN CONTINUE THE SCAN PROCESS IMMEDIATELY. + * THE COMPLETED STATUS MUST BE TRUE SINCE IT IS NOT CLOSED. IF IT WAS + * FALSE IT MUST HAVE BEEN MORE TUPLES TO SCAN AND AT LEAST ONE OF + * THOSE SHOULD HAVE BEEN REPORTED. + */ + if (scanFragptr.p->scanFragCompletedStatus == ZFALSE) { + jam(); + /** + * THE SENDING NODE IS OUT OF ORDER WE WILL KILL IT BY SENDING SYSTEM + * ERROR TO IT + */ + const BlockReference errRef = + calcNdbCntrBlockRef(scanFragptr.p->scanFragNodeId); + SystemError * const sysErr = (SystemError*)&signal->theData[0]; + sysErr->errorCode = SystemError::ScanfragStateError; + sysErr->errorRef = reference(); + sendSignal(errRef, GSN_SYSTEM_ERROR, signal, + SystemError::SignalLength, JBA); + return; + }//if + returnFromQueuedDeliveryLab(signal); +}//Dbtc::execSCAN_FRAGCONF() + +void Dbtc::returnFromQueuedDeliveryLab(Signal* signal) +{ + apiConnectptr.i = scanptr.p->scanApiRec; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + + switch(scanFragptr.p->scanFragCompletedStatus) { + case ZFALSE: + { + /********************************************************************* + * WE HAVE SENT THE SCANNED OPERATION TO THE APPLICATION AND WE HAVE + * RECEIVED THE ORDER TO CONTINUE SCANNING. THE CURRENT FRAGMENT STILL + * CONTAINS MORE TUPLES TO SCAN. + *********************************************************************/ + jam(); + scanFragptr.p->scanFragState = ScanFragRec::LQH_ACTIVE; + ScanFragNextReq * nextReq = (ScanFragNextReq*)&signal->theData[0]; + nextReq->senderData = scanFragptr.i; + nextReq->closeFlag = ZFALSE; + nextReq->transId1 = apiConnectptr.p->transid[0]; + nextReq->transId2 = apiConnectptr.p->transid[1]; + sendSignal(scanFragptr.p->lqhBlockref, GSN_SCAN_NEXTREQ, signal, + ScanFragNextReq::SignalLength, JBB); + } + break; + + case ZTRUE: + { + /********************************************************************* + * WE HAVE SENT THE SCANNED OPERATION TO THE APPLICATION AND WE HAVE + * RECEIVED THE ORDER TO CONTINUE SCANNING. THE CURRENT FRAGMENT HAVE + * BEEN COMPLETELY SCANNED AND WE ARE READY TO CLOSE IT. + *********************************************************************/ + jam(); + scanFragptr.p->scanFragState = ScanFragRec::LQH_ACTIVE_CLOSE; + ScanFragNextReq * nextReq = (ScanFragNextReq*)&signal->theData[0]; + nextReq->senderData = scanFragptr.i; + nextReq->closeFlag = ZTRUE; + nextReq->transId1 = apiConnectptr.p->transid[0]; + nextReq->transId2 = apiConnectptr.p->transid[1]; + sendSignal(scanFragptr.p->lqhBlockref, GSN_SCAN_NEXTREQ, signal, + ScanFragNextReq::SignalLength, JBB); + } + break; + + case ZCLOSED: + { + /******************************************************************** + * THE SCANNED FRAGMENT HAVE BEEN CLOSED. IF CLOSE SCAN HAVE BEEN + * ORDERED THEN WE CAN REPORT THAT THIS SCAN PROCESS IS COMPLETED. + * ALSO IF THERE ARE NO MORE FRAGMENTS TO SCAN WE CAN REPORT THAT + * THE SCAN PROCESS IS COMPLETED. + ********************************************************************/ + jam(); + scanFragptr.p->lqhBlockref = RNIL; + if ((scanptr.p->scanState != ScanRecord::CLOSING_SCAN) && + (scanptr.p->scanNextFragId < scanptr.p->scanNoFrag)){ + jam(); + scanFragptr.p->scanFragState = ScanFragRec::WAIT_GET_PRIMCONF; + tcConnectptr.i = scanptr.p->scanTcrec; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + scanFragptr.p->scanFragId = scanptr.p->scanNextFragId; + scanptr.p->scanNextFragId++; + signal->theData[0] = tcConnectptr.p->dihConnectptr; + signal->theData[1] = scanFragptr.i; + signal->theData[2] = scanptr.p->scanTableref; + signal->theData[3] = scanFragptr.p->scanFragId; + sendSignal(cdihblockref, GSN_DIGETPRIMREQ, signal, 4, JBB); + } else { + jam(); + sendScanProcConf(signal); + }//if + } + break; + + default: + jam(); + systemErrorLab(signal); + break; + }//switch + + updateBuddyTimer(apiConnectptr); + scanFragptr.p->startFragTimer(ctcTimer); +}//Dbtc::returnFromQueuedDeliveryLab() + +/********************************************************** + * execSCAN_PROCCONF + **********************************************************/ +void Dbtc::execSCAN_PROCCONF(Signal* signal) +{ + jamEntry(); + + scanptr.i = signal->theData[0]; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + scanptr.p->scanProcessesCompleted++; + ndbassert(scanptr.p->scanProcessesCompleted <= scanptr.p->scanParallel); + + scanFragptr.i = signal->theData[1]; + ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord); + scanFragptr.p->stopFragTimer(); + scanFragptr.p->scanFragState = ScanFragRec::COMPLETED; + + if (scanptr.p->scanProcessesCompleted == scanptr.p->scanParallel) { + jam(); + + // Check that all scan processes are in state COMPLETED + for (Uint32 i = 0; i < 16; i++) { + scanFragptr.i = scanptr.p->scanFragrec[i]; + if (scanFragptr.i != RNIL) { + ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord); + ndbrequire(scanFragptr.p->scanFragState == ScanFragRec::COMPLETED); + } + } + + // ALL SCAN PROCESSES HAS COMPLETED + scanptr.p->scanCompletedStatus = ZTRUE; + switch (scanptr.p->scanState) { + + case ScanRecord::CLOSING_SCAN: + jam(); + if (scanptr.p->apiIsClosed == true) { + jam(); + /* + * The API has either failed or ordered a close of this scan + * it's resources should be released and a response sent + */ + scanReleaseResourcesLab(signal); + return; + }//if + + /** + * The close have been performed but the API is still alive and not + * expecting a response, keep resources until API fails or it orders + * a close + */ + return; + case ScanRecord::SCAN_NEXT_ORDERED: + jam(); + /** + * The scan is completed and api is waiting for a response. + * Reslease resources and send a response. + */ + scanReleaseResourcesLab(signal); + return; + case ScanRecord::DELIVERED: + case ScanRecord::QUEUED_DELIVERED: + jam(); + /** + * All processes have reported completion, wait for a new request from + * API and start close of the scan then. + */ + scanptr.p->scanReceivedOperations = 0; + scanptr.p->scanState = ScanRecord::CLOSING_SCAN; + return; + default: + jam(); + systemErrorLab(signal); + break; + }//switch + } +}//Dbtc::execSCAN_PROCCONF() + + +/**************************************************************************** + * execSCAN_NEXTREQ + * + * THE APPLICATION HAVE PROCESSED THE TUPLES TRANSFERRED AND IS NOW READY FOR + * MORE. THIS SIGNAL IS ALSO USED TO CLOSE THE SCAN. + ****************************************************************************/ +void Dbtc::execSCAN_NEXTREQ(Signal* signal) +{ + const ScanNextReq * const req = (ScanNextReq *)&signal->theData[0]; + const UintR transid1 = req->transId1; + const UintR transid2 = req->transId2; + const UintR stopScan = req->stopScan; + + jamEntry(); + + apiConnectptr.i = req->apiConnectPtr; + if (apiConnectptr.i >= capiConnectFilesize) { + jam(); + warningHandlerLab(signal); + return; + }//if + ptrAss(apiConnectptr, apiConnectRecord); + + /** + * Check transid + */ + const UintR ctransid1 = apiConnectptr.p->transid[0] ^ transid1; + const UintR ctransid2 = apiConnectptr.p->transid[1] ^ transid2; + if ((ctransid1 | ctransid2) != 0){ + ScanTabRef * ref = (ScanTabRef*)&signal->theData[0]; + ref->apiConnectPtr = apiConnectptr.p->ndbapiConnect; + ref->transId1 = transid1; + ref->transId2 = transid2; + ref->errorCode = ZSTATE_ERROR; + sendSignal(signal->senderBlockRef(), GSN_SCAN_TABREF, + signal, ScanTabRef::SignalLength, JBB); + DEBUG("Wrong transid"); + return; + } + + /** + * Check state of API connection + */ + if (apiConnectptr.p->apiConnectstate != CS_START_SCAN) { + jam(); + if (apiConnectptr.p->apiConnectstate == CS_CONNECTED) { + jam(); + /********************************************************************* + * The application sends a SCAN_NEXTREQ after experiencing a time-out. + * We will send a SCAN_TABREF to indicate a time-out occurred. + *********************************************************************/ + DEBUG("scanTabRefLab: ZSCANTIME_OUT_ERROR2"); + ndbrequire(false); //B2 indication of strange things going on + scanTabRefLab(signal, ZSCANTIME_OUT_ERROR2); + return; + } + DEBUG("scanTabRefLab: ZSTATE_ERROR"); + DEBUG(" apiConnectstate="<apiConnectstate); + scanTabRefLab(signal, ZSTATE_ERROR); + return; + }//if + + /******************************************************* + * START THE ACTUAL LOGIC OF SCAN_NEXTREQ. + ********************************************************/ + // Stop the timer that is used to check for timeout in the API + setApiConTimer(apiConnectptr.i, 0, __LINE__); + scanptr.i = apiConnectptr.p->apiScanRec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + + if (scanptr.p->apiIsClosed == true) { + jam(); + /** + * The close is already started. Api has failed or + * has not responded in time so this signal is not allowed + */ + DEBUG("execSCAN_NEXTREQ: apiIsClosed == true"); + DEBUG(" apiConnectstate="<apiConnectstate); + DEBUG(" scanState="<scanState); + return; + }//if + + + if (scanptr.p->scanState == ScanRecord::CLOSING_SCAN) { + jam(); + /********************************************************************* + * WE HAVE STARTED A CLOSE OF THIS SCAN OPERATION. NOW WE CAN REPORT + * THIS TO THE APPLICATION. BEFORE WE REPORT IT TO THE APPLICATION WE + * MUST COMPLETE THE CLOSE FIRST. + *********************************************************************/ + if (scanptr.p->scanCompletedStatus == ZTRUE) { + jam(); + /********************************************************************* + * THE SCAN IS ALREADY COMPLETED. WE ARE NOW READY TO COMPLETE THE SCAN + * BY RELEASING ALL RESOURCES AND SENDING THE CONFIRMATION TO THE + * APPLICATION. + *********************************************************************/ + scanReleaseResourcesLab(signal); + return; + } else { + jam(); + /********************************************************************* + * THE CLOSE IS ONGOING BUT NOT YET COMPLETED. WE WILL SET THE STATE + * TO INDICATE THAT THE APPLICATION IS WAITING FOR THE RESPONSE. + *********************************************************************/ + scanptr.p->apiIsClosed = true; + return; + }//if + }//if + + if (stopScan == ZTRUE) { + jam(); + /********************************************************************* + * APPLICATION IS CLOSING THE SCAN. + **********************************************************************/ + scanptr.p->apiIsClosed = true; + scanCompletedLab(signal); + return; + }//if + + /********************************************************************* + * THOSE SCAN PROCESSES THAT WAS SENT IN PREVIOUS MESSAGE ARE + * ACKNOWLEDGED BY THIS REQUEST FOR MORE SCANNED OPERATIONS. WE CAN + * THUS RESTART THOSE SCAN PROCESSES. + *********************************************************************/ + for (Uint32 i = 0; i < 16; i++) { + jam(); + scanFragptr.i = scanptr.p->scanFragrec[i]; + if (scanFragptr.i != RNIL) { + jam(); + ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord); + if (scanFragptr.p->scanFragState == ScanFragRec::DELIVERED) { + jam(); + scanFragptr.p->scanFragState = ScanFragRec::RETURNING_FROM_DELIVERY; + signal->theData[0] = TcContinueB::ZRETURN_FROM_QUEUED_DELIVERY; + signal->theData[1] = scanptr.i; + signal->theData[2] = scanFragptr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB); + } + }//if + }//for + + switch (scanptr.p->scanState) { + case ScanRecord::QUEUED_DELIVERED: + /********************************************************************* + * A NUMBER OF SCAN PROCESSES ARE READY TO DELIVER. DELIVER AND SET + * STATE TO DELIVERED. ALSO CONTINUE PROCESS QUEUED SCAN PROCESSES. + *********************************************************************/ + jam(); + sendScanTabConf(signal); + scanptr.p->scanState = ScanRecord::DELIVERED; + /********************************************************************* + * UPDATE STATUS OF THE SCAN PROCESSES THAT WAS NOW SENT TO THE + * APPLICATION TO DELIVERED. PREVIOUSLY THEY WERE QUEUED FOR DELIVERY. + *********************************************************************/ + for (Uint32 i = 0; i < 16; i++) { + jam(); + scanFragptr.i = scanptr.p->scanFragrec[i]; + if (scanFragptr.i != RNIL) { + ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord); + if (scanFragptr.p->scanFragState == ScanFragRec::QUEUED_FOR_DELIVERY) { + jam(); + scanFragptr.p->scanFragState = ScanFragRec::DELIVERED; + }//if + }//if + }//for + return; + case ScanRecord::DELIVERED: + jam(); + /********************************************************************* + * WE HAVE NOT ANY QUEUED DELIVERIES. SET STATE TO INDICATE IT IS OK + * TO SEND SCAN_TABCONF AS SOON AS ANY FRAGMENT IS READY TO DELIVER. + *********************************************************************/ + scanptr.p->scanState = ScanRecord::SCAN_NEXT_ORDERED; + return; + case ScanRecord::SCAN_NEXT_ORDERED: + jam(); + /* empty */ + return; + default: + jam(); + systemErrorLab(signal); + return; + }//switch +}//Dbtc::execSCAN_NEXTREQ() + +void Dbtc::scanCompletedLab(Signal* signal) { + scanptr.p->scanReceivedOperations = 0; + scanptr.p->scanState = ScanRecord::CLOSING_SCAN; + + // Iterate over all fragment scans and check if + // they need to be closed in LQH + for (Uint32 i = 0; i < 16; i++) { + if (scanptr.p->scanFragrec[i] == RNIL) { + jam(); + continue; + } + scanFragptr.i = scanptr.p->scanFragrec[i]; + ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord); + + if (scanFragptr.p->lqhBlockref == RNIL){ + // The connection to this LQH has been closed + jam(); + continue; + } + + if (scanFragptr.p->scanFragCompletedStatus == ZCLOSED){ + // The fragment scan is already completed + jam(); + continue; + } + + if (scanFragptr.p->scanFragState == ScanFragRec::RETURNING_FROM_DELIVERY){ + // The scan process is soon to continue executing + // Set scanFragCompletedStatus to ZTRUE so that LQH is properly closed + // when this scan process "returns from delivery" + jam(); + DEBUG("scanCompletedLab: setting scanFragCompletedStatus to ZTRUE"); + scanFragptr.p->scanFragCompletedStatus = ZTRUE; + continue; + } + + apiConnectptr.i = scanptr.p->scanApiRec; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + + ScanFragNextReq * nextReq = (ScanFragNextReq*)&signal->theData[0]; + nextReq->senderData = scanFragptr.i; + nextReq->closeFlag = ZTRUE; + nextReq->transId1 = apiConnectptr.p->transid[0]; + nextReq->transId2 = apiConnectptr.p->transid[1]; + sendSignal(scanFragptr.p->lqhBlockref, GSN_SCAN_NEXTREQ, signal, + ScanFragNextReq::SignalLength, JBB); + updateBuddyTimer(apiConnectptr); + + updateBuddyTimer(apiConnectptr); + scanFragptr.p->startFragTimer(ctcTimer); + scanFragptr.p->scanFragState = ScanFragRec::LQH_ACTIVE_CLOSE; + + }//for +}//Dbtc::scanCompletedLab() + +void Dbtc::sendScanProcConf(Signal* signal){ + signal->theData[0] = scanptr.i; + signal->theData[1] = scanFragptr.i; + sendSignal(cownref, GSN_SCAN_PROCCONF, signal, 2, JBB); +} + +void Dbtc::releaseScanrec(Signal* signal) { + scanptr.p->nextScan = cfirstfreeScanrec; + scanptr.p->scanState = ScanRecord::IDLE; + scanptr.p->scanTcrec = RNIL; + cfirstfreeScanrec = scanptr.i; +}//Dbtc::releaseScanrec() + +void Dbtc::releaseScanFragrec(Signal* signal) { + scanFragptr.p->nextScanFrag = cfirstfreeScanFragrec; + scanFragptr.p->scanFragState = ScanFragRec::IDLE; + cfirstfreeScanFragrec = scanFragptr.i; + scanFragptr.p->stopFragTimer(); +}//Dbtc::releaseScanFragrec() + +void Dbtc::releaseScanOprec(Signal* signal) { + scanOpptr.p->nextScanOp = cfirstfreeScanOprec; + cfirstfreeScanOprec = scanOpptr.i; +}//Dbtc::releaseScanOprec() + +void Dbtc::seizeScanrec(Signal* signal) { + scanptr.i = cfirstfreeScanrec; + ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord); + cfirstfreeScanrec = scanptr.p->nextScan; + scanptr.p->nextScan = RNIL; + ndbrequire(scanptr.p->scanState == ScanRecord::IDLE); +}//Dbtc::seizeScanrec() + +void Dbtc::seizeScanFragrec(Signal* signal) { + scanFragptr.i = cfirstfreeScanFragrec; + ptrCheckGuard(scanFragptr, cscanFragrecFileSize, scanFragmentRecord); + cfirstfreeScanFragrec = scanFragptr.p->nextScanFrag; + scanFragptr.p->nextScanFrag = RNIL; + ndbrequire(scanFragptr.p->scanFragState == ScanFragRec::IDLE); +}//Dbtc::seizeScanFragrec() + +void Dbtc::seizeScanOprec(Signal* signal) { + scanOpptr.i = cfirstfreeScanOprec; + ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord); + cfirstfreeScanOprec = scanOpptr.p->nextScanOp; + scanOpptr.p->nextScanOp = RNIL; +}//Dbtc::seizeScanOprec() + + +void Dbtc::sendScanFragReq(Signal* signal) { + arrGuard(scanFragptr.p->scanFragProcId, 16); + scanOpptr.i = scanptr.p->scanOprec[scanFragptr.p->scanFragProcId]; + ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord); + + Uint32 requestInfo = 0; + ScanFragReq::setConcurrency(requestInfo, scanFragptr.p->scanFragConcurrency); + ScanFragReq::setLockMode(requestInfo, scanptr.p->scanLockMode); + ScanFragReq::setHoldLockFlag(requestInfo, scanptr.p->scanLockHold); + if(scanptr.p->scanLockMode == 1){ // Not read -> keyinfo + jam(); + ScanFragReq::setKeyinfoFlag(requestInfo, 1); + } + ScanFragReq::setReadCommittedFlag(requestInfo, scanptr.p->readCommitted); + ScanFragReq::setRangeScanFlag(requestInfo, scanptr.p->rangeScan); + ScanFragReq::setAttrLen(requestInfo, scanptr.p->scanAiLength); + apiConnectptr.i = scanptr.p->scanApiRec; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + ScanFragReq * const req = (ScanFragReq *)&signal->theData[0]; + req->senderData = scanFragptr.i; + req->resultRef = apiConnectptr.p->ndbapiBlockref; + req->requestInfo = requestInfo; + req->savePointId = apiConnectptr.p->currSavePointId; + req->tableId = scanptr.p->scanTableref; + req->fragmentNo = scanFragptr.p->scanFragId; + req->schemaVersion = scanptr.p->scanSchemaVersion; + req->transId1 = apiConnectptr.p->transid[0]; + req->transId2 = apiConnectptr.p->transid[1]; + for(int i = 0; i<16; i++){ + req->clientOpPtr[i] = scanOpptr.p->apiOpptr[i]; + } + sendSignal(scanFragptr.p->lqhBlockref, GSN_SCAN_FRAGREQ, signal, 25, JBB); + updateBuddyTimer(apiConnectptr); + scanFragptr.p->startFragTimer(ctcTimer); + scanFragptr.p->scanFragCompletedStatus = ZFALSE; + +}//Dbtc::sendScanFragReq() + + +void Dbtc::sendScanTabConf(Signal* signal) { + jam(); + /******************************************************* + * Send SCAN_TABINFO with information about all + * received operations + *******************************************************/ + Int32 operationsToSend = scanptr.p->scanReceivedOperations; + Uint32 sstOpIndex = 0; + + while (operationsToSend > 0){ + jam(); + + ScanTabInfo * info = (ScanTabInfo*)&signal->theData[0]; + info->apiConnectPtr = apiConnectptr.p->ndbapiConnect; + + for (int i = 0; i < 16; i++){ + jam(); + arrGuard(sstOpIndex, 16); + scanOpptr.i = scanptr.p->scanOprec[sstOpIndex]; + ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord); + info->operLenAndIdx[i] = scanOpptr.p->scanOpLength[i]; + operationsToSend--; + scanOpptr.p->scanOpLength[i] = RNIL; + } + sstOpIndex++; + sendSignal(apiConnectptr.p->ndbapiBlockref, + GSN_SCAN_TABINFO, signal, ScanTabInfo::SignalLength, JBB); + } + + /******************************************************** + * Send SCAN_TABCONF signaling that a result set have + * been sent to the API + *********************************************************/ + Uint32 requestInfo = 0; + ScanTabConf::setOperations(requestInfo, scanptr.p->scanReceivedOperations); + ScanTabConf::setScanStatus(requestInfo, scanptr.p->scanCompletedStatus); + + ScanTabConf * conf = (ScanTabConf*)&signal->theData[0]; + conf->apiConnectPtr = apiConnectptr.p->ndbapiConnect; + conf->requestInfo = requestInfo; + conf->transId1 = apiConnectptr.p->transid[0]; + conf->transId2 = apiConnectptr.p->transid[1]; + sendSignal(apiConnectptr.p->ndbapiBlockref, + GSN_SCAN_TABCONF, signal, ScanTabConf::SignalLength, JBB); + + scanptr.p->scanReceivedOperations = 0; + // Start the scanRec-timer again and wait for response from the API. + setApiConTimer(apiConnectptr.i, ctcTimer, __LINE__); + updateBuddyTimer(apiConnectptr); +}//Dbtc::sendScanTabConf() + + +/* + * Write index and length of all operations received into + * scanOprec->scanOpLength buffer + */ +void Dbtc::setScanReceived(Signal* signal, Uint32 noCompletedOps) +{ + UintR tssrIndividual; + UintR tssrOprecIndex; + UintR tssrLengthPlusIndex; + UintR tssrOpIndex; + + ndbrequire(noCompletedOps <= 16); + tssrIndividual = scanFragptr.p->scanIndividual; + for (Uint32 i = 0; i < noCompletedOps; i++) { + jam(); + tssrOprecIndex = scanptr.p->scanReceivedOperations >> 4; + arrGuard(tssrOprecIndex, 16); + scanOpptr.i = scanptr.p->scanOprec[tssrOprecIndex]; + ptrCheckGuard(scanOpptr, cscanOprecFileSize, scanOperationRecord); + tssrLengthPlusIndex = tssrIndividual << 24; + tssrLengthPlusIndex += cdata[i]; + tssrOpIndex = scanptr.p->scanReceivedOperations & 15; + scanOpptr.p->scanOpLength[tssrOpIndex] = tssrLengthPlusIndex; + scanptr.p->scanReceivedOperations++; + tssrIndividual++; + }//for +}//Dbtc::setScanReceived() + +void Dbtc::gcpTcfinished(Signal* signal) +{ + signal->theData[1] = tcheckGcpId; + sendSignal(cdihblockref, GSN_GCP_TCFINISHED, signal, 2, JBB); +}//Dbtc::gcpTcfinished() + +void Dbtc::initApiConnect(Signal* signal) +{ + Uint32 tiacTmp; + Uint32 guard4; + + tiacTmp = capiConnectFilesize / 3; + ndbrequire(tiacTmp > 0); + guard4 = tiacTmp + 1; + for (cachePtr.i = 0; cachePtr.i < guard4; cachePtr.i++) { + ptrAss(cachePtr, cacheRecord); + cachePtr.p->firstAttrbuf = RNIL; + cachePtr.p->lastAttrbuf = RNIL; + cachePtr.p->firstKeybuf = RNIL; + cachePtr.p->lastKeybuf = RNIL; + cachePtr.p->nextCacheRec = cachePtr.i + 1; + }//for + cachePtr.i = tiacTmp; + ptrCheckGuard(cachePtr, ccacheFilesize, cacheRecord); + cachePtr.p->nextCacheRec = RNIL; + cfirstfreeCacheRec = 0; + + guard4 = tiacTmp - 1; + for (apiConnectptr.i = 0; apiConnectptr.i <= guard4; apiConnectptr.i++) { + jam(); + ptrAss(apiConnectptr, apiConnectRecord); + apiConnectptr.p->apiConnectstate = CS_DISCONNECTED; + apiConnectptr.p->apiFailState = ZFALSE; + setApiConTimer(apiConnectptr.i, 0, __LINE__); + apiConnectptr.p->takeOverRec = (Uint8)Z8NIL; + apiConnectptr.p->cachePtr = RNIL; + apiConnectptr.p->nextApiConnect = apiConnectptr.i + 1; + apiConnectptr.p->ndbapiBlockref = 0xFFFFFFFF; // Invalid ref + apiConnectptr.p->commitAckMarker = RNIL; + apiConnectptr.p->firstTcConnect = RNIL; + apiConnectptr.p->triggerPending = false; + apiConnectptr.p->isIndexOp = false; + apiConnectptr.p->accumulatingIndexOp = RNIL; + apiConnectptr.p->executingIndexOp = RNIL; + apiConnectptr.p->buddyPtr = RNIL; + apiConnectptr.p->currSavePointId = 0; + }//for + apiConnectptr.i = tiacTmp - 1; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + apiConnectptr.p->nextApiConnect = RNIL; + cfirstfreeApiConnect = 0; + guard4 = (2 * tiacTmp) - 1; + for (apiConnectptr.i = tiacTmp; apiConnectptr.i <= guard4; apiConnectptr.i++) + { + jam(); + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + apiConnectptr.p->apiConnectstate = CS_RESTART; + apiConnectptr.p->apiFailState = ZFALSE; + setApiConTimer(apiConnectptr.i, 0, __LINE__); + apiConnectptr.p->takeOverRec = (Uint8)Z8NIL; + apiConnectptr.p->cachePtr = RNIL; + apiConnectptr.p->nextApiConnect = apiConnectptr.i + 1; + apiConnectptr.p->ndbapiBlockref = 0xFFFFFFFF; // Invalid ref + apiConnectptr.p->commitAckMarker = RNIL; + apiConnectptr.p->firstTcConnect = RNIL; + apiConnectptr.p->triggerPending = false; + apiConnectptr.p->isIndexOp = false; + apiConnectptr.p->accumulatingIndexOp = RNIL; + apiConnectptr.p->executingIndexOp = RNIL; + apiConnectptr.p->buddyPtr = RNIL; + apiConnectptr.p->currSavePointId = 0; + }//for + apiConnectptr.i = (2 * tiacTmp) - 1; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + apiConnectptr.p->nextApiConnect = RNIL; + cfirstfreeApiConnectCopy = tiacTmp; + guard4 = (3 * tiacTmp) - 1; + for (apiConnectptr.i = 2 * tiacTmp; apiConnectptr.i <= guard4; + apiConnectptr.i++) { + jam(); + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + setApiConTimer(apiConnectptr.i, 0, __LINE__); + apiConnectptr.p->apiFailState = ZFALSE; + apiConnectptr.p->apiConnectstate = CS_RESTART; + apiConnectptr.p->takeOverRec = (Uint8)Z8NIL; + apiConnectptr.p->cachePtr = RNIL; + apiConnectptr.p->nextApiConnect = apiConnectptr.i + 1; + apiConnectptr.p->ndbapiBlockref = 0xFFFFFFFF; // Invalid ref + apiConnectptr.p->commitAckMarker = RNIL; + apiConnectptr.p->firstTcConnect = RNIL; + apiConnectptr.p->triggerPending = false; + apiConnectptr.p->isIndexOp = false; + apiConnectptr.p->accumulatingIndexOp = RNIL; + apiConnectptr.p->executingIndexOp = RNIL; + apiConnectptr.p->buddyPtr = RNIL; + apiConnectptr.p->currSavePointId = 0; + }//for + apiConnectptr.i = (3 * tiacTmp) - 1; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + apiConnectptr.p->nextApiConnect = RNIL; + cfirstfreeApiConnectFail = 2 * tiacTmp; +}//Dbtc::initApiConnect() + +void Dbtc::initattrbuf(Signal* signal) +{ + ndbrequire(cattrbufFilesize > 0); + for (attrbufptr.i = 0; attrbufptr.i < cattrbufFilesize; attrbufptr.i++) { + jam(); + ptrAss(attrbufptr, attrbufRecord); + attrbufptr.p->attrbuf[ZINBUF_NEXT] = attrbufptr.i + 1; /* NEXT ATTRBUF */ + }//for + attrbufptr.i = cattrbufFilesize - 1; + ptrAss(attrbufptr, attrbufRecord); + attrbufptr.p->attrbuf[ZINBUF_NEXT] = RNIL; /* NEXT ATTRBUF */ + cfirstfreeAttrbuf = 0; +}//Dbtc::initattrbuf() + +void Dbtc::initdatabuf(Signal* signal) +{ + ndbrequire(cdatabufFilesize > 0); + for (databufptr.i = 0; databufptr.i < cdatabufFilesize; databufptr.i++) { + ptrAss(databufptr, databufRecord); + databufptr.p->nextDatabuf = databufptr.i + 1; + }//for + databufptr.i = cdatabufFilesize - 1; + ptrCheckGuard(databufptr, cdatabufFilesize, databufRecord); + databufptr.p->nextDatabuf = RNIL; + cfirstfreeDatabuf = 0; +}//Dbtc::initdatabuf() + +void Dbtc::initgcp(Signal* signal) +{ + ndbrequire(cgcpFilesize > 0); + for (gcpPtr.i = 0; gcpPtr.i < cgcpFilesize; gcpPtr.i++) { + ptrAss(gcpPtr, gcpRecord); + gcpPtr.p->nextGcp = gcpPtr.i + 1; + }//for + gcpPtr.i = cgcpFilesize - 1; + ptrCheckGuard(gcpPtr, cgcpFilesize, gcpRecord); + gcpPtr.p->nextGcp = RNIL; + cfirstfreeGcp = 0; + cfirstgcp = RNIL; + clastgcp = RNIL; +}//Dbtc::initgcp() + +void Dbtc::inithost(Signal* signal) +{ + cpackedListIndex = 0; + ndbrequire(chostFilesize > 0); + for (hostptr.i = 0; hostptr.i < chostFilesize; hostptr.i++) { + jam(); + ptrAss(hostptr, hostRecord); + hostptr.p->hostStatus = HS_DEAD; + hostptr.p->inPackedList = false; + hostptr.p->takeOverStatus = TOS_NOT_DEFINED; + hostptr.p->lqhTransStatus = LTS_IDLE; + hostptr.p->ndbVersion = ZNIL; + hostptr.p->noOfWordsTCKEYCONF = 0; + hostptr.p->noOfWordsTCINDXCONF = 0; + hostptr.p->noOfPackedWordsLqh = 0; + hostptr.p->hostLqhBlockRef = calcLqhBlockRef(hostptr.i); + }//for +}//Dbtc::inithost() + +void Dbtc::initialiseRecordsLab(Signal* signal, UintR Tdata0) +{ + switch (Tdata0) { + case 0: + jam(); + initApiConnect(signal); + break; + case 1: + jam(); + initattrbuf(signal); + break; + case 2: + jam(); + initdatabuf(signal); + break; + case 3: + jam(); + initgcp(signal); + break; + case 4: + jam(); + inithost(signal); + break; + case 5: + jam(); + // UNUSED Free to initialise something + break; + case 6: + jam(); + initTable(signal); + break; + case 7: + jam(); + initialiseScanrec(signal); + break; + case 8: + jam(); + initialiseScanOprec(signal); + break; + case 9: + jam(); + initialiseScanFragrec(signal); + break; + case 10: + jam(); + initialiseTcConnect(signal); + break; + case 11: + jam(); + initTcFail(signal); + returnInitialiseRecordsLab(signal); + return; + break; + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch + sendInitialiseRecords(signal, (Tdata0 + 1)); + return; +}//Dbtc::initialiseRecordsLab() + +void Dbtc::initialiseScanrec(Signal* signal) +{ + ndbrequire(cscanrecFileSize > 0); + for (scanptr.i = 0; scanptr.i < cscanrecFileSize; scanptr.i++) { + jam(); + ptrAss(scanptr, scanRecord); + scanptr.p->scanState = ScanRecord::IDLE; + scanptr.p->nextScan = scanptr.i + 1; + }//for + scanptr.i = cscanrecFileSize - 1; + ptrAss(scanptr, scanRecord); + scanptr.p->nextScan = RNIL; + cfirstfreeScanrec = 0; +}//Dbtc::initialiseScanrec() + +void Dbtc::initialiseScanFragrec(Signal* signal) +{ + ndbrequire(cscanFragrecFileSize > 0); + for (scanFragptr.i = 0; scanFragptr.i < cscanFragrecFileSize; + scanFragptr.i++) { + jam(); + ptrAss(scanFragptr, scanFragmentRecord); + scanFragptr.p->scanFragState = ScanFragRec::IDLE; + scanFragptr.p->stopFragTimer(); + scanFragptr.p->nextScanFrag = scanFragptr.i + 1; + }//for + scanFragptr.i = cscanFragrecFileSize - 1; + ptrAss(scanFragptr, scanFragmentRecord); + scanFragptr.p->nextScanFrag = RNIL; + cfirstfreeScanFragrec = 0; +}//Dbtc::initialiseScanFragrec() + +void Dbtc::initialiseScanOprec(Signal* signal) +{ + ndbrequire(cscanOprecFileSize > 0); + for (scanOpptr.i = 0; scanOpptr.i < cscanOprecFileSize; scanOpptr.i++) { + jam(); + ptrAss(scanOpptr, scanOperationRecord); + scanOpptr.p->nextScanOp = scanOpptr.i + 1; + }//for + scanOpptr.i = cscanOprecFileSize - 1; + ptrAss(scanOpptr, scanOperationRecord); + scanOpptr.p->nextScanOp = RNIL; + cfirstfreeScanOprec = 0; + cnoFreeScanOprec = cscanOprecFileSize; +}//Dbtc::initialiseScanOprec() + +void Dbtc::initTable(Signal* signal) +{ + + ndbrequire(ctabrecFilesize > 0); + for (tabptr.i = 0; tabptr.i < ctabrecFilesize; tabptr.i++) { + ptrAss(tabptr, tableRecord); + tabptr.p->currentSchemaVersion = 0; + tabptr.p->storedTable = true; + tabptr.p->tableType = 0; + tabptr.p->enabled = false; + tabptr.p->dropping = false; + }//for +}//Dbtc::initTable() + +void Dbtc::initialiseTcConnect(Signal* signal) +{ + ndbrequire(ctcConnectFilesize >= 2); + + // Place half of tcConnectptr's in cfirstfreeTcConnectFail list + Uint32 titcTmp = ctcConnectFilesize / 2; + for (tcConnectptr.i = 0; tcConnectptr.i < titcTmp; tcConnectptr.i++) { + jam(); + ptrAss(tcConnectptr, tcConnectRecord); + tcConnectptr.p->tcConnectstate = OS_RESTART; + tcConnectptr.p->apiConnect = RNIL; + tcConnectptr.p->noOfNodes = 0; + tcConnectptr.p->nextTcConnect = tcConnectptr.i + 1; + }//for + tcConnectptr.i = titcTmp - 1; + ptrAss(tcConnectptr, tcConnectRecord); + tcConnectptr.p->nextTcConnect = RNIL; + cfirstfreeTcConnectFail = 0; + + // Place other half in cfirstfreeTcConnect list + for (tcConnectptr.i = titcTmp; tcConnectptr.i < ctcConnectFilesize; + tcConnectptr.i++) { + jam(); + ptrAss(tcConnectptr, tcConnectRecord); + tcConnectptr.p->tcConnectstate = OS_RESTART; + tcConnectptr.p->apiConnect = RNIL; + tcConnectptr.p->noOfNodes = 0; + tcConnectptr.p->nextTcConnect = tcConnectptr.i + 1; + }//for + tcConnectptr.i = ctcConnectFilesize - 1; + ptrAss(tcConnectptr, tcConnectRecord); + tcConnectptr.p->nextTcConnect = RNIL; + cfirstfreeTcConnect = titcTmp; + cconcurrentOp = 0; +}//Dbtc::initialiseTcConnect() + +/* ------------------------------------------------------------------------- */ +/* ---- LINK A GLOBAL CHECKPOINT RECORD INTO THE LIST WITH TRANSACTIONS */ +/* WAITING FOR COMPLETION. */ +/* ------------------------------------------------------------------------- */ +void Dbtc::linkGciInGcilist(Signal* signal) +{ + GcpRecordPtr tmpGcpPointer; + if (cfirstgcp == RNIL) { + jam(); + cfirstgcp = gcpPtr.i; + } else { + jam(); + tmpGcpPointer.i = clastgcp; + ptrCheckGuard(tmpGcpPointer, cgcpFilesize, gcpRecord); + tmpGcpPointer.p->nextGcp = gcpPtr.i; + }//if + clastgcp = gcpPtr.i; +}//Dbtc::linkGciInGcilist() + +/* ------------------------------------------------------------------------- */ +/* ------- LINK SECONDARY KEY BUFFER IN OPERATION RECORD ------- */ +/* ------------------------------------------------------------------------- */ +void Dbtc::linkKeybuf(Signal* signal) +{ + seizeDatabuf(signal); + tmpDatabufptr.i = cachePtr.p->lastKeybuf; + cachePtr.p->lastKeybuf = databufptr.i; + if (tmpDatabufptr.i == RNIL) { + jam(); + cachePtr.p->firstKeybuf = databufptr.i; + } else { + jam(); + ptrCheckGuard(tmpDatabufptr, cdatabufFilesize, databufRecord); + tmpDatabufptr.p->nextDatabuf = databufptr.i; + }//if +}//Dbtc::linkKeybuf() + +/* ------------------------------------------------------------------------- */ +/* ------- LINK A TC CONNECT RECORD INTO THE API LIST OF TC CONNECTIONS --- */ +/* ------------------------------------------------------------------------- */ +void Dbtc::linkTcInConnectionlist(Signal* signal) +{ + /* POINTER FOR THE CONNECT_RECORD */ + TcConnectRecordPtr ltcTcConnectptr; + + tcConnectptr.p->nextTcConnect = RNIL; + ltcTcConnectptr.i = apiConnectptr.p->lastTcConnect; + ptrCheck(ltcTcConnectptr, ctcConnectFilesize, tcConnectRecord); + apiConnectptr.p->lastTcConnect = tcConnectptr.i; + if (ltcTcConnectptr.i == RNIL) { + jam(); + apiConnectptr.p->firstTcConnect = tcConnectptr.i; + } else { + jam(); + ptrGuard(ltcTcConnectptr); + ltcTcConnectptr.p->nextTcConnect = tcConnectptr.i; + }//if +}//Dbtc::linkTcInConnectionlist() + +/*---------------------------------------------------------------------------*/ +/* RELEASE_ABORT_RESOURCES */ +/* THIS CODE RELEASES ALL RESOURCES AFTER AN ABORT OF A TRANSACTION AND ALSO */ +/* SENDS THE ABORT DECISION TO THE APPLICATION. */ +/*---------------------------------------------------------------------------*/ +void Dbtc::releaseAbortResources(Signal* signal) +{ + TcConnectRecordPtr rarTcConnectptr; + + cabortCount++; + if (apiConnectptr.p->cachePtr != RNIL) { + cachePtr.i = apiConnectptr.p->cachePtr; + ptrCheckGuard(cachePtr, ccacheFilesize, cacheRecord); + releaseAttrinfo(signal); + releaseKeys(signal); + }//if + tcConnectptr.i = apiConnectptr.p->firstTcConnect; + while (tcConnectptr.i != RNIL) { + jam(); + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + // Clear any markers that were set in CS_RECEIVING state + clearCommitAckMarker(apiConnectptr.p, tcConnectptr.p); + rarTcConnectptr.i = tcConnectptr.p->nextTcConnect; + releaseTcCon(signal); + tcConnectptr.i = rarTcConnectptr.i; + }//while + apiConnectptr.p->firstTcConnect = RNIL; + apiConnectptr.p->lastTcConnect = RNIL; + + // MASV let state be CS_ABORTING until all + // signals in the "air" have been received. Reset to CS_CONNECTED + // will be done when a TCKEYREQ with start flag is recieved + // or releaseApiCon is called + // apiConnectptr.p->apiConnectstate = CS_CONNECTED; + apiConnectptr.p->apiConnectstate = CS_ABORTING; + apiConnectptr.p->abortState = AS_IDLE; + + bool ok = false; + Uint32 blockRef = apiConnectptr.p->ndbapiBlockref; + switch(apiConnectptr.p->returnsignal){ + case RS_TCROLLBACKCONF: + jam(); + ok = true; + signal->theData[0] = apiConnectptr.p->ndbapiConnect; + signal->theData[1] = apiConnectptr.p->transid[0]; + signal->theData[2] = apiConnectptr.p->transid[1]; + sendSignal(blockRef, GSN_TCROLLBACKCONF, signal, 3, JBB); + break; + case RS_TCROLLBACKREP:{ + jam(); + ok = true; + TcRollbackRep * const tcRollbackRep = + (TcRollbackRep *) signal->getDataPtr(); + + tcRollbackRep->connectPtr = apiConnectptr.p->ndbapiConnect; + tcRollbackRep->transId[0] = apiConnectptr.p->transid[0]; + tcRollbackRep->transId[1] = apiConnectptr.p->transid[1]; + tcRollbackRep->returnCode = apiConnectptr.p->returncode; + sendSignal(blockRef, GSN_TCROLLBACKREP, signal, + TcRollbackRep::SignalLength, JBB); + } + break; + case RS_NO_RETURN: + jam(); + ok = true; + break; + case RS_TCKEYCONF: + case RS_TCKEYREF: + case RS_TC_COMMITCONF: + break; + } + if(!ok){ + jam(); + ndbout_c("returnsignal = %d", apiConnectptr.p->returnsignal); + sendSystemError(signal); + }//if + + setApiConTimer(apiConnectptr.i, 0, __LINE__); + apiConnectptr.p->abortState = AS_IDLE; + if (apiConnectptr.p->apiFailState == ZTRUE) { + jam(); + handleApiFailState(signal, apiConnectptr.i); + return; + }//if +}//Dbtc::releaseAbortResources() + +void Dbtc::releaseApiCon(Signal* signal, UintR TapiConnectPtr) +{ + ApiConnectRecordPtr TlocalApiConnectptr; + + TlocalApiConnectptr.i = TapiConnectPtr; + ptrCheckGuard(TlocalApiConnectptr, capiConnectFilesize, apiConnectRecord); + TlocalApiConnectptr.p->nextApiConnect = cfirstfreeApiConnect; + cfirstfreeApiConnect = TlocalApiConnectptr.i; + setApiConTimer(TlocalApiConnectptr.i, 0, __LINE__); + TlocalApiConnectptr.p->apiConnectstate = CS_DISCONNECTED; +}//Dbtc::releaseApiCon() + +void Dbtc::releaseApiConnectFail(Signal* signal) +{ + apiConnectptr.p->apiConnectstate = CS_RESTART; + apiConnectptr.p->takeOverRec = (Uint8)Z8NIL; + setApiConTimer(apiConnectptr.i, 0, __LINE__); + apiConnectptr.p->nextApiConnect = cfirstfreeApiConnectFail; + cfirstfreeApiConnectFail = apiConnectptr.i; +}//Dbtc::releaseApiConnectFail() + +void Dbtc::releaseGcp(Signal* signal) +{ + ptrGuard(gcpPtr); + gcpPtr.p->nextGcp = cfirstfreeGcp; + cfirstfreeGcp = gcpPtr.i; +}//Dbtc::releaseGcp() + +void Dbtc::releaseKeys(Signal* signal) +{ + UintR Tmp; + databufptr.i = cachePtr.p->firstKeybuf; + while (databufptr.i != RNIL) { + jam(); + ptrCheckGuard(databufptr, cdatabufFilesize, databufRecord); + Tmp = databufptr.p->nextDatabuf; + databufptr.p->nextDatabuf = cfirstfreeDatabuf; + cfirstfreeDatabuf = databufptr.i; + databufptr.i = Tmp; + }//while + cachePtr.p->firstKeybuf = RNIL; + cachePtr.p->lastKeybuf = RNIL; +}//Dbtc::releaseKeys() + +void Dbtc::releaseTcConnectFail(Signal* signal) +{ + ptrGuard(tcConnectptr); + tcConnectptr.p->nextTcConnect = cfirstfreeTcConnectFail; + cfirstfreeTcConnectFail = tcConnectptr.i; +}//Dbtc::releaseTcConnectFail() + +void Dbtc::seizeApiConnect(Signal* signal) +{ + if (cfirstfreeApiConnect != RNIL) { + jam(); + terrorCode = ZOK; + apiConnectptr.i = cfirstfreeApiConnect; /* ASSIGN A FREE RECORD FROM */ + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + cfirstfreeApiConnect = apiConnectptr.p->nextApiConnect; + apiConnectptr.p->nextApiConnect = RNIL; + setApiConTimer(apiConnectptr.i, 0, __LINE__); + apiConnectptr.p->apiConnectstate = CS_CONNECTED; /* STATE OF CONNECTION */ + } else { + jam(); + terrorCode = ZNO_FREE_API_CONNECTION; + }//if + apiConnectptr.p->triggerPending = false; + apiConnectptr.p->isIndexOp = false; +}//Dbtc::seizeApiConnect() + +void Dbtc::seizeApiConnectFail(Signal* signal) +{ + apiConnectptr.i = cfirstfreeApiConnectFail; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + cfirstfreeApiConnectFail = apiConnectptr.p->nextApiConnect; +}//Dbtc::seizeApiConnectFail() + +void Dbtc::seizeDatabuf(Signal* signal) +{ + databufptr.i = cfirstfreeDatabuf; + ptrCheckGuard(databufptr, cdatabufFilesize, databufRecord); + cfirstfreeDatabuf = databufptr.p->nextDatabuf; + databufptr.p->nextDatabuf = RNIL; +}//Dbtc::seizeDatabuf() + +void Dbtc::seizeTcConnect(Signal* signal) +{ + tcConnectptr.i = cfirstfreeTcConnect; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + cfirstfreeTcConnect = tcConnectptr.p->nextTcConnect; + cconcurrentOp++; + tcConnectptr.p->isIndexOp = false; +}//Dbtc::seizeTcConnect() + +void Dbtc::seizeTcConnectFail(Signal* signal) +{ + tcConnectptr.i = cfirstfreeTcConnectFail; + ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord); + cfirstfreeTcConnectFail = tcConnectptr.p->nextTcConnect; +}//Dbtc::seizeTcConnectFail() + +void Dbtc::sendAttrinfo(Signal* signal, + UintR TattrinfoPtr, + AttrbufRecord * const regAttrPtr, + UintR TBref) +{ + UintR TdataPos; + UintR sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7; + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + TdataPos = regAttrPtr->attrbuf[ZINBUF_DATA_LEN]; + sig0 = TattrinfoPtr; + sig1 = regApiPtr->transid[0]; + sig2 = regApiPtr->transid[1]; + + signal->theData[0] = sig0; + signal->theData[1] = sig1; + signal->theData[2] = sig2; + + sig0 = regAttrPtr->attrbuf[0]; + sig1 = regAttrPtr->attrbuf[1]; + sig2 = regAttrPtr->attrbuf[2]; + sig3 = regAttrPtr->attrbuf[3]; + sig4 = regAttrPtr->attrbuf[4]; + sig5 = regAttrPtr->attrbuf[5]; + sig6 = regAttrPtr->attrbuf[6]; + sig7 = regAttrPtr->attrbuf[7]; + + signal->theData[3] = sig0; + signal->theData[4] = sig1; + signal->theData[5] = sig2; + signal->theData[6] = sig3; + signal->theData[7] = sig4; + signal->theData[8] = sig5; + signal->theData[9] = sig6; + signal->theData[10] = sig7; + + if (TdataPos > 8) { + sig0 = regAttrPtr->attrbuf[8]; + sig1 = regAttrPtr->attrbuf[9]; + sig2 = regAttrPtr->attrbuf[10]; + sig3 = regAttrPtr->attrbuf[11]; + sig4 = regAttrPtr->attrbuf[12]; + sig5 = regAttrPtr->attrbuf[13]; + sig6 = regAttrPtr->attrbuf[14]; + + jam(); + signal->theData[11] = sig0; + signal->theData[12] = sig1; + signal->theData[13] = sig2; + signal->theData[14] = sig3; + signal->theData[15] = sig4; + signal->theData[16] = sig5; + signal->theData[17] = sig6; + + if (TdataPos > 15) { + + sig0 = regAttrPtr->attrbuf[15]; + sig1 = regAttrPtr->attrbuf[16]; + sig2 = regAttrPtr->attrbuf[17]; + sig3 = regAttrPtr->attrbuf[18]; + sig4 = regAttrPtr->attrbuf[19]; + sig5 = regAttrPtr->attrbuf[20]; + sig6 = regAttrPtr->attrbuf[21]; + + jam(); + signal->theData[18] = sig0; + signal->theData[19] = sig1; + signal->theData[20] = sig2; + signal->theData[21] = sig3; + signal->theData[22] = sig4; + signal->theData[23] = sig5; + signal->theData[24] = sig6; + }//if + }//if + sendSignal(TBref, GSN_ATTRINFO, signal, TdataPos + 3, JBB); +}//Dbtc::sendAttrinfo() + +void Dbtc::sendContinueTimeOutControl(Signal* signal, Uint32 TapiConPtr) +{ + signal->theData[0] = TcContinueB::ZCONTINUE_TIME_OUT_CONTROL; + signal->theData[1] = TapiConPtr; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); +}//Dbtc::sendContinueTimeOutControl() + +/* ------------------------------------------------------------------------- + * SEND REAL-TIME BREAK DURING INITIALISATION OF VARIABLES DURING + * SYSTEM RESTART. + * ------------------------------------------------------------------------- */ +void Dbtc::sendInitialiseRecords(Signal* signal, UintR Tnext) +{ + signal->theData[0] = TcContinueB::ZINITIALISE_RECORDS; + signal->theData[1] = Tnext; + signal->theData[2] = 0; + sendSignal(DBTC_REF, GSN_CONTINUEB, signal, 3, JBB); +}//Dbtc::sendInitialiseRecords() + +void Dbtc::sendKeyinfo(Signal* signal, BlockReference TBRef, Uint32 len) +{ + signal->theData[0] = tcConnectptr.i; + signal->theData[1] = apiConnectptr.p->transid[0]; + signal->theData[2] = apiConnectptr.p->transid[1]; + signal->theData[3] = cdata[0]; + signal->theData[4] = cdata[1]; + signal->theData[5] = cdata[2]; + signal->theData[6] = cdata[3]; + signal->theData[7] = cdata[4]; + signal->theData[8] = cdata[5]; + signal->theData[9] = cdata[6]; + signal->theData[10] = cdata[7]; + signal->theData[11] = cdata[8]; + signal->theData[12] = cdata[9]; + signal->theData[13] = cdata[10]; + signal->theData[14] = cdata[11]; + signal->theData[15] = cdata[12]; + signal->theData[16] = cdata[13]; + signal->theData[17] = cdata[14]; + signal->theData[18] = cdata[15]; + signal->theData[19] = cdata[16]; + signal->theData[20] = cdata[17]; + signal->theData[21] = cdata[18]; + signal->theData[22] = cdata[19]; + sendSignal(TBRef, GSN_KEYINFO, signal, 3 + len, JBB); +}//Dbtc::sendKeyinfo() + +void Dbtc::sendSystemError(Signal* signal) +{ + progError(0, 0); +}//Dbtc::sendSystemError() + +/* ========================================================================= */ +/* ------- LINK ACTUAL GCP OUT OF LIST ------- */ +/* ------------------------------------------------------------------------- */ +void Dbtc::unlinkGcp(Signal* signal) +{ + if (cfirstgcp == gcpPtr.i) { + jam(); + cfirstgcp = gcpPtr.p->nextGcp; + if (gcpPtr.i == clastgcp) { + jam(); + clastgcp = RNIL; + }//if + } else { + jam(); + /* -------------------------------------------------------------------- + * WE ARE TRYING TO REMOVE A GLOBAL CHECKPOINT WHICH WAS NOT THE OLDEST. + * THIS IS A SYSTEM ERROR. + * ------------------------------------------------------------------- */ + sendSystemError(signal); + }//if + gcpPtr.p->nextGcp = cfirstfreeGcp; + cfirstfreeGcp = gcpPtr.i; +}//Dbtc::unlinkGcp() + +void +Dbtc::execDUMP_STATE_ORD(Signal* signal) +{ + DumpStateOrd * const dumpState = (DumpStateOrd *)&signal->theData[0]; + if(signal->theData[0] == DumpStateOrd::CommitAckMarkersSize){ + infoEvent("TC: m_commitAckMarkerPool: %d free size: %d", + m_commitAckMarkerPool.getNoOfFree(), + m_commitAckMarkerPool.getSize()); + } + if(signal->theData[0] == DumpStateOrd::CommitAckMarkersDump){ + infoEvent("TC: m_commitAckMarkerPool: %d free size: %d", + m_commitAckMarkerPool.getNoOfFree(), + m_commitAckMarkerPool.getSize()); + + CommitAckMarkerIterator iter; + for(m_commitAckMarkerHash.first(iter); iter.curr.i != RNIL; + m_commitAckMarkerHash.next(iter)){ + infoEvent("CommitAckMarker: i = %d (0x%x, 0x%x)" + " Api: %d Lghs(%d): %d %d %d %d bucket = %d", + iter.curr.i, + iter.curr.p->transid1, + iter.curr.p->transid2, + iter.curr.p->apiNodeId, + iter.curr.p->noOfLqhs, + iter.curr.p->lqhNodeId[0], + iter.curr.p->lqhNodeId[1], + iter.curr.p->lqhNodeId[2], + iter.curr.p->lqhNodeId[3], + iter.bucket); + } + } + // Dump all ScanFragRecs + if (dumpState->args[0] == DumpStateOrd::TcDumpAllScanFragRec){ + Uint32 recordNo = 0; + if (signal->getLength() == 1) + infoEvent("TC: Dump all ScanFragRec - size: %d", + cscanFragrecFileSize); + else if (signal->getLength() == 2) + recordNo = dumpState->args[1]; + else + return; + + dumpState->args[0] = DumpStateOrd::TcDumpOneScanFragRec; + dumpState->args[1] = recordNo; + execDUMP_STATE_ORD(signal); + + if (recordNo < cscanFragrecFileSize-1){ + dumpState->args[0] = DumpStateOrd::TcDumpAllScanFragRec; + dumpState->args[1] = recordNo+1; + sendSignal(reference(), GSN_DUMP_STATE_ORD, signal, 2, JBB); + } + } + + // Dump one ScanFragRec + if (dumpState->args[0] == DumpStateOrd::TcDumpOneScanFragRec){ + Uint32 recordNo = RNIL; + if (signal->getLength() == 2) + recordNo = dumpState->args[1]; + else + return; + + if (recordNo >= cscanFragrecFileSize) + return; + + ScanFragRecPtr sfp; + sfp.i = recordNo; + ptrAss(sfp, scanFragmentRecord); + infoEvent("Dbtc::ScanFragRec[%d]: state=%d, status=%d, " + "fragid=%d, procid=%d, ", + sfp.i, + sfp.p->scanFragState, + sfp.p->scanFragCompletedStatus, + sfp.p->scanFragId, + sfp.p->scanFragProcId); + infoEvent(" nodeid=%d, ind=%d, concurr=%d, timer=%d, next=%d", + sfp.p->scanFragNodeId, + sfp.p->scanIndividual, + sfp.p->scanFragConcurrency, + sfp.p->scanFragTimer, + sfp.p->nextScanFrag); + } + + // Dump all ScanRecords + if (dumpState->args[0] == DumpStateOrd::TcDumpAllScanRec){ + Uint32 recordNo = 0; + if (signal->getLength() == 1) + infoEvent("TC: Dump all ScanRecord - size: %d", + cscanrecFileSize); + else if (signal->getLength() == 2) + recordNo = dumpState->args[1]; + else + return; + + dumpState->args[0] = DumpStateOrd::TcDumpOneScanRec; + dumpState->args[1] = recordNo; + execDUMP_STATE_ORD(signal); + + if (recordNo < cscanrecFileSize-1){ + dumpState->args[0] = DumpStateOrd::TcDumpAllScanRec; + dumpState->args[1] = recordNo+1; + sendSignal(reference(), GSN_DUMP_STATE_ORD, signal, 2, JBB); + } + } + + // Dump all active ScanRecords + if (dumpState->args[0] == DumpStateOrd::TcDumpAllActiveScanRec){ + Uint32 recordNo = 0; + if (signal->getLength() == 1) + infoEvent("TC: Dump active ScanRecord - size: %d", + cscanrecFileSize); + else if (signal->getLength() == 2) + recordNo = dumpState->args[1]; + else + return; + + ScanRecordPtr sp; + sp.i = recordNo; + ptrAss(sp, scanRecord); + if (sp.p->scanState != ScanRecord::IDLE){ + dumpState->args[0] = DumpStateOrd::TcDumpOneScanRec; + dumpState->args[1] = recordNo; + execDUMP_STATE_ORD(signal); + } + + if (recordNo < cscanrecFileSize-1){ + dumpState->args[0] = DumpStateOrd::TcDumpAllActiveScanRec; + dumpState->args[1] = recordNo+1; + sendSignal(reference(), GSN_DUMP_STATE_ORD, signal, 2, JBB); + } + } + + // Dump one ScanRecord + // and associated ScanFragRec and ApiConnectRecord + if (dumpState->args[0] == DumpStateOrd::TcDumpOneScanRec){ + Uint32 recordNo = RNIL; + if (signal->getLength() == 2) + recordNo = dumpState->args[1]; + else + return; + + if (recordNo >= cscanrecFileSize) + return; + + ScanRecordPtr sp; + sp.i = recordNo; + ptrAss(sp, scanRecord); + infoEvent("Dbtc::ScanRecord[%d]: state=%d, scanOprec=%d, " + "nextfrag=%d, nofrag=%d", + sp.i, + sp.p->scanState, + sp.p->noScanOprec, + sp.p->scanNextFragId, + sp.p->scanNoFrag); + infoEvent(" ailen=%d, para=%d, receivedop=%d, noOprePperFrag=%d", + sp.p->scanAiLength, + sp.p->scanParallel, + sp.p->scanReceivedOperations, + sp.p->noOprecPerFrag); + infoEvent(" schv=%d, tab=%d, sproc=%d, noTI=%d, norecTI=%d", + sp.p->scanSchemaVersion, + sp.p->scanTableref, + sp.p->scanStoredProcId, + sp.p->noScanTabInfo, + sp.p->scanTabInfoReceived); + infoEvent(" apiclosed=%d, noProcCompl=%d, " + "complStat=%d, lhold=%d, lmode=%d", + sp.p->apiIsClosed, + sp.p->scanProcessesCompleted, + sp.p->scanCompletedStatus, + sp.p->scanLockHold, + sp.p->scanLockMode); + infoEvent(" apiRec=%d, next=%d", + sp.p->scanApiRec, sp.p->nextScan); + + if (sp.p->scanState != ScanRecord::IDLE){ + // Request dump of ScanFragRec + for (Uint32 i = 0; i < 16; i++){ + if (sp.p->scanFragrec[i] != RNIL){ + dumpState->args[0] = DumpStateOrd::TcDumpOneScanFragRec; + dumpState->args[1] = sp.p->scanFragrec[i]; + execDUMP_STATE_ORD(signal); + } + } + // Request dump of ApiConnectRecord + dumpState->args[0] = DumpStateOrd::TcDumpOneApiConnectRec; + dumpState->args[1] = sp.p->scanApiRec; + execDUMP_STATE_ORD(signal); + } + + } + + // Dump all ApiConnectRecord(s) + if (dumpState->args[0] == DumpStateOrd::TcDumpAllApiConnectRec){ + Uint32 recordNo = 0; + if (signal->getLength() == 1) + infoEvent("TC: Dump all ApiConnectRecord - size: %d", + capiConnectFilesize); + else if (signal->getLength() == 2) + recordNo = dumpState->args[1]; + else + return; + + dumpState->args[0] = DumpStateOrd::TcDumpOneApiConnectRec; + dumpState->args[1] = recordNo; + execDUMP_STATE_ORD(signal); + + if (recordNo < capiConnectFilesize-1){ + dumpState->args[0] = DumpStateOrd::TcDumpAllApiConnectRec; + dumpState->args[1] = recordNo+1; + sendSignal(reference(), GSN_DUMP_STATE_ORD, signal, 2, JBB); + } + } + + // Dump one ApiConnectRecord + if (dumpState->args[0] == DumpStateOrd::TcDumpOneApiConnectRec){ + Uint32 recordNo = RNIL; + if (signal->getLength() == 2) + recordNo = dumpState->args[1]; + else + return; + + if (recordNo >= capiConnectFilesize) + return; + + ApiConnectRecordPtr ap; + ap.i = recordNo; + ptrAss(ap, apiConnectRecord); + infoEvent("Dbtc::ApiConnectRecord[%d]: state=%d, abortState=%d, " + "apiFailState=%d", + ap.i, + ap.p->apiConnectstate, + ap.p->abortState, + ap.p->apiFailState); + infoEvent(" transid(0x%x, 0x%x), apiBref=0x%x, scanRec=%d", + ap.p->transid[0], + ap.p->transid[1], + ap.p->ndbapiBlockref, + ap.p->apiScanRec); + infoEvent(" ctcTimer=%d, apiTimer=%d, counter=%d, retcode=%d, " + "retsig=%d", + ctcTimer, getApiConTimer(ap.i), + ap.p->counter, + ap.p->returncode, + ap.p->returnsignal); + infoEvent(" lqhkeyconfrec=%d, lqhkeyreqrec=%d, " + "tckeyrec=%d", + ap.p->lqhkeyconfrec, + ap.p->lqhkeyreqrec, + ap.p->tckeyrec); + infoEvent(" next=%d ", + ap.p->nextApiConnect); + } + + if (dumpState->args[0] == DumpStateOrd::TcSetTransactionTimeout){ + jam(); + if(signal->getLength() > 1){ + set_timeout_value(signal->theData[1]); + } + } +}//Dbtc::execDUMP_STATE_ORD() + +void Dbtc::execSET_VAR_REQ(Signal* signal) +{ + + SetVarReq* const setVarReq = (SetVarReq*)&signal->theData[0]; + ConfigParamId var = setVarReq->variable(); + int val = setVarReq->value(); + + + switch (var) { + + case TransactionInactiveTime: + jam(); + set_appl_timeout_value(val); + break; + case TransactionDeadlockDetectionTimeout: + set_timeout_value(val); + sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB); + break; + + case NoOfConcurrentProcessesHandleTakeover: + set_no_parallel_takeover(val); + sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB); + break; + + default: + sendSignal(CMVMI_REF, GSN_SET_VAR_REF, signal, 1, JBB); + } // switch + +} + +void Dbtc::execABORT_ALL_REQ(Signal* signal) +{ + jamEntry(); + AbortAllReq * req = (AbortAllReq*)&signal->theData[0]; + AbortAllRef * ref = (AbortAllRef*)&signal->theData[0]; + + const Uint32 senderData = req->senderData; + const BlockReference senderRef = req->senderRef; + + if(getAllowStartTransaction() == true && !getNodeState().getSingleUserMode()){ + jam(); + + ref->senderData = senderData; + ref->errorCode = AbortAllRef::InvalidState; + sendSignal(senderRef, GSN_ABORT_ALL_REF, signal, + AbortAllRef::SignalLength, JBB); + return; + } + + if(c_abortRec.clientRef != 0){ + jam(); + + ref->senderData = senderData; + ref->errorCode = AbortAllRef::AbortAlreadyInProgress; + sendSignal(senderRef, GSN_ABORT_ALL_REF, signal, + AbortAllRef::SignalLength, JBB); + return; + } + + if(refToNode(senderRef) != getOwnNodeId()){ + jam(); + + ref->senderData = senderData; + ref->errorCode = AbortAllRef::FunctionNotImplemented; + sendSignal(senderRef, GSN_ABORT_ALL_REF, signal, + AbortAllRef::SignalLength, JBB); + return; + } + + c_abortRec.clientRef = senderRef; + c_abortRec.clientData = senderData; + c_abortRec.oldTimeOutValue = ctimeOutValue; + + ctimeOutValue = 0; + + const Uint32 sleepTime = (2 * 10 * ctimeOutCheckDelay + 199) / 200; + + checkAbortAllTimeout(signal, (sleepTime == 0 ? 1 : sleepTime)); +} + +void Dbtc::checkAbortAllTimeout(Signal* signal, Uint32 sleepTime) +{ + + ndbrequire(c_abortRec.clientRef != 0); + + if(sleepTime > 0){ + jam(); + + sleepTime -= 1; + signal->theData[0] = TcContinueB::ZWAIT_ABORT_ALL; + signal->theData[1] = sleepTime; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 200, 2); + return; + } + + AbortAllConf * conf = (AbortAllConf*)&signal->theData[0]; + conf->senderData = c_abortRec.clientData; + sendSignal(c_abortRec.clientRef, GSN_ABORT_ALL_CONF, signal, + AbortAllConf::SignalLength, JBB); + + ctimeOutValue = c_abortRec.oldTimeOutValue; + c_abortRec.clientRef = 0; +} + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* ------------------ TRIGGER AND INDEX HANDLING ------------------ */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ + +void Dbtc::execCREATE_TRIG_REQ(Signal* signal) +{ + jamEntry(); + CreateTrigReq * const createTrigReq = + (CreateTrigReq *)&signal->theData[0]; + TcDefinedTriggerData* triggerData; + DefinedTriggerPtr triggerPtr; + BlockReference sender = signal->senderBlockRef(); + + releaseSections(signal); + + triggerPtr.i = createTrigReq->getTriggerId(); + if (ERROR_INSERTED(8033) || + !c_theDefinedTriggers.seizeId(triggerPtr, + createTrigReq->getTriggerId())) { + CLEAR_ERROR_INSERT_VALUE; + // Failed to allocate trigger record + CreateTrigRef * const createTrigRef = + (CreateTrigRef *)&signal->theData[0]; + + createTrigRef->setConnectionPtr(createTrigReq->getConnectionPtr()); + createTrigRef->setErrorCode(CreateTrigRef::TooManyTriggers); + sendSignal(sender, GSN_CREATE_TRIG_REF, + signal, CreateTrigRef::SignalLength, JBB); + return; + } + + triggerData = triggerPtr.p; + triggerData->triggerId = createTrigReq->getTriggerId(); + triggerData->triggerType = createTrigReq->getTriggerType(); + triggerData->triggerEvent = createTrigReq->getTriggerEvent(); + triggerData->attributeMask = createTrigReq->getAttributeMask(); + if (triggerData->triggerType == TriggerType::SECONDARY_INDEX) + triggerData->indexId = createTrigReq->getIndexId(); + CreateTrigConf * const createTrigConf = + (CreateTrigConf *)&signal->theData[0]; + + createTrigConf->setConnectionPtr(createTrigReq->getConnectionPtr()); + sendSignal(sender, GSN_CREATE_TRIG_CONF, + signal, CreateTrigConf::SignalLength, JBB); +} + + +void Dbtc::execDROP_TRIG_REQ(Signal* signal) +{ + jamEntry(); + DropTrigReq * const dropTrigReq = (DropTrigReq *)&signal->theData[0]; + BlockReference sender = signal->senderBlockRef(); + + if ((c_theDefinedTriggers.getPtr(dropTrigReq->getTriggerId())) == NULL) { + jam(); + // Failed to find find trigger record + DropTrigRef * const dropTrigRef = (DropTrigRef *)&signal->theData[0]; + + dropTrigRef->setConnectionPtr(dropTrigReq->getConnectionPtr()); + dropTrigRef->setErrorCode(DropTrigRef::TriggerNotFound); + sendSignal(sender, GSN_DROP_TRIG_REF, + signal, DropTrigRef::SignalLength, JBB); + return; + } + + // Release trigger record + c_theDefinedTriggers.release(dropTrigReq->getTriggerId()); + + DropTrigConf * const dropTrigConf = (DropTrigConf *)&signal->theData[0]; + + dropTrigConf->setConnectionPtr(dropTrigReq->getConnectionPtr()); + sendSignal(sender, GSN_DROP_TRIG_CONF, + signal, DropTrigConf::SignalLength, JBB); +} + +void Dbtc::execCREATE_INDX_REQ(Signal* signal) +{ + jamEntry(); + CreateIndxReq * const createIndxReq = + (CreateIndxReq *)signal->getDataPtr(); + TcIndexData* indexData; + TcIndexDataPtr indexPtr; + BlockReference sender = signal->senderBlockRef(); + + if (ERROR_INSERTED(8034) || + !c_theIndexes.seizeId(indexPtr, createIndxReq->getIndexId())) { + CLEAR_ERROR_INSERT_VALUE; + // Failed to allocate index record + CreateIndxRef * const createIndxRef = + (CreateIndxRef *)&signal->theData[0]; + + createIndxRef->setConnectionPtr(createIndxReq->getConnectionPtr()); + createIndxRef->setErrorCode(CreateIndxRef::TooManyIndexes); + releaseSections(signal); + sendSignal(sender, GSN_CREATE_INDX_REF, + signal, CreateIndxRef::SignalLength, JBB); + return; + } + indexData = indexPtr.p; + // Indexes always start in state IS_BUILDING + // Will become IS_ONLINE in execALTER_INDX_REQ + indexData->indexState = IS_BUILDING; + indexData->indexId = indexPtr.i; + indexData->primaryTableId = createIndxReq->getTableId(); + + // So far need only attribute count + SegmentedSectionPtr ssPtr; + signal->getSection(ssPtr, CreateIndxReq::ATTRIBUTE_LIST_SECTION); + SimplePropertiesSectionReader r0(ssPtr, getSectionSegmentPool()); + r0.reset(); // undo implicit first() + if (!r0.getWord(&indexData->attributeList.sz) || + !r0.getWords(indexData->attributeList.id, indexData->attributeList.sz)) { + ndbrequire(false); + } + indexData->primaryKeyPos = indexData->attributeList.sz; + + releaseSections(signal); + + CreateIndxConf * const createIndxConf = + (CreateIndxConf *)&signal->theData[0]; + + createIndxConf->setConnectionPtr(createIndxReq->getConnectionPtr()); + createIndxConf->setTableId(createIndxReq->getTableId()); + createIndxConf->setIndexId(createIndxReq->getIndexId()); + sendSignal(sender, GSN_CREATE_INDX_CONF, + signal, CreateIndxConf::SignalLength, JBB); +} + +void Dbtc::execALTER_INDX_REQ(Signal* signal) +{ + jamEntry(); + AlterIndxReq * const alterIndxReq = (AlterIndxReq *)signal->getDataPtr(); + TcIndexData* indexData; + //BlockReference sender = signal->senderBlockRef(); + BlockReference sender = (BlockReference) alterIndxReq->getUserRef(); + Uint32 connectionPtr = alterIndxReq->getConnectionPtr(); + AlterIndxReq::RequestType requestType = alterIndxReq->getRequestType(); + Uint32 tableId = alterIndxReq->getTableId(); + Uint32 indexId = alterIndxReq->getIndexId(); + bool online = (alterIndxReq->getOnline() == 1) ? true : false; + + if ((indexData = c_theIndexes.getPtr(indexId)) == NULL) { + jam(); + // Failed to find index record + AlterIndxRef * const alterIndxRef = + (AlterIndxRef *)signal->getDataPtrSend(); + + alterIndxRef->setUserRef(reference()); + alterIndxRef->setConnectionPtr(connectionPtr); + alterIndxRef->setRequestType(requestType); + alterIndxRef->setTableId(tableId); + alterIndxRef->setIndexId(indexId); + alterIndxRef->setErrorCode(AlterIndxRef::IndexNotFound); + alterIndxRef->setErrorLine(__LINE__); + alterIndxRef->setErrorNode(getOwnNodeId()); + sendSignal(sender, GSN_ALTER_INDX_REF, + signal, AlterIndxRef::SignalLength, JBB); + return; + } + // Found index record, alter it's state + if (online) { + jam(); + indexData->indexState = IS_ONLINE; + } else { + jam(); + indexData->indexState = IS_BUILDING; + }//if + AlterIndxConf * const alterIndxConf = + (AlterIndxConf *)signal->getDataPtrSend(); + + alterIndxConf->setUserRef(reference()); + alterIndxConf->setConnectionPtr(connectionPtr); + alterIndxConf->setRequestType(requestType); + alterIndxConf->setTableId(tableId); + alterIndxConf->setIndexId(indexId); + sendSignal(sender, GSN_ALTER_INDX_CONF, + signal, AlterIndxConf::SignalLength, JBB); +} + +void Dbtc::execFIRE_TRIG_ORD(Signal* signal) +{ + jamEntry(); + FireTrigOrd * const fireTrigOrd = (FireTrigOrd *)signal->getDataPtr(); + ApiConnectRecord *localApiConnectRecord = apiConnectRecord; + ApiConnectRecordPtr transPtr; + TcConnectRecord *localTcConnectRecord = tcConnectRecord; + TcConnectRecordPtr opPtr; + + opPtr.i = fireTrigOrd->getConnectionPtr(); + ptrCheckGuard(opPtr, ctcConnectFilesize, localTcConnectRecord); + transPtr.i = opPtr.p->apiConnect; + transPtr.p = &localApiConnectRecord[transPtr.i]; + if(opPtr.p->triggerError == 0){ + scheduleFiredTrigger(&transPtr, &opPtr); + } + + // If we have received complete info of all fired triggers + // then execute the triggers + if (++(opPtr.p->noReceivedTriggers) == opPtr.p->noFiredTriggers) { + jam(); + if (opPtr.p->triggerError != 0) { + jam(); + // Abort transaction + apiConnectptr.i = transPtr.i; + terrorCode = opPtr.p->triggerError; + abortErrorLab(signal); + return; + }//if + executeTriggers(signal, &transPtr); + }//if +} + +void Dbtc::execTRIG_ATTRINFO(Signal* signal) +{ + jamEntry(); + TrigAttrInfo * const trigAttrInfo = (TrigAttrInfo *)signal->getDataPtr(); + Uint32 attrInfoLength = signal->getLength() - TrigAttrInfo::StaticLength; + const Uint32 *src = trigAttrInfo->getData(); + TcFiredTriggerData* currentTrigger; + FiredTriggerPtr firedTrigPtr; + TcConnectRecord *localTcConnectRecord = tcConnectRecord; + TcConnectRecordPtr opPtr; + + opPtr.i = trigAttrInfo->getConnectionPtr(); + ptrCheckGuard(opPtr, ctcConnectFilesize, localTcConnectRecord); + + if (opPtr.p->accumulatingTriggerData.p) { + jam(); + // We are already accumulating + } else { + jam(); + // Allocate new trigger record + ApiConnectRecord *localApiConnectRecord = apiConnectRecord; + ApiConnectRecordPtr transPtr; + + transPtr.i = opPtr.p->apiConnect; + //transPtr.p = &localApiConnectRecord[transPtr.i]; + ptrCheckGuard(transPtr, capiConnectFilesize, localApiConnectRecord); + if (!c_theFiredTriggerPool.seize(firedTrigPtr)) { + jam(); + // Resource shortage, abort transaction + // Mark transaction for abortion +#ifdef VM_TRACE + ndbout_c("Dbtc::execTRIG_ATTRINFO: Failed to seize fired triggers\n"); + ndbout_c("%u: Trigger error = %u\n", __LINE__, 4000); +#endif + opPtr.p->triggerError = 4000; + return; + }//if + ndbrequire(firedTrigPtr.p->keyValues.isEmpty() && + firedTrigPtr.p->beforeValues.isEmpty() && + firedTrigPtr.p->afterValues.isEmpty()); + firedTrigPtr.p->triggerId = trigAttrInfo->getTriggerId(); + opPtr.p->accumulatingTriggerData = firedTrigPtr; + firedTrigPtr.p->fireingOperation = opPtr.i; + }//if + currentTrigger = opPtr.p->accumulatingTriggerData.p; + switch (trigAttrInfo->getAttrInfoType()) { + case(TrigAttrInfo::PRIMARY_KEY): + jam(); + if (currentTrigger->keyValues.append(src, attrInfoLength) == false) { + jam(); + // Mark transaction for abortion +#ifdef VM_TRACE + ndbout_c("Dbtc::execTRIG_ATTRINFO: Failed to seize keyValues\n"); + ndbout_c("%u: Trigger error = %u\n", __LINE__, 4000); +#endif + opPtr.p->triggerError = 4000; + // Return trigger to pool + c_theFiredTriggerPool.release(opPtr.p->accumulatingTriggerData.i); + return; + } + break; + case(TrigAttrInfo::BEFORE_VALUES): + jam(); + if (currentTrigger->beforeValues.append(src, attrInfoLength) == false) { + jam(); + // Mark transaction for abortion +#ifdef VM_TRACE + ndbout_c("Dbtc::execTRIG_ATTRINFO: Failed to seize beforeValues\n"); + ndbout_c("%u: Trigger error = %u\n", __LINE__, 4000); +#endif + opPtr.p->triggerError = 4000; + // Return trigger to pool + c_theFiredTriggerPool.release(opPtr.p->accumulatingTriggerData.i); + return; + } + break; + case(TrigAttrInfo::AFTER_VALUES): + jam(); + if (currentTrigger->afterValues.append(src, attrInfoLength) == false) { + jam(); + // Mark transaction for abortion +#ifdef VM_TRACE + ndbout_c("Dbtc::execTRIG_ATTRINFO: Failed to seize afterValues\n"); + ndbout_c("%u: Trigger error = %u\n", __LINE__, 4000); +#endif + opPtr.p->triggerError = 4000; + // Return trigger to pool + c_theFiredTriggerPool.release(opPtr.p->accumulatingTriggerData.i); + return; + } + break; + } +} + +void Dbtc::execDROP_INDX_REQ(Signal* signal) +{ + jamEntry(); + DropIndxReq * const dropIndxReq = (DropIndxReq *)signal->getDataPtr(); + TcIndexData* indexData; + BlockReference sender = signal->senderBlockRef(); + + if ((indexData = c_theIndexes.getPtr(dropIndxReq->getIndexId())) == NULL) { + jam(); + // Failed to find index record + DropIndxRef * const dropIndxRef = + (DropIndxRef *)signal->getDataPtrSend(); + + dropIndxRef->setConnectionPtr(dropIndxReq->getConnectionPtr()); + dropIndxRef->setErrorCode(DropIndxRef::IndexNotFound); + sendSignal(sender, GSN_DROP_INDX_REF, + signal, DropIndxRef::SignalLength, JBB); + return; + } + // Release index record + c_theIndexes.release(dropIndxReq->getIndexId()); + + DropIndxConf * const dropIndxConf = + (DropIndxConf *)signal->getDataPtrSend(); + + dropIndxConf->setConnectionPtr(dropIndxReq->getConnectionPtr()); + sendSignal(sender, GSN_DROP_INDX_CONF, + signal, DropIndxConf::SignalLength, JBB); +} + +void Dbtc::execTCINDXREQ(Signal* signal) +{ + jamEntry(); + + TcIndxReq * const tcIndxReq = (TcIndxReq *)signal->getDataPtr(); + const UintR TapiIndex = tcIndxReq->apiConnectPtr; + Uint32 tcIndxRequestInfo = tcIndxReq->requestInfo; + Uint32 startFlag = tcIndxReq->getStartFlag(tcIndxRequestInfo); + Uint32 * dataPtr = &tcIndxReq->scanInfo; + Uint32 indexBufSize = 8; // Maximum for index in TCINDXREQ + Uint32 attrBufSize = 5; // Maximum for attrInfo in TCINDXREQ + ApiConnectRecordPtr transPtr; + transPtr.i = TapiIndex; + if (transPtr.i >= capiConnectFilesize) { + jam(); + warningHandlerLab(signal); + return; + }//if + ptrAss(transPtr, apiConnectRecord); + ApiConnectRecord * const regApiPtr = transPtr.p; + // Seize index operation + TcIndexOperationPtr indexOpPtr; + if ((startFlag == 1) && + ((regApiPtr->apiConnectstate == CS_CONNECTED) || + ((regApiPtr->apiConnectstate == CS_ABORTING) && + (regApiPtr->abortState == AS_IDLE)))) { + jam(); + // This is a newly started transaction, clean-up + releaseAllSeizedIndexOperations(regApiPtr); + }//if + if (!seizeIndexOperation(regApiPtr, indexOpPtr)) { + jam(); + // Failed to allocate index operation + TcIndxRef * const tcIndxRef = (TcIndxRef *)signal->getDataPtrSend(); + + tcIndxRef->connectPtr = tcIndxReq->senderData; + tcIndxRef->transId[0] = regApiPtr->transid[0]; + tcIndxRef->transId[1] = regApiPtr->transid[1]; + tcIndxRef->errorCode = 4000; + sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, + TcIndxRef::SignalLength, JBB); + return; + } + TcIndexOperation* indexOp = indexOpPtr.p; + indexOp->indexOpId = indexOpPtr.i; + + // Save original signal + *indexOp->tcIndxReq = *tcIndxReq; + indexOp->connectionIndex = TapiIndex; + regApiPtr->accumulatingIndexOp = indexOp->indexOpId; + + // If operation is readTupleExclusive or updateTuple then read index + // table with exclusive lock + Uint32 indexLength = TcIndxReq::getIndexLength(tcIndxRequestInfo); + Uint32 attrLength = tcIndxReq->attrLen; + indexOp->expectedKeyInfo = indexLength; + Uint32 includedIndexLength = MIN(indexLength, indexBufSize); + indexOp->expectedAttrInfo = attrLength; + Uint32 includedAttrLength = MIN(attrLength, attrBufSize); + if (saveINDXKEYINFO(signal, + indexOp, + dataPtr, + includedIndexLength)) { + jam(); + // We have received all we need + readIndexTable(signal, regApiPtr, indexOp); + return; + } + dataPtr += includedIndexLength; + if (saveINDXATTRINFO(signal, + indexOp, + dataPtr, + includedAttrLength)) { + jam(); + // We have received all we need + readIndexTable(signal, regApiPtr, indexOp); + return; + } +} + + +void Dbtc::sendTcIndxConf(Signal* signal, UintR TcommitFlag) +{ + HostRecordPtr localHostptr; + ApiConnectRecord * const regApiPtr = apiConnectptr.p; + const UintR TopWords = (UintR)regApiPtr->tcindxrec; + localHostptr.i = refToNode(regApiPtr->ndbapiBlockref); + const Uint32 type = getNodeInfo(localHostptr.i).m_type; + const bool is_api = (type >= NodeInfo::API && type <= NodeInfo::REP); + const BlockNumber TblockNum = refToBlock(regApiPtr->ndbapiBlockref); + const Uint32 Tmarker = (regApiPtr->commitAckMarker == RNIL ? 0 : 1); + ptrAss(localHostptr, hostRecord); + UintR TcurrLen = localHostptr.p->noOfWordsTCINDXCONF; + UintR confInfo = 0; + TcIndxConf::setNoOfOperations(confInfo, (TopWords >> 1)); + TcIndxConf::setCommitFlag(confInfo, TcommitFlag); + TcIndxConf::setMarkerFlag(confInfo, Tmarker); + const UintR TpacketLen = 6 + TopWords; + regApiPtr->tcindxrec = 0; + + if ((TpacketLen > 25) || !is_api){ + TcIndxConf * const tcIndxConf = (TcIndxConf *)signal->getDataPtrSend(); + + jam(); + tcIndxConf->apiConnectPtr = regApiPtr->ndbapiConnect; + tcIndxConf->gci = regApiPtr->globalcheckpointid;; + tcIndxConf->confInfo = confInfo; + tcIndxConf->transId1 = regApiPtr->transid[0]; + tcIndxConf->transId2 = regApiPtr->transid[1]; + copyFromToLen(®ApiPtr->tcIndxSendArray[0], + (UintR*)&tcIndxConf->operations, + (UintR)ZTCOPCONF_SIZE); + sendSignal(regApiPtr->ndbapiBlockref, + GSN_TCINDXCONF, signal, (TpacketLen - 1), JBB); + return; + } else if (((TcurrLen + TpacketLen) > 25) && (TcurrLen > 0)) { + jam(); + sendPackedTCINDXCONF(signal, localHostptr.p, localHostptr.i); + TcurrLen = 0; + } else { + jam(); + updatePackedList(signal, localHostptr.p, localHostptr.i); + }//if +// ------------------------------------------------------------------------- +// The header contains the block reference of receiver plus the real signal +// length - 3, since we have the real signal length plus one additional word +// for the header we have to do - 4. +// ------------------------------------------------------------------------- + UintR Tpack0 = (TblockNum << 16) + (TpacketLen - 4); + UintR Tpack1 = regApiPtr->ndbapiConnect; + UintR Tpack2 = regApiPtr->globalcheckpointid; + UintR Tpack3 = confInfo; + UintR Tpack4 = regApiPtr->transid[0]; + UintR Tpack5 = regApiPtr->transid[1]; + + localHostptr.p->noOfWordsTCINDXCONF = TcurrLen + TpacketLen; + + localHostptr.p->packedWordsTCINDXCONF[TcurrLen + 0] = Tpack0; + localHostptr.p->packedWordsTCINDXCONF[TcurrLen + 1] = Tpack1; + localHostptr.p->packedWordsTCINDXCONF[TcurrLen + 2] = Tpack2; + localHostptr.p->packedWordsTCINDXCONF[TcurrLen + 3] = Tpack3; + localHostptr.p->packedWordsTCINDXCONF[TcurrLen + 4] = Tpack4; + localHostptr.p->packedWordsTCINDXCONF[TcurrLen + 5] = Tpack5; + + UintR Ti; + for (Ti = 6; Ti < TpacketLen; Ti++) { + localHostptr.p->packedWordsTCINDXCONF[TcurrLen + Ti] = + regApiPtr->tcIndxSendArray[Ti - 6]; + }//for +}//Dbtc::sendTcIndxConf() + +void Dbtc::execINDXKEYINFO(Signal* signal) +{ + jamEntry(); + Uint32 keyInfoLength = signal->getLength() - IndxKeyInfo::HeaderLength; + IndxKeyInfo * const indxKeyInfo = (IndxKeyInfo *)signal->getDataPtr(); + const Uint32 *src = indxKeyInfo->getData(); + const UintR TconnectIndex = indxKeyInfo->connectPtr; + ApiConnectRecordPtr transPtr; + transPtr.i = TconnectIndex; + if (transPtr.i >= capiConnectFilesize) { + jam(); + warningHandlerLab(signal); + return; + }//if + ptrAss(transPtr, apiConnectRecord); + ApiConnectRecord * const regApiPtr = transPtr.p; + TcIndexOperationPtr indexOpPtr; + TcIndexOperation* indexOp; + + indexOpPtr.i = regApiPtr->accumulatingIndexOp; + indexOp = c_theIndexOperations.getPtr(indexOpPtr.i); + if (saveINDXKEYINFO(signal, + indexOp, + src, + keyInfoLength)) { + jam(); + // We have received all we need + readIndexTable(signal, regApiPtr, indexOp); + } +} + +void Dbtc::execINDXATTRINFO(Signal* signal) +{ + jamEntry(); + Uint32 attrInfoLength = signal->getLength() - IndxAttrInfo::HeaderLength; + IndxAttrInfo * const indxAttrInfo = (IndxAttrInfo *)signal->getDataPtr(); + const Uint32 *src = indxAttrInfo->getData(); + const UintR TconnectIndex = indxAttrInfo->connectPtr; + ApiConnectRecordPtr transPtr; + transPtr.i = TconnectIndex; + if (transPtr.i >= capiConnectFilesize) { + jam(); + warningHandlerLab(signal); + return; + }//if + ptrAss(transPtr, apiConnectRecord); + ApiConnectRecord * const regApiPtr = transPtr.p; + TcIndexOperationPtr indexOpPtr; + TcIndexOperation* indexOp; + + indexOpPtr.i = regApiPtr->accumulatingIndexOp; + indexOp = c_theIndexOperations.getPtr(indexOpPtr.i); + if (saveINDXATTRINFO(signal, + indexOp, + src, + attrInfoLength)) { + jam(); + // We have received all we need + readIndexTable(signal, regApiPtr, indexOp); + } +} + +/** + * Save signal INDXKEYINFO + * Return true if we have received all needed data + */ +bool Dbtc::saveINDXKEYINFO(Signal* signal, + TcIndexOperation* indexOp, + const Uint32 *src, + Uint32 len) +{ + if (!indexOp->keyInfo.append(src, len)) { + jam(); + // Failed to seize keyInfo, abort transaction +#ifdef VM_TRACE + ndbout_c("Dbtc::saveINDXKEYINFO: Failed to seize keyinfo\n"); +#endif + // Abort transaction + apiConnectptr.i = indexOp->connectionIndex; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + releaseIndexOperation(apiConnectptr.p, indexOp); + terrorCode = 4000; + abortErrorLab(signal); + return true; + } + if (receivedAllINDXKEYINFO(indexOp) && receivedAllINDXATTRINFO(indexOp)) { + jam(); + return true; + } + return false; +} + +bool Dbtc::receivedAllINDXKEYINFO(TcIndexOperation* indexOp) +{ + return (indexOp->keyInfo.getSize() == indexOp->expectedKeyInfo); +} + +/** + * Save signal INDXATTRINFO + * Return true if we have received all needed data + */ +bool Dbtc::saveINDXATTRINFO(Signal* signal, + TcIndexOperation* indexOp, + const Uint32 *src, + Uint32 len) +{ + if (!indexOp->attrInfo.append(src, len)) { + jam(); +#ifdef VM_TRACE + ndbout_c("Dbtc::saveINDXATTRINFO: Failed to seize attrInfo\n"); +#endif + apiConnectptr.i = indexOp->connectionIndex; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + releaseIndexOperation(apiConnectptr.p, indexOp); + terrorCode = 4000; + abortErrorLab(signal); + return true; + } + if (receivedAllINDXKEYINFO(indexOp) && receivedAllINDXATTRINFO(indexOp)) { + jam(); + return true; + } + return false; +} + +bool Dbtc::receivedAllINDXATTRINFO(TcIndexOperation* indexOp) +{ + return (indexOp->attrInfo.getSize() == indexOp->expectedAttrInfo); +} + +bool Dbtc::saveTRANSID_AI(Signal* signal, + TcIndexOperation* indexOp, + const Uint32 *src, + Uint32 len) +{ + Uint32 currentTransIdAILength = indexOp->transIdAI.getSize(); + + if (currentTransIdAILength == 0) { + jam(); + // Read first AttributeHeader to get expected size + // of the single key attribute expected + AttributeHeader* head = (AttributeHeader *) src; + indexOp->expectedTransIdAI = head->getHeaderSize() + head->getDataSize(); + } + if (!indexOp->transIdAI.append(src, len)) { + jam(); +#ifdef VM_TRACE + ndbout_c("Dbtc::saveTRANSID_AI: Failed to seize transIdAI\n"); +#endif + apiConnectptr.i = indexOp->connectionIndex; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + releaseIndexOperation(apiConnectptr.p, indexOp); + terrorCode = 4000; + abortErrorLab(signal); + return false; + } + return true; +} + +bool Dbtc::receivedAllTRANSID_AI(TcIndexOperation* indexOp) +{ + return (indexOp->transIdAI.getSize() == indexOp->expectedTransIdAI); +} + +/** + * Receive signal TCINDXCONF + * This can be either the return of reading an index table + * or performing an index operation + */ +void Dbtc::execTCKEYCONF(Signal* signal) +{ + TcKeyConf * const tcKeyConf = (TcKeyConf *)signal->getDataPtr(); + TcIndexOperationPtr indexOpPtr; + + jamEntry(); + indexOpPtr.i = tcKeyConf->apiConnectPtr; + TcIndexOperation* indexOp = c_theIndexOperations.getPtr(indexOpPtr.i); + Uint32 confInfo = tcKeyConf->confInfo; + + /** + * Check on TCKEYCONF wheater the the transaction was committed + */ + Uint32 Tcommit = TcKeyConf::getCommitFlag(confInfo); + + indexOpPtr.p = indexOp; + if (!indexOp) { + jam(); + // Missing index operation + return; + } + const UintR TconnectIndex = indexOp->connectionIndex; + ApiConnectRecord * const regApiPtr = &apiConnectRecord[TconnectIndex]; + switch(indexOp->indexOpState) { + case(IOS_NOOP): { + jam(); + // Should never happen, abort + TcIndxRef * const tcIndxRef = (TcIndxRef *)signal->getDataPtrSend(); + + tcIndxRef->connectPtr = indexOp->tcIndxReq->senderData; + tcIndxRef->transId[0] = regApiPtr->transid[0]; + tcIndxRef->transId[1] = regApiPtr->transid[1]; + tcIndxRef->errorCode = 4349; + sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, + TcIndxRef::SignalLength, JBB); + return; + } + case(IOS_INDEX_ACCESS): { + jam(); + // Wait for TRANSID_AI + indexOp->indexOpState = IOS_INDEX_ACCESS_WAIT_FOR_TRANSID_AI; + break; + } + case(IOS_INDEX_ACCESS_WAIT_FOR_TRANSID_AI): { + jam(); + // Double TCKEYCONF, should never happen, abort + TcIndxRef * const tcIndxRef = (TcIndxRef *)signal->getDataPtrSend(); + + tcIndxRef->connectPtr = indexOp->tcIndxReq->senderData; + tcIndxRef->transId[0] = regApiPtr->transid[0]; + tcIndxRef->transId[1] = regApiPtr->transid[1]; + tcIndxRef->errorCode = 4349; + sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, + TcIndxRef::SignalLength, JBB); + return; + } + case(IOS_INDEX_ACCESS_WAIT_FOR_TCKEYCONF): { + jam(); + // Continue with index operation + executeIndexOperation(signal, regApiPtr, indexOp); + break; + } + case(IOS_INDEX_OPERATION): { + // We are done, send TCINDXCONF + jam(); + Uint32 Ttcindxrec = regApiPtr->tcindxrec; + // Copy reply from TcKeyConf + + regApiPtr->noIndexOp--; // Decrease count + regApiPtr->tcIndxSendArray[Ttcindxrec] = indexOp->tcIndxReq->senderData; + regApiPtr->tcIndxSendArray[Ttcindxrec + 1] = + tcKeyConf->operations[0].attrInfoLen; + regApiPtr->tcindxrec = Ttcindxrec + 2; + if (regApiPtr->noIndexOp == 0) { + jam(); + sendTcIndxConf(signal, Tcommit); + } else if (regApiPtr->tcindxrec == ZTCOPCONF_SIZE) { + jam(); + sendTcIndxConf(signal, 0); + } + releaseIndexOperation(regApiPtr, indexOp); + break; + } + } +} + +void Dbtc::execTCKEYREF(Signal* signal) +{ + TcKeyRef * const tcKeyRef = (TcKeyRef *)signal->getDataPtr(); + TcIndexOperationPtr indexOpPtr; + + jamEntry(); + indexOpPtr.i = tcKeyRef->connectPtr; + TcIndexOperation* indexOp = c_theIndexOperations.getPtr(indexOpPtr.i); + indexOpPtr.p = indexOp; + if (!indexOp) { + jam(); + // Missing index operation + return; + } + const UintR TconnectIndex = indexOp->connectionIndex; + ApiConnectRecord * const regApiPtr = &apiConnectRecord[TconnectIndex]; + Uint32 tcKeyRequestInfo = indexOp->tcIndxReq->requestInfo; + Uint32 commitFlg = TcKeyReq::getCommitFlag(tcKeyRequestInfo); + + switch(indexOp->indexOpState) { + case(IOS_NOOP): { + jam(); + // Should never happen, abort + break; + } + case(IOS_INDEX_ACCESS): + case(IOS_INDEX_ACCESS_WAIT_FOR_TRANSID_AI): + case(IOS_INDEX_ACCESS_WAIT_FOR_TCKEYCONF): { + jam(); + // If we fail index access for a non-read operation during commit + // we abort transaction + if (commitFlg == 1) { + jam(); + releaseIndexOperation(regApiPtr, indexOp); + apiConnectptr.i = indexOp->connectionIndex; + ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); + terrorCode = tcKeyRef->errorCode; + abortErrorLab(signal); + break; + } + // else continue + } + case(IOS_INDEX_OPERATION): { + // Send TCINDXREF + + jam(); + TcIndxReq * const tcIndxReq = indexOp->tcIndxReq; + TcIndxRef * const tcIndxRef = (TcIndxRef *)signal->getDataPtrSend(); + + regApiPtr->noIndexOp--; // Decrease count + tcIndxRef->connectPtr = tcIndxReq->senderData; + tcIndxRef->transId[0] = tcKeyRef->transId[0]; + tcIndxRef->transId[1] = tcKeyRef->transId[1]; + tcIndxRef->errorCode = tcKeyRef->errorCode; + sendSignal(regApiPtr->ndbapiBlockref, + GSN_TCINDXREF, signal, TcIndxRef::SignalLength, JBB); + return; + } + } +} + +void Dbtc::execTRANSID_AI_R(Signal* signal){ + TransIdAI * const transIdAI = (TransIdAI *)signal->getDataPtr(); + Uint32 sigLen = signal->length(); + Uint32 dataLen = sigLen - TransIdAI::HeaderLength - 1; + Uint32 recBlockref = transIdAI->attrData[dataLen]; + + jamEntry(); + + /** + * Forward signal to final destination + * Truncate last word since that was used to hold the final dest. + */ + sendSignal(recBlockref, GSN_TRANSID_AI, + signal, sigLen - 1, JBB); +} + +void Dbtc::execKEYINFO20_R(Signal* signal){ + KeyInfo20 * const keyInfo = (KeyInfo20 *)signal->getDataPtr(); + Uint32 sigLen = signal->length(); + Uint32 dataLen = sigLen - KeyInfo20::HeaderLength - 1; + Uint32 recBlockref = keyInfo->keyData[dataLen]; + + jamEntry(); + + /** + * Forward signal to final destination + * Truncate last word since that was used to hold the final dest. + */ + sendSignal(recBlockref, GSN_KEYINFO20, + signal, sigLen - 1, JBB); +} + + +void Dbtc::execTRANSID_AI(Signal* signal) +{ + TransIdAI * const transIdAI = (TransIdAI *)signal->getDataPtr(); + + jamEntry(); + TcIndexOperationPtr indexOpPtr; + indexOpPtr.i = transIdAI->connectPtr; + TcIndexOperation* indexOp = c_theIndexOperations.getPtr(indexOpPtr.i); + indexOpPtr.p = indexOp; + if (!indexOp) { + jam(); + // Missing index operation + } + const UintR TconnectIndex = indexOp->connectionIndex; + // ApiConnectRecord * const regApiPtr = &apiConnectRecord[TconnectIndex]; + ApiConnectRecordPtr transPtr; + + transPtr.i = TconnectIndex; + ptrCheckGuard(transPtr, capiConnectFilesize, apiConnectRecord); + ApiConnectRecord * const regApiPtr = transPtr.p; + + // Acccumulate attribute data + if (!saveTRANSID_AI(signal, + indexOp, + transIdAI->getData(), + signal->getLength() - TransIdAI::HeaderLength)) { + jam(); + // Failed to allocate space for TransIdAI + TcIndxRef * const tcIndxRef = (TcIndxRef *)signal->getDataPtrSend(); + + tcIndxRef->connectPtr = indexOp->tcIndxReq->senderData; + tcIndxRef->transId[0] = regApiPtr->transid[0]; + tcIndxRef->transId[1] = regApiPtr->transid[1]; + tcIndxRef->errorCode = 4000; + sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, + TcIndxRef::SignalLength, JBB); + return; + } + + switch(indexOp->indexOpState) { + case(IOS_NOOP): { + jam(); + // Should never happen, abort + TcIndxRef * const tcIndxRef = (TcIndxRef *)signal->getDataPtrSend(); + + tcIndxRef->connectPtr = indexOp->tcIndxReq->senderData; + tcIndxRef->transId[0] = regApiPtr->transid[0]; + tcIndxRef->transId[1] = regApiPtr->transid[1]; + tcIndxRef->errorCode = 4349; + sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, + TcIndxRef::SignalLength, JBB); + return; + break; + } + case(IOS_INDEX_ACCESS): { + jam(); + // Check if all TRANSID_AI have been received + if (receivedAllTRANSID_AI(indexOp)) { + jam(); + // Wait for TRANSID_AI + indexOp->indexOpState = IOS_INDEX_ACCESS_WAIT_FOR_TCKEYCONF; + } + break; + } + case(IOS_INDEX_ACCESS_WAIT_FOR_TCKEYCONF): { + jam(); +#ifdef VM_TRACE + ndbout_c("Dbtc::execTRANSID_AI: Too many TRANSID_AI, ignore for now\n"); +#endif + /* + // Too many TRANSID_AI + TcIndxRef * const tcIndxRef = (TcIndxRef *)signal->getDataPtrSend(); + + tcIndexRef->connectPtr = indexOp->tcIndxReq->senderData; + tcIndxRef->transId[0] = regApiPtr->transid[0]; + tcIndxRef->transId[1] = regApiPtr->transid[1]; + tcIndxRef->errorCode = 4349; + sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, + TcIndxRef::SignalLength, JBB); + */ + break; + } + case(IOS_INDEX_ACCESS_WAIT_FOR_TRANSID_AI): { + jam(); + // Check if all TRANSID_AI have been received + if (receivedAllTRANSID_AI(indexOp)) { + jam(); + // Continue with index operation + executeIndexOperation(signal, regApiPtr, indexOp); + } + // else continue waiting for more TRANSID_AI + break; + } + case(IOS_INDEX_OPERATION): { + // Should never receive TRANSID_AI in this state!! + jam(); + TcIndxRef * const tcIndxRef = (TcIndxRef *)signal->getDataPtrSend(); + + tcIndxRef->connectPtr = indexOp->tcIndxReq->senderData; + tcIndxRef->transId[0] = regApiPtr->transid[0]; + tcIndxRef->transId[1] = regApiPtr->transid[1]; + tcIndxRef->errorCode = 4349; + sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, + TcIndxRef::SignalLength, JBB); + return; + } + } +} + +void Dbtc::execTCROLLBACKREP(Signal* signal) +{ + TcRollbackRep* tcRollbackRep = (TcRollbackRep *)signal->getDataPtr(); + jamEntry(); + TcIndexOperationPtr indexOpPtr; + indexOpPtr.i = tcRollbackRep->connectPtr; + TcIndexOperation* indexOp = c_theIndexOperations.getPtr(indexOpPtr.i); + indexOpPtr.p = indexOp; + tcRollbackRep = (TcRollbackRep *)signal->getDataPtrSend(); + tcRollbackRep->connectPtr = indexOp->tcIndxReq->senderData; + sendSignal(apiConnectptr.p->ndbapiBlockref, + GSN_TCROLLBACKREP, signal, TcRollbackRep::SignalLength, JBB); +} + +/** + * Read index table with the index attributes as PK + */ +void Dbtc::readIndexTable(Signal* signal, + ApiConnectRecord* regApiPtr, + TcIndexOperation* indexOp) +{ + Uint32 keyBufSize = 8; // Maximum for key in TCKEYREQ + Uint32 dataPos = 0; + TcKeyReq * const tcKeyReq = (TcKeyReq *)signal->getDataPtrSend(); + Uint32 * dataPtr = &tcKeyReq->scanInfo; + Uint32 tcKeyLength = TcKeyReq::StaticLength; + Uint32 tcKeyRequestInfo = indexOp->tcIndxReq->requestInfo; + AttributeBuffer::DataBufferIterator keyIter; + Uint32 keyLength = TcKeyReq::getKeyLength(tcKeyRequestInfo); + TcIndexData* indexData; + Uint32 transId1 = indexOp->tcIndxReq->transId1; + Uint32 transId2 = indexOp->tcIndxReq->transId2; + + const Uint8 opType = TcKeyReq::getOperationType(tcKeyRequestInfo); + + // Find index table + if ((indexData = c_theIndexes.getPtr(indexOp->tcIndxReq->indexId)) == NULL) { + jam(); + // Failed to find index record + TcIndxRef * const tcIndxRef = (TcIndxRef *)signal->getDataPtrSend(); + + tcIndxRef->connectPtr = indexOp->tcIndxReq->senderData; + tcIndxRef->transId[0] = regApiPtr->transid[0]; + tcIndxRef->transId[1] = regApiPtr->transid[1]; + tcIndxRef->errorCode = 4000; + sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, + TcIndxRef::SignalLength, JBB); + return; + } + tcKeyReq->transId1 = transId1; + tcKeyReq->transId2 = transId2; + tcKeyReq->tableId = indexData->indexId; + tcKeyLength += MIN(keyLength, keyBufSize); + tcKeyReq->tableSchemaVersion = indexOp->tcIndxReq->indexSchemaVersion; + TcKeyReq::setOperationType(tcKeyRequestInfo, + opType == ZREAD ? opType : ZREAD_EX); + TcKeyReq::setAIInTcKeyReq(tcKeyRequestInfo, 1); // Allways send one AttrInfo + TcKeyReq::setExecutingTrigger(tcKeyRequestInfo, 0); + BlockReference originalReceiver = regApiPtr->ndbapiBlockref; + regApiPtr->ndbapiBlockref = reference(); // Send result to me + tcKeyReq->senderData = indexOp->indexOpId; + indexOp->indexOpState = IOS_INDEX_ACCESS; + regApiPtr->executingIndexOp = regApiPtr->accumulatingIndexOp; + regApiPtr->accumulatingIndexOp = RNIL; + regApiPtr->isIndexOp = true; + + Uint32 remainingKey = indexOp->keyInfo.getSize(); + bool moreKeyData = indexOp->keyInfo.first(keyIter); + // *********** KEYINFO in TCKEYREQ *********** + while((dataPos < keyBufSize) && + (remainingKey-- != 0)) { + *dataPtr++ = *keyIter.data; + dataPos++; + moreKeyData = indexOp->keyInfo.next(keyIter); + } + // *********** ATTRINFO in TCKEYREQ *********** + tcKeyReq->attrLen = 1; // Primary key is stored as one attribute + AttributeHeader::init(dataPtr, indexData->primaryKeyPos, 0); + tcKeyLength++; + tcKeyReq->requestInfo = tcKeyRequestInfo; + EXECUTE_DIRECT(DBTC, GSN_TCKEYREQ, signal, tcKeyLength); + + /** + * "Fool" TC not to start commiting transaction since it always will + * have one outstanding lqhkeyreq + * This is later decreased when the index read is complete + */ + regApiPtr->lqhkeyreqrec++; + + /** + * Remember ptr to index read operation + * (used to set correct save point id on index operation later) + */ + indexOp->indexReadTcConnect = regApiPtr->lastTcConnect; + + jamEntry(); + // *********** KEYINFO *********** + if (moreKeyData) { + jam(); + // Send KEYINFO sequence + KeyInfo * const keyInfo = (KeyInfo *)signal->getDataPtrSend(); + + keyInfo->connectPtr = indexOp->tcIndxReq->apiConnectPtr; + keyInfo->transId[0] = transId1; + keyInfo->transId[1] = transId2; + dataPtr = (Uint32 *) &keyInfo->keyData; + dataPos = 0; + while(remainingKey-- != 0) {// If we have not read complete key + *dataPtr++ = *keyIter.data; + dataPos++; + if (dataPos == KeyInfo::DataLength) { + // Flush KEYINFO + EXECUTE_DIRECT(DBTC, GSN_KEYINFO, signal, + KeyInfo::HeaderLength + KeyInfo::DataLength); + jamEntry(); + dataPos = 0; + dataPtr = (Uint32 *) &keyInfo->keyData; + } + moreKeyData = indexOp->keyInfo.next(keyIter); + } + if (dataPos != 0) { + // Flush last KEYINFO + EXECUTE_DIRECT(DBTC, GSN_KEYINFO, signal, + KeyInfo::HeaderLength + dataPos); + jamEntry(); + } + } + + regApiPtr->ndbapiBlockref = originalReceiver; // reset original receiver +} + +/** + * Execute the index operation with the result from + * the index table read as PK + */ +void Dbtc::executeIndexOperation(Signal* signal, + ApiConnectRecord* regApiPtr, + TcIndexOperation* indexOp) { + + Uint32 keyBufSize = 8; // Maximum for key in TCKEYREQ + Uint32 attrBufSize = 5; + Uint32 dataPos = 0; + TcIndxReq * const tcIndxReq = indexOp->tcIndxReq; + TcKeyReq * const tcKeyReq = (TcKeyReq *)signal->getDataPtrSend(); + Uint32 * dataPtr = &tcKeyReq->scanInfo; + Uint32 tcKeyLength = TcKeyReq::StaticLength; + Uint32 tcKeyRequestInfo = tcIndxReq->requestInfo; + TcIndexData* indexData; + AttributeBuffer::DataBufferIterator attrIter; + AttributeBuffer::DataBufferIterator aiIter; + bool moreKeyData = indexOp->transIdAI.first(aiIter); + + // Find index table + if ((indexData = c_theIndexes.getPtr(tcIndxReq->indexId)) == NULL) { + jam(); + // Failed to find index record + TcIndxRef * const tcIndxRef = (TcIndxRef *)signal->getDataPtrSend(); + + tcIndxRef->connectPtr = indexOp->tcIndxReq->senderData; + tcIndxRef->transId[0] = regApiPtr->transid[0]; + tcIndxRef->transId[1] = regApiPtr->transid[1]; + tcIndxRef->errorCode = 4349; + sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, + TcIndxRef::SignalLength, JBB); + return; + } + // Find schema version of primary table + TableRecordPtr tabPtr; + tabPtr.i = indexData->primaryTableId; + ptrCheckGuard(tabPtr, ctabrecFilesize, tableRecord); + + tcKeyReq->apiConnectPtr = tcIndxReq->apiConnectPtr; + tcKeyReq->attrLen = tcIndxReq->attrLen; + tcKeyReq->tableId = indexData->primaryTableId; + tcKeyReq->tableSchemaVersion = tabPtr.p->currentSchemaVersion; + tcKeyReq->transId1 = regApiPtr->transid[0]; + tcKeyReq->transId2 = regApiPtr->transid[1]; + tcKeyReq->senderData = tcIndxReq->senderData; // Needed for TRANSID_AI to API + indexOp->indexOpState = IOS_INDEX_OPERATION; + regApiPtr->isIndexOp = true; + regApiPtr->executingIndexOp = indexOp->indexOpId;; + regApiPtr->noIndexOp++; // Increase count + + // Filter out AttributeHeader:s since this should not be in key + AttributeHeader* attrHeader = (AttributeHeader *) aiIter.data; + + Uint32 headerSize = attrHeader->getHeaderSize(); + Uint32 keySize = attrHeader->getDataSize(); + TcKeyReq::setKeyLength(tcKeyRequestInfo, keySize); + // Skip header + if (headerSize == 1) { + jam(); + moreKeyData = indexOp->transIdAI.next(aiIter); + } else { + jam(); + moreKeyData = indexOp->transIdAI.next(aiIter, headerSize - 1); + }//if + while(// If we have not read complete key + (keySize != 0) && + (dataPos < keyBufSize)) { + *dataPtr++ = *aiIter.data; + dataPos++; + keySize--; + moreKeyData = indexOp->transIdAI.next(aiIter); + } + tcKeyLength += dataPos; + + Uint32 attributesLength = indexOp->attrInfo.getSize(); + if (attributesLength <= attrBufSize) { + jam(); + // ATTRINFO fits in TCKEYREQ + // Pack ATTRINFO IN TCKEYREQ + TcKeyReq::setAIInTcKeyReq(tcKeyRequestInfo, indexOp->attrInfo.getSize()); + // Insert IndxAttrInfo + for(bool moreAttrData = indexOp->attrInfo.first(attrIter); + moreAttrData; + moreAttrData = indexOp->attrInfo.next(attrIter)) { + *dataPtr++ = *attrIter.data; + } + tcKeyLength += attributesLength; + } else { + jam(); + // No ATTRINFO in TCKEYREQ + TcKeyReq::setAIInTcKeyReq(tcKeyRequestInfo, 0); + } + + TcKeyReq::setCommitFlag(tcKeyRequestInfo, 0); + TcKeyReq::setExecuteFlag(tcKeyRequestInfo, 0); + TcKeyReq::setExecutingTrigger(tcKeyRequestInfo, 0); + tcKeyReq->requestInfo = tcKeyRequestInfo; + + /** + * Decrease lqhkeyreqrec to compensate for addition + * during read of index table + * I.e. let TC start committing when other operations has completed + */ + regApiPtr->lqhkeyreqrec--; + + /** + * Fix savepoint id - + * fix so that index operation has the same savepoint id + * as the read of the index table (TCINDXREQ) + */ + TcConnectRecordPtr tmp; + tmp.i = indexOp->indexReadTcConnect; + ptrCheckGuard(tmp, ctcConnectFilesize, tcConnectRecord); + const Uint32 currSavePointId = regApiPtr->currSavePointId; + regApiPtr->currSavePointId = tmp.p->savePointId; + EXECUTE_DIRECT(DBTC, GSN_TCKEYREQ, signal, tcKeyLength); + regApiPtr->currSavePointId = currSavePointId; + + jamEntry(); + // *********** KEYINFO *********** + if (moreKeyData) { + jam(); + // Send KEYINFO sequence + KeyInfo * const keyInfo = (KeyInfo *)signal->getDataPtrSend(); + + keyInfo->connectPtr = indexOp->tcIndxReq->apiConnectPtr; + keyInfo->transId[0] = regApiPtr->transid[0]; + keyInfo->transId[1] = regApiPtr->transid[1]; + dataPtr = (Uint32 *) &keyInfo->keyData; + dataPos = 0; + // Pack any part of a key attribute that did no fit TCKEYREQ + while(keySize-- != 0) {// If we have not read complete key + *dataPtr++ = *aiIter.data; + dataPos++; + if (dataPos == KeyInfo::DataLength) { + // Flush KEYINFO + EXECUTE_DIRECT(DBTC, GSN_KEYINFO, signal, + KeyInfo::HeaderLength + KeyInfo::DataLength); + jamEntry(); + dataPos = 0; + dataPtr = (Uint32 *) &keyInfo->keyData; + } + moreKeyData = indexOp->transIdAI.next(aiIter); + } + if (dataPos != 0) { + // Flush last KEYINFO + EXECUTE_DIRECT(DBTC, GSN_KEYINFO, signal, + KeyInfo::HeaderLength + dataPos); + jamEntry(); + } + } + + // *********** ATTRINFO *********** + if (attributesLength > attrBufSize) { + jam(); + // No ATTRINFO in TcKeyReq + TcKeyReq::setAIInTcKeyReq(tcKeyReq->requestInfo, 0); + // Send ATTRINFO sequence + AttrInfo * const attrInfo = (AttrInfo *)signal->getDataPtrSend(); + Uint32 attrInfoPos = 0; + + attrInfo->connectPtr = indexOp->tcIndxReq->apiConnectPtr; + attrInfo->transId[0] = regApiPtr->transid[0]; + attrInfo->transId[1] = regApiPtr->transid[1]; + dataPtr = (Uint32 *) &attrInfo->attrData; + + + // Insert attribute values (insert key values of primary table) + for(bool moreAttrData = indexOp->attrInfo.first(attrIter); + moreAttrData; + moreAttrData = indexOp->attrInfo.next(attrIter)) { + *dataPtr++ = *attrIter.data; + attrInfoPos++; + if (attrInfoPos == AttrInfo::DataLength) { + // Flush ATTRINFO + EXECUTE_DIRECT(DBTC, GSN_ATTRINFO, signal, + AttrInfo::HeaderLength + AttrInfo::DataLength); + jamEntry(); + attrInfoPos = 0; + dataPtr = (Uint32 *) &attrInfo->attrData; + } + } + if (attrInfoPos != 0) { + // Send last ATTRINFO + EXECUTE_DIRECT(DBTC, GSN_ATTRINFO, signal, + AttrInfo::HeaderLength + attrInfoPos); + jamEntry(); + } + } +} + +bool Dbtc::seizeIndexOperation(ApiConnectRecord* regApiPtr, + TcIndexOperationPtr& indexOpPtr) +{ + bool seizeOk; + + seizeOk = c_theIndexOperations.seize(indexOpPtr); + if (seizeOk) { + jam(); + TcSeizedIndexOperationPtr seizedIndexOpPtr; + seizeOk &= regApiPtr->theSeizedIndexOperations.seizeId(seizedIndexOpPtr, + indexOpPtr.i); + } + return seizeOk; +} + +void Dbtc::releaseIndexOperation(ApiConnectRecord* regApiPtr, + TcIndexOperation* indexOp) +{ + indexOp->indexOpState = IOS_NOOP; + indexOp->expectedKeyInfo = 0; + indexOp->keyInfo.release(); + indexOp->expectedAttrInfo = 0; + indexOp->attrInfo.release(); + indexOp->expectedTransIdAI = 0; + indexOp->transIdAI.release(); + regApiPtr->theSeizedIndexOperations.release(indexOp->indexOpId); + c_theIndexOperations.release(indexOp->indexOpId); +} + +void Dbtc::releaseAllSeizedIndexOperations(ApiConnectRecord* regApiPtr) +{ + TcSeizedIndexOperationPtr seizedIndexOpPtr; + + regApiPtr->theSeizedIndexOperations.first(seizedIndexOpPtr); + while(seizedIndexOpPtr.i != RNIL) { + jam(); + TcIndexOperation* indexOp = + c_theIndexOperations.getPtr(seizedIndexOpPtr.i); + + indexOp->indexOpState = IOS_NOOP; + indexOp->expectedKeyInfo = 0; + indexOp->keyInfo.release(); + indexOp->expectedAttrInfo = 0; + indexOp->attrInfo.release(); + indexOp->expectedTransIdAI = 0; + indexOp->transIdAI.release(); + c_theIndexOperations.release(seizedIndexOpPtr.i); + regApiPtr->theSeizedIndexOperations.next(seizedIndexOpPtr); + } + regApiPtr->theSeizedIndexOperations.release(); +} + +void Dbtc::saveTriggeringOpState(Signal* signal, TcConnectRecord* trigOp) +{ + LqhKeyConf * lqhKeyConf = (LqhKeyConf *)signal->getDataPtr(); + copyFromToLen((UintR*)lqhKeyConf, + &trigOp->savedState[0], + LqhKeyConf::SignalLength); +} + +void Dbtc::restoreTriggeringOpState(Signal* signal, TcConnectRecord* trigOp) +{ + LqhKeyConf * lqhKeyConf = (LqhKeyConf *)signal->getDataPtr(); + copyFromToLen(&trigOp->savedState[0], + (UintR*)lqhKeyConf, + LqhKeyConf::SignalLength); + lqhKeyConf->noFiredTriggers = 0; +} + +void Dbtc::continueTriggeringOp(Signal* signal, TcConnectRecord* trigOp) +{ + restoreTriggeringOpState(signal, trigOp); + trigOp->noReceivedTriggers = 0; + if (trigOp->triggerError != 0) { + // A trigger operation has failed + LqhKeyConf * lqhKeyConf = (LqhKeyConf *)signal->getDataPtr(); + LqhKeyRef * lqhKeyRef = (LqhKeyRef *)signal->getDataPtrSend(); + // Copy fields to avoid overwrite + Uint32 opPtr = lqhKeyConf->opPtr; + Uint32 userRef = lqhKeyConf->userRef; + Uint32 transId1 = lqhKeyConf->transId1; + Uint32 transId2 = lqhKeyConf->transId2; + + lqhKeyRef->connectPtr = opPtr; + lqhKeyRef->userRef = userRef; + if (trigOp->triggerError == 630) { // Tuple already existed + jam(); + lqhKeyRef->errorCode = 893; // Constraint violation + } else { + jam(); + lqhKeyRef->errorCode = trigOp->triggerError; + }//if + lqhKeyRef->transId1 = transId1; + lqhKeyRef->transId2 = transId2; + handleFailedOperation(signal, lqhKeyRef, false); + } else { + jam(); + // All triggers executed successfully, continue operation + execLQHKEYCONF(signal); + }//if +} + +void Dbtc::scheduleFiredTrigger(ApiConnectRecordPtr* transPtr, + TcConnectRecordPtr* opPtr) +{ + // Set initial values for trigger fireing operation + opPtr->p->triggerExecutionCount++; + opPtr->p->triggerError = 0; + // Insert fired trigger in execution queue + transPtr->p->theFiredTriggers.add(opPtr->p->accumulatingTriggerData); + opPtr->p->accumulatingTriggerData.i = RNIL; + opPtr->p->accumulatingTriggerData.p = NULL; +} + +void Dbtc::executeTriggers(Signal* signal, ApiConnectRecordPtr* transPtr) +{ + ApiConnectRecord* regApiPtr = transPtr->p; + TcConnectRecord *localTcConnectRecord = tcConnectRecord; + TcConnectRecordPtr opPtr; + FiredTriggerPtr trigPtr; + + if (!regApiPtr->theFiredTriggers.isEmpty()) { + jam(); + if ((regApiPtr->apiConnectstate == CS_STARTED) || + (regApiPtr->apiConnectstate == CS_START_COMMITTING)) { + jam(); + regApiPtr->theFiredTriggers.first(trigPtr); + while (trigPtr.i != RNIL) { + jam(); + // Execute all ready triggers in parallel + opPtr.i = trigPtr.p->fireingOperation; + ptrCheckGuard(opPtr, ctcConnectFilesize, localTcConnectRecord); + FiredTriggerPtr nextTrigPtr; + nextTrigPtr.i = trigPtr.i; + nextTrigPtr.p = trigPtr.p; + regApiPtr->theFiredTriggers.next(nextTrigPtr); + if (opPtr.p->noReceivedTriggers == opPtr.p->noFiredTriggers) { + jam(); + // Fireing operation is ready to have a trigger executing + executeTrigger(signal, trigPtr.p, transPtr, &opPtr); + // Should allow for interleaving here by sending a CONTINUEB and + // return + // Release trigger records + trigPtr.p->keyValues.release(); + trigPtr.p->beforeValues.release(); + trigPtr.p->afterValues.release(); + regApiPtr->theFiredTriggers.release(trigPtr.i); + } + trigPtr = nextTrigPtr; + } + return; + // No more triggers, continue transaction after last executed trigger has + // reurned (in execLQHKEYCONF or execLQHKEYREF) + } else { + // Wait until transaction is ready to execute a trigger + jam(); + if (!regApiPtr->triggerPending) { + jam(); + regApiPtr->triggerPending = true; + signal->theData[0] = TcContinueB::TRIGGER_PENDING; + signal->theData[1] = transPtr->i; + sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB); + } + // else + // We are already waiting for a pending trigger (CONTINUEB) + } + } +} + +void Dbtc::executeTrigger(Signal* signal, + TcFiredTriggerData* firedTriggerData, + ApiConnectRecordPtr* transPtr, + TcConnectRecordPtr* opPtr) +{ + TcDefinedTriggerData* definedTriggerData; + + if ((definedTriggerData = + c_theDefinedTriggers.getPtr(firedTriggerData->triggerId)) + != NULL) { + switch(definedTriggerData->triggerType) { + case(TriggerType::SECONDARY_INDEX): + jam(); + executeIndexTrigger(signal, definedTriggerData, firedTriggerData, + transPtr, opPtr); + break; + default: + ndbrequire(false); + } + } +} + +void Dbtc::executeIndexTrigger(Signal* signal, + TcDefinedTriggerData* definedTriggerData, + TcFiredTriggerData* firedTriggerData, + ApiConnectRecordPtr* transPtr, + TcConnectRecordPtr* opPtr) +{ + TcIndexData* indexData; + + indexData = c_theIndexes.getPtr(definedTriggerData->indexId); + ndbassert(indexData != NULL); + + switch (definedTriggerData->triggerEvent) { + case(TriggerEvent::TE_INSERT): { + jam(); + insertIntoIndexTable(signal, firedTriggerData, transPtr, opPtr, indexData); + break; + } + case(TriggerEvent::TE_DELETE): { + jam(); + deleteFromIndexTable(signal, firedTriggerData, transPtr, opPtr, indexData); + break; + } + case(TriggerEvent::TE_UPDATE): { + jam(); + deleteFromIndexTable(signal, firedTriggerData, transPtr, opPtr, + indexData, true); // Hold the triggering operation + insertIntoIndexTable(signal, firedTriggerData, transPtr, opPtr, indexData); + break; + } + default: + ndbrequire(false); + } +} + +void Dbtc::releaseFiredTriggerData(DLFifoList* triggers) +{ + FiredTriggerPtr trigPtr; + + triggers->first(trigPtr); + while (trigPtr.i != RNIL) { + jam(); + // Release trigger records + trigPtr.p->keyValues.release(); + trigPtr.p->beforeValues.release(); + trigPtr.p->afterValues.release(); + triggers->next(trigPtr); + } + triggers->release(); +} + +void Dbtc::insertIntoIndexTable(Signal* signal, + TcFiredTriggerData* firedTriggerData, + ApiConnectRecordPtr* transPtr, + TcConnectRecordPtr* opPtr, + TcIndexData* indexData, + bool holdOperation) +{ + ApiConnectRecord* regApiPtr = transPtr->p; + TcConnectRecord* opRecord = opPtr->p; + TcKeyReq * const tcKeyReq = (TcKeyReq *)signal->getDataPtrSend(); + Uint32 tcKeyRequestInfo = 0; + Uint32 tcKeyLength = TcKeyReq::StaticLength; + TableRecordPtr indexTabPtr; + AttributeBuffer::DataBufferIterator iter; + Uint32 attrId = 0; + Uint32 keyLength = 0; + Uint32 totalPrimaryKeyLength = 0; + Uint32 hops; + + indexTabPtr.i = indexData->indexId; + ptrCheckGuard(indexTabPtr, ctabrecFilesize, tableRecord); + tcKeyReq->apiConnectPtr = transPtr->i; + tcKeyReq->senderData = opPtr->i; + if (holdOperation) { + jam(); + opRecord->triggerExecutionCount++; + }//if + // Calculate key length and renumber attribute id:s + for(bool moreKeyAttrs = firedTriggerData->afterValues.first(iter); + moreKeyAttrs; + attrId++) { + jam(); + AttributeHeader* attrHeader = (AttributeHeader *) iter.data; + + attrHeader->setAttributeId(attrId); + keyLength += attrHeader->getDataSize(); + hops = attrHeader->getHeaderSize() + attrHeader->getDataSize(); + moreKeyAttrs = firedTriggerData->afterValues.next(iter, hops); + } + + // Filter out single NULL attributes + if (attrId == 1) { + jam(); + firedTriggerData->afterValues.first(iter); + AttributeHeader* attrHeader = (AttributeHeader *) iter.data; + if (attrHeader->isNULL() && !firedTriggerData->afterValues.next(iter)) { + jam(); + opRecord->triggerExecutionCount--; + if (opRecord->triggerExecutionCount == 0) { + /* + We have completed current trigger execution + Continue triggering operation + */ + jam(); + continueTriggeringOp(signal, opRecord); + }//if + return; + }//if + }//if + + // Calculate total length of primary key to be stored in index table + for(bool moreAttrData = firedTriggerData->keyValues.first(iter); + (moreAttrData); + moreAttrData = firedTriggerData->keyValues.next(iter, hops)) { + jam(); + AttributeHeader* attrHeader = (AttributeHeader *) iter.data; + + totalPrimaryKeyLength += attrHeader->getDataSize(); + hops = attrHeader->getHeaderSize() + attrHeader->getDataSize(); + } + AttributeHeader pkAttrHeader(attrId, totalPrimaryKeyLength); + + TcKeyReq::setKeyLength(tcKeyRequestInfo, keyLength); + tcKeyReq->attrLen = + firedTriggerData->afterValues.getSize() + + pkAttrHeader.getHeaderSize() + pkAttrHeader.getDataSize(); + tcKeyReq->tableId = indexData->indexId; + TcKeyReq::setOperationType(tcKeyRequestInfo, ZINSERT); + TcKeyReq::setExecutingTrigger(tcKeyRequestInfo, true); + tcKeyReq->tableSchemaVersion = indexTabPtr.p->currentSchemaVersion; + tcKeyReq->transId1 = regApiPtr->transid[0]; + tcKeyReq->transId2 = regApiPtr->transid[1]; + Uint32 * dataPtr = &tcKeyReq->scanInfo; + // Write first part of key in TCKEYREQ + Uint32 keyBufSize = 8; // Maximum for key in TCKEYREQ + Uint32 attrBufSize = 5; // Maximum for key in TCKEYREQ + Uint32 dataPos = 0; + // Filter out AttributeHeader:s since this should no be in key + bool moreKeyData = firedTriggerData->afterValues.first(iter); + Uint32 headerSize = 0, keyAttrSize = 0, dataSize = 0, headAndData = 0; + + while (moreKeyData && + (dataPos < keyBufSize)) { + /* + If we have not read complete key + and it fits in the signal + */ + jam(); + AttributeHeader* attrHeader = (AttributeHeader *) iter.data; + + headerSize = attrHeader->getHeaderSize(); + keyAttrSize = attrHeader->getDataSize(); + headAndData = headerSize + attrHeader->getDataSize(); + // Skip header + if (headerSize == 1) { + jam(); + moreKeyData = firedTriggerData->afterValues.next(iter); + } else { + jam(); + moreKeyData = firedTriggerData->afterValues.next(iter, headerSize - 1); + }//if + while((keyAttrSize != 0) && + (dataPos < keyBufSize)) { + // If we have not read complete key + jam(); + *dataPtr++ = *iter.data; + dataPos++; + keyAttrSize--; + moreKeyData = firedTriggerData->afterValues.next(iter); + } + if (keyAttrSize != 0) { + jam(); + break; + }//if + } + + tcKeyLength += dataPos; + Uint32 attributesLength = + firedTriggerData->afterValues.getSize() + + pkAttrHeader.getHeaderSize() + pkAttrHeader.getDataSize(); + if (attributesLength <= attrBufSize) { + jam(); + // ATTRINFO fits in TCKEYREQ + // Pack ATTRINFO IN TCKEYREQ as one attribute + TcKeyReq::setAIInTcKeyReq(tcKeyRequestInfo, attributesLength); + bool moreAttrData; + // Insert primary key attributes (insert after values of primary table) + for(moreAttrData = firedTriggerData->afterValues.first(iter); + moreAttrData; + moreAttrData = firedTriggerData->afterValues.next(iter)) { + *dataPtr++ = *iter.data; + } + // Insert attribute values (insert key values of primary table) + // as one attribute + pkAttrHeader.insertHeader(dataPtr); + dataPtr += pkAttrHeader.getHeaderSize(); + moreAttrData = firedTriggerData->keyValues.first(iter); + while(moreAttrData) { + jam(); + AttributeHeader* attrHeader = (AttributeHeader *) iter.data; + + headerSize = attrHeader->getHeaderSize(); + dataSize = attrHeader->getDataSize(); + // Skip header + if (headerSize == 1) { + jam(); + moreAttrData = firedTriggerData->keyValues.next(iter); + } else { + jam(); + moreAttrData = firedTriggerData->keyValues.next(iter, headerSize - 1); + }//if + // Copy attribute data + while(dataSize-- != 0) { + *dataPtr++ = *iter.data; + moreAttrData = firedTriggerData->keyValues.next(iter); + } + } + tcKeyLength += attributesLength; + } else { + jam(); + // No ATTRINFO in TCKEYREQ + TcKeyReq::setAIInTcKeyReq(tcKeyRequestInfo, 0); + } + tcKeyReq->requestInfo = tcKeyRequestInfo; + + /** + * Fix savepoint id - + * fix so that insert has same savepoint id as triggering operation + */ + const Uint32 currSavePointId = regApiPtr->currSavePointId; + regApiPtr->currSavePointId = opRecord->savePointId; + EXECUTE_DIRECT(DBTC, GSN_TCKEYREQ, signal, tcKeyLength); + regApiPtr->currSavePointId = currSavePointId; + tcConnectptr.p->currentIndexId = indexData->indexId; + jamEntry(); + + // *********** KEYINFO *********** + if (moreKeyData) { + jam(); + // Send KEYINFO sequence + KeyInfo * const keyInfo = (KeyInfo *)signal->getDataPtrSend(); + + keyInfo->connectPtr = transPtr->i; + keyInfo->transId[0] = regApiPtr->transid[0]; + keyInfo->transId[1] = regApiPtr->transid[1]; + dataPtr = (Uint32 *) &keyInfo->keyData; + dataPos = 0; + // Pack any part of a key attribute that did no fit TCKEYREQ + while((keyAttrSize != 0) && + (dataPos < KeyInfo::DataLength)) { + // If we have not read complete key + *dataPtr++ = *iter.data; + dataPos++; + keyAttrSize--; + if (dataPos == KeyInfo::DataLength) { + jam(); + // Flush KEYINFO +#if INTERNAL_TRIGGER_TCKEYREQ_JBA + sendSignal(reference(), GSN_KEYINFO, signal, + KeyInfo::HeaderLength + KeyInfo::DataLength, JBA); +#else + EXECUTE_DIRECT(DBTC, GSN_KEYINFO, signal, + KeyInfo::HeaderLength + KeyInfo::DataLength); + jamEntry(); +#endif + dataPtr = (Uint32 *) &keyInfo->keyData; + dataPos = 0; + } + moreKeyData = firedTriggerData->afterValues.next(iter); + } + + while(moreKeyData) { + jam(); + AttributeHeader* attrHeader = (AttributeHeader *) iter.data; + + headerSize = attrHeader->getHeaderSize(); + keyAttrSize = attrHeader->getDataSize(); + headAndData = headerSize + attrHeader->getDataSize(); + // Skip header + if (headerSize == 1) { + jam(); + moreKeyData = firedTriggerData->afterValues.next(iter); + } else { + jam(); + moreKeyData = firedTriggerData->afterValues.next(iter, + headerSize - 1); + }//if + while (keyAttrSize-- != 0) { + *dataPtr++ = *iter.data; + dataPos++; + if (dataPos == KeyInfo::DataLength) { + jam(); + // Flush KEYINFO +#if INTERNAL_TRIGGER_TCKEYREQ_JBA + sendSignal(reference(), GSN_KEYINFO, signal, + KeyInfo::HeaderLength + KeyInfo::DataLength, JBA); +#else + EXECUTE_DIRECT(DBTC, GSN_KEYINFO, signal, + KeyInfo::HeaderLength + KeyInfo::DataLength); + jamEntry(); +#endif + dataPtr = (Uint32 *) &keyInfo->keyData; + dataPos = 0; + } + moreKeyData = firedTriggerData->afterValues.next(iter); + } + } + if (dataPos != 0) { + jam(); + // Flush last KEYINFO +#if INTERNAL_TRIGGER_TCKEYREQ_JBA + sendSignal(reference(), GSN_KEYINFO, signal, + KeyInfo::HeaderLength + dataPos, JBA); +#else + EXECUTE_DIRECT(DBTC, GSN_KEYINFO, signal, + KeyInfo::HeaderLength + dataPos); + jamEntry(); +#endif + } + } + + // *********** ATTRINFO *********** + if (attributesLength > attrBufSize) { + jam(); + // No ATTRINFO in TcKeyReq + TcKeyReq::setAIInTcKeyReq(tcKeyReq->requestInfo, 0); + // Send ATTRINFO sequence + AttrInfo * const attrInfo = (AttrInfo *)signal->getDataPtrSend(); + Uint32 attrInfoPos = 0; + + attrInfo->connectPtr = transPtr->i; + attrInfo->transId[0] = regApiPtr->transid[0]; + attrInfo->transId[1] = regApiPtr->transid[1]; + dataPtr = (Uint32 *) &attrInfo->attrData; + + bool moreAttrData; + // Insert primary key attributes (insert after values of primary table) + for(moreAttrData = firedTriggerData->afterValues.first(iter); + moreAttrData; + moreAttrData = firedTriggerData->afterValues.next(iter)) { + *dataPtr++ = *iter.data; + attrInfoPos++; + if (attrInfoPos == AttrInfo::DataLength) { + jam(); + // Flush ATTRINFO +#if INTERNAL_TRIGGER_TCKEYREQ_JBA + sendSignal(reference(), GSN_ATTRINFO, signal, + AttrInfo::HeaderLength + AttrInfo::DataLength, JBA); +#else + EXECUTE_DIRECT(DBTC, GSN_ATTRINFO, signal, + AttrInfo::HeaderLength + AttrInfo::DataLength); + jamEntry(); +#endif + dataPtr = (Uint32 *) &attrInfo->attrData; + attrInfoPos = 0; + } + } + // Insert attribute values (insert key values of primary table) + // as one attribute + pkAttrHeader.insertHeader(dataPtr); + dataPtr += pkAttrHeader.getHeaderSize(); + attrInfoPos += pkAttrHeader.getHeaderSize(); + moreAttrData = firedTriggerData->keyValues.first(iter); + while(moreAttrData) { + jam(); + AttributeHeader* attrHeader = (AttributeHeader *) iter.data; + + headerSize = attrHeader->getHeaderSize(); + dataSize = attrHeader->getDataSize(); + // Skip header + if (headerSize == 1) { + jam(); + moreAttrData = firedTriggerData->keyValues.next(iter); + } else { + jam(); + moreAttrData = firedTriggerData->keyValues.next(iter, + headerSize - 1); + }//if + while(dataSize-- != 0) { // If we have not read complete key + if (attrInfoPos == AttrInfo::DataLength) { + jam(); + // Flush ATTRINFO +#if INTERNAL_TRIGGER_TCKEYREQ_JBA + sendSignal(reference(), GSN_ATTRINFO, signal, + AttrInfo::HeaderLength + AttrInfo::DataLength, JBA); +#else + EXECUTE_DIRECT(DBTC, GSN_ATTRINFO, signal, + AttrInfo::HeaderLength + AttrInfo::DataLength); + jamEntry(); +#endif + dataPtr = (Uint32 *) &attrInfo->attrData; + attrInfoPos = 0; + } + *dataPtr++ = *iter.data; + attrInfoPos++; + moreAttrData = firedTriggerData->keyValues.next(iter); + } + } + if (attrInfoPos != 0) { + jam(); + // Flush last ATTRINFO +#if INTERNAL_TRIGGER_TCKEYREQ_JBA + sendSignal(reference(), GSN_ATTRINFO, signal, + AttrInfo::HeaderLength + attrInfoPos, JBA); +#else + EXECUTE_DIRECT(DBTC, GSN_ATTRINFO, signal, + AttrInfo::HeaderLength + attrInfoPos); + jamEntry(); +#endif + } + } +} + +void Dbtc::deleteFromIndexTable(Signal* signal, + TcFiredTriggerData* firedTriggerData, + ApiConnectRecordPtr* transPtr, + TcConnectRecordPtr* opPtr, + TcIndexData* indexData, + bool holdOperation) +{ + ApiConnectRecord* regApiPtr = transPtr->p; + TcConnectRecord* opRecord = opPtr->p; + TcKeyReq * const tcKeyReq = (TcKeyReq *)signal->getDataPtrSend(); + Uint32 tcKeyRequestInfo = 0; + Uint32 tcKeyLength = 12; // Static length + TableRecordPtr indexTabPtr; + AttributeBuffer::DataBufferIterator iter; + Uint32 attrId = 0; + Uint32 keyLength = 0; + Uint32 hops; + + indexTabPtr.i = indexData->indexId; + ptrCheckGuard(indexTabPtr, ctabrecFilesize, tableRecord); + tcKeyReq->apiConnectPtr = transPtr->i; + tcKeyReq->senderData = opPtr->i; + if (holdOperation) { + jam(); + opRecord->triggerExecutionCount++; + }//if + // Calculate key length and renumber attribute id:s + for(bool moreKeyAttrs = firedTriggerData->beforeValues.first(iter); + (moreKeyAttrs); + attrId++) { + jam(); + AttributeHeader* attrHeader = (AttributeHeader *) iter.data; + + attrHeader->setAttributeId(attrId); + keyLength += attrHeader->getDataSize(); + hops = attrHeader->getHeaderSize() + attrHeader->getDataSize(); + moreKeyAttrs = firedTriggerData->beforeValues.next(iter, hops); + } + + // Filter out single NULL attributes + if (attrId == 1) { + jam(); + firedTriggerData->beforeValues.first(iter); + AttributeHeader* attrHeader = (AttributeHeader *) iter.data; + if (attrHeader->isNULL() && !firedTriggerData->beforeValues.next(iter)) { + jam(); + opRecord->triggerExecutionCount--; + if (opRecord->triggerExecutionCount == 0) { + /* + We have completed current trigger execution + Continue triggering operation + */ + jam(); + continueTriggeringOp(signal, opRecord); + }//if + return; + }//if + }//if + + TcKeyReq::setKeyLength(tcKeyRequestInfo, keyLength); + tcKeyReq->attrLen = 0; + tcKeyReq->tableId = indexData->indexId; + TcKeyReq::setOperationType(tcKeyRequestInfo, ZDELETE); + TcKeyReq::setExecutingTrigger(tcKeyRequestInfo, true); + tcKeyReq->tableSchemaVersion = indexTabPtr.p->currentSchemaVersion; + tcKeyReq->transId1 = regApiPtr->transid[0]; + tcKeyReq->transId2 = regApiPtr->transid[1]; + Uint32 * dataPtr = &tcKeyReq->scanInfo; + // Write first part of key in TCKEYREQ + Uint32 keyBufSize = 8; // Maximum for key in TCKEYREQ + Uint32 dataPos = 0; + // Filter out AttributeHeader:s since this should no be in key + bool moreKeyData = firedTriggerData->beforeValues.first(iter); + Uint32 headerSize = 0, keyAttrSize = 0, headAndData = 0; + + while (moreKeyData && + (dataPos < keyBufSize)) { + /* + If we have not read complete key + and it fits in the signal + */ + jam(); + AttributeHeader* attrHeader = (AttributeHeader *) iter.data; + + headerSize = attrHeader->getHeaderSize(); + keyAttrSize = attrHeader->getDataSize(); + headAndData = headerSize + attrHeader->getDataSize(); + // Skip header + if (headerSize == 1) { + jam(); + moreKeyData = firedTriggerData->beforeValues.next(iter); + } else { + jam(); + moreKeyData = firedTriggerData->beforeValues.next(iter, headerSize - 1); + }//if + while((keyAttrSize != 0) && + (dataPos < keyBufSize)) { + // If we have not read complete key + jam(); + *dataPtr++ = *iter.data; + dataPos++; + keyAttrSize--; + moreKeyData = firedTriggerData->beforeValues.next(iter); + } + if (keyAttrSize != 0) { + jam(); + break; + }//if + } + + tcKeyLength += dataPos; + tcKeyReq->requestInfo = tcKeyRequestInfo; + + /** + * Fix savepoint id - + * fix so that delete has same savepoint id as triggering operation + */ + const Uint32 currSavePointId = regApiPtr->currSavePointId; + regApiPtr->currSavePointId = opRecord->savePointId; + EXECUTE_DIRECT(DBTC, GSN_TCKEYREQ, signal, tcKeyLength); + regApiPtr->currSavePointId = currSavePointId; + tcConnectptr.p->currentIndexId = indexData->indexId; + jamEntry(); + + // *********** KEYINFO *********** + if (moreKeyData) { + jam(); + // Send KEYINFO sequence + KeyInfo * const keyInfo = (KeyInfo *)signal->getDataPtrSend(); + + keyInfo->connectPtr = transPtr->i; + keyInfo->transId[0] = regApiPtr->transid[0]; + keyInfo->transId[1] = regApiPtr->transid[1]; + dataPtr = (Uint32 *) &keyInfo->keyData; + dataPos = 0; + // Pack any part of a key attribute that did no fit TCKEYREQ + while((keyAttrSize != 0) && + (dataPos < KeyInfo::DataLength)) { + // If we have not read complete key + *dataPtr++ = *iter.data; + dataPos++; + keyAttrSize--; + if (dataPos == KeyInfo::DataLength) { + jam(); + // Flush KEYINFO +#if INTERNAL_TRIGGER_TCKEYREQ_JBA + sendSignal(reference(), GSN_KEYINFO, signal, + KeyInfo::HeaderLength + KeyInfo::DataLength, JBA); +#else + EXECUTE_DIRECT(DBTC, GSN_KEYINFO, signal, + KeyInfo::HeaderLength + KeyInfo::DataLength); + jamEntry(); +#endif + dataPtr = (Uint32 *) &keyInfo->keyData; + dataPos = 0; + } + moreKeyData = firedTriggerData->beforeValues.next(iter); + } + + while(moreKeyData) { + jam(); + AttributeHeader* attrHeader = (AttributeHeader *) iter.data; + + headerSize = attrHeader->getHeaderSize(); + keyAttrSize = attrHeader->getDataSize(); + headAndData = headerSize + attrHeader->getDataSize(); + // Skip header + if (headerSize == 1) { + jam(); + moreKeyData = firedTriggerData->beforeValues.next(iter); + } else { + jam(); + moreKeyData = firedTriggerData->beforeValues.next(iter, + headerSize - 1); + }//if + while (keyAttrSize-- != 0) { + *dataPtr++ = *iter.data; + dataPos++; + if (dataPos == KeyInfo::DataLength) { + jam(); + // Flush KEYINFO +#if INTERNAL_TRIGGER_TCKEYREQ_JBA + sendSignal(reference(), GSN_KEYINFO, signal, + KeyInfo::HeaderLength + KeyInfo::DataLength, JBA); +#else + EXECUTE_DIRECT(DBTC, GSN_KEYINFO, signal, + KeyInfo::HeaderLength + KeyInfo::DataLength); + jamEntry(); +#endif + dataPtr = (Uint32 *) &keyInfo->keyData; + dataPos = 0; + } + moreKeyData = firedTriggerData->beforeValues.next(iter); + } + } + if (dataPos != 0) { + jam(); + // Flush last KEYINFO +#if INTERNAL_TRIGGER_TCKEYREQ_JBA + sendSignal(reference(), GSN_KEYINFO, signal, + KeyInfo::HeaderLength + dataPos, JBA); +#else + EXECUTE_DIRECT(DBTC, GSN_KEYINFO, signal, + KeyInfo::HeaderLength + dataPos); + jamEntry(); +#endif + } + } +} + +Uint32 +Dbtc::TableRecord::getErrorCode(Uint32 schemaVersion) const { + if(!enabled) + return ZNO_SUCH_TABLE; + if(dropping) + return ZDROP_TABLE_IN_PROGRESS; + if(schemaVersion != currentSchemaVersion) + return ZWRONG_SCHEMA_VERSION_ERROR; + ErrorReporter::handleAssert("Dbtc::TableRecord::getErrorCode", + __FILE__, __LINE__); + return 0; +} + diff --git a/ndb/src/kernel/blocks/dbtc/Makefile b/ndb/src/kernel/blocks/dbtc/Makefile new file mode 100644 index 00000000000..ae876ab1f84 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtc/Makefile @@ -0,0 +1,11 @@ +include .defs.mk + +TYPE := kernel + +ARCHIVE_TARGET := dbtc +SOURCES = \ + DbtcInit.cpp \ + DbtcMain.cpp + +include $(NDB_TOP)/Epilogue.mk + diff --git a/ndb/src/kernel/blocks/dbtup/AttributeOffset.hpp b/ndb/src/kernel/blocks/dbtup/AttributeOffset.hpp new file mode 100644 index 00000000000..0f3881e9024 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/AttributeOffset.hpp @@ -0,0 +1,89 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef ATTRIBUTE_OFFSET_HPP +#define ATTRIBUTE_OFFSET_HPP + +class AttributeOffset { + friend class Dbtup; + +private: + static void setOffset(Uint32 & desc, Uint32 offset); + static void setNullFlagPos(Uint32 & desc, Uint32 offset); + + static Uint32 getOffset(const Uint32 &); + static Uint32 getNullFlagPos(const Uint32 &); + static Uint32 getNullFlagOffset(const Uint32 &); + static Uint32 getNullFlagBitOffset(const Uint32 &); + static bool isNULL(const Uint32 &, const Uint32 &); +}; + +#define AO_ATTRIBUTE_OFFSET_MASK (0xffff) +#define AO_NULL_FLAG_POS_MASK (0x7ff) +#define AO_NULL_FLAG_POS_SHIFT (21) +#define AO_NULL_FLAG_WORD_MASK (31) +#define AO_NULL_FLAG_OFFSET_SHIFT (5) + +inline +void +AttributeOffset::setOffset(Uint32 & desc, Uint32 offset){ + ASSERT_MAX(offset, AO_ATTRIBUTE_OFFSET_MASK, "AttributeOffset::setOffset"); + desc |= offset; +} + +inline +void +AttributeOffset::setNullFlagPos(Uint32 & desc, Uint32 pos){ + ASSERT_MAX(pos, AO_NULL_FLAG_POS_MASK, "AttributeOffset::setNullFlagPos"); + desc |= (pos << AO_NULL_FLAG_POS_SHIFT); +} + +inline +Uint32 +AttributeOffset::getOffset(const Uint32 & desc) +{ + return desc & AO_ATTRIBUTE_OFFSET_MASK; +} + +inline +Uint32 +AttributeOffset::getNullFlagPos(const Uint32 & desc) +{ + return ((desc >> AO_NULL_FLAG_POS_SHIFT) & AO_NULL_FLAG_POS_MASK); +} + +inline +Uint32 +AttributeOffset::getNullFlagOffset(const Uint32 & desc) +{ + return (getNullFlagPos(desc) >> AO_NULL_FLAG_OFFSET_SHIFT); +} + +inline +Uint32 +AttributeOffset::getNullFlagBitOffset(const Uint32 & desc) +{ + return (getNullFlagPos(desc) & AO_NULL_FLAG_WORD_MASK); +} + +inline +bool +AttributeOffset::isNULL(const Uint32 & pageWord, const Uint32 & desc) +{ + return (((pageWord >> getNullFlagBitOffset(desc)) & 1) == 1); +} + +#endif diff --git a/ndb/src/kernel/blocks/dbtup/Dbtup.hpp b/ndb/src/kernel/blocks/dbtup/Dbtup.hpp new file mode 100644 index 00000000000..053b853fa82 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/Dbtup.hpp @@ -0,0 +1,2359 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DBTUP_H +#define DBTUP_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define ZWORDS_ON_PAGE 8192 /* NUMBER OF WORDS ON A PAGE. */ +#define ZATTRBUF_SIZE 32 /* SIZE OF ATTRIBUTE RECORD BUFFER */ +#define ZMIN_PAGE_LIMIT_TUPKEYREQ 5 +#define ZTUP_VERSION_BITS 15 + +typedef bool (Dbtup::* ReadFunction)(Uint32*, + AttributeHeader*, + Uint32, + Uint32); +typedef bool (Dbtup::* UpdateFunction)(Uint32*, + Uint32, + Uint32); + +#ifdef DBTUP_C +//------------------------------------------------------------------ +// Jam Handling: +// +// When DBTUP reports lines through jam in the trace files it has to +// be interpreted. 4024 means as an example line 24 in DbtupCommit.cpp +// Thus 4000 is added to the line number beacuse it is located in the +// file DbtupCommit.cpp. The following is the exhaustive list of the +// added value in the various files. ndbrequire, ptrCheckGuard still +// only reports the line number in the file it currently is located in. +// +// DbtupExecQuery.cpp 0 +// DbtupBuffer.cpp 2000 +// DbtupRoutines.cpp 3000 +// DbtupCommit.cpp 5000 +// DbtupFixAlloc.cpp 6000 +// DbtupTrigger.cpp 7000 +// DbtupAbort.cpp 9000 +// DbtupLCP.cpp 10000 +// DbtupUndoLog.cpp 12000 +// DbtupPageMap.cpp 14000 +// DbtupPagMan.cpp 16000 +// DbtupStoredProcDef.cpp 18000 +// DbtupMeta.cpp 20000 +// DbtupTabDesMan.cpp 22000 +// DbtupGen.cpp 24000 +// DbtupSystemRestart.cpp 26000 +// DbtupIndex.cpp 28000 +// DbtupDebug.cpp 30000 +//------------------------------------------------------------------ + +/* +2.2 LOCAL SYMBOLS +----------------- +*/ +/* ---------------------------------------------------------------- */ +/* S I Z E O F R E C O R D S */ +/* ---------------------------------------------------------------- */ +#define ZNO_OF_ATTRBUFREC 10000 /* SIZE OF ATTRIBUTE INFO FILE */ +#define ZNO_OF_CONCURRENT_OPEN_OP 40 /* NUMBER OF CONCURRENT OPENS */ +#define ZNO_OF_CONCURRENT_WRITE_OP 80 /* NUMBER OF CONCURRENT DISK WRITES*/ +#define ZNO_OF_FRAGOPREC 20 /* NUMBER OF CONCURRENT ADD FRAG. */ +#define ZNO_OF_FRAGREC 64 /* SIZE OF FRAGMENT FILE. */ +#define ZNO_OF_LCP_REC 10 /* NUMBER OF CONCURRENT CHECKPOINTS*/ +#define ZNO_OF_OPREC 116 /* SIZE OF OPERATION RECORD FILE */ +#define TOT_PAGE_RECORD_SPACE 262144 /* SIZE OF PAGE RECORD FILE. */ +#define ZNO_OF_PAGE TOT_PAGE_RECORD_SPACE/ZWORDS_ON_PAGE +#define ZNO_OF_PAGE_RANGE_REC 128 /* SIZE OF PAGE RANGE FILE */ +#define ZNO_OF_PARALLELL_UNDO_FILES 16 /* NUMBER OF PARALLEL UNDO FILES */ +#define ZNO_OF_RESTART_INFO_REC 10 /* MAXIMUM PARALLELL RESTART INFOS */ +#define ZNO_OF_TAB_DESCR_REC 484 /* SIZE OF TABLE DESCRIPTOR FILE */ +#define ZNO_OF_TABLEREC 16 /* SIZE OF TABLE RECORD FILE. */ +#ifdef NDB_OSE +#define ZNO_OF_UNDO_PAGE 80 // Must be multiple of 8 +#else +#define ZNO_OF_UNDO_PAGE 500 // Must be multiple of 8 +#endif + /* 24 SEGMENTS WITH 8 PAGES IN EACH*/ + /* PLUS ONE UNDO BUFFER CACHE */ +// Undo record identifiers are 32-bits with page index 13-bits +#define ZUNDO_RECORD_ID_PAGE_INDEX 13 /* 13 BITS = 8192 WORDS/PAGE */ +#define ZUNDO_RECORD_ID_PAGE_INDEX_MASK (ZWORDS_ON_PAGE - 1) /* 1111111111111 */ + +// Trigger constants +#define ZDEFAULT_MAX_NO_TRIGGERS_PER_TABLE 16 + +/* ---------------------------------------------------------------- */ +// VARIABLE NUMBERS OF PAGE_WORD, UNDO_WORD AND LOGIC_WORD FOR +// COMMUNICATION WITH FILE SYSTEM +/* ---------------------------------------------------------------- */ +#define ZBASE_ADDR_PAGE_WORD 1 /* BASE ADDRESS OF PAGE_WORD VAR */ +#define ZBASE_ADDR_UNDO_WORD 2 /* BASE ADDRESS OF UNDO_WORD VAR */ +#define ZBASE_ADDR_LOGIC_WORD 3 /* BASE ADDRESS OF LOGIC_WORD VAR */ + +/* ---------------------------------------------------------------- */ +// NUMBER OF PAGES SENT TO DISK IN DATA BUFFER AND UNDO BUFFER WHEN +// OPTIMUM PERFORMANCE IS ACHIEVED. +/* ---------------------------------------------------------------- */ +#define ZUB_SEGMENT_SIZE 8 /* SEGMENT SIZE OF UNDO BUFFER */ +#define ZDB_SEGMENT_SIZE 8 /* SEGMENT SIZE OF DATA BUFFER */ + +/* ---------------------------------------------------------------- */ +/* A ATTRIBUTE MAY BE NULL, DYNAMIC OR NORMAL. A NORMAL ATTRIBUTE */ +/* IS A ATTRIBUTE THAT IS NOT NULL OR DYNAMIC. A NULL ATTRIBUTE */ +/* MAY HAVE NO VALUE. A DYNAMIC ATTRIBUTE IS A NULL ATTRIBUTE THAT */ +/* DOES NOT HAVE TO BE A MEMBER OF EVERY TUPLE I A CERTAIN TABLE. */ +/* ---------------------------------------------------------------- */ +/** + * #defines moved into include/kernel/Interpreter.hpp + */ +#define ZMAX_REGISTER 21 +#define ZINSERT_DELETE 0 +/* ---------------------------------------------------------------- */ +/* THE MINIMUM SIZE OF AN 'EMPTY' TUPLE HEADER IN R-WORDS */ +/* ---------------------------------------------------------------- */ +#define ZTUP_HEAD_MINIMUM_SIZE 2 + /* THE TUPLE HEADER FIELD 'SIZE OF NULL ATTR. FIELD' SPECIFYES */ + /* THE SIZE OF THE TUPLE HEADER FIELD 'NULL ATTR. FIELD'. */ + /* THE TUPLE HEADER FIELD 'TYPE' SPECIFYES THE TYPE OF THE TUPLE */ + /* HEADER. */ + /* TUPLE ATTRIBUTE INDEX CLUSTERS, ATTRIBUTE */ + /* CLUSTERS AND A DYNAMIC ATTRIBUTE HEADER. */ + /* IT MAY ALSO CONTAIN SHORT ATTRIBUTES AND */ + /* POINTERS TO LONG ATTRIBUTE HEADERS. */ + /* TUPLE ATTRIBUTE INDEX CLUSTERS, ATTRIBUTE */ + /* CLUSTERS AND A DYNAMIC ATTRIBUTE HEADER. */ + +#define ZTH_TYPE3 2 /* TUPLE HEADER THAT MAY HAVE A POINTER TO */ + /* A DYNAMIC ATTRIBUTE HEADER. IT MAY ALSO */ + /* CONTAIN SHORT ATTRIBUTES AND POINTERS */ + /* TO LONG ATTRIBUTE HEADERS. */ + + /* DATA STRUCTURE TYPES */ + /* WHEN ATTRIBUTE INFO IS SENT WITH A ATTRINFO-SIGNAL THE */ + /* VARIABLE TYPE IS SPECIFYED. THIS MUST BE DONE TO BE ABLE TO */ + /* NOW HOW MUCH DATA OF A ATTRIBUTE TO READ FROM ATTRINFO. */ +#define ZFIXED_ARRAY 2 /* ZFIXED ARRAY FIELD. */ +#define ZNON_ARRAY 1 /* NORMAL FIELD. */ +#define ZVAR_ARRAY 0 /* VARIABLE ARRAY FIELD */ +#define ZNOT_STORE 3 /* THE ATTR IS STORED IN THE INDEX BLOCK */ +#define ZMAX_SMALL_VAR_ARRAY 256 + + /* PLEASE OBSERVE THAT THEESE CONSTANTS CORRESPONDS TO THE NUMBER */ + /* OF BITS NEEDED TO REPRESENT THEM D O N O T C H A N G E */ +#define Z1BIT_VAR 0 /* 1 BIT VARIABLE. */ +#define Z2BIT_VAR 1 /* 2 BIT VARIABLE. */ +#define Z4BIT_VAR 2 /* 4 BIT VARIABLE. */ +#define Z8BIT_VAR 3 /* 8 BIT VARIABLE. */ +#define Z16BIT_VAR 4 /* 16 BIT VARIABLE. */ +#define Z32BIT_VAR 5 /* 32 BIT VARIABLE. */ +#define Z64BIT_VAR 6 /* 64 BIT VARIABLE. */ +#define Z128BIT_VAR 7 /* 128 BIT VARIABLE. */ + + /* WHEN A REQUEST CAN NOT BE EXECUTED BECAUSE OF A ERROR THE */ + /* ERROR MUST BE IDENTIFYED BY MEANS OF A ERROR CODE AND SENT TO */ + /* THE REQUESTER. */ +#define ZGET_OPREC_ERROR 804 // TUP_SEIZEREF + +#define ZEXIST_FRAG_ERROR 816 // Add fragment +#define ZFULL_FRAGRECORD_ERROR 817 // Add fragment +#define ZNO_FREE_PAGE_RANGE_ERROR 818 // Add fragment +#define ZNOFREE_FRAGOP_ERROR 830 // Add fragment +#define ZTOO_LARGE_TUPLE_ERROR 851 // Add fragment +#define ZNO_FREE_TAB_ENTRY_ERROR 852 // Add fragment +#define ZNO_PAGES_ALLOCATED_ERROR 881 // Add fragment + +#define ZGET_REALPID_ERROR 809 +#define ZNOT_IMPLEMENTED_ERROR 812 +#define ZSEIZE_ATTRINBUFREC_ERROR 805 +#define ZTOO_MUCH_ATTRINFO_ERROR 823 +#define ZMEM_NOTABDESCR_ERROR 826 +#define ZMEM_NOMEM_ERROR 827 +#define ZAI_INCONSISTENCY_ERROR 829 +#define ZNO_ILLEGAL_NULL_ATTR 839 +#define ZNOT_NULL_ATTR 840 +#define ZNO_INSTRUCTION_ERROR 871 +#define ZOUTSIDE_OF_PROGRAM_ERROR 876 +#define ZSTORED_PROC_ID_ERROR 877 +#define ZREGISTER_INIT_ERROR 878 +#define ZATTRIBUTE_ID_ERROR 879 +#define ZTRY_TO_READ_TOO_MUCH_ERROR 880 +#define ZTOTAL_LEN_ERROR 882 +#define ZATTR_INTERPRETER_ERROR 883 +#define ZSTACK_OVERFLOW_ERROR 884 +#define ZSTACK_UNDERFLOW_ERROR 885 +#define ZTOO_MANY_INSTRUCTIONS_ERROR 886 +#define ZTRY_TO_UPDATE_ERROR 888 +#define ZCALL_ERROR 890 +#define ZTEMPORARY_RESOURCE_FAILURE 891 + +#define ZSTORED_SEIZE_ATTRINBUFREC_ERROR 873 // Part of Scan + +#define ZREAD_ONLY_CONSTRAINT_VIOLATION 893 +#define ZVAR_SIZED_NOT_SUPPORTED 894 +#define ZINCONSISTENT_NULL_ATTRIBUTE_COUNT 895 +#define ZTUPLE_CORRUPTED_ERROR 896 +#define ZTRY_UPDATE_PRIMARY_KEY 897 +#define ZMUST_BE_ABORTED_ERROR 898 +#define ZTUPLE_DELETED_ERROR 626 +#define ZINSERT_ERROR 630 + + + /* SOME WORD POSITIONS OF FIELDS IN SOME HEADERS */ +#define ZPAGE_STATE_POS 0 /* POSITION OF PAGE STATE */ +#define ZPAGE_NEXT_POS 1 /* POSITION OF THE NEXT POINTER WHEN IN FREELIST */ +#define ZPAGE_PREV_POS 2 /* POSITION OF THE PREVIOUS POINTER WHEN IN FREELIST */ +#define ZFREELIST_HEADER_POS 3 /* POSITION OF THE FIRST FREELIST */ +#define ZPAGE_FRAG_PAGE_ID_POS 4 /* POSITION OF FRAG PAGE ID WHEN USED*/ +#define ZPAGE_NEXT_CLUST_POS 5 /* POSITION OF NEXT FREE SET OF PAGES */ +#define ZPAGE_FIRST_CLUST_POS 2 /* POSITION OF THE POINTER TO THE FIRST PAGE IN A CLUSTER */ +#define ZPAGE_LAST_CLUST_POS 6 /* POSITION OF THE POINTER TO THE LAST PAGE IN A CLUSTER */ +#define ZPAGE_PREV_CLUST_POS 7 /* POSITION OF THE PREVIOUS POINTER */ +#define ZPAGE_HEADER_SIZE 32 /* NUMBER OF WORDS IN MEM PAGEHEADER */ +#define ZDISK_PAGE_HEADER_SIZE 32 /* NUMBER OF WORDS IN DISK PAGEHEADER */ +#define ZNO_OF_FREE_BLOCKS 3 /* NO OF FREE BLOCK IN THE DISK PAGE */ +#define ZDISK_PAGE_ID 8 /* ID OF THE PAGE ON THE DISK */ +#define ZBLOCK_LIST 9 +#define ZCOPY_OF_PAGE 10 +#define ZPAGE_PHYSICAL_INDEX 11 +#define ZNEXT_IN_PAGE_USED_LIST 12 +#define ZPREV_IN_PAGE_USED_LIST 13 +#define ZDISK_USED_TYPE 14 +#define ZFREE_COMMON 1 /* PAGE STATE, PAGE IN COMMON AREA */ +#define ZEMPTY_MM 2 /* PAGE STATE, PAGE IN EMPTY LIST */ +#define ZTH_MM_FREE 3 /* PAGE STATE, TUPLE HEADER PAGE WITH FREE AREA */ +#define ZTH_MM_FULL 4 /* PAGE STATE, TUPLE HEADER PAGE WHICH IS FULL */ +#define ZAC_MM_FREE 5 /* PAGE STATE, ATTRIBUTE CLUSTER PAGE WITH FREE AREA */ +#define ZTH_MM_FREE_COPY 7 /* PAGE STATE, TH COPY PAGE WITH FREE AREA */ +#define ZTH_MM_FULL_COPY 8 /* PAGE STATE, TH COPY PAGE WHICH IS FULL */ +#define ZAC_MM_FREE_COPY 9 /* PAGE STATE, AC COPY PAGE WITH FREE AREA */ +#define ZMAX_NO_COPY_PAGES 4 /* THE MAXIMUM NUMBER OF COPY PAGES ALLOWED PER FRAGMENT */ + + /* CONSTANTS USED TO HANDLE TABLE DESCRIPTOR RECORDS */ + /* ALL POSITIONS AND SIZES IS BASED ON R-WORDS (32-BIT ON APZ 212) */ +#define ZTD_HEADER 0 /* HEADER POSITION */ +#define ZTD_DATASIZE 1 /* SIZE OF THE DATA IN THIS CHUNK */ +#define ZTD_SIZE 2 /* TOTAL SIZE OF TABLE DESCRIPTOR */ + + /* TRAILER POSITIONS FROM END OF TABLE DESCRIPTOR RECORD */ +#define ZTD_TR_SIZE 1 /* SIZE DESCRIPTOR POS FROM END+1 */ +#define ZTD_TR_TYPE 2 +#define ZTD_TRAILER_SIZE 2 /* TOTAL SIZE OF TABLE TRAILER */ +#define ZAD_SIZE 2 /* TOTAL SIZE OF ATTR DESCRIPTOR */ +#define ZAD_LOG_SIZE 1 /* TWO LOG OF TOTAL SIZE OF ATTR DESCRIPTOR */ + + /* CONSTANTS USED TO HANDLE TABLE DESCRIPTOR AS A FREELIST */ +#define ZTD_FL_HEADER 0 /* HEADER POSITION */ +#define ZTD_FL_SIZE 1 /* TOTAL SIZE OF THIS FREELIST ENTRY */ +#define ZTD_FL_PREV 2 /* PREVIOUS RECORD IN FREELIST */ +#define ZTD_FL_NEXT 3 /* NEXT RECORD IN FREELIST */ +#define ZTD_FREE_SIZE 16 /* SIZE NEEDED TO HOLD ONE FL ENTRY */ + + /* CONSTANTS USED IN LSB OF TABLE DESCRIPTOR HEADER DESCRIBING USAGE */ +#define ZTD_TYPE_FREE 0 /* RECORD LINKED INTO FREELIST */ +#define ZTD_TYPE_NORMAL 1 /* RECORD USED AS TABLE DESCRIPTOR */ + /* ATTRIBUTE OPERATION CONSTANTS */ +#define ZLEAF 1 +#define ZNON_LEAF 2 + + /* ATTRINBUFREC VARIABLE POSITIONS. */ +#define ZBUF_PREV 29 /* POSITION OF 'PREV'-VARIABLE (USED BY INTERPRETED EXEC) */ +#define ZBUF_DATA_LEN 30 /* POSITION OF 'DATA LENGTH'-VARIABLE. */ +#define ZBUF_NEXT 31 /* POSITION OF 'NEXT'-VARIABLE. */ +#define ZSAVE_BUF_NEXT 28 +#define ZSAVE_BUF_DATA_LEN 27 + + /* RETURN POINTS. */ + /* RESTART PHASES */ +#define ZSTARTPHASE1 1 +#define ZSTARTPHASE2 2 +#define ZSTARTPHASE3 3 +#define ZSTARTPHASE4 4 +#define ZSTARTPHASE6 6 + +#define ZADDFRAG 0 + + /* CHECKPOINT RECORD TYPES */ +#define ZLCPR_TYPE_INSERT_TH 0 /* INSERT TUPLE HEADER */ +#define ZLCPR_TYPE_DELETE_TH 1 /* DELETE TUPLE HEADER */ +#define ZLCPR_TYPE_UPDATE_TH 2 /* DON'T CREATE IT, JUST UPDETE */ +#define ZLCPR_TYPE_INSERT_TH_NO_DATA 3 /* INSERT TUPLE HEADER */ +#define ZLCPR_ABORT_UPDATE 4 /* UNDO AN UPDATE OPERATION THAT WAS ACTIVE IN LCP */ +#define ZLCPR_ABORT_INSERT 5 /* UNDO AN INSERT OPERATION THAT WAS ACTIVE IN LCP */ +#define ZTABLE_DESCRIPTOR 6 /* TABLE DESCRIPTOR */ +#define ZINDICATE_NO_OP_ACTIVE 7 /* ENSURE THAT NO OPERATION ACTIVE AFTER RESTART */ +#define ZLCPR_UNDO_LOG_PAGE_HEADER 8 /* CHANGE IN PAGE HEADER IS UNDO LOGGED */ +#define ZLCPR_TYPE_UPDATE_GCI 9 /* Update GCI at commit time */ +#define ZNO_CHECKPOINT_RECORDS 10 /* NUMBER OF CHECKPOINTRECORD TYPES */ + + /* RESULT CODES */ + /* ELEMENT POSITIONS IN SYSTEM RESTART INFO PAGE OF THE DATA FILE */ +#define ZSRI_NO_OF_FRAG_PAGES_POS 10 /* NUMBER OF FRAGMENT PAGES WHEN CHECKPOINT STARTED */ +#define ZSRI_TUP_RESERVED_SIZE_POS 11 /* RESERVED SIZE OF THE TUPLE WHEN CP STARTED */ +#define ZSRI_TUP_FIXED_AREA_POS 12 /* SIZE OF THE TUPLE FIXED AREA WHEN CP STARTED */ +#define ZSRI_TAB_DESCR_SIZE 13 /* SIZE OF THE TABLE DESCRIPTOR WHEN CP STARTED */ +#define ZSRI_NO_OF_ATTRIBUTES_POS 14 /* NUMBER OF ATTRIBUTES */ +#define ZSRI_UNDO_LOG_END_REC_ID 15 /* LAST UNDO LOG RECORD ID FOR THIS CHECKPOINT */ +#define ZSRI_UNDO_LOG_END_PAGE_ID 16 /* LAST USED LOG PAGE ID FOR THIS CHECKPOINT */ +#define ZSRI_TH_FREE_FIRST 17 /* FIRST FREE PAGE OF TUPLE HEADERS */ +#define ZSRI_TH_FREE_COPY_FIRST 18 /* FIRST FREE PAGE OF TUPLE HEADER COPIES */ +#define ZSRI_EMPTY_PRIM_PAGE 27 /* FIRST EMPTY PAGE */ +#define ZSRI_NO_COPY_PAGES_ALLOC 28 /* NO COPY PAGES IN FRAGMENT AT LOCAL CHECKPOINT */ +#define ZSRI_UNDO_FILE_VER 29 /* CHECK POINT ID OF THE UNDO FILE */ +#define ZSRI_NO_OF_INDEX_ATTR 30 /* No of index attributes */ +#define ZNO_OF_PAGES_CLUSTER_REC 0 + +//------------------------------------------------------------ +// TUP_CONTINUEB codes +//------------------------------------------------------------ +#define ZSTART_EXEC_UNDO_LOG 0 +#define ZCONT_START_SAVE_CL 1 +#define ZCONT_SAVE_DP 2 +#define ZCONT_EXECUTE_LC 3 +#define ZCONT_LOAD_DP 4 +#define ZLOAD_BAL_LCP_TIMER 5 +#define ZINITIALISE_RECORDS 6 +#define ZREL_FRAG 7 +#define ZREPORT_MEMORY_USAGE 8 +#define ZBUILD_INDEX 9 + +#define ZINDEX_STORAGE 0 +#define ZDATA_WORD_AT_DISK_PAGE 2030 +#define ZALLOC_DISK_PAGE_LAST_INDEX 2047 +#define ZWORD_IN_BLOCK 127 /* NO OF WORD IN A BLOCK */ +#define ZNO_DISK_PAGES_FILE_REC 100 +#define ZMASK_PAGE_INDEX 0x7ff +#define ZBIT_PAGE_INDEX 11 /* 8 KBYT PAGE = 2048 WORDS */ +#define ZSCAN_PROCEDURE 0 +#define ZCOPY_PROCEDURE 2 +#define ZSTORED_PROCEDURE_DELETE 3 +#define ZSTORED_PROCEDURE_FREE 0xffff +#define ZMIN_PAGE_LIMIT_TUP_COMMITREQ 2 +#define ZUNDO_PAGE_HEADER_SIZE 2 /* SIZE OF UNDO PAGE HEADER */ +#endif + +class Dbtup: public SimulatedBlock { +public: +// State values +enum State { + NOT_INITIALIZED = 0, + COMMON_AREA_PAGES = 1, + UNDO_RESTART_PAGES = 2, + UNDO_PAGES = 3, + READ_ONE_PAGE = 4, + CHECKPOINT_DATA_READ = 7, + CHECKPOINT_DATA_READ_PAGE_ZERO = 8, + CHECKPOINT_DATA_WRITE = 9, + CHECKPOINT_DATA_WRITE_LAST = 10, + CHECKPOINT_DATA_WRITE_FLUSH = 11, + CHECKPOINT_UNDO_READ = 12, + CHECKPOINT_UNDO_READ_FIRST = 13, + CHECKPOINT_UNDO_WRITE = 14, + CHECKPOINT_UNDO_WRITE_FLUSH = 15, + CHECKPOINT_TD_READ = 16, + IDLE = 17, + ACTIVE = 18, + SYSTEM_RESTART = 19, + NO_OTHER_OP = 20, + COMMIT_DELETE = 21, + TO_BE_COMMITTED = 22, + ABORTED = 23, + ALREADY_ABORTED_INSERT = 24, + ALREADY_ABORTED = 25, + ABORT_INSERT = 26, + ABORT_UPDATE = 27, + INIT = 28, + INITIAL_READ = 29, + INTERPRETED_EXECUTION = 30, + FINAL_READ = 31, + FINAL_UPDATE = 32, + DISCONNECTED = 33, + DEFINED = 34, + ERROR_WAIT_TUPKEYREQ = 35, + STARTED = 36, + NOT_DEFINED = 37, + COMPLETED = 38, + WAIT_ABORT = 39, + NORMAL_PAGE = 40, + COPY_PAGE = 41, + DELETE_BLOCK = 42, + WAIT_STORED_PROCEDURE_ATTR_INFO = 43, + DATA_FILE_READ = 45, + DATA_FILE_WRITE = 46, + LCP_DATA_FILE_READ = 47, + LCP_DATA_FILE_WRITE = 48, + LCP_DATA_FILE_WRITE_WITH_UNDO = 49, + LCP_DATA_FILE_CLOSE = 50, + LCP_UNDO_FILE_READ = 51, + LCP_UNDO_FILE_CLOSE = 52, + LCP_UNDO_FILE_WRITE = 53, + OPENING_DATA_FILE = 54, + INITIATING_RESTART_INFO = 55, + INITIATING_FRAGMENT = 56, + OPENING_UNDO_FILE = 57, + READING_RESTART_INFO = 58, + INIT_UNDO_SEGMENTS = 59, + READING_TAB_DESCR = 60, + READING_DATA_PAGES = 61, + WAIT_COPY_PROCEDURE = 62, + TOO_MUCH_AI = 63, + SAME_PAGE = 64, + DEFINING = 65, + TUPLE_BLOCKED = 66, + ERROR_WAIT_STORED_PROCREQ = 67 +}; + +// Records +/* ************** ATTRIBUTE INFO BUFFER RECORD ****************** */ +/* THIS RECORD IS USED AS A BUFFER FOR INCOMING AND OUTGOING DATA */ +/* ************************************************************** */ +struct Attrbufrec { + Uint32 attrbuf[ZATTRBUF_SIZE]; +}; /* p2c: size = 128 bytes */ + +typedef Ptr AttrbufrecPtr; + +/* ********** CHECKPOINT INFORMATION ************ */ +/* THIS RECORD HOLDS INFORMATION NEEDED TO */ +/* PERFORM A CHECKPOINT. IT'S POSSIBLE TO RUN */ +/* MULTIPLE CHECKPOINTS AT A TIME. THIS RECORD */ +/* MAKES IT POSSIBLE TO DISTINGER BETWEEN THE */ +/* DIFFERENT CHECKPOINTS. */ +/* ********************************************** */ +struct CheckpointInfo { + Uint32 lcpNextRec; /* NEXT RECORD IN FREELIST */ + Uint32 lcpCheckpointVersion; /* VERSION OF THE CHECKPOINT */ + Uint32 lcpLocalLogInfoP; /* POINTER TO A LOCAL LOG INFO RECORD */ + Uint32 lcpUserptr; /* USERPOINTER TO THE BLOCK REQUESTING THE CP */ + Uint32 lcpFragmentP; /* FRAGMENT POINTER TO WHICH THE CHECKPOINT APPLIES */ + Uint32 lcpFragmentId; /* FRAGMENT ID */ + Uint32 lcpTabPtr; /* TABLE POINTER */ + Uint32 lcpDataBufferSegmentP; /* POINTER TO A DISK BUFFER SEGMENT POINTER (DATA) */ + Uint32 lcpDataFileHandle; /* FILE HANDLES FOR DATA FILE. LOG FILE HANDLE IN LOCAL_LOG_INFO_RECORD */ + /* FILE HANDLE TO THE OPEN DATA FILE */ + Uint32 lcpNoOfPages; + Uint32 lcpThFreeFirst; + Uint32 lcpThFreeCopyFirst; + Uint32 lcpEmptyPrimPage; + Uint32 lcpNoCopyPagesAlloc; + Uint32 lcpTmpOperPtr; /* TEMPORARY STORAGE OF OPER_PTR DURING SAVE */ + BlockReference lcpBlockref; /* BLOCKREFERENCE TO THE BLOCK REQUESTING THE CP */ +}; +typedef Ptr CheckpointInfoPtr; + +/* *********** DISK BUFFER SEGMENT INFO ********* */ +/* THIS RECORD HOLDS INFORMATION NEEDED DURING */ +/* A WRITE OF THE DATA BUFFER TO DISK. WHEN THE */ +/* WRITE SIGNAL IS SENT A POINTER TO THIS RECORD */ +/* IS INCLUDED. WHEN THE WRITE IS COMPLETED AND */ +/* CONFIRMED THE PTR TO THIS RECORD IS RETURNED */ +/* AND THE BUFFER PAGES COULD EASILY BE LOCATED */ +/* AND DEALLOCATED. THE CHECKPOINT_INFO_VERSION */ +/* KEEPS TRACK OF THE CHECPOINT_INFO_RECORD THAT */ +/* INITIATED THE WRITE AND THE CP_PAGE_TO_DISK */ +/* ELEMENT COULD BE INCREASED BY THE NUMBER OF */ +/* PAGES WRITTEN. */ +/* ********************************************** */ +struct DiskBufferSegmentInfo { + Uint32 pdxDataPage[16]; /* ARRAY OF DATA BUFFER PAGES */ + Uint32 pdxUndoBufferSet[2]; + Uint32 pdxNextRec; + State pdxBuffertype; + State pdxOperation; + /*---------------------------------------------------------------------------*/ + /* PDX_FLAGS BITS AND THEIR USAGE: */ + /* BIT 0 1 COMMENT */ + /*---------------------------------------------------------------------------*/ + /* 0 SEGMENT INVALID SEGMENT VALID USED DURING READS */ + /* 1-15 NOT USED */ + /*---------------------------------------------------------------------------*/ + Uint32 pdxCheckpointInfoP; /* USED DURING LOCAL CHKP */ + Uint32 pdxRestartInfoP; /* USED DURING RESTART */ + Uint32 pdxLocalLogInfoP; /* POINTS TO A LOCAL LOG INFO */ + Uint32 pdxFilePage; /* START PAGE IN FILE */ + Uint32 pdxNumDataPages; /* NUMBER OF DATA PAGES */ +}; +typedef Ptr DiskBufferSegmentInfoPtr; + +struct Fragoperrec { + bool definingFragment; + Uint32 nextFragoprec; + Uint32 lqhPtrFrag; + Uint32 fragidFrag; + Uint32 tableidFrag; + Uint32 fragPointer; + Uint32 attributeCount; + Uint32 freeNullBit; + Uint32 noOfNewAttrCount; + BlockReference lqhBlockrefFrag; +}; +typedef Ptr FragoperrecPtr; + +struct Fragrecord { + Uint32 nextStartRange; + Uint32 currentPageRange; + Uint32 rootPageRange; + Uint32 noOfPages; + Uint32 emptyPrimPage; + + Uint32 firstusedOprec; + + Uint32 thFreeFirst; + Uint32 thFreeCopyFirst; + Uint32 noCopyPagesAlloc; + + Uint32 checkpointVersion; + Uint32 minPageNotWrittenInCheckpoint; + Uint32 maxPageWrittenInCheckpoint; + State fragStatus; + Uint32 fragTableId; + Uint32 fragmentId; + Uint32 nextfreefrag; +}; +typedef Ptr FragrecordPtr; + + /* ************ LOCAL LOG FILE INFO ************* */ + /* THIS RECORD HOLDS INFORMATION NEEDED DURING */ + /* CHECKPOINT AND RESTART. THERE ARE FOUR */ + /* PARALLELL UNDO LOG FILES, EACH ONE REPRESENTED */ + /* BY AN ENTITY OF THIS RECORD. */ + /* BECAUSE EACH FILE IS SHARED BETWEEN FOUR */ + /* TABLES AND HAS ITS OWN PAGEPOINTERS AND */ + /* WORDPOINTERS. */ + /* ********************************************** */ +struct LocalLogInfo { + Uint32 lliActiveLcp; /* NUMBER OF ACTIVE LOCAL CHECKPOINTS ON THIS FILE */ + Uint32 lliEndPageId; /* PAGE IDENTIFIER OF LAST PAGE WITH LOG DATA */ + Uint32 lliPrevRecordId; /* PREVIOUS RECORD IN THIS LOGFILE */ + Uint32 lliLogFilePage; /* PAGE IN LOGFILE */ + Uint32 lliNumFragments; /* NO OF FRAGMENTS RESTARTING FROM THIS LOCAL LOG */ + Uint32 lliUndoBufferSegmentP; /* POINTER TO A DISK BUFFER SEGMENT POINTER (UNDO) */ + Uint32 lliUndoFileHandle; /* FILE HANDLE OF UNDO LOG FILE */ + Uint32 lliUndoPage; /* UNDO PAGE IN BUFFER */ + Uint32 lliUndoWord; + Uint32 lliUndoPagesToDiskWithoutSynch; +}; +typedef Ptr LocalLogInfoPtr; + +struct Operationrec { +// Easy to remove (2 words) + Uint32 attroutbufLen; + Uint32 logSize; + +// Needed (20 words) + State tupleState; + Uint32 prevActiveOp; + Uint32 nextActiveOp; + Uint32 nextOprecInList; + Uint32 prevOprecInList; + Uint32 tableRef; + Uint32 fragId; + Uint32 fragmentPtr; + Uint32 fragPageId; + Uint32 realPageId; + bool undoLogged; + Uint32 realPageIdC; + Uint32 fragPageIdC; + Uint32 firstAttrinbufrec; + Uint32 lastAttrinbufrec; + Uint32 attrinbufLen; + Uint32 currentAttrinbufLen; + Uint32 userpointer; + State transstate; + Uint32 savePointId; + +// Easy to remove (3 words) + Uint32 tcOperationPtr; + Uint32 transid1; + Uint32 transid2; + +// Needed (2 words) + Uint16 pageIndex; + Uint16 pageOffset; + Uint16 pageOffsetC; + Uint16 pageIndexC; +// Hard to remove + Uint16 tupVersion; + +// Easy to remove (1.5 word) + BlockReference recBlockref; + BlockReference userblockref; + Uint16 storedProcedureId; + + Uint8 inFragList; + Uint8 inActiveOpList; + Uint8 deleteInsertFlag; + +// Needed (1 word) + Uint8 dirtyOp; + Uint8 interpretedExec; + Uint8 optype; + Uint8 opSimple; + +// Used by triggers + Uint32 primaryReplica; + BlockReference coordinatorTC; + Uint32 tcOpIndex; + Uint32 gci; + Uint32 noFiredTriggers; + Uint32 hashValue; // only used in TUP_COMMITREQ + Bitmask changeMask; +}; +typedef Ptr OperationrecPtr; + +struct Page { + Uint32 pageWord[ZWORDS_ON_PAGE]; +}; +typedef Ptr PagePtr; + + /* ****************************** PAGE RANGE RECORD ************************** */ + /* PAGE RANGES AND BASE PAGE ID. EACH RANGE HAS A CORRESPONDING BASE PAGE ID */ + /* THAT IS USED TO CALCULATE REAL PAGE ID FROM A FRAGMENT PAGE ID AND A TABLE */ + /* REFERENCE. */ + /* THE PAGE RANGES ARE ORGANISED IN A B-TREE FASHION WHERE THE VARIABLE TYPE */ + /* SPECIFIES IF A LEAF NODE HAS BEEN REACHED. IF A LEAF NODE HAS BEEN REACHED */ + /* THEN BASE_PAGE_ID IS THE BASE_PAGE_ID OF THE SET OF PAGES THAT WAS */ + /* ALLOCATED IN THAT RANGE. OTHERWISE BASE_PAGE_ID IS THE POINTER TO THE NEXT */ + /* PAGE_RANGE RECORD. */ + /* *************************************************************************** */ +struct PageRange { + Uint32 startRange[4]; /* START OF RANGE */ + Uint32 endRange[4]; /* END OF THIS RANGE */ + Uint32 basePageId[4]; /* BASE PAGE ID. */ +/*---- VARIABLE BASE_PAGE_ID2 (4) 8 DS NEEDED WHEN SUPPORTING 40 BIT PAGE ID -------*/ + Uint8 type[4]; /* TYPE OF BASE PAGE ID */ + Uint32 nextFree; /* NEXT FREE PAGE RANGE RECORD */ + Uint32 parentPtr; /* THE PARENT TO THE PAGE RANGE REC IN THE B-TREE */ + Uint8 currentIndexPos; +}; +typedef Ptr PageRangePtr; + + /* *********** PENDING UNDO WRITE INFO ********** */ + /* THIS RECORD HOLDS INFORMATION NEEDED DURING */ + /* A FILE OPEN OPERATION */ + /* IF THE FILE OPEN IS A PART OF A CHECKPOINT THE */ + /* CHECKPOINT_INFO_P WILL HOLD A POINTER TO THE */ + /* CHECKPOINT_INFOR_PTR RECORD */ + /* IF IT IS A PART OF RESTART THE PFO_RESTART_INFO*/ + /* ELEMENT WILL POINT TO A RESTART INFO RECORD */ + /* ********************************************** */ +struct PendingFileOpenInfo { + Uint32 pfoNextRec; + State pfoOpenType; + Uint32 pfoCheckpointInfoP; + Uint32 pfoRestartInfoP; +}; +typedef Ptr PendingFileOpenInfoPtr; + +struct RestartInfoRecord { + Uint32 sriNextRec; + State sriState; /* BLOCKREFERENCE TO THE REQUESTING BLOCK */ + Uint32 sriUserptr; /* USERPOINTER TO THE REQUESTING BLOCK */ + Uint32 sriDataBufferSegmentP; /* POINTER TO A DISK BUFFER SEGMENT POINTER (DATA) */ + Uint32 sriDataFileHandle; /* FILE HANDLE TO THE OPEN DATA FILE */ + Uint32 sriCheckpointVersion; /* CHECKPOINT VERSION TO RESTART FROM */ + Uint32 sriFragid; /* FRAGMENT ID */ + Uint32 sriFragP; /* FRAGMENT POINTER */ + Uint32 sriTableId; /* TABLE ID */ + Uint32 sriLocalLogInfoP; /* POINTER TO A LOCAL LOG INFO RECORD */ + Uint32 sriNumDataPages; /* NUMBER OF DATA PAGES TO READ */ + Uint32 sriCurDataPageFromBuffer; /* THE CHECKPOINT IS COMPLETED */ + BlockReference sriBlockref; +}; +typedef Ptr RestartInfoRecordPtr; + + /* ************* TRIGGER DATA ************* */ + /* THIS RECORD FORMS LISTS OF ACTIVE */ + /* TRIGGERS FOR EACH TABLE. */ + /* THE RECORDS ARE MANAGED BY A TRIGGER */ + /* POOL wHERE A TRIGGER RECORD IS SEIZED */ + /* WHEN A TRIGGER IS ACTIVATED AND RELEASED */ + /* WHEN THE TRIGGER IS DEACTIVATED. */ + /* **************************************** */ +struct TupTriggerData { + + /** + * Trigger id, used by DICT/TRIX to identify the trigger + */ + Uint32 triggerId; + + /** + * Index id is needed for ordered index. + */ + Uint32 indexId; + + /** + * Trigger type etc, defines what the trigger is used for + */ + TriggerType::Value triggerType; + TriggerActionTime::Value triggerActionTime; + TriggerEvent::Value triggerEvent; + /** + * Receiver block + */ + Uint32 m_receiverBlock; + + /** + * Monitor all replicas, i.e. trigger will fire on all nodes where tuples + * are stored + */ + bool monitorReplicas; + + /** + * Monitor all attributes, the trigger monitors all changes to attributes + * in the table + */ + bool monitorAllAttributes; + + /** + * Send only changed attributes at trigger firing time. + */ + bool sendOnlyChangedAttributes; + + /** + * Send also before values at trigger firing time. + */ + bool sendBeforeValues; + + /** + * Attribute mask, defines what attributes are to be monitored + * Can be seen as a compact representation of SQL column name list + */ + Bitmask attributeMask; + + /** + * Next ptr (used in pool/list) + */ + union { + Uint32 nextPool; + Uint32 nextList; + }; + + /** + * Prev pointer (used in list) + */ + Uint32 prevList; + + inline void print(NdbOut & s) const { s << "[TriggerData = " << triggerId << "]"; }; +}; + +typedef Ptr TriggerPtr; + +/** + * Pool of trigger data record + */ +ArrayPool c_triggerPool; + + /* ************ TABLE RECORD ************ */ + /* THIS RECORD FORMS A LIST OF TABLE */ + /* REFERENCE INFORMATION. ONE RECORD */ + /* PER TABLE REFERENCE. */ + /* ************************************** */ +struct Tablerec { + Tablerec(ArrayPool & triggerPool) : + afterInsertTriggers(triggerPool), + afterDeleteTriggers(triggerPool), + afterUpdateTriggers(triggerPool), + subscriptionInsertTriggers(triggerPool), + subscriptionDeleteTriggers(triggerPool), + subscriptionUpdateTriggers(triggerPool), + constraintUpdateTriggers(triggerPool), + tuxCustomTriggers(triggerPool) + {} + + Bitmask notNullAttributeMask; + + ReadFunction* readFunctionArray; + UpdateFunction* updateFunctionArray; + + Uint32 readKeyArray; + Uint32 tabDescriptor; + Uint32 attributeGroupDescriptor; + + bool GCPIndicator; + bool checksumIndicator; + + Uint16 tupheadsize; + Uint16 noOfAttr; + Uint16 noOfKeyAttr; + Uint16 noOfNewAttr; + Uint16 noOfNullAttr; + Uint16 noOfAttributeGroups; + + Uint8 tupChecksumIndex; + Uint8 tupNullIndex; + Uint8 tupNullWords; + Uint8 tupGCPIndex; + + // Lists of trigger data for active triggers + ArrayList afterInsertTriggers; + ArrayList afterDeleteTriggers; + ArrayList afterUpdateTriggers; + ArrayList subscriptionInsertTriggers; + ArrayList subscriptionDeleteTriggers; + ArrayList subscriptionUpdateTriggers; + ArrayList constraintUpdateTriggers; + + // List of ordered indexes + ArrayList tuxCustomTriggers; + + Uint32 fragid[2 * NO_OF_FRAG_PER_NODE]; + Uint32 fragrec[2 * NO_OF_FRAG_PER_NODE]; + + struct { + Uint32 tabUserPtr; + Uint32 tabUserRef; + } m_dropTable; + State tableStatus; +}; + +typedef Ptr TablerecPtr; + +struct storedProc { + Uint32 storedLinkFirst; + Uint32 storedLinkLast; + Uint32 storedCounter; + Uint32 nextPool; + Uint16 storedCode; + Uint16 storedProcLength; +}; + +typedef Ptr StoredProcPtr; + +ArrayPool c_storedProcPool; + +/* **************************** TABLE_DESCRIPTOR RECORD ******************************** */ +/* THIS VARIABLE IS USED TO STORE TABLE DESCRIPTIONS. A TABLE DESCRIPTION IS STORED AS A */ +/* CONTIGUOS ARRAY IN THIS VARIABLE. WHEN A NEW TABLE IS ADDED A CHUNK IS ALLOCATED IN */ +/* THIS RECORD. WHEN ATTRIBUTES ARE ADDED TO THE TABLE, A NEW CHUNK OF PROPER SIZE IS */ +/* ALLOCATED AND ALL DATA IS COPIED TO THIS NEW CHUNK AND THEN THE OLD CHUNK IS PUT IN */ +/* THE FREE LIST. EACH TABLE IS DESCRIBED BY A NUMBER OF TABLE DESCRIPTIVE ATTRIBUTES */ +/* AND A NUMBER OF ATTRIBUTE DESCRIPTORS AS SHOWN IN FIGURE BELOW */ +/* */ +/* WHEN ALLOCATING A TABLE DESCRIPTOR THE SIZE IS ALWAYS A MULTIPLE OF 16 WORDS. */ +/* */ +/* ---------------------------------------------- */ +/* | TRAILER USED FOR ALLOC/DEALLOC | */ +/* ---------------------------------------------- */ +/* | TABLE DESCRIPTIVE ATTRIBUTES | */ +/* ---------------------------------------------- */ +/* | ATTRIBUTE DESCRIPTION 1 | */ +/* ---------------------------------------------- */ +/* | ATTRIBUTE DESCRIPTION 2 | */ +/* ---------------------------------------------- */ +/* | | */ +/* | | */ +/* | | */ +/* ---------------------------------------------- */ +/* | ATTRIBUTE DESCRIPTION N | */ +/* ---------------------------------------------- */ +/* */ +/* THE TABLE DESCRIPTIVE ATTRIBUTES CONTAINS THE FOLLOWING ATTRIBUTES: */ +/* */ +/* ---------------------------------------------- */ +/* | HEADER (TYPE OF INFO) | */ +/* ---------------------------------------------- */ +/* | SIZE OF WHOLE CHUNK (INCL. TRAILER) | */ +/* ---------------------------------------------- */ +/* | TABLE IDENTITY | */ +/* ---------------------------------------------- */ +/* | FRAGMENT IDENTITY | */ +/* ---------------------------------------------- */ +/* | NUMBER OF ATTRIBUTES | */ +/* ---------------------------------------------- */ +/* | SIZE OF FIXED ATTRIBUTES | */ +/* ---------------------------------------------- */ +/* | NUMBER OF NULL FIELDS | */ +/* ---------------------------------------------- */ +/* | NOT USED | */ +/* ---------------------------------------------- */ +/* */ +/* THESE ATTRIBUTES ARE ALL ONE R-VARIABLE IN THE RECORD. */ +/* NORMALLY ONLY ONE TABLE DESCRIPTOR IS USED. DURING SCHEMA CHANGES THERE COULD */ +/* HOWEVER EXIST MORE THAN ONE TABLE DESCRIPTION SINCE THE SCHEMA CHANGE OF VARIOUS */ +/* FRAGMENTS ARE NOT SYNCHRONISED. THIS MEANS THAT ALTHOUGH THE SCHEMA HAS CHANGED */ +/* IN ALL FRAGMENTS, BUT THE FRAGMENTS HAVE NOT REMOVED THE ATTRIBUTES IN THE SAME */ +/* TIME-FRAME. THEREBY SOME ATTRIBUTE INFORMATION MIGHT DIFFER BETWEEN FRAGMENTS. */ +/* EXAMPLES OF ATTRIBUTES THAT MIGHT DIFFER ARE SIZE OF FIXED ATTRIBUTES, NUMBER OF */ +/* ATTRIBUTES, FIELD START WORD, START BIT. */ +/* */ +/* AN ATTRIBUTE DESCRIPTION CONTAINS THE FOLLOWING ATTRIBUTES: */ +/* */ +/* ---------------------------------------------- */ +/* | Field Type, 4 bits (LSB Bits) | */ +/* ---------------------------------------------- */ +/* | Attribute Size, 4 bits | */ +/* ---------------------------------------------- */ +/* | NULL indicator 1 bit | */ +/* ---------------------------------------------- */ +/* | Indicator if TUP stores attr. 1 bit | */ +/* ---------------------------------------------- */ +/* | Not used 6 bits | */ +/* ---------------------------------------------- */ +/* | No. of elements in fixed array 16 bits | */ +/* ---------------------------------------------- */ +/* ---------------------------------------------- */ +/* | Field Start Word, 21 bits (LSB Bits) | */ +/* ---------------------------------------------- */ +/* | NULL Bit, 11 bits | */ +/* ---------------------------------------------- */ +/* */ +/* THE ATTRIBUTE SIZE CAN BE 1,2,4,8,16,32,64 AND 128 BITS. */ +/* */ +/* THE UNUSED PARTS OF THE RECORDS ARE PUT IN A LINKED LIST OF FREE PARTS. EACH OF */ +/* THOSE FREE PARTS HAVE THREE RECORDS ASSIGNED AS SHOWN IN THIS STRUCTURE */ +/* ALL FREE PARTS ARE SET INTO A CHUNK LIST WHERE EACH CHUNK IS AT LEAST 16 WORDS */ +/* */ +/* ---------------------------------------------- */ +/* | HEADER = RNIL | */ +/* ---------------------------------------------- */ +/* | SIZE OF FREE AREA | */ +/* ---------------------------------------------- */ +/* | POINTER TO PREVIOUS FREE AREA | */ +/* ---------------------------------------------- */ +/* | POINTER TO NEXT FREE AREA | */ +/* ---------------------------------------------- */ +/* */ +/* IF THE POINTER TO THE NEXT AREA IS RNIL THEN THIS IS THE LAST FREE AREA. */ +/* */ +/*****************************************************************************************/ +struct TableDescriptor { + Uint32 tabDescr; +}; +typedef Ptr TableDescriptorPtr; + +struct HostBuffer { + bool inPackedList; + Uint32 packetLenRC; + Uint32 noOfPacketsRC; + Uint32 packetBufferRC[29]; + Uint32 packetLenTA; + Uint32 noOfPacketsTA; + Uint32 packetBufferTA[30]; +}; +typedef Ptr HostBufferPtr; + + /* **************** UNDO PAGE RECORD ******************* */ + /* THIS RECORD FORMS AN UNDO PAGE CONTAINING A NUMBER OF */ + /* DATA WORDS. CURRENTLY THERE ARE 2048 WORDS ON A PAGE */ + /* EACH OF 32 BITS (4 BYTES) WHICH FORMS AN UNDO PAGE */ + /* WITH A TOTAL OF 8192 BYTES */ + /* ***************************************************** */ +struct UndoPage { + Uint32 undoPageWord[ZWORDS_ON_PAGE]; /* 32 KB */ +}; +typedef Ptr UndoPagePtr; + + /* + * Build index operation record. + */ + struct BuildIndexRec { + // request cannot use signal class due to extra members + Uint32 m_request[BuildIndxReq::SignalLength]; + Uint32 m_triggerPtrI; // the index trigger + Uint32 m_fragNo; // fragment number under Tablerec + Uint32 m_pageId; // logical fragment page id + Uint32 m_tupleNo; // tuple number on page (pageIndex >> 1) + BuildIndxRef::ErrorCode m_errorCode; + union { + Uint32 nextPool; + Uint32 nextList; + }; + Uint32 prevList; + }; + typedef Ptr BuildIndexPtr; + ArrayPool c_buildIndexPool; + ArrayList c_buildIndexList; + Uint32 c_noOfBuildIndexRec; + +public: + Dbtup(const class Configuration &); + virtual ~Dbtup(); + +private: + BLOCK_DEFINES(Dbtup); + + // Transit signals + void execDEBUG_SIG(Signal* signal); + void execCONTINUEB(Signal* signal); + + // Received signals + void execDUMP_STATE_ORD(Signal* signal); + void execSEND_PACKED(Signal* signal); + void execSTTOR(Signal* signal); + void execTUP_LCPREQ(Signal* signal); + void execEND_LCPREQ(Signal* signal); + void execSTART_RECREQ(Signal* signal); + void execMEMCHECKREQ(Signal* signal); + void execTUPSEIZEREQ(Signal* signal); + void execTUPRELEASEREQ(Signal* signal); + void execSTORED_PROCREQ(Signal* signal); + void execTUPFRAGREQ(Signal* signal); + void execTUP_ADD_ATTRREQ(Signal* signal); + void execTUP_COMMITREQ(Signal* signal); + void execTUP_ABORTREQ(Signal* signal); + void execTUP_SRREQ(Signal* signal); + void execTUP_PREPLCPREQ(Signal* signal); + void execFSOPENCONF(Signal* signal); + void execFSOPENREF(Signal* signal); + void execFSCLOSECONF(Signal* signal); + void execFSCLOSEREF(Signal* signal); + void execFSWRITECONF(Signal* signal); + void execFSWRITEREF(Signal* signal); + void execFSREADCONF(Signal* signal); + void execFSREADREF(Signal* signal); + void execNDB_STTOR(Signal* signal); + void execSIZEALT_REP(Signal* signal); + void execSET_VAR_REQ(Signal* signal); + void execDROP_TAB_REQ(Signal* signal); + void execALTER_TAB_REQ(Signal* signal); + void execFSREMOVECONF(Signal* signal); + void execFSREMOVEREF(Signal* signal); + void execTUP_ALLOCREQ(Signal* signal); + void execTUP_DEALLOCREQ(Signal* signal); + void execTUP_WRITELOG_REQ(Signal* signal); + + // Ordered index related + void execTUP_READ_ATTRS(Signal* signal); + void execTUP_QUERY_TH(Signal* signal); + void execTUP_STORE_TH(Signal* signal); + void execBUILDINDXREQ(Signal* signal); + void buildIndex(Signal* signal, Uint32 buildPtrI); + void buildIndexReply(Signal* signal, const BuildIndexRec* buildRec); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ +// Methods to handle execution of TUPKEYREQ + ATTRINFO. +// +// Module Execution Manager +// +// The TUPKEYREQ signal is central to this block. This signal is used +// by everybody that needs to read data residing in DBTUP. The data is +// read using an interpreter approach. +// +// Operations only needing to read execute a simplified version of the +// interpreter where the only instruction is read Attribute to send. +// Operations only needing to update the record (insert or update) +// execute a simplified version of the interpreter where the only +// instruction is write Attribute. +// +// Currently TUPKEYREQ is used in the following situations. +// 1) Normal transaction execution. Can be any of the types described +// below. +// 2) Execution of fragment redo log during system restart. +// In this situation there will only be normal updates, inserts +// and deletes performed. +// 3) A special type of normal transaction execution is to write the +// records arriving from the primary replica in the node restart +// processing. This will always be normal write operations which +// are translated to inserts or updates before arriving to TUP. +// 4) Scan processing. The scan processing will use normal reads or +// interpreted reads in their execution. There will be one TUPKEYREQ +// signal for each record processed. +// 5) Copy fragment processing. This is a special type of scan used in the +// primary replica at system restart. It reads the entire reads and +// converts those to writes to the starting node. In this special case +// LQH acts as an API node and receives also the ATTRINFO sent in the +// TRANSID_AI signals. +// +// Signal Diagram: +// +// In Signals: +// ----------- +// +// Logically there is one request TUPKEYREQ which requests to read/write data +// of one tuple in the database. Since the definition of what to read and write +// can be bigger than the maximum signal size we segment the signal. The definition +// of what to read/write/interpreted program is sent before the TUPKEYREQ signal. +// +// ---> ATTRINFO +// ... +// ---> ATTRINFO +// ---> TUPKEYREQ +// The number of ATTRINFO signals can be anything between 0 and upwards. +// The total size of the ATTRINFO is not allowed to be more than 16384 words. +// There is always one and only one TUPKEYREQ. +// +// Response Signals (successful case): +// +// Simple/Dirty Read Operation +// --------------------------- +// +// <---- TRANSID_AI (to API) +// ... +// <---- TRANSID_AI (to API) +// <---- READCONF (to API) +// <---- TUPKEYCONF (to LQH) +// There is always exactly one READCONF25 sent last. The number of +// TRANSID_AI is dependent on how much that was read. The maximum size +// of the ATTRINFO sent back is 16384 words. The signals are sent +// directly to the application with an address provided by the +// TUPKEYREQ signal. +// A positive response signal is also sent to LQH. +// +// Normal Read Operation +// --------------------- +// +// <---- TRANSID_AI (to API) +// ... +// <---- TRANSID_AI (to API) +// <---- TUPKEYCONF (to LQH) +// The number of TRANSID_AI is dependent on how much that was read. +// The maximum size of the ATTRINFO sent back is 16384 words. The +// signals are sent directly to the application with an address +// provided by the TUPKEYREQ signal. +// A positive response signal is also sent to LQH. +// +// Normal update/insert/delete operation +// ------------------------------------- +// +// <---- TUPKEYCONF +// After successful updating of the tuple LQH is informed of this. +// +// Delete with read +// ---------------- +// +// Will behave as a normal read although it also prepares the +// deletion of the tuple. +// +// Interpreted Update +// ------------------ +// +// <---- TRANSID_AI (to API) +// ... +// <---- TRANSID_AI (to API) +// <---- TUP_ATTRINFO (to LQH) +// ... +// <---- TUP_ATTRINFO (to LQH) +// <---- TUPKEYCONF (to LQH) +// +// The interpreted Update contains five sections: +// The first section performs read Attribute operations +// that send results back to the API. +// +// The second section executes the interpreted program +// where data from attributes can be updated and it +// can also read attribute values into the registers. +// +// The third section performs unconditional updates of +// attributes. +// +// The fourth section can read the attributes to be sent to the +// API after updating the record. +// +// The fifth section contains subroutines used by the interpreter +// in the second section. +// +// All types of interpreted programs contains the same five sections. +// The only difference is that only interpreted updates can update +// attributes. Interpreted inserts are not allowed. +// +// Interpreted Updates have to send back the information about the +// attributes they have updated. This information will be shipped to +// the log and also to any other replicas. Thus interpreted updates +// are only performed in the primary replica. The fragment redo log +// in LQH will contain information so that normal update/inserts/deletes +// can be performed using TUPKEYREQ. +// +// Interpreted Read +// ---------------- +// +// From a signalling point of view the Interpreted Read behaves as +// as a Normal Read. The interpreted Read is often used by Scan's. +// +// Interpreted Delete +// ------------------ +// +// <---- TUPKEYCONF +// After successful prepartion to delete the tuple LQH is informed +// of this. +// +// Interpreted Delete with Read +// ---------------------------- +// +// From a signalling point of view an interpreted delete with read +// behaves as a normal read. +// +// Continuation after successful case: +// +// After a read of any kind the operation record is ready to be used +// again by a new operation. +// +// Any updates, inserts or deletes waits for either of two messages. +// A commit specifying that the operation is to be performed for real +// or an abort specifying that the operation is to be rolled back and +// the record to be restored in its original format. +// +// This is handled by the module Transaction Manager. +// +// Response Signals (unsuccessful case): +// +// <---- TUPKEYREF (to LQH) +// A signal is sent back to LQH informing about the unsuccessful +// operation. In this case TUP waits for an abort signal to arrive +// before the operation record is ready for the next operation. +// This is handled by the Transaction Manager. +//------------------------------------------------------------------ +//------------------------------------------------------------------ + +// ***************************************************************** +// Signal Reception methods. +// ***************************************************************** +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void execTUPKEYREQ(Signal* signal); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void execATTRINFO(Signal* signal); + +// Trigger signals +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void execCREATE_TRIG_REQ(Signal* signal); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void execDROP_TRIG_REQ(Signal* signal); + +// ***************************************************************** +// Support methods for ATTRINFO. +// ***************************************************************** +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void handleATTRINFOforTUPKEYREQ(Signal* signal, + Uint32 length, + Operationrec * const regOperPtr); + +// ***************************************************************** +// Setting up the environment for reads, inserts, updates and deletes. +// ***************************************************************** +//------------------------------------------------------------------ +//------------------------------------------------------------------ + int handleReadReq(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTabPtr, + Page* pagePtr); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + int handleUpdateReq(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr, + Page* const pagePtr); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + int handleInsertReq(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr, + Page* const pagePtr); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + int handleDeleteReq(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr, + Page* const pagePtr); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + int updateStartLab(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTabPtr, + Page* const pagePtr); + +// ***************************************************************** +// Interpreter Handling methods. +// ***************************************************************** + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + int interpreterStartLab(Signal* signal, + Page* const pagePtr, + Uint32 TupHeadOffset); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + int interpreterNextLab(Signal* signal, + Page* const pagePtr, + Uint32 TupHeadOffset, + Uint32* logMemory, + Uint32* mainProgram, + Uint32 TmainProgLen, + Uint32* subroutineProg, + Uint32 TsubroutineLen, + Uint32 * tmpArea, + Uint32 tmpAreaSz); + +// ***************************************************************** +// Signal Sending methods. +// ***************************************************************** +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void sendReadAttrinfo(Signal* signal, + Uint32 TnoOfData, + const Operationrec * const regOperPtr); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void sendLogAttrinfo(Signal* signal, + Uint32 TlogSize, + Operationrec * const regOperPtr); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void sendTUPKEYCONF(Signal* signal, Operationrec * + const regOperPtr, + Uint32 TlogSize); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ +// ***************************************************************** +// The methods that perform the actual read and update of attributes +// in the tuple. +// ***************************************************************** +//------------------------------------------------------------------ +//------------------------------------------------------------------ + int readAttributes(Page* const pagePtr, + Uint32 TupHeadOffset, + Uint32* inBuffer, + Uint32 inBufLen, + Uint32* outBuffer, + Uint32 TmaxRead); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + int readAttributesWithoutHeader(Page* const pagePtr, + Uint32 TupHeadOffset, + Uint32* inBuffer, + Uint32 inBufLen, + Uint32* outBuffer, + Uint32* attrBuffer, + Uint32 TmaxRead); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + int updateAttributes(Page* const pagePtr, + Uint32 TupHeadOffset, + Uint32* inBuffer, + Uint32 inBufLen); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readFixedSizeTHOneWordNotNULL(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateFixedSizeTHOneWordNotNULL(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readFixedSizeTHTwoWordNotNULL(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateFixedSizeTHTwoWordNotNULL(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readFixedSizeTHManyWordNotNULL(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateFixedSizeTHManyWordNotNULL(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readFixedSizeTHOneWordNULLable(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateFixedSizeTHOneWordNULLable(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readFixedSizeTHTwoWordNULLable(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateFixedSizeTHTwoWordNULLable(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readFixedSizeTHManyWordNULLable(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readFixedSizeTHZeroWordNULLable(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateFixedSizeTHManyWordNULLable(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readVariableSizedAttr(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateVariableSizedAttr(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readVarSizeUnlimitedNotNULL(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateVarSizeUnlimitedNotNULL(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readVarSizeUnlimitedNULLable(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateVarSizeUnlimitedNULLable(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readBigVarSizeNotNULL(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateBigVarSizeNotNULL(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readBigVarSizeNULLable(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateBigVarSizeNULLable(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readSmallVarSizeNotNULL(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateSmallVarSizeNotNULL(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readSmallVarSizeNULLable(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateSmallVarSizeNULLable(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readDynFixedSize(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateDynFixedSize(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readDynVarSizeUnlimited(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateDynVarSizeUnlimited(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readDynBigVarSize(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateDynBigVarSize(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool readDynSmallVarSize(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool updateDynSmallVarSize(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + bool nullFlagCheck(Uint32 attrDes2); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void setUpQueryRoutines(Tablerec* const regTabPtr); + +// ***************************************************************** +// Service methods. +// ***************************************************************** +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void copyAttrinfo(Signal* signal, Operationrec * const regOperPtr, Uint32* inBuffer); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void initOpConnection(Operationrec* const regOperPtr); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void initOperationrec(Signal* signal); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + int initStoredOperationrec(Operationrec* const regOperPtr, + Uint32 storedId); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void insertActiveOpList(Signal* signal, + OperationrecPtr regOperPtr, + Page * const pagePtr, + Uint32 pageOffset); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void linkOpIntoFragList(OperationrecPtr regOperPtr, + Fragrecord* const regFragPtr); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void bufferREADCONF(Signal* signal, BlockReference aRef, Uint32* buffer, Uint32 Tlen); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void bufferTRANSID_AI(Signal* signal, BlockReference aRef, Uint32* buffer, Uint32 Tlen); + +//------------------------------------------------------------------ +// Trigger handling routines +//------------------------------------------------------------------ + ArrayList* findTriggerList(Tablerec* table, + TriggerType::Value ttype, + TriggerActionTime::Value ttime, + TriggerEvent::Value tevent); + + bool createTrigger(Tablerec* table, const CreateTrigReq* req); + + Uint32 dropTrigger(Tablerec* table, const DropTrigReq* req); + + void checkImmediateTriggersAfterInsert(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const tablePtr); + + void checkImmediateTriggersAfterUpdate(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const tablePtr); + + void checkImmediateTriggersAfterDelete(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const tablePtr); + +#if 0 + void checkDeferredTriggers(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTablePtr); +#endif + void checkDetachedTriggers(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTablePtr); + + void fireImmediateTriggers(Signal* signal, + ArrayList& triggerList, + Operationrec* const regOperPtr); + + void fireDeferredTriggers(Signal* signal, + ArrayList& triggerList, + Operationrec* const regOperPtr); + + void fireDetachedTriggers(Signal* signal, + ArrayList& triggerList, + Operationrec* const regOperPtr); + + void executeTriggers(Signal* signal, + ArrayList& triggerList, + Operationrec* const regOperPtr); + + void executeTrigger(Signal* signal, + TupTriggerData* const trigPtr, + Operationrec* const regOperPtr); + + bool readTriggerInfo(TupTriggerData* const trigPtr, + Operationrec* const regOperPtr, + Uint32* const keyBuffer, + Uint32& noPrimKey, + Uint32* const mainBuffer, + Uint32& noMainWords, + Uint32* const copyBuffer, + Uint32& noCopyWords); + + void sendTrigAttrInfo(Signal* signal, + Uint32* data, + Uint32 dataLen, + bool executeDirect, + BlockReference receiverReference); + + Uint32 setAttrIds(Bitmask& attributeMask, + Uint32 noOfAttributes, + Uint32* inBuffer); + + void sendFireTrigOrd(Signal* signal, + Operationrec * const regOperPtr, + TupTriggerData* const trigPtr, + Uint32 noPrimKeySignals, + Uint32 noBeforeSignals, + Uint32 noAfterSignals); + + bool primaryKey(Tablerec* const, Uint32); + + // these set terrorCode and return non-zero on error + + int executeTuxInsertTriggers(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTabPtr); + + int executeTuxUpdateTriggers(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTabPtr); + + int executeTuxDeleteTriggers(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTabPtr); + + // these crash the node on error + + void executeTuxCommitTriggers(Signal* signal, + Operationrec* regOperPtr, + Tablerec* const regTabPtr); + + void executeTuxAbortTriggers(Signal* signal, + Operationrec* regOperPtr, + Tablerec* const regTabPtr); + +// ***************************************************************** +// Error Handling routines. +// ***************************************************************** +//------------------------------------------------------------------ +//------------------------------------------------------------------ + int TUPKEY_abort(Signal* signal, int error_type); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ + void tupkeyErrorLab(Signal* signal); + +//------------------------------------------------------------------ +//------------------------------------------------------------------ +// Methods to handle execution of TUP_COMMITREQ + TUP_ABORTREQ. +// +// Module Transaction Manager +// +// The Transaction Manager module is responsible for the commit +// and abort of operations started by the Execution Manager. +// +// Commit Operation: +// ---------------- +// +// Failures in commit processing is not allowed since that would +// leave the database in an unreliable state. Thus the only way +// to handle failures in commit processing is to crash the node. +// +// TUP_COMMITREQ can only be received in the wait state after a +// successful TUPKEYREQ which was not a read operation. +// +// Commit of Delete: +// ----------------- +// +// This will actually perform the deletion of the record unless +// other operations also are connected to the record. In this case +// we will set the delete state on the record that becomes the owner +// of the record. +// +// Commit of Update: +// ---------------- +// +// We will release the copy record where the original record was kept. +// Also here we will take special care if more operations are updating +// the record simultaneously. +// +// Commit of Insert: +// ----------------- +// +// Will simply reset the state of the operation record. +// +// Signal Diagram: +// ---> TUP_COMMITREQ (from LQH) +// <---- TUP_COMMITCONF (to LQH) +// +// +// Abort Operation: +// ---------------- +// +// Signal Diagram: +// ---> TUP_ABORTREQ (from LQH) +// <---- TUP_ABORTCONF (to LQH) +// +// Failures in abort processing is not allowed since that would +// leave the database in an unreliable state. Thus the only way +// to handle failures in abort processing is to crash the node. +// +// Abort messages can arrive at any time. It can arrive even before +// anything at all have arrived of the operation. It can arrive after +// receiving a number of ATTRINFO but before TUPKEYREQ has been received. +// It must arrive after that we sent TUPKEYREF in response to TUPKEYREQ +// and finally it can arrive after successfully performing the TUPKEYREQ +// in all cases including the read case. +//------------------------------------------------------------------ +//------------------------------------------------------------------ + +#if 0 + void checkPages(Fragrecord* const regFragPtr); +#endif + void printoutTuplePage(Uint32 fragid, Uint32 pageid, Uint32 printLimit); + + bool checkUpdateOfPrimaryKey(Uint32* updateBuffer, Tablerec* const regTabPtr); + + void setNullBits(Page* const regPage, Tablerec* const regTabPtr, Uint32 pageOffset); + bool checkNullAttributes(Operationrec* const, Tablerec* const); + bool getPage(PagePtr& pagePtr, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr); + + bool getPageLastCommitted(Operationrec* const regOperPtr, + Operationrec* const leaderOpPtr); + + bool getPageThroughSavePoint(Operationrec* const regOperPtr, + Operationrec* const leaderOpPtr); + + Uint32 calculateChecksum(Page* const pagePtr, Uint32 tupHeadOffset, Uint32 tupHeadSize); + void setChecksum(Page* const pagePtr, Uint32 tupHeadOffset, Uint32 tupHeadSize); + + void commitSimple(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr); + + void commitRecord(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr); + + void setTupleStatesSetOpType(Operationrec* const regOperPtr, + Page* const pagePtr, + Uint32& opType, + OperationrecPtr& firstOpPtr); + + void findBeforeValueOperation(OperationrecPtr& befOpPtr, + OperationrecPtr firstOpPtr); + + void calculateChangeMask(Page* const PagePtr, + Tablerec* const regTabPtr, + Uint32 pageOffset, + Bitmask& attributeMask); + + void updateGcpId(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr); + + void abortUpdate(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr); + void commitUpdate(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr); + + void setTupleStateOnPreviousOps(Uint32 prevOpIndex); + void copyMem(Signal* signal, Uint32 sourceIndex, Uint32 destIndex); + + void freeAllAttrBuffers(Operationrec* const regOperPtr); + void freeAttrinbufrec(Uint32 anAttrBufRec); + void removeActiveOpList(Operationrec* const regOperPtr); + + void updatePackedList(Signal* signal, Uint16 ahostIndex); + + void setUpDescriptorReferences(Uint32 descriptorReference, + Tablerec* const regTabPtr); + void setUpKeyArray(Tablerec* const regTabPtr); + bool addfragtotab(Tablerec* const regTabPtr, Uint32 fragId, Uint32 fragIndex); + void deleteFragTab(Tablerec* const regTabPtr, Uint32 fragId); + void releaseTabDescr(Tablerec* const regTabPtr); + void getFragmentrec(FragrecordPtr& regFragPtr, Uint32 fragId, Tablerec* const regTabPtr); + + void initialiseRecordsLab(Signal* signal, Uint32 switchData); + void initializeAttrbufrec(); + void initializeCheckpointInfoRec(); + void initializeDiskBufferSegmentRecord(); + void initializeFragoperrec(); + void initializeFragrecord(); + void initializeHostBuffer(); + void initializeLocalLogInfo(); + void initializeOperationrec(); + void initializePendingFileOpenInfoRecord(); + void initializeRestartInfoRec(); + void initializeTablerec(); + void initializeTabDescr(); + void initializeUndoPage(); + + void initTab(Tablerec* const regTabPtr); + + void startphase3Lab(Signal* signal, Uint32 config1, Uint32 config2); + + void fragrefuseLab(Signal* signal, FragoperrecPtr fragOperPtr); + void fragrefuse1Lab(Signal* signal, FragoperrecPtr fragOperPtr); + void fragrefuse2Lab(Signal* signal, FragoperrecPtr fragOperPtr, FragrecordPtr regFragPtr); + void fragrefuse3Lab(Signal* signal, + FragoperrecPtr fragOperPtr, + FragrecordPtr regFragPtr, + Tablerec* const regTabPtr, + Uint32 fragId); + void fragrefuse4Lab(Signal* signal, + FragoperrecPtr fragOperPtr, + FragrecordPtr regFragPtr, + Tablerec* const regTabPtr, + Uint32 fragId); + void addattrrefuseLab(Signal* signal, + FragrecordPtr regFragPtr, + FragoperrecPtr fragOperPtr, + Tablerec* const regTabPtr, + Uint32 fragId); + + + void checkLcpActiveBufferPage(Uint32 minPageNotWrittenInCheckpoint, DiskBufferSegmentInfoPtr dbsiPtr); + void lcpWriteListDataPageSegment(Signal* signal, + DiskBufferSegmentInfoPtr dbsiPtr, + CheckpointInfoPtr ciPtr, + bool flushFlag); + void lcpFlushLogLab(Signal* signal, CheckpointInfoPtr ciPtr); + void lcpClosedDataFileLab(Signal* signal, CheckpointInfoPtr ciPtr); + void lcpEndconfLab(Signal* signal); + void lcpSaveDataPageLab(Signal* signal, Uint32 ciIndex); + void lcpCompletedLab(Signal* signal, Uint32 ciIndex); + void lcpFlushRestartInfoLab(Signal* signal, Uint32 ciIndex); + void lcpSaveCopyListLab(Signal* signal, CheckpointInfoPtr ciPtr); + + void sendFSREMOVEREQ(Signal* signal, TablerecPtr tabPtr); + void releaseFragment(Signal* signal, Uint32 tableId); + + void allocDataBufferSegment(Signal* signal, DiskBufferSegmentInfoPtr& dbsiPtr); + void allocRestartUndoBufferSegment(Signal* signal, DiskBufferSegmentInfoPtr& dbsiPtr, LocalLogInfoPtr lliPtr); + void freeDiskBufferSegmentRecord(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr); + void freeUndoBufferPages(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr); + + void releaseCheckpointInfoRecord(CheckpointInfoPtr ciPtr); + void releaseDiskBufferSegmentRecord(DiskBufferSegmentInfoPtr dbsiPtr); + void releaseFragoperrec(FragoperrecPtr fragOperPtr); + void releaseFragrec(FragrecordPtr regFragPtr); + void releasePendingFileOpenInfoRecord(PendingFileOpenInfoPtr pfoPtr); + void releaseRestartInfoRecord(RestartInfoRecordPtr riPtr); + + void seizeDiskBufferSegmentRecord(DiskBufferSegmentInfoPtr& dbsiPtr); + void seizeCheckpointInfoRecord(CheckpointInfoPtr& ciPtr); + void seizeFragoperrec(FragoperrecPtr& fragOperPtr); + void seizeFragrecord(FragrecordPtr& regFragPtr); + void seizeOpRec(OperationrecPtr& regOperPtr); + void seizePendingFileOpenInfoRecord(PendingFileOpenInfoPtr& pfoiPtr); + void seizeRestartInfoRecord(RestartInfoRecordPtr& riPtr); + + // Initialisation + void initData(); + void initRecords(); + + void rfrClosedDataFileLab(Signal* signal, Uint32 restartIndex); + void rfrCompletedLab(Signal* signal, RestartInfoRecordPtr riPtr); + void rfrInitRestartInfoLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr); + void rfrLoadDataPagesLab(Signal* signal, RestartInfoRecordPtr riPtr, DiskBufferSegmentInfoPtr dbsiPtr); + void rfrReadFirstUndoSegment(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr); + void rfrReadNextDataSegment(Signal* signal, RestartInfoRecordPtr riPtr, DiskBufferSegmentInfoPtr dbsiPtr); + void rfrReadNextUndoSegment(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr); + void rfrReadRestartInfoLab(Signal* signal, RestartInfoRecordPtr riPtr); + void rfrReadSecondUndoLogLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr); + + void startExecUndoLogLab(Signal* signal, Uint32 lliIndex); + void readExecUndoLogLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr); + void closeExecUndoLogLab(Signal* signal, LocalLogInfoPtr lliPtr); + void endExecUndoLogLab(Signal* signal, Uint32 lliIndex); + + struct XlcStruct { + Uint32 PageId; + Uint32 PageIndex; + Uint32 LogRecordType; + Uint32 FragId; + FragrecordPtr FragPtr; + LocalLogInfoPtr LliPtr; + DiskBufferSegmentInfoPtr DbsiPtr; + UndoPagePtr UPPtr; + TablerecPtr TabPtr; + }; + + void xlcGetNextRecordLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr); + void xlcRestartCompletedLab(Signal* signal); + + void xlcCopyData(XlcStruct& xlcStruct, Uint32 pageOffset, Uint32 noOfWords, PagePtr pagePtr); + void xlcGetLogHeader(XlcStruct& xlcStruct); + Uint32 xlcGetLogWord(XlcStruct& xlcStruct); + + void xlcAbortInsert(Signal* signal, XlcStruct& xlcStruct); + void xlcAbortUpdate(Signal* signal, XlcStruct& xlcStruct); + void xlcDeleteTh(XlcStruct& xlcStruct); + void xlcIndicateNoOpActive(XlcStruct& xlcStruct); + void xlcInsertTh(XlcStruct& xlcStruct); + void xlcTableDescriptor(XlcStruct& xlcStruct); + void xlcUndoLogPageHeader(XlcStruct& xlcStruct); + void xlcUpdateTh(XlcStruct& xlcStruct); + void xlcUpdateGCI(XlcStruct& xlcStruct); + + + void cprAddData(Signal* signal, + Fragrecord* const regFragPtr, + Uint32 pageIndex, + Uint32 noOfWords, + Uint32 startOffset); + void cprAddGCIUpdate(Signal* signal, + Uint32 prevGCI, + Fragrecord* const regFragPtr); + void cprAddLogHeader(Signal* signal, + LocalLogInfo* const lliPtr, + Uint32 recordType, + Uint32 tableId, + Uint32 fragId); + void cprAddUndoLogPageHeader(Signal* signal, + Page* const regPagePtr, + Fragrecord* const regFragPtr); + void cprAddUndoLogRecord(Signal* signal, + Uint32 recordType, + Uint32 pageId, + Uint32 pageIndex, + Uint32 tableId, + Uint32 fragId, + Uint32 localLogIndex); + void cprAddAbortUpdate(Signal* signal, + LocalLogInfo* const lliPtr, + Operationrec* const regOperPtr); + void cprAddUndoLogWord(Signal* signal, + LocalLogInfo* const lliPtr, + Uint32 undoWord); + bool isUndoLoggingNeeded(Fragrecord* const regFragPtr, Uint32 pageId); + bool isUndoLoggingActive(Fragrecord* const regFragPtr); + bool isUndoLoggingBlocked(Fragrecord* const regFragPtr); + bool isPageUndoLogged(Fragrecord* const regFragPtr, Uint32 pageId); + + void seizeUndoBufferSegment(Signal* signal, UndoPagePtr& regUndoPagePtr); + void lcpWriteUndoSegment(Signal* signal, LocalLogInfo* const lliPtr, bool flushFlag); + + + void deleteScanProcedure(Signal* signal, Operationrec* regOperPtr); + void copyProcedure(Signal* signal, + TablerecPtr regTabPtr, + Operationrec* regOperPtr); + void scanProcedure(Signal* signal, + Operationrec* regOperPtr, + Uint32 lenAttrInfo); + void storedSeizeAttrinbufrecErrorLab(Signal* signal, + Operationrec* regOperPtr); + bool storedProcedureAttrInfo(Signal* signal, + Operationrec* regOperPtr, + Uint32 length, + Uint32 firstWord, + bool copyProc); + +//----------------------------------------------------------------------------- +// Table Descriptor Memory Manager +//----------------------------------------------------------------------------- + +// Public methods + Uint32 allocTabDescr(Uint32 noOfAttributes, Uint32 noOfKeyAttr, Uint32 noOfAttributeGroups); + void freeTabDescr(Uint32 retRef, Uint32 retNo); + Uint32 getTabDescrWord(Uint32 index); + void setTabDescrWord(Uint32 index, Uint32 word); + +// Private methods + Uint32 sizeOfReadFunction(); + void removeTdArea(Uint32 tabDesRef, Uint32 list); + void insertTdArea(Uint32 sizeOfChunk, Uint32 tabDesRef, Uint32 list); + Uint32 itdaMergeTabDescr(Uint32 retRef, Uint32 retNo); + +//------------------------------------------------------------------------------------------------------ +// Page Memory Manager +//------------------------------------------------------------------------------------------------------ + +// Public methods + void allocConsPages(Uint32 noOfPagesToAllocate, + Uint32& noOfPagesAllocated, + Uint32& allocPageRef); + void returnCommonArea(Uint32 retPageRef, Uint32 retNo); + void initializePage(); + +// Private methods + void removeCommonArea(Uint32 remPageRef, Uint32 list); + void insertCommonArea(Uint32 insPageRef, Uint32 list); + void findFreeLeftNeighbours(Uint32& allocPageRef, Uint32& noPagesAllocated, Uint32 noPagesToAllocate); + void findFreeRightNeighbours(Uint32& allocPageRef, Uint32& noPagesAllocated, Uint32 noPagesToAllocate); + Uint32 nextHigherTwoLog(Uint32 input); + +// Private data + Uint32 cfreepageList[16]; + +//------------------------------------------------------------------------------------------------------ +// Page Mapper, convert logical page id's to physical page id's +// The page mapper also handles the pages allocated to the fragment. +//------------------------------------------------------------------------------------------------------ +// +// Public methods + Uint32 getRealpid(Fragrecord* const regFragPtr, Uint32 logicalPageId); + Uint32 getNoOfPages(Fragrecord* const regFragPtr); + void initPageRangeSize(Uint32 size); + bool insertPageRangeTab(Fragrecord* const regFragPtr, + Uint32 startPageId, + Uint32 noPages); + void releaseFragPages(Fragrecord* const regFragPtr); + void initFragRange(Fragrecord* const regFragPtr); + void initializePageRange(); + Uint32 getEmptyPage(Fragrecord* const regFragPtr); + Uint32 allocFragPages(Fragrecord* const regFragPtr, Uint32 noOfPagesAllocated); + +// Private methods + Uint32 leafPageRangeFull(Fragrecord* const regFragPtr, PageRangePtr currPageRangePtr); + void releasePagerange(PageRangePtr regPRPtr); + void seizePagerange(PageRangePtr& regPageRangePtr); + void errorHandler(Uint32 errorCode); + void allocMoreFragPages(Fragrecord* const regFragPtr); + +// Private data + Uint32 cfirstfreerange; + PageRange *pageRange; + Uint32 c_noOfFreePageRanges; + Uint32 cnoOfPageRangeRec; + +//------------------------------------------------------------------------------------------------------ +// Fixed Allocator +// Allocates and deallocates tuples of fixed size on a fragment. +//------------------------------------------------------------------------------------------------------ +// +// Public methods + bool allocTh(Fragrecord* const regFragPtr, + Tablerec* const regTabPtr, + Uint32 pageType, + Signal* signal, + Uint32& pageOffset, + PagePtr& pagePtr); + + void freeThSr(Tablerec* const regTabPtr, + Page* const regPagePtr, + Uint32 freePageOffset); + + void freeTh(Fragrecord* const regFragPtr, + Tablerec* const regTabPtr, + Signal* signal, + Page* const regPagePtr, + Uint32 freePageOffset); + + void getThAtPageSr(Page* const regPagePtr, + Uint32& pageOffset); + +// Private methods + void convertThPage(Uint32 Tupheadsize, + Page* const regPagePtr); + + void getThAtPage(Fragrecord* const regFragPtr, + Page* const regPagePtr, + Signal* signal, + Uint32& pageOffset); + + void getEmptyPageThCopy(Fragrecord* const regFragPtr, + Signal* signal, + Page* const regPagePtr); + + void getEmptyPageTh(Fragrecord* const regFragPtr, + Signal* signal, + Page* const regPagePtr); + +//------------------------------------------------------------------------------------------------------ +// Temporary variables used for storing commonly used variables in certain modules +//------------------------------------------------------------------------------------------------------ + + FragrecordPtr fragptr; + OperationrecPtr operPtr; + TablerecPtr tabptr; + +// readAttributes and updateAttributes module + Uint32 tCheckOffset; + Uint32 tMaxRead; + Uint32 tOutBufIndex; + Uint32* tTupleHeader; + +// updateAttributes module + Uint32 tInBufIndex; + Uint32 tInBufLen; + + Uint32 terrorCode; + +//------------------------------------------------------------------------------------------------------ +// Common stored variables. Variables that have a valid value always. +//------------------------------------------------------------------------------------------------------ + Uint32 cnoOfLcpRec; + Uint32 cnoOfParallellUndoFiles; + Uint32 cnoOfUndoPage; + + Attrbufrec *attrbufrec; + Uint32 cfirstfreeAttrbufrec; + Uint32 cnoOfAttrbufrec; + Uint32 cnoFreeAttrbufrec; + + CheckpointInfo *checkpointInfo; + Uint32 cfirstfreeLcp; + + DiskBufferSegmentInfo *diskBufferSegmentInfo; + Uint32 cfirstfreePdx; + Uint32 cnoOfConcurrentWriteOp; + + Fragoperrec *fragoperrec; + Uint32 cfirstfreeFragopr; + Uint32 cnoOfFragoprec; + + Fragrecord *fragrecord; + Uint32 cfirstfreefrag; + Uint32 cnoOfFragrec; + + HostBuffer *hostBuffer; + + LocalLogInfo *localLogInfo; + Uint32 cnoOfLocalLogInfo; + + Uint32 cfirstfreeOprec; + Operationrec *operationrec; + Uint32 cnoOfOprec; + + Page *page; + Uint32 cnoOfPage; + Uint32 cnoOfAllocatedPages; + + PendingFileOpenInfo *pendingFileOpenInfo; + Uint32 cfirstfreePfo; + Uint32 cnoOfConcurrentOpenOp; + + RestartInfoRecord *restartInfoRecord; + Uint32 cfirstfreeSri; + Uint32 cnoOfRestartInfoRec; + + Tablerec *tablerec; + Uint32 cnoOfTablerec; + + TableDescriptor *tableDescriptor; + Uint32 cnoOfTabDescrRec; + + UndoPage *undoPage; + Uint32 cfirstfreeUndoSeg; + Int32 cnoFreeUndoSeg; + + + + Uint32 cnoOfDataPagesToDiskWithoutSynch; + + Uint32 cdata[32]; + Uint32 cdataPages[16]; + Uint32 cpackedListIndex; + Uint32 cpackedList[MAX_NODES]; + Uint32 cfreeTdList[16]; + Uint32 clastBitMask; + Uint32 clblPageCounter; + Uint32 clblPagesPerTick; + Uint32 clblPagesPerTickAfterSr; + BlockReference clqhBlockref; + Uint32 clqhUserpointer; + Uint32 cminusOne; + BlockReference cndbcntrRef; + Uint32 cundoFileVersion; + BlockReference cownref; + Uint32 cownNodeId; + Uint32 czero; + + // A little bit bigger to cover overwrites in copy algorithms (16384 real size). +#define ZATTR_BUFFER_SIZE 16384 + Uint32 clogMemBuffer[ZATTR_BUFFER_SIZE + 16]; + Uint32 coutBuffer[ZATTR_BUFFER_SIZE + 16]; + Uint32 cinBuffer[ZATTR_BUFFER_SIZE + 16]; + Uint32 totNoOfPagesAllocated; + + // Trigger variables + Uint32 c_maxTriggersPerTable; + + // Counters for num UNDO log records executed + Uint32 cSrUndoRecords[9]; + + Uint32 c_errorInsert4000TableId; + + void initGlobalTemporaryVars(); + void reportMemoryUsage(Signal* signal, int incDec); +#ifdef VM_TRACE + struct Th { + Uint32 data[1]; + }; + friend class NdbOut& operator<<(NdbOut&, const Operationrec&); + friend class NdbOut& operator<<(NdbOut&, const Th&); +#endif +}; + +inline +bool Dbtup::isUndoLoggingNeeded(Fragrecord* const regFragPtr, + Uint32 pageId) +{ + if ((regFragPtr->checkpointVersion != RNIL) && + (pageId >= regFragPtr->minPageNotWrittenInCheckpoint) && + (pageId < regFragPtr->maxPageWrittenInCheckpoint)) { + return true; + }//if + return false; +}//Dbtup::isUndoLoggingNeeded() + +inline +bool Dbtup::isUndoLoggingActive(Fragrecord* const regFragPtr) +{ + if (regFragPtr->checkpointVersion != RNIL) { + return true; + }//if + return false; +}//Dbtup::isUndoLoggingNeeded() + +inline +bool Dbtup::isUndoLoggingBlocked(Fragrecord* const regFragPtr) +{ + if ((regFragPtr->checkpointVersion != RNIL) && + (cnoFreeUndoSeg < ZMIN_PAGE_LIMIT_TUPKEYREQ)) { + return true; + }//if + return false; +}//Dbtup::isUndoLoggingNeeded() + +inline +bool Dbtup::isPageUndoLogged(Fragrecord* const regFragPtr, + Uint32 pageId) +{ + if ((pageId >= regFragPtr->minPageNotWrittenInCheckpoint) && + (pageId < regFragPtr->maxPageWrittenInCheckpoint)) { + return true; + }//if + return false; +}//Dbtup::isUndoLoggingNeeded() + +#endif diff --git a/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp b/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp new file mode 100644 index 00000000000..1ffc5f06754 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp @@ -0,0 +1,473 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include + +#define ljam() { jamLine(9000 + __LINE__); } +#define ljamEntry() { jamEntryLine(9000 + __LINE__); } + +void Dbtup::freeAllAttrBuffers(Operationrec* const regOperPtr) +{ + if (regOperPtr->storedProcedureId == ZNIL) { + ljam(); + freeAttrinbufrec(regOperPtr->firstAttrinbufrec); + } else { + StoredProcPtr storedPtr; + c_storedProcPool.getPtr(storedPtr, (Uint32)regOperPtr->storedProcedureId); + ndbrequire(storedPtr.p->storedCode == ZSCAN_PROCEDURE); + ljam(); + storedPtr.p->storedCounter--; + regOperPtr->storedProcedureId = ZNIL; + }//if + regOperPtr->firstAttrinbufrec = RNIL; + regOperPtr->lastAttrinbufrec = RNIL; +}//Dbtup::freeAllAttrBuffers() + +void Dbtup::freeAttrinbufrec(Uint32 anAttrBuf) +{ + Uint32 Ttemp; + AttrbufrecPtr localAttrBufPtr; + Uint32 RnoFree = cnoFreeAttrbufrec; + localAttrBufPtr.i = anAttrBuf; + while (localAttrBufPtr.i != RNIL) { + ljam(); + ptrCheckGuard(localAttrBufPtr, cnoOfAttrbufrec, attrbufrec); + Ttemp = localAttrBufPtr.p->attrbuf[ZBUF_NEXT]; + localAttrBufPtr.p->attrbuf[ZBUF_NEXT] = cfirstfreeAttrbufrec; + cfirstfreeAttrbufrec = localAttrBufPtr.i; + localAttrBufPtr.i = Ttemp; + RnoFree++; + }//if + cnoFreeAttrbufrec = RnoFree; +}//Dbtup::freeAttrinbufrec() + +/* ----------------------------------------------------------------- */ +/* ----------- ABORT THIS PART OF THE TRANSACTION ------------------ */ +/* ----------------------------------------------------------------- */ +void Dbtup::execTUP_ABORTREQ(Signal* signal) +{ + OperationrecPtr regOperPtr; + FragrecordPtr regFragPtr; + TablerecPtr regTabPtr; + + ljamEntry(); + regOperPtr.i = signal->theData[0]; + ptrCheckGuard(regOperPtr, cnoOfOprec, operationrec); + ndbrequire((regOperPtr.p->transstate == STARTED) || + (regOperPtr.p->transstate == TOO_MUCH_AI) || + (regOperPtr.p->transstate == ERROR_WAIT_TUPKEYREQ) || + (regOperPtr.p->transstate == IDLE)); + if (regOperPtr.p->optype == ZREAD) { + ljam(); + freeAllAttrBuffers(regOperPtr.p); + initOpConnection(regOperPtr.p); + return; + }//if + + regTabPtr.i = regOperPtr.p->tableRef; + ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec); + + regFragPtr.i = regOperPtr.p->fragmentPtr; + ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord); + + // XXX should be integrated into the code that comes after + if (!regTabPtr.p->tuxCustomTriggers.isEmpty() && + regOperPtr.p->tupleState == NO_OTHER_OP) { + ljam(); + executeTuxAbortTriggers(signal, + regOperPtr.p, + regTabPtr.p); + OperationrecPtr loopOpPtr; + loopOpPtr.i = regOperPtr.p->prevActiveOp; + while (loopOpPtr.i != RNIL) { + ljam(); + ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec); + if (loopOpPtr.p->tupleState != ALREADY_ABORTED) { + ljam(); + executeTuxAbortTriggers(signal, + loopOpPtr.p, + regTabPtr.p); + } + loopOpPtr.i = loopOpPtr.p->prevActiveOp; + } + } + + Uint32 prevActiveOp = regOperPtr.p->prevActiveOp; + removeActiveOpList(regOperPtr.p); + if (regOperPtr.p->tupleState == NO_OTHER_OP) { + if (prevActiveOp == RNIL) { + ljam(); + abortUpdate(signal, regOperPtr.p, regFragPtr.p, regTabPtr.p); + } else { //prevActiveOp != RNIL + setTupleStateOnPreviousOps(prevActiveOp); + if (regOperPtr.p->optype == ZDELETE) { + ljam(); + OperationrecPtr prevOpPtr; + prevOpPtr.i = prevActiveOp; + ptrCheckGuard(prevOpPtr, cnoOfOprec, operationrec); + ndbrequire(prevOpPtr.p->realPageIdC != RNIL); + ndbrequire(prevOpPtr.p->optype == ZINSERT); + abortUpdate(signal, prevOpPtr.p, regFragPtr.p, regTabPtr.p); + } else { + jam(); + abortUpdate(signal, regOperPtr.p, regFragPtr.p, regTabPtr.p); + }//if + }//if + } else { + ndbrequire(regOperPtr.p->tupleState == ALREADY_ABORTED); + commitUpdate(signal, regOperPtr.p, regFragPtr.p, regTabPtr.p); + }//if + initOpConnection(regOperPtr.p); +}//execTUP_ABORTREQ() + +void Dbtup::setTupleStateOnPreviousOps(Uint32 prevOpIndex) +{ + OperationrecPtr loopOpPtr; + loopOpPtr.i = prevOpIndex; + do { + ljam(); + ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec); + loopOpPtr.p->tupleState = ALREADY_ABORTED; + loopOpPtr.i = loopOpPtr.p->prevActiveOp; + } while (loopOpPtr.i != RNIL); +}//Dbtup::setTupleStateOnPreviousOps() + +/* ---------------------------------------------------------------- */ +/* ------------ PERFORM AN ABORT OF AN UPDATE OPERATION ----------- */ +/* ---------------------------------------------------------------- */ +void Dbtup::abortUpdate(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr) +{ + /* RESTORE THE ORIGINAL DATA */ + /* THE OPER_PTR ALREADY CONTAINS BOTH THE PAGE AND THE COPY PAGE */ + if (regOperPtr->realPageIdC != RNIL) { + ljam(); + /***********************/ + /* CHECKPOINT SPECIFIC */ + /***********************/ + if (isUndoLoggingNeeded(regFragPtr, regOperPtr->fragPageIdC)) { + if (regOperPtr->undoLogged) { + ljam(); +/* ---------------------------------------------------------------- */ +/* THE UPDATE WAS MADE AFTER THE LOCAL CHECKPOINT STARTED. */ +/* THUS THE ORIGINAL TUPLE WILL BE RESTORED BY A LOG RECORD */ +/* CREATED WHEN UPDATING. THUS IT IS ENOUGH TO LOG THE UNDO */ +/* OF THE COPY RELEASE == INSERT THE COPY TUPLE HEADER WITH */ +/* NO DATA. */ +/* ---------------------------------------------------------------- */ + cprAddUndoLogRecord(signal, + ZLCPR_TYPE_INSERT_TH_NO_DATA, + regOperPtr->fragPageIdC, + regOperPtr->pageIndexC, + regOperPtr->tableRef, + regOperPtr->fragId, + regFragPtr->checkpointVersion); + } else { + ljam(); +/* ---------------------------------------------------------------- */ +/* THE UPDATE WAS MADE BEFORE THE LOCAL CHECKPOINT STARTED. */ +/* THE TUPLE WILL THUS BE RESTORED BY COPYING FROM THE COPY. */ +/* THUS WE DO NOT NEED TO RESTORE THE DATA IN THE ORIGINAL. */ +/* WE DO HOWEVER NEED TO ENSURE THAT THE COPY CONTAINS THE */ +/* CORRECT DATA. */ +/* ---------------------------------------------------------------- */ + cprAddUndoLogRecord(signal, + ZLCPR_TYPE_INSERT_TH, + regOperPtr->fragPageIdC, + regOperPtr->pageIndexC, + regOperPtr->tableRef, + regOperPtr->fragId, + regFragPtr->checkpointVersion); + cprAddData(signal, + regFragPtr, + regOperPtr->realPageIdC, + regTabPtr->tupheadsize, + regOperPtr->pageOffsetC); + }//if + }//if + Uint32 rpid = regOperPtr->realPageId; + Uint32 rpid_copy = regOperPtr->realPageIdC; + Uint32 offset = regOperPtr->pageOffset; + Uint32 offset_copy = regOperPtr->pageOffsetC; + Uint32 tuple_size = regTabPtr->tupheadsize; + Uint32 end = offset + tuple_size; + Uint32 end_copy = offset_copy + tuple_size; + ndbrequire(rpid < cnoOfPage && + rpid_copy < cnoOfPage && + end <= ZWORDS_ON_PAGE && + end_copy <= ZWORDS_ON_PAGE); + void* Tdestination = (void*)&page[rpid].pageWord[offset + 1]; + const void* Tsource = (void*)&page[rpid_copy].pageWord[offset_copy + 1]; + MEMCOPY_NO_WORDS(Tdestination, Tsource, (tuple_size - 1)); + { + PagePtr pagePtr; + + pagePtr.i = rpid_copy; + ptrAss(pagePtr, page); + freeTh(regFragPtr, + regTabPtr, + signal, + pagePtr.p, + offset_copy); + } + regOperPtr->realPageIdC = RNIL; + regOperPtr->fragPageIdC = RNIL; + regOperPtr->pageOffsetC = ZNIL; + regOperPtr->pageIndexC = ZNIL; + }//if +}//Dbtup::abortUpdate() + +/* **************************************************************** */ +/* ********************** TRANSACTION ERROR MODULE **************** */ +/* **************************************************************** */ +int Dbtup::TUPKEY_abort(Signal* signal, int error_type) +{ + switch(error_type) { + case 0: + ndbrequire(false); + break; +// Not used currently + + case 1: +//tmupdate_alloc_error: + ljam(); + break; + + case 2: + ndbrequire(false); + break; +// Not used currently + + break; + + case 3: +//tmupdate_alloc_error: + ljam(); + break; + + case 4: +//Trying to read non-existing attribute identity + ljam(); + terrorCode = ZATTRIBUTE_ID_ERROR; + break; + + case 6: + ljam(); + terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR; + break; + + case 7: + ljam(); + terrorCode = ZAI_INCONSISTENCY_ERROR; + break; + + case 8: + ljam(); + terrorCode = ZATTR_INTERPRETER_ERROR; + break; + + case 9: + ljam(); +//Trying to read non-existing attribute identity + ljam(); + terrorCode = ZATTRIBUTE_ID_ERROR; + break; + + case 11: + ljam(); + terrorCode = ZATTR_INTERPRETER_ERROR; + break; + + case 12: + ljam(); + ndbrequire(false); + break; + + case 13: + ljam(); + ndbrequire(false); + break; + + case 14: + ljam(); + terrorCode = ZREGISTER_INIT_ERROR; + break; + + case 15: + ljam(); + terrorCode = ZREGISTER_INIT_ERROR; + break; + + case 16: + ljam(); + terrorCode = ZTRY_TO_UPDATE_ERROR; + break; + + case 17: + ljam(); + terrorCode = ZNO_ILLEGAL_NULL_ATTR; + break; + + case 18: + ljam(); + terrorCode = ZNOT_NULL_ATTR; + break; + + case 19: + ljam(); + terrorCode = ZTRY_TO_UPDATE_ERROR; + break; + + case 20: + ljam(); + terrorCode = ZREGISTER_INIT_ERROR; + break; + + case 21: + ljam(); + terrorCode = ZREGISTER_INIT_ERROR; + break; + + case 22: + ljam(); + terrorCode = ZTOTAL_LEN_ERROR; + break; + + case 23: + ljam(); + terrorCode = ZREGISTER_INIT_ERROR; + break; + + case 24: + ljam(); + terrorCode = ZREGISTER_INIT_ERROR; + break; + + case 25: + ljam(); + terrorCode = ZREGISTER_INIT_ERROR; + break; + + case 26: + ljam(); + terrorCode = ZREGISTER_INIT_ERROR; + break; + + case 27: + ljam(); + terrorCode = ZREGISTER_INIT_ERROR; + break; + + case 28: + ljam(); + terrorCode = ZREGISTER_INIT_ERROR; + break; + + case 29: + ljam(); + break; + + case 30: + ljam(); + terrorCode = ZCALL_ERROR; + break; + + case 31: + ljam(); + terrorCode = ZSTACK_OVERFLOW_ERROR; + break; + + case 32: + ljam(); + terrorCode = ZSTACK_UNDERFLOW_ERROR; + break; + + case 33: + ljam(); + terrorCode = ZNO_INSTRUCTION_ERROR; + break; + + case 34: + ljam(); + terrorCode = ZOUTSIDE_OF_PROGRAM_ERROR; + break; + + case 35: + ljam(); + terrorCode = ZTOO_MANY_INSTRUCTIONS_ERROR; + break; + + case 36: + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + break; + + case 37: + ljam(); + terrorCode = ZTEMPORARY_RESOURCE_FAILURE; + break; + + case 38: + ljam(); + terrorCode = ZTEMPORARY_RESOURCE_FAILURE; + break; + + case 39: + ljam(); + if (operPtr.p->transstate == TOO_MUCH_AI) { + ljam(); + terrorCode = ZTOO_MUCH_ATTRINFO_ERROR; + } else if (operPtr.p->transstate == ERROR_WAIT_TUPKEYREQ) { + ljam(); + terrorCode = ZSEIZE_ATTRINBUFREC_ERROR; + } else { + ndbrequire(false); + }//if + break; + + default: + ndbrequire(false); + break; + }//switch + tupkeyErrorLab(signal); + return -1; +}//Dbtup::TUPKEY_abort() + +void Dbtup::tupkeyErrorLab(Signal* signal) +{ + Operationrec * const regOperPtr = operPtr.p; + + freeAllAttrBuffers(regOperPtr); + abortUpdate(signal, regOperPtr, fragptr.p, tabptr.p); + removeActiveOpList(regOperPtr); + initOpConnection(regOperPtr); + regOperPtr->transstate = IDLE; + regOperPtr->tupleState = NO_OTHER_OP; + TupKeyRef * const tupKeyRef = (TupKeyRef *)signal->getDataPtrSend(); + + tupKeyRef->userRef = regOperPtr->userpointer; + tupKeyRef->errorCode = terrorCode; + sendSignal(regOperPtr->userblockref, GSN_TUPKEYREF, signal, + TupKeyRef::SignalLength, JBB); + return; +}//Dbtup::tupkeyErrorLab() + diff --git a/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp b/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp new file mode 100644 index 00000000000..90c6dbc6802 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp @@ -0,0 +1,329 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include +#include + +#define ljam() { jamLine(2000 + __LINE__); } +#define ljamEntry() { jamEntryLine(2000 + __LINE__); } + +void Dbtup::execSEND_PACKED(Signal* signal) +{ + Uint16 hostId; + Uint32 i; + Uint32 TpackedListIndex = cpackedListIndex; + ljamEntry(); + for (i = 0; i < TpackedListIndex; i++) { + ljam(); + hostId = cpackedList[i]; + ndbrequire((hostId - 1) < (MAX_NODES - 1)); // Also check not zero + Uint32 TpacketTA = hostBuffer[hostId].noOfPacketsTA; + Uint32 TpacketRC = hostBuffer[hostId].noOfPacketsRC; + if (TpacketTA != 0) { + ljam(); + BlockReference TBref = numberToRef(API_PACKED, hostId); + Uint32 TpacketLen = hostBuffer[hostId].packetLenTA; + MEMCOPY_NO_WORDS(&signal->theData[0], + &hostBuffer[hostId].packetBufferTA[0], + TpacketLen); + sendSignal(TBref, GSN_TRANSID_AI, signal, TpacketLen, JBB); + hostBuffer[hostId].noOfPacketsTA = 0; + hostBuffer[hostId].packetLenTA = 0; + }//if + if (TpacketRC != 0) { + ljam(); + BlockReference TBref = numberToRef(API_PACKED, hostId); + Uint32 TpacketLen = hostBuffer[hostId].packetLenRC; + MEMCOPY_NO_WORDS(&signal->theData[0], + &hostBuffer[hostId].packetBufferRC[0], + TpacketLen); + sendSignal(TBref, GSN_READCONF, signal, TpacketLen, JBB); + hostBuffer[hostId].noOfPacketsRC = 0; + hostBuffer[hostId].packetLenRC = 0; + }//if + hostBuffer[hostId].inPackedList = false; + }//for + cpackedListIndex = 0; +}//Dbtup::execSEND_PACKED() + +void Dbtup::bufferREADCONF(Signal* signal, BlockReference aRef, + Uint32* buffer, Uint32 Tlen) +{ + Uint32 hostId = refToNode(aRef); + Uint32 Theader = ((refToBlock(aRef) << 16) + (Tlen-3)); + + ndbrequire(hostId < MAX_NODES); + Uint32 TpacketLen = hostBuffer[hostId].packetLenRC; + Uint32 TnoOfPackets = hostBuffer[hostId].noOfPacketsRC; + Uint32 sig0 = signal->theData[0]; + Uint32 sig1 = signal->theData[1]; + Uint32 sig2 = signal->theData[2]; + Uint32 sig3 = signal->theData[3]; + + BlockReference TBref = numberToRef(API_PACKED, hostId); + + if ((Tlen + TpacketLen + 1) <= 25) { +// ---------------------------------------------------------------- +// There is still space in the buffer. We will copy it into the +// buffer. +// ---------------------------------------------------------------- + ljam(); + updatePackedList(signal, hostId); + } else if (TnoOfPackets == 1) { +// ---------------------------------------------------------------- +// The buffer is full and there was only one packet buffered. We +// will send this as a normal signal. +// ---------------------------------------------------------------- + Uint32 TnewRef = numberToRef((hostBuffer[hostId].packetBufferRC[0] >> 16), + hostId); + MEMCOPY_NO_WORDS(&signal->theData[0], + &hostBuffer[hostId].packetBufferRC[1], + TpacketLen - 1); + sendSignal(TnewRef, GSN_READCONF, signal, (TpacketLen - 1), JBB); + TpacketLen = 0; + TnoOfPackets = 0; + } else { +// ---------------------------------------------------------------- +// The buffer is full but at least two packets. Send those in +// packed form. +// ---------------------------------------------------------------- + MEMCOPY_NO_WORDS(&signal->theData[0], + &hostBuffer[hostId].packetBufferRC[0], + TpacketLen); + sendSignal(TBref, GSN_READCONF, signal, TpacketLen, JBB); + TpacketLen = 0; + TnoOfPackets = 0; + }//if +// ---------------------------------------------------------------- +// Copy the signal into the buffer +// ---------------------------------------------------------------- + hostBuffer[hostId].packetBufferRC[TpacketLen + 0] = Theader; + hostBuffer[hostId].packetBufferRC[TpacketLen + 1] = sig0; + hostBuffer[hostId].packetBufferRC[TpacketLen + 2] = sig1; + hostBuffer[hostId].packetBufferRC[TpacketLen + 3] = sig2; + hostBuffer[hostId].packetBufferRC[TpacketLen + 4] = sig3; + hostBuffer[hostId].noOfPacketsRC = TnoOfPackets + 1; + hostBuffer[hostId].packetLenRC = Tlen + TpacketLen + 1; + MEMCOPY_NO_WORDS(&hostBuffer[hostId].packetBufferRC[TpacketLen + 5], + buffer, + Tlen - 4); +}//Dbtup::bufferREADCONF() + +void Dbtup::bufferTRANSID_AI(Signal* signal, BlockReference aRef, + Uint32* buffer, Uint32 Tlen) +{ + Uint32 hostId = refToNode(aRef); + Uint32 Theader = ((refToBlock(aRef) << 16)+(Tlen-3)); + + ndbrequire(hostId < MAX_NODES); + Uint32 TpacketLen = hostBuffer[hostId].packetLenTA; + Uint32 TnoOfPackets = hostBuffer[hostId].noOfPacketsTA; + Uint32 sig0 = signal->theData[0]; + Uint32 sig1 = signal->theData[1]; + Uint32 sig2 = signal->theData[2]; + + BlockReference TBref = numberToRef(API_PACKED, hostId); + + if ((Tlen + TpacketLen + 1) <= 25) { +// ---------------------------------------------------------------- +// There is still space in the buffer. We will copy it into the +// buffer. +// ---------------------------------------------------------------- + ljam(); + updatePackedList(signal, hostId); + } else if (TnoOfPackets == 1) { +// ---------------------------------------------------------------- +// The buffer is full and there was only one packet buffered. We +// will send this as a normal signal. +// ---------------------------------------------------------------- + Uint32 TnewRef = numberToRef((hostBuffer[hostId].packetBufferTA[0] >> 16), + hostId); + MEMCOPY_NO_WORDS(&signal->theData[0], + &hostBuffer[hostId].packetBufferTA[1], + TpacketLen - 1); + sendSignal(TnewRef, GSN_TRANSID_AI, signal, (TpacketLen - 1), JBB); + TpacketLen = 0; + TnoOfPackets = 0; + } else { +// ---------------------------------------------------------------- +// The buffer is full but at least two packets. Send those in +// packed form. +// ---------------------------------------------------------------- + MEMCOPY_NO_WORDS(&signal->theData[0], + &hostBuffer[hostId].packetBufferTA[0], + TpacketLen); + sendSignal(TBref, GSN_TRANSID_AI, signal, TpacketLen, JBB); + TpacketLen = 0; + TnoOfPackets = 0; + }//if +// ---------------------------------------------------------------- +// Copy the signal into the buffer +// ---------------------------------------------------------------- + hostBuffer[hostId].packetBufferTA[TpacketLen + 0] = Theader; + hostBuffer[hostId].packetBufferTA[TpacketLen + 1] = sig0; + hostBuffer[hostId].packetBufferTA[TpacketLen + 2] = sig1; + hostBuffer[hostId].packetBufferTA[TpacketLen + 3] = sig2; + hostBuffer[hostId].noOfPacketsTA = TnoOfPackets + 1; + hostBuffer[hostId].packetLenTA = Tlen + TpacketLen + 1; + MEMCOPY_NO_WORDS(&hostBuffer[hostId].packetBufferTA[TpacketLen + 4], + buffer, + Tlen - 3); +}//Dbtup::bufferTRANSID_AI() + +void Dbtup::updatePackedList(Signal* signal, Uint16 hostId) +{ + if (hostBuffer[hostId].inPackedList == false) { + Uint32 TpackedListIndex = cpackedListIndex; + ljam(); + hostBuffer[hostId].inPackedList = true; + cpackedList[TpackedListIndex] = hostId; + cpackedListIndex = TpackedListIndex + 1; + }//if +}//Dbtup::updatePackedList() + +/* ---------------------------------------------------------------- */ +/* ----------------------- SEND READ ATTRINFO --------------------- */ +/* ---------------------------------------------------------------- */ +void Dbtup::sendReadAttrinfo(Signal* signal, + Uint32 ToutBufIndex, + const Operationrec * const regOperPtr) +{ + const BlockReference recBlockref = regOperPtr->recBlockref; + bool toOwnNode = refToNode(recBlockref) == getOwnNodeId(); + bool connectedToNode = getNodeInfo(refToNode(recBlockref)).m_connected; + const Uint32 type = getNodeInfo(refToNode(recBlockref)).m_type; + bool is_api = (type >= NodeInfo::API && type <= NodeInfo::REP); + + if (ERROR_INSERTED(4006)){ + // Use error insert to turn routing on + ljam(); + connectedToNode = false; + } + + if (!toOwnNode && !connectedToNode){ + /** + * If this node does not have a direct connection + * to the receiving node we want to send the signals + * routed via the node that controls this read + */ + Uint32 routeBlockref = regOperPtr->coordinatorTC; + + /** + * Fill in a TRANSID_AI signal, use last word to store + * final destination and send it to route node + * as signal TRANSID_AI_R (R as in Routed) + */ + TransIdAI * const transIdAI = (TransIdAI *)signal->getDataPtr(); + transIdAI->connectPtr = regOperPtr->tcOperationPtr; + transIdAI->transId[0] = regOperPtr->transid1; + transIdAI->transId[1] = regOperPtr->transid2; + + Uint32 tot = ToutBufIndex; + Uint32 sent = 0; + Uint32 maxLen = TransIdAI::DataLength - 1; + while (sent < tot) { + ljam(); + Uint32 dataLen = (tot - sent > maxLen) ? maxLen : tot - sent; + Uint32 sigLen = dataLen + TransIdAI::HeaderLength + 1; + MEMCOPY_NO_WORDS(&transIdAI->attrData, + &coutBuffer[sent], + dataLen); + // Set final destination in last word + transIdAI->attrData[dataLen] = recBlockref; + + sendSignal(routeBlockref, GSN_TRANSID_AI_R, + signal, sigLen, JBB); + sent += dataLen; + + } + return; + } + + Uint32 TbufIndex = 0; + Uint32 sig0 = regOperPtr->tcOperationPtr; + Uint32 sig1 = regOperPtr->transid1; + Uint32 sig2 = regOperPtr->transid2; + signal->theData[0] = sig0; + signal->theData[1] = sig1; + signal->theData[2] = sig2; + + while (ToutBufIndex > 21) { + ljam(); + MEMCOPY_NO_WORDS(&signal->theData[3], + &coutBuffer[TbufIndex], + 22); + TbufIndex += 22; + ToutBufIndex -= 22; + const BlockReference sendBref = regOperPtr->recBlockref; + if (refToNode(sendBref) != getOwnNodeId()) { + ljam(); + sendSignal(sendBref, GSN_TRANSID_AI, signal, 25, JBB); + ljam(); + } else { + ljam(); + EXECUTE_DIRECT(refToBlock(sendBref), GSN_TRANSID_AI, signal, 25); + ljamEntry(); + }//if + }//while + + Uint32 TsigNumber; + Uint32 TsigLen; + Uint32 TdataIndex; + if ((regOperPtr->opSimple == ZTRUE) && + (regOperPtr->optype == ZREAD)) { + /* DIRTY OPERATIONS ARE ALSO SIMPLE */ + ljam(); + Uint32 sig3 = regOperPtr->attroutbufLen; + TdataIndex = 4; + TsigLen = 4 + ToutBufIndex; + TsigNumber = GSN_READCONF; + signal->theData[3] = sig3; + if ((TsigLen < 18) && is_api){ + bufferREADCONF(signal, regOperPtr->recBlockref, + &coutBuffer[TbufIndex], TsigLen); + return; + }//if + } else if (ToutBufIndex > 0) { + ljam(); + TdataIndex = 3; + TsigLen = 3 + ToutBufIndex; + TsigNumber = GSN_TRANSID_AI; + if ((TsigLen < 18) && is_api){ + ljam(); + bufferTRANSID_AI(signal, regOperPtr->recBlockref, + &coutBuffer[TbufIndex], TsigLen); + return; + }//if + } else { + ljam(); + return; + }//if + MEMCOPY_NO_WORDS(&signal->theData[TdataIndex], + &coutBuffer[TbufIndex], + ToutBufIndex); + const BlockReference sendBref = regOperPtr->recBlockref; + if (refToNode(sendBref) != getOwnNodeId()) { + ljam(); + sendSignal(sendBref, TsigNumber, signal, TsigLen, JBB); + } else { + EXECUTE_DIRECT(refToBlock(sendBref), GSN_TRANSID_AI, signal, TsigLen); + ljamEntry(); + }//if +}//Dbtup::sendReadAttrinfo() diff --git a/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp b/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp new file mode 100644 index 00000000000..fa3667b221e --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp @@ -0,0 +1,589 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include +#include + +#define ljam() { jamLine(5000 + __LINE__); } +#define ljamEntry() { jamEntryLine(5000 + __LINE__); } + +void Dbtup::execTUP_WRITELOG_REQ(Signal* signal) +{ + jamEntry(); + OperationrecPtr loopOpPtr; + loopOpPtr.i = signal->theData[0]; + Uint32 gci = signal->theData[1]; + ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec); + while (loopOpPtr.p->nextActiveOp != RNIL) { + ljam(); + loopOpPtr.i = loopOpPtr.p->nextActiveOp; + ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec); + }//while + do { + Uint32 blockNo = refToBlock(loopOpPtr.p->userblockref); + ndbrequire(loopOpPtr.p->transstate == STARTED); + signal->theData[0] = loopOpPtr.p->userpointer; + signal->theData[1] = gci; + if (loopOpPtr.p->prevActiveOp == RNIL) { + ljam(); + EXECUTE_DIRECT(blockNo, GSN_LQH_WRITELOG_REQ, signal, 2); + return; + }//if + ljam(); + EXECUTE_DIRECT(blockNo, GSN_LQH_WRITELOG_REQ, signal, 2); + jamEntry(); + loopOpPtr.i = loopOpPtr.p->prevActiveOp; + ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec); + } while (true); +}//Dbtup::execTUP_WRITELOG_REQ() + +void Dbtup::execTUP_DEALLOCREQ(Signal* signal) +{ + TablerecPtr regTabPtr; + FragrecordPtr regFragPtr; + + jamEntry(); + + Uint32 fragId = signal->theData[0]; + regTabPtr.i = signal->theData[1]; + Uint32 fragPageId = signal->theData[2]; + Uint32 pageIndex = signal->theData[3]; + + ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec); + getFragmentrec(regFragPtr, fragId, regTabPtr.p); + ndbrequire(regFragPtr.p != NULL); + + PagePtr pagePtr; + pagePtr.i = getRealpid(regFragPtr.p, fragPageId); + ptrCheckGuard(pagePtr, cnoOfPage, page); + Uint32 pageIndexScaled = pageIndex >> 1; + ndbrequire((pageIndex & 1) == 0); + Uint32 pageOffset = ZPAGE_HEADER_SIZE + + (regTabPtr.p->tupheadsize * pageIndexScaled); +//--------------------------------------------------- +/* --- Deallocate a tuple as requested by ACC --- */ +//--------------------------------------------------- + if (isUndoLoggingNeeded(regFragPtr.p, fragPageId)) { + ljam(); + cprAddUndoLogRecord(signal, + ZLCPR_TYPE_INSERT_TH, + fragPageId, + pageIndex, + regTabPtr.i, + fragId, + regFragPtr.p->checkpointVersion); + cprAddData(signal, + regFragPtr.p, + pagePtr.i, + regTabPtr.p->tupheadsize, + pageOffset); + }//if + { + freeTh(regFragPtr.p, + regTabPtr.p, + signal, + pagePtr.p, + pageOffset); + } +} + +/* ---------------------------------------------------------------- */ +/* ------------ PERFORM A COMMIT ON AN UPDATE OPERATION ---------- */ +/* ---------------------------------------------------------------- */ +void Dbtup::commitUpdate(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr) +{ + if (regOperPtr->realPageIdC != RNIL) { + if (isUndoLoggingNeeded(regFragPtr, regOperPtr->fragPageIdC)) { +/* ------------------------------------------------------------------------ */ +/* IF THE COPY WAS CREATED WITHIN THIS CHECKPOINT WE ONLY HAVE */ +/* TO LOG THE CREATION OF THE COPY. IF HOWEVER IT WAS CREATED BEFORE SAVE */ +/* THIS CHECKPOINT, WE HAVE TO THE DATA AS WELL. */ +/* ------------------------------------------------------------------------ */ + if (regOperPtr->undoLogged) { + ljam(); + cprAddUndoLogRecord(signal, + ZLCPR_TYPE_INSERT_TH_NO_DATA, + regOperPtr->fragPageIdC, + regOperPtr->pageIndexC, + regOperPtr->tableRef, + regOperPtr->fragId, + regFragPtr->checkpointVersion); + } else { + ljam(); + cprAddUndoLogRecord(signal, + ZLCPR_TYPE_INSERT_TH, + regOperPtr->fragPageIdC, + regOperPtr->pageIndexC, + regOperPtr->tableRef, + regOperPtr->fragId, + regFragPtr->checkpointVersion); + cprAddData(signal, + regFragPtr, + regOperPtr->realPageIdC, + regTabPtr->tupheadsize, + regOperPtr->pageOffsetC); + }//if + }//if + + PagePtr copyPagePtr; + copyPagePtr.i = regOperPtr->realPageIdC; + ptrCheckGuard(copyPagePtr, cnoOfPage, page); + freeTh(regFragPtr, + regTabPtr, + signal, + copyPagePtr.p, + (Uint32)regOperPtr->pageOffsetC); + regOperPtr->realPageIdC = RNIL; + regOperPtr->fragPageIdC = RNIL; + regOperPtr->pageOffsetC = ZNIL; + regOperPtr->pageIndexC = ZNIL; + }//if +}//Dbtup::commitUpdate() + +void +Dbtup::commitSimple(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr) +{ + operPtr.p = regOperPtr; + fragptr.p = regFragPtr; + tabptr.p = regTabPtr; + + // Checking detached triggers + checkDetachedTriggers(signal, + regOperPtr, + regTabPtr); + + removeActiveOpList(regOperPtr); + if (regOperPtr->optype == ZUPDATE) { + ljam(); + commitUpdate(signal, regOperPtr, regFragPtr, regTabPtr); + if (regTabPtr->GCPIndicator) { + updateGcpId(signal, regOperPtr, regFragPtr, regTabPtr); + }//if + } else if (regOperPtr->optype == ZINSERT) { + ljam(); + if (regTabPtr->GCPIndicator) { + updateGcpId(signal, regOperPtr, regFragPtr, regTabPtr); + }//if + } else { + ndbrequire(regOperPtr->optype == ZDELETE); + }//if +}//Dbtup::commitSimple() + +void Dbtup::removeActiveOpList(Operationrec* const regOperPtr) +{ + if (regOperPtr->inActiveOpList == ZTRUE) { + OperationrecPtr raoOperPtr; + regOperPtr->inActiveOpList = ZFALSE; + if (regOperPtr->prevActiveOp != RNIL) { + ljam(); + raoOperPtr.i = regOperPtr->prevActiveOp; + ptrCheckGuard(raoOperPtr, cnoOfOprec, operationrec); + raoOperPtr.p->nextActiveOp = regOperPtr->nextActiveOp; + } else { + ljam(); + PagePtr pagePtr; + pagePtr.i = regOperPtr->realPageId; + ptrCheckGuard(pagePtr, cnoOfPage, page); + ndbrequire(regOperPtr->pageOffset < ZWORDS_ON_PAGE); + pagePtr.p->pageWord[regOperPtr->pageOffset] = regOperPtr->nextActiveOp; + }//if + if (regOperPtr->nextActiveOp != RNIL) { + ljam(); + raoOperPtr.i = regOperPtr->nextActiveOp; + ptrCheckGuard(raoOperPtr, cnoOfOprec, operationrec); + raoOperPtr.p->prevActiveOp = regOperPtr->prevActiveOp; + }//if + regOperPtr->prevActiveOp = RNIL; + regOperPtr->nextActiveOp = RNIL; + }//if +}//Dbtup::removeActiveOpList() + +/* ---------------------------------------------------------------- */ +/* INITIALIZATION OF ONE CONNECTION RECORD TO PREPARE FOR NEXT OP. */ +/* ---------------------------------------------------------------- */ +void Dbtup::initOpConnection(Operationrec* const regOperPtr) +{ + Uint32 RinFragList = regOperPtr->inFragList; + regOperPtr->transstate = IDLE; + regOperPtr->currentAttrinbufLen = 0; + regOperPtr->optype = ZREAD; + if (RinFragList == ZTRUE) { + OperationrecPtr tropNextLinkPtr; + OperationrecPtr tropPrevLinkPtr; +/*----------------------------------------------------------------- */ +/* TO ENSURE THAT WE HAVE SUCCESSFUL ABORTS OF FOLLOWING */ +/* OPERATIONS WHICH NEVER STARTED WE SET THE OPTYPE TO READ. */ +/*----------------------------------------------------------------- */ +/* REMOVE IT FROM THE DOUBLY LINKED LIST ON THE FRAGMENT */ +/*----------------------------------------------------------------- */ + tropPrevLinkPtr.i = regOperPtr->prevOprecInList; + tropNextLinkPtr.i = regOperPtr->nextOprecInList; + regOperPtr->inFragList = ZFALSE; + if (tropPrevLinkPtr.i == RNIL) { + ljam(); + FragrecordPtr regFragPtr; + regFragPtr.i = regOperPtr->fragmentPtr; + ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord); + regFragPtr.p->firstusedOprec = tropNextLinkPtr.i; + } else { + ljam(); + ptrCheckGuard(tropPrevLinkPtr, cnoOfOprec, operationrec); + tropPrevLinkPtr.p->nextOprecInList = tropNextLinkPtr.i; + }//if + if (tropNextLinkPtr.i == RNIL) { + ; + } else { + ljam(); + ptrCheckGuard(tropNextLinkPtr, cnoOfOprec, operationrec); + tropNextLinkPtr.p->prevOprecInList = tropPrevLinkPtr.i; + }//if + regOperPtr->prevOprecInList = RNIL; + regOperPtr->nextOprecInList = RNIL; + }//if +}//Dbtup::initOpConnection() + +/* ----------------------------------------------------------------- */ +/* --------------- COMMIT THIS PART OF A TRANSACTION --------------- */ +/* ----------------------------------------------------------------- */ +void Dbtup::execTUP_COMMITREQ(Signal* signal) +{ + FragrecordPtr regFragPtr; + OperationrecPtr regOperPtr; + TablerecPtr regTabPtr; + + TupCommitReq * const tupCommitReq = (TupCommitReq *)signal->getDataPtr(); + + ljamEntry(); + regOperPtr.i = tupCommitReq->opPtr; + ptrCheckGuard(regOperPtr, cnoOfOprec, operationrec); + + ndbrequire(regOperPtr.p->transstate == STARTED); + regOperPtr.p->gci = tupCommitReq->gci; + regOperPtr.p->hashValue = tupCommitReq->hashValue; + + regFragPtr.i = regOperPtr.p->fragmentPtr; + ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord); + + regTabPtr.i = regOperPtr.p->tableRef; + ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec); + + if (!regTabPtr.p->tuxCustomTriggers.isEmpty()) { + ljam(); + executeTuxCommitTriggers(signal, + regOperPtr.p, + regTabPtr.p); + } + + if (regOperPtr.p->tupleState == NO_OTHER_OP) { + if ((regOperPtr.p->prevActiveOp == RNIL) && + (regOperPtr.p->nextActiveOp == RNIL)) { + ljam(); +/* ---------------------------------------------------------- */ +// We handle the simple case separately as an optimisation +/* ---------------------------------------------------------- */ + commitSimple(signal, + regOperPtr.p, + regFragPtr.p, + regTabPtr.p); + } else { +/* ---------------------------------------------------------- */ +// This is the first commit message of this record in this +// transaction. We will commit this record completely for this +// transaction. If there are other operations they will be +// responsible to release their own resources. Also commit of +// a delete is postponed until the last operation is committed +// on the tuple. +// +// As part of this commitRecord we will also handle detached +// triggers and release of resources for this operation. +/* ---------------------------------------------------------- */ + ljam(); + commitRecord(signal, + regOperPtr.p, + regFragPtr.p, + regTabPtr.p); + removeActiveOpList(regOperPtr.p); + }//if + } else { + ljam(); +/* ---------------------------------------------------------- */ +// Release any copy tuples +/* ---------------------------------------------------------- */ + ndbrequire(regOperPtr.p->tupleState == TO_BE_COMMITTED); + commitUpdate(signal, regOperPtr.p, regFragPtr.p, regTabPtr.p); + removeActiveOpList(regOperPtr.p); + }//if + initOpConnection(regOperPtr.p); +}//execTUP_COMMITREQ() + +void +Dbtup::updateGcpId(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr) +{ + PagePtr pagePtr; + ljam(); +//-------------------------------------------------------------------- +// Is this code safe for UNDO logging. Not sure currently. RONM +//-------------------------------------------------------------------- + pagePtr.i = regOperPtr->realPageId; + ptrCheckGuard(pagePtr, cnoOfPage, page); + Uint32 temp = regOperPtr->pageOffset + regTabPtr->tupGCPIndex; + ndbrequire((temp < ZWORDS_ON_PAGE) && + (regTabPtr->tupGCPIndex < regTabPtr->tupheadsize)); + if (isUndoLoggingNeeded(regFragPtr, regOperPtr->fragPageId)) { + Uint32 prevGCI = pagePtr.p->pageWord[temp]; + ljam(); + cprAddUndoLogRecord(signal, + ZLCPR_TYPE_UPDATE_GCI, + regOperPtr->fragPageId, + regOperPtr->pageIndex, + regOperPtr->tableRef, + regOperPtr->fragId, + regFragPtr->checkpointVersion); + cprAddGCIUpdate(signal, + prevGCI, + regFragPtr); + }//if + pagePtr.p->pageWord[temp] = regOperPtr->gci; + if (regTabPtr->checksumIndicator) { + ljam(); + setChecksum(pagePtr.p, regOperPtr->pageOffset, regTabPtr->tupheadsize); + }//if +}//Dbtup::updateGcpId() + +void +Dbtup::commitRecord(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr) +{ + Uint32 opType; + OperationrecPtr firstOpPtr; + PagePtr pagePtr; + + pagePtr.i = regOperPtr->realPageId; + ptrCheckGuard(pagePtr, cnoOfPage, page); + + setTupleStatesSetOpType(regOperPtr, pagePtr.p, opType, firstOpPtr); + + fragptr.p = regFragPtr; + tabptr.p = regTabPtr; + + if (opType == ZINSERT_DELETE) { + ljam(); +//-------------------------------------------------------------------- +// We started by inserting the tuple and ended by deleting. Seen from +// transactions point of view no changes were made. +//-------------------------------------------------------------------- + commitUpdate(signal, regOperPtr, regFragPtr, regTabPtr); + return; + } else if (opType == ZINSERT) { + ljam(); +//-------------------------------------------------------------------- +// We started by inserting whereafter we made several changes to the +// tuple that could include updates, deletes and new inserts. The final +// state of the tuple is the original tuple. This is reached from this +// operation. We change the optype on this operation to ZINSERT to +// ensure proper operation of the detached trigger. +// We restore the optype after executing triggers although not really +// needed. +//-------------------------------------------------------------------- + Uint32 saveOpType = regOperPtr->optype; + regOperPtr->optype = ZINSERT; + operPtr.p = regOperPtr; + + checkDetachedTriggers(signal, + regOperPtr, + regTabPtr); + + regOperPtr->optype = saveOpType; + } else if (opType == ZUPDATE) { + ljam(); +//-------------------------------------------------------------------- +// We want to use the first operation which contains a copy tuple +// reference. This operation contains the before value of this record +// for this transaction. Then this operation is used for executing +// triggers with optype set to update. +//-------------------------------------------------------------------- + OperationrecPtr befOpPtr; + findBeforeValueOperation(befOpPtr, firstOpPtr); + + Uint32 saveOpType = befOpPtr.p->optype; + Bitmask attributeMask; + Bitmask saveAttributeMask; + + calculateChangeMask(pagePtr.p, + regTabPtr, + befOpPtr.p->pageOffset, + attributeMask); + + saveAttributeMask.clear(); + saveAttributeMask.bitOR(befOpPtr.p->changeMask); + befOpPtr.p->changeMask.clear(); + befOpPtr.p->changeMask.bitOR(attributeMask); + + operPtr.p = befOpPtr.p; + checkDetachedTriggers(signal, + befOpPtr.p, + regTabPtr); + + befOpPtr.p->changeMask.clear(); + befOpPtr.p->changeMask.bitOR(saveAttributeMask); + + befOpPtr.p->optype = saveOpType; + } else if (opType == ZDELETE) { + ljam(); +//-------------------------------------------------------------------- +// We want to use the first operation which contains a copy tuple. +// We benefit from the fact that we know that it cannot be a simple +// delete and it cannot be an insert followed by a delete. Thus there +// must either be an update or a insert following a delete. In both +// cases we will find a before value in a copy tuple. +// +// An added complexity is that the trigger handling assumes that the +// before value is located in the original tuple so we have to move the +// copy tuple reference to the original tuple reference and afterwards +// restore it again. +//-------------------------------------------------------------------- + OperationrecPtr befOpPtr; + findBeforeValueOperation(befOpPtr, firstOpPtr); + Uint32 saveOpType = befOpPtr.p->optype; + + Uint32 realPageId = befOpPtr.p->realPageId; + Uint32 pageOffset = befOpPtr.p->pageOffset; + Uint32 fragPageId = befOpPtr.p->fragPageId; + Uint32 pageIndex = befOpPtr.p->pageIndex; + + befOpPtr.p->realPageId = befOpPtr.p->realPageIdC; + befOpPtr.p->pageOffset = befOpPtr.p->pageOffsetC; + befOpPtr.p->fragPageId = befOpPtr.p->fragPageIdC; + befOpPtr.p->pageIndex = befOpPtr.p->pageIndexC; + + operPtr.p = befOpPtr.p; + checkDetachedTriggers(signal, + befOpPtr.p, + regTabPtr); + + befOpPtr.p->realPageId = realPageId; + befOpPtr.p->pageOffset = pageOffset; + befOpPtr.p->fragPageId = fragPageId; + befOpPtr.p->pageIndex = pageIndex; + befOpPtr.p->optype = saveOpType; + } else { + ndbrequire(false); + }//if + + commitUpdate(signal, regOperPtr, regFragPtr, regTabPtr); + if (regTabPtr->GCPIndicator) { + updateGcpId(signal, regOperPtr, regFragPtr, regTabPtr); + }//if +}//Dbtup::commitRecord() + +void +Dbtup::setTupleStatesSetOpType(Operationrec* const regOperPtr, + Page* const pagePtr, + Uint32& opType, + OperationrecPtr& firstOpPtr) +{ + OperationrecPtr loopOpPtr; + OperationrecPtr lastOpPtr; + + ndbrequire(regOperPtr->pageOffset < ZWORDS_ON_PAGE); + loopOpPtr.i = pagePtr->pageWord[regOperPtr->pageOffset]; + ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec); + lastOpPtr = loopOpPtr; + if (loopOpPtr.p->optype == ZDELETE) { + ljam(); + opType = ZDELETE; + } else { + ljam(); + opType = ZUPDATE; + }//if + do { + ljam(); + ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec); + firstOpPtr = loopOpPtr; + loopOpPtr.p->tupleState = TO_BE_COMMITTED; + loopOpPtr.i = loopOpPtr.p->nextActiveOp; + } while (loopOpPtr.i != RNIL); + if (opType == ZDELETE) { + ljam(); + if (firstOpPtr.p->optype == ZINSERT) { + ljam(); + opType = ZINSERT_DELETE; + }//if + } else { + ljam(); + if (firstOpPtr.p->optype == ZINSERT) { + ljam(); + opType = ZINSERT; + }//if + }///if +}//Dbtup::setTupleStatesSetOpType() + +void Dbtup::findBeforeValueOperation(OperationrecPtr& befOpPtr, + OperationrecPtr firstOpPtr) +{ + befOpPtr = firstOpPtr; + if (befOpPtr.p->realPageIdC != RNIL) { + ljam(); + return; + } else { + ljam(); + befOpPtr.i = befOpPtr.p->prevActiveOp; + ptrCheckGuard(befOpPtr, cnoOfOprec, operationrec); + ndbrequire(befOpPtr.p->realPageIdC != RNIL); + }//if +}//Dbtup::findBeforeValueOperation() + +void +Dbtup::calculateChangeMask(Page* const pagePtr, + Tablerec* const regTabPtr, + Uint32 pageOffset, + Bitmask& attributeMask) +{ + OperationrecPtr loopOpPtr; + + attributeMask.clear(); + ndbrequire(pageOffset < ZWORDS_ON_PAGE); + loopOpPtr.i = pagePtr->pageWord[pageOffset]; + do { + ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec); + if (loopOpPtr.p->optype == ZUPDATE) { + ljam(); + attributeMask.bitOR(loopOpPtr.p->changeMask); + } else if (loopOpPtr.p->optype == ZINSERT) { + ljam(); + attributeMask.set(); + return; + } else { + ndbrequire(loopOpPtr.p->optype == ZDELETE); + }//if + loopOpPtr.i = loopOpPtr.p->nextActiveOp; + } while (loopOpPtr.i != RNIL); +}//Dbtup::calculateChangeMask() diff --git a/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp b/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp new file mode 100644 index 00000000000..c38fde23404 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp @@ -0,0 +1,399 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include +#include +#include +#include +#include + +#define ljam() { jamLine(30000 + __LINE__); } +#define ljamEntry() { jamEntryLine(30000 + __LINE__); } + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* ------------------------ DEBUG MODULE -------------------------- */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ +void Dbtup::execDEBUG_SIG(Signal* signal) +{ + PagePtr regPagePtr; + ljamEntry(); + regPagePtr.i = signal->theData[0]; + ptrCheckGuard(regPagePtr, cnoOfPage, page); +}//Dbtup::execDEBUG_SIG() + +#ifdef TEST_MR +#include + +void startTimer(struct timespec *tp) +{ + clock_gettime(CLOCK_REALTIME, tp); +}//startTimer() + +int stopTimer(struct timespec *tp) +{ + double timer_count; + struct timespec theStopTime; + clock_gettime(CLOCK_REALTIME, &theStopTime); + timer_count = (double)(1000000*((double)theStopTime.tv_sec - (double)tp->tv_sec)) + + (double)((double)((double)theStopTime.tv_nsec - (double)tp->tv_nsec)/(double)1000); + return (int)timer_count; +}//stopTimer() + +#endif // end TEST_MR + +struct Chunk { + Uint32 pageId; + Uint32 pageCount; +}; + +void +Dbtup::reportMemoryUsage(Signal* signal, int incDec){ + signal->theData[0] = EventReport::MemoryUsage; + signal->theData[1] = incDec; + signal->theData[2] = sizeof(Page); + signal->theData[3] = cnoOfAllocatedPages; + signal->theData[4] = cnoOfPage; + signal->theData[5] = DBTUP; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 6, JBB); +} + +void +Dbtup::execDUMP_STATE_ORD(Signal* signal) +{ + Uint32 type = signal->theData[0]; + if(type == DumpStateOrd::DumpPageMemory){ + reportMemoryUsage(signal, 0); + return; + } + DumpStateOrd * const dumpState = (DumpStateOrd *)&signal->theData[0]; + +#if 0 + if (type == 100) { + RelTabMemReq * const req = (RelTabMemReq *)signal->getDataPtrSend(); + req->primaryTableId = 2; + req->secondaryTableId = RNIL; + req->userPtr = 2; + req->userRef = DBDICT_REF; + sendSignal(cownref, GSN_REL_TABMEMREQ, signal, + RelTabMemReq::SignalLength, JBB); + return; + }//if + if (type == 101) { + RelTabMemReq * const req = (RelTabMemReq *)signal->getDataPtrSend(); + req->primaryTableId = 4; + req->secondaryTableId = 5; + req->userPtr = 4; + req->userRef = DBDICT_REF; + sendSignal(cownref, GSN_REL_TABMEMREQ, signal, + RelTabMemReq::SignalLength, JBB); + return; + }//if + if (type == 102) { + RelTabMemReq * const req = (RelTabMemReq *)signal->getDataPtrSend(); + req->primaryTableId = 6; + req->secondaryTableId = 8; + req->userPtr = 6; + req->userRef = DBDICT_REF; + sendSignal(cownref, GSN_REL_TABMEMREQ, signal, + RelTabMemReq::SignalLength, JBB); + return; + }//if + if (type == 103) { + DropTabFileReq * const req = (DropTabFileReq *)signal->getDataPtrSend(); + req->primaryTableId = 2; + req->secondaryTableId = RNIL; + req->userPtr = 2; + req->userRef = DBDICT_REF; + sendSignal(cownref, GSN_DROP_TABFILEREQ, signal, + DropTabFileReq::SignalLength, JBB); + return; + }//if + if (type == 104) { + DropTabFileReq * const req = (DropTabFileReq *)signal->getDataPtrSend(); + req->primaryTableId = 4; + req->secondaryTableId = 5; + req->userPtr = 4; + req->userRef = DBDICT_REF; + sendSignal(cownref, GSN_DROP_TABFILEREQ, signal, + DropTabFileReq::SignalLength, JBB); + return; + }//if + if (type == 105) { + DropTabFileReq * const req = (DropTabFileReq *)signal->getDataPtrSend(); + req->primaryTableId = 6; + req->secondaryTableId = 8; + req->userPtr = 6; + req->userRef = DBDICT_REF; + sendSignal(cownref, GSN_DROP_TABFILEREQ, signal, + DropTabFileReq::SignalLength, JBB); + return; + }//if +#endif +#ifdef ERROR_INSERT + if (type == DumpStateOrd::EnableUndoDelayDataWrite) { + ndbout << "Dbtup:: delay write of datapages for table = " + << dumpState->args[1]<< endl; + c_errorInsert4000TableId = dumpState->args[1]; + SET_ERROR_INSERT_VALUE(4000); + return; + }//if +#endif +#ifdef VM_TRACE + if (type == 1211){ + ndbout_c("Startar modul test av Page Manager"); + + Vector chunks; + const Uint32 LOOPS = 1000; + for(Uint32 i = 0; ipageWord[ZPAGE_STATE_POS] = ~ZFREE_COMMON; + } + } + break; + } + } + while(chunks.size() > 0){ + Chunk chunk = chunks.back(); + returnCommonArea(chunk.pageId, chunk.pageCount); + chunks.erase(chunks.size() - 1); + } + } +#endif +}//Dbtup::execDUMP_STATE_ORD() + +/* ---------------------------------------------------------------- */ +/* --------- MEMORY CHECK ----------------------- */ +/* ---------------------------------------------------------------- */ +void Dbtup::execMEMCHECKREQ(Signal* signal) +{ + PagePtr regPagePtr; + DiskBufferSegmentInfoPtr dbsiPtr; + CheckpointInfoPtr ciPtr; + UndoPagePtr regUndoPagePtr; + Uint32* data = &signal->theData[0]; + + ljamEntry(); + BlockReference blockref = signal->theData[0]; + for (Uint32 i = 0; i < 25; i++) { + ljam(); + data[i] = 0; + }//for + for (Uint32 i = 0; i < 16; i++) { + regPagePtr.i = cfreepageList[i]; + ljam(); + while (regPagePtr.i != RNIL) { + ljam(); + ptrCheckGuard(regPagePtr, cnoOfPage, page); + regPagePtr.i = regPagePtr.p->pageWord[ZPAGE_NEXT_POS]; + data[0]++; + }//while + }//for + regUndoPagePtr.i = cfirstfreeUndoSeg; + while (regUndoPagePtr.i != RNIL) { + ljam(); + ptrCheckGuard(regUndoPagePtr, cnoOfUndoPage, undoPage); + regUndoPagePtr.i = regUndoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS]; + data[1] += ZUB_SEGMENT_SIZE; + }//while + ciPtr.i = cfirstfreeLcp; + while (ciPtr.i != RNIL) { + ljam(); + ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo); + ciPtr.i = ciPtr.p->lcpNextRec; + data[2]++; + }//while + dbsiPtr.i = cfirstfreePdx; + while (dbsiPtr.i != ZNIL) { + ljam(); + ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo); + dbsiPtr.i = dbsiPtr.p->pdxNextRec; + data[3]++; + }//while + sendSignal(blockref, GSN_MEMCHECKCONF, signal, 25, JBB); +}//Dbtup::memCheck() + +// ------------------------------------------------------------------------ +// Help function to be used when debugging. Prints out a tuple page. +// printLimit is the number of bytes that is printed out from the page. A +// page is of size 32768 bytes as of March 2003. +// ------------------------------------------------------------------------ +void Dbtup::printoutTuplePage(Uint32 fragid, Uint32 pageid, Uint32 printLimit) +{ + PagePtr tmpPageP; + FragrecordPtr tmpFragP; + TablerecPtr tmpTableP; + Uint32 tmpTupleSize; + + tmpPageP.i = pageid; + ptrCheckGuard(tmpPageP, cnoOfPage, page); + + tmpFragP.i = fragid; + ptrCheckGuard(tmpFragP, cnoOfFragrec, fragrecord); + + tmpTableP.i = tmpFragP.p->fragTableId; + ptrCheckGuard(tmpTableP, cnoOfTablerec, tablerec); + + tmpTupleSize = tmpTableP.p->tupheadsize; + + ndbout << "Fragid: " << fragid << " Pageid: " << pageid << endl + << "----------------------------------------" << endl; + + ndbout << "PageHead : "; + for (Uint32 i1 = 0; i1 < ZPAGE_HEADER_SIZE; i1++) { + if (i1 == 3) + ndbout << (tmpPageP.p->pageWord[i1] >> 16) << "," << (tmpPageP.p->pageWord[i1] & 0xffff) << " "; + else if (tmpPageP.p->pageWord[i1] == 4059165169u) + ndbout << "F1F1F1F1 "; + else if (tmpPageP.p->pageWord[i1] == 268435455u) + ndbout << "RNIL "; + else + ndbout << tmpPageP.p->pageWord[i1] << " "; + }//for + ndbout << endl; + for (Uint32 i = ZPAGE_HEADER_SIZE; i < printLimit; i += tmpTupleSize) { + ndbout << "pagepos " << i << " : "; + + for (Uint32 j = i; j < i + tmpTupleSize; j++) { + if (tmpPageP.p->pageWord[j] == 4059165169u) + ndbout << "F1F1F1F1 "; + else if (tmpPageP.p->pageWord[j] == 268435455u) + ndbout << "RNIL "; + else + ndbout << tmpPageP.p->pageWord[j] << " "; + }//for + ndbout << endl; + }//for +}//Dbtup::printoutTuplePage + +#ifdef VM_TRACE +NdbOut& +operator<<(NdbOut& out, const Dbtup::Operationrec& op) +{ + out << "[Operationrec " << hex << &op; + // table + out << " [tableRef " << dec << op.tableRef << "]"; + out << " [fragId " << dec << op.fragId << "]"; + out << " [fragmentPtr " << hex << op.fragmentPtr << "]"; + // type + out << " [optype " << dec << op.optype << "]"; + out << " [deleteInsertFlag " << dec << op.deleteInsertFlag << "]"; + out << " [dirtyOp " << dec << op.dirtyOp << "]"; + out << " [interpretedExec " << dec << op.interpretedExec << "]"; + out << " [opSimple " << dec << op.opSimple << "]"; + // state + out << " [tupleState " << dec << op.tupleState << "]"; + out << " [transstate " << dec << op.transstate << "]"; + out << " [inFragList " << dec << op.inFragList << "]"; + out << " [inActiveOpList " << dec << op.inActiveOpList << "]"; + out << " [undoLogged " << dec << op.undoLogged << "]"; + // links + out << " [prevActiveOp " << hex << op.prevActiveOp << "]"; + out << " [nextActiveOp " << hex << op.nextActiveOp << "]"; + // tuples + out << " [tupVersion " << hex << op.tupVersion << "]"; + out << " [fragPageId " << dec << op.fragPageId << "]"; + out << " [pageIndex " << dec << op.pageIndex << "]"; + out << " [realPageId " << hex << op.realPageId << "]"; + out << " [pageOffset " << dec << op.pageOffset << "]"; + out << " [fragPageIdC " << dec << op.fragPageIdC << "]"; + out << " [pageIndexC " << dec << op.pageIndexC << "]"; + out << " [realPageIdC " << hex << op.realPageIdC << "]"; + out << " [pageOffsetC " << dec << op.pageOffsetC << "]"; + // trans + out << " [transid1 " << hex << op.transid1 << "]"; + out << " [transid2 " << hex << op.transid2 << "]"; + out << "]"; + return out; +} + +// uses global tabptr +NdbOut& +operator<<(NdbOut& out, const Dbtup::Th& th) +{ + // ugly + Dbtup* tup = (Dbtup*)globalData.getBlock(DBTUP); + const Dbtup::Tablerec& tab = *tup->tabptr.p; + unsigned i = 0; + out << "[Th " << hex << &th; + out << " [op " << hex << th.data[i++] << "]"; + out << " [version " << hex << (Uint16)th.data[i++] << "]"; + if (tab.checksumIndicator) + out << " [checksum " << hex << th.data[i++] << "]"; + out << " [nullbits"; + for (unsigned j = 0; j < tab.tupNullWords; j++) + out << " " << hex << th.data[i++]; + out << "]"; + if (tab.GCPIndicator) + out << " [gcp " << dec << th.data[i++] << "]"; + out << " [data"; + while (i < tab.tupheadsize) + out << " " << hex << th.data[i++]; + out << "]"; + out << "]"; + return out; +} +#endif diff --git a/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp b/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp new file mode 100644 index 00000000000..07bad00acf1 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp @@ -0,0 +1,2067 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include +#include +#include "AttributeOffset.hpp" +#include +#include +#include +#include +#include + +/* ----------------------------------------------------------------- */ +/* ----------- INIT_STORED_OPERATIONREC -------------- */ +/* ----------------------------------------------------------------- */ +int Dbtup::initStoredOperationrec(Operationrec* const regOperPtr, + Uint32 storedId) +{ + jam(); + StoredProcPtr storedPtr; + c_storedProcPool.getPtr(storedPtr, storedId); + if (storedPtr.i != RNIL) { + if (storedPtr.p->storedCode == ZSCAN_PROCEDURE) { + storedPtr.p->storedCounter++; + regOperPtr->firstAttrinbufrec = storedPtr.p->storedLinkFirst; + regOperPtr->lastAttrinbufrec = storedPtr.p->storedLinkLast; + regOperPtr->attrinbufLen = storedPtr.p->storedProcLength; + regOperPtr->currentAttrinbufLen = storedPtr.p->storedProcLength; + return ZOK; + }//if + }//if + terrorCode = ZSTORED_PROC_ID_ERROR; + return terrorCode; +}//Dbtup::initStoredOperationrec() + +void Dbtup::copyAttrinfo(Signal* signal, + Operationrec * const regOperPtr, + Uint32* inBuffer) +{ + AttrbufrecPtr copyAttrBufPtr; + Uint32 RnoOfAttrBufrec = cnoOfAttrbufrec; + int RbufLen; + Uint32 RinBufIndex = 0; + Uint32 Rnext; + Uint32 Rfirst; + Uint32 TstoredProcedure = (regOperPtr->storedProcedureId != ZNIL); + Uint32 RnoFree = cnoFreeAttrbufrec; + +//------------------------------------------------------------------------- +// As a prelude to the execution of the TUPKEYREQ we will copy the program +// into the inBuffer to enable easy execution without any complex jumping +// between the buffers. In particular this will make the interpreter less +// complex. Hopefully it does also improve performance. +//------------------------------------------------------------------------- + copyAttrBufPtr.i = regOperPtr->firstAttrinbufrec; + while (copyAttrBufPtr.i != RNIL) { + jam(); + ndbrequire(copyAttrBufPtr.i < RnoOfAttrBufrec); + ptrAss(copyAttrBufPtr, attrbufrec); + RbufLen = copyAttrBufPtr.p->attrbuf[ZBUF_DATA_LEN]; + Rnext = copyAttrBufPtr.p->attrbuf[ZBUF_NEXT]; + Rfirst = cfirstfreeAttrbufrec; + MEMCOPY_NO_WORDS(&inBuffer[RinBufIndex], + ©AttrBufPtr.p->attrbuf[0], + RbufLen); + RinBufIndex += RbufLen; + if (!TstoredProcedure) { + copyAttrBufPtr.p->attrbuf[ZBUF_NEXT] = Rfirst; + cfirstfreeAttrbufrec = copyAttrBufPtr.i; + RnoFree++; + }//if + copyAttrBufPtr.i = Rnext; + }//while + cnoFreeAttrbufrec = RnoFree; + if (TstoredProcedure) { + jam(); + StoredProcPtr storedPtr; + c_storedProcPool.getPtr(storedPtr, (Uint32)regOperPtr->storedProcedureId); + ndbrequire(storedPtr.p->storedCode == ZSCAN_PROCEDURE); + storedPtr.p->storedCounter--; + regOperPtr->storedProcedureId = ZNIL; + }//if + // Release the ATTRINFO buffers + regOperPtr->firstAttrinbufrec = RNIL; + regOperPtr->lastAttrinbufrec = RNIL; +}//Dbtup::copyAttrinfo() + +void Dbtup::handleATTRINFOforTUPKEYREQ(Signal* signal, + Uint32 length, + Operationrec * const regOperPtr) +{ + AttrbufrecPtr TAttrinbufptr; + TAttrinbufptr.i = cfirstfreeAttrbufrec; + if ((cfirstfreeAttrbufrec < cnoOfAttrbufrec) && + (cnoFreeAttrbufrec > MIN_ATTRBUF)) { + ptrAss(TAttrinbufptr, attrbufrec); + MEMCOPY_NO_WORDS(&TAttrinbufptr.p->attrbuf[0], + &signal->theData[3], + length); + Uint32 RnoFree = cnoFreeAttrbufrec; + Uint32 Rnext = TAttrinbufptr.p->attrbuf[ZBUF_NEXT]; + TAttrinbufptr.p->attrbuf[ZBUF_DATA_LEN] = length; + TAttrinbufptr.p->attrbuf[ZBUF_NEXT] = RNIL; + + AttrbufrecPtr locAttrinbufptr; + Uint32 RnewLen = regOperPtr->currentAttrinbufLen; + + locAttrinbufptr.i = regOperPtr->lastAttrinbufrec; + cfirstfreeAttrbufrec = Rnext; + cnoFreeAttrbufrec = RnoFree - 1; + RnewLen += length; + regOperPtr->lastAttrinbufrec = TAttrinbufptr.i; + regOperPtr->currentAttrinbufLen = RnewLen; + if (locAttrinbufptr.i == RNIL) { + regOperPtr->firstAttrinbufrec = TAttrinbufptr.i; + return; + } else { + jam(); + ptrCheckGuard(locAttrinbufptr, cnoOfAttrbufrec, attrbufrec); + locAttrinbufptr.p->attrbuf[ZBUF_NEXT] = TAttrinbufptr.i; + }//if + if (RnewLen < ZATTR_BUFFER_SIZE) { + return; + } else { + jam(); + regOperPtr->transstate = TOO_MUCH_AI; + return; + }//if + } else if (cnoFreeAttrbufrec <= MIN_ATTRBUF) { + jam(); + regOperPtr->transstate = ERROR_WAIT_TUPKEYREQ; + } else { + ndbrequire(false); + }//if +}//Dbtup::handleATTRINFOforTUPKEYREQ() + +void Dbtup::execATTRINFO(Signal* signal) +{ + OperationrecPtr regOpPtr; + Uint32 Rsig0 = signal->theData[0]; + Uint32 Rlen = signal->length(); + regOpPtr.i = Rsig0; + + jamEntry(); + + ptrCheckGuard(regOpPtr, cnoOfOprec, operationrec); + if (regOpPtr.p->transstate == IDLE) { + handleATTRINFOforTUPKEYREQ(signal, Rlen - 3, regOpPtr.p); + return; + } else if (regOpPtr.p->transstate == WAIT_STORED_PROCEDURE_ATTR_INFO) { + storedProcedureAttrInfo(signal, regOpPtr.p, Rlen - 3, 3, false); + return; + }//if + switch (regOpPtr.p->transstate) { + case ERROR_WAIT_STORED_PROCREQ: + jam(); + case TOO_MUCH_AI: + jam(); + case ERROR_WAIT_TUPKEYREQ: + jam(); + return; /* IGNORE ATTRINFO IN THOSE STATES, WAITING FOR ABORT SIGNAL */ + break; + case DISCONNECTED: + jam(); + case STARTED: + jam(); + default: + ndbrequire(false); + }//switch +}//Dbtup::execATTRINFO() + +void Dbtup::execTUP_ALLOCREQ(Signal* signal) +{ + OperationrecPtr regOperPtr; + TablerecPtr regTabPtr; + FragrecordPtr regFragPtr; + + jamEntry(); + + regOperPtr.i = signal->theData[0]; + regFragPtr.i = signal->theData[1]; + regTabPtr.i = signal->theData[2]; + + if (!((regOperPtr.i < cnoOfOprec) && + (regFragPtr.i < cnoOfFragrec) && + (regTabPtr.i < cnoOfTablerec))) { + ndbrequire(false); + }//if + ptrAss(regOperPtr, operationrec); + ptrAss(regFragPtr, fragrecord); + ptrAss(regTabPtr, tablerec); + +//--------------------------------------------------- +/* --- Allocate a tuple as requested by ACC --- */ +//--------------------------------------------------- + PagePtr pagePtr; + Uint32 pageOffset; + if (!allocTh(regFragPtr.p, + regTabPtr.p, + NORMAL_PAGE, + signal, + pageOffset, + pagePtr)) { + signal->theData[0] = terrorCode; // Indicate failure + return; + }//if + Uint32 fragPageId = pagePtr.p->pageWord[ZPAGE_FRAG_PAGE_ID_POS]; + Uint32 pageIndex = ((pageOffset - ZPAGE_HEADER_SIZE) / + regTabPtr.p->tupheadsize) << 1; + regOperPtr.p->tableRef = regTabPtr.i; + regOperPtr.p->fragId = regFragPtr.p->fragmentId; + regOperPtr.p->realPageId = pagePtr.i; + regOperPtr.p->fragPageId = fragPageId; + regOperPtr.p->pageOffset = pageOffset; + regOperPtr.p->pageIndex = pageIndex; + /* -------------------------------------------------------------- */ + /* AN INSERT IS UNDONE BY FREEING THE DATA OCCUPIED BY THE INSERT */ + /* THE ONLY DATA WE HAVE TO LOG EXCEPT THE TYPE, PAGE AND INDEX */ + /* IS THE AMOUNT OF DATA TO FREE */ + /* -------------------------------------------------------------- */ + if (isUndoLoggingNeeded(regFragPtr.p, fragPageId)) { + jam(); + cprAddUndoLogRecord(signal, + ZLCPR_TYPE_DELETE_TH, + fragPageId, + pageIndex, + regTabPtr.i, + regFragPtr.p->fragmentId, + regFragPtr.p->checkpointVersion); + }//if + + //--------------------------------------------------------------- + // Initialise Active operation list by setting the list to empty + //--------------------------------------------------------------- + ndbrequire(pageOffset < ZWORDS_ON_PAGE); + pagePtr.p->pageWord[pageOffset] = RNIL; + + signal->theData[0] = 0; + signal->theData[1] = fragPageId; + signal->theData[2] = pageIndex; +}//Dbtup::execTUP_ALLOCREQ() + +void +Dbtup::setChecksum(Page* const pagePtr, Uint32 tupHeadOffset, Uint32 tupHeadSize) +{ + // 2 == regTabPtr.p->tupChecksumIndex + pagePtr->pageWord[tupHeadOffset + 2] = 0; + Uint32 checksum = calculateChecksum(pagePtr, tupHeadOffset, tupHeadSize); + pagePtr->pageWord[tupHeadOffset + 2] = checksum; +}//Dbtup::setChecksum() + +Uint32 +Dbtup::calculateChecksum(Page* pagePtr, + Uint32 tupHeadOffset, + Uint32 tupHeadSize) +{ + Uint32 checksum = 0; + Uint32 loopStop = tupHeadOffset + tupHeadSize; + ndbrequire(loopStop <= ZWORDS_ON_PAGE); + // includes tupVersion + for (Uint32 i = tupHeadOffset + 1; i < loopStop; i++) { + checksum ^= pagePtr->pageWord[i]; + }//if + return checksum; +}//Dbtup::calculateChecksum() + +/* ----------------------------------------------------------------- */ +/* ----------- INSERT_ACTIVE_OP_LIST -------------- */ +/* ----------------------------------------------------------------- */ +void Dbtup::insertActiveOpList(Signal* signal, + OperationrecPtr regOperPtr, + Page* const pagePtr, + Uint32 pageOffset) +{ + OperationrecPtr iaoPrevOpPtr; + ndbrequire(regOperPtr.p->inActiveOpList == ZFALSE); + regOperPtr.p->inActiveOpList = ZTRUE; + ndbrequire(pageOffset < ZWORDS_ON_PAGE); + iaoPrevOpPtr.i = pagePtr->pageWord[pageOffset]; + pagePtr->pageWord[pageOffset] = regOperPtr.i; + regOperPtr.p->prevActiveOp = RNIL; + regOperPtr.p->nextActiveOp = iaoPrevOpPtr.i; + if (iaoPrevOpPtr.i == RNIL) { + return; + } else { + jam(); + ptrCheckGuard(iaoPrevOpPtr, cnoOfOprec, operationrec); + iaoPrevOpPtr.p->prevActiveOp = regOperPtr.i; + if (iaoPrevOpPtr.p->optype == ZDELETE && + regOperPtr.p->optype == ZINSERT) { + jam(); + // mark both + iaoPrevOpPtr.p->deleteInsertFlag = 1; + regOperPtr.p->deleteInsertFlag = 1; + } + return; + }//if +}//Dbtup::insertActiveOpList() + +void Dbtup::linkOpIntoFragList(OperationrecPtr regOperPtr, + Fragrecord* const regFragPtr) +{ + OperationrecPtr sopTmpOperPtr; +/* ----------------------------------------------------------------- */ +/* LINK THE OPERATION INTO A DOUBLY LINKED LIST ON THE FRAGMENT*/ +/* PUT IT FIRST IN THIS LIST SINCE IT DOESN'T MATTER WHERE IT */ +/* IS PUT. */ +/* ----------------------------------------------------------------- */ + ndbrequire(regOperPtr.p->inFragList == ZFALSE); + regOperPtr.p->inFragList = ZTRUE; + regOperPtr.p->prevOprecInList = RNIL; + sopTmpOperPtr.i = regFragPtr->firstusedOprec; + regFragPtr->firstusedOprec = regOperPtr.i; + regOperPtr.p->nextOprecInList = sopTmpOperPtr.i; + if (sopTmpOperPtr.i == RNIL) { + return; + } else { + jam(); + ptrCheckGuard(sopTmpOperPtr, cnoOfOprec, operationrec); + sopTmpOperPtr.p->prevOprecInList = regOperPtr.i; + }//if +}//Dbtup::linkOpIntoFragList() + +/* +This routine is optimised for use from TUPKEYREQ. +This means that a lot of input data is stored in the operation record. +The routine expects the following data in the operation record to be +set-up properly. +Transaction data +1) transid1 +2) transid2 +3) savePointId + +Operation data +4) optype +5) dirtyOp + +Tuple address +6) fragPageId +7) pageIndex + +regFragPtr and regTabPtr are references to the table and fragment data and +is read-only. + +The routine will set up the following data in the operation record if +returned with success. + +Tuple address data +1) realPageId +2) fragPageId +3) pageOffset +4) pageIndex + +Also the pagePtr is an output variable if the routine returns with success. +It's input value can be undefined. +*/ +bool +Dbtup::getPage(PagePtr& pagePtr, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr) +{ +/* ------------------------------------------------------------------------- */ +// GET THE REFERENCE TO THE TUPLE HEADER BY TRANSLATING THE FRAGMENT PAGE ID +// INTO A REAL PAGE ID AND BY USING THE PAGE INDEX TO DERIVE THE PROPER INDEX +// IN THE REAL PAGE. +/* ------------------------------------------------------------------------- */ + pagePtr.i = getRealpid(regFragPtr, regOperPtr->fragPageId); + regOperPtr->realPageId = pagePtr.i; + Uint32 RpageIndex = regOperPtr->pageIndex; + Uint32 Rtupheadsize = regTabPtr->tupheadsize; + ptrCheckGuard(pagePtr, cnoOfPage, page); + Uint32 RpageIndexScaled = RpageIndex >> 1; + ndbrequire((RpageIndex & 1) == 0); + regOperPtr->pageOffset = ZPAGE_HEADER_SIZE + + (Rtupheadsize * RpageIndexScaled); + + OperationrecPtr leaderOpPtr; + ndbrequire(regOperPtr->pageOffset < ZWORDS_ON_PAGE); + leaderOpPtr.i = pagePtr.p->pageWord[regOperPtr->pageOffset]; + if (leaderOpPtr.i == RNIL) { + return true; + }//if + ptrCheckGuard(leaderOpPtr, cnoOfOprec, operationrec); + bool dirtyRead = ((regOperPtr->optype == ZREAD) && + (regOperPtr->dirtyOp == 1)); + if (dirtyRead) { + bool sameTrans = ((regOperPtr->transid1 == leaderOpPtr.p->transid1) && + (regOperPtr->transid2 == leaderOpPtr.p->transid2)); + if (!sameTrans) { + if (!getPageLastCommitted(regOperPtr, leaderOpPtr.p)) { + return false; + }//if + pagePtr.i = regOperPtr->realPageId; + ptrCheckGuard(pagePtr, cnoOfPage, page); + return true; + }//if + }//if + if (regOperPtr->optype == ZREAD) { + /* + Read uses savepoint id's to find the correct tuple version. + */ + if (getPageThroughSavePoint(regOperPtr, leaderOpPtr.p)) { + jam(); + pagePtr.i = regOperPtr->realPageId; + ptrCheckGuard(pagePtr, cnoOfPage, page); + return true; + } + return false; + } +//---------------------------------------------------------------------- +// Check that no other operation is already active on the tuple. Also +// that abort or commit is not ongoing. +//---------------------------------------------------------------------- + if (leaderOpPtr.p->tupleState == NO_OTHER_OP) { + jam(); + if ((leaderOpPtr.p->optype == ZDELETE) && + (regOperPtr->optype != ZINSERT)) { + jam(); + terrorCode = ZTUPLE_DELETED_ERROR; + return false; + }//if + return true; + } else if (leaderOpPtr.p->tupleState == ALREADY_ABORTED) { + jam(); + terrorCode = ZMUST_BE_ABORTED_ERROR; + return false; + } else { + ndbrequire(false); + }//if + return true; +}//Dbtup::getPage() + +bool +Dbtup::getPageThroughSavePoint(Operationrec* regOperPtr, + Operationrec* leaderOpPtr) +{ + bool found = false; + OperationrecPtr loopOpPtr; + loopOpPtr.p = leaderOpPtr; + while(true) { + if (regOperPtr->savePointId > loopOpPtr.p->savePointId) { + jam(); + found = true; + break; + } + if (loopOpPtr.p->nextActiveOp == RNIL) { + break; + } + loopOpPtr.i = loopOpPtr.p->nextActiveOp; + ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec); + jam(); + } + if (!found) { + return getPageLastCommitted(regOperPtr, loopOpPtr.p); + } else { + if (loopOpPtr.p->optype == ZDELETE) { + jam(); + terrorCode = ZTUPLE_DELETED_ERROR; + return false; + } + if (loopOpPtr.p->tupleState == ALREADY_ABORTED) { + /* + Requested tuple version has already been aborted + */ + jam(); + terrorCode = ZMUST_BE_ABORTED_ERROR; + return false; + } + bool use_copy; + if (loopOpPtr.p->prevActiveOp == RNIL) { + jam(); + /* + Use original tuple since we are reading from the last written tuple. + We are the + */ + use_copy = false; + } else { + /* + Go forward in time to find a copy of the tuple which this operation + produced + */ + loopOpPtr.i = loopOpPtr.p->prevActiveOp; + ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec); + if (loopOpPtr.p->optype == ZDELETE) { + /* + This operation was a Delete and thus have no copy tuple attached to + it. We will move forward to the next that either doesn't exist in + which case we will return the original tuple of any operation and + otherwise it must be an insert which contains a copy record. + */ + if (loopOpPtr.p->prevActiveOp == RNIL) { + jam(); + use_copy = false; + } else { + jam(); + loopOpPtr.i = loopOpPtr.p->prevActiveOp; + ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec); + ndbrequire(loopOpPtr.p->optype == ZINSERT); + use_copy = true; + } + } else if (loopOpPtr.p->optype == ZUPDATE) { + jam(); + /* + This operation which was the next in time have a copy which was the + result of the previous operation which we want to use. Thus use + the copy tuple of this operation. + */ + use_copy = true; + } else { + /* + This operation was an insert that happened after an insert or update. + This is not a possible case. + */ + ndbrequire(false); + return false; + } + } + if (use_copy) { + regOperPtr->realPageId = loopOpPtr.p->realPageIdC; + regOperPtr->fragPageId = loopOpPtr.p->fragPageIdC; + regOperPtr->pageIndex = loopOpPtr.p->pageIndexC; + regOperPtr->pageOffset = loopOpPtr.p->pageOffsetC; + } else { + regOperPtr->realPageId = loopOpPtr.p->realPageId; + regOperPtr->fragPageId = loopOpPtr.p->fragPageId; + regOperPtr->pageIndex = loopOpPtr.p->pageIndex; + regOperPtr->pageOffset = loopOpPtr.p->pageOffset; + } + return true; + } +} + +bool +Dbtup::getPageLastCommitted(Operationrec* const regOperPtr, + Operationrec* const leaderOpPtr) +{ +//---------------------------------------------------------------------- +// Dirty reads wants to read the latest committed tuple. The latest +// tuple value could be not existing or else we have to find the copy +// tuple. Start by finding the end of the list to find the first operation +// on the record in the ongoing transaction. +//---------------------------------------------------------------------- + jam(); + OperationrecPtr loopOpPtr; + loopOpPtr.p = leaderOpPtr; + while (loopOpPtr.p->nextActiveOp != RNIL) { + jam(); + loopOpPtr.i = loopOpPtr.p->nextActiveOp; + ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec); + }//while + if (loopOpPtr.p->optype == ZINSERT) { + jam(); +//---------------------------------------------------------------------- +// With an insert in the start of the list we know that the tuple did not +// exist before this transaction was started. We don't care if the current +// transaction is in the commit phase since the commit is not really +// completed until the operation is gone from TUP. +//---------------------------------------------------------------------- + terrorCode = ZTUPLE_DELETED_ERROR; + return false; + } else { +//---------------------------------------------------------------------- +// A successful update and delete as first in the queue means that a tuple +// exist in the committed world. We need to find it. +//---------------------------------------------------------------------- + if (loopOpPtr.p->optype == ZUPDATE) { + jam(); +//---------------------------------------------------------------------- +// The first operation was a delete we set our tuple reference to the +// copy tuple of this operation. +//---------------------------------------------------------------------- + regOperPtr->realPageId = loopOpPtr.p->realPageIdC; + regOperPtr->fragPageId = loopOpPtr.p->fragPageIdC; + regOperPtr->pageIndex = loopOpPtr.p->pageIndexC; + regOperPtr->pageOffset = loopOpPtr.p->pageOffsetC; + } else if ((loopOpPtr.p->optype == ZDELETE) && + (loopOpPtr.p->prevActiveOp == RNIL)) { + jam(); +//---------------------------------------------------------------------- +// There was only a delete. The original tuple still is ok. +//---------------------------------------------------------------------- + } else { + jam(); +//---------------------------------------------------------------------- +// There was another operation after the delete, this must be an insert +// and we have found our copy tuple there. +//---------------------------------------------------------------------- + loopOpPtr.i = loopOpPtr.p->prevActiveOp; + ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec); + ndbrequire(loopOpPtr.p->optype == ZINSERT); + regOperPtr->realPageId = loopOpPtr.p->realPageIdC; + regOperPtr->fragPageId = loopOpPtr.p->fragPageIdC; + regOperPtr->pageIndex = loopOpPtr.p->pageIndexC; + regOperPtr->pageOffset = loopOpPtr.p->pageOffsetC; + }//if + }//if + return true; +}//Dbtup::getPageLastCommitted() + +void Dbtup::execTUPKEYREQ(Signal* signal) +{ + TupKeyReq * const tupKeyReq = (TupKeyReq *)signal->getDataPtr(); + Uint32 RoperPtr = tupKeyReq->connectPtr; + Uint32 Rtabptr = tupKeyReq->tableRef; + Uint32 RfragId = tupKeyReq->fragId; + Uint32 Rstoredid = tupKeyReq->storedProcedure; + Uint32 Rfragptr = tupKeyReq->fragPtr; + + Uint32 RnoOfOprec = cnoOfOprec; + Uint32 RnoOfTablerec = cnoOfTablerec; + Uint32 RnoOfFragrec = cnoOfFragrec; + + operPtr.i = RoperPtr; + fragptr.i = Rfragptr; + tabptr.i = Rtabptr; + jamEntry(); + + ndbrequire(((RoperPtr < RnoOfOprec) && + (Rtabptr < RnoOfTablerec) && + (Rfragptr < RnoOfFragrec))); + ptrAss(operPtr, operationrec); + Operationrec * const regOperPtr = operPtr.p; + ptrAss(fragptr, fragrecord); + Fragrecord * const regFragPtr = fragptr.p; + ptrAss(tabptr, tablerec); + Tablerec* const regTabPtr = tabptr.p; + + Uint32 TrequestInfo = tupKeyReq->request; + + if (regOperPtr->transstate != IDLE) { + TUPKEY_abort(signal, 39); + return; + }//if +/* ----------------------------------------------------------------- */ +// Operation is ZREAD when we arrive here so no need to worry about the +// abort process. +/* ----------------------------------------------------------------- */ +/* ----------- INITIATE THE OPERATION RECORD -------------- */ +/* ----------------------------------------------------------------- */ + regOperPtr->fragmentPtr = Rfragptr; + regOperPtr->dirtyOp = TrequestInfo & 1; + regOperPtr->opSimple = (TrequestInfo >> 1) & 1; + regOperPtr->interpretedExec = (TrequestInfo >> 10) & 1; + regOperPtr->optype = (TrequestInfo >> 6) & 0xf; + + // Attributes needed by trigger execution + regOperPtr->noFiredTriggers = 0; + regOperPtr->tableRef = Rtabptr; + regOperPtr->tcOperationPtr = tupKeyReq->opRef; + regOperPtr->primaryReplica = tupKeyReq->primaryReplica; + regOperPtr->coordinatorTC = tupKeyReq->coordinatorTC; + regOperPtr->tcOpIndex = tupKeyReq->tcOpIndex; + regOperPtr->savePointId = tupKeyReq->savePointId; + + regOperPtr->fragId = RfragId; + + regOperPtr->fragPageId = tupKeyReq->keyRef1; + regOperPtr->pageIndex = tupKeyReq->keyRef2; + regOperPtr->attrinbufLen = regOperPtr->logSize = tupKeyReq->attrBufLen; + regOperPtr->recBlockref = tupKeyReq->applRef; + +// Schema Version in tupKeyReq->schemaVersion not used in this version + regOperPtr->storedProcedureId = Rstoredid; + regOperPtr->transid1 = tupKeyReq->transId1; + regOperPtr->transid2 = tupKeyReq->transId2; + + regOperPtr->attroutbufLen = 0; +/* ----------------------------------------------------------------------- */ +// INITIALISE TO DEFAULT VALUE +// INIT THE COPY REFERENCE RECORDS TO RNIL TO ENSURE THAT THEIR VALUES +// ARE VALID IF THEY EXISTS +// NO PENDING CHECKPOINT WHEN COPY CREATED (DEFAULT) +// NO TUPLE HAS BEEN ALLOCATED YET +// NO COPY HAS BEEN CREATED YET +/* ----------------------------------------------------------------------- */ + regOperPtr->undoLogged = false; + regOperPtr->realPageId = RNIL; + regOperPtr->realPageIdC = RNIL; + regOperPtr->fragPageIdC = RNIL; + + regOperPtr->pageOffset = ZNIL; + regOperPtr->pageOffsetC = ZNIL; + + regOperPtr->pageIndexC = ZNIL; + + // version not yet known + regOperPtr->tupVersion = ZNIL; + regOperPtr->deleteInsertFlag = 0; + + regOperPtr->tupleState = TUPLE_BLOCKED; + regOperPtr->changeMask.clear(); + + if (Rstoredid != ZNIL) { + ndbrequire(initStoredOperationrec(regOperPtr, Rstoredid) == ZOK); + }//if + copyAttrinfo(signal, regOperPtr, &cinBuffer[0]); + + PagePtr pagePtr; + if (!getPage(pagePtr, regOperPtr, regFragPtr, regTabPtr)) { + tupkeyErrorLab(signal); + return; + }//if + + Uint32 Roptype = regOperPtr->optype; + if (Roptype == ZREAD) { + jam(); + if (handleReadReq(signal, regOperPtr, regTabPtr, pagePtr.p) != -1) { + sendTUPKEYCONF(signal, regOperPtr, 0); +/* ------------------------------------------------------------------------- */ +// Read Operations need not to be taken out of any lists. We also do not +// need to wait for commit since there is no changes to commit. Thus we +// prepare the operation record already now for the next operation. +// Write operations have set the state to STARTED above indicating that +// they are waiting for the Commit or Abort decision. +/* ------------------------------------------------------------------------- */ + regOperPtr->transstate = IDLE; + regOperPtr->currentAttrinbufLen = 0; + }//if + return; + }//if + linkOpIntoFragList(operPtr, regFragPtr); + insertActiveOpList(signal, + operPtr, + pagePtr.p, + regOperPtr->pageOffset); + if (isUndoLoggingBlocked(regFragPtr)) { + TUPKEY_abort(signal, 38); + return; + }//if +/* ---------------------------------------------------------------------- */ +// WE SET THE CURRENT ACTIVE OPERATION IN THE TUPLE TO POINT TO OUR +//OPERATION RECORD. IF SEVERAL OPERATIONS WORK ON THIS TUPLE THEY ARE +// LINKED TO OUR OPERATION RECORD. DIRTY READS CAN ACCESS THE COPY +// TUPLE THROUGH OUR OPERATION RECORD. +/* ---------------------------------------------------------------------- */ + if (Roptype == ZINSERT) { + jam(); + if (handleInsertReq(signal, regOperPtr, + regFragPtr, regTabPtr, pagePtr.p) == -1) { + return; + }//if + if (!regTabPtr->tuxCustomTriggers.isEmpty()) { + jam(); + if (executeTuxInsertTriggers(signal, regOperPtr, regTabPtr) != 0) { + jam(); + tupkeyErrorLab(signal); + return; + } + } + checkImmediateTriggersAfterInsert(signal, + regOperPtr, + regTabPtr); + sendTUPKEYCONF(signal, regOperPtr, regOperPtr->logSize); + return; + }//if + if (regTabPtr->checksumIndicator && + (calculateChecksum(pagePtr.p, + regOperPtr->pageOffset, + regTabPtr->tupheadsize) != 0)) { + jam(); + terrorCode = ZTUPLE_CORRUPTED_ERROR; + tupkeyErrorLab(signal); + return; + }//if + if (Roptype == ZUPDATE) { + jam(); + if (handleUpdateReq(signal, regOperPtr, + regFragPtr, regTabPtr, pagePtr.p) == -1) { + return; + }//if + // If update operation is done on primary, + // check any after op triggers + terrorCode = 0; + if (!regTabPtr->tuxCustomTriggers.isEmpty()) { + jam(); + if (executeTuxUpdateTriggers(signal, regOperPtr, regTabPtr) != 0) { + jam(); + tupkeyErrorLab(signal); + return; + } + } + checkImmediateTriggersAfterUpdate(signal, + regOperPtr, + regTabPtr); + // XXX use terrorCode for now since all methods are void + if (terrorCode != 0) { + tupkeyErrorLab(signal); + return; + } + sendTUPKEYCONF(signal, regOperPtr, regOperPtr->logSize); + return; + } else if (Roptype == ZDELETE) { + jam(); + if (handleDeleteReq(signal, regOperPtr, + regFragPtr, regTabPtr, pagePtr.p) == -1) { + return; + }//if + // If delete operation is done on primary, + // check any after op triggers + if (!regTabPtr->tuxCustomTriggers.isEmpty()) { + jam(); + if (executeTuxDeleteTriggers(signal, regOperPtr, regTabPtr) != 0) { + jam(); + tupkeyErrorLab(signal); + return; + } + } + checkImmediateTriggersAfterDelete(signal, + regOperPtr, + regTabPtr); + sendTUPKEYCONF(signal, regOperPtr, 0); + return; + } else { + ndbrequire(false); + }//if +}//Dbtup::execTUPKEYREQ() + +/* ---------------------------------------------------------------- */ +/* ------------------------ CONFIRM REQUEST ----------------------- */ +/* ---------------------------------------------------------------- */ +void Dbtup::sendTUPKEYCONF(Signal* signal, + Operationrec * const regOperPtr, + Uint32 TlogSize) +{ + TupKeyConf * const tupKeyConf = (TupKeyConf *)signal->getDataPtrSend(); + + Uint32 RuserPointer = regOperPtr->userpointer; + Uint32 RfragPageId = regOperPtr->fragPageId; + Uint32 RpageIndex = regOperPtr->pageIndex; + Uint32 RattroutbufLen = regOperPtr->attroutbufLen; + Uint32 RnoFiredTriggers = regOperPtr->noFiredTriggers; + BlockReference Ruserblockref = regOperPtr->userblockref; + + regOperPtr->transstate = STARTED; + regOperPtr->tupleState = NO_OTHER_OP; + tupKeyConf->userPtr = RuserPointer; + tupKeyConf->pageId = RfragPageId; + tupKeyConf->pageIndex = RpageIndex; + tupKeyConf->readLength = RattroutbufLen; + tupKeyConf->writeLength = TlogSize; + tupKeyConf->noFiredTriggers = RnoFiredTriggers; + + EXECUTE_DIRECT(refToBlock(Ruserblockref), GSN_TUPKEYCONF, signal, + TupKeyConf::SignalLength); + return; +}//Dbtup::sendTUPKEYCONF() + +/* ---------------------------------------------------------------- */ +/* ----------------------------- READ ---------------------------- */ +/* ---------------------------------------------------------------- */ +int Dbtup::handleReadReq(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTabPtr, + Page* pagePtr) +{ + Uint32 Ttupheadoffset = regOperPtr->pageOffset; + if (regTabPtr->checksumIndicator && + (calculateChecksum(pagePtr, Ttupheadoffset, + regTabPtr->tupheadsize) != 0)) { + jam(); + terrorCode = ZTUPLE_CORRUPTED_ERROR; + tupkeyErrorLab(signal); + return -1; + }//if + + if (regOperPtr->interpretedExec != 1) { + jam(); + Uint32 TnoOfDataRead = readAttributes(pagePtr, + Ttupheadoffset, + &cinBuffer[0], + regOperPtr->attrinbufLen, + &coutBuffer[0], + (Uint32)ZATTR_BUFFER_SIZE); + if (TnoOfDataRead != (Uint32)-1) { +/* ------------------------------------------------------------------------- */ +// We have read all data into coutBuffer. Now send it to the API. +/* ------------------------------------------------------------------------- */ + jam(); + regOperPtr->attroutbufLen = TnoOfDataRead; + sendReadAttrinfo(signal, TnoOfDataRead, regOperPtr); + return 0; + }//if + jam(); + tupkeyErrorLab(signal); + return -1; + } else { + jam(); + if (interpreterStartLab(signal, pagePtr, Ttupheadoffset) != -1) { + return 0; + }//if + return -1; + }//if +}//Dbtup::handleReadReq() + +/* ---------------------------------------------------------------- */ +/* ---------------------------- UPDATE ---------------------------- */ +/* ---------------------------------------------------------------- */ +int Dbtup::handleUpdateReq(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr, + Page* const pagePtr) +{ + PagePtr copyPagePtr; + Uint32 tuple_size = regTabPtr->tupheadsize; + +//--------------------------------------------------- +/* --- MAKE A COPY OF THIS TUPLE ON A COPY PAGE --- */ +//--------------------------------------------------- + Uint32 RpageOffsetC; + if (!allocTh(regFragPtr, + regTabPtr, + COPY_PAGE, + signal, + RpageOffsetC, + copyPagePtr)) { + TUPKEY_abort(signal, 1); + return -1; + }//if + Uint32 RpageIdC = copyPagePtr.i; + Uint32 RfragPageIdC = copyPagePtr.p->pageWord[ZPAGE_FRAG_PAGE_ID_POS]; + Uint32 indexC = ((RpageOffsetC - ZPAGE_HEADER_SIZE) / tuple_size) << 1; + regOperPtr->pageIndexC = indexC; + regOperPtr->fragPageIdC = RfragPageIdC; + regOperPtr->realPageIdC = RpageIdC; + regOperPtr->pageOffsetC = RpageOffsetC; + /* -------------------------------------------------------------- */ + /* IF WE HAVE AN ONGING CHECKPOINT WE HAVE TO LOG THE ALLOCATION */ + /* OF THE TUPLE HEADER TO BE ABLE TO DELETE IT UPON RESTART */ + /* THE ONLY DATA EXCEPT THE TYPE, PAGE, INDEX IS THE SIZE TO FREE */ + /* -------------------------------------------------------------- */ + if (isUndoLoggingActive(regFragPtr)) { + if (isPageUndoLogged(regFragPtr, RfragPageIdC)) { + jam(); + regOperPtr->undoLogged = true; + cprAddUndoLogRecord(signal, + ZLCPR_TYPE_DELETE_TH, + RfragPageIdC, + indexC, + regOperPtr->tableRef, + regOperPtr->fragId, + regFragPtr->checkpointVersion); + }//if + if (isPageUndoLogged(regFragPtr, regOperPtr->fragPageId)) { + jam(); + cprAddUndoLogRecord(signal, + ZLCPR_TYPE_UPDATE_TH, + regOperPtr->fragPageId, + regOperPtr->pageIndex, + regOperPtr->tableRef, + regOperPtr->fragId, + regFragPtr->checkpointVersion); + cprAddData(signal, + regFragPtr, + regOperPtr->realPageId, + tuple_size, + regOperPtr->pageOffset); + }//if + }//if + Uint32 RwordCount = tuple_size - 1; + Uint32 end_dest = RpageOffsetC + tuple_size; + Uint32 offset = regOperPtr->pageOffset; + Uint32 end_source = offset + tuple_size; + ndbrequire(end_dest <= ZWORDS_ON_PAGE && end_source <= ZWORDS_ON_PAGE); + void* Tdestination = (void*)©PagePtr.p->pageWord[RpageOffsetC + 1]; + const void* Tsource = (void*)&pagePtr->pageWord[offset + 1]; + MEMCOPY_NO_WORDS(Tdestination, Tsource, RwordCount); + + Uint32 prev_tup_version; + // nextActiveOp is before this op in event order + if (regOperPtr->nextActiveOp == RNIL) { + jam(); + prev_tup_version = ((const Uint32*)Tsource)[0]; + } else { + OperationrecPtr prevOperPtr; + jam(); + prevOperPtr.i = regOperPtr->nextActiveOp; + ptrCheckGuard(prevOperPtr, cnoOfOprec, operationrec); + prev_tup_version = prevOperPtr.p->tupVersion; + }//if + regOperPtr->tupVersion = (prev_tup_version + 1) & + ((1 << ZTUP_VERSION_BITS) - 1); + // global variable alert + ndbassert(operationrec + operPtr.i == regOperPtr); + copyPagePtr.p->pageWord[RpageOffsetC] = operPtr.i; + + return updateStartLab(signal, regOperPtr, regTabPtr, pagePtr); +}//Dbtup::handleUpdateReq() + +/* ---------------------------------------------------------------- */ +/* ----------------------------- INSERT --------------------------- */ +/* ---------------------------------------------------------------- */ +int Dbtup::handleInsertReq(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr, + Page* const pagePtr) +{ + Uint32 ret_value; + + if (regOperPtr->nextActiveOp != RNIL) { + jam(); + OperationrecPtr prevExecOpPtr; + prevExecOpPtr.i = regOperPtr->nextActiveOp; + ptrCheckGuard(prevExecOpPtr, cnoOfOprec, operationrec); + if (prevExecOpPtr.p->optype != ZDELETE) { + terrorCode = ZINSERT_ERROR; + tupkeyErrorLab(signal); + return -1; + }//if + ret_value = handleUpdateReq(signal, regOperPtr, + regFragPtr, regTabPtr, pagePtr); + } else { + jam(); + regOperPtr->tupVersion = 0; + ret_value = updateStartLab(signal, regOperPtr, regTabPtr, pagePtr); + }//if + if (ret_value != (Uint32)-1) { + if (checkNullAttributes(regOperPtr, regTabPtr)) { + jam(); + return 0; + }//if + TUPKEY_abort(signal, 17); + }//if + return -1; +}//Dbtup::handleInsertReq() + +/* ---------------------------------------------------------------- */ +/* ---------------------------- DELETE ---------------------------- */ +/* ---------------------------------------------------------------- */ +int Dbtup::handleDeleteReq(Signal* signal, + Operationrec* const regOperPtr, + Fragrecord* const regFragPtr, + Tablerec* const regTabPtr, + Page* const pagePtr) +{ + // delete must set but not increment tupVersion + if (regOperPtr->nextActiveOp != RNIL) { + OperationrecPtr prevExecOpPtr; + prevExecOpPtr.i = regOperPtr->nextActiveOp; + ptrCheckGuard(prevExecOpPtr, cnoOfOprec, operationrec); + regOperPtr->tupVersion = prevExecOpPtr.p->tupVersion; + } else { + jam(); + regOperPtr->tupVersion = pagePtr->pageWord[regOperPtr->pageOffset + 1]; + } + if (isUndoLoggingNeeded(regFragPtr, regOperPtr->fragPageId)) { + jam(); + cprAddUndoLogRecord(signal, + ZINDICATE_NO_OP_ACTIVE, + regOperPtr->fragPageId, + regOperPtr->pageIndex, + regOperPtr->tableRef, + regOperPtr->fragId, + regFragPtr->checkpointVersion); + }//if + if (regOperPtr->attrinbufLen == 0) { + return 0; + }//if +/* ------------------------------------------------------------------------ */ +/* THE APPLICATION WANTS TO READ THE TUPLE BEFORE IT IS DELETED. */ +/* ------------------------------------------------------------------------ */ + return handleReadReq(signal, regOperPtr, regTabPtr, pagePtr); +}//Dbtup::handleDeleteReq() + +int +Dbtup::updateStartLab(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTabPtr, + Page* const pagePtr) +{ + Uint32 retValue; + if (regOperPtr->optype == ZINSERT) { + jam(); + setNullBits(pagePtr, regTabPtr, regOperPtr->pageOffset); + } + if (regOperPtr->interpretedExec != 1) { + jam(); + retValue = updateAttributes(pagePtr, + regOperPtr->pageOffset, + &cinBuffer[0], + regOperPtr->attrinbufLen); + if (retValue == (Uint32)-1) { + tupkeyErrorLab(signal); + }//if + } else { + jam(); + retValue = interpreterStartLab(signal, pagePtr, regOperPtr->pageOffset); + }//if + ndbrequire(regOperPtr->tupVersion != ZNIL); + pagePtr->pageWord[regOperPtr->pageOffset + 1] = regOperPtr->tupVersion; + if (regTabPtr->checksumIndicator) { + jam(); + setChecksum(pagePtr, regOperPtr->pageOffset, regTabPtr->tupheadsize); + }//if + return retValue; +}//Dbtup::updateStartLab() + +void +Dbtup::setNullBits(Page* const regPage, Tablerec* const regTabPtr, Uint32 pageOffset) +{ + Uint32 noOfExtraNullWords = regTabPtr->tupNullWords; + Uint32 nullOffsetStart = regTabPtr->tupNullIndex + pageOffset; + ndbrequire((noOfExtraNullWords + nullOffsetStart) < ZWORDS_ON_PAGE); + for (Uint32 i = 0; i < noOfExtraNullWords; i++) { + regPage->pageWord[nullOffsetStart + i] = 0xFFFFFFFF; + }//for +}//Dbtup::setNullBits() + +bool +Dbtup::checkNullAttributes(Operationrec* const regOperPtr, + Tablerec* const regTabPtr) +{ +// Implement checking of updating all not null attributes in an insert here. + Bitmask attributeMask; + /* + * The idea here is maybe that changeMask is not-null attributes + * and must contain notNullAttributeMask. But: + * + * 1. changeMask has all bits set on insert + * 2. not-null is checked in each UpdateFunction + * 3. the code below does not work except trivially due to 1. + * + * XXX remove or fix + */ + attributeMask.clear(); + attributeMask.bitOR(regOperPtr->changeMask); + attributeMask.bitAND(regTabPtr->notNullAttributeMask); + attributeMask.bitXOR(regTabPtr->notNullAttributeMask); + if (!attributeMask.isclear()) { + return false; + }//if + return true; +}//Dbtup::checkNullAttributes() + +/* ---------------------------------------------------------------- */ +/* THIS IS THE START OF THE INTERPRETED EXECUTION OF UPDATES. WE */ +/* START BY LINKING ALL ATTRINFO'S IN A DOUBLY LINKED LIST (THEY ARE*/ +/* ALREADY IN A LINKED LIST). WE ALLOCATE A REGISTER MEMORY (EQUAL */ +/* TO AN ATTRINFO RECORD). THE INTERPRETER GOES THROUGH FOUR PHASES*/ +/* DURING THE FIRST PHASE IT IS ONLY ALLOWED TO READ ATTRIBUTES THAT*/ +/* ARE SENT TO THE CLIENT APPLICATION. DURING THE SECOND PHASE IT IS*/ +/* ALLOWED TO READ FROM ATTRIBUTES INTO REGISTERS, TO UPDATE */ +/* ATTRIBUTES BASED ON EITHER A CONSTANT VALUE OR A REGISTER VALUE, */ +/* A DIVERSE SET OF OPERATIONS ON REGISTERS ARE AVAILABLE AS WELL. */ +/* IT IS ALSO POSSIBLE TO PERFORM JUMPS WITHIN THE INSTRUCTIONS THAT*/ +/* BELONGS TO THE SECOND PHASE. ALSO SUBROUTINES CAN BE CALLED IN */ +/* THIS PHASE. THE THIRD PHASE IS TO AGAIN READ ATTRIBUTES AND */ +/* FINALLY THE FOURTH PHASE READS SELECTED REGISTERS AND SEND THEM */ +/* TO THE CLIENT APPLICATION. */ +/* THERE IS A FIFTH REGION WHICH CONTAINS SUBROUTINES CALLABLE FROM */ +/* THE INTERPRETER EXECUTION REGION. */ +/* THE FIRST FIVE WORDS WILL GIVE THE LENGTH OF THE FIVEE REGIONS */ +/* */ +/* THIS MEANS THAT FROM THE APPLICATIONS POINT OF VIEW THE DATABASE */ +/* CAN HANDLE SUBROUTINE CALLS WHERE THE CODE IS SENT IN THE REQUEST*/ +/* THE RETURN PARAMETERS ARE FIXED AND CAN EITHER BE GENERATED */ +/* BEFORE THE EXECUTION OF THE ROUTINE OR AFTER. */ +/* */ +/* IN LATER VERSIONS WE WILL ADD MORE THINGS LIKE THE POSSIBILITY */ +/* TO ALLOCATE MEMORY AND USE THIS AS LOCAL STORAGE. IT IS ALSO */ +/* IMAGINABLE TO HAVE SPECIAL ROUTINES THAT CAN PERFORM CERTAIN */ +/* OPERATIONS ON BLOB'S DEPENDENT ON WHAT THE BLOB REPRESENTS. */ +/* */ +/* */ +/* ----------------------------------------- */ +/* + INITIAL READ REGION + */ +/* ----------------------------------------- */ +/* + INTERPRETED EXECUTE REGION + */ +/* ----------------------------------------- */ +/* + FINAL UPDATE REGION + */ +/* ----------------------------------------- */ +/* + FINAL READ REGION + */ +/* ----------------------------------------- */ +/* + SUBROUTINE REGION + */ +/* ----------------------------------------- */ +/* ---------------------------------------------------------------- */ +/* ---------------------------------------------------------------- */ +/* ----------------- INTERPRETED EXECUTION ----------------------- */ +/* ---------------------------------------------------------------- */ +int Dbtup::interpreterStartLab(Signal* signal, + Page* const pagePtr, + Uint32 TupHeadOffset) +{ + Operationrec * const regOperPtr = operPtr.p; + Uint32 RtotalLen; + Uint32 TnoDataRW; + + Uint32 RinitReadLen = cinBuffer[0]; + Uint32 RexecRegionLen = cinBuffer[1]; + Uint32 RfinalUpdateLen = cinBuffer[2]; + Uint32 RfinalRLen = cinBuffer[3]; + Uint32 RsubLen = cinBuffer[4]; + + Uint32 RattrinbufLen = regOperPtr->attrinbufLen; + const BlockReference sendBref = regOperPtr->recBlockref; + + Uint32 * dst = &coutBuffer[0]; + Uint32 dstLen = sizeof(coutBuffer) / 4; + Uint32 * tmp = &signal->theData[3]; + Uint32 tmpLen = (sizeof(signal->theData) / 4) - 3; + bool executeDirect = false; + const Uint32 node = refToNode(sendBref); + if(node != 0 && node != getOwnNodeId()) { + ; + } else { + jam(); + /** + * execute direct + */ + executeDirect = true; + dst = &signal->theData[3]; + dstLen = (sizeof(signal->theData) / 4) - 3; + + tmp = &coutBuffer[0]; + tmpLen = sizeof(coutBuffer) / 4; + } + + RtotalLen = RinitReadLen; + RtotalLen += RexecRegionLen; + RtotalLen += RfinalUpdateLen; + RtotalLen += RfinalRLen; + RtotalLen += RsubLen; + + Uint32 RattroutCounter = 0; + Uint32 RinstructionCounter = 5; + Uint32 RlogSize = 0; + + if (((RtotalLen + 5) == RattrinbufLen) && + (RattrinbufLen >= 5) && + (RattrinbufLen < ZATTR_BUFFER_SIZE)) { + /* ---------------------------------------------------------------- */ + // We start by checking consistency. We must have the first five + // words of the ATTRINFO to give us the length of the regions. The + // size of these regions must be the same as the total ATTRINFO + // length and finally the total length must be within the limits. + /* ---------------------------------------------------------------- */ + + if (RinitReadLen > 0) { + jam(); + /* ---------------------------------------------------------------- */ + // The first step that can be taken in the interpreter is to read + // data of the tuple before any updates have been applied. + /* ---------------------------------------------------------------- */ + TnoDataRW = readAttributes(pagePtr, + TupHeadOffset, + &cinBuffer[5], + RinitReadLen, + &dst[0], + dstLen); + if (TnoDataRW != (Uint32)-1) { + RattroutCounter = TnoDataRW; + RinstructionCounter += RinitReadLen; + } else { + jam(); + tupkeyErrorLab(signal); + return -1; + }//if + }//if + if (RexecRegionLen > 0) { + jam(); + /* ---------------------------------------------------------------- */ + // The next step is the actual interpreted execution. This executes + // a register-based virtual machine which can read and write attributes + // to and from registers. + /* ---------------------------------------------------------------- */ + Uint32 RsubPC = RinstructionCounter + RfinalUpdateLen + RfinalRLen; + TnoDataRW = interpreterNextLab(signal, + pagePtr, + TupHeadOffset, + &clogMemBuffer[0], + &cinBuffer[RinstructionCounter], + RexecRegionLen, + &cinBuffer[RsubPC], + RsubLen, + tmp, + tmpLen); + if (TnoDataRW != (Uint32)-1) { + RinstructionCounter += RexecRegionLen; + RlogSize = TnoDataRW; + } else { + jam(); + return -1; + }//if + }//if + if (RfinalUpdateLen > 0) { + jam(); + /* ---------------------------------------------------------------- */ + // We can also apply a set of updates without any conditions as part + // of the interpreted execution. + /* ---------------------------------------------------------------- */ + if (regOperPtr->optype == ZUPDATE) { + TnoDataRW = updateAttributes(pagePtr, + TupHeadOffset, + &cinBuffer[RinstructionCounter], + RfinalUpdateLen); + if (TnoDataRW != (Uint32)-1) { + MEMCOPY_NO_WORDS(&clogMemBuffer[RlogSize], + &cinBuffer[RinstructionCounter], + RfinalUpdateLen); + RinstructionCounter += RfinalUpdateLen; + RlogSize += RfinalUpdateLen; + } else { + jam(); + tupkeyErrorLab(signal); + return -1; + }//if + } else { + return TUPKEY_abort(signal, 19); + }//if + }//if + if (RfinalRLen > 0) { + jam(); + /* ---------------------------------------------------------------- */ + // The final action is that we can also read the tuple after it has + // been updated. + /* ---------------------------------------------------------------- */ + TnoDataRW = readAttributes(pagePtr, + TupHeadOffset, + &cinBuffer[RinstructionCounter], + RfinalRLen, + &dst[RattroutCounter], + (dstLen - RattroutCounter)); + if (TnoDataRW != (Uint32)-1) { + RattroutCounter += TnoDataRW; + } else { + jam(); + tupkeyErrorLab(signal); + return -1; + }//if + }//if + regOperPtr->logSize = RlogSize; + regOperPtr->attroutbufLen = RattroutCounter; + if(!executeDirect) { + jam(); + sendReadAttrinfo(signal, RattroutCounter, regOperPtr); + } else { + jam(); + Uint32 sig0 = regOperPtr->tcOperationPtr; + Uint32 sig1 = regOperPtr->transid1; + Uint32 sig2 = regOperPtr->transid2; + signal->theData[0] = sig0; + signal->theData[1] = sig1; + signal->theData[2] = sig2; + EXECUTE_DIRECT(refToBlock(sendBref), GSN_TRANSID_AI, signal, + 3 + RattroutCounter); + }//if + if (RlogSize > 0) { + sendLogAttrinfo(signal, RlogSize, regOperPtr); + }//if + return 0; + } else { + return TUPKEY_abort(signal, 22); + }//if +}//Dbtup::interpreterStartLab() + +/* ---------------------------------------------------------------- */ +/* WHEN EXECUTION IS INTERPRETED WE NEED TO SEND SOME ATTRINFO*/ +/* BACK TO LQH FOR LOGGING AND SENDING TO BACKUP AND STANDBY */ +/* NODES. */ +/* INPUT: LOG_ATTRINFOPTR WHERE TO FETCH DATA FROM */ +/* TLOG_START FIRST INDEX TO LOG */ +/* TLOG_END LAST INDEX + 1 TO LOG */ +/* ---------------------------------------------------------------- */ +void Dbtup::sendLogAttrinfo(Signal* signal, + Uint32 TlogSize, + Operationrec * const regOperPtr) + +{ + Uint32 TbufferIndex = 0; + signal->theData[0] = regOperPtr->userpointer; + while (TlogSize > 22) { + MEMCOPY_NO_WORDS(&signal->theData[3], + &clogMemBuffer[TbufferIndex], + 22); + EXECUTE_DIRECT(refToBlock(regOperPtr->userblockref), + GSN_TUP_ATTRINFO, signal, 25); + TbufferIndex += 22; + TlogSize -= 22; + }//while + MEMCOPY_NO_WORDS(&signal->theData[3], + &clogMemBuffer[TbufferIndex], + TlogSize); + EXECUTE_DIRECT(refToBlock(regOperPtr->userblockref), + GSN_TUP_ATTRINFO, signal, 3 + TlogSize); +}//Dbtup::sendLogAttrinfo() + +inline +Uint32 +brancher(Uint32 TheInstruction, Uint32 TprogramCounter) +{ + Uint32 TbranchDirection = TheInstruction >> 31; + Uint32 TbranchLength = (TheInstruction >> 16) & 0x7fff; + TprogramCounter--; + if (TbranchDirection == 1) { + jam(); + /* ---------------------------------------------------------------- */ + /* WE JUMP BACKWARDS. */ + /* ---------------------------------------------------------------- */ + return (TprogramCounter - TbranchLength); + } else { + jam(); + /* ---------------------------------------------------------------- */ + /* WE JUMP FORWARD. */ + /* ---------------------------------------------------------------- */ + return (TprogramCounter + TbranchLength); + }//if +}//brancher() + +int Dbtup::interpreterNextLab(Signal* signal, + Page* const pagePtr, + Uint32 TupHeadOffset, + Uint32* logMemory, + Uint32* mainProgram, + Uint32 TmainProgLen, + Uint32* subroutineProg, + Uint32 TsubroutineLen, + Uint32 * tmpArea, + Uint32 tmpAreaSz) +{ + register Uint32* TcurrentProgram = mainProgram; + register Uint32 TcurrentSize = TmainProgLen; + register Uint32 RnoOfInstructions = 0; + register Uint32 TprogramCounter = 0; + register Uint32 theInstruction; + register Uint32 theRegister; + Uint32 TdataWritten = 0; + Uint32 RstackPtr = 0; + Uint32 TregMemBuffer[32]; + Uint32 TstackMemBuffer[32]; + + /* ---------------------------------------------------------------- */ + // Initialise all 8 registers to contain the NULL value. + // In this version we can handle 32 and 64 bit unsigned integers. + // They are handled as 64 bit values. Thus the 32 most significant + // bits are zeroed for 32 bit values. + /* ---------------------------------------------------------------- */ + TregMemBuffer[0] = 0; + TregMemBuffer[4] = 0; + TregMemBuffer[8] = 0; + TregMemBuffer[12] = 0; + TregMemBuffer[16] = 0; + TregMemBuffer[20] = 0; + TregMemBuffer[24] = 0; + TregMemBuffer[28] = 0; + Uint32 tmpHabitant = ~0; + + while (RnoOfInstructions < 8000) { + /* ---------------------------------------------------------------- */ + /* EXECUTE THE NEXT INTERPRETER INSTRUCTION. */ + /* ---------------------------------------------------------------- */ + RnoOfInstructions++; + theInstruction = TcurrentProgram[TprogramCounter]; + theRegister = Interpreter::getReg1(theInstruction) << 2; + if (TprogramCounter < TcurrentSize) { + TprogramCounter++; + switch (Interpreter::getOpCode(theInstruction)) { + case Interpreter::READ_ATTR_INTO_REG: + jam(); + /* ---------------------------------------------------------------- */ + // Read an attribute from the tuple into a register. + // While reading an attribute we allow the attribute to be an array + // as long as it fits in the 64 bits of the register. + /* ---------------------------------------------------------------- */ + { + Uint32 theAttrinfo = theInstruction; + Uint32 TnoDataRW; + TnoDataRW = readAttributes(pagePtr, + TupHeadOffset, + &theAttrinfo, + (Uint32)1, + &TregMemBuffer[theRegister], + (Uint32)3); + if (TnoDataRW == 2) { + /* ------------------------------------------------------------- */ + // Two words read means that we get the instruction plus one 32 + // word read. Thus we set the register to be a 32 bit register. + /* ------------------------------------------------------------- */ + TregMemBuffer[theRegister] = 0x50; + TregMemBuffer[theRegister + 2] = 0; + } else if (TnoDataRW == 3) { + /* ------------------------------------------------------------- */ + // Three words read means that we get the instruction plus two + // 32 words read. Thus we set the register to be a 64 bit register. + /* ------------------------------------------------------------- */ + TregMemBuffer[theRegister] = 0x60; + } else if (TnoDataRW == 1) { + /* ------------------------------------------------------------- */ + // One word read means that we must have read a NULL value. We set + // the register to indicate a NULL value. + /* ------------------------------------------------------------- */ + TregMemBuffer[theRegister] = 0; + } else if (TnoDataRW == (Uint32)-1) { + jam(); + tupkeyErrorLab(signal); + return -1; + } else { + /* ------------------------------------------------------------- */ + // Any other return value from the read attribute here is not + // allowed and will lead to a system crash. + /* ------------------------------------------------------------- */ + ndbrequire(false); + }//if + break; + } + + case Interpreter::WRITE_ATTR_FROM_REG: + jam(); + { + Uint32 TattrId = theInstruction >> 16; + Uint32 TattrDescrIndex = tabptr.p->tabDescriptor + + (TattrId << ZAD_LOG_SIZE); + Uint32 TattrDesc1 = tableDescriptor[TattrDescrIndex].tabDescr; + Uint32 TregType = TregMemBuffer[theRegister]; + + /* --------------------------------------------------------------- */ + // Calculate the number of words of this attribute. + // We allow writes into arrays as long as they fit into the 64 bit + // register size. + //TEST_MR See to that TattrNoOfWords can be + // read faster from attribute description. + /* --------------------------------------------------------------- */ + Uint32 TarraySize = (TattrDesc1 >> 16); + Uint32 TattrLogLen = (TattrDesc1 >> 4) & 0xf; + Uint32 TattrNoOfBits = TarraySize << TattrLogLen; + Uint32 TattrNoOfWords = (TattrNoOfBits + 31) >> 5; + Uint32 Toptype = operPtr.p->optype; + + Uint32 TdataForUpdate[3]; + Uint32 Tlen; + + AttributeHeader& ah = AttributeHeader::init(&TdataForUpdate[0], + TattrId, TattrNoOfWords); + TdataForUpdate[1] = TregMemBuffer[theRegister + 1]; + TdataForUpdate[2] = TregMemBuffer[theRegister + 2]; + Tlen = TattrNoOfWords + 1; + if (Toptype == ZUPDATE) { + if (TattrNoOfWords <= 2) { + if (TregType == 0) { + /* --------------------------------------------------------- */ + // Write a NULL value into the attribute + /* --------------------------------------------------------- */ + ah.setNULL(); + Tlen = 1; + }//if + Uint32 TnoDataRW; + TnoDataRW = updateAttributes(pagePtr, + TupHeadOffset, + &TdataForUpdate[0], + Tlen); + if (TnoDataRW != (Uint32)-1) { + /* --------------------------------------------------------- */ + // Write the written data also into the log buffer so that it + // will be logged. + /* --------------------------------------------------------- */ + logMemory[TdataWritten + 0] = TdataForUpdate[0]; + logMemory[TdataWritten + 1] = TdataForUpdate[1]; + logMemory[TdataWritten + 2] = TdataForUpdate[2]; + TdataWritten += Tlen; + } else { + tupkeyErrorLab(signal); + return -1; + }//if + } else { + return TUPKEY_abort(signal, 15); + }//if + } else { + return TUPKEY_abort(signal, 16); + }//if + break; + } + + case Interpreter::LOAD_CONST_NULL: + jam(); + TregMemBuffer[theRegister] = 0; /* NULL INDICATOR */ + break; + + case Interpreter::LOAD_CONST16: + jam(); + TregMemBuffer[theRegister] = 0x50; /* 32 BIT UNSIGNED CONSTANT */ + TregMemBuffer[theRegister + 1] = theInstruction >> 16; + TregMemBuffer[theRegister + 2] = 0; + break; + + case Interpreter::LOAD_CONST32: + jam(); + TregMemBuffer[theRegister] = 0x50; /* 32 BIT UNSIGNED CONSTANT */ + TregMemBuffer[theRegister + 1] = TcurrentProgram[TprogramCounter]; + TregMemBuffer[theRegister + 2] = 0; + TprogramCounter++; + break; + + case Interpreter::LOAD_CONST64: + jam(); + TregMemBuffer[theRegister] = 0x60; /* 64 BIT UNSIGNED CONSTANT */ + TregMemBuffer[theRegister + 1] = TcurrentProgram[TprogramCounter + 0]; + TregMemBuffer[theRegister + 2] = TcurrentProgram[TprogramCounter + 1]; + TprogramCounter += 2; + break; + + case Interpreter::ADD_REG_REG: + jam(); + { + Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2; + Uint32 TdestRegister = Interpreter::getReg3(theInstruction) << 2; + + Uint32 TrightType = TregMemBuffer[TrightRegister]; + Uint32 Tright0 = TregMemBuffer[TrightRegister + 1]; + Uint32 Tright1 = TregMemBuffer[TrightRegister + 2]; + + Uint32 TleftType = TregMemBuffer[theRegister]; + Uint32 Tleft0 = TregMemBuffer[theRegister + 1]; + Uint32 Tleft1 = TregMemBuffer[theRegister + 2]; + Uint32 Tany64bit = (((TleftType | TrightType) & 0x60) == 0x60); + + if ((TleftType | TrightType) != 0) { + Uint32 Tdest0 = Tleft0 + Tright0; + Uint32 Tdest1 = 0; + TregMemBuffer[TdestRegister + 1] = Tdest0; + TregMemBuffer[TdestRegister] = 0x50; + if (Tany64bit) { + TregMemBuffer[TdestRegister] = 0x60; + Tdest1 = Tleft1 + Tright1; + if (Tdest0 < Tleft0) { + Tdest1++; + } + }//if + TregMemBuffer[TdestRegister + 2] = Tdest1; + } else { + return TUPKEY_abort(signal, 20); + } + break; + } + + case Interpreter::SUB_REG_REG: + jam(); + { + Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2; + Uint32 TdestRegister = Interpreter::getReg3(theInstruction) << 2; + + Uint32 TrightType = TregMemBuffer[TrightRegister]; + Uint32 Tright0 = TregMemBuffer[TrightRegister + 1]; + Uint32 Tright1 = TregMemBuffer[TrightRegister + 2]; + + Uint32 TleftType = TregMemBuffer[theRegister]; + Uint32 Tleft0 = TregMemBuffer[theRegister + 1]; + Uint32 Tleft1 = TregMemBuffer[theRegister + 2]; + Uint32 Tany64bit = (((TleftType | TrightType) & 0x60) == 0x60); + + if ((TleftType | TrightType) != 0) { + Uint32 Tdest0 = Tleft0 - Tright0; + Uint32 Tdest1 = 0; + TregMemBuffer[TdestRegister + 1] = Tdest0; + TregMemBuffer[TdestRegister] = 0x50; + if (Tany64bit) { + TregMemBuffer[TdestRegister] = 0x60; + Tdest1 = Tleft1 - Tright1; + if (Tdest0 > Tleft0) { + Tdest1--; + }//if + }//if + TregMemBuffer[TdestRegister + 2] = Tdest1; + } else { + return TUPKEY_abort(signal, 21); + }//if + break; + } + + case Interpreter::BRANCH: + TprogramCounter = brancher(theInstruction, TprogramCounter); + break; + + case Interpreter::BRANCH_REG_EQ_NULL: + if (TregMemBuffer[theRegister] != 0) { + jam(); + continue; + } else { + jam(); + TprogramCounter = brancher(theInstruction, TprogramCounter); + }//if + break; + + case Interpreter::BRANCH_REG_NE_NULL: + if (TregMemBuffer[theRegister] == 0) { + jam(); + continue; + } else { + jam(); + TprogramCounter = brancher(theInstruction, TprogramCounter); + }//if + break; + + + case Interpreter::BRANCH_EQ_REG_REG: + { + Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2; + + Uint32 TleftType = TregMemBuffer[theRegister]; + Uint32 Tleft0 = TregMemBuffer[theRegister + 1]; + Uint32 Tleft1 = TregMemBuffer[theRegister + 2]; + + Uint32 TrightType = TregMemBuffer[TrightRegister]; + Uint32 Tright0 = TregMemBuffer[TrightRegister + 1]; + Uint32 Tright1 = TregMemBuffer[TrightRegister + 2]; + if ((TrightType | TleftType) != 0) { + jam(); + if ((Tleft0 == Tright0) && (Tleft1 == Tright1)) { + TprogramCounter = brancher(theInstruction, TprogramCounter); + }//if + } else { + return TUPKEY_abort(signal, 23); + }//if + break; + } + + case Interpreter::BRANCH_NE_REG_REG: + { + Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2; + + Uint32 TleftType = TregMemBuffer[theRegister]; + Uint32 Tleft0 = TregMemBuffer[theRegister + 1]; + Uint32 Tleft1 = TregMemBuffer[theRegister + 2]; + + Uint32 TrightType = TregMemBuffer[TrightRegister]; + Uint32 Tright0 = TregMemBuffer[TrightRegister + 1]; + Uint32 Tright1 = TregMemBuffer[TrightRegister + 2]; + if ((TrightType | TleftType) != 0) { + jam(); + if ((Tleft0 != Tright0) || (Tleft1 != Tright1)) { + TprogramCounter = brancher(theInstruction, TprogramCounter); + }//if + } else { + return TUPKEY_abort(signal, 24); + }//if + break; + } + + case Interpreter::BRANCH_LT_REG_REG: + { + Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2; + + Uint32 TleftType = TregMemBuffer[theRegister]; + Uint32 Tleft0 = TregMemBuffer[theRegister + 1]; + Uint32 Tleft1 = TregMemBuffer[theRegister + 2]; + + Uint32 TrightType = TregMemBuffer[TrightRegister]; + Uint32 Tright0 = TregMemBuffer[TrightRegister + 1]; + Uint32 Tright1 = TregMemBuffer[TrightRegister + 2]; + if ((TrightType | TleftType) != 0) { + jam(); + if ((Tleft0 < Tright0) || ((Tleft0 == Tright0) && + (Tleft1 < Tright1))) { + TprogramCounter = brancher(theInstruction, TprogramCounter); + }//if + } else { + return TUPKEY_abort(signal, 24); + }//if + break; + } + + case Interpreter::BRANCH_LE_REG_REG: + { + Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2; + + Uint32 TleftType = TregMemBuffer[theRegister]; + Uint32 Tleft0 = TregMemBuffer[theRegister + 1]; + Uint32 Tleft1 = TregMemBuffer[theRegister + 2]; + + Uint32 TrightType = TregMemBuffer[TrightRegister]; + Uint32 Tright0 = TregMemBuffer[TrightRegister + 1]; + Uint32 Tright1 = TregMemBuffer[TrightRegister + 2]; + if ((TrightType | TleftType) != 0) { + jam(); + if ((Tleft0 < Tright0) || ((Tleft0 == Tright0) && + (Tleft1 <= Tright1))) { + TprogramCounter = brancher(theInstruction, TprogramCounter); + }//if + } else { + return TUPKEY_abort(signal, 26); + }//if + break; + } + + case Interpreter::BRANCH_GT_REG_REG: + { + Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2; + + Uint32 TleftType = TregMemBuffer[theRegister]; + Uint32 Tleft0 = TregMemBuffer[theRegister + 1]; + Uint32 Tleft1 = TregMemBuffer[theRegister + 2]; + + Uint32 TrightType = TregMemBuffer[TrightRegister]; + Uint32 Tright0 = TregMemBuffer[TrightRegister + 1]; + Uint32 Tright1 = TregMemBuffer[TrightRegister + 2]; + if ((TrightType | TleftType) != 0) { + jam(); + if ((Tleft0 > Tright0) || ((Tleft0 == Tright0) && + (Tleft1 > Tright1))) { + TprogramCounter = brancher(theInstruction, TprogramCounter); + }//if + } else { + return TUPKEY_abort(signal, 27); + }//if + break; + } + + case Interpreter::BRANCH_GE_REG_REG: + { + Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2; + + Uint32 TleftType = TregMemBuffer[theRegister]; + Uint32 Tleft0 = TregMemBuffer[theRegister + 1]; + Uint32 Tleft1 = TregMemBuffer[theRegister + 2]; + + Uint32 TrightType = TregMemBuffer[TrightRegister]; + Uint32 Tright0 = TregMemBuffer[TrightRegister + 1]; + Uint32 Tright1 = TregMemBuffer[TrightRegister + 2]; + if ((TrightType | TleftType) != 0) { + jam(); + if ((Tleft0 > Tright0) || ((Tleft0 == Tright0) && + (Tleft1 >= Tright1))) { + TprogramCounter = brancher(theInstruction, TprogramCounter); + }//if + } else { + return TUPKEY_abort(signal, 28); + }//if + break; + } + + case Interpreter::BRANCH_ATTR_OP_ARG:{ + jam(); + Uint32 cond = Interpreter::getBinaryCondition(theInstruction); + Uint32 diff = Interpreter::getArrayLengthDiff(theInstruction); + Uint32 vchr = Interpreter::isVarchar(theInstruction); + Uint32 nopad =Interpreter::isNopad(theInstruction); + Uint32 ins2 = TcurrentProgram[TprogramCounter]; + Uint32 attrId = Interpreter::getBranchCol_AttrId(ins2) << 16; + Uint32 argLen = Interpreter::getBranchCol_Len(ins2); + + if(tmpHabitant != attrId){ + Int32 TnoDataR = readAttributes(pagePtr, + TupHeadOffset, + &attrId, 1, + tmpArea, tmpAreaSz); + + if (TnoDataR == -1) { + jam(); + tupkeyErrorLab(signal); + return -1; + } + tmpHabitant = attrId; + } + + AttributeHeader ah(tmpArea[0]); + + const char* s1 = (char*)&tmpArea[1]; + const char* s2 = (char*)&TcurrentProgram[TprogramCounter+1]; + Uint32 attrLen = (4 * ah.getDataSize()) - diff; + if (vchr) { +#if NDB_VERSION_MAJOR >= 3 + bool vok = false; + if (attrLen >= 2) { + Uint32 vlen = (s1[0] << 8) | s1[1]; // big-endian + s1 += 2; + attrLen -= 2; + if (attrLen >= vlen) { + attrLen = vlen; + vok = true; + } + } + if (!vok) { + terrorCode = ZREGISTER_INIT_ERROR; + tupkeyErrorLab(signal); + return -1; + } +#else + Uint32 tmp; + if (attrLen >= 2) { + unsigned char* ss = (unsigned char*)&s1[attrLen - 2]; + tmp = (ss[0] << 8) | ss[1]; + if (tmp <= attrLen - 2) + attrLen = tmp; + } + // XXX handle bad data +#endif + } + bool res = false; + + switch ((Interpreter::BinaryCondition)cond) { + case Interpreter::EQ: + res = NdbSqlUtil::char_compare(s1, attrLen, s2, argLen, !nopad) == 0; + break; + case Interpreter::NE: + res = NdbSqlUtil::char_compare(s1, attrLen, s2, argLen, !nopad) != 0; + break; + // note the condition is backwards + case Interpreter::LT: + res = NdbSqlUtil::char_compare(s1, attrLen, s2, argLen, !nopad) > 0; + break; + case Interpreter::LE: + res = NdbSqlUtil::char_compare(s1, attrLen, s2, argLen, !nopad) >= 0; + break; + case Interpreter::GT: + res = NdbSqlUtil::char_compare(s1, attrLen, s2, argLen, !nopad) < 0; + break; + case Interpreter::GE: + res = NdbSqlUtil::char_compare(s1, attrLen, s2, argLen, !nopad) <= 0; + break; + case Interpreter::LIKE: + res = NdbSqlUtil::char_like(s1, attrLen, s2, argLen, !nopad); + break; + case Interpreter::NOT_LIKE: + res = ! NdbSqlUtil::char_like(s1, attrLen, s2, argLen, !nopad); + break; + // XXX handle invalid value + } +#ifdef TRACE_INTERPRETER + ndbout_c("cond=%u diff=%d vc=%d nopad=%d attr(%d) = >%.*s<(%d) str=>%.*s<(%d) -> res = %d", + cond, diff, vchr, nopad, + attrId >> 16, attrLen, s1, attrLen, argLen, s2, argLen, res); +#endif + if (res) + TprogramCounter = brancher(theInstruction, TprogramCounter); + else { + Uint32 tmp = (Interpreter::mod4(argLen) >> 2) + 1; + TprogramCounter += tmp; + } + break; + } + + case Interpreter::BRANCH_ATTR_EQ_NULL:{ + jam(); + Uint32 ins2 = TcurrentProgram[TprogramCounter]; + Uint32 attrId = Interpreter::getBranchCol_AttrId(ins2) << 16; + + if(tmpHabitant != attrId){ + Int32 TnoDataR = readAttributes(pagePtr, + TupHeadOffset, + &attrId, 1, + tmpArea, tmpAreaSz); + + if (TnoDataR == -1) { + jam(); + tupkeyErrorLab(signal); + return -1; + } + tmpHabitant = attrId; + } + + AttributeHeader ah(tmpArea[0]); + if(ah.isNULL()){ + TprogramCounter = brancher(theInstruction, TprogramCounter); + } else { + TprogramCounter ++; + } + break; + } + + case Interpreter::BRANCH_ATTR_NE_NULL:{ + jam(); + Uint32 ins2 = TcurrentProgram[TprogramCounter]; + Uint32 attrId = Interpreter::getBranchCol_AttrId(ins2) << 16; + + if(tmpHabitant != attrId){ + Int32 TnoDataR = readAttributes(pagePtr, + TupHeadOffset, + &attrId, 1, + tmpArea, tmpAreaSz); + + if (TnoDataR == -1) { + jam(); + tupkeyErrorLab(signal); + return -1; + } + tmpHabitant = attrId; + } + + AttributeHeader ah(tmpArea[0]); + if(ah.isNULL()){ + TprogramCounter ++; + } else { + TprogramCounter = brancher(theInstruction, TprogramCounter); + } + break; + } + + case Interpreter::EXIT_OK: + case Interpreter::EXIT_OK_LAST: + jam(); +#ifdef TRACE_INTERPRETER + ndbout_c(" - exit_ok"); +#endif + return TdataWritten; + + case Interpreter::EXIT_REFUSE: + jam(); +#ifdef TRACE_INTERPRETER + ndbout_c(" - exit_nok"); +#endif + terrorCode = theInstruction >> 16; + return TUPKEY_abort(signal, 29); + + case Interpreter::CALL: + jam(); + RstackPtr++; + if (RstackPtr < 32) { + TstackMemBuffer[RstackPtr] = TprogramCounter + 1; + TprogramCounter = theInstruction >> 16; + if (TprogramCounter < TsubroutineLen) { + TcurrentProgram = subroutineProg; + TcurrentSize = TsubroutineLen; + } else { + return TUPKEY_abort(signal, 30); + }//if + } else { + return TUPKEY_abort(signal, 31); + }//if + break; + + case Interpreter::RETURN: + jam(); + if (RstackPtr > 0) { + TprogramCounter = TstackMemBuffer[RstackPtr]; + RstackPtr--; + if (RstackPtr == 0) { + jam(); + /* ------------------------------------------------------------- */ + // We are back to the main program. + /* ------------------------------------------------------------- */ + TcurrentProgram = mainProgram; + TcurrentSize = TmainProgLen; + }//if + } else { + return TUPKEY_abort(signal, 32); + }//if + break; + + default: + return TUPKEY_abort(signal, 33); + }//switch + } else { + return TUPKEY_abort(signal, 34); + }//if + }//while + return TUPKEY_abort(signal, 35); +}//Dbtup::interpreterNextLab() + + diff --git a/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp b/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp new file mode 100644 index 00000000000..cdd54ba2337 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp @@ -0,0 +1,384 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include + +#define ljam() { jamLine(6000 + __LINE__); } +#define ljamEntry() { jamEntryLine(6000 + __LINE__); } + +// +// Fixed Allocator +// This module is used to allocate and free fixed size tuples from the +// set of pages attached to a fragment. The fixed size is preset per +// fragment and their can only be one such value per fragment in the +// current implementation. +// +// Public methods +// bool allocTh(Fragrecord* const regFragPtr, # In +// Tablerec* const regTabPtr, # In +// Uint32 pageType, # In +// Signal* signal, # In +// Uint32& pageOffset, # Out +// PagePtr& pagePtr) # In/Out +// This method allocates a fixed size and the pagePtr is a reference +// to the page and pageOffset is the offset in the page of the tuple. +// +// freeTh() +// This method is used to free a tuple header in normal transaction +// handling. +// +// freeThSr() +// This method is used to free a tuple as part of executing the undo +// log records. +// +// getThAtPageSr() +// This method is used to allocate a tuple on a set page as part of +// undo log execution. +// +// +// Private methods +// getThAtPage() +// This method gets a tuple from a page with free tuples. +// +// convertThPage() +// Convert an empty page into a page of free tuples in a linked list. +// +// getEmptyPageThCopy() +// A page recently taken from set of empty pages on fragment is made +// part of the copy pages. +// +// getEmptyPageTh() +// A page recently taken from the set of empty pages on the fragment is +// is made part of the set of free pages with fixed size tuples in the +// fragment. +// +bool Dbtup::allocTh(Fragrecord* const regFragPtr, + Tablerec* const regTabPtr, + Uint32 pageType, + Signal* signal, + Uint32& pageOffset, + PagePtr& pagePtr) +{ + if (pageType == SAME_PAGE) { + ljam(); + ptrCheckGuard(pagePtr, cnoOfPage, page); + if (pagePtr.p->pageWord[ZPAGE_STATE_POS] == ZTH_MM_FREE) { + ljam(); + getThAtPage(regFragPtr, pagePtr.p, signal, pageOffset); + return true; + }//if + pageType = NORMAL_PAGE; + }//if + if (pageType == COPY_PAGE) { +/* ---------------------------------------------------------------- */ +// Allocate a tuple header for the copy of the tuple header +/* ---------------------------------------------------------------- */ + if (regFragPtr->thFreeCopyFirst == RNIL) { +/* ---------------------------------------------------------------- */ +// No page in list with free tuple header exists +/* ---------------------------------------------------------------- */ + if (regFragPtr->noCopyPagesAlloc < ZMAX_NO_COPY_PAGES) { + ljam(); +/* ---------------------------------------------------------------- */ +// We have not yet allocated the maximum number of copy pages for +// this fragment. +/* ---------------------------------------------------------------- */ + pagePtr.i = getEmptyPage(regFragPtr); + if (pagePtr.i != RNIL) { + ljam(); +/* ---------------------------------------------------------------- */ +// We have empty pages already allocated to this fragment. Allocate +// one of those as copy page. +/* ---------------------------------------------------------------- */ + ptrCheckGuard(pagePtr, cnoOfPage, page); + getEmptyPageThCopy(regFragPtr, signal, pagePtr.p); +/* ---------------------------------------------------------------- */ +// Convert page into a tuple header page. +/* ---------------------------------------------------------------- */ + convertThPage(regTabPtr->tupheadsize, pagePtr.p); + getThAtPage(regFragPtr, pagePtr.p, signal, pageOffset); + return true; + }//if + }//if + } else { + ljam(); +/* ---------------------------------------------------------------- */ +/* NORMAL PATH WHEN COPY PAGE REQUESTED, GET PAGE POINTER */ +/* AND THEN GOTO COMMON HANDLING OF GET TUPLE HEADER AT PAGE. */ +/* ---------------------------------------------------------------- */ + pagePtr.i = getRealpid(regFragPtr, regFragPtr->thFreeCopyFirst); + ptrCheckGuard(pagePtr, cnoOfPage, page); + getThAtPage(regFragPtr, pagePtr.p, signal, pageOffset); + return true; + }//if + }//if +/* ---------------------------------------------------------------- */ +/* EITHER NORMAL PAGE REQUESTED OR ALLOCATION FROM COPY PAGE */ +/* FAILED. TRY ALLOCATING FROM NORMAL PAGE. */ +/* ---------------------------------------------------------------- */ + Uint32 fragPageId = regFragPtr->thFreeFirst; + if (fragPageId == RNIL) { +/* ---------------------------------------------------------------- */ +// No prepared tuple header page with free entries exists. +/* ---------------------------------------------------------------- */ + pagePtr.i = getEmptyPage(regFragPtr); + if (pagePtr.i != RNIL) { + ljam(); +/* ---------------------------------------------------------------- */ +// We found empty pages on the fragment. Allocate an empty page and +// convert it into a tuple header page and put it in thFreeFirst-list. +/* ---------------------------------------------------------------- */ + ptrCheckGuard(pagePtr, cnoOfPage, page); + getEmptyPageTh(regFragPtr, signal, pagePtr.p); + convertThPage(regTabPtr->tupheadsize, pagePtr.p); + getThAtPage(regFragPtr, pagePtr.p, signal, pageOffset); + return true; + } else { + ljam(); +/* ---------------------------------------------------------------- */ +/* THERE ARE NO EMPTY PAGES. MEMORY CAN NOT BE ALLOCATED. */ +/* ---------------------------------------------------------------- */ + terrorCode = ZMEM_NOMEM_ERROR; + return false; + }//if + } else { + ljam(); +/* ---------------------------------------------------------------- */ +/* THIS SHOULD BE THE COMMON PATH THROUGH THE CODE, FREE */ +/* COPY PAGE EXISTED. */ +/* ---------------------------------------------------------------- */ + pagePtr.i = getRealpid(regFragPtr, fragPageId); + ptrCheckGuard(pagePtr, cnoOfPage, page); + getThAtPage(regFragPtr, pagePtr.p, signal, pageOffset); + return true; + }//if + ndbrequire(false); // Dead code + return false; +}//Dbtup::allocTh() + +void Dbtup::convertThPage(Uint32 Tupheadsize, + Page* const regPagePtr) +{ + Uint32 ctpConstant = Tupheadsize << 16; + Uint32 nextTuple = ZPAGE_HEADER_SIZE + Tupheadsize; + Uint32 endOfList; + /* + ASSUMES AT LEAST ONE TUPLE HEADER FITS AND THEREFORE NO HANDLING + OF ZERO AS EXTREME CASE + */ + do { + ljam(); + endOfList = nextTuple - Tupheadsize; + regPagePtr->pageWord[endOfList] = ctpConstant + nextTuple; + nextTuple += Tupheadsize; + } while (nextTuple <= ZWORDS_ON_PAGE); + regPagePtr->pageWord[endOfList] = ctpConstant; + Uint32 startOfList = ZPAGE_HEADER_SIZE; + regPagePtr->pageWord[ZFREELIST_HEADER_POS] = (startOfList << 16) + endOfList; +}//Dbtup::convertThPage() + +void Dbtup::getEmptyPageTh(Fragrecord* const regFragPtr, + Signal* signal, + Page* const regPagePtr) +{ + if (isUndoLoggingNeeded(regFragPtr, regPagePtr->pageWord[ZPAGE_FRAG_PAGE_ID_POS])) { + cprAddUndoLogPageHeader(signal, + regPagePtr, + regFragPtr); + }//if + regPagePtr->pageWord[ZPAGE_NEXT_POS] = regFragPtr->thFreeFirst; + regPagePtr->pageWord[ZPAGE_STATE_POS] = ZTH_MM_FREE; + regFragPtr->thFreeFirst = regPagePtr->pageWord[ZPAGE_FRAG_PAGE_ID_POS]; + +ndbrequire(regFragPtr->thFreeFirst != (RNIL -1)); +}//Dbtup::getEmptyPageTh() + +void Dbtup::getEmptyPageThCopy(Fragrecord* const regFragPtr, + Signal* signal, + Page* const regPagePtr) +{ + if (isUndoLoggingNeeded(regFragPtr, regPagePtr->pageWord[ZPAGE_FRAG_PAGE_ID_POS])) { + cprAddUndoLogPageHeader(signal, + regPagePtr, + regFragPtr); + }//if + regPagePtr->pageWord[ZPAGE_NEXT_POS] = regFragPtr->thFreeCopyFirst; + regPagePtr->pageWord[ZPAGE_STATE_POS] = ZTH_MM_FREE_COPY; + regFragPtr->thFreeCopyFirst = regPagePtr->pageWord[ZPAGE_FRAG_PAGE_ID_POS]; + regFragPtr->noCopyPagesAlloc++; +}//Dbtup::getEmptyPageThCopy() + +void Dbtup::getThAtPage(Fragrecord* const regFragPtr, + Page* const regPagePtr, + Signal* signal, + Uint32& pageOffset) +{ + Uint32 freeListHeader = regPagePtr->pageWord[ZFREELIST_HEADER_POS]; + Uint32 startTuple = freeListHeader >> 16; + Uint32 endTuple = freeListHeader & 0xffff; + pageOffset = startTuple; /* START IS THE ONE ALLOCATED */ + if (startTuple > 0) { + if (startTuple != endTuple) { +/* ---------------------------------------------------------------- */ +/* NOT THE LAST, SIMPLY RESHUFFLE POINTERS. */ +/* ---------------------------------------------------------------- */ + ndbrequire(startTuple < ZWORDS_ON_PAGE); + startTuple = regPagePtr->pageWord[startTuple] & 0xffff; + regPagePtr->pageWord[ZFREELIST_HEADER_POS] = endTuple + + (startTuple << 16); + return; + } else { +/* ---------------------------------------------------------------- */ +/* THIS WAS THE LAST TUPLE HEADER IN THIS PAGE. REMOVE IT FROM*/ +/* THE TUPLE HEADER FREE LIST OR TH COPY FREE LIST. ALSO SET */ +/* A PROPER PAGE STATE. */ +/* */ +/* WE ALSO HAVE TO INSERT AN UNDO LOG ENTRY TO ENSURE PAGE */ +/* ARE MAINTAINED EVEN AFTER A SYSTEM CRASH. */ +/* ---------------------------------------------------------------- */ + if (isUndoLoggingNeeded(regFragPtr, + regPagePtr->pageWord[ZPAGE_FRAG_PAGE_ID_POS])) { + cprAddUndoLogPageHeader(signal, + regPagePtr, + regFragPtr); + }//if + if (regPagePtr->pageWord[ZPAGE_STATE_POS] == ZTH_MM_FREE) { + ljam(); + regFragPtr->thFreeFirst = regPagePtr->pageWord[ZPAGE_NEXT_POS]; + regPagePtr->pageWord[ZPAGE_STATE_POS] = ZTH_MM_FULL; + } else if (regPagePtr->pageWord[ZPAGE_STATE_POS] == ZTH_MM_FREE_COPY) { + ljam(); + regFragPtr->thFreeCopyFirst = regPagePtr->pageWord[ZPAGE_NEXT_POS]; + regPagePtr->pageWord[ZPAGE_STATE_POS] = ZTH_MM_FULL_COPY; + } else { + ndbrequire(false); + }//if + regPagePtr->pageWord[ZFREELIST_HEADER_POS] = 0; + regPagePtr->pageWord[ZPAGE_NEXT_POS] = RNIL; + }//if + } else { + ndbrequire(false); + }//if + return; +}//Dbtup::getThAtPage() + +void Dbtup::getThAtPageSr(Page* const regPagePtr, + Uint32& pageOffset) +{ + Uint32 freeListHeader = regPagePtr->pageWord[ZFREELIST_HEADER_POS]; + Uint32 startTuple = freeListHeader >> 16; + Uint32 endTuple = freeListHeader & 0xffff; + ndbrequire(startTuple > 0); + pageOffset = startTuple; /* START IS THE ONE ALLOCATED */ + if (startTuple == endTuple) { + ljam(); +/* ---------------------------------------------------------------- */ +/* THIS WAS THE LAST TUPLE HEADER IN THIS PAGE. SINCE WE ARE */ +/* UNDOING PAGE UPDATES WE SHALL NOT DO ANYTHING ABOUT THE */ +/* PAGE HEADER. THIS IS DONE BY SEPARATE LOG RECORDS. */ +/* ---------------------------------------------------------------- */ + regPagePtr->pageWord[ZFREELIST_HEADER_POS] = 0; + } else { + ljam(); +/* ---------------------------------------------------------------- */ +/* NOT THE LAST, SIMPLY RESHUFFLE POINTERS. */ +/* ---------------------------------------------------------------- */ + ndbrequire(startTuple < ZWORDS_ON_PAGE); + startTuple = regPagePtr->pageWord[startTuple] & 0xffff; /* GET NEXT POINTER */ + regPagePtr->pageWord[ZFREELIST_HEADER_POS] = endTuple + (startTuple << 16); + }//if +}//Dbtup::getThAtPageSr() + +void Dbtup::freeTh(Fragrecord* const regFragPtr, + Tablerec* const regTabPtr, + Signal* signal, + Page* const regPagePtr, + Uint32 freePageOffset) +{ + Uint32 startOfList = regPagePtr->pageWord[ZFREELIST_HEADER_POS] >> 16; + Uint32 endOfList = regPagePtr->pageWord[ZFREELIST_HEADER_POS] & 0xffff; +/* LINK THE NOW FREE TUPLE SPACE INTO BEGINNING OF FREE LIST OF OF THE PAGE */ +/* SET THE SIZE OF THE NEW FREE SPACE AND LINK TO THE OLD START OF FREELIST */ + ndbrequire(freePageOffset < ZWORDS_ON_PAGE); + regPagePtr->pageWord[freePageOffset] = (regTabPtr->tupheadsize << 16) + + startOfList; + if (endOfList == 0) { + ljam(); + ndbrequire(startOfList == 0); +/* ---------------------------------------------------------------- */ +/* THE PAGE WAS PREVIOUSLY FULL, NO EMPTY SPACE AT ALL. */ +/* THIS ENTRY WILL THEN BE BOTH THE START AND THE END OF THE */ +/* LIST. IT WILL ALSO BE PUT ON THE PROPER FREE LIST. */ +/* */ +/* UPDATE OF NEXT POINTER AND PAGE STATE MUST BE LOGGED TO */ +/* THE UNDO LOG TO ENSURE THAT FREE LISTS ARE OK AFTER A */ +/* SYSTEM RESTART. */ +/* ---------------------------------------------------------------- */ + if (isUndoLoggingNeeded(regFragPtr, regPagePtr->pageWord[ZPAGE_FRAG_PAGE_ID_POS])) { + cprAddUndoLogPageHeader(signal, + regPagePtr, + regFragPtr); + }//if + regPagePtr->pageWord[ZFREELIST_HEADER_POS] = (freePageOffset << 16) + freePageOffset; + if (regPagePtr->pageWord[ZPAGE_STATE_POS] == ZTH_MM_FULL) { + ljam(); + regPagePtr->pageWord[ZPAGE_NEXT_POS] = regFragPtr->thFreeFirst; + regFragPtr->thFreeFirst = regPagePtr->pageWord[ZPAGE_FRAG_PAGE_ID_POS]; + regPagePtr->pageWord[ZPAGE_STATE_POS] = ZTH_MM_FREE; + } else { + ndbrequire(regPagePtr->pageWord[ZPAGE_STATE_POS] == ZTH_MM_FULL_COPY); + ljam(); + regPagePtr->pageWord[ZPAGE_NEXT_POS] = regFragPtr->thFreeCopyFirst; + regFragPtr->thFreeCopyFirst = regPagePtr->pageWord[ZPAGE_FRAG_PAGE_ID_POS]; + regPagePtr->pageWord[ZPAGE_STATE_POS] = ZTH_MM_FREE_COPY; + }//if + } else { + ljam(); + regPagePtr->pageWord[ZFREELIST_HEADER_POS] = (freePageOffset << 16) + endOfList; + }//if +}//Dbtup::freeTh() + +void Dbtup::freeThSr(Tablerec* const regTabPtr, + Page* const regPagePtr, + Uint32 freePageOffset) +{ +/* ------------------------------------------------------------------------ */ +/* LINK THE NOW FREE TUPLE SPACE INTO BEGINNING OF FREE LIST OF OF THE PAGE */ +/* SET THE SIZE OF THE NEW FREE SPACE AND LINK TO THE OLD START OF FREELIST */ +/* ------------------------------------------------------------------------ */ + Uint32 startOfList = regPagePtr->pageWord[ZFREELIST_HEADER_POS] >> 16; + Uint32 endOfList = regPagePtr->pageWord[ZFREELIST_HEADER_POS] & 0xffff; + ndbrequire(freePageOffset < ZWORDS_ON_PAGE); + regPagePtr->pageWord[freePageOffset] = (regTabPtr->tupheadsize << 16) + startOfList; + if (endOfList == 0) { + ljam(); + ndbrequire(startOfList == 0); +/* ---------------------------------------------------------------- */ +/* THE PAGE WAS PREVIOUSLY FULL, NO EMPTY SPACE AT ALL. */ +/* THIS ENTRY WILL THEN BE BOTH THE START AND THE END OF THE */ +/* LIST. IT WILL ALSO BE PUT ON THE PROPER FREE LIST. */ +/* ---------------------------------------------------------------- */ + regPagePtr->pageWord[ZFREELIST_HEADER_POS] = (freePageOffset << 16) + freePageOffset; + } else { + ljam(); + regPagePtr->pageWord[ZFREELIST_HEADER_POS] = (freePageOffset << 16) + endOfList; + }//if +}//Dbtup::freeThSr() + diff --git a/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp b/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp new file mode 100644 index 00000000000..982e1b8df24 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp @@ -0,0 +1,1319 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include +#include +#include "AttributeOffset.hpp" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#define DEBUG(x) { ndbout << "TUP::" << x << endl; } + +#define ljam() { jamLine(24000 + __LINE__); } +#define ljamEntry() { jamEntryLine(24000 + __LINE__); } + +void Dbtup::initData() +{ + cnoOfAttrbufrec = ZNO_OF_ATTRBUFREC; + cnoOfLcpRec = ZNO_OF_LCP_REC; + cnoOfConcurrentOpenOp = ZNO_OF_CONCURRENT_OPEN_OP; + cnoOfConcurrentWriteOp = ZNO_OF_CONCURRENT_WRITE_OP; + cnoOfFragoprec = 2 * NO_OF_FRAG_PER_NODE; + cnoOfFragrec = ZNO_OF_FRAGREC; + cnoOfOprec = ZNO_OF_OPREC; + cnoOfPage = ZNO_OF_PAGE; + cnoOfPageRangeRec = ZNO_OF_PAGE_RANGE_REC; + cnoOfParallellUndoFiles = ZNO_OF_PARALLELL_UNDO_FILES; + cnoOfRestartInfoRec = ZNO_OF_RESTART_INFO_REC; + cnoOfTablerec = ZNO_OF_TABLEREC; + cnoOfTabDescrRec = ZNO_OF_TAB_DESCR_REC; + cnoOfUndoPage = ZNO_OF_UNDO_PAGE; + c_maxTriggersPerTable = ZDEFAULT_MAX_NO_TRIGGERS_PER_TABLE; + c_noOfBuildIndexRec = 32; + + attrbufrec = 0; + checkpointInfo = 0; + diskBufferSegmentInfo = 0; + fragoperrec = 0; + fragrecord = 0; + hostBuffer = 0; + localLogInfo = 0; + operationrec = 0; + page = 0; + pageRange = 0; + pendingFileOpenInfo = 0; + restartInfoRecord = 0; + tablerec = 0; + tableDescriptor = 0; + undoPage = 0; + totNoOfPagesAllocated = 0; + cnoOfAllocatedPages = 0; + + // Records with constant sizes +}//Dbtup::initData() + +Dbtup::Dbtup(const class Configuration & conf) + : SimulatedBlock(DBTUP, conf), + c_storedProcPool(), + c_buildIndexList(c_buildIndexPool) +{ + + BLOCK_CONSTRUCTOR(Dbtup); + + addRecSignal(GSN_DEBUG_SIG, &Dbtup::execDEBUG_SIG); + addRecSignal(GSN_CONTINUEB, &Dbtup::execCONTINUEB); + + addRecSignal(GSN_DUMP_STATE_ORD, &Dbtup::execDUMP_STATE_ORD); + addRecSignal(GSN_SEND_PACKED, &Dbtup::execSEND_PACKED); + addRecSignal(GSN_ATTRINFO, &Dbtup::execATTRINFO); + addRecSignal(GSN_STTOR, &Dbtup::execSTTOR); + addRecSignal(GSN_TUP_LCPREQ, &Dbtup::execTUP_LCPREQ); + addRecSignal(GSN_END_LCPREQ, &Dbtup::execEND_LCPREQ); + addRecSignal(GSN_START_RECREQ, &Dbtup::execSTART_RECREQ); + addRecSignal(GSN_MEMCHECKREQ, &Dbtup::execMEMCHECKREQ); + addRecSignal(GSN_TUPKEYREQ, &Dbtup::execTUPKEYREQ); + addRecSignal(GSN_TUPSEIZEREQ, &Dbtup::execTUPSEIZEREQ); + addRecSignal(GSN_TUPRELEASEREQ, &Dbtup::execTUPRELEASEREQ); + addRecSignal(GSN_STORED_PROCREQ, &Dbtup::execSTORED_PROCREQ); + addRecSignal(GSN_TUPFRAGREQ, &Dbtup::execTUPFRAGREQ); + addRecSignal(GSN_TUP_ADD_ATTRREQ, &Dbtup::execTUP_ADD_ATTRREQ); + addRecSignal(GSN_TUP_COMMITREQ, &Dbtup::execTUP_COMMITREQ); + addRecSignal(GSN_TUP_ABORTREQ, &Dbtup::execTUP_ABORTREQ); + addRecSignal(GSN_TUP_SRREQ, &Dbtup::execTUP_SRREQ); + addRecSignal(GSN_TUP_PREPLCPREQ, &Dbtup::execTUP_PREPLCPREQ); + addRecSignal(GSN_FSOPENCONF, &Dbtup::execFSOPENCONF); + addRecSignal(GSN_FSOPENREF, &Dbtup::execFSOPENREF); + addRecSignal(GSN_FSCLOSECONF, &Dbtup::execFSCLOSECONF); + addRecSignal(GSN_FSCLOSEREF, &Dbtup::execFSCLOSEREF); + addRecSignal(GSN_FSWRITECONF, &Dbtup::execFSWRITECONF); + addRecSignal(GSN_FSWRITEREF, &Dbtup::execFSWRITEREF); + addRecSignal(GSN_FSREADCONF, &Dbtup::execFSREADCONF); + addRecSignal(GSN_FSREADREF, &Dbtup::execFSREADREF); + addRecSignal(GSN_NDB_STTOR, &Dbtup::execNDB_STTOR); + addRecSignal(GSN_SIZEALT_REP, &Dbtup::execSIZEALT_REP); + addRecSignal(GSN_SET_VAR_REQ, &Dbtup::execSET_VAR_REQ); + + // Trigger Signals + addRecSignal(GSN_CREATE_TRIG_REQ, &Dbtup::execCREATE_TRIG_REQ); + addRecSignal(GSN_DROP_TRIG_REQ, &Dbtup::execDROP_TRIG_REQ); + + addRecSignal(GSN_DROP_TAB_REQ, &Dbtup::execDROP_TAB_REQ); + addRecSignal(GSN_FSREMOVEREF, &Dbtup::execFSREMOVEREF); + addRecSignal(GSN_FSREMOVECONF, &Dbtup::execFSREMOVECONF); + + addRecSignal(GSN_TUP_ALLOCREQ, &Dbtup::execTUP_ALLOCREQ); + addRecSignal(GSN_TUP_DEALLOCREQ, &Dbtup::execTUP_DEALLOCREQ); + addRecSignal(GSN_TUP_WRITELOG_REQ, &Dbtup::execTUP_WRITELOG_REQ); + + // Ordered index related + addRecSignal(GSN_TUP_READ_ATTRS, &Dbtup::execTUP_READ_ATTRS); + addRecSignal(GSN_TUP_QUERY_TH, &Dbtup::execTUP_QUERY_TH); + addRecSignal(GSN_TUP_STORE_TH, &Dbtup::execTUP_STORE_TH); + addRecSignal(GSN_BUILDINDXREQ, &Dbtup::execBUILDINDXREQ); + + initData(); +}//Dbtup::Dbtup() + +Dbtup::~Dbtup() +{ + // Records with dynamic sizes + deallocRecord((void **)&attrbufrec,"Attrbufrec", + sizeof(Attrbufrec), + cnoOfAttrbufrec); + + deallocRecord((void **)&checkpointInfo,"CheckpointInfo", + sizeof(CheckpointInfo), + cnoOfLcpRec); + + deallocRecord((void **)&diskBufferSegmentInfo, + "DiskBufferSegmentInfo", + sizeof(DiskBufferSegmentInfo), + cnoOfConcurrentWriteOp); + + deallocRecord((void **)&fragoperrec,"Fragoperrec", + sizeof(Fragoperrec), + cnoOfFragoprec); + + deallocRecord((void **)&fragrecord,"Fragrecord", + sizeof(Fragrecord), + cnoOfFragrec); + + deallocRecord((void **)&hostBuffer,"HostBuffer", + sizeof(HostBuffer), + MAX_NODES); + + deallocRecord((void **)&localLogInfo,"LocalLogInfo", + sizeof(LocalLogInfo), + cnoOfParallellUndoFiles); + + deallocRecord((void **)&operationrec,"Operationrec", + sizeof(Operationrec), + cnoOfOprec); + + deallocRecord((void **)&page,"Page", + sizeof(Page), + cnoOfPage); + + deallocRecord((void **)&pageRange,"PageRange", + sizeof(PageRange), + cnoOfPageRangeRec); + + deallocRecord((void **)&pendingFileOpenInfo, + "PendingFileOpenInfo", + sizeof(PendingFileOpenInfo), + cnoOfConcurrentOpenOp); + + deallocRecord((void **)&restartInfoRecord, + "RestartInfoRecord", + sizeof(RestartInfoRecord), + cnoOfRestartInfoRec); + + deallocRecord((void **)&tablerec,"Tablerec", + sizeof(Tablerec), + cnoOfTablerec); + + deallocRecord((void **)&tableDescriptor, "TableDescriptor", + sizeof(TableDescriptor), + cnoOfTabDescrRec); + + deallocRecord((void **)&undoPage,"UndoPage", + sizeof(UndoPage), + cnoOfUndoPage); + +}//Dbtup::~Dbtup() + +BLOCK_FUNCTIONS(Dbtup); + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* ----- GENERAL SIGNAL MULTIPLEXER (FS + CONTINUEB) -------------- */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ +void Dbtup::execFSCLOSECONF(Signal* signal) +{ + PendingFileOpenInfoPtr pfoPtr; + ljamEntry(); + pfoPtr.i = signal->theData[0]; + ptrCheckGuard(pfoPtr, cnoOfConcurrentOpenOp, pendingFileOpenInfo); + switch (pfoPtr.p->pfoOpenType) { + case LCP_DATA_FILE_CLOSE: + { + CheckpointInfoPtr ciPtr; + ljam(); + ciPtr.i = pfoPtr.p->pfoCheckpointInfoP; + ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo); + ciPtr.p->lcpDataFileHandle = RNIL; + lcpClosedDataFileLab(signal, ciPtr); + break; + } + case LCP_UNDO_FILE_CLOSE: + { + LocalLogInfoPtr lliPtr; + ljam(); + lliPtr.i = pfoPtr.p->pfoCheckpointInfoP; + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); + lliPtr.p->lliUndoFileHandle = RNIL; + lcpEndconfLab(signal); + break; + } + case LCP_UNDO_FILE_READ: + ljam(); + endExecUndoLogLab(signal, pfoPtr.p->pfoCheckpointInfoP); + break; + case LCP_DATA_FILE_READ: + ljam(); + rfrClosedDataFileLab(signal, pfoPtr.p->pfoCheckpointInfoP); + break; + default: + ndbrequire(false); + break; + }//switch + releasePendingFileOpenInfoRecord(pfoPtr); +}//Dbtup::execFSCLOSECONF() + +void Dbtup::execFSCLOSEREF(Signal* signal) +{ + ljamEntry(); + ndbrequire(false); +}//Dbtup::execFSCLOSEREF() + +void Dbtup::execFSOPENCONF(Signal* signal) +{ + PendingFileOpenInfoPtr pfoPtr; + + ljamEntry(); + pfoPtr.i = signal->theData[0]; + Uint32 fileHandle = signal->theData[1]; + ptrCheckGuard(pfoPtr, cnoOfConcurrentOpenOp, pendingFileOpenInfo); + switch (pfoPtr.p->pfoOpenType) { + case LCP_DATA_FILE_READ: + { + RestartInfoRecordPtr riPtr; + ljam(); + riPtr.i = pfoPtr.p->pfoRestartInfoP; + ptrCheckGuard(riPtr, cnoOfRestartInfoRec, restartInfoRecord); + riPtr.p->sriDataFileHandle = fileHandle; + rfrReadRestartInfoLab(signal, riPtr); + break; + } + case LCP_UNDO_FILE_READ: + { + RestartInfoRecordPtr riPtr; + LocalLogInfoPtr lliPtr; + DiskBufferSegmentInfoPtr dbsiPtr; + + ljam(); + riPtr.i = pfoPtr.p->pfoRestartInfoP; + ptrCheckGuard(riPtr, cnoOfRestartInfoRec, restartInfoRecord); + lliPtr.i = riPtr.p->sriLocalLogInfoP; + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); + lliPtr.p->lliUndoFileHandle = fileHandle; + dbsiPtr.i = riPtr.p->sriDataBufferSegmentP; + ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo); + rfrLoadDataPagesLab(signal, riPtr, dbsiPtr); + break; + } + case LCP_DATA_FILE_WRITE_WITH_UNDO: + { + CheckpointInfoPtr ciPtr; + LocalLogInfoPtr lliPtr; + + ljam(); + ciPtr.i = pfoPtr.p->pfoCheckpointInfoP; + ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo); + lliPtr.i = ciPtr.p->lcpLocalLogInfoP; + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); + ciPtr.p->lcpDataFileHandle = fileHandle; + if (lliPtr.p->lliUndoFileHandle != RNIL) { + ljam(); + signal->theData[0] = ciPtr.p->lcpUserptr; + signal->theData[1] = ciPtr.i; + sendSignal(ciPtr.p->lcpBlockref, GSN_TUP_PREPLCPCONF, signal, 2, JBB); + }//if + break; + } + case LCP_DATA_FILE_WRITE: + { + CheckpointInfoPtr ciPtr; + + ljam(); + ciPtr.i = pfoPtr.p->pfoCheckpointInfoP; + ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo); + ciPtr.p->lcpDataFileHandle = fileHandle; + signal->theData[0] = ciPtr.p->lcpUserptr; + signal->theData[1] = ciPtr.i; + sendSignal(ciPtr.p->lcpBlockref, GSN_TUP_PREPLCPCONF, signal, 2, JBB); + break; + } + case LCP_UNDO_FILE_WRITE: + { + CheckpointInfoPtr ciPtr; + LocalLogInfoPtr lliPtr; + + ljam(); + ciPtr.i = pfoPtr.p->pfoCheckpointInfoP; + ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo); + lliPtr.i = ciPtr.p->lcpLocalLogInfoP; + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); + lliPtr.p->lliUndoFileHandle = fileHandle; + if (ciPtr.p->lcpDataFileHandle != RNIL) { + ljam(); + signal->theData[0] = ciPtr.p->lcpUserptr; + signal->theData[1] = ciPtr.i; + sendSignal(ciPtr.p->lcpBlockref, GSN_TUP_PREPLCPCONF, signal, 2, JBB); + }//if + break; + } + default: + ndbrequire(false); + break; + }//switch + releasePendingFileOpenInfoRecord(pfoPtr); +}//Dbtup::execFSOPENCONF() + +void Dbtup::execFSOPENREF(Signal* signal) +{ + ljamEntry(); + ndbrequire(false); +}//Dbtup::execFSOPENREF() + +void Dbtup::execFSREADCONF(Signal* signal) +{ + DiskBufferSegmentInfoPtr dbsiPtr; + ljamEntry(); + dbsiPtr.i = signal->theData[0]; + ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo); + switch (dbsiPtr.p->pdxOperation) { + case CHECKPOINT_DATA_READ: + { + RestartInfoRecordPtr riPtr; + ljam(); + riPtr.i = dbsiPtr.p->pdxRestartInfoP; + ptrCheckGuard(riPtr, cnoOfRestartInfoRec, restartInfoRecord); +/************************************************************/ +/* VERIFY THAT THE PAGES ARE CORRECT, HAVE A CORRECT */ +/* STATE AND A CORRECT PAGE ID. */ +/************************************************************/ + ndbrequire(dbsiPtr.p->pdxNumDataPages <= 16); + for (Uint32 i = 0; i < dbsiPtr.p->pdxNumDataPages; i++) { + PagePtr pagePtr; + ljam(); + pagePtr.i = dbsiPtr.p->pdxDataPage[i]; + ptrCheckGuard(pagePtr, cnoOfPage, page); + ndbrequire(pagePtr.p->pageWord[ZPAGE_STATE_POS] != 0); + ndbrequire(pagePtr.p->pageWord[ZPAGE_STATE_POS] <= ZAC_MM_FREE_COPY); + ndbrequire(pagePtr.p->pageWord[ZPAGE_FRAG_PAGE_ID_POS] == ((dbsiPtr.p->pdxFilePage - 1) + i)); + }//for + rfrLoadDataPagesLab(signal, riPtr, dbsiPtr); + break; + } + case CHECKPOINT_DATA_READ_PAGE_ZERO: + { + ljam(); + rfrInitRestartInfoLab(signal, dbsiPtr); + break; + } + case CHECKPOINT_UNDO_READ: + { + LocalLogInfoPtr lliPtr; + ljam(); + lliPtr.i = dbsiPtr.p->pdxCheckpointInfoP; + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); + xlcGetNextRecordLab(signal, dbsiPtr, lliPtr); + break; + } + case CHECKPOINT_UNDO_READ_FIRST: + ljam(); + rfrReadSecondUndoLogLab(signal, dbsiPtr); + break; + default: + ndbrequire(false); + break; + }//switch +}//Dbtup::execFSREADCONF() + +void Dbtup::execFSREADREF(Signal* signal) +{ + ljamEntry(); + ndbrequire(false); +}//Dbtup::execFSREADREF() + +void Dbtup::execFSWRITECONF(Signal* signal) +{ + DiskBufferSegmentInfoPtr dbsiPtr; + + ljamEntry(); + dbsiPtr.i = signal->theData[0]; + ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo); + switch (dbsiPtr.p->pdxOperation) { + case CHECKPOINT_DATA_WRITE: + ljam(); + lcpSaveDataPageLab(signal, dbsiPtr.p->pdxCheckpointInfoP); + break; + case CHECKPOINT_DATA_WRITE_LAST: + { + CheckpointInfoPtr ciPtr; + ljam(); + ciPtr.i = dbsiPtr.p->pdxCheckpointInfoP; + ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo); + lcpFlushLogLab(signal, ciPtr); + break; + } + case CHECKPOINT_DATA_WRITE_FLUSH: + { + ljam(); + Uint32 ciIndex = dbsiPtr.p->pdxCheckpointInfoP; + freeDiskBufferSegmentRecord(signal, dbsiPtr); + lcpCompletedLab(signal, ciIndex); + break; + } + case CHECKPOINT_UNDO_WRITE_FLUSH: + { + ljam(); + Uint32 ciIndex = dbsiPtr.p->pdxCheckpointInfoP; + freeDiskBufferSegmentRecord(signal, dbsiPtr); + lcpFlushRestartInfoLab(signal, ciIndex); + break; + } + case CHECKPOINT_UNDO_WRITE: + ljam(); + freeDiskBufferSegmentRecord(signal, dbsiPtr); + break; + default: + ndbrequire(false); + break; + }//switch + return; +}//Dbtup::execFSWRITECONF() + +void Dbtup::execFSWRITEREF(Signal* signal) +{ + ljamEntry(); + ndbrequire(false); +}//Dbtup::execFSWRITEREF() + +void Dbtup::execCONTINUEB(Signal* signal) +{ + ljamEntry(); + Uint32 actionType = signal->theData[0]; + Uint32 dataPtr = signal->theData[1]; + switch (actionType) { + case ZSTART_EXEC_UNDO_LOG: + ljam(); + startExecUndoLogLab(signal, dataPtr); + break; + case ZCONT_SAVE_DP: + ljam(); + lcpSaveDataPageLab(signal, dataPtr); + break; + case ZCONT_START_SAVE_CL: + { + CheckpointInfoPtr ciPtr; + + ljam(); + ciPtr.i = dataPtr; + ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo); + lcpSaveCopyListLab(signal, ciPtr); + break; + } + case ZCONT_EXECUTE_LC: + { + LocalLogInfoPtr lliPtr; + DiskBufferSegmentInfoPtr dbsiPtr; + + ljam(); + lliPtr.i = dataPtr; + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); + dbsiPtr.i = lliPtr.p->lliUndoBufferSegmentP; + ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo); + xlcGetNextRecordLab(signal, dbsiPtr, lliPtr); + break; + } + case ZCONT_LOAD_DP: + { + DiskBufferSegmentInfoPtr dbsiPtr; + RestartInfoRecordPtr riPtr; + + ljam(); + riPtr.i = dataPtr; + ptrCheckGuard(riPtr, cnoOfRestartInfoRec, restartInfoRecord); + dbsiPtr.i = riPtr.p->sriDataBufferSegmentP; + ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo); + rfrLoadDataPagesLab(signal, riPtr, dbsiPtr); + break; + } + case ZLOAD_BAL_LCP_TIMER: + ljam(); + clblPageCounter = clblPagesPerTick; + signal->theData[0] = ZLOAD_BAL_LCP_TIMER; + sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 400, 1); + break; + case ZINITIALISE_RECORDS: + ljam(); + initialiseRecordsLab(signal, dataPtr); + break; + case ZREL_FRAG: + ljam(); + releaseFragment(signal, dataPtr); + break; + case ZREPORT_MEMORY_USAGE:{ + ljam(); + static int c_currentMemUsed = 0; + int now = (cnoOfAllocatedPages * 100)/cnoOfPage; + const int thresholds[] = { 100, 90, 80, 0 }; + + Uint32 i = 0; + const Uint32 sz = sizeof(thresholds)/sizeof(thresholds[0]); + for(i = 0; i= thresholds[i]){ + now = thresholds[i]; + break; + } + } + + if(now != c_currentMemUsed){ + reportMemoryUsage(signal, now > c_currentMemUsed ? 1 : -1); + c_currentMemUsed = now; + } + signal->theData[0] = ZREPORT_MEMORY_USAGE; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 2000, 1); + return; + } + case ZBUILD_INDEX: + ljam(); + buildIndex(signal, dataPtr); + break; + default: + ndbrequire(false); + break; + }//switch +}//Dbtup::execTUP_CONTINUEB() + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* ------------------- SYSTEM RESTART MODULE ---------------------- */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ +void Dbtup::execSTTOR(Signal* signal) +{ + ljamEntry(); + Uint32 startPhase = signal->theData[1]; + Uint32 sigKey = signal->theData[6]; + switch (startPhase) { + case ZSTARTPHASE1: + ljam(); + CLEAR_ERROR_INSERT_VALUE; + cownref = calcTupBlockRef(0); + break; + default: + ljam(); + break; + }//switch + signal->theData[0] = sigKey; + signal->theData[1] = 3; + signal->theData[2] = 2; + signal->theData[3] = ZSTARTPHASE1; + signal->theData[4] = 255; + sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 5, JBB); + return; +}//Dbtup::execSTTOR() + +/************************************************************************************************/ +// SIZE_ALTREP INITIALIZE DATA STRUCTURES, FILES AND DS VARIABLES, GET READY FOR EXTERNAL +// CONNECTIONS. +/************************************************************************************************/ +void Dbtup::execSIZEALT_REP(Signal* signal) +{ + BlockReference tsizealtBlockRef; + + ljamEntry(); + tsizealtBlockRef = signal->theData[TupSizeAltReq::IND_BLOCK_REF]; + cnoOfFragrec = signal->theData[TupSizeAltReq::IND_FRAG]; + cnoOfOprec = signal->theData[TupSizeAltReq::IND_OP_RECS]; + // MemorySpaceTuples is specified in 8k pages, divide by 4 for 32k pages + Uint64 noOfWords = (signal->theData[TupSizeAltReq::IND_PAGE] * 2048) + (ZWORDS_ON_PAGE - 1); + Uint64 noOfPages = noOfWords / (Uint64)ZWORDS_ON_PAGE; + cnoOfPage = (Uint32)noOfPages; + initPageRangeSize(signal->theData[TupSizeAltReq::IND_PAGE_RANGE]); + cnoOfTablerec = signal->theData[TupSizeAltReq::IND_TABLE]; + cnoOfTabDescrRec = signal->theData[TupSizeAltReq::IND_TABLE_DESC]; + Uint32 noOfStoredProc = signal->theData[TupSizeAltReq::IND_STORED_PROC]; + + cnoOfTabDescrRec = (cnoOfTabDescrRec & 0xFFFFFFF0) + 16; + c_storedProcPool.setSize(noOfStoredProc); + c_buildIndexPool.setSize(c_noOfBuildIndexRec); + + initRecords(); + czero = 0; + cminusOne = czero - 1; + clastBitMask = 1; + clastBitMask = clastBitMask << 31; + cnoOfLocalLogInfo = 0; + cnoFreeUndoSeg = 0; + + initialiseRecordsLab(signal, 0); +}//Dbtup::execSIZEALT_REP() + +void Dbtup::initRecords() +{ + // Records with dynamic sizes + attrbufrec = (Attrbufrec*)allocRecord("Attrbufrec", + sizeof(Attrbufrec), + cnoOfAttrbufrec); + + checkpointInfo = (CheckpointInfo*)allocRecord("CheckpointInfo", + sizeof(CheckpointInfo), + cnoOfLcpRec); + + diskBufferSegmentInfo = (DiskBufferSegmentInfo*) + allocRecord("DiskBufferSegmentInfo", + sizeof(DiskBufferSegmentInfo), + cnoOfConcurrentWriteOp); + + fragoperrec = (Fragoperrec*)allocRecord("Fragoperrec", + sizeof(Fragoperrec), + cnoOfFragoprec); + + fragrecord = (Fragrecord*)allocRecord("Fragrecord", + sizeof(Fragrecord), + cnoOfFragrec); + + hostBuffer = (HostBuffer*)allocRecord("HostBuffer", + sizeof(HostBuffer), + MAX_NODES); + + localLogInfo = (LocalLogInfo*)allocRecord("LocalLogInfo", + sizeof(LocalLogInfo), + cnoOfParallellUndoFiles); + + operationrec = (Operationrec*)allocRecord("Operationrec", + sizeof(Operationrec), + cnoOfOprec); + + page = (Page*)allocRecord("Page", + sizeof(Page), + cnoOfPage); + + pageRange = (PageRange*)allocRecord("PageRange", + sizeof(PageRange), + cnoOfPageRangeRec); + + pendingFileOpenInfo = (PendingFileOpenInfo*) + allocRecord("PendingFileOpenInfo", + sizeof(PendingFileOpenInfo), + cnoOfConcurrentOpenOp); + + restartInfoRecord = (RestartInfoRecord*) + allocRecord("RestartInfoRecord", + sizeof(RestartInfoRecord), + cnoOfRestartInfoRec); + + // Trigger data + c_triggerPool.setSize(cnoOfTablerec*c_maxTriggersPerTable); + + tablerec = (Tablerec*)allocRecord("Tablerec", + sizeof(Tablerec), + cnoOfTablerec); + + for(unsigned i = 0; ipageWord[0]; + bat[1].nrr = cnoOfPage; + bat[1].ClusterSize = sizeof(Page); + bat[1].bits.q = 13; /* 8192 words/page */ + bat[1].bits.v = 5; + bat[2].WA = &undoPage->undoPageWord[0]; + bat[2].nrr = cnoOfUndoPage; + bat[2].ClusterSize = sizeof(UndoPage); + bat[2].bits.q = 13; /* 8192 words/page */ + bat[2].bits.v = 5; +}//Dbtup::initRecords() + +void Dbtup::initialiseRecordsLab(Signal* signal, Uint32 switchData) +{ + switch (switchData) { + case 0: + ljam(); + initializeHostBuffer(); + break; + case 1: + ljam(); + initializeOperationrec(); + break; + case 2: + ljam(); + initializePage(); + break; + case 3: + ljam(); + initializeUndoPage(); + break; + case 4: + ljam(); + initializeTablerec(); + break; + case 5: + ljam(); + initializeCheckpointInfoRec(); + break; + case 6: + ljam(); + initializeFragrecord(); + break; + case 7: + ljam(); + initializeFragoperrec(); + break; + case 8: + ljam(); + initializePageRange(); + break; + case 9: + ljam(); + initializeTabDescr(); + break; + case 10: + ljam(); + initializeDiskBufferSegmentRecord(); + break; + case 11: + ljam(); + initializeLocalLogInfo(); + break; + case 12: + ljam(); + initializeAttrbufrec(); + break; + case 13: + ljam(); + initializePendingFileOpenInfoRecord(); + break; + case 14: + ljam(); + initializeRestartInfoRec(); + signal->theData[0] = cownref; + sendSignal(CMVMI_REF, GSN_SIZEALT_ACK, signal, 1, JBB); + return; + default: + ndbrequire(false); + break; + }//switch +/******************************************************************************/ +/* SEND REAL-TIME BREAK DURING INITIALISATION OF VARIABLES IN SYSTEM RESTART */ +/******************************************************************************/ + signal->theData[0] = ZINITIALISE_RECORDS; + signal->theData[1] = switchData + 1; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + return; +}//Dbtup::initialiseRecordsLab() + +void Dbtup::execNDB_STTOR(Signal* signal) +{ + ljamEntry(); + cndbcntrRef = signal->theData[0]; + Uint32 ownNodeId = signal->theData[1]; + Uint32 startPhase = signal->theData[2]; + Uint32 data1 = signal->theData[14]; + Uint32 data2 = signal->theData[15]; + switch (startPhase) { + case ZSTARTPHASE1: + ljam(); + cownNodeId = ownNodeId; + cownref = calcTupBlockRef(ownNodeId); + break; + case ZSTARTPHASE2: + ljam(); + break; + case ZSTARTPHASE3: + ljam(); + startphase3Lab(signal, data1, data2); + break; + case ZSTARTPHASE4: + ljam(); + break; + case ZSTARTPHASE6: + ljam(); +/*****************************************/ +/* NOW SET THE DISK WRITE SPEED TO */ +/* PAGES PER TICK AFTER SYSTEM */ +/* RESTART. */ +/*****************************************/ + clblPagesPerTick = clblPagesPerTickAfterSr; + + signal->theData[0] = ZREPORT_MEMORY_USAGE; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 2000, 1); + break; + default: + ljam(); + break; + }//switch + signal->theData[0] = cownref; + sendSignal(cndbcntrRef, GSN_NDB_STTORRY, signal, 1, JBB); +}//Dbtup::execNDB_STTOR() + +void Dbtup::startphase3Lab(Signal* signal, Uint32 config1, Uint32 config2) +{ + if (config1 > 0) { + ljam(); + clblPagesPerTick = config1; + } else { + ljam(); + clblPagesPerTick = 1; + }//if + if (config2 > 0) { + ljam(); + clblPagesPerTickAfterSr = config2; + } else { + ljam(); + clblPagesPerTickAfterSr = 1; + }//if + clblPageCounter = clblPagesPerTick; + signal->theData[0] = ZLOAD_BAL_LCP_TIMER; + sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 100, 1); +}//Dbtup::startphase3Lab() + +void Dbtup::initializeAttrbufrec() +{ + AttrbufrecPtr attrBufPtr; + for (attrBufPtr.i = 0; + attrBufPtr.i < cnoOfAttrbufrec; attrBufPtr.i++) { + ptrAss(attrBufPtr, attrbufrec); + attrBufPtr.p->attrbuf[ZBUF_NEXT] = attrBufPtr.i + 1; + }//for + attrBufPtr.i = cnoOfAttrbufrec - 1; + ptrAss(attrBufPtr, attrbufrec); + attrBufPtr.p->attrbuf[ZBUF_NEXT] = RNIL; + cfirstfreeAttrbufrec = 0; + cnoFreeAttrbufrec = cnoOfAttrbufrec; +}//Dbtup::initializeAttrbufrec() + +void Dbtup::initializeCheckpointInfoRec() +{ + CheckpointInfoPtr checkpointInfoPtr; + for (checkpointInfoPtr.i = 0; + checkpointInfoPtr.i < cnoOfLcpRec; checkpointInfoPtr.i++) { + ptrAss(checkpointInfoPtr, checkpointInfo); + checkpointInfoPtr.p->lcpNextRec = checkpointInfoPtr.i + 1; + }//for + checkpointInfoPtr.i = cnoOfLcpRec - 1; + ptrAss(checkpointInfoPtr, checkpointInfo); + checkpointInfoPtr.p->lcpNextRec = RNIL; + cfirstfreeLcp = 0; +}//Dbtup::initializeCheckpointInfoRec() + +void Dbtup::initializeDiskBufferSegmentRecord() +{ + DiskBufferSegmentInfoPtr diskBufferSegmentPtr; + for (diskBufferSegmentPtr.i = 0; + diskBufferSegmentPtr.i < cnoOfConcurrentWriteOp; diskBufferSegmentPtr.i++) { + ptrAss(diskBufferSegmentPtr, diskBufferSegmentInfo); + diskBufferSegmentPtr.p->pdxNextRec = diskBufferSegmentPtr.i + 1; + diskBufferSegmentPtr.p->pdxBuffertype = NOT_INITIALIZED; + }//for + diskBufferSegmentPtr.i = cnoOfConcurrentWriteOp - 1; + ptrAss(diskBufferSegmentPtr, diskBufferSegmentInfo); + diskBufferSegmentPtr.p->pdxNextRec = RNIL; + cfirstfreePdx = 0; +}//Dbtup::initializeDiskBufferSegmentRecord() + +void Dbtup::initializeFragoperrec() +{ + FragoperrecPtr fragoperPtr; + for (fragoperPtr.i = 0; fragoperPtr.i < cnoOfFragoprec; fragoperPtr.i++) { + ptrAss(fragoperPtr, fragoperrec); + fragoperPtr.p->nextFragoprec = fragoperPtr.i + 1; + }//for + fragoperPtr.i = cnoOfFragoprec - 1; + ptrAss(fragoperPtr, fragoperrec); + fragoperPtr.p->nextFragoprec = RNIL; + cfirstfreeFragopr = 0; +}//Dbtup::initializeFragoperrec() + +void Dbtup::initializeFragrecord() +{ + FragrecordPtr regFragPtr; + for (regFragPtr.i = 0; regFragPtr.i < cnoOfFragrec; regFragPtr.i++) { + ptrAss(regFragPtr, fragrecord); + regFragPtr.p->nextfreefrag = regFragPtr.i + 1; + regFragPtr.p->checkpointVersion = RNIL; + regFragPtr.p->firstusedOprec = RNIL; + regFragPtr.p->fragStatus = IDLE; + }//for + regFragPtr.i = cnoOfFragrec - 1; + ptrAss(regFragPtr, fragrecord); + regFragPtr.p->nextfreefrag = RNIL; + cfirstfreefrag = 0; +}//Dbtup::initializeFragrecord() + +void Dbtup::initializeHostBuffer() +{ + Uint32 hostId; + cpackedListIndex = 0; + for (hostId = 0; hostId < MAX_NODES; hostId++) { + hostBuffer[hostId].inPackedList = false; + hostBuffer[hostId].noOfPacketsTA = 0; + hostBuffer[hostId].noOfPacketsRC = 0; + hostBuffer[hostId].packetLenTA = 0; + hostBuffer[hostId].packetLenRC = 0; + }//for +}//Dbtup::initializeHostBuffer() + +void Dbtup::initializeLocalLogInfo() +{ + LocalLogInfoPtr localLogInfoPtr; + for (localLogInfoPtr.i = 0; + localLogInfoPtr.i < cnoOfParallellUndoFiles; localLogInfoPtr.i++) { + ptrAss(localLogInfoPtr, localLogInfo); + localLogInfoPtr.p->lliActiveLcp = 0; + localLogInfoPtr.p->lliUndoFileHandle = RNIL; + }//for +}//Dbtup::initializeLocalLogInfo() + +void Dbtup::initializeOperationrec() +{ + OperationrecPtr regOpPtr; + for (regOpPtr.i = 0; regOpPtr.i < cnoOfOprec; regOpPtr.i++) { + ptrAss(regOpPtr, operationrec); + regOpPtr.p->firstAttrinbufrec = RNIL; + regOpPtr.p->lastAttrinbufrec = RNIL; + regOpPtr.p->prevOprecInList = RNIL; + regOpPtr.p->nextOprecInList = regOpPtr.i + 1; + regOpPtr.p->optype = ZREAD; + regOpPtr.p->inFragList = ZFALSE; + regOpPtr.p->inActiveOpList = ZFALSE; +/* FOR ABORT HANDLING BEFORE ANY SUCCESSFUL OPERATION */ + regOpPtr.p->transstate = DISCONNECTED; + regOpPtr.p->storedProcedureId = ZNIL; + regOpPtr.p->prevActiveOp = RNIL; + regOpPtr.p->nextActiveOp = RNIL; + regOpPtr.p->tupVersion = ZNIL; + regOpPtr.p->deleteInsertFlag = 0; + }//for + regOpPtr.i = cnoOfOprec - 1; + ptrAss(regOpPtr, operationrec); + regOpPtr.p->nextOprecInList = RNIL; + cfirstfreeOprec = 0; +}//Dbtup::initializeOperationrec() + +void Dbtup::initializePendingFileOpenInfoRecord() +{ + PendingFileOpenInfoPtr pendingFileOpenInfoPtr; + for (pendingFileOpenInfoPtr.i = 0; + pendingFileOpenInfoPtr.i < cnoOfConcurrentOpenOp; pendingFileOpenInfoPtr.i++) { + ptrAss(pendingFileOpenInfoPtr, pendingFileOpenInfo); + pendingFileOpenInfoPtr.p->pfoNextRec = pendingFileOpenInfoPtr.i + 1; + }//for + pendingFileOpenInfoPtr.i = cnoOfConcurrentOpenOp - 1; + ptrAss(pendingFileOpenInfoPtr, pendingFileOpenInfo); + pendingFileOpenInfoPtr.p->pfoNextRec = RNIL; + cfirstfreePfo = 0; +}//Dbtup::initializePendingFileOpenInfoRecord() + +void Dbtup::initializeRestartInfoRec() +{ + RestartInfoRecordPtr restartInfoPtr; + for (restartInfoPtr.i = 0; restartInfoPtr.i < cnoOfRestartInfoRec; restartInfoPtr.i++) { + ptrAss(restartInfoPtr, restartInfoRecord); + restartInfoPtr.p->sriNextRec = restartInfoPtr.i + 1; + }//for + restartInfoPtr.i = cnoOfRestartInfoRec - 1; + ptrAss(restartInfoPtr, restartInfoRecord); + restartInfoPtr.p->sriNextRec = RNIL; + cfirstfreeSri = 0; +}//Dbtup::initializeRestartInfoRec() + +void Dbtup::initializeTablerec() +{ + TablerecPtr regTabPtr; + for (regTabPtr.i = 0; regTabPtr.i < cnoOfTablerec; regTabPtr.i++) { + ljam(); + ptrAss(regTabPtr, tablerec); + initTab(regTabPtr.p); + }//for +}//Dbtup::initializeTablerec() + +void +Dbtup::initTab(Tablerec* const regTabPtr) +{ + for (Uint32 i = 0; i < (2 * NO_OF_FRAG_PER_NODE); i++) { + regTabPtr->fragid[i] = RNIL; + regTabPtr->fragrec[i] = RNIL; + }//for + regTabPtr->readFunctionArray = NULL; + regTabPtr->updateFunctionArray = NULL; + + regTabPtr->tabDescriptor = RNIL; + regTabPtr->attributeGroupDescriptor = RNIL; + regTabPtr->readKeyArray = RNIL; + + regTabPtr->checksumIndicator = false; + regTabPtr->GCPIndicator = false; + + regTabPtr->noOfAttr = 0; + regTabPtr->noOfKeyAttr = 0; + regTabPtr->noOfNewAttr = 0; + regTabPtr->noOfAttributeGroups = 0; + + regTabPtr->tupheadsize = 0; + regTabPtr->tupNullIndex = 0; + regTabPtr->tupNullWords = 0; + regTabPtr->tupChecksumIndex = 0; + regTabPtr->tupGCPIndex = 0; + + regTabPtr->m_dropTable.tabUserPtr = RNIL; + regTabPtr->m_dropTable.tabUserRef = 0; + regTabPtr->tableStatus = NOT_DEFINED; + + // Clear trigger data + if (!regTabPtr->afterInsertTriggers.isEmpty()) + regTabPtr->afterInsertTriggers.release(); + if (!regTabPtr->afterDeleteTriggers.isEmpty()) + regTabPtr->afterDeleteTriggers.release(); + if (!regTabPtr->afterUpdateTriggers.isEmpty()) + regTabPtr->afterUpdateTriggers.release(); + if (!regTabPtr->subscriptionInsertTriggers.isEmpty()) + regTabPtr->subscriptionInsertTriggers.release(); + if (!regTabPtr->subscriptionDeleteTriggers.isEmpty()) + regTabPtr->subscriptionDeleteTriggers.release(); + if (!regTabPtr->subscriptionUpdateTriggers.isEmpty()) + regTabPtr->subscriptionUpdateTriggers.release(); + if (!regTabPtr->constraintUpdateTriggers.isEmpty()) + regTabPtr->constraintUpdateTriggers.release(); + if (!regTabPtr->tuxCustomTriggers.isEmpty()) + regTabPtr->tuxCustomTriggers.release(); +}//Dbtup::initTab() + +void Dbtup::initializeTabDescr() +{ + TableDescriptorPtr regTabDesPtr; + for (Uint32 i = 0; i < 16; i++) { + cfreeTdList[i] = RNIL; + }//for + for (regTabDesPtr.i = 0; regTabDesPtr.i < cnoOfTabDescrRec; regTabDesPtr.i++) { + ptrAss(regTabDesPtr, tableDescriptor); + regTabDesPtr.p->tabDescr = RNIL; + }//for + freeTabDescr(0, cnoOfTabDescrRec); +}//Dbtup::initializeTabDescr() + +void Dbtup::initializeUndoPage() +{ + UndoPagePtr undoPagep; + for (undoPagep.i = 0; + undoPagep.i < cnoOfUndoPage; + undoPagep.i = undoPagep.i + ZUB_SEGMENT_SIZE) { + ptrAss(undoPagep, undoPage); + undoPagep.p->undoPageWord[ZPAGE_NEXT_POS] = undoPagep.i + + ZUB_SEGMENT_SIZE; + cnoFreeUndoSeg++; + }//for + undoPagep.i = cnoOfUndoPage - ZUB_SEGMENT_SIZE; + ptrAss(undoPagep, undoPage); + undoPagep.p->undoPageWord[ZPAGE_NEXT_POS] = RNIL; + cfirstfreeUndoSeg = 0; +}//Dbtup::initializeUndoPage() + +/* ---------------------------------------------------------------- */ +/* ---------------------------------------------------------------- */ +/* --------------- CONNECT/DISCONNECT MODULE ---------------------- */ +/* ---------------------------------------------------------------- */ +/* ---------------------------------------------------------------- */ +void Dbtup::execTUPSEIZEREQ(Signal* signal) +{ + OperationrecPtr regOperPtr; + ljamEntry(); + Uint32 userPtr = signal->theData[0]; + BlockReference userRef = signal->theData[1]; + if (cfirstfreeOprec != RNIL) { + ljam(); + seizeOpRec(regOperPtr); + } else { + ljam(); + signal->theData[0] = userPtr; + signal->theData[1] = ZGET_OPREC_ERROR; + sendSignal(userRef, GSN_TUPSEIZEREF, signal, 2, JBB); + return; + }//if + regOperPtr.p->optype = ZREAD; + initOpConnection(regOperPtr.p); + regOperPtr.p->userpointer = userPtr; + regOperPtr.p->userblockref = userRef; + signal->theData[0] = regOperPtr.p->userpointer; + signal->theData[1] = regOperPtr.i; + sendSignal(userRef, GSN_TUPSEIZECONF, signal, 2, JBB); + return; +}//Dbtup::execTUPSEIZEREQ() + +#define printFragment(t){ for(Uint32 i = 0; i < (2 * NO_OF_FRAG_PER_NODE);i++){\ + ndbout_c("table = %d fragid[%d] = %d fragrec[%d] = %d", \ + t.i, t.p->fragid[i], i, t.p->fragrec[i]); }} + +void Dbtup::execTUPRELEASEREQ(Signal* signal) +{ + OperationrecPtr regOperPtr; + ljamEntry(); + regOperPtr.i = signal->theData[0]; + ptrCheckGuard(regOperPtr, cnoOfOprec, operationrec); + regOperPtr.p->transstate = DISCONNECTED; + regOperPtr.p->nextOprecInList = cfirstfreeOprec; + cfirstfreeOprec = regOperPtr.i; + signal->theData[0] = regOperPtr.p->userpointer; + sendSignal(regOperPtr.p->userblockref, GSN_TUPRELEASECONF, signal, 1, JBB); + return; +}//Dbtup::execTUPRELEASEREQ() + +/* ---------------------------------------------------------------- */ +/* ---------------- FREE_DISK_BUFFER_SEGMENT_RECORD --------------- */ +/* ---------------------------------------------------------------- */ +/* */ +/* THIS ROUTINE DEALLOCATES A DISK SEGMENT AND ITS DATA PAGES */ +/* */ +/* INPUT: DISK_BUFFER_SEGMENT_PTR THE DISK SEGMENT */ +/* */ +/* -----------------------------------------------------------------*/ +void Dbtup::freeDiskBufferSegmentRecord(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr) +{ + switch (dbsiPtr.p->pdxBuffertype) { + case UNDO_PAGES: + case COMMON_AREA_PAGES: + ljam(); + freeUndoBufferPages(signal, dbsiPtr); + break; + case UNDO_RESTART_PAGES: + ljam(); + dbsiPtr.p->pdxDataPage[0] = dbsiPtr.p->pdxUndoBufferSet[0]; + freeUndoBufferPages(signal, dbsiPtr); + dbsiPtr.p->pdxDataPage[0] = dbsiPtr.p->pdxUndoBufferSet[1]; + freeUndoBufferPages(signal, dbsiPtr); + break; + default: + ndbrequire(false); + break; + }//switch + releaseDiskBufferSegmentRecord(dbsiPtr); +}//Dbtup::freeDiskBufferSegmentRecord() + +/* ---------------------------------------------------------------- */ +/* -------------------- FREE_UNDO_BUFFER_PAGES -------------------- */ +/* ---------------------------------------------------------------- */ +/* */ +/* THIS ROUTINE DEALLOCATES A SEGMENT OF UNDO PAGES */ +/* */ +/* INPUT: UNDO_PAGEP POINTER TO FIRST PAGE IN SEGMENT */ +/* */ +/* -----------------------------------------------------------------*/ +void Dbtup::freeUndoBufferPages(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr) +{ + UndoPagePtr undoPagePtr; + + undoPagePtr.i = dbsiPtr.p->pdxDataPage[0]; + ptrCheckGuard(undoPagePtr, cnoOfUndoPage, undoPage); + undoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS] = cfirstfreeUndoSeg; + cfirstfreeUndoSeg = undoPagePtr.i; + cnoFreeUndoSeg++; + if (cnoFreeUndoSeg == ZMIN_PAGE_LIMIT_TUP_COMMITREQ) { + EXECUTE_DIRECT(DBLQH, GSN_TUP_COM_UNBLOCK, signal, 1); + ljamEntry(); + }//if +}//Dbtup::freeUndoBufferPages() + +void Dbtup::releaseCheckpointInfoRecord(CheckpointInfoPtr ciPtr) +{ + ciPtr.p->lcpNextRec = cfirstfreeLcp; + cfirstfreeLcp = ciPtr.i; +}//Dbtup::releaseCheckpointInfoRecord() + +void Dbtup::releaseDiskBufferSegmentRecord(DiskBufferSegmentInfoPtr dbsiPtr) +{ + dbsiPtr.p->pdxNextRec = cfirstfreePdx; + cfirstfreePdx = dbsiPtr.i; +}//Dbtup::releaseDiskBufferSegmentRecord() + +void Dbtup::releaseFragrec(FragrecordPtr regFragPtr) +{ + regFragPtr.p->nextfreefrag = cfirstfreefrag; + cfirstfreefrag = regFragPtr.i; +}//Dbtup::releaseFragrec() + +void Dbtup::releasePendingFileOpenInfoRecord(PendingFileOpenInfoPtr pfoPtr) +{ + pfoPtr.p->pfoNextRec = cfirstfreePfo; + cfirstfreePfo = pfoPtr.i; +}//Dbtup::releasePendingFileOpenInfoRecord() + +void Dbtup::releaseRestartInfoRecord(RestartInfoRecordPtr riPtr) +{ + riPtr.p->sriNextRec = cfirstfreeSri; + cfirstfreeSri = riPtr.i; +}//Dbtup::releaseRestartInfoRecord() + +void Dbtup::seizeCheckpointInfoRecord(CheckpointInfoPtr& ciPtr) +{ + ciPtr.i = cfirstfreeLcp; + ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo); + cfirstfreeLcp = ciPtr.p->lcpNextRec; + ciPtr.p->lcpNextRec = RNIL; +}//Dbtup::seizeCheckpointInfoRecord() + +void Dbtup::seizeDiskBufferSegmentRecord(DiskBufferSegmentInfoPtr& dbsiPtr) +{ + dbsiPtr.i = cfirstfreePdx; + ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo); + cfirstfreePdx = dbsiPtr.p->pdxNextRec; + dbsiPtr.p->pdxNextRec = RNIL; + for (Uint32 i = 0; i < 16; i++) { + dbsiPtr.p->pdxDataPage[i] = RNIL; + }//for + dbsiPtr.p->pdxCheckpointInfoP = RNIL; + dbsiPtr.p->pdxRestartInfoP = RNIL; + dbsiPtr.p->pdxLocalLogInfoP = RNIL; + dbsiPtr.p->pdxFilePage = 0; + dbsiPtr.p->pdxNumDataPages = 0; +}//Dbtup::seizeDiskBufferSegmentRecord() + +void Dbtup::seizeOpRec(OperationrecPtr& regOperPtr) +{ + regOperPtr.i = cfirstfreeOprec; + ptrCheckGuard(regOperPtr, cnoOfOprec, operationrec); + cfirstfreeOprec = regOperPtr.p->nextOprecInList; +}//Dbtup::seizeOpRec() + +void Dbtup::seizePendingFileOpenInfoRecord(PendingFileOpenInfoPtr& pfoiPtr) +{ + pfoiPtr.i = cfirstfreePfo; + ptrCheckGuard(pfoiPtr, cnoOfConcurrentOpenOp, pendingFileOpenInfo); + cfirstfreePfo = pfoiPtr.p->pfoNextRec; + pfoiPtr.p->pfoNextRec = RNIL; +}//Dbtup::seizePendingFileOpenInfoRecord() + +void Dbtup::execSET_VAR_REQ(Signal* signal) +{ + SetVarReq* const setVarReq = (SetVarReq*)signal->getDataPtrSend(); + ConfigParamId var = setVarReq->variable(); + int val = setVarReq->value(); + + switch (var) { + + case NoOfDiskPagesToDiskAfterRestartTUP: + clblPagesPerTick = val; + sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB); + break; + + case NoOfDiskPagesToDiskDuringRestartTUP: + // Valid only during start so value not set. + sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB); + break; + + default: + sendSignal(CMVMI_REF, GSN_SET_VAR_REF, signal, 1, JBB); + } // switch + + +}//execSET_VAR_REQ() + + + + diff --git a/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp b/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp new file mode 100644 index 00000000000..3a074f7fe5b --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp @@ -0,0 +1,576 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include +#include +#include "AttributeOffset.hpp" +#include +#include +#include + +#define ljam() { jamLine(28000 + __LINE__); } +#define ljamEntry() { jamEntryLine(28000 + __LINE__); } + +// methods used by ordered index + +void +Dbtup::execTUP_READ_ATTRS(Signal* signal) +{ + ljamEntry(); + TupReadAttrs* const sig = (TupReadAttrs*)signal->getDataPtrSend(); + TupReadAttrs reqCopy = *sig; + TupReadAttrs* const req = &reqCopy; + req->errorCode = 0; + // get table + TablerecPtr tablePtr; + tablePtr.i = req->tableId; + ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec); + // get fragment + FragrecordPtr fragPtr; + if (req->fragPtrI == RNIL) { + ljam(); + getFragmentrec(fragPtr, req->fragId, tablePtr.p); + ndbrequire(fragPtr.i != RNIL); + req->fragPtrI = fragPtr.i; + } else { + fragPtr.i = req->fragPtrI; + ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord); + ndbrequire(req->fragId == fragPtr.p->fragmentId); + } + // get page + PagePtr pagePtr; + if (req->pageId == RNIL) { + ljam(); + Uint32 fragPageId = req->tupAddr >> MAX_TUPLES_BITS; + Uint32 pageIndex = req->tupAddr & ((1 << MAX_TUPLES_BITS ) - 1); + ndbrequire((pageIndex & 0x1) == 0); + // data returned for original tuple + req->pageId = getRealpid(fragPtr.p, fragPageId); + req->pageOffset = ZPAGE_HEADER_SIZE + (pageIndex >> 1) * tablePtr.p->tupheadsize; + } + pagePtr.i = req->pageId; + ptrCheckGuard(pagePtr, cnoOfPage, page); + Uint32 pageOffset = req->pageOffset; + // search for tuple version if not original + if (! (req->requestInfo & TupReadAttrs::ReadKeys) && + pagePtr.p->pageWord[pageOffset + 1] != req->tupVersion) { + ljam(); + OperationrecPtr opPtr; + opPtr.i = pagePtr.p->pageWord[pageOffset]; + Uint32 loopGuard = 0; + while (true) { + ptrCheckGuard(opPtr, cnoOfOprec, operationrec); + if (opPtr.p->realPageIdC != RNIL) { + pagePtr.i = opPtr.p->realPageIdC; + pageOffset = opPtr.p->pageOffsetC; + ptrCheckGuard(pagePtr, cnoOfPage, page); + if (pagePtr.p->pageWord[pageOffset + 1] == req->tupVersion) { + ljam(); + break; + } + } + ljam(); + // next means before in event order + opPtr.i = opPtr.p->nextActiveOp; + ndbrequire(++loopGuard < (1 << ZTUP_VERSION_BITS)); + } + } + // shared buffer + Uint32* buffer = (Uint32*)sig + TupReadAttrs::SignalLength; + // if request is for keys then we create input section + if (req->requestInfo & TupReadAttrs::ReadKeys) { + ljam(); + buffer[0] = tablePtr.p->noOfKeyAttr; + const Uint32* keyArray = &tableDescriptor[tablePtr.p->readKeyArray].tabDescr; + MEMCOPY_NO_WORDS(&buffer[1], keyArray, tablePtr.p->noOfKeyAttr); + } + Uint32 inBufLen = buffer[0]; + Uint32* inBuffer = &buffer[1]; + Uint32* outBuffer = &buffer[1 + inBufLen]; + Uint32 maxRead = ZATTR_BUFFER_SIZE; + // save globals + TablerecPtr tabptr_old = tabptr; + FragrecordPtr fragptr_old = fragptr; + OperationrecPtr operPtr_old = operPtr; + // new globals + tabptr = tablePtr; + fragptr = fragPtr; + operPtr.i = RNIL; // XXX check later + operPtr.p = NULL; + int ret = readAttributes(pagePtr.p, pageOffset, inBuffer, inBufLen, outBuffer, maxRead); + // restore globals + tabptr = tabptr_old; + fragptr = fragptr_old; + operPtr = operPtr_old; + // check error + if ((Uint32)ret == (Uint32)-1) { + ljam(); + req->errorCode = terrorCode; + } + // copy back + *sig = *req; +} + +void +Dbtup::execTUP_QUERY_TH(Signal* signal) +{ + ljamEntry(); + Operationrec tempOp; + TupQueryTh* const req = (TupQueryTh*)signal->getDataPtrSend(); + Uint32 tableId = req->tableId; + Uint32 fragId = req->fragId; + Uint32 tupAddr = req->tupAddr; + Uint32 req_tupVersion = req->tupVersion; + Uint32 transid1 = req->transId1; + Uint32 transid2 = req->transId2; + Uint32 savePointId = req->savePointId; + Uint32 ret_result = 0; + // get table + TablerecPtr tablePtr; + tablePtr.i = tableId; + ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec); + // get fragment + FragrecordPtr fragPtr; + getFragmentrec(fragPtr, fragId, tablePtr.p); + ndbrequire(fragPtr.i != RNIL); + // get page + PagePtr pagePtr; + Uint32 fragPageId = tupAddr >> MAX_TUPLES_BITS; + Uint32 pageIndex = tupAddr & ((1 << MAX_TUPLES_BITS ) - 1); + + tempOp.fragPageId = fragPageId; + tempOp.pageIndex = pageIndex; + tempOp.transid1 = transid1; + tempOp.transid2 = transid2; + tempOp.savePointId = savePointId; + tempOp.optype = ZREAD; + tempOp.dirtyOp = 1; + if (getPage(pagePtr, &tempOp, fragPtr.p, tablePtr.p)) { + /* + We use the normal getPage which will return the tuple to be used + for this transaction and savepoint id. If its tuple version equals + the requested then we have a visible tuple otherwise not. + */ + jam(); + Uint32 read_tupVersion = pagePtr.p->pageWord[tempOp.pageOffset + 1]; + if (read_tupVersion == req_tupVersion) { + jam(); + ret_result = 1; + } + } + req->returnCode = ret_result; + return; +} + +void +Dbtup::execTUP_STORE_TH(Signal* signal) +{ + ljamEntry(); + TupStoreTh* const sig = (TupStoreTh*)signal->getDataPtrSend(); + TupStoreTh reqCopy = *sig; + TupStoreTh* const req = &reqCopy; + req->errorCode = 0; + ndbrequire(req->tupVersion == 0); + // get table + TablerecPtr tablePtr; + tablePtr.i = req->tableId; + ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec); + // offset to attribute 0 + Uint32 attrDescIndex = tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE); + Uint32 attrDataOffset = AttributeOffset::getOffset(tableDescriptor[attrDescIndex + 1].tabDescr); + // get fragment + FragrecordPtr fragPtr; + if (req->fragPtrI == RNIL) { + ljam(); + getFragmentrec(fragPtr, req->fragId, tablePtr.p); + ndbrequire(fragPtr.i != RNIL); + req->fragPtrI = fragPtr.i; + } else { + fragPtr.i = req->fragPtrI; + ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord); + ndbrequire(req->fragId == fragPtr.p->fragmentId); + } + // handle each case + switch (req->opCode) { + case TupStoreTh::OpRead: + ljam(); + { + PagePtr pagePtr; + if (req->pageId == RNIL) { + ljam(); + Uint32 fragPageId = req->tupAddr >> MAX_TUPLES_BITS; + Uint32 pageIndex = req->tupAddr & ((1 << MAX_TUPLES_BITS ) - 1); + ndbrequire((pageIndex & 0x1) == 0); + req->pageId = getRealpid(fragPtr.p, fragPageId); + req->pageOffset = ZPAGE_HEADER_SIZE + (pageIndex >> 1) * tablePtr.p->tupheadsize; + } + pagePtr.i = req->pageId; + ptrCheckGuard(pagePtr, cnoOfPage, page); + Uint32* data = &pagePtr.p->pageWord[req->pageOffset] + attrDataOffset; + Uint32* buffer = (Uint32*)sig + TupStoreTh::SignalLength; + ndbrequire(req->dataOffset + req->dataSize <= tablePtr.p->tupheadsize); + memcpy(buffer + req->dataOffset, data + req->dataOffset, req->dataSize << 2); + } + break; + case TupStoreTh::OpInsert: + ljam(); + { + PagePtr pagePtr; + if (! allocTh(fragPtr.p, tablePtr.p, NORMAL_PAGE, signal, req->pageOffset, pagePtr)) { + ljam(); + req->errorCode = terrorCode; + break; + } + req->pageId = pagePtr.i; + Uint32 fragPageId = pagePtr.p->pageWord[ZPAGE_FRAG_PAGE_ID_POS]; + Uint32 pageIndex = ((req->pageOffset - ZPAGE_HEADER_SIZE) / tablePtr.p->tupheadsize) << 1; + req->tupAddr = (fragPageId << MAX_TUPLES_BITS) | pageIndex; + ndbrequire(req->dataOffset + req->dataSize <= tablePtr.p->tupheadsize); + Uint32* data = &pagePtr.p->pageWord[req->pageOffset] + attrDataOffset; + Uint32* buffer = (Uint32*)sig + TupStoreTh::SignalLength; + memcpy(data + req->dataOffset, buffer + req->dataOffset, req->dataSize << 2); + } + break; + case TupStoreTh::OpUpdate: + ljam(); + { + PagePtr pagePtr; + if (req->pageId == RNIL) { + ljam(); + Uint32 fragPageId = req->tupAddr >> MAX_TUPLES_BITS; + Uint32 pageIndex = req->tupAddr & ((1 << MAX_TUPLES_BITS ) - 1); + ndbrequire((pageIndex & 0x1) == 0); + req->pageId = getRealpid(fragPtr.p, fragPageId); + req->pageOffset = ZPAGE_HEADER_SIZE + (pageIndex >> 1) * tablePtr.p->tupheadsize; + } + pagePtr.i = req->pageId; + ptrCheckGuard(pagePtr, cnoOfPage, page); + Uint32* data = &pagePtr.p->pageWord[req->pageOffset] + attrDataOffset; + Uint32* buffer = (Uint32*)sig + TupStoreTh::SignalLength; + ndbrequire(req->dataOffset + req->dataSize <= tablePtr.p->tupheadsize); + memcpy(data + req->dataOffset, buffer + req->dataOffset, req->dataSize << 2); + } + break; + case TupStoreTh::OpDelete: + ljam(); + { + PagePtr pagePtr; + if (req->pageId == RNIL) { + ljam(); + Uint32 fragPageId = req->tupAddr >> MAX_TUPLES_BITS; + Uint32 pageIndex = req->tupAddr & ((1 << MAX_TUPLES_BITS ) - 1); + ndbrequire((pageIndex & 0x1) == 0); + req->pageId = getRealpid(fragPtr.p, fragPageId); + req->pageOffset = ZPAGE_HEADER_SIZE + (pageIndex >> 1) * tablePtr.p->tupheadsize; + } + pagePtr.i = req->pageId; + ptrCheckGuard(pagePtr, cnoOfPage, page); + freeTh(fragPtr.p, tablePtr.p, signal, pagePtr.p, req->pageOffset); + // null location + req->tupAddr = (Uint32)-1; + req->pageId = RNIL; + req->pageOffset = 0; + } + break; + } + // copy back + *sig = *req; +} + +// ordered index build + +//#define TIME_MEASUREMENT +#ifdef TIME_MEASUREMENT + static Uint32 time_events; + NDB_TICKS tot_time_passed; + Uint32 number_events; +#endif +void +Dbtup::execBUILDINDXREQ(Signal* signal) +{ + ljamEntry(); +#ifdef TIME_MEASUREMENT + time_events = 0; + tot_time_passed = 0; + number_events = 1; +#endif + // get new operation + BuildIndexPtr buildPtr; + if (! c_buildIndexList.seize(buildPtr)) { + ljam(); + BuildIndexRec buildRec; + memcpy(buildRec.m_request, signal->theData, sizeof(buildRec.m_request)); + buildRec.m_errorCode = BuildIndxRef::Busy; + buildIndexReply(signal, &buildRec); + return; + } + memcpy(buildPtr.p->m_request, signal->theData, sizeof(buildPtr.p->m_request)); + // check + buildPtr.p->m_errorCode = BuildIndxRef::NoError; + do { + const BuildIndxReq* buildReq = (const BuildIndxReq*)buildPtr.p->m_request; + if (buildReq->getTableId() >= cnoOfTablerec) { + ljam(); + buildPtr.p->m_errorCode = BuildIndxRef::InvalidPrimaryTable; + break; + } + TablerecPtr tablePtr; + tablePtr.i = buildReq->getTableId(); + ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec); + if (tablePtr.p->tableStatus != DEFINED) { + ljam(); + buildPtr.p->m_errorCode = BuildIndxRef::InvalidPrimaryTable; + break; + } + if (! DictTabInfo::isOrderedIndex(buildReq->getIndexType())) { + ljam(); + buildPtr.p->m_errorCode = BuildIndxRef::InvalidIndexType; + break; + } + const ArrayList& triggerList = tablePtr.p->tuxCustomTriggers; + TriggerPtr triggerPtr; + triggerList.first(triggerPtr); + while (triggerPtr.i != RNIL) { + if (triggerPtr.p->indexId == buildReq->getIndexId()) { + ljam(); + break; + } + triggerList.next(triggerPtr); + } + if (triggerPtr.i == RNIL) { + ljam(); + // trigger was not created + buildPtr.p->m_errorCode = BuildIndxRef::InternalError; + break; + } + buildPtr.p->m_triggerPtrI = triggerPtr.i; + // set to first tuple position + buildPtr.p->m_fragNo = 0; + buildPtr.p->m_pageId = 0; + buildPtr.p->m_tupleNo = 0; + // start build + buildIndex(signal, buildPtr.i); + return; + } while (0); + // check failed + buildIndexReply(signal, buildPtr.p); + c_buildIndexList.release(buildPtr); +} + +void +Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI) +{ + // get build record + BuildIndexPtr buildPtr; + buildPtr.i = buildPtrI; + c_buildIndexList.getPtr(buildPtr); + const BuildIndxReq* buildReq = (const BuildIndxReq*)buildPtr.p->m_request; + // get table + TablerecPtr tablePtr; + tablePtr.i = buildReq->getTableId(); + ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec); + // get trigger + TriggerPtr triggerPtr; + triggerPtr.i = buildPtr.p->m_triggerPtrI; + c_triggerPool.getPtr(triggerPtr); + ndbrequire(triggerPtr.p->indexId == buildReq->getIndexId()); +#ifdef TIME_MEASUREMENT + MicroSecondTimer start; + MicroSecondTimer stop; + NDB_TICKS time_passed; +#endif + do { + // get fragment + FragrecordPtr fragPtr; + if (buildPtr.p->m_fragNo == 2 * NO_OF_FRAG_PER_NODE) { + ljam(); + // build ready + buildIndexReply(signal, buildPtr.p); + c_buildIndexList.release(buildPtr); + return; + } + ndbrequire(buildPtr.p->m_fragNo < 2 * NO_OF_FRAG_PER_NODE); + fragPtr.i = tablePtr.p->fragrec[buildPtr.p->m_fragNo]; + if (fragPtr.i == RNIL) { + ljam(); + buildPtr.p->m_fragNo++; + buildPtr.p->m_pageId = 0; + buildPtr.p->m_tupleNo = 0; + break; + } + ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord); + // get page + PagePtr pagePtr; + if (buildPtr.p->m_pageId >= fragPtr.p->noOfPages) { + ljam(); + buildPtr.p->m_fragNo++; + buildPtr.p->m_pageId = 0; + buildPtr.p->m_tupleNo = 0; + break; + } + pagePtr.i = getRealpid(fragPtr.p, buildPtr.p->m_pageId); + ptrCheckGuard(pagePtr, cnoOfPage, page); + const Uint32 pageState = pagePtr.p->pageWord[ZPAGE_STATE_POS]; + if (pageState != ZTH_MM_FREE && + pageState != ZTH_MM_FREE_COPY && + pageState != ZTH_MM_FULL && + pageState != ZTH_MM_FULL_COPY) { + ljam(); + buildPtr.p->m_pageId++; + buildPtr.p->m_tupleNo = 0; + break; + } + // get tuple + const Uint32 tupheadsize = tablePtr.p->tupheadsize; + const Uint32 pageOffset = ZPAGE_HEADER_SIZE + + buildPtr.p->m_tupleNo * tupheadsize; + if (pageOffset + tupheadsize > ZWORDS_ON_PAGE) { + ljam(); + buildPtr.p->m_pageId++; + buildPtr.p->m_tupleNo = 0; + break; + } + // skip over free tuple + bool isFree = false; + if (pageState == ZTH_MM_FREE || + pageState == ZTH_MM_FREE_COPY) { + ljam(); + if ((pagePtr.p->pageWord[pageOffset] >> 16) == tupheadsize) { + // verify it really is free XXX far too expensive + Uint32 nextTuple = pagePtr.p->pageWord[ZFREELIST_HEADER_POS] >> 16; + ndbrequire(nextTuple != 0); + while (nextTuple != 0) { + ljam(); + if (nextTuple == pageOffset) { + ljam(); + isFree = true; + break; + } + nextTuple = pagePtr.p->pageWord[nextTuple] & 0xffff; + } + } + } + if (isFree) { + ljam(); + buildPtr.p->m_tupleNo++; + break; + } + OperationrecPtr pageOperPtr; + pageOperPtr.i = pagePtr.p->pageWord[pageOffset]; + Uint32 pageId = buildPtr.p->m_pageId; + Uint32 pageIndex = buildPtr.p->m_tupleNo << 1; + if (pageOperPtr.i != RNIL) { + /* + If there is an ongoing operation on the tuple then it is either a + copy tuple or an original tuple with an ongoing transaction. In + both cases fragPageId and pageIndex refers to the original tuple. + The tuple address stored in TUX will always be the original tuple + but with the tuple version of the tuple we found. + + This is necessary to avoid having to update TUX at abort of + update. If an update aborts then the copy tuple is copied to + the original tuple. The build will however have found that + tuple as a copy tuple. The original tuple is stable and is thus + preferrable to store in TUX. + */ + jam(); + ptrCheckGuard(pageOperPtr, cnoOfOprec, operationrec); + pageId = pageOperPtr.p->fragPageId; + pageIndex = pageOperPtr.p->pageIndex; + }//if + Uint32 tup_version = pagePtr.p->pageWord[pageOffset + 1]; +#ifdef TIME_MEASUREMENT + NdbTick_getMicroTimer(&start); +#endif + // add to index + TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend(); + req->errorCode = RNIL; + req->tableId = tablePtr.i; + req->indexId = triggerPtr.p->indexId; + req->fragId = tablePtr.p->fragid[buildPtr.p->m_fragNo]; + req->tupAddr = (pageId << MAX_TUPLES_BITS) | pageIndex; + req->tupVersion = tup_version; + req->opInfo = TuxMaintReq::OpAdd; + EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ, + signal, TuxMaintReq::SignalLength); + ljamEntry(); + if (req->errorCode != 0) { + switch (req->errorCode) { + case TuxMaintReq::NoMemError: + ljam(); + buildPtr.p->m_errorCode = BuildIndxRef::AllocationFailure; + break; + default: + ndbrequire(false); + break; + } + buildIndexReply(signal, buildPtr.p); + c_buildIndexList.release(buildPtr); + return; + } +#ifdef TIME_MEASUREMENT + NdbTick_getMicroTimer(&stop); + time_passed = NdbTick_getMicrosPassed(start, stop); + if (time_passed < 1000) { + time_events++; + tot_time_passed += time_passed; + if (time_events == number_events) { + NDB_TICKS mean_time_passed = tot_time_passed / (NDB_TICKS)number_events; + ndbout << "Number of events = " << number_events; + ndbout << " Mean time passed = " << mean_time_passed << endl; + number_events <<= 1; + tot_time_passed = (NDB_TICKS)0; + time_events = 0; + }//if + } +#endif + // next tuple + buildPtr.p->m_tupleNo++; + break; + } while (0); + signal->theData[0] = ZBUILD_INDEX; + signal->theData[1] = buildPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); +} + +void +Dbtup::buildIndexReply(Signal* signal, const BuildIndexRec* buildPtrP) +{ + const BuildIndxReq* const buildReq = (const BuildIndxReq*)buildPtrP->m_request; + // conf is subset of ref + BuildIndxRef* rep = (BuildIndxRef*)signal->getDataPtr(); + rep->setUserRef(buildReq->getUserRef()); + rep->setConnectionPtr(buildReq->getConnectionPtr()); + rep->setRequestType(buildReq->getRequestType()); + rep->setTableId(buildReq->getTableId()); + rep->setIndexType(buildReq->getIndexType()); + rep->setIndexId(buildReq->getIndexId()); + // conf + if (buildPtrP->m_errorCode == BuildIndxRef::NoError) { + ljam(); + sendSignal(rep->getUserRef(), GSN_BUILDINDXCONF, + signal, BuildIndxConf::SignalLength, JBB); + return; + } + // ref + rep->setErrorCode(buildPtrP->m_errorCode); + sendSignal(rep->getUserRef(), GSN_BUILDINDXREF, + signal, BuildIndxRef::SignalLength, JBB); +} diff --git a/ndb/src/kernel/blocks/dbtup/DbtupLCP.cpp b/ndb/src/kernel/blocks/dbtup/DbtupLCP.cpp new file mode 100644 index 00000000000..b74b2c00e3e --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupLCP.cpp @@ -0,0 +1,593 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include +#include +#include + +#define ljam() { jamLine(10000 + __LINE__); } +#define ljamEntry() { jamEntryLine(10000 + __LINE__); } + +/* ---------------------------------------------------------------- */ +/* ---------------------------------------------------------------- */ +/* -------------------- LOCAL CHECKPOINT MODULE ------------------- */ +/* ---------------------------------------------------------------- */ +/* ---------------------------------------------------------------- */ +void Dbtup::execTUP_PREPLCPREQ(Signal* signal) +{ + CheckpointInfoPtr ciPtr; + DiskBufferSegmentInfoPtr dbsiPtr; + FragrecordPtr regFragPtr; + LocalLogInfoPtr lliPtr; + TablerecPtr regTabPtr; + + ljamEntry(); + Uint32 userptr = signal->theData[0]; + BlockReference userblockref = signal->theData[1]; + regTabPtr.i = signal->theData[2]; + ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec); + Uint32 fragId = signal->theData[3]; + Uint32 checkpointNumber = signal->theData[4]; + cundoFileVersion = signal->theData[5]; + + getFragmentrec(regFragPtr, fragId, regTabPtr.p); + ndbrequire(regTabPtr.i != RNIL); + seizeCheckpointInfoRecord(ciPtr); + + lliPtr.i = (cundoFileVersion << 2) + (regTabPtr.i & 0x3); + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); + cnoOfDataPagesToDiskWithoutSynch = 0; + + ciPtr.p->lcpDataFileHandle = RNIL; + ciPtr.p->lcpCheckpointVersion = checkpointNumber; + ciPtr.p->lcpLocalLogInfoP = lliPtr.i; + ciPtr.p->lcpFragmentP = regFragPtr.i; /* SET THE FRAGMENT */ + ciPtr.p->lcpFragmentId = fragId; /* SAVE THE FRAGMENT IDENTITY */ + ciPtr.p->lcpTabPtr = regTabPtr.i; /* SET THE TABLE POINTER */ + ciPtr.p->lcpBlockref = userblockref; /* SET THE BLOCK REFERENCE */ + ciPtr.p->lcpUserptr = userptr; /* SET THE USERPOINTER */ + + /***************************************************************/ + /* OPEN THE UNDO FILE FOR WRITE */ + /* UPON FSOPENCONF */ + /***************************************************************/ + if (lliPtr.p->lliActiveLcp == 0) { /* IS THE UNDO LOG FILE OPEN? */ + PendingFileOpenInfoPtr undoPfoiPtr; + UndoPagePtr regUndoPagePtr; + + ljam(); + lliPtr.p->lliPrevRecordId = 0; + lliPtr.p->lliLogFilePage = 0; + lliPtr.p->lliUndoPagesToDiskWithoutSynch = 0; + lliPtr.p->lliUndoWord = ZUNDO_PAGE_HEADER_SIZE; + + seizeUndoBufferSegment(signal, regUndoPagePtr); + seizeDiskBufferSegmentRecord(dbsiPtr); + dbsiPtr.p->pdxBuffertype = UNDO_PAGES; + for (Uint32 i = 0; i < ZUB_SEGMENT_SIZE; i++) { + dbsiPtr.p->pdxDataPage[i] = regUndoPagePtr.i + i; + }//for + dbsiPtr.p->pdxFilePage = lliPtr.p->lliLogFilePage; + lliPtr.p->lliUndoPage = regUndoPagePtr.i; + lliPtr.p->lliUndoBufferSegmentP = dbsiPtr.i; + /* F LEVEL NOT USED */ + Uint32 fileType = 1; /* VERSION */ + fileType = (fileType << 8) | 2; /* .LOCLOG */ + fileType = (fileType << 8) | 6; /* D6 */ + fileType = (fileType << 8) | 0xff; /* DON'T USE P DIRECTORY LEVEL */ + Uint32 fileFlag = 0x301; /* CREATE, WRITE ONLY, TRUNCATE */ + + seizePendingFileOpenInfoRecord(undoPfoiPtr); + undoPfoiPtr.p->pfoOpenType = LCP_UNDO_FILE_WRITE; + undoPfoiPtr.p->pfoCheckpointInfoP = ciPtr.i; + + signal->theData[0] = cownref; + signal->theData[1] = undoPfoiPtr.i; + signal->theData[2] = lliPtr.i; + signal->theData[3] = 0xFFFFFFFF; + signal->theData[4] = cundoFileVersion; + signal->theData[5] = fileType; + signal->theData[6] = fileFlag; + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA); + }//if + /***************************************************************/ + /* OPEN THE DATA FILE FOR WRITE */ + /* THE FILE HANDLE WILL BE SET IN THE CHECKPOINT_INFO_RECORD */ + /* UPON FSOPENCONF */ + /***************************************************************/ + /* OPEN THE DATA FILE IN THE FOLLOWING FORM */ + /* D5/DBTUP/T/F/S.DATA */ + + PendingFileOpenInfoPtr dataPfoiPtr; + + Uint32 fileType = 1; /* VERSION */ + fileType = (fileType << 8) | 0; /* .DATA */ + fileType = (fileType << 8) | 5; /* D5 */ + fileType = (fileType << 8) | 0xff; /* DON'T USE P DIRECTORY LEVEL */ + Uint32 fileFlag = 0x301; /* CREATE, WRITE ONLY, TRUNCATE */ + + seizePendingFileOpenInfoRecord(dataPfoiPtr); /* SEIZE A NEW FILE OPEN INFO */ + if (lliPtr.p->lliActiveLcp == 0) { + ljam(); + dataPfoiPtr.p->pfoOpenType = LCP_DATA_FILE_WRITE_WITH_UNDO; + } else { + ljam(); + dataPfoiPtr.p->pfoOpenType = LCP_DATA_FILE_WRITE; + }//if + dataPfoiPtr.p->pfoCheckpointInfoP = ciPtr.i; + + /* LET'S OPEN THE DATA FILE FOR WRITE */ + /* INCREASE NUMBER OF ACTIVE CHECKPOINTS */ + lliPtr.p->lliActiveLcp = 1; + signal->theData[0] = cownref; + signal->theData[1] = dataPfoiPtr.i; + signal->theData[2] = ciPtr.p->lcpTabPtr; + signal->theData[3] = ciPtr.p->lcpFragmentId; + signal->theData[4] = ciPtr.p->lcpCheckpointVersion; + signal->theData[5] = fileType; + signal->theData[6] = fileFlag; + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA); + return; +}//Dbtup::execTUP_PREPLCPREQ() + +/* ---------------------------------------------------------------- */ +/* ------------------------ START CHECKPOINT --------------------- */ +/* ---------------------------------------------------------------- */ +void Dbtup::execTUP_LCPREQ(Signal* signal) +{ + CheckpointInfoPtr ciPtr; + DiskBufferSegmentInfoPtr dbsiPtr; + FragrecordPtr regFragPtr; + LocalLogInfoPtr lliPtr; + + ljamEntry(); +// Uint32 userptr = signal->theData[0]; +// BlockReference userblockref = signal->theData[1]; + ciPtr.i = signal->theData[2]; + + ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo); + regFragPtr.i = ciPtr.p->lcpFragmentP; + ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord); + +/* ---------------------------------------------------------------- */ +/* ASSIGNING A VALUE DIFFERENT FROM RNIL TO CHECKPOINT VERSION*/ +/* TRIGGERS THAT UNDO LOGGING WILL START FOR THIS FRAGMENT. */ +/* WE ASSIGN IT THE POINTER TO THE CHECKPOINT RECORD FOR */ +/* OPTIMISATION OF THE WRITING OF THE UNDO LOG. */ +/* ---------------------------------------------------------------- */ + regFragPtr.p->checkpointVersion = ciPtr.p->lcpLocalLogInfoP; /* MARK START OF UNDO LOGGING */ + + regFragPtr.p->maxPageWrittenInCheckpoint = getNoOfPages(regFragPtr.p); + regFragPtr.p->minPageNotWrittenInCheckpoint = 0; + ndbrequire(getNoOfPages(regFragPtr.p) > 0); + allocDataBufferSegment(signal, dbsiPtr); + + dbsiPtr.p->pdxNumDataPages = 0; + dbsiPtr.p->pdxFilePage = 1; + ciPtr.p->lcpDataBufferSegmentP = dbsiPtr.i; + dbsiPtr.p->pdxCheckpointInfoP = ciPtr.i; + ciPtr.p->lcpNoOfPages = getNoOfPages(regFragPtr.p); + ciPtr.p->lcpNoCopyPagesAlloc = regFragPtr.p->noCopyPagesAlloc; + ciPtr.p->lcpEmptyPrimPage = regFragPtr.p->emptyPrimPage; + ciPtr.p->lcpThFreeFirst = regFragPtr.p->thFreeFirst; + ciPtr.p->lcpThFreeCopyFirst = regFragPtr.p->thFreeCopyFirst; + lliPtr.i = ciPtr.p->lcpLocalLogInfoP; + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); +/* ---------------------------------------------------------------- */ +/* --- PERFORM A COPY OF THE TABLE DESCRIPTOR FOR THIS FRAGMENT --- */ +/* ---------------------------------------------------------------- */ + cprAddLogHeader(signal, + lliPtr.p, + ZTABLE_DESCRIPTOR, + ciPtr.p->lcpTabPtr, + ciPtr.p->lcpFragmentId); + +/* ---------------------------------------------------------------- */ +/* CONTINUE WITH SAVING ACTIVE OPERATIONS AFTER A REAL-TIME */ +/* BREAK. */ +/* ---------------------------------------------------------------- */ + ciPtr.p->lcpTmpOperPtr = regFragPtr.p->firstusedOprec; + lcpSaveCopyListLab(signal, ciPtr); + return; +}//Dbtup::execTUP_LCPREQ() + +void Dbtup::allocDataBufferSegment(Signal* signal, DiskBufferSegmentInfoPtr& dbsiPtr) +{ + UndoPagePtr regUndoPagePtr; + + seizeDiskBufferSegmentRecord(dbsiPtr); + dbsiPtr.p->pdxBuffertype = COMMON_AREA_PAGES; + ndbrequire(cfirstfreeUndoSeg != RNIL); + if (cnoFreeUndoSeg == ZMIN_PAGE_LIMIT_TUP_COMMITREQ) { + EXECUTE_DIRECT(DBLQH, GSN_TUP_COM_BLOCK, signal, 1); + ljamEntry(); + }//if + cnoFreeUndoSeg--; + ndbrequire(cnoFreeUndoSeg >= 0); + + regUndoPagePtr.i = cfirstfreeUndoSeg; + ptrCheckGuard(regUndoPagePtr, cnoOfUndoPage, undoPage); + cfirstfreeUndoSeg = regUndoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS]; + regUndoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS] = RNIL; + for (Uint32 i = 0; i < ZUB_SEGMENT_SIZE; i++) { + dbsiPtr.p->pdxDataPage[i] = regUndoPagePtr.i + i; + }//for +}//Dbtup::allocDataBufferSegment() + +/* ---------------------------------------------------------------- */ +/* --- PERFORM A COPY OF THE ACTIVE OPERATIONS FOR THIS FRAGMENT -- */ +/* ---------------------------------------------------------------- */ +void Dbtup::lcpSaveCopyListLab(Signal* signal, CheckpointInfoPtr ciPtr) +{ + FragrecordPtr regFragPtr; + LocalLogInfoPtr lliPtr; + OperationrecPtr regOpPtr; + + regFragPtr.i = ciPtr.p->lcpFragmentP; + ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord); + lliPtr.i = ciPtr.p->lcpLocalLogInfoP; + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); + regOpPtr.i = ciPtr.p->lcpTmpOperPtr; + +/* -------------------------------------------------------------------------------- */ +/* TRAVERSE THE ENTIRE BLOCK OF OPERATIONS. CHECK IF THERE ARE EXISTING COPYS OF */ +/* TUPLES IN THE CHECKPOINTED FRAGMENT. SAVE THOSE IN A LIST IN THE FOLLOWING FORM: */ +/* */ +/* SOURCE PAGE */ +/* SOURCE INDEX */ +/* COPY PAGE */ +/* COPY INDEX */ +/* -------------------------------------------------------------------------------- */ + Uint32 loopCount = 0; + while ((regOpPtr.i != RNIL) && (loopCount < 50)) { + ljam(); + ptrCheckGuard(regOpPtr, cnoOfOprec, operationrec); + if (regOpPtr.p->realPageId != RNIL) { +/* ---------------------------------------------------------------- */ +// We ensure that we have actually allocated the tuple header and +// also found it. Otherwise we will fill the undo log with garbage. +/* ---------------------------------------------------------------- */ + if (regOpPtr.p->optype == ZUPDATE) { + ljam(); + if (regOpPtr.p->realPageIdC != RNIL) { +/* ---------------------------------------------------------------- */ +// We ensure that we have actually allocated the tuple header copy. +// Otherwise we will fill the undo log with garbage. +/* ---------------------------------------------------------------- */ + cprAddLogHeader(signal, + lliPtr.p, + ZLCPR_ABORT_UPDATE, + ciPtr.p->lcpTabPtr, + ciPtr.p->lcpFragmentId); + cprAddAbortUpdate(signal, lliPtr.p, regOpPtr.p); + }//if + } else if (regOpPtr.p->optype == ZINSERT) { + ljam(); + cprAddUndoLogRecord(signal, + ZLCPR_ABORT_INSERT, + regOpPtr.p->fragPageId, + regOpPtr.p->pageIndex, + regOpPtr.p->tableRef, + regOpPtr.p->fragId, + regFragPtr.p->checkpointVersion); + } else { + ndbrequire(regOpPtr.p->optype == ZDELETE); + ljam(); + cprAddUndoLogRecord(signal, + ZINDICATE_NO_OP_ACTIVE, + regOpPtr.p->fragPageId, + regOpPtr.p->pageIndex, + regOpPtr.p->tableRef, + regOpPtr.p->fragId, + regFragPtr.p->checkpointVersion); + }//if + }//if + loopCount++;; + regOpPtr.i = regOpPtr.p->nextOprecInList; + }//while + if (regOpPtr.i == RNIL) { + ljam(); + + signal->theData[0] = ciPtr.p->lcpUserptr; + sendSignal(ciPtr.p->lcpBlockref, GSN_TUP_LCPSTARTED, signal, 1, JBA); + + signal->theData[0] = ZCONT_SAVE_DP; + signal->theData[1] = ciPtr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + } else { + ljam(); + ciPtr.p->lcpTmpOperPtr = regOpPtr.i; + signal->theData[0] = ZCONT_START_SAVE_CL; + signal->theData[1] = ciPtr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + }//if +}//Dbtup::lcpSaveCopyListLab() + +/* ---------------------------------------------------------------- */ +/* ------- PERFORM A COPY OF ONE DATAPAGE DURING CHECKPOINT ------- */ +/* ---------------------------------------------------------------- */ +/* THE RANGE OF DATA PAGES IS INCLUDED IN THE CHECKPOINT_INFO_PTR */ +/* LAST_PAGE_TO_BUFFER ELEMENT IS INCREASED UNTIL ALL PAGES ARE */ +/* COPIED TO THE DISK BUFFER. WHEN A DISK BUFFER SEGMENT IS FULL */ +/* IT WILL BE WRITTEN TO DISK (TYPICALLY EACH 8:TH PAGE) */ +/* ---------------------------------------------------------------- */ +void Dbtup::lcpSaveDataPageLab(Signal* signal, Uint32 ciIndex) +{ + CheckpointInfoPtr ciPtr; + DiskBufferSegmentInfoPtr dbsiPtr; + FragrecordPtr regFragPtr; + LocalLogInfoPtr lliPtr; + UndoPagePtr undoCopyPagePtr; + PagePtr pagePtr; + + ciPtr.i = ciIndex; + ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo); + if (ERROR_INSERTED(4000)){ + if (ciPtr.p->lcpTabPtr == c_errorInsert4000TableId) { + // Delay writing of data pages during LCP + ndbout << "Delay writing of data pages during LCP" << endl; + sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 1000, 2); + return; + }//if + }//if + if (clblPageCounter == 0) { + ljam(); + signal->theData[0] = ZCONT_SAVE_DP; + signal->theData[1] = ciPtr.i; + sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 100, 2); + return; + } else { + ljam(); + clblPageCounter--; + }//if + + regFragPtr.i = ciPtr.p->lcpFragmentP; + ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord); + dbsiPtr.i = ciPtr.p->lcpDataBufferSegmentP; + ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo); + + pagePtr.i = getRealpid(regFragPtr.p, regFragPtr.p->minPageNotWrittenInCheckpoint); + ptrCheckGuard(pagePtr, cnoOfPage, page); + ndbrequire(dbsiPtr.p->pdxNumDataPages < 16); + undoCopyPagePtr.i = dbsiPtr.p->pdxDataPage[dbsiPtr.p->pdxNumDataPages]; + ptrCheckGuard(undoCopyPagePtr, cnoOfUndoPage, undoPage); + MEMCOPY_NO_WORDS(&undoCopyPagePtr.p->undoPageWord[0], + &pagePtr.p->pageWord[0], + ZWORDS_ON_PAGE); + regFragPtr.p->minPageNotWrittenInCheckpoint++; + dbsiPtr.p->pdxNumDataPages++; + if (regFragPtr.p->minPageNotWrittenInCheckpoint == regFragPtr.p->maxPageWrittenInCheckpoint) { + /* ---------------------------------------------------------- */ + /* ALL PAGES ARE COPIED, TIME TO FINISH THE CHECKPOINT */ + /* SAVE THE END POSITIONS OF THE LOG RECORDS SINCE ALL DATA */ + /* PAGES ARE NOW SAFE ON DISK AND NO MORE LOGGING WILL APPEAR */ + /* ---------------------------------------------------------- */ + ljam(); + lliPtr.i = ciPtr.p->lcpLocalLogInfoP; + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); + regFragPtr.p->checkpointVersion = RNIL; /* UNDO LOGGING IS SHUT OFF */ + lcpWriteListDataPageSegment(signal, dbsiPtr, ciPtr, false); + dbsiPtr.p->pdxOperation = CHECKPOINT_DATA_WRITE_LAST; + } else if (dbsiPtr.p->pdxNumDataPages == ZDB_SEGMENT_SIZE) { + ljam(); + lcpWriteListDataPageSegment(signal, dbsiPtr, ciPtr, false); + dbsiPtr.p->pdxOperation = CHECKPOINT_DATA_WRITE; + } else { + ljam(); + signal->theData[0] = ZCONT_SAVE_DP; + signal->theData[1] = ciPtr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + }//if +}//Dbtup::lcpSaveDataPageLab() + +void Dbtup::lcpWriteListDataPageSegment(Signal* signal, + DiskBufferSegmentInfoPtr dbsiPtr, + CheckpointInfoPtr ciPtr, + bool flushFlag) +{ + Uint32 flags = 1; + cnoOfDataPagesToDiskWithoutSynch += dbsiPtr.p->pdxNumDataPages; + if ((cnoOfDataPagesToDiskWithoutSynch > MAX_PAGES_WITHOUT_SYNCH) || + (flushFlag)) { + ljam(); +/* ---------------------------------------------------------------- */ +// To avoid synching too big chunks at a time we synch after writing +// a certain number of data pages. (e.g. 2 MBytes). +/* ---------------------------------------------------------------- */ + cnoOfDataPagesToDiskWithoutSynch = 0; + flags |= 0x10; //Set synch flag unconditionally + }//if + signal->theData[0] = ciPtr.p->lcpDataFileHandle; + signal->theData[1] = cownref; + signal->theData[2] = dbsiPtr.i; + signal->theData[3] = flags; + signal->theData[4] = ZBASE_ADDR_UNDO_WORD; + signal->theData[5] = dbsiPtr.p->pdxNumDataPages; + signal->theData[6] = dbsiPtr.p->pdxDataPage[0]; + signal->theData[7] = dbsiPtr.p->pdxFilePage; + sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal, 8, JBA); + + dbsiPtr.p->pdxFilePage += dbsiPtr.p->pdxNumDataPages; + dbsiPtr.p->pdxNumDataPages = 0; +}//Dbtup::lcpWriteListDataPageSegment() + +void Dbtup::lcpFlushLogLab(Signal* signal, CheckpointInfoPtr ciPtr) +{ + DiskBufferSegmentInfoPtr oldDbsiPtr; + LocalLogInfoPtr lliPtr; + UndoPagePtr oldUndoPagePtr; + UndoPagePtr newUndoPagePtr; + + lliPtr.i = ciPtr.p->lcpLocalLogInfoP; + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); + oldDbsiPtr.i = lliPtr.p->lliUndoBufferSegmentP; + ptrCheckGuard(oldDbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo); + oldDbsiPtr.p->pdxNumDataPages++; + if (clblPageCounter > 0) { + ljam(); + clblPageCounter--; + }//if + oldUndoPagePtr.i = lliPtr.p->lliUndoPage; + ptrCheckGuard(oldUndoPagePtr, cnoOfUndoPage, undoPage); + lcpWriteUndoSegment(signal, lliPtr.p, true); + oldDbsiPtr.p->pdxOperation = CHECKPOINT_UNDO_WRITE_FLUSH; + oldDbsiPtr.p->pdxCheckpointInfoP = ciPtr.i; + +/* ---------------------------------------------------------------- */ +/* SINCE LAST PAGE SENT TO DISK WAS NOT FULL YET WE COPY IT */ +/* TO THE NEW LAST PAGE. */ +/* ---------------------------------------------------------------- */ + newUndoPagePtr.i = lliPtr.p->lliUndoPage; + ptrCheckGuard(newUndoPagePtr, cnoOfUndoPage, undoPage); + ndbrequire(lliPtr.p->lliUndoWord < ZWORDS_ON_PAGE); + MEMCOPY_NO_WORDS(&newUndoPagePtr.p->undoPageWord[0], + &oldUndoPagePtr.p->undoPageWord[0], + lliPtr.p->lliUndoWord); +}//Dbtup::lcpFlushLogLab() + +void Dbtup::lcpFlushRestartInfoLab(Signal* signal, Uint32 ciIndex) +{ + CheckpointInfoPtr ciPtr; + DiskBufferSegmentInfoPtr dbsiPtr; + LocalLogInfoPtr lliPtr; + UndoPagePtr undoCopyPagePtr; + + ciPtr.i = ciIndex; + ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo); + + lliPtr.i = ciPtr.p->lcpLocalLogInfoP; + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); + dbsiPtr.i = ciPtr.p->lcpDataBufferSegmentP; + ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo); + undoCopyPagePtr.i = dbsiPtr.p->pdxDataPage[0]; /* UNDO INFO STORED AT PAGE 0 */ + ptrCheckGuard(undoCopyPagePtr, cnoOfUndoPage, undoPage); + ndbrequire(ciPtr.p->lcpNoOfPages > 0); + undoCopyPagePtr.p->undoPageWord[ZSRI_NO_OF_FRAG_PAGES_POS] = ciPtr.p->lcpNoOfPages; + undoCopyPagePtr.p->undoPageWord[ZSRI_NO_COPY_PAGES_ALLOC] = ciPtr.p->lcpNoCopyPagesAlloc; + undoCopyPagePtr.p->undoPageWord[ZSRI_EMPTY_PRIM_PAGE] = ciPtr.p->lcpEmptyPrimPage; + undoCopyPagePtr.p->undoPageWord[ZSRI_TH_FREE_FIRST] = ciPtr.p->lcpThFreeFirst; + undoCopyPagePtr.p->undoPageWord[ZSRI_TH_FREE_COPY_FIRST] = ciPtr.p->lcpThFreeCopyFirst; + undoCopyPagePtr.p->undoPageWord[ZSRI_UNDO_LOG_END_REC_ID] = lliPtr.p->lliPrevRecordId; + undoCopyPagePtr.p->undoPageWord[ZSRI_UNDO_FILE_VER] = cundoFileVersion; + if (lliPtr.p->lliUndoWord == ZUNDO_PAGE_HEADER_SIZE) { + ljam(); + undoCopyPagePtr.p->undoPageWord[ZSRI_UNDO_LOG_END_PAGE_ID] = lliPtr.p->lliLogFilePage - 1; + } else { + ljam(); + undoCopyPagePtr.p->undoPageWord[ZSRI_UNDO_LOG_END_PAGE_ID] = lliPtr.p->lliLogFilePage; + }//if + dbsiPtr.p->pdxNumDataPages = 1; + dbsiPtr.p->pdxFilePage = 0; + if (clblPageCounter > 0) { + ljam(); + clblPageCounter--; + }//if + lcpWriteListDataPageSegment(signal, dbsiPtr, ciPtr, true); + dbsiPtr.p->pdxOperation = CHECKPOINT_DATA_WRITE_FLUSH; + return; +}//Dbtup::lcpFlushRestartInfoLab() + +void Dbtup::lcpCompletedLab(Signal* signal, Uint32 ciIndex) +{ + CheckpointInfoPtr ciPtr; + PendingFileOpenInfoPtr pfoiPtr; +/* ---------------------------------------------------------------------- */ +/* INSERT CODE TO CLOSE DATA FILE HERE. DO THIS BEFORE SEND CONF */ +/* ---------------------------------------------------------------------- */ + ciPtr.i = ciIndex; + ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo); + + seizePendingFileOpenInfoRecord(pfoiPtr); + pfoiPtr.p->pfoOpenType = LCP_DATA_FILE_CLOSE; + pfoiPtr.p->pfoCheckpointInfoP = ciPtr.i; + + signal->theData[0] = ciPtr.p->lcpDataFileHandle; + signal->theData[1] = cownref; + signal->theData[2] = pfoiPtr.i; + signal->theData[3] = 0; + sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA); + return; +}//Dbtup::lcpCompletedLab() + +void Dbtup::lcpClosedDataFileLab(Signal* signal, CheckpointInfoPtr ciPtr) +{ + signal->theData[0] = ciPtr.p->lcpUserptr; + sendSignal(ciPtr.p->lcpBlockref, GSN_TUP_LCPCONF, signal, 1, JBB); + releaseCheckpointInfoRecord(ciPtr); + return; +}//Dbtup::lcpClosedDataFileLab() + +/* ---------------------------------------------------------------------- */ +/* LCP END IS THE LAST STEP IN THE LCP PROCESS IT WILL CLOSE THE LOGFILES */ +/* AND RELEASE THE ALLOCATED CHECKPOINT_INFO_RECORDS */ +/* ---------------------------------------------------------------------- */ +void Dbtup::execEND_LCPREQ(Signal* signal) +{ + DiskBufferSegmentInfoPtr dbsiPtr; + LocalLogInfoPtr lliPtr; + PendingFileOpenInfoPtr pfoiPtr; + + ljamEntry(); + clqhUserpointer = signal->theData[0]; + clqhBlockref = signal->theData[1]; + for (lliPtr.i = 0; lliPtr.i < 16; lliPtr.i++) { + ljam(); + ptrAss(lliPtr, localLogInfo); + if (lliPtr.p->lliActiveLcp > 0) { + ljam(); + dbsiPtr.i = lliPtr.p->lliUndoBufferSegmentP; + ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo); + freeDiskBufferSegmentRecord(signal, dbsiPtr); + + seizePendingFileOpenInfoRecord(pfoiPtr); /* SEIZE A NEW FILE OPEN INFO */ + pfoiPtr.p->pfoOpenType = LCP_UNDO_FILE_CLOSE; + pfoiPtr.p->pfoCheckpointInfoP = lliPtr.i; + + signal->theData[0] = lliPtr.p->lliUndoFileHandle; + signal->theData[1] = cownref; + signal->theData[2] = pfoiPtr.i; + signal->theData[3] = 0; + sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA); + lliPtr.p->lliActiveLcp = 0; + }//if + }//for + return; +}//Dbtup::execEND_LCPREQ() + +void Dbtup::lcpEndconfLab(Signal* signal) +{ + LocalLogInfoPtr lliPtr; + for (lliPtr.i = 0; lliPtr.i < 16; lliPtr.i++) { + ljam(); + ptrAss(lliPtr, localLogInfo); + if (lliPtr.p->lliUndoFileHandle != RNIL) { + ljam(); +/* ---------------------------------------------------------------------- */ +/* WAIT UNTIL ALL LOG FILES HAVE BEEN CLOSED. */ +/* ---------------------------------------------------------------------- */ + return; + }//if + }//for + signal->theData[0] = clqhUserpointer; + sendSignal(clqhBlockref, GSN_END_LCPCONF, signal, 1, JBB); + return; +}//Dbtup::lcpEndconfLab() + diff --git a/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp b/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp new file mode 100644 index 00000000000..887f82308d6 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp @@ -0,0 +1,597 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include +#include +#include +#include +#include +#include +#include "AttributeOffset.hpp" + +#define ljam() { jamLine(20000 + __LINE__); } +#define ljamEntry() { jamEntryLine(20000 + __LINE__); } + +/* ---------------------------------------------------------------- */ +/* ---------------------------------------------------------------- */ +/* --------------- ADD/DROP FRAGMENT TABLE MODULE ----------------- */ +/* ---------------------------------------------------------------- */ +/* ---------------------------------------------------------------- */ +void Dbtup::execTUPFRAGREQ(Signal* signal) +{ + FragoperrecPtr fragOperPtr; + FragrecordPtr regFragPtr; + TablerecPtr regTabPtr; + + ljamEntry(); + Uint32 userptr = signal->theData[0]; + Uint32 userblockref = signal->theData[1]; + Uint32 reqinfo = signal->theData[2]; + regTabPtr.i = signal->theData[3]; + Uint32 noOfAttributes = signal->theData[4]; + Uint32 fragId = signal->theData[5]; + Uint32 noOfNullAttr = signal->theData[7]; + Uint32 schemaVersion = signal->theData[8]; + Uint32 noOfKeyAttr = signal->theData[9]; + + Uint32 noOfNewAttr = signal->theData[10]; + Uint32 checksumIndicator = signal->theData[11]; + Uint32 noOfAttributeGroups = signal->theData[12]; + Uint32 globalCheckpointIdIndicator = signal->theData[13]; + + ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec); + if (cfirstfreeFragopr == RNIL) { + ljam(); + signal->theData[0] = userptr; + signal->theData[1] = ZNOFREE_FRAGOP_ERROR; + sendSignal(userblockref, GSN_TUPFRAGREF, signal, 2, JBB); + return; + }//if + seizeFragoperrec(fragOperPtr); + + fragOperPtr.p->nextFragoprec = RNIL; + fragOperPtr.p->lqhBlockrefFrag = userblockref; + fragOperPtr.p->lqhPtrFrag = userptr; + fragOperPtr.p->fragidFrag = fragId; + fragOperPtr.p->tableidFrag = regTabPtr.i; + fragOperPtr.p->attributeCount = noOfAttributes; + fragOperPtr.p->freeNullBit = noOfNullAttr; + fragOperPtr.p->noOfNewAttrCount = noOfNewAttr; + + ndbrequire(reqinfo == ZADDFRAG); + + getFragmentrec(regFragPtr, fragId, regTabPtr.p); + if (regFragPtr.i != RNIL) { + ljam(); + terrorCode = ZEXIST_FRAG_ERROR; /* THE FRAGMENT ALREADY EXIST */ + fragrefuse1Lab(signal, fragOperPtr); + return; + }//if + if (cfirstfreefrag != RNIL) { + ljam(); + seizeFragrecord(regFragPtr); + } else { + ljam(); + terrorCode = ZFULL_FRAGRECORD_ERROR; + fragrefuse1Lab(signal, fragOperPtr); + return; + }//if + initFragRange(regFragPtr.p); + if (!addfragtotab(regTabPtr.p, fragId, regFragPtr.i)) { + ljam(); + terrorCode = ZNO_FREE_TAB_ENTRY_ERROR; + fragrefuse2Lab(signal, fragOperPtr, regFragPtr); + return; + }//if + if (cfirstfreerange == RNIL) { + ljam(); + terrorCode = ZNO_FREE_PAGE_RANGE_ERROR; + fragrefuse3Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId); + return; + }//if + + regFragPtr.p->emptyPrimPage = RNIL; + regFragPtr.p->thFreeFirst = RNIL; + regFragPtr.p->thFreeCopyFirst = RNIL; + regFragPtr.p->noCopyPagesAlloc = 0; + regFragPtr.p->fragTableId = regTabPtr.i; + regFragPtr.p->fragmentId = fragId; + regFragPtr.p->checkpointVersion = RNIL; + + Uint32 noAllocatedPages = 2; + noAllocatedPages = allocFragPages(regFragPtr.p, noAllocatedPages); + + if (noAllocatedPages == 0) { + ljam(); + terrorCode = ZNO_PAGES_ALLOCATED_ERROR; + fragrefuse3Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId); + return; + }//if + + if (regTabPtr.p->tableStatus == NOT_DEFINED) { + ljam(); +//------------------------------------------------------------------------------------- +// We are setting up references to the header of the tuple. +// Active operation This word contains a reference to the operation active on the tuple +// at the moment. RNIL means no one active at all. Not optional. +// Tuple version Uses only low 16 bits. Not optional. +// Checksum The third header word is optional and contains a checksum of the +// tuple header. +// Null-bits A number of words to contain null bits for all non-dynamic attributes. +// Each word contains upto 32 null bits. Each time a new word is needed +// we allocate the complete word. Zero nullable attributes means that +// there is no word at all +// Global Checkpoint id +// This word is optional. When used it is stored as a 32-bit unsigned +// attribute with attribute identity 0. Thus the kernel assumes that +// this is the first word after the header. +//------------------------------------------------------------------------------------- + fragOperPtr.p->definingFragment = true; + regTabPtr.p->tableStatus = DEFINING; + regTabPtr.p->checksumIndicator = (checksumIndicator != 0 ? true : false); + regTabPtr.p->GCPIndicator = (globalCheckpointIdIndicator != 0 ? true : false); + + regTabPtr.p->tupChecksumIndex = 2; + regTabPtr.p->tupNullIndex = 2 + (checksumIndicator != 0 ? 1 : 0); + regTabPtr.p->tupNullWords = (noOfNullAttr + 31) >> 5; + regTabPtr.p->tupGCPIndex = regTabPtr.p->tupNullIndex + regTabPtr.p->tupNullWords; + regTabPtr.p->tupheadsize = regTabPtr.p->tupGCPIndex; + + regTabPtr.p->noOfKeyAttr = noOfKeyAttr; + regTabPtr.p->noOfAttr = noOfAttributes; + regTabPtr.p->noOfNewAttr = noOfNewAttr; + regTabPtr.p->noOfNullAttr = noOfNullAttr; + regTabPtr.p->noOfAttributeGroups = noOfAttributeGroups; + + regTabPtr.p->notNullAttributeMask.clear(); + + Uint32 tableDescriptorRef = allocTabDescr(noOfAttributes, noOfKeyAttr, noOfAttributeGroups); + if (tableDescriptorRef == RNIL) { + ljam(); + fragrefuse4Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId); + return; + }//if + setUpDescriptorReferences(tableDescriptorRef, regTabPtr.p); + } else { + ljam(); + fragOperPtr.p->definingFragment = false; + }//if + signal->theData[0] = fragOperPtr.p->lqhPtrFrag; + signal->theData[1] = fragOperPtr.i; + signal->theData[2] = regFragPtr.i; + signal->theData[3] = fragId; + sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUPFRAGCONF, signal, 4, JBB); + return; +}//Dbtup::execTUPFRAGREQ() + +/* -------------------------------------------------------------------- */ +/* ------------------------- ADDFRAGTOTAB ----------------------------- */ +/* PUTS A FRAGMENT POINTER AND FID IN THE TABLE ARRAY OF THE TID RECORD */ +/* -------------------------------------------------------------------- */ +bool Dbtup::addfragtotab(Tablerec* const regTabPtr, Uint32 fragId, Uint32 fragIndex) +{ + for (Uint32 i = 0; i < (2 * NO_OF_FRAG_PER_NODE); i++) { + ljam(); + if (regTabPtr->fragid[i] == RNIL) { + ljam(); + regTabPtr->fragid[i] = fragId; + regTabPtr->fragrec[i] = fragIndex; + return true; + }//if + }//for + return false; +}//Dbtup::addfragtotab() + +void Dbtup::getFragmentrec(FragrecordPtr& regFragPtr, Uint32 fragId, Tablerec* const regTabPtr) +{ + for (Uint32 i = 0; i < (2 * NO_OF_FRAG_PER_NODE); i++) { + ljam(); + if (regTabPtr->fragid[i] == fragId) { + ljam(); +/* ---------------------------------------------------------------- */ +/* A FRAGMENT RECORD HAVE BEEN FOUND FOR THIS OPERATION. */ +/* ---------------------------------------------------------------- */ + regFragPtr.i = regTabPtr->fragrec[i]; + ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord); + return; + }//if + }//for + regFragPtr.i = RNIL; + ptrNull(regFragPtr); +}//Dbtup::getFragmentrec() + +void Dbtup::seizeFragrecord(FragrecordPtr& regFragPtr) +{ + regFragPtr.i = cfirstfreefrag; + ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord); + cfirstfreefrag = regFragPtr.p->nextfreefrag; + regFragPtr.p->nextfreefrag = RNIL; +}//Dbtup::seizeFragrecord() + +/* ---------------------------------------------------------------- */ +/* SEIZE A FRAGMENT OPERATION RECORD */ +/* ---------------------------------------------------------------- */ +void Dbtup::seizeFragoperrec(FragoperrecPtr& fragOperPtr) +{ + fragOperPtr.i = cfirstfreeFragopr; + ptrCheckGuard(fragOperPtr, cnoOfFragoprec, fragoperrec); + cfirstfreeFragopr = fragOperPtr.p->nextFragoprec; + fragOperPtr.p->nextFragoprec = RNIL; +}//Dbtup::seizeFragoperrec() + +/* **************************************************************** */ +/* ************** TUP_ADD_ATTRREQ ****************** */ +/* **************************************************************** */ +void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal) +{ + FragrecordPtr regFragPtr; + FragoperrecPtr fragOperPtr; + TablerecPtr regTabPtr; + + ljamEntry(); + fragOperPtr.i = signal->theData[0]; + ptrCheckGuard(fragOperPtr, cnoOfFragoprec, fragoperrec); + Uint32 attrId = signal->theData[2]; + Uint32 attrDescriptor = signal->theData[3]; + + regTabPtr.i = fragOperPtr.p->tableidFrag; + ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec); + + Uint32 fragId = fragOperPtr.p->fragidFrag; + + getFragmentrec(regFragPtr, fragId, regTabPtr.p); + ndbrequire(regFragPtr.i != RNIL); + + ndbrequire(fragOperPtr.p->attributeCount > 0); + fragOperPtr.p->attributeCount--; + + if ((regTabPtr.p->tableStatus == DEFINING) && + (fragOperPtr.p->definingFragment)) { + ljam(); + Uint32 firstTabDesIndex = regTabPtr.p->tabDescriptor + (attrId * ZAD_SIZE); + setTabDescrWord(firstTabDesIndex, attrDescriptor); + Uint32 attrLen = AttributeDescriptor::getSize(attrDescriptor); + Uint32 nullBitPos = 0; /* Default pos for NOT NULL attributes */ + if (AttributeDescriptor::getNullable(attrDescriptor)) { + if (!AttributeDescriptor::getDynamic(attrDescriptor)) { + ljam(); /* NULL ATTR */ + fragOperPtr.p->freeNullBit--; /* STORE NULL BIT POSTITION */ + nullBitPos = fragOperPtr.p->freeNullBit; + ndbrequire(fragOperPtr.p->freeNullBit < ZNIL); /* Check not below zero */ + }//if + } else { + ljam(); + regTabPtr.p->notNullAttributeMask.set(attrId); + }//if + + Uint32 attrDes2 = 0; + if (!AttributeDescriptor::getDynamic(attrDescriptor)) { + ljam(); + Uint32 attributePos = regTabPtr.p->tupheadsize; + switch (AttributeDescriptor::getArrayType(attrDescriptor)) { + case 1: + case 2: + { + ljam(); + Uint32 bitsUsed = AttributeDescriptor::getArraySize(attrDescriptor) * (1 << attrLen); + regTabPtr.p->tupheadsize += ((bitsUsed + 31) >> 5); + break; + } + default: + ndbrequire(false); + break; + }//switch + AttributeOffset::setOffset(attrDes2, attributePos); + AttributeOffset::setNullFlagPos(attrDes2, nullBitPos); + } else { + ndbrequire(false); + }//if + setTabDescrWord(firstTabDesIndex + 1, attrDes2); + + if (regTabPtr.p->tupheadsize > MAX_TUPLE_SIZE_IN_WORDS) { + ljam(); + terrorCode = ZTOO_LARGE_TUPLE_ERROR; + addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId); + return; + }//if + if ((fragOperPtr.p->attributeCount == 0) && + (fragOperPtr.p->freeNullBit != 0)) { + ljam(); + terrorCode = ZINCONSISTENT_NULL_ATTRIBUTE_COUNT; + addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId); + return; + }//if + }//if +/* **************************************************************** */ +/* ************** TUP_ADD_ATTCONF ****************** */ +/* **************************************************************** */ + signal->theData[0] = fragOperPtr.p->lqhPtrFrag; + sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUP_ADD_ATTCONF, signal, 1, JBB); + if (fragOperPtr.p->attributeCount > 0) { + ljam(); + return; /* EXIT AND WAIT FOR MORE */ + }//if + regFragPtr.p->fragStatus = ACTIVE; + if (regTabPtr.p->tableStatus == DEFINING) { + ljam(); + setUpQueryRoutines(regTabPtr.p); + setUpKeyArray(regTabPtr.p); + regTabPtr.p->tableStatus = DEFINED; + }//if + releaseFragoperrec(fragOperPtr); + return; +}//Dbtup::execTUP_ADD_ATTRREQ() + +void Dbtup::setUpDescriptorReferences(Uint32 descriptorReference, + Tablerec* const regTabPtr) +{ + Uint32 noOfAttributes = regTabPtr->noOfAttr; + descriptorReference += ZTD_SIZE; + ReadFunction * tmp = (ReadFunction*)&tableDescriptor[descriptorReference].tabDescr; + regTabPtr->readFunctionArray = tmp; + regTabPtr->updateFunctionArray = (UpdateFunction*)(tmp + noOfAttributes); + + TableDescriptor * start = &tableDescriptor[descriptorReference]; + TableDescriptor * end = (TableDescriptor*)(tmp + 2 * noOfAttributes); + regTabPtr->readKeyArray = descriptorReference + (end - start); + regTabPtr->attributeGroupDescriptor = regTabPtr->readKeyArray + regTabPtr->noOfKeyAttr; + regTabPtr->tabDescriptor = regTabPtr->attributeGroupDescriptor + regTabPtr->noOfAttributeGroups; +}//Dbtup::setUpDescriptorReferences() + +Uint32 +Dbtup::sizeOfReadFunction() +{ + ReadFunction* tmp = (ReadFunction*)&tableDescriptor[0]; + TableDescriptor* start = &tableDescriptor[0]; + TableDescriptor * end = (TableDescriptor*)(tmp + 1); + return (Uint32)(end - start); +}//Dbtup::sizeOfReadFunction() + +void Dbtup::setUpKeyArray(Tablerec* const regTabPtr) +{ + ndbrequire((regTabPtr->readKeyArray + regTabPtr->noOfKeyAttr) < cnoOfTabDescrRec); + Uint32* keyArray = &tableDescriptor[regTabPtr->readKeyArray].tabDescr; + Uint32 countKeyAttr = 0; + for (Uint32 i = 0; i < regTabPtr->noOfAttr; i++) { + ljam(); + Uint32 refAttr = regTabPtr->tabDescriptor + (i * ZAD_SIZE); + Uint32 attrDescriptor = getTabDescrWord(refAttr); + if (AttributeDescriptor::getPrimaryKey(attrDescriptor)) { + ljam(); + AttributeHeader::init(&keyArray[countKeyAttr], i, 0); + countKeyAttr++; + }//if + }//for + ndbrequire(countKeyAttr == regTabPtr->noOfKeyAttr); +}//Dbtup::setUpKeyArray() + +void Dbtup::addattrrefuseLab(Signal* signal, + FragrecordPtr regFragPtr, + FragoperrecPtr fragOperPtr, + Tablerec* const regTabPtr, + Uint32 fragId) +{ + releaseFragPages(regFragPtr.p); + deleteFragTab(regTabPtr, fragId); + releaseFragrec(regFragPtr); + releaseTabDescr(regTabPtr); + initTab(regTabPtr); + + signal->theData[0] = fragOperPtr.p->lqhPtrFrag; + signal->theData[1] = terrorCode; + sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUP_ADD_ATTRREF, signal, 2, JBB); + releaseFragoperrec(fragOperPtr); + return; +}//Dbtup::addattrrefuseLab() + +void Dbtup::fragrefuse4Lab(Signal* signal, + FragoperrecPtr fragOperPtr, + FragrecordPtr regFragPtr, + Tablerec* const regTabPtr, + Uint32 fragId) +{ + releaseFragPages(regFragPtr.p); + fragrefuse3Lab(signal, fragOperPtr, regFragPtr, regTabPtr, fragId); + initTab(regTabPtr); + return; +}//Dbtup::fragrefuse4Lab() + +void Dbtup::fragrefuse3Lab(Signal* signal, + FragoperrecPtr fragOperPtr, + FragrecordPtr regFragPtr, + Tablerec* const regTabPtr, + Uint32 fragId) +{ + fragrefuse2Lab(signal, fragOperPtr, regFragPtr); + deleteFragTab(regTabPtr, fragId); + return; +}//Dbtup::fragrefuse3Lab() + +void Dbtup::fragrefuse2Lab(Signal* signal, FragoperrecPtr fragOperPtr, FragrecordPtr regFragPtr) +{ + fragrefuse1Lab(signal, fragOperPtr); + releaseFragrec(regFragPtr); + return; +}//Dbtup::fragrefuse2Lab() + +void Dbtup::fragrefuse1Lab(Signal* signal, FragoperrecPtr fragOperPtr) +{ + fragrefuseLab(signal, fragOperPtr); + releaseFragoperrec(fragOperPtr); + return; +}//Dbtup::fragrefuse1Lab() + +void Dbtup::fragrefuseLab(Signal* signal, FragoperrecPtr fragOperPtr) +{ + signal->theData[0] = fragOperPtr.p->lqhPtrFrag; + signal->theData[1] = terrorCode; + sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUPFRAGREF, signal, 2, JBB); + return; +}//Dbtup::fragrefuseLab() + +void Dbtup::releaseFragoperrec(FragoperrecPtr fragOperPtr) +{ + fragOperPtr.p->nextFragoprec = cfirstfreeFragopr; + cfirstfreeFragopr = fragOperPtr.i; +}//Dbtup::releaseFragoperrec() + + +void Dbtup::deleteFragTab(Tablerec* const regTabPtr, Uint32 fragId) +{ + for (Uint32 i = 0; i < (2 * NO_OF_FRAG_PER_NODE); i++) { + ljam(); + if (regTabPtr->fragid[i] == fragId) { + ljam(); + regTabPtr->fragid[i] = RNIL; + regTabPtr->fragrec[i] = RNIL; + return; + }//if + }//for + ndbrequire(false); +}//Dbtup::deleteFragTab() + +void +Dbtup::execDROP_TAB_REQ(Signal* signal) +{ + ljamEntry(); + DropTabReq* req = (DropTabReq*)signal->getDataPtr(); + + TablerecPtr tabPtr; + tabPtr.i = req->tableId; + ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec); + + tabPtr.p->m_dropTable.tabUserRef = req->senderRef; + tabPtr.p->m_dropTable.tabUserPtr = req->senderData; + + signal->theData[0] = ZREL_FRAG; + signal->theData[1] = tabPtr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); +}//Dbtup::execDROP_TAB_REQ() + +void Dbtup::releaseTabDescr(Tablerec* const regTabPtr) +{ + Uint32 descriptor = regTabPtr->readKeyArray; + if (descriptor != RNIL) { + ljam(); + regTabPtr->tabDescriptor = RNIL; + regTabPtr->readKeyArray = RNIL; + regTabPtr->readFunctionArray = NULL; + regTabPtr->updateFunctionArray = NULL; + regTabPtr->attributeGroupDescriptor= RNIL; + + Uint32 sizeFunctionArrays = 2 * (regTabPtr->noOfAttr * sizeOfReadFunction()); + descriptor -= (sizeFunctionArrays + ZTD_SIZE); + Uint32 retNo = getTabDescrWord(descriptor + ZTD_DATASIZE); + ndbrequire(getTabDescrWord(descriptor + ZTD_HEADER) == ZTD_TYPE_NORMAL); + ndbrequire(retNo == getTabDescrWord((descriptor + retNo) - ZTD_TR_SIZE)); + ndbrequire(ZTD_TYPE_NORMAL == getTabDescrWord((descriptor + retNo) - ZTD_TR_TYPE)); + freeTabDescr(descriptor, retNo); + }//if +}//Dbtup::releaseTabDescr() + +void Dbtup::releaseFragment(Signal* signal, Uint32 tableId) +{ + TablerecPtr tabPtr; + tabPtr.i = tableId; + ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec); + Uint32 fragIndex = RNIL; + Uint32 fragId = RNIL; + Uint32 i = 0; + for (i = 0; i < (2 * NO_OF_FRAG_PER_NODE); i++) { + ljam(); + if (tabPtr.p->fragid[i] != RNIL) { + ljam(); + fragIndex = tabPtr.p->fragrec[i]; + fragId = tabPtr.p->fragid[i]; + break; + }//if + }//for + if (fragIndex != RNIL) { + ljam(); + + FragrecordPtr regFragPtr; + regFragPtr.i = fragIndex; + ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord); + releaseFragPages(regFragPtr.p); + + tabPtr.p->fragid[i] = RNIL; + tabPtr.p->fragrec[i] = RNIL; + releaseFragrec(regFragPtr); + + signal->theData[0] = ZREL_FRAG; + signal->theData[1] = tableId; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + return; + }//if + + /** + * Finished... + */ + sendFSREMOVEREQ(signal, tabPtr); +}//Dbtup::releaseFragment() + +void Dbtup::sendFSREMOVEREQ(Signal* signal, TablerecPtr tabPtr) +{ + FsRemoveReq * const fsReq = (FsRemoveReq *)signal->getDataPtrSend(); + fsReq->userReference = cownref; + fsReq->userPointer = tabPtr.i; + fsReq->fileNumber[0] = tabPtr.i; + fsReq->fileNumber[1] = (Uint32)-1; // Remove all fragments + fsReq->fileNumber[2] = (Uint32)-1; // Remove all data files within fragment + fsReq->fileNumber[3] = 255 | // No P-value used here + (5 << 8) | // Data-files in D5 + (0 << 16) | // Data-files + (1 << 24); // Version 1 of fileNumber + + fsReq->directory = 1; + fsReq->ownDirectory = 1; + sendSignal(NDBFS_REF, GSN_FSREMOVEREQ, signal, + FsRemoveReq::SignalLength, JBA); +}//Dbtup::sendFSREMOVEREQ() + +void Dbtup::execFSREMOVECONF(Signal* signal) +{ + ljamEntry(); + + FsConf * const fsConf = (FsConf *)signal->getDataPtrSend(); + TablerecPtr tabPtr; + tabPtr.i = fsConf->userPointer; + ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec); + + + DropTabConf * const dropConf = (DropTabConf *)signal->getDataPtrSend(); + dropConf->senderRef = reference(); + dropConf->senderData = tabPtr.p->m_dropTable.tabUserPtr; + dropConf->tableId = tabPtr.i; + sendSignal(tabPtr.p->m_dropTable.tabUserRef, GSN_DROP_TAB_CONF, + signal, DropTabConf::SignalLength, JBB); + + releaseTabDescr(tabPtr.p); + initTab(tabPtr.p); +}//Dbtup::execFSREMOVECONF() + +void Dbtup::execFSREMOVEREF(Signal* signal) +{ + ljamEntry(); + ndbrequire(false); +}//Dbtup::execFSREMOVEREF() + + diff --git a/ndb/src/kernel/blocks/dbtup/DbtupPagMan.cpp b/ndb/src/kernel/blocks/dbtup/DbtupPagMan.cpp new file mode 100644 index 00000000000..410cafee161 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupPagMan.cpp @@ -0,0 +1,360 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include + +#define ljam() { jamLine(16000 + __LINE__); } +#define ljamEntry() { jamEntryLine(16000 + __LINE__); } + +/* ---------------------------------------------------------------- */ +// 4) Page Memory Manager (buddy algorithm) +// +// The following data structures in Dbtup is used by the Page Memory +// Manager. +// +// cfreepageList[16] +// Pages with a header +// +// The cfreepageList is 16 free lists. Free list 0 contains chunks of +// pages with 2^0 (=1) pages in each chunk. Free list 1 chunks of 2^1 +// (=2) pages in each chunk and so forth upto free list 15 which +// contains chunks of 2^15 (=32768) pages in each chunk. +// The cfreepageList array contains the pointer to the first chunk +// in each of those lists. The lists are doubly linked where the +// first page in each chunk contains the next and previous references +// in position ZPAGE_NEXT_CLUST_POS and ZPAGE_PREV_CLUST_POS in the +// page header. +// In addition the leading page and the last page in each chunk is marked +// with a state (=ZFREE_COMMON) in position ZPAGE_STATE_POS in page +// header. This state indicates that the page is the leading or last page +// in a chunk of free pages. Furthermore the leading and last page is +// also marked with a reference to the leading (=ZPAGE_FIRST_CLUST_POS) +// and the last page (=ZPAGE_LAST_CLUST_POS) in the chunk. +// +// The aim of these data structures is to enable a free area handling of +// free pages based on a buddy algorithm. When allocating pages it is +// performed in chunks of pages and the algorithm tries to make the +// chunks as large as possible. +// This manager is invoked when fragments lack internal page space to +// accomodate all the data they are requested to store. It is also +// invoked when fragments deallocate page space back to the free area. +// +// The following routines are part of the external interface: +// void +// allocConsPages(Uint32 noOfPagesToAllocate, #In +// Uint32& noOfPagesAllocated, #Out +// Uint32& retPageRef) #Out +// void +// returnCommonArea(Uint32 retPageRef, #In +// Uint32 retNoPages) #In +// +// allocConsPages tries to allocate noOfPagesToAllocate pages in one chunk. +// If this fails it delivers a chunk as large as possible. It returns the +// i-value of the first page in the chunk delivered, if zero pages returned +// this i-value is undefined. It also returns the size of the chunk actually +// delivered. +// +// returnCommonArea is used when somebody is returning pages to the free area. +// It is used both from internal routines and external routines. +// +// The following routines are private routines used to support the +// above external interface: +// removeCommonArea() +// insertCommonArea() +// findFreeLeftNeighbours() +// findFreeRightNeighbours() +// Uint32 +// nextHigherTwoLog(Uint32 input) +// +// nextHigherTwoLog is a support routine which is a mathematical function with +// an integer as input and an integer as output. It calculates the 2-log of +// (input + 1). If the 2-log of (input + 1) is larger than 15 then the routine +// will return 15. It is part of the external interface since it is also used +// by other similar memory management algorithms. +// +// External dependencies: +// None. +// +// Side Effects: +// Apart from the above mentioned data structures there are no more +// side effects other than through the subroutine parameters in the +// external interface. +// +/* ---------------------------------------------------------------- */ + +/* ---------------------------------------------------------------- */ +/* CALCULATE THE 2-LOG + 1 OF TMP AND PUT RESULT INTO TBITS */ +/* ---------------------------------------------------------------- */ +Uint32 Dbtup::nextHigherTwoLog(Uint32 input) +{ + input = input | (input >> 8); + input = input | (input >> 4); + input = input | (input >> 2); + input = input | (input >> 1); + Uint32 output = (input & 0x5555) + ((input >> 1) & 0x5555); + output = (output & 0x3333) + ((output >> 2) & 0x3333); + output = output + (output >> 4); + output = (output & 0xf) + ((output >> 8) & 0xf); + return output; +}//nextHigherTwoLog() + +void Dbtup::initializePage() +{ + for (Uint32 i = 0; i < 16; i++) { + cfreepageList[i] = RNIL; + }//for + PagePtr pagePtr; + for (pagePtr.i = 0; pagePtr.i < cnoOfPage; pagePtr.i++) { + ljam(); + ptrAss(pagePtr, page); + pagePtr.p->pageWord[ZPAGE_PHYSICAL_INDEX] = pagePtr.i; + pagePtr.p->pageWord[ZPAGE_NEXT_POS] = pagePtr.i + 1; + pagePtr.p->pageWord[ZPAGE_NEXT_CLUST_POS] = RNIL; + pagePtr.p->pageWord[ZPAGE_LAST_CLUST_POS] = RNIL; + pagePtr.p->pageWord[ZPAGE_PREV_POS] = RNIL; + pagePtr.p->pageWord[ZPAGE_STATE_POS] = ZFREE_COMMON; + }//for + pagePtr.i = cnoOfPage - 1; + ptrAss(pagePtr, page); + pagePtr.p->pageWord[ZPAGE_NEXT_POS] = RNIL; + + pagePtr.i = 0; + ptrAss(pagePtr, page); + pagePtr.p->pageWord[ZPAGE_STATE_POS] = ~ZFREE_COMMON; + + returnCommonArea(1, cnoOfPage - 1); + cnoOfAllocatedPages = 1; +}//Dbtup::initializePage() + +void Dbtup::allocConsPages(Uint32 noOfPagesToAllocate, + Uint32& noOfPagesAllocated, + Uint32& allocPageRef) +{ + if (noOfPagesToAllocate == 0) { + ljam(); + noOfPagesAllocated = 0; + return; + }//if + Uint32 firstListToCheck = nextHigherTwoLog(noOfPagesToAllocate - 1); + for (Uint32 i = firstListToCheck; i < 16; i++) { + ljam(); + if (cfreepageList[i] != RNIL) { + ljam(); +/* ---------------------------------------------------------------- */ +/* PROPER AMOUNT OF PAGES WERE FOUND. NOW SPLIT THE FOUND */ +/* AREA AND RETURN THE PART NOT NEEDED. */ +/* ---------------------------------------------------------------- */ + noOfPagesAllocated = noOfPagesToAllocate; + allocPageRef = cfreepageList[i]; + removeCommonArea(allocPageRef, i); + Uint32 retNo = (1 << i) - noOfPagesToAllocate; + Uint32 retPageRef = allocPageRef + noOfPagesToAllocate; + returnCommonArea(retPageRef, retNo); + return; + }//if + }//for +/* ---------------------------------------------------------------- */ +/* PROPER AMOUNT OF PAGES WERE NOT FOUND. FIND AS MUCH AS */ +/* POSSIBLE. */ +/* ---------------------------------------------------------------- */ + for (Uint32 j = firstListToCheck; (Uint32)~j; j--) { + ljam(); + if (cfreepageList[j] != RNIL) { + ljam(); +/* ---------------------------------------------------------------- */ +/* SOME AREA WAS FOUND, ALLOCATE ALL OF IT. */ +/* ---------------------------------------------------------------- */ + allocPageRef = cfreepageList[j]; + removeCommonArea(allocPageRef, j); + noOfPagesAllocated = 1 << j; + findFreeLeftNeighbours(allocPageRef, noOfPagesAllocated, + noOfPagesToAllocate); + findFreeRightNeighbours(allocPageRef, noOfPagesAllocated, + noOfPagesToAllocate); + + return; + }//if + }//for +/* ---------------------------------------------------------------- */ +/* NO FREE AREA AT ALL EXISTED. RETURN ZERO PAGES */ +/* ---------------------------------------------------------------- */ + noOfPagesAllocated = 0; + return; +}//allocConsPages() + +void Dbtup::returnCommonArea(Uint32 retPageRef, Uint32 retNo) +{ + do { + ljam(); + if (retNo == 0) { + ljam(); + return; + }//if + Uint32 list = nextHigherTwoLog(retNo) - 1; + retNo -= (1 << list); + insertCommonArea(retPageRef, list); + retPageRef += (1 << list); + } while (1); +}//Dbtup::returnCommonArea() + +void Dbtup::findFreeLeftNeighbours(Uint32& allocPageRef, + Uint32& noPagesAllocated, + Uint32 noOfPagesToAllocate) +{ + PagePtr pageFirstPtr, pageLastPtr; + Uint32 remainAllocate = noOfPagesToAllocate - noPagesAllocated; + while (allocPageRef > 0) { + ljam(); + pageLastPtr.i = allocPageRef - 1; + ptrCheckGuard(pageLastPtr, cnoOfPage, page); + if (pageLastPtr.p->pageWord[ZPAGE_STATE_POS] != ZFREE_COMMON) { + ljam(); + return; + } else { + ljam(); + pageFirstPtr.i = pageLastPtr.p->pageWord[ZPAGE_FIRST_CLUST_POS]; + ndbrequire(pageFirstPtr.i != RNIL); + Uint32 list = nextHigherTwoLog(pageLastPtr.i - pageFirstPtr.i); + removeCommonArea(pageFirstPtr.i, list); + Uint32 listSize = 1 << list; + if (listSize > remainAllocate) { + ljam(); + Uint32 retNo = listSize - remainAllocate; + returnCommonArea(pageFirstPtr.i, retNo); + allocPageRef = pageFirstPtr.i + retNo; + noPagesAllocated = noOfPagesToAllocate; + return; + } else { + ljam(); + allocPageRef = pageFirstPtr.i; + noPagesAllocated += listSize; + remainAllocate -= listSize; + }//if + }//if + }//while +}//Dbtup::findFreeLeftNeighbours() + +void Dbtup::findFreeRightNeighbours(Uint32& allocPageRef, + Uint32& noPagesAllocated, + Uint32 noOfPagesToAllocate) +{ + PagePtr pageFirstPtr, pageLastPtr; + Uint32 remainAllocate = noOfPagesToAllocate - noPagesAllocated; + if (remainAllocate == 0) { + ljam(); + return; + }//if + while ((allocPageRef + noPagesAllocated) < cnoOfPage) { + ljam(); + pageFirstPtr.i = allocPageRef + noPagesAllocated; + ptrCheckGuard(pageFirstPtr, cnoOfPage, page); + if (pageFirstPtr.p->pageWord[ZPAGE_STATE_POS] != ZFREE_COMMON) { + ljam(); + return; + } else { + ljam(); + pageLastPtr.i = pageFirstPtr.p->pageWord[ZPAGE_LAST_CLUST_POS]; + ndbrequire(pageLastPtr.i != RNIL); + Uint32 list = nextHigherTwoLog(pageLastPtr.i - pageFirstPtr.i); + removeCommonArea(pageFirstPtr.i, list); + Uint32 listSize = 1 << list; + if (listSize > remainAllocate) { + ljam(); + Uint32 retPageRef = pageFirstPtr.i + remainAllocate; + Uint32 retNo = listSize - remainAllocate; + returnCommonArea(retPageRef, retNo); + noPagesAllocated += remainAllocate; + return; + } else { + ljam(); + noPagesAllocated += listSize; + remainAllocate -= listSize; + }//if + }//if + }//while +}//Dbtup::findFreeRightNeighbours() + +void Dbtup::insertCommonArea(Uint32 insPageRef, Uint32 insList) +{ + cnoOfAllocatedPages -= (1 << insList); + PagePtr pageLastPtr, pageInsPtr; + + pageInsPtr.i = insPageRef; + ptrCheckGuard(pageInsPtr, cnoOfPage, page); + ndbrequire(insList < 16); + pageLastPtr.i = (pageInsPtr.i + (1 << insList)) - 1; + + pageInsPtr.p->pageWord[ZPAGE_NEXT_CLUST_POS] = cfreepageList[insList]; + pageInsPtr.p->pageWord[ZPAGE_PREV_CLUST_POS] = RNIL; + pageInsPtr.p->pageWord[ZPAGE_LAST_CLUST_POS] = pageLastPtr.i; + cfreepageList[insList] = pageInsPtr.i; + + ptrCheckGuard(pageLastPtr, cnoOfPage, page); + pageLastPtr.p->pageWord[ZPAGE_FIRST_CLUST_POS] = pageInsPtr.i; + pageLastPtr.p->pageWord[ZPAGE_NEXT_POS] = RNIL; +}//Dbtup::insertCommonArea() + +void Dbtup::removeCommonArea(Uint32 remPageRef, Uint32 list) +{ + cnoOfAllocatedPages += (1 << list); + PagePtr pagePrevPtr, pageNextPtr, pageLastPtr, pageSearchPtr, remPagePtr; + + remPagePtr.i = remPageRef; + ptrCheckGuard(remPagePtr, cnoOfPage, page); + ndbrequire(list < 16); + if (cfreepageList[list] == remPagePtr.i) { + ljam(); + cfreepageList[list] = remPagePtr.p->pageWord[ZPAGE_NEXT_CLUST_POS]; + pageNextPtr.i = cfreepageList[list]; + if (pageNextPtr.i != RNIL) { + ljam(); + ptrCheckGuard(pageNextPtr, cnoOfPage, page); + pageNextPtr.p->pageWord[ZPAGE_PREV_CLUST_POS] = RNIL; + }//if + } else { + pageSearchPtr.i = cfreepageList[list]; + while (true) { + ljam(); + ptrCheckGuard(pageSearchPtr, cnoOfPage, page); + pagePrevPtr = pageSearchPtr; + pageSearchPtr.i = pageSearchPtr.p->pageWord[ZPAGE_NEXT_CLUST_POS]; + if (pageSearchPtr.i == remPagePtr.i) { + ljam(); + break; + }//if + }//while + pageNextPtr.i = remPagePtr.p->pageWord[ZPAGE_NEXT_CLUST_POS]; + pagePrevPtr.p->pageWord[ZPAGE_NEXT_CLUST_POS] = pageNextPtr.i; + if (pageNextPtr.i != RNIL) { + ljam(); + ptrCheckGuard(pageNextPtr, cnoOfPage, page); + pageNextPtr.p->pageWord[ZPAGE_PREV_CLUST_POS] = pagePrevPtr.i; + }//if + }//if + remPagePtr.p->pageWord[ZPAGE_NEXT_CLUST_POS] = RNIL; + remPagePtr.p->pageWord[ZPAGE_LAST_CLUST_POS] = RNIL; + remPagePtr.p->pageWord[ZPAGE_PREV_CLUST_POS] = RNIL; + + pageLastPtr.i = (remPagePtr.i + (1 << list)) - 1; + ptrCheckGuard(pageLastPtr, cnoOfPage, page); + pageLastPtr.p->pageWord[ZPAGE_FIRST_CLUST_POS] = RNIL; +}//Dbtup::removeCommonArea() + + diff --git a/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp b/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp new file mode 100644 index 00000000000..1f674876642 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp @@ -0,0 +1,556 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include + +#define ljam() { jamLine(14000 + __LINE__); } +#define ljamEntry() { jamEntryLine(14000 + __LINE__); } + +// +// PageMap is a service used by Dbtup to map logical page id's to physical +// page id's. The mapping is needs the fragment and the logical page id to +// provide the physical id. +// +// This is a part of Dbtup which is the exclusive user of a certain set of +// variables on the fragment record and it is the exclusive user of the +// struct for page ranges. +// +// +// The following methods operate on the data handled by the page map class. +// +// Public methods +// insertPageRange(Uint32 startPageId, # In +// Uint32 noPages) # In +// Inserts a range of pages into the mapping structure. +// +// void releaseFragPages() +// Releases all pages and their mappings belonging to a fragment. +// +// Uint32 allocFragPages(Uint32 tafpNoAllocRequested) +// Allocate a set of pages to the fragment from the page manager +// +// Uint32 getEmptyPage() +// Get an empty page from the pool of empty pages on the fragment. +// It returns the physical page id of the empty page. +// Returns RNIL if no empty page is available. +// +// Uint32 getRealpid(Uint32 logicalPageId) +// Return the physical page id provided the logical page id +// +// void initializePageRange() +// Initialise free list of page ranges and initialise the page raneg records. +// +// void initFragRange() +// Initialise the fragment variables when allocating a fragment to a table. +// +// void initPageRangeSize(Uint32 size) +// Initialise the number of page ranges. +// +// Uint32 getNoOfPages() +// Get the number of pages on the fragment currently. +// +// +// Private methods +// Uint32 leafPageRangeFull(PageRangePtr currPageRangePtr) +// +// void errorHandler() +// Method to crash NDB kernel in case of weird data set-up +// +// void allocMoreFragPages() +// When no more empty pages are attached to the fragment and we need more +// we allocate more pages from the page manager using this method. +// +// Private data +// On the fragment record +// currentPageRange # The current page range where to insert the next range +// rootPageRange # The root of the page ranges owned +// nextStartRange # The next page id to assign when expanding the +// # page map +// noOfPages # The number of pages in the fragment +// emptyPrimPage # The first page of the empty pages in the fragment +// +// The full page range struct + +Uint32 Dbtup::getEmptyPage(Fragrecord* const regFragPtr) +{ + Uint32 logicalPageId = regFragPtr->emptyPrimPage; + if (logicalPageId == RNIL) { + ljam(); + allocMoreFragPages(regFragPtr); + logicalPageId = regFragPtr->emptyPrimPage; + if (logicalPageId == RNIL) { + ljam(); + return RNIL; + }//if + }//if + Uint32 physicalPageId = getRealpid(regFragPtr, logicalPageId); + PagePtr pagePtr; + pagePtr.i = physicalPageId; + ptrCheckGuard(pagePtr, cnoOfPage, page); + regFragPtr->emptyPrimPage = pagePtr.p->pageWord[ZPAGE_NEXT_POS]; + return physicalPageId; +}//Dbtup::getEmptyPage() + +Uint32 Dbtup::getRealpid(Fragrecord* const regFragPtr, Uint32 logicalPageId) +{ + PageRangePtr grpPageRangePtr; + Uint32 loopLimit; + Uint32 loopCount = 0; + Uint32 pageRangeLimit = cnoOfPageRangeRec; + + grpPageRangePtr.i = regFragPtr->rootPageRange; + while (true) { + ndbrequire(loopCount++ < 100); + ndbrequire(grpPageRangePtr.i < pageRangeLimit); + ptrAss(grpPageRangePtr, pageRange); + loopLimit = grpPageRangePtr.p->currentIndexPos; + ndbrequire(loopLimit <= 3); + for (Uint32 i = 0; i <= loopLimit; i++) { + ljam(); + if (grpPageRangePtr.p->startRange[i] <= logicalPageId) { + if (grpPageRangePtr.p->endRange[i] >= logicalPageId) { + if (grpPageRangePtr.p->type[i] == ZLEAF) { + ljam(); + Uint32 realPageId = (logicalPageId - grpPageRangePtr.p->startRange[i]) + + grpPageRangePtr.p->basePageId[i]; + return realPageId; + } else { + ndbrequire(grpPageRangePtr.p->type[i] == ZNON_LEAF); + grpPageRangePtr.i = grpPageRangePtr.p->basePageId[i]; + }//if + }//if + }//if + }//for + }//while + return 0; +}//Dbtup::getRealpid() + +Uint32 Dbtup::getNoOfPages(Fragrecord* const regFragPtr) +{ + return regFragPtr->noOfPages; +}//Dbtup::getNoOfPages() + +void Dbtup::initPageRangeSize(Uint32 size) +{ + cnoOfPageRangeRec = size; +}//Dbtup::initPageRangeSize() + +/* ---------------------------------------------------------------- */ +/* ----------------------- INSERT_PAGE_RANGE_TAB ------------------ */ +/* ---------------------------------------------------------------- */ +/* INSERT A PAGE RANGE INTO THE FRAGMENT */ +/* */ +/* NOTE: THE METHOD IS ATOMIC. EITHER THE ACTION IS */ +/* PERFORMED FULLY OR NO ACTION IS PERFORMED AT ALL. */ +/* TO SUPPORT THIS THE CODE HAS A CLEANUP PART AFTER */ +/* ERRORS. */ +/* ---------------------------------------------------------------- */ +bool Dbtup::insertPageRangeTab(Fragrecord* const regFragPtr, + Uint32 startPageId, + Uint32 noPages) +{ + PageRangePtr currPageRangePtr; + if (cfirstfreerange == RNIL) { + ljam(); + return false; + }//if + currPageRangePtr.i = regFragPtr->currentPageRange; + if (currPageRangePtr.i == RNIL) { + ljam(); +/* ---------------------------------------------------------------- */ +/* THE FIRST PAGE RANGE IS HANDLED WITH SPECIAL CODE */ +/* ---------------------------------------------------------------- */ + seizePagerange(currPageRangePtr); + regFragPtr->rootPageRange = currPageRangePtr.i; + currPageRangePtr.p->currentIndexPos = 0; + currPageRangePtr.p->parentPtr = RNIL; + } else { + ljam(); + ptrCheckGuard(currPageRangePtr, cnoOfPageRangeRec, pageRange); + if (currPageRangePtr.p->currentIndexPos < 3) { + ljam(); +/* ---------------------------------------------------------------- */ +/* THE SIMPLE CASE WHEN IT IS ONLY NECESSARY TO FILL IN THE */ +/* NEXT EMPTY POSITION IN THE PAGE RANGE RECORD IS TREATED */ +/* BY COMMON CODE AT THE END OF THE SUBROUTINE. */ +/* ---------------------------------------------------------------- */ + currPageRangePtr.p->currentIndexPos++; + } else { + ljam(); + ndbrequire(currPageRangePtr.p->currentIndexPos == 3); + currPageRangePtr.i = leafPageRangeFull(regFragPtr, currPageRangePtr); + if (currPageRangePtr.i == RNIL) { + return false; + }//if + ptrCheckGuard(currPageRangePtr, cnoOfPageRangeRec, pageRange); + }//if + }//if + currPageRangePtr.p->startRange[currPageRangePtr.p->currentIndexPos] = regFragPtr->nextStartRange; +/* ---------------------------------------------------------------- */ +/* NOW SET THE LEAF LEVEL PAGE RANGE RECORD PROPERLY */ +/* PAGE_RANGE_PTR REFERS TO LEAF RECORD WHEN ARRIVING HERE */ +/* ---------------------------------------------------------------- */ + currPageRangePtr.p->endRange[currPageRangePtr.p->currentIndexPos] = + (regFragPtr->nextStartRange + noPages) - 1; + currPageRangePtr.p->basePageId[currPageRangePtr.p->currentIndexPos] = startPageId; + currPageRangePtr.p->type[currPageRangePtr.p->currentIndexPos] = ZLEAF; +/* ---------------------------------------------------------------- */ +/* WE NEED TO UPDATE THE CURRENT PAGE RANGE IN CASE IT HAS */ +/* CHANGED. WE ALSO NEED TO UPDATE THE NEXT START RANGE */ +/* ---------------------------------------------------------------- */ + regFragPtr->currentPageRange = currPageRangePtr.i; + regFragPtr->nextStartRange += noPages; +/* ---------------------------------------------------------------- */ +/* WE NEED TO UPDATE THE END RANGE IN ALL PAGE RANGE RECORDS */ +/* UP TO THE ROOT. */ +/* ---------------------------------------------------------------- */ + PageRangePtr loopPageRangePtr; + loopPageRangePtr = currPageRangePtr; + while (true) { + ljam(); + loopPageRangePtr.i = loopPageRangePtr.p->parentPtr; + if (loopPageRangePtr.i != RNIL) { + ljam(); + ptrCheckGuard(loopPageRangePtr, cnoOfPageRangeRec, pageRange); + ndbrequire(loopPageRangePtr.p->currentIndexPos < 4); + loopPageRangePtr.p->endRange[loopPageRangePtr.p->currentIndexPos] += noPages; + } else { + ljam(); + break; + }//if + }//while + regFragPtr->noOfPages += noPages; + return true; +}//Dbtup::insertPageRangeTab() + + +void Dbtup::releaseFragPages(Fragrecord* const regFragPtr) +{ + if (regFragPtr->rootPageRange == RNIL) { + ljam(); + return; + }//if + PageRangePtr regPRPtr; + regPRPtr.i = regFragPtr->rootPageRange; + ptrCheckGuard(regPRPtr, cnoOfPageRangeRec, pageRange); + while (true) { + ljam(); + const Uint32 indexPos = regPRPtr.p->currentIndexPos; + ndbrequire(indexPos < 4); + + const Uint32 basePageId = regPRPtr.p->basePageId[indexPos]; + regPRPtr.p->basePageId[indexPos] = RNIL; + if (basePageId == RNIL) { + ljam(); + /** + * Finished with indexPos continue with next + */ + if (indexPos > 0) { + ljam(); + regPRPtr.p->currentIndexPos--; + continue; + }//if + + /* ---------------------------------------------------------------- */ + /* THE PAGE RANGE REC IS EMPTY. RELEASE IT. */ + /*----------------------------------------------------------------- */ + Uint32 parentPtr = regPRPtr.p->parentPtr; + releasePagerange(regPRPtr); + + if (parentPtr != RNIL) { + ljam(); + regPRPtr.i = parentPtr; + ptrCheckGuard(regPRPtr, cnoOfPageRangeRec, pageRange); + continue; + }//if + + ljam(); + ndbrequire(regPRPtr.i == regFragPtr->rootPageRange); + initFragRange(regFragPtr); + return; + } else { + if (regPRPtr.p->type[indexPos] == ZNON_LEAF) { + jam(); + /* ---------------------------------------------------------------- */ + // A non-leaf node, we must release everything below it before we + // release this node. + /* ---------------------------------------------------------------- */ + regPRPtr.i = basePageId; + ptrCheckGuard(regPRPtr, cnoOfPageRangeRec, pageRange); + } else { + jam(); + ndbrequire(regPRPtr.p->type[indexPos] == ZLEAF); + /* ---------------------------------------------------------------- */ + /* PAGE_RANGE_PTR /= RNIL AND THE CURRENT POS IS NOT A CHLED. */ + /*----------------------------------------------------------------- */ + const Uint32 start = regPRPtr.p->startRange[indexPos]; + const Uint32 stop = regPRPtr.p->endRange[indexPos]; + ndbrequire(stop >= start); + const Uint32 retNo = (stop - start + 1); + returnCommonArea(basePageId, retNo); + }//if + }//if + }//while +}//Dbtup::releaseFragPages() + +void Dbtup::initializePageRange() +{ + PageRangePtr regPTRPtr; + for (regPTRPtr.i = 0; + regPTRPtr.i < cnoOfPageRangeRec; regPTRPtr.i++) { + ptrAss(regPTRPtr, pageRange); + regPTRPtr.p->nextFree = regPTRPtr.i + 1; + }//for + regPTRPtr.i = cnoOfPageRangeRec - 1; + ptrAss(regPTRPtr, pageRange); + regPTRPtr.p->nextFree = RNIL; + cfirstfreerange = 0; + c_noOfFreePageRanges = cnoOfPageRangeRec; +}//Dbtup::initializePageRange() + +void Dbtup::initFragRange(Fragrecord* const regFragPtr) +{ + regFragPtr->emptyPrimPage = RNIL; + regFragPtr->rootPageRange = RNIL; + regFragPtr->currentPageRange = RNIL; + regFragPtr->noOfPages = 0; + regFragPtr->nextStartRange = 0; +}//initFragRange() + +Uint32 Dbtup::allocFragPages(Fragrecord* const regFragPtr, Uint32 tafpNoAllocRequested) +{ + Uint32 tafpPagesAllocated = 0; + while (true) { + Uint32 noOfPagesAllocated = 0; + Uint32 noPagesToAllocate = tafpNoAllocRequested - tafpPagesAllocated; + Uint32 retPageRef = RNIL; + allocConsPages(noPagesToAllocate, noOfPagesAllocated, retPageRef); + if (noOfPagesAllocated == 0) { + ljam(); + return tafpPagesAllocated; + }//if +/* ---------------------------------------------------------------- */ +/* IT IS NOW TIME TO PUT THE ALLOCATED AREA INTO THE PAGE */ +/* RANGE TABLE. */ +/* ---------------------------------------------------------------- */ + Uint32 startRange = regFragPtr->nextStartRange; + if (!insertPageRangeTab(regFragPtr, retPageRef, noOfPagesAllocated)) { + ljam(); + returnCommonArea(retPageRef, noOfPagesAllocated); + return tafpPagesAllocated; + }//if + tafpPagesAllocated += noOfPagesAllocated; + Uint32 loopLimit = retPageRef + noOfPagesAllocated; + PagePtr loopPagePtr; +/* ---------------------------------------------------------------- */ +/* SINCE A NUMBER OF PAGES WERE ALLOCATED FROM COMMON AREA */ +/* WITH SUCCESS IT IS NOW TIME TO CHANGE THE STATE OF */ +/* THOSE PAGES TO EMPTY_MM AND LINK THEM INTO THE EMPTY */ +/* PAGE LIST OF THE FRAGMENT. */ +/* ---------------------------------------------------------------- */ + for (loopPagePtr.i = retPageRef; loopPagePtr.i < loopLimit; loopPagePtr.i++) { + ljam(); + ptrCheckGuard(loopPagePtr, cnoOfPage, page); + loopPagePtr.p->pageWord[ZPAGE_STATE_POS] = ZEMPTY_MM; + loopPagePtr.p->pageWord[ZPAGE_FRAG_PAGE_ID_POS] = startRange + + (loopPagePtr.i - retPageRef); + loopPagePtr.p->pageWord[ZPAGE_NEXT_POS] = loopPagePtr.p->pageWord[ZPAGE_FRAG_PAGE_ID_POS] + 1; + }//for + loopPagePtr.i = (retPageRef + noOfPagesAllocated) - 1; + ptrCheckGuard(loopPagePtr, cnoOfPage, page); + loopPagePtr.p->pageWord[ZPAGE_NEXT_POS] = regFragPtr->emptyPrimPage; + regFragPtr->emptyPrimPage = startRange; +/* ---------------------------------------------------------------- */ +/* WAS ENOUGH PAGES ALLOCATED OR ARE MORE NEEDED. */ +/* ---------------------------------------------------------------- */ + if (tafpPagesAllocated < tafpNoAllocRequested) { + ljam(); + } else { + ndbrequire(tafpPagesAllocated == tafpNoAllocRequested); + ljam(); + return tafpNoAllocRequested; + }//if + }//while +}//Dbtup::allocFragPages() + +void Dbtup::allocMoreFragPages(Fragrecord* const regFragPtr) +{ + Uint32 noAllocPages = regFragPtr->noOfPages >> 3; // 12.5% + noAllocPages += regFragPtr->noOfPages >> 4; // 6.25% + noAllocPages += 2; +/* -----------------------------------------------------------------*/ +// We will grow by 18.75% plus two more additional pages to grow +// a little bit quicker in the beginning. +/* -----------------------------------------------------------------*/ + allocFragPages(regFragPtr, noAllocPages); +}//Dbtup::allocMoreFragPages() + +Uint32 Dbtup::leafPageRangeFull(Fragrecord* const regFragPtr, PageRangePtr currPageRangePtr) +{ +/* ---------------------------------------------------------------- */ +/* THE COMPLEX CASE WHEN THE LEAF NODE IS FULL. GO UP THE TREE*/ +/* TO FIND THE FIRST RECORD WITH A FREE ENTRY. ALLOCATE NEW */ +/* PAGE RANGE RECORDS THEN ALL THE WAY DOWN TO THE LEAF LEVEL */ +/* AGAIN. THE TREE SHOULD ALWAYS REMAIN BALANCED. */ +/* ---------------------------------------------------------------- */ + PageRangePtr parentPageRangePtr; + PageRangePtr foundPageRangePtr; + parentPageRangePtr = currPageRangePtr; + Uint32 tiprNoLevels = 1; + while (true) { + ljam(); + parentPageRangePtr.i = parentPageRangePtr.p->parentPtr; + if (parentPageRangePtr.i == RNIL) { + ljam(); +/* ---------------------------------------------------------------- */ +/* WE HAVE REACHED THE ROOT. A NEW ROOT MUST BE ALLOCATED. */ +/* ---------------------------------------------------------------- */ + if (c_noOfFreePageRanges < tiprNoLevels) { + ljam(); + return RNIL; + }//if + PageRangePtr oldRootPRPtr; + PageRangePtr newRootPRPtr; + oldRootPRPtr.i = regFragPtr->rootPageRange; + ptrCheckGuard(oldRootPRPtr, cnoOfPageRangeRec, pageRange); + seizePagerange(newRootPRPtr); + regFragPtr->rootPageRange = newRootPRPtr.i; + oldRootPRPtr.p->parentPtr = newRootPRPtr.i; + + newRootPRPtr.p->basePageId[0] = oldRootPRPtr.i; + newRootPRPtr.p->parentPtr = RNIL; + newRootPRPtr.p->startRange[0] = 0; + newRootPRPtr.p->endRange[0] = regFragPtr->nextStartRange - 1; + newRootPRPtr.p->type[0] = ZNON_LEAF; + newRootPRPtr.p->startRange[1] = regFragPtr->nextStartRange; + newRootPRPtr.p->endRange[1] = regFragPtr->nextStartRange - 1; + newRootPRPtr.p->type[1] = ZNON_LEAF; + newRootPRPtr.p->currentIndexPos = 1; + foundPageRangePtr = newRootPRPtr; + break; + } else { + ljam(); + ptrCheckGuard(parentPageRangePtr, cnoOfPageRangeRec, pageRange); + if (parentPageRangePtr.p->currentIndexPos < 3) { + ljam(); +/* ---------------------------------------------------------------- */ +/* WE HAVE FOUND AN EMPTY ENTRY IN A PAGE RANGE RECORD. */ +/* ALLOCATE A NEW PAGE RANGE RECORD, FILL IN THE START RANGE, */ +/* ALLOCATE A NEW PAGE RANGE RECORD AND UPDATE THE POINTERS */ +/* ---------------------------------------------------------------- */ + parentPageRangePtr.p->currentIndexPos++; + parentPageRangePtr.p->startRange[parentPageRangePtr.p->currentIndexPos] = regFragPtr->nextStartRange; + parentPageRangePtr.p->endRange[parentPageRangePtr.p->currentIndexPos] = regFragPtr->nextStartRange - 1; + parentPageRangePtr.p->type[parentPageRangePtr.p->currentIndexPos] = ZNON_LEAF; + foundPageRangePtr = parentPageRangePtr; + break; + } else { + ljam(); + ndbrequire(parentPageRangePtr.p->currentIndexPos == 3); +/* ---------------------------------------------------------------- */ +/* THE PAGE RANGE RECORD WAS FULL. FIND THE PARENT RECORD */ +/* AND INCREASE THE NUMBER OF LEVELS WE HAVE TRAVERSED */ +/* GOING UP THE TREE. */ +/* ---------------------------------------------------------------- */ + tiprNoLevels++; + }//if + }//if + }//while +/* ---------------------------------------------------------------- */ +/* REMEMBER THE ERROR LEVEL IN CASE OF ALLOCATION ERRORS */ +/* ---------------------------------------------------------------- */ + PageRangePtr newPageRangePtr; + PageRangePtr prevPageRangePtr; + prevPageRangePtr = foundPageRangePtr; + if (c_noOfFreePageRanges < tiprNoLevels) { + ljam(); + return RNIL; + }//if +/* ---------------------------------------------------------------- */ +/* NOW WE HAVE PERFORMED THE SEARCH UPWARDS AND FILLED IN THE */ +/* PROPER FIELDS IN THE PAGE RANGE RECORD WHERE SOME SPACE */ +/* WAS FOUND. THE NEXT STEP IS TO ALLOCATE PAGE RANGES SO */ +/* THAT WE KEEP THE B-TREE BALANCED. THE NEW PAGE RANGE */ +/* ARE ALSO PROPERLY UPDATED ON THE PATH TO THE LEAF LEVEL. */ +/* ---------------------------------------------------------------- */ + while (true) { + ljam(); + seizePagerange(newPageRangePtr); + tiprNoLevels--; + ndbrequire(prevPageRangePtr.p->currentIndexPos < 4); + prevPageRangePtr.p->basePageId[prevPageRangePtr.p->currentIndexPos] = newPageRangePtr.i; + newPageRangePtr.p->parentPtr = prevPageRangePtr.i; + newPageRangePtr.p->currentIndexPos = 0; + if (tiprNoLevels > 0) { + ljam(); + newPageRangePtr.p->startRange[0] = regFragPtr->nextStartRange; + newPageRangePtr.p->endRange[0] = regFragPtr->nextStartRange - 1; + newPageRangePtr.p->type[0] = ZNON_LEAF; + prevPageRangePtr = newPageRangePtr; + } else { + ljam(); + break; + }//if + }//while + return newPageRangePtr.i; +}//Dbtup::leafPageRangeFull() + +void Dbtup::releasePagerange(PageRangePtr regPRPtr) +{ + regPRPtr.p->nextFree = cfirstfreerange; + cfirstfreerange = regPRPtr.i; + c_noOfFreePageRanges++; +}//Dbtup::releasePagerange() + +void Dbtup::seizePagerange(PageRangePtr& regPageRangePtr) +{ + regPageRangePtr.i = cfirstfreerange; + ptrCheckGuard(regPageRangePtr, cnoOfPageRangeRec, pageRange); + cfirstfreerange = regPageRangePtr.p->nextFree; + regPageRangePtr.p->nextFree = RNIL; + regPageRangePtr.p->currentIndexPos = 0; + regPageRangePtr.p->parentPtr = RNIL; + for (Uint32 i = 0; i < 4; i++) { + regPageRangePtr.p->startRange[i] = 1; + regPageRangePtr.p->endRange[i] = 0; + regPageRangePtr.p->type[i] = ZNON_LEAF; + regPageRangePtr.p->basePageId[i] = (Uint32)-1; + }//for + c_noOfFreePageRanges--; +}//Dbtup::seizePagerange() + +void Dbtup::errorHandler(Uint32 errorCode) +{ + switch (errorCode) { + case 0: + ljam(); + break; + case 1: + ljam(); + break; + case 2: + ljam(); + break; + default: + ljam(); + } + ndbrequire(false); +}//Dbtup::errorHandler() diff --git a/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp b/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp new file mode 100644 index 00000000000..a5f56a356f9 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp @@ -0,0 +1,896 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include +#include +#include "AttributeOffset.hpp" +#include + +#define ljam() { jamLine(3000 + __LINE__); } +#define ljamEntry() { jamEntryLine(3000 + __LINE__); } + +void +Dbtup::setUpQueryRoutines(Tablerec* const regTabPtr) +{ + Uint32 startDescriptor = regTabPtr->tabDescriptor; + ndbrequire((startDescriptor + (regTabPtr->noOfAttr << ZAD_LOG_SIZE)) <= cnoOfTabDescrRec); + for (Uint32 i = 0; i < regTabPtr->noOfAttr; i++) { + Uint32 attrDescriptorStart = startDescriptor + (i << ZAD_LOG_SIZE); + Uint32 attrDescriptor = tableDescriptor[attrDescriptorStart].tabDescr; + if (!AttributeDescriptor::getDynamic(attrDescriptor)) { + if ((AttributeDescriptor::getArrayType(attrDescriptor) == ZNON_ARRAY) || + (AttributeDescriptor::getArrayType(attrDescriptor) == ZFIXED_ARRAY)) { + if (!AttributeDescriptor::getNullable(attrDescriptor)) { + if (AttributeDescriptor::getSizeInWords(attrDescriptor) == 1) { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHOneWordNotNULL; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHOneWordNotNULL; + } else if (AttributeDescriptor::getSizeInWords(attrDescriptor) == 2) { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHTwoWordNotNULL; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHTwoWordNotNULL; + } else if (AttributeDescriptor::getSizeInWords(attrDescriptor) > 2) { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHManyWordNotNULL; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNotNULL; + } else { + ndbrequire(false); + }//if + } else { + if (AttributeDescriptor::getSizeInWords(attrDescriptor) == 1) { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHOneWordNULLable; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNULLable; + } else if (AttributeDescriptor::getSizeInWords(attrDescriptor) == 2) { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHTwoWordNULLable; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNULLable; + } else if (AttributeDescriptor::getSizeInWords(attrDescriptor) > 2) { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHManyWordNULLable; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNULLable; + } else { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHZeroWordNULLable; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNULLable; + }//if + }//if + } else if (AttributeDescriptor::getArrayType(attrDescriptor) == ZVAR_ARRAY) { + if (!AttributeDescriptor::getNullable(attrDescriptor)) { + if (AttributeDescriptor::getArraySize(attrDescriptor) == 0) { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readVarSizeUnlimitedNotNULL; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateVarSizeUnlimitedNotNULL; + } else if (AttributeDescriptor::getArraySize(attrDescriptor) > ZMAX_SMALL_VAR_ARRAY) { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readBigVarSizeNotNULL; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateBigVarSizeNotNULL; + } else { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readSmallVarSizeNotNULL; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateSmallVarSizeNotNULL; + }//if + } else { + if (AttributeDescriptor::getArraySize(attrDescriptor) == 0) { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readVarSizeUnlimitedNULLable; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateVarSizeUnlimitedNULLable; + } else if (AttributeDescriptor::getArraySize(attrDescriptor) > ZMAX_SMALL_VAR_ARRAY) { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readBigVarSizeNULLable; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateBigVarSizeNULLable; + } else { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readSmallVarSizeNULLable; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateSmallVarSizeNULLable; + }//if + }//if + } else { + ndbrequire(false); + }//if + } else { + if ((AttributeDescriptor::getArrayType(attrDescriptor) == ZNON_ARRAY) || + (AttributeDescriptor::getArrayType(attrDescriptor) == ZFIXED_ARRAY)) { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readDynFixedSize; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateDynFixedSize; + } else if (AttributeDescriptor::getType(attrDescriptor) == ZVAR_ARRAY) { + if (AttributeDescriptor::getArraySize(attrDescriptor) == 0) { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readDynVarSizeUnlimited; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateDynVarSizeUnlimited; + } else if (AttributeDescriptor::getArraySize(attrDescriptor) > ZMAX_SMALL_VAR_ARRAY) { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readDynBigVarSize; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateDynBigVarSize; + } else { + ljam(); + regTabPtr->readFunctionArray[i] = &Dbtup::readDynSmallVarSize; + regTabPtr->updateFunctionArray[i] = &Dbtup::updateDynSmallVarSize; + }//if + } else { + ndbrequire(false); + }//if + }//if + }//for +}//Dbtup::setUpQueryRoutines() + +/* ---------------------------------------------------------------- */ +/* THIS ROUTINE IS USED TO READ A NUMBER OF ATTRIBUTES IN THE */ +/* DATABASE AND PLACE THE RESULT IN ATTRINFO RECORDS. */ +// +// In addition to the parameters used in the call it also relies on the +// following variables set-up properly. +// +// operPtr.p Operation record pointer +// fragptr.p Fragment record pointer +// tabptr.p Table record pointer +/* ---------------------------------------------------------------- */ +int Dbtup::readAttributes(Page* const pagePtr, + Uint32 tupHeadOffset, + Uint32* inBuffer, + Uint32 inBufLen, + Uint32* outBuffer, + Uint32 maxRead) +{ + Tablerec* const regTabPtr = tabptr.p; + Uint32 numAttributes = regTabPtr->noOfAttr; + Uint32 attrDescriptorStart = regTabPtr->tabDescriptor; + Uint32 inBufIndex = 0; + + ndbrequire(attrDescriptorStart + (numAttributes << ZAD_LOG_SIZE) <= cnoOfTabDescrRec); + + tOutBufIndex = 0; + tCheckOffset = regTabPtr->tupheadsize; + tMaxRead = maxRead; + tTupleHeader = &pagePtr->pageWord[tupHeadOffset]; + + ndbrequire(tupHeadOffset + tCheckOffset <= ZWORDS_ON_PAGE); + while (inBufIndex < inBufLen) { + Uint32 tmpAttrBufIndex = tOutBufIndex; + AttributeHeader ahIn(inBuffer[inBufIndex]); + inBufIndex++; + Uint32 attributeId = ahIn.getAttributeId(); + Uint32 attrDescriptorIndex = attrDescriptorStart + (attributeId << ZAD_LOG_SIZE); + ljam(); + + AttributeHeader::init(&outBuffer[tmpAttrBufIndex], attributeId, 0); + AttributeHeader* ahOut = (AttributeHeader*)&outBuffer[tmpAttrBufIndex]; + tOutBufIndex = tmpAttrBufIndex + 1; + if (attributeId < numAttributes) { + Uint32 attributeDescriptor = tableDescriptor[attrDescriptorIndex].tabDescr; + Uint32 attributeOffset = tableDescriptor[attrDescriptorIndex + 1].tabDescr; + ReadFunction f = regTabPtr->readFunctionArray[attributeId]; + if ((this->*f)(outBuffer, + ahOut, + attributeDescriptor, + attributeOffset)) { + continue; + } else { + return (Uint32)-1; + }//if + } else { + terrorCode = ZATTRIBUTE_ID_ERROR; + return (Uint32)-1; + }//if + }//while + return tOutBufIndex; +}//Dbtup::readAttributes() + +int Dbtup::readAttributesWithoutHeader(Page* const pagePtr, + Uint32 tupHeadOffset, + Uint32* inBuffer, + Uint32 inBufLen, + Uint32* outBuffer, + Uint32* attrBuffer, + Uint32 maxRead) +{ + Tablerec* const regTabPtr = tabptr.p; + Uint32 numAttributes = regTabPtr->noOfAttr; + Uint32 attrDescriptorStart = regTabPtr->tabDescriptor; + Uint32 inBufIndex = 0; + Uint32 attrBufIndex = 0; + + ndbrequire(attrDescriptorStart + (numAttributes << ZAD_LOG_SIZE) <= cnoOfTabDescrRec); + + tOutBufIndex = 0; + tCheckOffset = regTabPtr->tupheadsize; + tMaxRead = maxRead; + tTupleHeader = &pagePtr->pageWord[tupHeadOffset]; + + ndbrequire(tupHeadOffset + tCheckOffset <= ZWORDS_ON_PAGE); + while (inBufIndex < inBufLen) { + AttributeHeader ahIn(inBuffer[inBufIndex]); + inBufIndex++; + Uint32 attributeId = ahIn.getAttributeId(); + Uint32 attrDescriptorIndex = attrDescriptorStart + (attributeId << ZAD_LOG_SIZE); + ljam(); + + AttributeHeader::init(&attrBuffer[attrBufIndex], attributeId, 0); + AttributeHeader* ahOut = (AttributeHeader*)&attrBuffer[attrBufIndex]; + attrBufIndex++; + if (attributeId < numAttributes) { + Uint32 attributeDescriptor = tableDescriptor[attrDescriptorIndex].tabDescr; + Uint32 attributeOffset = tableDescriptor[attrDescriptorIndex + 1].tabDescr; + ReadFunction f = regTabPtr->readFunctionArray[attributeId]; + if ((this->*f)(outBuffer, + ahOut, + attributeDescriptor, + attributeOffset)) { + continue; + } else { + return (Uint32)-1; + }//if + } else { + terrorCode = ZATTRIBUTE_ID_ERROR; + return (Uint32)-1; + }//if + }//while + ndbrequire(attrBufIndex == inBufLen); + return tOutBufIndex; +}//Dbtup::readAttributes() + +bool +Dbtup::readFixedSizeTHOneWordNotNULL(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + Uint32 indexBuf = tOutBufIndex; + Uint32 readOffset = AttributeOffset::getOffset(attrDes2); + Uint32 const wordRead = tTupleHeader[readOffset]; + Uint32 newIndexBuf = indexBuf + 1; + Uint32 maxRead = tMaxRead; + + ndbrequire(readOffset < tCheckOffset); + if (newIndexBuf <= maxRead) { + ljam(); + outBuffer[indexBuf] = wordRead; + ahOut->setDataSize(1); + tOutBufIndex = newIndexBuf; + return true; + } else { + ljam(); + terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR; + return false; + }//if +}//Dbtup::readFixedSizeTHOneWordNotNULL() + +bool +Dbtup::readFixedSizeTHTwoWordNotNULL(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + Uint32 indexBuf = tOutBufIndex; + Uint32 readOffset = AttributeOffset::getOffset(attrDes2); + Uint32 const wordReadFirst = tTupleHeader[readOffset]; + Uint32 const wordReadSecond = tTupleHeader[readOffset + 1]; + Uint32 newIndexBuf = indexBuf + 2; + Uint32 maxRead = tMaxRead; + + ndbrequire(readOffset + 1 < tCheckOffset); + if (newIndexBuf <= maxRead) { + ljam(); + ahOut->setDataSize(2); + outBuffer[indexBuf] = wordReadFirst; + outBuffer[indexBuf + 1] = wordReadSecond; + tOutBufIndex = newIndexBuf; + return true; + } else { + ljam(); + terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR; + return false; + }//if +}//Dbtup::readFixedSizeTHTwoWordNotNULL() + +bool +Dbtup::readFixedSizeTHManyWordNotNULL(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + Uint32 indexBuf = tOutBufIndex; + Uint32 readOffset = AttributeOffset::getOffset(attrDes2); + Uint32 attrNoOfWords = AttributeDescriptor::getSizeInWords(attrDescriptor); + Uint32 newIndexBuf = indexBuf + attrNoOfWords; + Uint32 maxRead = tMaxRead; + + ndbrequire((readOffset + attrNoOfWords - 1) < tCheckOffset); + if (newIndexBuf <= maxRead) { + ljam(); + ahOut->setDataSize(attrNoOfWords); + MEMCOPY_NO_WORDS(&outBuffer[indexBuf], + &tTupleHeader[readOffset], + attrNoOfWords); + tOutBufIndex = newIndexBuf; + return true; + } else { + ljam(); + terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR; + return false; + }//if +}//Dbtup::readFixedSizeTHManyWordNotNULL() + +bool +Dbtup::readFixedSizeTHOneWordNULLable(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + if (!nullFlagCheck(attrDes2)) { + ljam(); + return readFixedSizeTHOneWordNotNULL(outBuffer, + ahOut, + attrDescriptor, + attrDes2); + } else { + ljam(); + ahOut->setNULL(); + return true; + }//if +}//Dbtup::readFixedSizeTHOneWordNULLable() + +bool +Dbtup::readFixedSizeTHTwoWordNULLable(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + if (!nullFlagCheck(attrDes2)) { + ljam(); + return readFixedSizeTHTwoWordNotNULL(outBuffer, + ahOut, + attrDescriptor, + attrDes2); + } else { + ljam(); + ahOut->setNULL(); + return true; + }//if +}//Dbtup::readFixedSizeTHTwoWordNULLable() + +bool +Dbtup::readFixedSizeTHManyWordNULLable(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ +ljam(); + if (!nullFlagCheck(attrDes2)) { + ljam(); + return readFixedSizeTHManyWordNotNULL(outBuffer, + ahOut, + attrDescriptor, + attrDes2); + } else { + ljam(); + ahOut->setNULL(); + return true; + }//if +}//Dbtup::readFixedSizeTHManyWordNULLable() + +bool +Dbtup::readFixedSizeTHZeroWordNULLable(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + if (nullFlagCheck(attrDes2)) { + ljam(); + ahOut->setNULL(); + }//if + return true; +}//Dbtup::readFixedSizeTHZeroWordNULLable() + +bool +Dbtup::nullFlagCheck(Uint32 attrDes2) +{ + Tablerec* const regTabPtr = tabptr.p; + Uint32 nullFlagOffsetInTuple = AttributeOffset::getNullFlagOffset(attrDes2); + ndbrequire(nullFlagOffsetInTuple < regTabPtr->tupNullWords); + nullFlagOffsetInTuple += regTabPtr->tupNullIndex; + ndbrequire(nullFlagOffsetInTuple < tCheckOffset); + + return (AttributeOffset::isNULL(tTupleHeader[nullFlagOffsetInTuple], attrDes2)); +}//Dbtup::nullFlagCheck() + +bool +Dbtup::readVariableSizedAttr(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::readVariableSizedAttr() + +bool +Dbtup::readVarSizeUnlimitedNotNULL(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::readVarSizeUnlimitedNotNULL() + +bool +Dbtup::readVarSizeUnlimitedNULLable(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::readVarSizeUnlimitedNULLable() + +bool +Dbtup::readBigVarSizeNotNULL(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::readBigVarSizeNotNULL() + +bool +Dbtup::readBigVarSizeNULLable(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::readBigVarSizeNULLable() + +bool +Dbtup::readSmallVarSizeNotNULL(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::readSmallVarSizeNotNULL() + +bool +Dbtup::readSmallVarSizeNULLable(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::readSmallVarSizeNULLable() + +bool +Dbtup::readDynFixedSize(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::readDynFixedSize() + +bool +Dbtup::readDynVarSizeUnlimited(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::readDynVarSizeUnlimited() + +bool +Dbtup::readDynBigVarSize(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::readDynBigVarSize() + +bool +Dbtup::readDynSmallVarSize(Uint32* outBuffer, + AttributeHeader* ahOut, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::readDynSmallVarSize() + +/* ---------------------------------------------------------------------- */ +/* THIS ROUTINE IS USED TO UPDATE A NUMBER OF ATTRIBUTES. IT IS */ +/* USED BY THE INSERT ROUTINE, THE UPDATE ROUTINE AND IT CAN BE */ +/* CALLED SEVERAL TIMES FROM THE INTERPRETER. */ +// In addition to the parameters used in the call it also relies on the +// following variables set-up properly. +// +// pagep.p Page record pointer +// fragptr.p Fragment record pointer +// operPtr.p Operation record pointer +// tabptr.p Table record pointer +/* ---------------------------------------------------------------------- */ +int Dbtup::updateAttributes(Page* const pagePtr, + Uint32 tupHeadOffset, + Uint32* inBuffer, + Uint32 inBufLen) +{ + Tablerec* const regTabPtr = tabptr.p; + Operationrec* const regOperPtr = operPtr.p; + Uint32 numAttributes = regTabPtr->noOfAttr; + Uint32 attrDescriptorStart = regTabPtr->tabDescriptor; + ndbrequire(attrDescriptorStart + (numAttributes << ZAD_LOG_SIZE) <= cnoOfTabDescrRec); + + tCheckOffset = regTabPtr->tupheadsize; + tTupleHeader = &pagePtr->pageWord[tupHeadOffset]; + Uint32 inBufIndex = 0; + tInBufIndex = 0; + tInBufLen = inBufLen; + + ndbrequire(tupHeadOffset + tCheckOffset <= ZWORDS_ON_PAGE); + while (inBufIndex < inBufLen) { + AttributeHeader ahIn(inBuffer[inBufIndex]); + Uint32 attributeId = ahIn.getAttributeId(); + Uint32 attrDescriptorIndex = attrDescriptorStart + (attributeId << ZAD_LOG_SIZE); + if (attributeId < numAttributes) { + Uint32 attrDescriptor = tableDescriptor[attrDescriptorIndex].tabDescr; + Uint32 attributeOffset = tableDescriptor[attrDescriptorIndex + 1].tabDescr; + if ((AttributeDescriptor::getPrimaryKey(attrDescriptor)) && + (regOperPtr->optype != ZINSERT)) { + if (checkUpdateOfPrimaryKey(&inBuffer[inBufIndex], regTabPtr)) { + ljam(); + terrorCode = ZTRY_UPDATE_PRIMARY_KEY; + return -1; + }//if + }//if + UpdateFunction f = regTabPtr->updateFunctionArray[attributeId]; + ljam(); + regOperPtr->changeMask.set(attributeId); + if ((this->*f)(inBuffer, + attrDescriptor, + attributeOffset)) { + inBufIndex = tInBufIndex; + continue; + } else { + ljam(); + return (Uint32)-1; + }//if + } else { + ljam(); + terrorCode = ZATTRIBUTE_ID_ERROR; + return (Uint32)-1; + }//if + }//while + return 0; +}//Dbtup::updateAttributes() + +bool +Dbtup::checkUpdateOfPrimaryKey(Uint32* updateBuffer, Tablerec* const regTabPtr) +{ + Uint32 keyReadBuffer[MAX_KEY_SIZE_IN_WORDS]; + Uint32 attributeHeader; + AttributeHeader* ahOut = (AttributeHeader*)&attributeHeader; + AttributeHeader ahIn(*updateBuffer); + Uint32 attributeId = ahIn.getAttributeId(); + Uint32 attrDescriptorIndex = regTabPtr->tabDescriptor + (attributeId << ZAD_LOG_SIZE); + Uint32 attrDescriptor = tableDescriptor[attrDescriptorIndex].tabDescr; + Uint32 attributeOffset = tableDescriptor[attrDescriptorIndex + 1].tabDescr; + ReadFunction f = regTabPtr->readFunctionArray[attributeId]; + + AttributeHeader::init(&attributeHeader, attributeId, 0); + tOutBufIndex = 0; + tMaxRead = MAX_KEY_SIZE_IN_WORDS; + + ndbrequire((this->*f)(&keyReadBuffer[0], ahOut, attrDescriptor, attributeOffset)); + ndbrequire(tOutBufIndex == ahOut->getDataSize()); + if (ahIn.getDataSize() != ahOut->getDataSize()) { + ljam(); + return true; + }//if + if (memcmp(&keyReadBuffer[0], &updateBuffer[1], tOutBufIndex << 2) != 0) { + ljam(); + return true; + }//if + return false; +}//Dbtup::checkUpdateOfPrimaryKey() + +#if 0 +void Dbtup::checkPages(Fragrecord* const regFragPtr) +{ + Uint32 noPages = getNoOfPages(regFragPtr); + for (Uint32 i = 0; i < noPages ; i++) { + PagePtr pagePtr; + pagePtr.i = getRealpid(regFragPtr, i); + ptrCheckGuard(pagePtr, cnoOfPage, page); + ndbrequire(pagePtr.p->pageWord[1] != (RNIL - 1)); + } +} +#endif + +bool +Dbtup::updateFixedSizeTHOneWordNotNULL(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + Uint32 indexBuf = tInBufIndex; + Uint32 inBufLen = tInBufLen; + Uint32 updateOffset = AttributeOffset::getOffset(attrDes2); + AttributeHeader ahIn(inBuffer[indexBuf]); + Uint32 nullIndicator = ahIn.isNULL(); + Uint32 newIndex = indexBuf + 2; + ndbrequire(updateOffset < tCheckOffset); + + if (newIndex <= inBufLen) { + Uint32 updateWord = inBuffer[indexBuf + 1]; + if (!nullIndicator) { + ljam(); + tInBufIndex = newIndex; + tTupleHeader[updateOffset] = updateWord; + return true; + } else { + ljam(); + terrorCode = ZNOT_NULL_ATTR; + return false; + }//if + } else { + ljam(); + terrorCode = ZAI_INCONSISTENCY_ERROR; + return false; + }//if + return true; +}//Dbtup::updateFixedSizeTHOneWordNotNULL() + +bool +Dbtup::updateFixedSizeTHTwoWordNotNULL(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + Uint32 indexBuf = tInBufIndex; + Uint32 inBufLen = tInBufLen; + Uint32 updateOffset = AttributeOffset::getOffset(attrDes2); + AttributeHeader ahIn(inBuffer[indexBuf]); + Uint32 nullIndicator = ahIn.isNULL(); + Uint32 newIndex = indexBuf + 3; + ndbrequire((updateOffset + 1) < tCheckOffset); + + if (newIndex <= inBufLen) { + Uint32 updateWord1 = inBuffer[indexBuf + 1]; + Uint32 updateWord2 = inBuffer[indexBuf + 2]; + if (!nullIndicator) { + ljam(); + tInBufIndex = newIndex; + tTupleHeader[updateOffset] = updateWord1; + tTupleHeader[updateOffset + 1] = updateWord2; + return true; + } else { + ljam(); + terrorCode = ZNOT_NULL_ATTR; + return false; + }//if + } else { + ljam(); + terrorCode = ZAI_INCONSISTENCY_ERROR; + return false; + }//if +}//Dbtup::updateFixedSizeTHTwoWordNotNULL() + +bool +Dbtup::updateFixedSizeTHManyWordNotNULL(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + Uint32 indexBuf = tInBufIndex; + Uint32 inBufLen = tInBufLen; + Uint32 updateOffset = AttributeOffset::getOffset(attrDes2); + AttributeHeader ahIn(inBuffer[indexBuf]); + Uint32 nullIndicator = ahIn.isNULL(); + Uint32 noOfWords = AttributeDescriptor::getSizeInWords(attrDescriptor); + Uint32 newIndex = indexBuf + noOfWords + 1; + ndbrequire((updateOffset + noOfWords - 1) < tCheckOffset); + + if (newIndex <= inBufLen) { + if (!nullIndicator) { + ljam(); + tInBufIndex = newIndex; + MEMCOPY_NO_WORDS(&tTupleHeader[updateOffset], + &inBuffer[indexBuf + 1], + noOfWords); + return true; + } else { + ljam(); + terrorCode = ZNOT_NULL_ATTR; + return false; + }//if + } else { + ljam(); + terrorCode = ZAI_INCONSISTENCY_ERROR; + return false; + }//if +}//Dbtup::updateFixedSizeTHManyWordNotNULL() + +bool +Dbtup::updateFixedSizeTHManyWordNULLable(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + Tablerec* const regTabPtr = tabptr.p; + AttributeHeader ahIn(inBuffer[tInBufIndex]); + Uint32 nullIndicator = ahIn.isNULL(); + Uint32 nullFlagOffset = AttributeOffset::getNullFlagOffset(attrDes2); + Uint32 nullFlagBitOffset = AttributeOffset::getNullFlagBitOffset(attrDes2); + Uint32 nullWordOffset = nullFlagOffset + regTabPtr->tupNullIndex; + ndbrequire((nullFlagOffset < regTabPtr->tupNullWords) && + (nullWordOffset < tCheckOffset)); + Uint32 nullBits = tTupleHeader[nullWordOffset]; + + if (!nullIndicator) { + nullBits &= (~(1 << nullFlagBitOffset)); + ljam(); + tTupleHeader[nullWordOffset] = nullBits; + return updateFixedSizeTHManyWordNotNULL(inBuffer, + attrDescriptor, + attrDes2); + } else { + Uint32 newIndex = tInBufIndex + 1; + if (newIndex <= tInBufLen) { + nullBits |= (1 << nullFlagBitOffset); + ljam(); + tTupleHeader[nullWordOffset] = nullBits; + tInBufIndex = newIndex; + return true; + } else { + ljam(); + terrorCode = ZAI_INCONSISTENCY_ERROR; + return false; + }//if + }//if +}//Dbtup::updateFixedSizeTHManyWordNULLable() + +bool +Dbtup::updateVariableSizedAttr(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::updateVariableSizedAttr() + +bool +Dbtup::updateVarSizeUnlimitedNotNULL(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::updateVarSizeUnlimitedNotNULL() + +bool +Dbtup::updateVarSizeUnlimitedNULLable(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::updateVarSizeUnlimitedNULLable() + +bool +Dbtup::updateBigVarSizeNotNULL(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::updateBigVarSizeNotNULL() + +bool +Dbtup::updateBigVarSizeNULLable(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::updateBigVarSizeNULLable() + +bool +Dbtup::updateSmallVarSizeNotNULL(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::updateSmallVarSizeNotNULL() + +bool +Dbtup::updateSmallVarSizeNULLable(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::updateSmallVarSizeNULLable() + +bool +Dbtup::updateDynFixedSize(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::updateDynFixedSize() + +bool +Dbtup::updateDynVarSizeUnlimited(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::updateDynVarSizeUnlimited() + +bool +Dbtup::updateDynBigVarSize(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::updateDynBigVarSize() + +bool +Dbtup::updateDynSmallVarSize(Uint32* inBuffer, + Uint32 attrDescriptor, + Uint32 attrDes2) +{ + ljam(); + terrorCode = ZVAR_SIZED_NOT_SUPPORTED; + return false; +}//Dbtup::updateDynSmallVarSize() + + diff --git a/ndb/src/kernel/blocks/dbtup/DbtupStoredProcDef.cpp b/ndb/src/kernel/blocks/dbtup/DbtupStoredProcDef.cpp new file mode 100644 index 00000000000..3b957688a1c --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupStoredProcDef.cpp @@ -0,0 +1,230 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include + +#define ljam() { jamLine(18000 + __LINE__); } +#define ljamEntry() { jamEntryLine(18000 + __LINE__); } + +/* ---------------------------------------------------------------- */ +/* ---------------------------------------------------------------- */ +/* ------------ADD/DROP STORED PROCEDURE MODULE ------------------- */ +/* ---------------------------------------------------------------- */ +/* ---------------------------------------------------------------- */ +void Dbtup::execSTORED_PROCREQ(Signal* signal) +{ + OperationrecPtr regOperPtr; + TablerecPtr regTabPtr; + ljamEntry(); + regOperPtr.i = signal->theData[0]; + ptrCheckGuard(regOperPtr, cnoOfOprec, operationrec); + regTabPtr.i = signal->theData[1]; + ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec); + + Uint32 requestInfo = signal->theData[3]; + + ndbrequire(regOperPtr.p->transstate == IDLE || + ((regOperPtr.p->transstate == ERROR_WAIT_STORED_PROCREQ) && + (requestInfo == ZSTORED_PROCEDURE_DELETE))); + ndbrequire(regTabPtr.p->tableStatus == DEFINED); + switch (requestInfo) { + case ZSCAN_PROCEDURE: + ljam(); + scanProcedure(signal, + regOperPtr.p, + signal->theData[4]); + break; + case ZCOPY_PROCEDURE: + ljam(); + copyProcedure(signal, regTabPtr, regOperPtr.p); + break; + case ZSTORED_PROCEDURE_DELETE: + ljam(); + deleteScanProcedure(signal, regOperPtr.p); + break; + default: + ndbrequire(false); + }//switch +}//Dbtup::execSTORED_PROCREQ() + +void Dbtup::deleteScanProcedure(Signal* signal, + Operationrec* regOperPtr) +{ + StoredProcPtr storedPtr; + Uint32 storedProcId = signal->theData[4]; + c_storedProcPool.getPtr(storedPtr, storedProcId); + ndbrequire(storedPtr.p->storedCode == ZSCAN_PROCEDURE); + ndbrequire(storedPtr.p->storedCounter == 0); + Uint32 firstAttrinbuf = storedPtr.p->storedLinkFirst; + storedPtr.p->storedCode = ZSTORED_PROCEDURE_FREE; + storedPtr.p->storedLinkFirst = RNIL; + storedPtr.p->storedLinkLast = RNIL; + storedPtr.p->storedProcLength = 0; + c_storedProcPool.release(storedPtr); + freeAttrinbufrec(firstAttrinbuf); + regOperPtr->currentAttrinbufLen = 0; + regOperPtr->transstate = IDLE; + signal->theData[0] = regOperPtr->userpointer; + signal->theData[1] = storedProcId; + sendSignal(regOperPtr->userblockref, GSN_STORED_PROCCONF, signal, 2, JBB); +}//Dbtup::deleteScanProcedure() + +void Dbtup::scanProcedure(Signal* signal, + Operationrec* regOperPtr, + Uint32 lenAttrInfo) +{ +//-------------------------------------------------------- +// We introduce the maxCheck so that there is always one +// stored procedure entry free for copy procedures. Thus +// no amount of scanning can cause problems for the node +// recovery functionality. +//-------------------------------------------------------- + StoredProcPtr storedPtr; + c_storedProcPool.seize(storedPtr); + ndbrequire(storedPtr.i != RNIL); + storedPtr.p->storedCode = ZSCAN_PROCEDURE; + storedPtr.p->storedCounter = 0; + storedPtr.p->storedProcLength = lenAttrInfo; + storedPtr.p->storedLinkFirst = RNIL; + storedPtr.p->storedLinkLast = RNIL; + regOperPtr->transstate = WAIT_STORED_PROCEDURE_ATTR_INFO; + regOperPtr->attrinbufLen = lenAttrInfo; + regOperPtr->currentAttrinbufLen = 0; + regOperPtr->pageOffset = storedPtr.i; +}//Dbtup::scanProcedure() + +void Dbtup::copyProcedure(Signal* signal, + TablerecPtr regTabPtr, + Operationrec* regOperPtr) +{ + Uint32 TnoOfAttributes = regTabPtr.p->noOfAttr; + scanProcedure(signal, + regOperPtr, + TnoOfAttributes); + + Uint32 length = 0; + for (Uint32 Ti = 0; Ti < TnoOfAttributes; Ti++) { + AttributeHeader::init(&signal->theData[length + 1], Ti, 0); + length++; + if (length == 24) { + ljam(); + ndbrequire(storedProcedureAttrInfo(signal, regOperPtr, length, 1, true)); + length = 0; + }//if + }//for + if (length != 0) { + ljam(); + ndbrequire(storedProcedureAttrInfo(signal, regOperPtr, length, 1, true)); + }//if + ndbrequire(regOperPtr->currentAttrinbufLen == 0); +}//Dbtup::copyProcedure() + +bool Dbtup::storedProcedureAttrInfo(Signal* signal, + Operationrec* regOperPtr, + Uint32 length, + Uint32 firstWord, + bool copyProcedure) +{ + AttrbufrecPtr regAttrPtr; + Uint32 RnoFree = cnoFreeAttrbufrec; + if (ERROR_INSERTED(4004) && !copyProcedure) { + CLEAR_ERROR_INSERT_VALUE; + storedSeizeAttrinbufrecErrorLab(signal, regOperPtr); + return false; + }//if + regOperPtr->currentAttrinbufLen += length; + ndbrequire(regOperPtr->currentAttrinbufLen <= regOperPtr->attrinbufLen); + if ((RnoFree > MIN_ATTRBUF) || + (copyProcedure)) { + ljam(); + regAttrPtr.i = cfirstfreeAttrbufrec; + ptrCheckGuard(regAttrPtr, cnoOfAttrbufrec, attrbufrec); + regAttrPtr.p->attrbuf[ZBUF_DATA_LEN] = 0; + cfirstfreeAttrbufrec = regAttrPtr.p->attrbuf[ZBUF_NEXT]; + cnoFreeAttrbufrec = RnoFree - 1; + regAttrPtr.p->attrbuf[ZBUF_NEXT] = RNIL; + } else { + ljam(); + storedSeizeAttrinbufrecErrorLab(signal, regOperPtr); + return false; + }//if + if (regOperPtr->firstAttrinbufrec == RNIL) { + ljam(); + regOperPtr->firstAttrinbufrec = regAttrPtr.i; + }//if + regAttrPtr.p->attrbuf[ZBUF_NEXT] = RNIL; + if (regOperPtr->lastAttrinbufrec != RNIL) { + AttrbufrecPtr tempAttrinbufptr; + ljam(); + tempAttrinbufptr.i = regOperPtr->lastAttrinbufrec; + ptrCheckGuard(tempAttrinbufptr, cnoOfAttrbufrec, attrbufrec); + tempAttrinbufptr.p->attrbuf[ZBUF_NEXT] = regAttrPtr.i; + }//if + regOperPtr->lastAttrinbufrec = regAttrPtr.i; + + regAttrPtr.p->attrbuf[ZBUF_DATA_LEN] = length; + MEMCOPY_NO_WORDS(®AttrPtr.p->attrbuf[0], + &signal->theData[firstWord], + length); + + if (regOperPtr->currentAttrinbufLen < regOperPtr->attrinbufLen) { + ljam(); + return true; + }//if + if (ERROR_INSERTED(4005) && !copyProcedure) { + CLEAR_ERROR_INSERT_VALUE; + storedSeizeAttrinbufrecErrorLab(signal, regOperPtr); + return false; + }//if + + StoredProcPtr storedPtr; + c_storedProcPool.getPtr(storedPtr, (Uint32)regOperPtr->pageOffset); + ndbrequire(storedPtr.p->storedCode == ZSCAN_PROCEDURE); + + regOperPtr->currentAttrinbufLen = 0; + storedPtr.p->storedLinkFirst = regOperPtr->firstAttrinbufrec; + storedPtr.p->storedLinkLast = regOperPtr->lastAttrinbufrec; + regOperPtr->firstAttrinbufrec = RNIL; + regOperPtr->lastAttrinbufrec = RNIL; + regOperPtr->transstate = IDLE; + signal->theData[0] = regOperPtr->userpointer; + signal->theData[1] = storedPtr.i; + sendSignal(regOperPtr->userblockref, GSN_STORED_PROCCONF, signal, 2, JBB); + return true; +}//Dbtup::storedProcedureAttrInfo() + +void Dbtup::storedSeizeAttrinbufrecErrorLab(Signal* signal, + Operationrec* regOperPtr) +{ + StoredProcPtr storedPtr; + c_storedProcPool.getPtr(storedPtr, (Uint32)regOperPtr->pageOffset); + ndbrequire(storedPtr.p->storedCode == ZSCAN_PROCEDURE); + + storedPtr.p->storedLinkFirst = regOperPtr->firstAttrinbufrec; + regOperPtr->firstAttrinbufrec = RNIL; + regOperPtr->lastAttrinbufrec = RNIL; + regOperPtr->transstate = ERROR_WAIT_STORED_PROCREQ; + signal->theData[0] = regOperPtr->userpointer; + signal->theData[1] = ZSTORED_SEIZE_ATTRINBUFREC_ERROR; + signal->theData[2] = regOperPtr->pageOffset; + sendSignal(regOperPtr->userblockref, GSN_STORED_PROCREF, signal, 3, JBB); +}//Dbtup::storedSeizeAttrinbufrecErrorLab() + diff --git a/ndb/src/kernel/blocks/dbtup/DbtupSystemRestart.cpp b/ndb/src/kernel/blocks/dbtup/DbtupSystemRestart.cpp new file mode 100644 index 00000000000..580d764c96f --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupSystemRestart.cpp @@ -0,0 +1,1003 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include +#include +#include +#include + +#define ljam() { jamLine(26000 + __LINE__); } +#define ljamEntry() { jamEntryLine(26000 + __LINE__); } + +/* **************************************************************** */ +/* ********************* SYSTEM RESTART MANAGER ******************* */ +/* **************************************************************** */ +/***************************************************************/ +/* CHECK RESTART STATE AND SET NEW STATE CALLED IN OPEN, */ +/* READ AND COPY STATES */ +/***************************************************************/ +void Dbtup::execTUP_SRREQ(Signal* signal) +{ + RestartInfoRecordPtr riPtr; + PendingFileOpenInfoPtr pfoiPtr; + + ljamEntry(); + Uint32 userPtr = signal->theData[0]; + Uint32 userBlockref = signal->theData[1]; + Uint32 tableId = signal->theData[2]; + Uint32 fragId = signal->theData[3]; + Uint32 checkpointNumber = signal->theData[4]; + + seizeRestartInfoRecord(riPtr); + + riPtr.p->sriUserptr = userPtr; + riPtr.p->sriBlockref = userBlockref; + riPtr.p->sriState = OPENING_DATA_FILE; + riPtr.p->sriCheckpointVersion = checkpointNumber; + riPtr.p->sriFragid = fragId; + riPtr.p->sriTableId = tableId; + + /* OPEN THE DATA FILE IN THE FOLLOWING FORM */ + /* D5/DBTUP/T/F/S.DATA */ + Uint32 fileType = 1; /* VERSION */ + fileType = (fileType << 8) | 0; /* .DATA */ + fileType = (fileType << 8) | 5; /* D5 */ + fileType = (fileType << 8) | 0xff; /* DON'T USE P DIRECTORY LEVEL */ + Uint32 fileFlag = 0; /* READ ONLY */ + + seizePendingFileOpenInfoRecord(pfoiPtr); + pfoiPtr.p->pfoOpenType = LCP_DATA_FILE_READ; + pfoiPtr.p->pfoRestartInfoP = riPtr.i; + + signal->theData[0] = cownref; + signal->theData[1] = pfoiPtr.i; + signal->theData[2] = tableId; + signal->theData[3] = fragId; + signal->theData[4] = checkpointNumber; + signal->theData[5] = fileType; + signal->theData[6] = fileFlag; + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA); + return; +}//Dbtup::execTUP_SRREQ() + +void Dbtup::seizeRestartInfoRecord(RestartInfoRecordPtr& riPtr) +{ + riPtr.i = cfirstfreeSri; + ptrCheckGuard(riPtr, cnoOfRestartInfoRec, restartInfoRecord); + cfirstfreeSri = riPtr.p->sriNextRec; + riPtr.p->sriNextRec = RNIL; +}//Dbtup::seizeRestartInfoRecord() + +void Dbtup::rfrReadRestartInfoLab(Signal* signal, RestartInfoRecordPtr riPtr) +{ + DiskBufferSegmentInfoPtr dbsiPtr; + + seizeDiskBufferSegmentRecord(dbsiPtr); + riPtr.p->sriDataBufferSegmentP = dbsiPtr.i; + Uint32 retPageRef; + Uint32 noAllocPages = 1; + Uint32 noOfPagesAllocated; + allocConsPages(noAllocPages, noOfPagesAllocated, retPageRef); + ndbrequire(noOfPagesAllocated == 1); + + dbsiPtr.p->pdxDataPage[0] = retPageRef; + dbsiPtr.p->pdxNumDataPages = 1; + dbsiPtr.p->pdxFilePage = 0; + rfrReadNextDataSegment(signal, riPtr, dbsiPtr); + dbsiPtr.p->pdxOperation = CHECKPOINT_DATA_READ_PAGE_ZERO; +}//Dbtup::rfrReadRestartInfoLab() + +/***************************************************************/ +/* THE RESTART INFORMATION IS NOW READ INTO THE DATA BUFFER */ +/* USE THE RESTART INFORMATION TO INITIATE THE RESTART RECORD */ +/***************************************************************/ +void +Dbtup::rfrInitRestartInfoLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr) +{ + Uint32 TzeroDataPage[64]; + Uint32 Ti; + FragrecordPtr regFragPtr; + LocalLogInfoPtr lliPtr; + PagePtr pagePtr; + RestartInfoRecordPtr riPtr; + TablerecPtr regTabPtr; + + riPtr.i = dbsiPtr.p->pdxRestartInfoP; + ptrCheckGuard(riPtr, cnoOfRestartInfoRec, restartInfoRecord); + + regTabPtr.i = riPtr.p->sriTableId; + ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec); + + Uint32 fragId = riPtr.p->sriFragid; + getFragmentrec(regFragPtr, fragId, regTabPtr.p); + riPtr.p->sriFragP = regFragPtr.i; + + /* ----- PAGE ALLOCATION --- */ + /* ALLOCATE PAGES TO FRAGMENT, INSERT THEM INTO PAGE RANGE TABLE AND */ + /* ALSO CONVERT THEM INTO EMPTY PAGES AND INSERT THEM INTO THE EMPTY LIST */ + /* OF THE FRAGMENT. SET ALL LISTS OF FREE PAGES TO RNIL */ + + ndbrequire(cfirstfreerange != RNIL); + pagePtr.i = dbsiPtr.p->pdxDataPage[0]; + ptrCheckGuard(pagePtr, cnoOfPage, page); + for (Ti = 0; Ti < 63; Ti++) { + /***************************************************************/ + // Save Important content from Page zero in stack variable so + // that we can immediately release page zero. + /***************************************************************/ + TzeroDataPage[Ti] = pagePtr.p->pageWord[Ti]; + }//for + /************************************************************************/ + /* NOW WE DON'T NEED THE RESTART INFO BUFFER PAGE ANYMORE */ + /* LETS REMOVE IT AND REUSE THE SEGMENT FOR REAL DATA PAGES */ + /* REMOVE ONE PAGE ONLY, PAGEP IS ALREADY SET TO THE RESTART INFO PAGE */ + /************************************************************************/ + returnCommonArea(pagePtr.i, 1); + + Uint32 undoFileVersion = TzeroDataPage[ZSRI_UNDO_FILE_VER]; + lliPtr.i = (undoFileVersion << 2) + (regTabPtr.i & 0x3); + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); + riPtr.p->sriLocalLogInfoP = lliPtr.i; + + ndbrequire(regFragPtr.p->fragTableId == regTabPtr.i); + ndbrequire(regFragPtr.p->fragmentId == fragId); + + regFragPtr.p->fragStatus = SYSTEM_RESTART; + + regFragPtr.p->noCopyPagesAlloc = TzeroDataPage[ZSRI_NO_COPY_PAGES_ALLOC]; + + riPtr.p->sriCurDataPageFromBuffer = 0; + riPtr.p->sriNumDataPages = TzeroDataPage[ZSRI_NO_OF_FRAG_PAGES_POS]; + + ndbrequire(riPtr.p->sriNumDataPages >= regFragPtr.p->noOfPages); + const Uint32 pageCount = riPtr.p->sriNumDataPages - regFragPtr.p->noOfPages; + if(pageCount > 0){ + Uint32 noAllocPages = allocFragPages(regFragPtr.p, pageCount); + ndbrequire(noAllocPages == pageCount); + }//if + ndbrequire(getNoOfPages(regFragPtr.p) == riPtr.p->sriNumDataPages); + +/***************************************************************/ +// Set the variables on fragment record which might have been +// affected by allocFragPages. +/***************************************************************/ + + regFragPtr.p->emptyPrimPage = TzeroDataPage[ZSRI_EMPTY_PRIM_PAGE]; + regFragPtr.p->thFreeFirst = TzeroDataPage[ZSRI_TH_FREE_FIRST]; + regFragPtr.p->thFreeCopyFirst = TzeroDataPage[ZSRI_TH_FREE_COPY_FIRST]; + +/***************************************************************/ +/* THE RESTART INFORMATION IS NOW READ INTO THE DATA BUFFER */ +/* USE THE RESTART INFORMATION TO INITIATE THE FRAGMENT */ +/***************************************************************/ + /** + * IF THIS UNDO FILE IS NOT OPEN, IT WILL BE OPENED HERE AND THE EXECUTION + * WILL CONTINUE WHEN THE FSOPENCONF IS ENTERED. + * IF IT'S ALREADY IN USE THE EXECUTION WILL CONTINUE BY A + * CONTINUE B SIGNAL + */ + if (lliPtr.p->lliActiveLcp == 0) { + PendingFileOpenInfoPtr pfoiPtr; + ljam(); +/***************************************************************/ +/* OPEN THE UNDO FILE FOR READ */ +/* THE FILE HANDLE WILL BE SET IN THE LOCAL_LOG_INFO_REC */ +/* UPON FSOPENCONF */ +/***************************************************************/ + cnoOfLocalLogInfo++; + /* F_LEVEL NOT USED */ + Uint32 fileType = 1; /* VERSION */ + fileType = (fileType << 8) | 2; /* .LOCLOG */ + fileType = (fileType << 8) | 6; /* D6 */ + fileType = (fileType << 8) | 0xff; /* DON'T USE P DIRECTORY LEVEL */ + Uint32 fileFlag = 0; /* READ ONLY */ + + seizePendingFileOpenInfoRecord(pfoiPtr); + pfoiPtr.p->pfoOpenType = LCP_UNDO_FILE_READ; + pfoiPtr.p->pfoRestartInfoP = riPtr.i; + + signal->theData[0] = cownref; + signal->theData[1] = pfoiPtr.i; + signal->theData[2] = lliPtr.i; + signal->theData[3] = 0xFFFFFFFF; + signal->theData[4] = undoFileVersion; + signal->theData[5] = fileType; + signal->theData[6] = fileFlag; + sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA); + + lliPtr.p->lliPrevRecordId = 0; + lliPtr.p->lliActiveLcp = 1; + lliPtr.p->lliNumFragments = 1; + } else { + ljam(); + signal->theData[0] = ZCONT_LOAD_DP; + signal->theData[1] = riPtr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + lliPtr.p->lliNumFragments++; + }//if + /* RETAIN THE HIGH- AND LOWSCORE ID:S OF THE LOGRECORD POSITIONS. WE HAVE TO EXECUTE THE */ + /* UNDO LOG BETWEEN THE END AND START RECORDS FOR ALL RECORDS THAT INCLUDE FRAGMENTS OF */ + /* THE RIGHT CHECKPOINT VERSION TO COMPLETE THE OPERATION WE HAVE TO RUN ALL LOGS THAT */ + /* HAS THE NUMBER OF LCP ELEMENT GREATER THAN 0, I.E. IS INCLUDED. */ + if (TzeroDataPage[ZSRI_UNDO_LOG_END_REC_ID] > lliPtr.p->lliPrevRecordId) { + ljam(); + lliPtr.p->lliPrevRecordId = TzeroDataPage[ZSRI_UNDO_LOG_END_REC_ID]; + lliPtr.p->lliEndPageId = TzeroDataPage[ZSRI_UNDO_LOG_END_PAGE_ID]; + }//if + return; +}//Dbtup::rfrInitRestartInfoLab() + +/***************************************************************/ +/* LOAD THE NEXT DATA PAGE SEGMENT INTO MEMORY */ +/***************************************************************/ +void Dbtup::rfrLoadDataPagesLab(Signal* signal, RestartInfoRecordPtr riPtr, DiskBufferSegmentInfoPtr dbsiPtr) +{ + FragrecordPtr regFragPtr; + + if (riPtr.p->sriCurDataPageFromBuffer >= riPtr.p->sriNumDataPages) { + ljam(); + rfrCompletedLab(signal, riPtr); + return; + }//if + Uint32 startPage = riPtr.p->sriCurDataPageFromBuffer; + Uint32 endPage; + if ((startPage + ZDB_SEGMENT_SIZE) < riPtr.p->sriNumDataPages) { + ljam(); + endPage = startPage + ZDB_SEGMENT_SIZE; + } else { + ljam(); + endPage = riPtr.p->sriNumDataPages; + }//if + regFragPtr.i = riPtr.p->sriFragP; + ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord); + ndbrequire((endPage - startPage) <= 16); + Uint32 i = 0; + for (Uint32 pageId = startPage; pageId < endPage; pageId++) { + ljam(); + dbsiPtr.p->pdxDataPage[i] = getRealpid(regFragPtr.p, pageId); + i++; + }//for + dbsiPtr.p->pdxNumDataPages = endPage - startPage; /* SET THE NUMBER OF DATA PAGES */ + riPtr.p->sriCurDataPageFromBuffer = endPage; + dbsiPtr.p->pdxFilePage = startPage + 1; + rfrReadNextDataSegment(signal, riPtr, dbsiPtr); + return; +}//Dbtup::rfrLoadDataPagesLab() + +void Dbtup::rfrCompletedLab(Signal* signal, RestartInfoRecordPtr riPtr) +{ + PendingFileOpenInfoPtr pfoPtr; +/* ---------------------------------------------------------------------- */ +/* CLOSE THE DATA FILE BEFORE SENDING TUP_SRCONF */ +/* ---------------------------------------------------------------------- */ + seizePendingFileOpenInfoRecord(pfoPtr); + pfoPtr.p->pfoOpenType = LCP_DATA_FILE_READ; + pfoPtr.p->pfoCheckpointInfoP = riPtr.i; + + signal->theData[0] = riPtr.p->sriDataFileHandle; + signal->theData[1] = cownref; + signal->theData[2] = pfoPtr.i; + signal->theData[3] = 0; + sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA); +}//Dbtup::rfrCompletedLab() + +void Dbtup::rfrClosedDataFileLab(Signal* signal, Uint32 restartIndex) +{ + RestartInfoRecordPtr riPtr; + DiskBufferSegmentInfoPtr dbsiPtr; + + riPtr.i = restartIndex; + ptrCheckGuard(riPtr, cnoOfRestartInfoRec, restartInfoRecord); + riPtr.p->sriDataFileHandle = RNIL; + dbsiPtr.i = riPtr.p->sriDataBufferSegmentP; + ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo); + releaseDiskBufferSegmentRecord(dbsiPtr); + signal->theData[0] = riPtr.p->sriUserptr; + signal->theData[1] = riPtr.p->sriFragP; + sendSignal(riPtr.p->sriBlockref, GSN_TUP_SRCONF, signal, 2, JBB); + releaseRestartInfoRecord(riPtr); +}//Dbtup::rfrClosedDataFileLab() + +/* ---------------------------------------------------------------- */ +/* ---------------------- EXECUTE LOCAL LOG ---------------------- */ +/* ---------------------------------------------------------------- */ +void Dbtup::execSTART_RECREQ(Signal* signal) +{ + ljamEntry(); + clqhUserpointer = signal->theData[0]; + clqhBlockref = signal->theData[1]; + + for (int i = 0; i < ZNO_CHECKPOINT_RECORDS; i++){ + cSrUndoRecords[i] = 0; + }//for + + if (cnoOfLocalLogInfo == 0) { + ljam(); +/* ---------------------------------------------------------------- */ +/* THERE WERE NO LOCAL LOGS TO EXECUTE IN THIS SYSTEM RESTART */ +/* ---------------------------------------------------------------- */ + xlcRestartCompletedLab(signal); + return; + }//if + LocalLogInfoPtr lliPtr; + for (lliPtr.i = 0; lliPtr.i < 16; lliPtr.i++) { + ljam(); + ptrAss(lliPtr, localLogInfo); + if (lliPtr.p->lliActiveLcp == 1) { + ljam(); + signal->theData[0] = ZSTART_EXEC_UNDO_LOG; + signal->theData[1] = lliPtr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + }//if + }//for + return; +}//Dbtup::execSTART_RECREQ() + +void Dbtup::closeExecUndoLogLab(Signal* signal, LocalLogInfoPtr lliPtr) +{ + PendingFileOpenInfoPtr pfoPtr; +/* ---------------------------------------------------------------------- */ +/* CLOSE THE UNDO LOG BEFORE COMPLETION OF THE SYSTEM RESTART */ +/* ---------------------------------------------------------------------- */ + seizePendingFileOpenInfoRecord(pfoPtr); + pfoPtr.p->pfoOpenType = LCP_UNDO_FILE_READ; + pfoPtr.p->pfoCheckpointInfoP = lliPtr.i; + + signal->theData[0] = lliPtr.p->lliUndoFileHandle; + signal->theData[1] = cownref; + signal->theData[2] = pfoPtr.i; + signal->theData[3] = 0; + sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA); + return; +}//Dbtup::closeExecUndoLogLab() + +void Dbtup::endExecUndoLogLab(Signal* signal, Uint32 lliIndex) +{ + DiskBufferSegmentInfoPtr dbsiPtr; + LocalLogInfoPtr lliPtr; + + lliPtr.i = lliIndex; + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); + lliPtr.p->lliUndoFileHandle = RNIL; + lliPtr.p->lliActiveLcp = 0; +/* ---------------------------------------------------------------------- */ +/* WE HAVE NOW CLOSED THE LOG. WE WAIT FOR ALL LOCAL LOGS TO */ +/* COMPLETE LOG EXECUTION BEFORE SENDING THE RESPONSE TO LQH. */ +/* ---------------------------------------------------------------------- */ + dbsiPtr.i = lliPtr.p->lliUndoBufferSegmentP; + ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo); + freeDiskBufferSegmentRecord(signal, dbsiPtr); + lliPtr.p->lliUndoBufferSegmentP = RNIL; + for (lliPtr.i = 0; lliPtr.i < 16; lliPtr.i++) { + ljam(); + ptrAss(lliPtr, localLogInfo); + if (lliPtr.p->lliActiveLcp == 1) { + ljam(); + return; + }//if + }//for + xlcRestartCompletedLab(signal); + return; +}//Dbtup::endExecUndoLogLab() + +void Dbtup::xlcRestartCompletedLab(Signal* signal) +{ + cnoOfLocalLogInfo = 0; + + signal->theData[0] = EventReport::UNDORecordsExecuted; + signal->theData[1] = DBTUP; // From block + signal->theData[2] = 0; // Total records executed + for (int i = 0; i < 10; i++) { + if (i < ZNO_CHECKPOINT_RECORDS){ + signal->theData[i+3] = cSrUndoRecords[i]; + signal->theData[2] += cSrUndoRecords[i]; + } else { + signal->theData[i+3] = 0; // Unsused data + }//if + }//for + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 12, JBB); + +/* ---------------------------------------------------------------------- */ +/* ALL LOCAL LOGS HAVE COMPLETED. WE HAVE COMPLETED OUR PART OF THE */ +/* SYSTEM RESTART. */ +/* ---------------------------------------------------------------------- */ + signal->theData[0] = clqhUserpointer; + sendSignal(clqhBlockref, GSN_START_RECCONF, signal, 1, JBB); + return; +}//Dbtup::xlcRestartCompletedLab() + +void Dbtup::startExecUndoLogLab(Signal* signal, Uint32 lliIndex) +{ + DiskBufferSegmentInfoPtr dbsiPtr; + LocalLogInfoPtr lliPtr; + +/* ---------------------------------------------------------------------- */ +/* START EXECUTING THE LOG FOR THIS PART. WE BEGIN BY READING THE */ +/* LAST 16 PAGES. */ +/* ---------------------------------------------------------------------- */ + /* SET THE PREVIOS RECORD TO THE LAST ONE BECAUSE THAT'S WHERE TO START */ + lliPtr.i = lliIndex; + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); + + allocRestartUndoBufferSegment(signal, dbsiPtr, lliPtr); + lliPtr.p->lliUndoBufferSegmentP = dbsiPtr.i; + dbsiPtr.p->pdxCheckpointInfoP = lliPtr.i; + if (lliPtr.p->lliEndPageId > ((2 * ZUB_SEGMENT_SIZE) - 1)) { + ljam(); + dbsiPtr.p->pdxNumDataPages = ZUB_SEGMENT_SIZE; + dbsiPtr.p->pdxFilePage = lliPtr.p->lliEndPageId - (ZUB_SEGMENT_SIZE - 1); + } else if (lliPtr.p->lliEndPageId > (ZUB_SEGMENT_SIZE - 1)) { + ljam(); + dbsiPtr.p->pdxNumDataPages = lliPtr.p->lliEndPageId - (ZUB_SEGMENT_SIZE - 1); + dbsiPtr.p->pdxFilePage = ZUB_SEGMENT_SIZE; + } else { + ljam(); + dbsiPtr.p->pdxNumDataPages = lliPtr.p->lliEndPageId + 1; + dbsiPtr.p->pdxFilePage = 0; + rfrReadNextUndoSegment(signal, dbsiPtr, lliPtr); + return; + }//if + rfrReadFirstUndoSegment(signal, dbsiPtr, lliPtr); + return; +}//Dbtup::startExecUndoLogLab() + +void Dbtup::rfrReadSecondUndoLogLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr) +{ + LocalLogInfoPtr lliPtr; + lliPtr.i = dbsiPtr.p->pdxCheckpointInfoP; + ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo); + + dbsiPtr.p->pdxNumDataPages = ZUB_SEGMENT_SIZE; + dbsiPtr.p->pdxFilePage -= ZUB_SEGMENT_SIZE; + rfrReadNextUndoSegment(signal, dbsiPtr, lliPtr); + return; +}//Dbtup::rfrReadSecondUndoLogLab() + +void Dbtup::readExecUndoLogLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr) +{ +/* ---------------------------------------------------------------------- */ +/* THE NEXT UNDO LOG RECORD HAS NOT BEEN READ FROM DISK YET. WE WILL*/ +/* READ UPTO 8 PAGES BACKWARDS OF THE UNDO LOG FILE. WE WILL KEEP */ +/* THE LAST 8 PAGES TO ENSURE THAT WE WILL BE ABLE TO READ THE NEXT */ +/* LOG RECORD EVEN IF IT SPANS UPTO 8 PAGES. */ +/* ---------------------------------------------------------------------- */ + if (dbsiPtr.p->pdxFilePage >= ZUB_SEGMENT_SIZE) { + ljam(); + for (Uint32 i = 0; i < ZUB_SEGMENT_SIZE; i++) { + ljam(); + Uint32 savePageId = dbsiPtr.p->pdxDataPage[i + ZUB_SEGMENT_SIZE]; + dbsiPtr.p->pdxDataPage[i + ZUB_SEGMENT_SIZE] = dbsiPtr.p->pdxDataPage[i]; + dbsiPtr.p->pdxDataPage[i] = savePageId; + }//for + dbsiPtr.p->pdxNumDataPages = ZUB_SEGMENT_SIZE; + dbsiPtr.p->pdxFilePage = dbsiPtr.p->pdxFilePage - ZUB_SEGMENT_SIZE; + } else { + ljam(); + Uint32 dataPages[16]; + ndbrequire(dbsiPtr.p->pdxFilePage > 0); + ndbrequire(dbsiPtr.p->pdxFilePage <= ZUB_SEGMENT_SIZE); + for (Uint32 i = 0; i < dbsiPtr.p->pdxFilePage; i++) { + ljam(); + dataPages[i] = dbsiPtr.p->pdxDataPage[i + ZUB_SEGMENT_SIZE]; + }//for + for (Uint32 i = 0; i < ZUB_SEGMENT_SIZE; i++) { + ljam(); + dataPages[i + dbsiPtr.p->pdxFilePage] = dbsiPtr.p->pdxDataPage[i]; + }//for + Uint32 limitLoop = ZUB_SEGMENT_SIZE + dbsiPtr.p->pdxFilePage; + for (Uint32 i = 0; i < limitLoop; i++) { + ljam(); + dbsiPtr.p->pdxDataPage[i] = dataPages[i]; + }//for + dbsiPtr.p->pdxNumDataPages = dbsiPtr.p->pdxFilePage; + dbsiPtr.p->pdxFilePage = 0; + }//if + rfrReadNextUndoSegment(signal, dbsiPtr, lliPtr); + return; +}//Dbtup::readExecUndoLogLab() + +void Dbtup::rfrReadNextDataSegment(Signal* signal, RestartInfoRecordPtr riPtr, DiskBufferSegmentInfoPtr dbsiPtr) +{ + dbsiPtr.p->pdxRestartInfoP = riPtr.i; + dbsiPtr.p->pdxOperation = CHECKPOINT_DATA_READ; + ndbrequire(dbsiPtr.p->pdxNumDataPages <= 8); + + signal->theData[0] = riPtr.p->sriDataFileHandle; + signal->theData[1] = cownref; + signal->theData[2] = dbsiPtr.i; + signal->theData[3] = 2; + signal->theData[4] = ZBASE_ADDR_PAGE_WORD; + signal->theData[5] = dbsiPtr.p->pdxNumDataPages; + for (Uint32 i = 0; i < dbsiPtr.p->pdxNumDataPages; i++) { + ljam(); + signal->theData[6 + i] = dbsiPtr.p->pdxDataPage[i]; + }//for + signal->theData[6 + dbsiPtr.p->pdxNumDataPages] = dbsiPtr.p->pdxFilePage; + sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 15, JBA); +}//Dbtup::rfrReadNextDataSegment() + +/* ---------------------------------------------------------------- */ +/* ------------------- RFR_READ_FIRST_UNDO_SEGMENT ---------------- */ +/* ---------------------------------------------------------------- */ +/* THIS ROUTINE READS IN THE FIRST UNDO SEGMENT INTO THE CURRENTLY */ +/* ACTIVE UNDO BUFFER SEGMENT */ +/* -----------------------------------------------------------------*/ +void Dbtup::rfrReadFirstUndoSegment(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr) +{ + dbsiPtr.p->pdxOperation = CHECKPOINT_UNDO_READ_FIRST; + + signal->theData[0] = lliPtr.p->lliUndoFileHandle; + signal->theData[1] = cownref; + signal->theData[2] = dbsiPtr.i; + signal->theData[3] = 1; + signal->theData[4] = ZBASE_ADDR_UNDO_WORD; + signal->theData[5] = dbsiPtr.p->pdxNumDataPages; + signal->theData[6] = dbsiPtr.p->pdxDataPage[ZUB_SEGMENT_SIZE]; + signal->theData[7] = dbsiPtr.p->pdxFilePage; + sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 8, JBA); +}//Dbtup::rfrReadFirstUndoSegment() + +/* ---------------------------------------------------------------- */ +/* ------------------- RFR_READ_NEXT_UNDO_SEGMENT ----------------- */ +/* ---------------------------------------------------------------- */ +/* THIS ROUTINE READS IN THE NEXT UNDO SEGMENT INTO THE CURRENTLY */ +/* ACTIVE UNDO BUFFER SEGMENT AND SWITCH TO THE UNACTIVE, READY ONE */ +/* -----------------------------------------------------------------*/ +void Dbtup::rfrReadNextUndoSegment(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr) +{ + dbsiPtr.p->pdxOperation = CHECKPOINT_UNDO_READ; + + signal->theData[0] = lliPtr.p->lliUndoFileHandle; + signal->theData[1] = cownref; + signal->theData[2] = dbsiPtr.i; + signal->theData[3] = 1; + signal->theData[4] = ZBASE_ADDR_UNDO_WORD; + signal->theData[5] = dbsiPtr.p->pdxNumDataPages; + signal->theData[6] = dbsiPtr.p->pdxDataPage[0]; + signal->theData[7] = dbsiPtr.p->pdxFilePage; + sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 8, JBA); +}//Dbtup::rfrReadNextUndoSegment() + +void Dbtup::xlcGetNextRecordLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr) +{ + Uint32 loopCount = 0; +/* ---------------------------------------------------------------------- */ +/* EXECUTE A NEW SET OF UNDO LOG RECORDS. */ +/* ---------------------------------------------------------------------- */ + XlcStruct xlcStruct; + + xlcStruct.LliPtr = lliPtr; + xlcStruct.DbsiPtr = dbsiPtr; + + do { + ljam(); + loopCount++; + if (loopCount == 20) { + ljam(); + signal->theData[0] = ZCONT_EXECUTE_LC; + signal->theData[1] = xlcStruct.LliPtr.i; + sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB); + return; + }//if + if (xlcStruct.LliPtr.p->lliPrevRecordId == 0) { + ljam(); + closeExecUndoLogLab(signal, xlcStruct.LliPtr); + return; + }//if + xlcStruct.PageId = xlcStruct.LliPtr.p->lliPrevRecordId >> ZUNDO_RECORD_ID_PAGE_INDEX; + xlcStruct.PageIndex = xlcStruct.LliPtr.p->lliPrevRecordId & ZUNDO_RECORD_ID_PAGE_INDEX_MASK; + if (xlcStruct.PageId < xlcStruct.DbsiPtr.p->pdxFilePage) { + ljam(); + readExecUndoLogLab(signal, xlcStruct.DbsiPtr, xlcStruct.LliPtr); + return; + }//if + ndbrequire((xlcStruct.PageId - xlcStruct.DbsiPtr.p->pdxFilePage) < 16); + xlcStruct.UPPtr.i = xlcStruct.DbsiPtr.p->pdxDataPage[xlcStruct.PageId - xlcStruct.DbsiPtr.p->pdxFilePage]; + ptrCheckGuard(xlcStruct.UPPtr, cnoOfUndoPage, undoPage); + xlcGetLogHeader(xlcStruct); + getFragmentrec(xlcStruct.FragPtr, xlcStruct.FragId, xlcStruct.TabPtr.p); + if (xlcStruct.FragPtr.i == RNIL) { + ljam(); + continue; + }//if + if (xlcStruct.FragPtr.p->fragStatus != SYSTEM_RESTART) { + ljam(); + continue; + }//if + ndbrequire(xlcStruct.LogRecordType < ZNO_CHECKPOINT_RECORDS); + cSrUndoRecords[xlcStruct.LogRecordType]++; + switch (xlcStruct.LogRecordType) { + case ZLCPR_TYPE_INSERT_TH: + ljam(); + xlcInsertTh(xlcStruct); + break; + case ZLCPR_TYPE_DELETE_TH: + ljam(); + xlcDeleteTh(xlcStruct); + break; + case ZLCPR_TYPE_UPDATE_TH: + ljam(); + xlcUpdateTh(xlcStruct); + break; + case ZLCPR_TYPE_INSERT_TH_NO_DATA: + ljam(); + xlcInsertTh(xlcStruct); + break; + case ZLCPR_ABORT_UPDATE: + ljam(); + xlcAbortUpdate(signal, xlcStruct); + break; + case ZLCPR_ABORT_INSERT: + ljam(); + xlcAbortInsert(signal, xlcStruct); + break; + case ZTABLE_DESCRIPTOR: + ljam(); + xlcTableDescriptor(xlcStruct); + if (xlcStruct.LliPtr.p->lliNumFragments == 0) { + ljam(); + closeExecUndoLogLab(signal, xlcStruct.LliPtr); + return; + }//if + break; + case ZLCPR_UNDO_LOG_PAGE_HEADER: + ljam(); + xlcUndoLogPageHeader(xlcStruct); + break; + case ZINDICATE_NO_OP_ACTIVE: + ljam(); + xlcIndicateNoOpActive(xlcStruct); + break; + case ZLCPR_TYPE_UPDATE_GCI: + ljam(); + xlcUpdateGCI(xlcStruct); + break; + default: + ndbrequire(false); + break; + }//switch + } while (1); +}//Dbtup::xlcGetNextRecordLab() + +/* ---------------------------------------------------------------- */ +/* ----------------- XLC_GET_LOG_HEADER ---------------------- */ +/* ---------------------------------------------------------------- */ +void Dbtup::xlcGetLogHeader(XlcStruct& xlcStruct) +{ + Uint32 pIndex = xlcStruct.PageIndex; + Uint32 fragId; + Uint32 tableId; + Uint32 prevId; + if ((pIndex + 4) < ZWORDS_ON_PAGE) { + UndoPage* const regUndoPagePtr = xlcStruct.UPPtr.p; + ljam(); + xlcStruct.LogRecordType = regUndoPagePtr->undoPageWord[pIndex]; + prevId = regUndoPagePtr->undoPageWord[pIndex + 1]; + tableId = regUndoPagePtr->undoPageWord[pIndex + 2]; + fragId = regUndoPagePtr->undoPageWord[pIndex + 3]; + xlcStruct.PageIndex = pIndex + 4; + } else { + ljam(); + xlcStruct.LogRecordType = xlcGetLogWord(xlcStruct); + prevId = xlcGetLogWord(xlcStruct); + tableId = xlcGetLogWord(xlcStruct); + fragId = xlcGetLogWord(xlcStruct); + }//if + xlcStruct.LliPtr.p->lliPrevRecordId = prevId; + xlcStruct.FragId = fragId; + xlcStruct.TabPtr.i = tableId; + ptrCheckGuard(xlcStruct.TabPtr, cnoOfTablerec, tablerec); +}//Dbtup::xlcGetLogHeader() + +/* ------------------------------------------------------------------- */ +/* ---------------------- XLC_GET_LOG_WORD --------------------------- */ +/* ------------------------------------------------------------------- */ +Uint32 Dbtup::xlcGetLogWord(XlcStruct& xlcStruct) +{ + Uint32 pIndex = xlcStruct.PageIndex; + ndbrequire(xlcStruct.UPPtr.p != NULL); + ndbrequire(pIndex < ZWORDS_ON_PAGE); + Uint32 logWord = xlcStruct.UPPtr.p->undoPageWord[pIndex]; + pIndex++; + xlcStruct.PageIndex = pIndex; + if (pIndex == ZWORDS_ON_PAGE) { + ljam(); + xlcStruct.PageIndex = ZUNDO_PAGE_HEADER_SIZE; + xlcStruct.PageId++; + if ((xlcStruct.PageId - xlcStruct.DbsiPtr.p->pdxFilePage) >= (2 * ZUB_SEGMENT_SIZE)) { + ljam(); + xlcStruct.UPPtr.i = RNIL; + ptrNull(xlcStruct.UPPtr); + } else { + ljam(); + Uint32 index = xlcStruct.PageId - xlcStruct.DbsiPtr.p->pdxFilePage; + ndbrequire(index < 16); + xlcStruct.UPPtr.i = xlcStruct.DbsiPtr.p->pdxDataPage[index]; + ptrCheckGuard(xlcStruct.UPPtr, cnoOfUndoPage, undoPage); + }//if + }//if + return logWord; +}//Dbtup::xlcGetLogWord() + + /****************************************************/ + /* INSERT A TUPLE HEADER THE DATA IS THE TUPLE DATA */ + /****************************************************/ +void Dbtup::xlcInsertTh(XlcStruct& xlcStruct) +{ + PagePtr pagePtr; + Fragrecord* const regFragPtr = xlcStruct.FragPtr.p; + Tablerec* const regTabPtr = xlcStruct.TabPtr.p; + + Uint32 fragPageId = xlcGetLogWord(xlcStruct); + Uint32 pageIndex = xlcGetLogWord(xlcStruct); + ndbrequire((pageIndex & 1) == 0); + pagePtr.i = getRealpid(regFragPtr, fragPageId); + ptrCheckGuard(pagePtr, cnoOfPage, page); + Uint32 pageOffset; + getThAtPageSr(pagePtr.p, pageOffset); + ndbrequire(pageOffset == (ZPAGE_HEADER_SIZE + (regTabPtr->tupheadsize * (pageIndex >> 1)))); + if (xlcStruct.LogRecordType == ZLCPR_TYPE_INSERT_TH) { + ljam(); + xlcCopyData(xlcStruct, pageOffset, regTabPtr->tupheadsize, pagePtr); + } else { + ndbrequire(xlcStruct.LogRecordType == ZLCPR_TYPE_INSERT_TH_NO_DATA); + ljam(); + }//if +/* ----------------------------------------*/ +/* INDICATE THAT NO OPERATIONS ACTIVE */ +/* ----------------------------------------*/ + ndbrequire(pageOffset < ZWORDS_ON_PAGE); + pagePtr.p->pageWord[pageOffset] = RNIL; +}//Dbtup::xlcInsertTh() + + /**********************************************/ + /* DELETE A TUPLE HEADER - NO ADDITIONAL DATA */ + /**********************************************/ +void Dbtup::xlcDeleteTh(XlcStruct& xlcStruct) +{ + PagePtr pagePtr; + Fragrecord* const regFragPtr = xlcStruct.FragPtr.p; + Tablerec* const regTabPtr = xlcStruct.TabPtr.p; + + Uint32 fragPageId = xlcGetLogWord(xlcStruct); + Uint32 pageIndex = xlcGetLogWord(xlcStruct); + ndbrequire((pageIndex & 1) == 0); + pagePtr.i = getRealpid(regFragPtr, fragPageId); + ptrCheckGuard(pagePtr, cnoOfPage, page); + Uint32 pageOffset = ZPAGE_HEADER_SIZE + (regTabPtr->tupheadsize * (pageIndex >> 1)); + freeThSr(regTabPtr, pagePtr.p, pageOffset); +}//Dbtup::xlcDeleteTh() + + /*****************************************************/ + /* UPDATE A TUPLE HEADER, THE DATA IS THE TUPLE DATA */ + /*****************************************************/ +void Dbtup::xlcUpdateTh(XlcStruct& xlcStruct) +{ + PagePtr pagePtr; + Fragrecord* const regFragPtr = xlcStruct.FragPtr.p; + Tablerec* const regTabPtr = xlcStruct.TabPtr.p; + + Uint32 fragPageId = xlcGetLogWord(xlcStruct); + Uint32 pageIndex = xlcGetLogWord(xlcStruct); + ndbrequire((pageIndex & 1) == 0); + pagePtr.i = getRealpid(regFragPtr, fragPageId); + ptrCheckGuard(pagePtr, cnoOfPage, page); + Uint32 pageOffset = ZPAGE_HEADER_SIZE + (regTabPtr->tupheadsize * (pageIndex >> 1)); + xlcCopyData(xlcStruct, pageOffset, regTabPtr->tupheadsize, pagePtr); +/* ----------------------------------------*/ +/* INDICATE THAT NO OPERATIONS ACTIVE */ +/* ----------------------------------------*/ + ndbrequire(pageOffset < ZWORDS_ON_PAGE); + pagePtr.p->pageWord[pageOffset] = RNIL; +}//Dbtup::xlcUpdateTh() + + /**************************************************/ + /* ABORT AN INSERT OPERATION - NO ADDITIONAL DATA */ + /**************************************************/ +void Dbtup::xlcAbortInsert(Signal* signal, XlcStruct& xlcStruct) +{ + PagePtr pagePtr; + Fragrecord* const regFragPtr = xlcStruct.FragPtr.p; + Tablerec* const regTabPtr = xlcStruct.TabPtr.p; + + Uint32 fragPageId = xlcGetLogWord(xlcStruct); + Uint32 pageIndex = xlcGetLogWord(xlcStruct); + ndbrequire((pageIndex & 1) == 0); + pagePtr.i = getRealpid(regFragPtr, fragPageId); + ptrCheckGuard(pagePtr, cnoOfPage, page); + Uint32 pageOffset = ZPAGE_HEADER_SIZE + (regTabPtr->tupheadsize * (pageIndex >> 1)); + freeTh(regFragPtr, regTabPtr, signal, pagePtr.p, pageOffset); +}//Dbtup::xlcAbortInsert() + + /*****************************************************/ + /* COPY DATA FROM COPY TUPLE TO ORIGINAL TUPLE */ + /*****************************************************/ +void Dbtup::xlcAbortUpdate(Signal* signal, XlcStruct& xlcStruct) +{ + PagePtr pagePtr; + Fragrecord* const regFragPtr = xlcStruct.FragPtr.p; + Tablerec* const regTabPtr = xlcStruct.TabPtr.p; + Uint32 tuple_size = regTabPtr->tupheadsize; + + Uint32 fragPageIdC = xlcGetLogWord(xlcStruct); + Uint32 pageIndexC = xlcGetLogWord(xlcStruct); + ndbrequire((pageIndexC & 1) == 0); + Uint32 TdestPageId = getRealpid(regFragPtr, fragPageIdC); + Uint32 TcmDestIndex = ZPAGE_HEADER_SIZE + + (tuple_size * (pageIndexC >> 1)); + + Uint32 fragPageId = xlcGetLogWord(xlcStruct); + Uint32 pageIndex = xlcGetLogWord(xlcStruct); + ndbrequire((pageIndex & 1) == 0); + Uint32 TsourcePageId = getRealpid(regFragPtr, fragPageId); + Uint32 TcmSourceIndex = ZPAGE_HEADER_SIZE + + (tuple_size * (pageIndex >> 1)); + Uint32 end_source = tuple_size + TcmSourceIndex; + Uint32 end_dest = tuple_size + TcmDestIndex; + + void* Tdestination = (void*)&page[TdestPageId].pageWord[TcmDestIndex + 1]; + const void* Tsource = + (void*)&page[TsourcePageId].pageWord[TcmSourceIndex + 1]; + + ndbrequire(TsourcePageId < cnoOfPage && + TdestPageId < cnoOfPage && + end_source <= ZWORDS_ON_PAGE && + end_dest <= ZWORDS_ON_PAGE); + MEMCOPY_NO_WORDS(Tdestination, Tsource, (tuple_size - 1)); + + pagePtr.i = TsourcePageId; + ptrAss(pagePtr, page); + freeTh(regFragPtr, regTabPtr, signal, pagePtr.p, TcmSourceIndex); + + pagePtr.i = TdestPageId; + ptrAss(pagePtr, page); + pagePtr.p->pageWord[TcmDestIndex] = RNIL; +}//Dbtup::xlcAbortUpdate() + + /*****************************/ + /* RESTORE UPDATED GCI VALUE */ + /*****************************/ +void Dbtup::xlcUpdateGCI(XlcStruct& xlcStruct) +{ + PagePtr pagePtr; + Fragrecord* const regFragPtr = xlcStruct.FragPtr.p; + Tablerec* const regTabPtr = xlcStruct.TabPtr.p; + + Uint32 fragPageId = xlcGetLogWord(xlcStruct); + Uint32 pageIndex = xlcGetLogWord(xlcStruct); + Uint32 restoredGCI = xlcGetLogWord(xlcStruct); + + ndbrequire((pageIndex & 1) == 0); + pagePtr.i = getRealpid(regFragPtr, fragPageId); + ptrCheckGuard(pagePtr, cnoOfPage, page); + Uint32 pageOffset = ZPAGE_HEADER_SIZE + (regTabPtr->tupheadsize * (pageIndex >> 1)); + Uint32 gciOffset = pageOffset + regTabPtr->tupGCPIndex; + ndbrequire((gciOffset < ZWORDS_ON_PAGE) && + (regTabPtr->tupGCPIndex < regTabPtr->tupheadsize)); + pagePtr.p->pageWord[gciOffset] = restoredGCI; +}//Dbtup::xlcUpdateGCI() + + /*****************************************************/ + /* READ TABLE DESCRIPTOR FROM UNDO LOG */ + /*****************************************************/ +void Dbtup::xlcTableDescriptor(XlcStruct& xlcStruct) +{ + xlcStruct.LliPtr.p->lliNumFragments--; + xlcStruct.FragPtr.p->fragStatus = ACTIVE; +}//Dbtup::xlcTableDescriptor() + + /********************************************************/ + /* UPDATE PAGE STATE AND NEXT POINTER IN PAGE */ + /********************************************************/ +void Dbtup::xlcUndoLogPageHeader(XlcStruct& xlcStruct) +{ + Fragrecord* const regFragPtr = xlcStruct.FragPtr.p; + PagePtr xlcPagep; + + Uint32 fragPageId = xlcGetLogWord(xlcStruct); + xlcPagep.i = getRealpid(regFragPtr, fragPageId); + ptrCheckGuard(xlcPagep, cnoOfPage, page); + Uint32 logWord = xlcGetLogWord(xlcStruct); + ndbrequire(logWord != 0); + ndbrequire(logWord <= ZAC_MM_FREE_COPY); + + xlcPagep.p->pageWord[ZPAGE_STATE_POS] = logWord; + xlcPagep.p->pageWord[ZPAGE_NEXT_POS] = xlcGetLogWord(xlcStruct); +}//Dbtup::xlcUndoLogPageHeader() + + /********************************************************/ + /* INDICATE THAT NO OPERATIONS ACTIVE */ + /********************************************************/ +void Dbtup::xlcIndicateNoOpActive(XlcStruct& xlcStruct) +{ + PagePtr pagePtr; + Fragrecord* const regFragPtr = xlcStruct.FragPtr.p; + Tablerec* const regTabPtr = xlcStruct.TabPtr.p; + + Uint32 fragPageId = xlcGetLogWord(xlcStruct); + Uint32 pageIndex = xlcGetLogWord(xlcStruct); + ndbrequire((pageIndex & 1) == 0); + pagePtr.i = getRealpid(regFragPtr, fragPageId); + ptrCheckGuard(pagePtr, cnoOfPage, page); + Uint32 pageOffset = ZPAGE_HEADER_SIZE + (regTabPtr->tupheadsize * (pageIndex >> 1)); +/* ----------------------------------------*/ +/* INDICATE THAT NO OPERATIONS ACTIVE */ +/* ----------------------------------------*/ + ndbrequire(pageOffset < ZWORDS_ON_PAGE); + pagePtr.p->pageWord[pageOffset] = RNIL; +}//Dbtup::xlcIndicateNoOpActive() + + /********************************************************/ + /* THIS IS THE COMMON ROUTINE TO COPY DATA FROM THE */ + /* UNDO BUFFER TO THE DATA PAGES. IT USES THE */ + /* XLC_REQUEST_SEGMENT SUB TO GET MORE DATA WHEN NEEDED */ + /********************************************************/ +void Dbtup::xlcCopyData(XlcStruct& xlcStruct, Uint32 pageOffset, Uint32 noOfWords, PagePtr pagePtr) +{ + ndbrequire((pageOffset + noOfWords - 1) < ZWORDS_ON_PAGE); + for (Uint32 i = 1; i < noOfWords; i++) { + ljam(); + pagePtr.p->pageWord[pageOffset + i] = xlcGetLogWord(xlcStruct); + }//for +}//Dbtup::xlcCopyData() + +void Dbtup::allocRestartUndoBufferSegment(Signal* signal, DiskBufferSegmentInfoPtr& dbsiPtr, LocalLogInfoPtr lliPtr) +{ + UndoPagePtr undoPagePtr; + + ndbrequire(cfirstfreeUndoSeg != RNIL); + if (cnoFreeUndoSeg == ZMIN_PAGE_LIMIT_TUP_COMMITREQ) { + EXECUTE_DIRECT(DBLQH, GSN_TUP_COM_BLOCK, signal, 1); + ljamEntry(); + }//if + cnoFreeUndoSeg--; + ndbrequire(cnoFreeUndoSeg >= 0); + undoPagePtr.i = cfirstfreeUndoSeg; + ptrCheckGuard(undoPagePtr, cnoOfUndoPage, undoPage); + cfirstfreeUndoSeg = undoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS]; + undoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS] = RNIL; + seizeDiskBufferSegmentRecord(dbsiPtr); + dbsiPtr.p->pdxBuffertype = UNDO_RESTART_PAGES; + dbsiPtr.p->pdxUndoBufferSet[0] = undoPagePtr.i; + for (Uint32 i = 0; i < ZUB_SEGMENT_SIZE; i++) { + dbsiPtr.p->pdxDataPage[i] = undoPagePtr.i + i; + }//for + + ndbrequire(cfirstfreeUndoSeg != RNIL); + if (cnoFreeUndoSeg == ZMIN_PAGE_LIMIT_TUP_COMMITREQ) { + EXECUTE_DIRECT(DBLQH, GSN_TUP_COM_BLOCK, signal, 1); + ljamEntry(); + }//if + cnoFreeUndoSeg--; + ndbrequire(cnoFreeUndoSeg >= 0); + undoPagePtr.i = cfirstfreeUndoSeg; + ptrCheckGuard(undoPagePtr, cnoOfUndoPage, undoPage); + cfirstfreeUndoSeg = undoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS]; + undoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS] = RNIL; + dbsiPtr.p->pdxUndoBufferSet[1] = undoPagePtr.i; +// lliPtr.p->lliUndoPage = undoPagePtr.i; + for (Uint32 i = ZUB_SEGMENT_SIZE; i < (2 * ZUB_SEGMENT_SIZE); i++) { + dbsiPtr.p->pdxDataPage[i] = undoPagePtr.i + (i - ZUB_SEGMENT_SIZE); + }//for + return; +}//Dbtup::allocRestartUndoBufferSegment() + + diff --git a/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp b/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp new file mode 100644 index 00000000000..d31ab43f108 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp @@ -0,0 +1,191 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include + +#define ljam() { jamLine(22000 + __LINE__); } +#define ljamEntry() { jamEntryLine(22000 + __LINE__); } + +/* **************************************************************** */ +/* *********** TABLE DESCRIPTOR MEMORY MANAGER ******************** */ +/* **************************************************************** */ +/* This module is used to allocate and deallocate table descriptor */ +/* memory attached to fragments (could be allocated per table */ +/* instead. Performs its task by a buddy algorithm. */ +/* **************************************************************** */ +Uint32 Dbtup::allocTabDescr(Uint32 noOfAttributes, Uint32 noOfKeyAttr, Uint32 noOfAttributeGroups) +{ + Uint32 reference = RNIL; + Uint32 allocSize = (ZTD_SIZE + ZTD_TRAILER_SIZE) + (noOfAttributes * ZAD_SIZE); + allocSize += noOfAttributeGroups; + allocSize += ((2 * noOfAttributes * sizeOfReadFunction()) + noOfKeyAttr); +/* ---------------------------------------------------------------- */ +/* ALWAYS ALLOCATE A MULTIPLE OF 16 BYTES */ +/* ---------------------------------------------------------------- */ + allocSize = (((allocSize - 1) >> 4) + 1) << 4; + Uint32 list = nextHigherTwoLog(allocSize - 1); /* CALCULATE WHICH LIST IT BELONGS TO */ + for (Uint32 i = list; i < 16; i++) { + ljam(); + if (cfreeTdList[i] != RNIL) { + ljam(); + reference = cfreeTdList[i]; + removeTdArea(reference, i); /* REMOVE THE AREA FROM THE FREELIST */ + Uint32 retNo = (1 << i) - allocSize; /* CALCULATE THE DIFFERENCE */ + if (retNo >= ZTD_FREE_SIZE) { + ljam(); + Uint32 retRef = reference + allocSize; /* SET THE RETURN POINTER */ + retNo = itdaMergeTabDescr(retRef, retNo); /* MERGE WITH POSSIBLE RIGHT NEIGHBOURS */ + freeTabDescr(retRef, retNo); /* RETURN UNUSED TD SPACE TO THE TD AREA */ + } else { + ljam(); + allocSize = 1 << i; + }//if + break; + }//if + }//for + if (reference == RNIL) { + ljam(); + terrorCode = ZMEM_NOTABDESCR_ERROR; + return RNIL; + } else { + ljam(); + setTabDescrWord((reference + allocSize) - ZTD_TR_TYPE, ZTD_TYPE_NORMAL); + setTabDescrWord(reference + ZTD_DATASIZE, allocSize); + + /* INITIALIZE THE TRAILER RECORD WITH TYPE AND SIZE */ + /* THE TRAILER IS USED TO SIMPLIFY MERGE OF FREE AREAS */ + + setTabDescrWord(reference + ZTD_HEADER, ZTD_TYPE_NORMAL); + setTabDescrWord((reference + allocSize) - ZTD_TR_SIZE, allocSize); + return reference; + }//if +}//Dbtup::allocTabDescr() + +void Dbtup::freeTabDescr(Uint32 retRef, Uint32 retNo) +{ + while (retNo >= ZTD_FREE_SIZE) { + ljam(); + Uint32 list = nextHigherTwoLog(retNo); + list--; /* RETURN TO NEXT LOWER LIST */ + Uint32 sizeOfChunk = 1 << list; + insertTdArea(sizeOfChunk, retRef, list); + retRef += sizeOfChunk; + retNo -= sizeOfChunk; + }//while +}//Dbtup::freeTabDescr() + +Uint32 +Dbtup::getTabDescrWord(Uint32 index) +{ + ndbrequire(index < cnoOfTabDescrRec); + return tableDescriptor[index].tabDescr; +}//Dbtup::getTabDescrWord() + +void +Dbtup::setTabDescrWord(Uint32 index, Uint32 word) +{ + ndbrequire(index < cnoOfTabDescrRec); + tableDescriptor[index].tabDescr = word; +}//Dbtup::setTabDescrWord() + +void Dbtup::insertTdArea(Uint32 sizeOfChunk, Uint32 tabDesRef, Uint32 list) +{ + ndbrequire(list < 16); + setTabDescrWord(tabDesRef + ZTD_FL_HEADER, ZTD_TYPE_FREE); + setTabDescrWord(tabDesRef + ZTD_FL_NEXT, cfreeTdList[list]); + if (cfreeTdList[list] != RNIL) { + ljam(); /* PREVIOUSLY EMPTY SLOT */ + setTabDescrWord(cfreeTdList[list] + ZTD_FL_PREV, tabDesRef); + }//if + cfreeTdList[list] = tabDesRef; /* RELINK THE LIST */ + + setTabDescrWord(tabDesRef + ZTD_FL_PREV, RNIL); + setTabDescrWord(tabDesRef + ZTD_FL_SIZE, 1 << list); + setTabDescrWord((tabDesRef + (1 << list)) - ZTD_TR_TYPE, ZTD_TYPE_FREE); + setTabDescrWord((tabDesRef + (1 << list)) - ZTD_TR_SIZE, 1 << list); +}//Dbtup::insertTdArea() + +/* ---------------------------------------------------------------- */ +/* ----------------------- MERGE_TAB_DESCR ------------------------ */ +/* ---------------------------------------------------------------- */ +/* INPUT: TAB_DESCR_PTR POINTING AT THE CURRENT CHUNK */ +/* */ +/* SHORTNAME: MTD */ +/* -----------------------------------------------------------------*/ +Uint32 Dbtup::itdaMergeTabDescr(Uint32 retRef, Uint32 retNo) +{ + /* THE SIZE OF THE PART TO MERGE MUST BE OF THE SAME SIZE AS THE INSERTED PART */ + /* THIS IS TRUE EITHER IF ONE PART HAS THE SAME SIZE OR THE SUM OF BOTH PARTS */ + /* TOGETHER HAS THE SAME SIZE AS THE PART TO BE INSERTED */ + /* FIND THE SIZES OF THE PARTS TO THE RIGHT OF THE PART TO BE REINSERTED */ + while ((retRef + retNo) < cnoOfTabDescrRec) { + ljam(); + Uint32 tabDesRef = retRef + retNo; + Uint32 headerWord = getTabDescrWord(tabDesRef + ZTD_FL_HEADER); + if (headerWord == ZTD_TYPE_FREE) { + ljam(); + Uint32 sizeOfMergedPart = getTabDescrWord(tabDesRef + ZTD_FL_SIZE); + + retNo += sizeOfMergedPart; + Uint32 list = nextHigherTwoLog(sizeOfMergedPart - 1); + removeTdArea(tabDesRef, list); + } else { + ljam(); + return retNo; + }//if + }//while + ndbrequire((retRef + retNo) == cnoOfTabDescrRec); + return retNo; +}//Dbtup::itdaMergeTabDescr() + +/* ---------------------------------------------------------------- */ +/* ------------------------ REMOVE_TD_AREA ------------------------ */ +/* ---------------------------------------------------------------- */ +/* */ +/* THIS ROUTINE REMOVES A TD CHUNK FROM THE POOL OF TD RECORDS */ +/* */ +/* INPUT: TLIST LIST TO USE */ +/* TAB_DESCR_PTR POINTS TO THE CHUNK TO BE REMOVED */ +/* */ +/* SHORTNAME: RMTA */ +/* -----------------------------------------------------------------*/ +void Dbtup::removeTdArea(Uint32 tabDesRef, Uint32 list) +{ + ndbrequire(list < 16); + Uint32 tabDescrNextPtr = getTabDescrWord(tabDesRef + ZTD_FL_NEXT); + Uint32 tabDescrPrevPtr = getTabDescrWord(tabDesRef + ZTD_FL_PREV); + + setTabDescrWord(tabDesRef + ZTD_HEADER, ZTD_TYPE_NORMAL); + setTabDescrWord((tabDesRef + (1 << list)) - ZTD_TR_TYPE, ZTD_TYPE_NORMAL); + + if (tabDesRef == cfreeTdList[list]) { + ljam(); + cfreeTdList[list] = tabDescrNextPtr; /* RELINK THE LIST */ + }//if + if (tabDescrNextPtr != RNIL) { + ljam(); + setTabDescrWord(tabDescrNextPtr + ZTD_FL_PREV, tabDescrPrevPtr); + }//if + if (tabDescrPrevPtr != RNIL) { + ljam(); + setTabDescrWord(tabDescrPrevPtr + ZTD_FL_NEXT, tabDescrNextPtr); + }//if +}//Dbtup::removeTdArea() diff --git a/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp b/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp new file mode 100644 index 00000000000..6fceea31150 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp @@ -0,0 +1,1138 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include +#include +#include "AttributeOffset.hpp" +#include +#include +#include +#include + +#define ljam() { jamLine(7000 + __LINE__); } +#define ljamEntry() { jamEntryLine(7000 + __LINE__); } + +/* **************************************************************** */ +/* ---------------------------------------------------------------- */ +/* ----------------------- TRIGGER HANDLING ----------------------- */ +/* ---------------------------------------------------------------- */ +/* **************************************************************** */ + +ArrayList* +Dbtup::findTriggerList(Tablerec* table, + TriggerType::Value ttype, + TriggerActionTime::Value ttime, + TriggerEvent::Value tevent) +{ + ArrayList* tlist = NULL; + switch (ttype) { + case TriggerType::SUBSCRIPTION: + case TriggerType::SUBSCRIPTION_BEFORE: + switch (tevent) { + case TriggerEvent::TE_INSERT: + ljam(); + if (ttime == TriggerActionTime::TA_DETACHED) + tlist = &table->subscriptionInsertTriggers; + break; + case TriggerEvent::TE_UPDATE: + ljam(); + if (ttime == TriggerActionTime::TA_DETACHED) + tlist = &table->subscriptionUpdateTriggers; + break; + case TriggerEvent::TE_DELETE: + ljam(); + if (ttime == TriggerActionTime::TA_DETACHED) + tlist = &table->subscriptionDeleteTriggers; + break; + default: + break; + } + break; + case TriggerType::SECONDARY_INDEX: + switch (tevent) { + case TriggerEvent::TE_INSERT: + ljam(); + if (ttime == TriggerActionTime::TA_AFTER) + tlist = &table->afterInsertTriggers; + break; + case TriggerEvent::TE_UPDATE: + ljam(); + if (ttime == TriggerActionTime::TA_AFTER) + tlist = &table->afterUpdateTriggers; + break; + case TriggerEvent::TE_DELETE: + ljam(); + if (ttime == TriggerActionTime::TA_AFTER) + tlist = &table->afterDeleteTriggers; + break; + default: + break; + } + break; + case TriggerType::ORDERED_INDEX: + switch (tevent) { + case TriggerEvent::TE_CUSTOM: + ljam(); + if (ttime == TriggerActionTime::TA_CUSTOM) + tlist = &table->tuxCustomTriggers; + break; + default: + break; + } + break; + case TriggerType::READ_ONLY_CONSTRAINT: + switch (tevent) { + case TriggerEvent::TE_UPDATE: + ljam(); + if (ttime == TriggerActionTime::TA_AFTER) + tlist = &table->constraintUpdateTriggers; + break; + default: + break; + } + break; + default: + break; + } + return tlist; +} + +// Trigger signals +void +Dbtup::execCREATE_TRIG_REQ(Signal* signal) +{ + ljamEntry(); + BlockReference senderRef = signal->getSendersBlockRef(); + const CreateTrigReq reqCopy = *(const CreateTrigReq*)signal->getDataPtr(); + const CreateTrigReq* const req = &reqCopy; + + // Find table + TablerecPtr tabPtr; + tabPtr.i = req->getTableId(); + ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec); + + // Create trigger and associate it with the table + if (createTrigger(tabPtr.p, req)) { + ljam(); + // Send conf + CreateTrigConf* const conf = (CreateTrigConf*)signal->getDataPtrSend(); + conf->setUserRef(reference()); + conf->setConnectionPtr(req->getConnectionPtr()); + conf->setRequestType(req->getRequestType()); + conf->setTableId(req->getTableId()); + conf->setIndexId(req->getIndexId()); + conf->setTriggerId(req->getTriggerId()); + conf->setTriggerInfo(req->getTriggerInfo()); + sendSignal(senderRef, GSN_CREATE_TRIG_CONF, + signal, CreateTrigConf::SignalLength, JBB); + } else { + ljam(); + // Send ref + CreateTrigRef* const ref = (CreateTrigRef*)signal->getDataPtrSend(); + ref->setUserRef(reference()); + ref->setConnectionPtr(req->getConnectionPtr()); + ref->setRequestType(req->getRequestType()); + ref->setTableId(req->getTableId()); + ref->setIndexId(req->getIndexId()); + ref->setTriggerId(req->getTriggerId()); + ref->setTriggerInfo(req->getTriggerInfo()); + ref->setErrorCode(CreateTrigRef::TooManyTriggers); + sendSignal(senderRef, GSN_CREATE_TRIG_REF, + signal, CreateTrigRef::SignalLength, JBB); + } +}//Dbtup::execCREATE_TRIG_REQ() + +void +Dbtup::execDROP_TRIG_REQ(Signal* signal) +{ + ljamEntry(); + BlockReference senderRef = signal->getSendersBlockRef(); + const DropTrigReq reqCopy = *(const DropTrigReq*)signal->getDataPtr(); + const DropTrigReq* const req = &reqCopy; + + // Find table + TablerecPtr tabPtr; + tabPtr.i = req->getTableId(); + ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec); + + // Drop trigger + Uint32 r = dropTrigger(tabPtr.p, req); + if (r == 0){ + // Send conf + DropTrigConf* const conf = (DropTrigConf*)signal->getDataPtrSend(); + conf->setUserRef(senderRef); + conf->setConnectionPtr(req->getConnectionPtr()); + conf->setRequestType(req->getRequestType()); + conf->setTableId(req->getTableId()); + conf->setIndexId(req->getIndexId()); + conf->setTriggerId(req->getTriggerId()); + sendSignal(senderRef, GSN_DROP_TRIG_CONF, + signal, DropTrigConf::SignalLength, JBB); + } else { + // Send ref + DropTrigRef* const ref = (DropTrigRef*)signal->getDataPtrSend(); + ref->setUserRef(senderRef); + ref->setConnectionPtr(req->getConnectionPtr()); + ref->setRequestType(req->getRequestType()); + ref->setTableId(req->getTableId()); + ref->setIndexId(req->getIndexId()); + ref->setTriggerId(req->getTriggerId()); + ref->setErrorCode((DropTrigRef::ErrorCode)r); + ref->setErrorLine(__LINE__); + ref->setErrorNode(refToNode(reference())); + sendSignal(senderRef, GSN_DROP_TRIG_REF, + signal, DropTrigRef::SignalLength, JBB); + } +}//Dbtup::DROP_TRIG_REQ() + +/* ---------------------------------------------------------------- */ +/* ------------------------- createTrigger ------------------------ */ +/* */ +/* Creates a new trigger record by fetching one from the trigger */ +/* pool and associates it with the given table. */ +/* Trigger type can be one of secondary_index, subscription, */ +/* constraint(NYI), foreign_key(NYI), schema_upgrade(NYI), */ +/* api_trigger(NYI) or sql_trigger(NYI). */ +/* Note that this method only checks for total number of allowed */ +/* triggers. Checking the number of allowed triggers per table is */ +/* done by TRIX. */ +/* */ +/* ---------------------------------------------------------------- */ +bool +Dbtup::createTrigger(Tablerec* table, const CreateTrigReq* req) +{ + if (ERROR_INSERTED(4003)) { + CLEAR_ERROR_INSERT_VALUE; + return false; + } + TriggerType::Value ttype = req->getTriggerType(); + TriggerActionTime::Value ttime = req->getTriggerActionTime(); + TriggerEvent::Value tevent = req->getTriggerEvent(); + + ArrayList* tlist = findTriggerList(table, ttype, ttime, tevent); + ndbrequire(tlist != NULL); + + TriggerPtr tptr; + if (!tlist->seize(tptr)) + return false; + + // Set trigger id + tptr.p->triggerId = req->getTriggerId(); + + // ndbout_c("Create TupTrigger %u = %u %u %u %u", tptr.p->triggerId, table, ttype, ttime, tevent); + + // Set index id + tptr.p->indexId = req->getIndexId(); + + // Set trigger type etc + tptr.p->triggerType = ttype; + tptr.p->triggerActionTime = ttime; + tptr.p->triggerEvent = tevent; + + tptr.p->sendBeforeValues = true; + if ((tptr.p->triggerType == TriggerType::SUBSCRIPTION) && + ((tptr.p->triggerEvent == TriggerEvent::TE_UPDATE) || + (tptr.p->triggerEvent == TriggerEvent::TE_DELETE))) { + ljam(); + tptr.p->sendBeforeValues = false; + } + tptr.p->sendOnlyChangedAttributes = false; + if (((tptr.p->triggerType == TriggerType::SUBSCRIPTION) || + (tptr.p->triggerType == TriggerType::SUBSCRIPTION_BEFORE)) && + (tptr.p->triggerEvent == TriggerEvent::TE_UPDATE)) { + ljam(); + tptr.p->sendOnlyChangedAttributes = true; + } + + // Set monitor all + tptr.p->monitorAllAttributes = req->getMonitorAllAttributes(); + tptr.p->monitorReplicas = req->getMonitorReplicas(); + tptr.p->m_receiverBlock = refToBlock(req->getReceiverRef()); + + tptr.p->attributeMask.clear(); + if (tptr.p->monitorAllAttributes) { + ljam(); + for(Uint32 i = 0; i < table->noOfAttr; i++) { + if (!primaryKey(table, i)) { + ljam(); + tptr.p->attributeMask.set(i); + } + } + } else { + // Set attribute mask + ljam(); + tptr.p->attributeMask = req->getAttributeMask(); + } + return true; +}//Dbtup::createTrigger() + +bool +Dbtup::primaryKey(Tablerec* const regTabPtr, Uint32 attrId) +{ + Uint32 attrDescriptorStart = regTabPtr->tabDescriptor; + Uint32 attrDescriptor = getTabDescrWord(attrDescriptorStart + (attrId * ZAD_SIZE)); + return (bool)AttributeDescriptor::getPrimaryKey(attrDescriptor); +}//Dbtup::primaryKey() + +/* ---------------------------------------------------------------- */ +/* -------------------------- dropTrigger ------------------------- */ +/* */ +/* Deletes a trigger record by disassociating it with the given */ +/* table and returning it to the trigger pool. */ +/* Trigger type can be one of secondary_index, subscription, */ +/* constraint(NYI), foreign_key(NYI), schema_upgrade(NYI), */ +/* api_trigger(NYI) or sql_trigger(NYI). */ +/* */ +/* ---------------------------------------------------------------- */ +Uint32 +Dbtup::dropTrigger(Tablerec* table, const DropTrigReq* req) +{ + Uint32 triggerId = req->getTriggerId(); + + TriggerType::Value ttype = req->getTriggerType(); + TriggerActionTime::Value ttime = req->getTriggerActionTime(); + TriggerEvent::Value tevent = req->getTriggerEvent(); + + // ndbout_c("Drop TupTrigger %u = %u %u %u %u", triggerId, table, ttype, ttime, tevent); + + ArrayList* tlist = findTriggerList(table, ttype, ttime, tevent); + ndbrequire(tlist != NULL); + + Ptr ptr; + for (tlist->first(ptr); !ptr.isNull(); tlist->next(ptr)) { + ljam(); + if (ptr.p->triggerId == triggerId) { + ljam(); + tlist->release(ptr.i); + return 0; + } + } + return DropTrigRef::TriggerNotFound; +}//Dbtup::dropTrigger() + +/* ---------------------------------------------------------------- */ +/* -------------- checkImmediateTriggersAfterOp ------------------ */ +/* */ +/* Called after an insert, delete, or update operation takes */ +/* place. Fetches before tuple for deletes and updates and */ +/* after tuple for inserts and updates. */ +/* Executes immediate triggers by sending FIRETRIGORD */ +/* */ +/* ---------------------------------------------------------------- */ +void Dbtup::checkImmediateTriggersAfterInsert(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTablePtr) +{ + if(refToBlock(regOperPtr->coordinatorTC) == DBLQH) { + return; + } + + if ((regOperPtr->primaryReplica) && + (!(regTablePtr->afterInsertTriggers.isEmpty()))) { + ljam(); + fireImmediateTriggers(signal, + regTablePtr->afterInsertTriggers, + regOperPtr); + }//if +}//Dbtup::checkImmediateTriggersAfterInsert() + +void Dbtup::checkImmediateTriggersAfterUpdate(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTablePtr) +{ + if(refToBlock(regOperPtr->coordinatorTC) == DBLQH) { + return; + } + + if ((regOperPtr->primaryReplica) && + (!(regTablePtr->afterUpdateTriggers.isEmpty()))) { + ljam(); + fireImmediateTriggers(signal, + regTablePtr->afterUpdateTriggers, + regOperPtr); + }//if + if ((regOperPtr->primaryReplica) && + (!(regTablePtr->constraintUpdateTriggers.isEmpty()))) { + ljam(); + fireImmediateTriggers(signal, + regTablePtr->constraintUpdateTriggers, + regOperPtr); + }//if +}//Dbtup::checkImmediateTriggersAfterUpdate() + +void Dbtup::checkImmediateTriggersAfterDelete(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTablePtr) +{ + if(refToBlock(regOperPtr->coordinatorTC) == DBLQH) { + return; + } + + if ((regOperPtr->primaryReplica) && + (!(regTablePtr->afterDeleteTriggers.isEmpty()))) { + ljam(); + executeTriggers(signal, + regTablePtr->afterDeleteTriggers, + regOperPtr); + }//if +}//Dbtup::checkImmediateTriggersAfterDelete() + +#if 0 +/* ---------------------------------------------------------------- */ +/* --------------------- checkDeferredTriggers -------------------- */ +/* */ +/* Called before commit after an insert, delete, or update */ +/* operation. Fetches before tuple for deletes and updates and */ +/* after tuple for inserts and updates. */ +/* Executes deferred triggers by sending FIRETRIGORD */ +/* */ +/* ---------------------------------------------------------------- */ +void Dbtup::checkDeferredTriggers(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTablePtr) +{ + ljam(); + // NYI +}//Dbtup::checkDeferredTriggers() +#endif + +/* ---------------------------------------------------------------- */ +/* --------------------- checkDetachedTriggers -------------------- */ +/* */ +/* Called at commit after an insert, delete, or update operation. */ +/* Fetches before tuple for deletes and updates and */ +/* after tuple for inserts and updates. */ +/* Executes detached triggers by sending FIRETRIGORD */ +/* */ +/* ---------------------------------------------------------------- */ +void Dbtup::checkDetachedTriggers(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTablePtr) +{ + switch(regOperPtr->optype) { + case(ZINSERT): + ljam(); + if (regTablePtr->subscriptionInsertTriggers.isEmpty()) { + // Table has no active triggers monitoring inserts at commit + ljam(); + return; + }//if + + // If any fired immediate insert trigger then fetch after tuple + fireDetachedTriggers(signal, + regTablePtr->subscriptionInsertTriggers, + regOperPtr); + break; + case(ZDELETE): + ljam(); + if (regTablePtr->subscriptionDeleteTriggers.isEmpty()) { + // Table has no active triggers monitoring deletes at commit + ljam(); + return; + }//if + + // Execute any after delete triggers by sending + // FIRETRIGORD with the before tuple + executeTriggers(signal, + regTablePtr->subscriptionDeleteTriggers, + regOperPtr); + break; + case(ZUPDATE): + ljam(); + if (regTablePtr->subscriptionUpdateTriggers.isEmpty()) { + // Table has no active triggers monitoring updates at commit + ljam(); + return; + }//if + + // If any fired immediate update trigger then fetch after tuple + // and send two FIRETRIGORD one with before tuple and one with after tuple + fireDetachedTriggers(signal, + regTablePtr->subscriptionUpdateTriggers, + regOperPtr); + break; + default: + ndbrequire(false); + break; + }//switch +}//Dbtup::CheckDetachedTriggers() + +void +Dbtup::fireImmediateTriggers(Signal* signal, + ArrayList& triggerList, + Operationrec* const regOperPtr) +{ + TriggerPtr trigPtr; + triggerList.first(trigPtr); + while (trigPtr.i != RNIL) { + ljam(); + if (trigPtr.p->monitorAllAttributes || + trigPtr.p->attributeMask.overlaps(regOperPtr->changeMask)) { + ljam(); + executeTrigger(signal, + trigPtr.p, + regOperPtr); + }//if + triggerList.next(trigPtr); + }//while +}//Dbtup::fireImmediateTriggers() + +#if 0 +void +Dbtup::fireDeferredTriggers(Signal* signal, + ArrayList& triggerList, + Operationrec* const regOperPtr) +{ + TriggerPtr trigPtr; + triggerList.first(trigPtr); + while (trigPtr.i != RNIL) { + ljam(); + if (trigPtr.p->monitorAllAttributes || + trigPtr.p->attributeMask.overlaps(regOperPtr->changeMask)) { + ljam(); + executeTrigger(signal, + trigPtr, + regOperPtr); + }//if + triggerList.next(trigPtr); + }//while +}//Dbtup::fireDeferredTriggers() +#endif + +void +Dbtup::fireDetachedTriggers(Signal* signal, + ArrayList& triggerList, + Operationrec* const regOperPtr) +{ + TriggerPtr trigPtr; + triggerList.first(trigPtr); + while (trigPtr.i != RNIL) { + ljam(); + if ((trigPtr.p->monitorReplicas || regOperPtr->primaryReplica) && + (trigPtr.p->monitorAllAttributes || + trigPtr.p->attributeMask.overlaps(regOperPtr->changeMask))) { + ljam(); + executeTrigger(signal, + trigPtr.p, + regOperPtr); + }//if + triggerList.next(trigPtr); + }//while +}//Dbtup::fireDetachedTriggers() + +void Dbtup::executeTriggers(Signal* signal, + ArrayList& triggerList, + Operationrec* regOperPtr) +{ + TriggerPtr trigPtr; + triggerList.first(trigPtr); + while (trigPtr.i != RNIL) { + ljam(); + executeTrigger(signal, + trigPtr.p, + regOperPtr); + triggerList.next(trigPtr); + + }//while +}//Dbtup::executeTriggers() + +void Dbtup::executeTrigger(Signal* signal, + TupTriggerData* const trigPtr, + Operationrec* const regOperPtr) +{ + + /** + * The block below does not work together with GREP. + * I have 2 db nodes (2 replicas) -> one node group. + * I want to have FIRETRIG_ORD sent to all SumaParticipants, + * from all nodes in the node group described above. However, + * only one of the nodes in the node group actually sends the + * FIRE_TRIG_ORD, and the other node enters this "hack" below. + * I don't really know what the code snippet below does, but it + * does not work with GREP the way Lars and I want it. + * We need to have triggers fired from both the primary and the + * backup replica, not only the primary as it is now. + * + * Note: In Suma, I have changed triggers to be created with + * setMonitorReplicas(true). + * /Johan + * + * See RT 709 + */ + // XXX quick fix to NR, should fix in LQHKEYREQ instead + /* + if (refToBlock(regOperPtr->coordinatorTC) == DBLQH) { + jam(); + return; + } + */ + BlockReference ref = trigPtr->m_receiverBlock; + Uint32* const keyBuffer = &cinBuffer[0]; + Uint32* const mainBuffer = &coutBuffer[0]; + Uint32* const copyBuffer = &clogMemBuffer[0]; + + Uint32 noPrimKey, noMainWords, noCopyWords; + + if (ref == BACKUP) { + ljam(); + /* + In order for the implementation of BACKUP to work even when changing + primaries in the middle of the backup we need to set the trigger on + all replicas. This check checks whether this is the node where this + trigger should be fired. The check should preferably have been put + completely in the BACKUP block but it was about five times simpler + to put it here and also much faster for the backup (small overhead + for everybody else. + */ + signal->theData[0] = trigPtr->triggerId; + signal->theData[1] = regOperPtr->fragId; + EXECUTE_DIRECT(BACKUP, GSN_BACKUP_TRIG_REQ, signal, 2); + ljamEntry(); + if (signal->theData[0] == 0) { + ljam(); + return; + }//if + }//if + if (!readTriggerInfo(trigPtr, + regOperPtr, + keyBuffer, + noPrimKey, + mainBuffer, + noMainWords, + copyBuffer, + noCopyWords)) { + ljam(); + return; + }//if +//-------------------------------------------------------------------- +// Now all data for this trigger has been read. It is now time to send +// the trigger information consisting of two or three sets of TRIG_ +// ATTRINFO signals and one FIRE_TRIG_ORD signal. +// We start by setting common header info for all TRIG_ATTRINFO signals. +//-------------------------------------------------------------------- + bool executeDirect; + TrigAttrInfo* const trigAttrInfo = (TrigAttrInfo *)signal->getDataPtrSend(); + trigAttrInfo->setConnectionPtr(regOperPtr->tcOpIndex); + trigAttrInfo->setTriggerId(trigPtr->triggerId); + + switch(trigPtr->triggerType) { + case (TriggerType::SECONDARY_INDEX): + ljam(); + ref = regOperPtr->coordinatorTC; + executeDirect = false; + break; + case (TriggerType::SUBSCRIPTION): + case (TriggerType::SUBSCRIPTION_BEFORE): + ljam(); + // Since only backup uses subscription triggers we send to backup directly for now + ref = trigPtr->m_receiverBlock; + executeDirect = true; + break; + case (TriggerType::READ_ONLY_CONSTRAINT): + terrorCode = ZREAD_ONLY_CONSTRAINT_VIOLATION; + // XXX should return status and abort the rest + return; + default: + ndbrequire(false); + }//switch + + regOperPtr->noFiredTriggers++; + + trigAttrInfo->setAttrInfoType(TrigAttrInfo::PRIMARY_KEY); + sendTrigAttrInfo(signal, keyBuffer, noPrimKey, executeDirect, ref); + + Uint32 noAfter = 0; + Uint32 noBefore = 0; + switch(regOperPtr->optype) { + case(ZINSERT): + ljam(); + // Send AttrInfo signals with new attribute values + trigAttrInfo->setAttrInfoType(TrigAttrInfo::AFTER_VALUES); + sendTrigAttrInfo(signal, mainBuffer, noMainWords, executeDirect, ref); + noAfter = noMainWords; + break; + case(ZDELETE): + if (trigPtr->sendBeforeValues) { + ljam(); + trigAttrInfo->setAttrInfoType(TrigAttrInfo::BEFORE_VALUES); + sendTrigAttrInfo(signal, mainBuffer, noMainWords, executeDirect, ref); + noBefore = noMainWords; + }//if + break; + case(ZUPDATE): + ljam(); + if (trigPtr->sendBeforeValues) { + ljam(); + trigAttrInfo->setAttrInfoType(TrigAttrInfo::BEFORE_VALUES); + sendTrigAttrInfo(signal, copyBuffer, noCopyWords, executeDirect, ref); + noBefore = noCopyWords; + }//if + trigAttrInfo->setAttrInfoType(TrigAttrInfo::AFTER_VALUES); + sendTrigAttrInfo(signal, mainBuffer, noMainWords, executeDirect, ref); + noAfter = noMainWords; + break; + default: + ndbrequire(false); + }//switch + sendFireTrigOrd(signal, + regOperPtr, + trigPtr, + noPrimKey, + noBefore, + noAfter); +}//Dbtup::executeTrigger() + +Uint32 Dbtup::setAttrIds(Bitmask& attributeMask, + Uint32 noOfAttributes, + Uint32* inBuffer) +{ + Uint32 bufIndx = 0; + for (Uint32 i = 0; i < noOfAttributes; i++) { + ljam(); + if (attributeMask.get(i)) { + ljam(); + AttributeHeader::init(&inBuffer[bufIndx++], i, 0); + }//if + }//for + return bufIndx; +}//Dbtup::setAttrIds() + +bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr, + Operationrec* const regOperPtr, + Uint32* const keyBuffer, + Uint32& noPrimKey, + Uint32* const mainBuffer, + Uint32& noMainWords, + Uint32* const copyBuffer, + Uint32& noCopyWords) +{ + noCopyWords = 0; + noMainWords = 0; + Uint32 readBuffer[MAX_ATTRIBUTES_IN_TABLE]; + PagePtr pagep; + +//--------------------------------------------------------------------------- +// Set-up variables needed by readAttributes operPtr.p, tabptr.p +//--------------------------------------------------------------------------- + operPtr.p = regOperPtr; + tabptr.i = regOperPtr->tableRef; + ptrCheckGuard(tabptr, cnoOfTablerec, tablerec); + Tablerec* const regTabPtr = tabptr.p; +//-------------------------------------------------------------------- +// Initialise pagep and tuple offset for read of main tuple +//-------------------------------------------------------------------- + Uint32 tupheadoffset = regOperPtr->pageOffset; + pagep.i = regOperPtr->realPageId; + ptrCheckGuard(pagep, cnoOfPage, page); + +//-------------------------------------------------------------------- +// Read Primary Key Values +//-------------------------------------------------------------------- + noPrimKey = readAttributes(pagep.p, + tupheadoffset, + &tableDescriptor[regTabPtr->readKeyArray].tabDescr, + regTabPtr->noOfKeyAttr, + keyBuffer, + ZATTR_BUFFER_SIZE); + ndbrequire(noPrimKey != (Uint32)-1); + + Uint32 numAttrsToRead; + if ((regOperPtr->optype == ZUPDATE) && + (trigPtr->sendOnlyChangedAttributes)) { + ljam(); +//-------------------------------------------------------------------- +// Update that sends only changed information +//-------------------------------------------------------------------- + Bitmask attributeMask; + attributeMask = trigPtr->attributeMask; + attributeMask.bitAND(regOperPtr->changeMask); + numAttrsToRead = setAttrIds(attributeMask, regTabPtr->noOfAttr, &readBuffer[0]); + + } else if ((regOperPtr->optype == ZDELETE) && + (!trigPtr->sendBeforeValues)) { + ljam(); +//-------------------------------------------------------------------- +// Delete without sending before values only read Primary Key +//-------------------------------------------------------------------- + return true; + } else { + ljam(); +//-------------------------------------------------------------------- +// All others send all attributes that are monitored +//-------------------------------------------------------------------- + numAttrsToRead = setAttrIds(trigPtr->attributeMask, regTabPtr->noOfAttr, &readBuffer[0]); + }//if + ndbrequire(numAttrsToRead < MAX_ATTRIBUTES_IN_TABLE); +//-------------------------------------------------------------------- +// Read Main tuple values +//-------------------------------------------------------------------- + if ((regOperPtr->optype != ZDELETE) || + (trigPtr->sendBeforeValues)) { + ljam(); + noMainWords = readAttributes(pagep.p, + tupheadoffset, + &readBuffer[0], + numAttrsToRead, + mainBuffer, + ZATTR_BUFFER_SIZE); + ndbrequire(noMainWords != (Uint32)-1); + } else { + ljam(); + noMainWords = 0; + }//if +//-------------------------------------------------------------------- +// Read Copy tuple values for UPDATE's +//-------------------------------------------------------------------- +// Initialise pagep and tuple offset for read of copy tuple +//-------------------------------------------------------------------- + if ((regOperPtr->optype == ZUPDATE) && + (trigPtr->sendBeforeValues)) { + ljam(); + + tupheadoffset = regOperPtr->pageOffsetC; + pagep.i = regOperPtr->realPageIdC; + ptrCheckGuard(pagep, cnoOfPage, page); + + noCopyWords = readAttributes(pagep.p, + tupheadoffset, + &readBuffer[0], + numAttrsToRead, + copyBuffer, + ZATTR_BUFFER_SIZE); + + ndbrequire(noCopyWords != (Uint32)-1); + if ((noMainWords == noCopyWords) && + (memcmp(mainBuffer, copyBuffer, noMainWords << 2) == 0)) { +//-------------------------------------------------------------------- +// Although a trigger was fired it was not necessary since the old +// value and the new value was exactly the same +//-------------------------------------------------------------------- + ljam(); + return false; + }//if + }//if + return true; +}//Dbtup::readTriggerInfo() + +void Dbtup::sendTrigAttrInfo(Signal* signal, + Uint32* data, + Uint32 dataLen, + bool executeDirect, + BlockReference receiverReference) +{ + TrigAttrInfo* const trigAttrInfo = (TrigAttrInfo *)signal->getDataPtrSend(); + Uint32 sigLen; + Uint32 dataIndex = 0; + do { + sigLen = dataLen - dataIndex; + if (sigLen > TrigAttrInfo::DataLength) { + ljam(); + sigLen = TrigAttrInfo::DataLength; + }//if + MEMCOPY_NO_WORDS(trigAttrInfo->getData(), + data + dataIndex, + sigLen); + if (executeDirect) { + ljam(); + EXECUTE_DIRECT(receiverReference, + GSN_TRIG_ATTRINFO, + signal, + TrigAttrInfo::StaticLength + sigLen); + ljamEntry(); + } else { + ljam(); + sendSignal(receiverReference, + GSN_TRIG_ATTRINFO, + signal, + TrigAttrInfo::StaticLength + sigLen, + JBB); + }//if + dataIndex += sigLen; + } while (dataLen != dataIndex); +}//Dbtup::sendTrigAttrInfo() + +void Dbtup::sendFireTrigOrd(Signal* signal, + Operationrec * const regOperPtr, + TupTriggerData* const trigPtr, + Uint32 noPrimKeyWords, + Uint32 noBeforeValueWords, + Uint32 noAfterValueWords) +{ + FireTrigOrd* const fireTrigOrd = (FireTrigOrd *)signal->getDataPtrSend(); + + fireTrigOrd->setConnectionPtr(regOperPtr->tcOpIndex); + fireTrigOrd->setTriggerId(trigPtr->triggerId); + + switch(regOperPtr->optype) { + case(ZINSERT): + ljam(); + fireTrigOrd->setTriggerEvent(TriggerEvent::TE_INSERT); + break; + case(ZDELETE): + ljam(); + fireTrigOrd->setTriggerEvent(TriggerEvent::TE_DELETE); + break; + case(ZUPDATE): + ljam(); + fireTrigOrd->setTriggerEvent(TriggerEvent::TE_UPDATE); + break; + default: + ndbrequire(false); + break; + }//switch + + fireTrigOrd->setNoOfPrimaryKeyWords(noPrimKeyWords); + fireTrigOrd->setNoOfBeforeValueWords(noBeforeValueWords); + fireTrigOrd->setNoOfAfterValueWords(noAfterValueWords); + + switch(trigPtr->triggerType) { + case (TriggerType::SECONDARY_INDEX): + ljam(); + sendSignal(regOperPtr->coordinatorTC, GSN_FIRE_TRIG_ORD, + signal, FireTrigOrd::SignalLength, JBB); + break; + case (TriggerType::SUBSCRIPTION_BEFORE): // Only Suma + ljam(); + // Since only backup uses subscription triggers we + // send to backup directly for now + fireTrigOrd->setGCI(regOperPtr->gci); + fireTrigOrd->setHashValue(regOperPtr->hashValue); + EXECUTE_DIRECT(trigPtr->m_receiverBlock, + GSN_FIRE_TRIG_ORD, + signal, + FireTrigOrd::SignalWithHashValueLength); + break; + case (TriggerType::SUBSCRIPTION): + ljam(); + // Since only backup uses subscription triggers we + // send to backup directly for now + fireTrigOrd->setGCI(regOperPtr->gci); + EXECUTE_DIRECT(trigPtr->m_receiverBlock, + GSN_FIRE_TRIG_ORD, + signal, + FireTrigOrd::SignalWithGCILength); + break; + default: + ndbrequire(false); + break; + }//switch +}//Dbtup::sendFireTrigOrd() + +/* + * Ordered index triggers. + * + * Insert: add entry to index + * Update: add entry to index, de|ay remove until commit + * Delete: do nothing, delay remove until commit + * Commit: remove entry delayed from update and delete + * Abort : remove entry added by insert and update + * + * See Notes.txt for the details. + */ + +int +Dbtup::executeTuxInsertTriggers(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTabPtr) +{ + TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend(); + PagePtr pagePtr; + pagePtr.i = regOperPtr->realPageId; + ptrCheckGuard(pagePtr, cnoOfPage, page); + Uint32 tupVersion = pagePtr.p->pageWord[regOperPtr->pageOffset + 1]; + ndbrequire(tupVersion == regOperPtr->tupVersion); + // fill in constant part + req->tableId = regOperPtr->tableRef; + req->fragId = regOperPtr->fragId; + req->tupAddr = (regOperPtr->fragPageId << MAX_TUPLES_BITS) | regOperPtr->pageIndex; + req->tupVersion = tupVersion; + req->opInfo = TuxMaintReq::OpAdd; + // loop over index list + const ArrayList& triggerList = regTabPtr->tuxCustomTriggers; + TriggerPtr triggerPtr; + triggerList.first(triggerPtr); + while (triggerPtr.i != RNIL) { + ljam(); + req->indexId = triggerPtr.p->indexId; + req->errorCode = RNIL; + EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ, + signal, TuxMaintReq::SignalLength); + ljamEntry(); + if (req->errorCode != 0) { + ljam(); + terrorCode = req->errorCode; + return -1; + } + triggerList.next(triggerPtr); + } + return 0; +} + +int +Dbtup::executeTuxUpdateTriggers(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTabPtr) +{ + TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend(); + PagePtr pagePtr; + pagePtr.i = regOperPtr->realPageId; + ptrCheckGuard(pagePtr, cnoOfPage, page); + Uint32 tupVersion = pagePtr.p->pageWord[regOperPtr->pageOffset + 1]; + ndbrequire(tupVersion == regOperPtr->tupVersion); + // fill in constant part + req->tableId = regOperPtr->tableRef; + req->fragId = regOperPtr->fragId; + req->tupAddr = (regOperPtr->fragPageId << MAX_TUPLES_BITS) | regOperPtr->pageIndex; + req->tupVersion = tupVersion; + req->opInfo = TuxMaintReq::OpAdd; + // loop over index list + const ArrayList& triggerList = regTabPtr->tuxCustomTriggers; + TriggerPtr triggerPtr; + triggerList.first(triggerPtr); + while (triggerPtr.i != RNIL) { + ljam(); + req->tupAddr = (regOperPtr->fragPageId << MAX_TUPLES_BITS) | regOperPtr->pageIndex; + req->indexId = triggerPtr.p->indexId; + req->errorCode = RNIL; + EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ, + signal, TuxMaintReq::SignalLength); + ljamEntry(); + if (req->errorCode != 0) { + ljam(); + terrorCode = req->errorCode; + return -1; + } + triggerList.next(triggerPtr); + } + return 0; +} + +int +Dbtup::executeTuxDeleteTriggers(Signal* signal, + Operationrec* const regOperPtr, + Tablerec* const regTabPtr) +{ + // do nothing + return 0; +} + +void +Dbtup::executeTuxCommitTriggers(Signal* signal, + Operationrec* regOperPtr, + Tablerec* const regTabPtr) +{ + TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend(); + // get version + // XXX could add prevTupVersion to Operationrec + Uint32 tupVersion; + if (regOperPtr->optype == ZINSERT) { + if (! regOperPtr->deleteInsertFlag) + return; + ljam(); + PagePtr pagePtr; + pagePtr.i = regOperPtr->realPageIdC; + ptrCheckGuard(pagePtr, cnoOfPage, page); + tupVersion = pagePtr.p->pageWord[regOperPtr->pageOffsetC + 1]; + ndbrequire(tupVersion != regOperPtr->tupVersion); + } else if (regOperPtr->optype == ZUPDATE) { + ljam(); + PagePtr pagePtr; + pagePtr.i = regOperPtr->realPageIdC; + ptrCheckGuard(pagePtr, cnoOfPage, page); + tupVersion = pagePtr.p->pageWord[regOperPtr->pageOffsetC + 1]; + ndbrequire(tupVersion != regOperPtr->tupVersion); + } else if (regOperPtr->optype == ZDELETE) { + if (regOperPtr->deleteInsertFlag) + return; + ljam(); + PagePtr pagePtr; + pagePtr.i = regOperPtr->realPageId; + ptrCheckGuard(pagePtr, cnoOfPage, page); + tupVersion = pagePtr.p->pageWord[regOperPtr->pageOffset + 1]; + ndbrequire(tupVersion == regOperPtr->tupVersion); + } else { + ndbrequire(false); + } + // fill in constant part + req->tableId = regOperPtr->tableRef; + req->fragId = regOperPtr->fragId; + req->tupAddr = (regOperPtr->fragPageId << MAX_TUPLES_BITS) | regOperPtr->pageIndex; + req->tupVersion = tupVersion; + req->opInfo = TuxMaintReq::OpRemove; + // loop over index list + const ArrayList& triggerList = regTabPtr->tuxCustomTriggers; + TriggerPtr triggerPtr; + triggerList.first(triggerPtr); + while (triggerPtr.i != RNIL) { + ljam(); + req->indexId = triggerPtr.p->indexId; + req->errorCode = RNIL; + EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ, + signal, TuxMaintReq::SignalLength); + ljamEntry(); + // commit must succeed + ndbrequire(req->errorCode == 0); + triggerList.next(triggerPtr); + } +} + +void +Dbtup::executeTuxAbortTriggers(Signal* signal, + Operationrec* regOperPtr, + Tablerec* const regTabPtr) +{ + TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend(); + // get version + Uint32 tupVersion; + if (regOperPtr->optype == ZINSERT) { + ljam(); + tupVersion = regOperPtr->tupVersion; + } else if (regOperPtr->optype == ZUPDATE) { + ljam(); + tupVersion = regOperPtr->tupVersion; + } else if (regOperPtr->optype == ZDELETE) { + ljam(); + return; + } else { + ndbrequire(false); + } + // fill in constant part + req->tableId = regOperPtr->tableRef; + req->fragId = regOperPtr->fragId; + req->tupAddr = (regOperPtr->fragPageId << MAX_TUPLES_BITS) | regOperPtr->pageIndex; + req->tupVersion = tupVersion; + req->opInfo = TuxMaintReq::OpRemove; + // loop over index list + const ArrayList& triggerList = regTabPtr->tuxCustomTriggers; + TriggerPtr triggerPtr; + triggerList.first(triggerPtr); + while (triggerPtr.i != RNIL) { + ljam(); + req->indexId = triggerPtr.p->indexId; + req->errorCode = RNIL, + EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ, + signal, TuxMaintReq::SignalLength); + ljamEntry(); + // abort must succeed + ndbrequire(req->errorCode == 0); + triggerList.next(triggerPtr); + } +} diff --git a/ndb/src/kernel/blocks/dbtup/DbtupUndoLog.cpp b/ndb/src/kernel/blocks/dbtup/DbtupUndoLog.cpp new file mode 100644 index 00000000000..869f399583f --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/DbtupUndoLog.cpp @@ -0,0 +1,284 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#define DBTUP_C +#include "Dbtup.hpp" +#include +#include +#include + +#define ljam() { jamLine(12000 + __LINE__); } +#define ljamEntry() { jamEntryLine(12000 + __LINE__); } + +void Dbtup::cprAddData(Signal* signal, + Fragrecord* const regFragPtr, + Uint32 pageIndex, + Uint32 noOfWords, + Uint32 startOffset) +{ + UndoPagePtr undoPagePtr; + PagePtr pagePtr; + LocalLogInfoPtr regLliPtr; + + regLliPtr.i = regFragPtr->checkpointVersion; + ptrCheckGuard(regLliPtr, cnoOfParallellUndoFiles, localLogInfo); + + pagePtr.i = pageIndex; + ptrCheckGuard(pagePtr, cnoOfPage, page); + undoPagePtr.i = regLliPtr.p->lliUndoPage; + ptrCheckGuard(undoPagePtr, cnoOfUndoPage, undoPage); + + startOffset++; + noOfWords--; + if ((regLliPtr.p->lliUndoWord + noOfWords) < ZWORDS_ON_PAGE) { + ljam(); + MEMCOPY_NO_WORDS(&undoPagePtr.p->undoPageWord[regLliPtr.p->lliUndoWord], + &pagePtr.p->pageWord[startOffset], + noOfWords); + regLliPtr.p->lliUndoWord += noOfWords; + } else { + for (Uint32 i = 0; i < noOfWords; i++) { + ljam(); + Uint32 undoWord = pagePtr.p->pageWord[startOffset + i]; + cprAddUndoLogWord(signal, regLliPtr.p, undoWord); + }//for + }//if +}//Dbtup::cprAddData() + +void Dbtup::cprAddLogHeader(Signal* signal, + LocalLogInfo* const lliPtr, + Uint32 recordType, + Uint32 tableId, + Uint32 fragId) +{ + Uint32 prevRecId = lliPtr->lliPrevRecordId; + lliPtr->lliPrevRecordId = lliPtr->lliUndoWord + (lliPtr->lliLogFilePage << ZUNDO_RECORD_ID_PAGE_INDEX); + cprAddUndoLogWord(signal, lliPtr, recordType); + cprAddUndoLogWord(signal, lliPtr, prevRecId); + cprAddUndoLogWord(signal, lliPtr, tableId); + cprAddUndoLogWord(signal, lliPtr, fragId); +}//Dbtup::cprAddLogHeader() + +void Dbtup::cprAddGCIUpdate(Signal* signal, + Uint32 prevGCI, + Fragrecord* const regFragPtr) +{ + LocalLogInfoPtr regLliPtr; + regLliPtr.i = regFragPtr->checkpointVersion; + ptrCheckGuard(regLliPtr, cnoOfParallellUndoFiles, localLogInfo); + + cprAddUndoLogWord(signal, regLliPtr.p, prevGCI); +}//Dbtup::cprAddLogHeader() + +void Dbtup::cprAddUndoLogPageHeader(Signal* signal, + Page* const regPagePtr, + Fragrecord* const regFragPtr) +{ + UndoPagePtr regUndoPagePtr; + LocalLogInfoPtr regLliPtr; + + regLliPtr.i = regFragPtr->checkpointVersion; + ptrCheckGuard(regLliPtr, cnoOfParallellUndoFiles, localLogInfo); + + Uint32 prevRecId = regLliPtr.p->lliPrevRecordId; + Uint32 lliWord = regLliPtr.p->lliUndoWord; + regLliPtr.p->lliPrevRecordId = lliWord + + (regLliPtr.p->lliLogFilePage << ZUNDO_RECORD_ID_PAGE_INDEX); + if ((lliWord + 7) < ZWORDS_ON_PAGE) { + ljam(); + regUndoPagePtr.i = regLliPtr.p->lliUndoPage; + ptrCheckGuard(regUndoPagePtr, cnoOfUndoPage, undoPage); + + regUndoPagePtr.p->undoPageWord[lliWord] = ZLCPR_UNDO_LOG_PAGE_HEADER; + regUndoPagePtr.p->undoPageWord[lliWord + 1] = prevRecId; + regUndoPagePtr.p->undoPageWord[lliWord + 2] = regFragPtr->fragTableId; + regUndoPagePtr.p->undoPageWord[lliWord + 3] = regFragPtr->fragmentId; + regUndoPagePtr.p->undoPageWord[lliWord + 4] = regPagePtr->pageWord[ZPAGE_FRAG_PAGE_ID_POS]; + regUndoPagePtr.p->undoPageWord[lliWord + 5] = regPagePtr->pageWord[ZPAGE_STATE_POS]; + regUndoPagePtr.p->undoPageWord[lliWord + 6] = regPagePtr->pageWord[ZPAGE_NEXT_POS]; + regLliPtr.p->lliUndoWord = lliWord + 7; + } else { + ljam(); + cprAddUndoLogWord(signal, regLliPtr.p, ZLCPR_UNDO_LOG_PAGE_HEADER); + cprAddUndoLogWord(signal, regLliPtr.p, prevRecId); + cprAddUndoLogWord(signal, regLliPtr.p, regFragPtr->fragTableId); + cprAddUndoLogWord(signal, regLliPtr.p, regFragPtr->fragmentId); + cprAddUndoLogWord(signal, regLliPtr.p, regPagePtr->pageWord[ZPAGE_FRAG_PAGE_ID_POS]); + cprAddUndoLogWord(signal, regLliPtr.p, regPagePtr->pageWord[ZPAGE_STATE_POS]); + cprAddUndoLogWord(signal, regLliPtr.p, regPagePtr->pageWord[ZPAGE_NEXT_POS]); + }//if +}//Dbtup::cprAddUndoLogPageHeader() + +void Dbtup::cprAddUndoLogRecord(Signal* signal, + Uint32 recordType, + Uint32 pageId, + Uint32 pageIndex, + Uint32 tableId, + Uint32 fragId, + Uint32 localLogIndex) +{ + LocalLogInfoPtr regLliPtr; + UndoPagePtr regUndoPagePtr; + + regLliPtr.i = localLogIndex; + ptrCheckGuard(regLliPtr, cnoOfParallellUndoFiles, localLogInfo); + + Uint32 prevRecId = regLliPtr.p->lliPrevRecordId; + Uint32 lliWord = regLliPtr.p->lliUndoWord; + + regLliPtr.p->lliPrevRecordId = lliWord + + (regLliPtr.p->lliLogFilePage << ZUNDO_RECORD_ID_PAGE_INDEX); + if ((lliWord + 6) < ZWORDS_ON_PAGE) { + ljam(); + regUndoPagePtr.i = regLliPtr.p->lliUndoPage; + ptrCheckGuard(regUndoPagePtr, cnoOfUndoPage, undoPage); + regUndoPagePtr.p->undoPageWord[lliWord] = recordType; + regUndoPagePtr.p->undoPageWord[lliWord + 1] = prevRecId; + regUndoPagePtr.p->undoPageWord[lliWord + 2] = tableId; + regUndoPagePtr.p->undoPageWord[lliWord + 3] = fragId; + regUndoPagePtr.p->undoPageWord[lliWord + 4] = pageId; + regUndoPagePtr.p->undoPageWord[lliWord + 5] = pageIndex; + + regLliPtr.p->lliUndoWord = lliWord + 6; + } else { + ljam(); + cprAddUndoLogWord(signal, regLliPtr.p, recordType); + cprAddUndoLogWord(signal, regLliPtr.p, prevRecId); + cprAddUndoLogWord(signal, regLliPtr.p, tableId); + cprAddUndoLogWord(signal, regLliPtr.p, fragId); + cprAddUndoLogWord(signal, regLliPtr.p, pageId); + cprAddUndoLogWord(signal, regLliPtr.p, pageIndex); + }//if +}//Dbtup::cprAddUndoLogRecord() + +void Dbtup::cprAddAbortUpdate(Signal* signal, + LocalLogInfo* const lliPtr, + Operationrec* const regOperPtr) +{ + Uint32 lliWord = lliPtr->lliUndoWord; + if ((lliWord + 4) < ZWORDS_ON_PAGE) { + ljam(); + UndoPagePtr regUndoPagePtr; + regUndoPagePtr.i = lliPtr->lliUndoPage; + ptrCheckGuard(regUndoPagePtr, cnoOfUndoPage, undoPage); + + regUndoPagePtr.p->undoPageWord[lliWord] = regOperPtr->fragPageId; + regUndoPagePtr.p->undoPageWord[lliWord + 1] = regOperPtr->pageIndex; + regUndoPagePtr.p->undoPageWord[lliWord + 2] = regOperPtr->fragPageIdC; + regUndoPagePtr.p->undoPageWord[lliWord + 3] = regOperPtr->pageIndexC; + lliPtr->lliUndoWord = lliWord + 4; + } else { + ljam(); + cprAddUndoLogWord(signal, lliPtr, regOperPtr->fragPageId); + cprAddUndoLogWord(signal, lliPtr, regOperPtr->pageIndex); + cprAddUndoLogWord(signal, lliPtr, regOperPtr->fragPageIdC); + cprAddUndoLogWord(signal, lliPtr, regOperPtr->pageIndexC); + }//if +}//Dbtup::cprAddAbortUpdate() + +void Dbtup::cprAddUndoLogWord(Signal* signal, LocalLogInfo* const lliPtr, Uint32 undoWord) +{ + DiskBufferSegmentInfoPtr dbsiPtr; + UndoPagePtr regUndoPagePtr; + + ljam(); + regUndoPagePtr.i = lliPtr->lliUndoPage; + ptrCheckGuard(regUndoPagePtr, cnoOfUndoPage, undoPage); + ndbrequire(lliPtr->lliUndoWord < ZWORDS_ON_PAGE); + regUndoPagePtr.p->undoPageWord[lliPtr->lliUndoWord] = undoWord; + + lliPtr->lliUndoWord++; + if (lliPtr->lliUndoWord == ZWORDS_ON_PAGE) { + ljam(); + lliPtr->lliUndoWord = ZUNDO_PAGE_HEADER_SIZE; + lliPtr->lliUndoPage++; + if (clblPageCounter > 0) { + ljam(); + clblPageCounter--; + }//if + dbsiPtr.i = lliPtr->lliUndoBufferSegmentP; + ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo); + dbsiPtr.p->pdxNumDataPages++; + ndbrequire(dbsiPtr.p->pdxNumDataPages < 16); + lliPtr->lliLogFilePage++; + if (dbsiPtr.p->pdxNumDataPages == ZUB_SEGMENT_SIZE) { + ljam(); + lcpWriteUndoSegment(signal, lliPtr, false); + }//if + }//if +}//Dbtup::cprAddUndoLogWord() + +void Dbtup::lcpWriteUndoSegment(Signal* signal, LocalLogInfo* const lliPtr, bool flushFlag) +{ + DiskBufferSegmentInfoPtr dbsiPtr; + + dbsiPtr.i = lliPtr->lliUndoBufferSegmentP; + ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo); + Uint32 flags = 1; + lliPtr->lliUndoPagesToDiskWithoutSynch += dbsiPtr.p->pdxNumDataPages; + if ((lliPtr->lliUndoPagesToDiskWithoutSynch > MAX_PAGES_WITHOUT_SYNCH) || + (flushFlag)) { + ljam(); +/* ---------------------------------------------------------------- */ +// To avoid synching too big chunks at a time we synch after writing +// a certain number of data pages. (e.g. 2 MBytes). +/* ---------------------------------------------------------------- */ + lliPtr->lliUndoPagesToDiskWithoutSynch = 0; + flags |= 0x10; //Set synch flag unconditionally + }//if + dbsiPtr.p->pdxOperation = CHECKPOINT_UNDO_WRITE; + signal->theData[0] = lliPtr->lliUndoFileHandle; + signal->theData[1] = cownref; + signal->theData[2] = dbsiPtr.i; + signal->theData[3] = flags; + signal->theData[4] = ZBASE_ADDR_UNDO_WORD; + signal->theData[5] = dbsiPtr.p->pdxNumDataPages; + signal->theData[6] = dbsiPtr.p->pdxDataPage[0]; + signal->theData[7] = dbsiPtr.p->pdxFilePage; + sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal, 8, JBA); + + DiskBufferSegmentInfoPtr newDbsiPtr; + UndoPagePtr newUndoPagePtr; + + seizeUndoBufferSegment(signal, newUndoPagePtr); + seizeDiskBufferSegmentRecord(newDbsiPtr); + newDbsiPtr.p->pdxBuffertype = UNDO_PAGES; + for (Uint32 i = 0; i < ZUB_SEGMENT_SIZE; i++) { + newDbsiPtr.p->pdxDataPage[i] = newUndoPagePtr.i + i; + }//for + newDbsiPtr.p->pdxFilePage = lliPtr->lliLogFilePage; + lliPtr->lliUndoPage = newUndoPagePtr.i; + lliPtr->lliUndoBufferSegmentP = newDbsiPtr.i; +}//Dbtup::lcpWriteUndoSegment() + +void Dbtup::seizeUndoBufferSegment(Signal* signal, UndoPagePtr& regUndoPagePtr) +{ + if (cnoFreeUndoSeg == ZMIN_PAGE_LIMIT_TUP_COMMITREQ) { + EXECUTE_DIRECT(DBLQH, GSN_TUP_COM_BLOCK, signal, 1); + ljamEntry(); + }//if + cnoFreeUndoSeg--; + ndbrequire(cnoFreeUndoSeg >= 0); + ndbrequire(cfirstfreeUndoSeg != RNIL); + regUndoPagePtr.i = cfirstfreeUndoSeg; + ptrCheckGuard(regUndoPagePtr, cnoOfUndoPage, undoPage); + cfirstfreeUndoSeg = regUndoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS]; + regUndoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS] = RNIL; +}//Dbtup::seizeUndoBufferSegment() + + + diff --git a/ndb/src/kernel/blocks/dbtup/Makefile b/ndb/src/kernel/blocks/dbtup/Makefile new file mode 100644 index 00000000000..87146f4b441 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/Makefile @@ -0,0 +1,26 @@ +include .defs.mk + +TYPE := kernel + +ARCHIVE_TARGET := dbtup +SOURCES = \ + DbtupExecQuery.cpp \ + DbtupBuffer.cpp \ + DbtupRoutines.cpp \ + DbtupCommit.cpp \ + DbtupFixAlloc.cpp \ + DbtupTrigger.cpp \ + DbtupAbort.cpp \ + DbtupLCP.cpp \ + DbtupUndoLog.cpp \ + DbtupPageMap.cpp \ + DbtupPagMan.cpp \ + DbtupStoredProcDef.cpp \ + DbtupMeta.cpp \ + DbtupTabDesMan.cpp \ + DbtupGen.cpp \ + DbtupSystemRestart.cpp \ + DbtupIndex.cpp \ + DbtupDebug.cpp + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/kernel/blocks/dbtup/Notes.txt b/ndb/src/kernel/blocks/dbtup/Notes.txt new file mode 100644 index 00000000000..9d47c591fe8 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtup/Notes.txt @@ -0,0 +1,183 @@ +Operations, tuples, versions +============================ + +Operation types. + +INSERT insert new original tuple, or insert after delete +UPDATE update +DELETE delete + +Following need not be considered here. + +READ does not change tuples or versions +WRITE turns into INSERT or UPDATE in LQH + +We use more specific names in some cases: + +first/INSERT initial insert of new tuple +delete/INSERT INSERT preceded by DELETE +DELETE/last DELETE as last operation +DELETE/insert DELETE followed by INSERT + +Tuple + op Can be followed by +-------------- ------------------ +does not exist first/INSERT +tuple exists UPDATE DELETE +INSERT UPDATE DELETE +UPDATE UPDATE DELETE +DELETE delete/INSERT + +Operations on same tuple are kept in doubly linked list until +commit or abort. The links at both ends are RNIL i.e. the list +is not circular. The links are: + +nextActiveOp the operation BEFORE this one, in event order +prevActiveOp the operation AFTER this one, in event order + +Operations are done on the "original tuple" i.e. the tuple is +modified in place. If an operation is about to write over data +in original tuple, it first copies the tuple to a "copy tuple". + +Operation Copy tuple +--------- ---------- +first/INSERT no +delete/INSERT yes (this is in effect an update) +UPDATE yes +DELETE no + +The operation points to the tuples via: + +realPageId page i-value of original tuple +pageOffset word offset of original tuple on the page +realPageIdC page i-value of copy tuple or RNIL is no copy exists +pageOffsetC word offset of copy tuple on the page + +The original tuple and the copy tuple (if any) point back to +the operation via word 0. In copy tuple this pointer is never +changed. In original tuple however it always points to the LATEST +existing operation i.e. the one with prevActiveOp == RNIL. +Thus word 0 of original tuple is changed on 2 occasions: + +- when a new operation is added to the list +- when commit or abort removes the latest operation + +Note that commit/abort of operations occurs in random order. +The list is adjusted accordingly. + +Versions +-------- + +Tuple version is stored in tuple word 1. A new original tuple +gets version 0. The version is incremented by each new operation +which makes a copy tuple. Version number wraps around at 15 bits. + +When a copy tuple is made, the version in original tuple is copied +to copy tuple as part of tuple data. This takes place before +the version in original tuple is updated. + +Each operation record contains tuple version called tupVersion. + +- at insert of new original tuple, tupVersion is set to 0 + +- if tuple already exists, the FIRST operation (in event order) + reads tupVersion from tuple word 1. If the operation is + not DELETE, the version is incremented + +- subsequent operation reads tupVersion from the operation + BEFORE it (nextActiveOp). If this subsequent operation is + not DELETE, the version is incremented + +When the operation writes the tuple it sets word 1 to tupVersion. +In detail, per operation type, where INSERT is divided into +insert of new original tuple and insert after delete: + +Operation Copy Increment Set version in original +--------- ---- --------- ----------------------- +first/INSERT no no yes, to 0 +delete/INSERT yes yes yes +UPDATE yes yes yes +DELETE no no no + +Thus an existing version is incremented if and only if +a copy tuple is made. + +Ordered index maintenance +------------------------- + +Each index entry has logical tuple address and tuple version. +Index entries are added during prepare phase (when each operation +is executed) and removed during commit or abort phase. + +Access to correct tuple version (original or copy) is required +in TUX which reads index key values 1) to check that at least one +is not null 2) to do tree search 3) to set min/max prefixes. +See "Read attributes" below. + +An additional complication is that commit/abort of operations +arrives in random order. So we cannot check for, for example, +DELETE/insert by looking at prevActiveOp. + +Phase Op Action Version in +----- -- ------ ---------- +prepare INSERT add op and original +prepare UPDATE add op and original +prepare DELETE none - + +commit first/INSERT none - +commit delete/INSERT remove copy tuple 1) +commit UPDATE remove copy tuple 1) +commit DELETE/last remove op and original +commit DELETE/insert none - + +abort INSERT remove op +abort UPDATE remove op +abort DELETE none - + +1) alternatively, store prevTupVersion in operation record. + +Read attributes, query status +----------------------------- + +TUP_READ_ATTRS signal (or equivalent direct call) reads attribute +values. Input is logical address of original tuple and tuple +version. The steps are: + +- Translate logical address to physical address of original tuple. + +- If version of original tuple in word 1 is right, stop. + +- Otherwise word 0 points to LATEST not yet deleted operation. + Walk through operation list via nextActiveOp. + +- If an operation on the list has realPageIdC == RNIL, skip it. + +- Otherwise find copy tuple via realPageIdC, pageOffsetC. + If the version of the copy tuple in word 1 is right, stop. + +- Call readAttributes() on the tuple found (original or copy). + +In short, the version must exist in some not yet deleted tuple, +either in original or in some copy. + +Note that this must work during all phases since index code +needs to read index key attributes from correct tuple version in +each add/remove operation. + +TUP_QUERY_TH signal (or equivalent direct call) does same search +for tuple version. It is called from index scan and returns info +used to decide if the scan can see the tuple. + +This signal may also be called during any phase since commit/abort +of all operations is not done in one time-slice. + +Commit and abort +---------------- + +[ hairy stuff ] + +Problems +-------- + +Current abort code can destroy a tuple version too early. This +happens in test case "ticuur" (insert-commit-update-update-rollback), +if abort of first update arrives before abort of second update. diff --git a/ndb/src/kernel/blocks/dbtux/Dbtux.hpp b/ndb/src/kernel/blocks/dbtux/Dbtux.hpp new file mode 100644 index 00000000000..c56e455a42a --- /dev/null +++ b/ndb/src/kernel/blocks/dbtux/Dbtux.hpp @@ -0,0 +1,1218 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DBTUX_H +#define DBTUX_H + +#include +#include +#include +#include +#include +#include +#include + +// signal classes +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// debug +#ifdef VM_TRACE +#include +#include +#endif + +// jams +#undef jam +#undef jamEntry +#ifdef DBTUX_GEN_CPP +#define jam() jamLine(10000 + __LINE__) +#define jamEntry() jamEntryLine(10000 + __LINE__) +#endif +#ifdef DBTUX_META_CPP +#define jam() jamLine(20000 + __LINE__) +#define jamEntry() jamEntryLine(20000 + __LINE__) +#endif +#ifdef DBTUX_MAINT_CPP +#define jam() jamLine(30000 + __LINE__) +#define jamEntry() jamEntryLine(30000 + __LINE__) +#endif +#ifdef DBTUX_NODE_CPP +#define jam() jamLine(40000 + __LINE__) +#define jamEntry() jamEntryLine(40000 + __LINE__) +#endif +#ifdef DBTUX_TREE_CPP +#define jam() jamLine(50000 + __LINE__) +#define jamEntry() jamEntryLine(50000 + __LINE__) +#endif +#ifdef DBTUX_SCAN_CPP +#define jam() jamLine(60000 + __LINE__) +#define jamEntry() jamEntryLine(60000 + __LINE__) +#endif +#ifdef DBTUX_CMP_CPP +#define jam() jamLine(70000 + __LINE__) +#define jamEntry() jamEntryLine(70000 + __LINE__) +#endif +#ifdef DBTUX_DEBUG_CPP +#define jam() jamLine(90000 + __LINE__) +#define jamEntry() jamEntryLine(90000 + __LINE__) +#endif + +class Configuration; + +class Dbtux : public SimulatedBlock { +public: + Dbtux(const Configuration& conf); + virtual ~Dbtux(); + +private: + // sizes are in words (Uint32) + static const unsigned MaxIndexFragments = 2 * NO_OF_FRAG_PER_NODE; + static const unsigned MaxIndexAttributes = MAX_ATTRIBUTES_IN_INDEX; +#ifdef VM_TRACE + static const unsigned MaxNodeHandles = 10000; // More space for printTree +#else + static const unsigned MaxNodeHandles = 128; // enough for 1 operation +#endif + static const unsigned MaxAttrDataSize = 2048; + static const unsigned DescPageSize = 256; + static const unsigned MaxTreeNodeSize = MAX_TTREE_NODE_SIZE; + static const unsigned ScanBoundSegmentSize = 7; + static const unsigned MaxAccLockOps = MAX_PARALLEL_OP_PER_SCAN; + BLOCK_DEFINES(Dbtux); + + // forward declarations + struct DescEnt; + + /* + * Pointer to Uint32 data. Interpretation is context dependent. + */ + struct Data { + private: + Uint32* m_data; + public: + Data(); + Data(Uint32* data); + Data& operator=(Uint32* data); + operator Uint32*() const; + Data& operator+=(size_t n); + AttributeHeader& ah() const; + }; + + /* + * Pointer to constant Uint32 data. + */ + struct ConstData { + private: + const Uint32* m_data; + public: + ConstData(); + ConstData(const Uint32* data); + ConstData& operator=(const Uint32* data); + operator const Uint32*() const; + ConstData& operator+=(size_t n); + const AttributeHeader& ah() const; + // non-const pointer can be cast to const pointer + ConstData(Data data); + ConstData& operator=(Data data); + }; + + // AttributeHeader size is assumed to be 1 word + static const unsigned AttributeHeaderSize = 1; + + /* + * Logical tuple address, "local key". Identifies both table tuples + * and index tuples. The code assumes it is one word. + */ + typedef Uint32 TupAddr; + static const unsigned NullTupAddr = (Uint32)-1; + + /* + * Physical tuple address in TUP. Provides fast access to table tuple + * or index node. Valid within the db node and across timeslices. + * Not valid between db nodes or across restarts. + */ + struct TupLoc { + Uint32 m_pageId; // page i-value + Uint16 m_pageOffset; // page offset in words + TupLoc(); + }; + + // tree definitions + + /* + * Tree entry. Points to a tuple in primary table via logical address + * of "original" tuple and tuple version. Uses 2 words to get correct + * aligment (one byte is wasted currently). + */ + struct TreeEnt { + TupAddr m_tupAddr; // address of original tuple + Uint16 m_tupVersion; // version + Uint8 m_fragBit; // which duplicated table fragment + Uint8 unused1; + TreeEnt(); + // methods + int cmp(const TreeEnt ent) const; + }; + static const unsigned TreeEntSize = sizeof(TreeEnt) >> 2; + static const TreeEnt NullTreeEnt; + + /* + * Tree node has 1) fixed part 2) actual table data for min and max + * prefix 3) max and min entries 4) rest of entries 5) one extra entry + * used as work space. + * + * struct TreeNode part 1 + * min prefix part 2, size TreeHead::m_prefSize + * max prefix part 2, size TreeHead::m_prefSize + * max entry part 3 + * min entry part 3 + * rest of entries part 4 + * work entry part 5 + * + * Occupancy (number of entries) is at least 1 except temporarily when + * a node is about to be removed. If occupancy is 1, only max entry + * is present but both min and max prefixes are set. + */ + struct TreeNode { + TupAddr m_link[3]; // link to 0-left child 1-right child 2-parent + Uint8 m_side; // we are 0-left child 1-right child 2-root + Uint8 m_occup; // current number of entries + Int8 m_balance; // balance -1, 0, +1 + Uint8 unused1; + Uint32 m_nodeScan; // list of scans at this node + TreeNode(); + }; + static const unsigned NodeHeadSize = sizeof(TreeNode) >> 2; + + /* + * Tree nodes are not always accessed fully, for cache reasons. There + * are 3 access sizes. + */ + enum AccSize { + AccNone = 0, + AccHead = 1, // part 1 + AccPref = 2, // parts 1-3 + AccFull = 3 // parts 1-5 + }; + + /* + * Tree header. There is one in each fragment. Contains tree + * parameters and address of root node. + */ + struct TreeHead { + Uint8 m_nodeSize; // words in tree node + Uint8 m_prefSize; // words in min/max prefix each + Uint8 m_minOccup; // min entries in internal node + Uint8 m_maxOccup; // max entries in node + TupAddr m_root; // root node + TreeHead(); + // methods + unsigned getSize(AccSize acc) const; + Data getPref(TreeNode* node, unsigned i) const; + TreeEnt* getEntList(TreeNode* node) const; + }; + + /* + * Tree position. Specifies node, position within node (from 0 to + * m_occup), and whether the position is at an existing entry or + * before one (if any). Position m_occup points past the node and is + * also represented by position 0 of next node. Includes direction + * and copy of entry used by scan. + */ + struct TreePos { + TupAddr m_addr; // logical node address + TupLoc m_loc; // physical address + Uint16 m_pos; // position 0 to m_occup + Uint8 m_match; // at an existing entry + Uint8 m_dir; // from link (0-2) or within node (3) + TreeEnt m_ent; // copy of current entry + TreePos(); + }; + + // packed metadata + + /* + * Descriptor page. The "hot" metadata for an index is stored as + * a contiguous array of words on some page. + */ + struct DescPage { + Uint32 m_nextPage; + Uint32 m_numFree; // number of free words + union { + Uint32 m_data[DescPageSize]; + Uint32 nextPool; + }; + DescPage(); + }; + typedef Ptr DescPagePtr; + ArrayPool c_descPagePool; + Uint32 c_descPageList; + + /* + * Header for index metadata. Size must be multiple of word size. + */ + struct DescHead { + unsigned m_indexId : 24; + unsigned pad1 : 8; + }; + static const unsigned DescHeadSize = sizeof(DescHead) >> 2; + + /* + * Attribute metadata. Size must be multiple of word size. + */ + struct DescAttr { + unsigned m_primaryAttrId : 16; + unsigned m_typeId : 8; + unsigned m_nullable : 1; + unsigned pad1 : 7; + }; + static const unsigned DescAttrSize = sizeof(DescAttr) >> 2; + + /* + * Complete metadata for one index. The array of attributes has + * variable size. + */ + struct DescEnt { + DescHead m_descHead; + DescAttr m_descAttr[1]; // variable size data + }; + + // range scan + + /* + * Scan bounds are stored in linked list of segments. + */ + typedef DataBuffer ScanBound; + typedef DataBuffer::ConstDataBufferIterator ScanBoundIterator; + typedef DataBuffer::DataBufferPool ScanBoundPool; + ScanBoundPool c_scanBoundPool; + + /* + * Scan operation. + * + * Tuples are locked one at a time. The current lock op is set to + * RNIL as soon as the lock is obtained and passed to LQH. We must + * however remember all locks which LQH has not returned for unlocking + * since they must be aborted by us when the scan is closed. + * + * Scan state describes the entry we are interested in. There is + * a separate lock wait flag. It may be for current entry or it may + * be for an entry we were moved away from. In any case nothing + * happens with current entry before lock wait flag is cleared. + */ + struct ScanOp { + enum { + Undef = 0, + First = 1, // before first entry + Current = 2, // at current before locking + Blocked = 3, // at current waiting for ACC lock + Locked = 4, // at current and locked or no lock needed + Next = 5, // looking for next extry + Last = 6, // after last entry + Aborting = 7, // lock wait at scan close + Invalid = 9 // cannot return REF to LQH currently + }; + Uint16 m_state; + Uint16 m_lockwait; + Uint32 m_userPtr; // scanptr.i in LQH + Uint32 m_userRef; + Uint32 m_tableId; + Uint32 m_indexId; + Uint32 m_fragId; + Uint32 m_fragPtrI; + Uint32 m_transId1; + Uint32 m_transId2; + Uint32 m_savePointId; + // lock waited for or obtained and not yet passed to LQH + Uint32 m_accLockOp; + // locks obtained and passed to LQH but not yet returned by LQH + Uint32 m_accLockOps[MaxAccLockOps]; + Uint8 m_readCommitted; // no locking + Uint8 m_lockMode; + Uint8 m_keyInfo; + ScanBound m_boundMin; + ScanBound m_boundMax; + ScanBound* m_bound[2]; // pointers to above 2 + Uint16 m_boundCnt[2]; // number of bounds in each + TreePos m_scanPos; // position + TreeEnt m_lastEnt; // last entry returned + Uint32 m_nodeScan; // next scan at node (single-linked) + union { + Uint32 nextPool; + Uint32 nextList; + }; + Uint32 prevList; + ScanOp(ScanBoundPool& scanBoundPool); + }; + typedef Ptr ScanOpPtr; + ArrayPool c_scanOpPool; + + // indexes and fragments + + /* + * Ordered index. Top level data structure. The primary table (table + * being indexed) lives in TUP. + */ + struct Index { + enum State { + NotDefined = 0, + Defining = 1, + Online = 2, // triggers activated and build done + Dropping = 9 + }; + State m_state; + DictTabInfo::TableType m_tableType; + Uint32 m_tableId; + Uint16 m_fragOff; // offset for duplicate fragId bits + Uint16 m_numFrags; + Uint32 m_fragId[MaxIndexFragments]; + Uint32 m_fragPtrI[MaxIndexFragments]; + Uint32 m_descPage; // descriptor page + Uint16 m_descOff; // offset within the page + Uint16 m_numAttrs; + union { + Uint32 nextPool; + }; + Index(); + }; + typedef Ptr IndexPtr; + ArrayPool c_indexPool; + + /* + * Fragment of an index, as known to DIH/TC. Represents the two + * duplicate fragments known to LQH/ACC/TUP. Includes tree header. + * There are no maintenance operation records yet. + */ + struct Frag { + Uint32 m_tableId; // copy from index level + Uint32 m_indexId; + Uint16 m_fragOff; + Uint16 m_fragId; + Uint32 m_descPage; // copy from index level + Uint16 m_descOff; + Uint16 m_numAttrs; + TreeHead m_tree; + Uint32 m_nodeList; // node cache of current operation + Uint32 m_nodeFree; // one node pre-allocated for insert + DLList m_scanList; // current scans on this fragment + union { + Uint32 nextPool; + }; + Frag(ArrayPool& scanOpPool); + }; + typedef Ptr FragPtr; + ArrayPool c_fragPool; + + /* + * Fragment metadata operation. + */ + struct FragOp { + Uint32 m_userPtr; + Uint32 m_userRef; + Uint32 m_indexId; + Uint32 m_fragId; + Uint32 m_fragPtrI; + Uint32 m_fragNo; // fragment number starting at zero + Uint32 m_numAttrsRecvd; + union { + Uint32 nextPool; + }; + FragOp(); + }; + typedef Ptr FragOpPtr; + ArrayPool c_fragOpPool; + + // node handles + + /* + * A tree operation builds a cache of accessed nodes. This allows + * different implementations of index memory access. The cache is + * committed and released at the end of the operation. + */ + struct NodeHandle { + enum Flags { + // bits 0,1 mark need for left,right prefix + DoInsert = (1 << 2), + DoDelete = (1 << 3), + DoUpdate = (1 << 4) + }; + Dbtux& m_tux; // this block + Frag& m_frag; // fragment using the node + TupAddr m_addr; // logical node address + TupLoc m_loc; // physical node address + AccSize m_acc; // accessed size + unsigned m_flags; // flags + union { + Uint32 m_next; // next active node under fragment + Uint32 nextPool; + }; + TreeNode* m_node; // pointer to node storage + Uint32 m_cache[MaxTreeNodeSize]; + NodeHandle(Dbtux& tux, Frag& frag); + // getters + TupAddr getLink(unsigned i); + unsigned getChilds(); // cannot spell + unsigned getSide(); + unsigned getOccup(); + int getBalance(); + Uint32 getNodeScan(); + Data getPref(unsigned i); + TreeEnt getEnt(unsigned pos); + TreeEnt getMinMax(unsigned i); + // setters + void setLink(unsigned i, TupAddr addr); + void setSide(unsigned i); + void setOccup(unsigned n); + void setBalance(int b); + void setNodeScan(Uint32 scanPtrI); + // operations XXX maybe these should move to Dbtux level + void pushUp(Signal* signal, unsigned pos, const TreeEnt& ent); + void popDown(Signal* signal, unsigned pos, TreeEnt& ent); + void pushDown(Signal* signal, unsigned pos, TreeEnt& ent); + void popUp(Signal* signal, unsigned pos, TreeEnt& ent); + void slide(Signal* signal, Ptr nodePtr, unsigned i); + void linkScan(Dbtux::ScanOpPtr scanPtr); + void unlinkScan(Dbtux::ScanOpPtr scanPtr); + bool islinkScan(Dbtux::ScanOpPtr scanPtr); + // for ndbrequire + void progError(int line, int cause, const char* extra); + }; + typedef Ptr NodeHandlePtr; + ArrayPool c_nodeHandlePool; + friend class NodeHandle; + + // parameters for methods + + /* + * Copy attribute data. + */ + struct CopyPar { + unsigned m_items; // number of attributes + bool m_headers; // copy headers flag (default true) + unsigned m_maxwords; // limit size (default no limit) + // output + unsigned m_numitems; // number of attributes fully copied + unsigned m_numwords; // number of words copied + CopyPar(); + }; + + /* + * Read index key attributes. + */ + struct ReadPar { + TreeEnt m_ent; // tuple to read + unsigned m_first; // first index attribute + unsigned m_count; // number of consecutive index attributes + Data m_data; // set pointer if 0 else copy result to it + unsigned m_size; // number of words (set in read keys only) + ReadPar(); + }; + + /* + * Node storage operation. + */ + struct StorePar { + TupStoreTh::OpCode m_opCode;// operation code + unsigned m_offset; // data offset in words + unsigned m_size; // number of words + Uint32 m_errorCode; // terrorCode from TUP + StorePar(); + }; + + /* + * Tree search for entry. + */ + struct SearchPar { + ConstData m_data; // input index key values + TreeEnt m_ent; // input tuple and version + SearchPar(); + }; + + /* + * Attribute data comparison. + */ + struct CmpPar { + ConstData m_data1; // full search key + ConstData m_data2; // full or prefix data + unsigned m_len2; // words in data2 buffer + unsigned m_first; // first attribute + unsigned m_numEq; // number of initial equal attributes + CmpPar(); + }; + + /* + * Scan bound comparison. + */ + struct BoundPar { + ConstData m_data1; // full bound data + ConstData m_data2; // full or prefix data + unsigned m_count1; // number of bounds + unsigned m_len2; // words in data2 buffer + unsigned m_dir; // 0-lower bound 1-upper bound + BoundPar(); + }; + + // methods + + /* + * DbtuxGen.cpp + */ + void execCONTINUEB(Signal* signal); + void execSTTOR(Signal* signal); + void execSIZEALT_REP(Signal* signal); + // utils + void copyAttrs(Data dst, ConstData src, CopyPar& copyPar); + + /* + * DbtuxMeta.cpp + */ + void execTUXFRAGREQ(Signal* signal); + void execTUX_ADD_ATTRREQ(Signal* signal); + void execALTER_INDX_REQ(Signal* signal); + void execDROP_TAB_REQ(Signal* signal); + bool allocDescEnt(IndexPtr indexPtr); + void freeDescEnt(IndexPtr indexPtr); + void dropIndex(Signal* signal, IndexPtr indexPtr, Uint32 senderRef, Uint32 senderData); + // helpers + DescEnt& getDescEnt(Uint32 descPage, Uint32 descOff); + + /* + * DbtuxMaint.cpp + */ + void execTUX_MAINT_REQ(Signal* signal); + void tupReadAttrs(Signal* signal, const Frag& frag, ReadPar& readPar); + void tupReadKeys(Signal* signal, const Frag& frag, ReadPar& readPar); + void tupStoreTh(Signal* signal, const Frag& frag, NodeHandlePtr nodePtr, StorePar storePar); + + /* + * DbtuxNode.cpp + */ + void seizeNode(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr); + void preallocNode(Signal* signal, Frag& frag, Uint32& errorCode); + void findNode(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr, TupAddr addr); + void selectNode(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr, TupAddr addr, AccSize acc); + void insertNode(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr, AccSize acc); + void deleteNode(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr); + void accessNode(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr, AccSize acc); + void setNodePref(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr, unsigned i); + void commitNodes(Signal* signal, Frag& frag, bool updateOk); + + /* + * DbtuxTree.cpp + */ + void treeSearch(Signal* signal, Frag& frag, SearchPar searchPar, TreePos& treePos); + void treeAdd(Signal* signal, Frag& frag, TreePos treePos, TreeEnt ent); + void treeRemove(Signal* signal, Frag& frag, TreePos treePos); + void treeRotateSingle(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr, unsigned i); + void treeRotateDouble(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr, unsigned i); + + /* + * DbtuxScan.cpp + */ + void execACC_SCANREQ(Signal* signal); + void execTUX_BOUND_INFO(Signal* signal); + void execNEXT_SCANREQ(Signal* signal); + void execACC_CHECK_SCAN(Signal* signal); + void execACCKEYCONF(Signal* signal); + void execACCKEYREF(Signal* signal); + void execACC_ABORTCONF(Signal* signal); + void scanFirst(Signal* signal, ScanOpPtr scanPtr); + void scanNext(Signal* signal, ScanOpPtr scanPtr); + bool scanVisible(Signal* signal, ScanOpPtr scanPtr, TreeEnt ent); + void scanClose(Signal* signal, ScanOpPtr scanPtr); + void addAccLockOp(ScanOp& scan, Uint32 accLockOp); + void removeAccLockOp(ScanOp& scan, Uint32 accLockOp); + void releaseScanOp(ScanOpPtr& scanPtr); + + /* + * DbtuxCmp.cpp + */ + int cmpTreeAttrs(const Frag& frag, CmpPar& cmpPar); + int cmpScanBound(const Frag& frag, const BoundPar boundPar); + + /* + * DbtuxDebug.cpp + */ + void execDUMP_STATE_ORD(Signal* signal); +#ifdef VM_TRACE + struct PrintPar { + char m_path[100]; // LR prefix + unsigned m_side; // expected side + TupAddr m_parent; // expected parent address + int m_depth; // returned depth + unsigned m_occup; // returned occupancy + bool m_ok; // returned status + PrintPar(); + }; + void printTree(Signal* signal, Frag& frag, NdbOut& out); + void printNode(Signal* signal, Frag& frag, NdbOut& out, TupAddr addr, PrintPar& par); + friend class NdbOut& operator<<(NdbOut&, const TreeEnt&); + friend class NdbOut& operator<<(NdbOut&, const TreeNode&); + friend class NdbOut& operator<<(NdbOut&, const TreeHead&); + friend class NdbOut& operator<<(NdbOut&, const TreePos&); + friend class NdbOut& operator<<(NdbOut&, const DescAttr&); + friend class NdbOut& operator<<(NdbOut&, const Index&); + friend class NdbOut& operator<<(NdbOut&, const Frag&); + friend class NdbOut& operator<<(NdbOut&, const NodeHandle&); + friend class NdbOut& operator<<(NdbOut&, const ScanOp&); + FILE* debugFile; + NdbOut debugOut; + unsigned debugFlags; + enum { + DebugMeta = 1, // log create and drop index + DebugMaint = 2, // log maintenance ops + DebugTree = 4, // log and check tree after each op + DebugScan = 8 // log scans + }; +#endif + + // start up info + Uint32 c_internalStartPhase; + Uint32 c_typeOfStart; + + // buffers + Data c_keyBuffer; // search key or scan bound + + // small stuff + static unsigned min(unsigned x, unsigned y); + static unsigned max(unsigned x, unsigned y); +}; + +// Dbtux::Data + +inline +Dbtux::Data::Data() : + m_data(0) +{ +} + +inline +Dbtux::Data::Data(Uint32* data) : + m_data(data) +{ +} + +inline Dbtux::Data& +Dbtux::Data::operator=(Uint32* data) +{ + m_data = data; + return *this; +} + +inline +Dbtux::Data::operator Uint32*() const +{ + return m_data; +} + +inline Dbtux::Data& +Dbtux::Data::operator+=(size_t n) +{ + m_data += n; + return *this; +} + +inline AttributeHeader& +Dbtux::Data::ah() const +{ + return *reinterpret_cast(m_data); +} + +// Dbtux::ConstData + +inline +Dbtux::ConstData::ConstData() : + m_data(0) +{ +} + +inline +Dbtux::ConstData::ConstData(const Uint32* data) : + m_data(data) +{ +} + +inline Dbtux::ConstData& +Dbtux::ConstData::operator=(const Uint32* data) +{ + m_data = data; + return *this; +} + +inline +Dbtux::ConstData::operator const Uint32*() const +{ + return m_data; +} + +inline Dbtux::ConstData& +Dbtux::ConstData::operator+=(size_t n) +{ + m_data += n; + return *this; +} + +inline const AttributeHeader& +Dbtux::ConstData::ah() const +{ + return *reinterpret_cast(m_data); +} + +inline +Dbtux::ConstData::ConstData(Data data) : + m_data(static_cast(data)) +{ +} + +inline Dbtux::ConstData& +Dbtux::ConstData::operator=(Data data) +{ + m_data = static_cast(data); + return *this; +} + +// Dbtux::TreeEnt + +inline int +Dbtux::TreeEnt::cmp(const TreeEnt ent) const +{ + // compare frags first (not optimal but makes easier to read logs) + if (m_fragBit < ent.m_fragBit) + return -1; + if (m_fragBit > ent.m_fragBit) + return +1; + if (m_tupAddr < ent.m_tupAddr) + return -1; + if (m_tupAddr > ent.m_tupAddr) + return +1; + if (m_tupVersion < ent.m_tupVersion) + return -1; + if (m_tupVersion > ent.m_tupVersion) + return +1; + return 0; +} + +// Dbtux::TreeHead + +inline unsigned +Dbtux::TreeHead::getSize(AccSize acc) const +{ + switch (acc) { + case AccNone: + return 0; + case AccHead: + return NodeHeadSize; + case AccPref: + return NodeHeadSize + 2 * m_prefSize + 2 * TreeEntSize; + case AccFull: + return m_nodeSize; + } + REQUIRE(false, "invalid Dbtux::AccSize"); + return 0; +} + +inline Dbtux::Data +Dbtux::TreeHead::getPref(TreeNode* node, unsigned i) const +{ + Uint32* ptr = (Uint32*)node + NodeHeadSize + i * m_prefSize; + return ptr; +} + +inline Dbtux::TreeEnt* +Dbtux::TreeHead::getEntList(TreeNode* node) const +{ + Uint32* ptr = (Uint32*)node + NodeHeadSize + 2 * m_prefSize; + return (TreeEnt*)ptr; +} + +// Dbtux + +// constructors + +inline +Dbtux::TupLoc::TupLoc() : + m_pageId(RNIL), + m_pageOffset(0) +{ +} + +inline +Dbtux::TreeEnt::TreeEnt() : + m_tupAddr(NullTupAddr), + m_tupVersion(0), + m_fragBit(255), + unused1(0) +{ +} + +inline +Dbtux::TreeNode::TreeNode() : + m_side(255), + m_occup(0), + m_balance(0), + unused1(0xa1), + m_nodeScan(RNIL) +{ + m_link[0] = NullTupAddr; + m_link[1] = NullTupAddr; + m_link[2] = NullTupAddr; +} + +inline +Dbtux::TreeHead::TreeHead() : + m_nodeSize(0), + m_prefSize(0), + m_minOccup(0), + m_maxOccup(0), + m_root(0) +{ +} + +inline +Dbtux::TreePos::TreePos() : + m_addr(NullTupAddr), + m_loc(), + m_pos(ZNIL), + m_match(false), + m_dir(255), + m_ent() +{ +} + +inline +Dbtux::DescPage::DescPage() : + m_nextPage(RNIL), + m_numFree(ZNIL) +{ + for (unsigned i = 0; i < DescPageSize; i++) { +#ifdef VM_TRACE + m_data[i] = 0x13571357; +#else + m_data[i] = 0; +#endif + } +} + +inline +Dbtux::Index::Index() : + m_state(NotDefined), + m_tableType(DictTabInfo::UndefTableType), + m_tableId(RNIL), + m_numFrags(0), + m_descPage(RNIL), + m_descOff(0), + m_numAttrs(0) +{ + for (unsigned i = 0; i < MaxIndexFragments; i++) { + m_fragId[i] = ZNIL; + m_fragPtrI[i] = RNIL; + }; +}; + +inline +Dbtux::Frag::Frag(ArrayPool& scanOpPool) : + m_tableId(RNIL), + m_indexId(RNIL), + m_fragOff(ZNIL), + m_fragId(ZNIL), + m_descPage(RNIL), + m_descOff(0), + m_numAttrs(ZNIL), + m_tree(), + m_nodeList(RNIL), + m_nodeFree(RNIL), + m_scanList(scanOpPool) +{ +} + +inline +Dbtux::FragOp::FragOp() : + m_userPtr(RNIL), + m_userRef(RNIL), + m_indexId(RNIL), + m_fragId(ZNIL), + m_fragPtrI(RNIL), + m_fragNo(ZNIL), + m_numAttrsRecvd(ZNIL) +{ +}; + +inline +Dbtux::NodeHandle::NodeHandle(Dbtux& tux, Frag& frag) : + m_tux(tux), + m_frag(frag), + m_addr(NullTupAddr), + m_loc(), + m_acc(AccNone), + m_flags(0), + m_next(RNIL), + m_node(0) +{ +} + +inline +Dbtux::ScanOp::ScanOp(ScanBoundPool& scanBoundPool) : + m_state(Undef), + m_lockwait(false), + m_userPtr(RNIL), + m_userRef(RNIL), + m_tableId(RNIL), + m_indexId(RNIL), + m_fragPtrI(RNIL), + m_transId1(0), + m_transId2(0), + m_savePointId(0), + m_accLockOp(RNIL), + m_readCommitted(0), + m_lockMode(0), + m_keyInfo(0), + m_boundMin(scanBoundPool), + m_boundMax(scanBoundPool), + m_scanPos(), + m_lastEnt(), + m_nodeScan(RNIL) +{ + m_bound[0] = &m_boundMin; + m_bound[1] = &m_boundMax; + m_boundCnt[0] = 0; + m_boundCnt[1] = 0; + for (unsigned i = 0; i < MaxAccLockOps; i++) { + m_accLockOps[i] = RNIL; + } +} + +inline +Dbtux::CopyPar::CopyPar() : + m_items(0), + m_headers(true), + m_maxwords(~0), // max unsigned + // output + m_numitems(0), + m_numwords(0) +{ +} + +inline +Dbtux::ReadPar::ReadPar() : + m_first(0), + m_count(0), + m_data(0), + m_size(0) +{ +} + +inline +Dbtux::StorePar::StorePar() : + m_opCode(TupStoreTh::OpUndefined), + m_offset(0), + m_size(0), + m_errorCode(0) +{ +} + +inline +Dbtux::SearchPar::SearchPar() : + m_data(0), + m_ent() +{ +} + +inline +Dbtux::CmpPar::CmpPar() : + m_data1(0), + m_data2(0), + m_len2(0), + m_first(0), + m_numEq(0) +{ +} + +inline +Dbtux::BoundPar::BoundPar() : + m_data1(0), + m_data2(0), + m_count1(0), + m_len2(0), + m_dir(255) +{ +} + +#ifdef VM_TRACE +inline +Dbtux::PrintPar::PrintPar() : + // caller fills in + m_path(), + m_side(255), + m_parent(NullTupAddr), + // default return values + m_depth(0), + m_occup(0), + m_ok(true) +{ +} +#endif + +// node handles + +inline Dbtux::TupAddr +Dbtux::NodeHandle::getLink(unsigned i) +{ + ndbrequire(i <= 2); + return m_node->m_link[i]; +} + +inline unsigned +Dbtux::NodeHandle::getChilds() +{ + return + (m_node->m_link[0] != NullTupAddr) + + (m_node->m_link[1] != NullTupAddr); +} + +inline Dbtux::TupAddr +Dbtux::NodeHandle::getSide() +{ + return m_node->m_side; +} + +inline unsigned +Dbtux::NodeHandle::getOccup() +{ + return m_node->m_occup; +} + +inline int +Dbtux::NodeHandle::getBalance() +{ + return m_node->m_balance; +} + +inline Uint32 +Dbtux::NodeHandle::getNodeScan() +{ + return m_node->m_nodeScan; +} + +inline Dbtux::Data +Dbtux::NodeHandle::getPref(unsigned i) +{ + TreeHead& tree = m_frag.m_tree; + ndbrequire(m_acc >= AccPref && i <= 1); + return tree.getPref(m_node, i); +} + +inline Dbtux::TreeEnt +Dbtux::NodeHandle::getEnt(unsigned pos) +{ + TreeHead& tree = m_frag.m_tree; + TreeEnt* entList = tree.getEntList(m_node); + const unsigned occup = m_node->m_occup; + ndbrequire(pos < occup); + if (pos == 0 || pos == occup - 1) { + ndbrequire(m_acc >= AccPref) + } else { + ndbrequire(m_acc == AccFull) + } + return entList[(1 + pos) % occup]; +} + +inline Dbtux::TreeEnt +Dbtux::NodeHandle::getMinMax(unsigned i) +{ + const unsigned occup = m_node->m_occup; + ndbrequire(i <= 1 && occup != 0); + return getEnt(i == 0 ? 0 : occup - 1); +} + +inline void +Dbtux::NodeHandle::setLink(unsigned i, TupAddr addr) +{ + ndbrequire(i <= 2); + m_node->m_link[i] = addr; + m_flags |= DoUpdate; +} + +inline void +Dbtux::NodeHandle::setSide(unsigned i) +{ + // ndbrequire(i <= 1); + m_node->m_side = i; + m_flags |= DoUpdate; +} + +inline void +Dbtux::NodeHandle::setOccup(unsigned n) +{ + TreeHead& tree = m_frag.m_tree; + ndbrequire(n <= tree.m_maxOccup); + m_node->m_occup = n; + m_flags |= DoUpdate; +} + +inline void +Dbtux::NodeHandle::setBalance(int b) +{ + ndbrequire(abs(b) <= 1); + m_node->m_balance = b; + m_flags |= DoUpdate; +} + +inline void +Dbtux::NodeHandle::setNodeScan(Uint32 scanPtrI) +{ + m_node->m_nodeScan = scanPtrI; + m_flags |= DoUpdate; +} + +// other methods + +inline Dbtux::DescEnt& +Dbtux::getDescEnt(Uint32 descPage, Uint32 descOff) +{ + DescPagePtr pagePtr; + pagePtr.i = descPage; + c_descPagePool.getPtr(pagePtr); + ndbrequire(descOff < DescPageSize); + DescEnt* descEnt = (DescEnt*)&pagePtr.p->m_data[descOff]; + return *descEnt; +} + +inline unsigned +Dbtux::min(unsigned x, unsigned y) +{ + return x < y ? x : y; +} + +inline unsigned +Dbtux::max(unsigned x, unsigned y) +{ + return x > y ? x : y; +} + +#endif diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxCmp.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxCmp.cpp new file mode 100644 index 00000000000..6404cc66213 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtux/DbtuxCmp.cpp @@ -0,0 +1,202 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTUX_CMP_CPP +#include "Dbtux.hpp" + +/* + * Search key vs tree entry. + * + * Compare search key and index attribute data. The attribute data may + * be partial in which case CmpUnknown may be returned. Also counts how + * many (additional) initial attributes were equal. + */ +int +Dbtux::cmpTreeAttrs(const Frag& frag, CmpPar& cmpPar) +{ + const DescEnt& descEnt = getDescEnt(frag.m_descPage, frag.m_descOff); + ConstData data1 = cmpPar.m_data1; + ConstData data2 = cmpPar.m_data2; + // number of words of attribute data left + unsigned len2 = cmpPar.m_len2; + const unsigned numAttrs = frag.m_numAttrs; + unsigned index = cmpPar.m_first; + ndbrequire(index < numAttrs); + // skip to right position in search key XXX do it before the call + for (unsigned i = 0; i < index; i++) { + jam(); + data1 += AttributeHeaderSize + data1.ah().getDataSize(); + } + unsigned numEq = 0; + int ret = 0; + while (index < numAttrs) { + if (len2 < AttributeHeaderSize) { + jam(); + ret = NdbSqlUtil::CmpUnknown; + break; + } + len2 -= AttributeHeaderSize; + if (! data1.ah().isNULL()) { + if (! data2.ah().isNULL()) { + jam(); + // current attribute + const DescAttr& descAttr = descEnt.m_descAttr[index]; + const unsigned typeId = descAttr.m_typeId; + // full data size + const unsigned size1 = data1.ah().getDataSize(); + ndbrequire(size1 != 0 && size1 == data2.ah().getDataSize()); + const unsigned size2 = min(size1, len2); + len2 -= size2; + // compare + const Uint32* const p1 = &data1[AttributeHeaderSize]; + const Uint32* const p2 = &data2[AttributeHeaderSize]; + ret = NdbSqlUtil::cmp(typeId, p1, p2, size1, size2); + if (ret != 0) { + jam(); + break; + } + } else { + jam(); + // not NULL < NULL + ret = -1; + break; + } + } else { + if (! data2.ah().isNULL()) { + jam(); + // NULL > not NULL + ret = +1; + break; + } + } + data1 += AttributeHeaderSize + data1.ah().getDataSize(); + data2 += AttributeHeaderSize + data2.ah().getDataSize(); + numEq++; + index++; + } + // XXX until data format errors are handled + ndbrequire(ret != NdbSqlUtil::CmpError); + cmpPar.m_numEq += numEq; // add to previous count + return ret; +} + +/* + * Scan bound vs tree entry. + * + * Compare lower or upper bound and index attribute data. The attribute + * data may be partial in which case CmpUnknown may be returned. + * Returns -1 if the boundary is to the left of the compared key and +1 if + * the boundary is to the right of the compared key. + * + * To get this behaviour we treat equality a little bit special. + * If the boundary is a lower bound then the boundary is to the left of all + * equal keys and if it is an upper bound then the boundary is to the right + * of all equal keys. + * + * When searching for the first key we are using the lower bound to try + * to find the first key that is to the right of the boundary. + * Then we start scanning from this tuple (including the tuple itself) + * until we find the first key which is to the right of the boundary. Then + * we stop and do not include that key in the scan result. + */ +int +Dbtux::cmpScanBound(const Frag& frag, const BoundPar boundPar) +{ + unsigned type = 4; + int ret = 0; + /* + No boundary means full scan, low boundary is to the right of all keys. + Thus we should always return -1. For upper bound we are to the right of + all keys, thus we should always return +1. We achieve this behaviour + by initialising return value to 0 and set type to 4. + */ + const DescEnt& descEnt = getDescEnt(frag.m_descPage, frag.m_descOff); + ConstData data1 = boundPar.m_data1; + ConstData data2 = boundPar.m_data2; + // direction 0-lower 1-upper + const unsigned dir = boundPar.m_dir; + ndbrequire(dir <= 1); + // number of words of data left + unsigned len2 = boundPar.m_len2; + for (unsigned i = 0; i < boundPar.m_count1; i++) { + if (len2 < AttributeHeaderSize) { + jam(); + return NdbSqlUtil::CmpUnknown; + } + len2 -= AttributeHeaderSize; + // get and skip bound type + type = data1[0]; + data1 += 1; + ndbrequire(! data1.ah().isNULL()); + if (! data2.ah().isNULL()) { + jam(); + // current attribute + const unsigned index = data1.ah().getAttributeId(); + const DescAttr& descAttr = descEnt.m_descAttr[index]; + const unsigned typeId = descAttr.m_typeId; + ndbrequire(data2.ah().getAttributeId() == descAttr.m_primaryAttrId); + // full data size + const unsigned size1 = data1.ah().getDataSize(); + ndbrequire(size1 != 0 && size1 == data2.ah().getDataSize()); + const unsigned size2 = min(size1, len2); + len2 -= size2; + // compare + const Uint32* const p1 = &data1[AttributeHeaderSize]; + const Uint32* const p2 = &data2[AttributeHeaderSize]; + ret = NdbSqlUtil::cmp(typeId, p1, p2, size1, size2); + if (ret != 0) { + jam(); + return ret; + } + } else { + jam(); + /* + NULL is bigger than any bound, thus the boundary is always to the + left of NULL + */ + return -1; + } + data1 += AttributeHeaderSize + data1.ah().getDataSize(); + data2 += AttributeHeaderSize + data2.ah().getDataSize(); + } + ndbassert(ret == 0); + if (dir == 0) { + jam(); + /* + Looking for the lower bound. If strict lower bound then the boundary is + to the right of the compared key and otherwise (equal included in range) + then the boundary is to the left of the key. + */ + if (type == 1) { + jam(); + return +1; + } + return -1; + } else { + jam(); + /* + Looking for the upper bound. If strict upper bound then the boundary is + to the left of all equal keys and otherwise (equal included in the + range) then the boundary is to the right of all equal keys. + */ + if (type == 3) { + jam(); + return -1; + } + return +1; + } +} + diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxDebug.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxDebug.cpp new file mode 100644 index 00000000000..c5d24205d1a --- /dev/null +++ b/ndb/src/kernel/blocks/dbtux/DbtuxDebug.cpp @@ -0,0 +1,369 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTUX_DEBUG_CPP +#include "Dbtux.hpp" + +/* + * 12001 log file 0-close 1-open 2-append 3-append to signal log + * 12002 log flags 1-meta 2-maint 4-tree 8-scan + */ +void +Dbtux::execDUMP_STATE_ORD(Signal* signal) +{ + jamEntry(); +#ifdef VM_TRACE + if (signal->theData[0] == DumpStateOrd::TuxLogToFile) { + unsigned flag = signal->theData[1]; + const char* const tuxlog = "tux.log"; + FILE* slFile = globalSignalLoggers.getOutputStream(); + if (flag <= 3) { + if (debugFile != 0) { + if (debugFile != slFile) + fclose(debugFile); + debugFile = 0; + debugOut = *new NdbOut(*new NullOutputStream()); + } + if (flag == 1) + debugFile = fopen(tuxlog, "w"); + if (flag == 2) + debugFile = fopen(tuxlog, "a"); + if (flag == 3) + debugFile = slFile; + if (debugFile != 0) + debugOut = *new NdbOut(*new FileOutputStream(debugFile)); + } + return; + } + if (signal->theData[0] == DumpStateOrd::TuxSetLogFlags) { + debugFlags = signal->theData[1]; + return; + } + if (signal->theData[0] == DumpStateOrd::TuxMetaDataJunk) { + // read table definition + Uint32 tableId = signal->theData[1]; + Uint32 tableVersion = signal->theData[2]; + int ret; + MetaData md(this); + MetaData::Table table; + MetaData::Attribute attribute; + infoEvent("md: read table %u %u", tableId, tableVersion); + if ((ret = md.lock(false)) < 0) { + infoEvent("md.lock error %d", ret); + return; + } + if ((ret = md.getTable(table, tableId, tableVersion)) < 0) { + infoEvent("md.getTable error %d", ret); + // lock is released by destructor + return; + } + infoEvent("md: %s type=%d attrs=%u", table.tableName, table.tableType, table.noOfAttributes); + for (Uint32 i = 0; i < table.noOfAttributes; i++) { + if ((ret = md.getAttribute(attribute, table, i)) < 0) { + infoEvent("mg.getAttribute %u error %d", i, ret); + // lock is released by destructor + return; + } + infoEvent("md: %d %s", attribute.attributeId, attribute.attributeName); + } + if ((ret = md.unlock(false)) < 0) { + infoEvent("md.unlock error %d", ret); + return; + } + return; + } +#endif +} + +#ifdef VM_TRACE + +void +Dbtux::printTree(Signal* signal, Frag& frag, NdbOut& out) +{ + TreeHead& tree = frag.m_tree; + PrintPar par; + strcpy(par.m_path, "."); + par.m_side = 2; + par.m_parent = NullTupAddr; + printNode(signal, frag, out, tree.m_root, par); + out.m_out->flush(); + if (! par.m_ok) { + if (debugFile == 0) { + signal->theData[0] = 12001; + signal->theData[1] = 1; + execDUMP_STATE_ORD(signal); + if (debugFile != 0) { + commitNodes(signal, frag, false); + printTree(signal, frag, debugOut); + } + } + ndbrequire(false); + } + commitNodes(signal, frag, false); +} + +void +Dbtux::printNode(Signal* signal, Frag& frag, NdbOut& out, TupAddr addr, PrintPar& par) +{ + if (addr == NullTupAddr) { + par.m_depth = 0; + return; + } + TreeHead& tree = frag.m_tree; + NodeHandlePtr nodePtr; + selectNode(signal, frag, nodePtr, addr, AccFull); + out << par.m_path << " " << *nodePtr.p << endl; + // check children + PrintPar cpar[2]; + ndbrequire(strlen(par.m_path) + 1 < sizeof(par.m_path)); + for (unsigned i = 0; i <= 1; i++) { + sprintf(cpar[i].m_path, "%s%c", par.m_path, "LR"[i]); + cpar[i].m_side = i; + cpar[i].m_depth = 0; + cpar[i].m_parent = addr; + printNode(signal, frag, out, nodePtr.p->getLink(i), cpar[i]); + if (! cpar[i].m_ok) { + par.m_ok = false; + } + } + // check child-parent links + if (nodePtr.p->getLink(2) != par.m_parent) { + par.m_ok = false; + out << par.m_path << " *** "; + out << "parent addr " << hex << nodePtr.p->getLink(2); + out << " should be " << hex << par.m_parent << endl; + } + if (nodePtr.p->getSide() != par.m_side) { + par.m_ok = false; + out << par.m_path << " *** "; + out << "side " << dec << nodePtr.p->getSide(); + out << " should be " << dec << par.m_side << endl; + } + // check balance + const int balance = -cpar[0].m_depth + cpar[1].m_depth; + if (nodePtr.p->getBalance() != balance) { + par.m_ok = false; + out << par.m_path << " *** "; + out << "balance " << nodePtr.p->getBalance(); + out << " should be " << balance << endl; + } + if (abs(nodePtr.p->getBalance()) > 1) { + par.m_ok = false; + out << par.m_path << " *** "; + out << "balance " << nodePtr.p->getBalance() << " is invalid" << endl; + } + // check occupancy + if (nodePtr.p->getOccup() > tree.m_maxOccup) { + par.m_ok = false; + out << par.m_path << " *** "; + out << "occupancy " << nodePtr.p->getOccup(); + out << " greater than max " << tree.m_maxOccup << endl; + } + // check for occupancy of interior node + if (nodePtr.p->getChilds() == 2 && nodePtr.p->getOccup() < tree.m_minOccup) { + par.m_ok = false; + out << par.m_path << " *** "; + out << "occupancy " << nodePtr.p->getOccup() << " of interior node"; + out << " less than min " << tree.m_minOccup << endl; + } + // check missed half-leaf/leaf merge + for (unsigned i = 0; i <= 1; i++) { + if (nodePtr.p->getLink(i) != NullTupAddr && + nodePtr.p->getLink(1 - i) == NullTupAddr && + nodePtr.p->getOccup() + cpar[i].m_occup <= tree.m_maxOccup) { + par.m_ok = false; + out << par.m_path << " *** "; + out << "missed merge with child " << i << endl; + } + } + // return values + par.m_depth = 1 + max(cpar[0].m_depth, cpar[1].m_depth); + par.m_occup = nodePtr.p->getOccup(); +} + +NdbOut& +operator<<(NdbOut& out, const Dbtux::TreeEnt& ent) +{ + out << dec << ent.m_fragBit; + out << "-" << hex << ent.m_tupAddr; + out << "-" << dec << ent.m_tupVersion; + return out; +} + +NdbOut& +operator<<(NdbOut& out, const Dbtux::TreeNode& node) +{ + out << "[TreeNode " << hex << &node; + out << " [left " << hex << node.m_link[0] << "]"; + out << " [right " << hex << node.m_link[1] << "]"; + out << " [up " << hex << node.m_link[2] << "]"; + out << " [side " << dec << node.m_side << "]"; + out << " [occup " << dec << node.m_occup << "]"; + out << " [balance " << dec << (int)node.m_balance << "]"; + out << " [nodeScan " << hex << node.m_nodeScan << "]"; + out << "]"; + return out; +} + +NdbOut& +operator<<(NdbOut& out, const Dbtux::TreeHead& tree) +{ + out << "[TreeHead " << hex << &tree; + out << " [nodeSize " << dec << tree.m_nodeSize << "]"; + out << " [prefSize " << dec << tree.m_prefSize << "]"; + out << " [minOccup " << dec << tree.m_minOccup << "]"; + out << " [maxOccup " << dec << tree.m_maxOccup << "]"; + out << " [AccHead " << dec << tree.getSize(Dbtux::AccHead) << "]"; + out << " [AccPref " << dec << tree.getSize(Dbtux::AccPref) << "]"; + out << " [AccFull " << dec << tree.getSize(Dbtux::AccFull) << "]"; + out << " [root " << hex << tree.m_root << "]"; + out << "]"; + return out; +} + +NdbOut& +operator<<(NdbOut& out, const Dbtux::TreePos& pos) +{ + out << "[TreePos " << hex << &pos; + out << " [addr " << hex << pos.m_addr << "]"; + out << " [pos " << dec << pos.m_pos << "]"; + out << " [match " << dec << pos.m_match << "]"; + out << " [dir " << dec << pos.m_dir << "]"; + out << " [ent " << pos.m_ent << "]"; + out << "]"; + return out; +} + +NdbOut& +operator<<(NdbOut& out, const Dbtux::DescAttr& descAttr) +{ + out << "[DescAttr " << hex << &descAttr; + out << " [primaryAttrId " << dec << descAttr.m_primaryAttrId << "]"; + out << " [typeId " << dec << descAttr.m_typeId << "]"; + out << " [nullable " << dec << descAttr.m_nullable << "]"; + out << "]"; + return out; +} + +NdbOut& +operator<<(NdbOut& out, const Dbtux::ScanOp& scan) +{ + out << "[ScanOp " << hex << &scan; + out << " [state " << dec << scan.m_state << "]"; + out << " [lockwait " << dec << scan.m_lockwait << "]"; + out << " [indexId " << dec << scan.m_indexId << "]"; + out << " [fragId " << dec << scan.m_fragId << "]"; + out << " [transId " << hex << scan.m_transId1 << " " << scan.m_transId2 << "]"; + out << " [savePointId " << dec << scan.m_savePointId << "]"; + out << " [accLockOp " << hex << scan.m_accLockOp << "]"; + out << " [accLockOps"; + for (unsigned i = 0; i < Dbtux::MaxAccLockOps; i++) { + if (scan.m_accLockOps[i] != RNIL) + out << " " << hex << scan.m_accLockOps[i]; + } + out << "]"; + out << " [readCommitted " << dec << scan.m_readCommitted << "]"; + out << " [lockMode " << dec << scan.m_lockMode << "]"; + out << " [keyInfo " << dec << scan.m_keyInfo << "]"; + out << " [pos " << scan.m_scanPos << "]"; + for (unsigned i = 0; i <= 1; i++) { + out << " [bound " << dec << i; + Dbtux::ScanBound& bound = *scan.m_bound[i]; + Dbtux::ScanBoundIterator iter; + bound.first(iter); + for (unsigned j = 0; j < bound.getSize(); j++) { + out << " " << hex << *iter.data; + bound.next(iter); + } + out << "]"; + } + out << "]"; + return out; +} + +NdbOut& +operator<<(NdbOut& out, const Dbtux::Index& index) +{ + out << "[Index " << hex << &index; + out << " [tableId " << dec << index.m_tableId << "]"; + out << " [fragOff " << dec << index.m_fragOff << "]"; + out << " [numFrags " << dec << index.m_numFrags << "]"; + for (unsigned i = 0; i < index.m_numFrags; i++) { + out << " [frag " << dec << i << " "; + // dangerous and wrong + Dbtux* tux = (Dbtux*)globalData.getBlock(DBTUX); + const Dbtux::Frag& frag = *tux->c_fragPool.getPtr(index.m_fragPtrI[i]); + out << frag; + out << "]"; + } + out << " [descPage " << hex << index.m_descPage << "]"; + out << " [descOff " << dec << index.m_descOff << "]"; + out << " [numAttrs " << dec << index.m_numAttrs << "]"; + out << "]"; + return out; +} + +NdbOut& +operator<<(NdbOut& out, const Dbtux::Frag& frag) +{ + out << "[Frag " << hex << &frag; + out << " [tableId " << dec << frag.m_tableId << "]"; + out << " [indexId " << dec << frag.m_indexId << "]"; + out << " [fragOff " << dec << frag.m_fragOff << "]"; + out << " [fragId " << dec << frag.m_fragId << "]"; + out << " [descPage " << hex << frag.m_descPage << "]"; + out << " [descOff " << dec << frag.m_descOff << "]"; + out << " [numAttrs " << dec << frag.m_numAttrs << "]"; + out << " [tree " << frag.m_tree << "]"; + out << "]"; + return out; +} + +NdbOut& +operator<<(NdbOut& out, const Dbtux::NodeHandle& node) +{ + const Dbtux::Frag& frag = node.m_frag; + const Dbtux::TreeHead& tree = frag.m_tree; + out << "[NodeHandle " << hex << &node; + out << " [addr " << hex << node.m_addr << "]"; + out << " [acc " << dec << node.m_acc << "]"; + out << " [flags " << hex << node.m_flags << "]"; + out << " [node " << *node.m_node << "]"; + if (node.m_acc >= Dbtux::AccPref) { + for (unsigned i = 0; i <= 1; i++) { + out << " [pref " << dec << i; + const Uint32* data = (const Uint32*)node.m_node + Dbtux::NodeHeadSize + i * tree.m_prefSize; + for (unsigned j = 0; j < node.m_frag.m_tree.m_prefSize; j++) + out << " " << hex << data[j]; + out << "]"; + } + out << " [entList"; + unsigned numpos = node.m_node->m_occup; + if (node.m_acc < Dbtux::AccFull && numpos > 2) { + numpos = 2; + out << "(" << dec << numpos << ")"; + } + const Uint32* data = (const Uint32*)node.m_node + Dbtux::NodeHeadSize + 2 * tree.m_prefSize; + const Dbtux::TreeEnt* entList = (const Dbtux::TreeEnt*)data; + for (unsigned pos = 0; pos < numpos; pos++) + out << " " << entList[pos]; + out << "]"; + } + out << "]"; + return out; +} + +#endif diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxGen.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxGen.cpp new file mode 100644 index 00000000000..32d66422d5c --- /dev/null +++ b/ndb/src/kernel/blocks/dbtux/DbtuxGen.cpp @@ -0,0 +1,221 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTUX_GEN_CPP +#include "Dbtux.hpp" + +Dbtux::Dbtux(const Configuration& conf) : + SimulatedBlock(DBTUX, conf), + c_descPageList(RNIL), +#ifdef VM_TRACE + debugFile(0), + debugOut(*new NullOutputStream()), + debugFlags(0), +#endif + c_internalStartPhase(0), + c_typeOfStart(NodeState::ST_ILLEGAL_TYPE), + c_keyBuffer(0) +{ + BLOCK_CONSTRUCTOR(Dbtux); + // verify size assumptions (also when release-compiled) + ndbrequire( + (sizeof(DescHead) & 0x3) == 0 && + (sizeof(DescAttr) & 0x3) == 0 && + (sizeof(TreeEnt) & 0x3) == 0 && + (sizeof(TreeNode) & 0x3) == 0 + ); + /* + * DbtuxGen.cpp + */ + addRecSignal(GSN_CONTINUEB, &Dbtux::execCONTINUEB); + addRecSignal(GSN_STTOR, &Dbtux::execSTTOR); + addRecSignal(GSN_SIZEALT_REP, &Dbtux::execSIZEALT_REP); + /* + * DbtuxMeta.cpp + */ + addRecSignal(GSN_TUXFRAGREQ, &Dbtux::execTUXFRAGREQ); + addRecSignal(GSN_TUX_ADD_ATTRREQ, &Dbtux::execTUX_ADD_ATTRREQ); + addRecSignal(GSN_ALTER_INDX_REQ, &Dbtux::execALTER_INDX_REQ); + addRecSignal(GSN_DROP_TAB_REQ, &Dbtux::execDROP_TAB_REQ); + /* + * DbtuxMaint.cpp + */ + addRecSignal(GSN_TUX_MAINT_REQ, &Dbtux::execTUX_MAINT_REQ); + /* + * DbtuxScan.cpp + */ + addRecSignal(GSN_ACC_SCANREQ, &Dbtux::execACC_SCANREQ); + addRecSignal(GSN_TUX_BOUND_INFO, &Dbtux::execTUX_BOUND_INFO); + addRecSignal(GSN_NEXT_SCANREQ, &Dbtux::execNEXT_SCANREQ); + addRecSignal(GSN_ACC_CHECK_SCAN, &Dbtux::execACC_CHECK_SCAN); + addRecSignal(GSN_ACCKEYCONF, &Dbtux::execACCKEYCONF); + addRecSignal(GSN_ACCKEYREF, &Dbtux::execACCKEYREF); + addRecSignal(GSN_ACC_ABORTCONF, &Dbtux::execACC_ABORTCONF); + /* + * DbtuxDebug.cpp + */ + addRecSignal(GSN_DUMP_STATE_ORD, &Dbtux::execDUMP_STATE_ORD); +} + +Dbtux::~Dbtux() +{ +} + +void +Dbtux::execCONTINUEB(Signal* signal) +{ + jamEntry(); + const Uint32* data = signal->getDataPtr(); + switch (data[0]) { + case TuxContinueB::DropIndex: + { + IndexPtr indexPtr; + c_indexPool.getPtr(indexPtr, data[1]); + dropIndex(signal, indexPtr, data[2], data[3]); + } + break; + default: + ndbrequire(false); + break; + } +} + +/* + * STTOR is sent to one block at a time. In NDBCNTR it triggers + * NDB_STTOR to the "old" blocks. STTOR carries start phase (SP) and + * NDB_STTOR carries internal start phase (ISP). + * + * SP ISP activities + * 1 none + * 2 1 + * 3 2 recover metadata, activate indexes + * 4 3 recover data + * 5 4-6 + * 6 skip + * 7 skip + * 8 7 build non-logged indexes on SR + * + * DBTUX catches type of start (IS, SR, NR, INR) at SP 3 and updates + * internal start phase at SP 7. These are used to prevent index + * maintenance operations caused by redo log at SR. + */ +void +Dbtux::execSTTOR(Signal* signal) +{ + jamEntry(); + Uint32 startPhase = signal->theData[1]; + switch (startPhase) { + case 1: + jam(); + CLEAR_ERROR_INSERT_VALUE; + break; + case 3: + jam(); + c_typeOfStart = signal->theData[7]; + break; + case 7: + c_internalStartPhase = 6; + default: + jam(); + break; + } + signal->theData[0] = 0; // garbage + signal->theData[1] = 0; // garbage + signal->theData[2] = 0; // garbage + signal->theData[3] = 1; + signal->theData[4] = 3; // for c_typeOfStart + signal->theData[5] = 7; // for c_internalStartPhase + signal->theData[6] = 255; + sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 7, JBB); +} + +void +Dbtux::execSIZEALT_REP(Signal* signal) +{ + jamEntry(); + const Uint32* data = signal->getDataPtr(); + BlockReference sender = data[TuxSizeAltReq::IND_BLOCK_REF]; + const Uint32 nIndex = data[TuxSizeAltReq::IND_INDEX]; + const Uint32 nFragment = data[TuxSizeAltReq::IND_FRAGMENT]; + const Uint32 nAttribute = data[TuxSizeAltReq::IND_ATTRIBUTE]; + const Uint32 nDescPage = (nIndex + nAttribute + DescPageSize - 1) / DescPageSize; + const Uint32 nScanOp = data[TuxSizeAltReq::IND_SCAN]; + const Uint32 nScanBoundWords = nScanOp * ScanBoundSegmentSize * 4; + // allocate records + c_indexPool.setSize(nIndex); + c_fragPool.setSize(nFragment); + c_descPagePool.setSize(nDescPage); + c_fragOpPool.setSize(MaxIndexFragments); + c_nodeHandlePool.setSize(MaxNodeHandles); + c_scanOpPool.setSize(nScanOp); + c_scanBoundPool.setSize(nScanBoundWords); + /* + * Index id is physical array index. We seize and initialize all + * index records now. This assumes ArrayPool is an array. + */ + IndexPtr indexPtr; + while (1) { + jam(); + c_indexPool.seize(indexPtr); + if (indexPtr.i == RNIL) { + jam(); + break; + } + new (indexPtr.p) Index(); + } + // allocate buffers + c_keyBuffer = (Uint32*)allocRecord("c_keyBuffer", sizeof(Uint64), (MaxAttrDataSize + 1) >> 1); + // ack + sendSignal(sender, GSN_SIZEALT_ACK, signal, 1, JBB); +} + +// utils + +void +Dbtux::copyAttrs(Data dst, ConstData src, CopyPar& copyPar) +{ + CopyPar c = copyPar; + c.m_numitems = 0; + c.m_numwords = 0; + while (c.m_numitems < c.m_items) { + jam(); + if (c.m_headers) { + unsigned i = 0; + while (i < AttributeHeaderSize) { + if (c.m_numwords >= c.m_maxwords) { + copyPar = c; + return; + } + dst[c.m_numwords++] = src[i++]; + } + } + unsigned size = src.ah().getDataSize(); + src += AttributeHeaderSize; + unsigned i = 0; + while (i < size) { + if (c.m_numwords >= c.m_maxwords) { + copyPar = c; + return; + } + dst[c.m_numwords++] = src[i++]; + } + src += size; + c.m_numitems++; + } + copyPar = c; +} + +BLOCK_FUNCTIONS(Dbtux); diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxMaint.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxMaint.cpp new file mode 100644 index 00000000000..a6b2485067c --- /dev/null +++ b/ndb/src/kernel/blocks/dbtux/DbtuxMaint.cpp @@ -0,0 +1,369 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTUX_MAINT_CPP +#include "Dbtux.hpp" + +/* + * Maintain index. + */ + +void +Dbtux::execTUX_MAINT_REQ(Signal* signal) +{ + jamEntry(); + TuxMaintReq* const sig = (TuxMaintReq*)signal->getDataPtrSend(); + // ignore requests from redo log + if (c_internalStartPhase < 6 && + c_typeOfStart != NodeState::ST_NODE_RESTART && + c_typeOfStart != NodeState::ST_INITIAL_NODE_RESTART) { + jam(); +#ifdef VM_TRACE + if (debugFlags & DebugMaint) { + debugOut << "opInfo=" << hex << sig->opInfo; + debugOut << " tableId=" << dec << sig->tableId; + debugOut << " indexId=" << dec << sig->indexId; + debugOut << " fragId=" << dec << sig->fragId; + debugOut << " tupAddr=" << hex << sig->tupAddr; + debugOut << " tupVersion=" << dec << sig->tupVersion; + debugOut << " -- ignored at ISP=" << dec << c_internalStartPhase; + debugOut << " TOS=" << dec << c_typeOfStart; + debugOut << endl; + } +#endif + sig->errorCode = 0; + return; + } + TuxMaintReq reqCopy = *sig; + TuxMaintReq* const req = &reqCopy; + const Uint32 opCode = req->opInfo & 0xFF; + const Uint32 opFlag = req->opInfo >> 8; + // get the index + IndexPtr indexPtr; + c_indexPool.getPtr(indexPtr, req->indexId); + ndbrequire(indexPtr.p->m_tableId == req->tableId); + // get base fragment id and extra bits + const Uint32 fragOff = indexPtr.p->m_fragOff; + const Uint32 fragId = req->fragId & ((1 << fragOff) - 1); + const Uint32 fragBit = req->fragId >> fragOff; + // get the fragment + FragPtr fragPtr; + fragPtr.i = RNIL; + for (unsigned i = 0; i < indexPtr.p->m_numFrags; i++) { + jam(); + if (indexPtr.p->m_fragId[i] == fragId) { + jam(); + c_fragPool.getPtr(fragPtr, indexPtr.p->m_fragPtrI[i]); + break; + } + } + ndbrequire(fragPtr.i != RNIL); + Frag& frag = *fragPtr.p; + ndbrequire(frag.m_nodeList == RNIL); + // set up index entry + TreeEnt ent; + ent.m_tupAddr = req->tupAddr; + ent.m_tupVersion = req->tupVersion; + ent.m_fragBit = fragBit; + // read search key + ReadPar readPar; + readPar.m_ent = ent; + readPar.m_first = 0; + readPar.m_count = frag.m_numAttrs; + // output goes here + readPar.m_data = c_keyBuffer; + tupReadAttrs(signal, frag, readPar); + // check if all keys are null + { + bool allNull = true; + ConstData data = readPar.m_data; + for (unsigned i = 0; i < frag.m_numAttrs; i++) { + if (! data.ah().isNULL()) { + jam(); + allNull = false; + break; + } + data += AttributeHeaderSize + data.ah().getDataSize(); + } + if (allNull) { + jam(); + req->errorCode = 0; + *sig = *req; + return; + } + } + // find position in tree + SearchPar searchPar; + searchPar.m_data = c_keyBuffer; + searchPar.m_ent = ent; + TreePos treePos; +#ifdef VM_TRACE + if (debugFlags & DebugMaint) { + debugOut << "opCode=" << dec << opCode; + debugOut << " opFlag=" << dec << opFlag; + debugOut << " tableId=" << dec << req->tableId; + debugOut << " indexId=" << dec << req->indexId; + debugOut << " fragId=" << dec << req->fragId; + debugOut << " entry=" << ent; + debugOut << endl; + } +#endif + treeSearch(signal, frag, searchPar, treePos); +#ifdef VM_TRACE + if (debugFlags & DebugMaint) { + debugOut << treePos << endl; + } +#endif + // do the operation + req->errorCode = 0; + switch (opCode) { + case TuxMaintReq::OpAdd: + jam(); + if (treePos.m_match) { + jam(); + // there is no "Building" state so this will have to do + if (indexPtr.p->m_state == Index::Online) { + jam(); + req->errorCode = TuxMaintReq::SearchError; + } + break; + } + /* + * At most one new node is inserted in the operation. We keep one + * free node pre-allocated so the operation cannot fail. This also + * gives a real TupAddr for links to the new node. + */ + if (frag.m_nodeFree == RNIL) { + jam(); + preallocNode(signal, frag, req->errorCode); + if (req->errorCode != 0) { + jam(); + break; + } + ndbrequire(frag.m_nodeFree != RNIL); + } + treeAdd(signal, frag, treePos, ent); + break; + case TuxMaintReq::OpRemove: + jam(); + if (! treePos.m_match) { + jam(); + // there is no "Building" state so this will have to do + if (indexPtr.p->m_state == Index::Online) { + jam(); + req->errorCode = TuxMaintReq::SearchError; + } + break; + } + treeRemove(signal, frag, treePos); + break; + default: + ndbrequire(false); + break; + } + // commit and release nodes + commitNodes(signal, frag, req->errorCode == 0); +#ifdef VM_TRACE + if (debugFlags & DebugTree) { + printTree(signal, frag, debugOut); + } +#endif + // copy back + *sig = *req; +} + +/* + * Read index key attributes from TUP. If buffer is provided the data + * is copied to it. Otherwise pointer is set to signal data. + */ +void +Dbtux::tupReadAttrs(Signal* signal, const Frag& frag, ReadPar& readPar) +{ + // define the direct signal + const TreeEnt ent = readPar.m_ent; + TupReadAttrs* const req = (TupReadAttrs*)signal->getDataPtrSend(); + req->errorCode = RNIL; + req->requestInfo = 0; + req->tableId = frag.m_tableId; + req->fragId = frag.m_fragId | (ent.m_fragBit << frag.m_fragOff); + req->fragPtrI = RNIL; + req->tupAddr = ent.m_tupAddr; + req->tupVersion = ent.m_tupVersion; + req->pageId = RNIL; + req->pageOffset = 0; + req->bufferId = 0; + // add count and list of attribute ids + Data data = (Uint32*)req + TupReadAttrs::SignalLength; + data[0] = readPar.m_count; + data += 1; + const DescEnt& descEnt = getDescEnt(frag.m_descPage, frag.m_descOff); + for (Uint32 i = 0; i < readPar.m_count; i++) { + jam(); + const DescAttr& descAttr = descEnt.m_descAttr[readPar.m_first + i]; + data.ah() = AttributeHeader(descAttr.m_primaryAttrId, 0); + data += 1; + } + // execute + EXECUTE_DIRECT(DBTUP, GSN_TUP_READ_ATTRS, signal, TupReadAttrs::SignalLength); + jamEntry(); + ndbrequire(req->errorCode == 0); + // data is at output + if (readPar.m_data == 0) { + readPar.m_data = data; + } else { + jam(); + CopyPar copyPar; + copyPar.m_items = readPar.m_count; + copyPar.m_headers = true; + copyAttrs(readPar.m_data, data, copyPar); + } +} + +/* + * Read primary keys. Copy the data without attribute headers into the + * given buffer. Number of words is returned in ReadPar argument. + */ +void +Dbtux::tupReadKeys(Signal* signal, const Frag& frag, ReadPar& readPar) +{ + // define the direct signal + const TreeEnt ent = readPar.m_ent; + TupReadAttrs* const req = (TupReadAttrs*)signal->getDataPtrSend(); + req->errorCode = RNIL; + req->requestInfo = TupReadAttrs::ReadKeys; + req->tableId = frag.m_tableId; + req->fragId = frag.m_fragId | (ent.m_fragBit << frag.m_fragOff); + req->fragPtrI = RNIL; + req->tupAddr = ent.m_tupAddr; + req->tupVersion = RNIL; // not used + req->pageId = RNIL; + req->pageOffset = 0; + req->bufferId = 0; + // execute + EXECUTE_DIRECT(DBTUP, GSN_TUP_READ_ATTRS, signal, TupReadAttrs::SignalLength); + jamEntry(); + ndbrequire(req->errorCode == 0); + // copy out in special format + ConstData data = (Uint32*)req + TupReadAttrs::SignalLength; + const Uint32 numKeys = data[0]; + data += 1 + numKeys; + // copy out without headers + ndbrequire(readPar.m_data != 0); + CopyPar copyPar; + copyPar.m_items = numKeys; + copyPar.m_headers = false; + copyAttrs(readPar.m_data, data, copyPar); + // return counts + readPar.m_count = numKeys; + readPar.m_size = copyPar.m_numwords; +} + +/* + * Operate on index node tuple in TUP. The data is copied between node + * cache and index storage via signal data. + */ +void +Dbtux::tupStoreTh(Signal* signal, const Frag& frag, NodeHandlePtr nodePtr, StorePar storePar) +{ + const TreeHead& tree = frag.m_tree; + // define the direct signal + TupStoreTh* req = (TupStoreTh*)signal->getDataPtrSend(); + req->errorCode = RNIL; + req->tableId = frag.m_indexId; + req->fragId = frag.m_fragId; + req->fragPtrI = RNIL; + req->tupAddr = nodePtr.p->m_addr; + req->tupVersion = 0; + req->pageId = nodePtr.p->m_loc.m_pageId; + req->pageOffset = nodePtr.p->m_loc.m_pageOffset; + req->bufferId = 0; + req->opCode = storePar.m_opCode; + ndbrequire(storePar.m_offset + storePar.m_size <= tree.m_nodeSize); + req->dataOffset = storePar.m_offset; + req->dataSize = storePar.m_size; + // the node cache + ndbrequire(nodePtr.p->m_node != 0); + // the buffer in signal data + Uint32* const buffer = (Uint32*)req + TupStoreTh::SignalLength; + // copy in data + switch (storePar.m_opCode) { + case TupStoreTh::OpRead: + jam(); + #ifdef VM_TRACE + { + Uint32* dst = buffer + storePar.m_offset; + memset(dst, 0xa9, storePar.m_size << 2); + } + #endif + break; + case TupStoreTh::OpInsert: + jam(); + // fallthru + case TupStoreTh::OpUpdate: + jam(); + // copy from cache to signal data + { + Uint32* dst = buffer + storePar.m_offset; + const Uint32* src = (const Uint32*)nodePtr.p->m_node + storePar.m_offset; + memcpy(dst, src, storePar.m_size << 2); + } + break; + case TupStoreTh::OpDelete: + jam(); + break; + default: + ndbrequire(false); + break; + } + // execute + EXECUTE_DIRECT(DBTUP, GSN_TUP_STORE_TH, signal, TupStoreTh::SignalLength); + jamEntry(); + if (req->errorCode != 0) { + jam(); + storePar.m_errorCode = req->errorCode; + return; + } + ndbrequire(req->errorCode == 0); + // copy out data + switch (storePar.m_opCode) { + case TupStoreTh::OpRead: + jam(); + { + Uint32* dst = (Uint32*)nodePtr.p->m_node + storePar.m_offset; + const Uint32* src = (const Uint32*)buffer + storePar.m_offset; + memcpy(dst, src, storePar.m_size << 2); + } + // fallthru + case TupStoreTh::OpInsert: + jam(); + // fallthru + case TupStoreTh::OpUpdate: + jam(); + nodePtr.p->m_addr = req->tupAddr; + nodePtr.p->m_loc.m_pageId = req->pageId; + nodePtr.p->m_loc.m_pageOffset = req->pageOffset; + break; + case TupStoreTh::OpDelete: + jam(); + nodePtr.p->m_addr = NullTupAddr; + nodePtr.p->m_loc.m_pageId = RNIL; + nodePtr.p->m_loc.m_pageOffset = 0; + break; + default: + ndbrequire(false); + break; + } +} diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxMeta.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxMeta.cpp new file mode 100644 index 00000000000..2ffd599429c --- /dev/null +++ b/ndb/src/kernel/blocks/dbtux/DbtuxMeta.cpp @@ -0,0 +1,427 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTUX_META_CPP +#include "Dbtux.hpp" + +/* + * Create index. + * + * For historical reasons it looks like we are adding random fragments + * and attributes to existing index. In fact all fragments must be + * created at one time and they have identical attributes. + */ + +void +Dbtux::execTUXFRAGREQ(Signal* signal) +{ + jamEntry(); + const TuxFragReq reqCopy = *(const TuxFragReq*)signal->getDataPtr(); + const TuxFragReq* const req = &reqCopy; + IndexPtr indexPtr; + indexPtr.i = RNIL; + FragOpPtr fragOpPtr; + fragOpPtr.i = RNIL; + TuxFragRef::ErrorCode errorCode = TuxFragRef::NoError; + do { + // get the index record + if (req->tableId >= c_indexPool.getSize()) { + jam(); + errorCode = TuxFragRef::InvalidRequest; + break; + } + c_indexPool.getPtr(indexPtr, req->tableId); + if (indexPtr.p->m_state != Index::NotDefined && + indexPtr.p->m_state != Index::Defining) { + jam(); + errorCode = TuxFragRef::InvalidRequest; + indexPtr.i = RNIL; // leave alone + break; + } + // get new operation record + c_fragOpPool.seize(fragOpPtr); + if (fragOpPtr.i == RNIL) { + jam(); + errorCode = TuxFragRef::NoFreeFragmentOper; + break; + } + new (fragOpPtr.p) FragOp(); + fragOpPtr.p->m_userPtr = req->userPtr; + fragOpPtr.p->m_userRef = req->userRef; + fragOpPtr.p->m_indexId = req->tableId; + fragOpPtr.p->m_fragId = req->fragId; + fragOpPtr.p->m_fragNo = indexPtr.p->m_numFrags; + fragOpPtr.p->m_numAttrsRecvd = 0; + // check if index has place for more fragments + if (indexPtr.p->m_numFrags == MaxIndexFragments) { + jam(); + errorCode = TuxFragRef::NoFreeIndexFragment; + break; + } + // seize new fragment record + FragPtr fragPtr; + c_fragPool.seize(fragPtr); + if (fragPtr.i == RNIL) { + jam(); + errorCode = TuxFragRef::NoFreeFragment; + break; + } + new (fragPtr.p) Frag(c_scanOpPool); + fragPtr.p->m_tableId = req->primaryTableId; + fragPtr.p->m_indexId = req->tableId; + fragPtr.p->m_fragOff = req->fragOff; + fragPtr.p->m_fragId = req->fragId; + fragPtr.p->m_numAttrs = req->noOfAttr; + // add the fragment to the index + indexPtr.p->m_fragId[indexPtr.p->m_numFrags] = req->fragId; + indexPtr.p->m_fragPtrI[indexPtr.p->m_numFrags] = fragPtr.i; + indexPtr.p->m_numFrags++; + // save under operation + fragOpPtr.p->m_fragPtrI = fragPtr.i; + // prepare to receive attributes + if (fragOpPtr.p->m_fragNo == 0) { + jam(); + // receiving first fragment + ndbrequire( + indexPtr.p->m_state == Index::NotDefined && + DictTabInfo::isOrderedIndex(req->tableType) && + req->noOfAttr > 0 && + req->noOfAttr <= MaxIndexAttributes && + indexPtr.p->m_descPage == RNIL); + indexPtr.p->m_state = Index::Defining; + indexPtr.p->m_tableType = (DictTabInfo::TableType)req->tableType; + indexPtr.p->m_tableId = req->primaryTableId; + indexPtr.p->m_fragOff = req->fragOff; + indexPtr.p->m_numAttrs = req->noOfAttr; + // allocate attribute descriptors + if (! allocDescEnt(indexPtr)) { + jam(); + errorCode = TuxFragRef::NoFreeAttributes; + break; + } + } else { + // receiving subsequent fragment + jam(); + ndbrequire( + indexPtr.p->m_state == Index::Defining && + indexPtr.p->m_tableType == (DictTabInfo::TableType)req->tableType && + indexPtr.p->m_tableId == req->primaryTableId && + indexPtr.p->m_fragOff == req->fragOff && + indexPtr.p->m_numAttrs == req->noOfAttr); + } + // copy metadata address to each fragment + fragPtr.p->m_descPage = indexPtr.p->m_descPage; + fragPtr.p->m_descOff = indexPtr.p->m_descOff; +#ifdef VM_TRACE + if (debugFlags & DebugMeta) { + debugOut << "Add frag " << fragPtr.i << " " << *fragPtr.p << endl; + } +#endif + // success + TuxFragConf* const conf = (TuxFragConf*)signal->getDataPtrSend(); + conf->userPtr = req->userPtr; + conf->tuxConnectPtr = fragOpPtr.i; + conf->fragPtr = fragPtr.i; + conf->fragId = fragPtr.p->m_fragId; + sendSignal(req->userRef, GSN_TUXFRAGCONF, + signal, TuxFragConf::SignalLength, JBB); + return; + } while (0); + // error + TuxFragRef* const ref = (TuxFragRef*)signal->getDataPtrSend(); + ref->userPtr = req->userPtr; + ref->errorCode = errorCode; + sendSignal(req->userRef, GSN_TUXFRAGREF, + signal, TuxFragRef::SignalLength, JBB); + if (fragOpPtr.i != RNIL) + c_fragOpPool.release(fragOpPtr); + if (indexPtr.i != RNIL) + dropIndex(signal, indexPtr, 0, 0); +} + +void +Dbtux::execTUX_ADD_ATTRREQ(Signal* signal) +{ + jamEntry(); + const TuxAddAttrReq reqCopy = *(const TuxAddAttrReq*)signal->getDataPtr(); + const TuxAddAttrReq* const req = &reqCopy; + // get the records + FragOpPtr fragOpPtr; + IndexPtr indexPtr; + FragPtr fragPtr; + c_fragOpPool.getPtr(fragOpPtr, req->tuxConnectPtr); + c_indexPool.getPtr(indexPtr, fragOpPtr.p->m_indexId); + c_fragPool.getPtr(fragPtr, fragOpPtr.p->m_fragPtrI); + TuxAddAttrRef::ErrorCode errorCode = TuxAddAttrRef::NoError; + do { + // expected attribute id + const unsigned attrId = fragOpPtr.p->m_numAttrsRecvd++; + ndbrequire( + indexPtr.p->m_state == Index::Defining && + attrId < indexPtr.p->m_numAttrs && + attrId == req->attrId); + // define the attribute + DescEnt& descEnt = getDescEnt(indexPtr.p->m_descPage, indexPtr.p->m_descOff); + DescAttr& descAttr = descEnt.m_descAttr[attrId]; + descAttr.m_primaryAttrId = req->primaryAttrId; + descAttr.m_typeId = req->extTypeInfo & 0xFF; + descAttr.m_nullable = AttributeDescriptor::getNullable(req->attrDescriptor); + descAttr.pad1 = 0; +#ifdef VM_TRACE + if (debugFlags & DebugMeta) { + debugOut << "Add frag " << fragPtr.i << " attr " << attrId << " " << descAttr << endl; + } +#endif + // check if type is valid and has a comparison method + const NdbSqlUtil::Type& type = NdbSqlUtil::type(descAttr.m_typeId); + if (type.m_typeId == NdbSqlUtil::Type::Undefined || + type.m_cmp == 0) { + jam(); + errorCode = TuxAddAttrRef::InvalidAttributeType; + break; + } + if (indexPtr.p->m_numAttrs == fragOpPtr.p->m_numAttrsRecvd) { + jam(); + // initialize tree header + TreeHead& tree = fragPtr.p->m_tree; + // make these configurable later + tree.m_nodeSize = MAX_TTREE_NODE_SIZE; + tree.m_prefSize = MAX_TTREE_PREF_SIZE; +#ifdef dbtux_min_occup_less_max_occup + const unsigned maxSlack = MAX_TTREE_NODE_SLACK; +#else + const unsigned maxSlack = 0; +#endif + // size up to and including first 2 entries + const unsigned pref = tree.getSize(AccPref); + if (! (pref <= tree.m_nodeSize)) { + jam(); + errorCode = TuxAddAttrRef::InvalidNodeSize; + break; + } + const unsigned slots = (tree.m_nodeSize - pref) / TreeEntSize; + // leave out work space entry + tree.m_maxOccup = 2 + slots - 1; + // min occupancy of interior node must be at least 2 + if (! (2 + maxSlack <= tree.m_maxOccup)) { + jam(); + errorCode = TuxAddAttrRef::InvalidNodeSize; + break; + } + tree.m_minOccup = tree.m_maxOccup - maxSlack; + // root node does not exist + tree.m_root = NullTupAddr; + // fragment is defined + c_fragOpPool.release(fragOpPtr); + } + // success + TuxAddAttrConf* conf = (TuxAddAttrConf*)signal->getDataPtrSend(); + conf->userPtr = fragOpPtr.p->m_userPtr; + sendSignal(fragOpPtr.p->m_userRef, GSN_TUX_ADD_ATTRCONF, + signal, TuxAddAttrConf::SignalLength, JBB); + return; + } while (0); + // error + TuxAddAttrRef* ref = (TuxAddAttrRef*)signal->getDataPtrSend(); + ref->userPtr = fragOpPtr.p->m_userPtr; + ref->errorCode = errorCode; + sendSignal(fragOpPtr.p->m_userRef, GSN_TUX_ADD_ATTRREF, + signal, TuxAddAttrRef::SignalLength, JBB); + c_fragOpPool.release(fragOpPtr); + dropIndex(signal, indexPtr, 0, 0); +} + +/* + * Set index online. Currently at system restart this arrives before + * build and is therefore not correct. + */ +void +Dbtux::execALTER_INDX_REQ(Signal* signal) +{ + jamEntry(); + const AlterIndxReq reqCopy = *(const AlterIndxReq*)signal->getDataPtr(); + const AlterIndxReq* const req = &reqCopy; + // set index online after build + IndexPtr indexPtr; + c_indexPool.getPtr(indexPtr, req->getIndexId()); + indexPtr.p->m_state = Index::Online; +#ifdef VM_TRACE + if (debugFlags & DebugMeta) { + debugOut << "Online index " << indexPtr.i << " " << *indexPtr.p << endl; + } +#endif + // success + AlterIndxConf* const conf = (AlterIndxConf*)signal->getDataPtrSend(); + conf->setUserRef(reference()); + conf->setConnectionPtr(req->getConnectionPtr()); + conf->setRequestType(req->getRequestType()); + conf->setTableId(req->getTableId()); + conf->setIndexId(req->getIndexId()); + conf->setIndexVersion(req->getIndexVersion()); + sendSignal(req->getUserRef(), GSN_ALTER_INDX_CONF, + signal, AlterIndxConf::SignalLength, JBB); +} + +/* + * Drop index. + * + * Uses same DROP_TAB_REQ signal as normal tables. + */ + +void +Dbtux::execDROP_TAB_REQ(Signal* signal) +{ + jamEntry(); + const DropTabReq reqCopy = *(const DropTabReq*)signal->getDataPtr(); + const DropTabReq* const req = &reqCopy; + IndexPtr indexPtr; + c_indexPool.getPtr(indexPtr, req->tableId); + // drop works regardless of index state +#ifdef VM_TRACE + if (debugFlags & DebugMeta) { + debugOut << "Drop index " << indexPtr.i << " " << *indexPtr.p << endl; + } +#endif + ndbrequire(req->senderRef != 0); + dropIndex(signal, indexPtr, req->senderRef, req->senderData); +} + +void +Dbtux::dropIndex(Signal* signal, IndexPtr indexPtr, Uint32 senderRef, Uint32 senderData) +{ + jam(); + indexPtr.p->m_state = Index::Dropping; + // drop one fragment at a time + if (indexPtr.p->m_numFrags > 0) { + jam(); + unsigned i = --indexPtr.p->m_numFrags; + FragPtr fragPtr; + c_fragPool.getPtr(fragPtr, indexPtr.p->m_fragPtrI[i]); + Frag& frag = *fragPtr.p; + ndbrequire(frag.m_nodeList == RNIL); + if (frag.m_nodeFree != RNIL) { + c_nodeHandlePool.release(frag.m_nodeFree); + frag.m_nodeFree = RNIL; + } + c_fragPool.release(fragPtr); + // the real time break is not used for anything currently + signal->theData[0] = TuxContinueB::DropIndex; + signal->theData[1] = indexPtr.i; + signal->theData[2] = senderRef; + signal->theData[3] = senderData; + sendSignal(reference(), GSN_CONTINUEB, signal, 4, JBB); + return; + } + // drop attributes + if (indexPtr.p->m_descPage != RNIL) { + jam(); + freeDescEnt(indexPtr); + indexPtr.p->m_descPage = RNIL; + } + if (senderRef != 0) { + jam(); + // reply to sender + DropTabConf* const conf = (DropTabConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = senderData; + conf->tableId = indexPtr.i; + sendSignal(senderRef, GSN_DROP_TAB_CONF, + signal, DropTabConf::SignalLength, JBB); + } + new (indexPtr.p) Index(); +} + +/* + * Subroutines. + */ + +bool +Dbtux::allocDescEnt(IndexPtr indexPtr) +{ + jam(); + const unsigned size = DescHeadSize + indexPtr.p->m_numAttrs * DescAttrSize; + DescPagePtr pagePtr; + pagePtr.i = c_descPageList; + while (pagePtr.i != RNIL) { + jam(); + c_descPagePool.getPtr(pagePtr); + if (pagePtr.p->m_numFree >= size) { + jam(); + break; + } + pagePtr.i = pagePtr.p->m_nextPage; + } + if (pagePtr.i == RNIL) { + jam(); + if (! c_descPagePool.seize(pagePtr)) { + jam(); + return false; + } + new (pagePtr.p) DescPage(); + // add in front of list + pagePtr.p->m_nextPage = c_descPageList; + c_descPageList = pagePtr.i; + pagePtr.p->m_numFree = DescPageSize; + } + ndbrequire(pagePtr.p->m_numFree >= size); + indexPtr.p->m_descPage = pagePtr.i; + indexPtr.p->m_descOff = DescPageSize - pagePtr.p->m_numFree; + pagePtr.p->m_numFree -= size; + DescEnt& descEnt = getDescEnt(indexPtr.p->m_descPage, indexPtr.p->m_descOff); + descEnt.m_descHead.m_indexId = indexPtr.i; + descEnt.m_descHead.pad1 = 0; + return true; +} + +void +Dbtux::freeDescEnt(IndexPtr indexPtr) +{ + DescPagePtr pagePtr; + c_descPagePool.getPtr(pagePtr, indexPtr.p->m_descPage); + Uint32* const data = pagePtr.p->m_data; + const unsigned size = DescHeadSize + indexPtr.p->m_numAttrs * DescAttrSize; + unsigned off = indexPtr.p->m_descOff; + // move the gap to the free area at the top + while (off + size < DescPageSize - pagePtr.p->m_numFree) { + jam(); + // next entry to move over the gap + DescEnt& descEnt2 = *(DescEnt*)&data[off + size]; + Uint32 indexId2 = descEnt2.m_descHead.m_indexId; + Index& index2 = *c_indexPool.getPtr(indexId2); + unsigned size2 = DescHeadSize + index2.m_numAttrs * DescAttrSize; + ndbrequire( + index2.m_descPage == pagePtr.i && + index2.m_descOff == off + size); + // move the entry (overlapping copy if size < size2) + for (unsigned i = 0; i < size2; i++) { + jam(); + data[off + i] = data[off + size + i]; + } + off += size2; + // adjust page offset in index and all fragments + index2.m_descOff -= size; + for (unsigned i = 0; i < index2.m_numFrags; i++) { + jam(); + Frag& frag2 = *c_fragPool.getPtr(index2.m_fragPtrI[i]); + frag2.m_descOff -= size; + ndbrequire( + frag2.m_descPage == index2.m_descPage && + frag2.m_descOff == index2.m_descOff); + } + } + ndbrequire(off + size == DescPageSize - pagePtr.p->m_numFree); + pagePtr.p->m_numFree += size; +} diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxNode.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxNode.cpp new file mode 100644 index 00000000000..6733a87da97 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtux/DbtuxNode.cpp @@ -0,0 +1,633 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTUX_NODE_CPP +#include "Dbtux.hpp" + +/* + * Node handles. + * + * We use the "cache" implementation. Node operations are done on + * cached copies. Index memory is updated at the end of the operation. + * At most one node is inserted and it is always pre-allocated. + * + * An alternative "pointer" implementation which writes directly into + * index memory is planned for later. + */ + +// Dbtux + +void +Dbtux::seizeNode(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr) +{ + if (! c_nodeHandlePool.seize(nodePtr)) { + jam(); + return; + } + new (nodePtr.p) NodeHandle(*this, frag); + nodePtr.p->m_next = frag.m_nodeList; + frag.m_nodeList = nodePtr.i; + // node cache used always + nodePtr.p->m_node = (TreeNode*)nodePtr.p->m_cache; + new (nodePtr.p->m_node) TreeNode(); +#ifdef VM_TRACE + TreeHead& tree = frag.m_tree; + TreeNode* node = nodePtr.p->m_node; + memset(tree.getPref(node, 0), 0xa2, tree.m_prefSize << 2); + memset(tree.getPref(node, 1), 0xa2, tree.m_prefSize << 2); + TreeEnt* entList = tree.getEntList(node); + memset(entList, 0xa4, (tree.m_maxOccup + 1) * (TreeEntSize << 2)); +#endif +} + +void +Dbtux::preallocNode(Signal* signal, Frag& frag, Uint32& errorCode) +{ + ndbrequire(frag.m_nodeFree == RNIL); + NodeHandlePtr nodePtr; + seizeNode(signal, frag, nodePtr); + ndbrequire(nodePtr.i != RNIL); + // remove from cache XXX ugly + frag.m_nodeFree = frag.m_nodeList; + frag.m_nodeList = nodePtr.p->m_next; + StorePar storePar; + storePar.m_opCode = TupStoreTh::OpInsert; + storePar.m_offset = 0; + storePar.m_size = 0; + tupStoreTh(signal, frag, nodePtr, storePar); + if (storePar.m_errorCode != 0) { + jam(); + errorCode = storePar.m_errorCode; + c_nodeHandlePool.release(nodePtr); + frag.m_nodeFree = RNIL; + } +} + +/* + * Find node in the cache. XXX too slow, use direct links instead + */ +void +Dbtux::findNode(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr, TupAddr addr) +{ + NodeHandlePtr tmpPtr; + tmpPtr.i = frag.m_nodeList; + while (tmpPtr.i != RNIL) { + jam(); + c_nodeHandlePool.getPtr(tmpPtr); + if (tmpPtr.p->m_addr == addr) { + jam(); + nodePtr = tmpPtr; + return; + } + tmpPtr.i = tmpPtr.p->m_next; + } + nodePtr.i = RNIL; + nodePtr.p = 0; +} + +/* + * Get handle for existing node. + */ +void +Dbtux::selectNode(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr, TupAddr addr, AccSize acc) +{ + ndbrequire(addr != NullTupAddr && acc > AccNone); + NodeHandlePtr tmpPtr; + // search in cache + findNode(signal, frag, tmpPtr, addr); + if (tmpPtr.i == RNIL) { + jam(); + // add new node + seizeNode(signal, frag, tmpPtr); + ndbrequire(tmpPtr.i != RNIL); + tmpPtr.p->m_addr = addr; + } + if (tmpPtr.p->m_acc < acc) { + jam(); + accessNode(signal, frag, tmpPtr, acc); + } + nodePtr = tmpPtr; +} + +/* + * Create new node in the cache and mark it for insert. + */ +void +Dbtux::insertNode(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr, AccSize acc) +{ + ndbrequire(acc > AccNone); + NodeHandlePtr tmpPtr; + // use the pre-allocated node + tmpPtr.i = frag.m_nodeFree; + frag.m_nodeFree = RNIL; + c_nodeHandlePool.getPtr(tmpPtr); + // move it to the cache + tmpPtr.p->m_next = frag.m_nodeList; + frag.m_nodeList = tmpPtr.i; + tmpPtr.p->m_acc = acc; + tmpPtr.p->m_flags |= NodeHandle::DoInsert; + nodePtr = tmpPtr; +} + +/* + * Mark existing node for deletion. + */ +void +Dbtux::deleteNode(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr) +{ + NodeHandlePtr tmpPtr = nodePtr; + ndbrequire(tmpPtr.p->getOccup() == 0); + tmpPtr.p->m_flags |= NodeHandle::DoDelete; + // scans have already been moved by popDown or popUp +} + +/* + * Access more of the node. + */ +void +Dbtux::accessNode(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr, AccSize acc) +{ + TreeHead& tree = frag.m_tree; + NodeHandlePtr tmpPtr = nodePtr; + if (tmpPtr.p->m_acc >= acc) + return; + if (! (tmpPtr.p->m_flags & NodeHandle::DoInsert)) { + jam(); + StorePar storePar; + storePar.m_opCode = TupStoreTh::OpRead; + storePar.m_offset = tree.getSize(tmpPtr.p->m_acc); + storePar.m_size = tree.getSize(acc) - tree.getSize(tmpPtr.p->m_acc); + tmpPtr.p->m_tux.tupStoreTh(signal, frag, tmpPtr, storePar); + ndbrequire(storePar.m_errorCode == 0); + } + tmpPtr.p->m_acc = acc; +} + +/* + * Set prefix. + */ +void +Dbtux::setNodePref(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr, unsigned i) +{ + TreeHead& tree = frag.m_tree; + NodeHandlePtr tmpPtr = nodePtr; + ReadPar readPar; + ndbrequire(i <= 1); + readPar.m_ent = tmpPtr.p->getMinMax(i); + readPar.m_first = 0; + readPar.m_count = frag.m_numAttrs; + // leave in signal data + readPar.m_data = 0; + // XXX implement max words to read + tupReadAttrs(signal, frag, readPar); + // copy whatever fits + CopyPar copyPar; + copyPar.m_items = readPar.m_count; + copyPar.m_headers = true; + copyPar.m_maxwords = tree.m_prefSize; + Data pref = tmpPtr.p->getPref(i); + copyAttrs(pref, readPar.m_data, copyPar); + nodePtr.p->m_flags |= NodeHandle::DoUpdate; +} + +/* + * Commit and release nodes at the end of an operation. Used also on + * error since no changes have been made (updateOk false). + */ +void +Dbtux::commitNodes(Signal* signal, Frag& frag, bool updateOk) +{ + TreeHead& tree = frag.m_tree; + NodeHandlePtr nodePtr; + nodePtr.i = frag.m_nodeList; + frag.m_nodeList = RNIL; + while (nodePtr.i != RNIL) { + c_nodeHandlePool.getPtr(nodePtr); + const unsigned flags = nodePtr.p->m_flags; + if (flags & NodeHandle::DoDelete) { + jam(); + ndbrequire(updateOk); + // delete + StorePar storePar; + storePar.m_opCode = TupStoreTh::OpDelete; + nodePtr.p->m_tux.tupStoreTh(signal, frag, nodePtr, storePar); + ndbrequire(storePar.m_errorCode == 0); + } else if (flags & NodeHandle::DoUpdate) { + jam(); + ndbrequire(updateOk); + // set prefixes + if (flags & (1 << 0)) { + jam(); + setNodePref(signal, frag, nodePtr, 0); + } + if (flags & (1 << 1)) { + jam(); + setNodePref(signal, frag, nodePtr, 1); + } + // update + StorePar storePar; + storePar.m_opCode = TupStoreTh::OpUpdate; + storePar.m_offset = 0; + storePar.m_size = tree.getSize(nodePtr.p->m_acc); + nodePtr.p->m_tux.tupStoreTh(signal, frag, nodePtr, storePar); + ndbrequire(storePar.m_errorCode == 0); + } + // release + NodeHandlePtr tmpPtr = nodePtr; + nodePtr.i = nodePtr.p->m_next; + c_nodeHandlePool.release(tmpPtr); + } +} + +// Dbtux::NodeHandle + +/* + * Add entry at position. Move entries greater than or equal to the old + * one (if any) to the right. + * + * X + * v + * A B C D E _ _ => A B C X D E _ + * 0 1 2 3 4 5 6 0 1 2 3 4 5 6 + */ +void +Dbtux::NodeHandle::pushUp(Signal* signal, unsigned pos, const TreeEnt& ent) +{ + TreeHead& tree = m_frag.m_tree; + const unsigned occup = getOccup(); + ndbrequire(occup < tree.m_maxOccup && pos <= occup); + // fix scans + ScanOpPtr scanPtr; + scanPtr.i = getNodeScan(); + while (scanPtr.i != RNIL) { + jam(); + m_tux.c_scanOpPool.getPtr(scanPtr); + TreePos& scanPos = scanPtr.p->m_scanPos; + ndbrequire(scanPos.m_addr == m_addr && scanPos.m_pos < occup); + if (scanPos.m_pos >= pos) { + jam(); +#ifdef VM_TRACE + if (m_tux.debugFlags & m_tux.DebugScan) { + m_tux.debugOut << "Fix scan " << scanPtr.i << " " << *scanPtr.p << endl; + m_tux.debugOut << "At pushUp pos=" << pos << " " << *this << endl; + } +#endif + scanPos.m_pos++; + } + scanPtr.i = scanPtr.p->m_nodeScan; + } + // fix node + TreeEnt* const entList = tree.getEntList(m_node); + entList[occup] = entList[0]; + TreeEnt* const tmpList = entList + 1; + for (unsigned i = occup; i > pos; i--) { + jam(); + tmpList[i] = tmpList[i - 1]; + } + tmpList[pos] = ent; + if (occup == 0 || pos == 0) + m_flags |= (1 << 0); + if (occup == 0 || pos == occup) + m_flags |= (1 << 1); + entList[0] = entList[occup + 1]; + setOccup(occup + 1); + m_flags |= DoUpdate; +} + +/* + * Remove and return entry at position. Move entries greater than the + * removed one to the left. This is the opposite of pushUp. + * + * D + * ^ ^ + * A B C D E F _ => A B C E F _ _ + * 0 1 2 3 4 5 6 0 1 2 3 4 5 6 + */ +void +Dbtux::NodeHandle::popDown(Signal* signal, unsigned pos, TreeEnt& ent) +{ + TreeHead& tree = m_frag.m_tree; + const unsigned occup = getOccup(); + ndbrequire(occup <= tree.m_maxOccup && pos < occup); + ScanOpPtr scanPtr; + // move scans whose entry disappears + scanPtr.i = getNodeScan(); + while (scanPtr.i != RNIL) { + jam(); + m_tux.c_scanOpPool.getPtr(scanPtr); + TreePos& scanPos = scanPtr.p->m_scanPos; + ndbrequire(scanPos.m_addr == m_addr && scanPos.m_pos < occup); + const Uint32 nextPtrI = scanPtr.p->m_nodeScan; + if (scanPos.m_pos == pos) { + jam(); +#ifdef VM_TRACE + if (m_tux.debugFlags & m_tux.DebugScan) { + m_tux.debugOut << "Move scan " << scanPtr.i << " " << *scanPtr.p << endl; + m_tux.debugOut << "At popDown pos=" << pos << " " << *this << endl; + } +#endif + m_tux.scanNext(signal, scanPtr); + } + scanPtr.i = nextPtrI; + } + // fix other scans + scanPtr.i = getNodeScan(); + while (scanPtr.i != RNIL) { + jam(); + m_tux.c_scanOpPool.getPtr(scanPtr); + TreePos& scanPos = scanPtr.p->m_scanPos; + ndbrequire(scanPos.m_addr == m_addr && scanPos.m_pos < occup); + ndbrequire(scanPos.m_pos != pos); + if (scanPos.m_pos > pos) { + jam(); +#ifdef VM_TRACE + if (m_tux.debugFlags & m_tux.DebugScan) { + m_tux.debugOut << "Fix scan " << scanPtr.i << " " << *scanPtr.p << endl; + m_tux.debugOut << "At popDown pos=" << pos << " " << *this << endl; + } +#endif + scanPos.m_pos--; + } + scanPtr.i = scanPtr.p->m_nodeScan; + } + // fix node + TreeEnt* const entList = tree.getEntList(m_node); + entList[occup] = entList[0]; + TreeEnt* const tmpList = entList + 1; + ent = tmpList[pos]; + for (unsigned i = pos; i < occup - 1; i++) { + jam(); + tmpList[i] = tmpList[i + 1]; + } + if (occup != 1 && pos == 0) + m_flags |= (1 << 0); + if (occup != 1 && pos == occup - 1) + m_flags |= (1 << 1); + entList[0] = entList[occup - 1]; + setOccup(occup - 1); + m_flags |= DoUpdate; +} + +/* + * Add entry at existing position. Move entries less than or equal to + * the old one to the left. Remove and return old min entry. + * + * X A + * ^ v ^ + * A B C D E _ _ => B C D X E _ _ + * 0 1 2 3 4 5 6 0 1 2 3 4 5 6 + */ +void +Dbtux::NodeHandle::pushDown(Signal* signal, unsigned pos, TreeEnt& ent) +{ + TreeHead& tree = m_frag.m_tree; + const unsigned occup = getOccup(); + ndbrequire(occup <= tree.m_maxOccup && pos < occup); + ScanOpPtr scanPtr; + // move scans whose entry disappears + scanPtr.i = getNodeScan(); + while (scanPtr.i != RNIL) { + jam(); + m_tux.c_scanOpPool.getPtr(scanPtr); + TreePos& scanPos = scanPtr.p->m_scanPos; + ndbrequire(scanPos.m_addr == m_addr && scanPos.m_pos < occup); + const Uint32 nextPtrI = scanPtr.p->m_nodeScan; + if (scanPos.m_pos == 0) { + jam(); +#ifdef VM_TRACE + if (m_tux.debugFlags & m_tux.DebugScan) { + m_tux.debugOut << "Move scan " << scanPtr.i << " " << *scanPtr.p << endl; + m_tux.debugOut << "At pushDown pos=" << pos << " " << *this << endl; + } +#endif + // here we may miss a valid entry "X" XXX known bug + m_tux.scanNext(signal, scanPtr); + } + scanPtr.i = nextPtrI; + } + // fix other scans + scanPtr.i = getNodeScan(); + while (scanPtr.i != RNIL) { + jam(); + m_tux.c_scanOpPool.getPtr(scanPtr); + TreePos& scanPos = scanPtr.p->m_scanPos; + ndbrequire(scanPos.m_addr == m_addr && scanPos.m_pos < occup); + ndbrequire(scanPos.m_pos != 0); + if (scanPos.m_pos <= pos) { + jam(); +#ifdef VM_TRACE + if (m_tux.debugFlags & m_tux.DebugScan) { + m_tux.debugOut << "Fix scan " << scanPtr.i << " " << *scanPtr.p << endl; + m_tux.debugOut << "At pushDown pos=" << pos << " " << *this << endl; + } +#endif + scanPos.m_pos--; + } + scanPtr.i = scanPtr.p->m_nodeScan; + } + // fix node + TreeEnt* const entList = tree.getEntList(m_node); + entList[occup] = entList[0]; + TreeEnt* const tmpList = entList + 1; + TreeEnt oldMin = tmpList[0]; + for (unsigned i = 0; i < pos; i++) { + jam(); + tmpList[i] = tmpList[i + 1]; + } + tmpList[pos] = ent; + ent = oldMin; + if (true) + m_flags |= (1 << 0); + if (occup == 1 || pos == occup - 1) + m_flags |= (1 << 1); + entList[0] = entList[occup]; + m_flags |= DoUpdate; +} + +/* + * Remove and return entry at position. Move entries less than the + * removed one to the right. Replace min entry by the input entry. + * This is the opposite of pushDown. + * + * X D + * v ^ ^ + * A B C D E _ _ => X A B C E _ _ + * 0 1 2 3 4 5 6 0 1 2 3 4 5 6 + */ +void +Dbtux::NodeHandle::popUp(Signal* signal, unsigned pos, TreeEnt& ent) +{ + TreeHead& tree = m_frag.m_tree; + const unsigned occup = getOccup(); + ndbrequire(occup <= tree.m_maxOccup && pos < occup); + ScanOpPtr scanPtr; + // move scans whose entry disappears + scanPtr.i = getNodeScan(); + while (scanPtr.i != RNIL) { + jam(); + m_tux.c_scanOpPool.getPtr(scanPtr); + TreePos& scanPos = scanPtr.p->m_scanPos; + ndbrequire(scanPos.m_addr == m_addr && scanPos.m_pos < occup); + const Uint32 nextPtrI = scanPtr.p->m_nodeScan; + if (scanPos.m_pos == pos) { + jam(); +#ifdef VM_TRACE + if (m_tux.debugFlags & m_tux.DebugScan) { + m_tux.debugOut << "Move scan " << scanPtr.i << " " << *scanPtr.p << endl; + m_tux.debugOut << "At popUp pos=" << pos << " " << *this << endl; + } +#endif + // here we may miss a valid entry "X" XXX known bug + m_tux.scanNext(signal, scanPtr); + } + scanPtr.i = nextPtrI; + } + // fix other scans + scanPtr.i = getNodeScan(); + while (scanPtr.i != RNIL) { + jam(); + m_tux.c_scanOpPool.getPtr(scanPtr); + TreePos& scanPos = scanPtr.p->m_scanPos; + ndbrequire(scanPos.m_addr == m_addr && scanPos.m_pos < occup); + ndbrequire(scanPos.m_pos != pos); + if (scanPos.m_pos < pos) { + jam(); +#ifdef VM_TRACE + if (m_tux.debugFlags & m_tux.DebugScan) { + m_tux.debugOut << "Fix scan " << scanPtr.i << " " << *scanPtr.p << endl; + m_tux.debugOut << "At popUp pos=" << pos << " " << *this << endl; + } +#endif + scanPos.m_pos++; + } + scanPtr.i = scanPtr.p->m_nodeScan; + } + // fix node + TreeEnt* const entList = tree.getEntList(m_node); + entList[occup] = entList[0]; + TreeEnt* const tmpList = entList + 1; + TreeEnt newMin = ent; + ent = tmpList[pos]; + for (unsigned i = pos; i > 0; i--) { + jam(); + tmpList[i] = tmpList[i - 1]; + } + tmpList[0] = newMin; + if (true) + m_flags |= (1 << 0); + if (occup == 1 || pos == occup - 1) + m_flags |= (1 << 1); + entList[0] = entList[occup]; + m_flags |= DoUpdate; +} + +/* + * Move all possible entries from another node before the min (i=0) or + * after the max (i=1). XXX can be optimized + */ +void +Dbtux::NodeHandle::slide(Signal* signal, NodeHandlePtr nodePtr, unsigned i) +{ + ndbrequire(i <= 1); + TreeHead& tree = m_frag.m_tree; + while (getOccup() < tree.m_maxOccup && nodePtr.p->getOccup() != 0) { + TreeEnt ent; + nodePtr.p->popDown(signal, i == 0 ? nodePtr.p->getOccup() - 1 : 0, ent); + pushUp(signal, i == 0 ? 0 : getOccup(), ent); + } +} + +/* + * Link scan to the list under the node. The list is single-linked and + * ordering does not matter. + */ +void +Dbtux::NodeHandle::linkScan(Dbtux::ScanOpPtr scanPtr) +{ +#ifdef VM_TRACE + if (m_tux.debugFlags & m_tux.DebugScan) { + m_tux.debugOut << "Link scan " << scanPtr.i << " " << *scanPtr.p << endl; + m_tux.debugOut << "To node " << *this << endl; + } +#endif + ndbrequire(! islinkScan(scanPtr) && scanPtr.p->m_nodeScan == RNIL); + scanPtr.p->m_nodeScan = getNodeScan(); + setNodeScan(scanPtr.i); +} + +/* + * Unlink a scan from the list under the node. + */ +void +Dbtux::NodeHandle::unlinkScan(Dbtux::ScanOpPtr scanPtr) +{ +#ifdef VM_TRACE + if (m_tux.debugFlags & m_tux.DebugScan) { + m_tux.debugOut << "Unlink scan " << scanPtr.i << " " << *scanPtr.p << endl; + m_tux.debugOut << "From node " << *this << endl; + } +#endif + Dbtux::ScanOpPtr currPtr; + currPtr.i = getNodeScan(); + Dbtux::ScanOpPtr prevPtr; + prevPtr.i = RNIL; + while (true) { + jam(); + m_tux.c_scanOpPool.getPtr(currPtr); + Uint32 nextPtrI = currPtr.p->m_nodeScan; + if (currPtr.i == scanPtr.i) { + jam(); + if (prevPtr.i == RNIL) { + setNodeScan(nextPtrI); + } else { + jam(); + prevPtr.p->m_nodeScan = nextPtrI; + } + scanPtr.p->m_nodeScan = RNIL; + // check for duplicates + ndbrequire(! islinkScan(scanPtr)); + return; + } + prevPtr = currPtr; + currPtr.i = nextPtrI; + } +} + +/* + * Check if a scan is linked to this node. Only for ndbrequire. + */ +bool +Dbtux::NodeHandle::islinkScan(Dbtux::ScanOpPtr scanPtr) +{ + Dbtux::ScanOpPtr currPtr; + currPtr.i = getNodeScan(); + while (currPtr.i != RNIL) { + jam(); + m_tux.c_scanOpPool.getPtr(currPtr); + if (currPtr.i == scanPtr.i) { + jam(); + return true; + } + currPtr.i = currPtr.p->m_nodeScan; + } + return false; +} + +void +Dbtux::NodeHandle::progError(int line, int cause, const char* extra) +{ + m_tux.progError(line, cause, extra); +} diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp new file mode 100644 index 00000000000..eaa539d9cfc --- /dev/null +++ b/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp @@ -0,0 +1,1124 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTUX_SCAN_CPP +#include "Dbtux.hpp" + +void +Dbtux::execACC_SCANREQ(Signal* signal) +{ + jamEntry(); + const AccScanReq reqCopy = *(const AccScanReq*)signal->getDataPtr(); + const AccScanReq* const req = &reqCopy; + ScanOpPtr scanPtr; + scanPtr.i = RNIL; + do { + // get the index + IndexPtr indexPtr; + c_indexPool.getPtr(indexPtr, req->tableId); + // get the fragment + FragPtr fragPtr; + fragPtr.i = RNIL; + for (unsigned i = 0; i < indexPtr.p->m_numFrags; i++) { + jam(); + if (indexPtr.p->m_fragId[i] == req->fragmentNo) { + jam(); + c_fragPool.getPtr(fragPtr, indexPtr.p->m_fragPtrI[i]); + break; + } + } + ndbrequire(fragPtr.i != RNIL); + Frag& frag = *fragPtr.p; + ndbrequire(frag.m_nodeList == RNIL); + // must be normal DIH/TC fragment + ndbrequire(frag.m_fragId < (1 << frag.m_fragOff)); + TreeHead& tree = frag.m_tree; + // check for empty fragment + if (tree.m_root == NullTupAddr) { + jam(); + AccScanConf* const conf = (AccScanConf*)signal->getDataPtrSend(); + conf->scanPtr = req->senderData; + conf->accPtr = RNIL; + conf->flag = AccScanConf::ZEMPTY_FRAGMENT; + sendSignal(req->senderRef, GSN_ACC_SCANCONF, + signal, AccScanConf::SignalLength, JBB); + return; + } + // seize from pool and link to per-fragment list + if (! frag.m_scanList.seize(scanPtr)) { + jam(); + break; + } + new (scanPtr.p) ScanOp(c_scanBoundPool); + scanPtr.p->m_state = ScanOp::First; + scanPtr.p->m_userPtr = req->senderData; + scanPtr.p->m_userRef = req->senderRef; + scanPtr.p->m_tableId = indexPtr.p->m_tableId; + scanPtr.p->m_indexId = indexPtr.i; + scanPtr.p->m_fragId = fragPtr.p->m_fragId; + scanPtr.p->m_fragPtrI = fragPtr.i; + scanPtr.p->m_transId1 = req->transId1; + scanPtr.p->m_transId2 = req->transId2; + scanPtr.p->m_savePointId = req->savePointId; + scanPtr.p->m_readCommitted = AccScanReq::getReadCommittedFlag(req->requestInfo); + scanPtr.p->m_lockMode = AccScanReq::getLockMode(req->requestInfo); + scanPtr.p->m_keyInfo = AccScanReq::getKeyinfoFlag(req->requestInfo); +#ifdef VM_TRACE + if (debugFlags & DebugScan) { + debugOut << "Seize scan " << scanPtr.i << " " << *scanPtr.p << endl; + } +#endif + /* + * readCommitted lockMode keyInfo + * 1 0 0 - read committed (no lock) + * 0 0 0 - read latest (read lock) + * 0 1 1 - read exclusive (write lock) + */ + // conf + AccScanConf* const conf = (AccScanConf*)signal->getDataPtrSend(); + conf->scanPtr = req->senderData; + conf->accPtr = scanPtr.i; + conf->flag = AccScanConf::ZNOT_EMPTY_FRAGMENT; + sendSignal(req->senderRef, GSN_ACC_SCANCONF, + signal, AccScanConf::SignalLength, JBB); + return; + } while (0); + if (scanPtr.i != RNIL) { + jam(); + releaseScanOp(scanPtr); + } + // LQH does not handle REF + signal->theData[0] = 0x313; + sendSignal(req->senderRef, GSN_ACC_SCANREF, + signal, 1, JBB); +} + +/* + * Receive bounds for scan in single direct call. The bounds can arrive + * in any order. Attribute ids are those of index table. + */ +void +Dbtux::execTUX_BOUND_INFO(Signal* signal) +{ + struct BoundInfo { + unsigned offset; + unsigned size; + int type; + }; + TuxBoundInfo* const sig = (TuxBoundInfo*)signal->getDataPtrSend(); + const TuxBoundInfo reqCopy = *(const TuxBoundInfo*)sig; + const TuxBoundInfo* const req = &reqCopy; + // get records + ScanOp& scan = *c_scanOpPool.getPtr(req->tuxScanPtrI); + Index& index = *c_indexPool.getPtr(scan.m_indexId); + // collect bound info for each index attribute + BoundInfo boundInfo[MaxIndexAttributes][2]; + // largest attrId seen plus one + Uint32 maxAttrId = 0; + // skip 5 words + if (req->boundAiLength < 5) { + jam(); + scan.m_state = ScanOp::Invalid; + sig->errorCode = TuxBoundInfo::InvalidAttrInfo; + return; + } + const Uint32* const data = (Uint32*)sig + TuxBoundInfo::SignalLength; + unsigned offset = 5; + // walk through entries + while (offset + 2 < req->boundAiLength) { + jam(); + const unsigned type = data[offset]; + if (type > 4) { + jam(); + scan.m_state = ScanOp::Invalid; + sig->errorCode = TuxBoundInfo::InvalidAttrInfo; + return; + } + const AttributeHeader* ah = (const AttributeHeader*)&data[offset + 1]; + const Uint32 attrId = ah->getAttributeId(); + const Uint32 dataSize = ah->getDataSize(); + if (attrId >= index.m_numAttrs) { + jam(); + scan.m_state = ScanOp::Invalid; + sig->errorCode = TuxBoundInfo::InvalidAttrInfo; + return; + } + while (maxAttrId <= attrId) { + BoundInfo* b = boundInfo[maxAttrId++]; + b[0].type = b[1].type = -1; + } + BoundInfo* b = boundInfo[attrId]; + if (type == 0 || type == 1 || type == 4) { + if (b[0].type != -1) { + jam(); + scan.m_state = ScanOp::Invalid; + sig->errorCode = TuxBoundInfo::InvalidBounds; + return; + } + b[0].offset = offset; + b[0].size = 2 + dataSize; + b[0].type = type; + } + if (type == 2 || type == 3 || type == 4) { + if (b[1].type != -1) { + jam(); + scan.m_state = ScanOp::Invalid; + sig->errorCode = TuxBoundInfo::InvalidBounds; + return; + } + b[1].offset = offset; + b[1].size = 2 + dataSize; + b[1].type = type; + } + // jump to next + offset += 2 + dataSize; + } + if (offset != req->boundAiLength) { + jam(); + scan.m_state = ScanOp::Invalid; + sig->errorCode = TuxBoundInfo::InvalidAttrInfo; + return; + } + // save the bounds in index attribute id order + scan.m_boundCnt[0] = 0; + scan.m_boundCnt[1] = 0; + for (unsigned i = 0; i < maxAttrId; i++) { + jam(); + const BoundInfo* b = boundInfo[i]; + // current limitation - check all but last is equality + if (i + 1 < maxAttrId) { + if (b[0].type != 4 || b[1].type != 4) { + jam(); + scan.m_state = ScanOp::Invalid; + sig->errorCode = TuxBoundInfo::InvalidBounds; + return; + } + } + for (unsigned j = 0; j <= 1; j++) { + if (b[j].type != -1) { + jam(); + bool ok = scan.m_bound[j]->append(&data[b[j].offset], b[j].size); + if (! ok) { + jam(); + scan.m_state = ScanOp::Invalid; + sig->errorCode = TuxBoundInfo::OutOfBuffers; + return; + } + scan.m_boundCnt[j]++; + } + } + } + // no error + sig->errorCode = 0; +} + +void +Dbtux::execNEXT_SCANREQ(Signal* signal) +{ + jamEntry(); + const NextScanReq reqCopy = *(const NextScanReq*)signal->getDataPtr(); + const NextScanReq* const req = &reqCopy; + ScanOpPtr scanPtr; + scanPtr.i = req->accPtr; + c_scanOpPool.getPtr(scanPtr); + ScanOp& scan = *scanPtr.p; + Frag& frag = *c_fragPool.getPtr(scan.m_fragPtrI); +#ifdef VM_TRACE + if (debugFlags & DebugScan) { + debugOut << "NEXT_SCANREQ scan " << scanPtr.i << " " << scan << endl; + } +#endif + ndbrequire(frag.m_nodeList == RNIL); + // handle unlock previous and close scan + switch (req->scanFlag) { + case NextScanReq::ZSCAN_NEXT: + jam(); + break; + case NextScanReq::ZSCAN_NEXT_COMMIT: + jam(); + case NextScanReq::ZSCAN_COMMIT: + jam(); + if (! scan.m_readCommitted) { + jam(); + AccLockReq* const lockReq = (AccLockReq*)signal->getDataPtrSend(); + lockReq->returnCode = RNIL; + lockReq->requestInfo = AccLockReq::Unlock; + lockReq->accOpPtr = req->accOperationPtr; + EXECUTE_DIRECT(DBACC, GSN_ACC_LOCKREQ, signal, AccLockReq::UndoSignalLength); + jamEntry(); + ndbrequire(lockReq->returnCode == AccLockReq::Success); + removeAccLockOp(scan, req->accOperationPtr); + } + if (req->scanFlag == NextScanReq::ZSCAN_COMMIT) { + jam(); + NextScanConf* const conf = (NextScanConf*)signal->getDataPtrSend(); + conf->scanPtr = scan.m_userPtr; + unsigned signalLength = 1; + sendSignal(scanPtr.p->m_userRef, GSN_NEXT_SCANCONF, + signal, signalLength, JBB); + return; + } + break; + case NextScanReq::ZSCAN_CLOSE: + jam(); + // unlink from tree node first to avoid state changes + if (scan.m_scanPos.m_addr != NullTupAddr) { + jam(); + const TupAddr addr = scan.m_scanPos.m_addr; + NodeHandlePtr nodePtr; + selectNode(signal, frag, nodePtr, addr, AccHead); + nodePtr.p->unlinkScan(scanPtr); + scan.m_scanPos.m_addr = NullTupAddr; + } + if (scan.m_lockwait) { + jam(); + ndbrequire(scan.m_accLockOp != RNIL); + // use ACC_ABORTCONF to flush out any reply in job buffer + AccLockReq* const lockReq = (AccLockReq*)signal->getDataPtrSend(); + lockReq->returnCode = RNIL; + lockReq->requestInfo = AccLockReq::AbortWithConf; + lockReq->accOpPtr = scan.m_accLockOp; + EXECUTE_DIRECT(DBACC, GSN_ACC_LOCKREQ, signal, AccLockReq::UndoSignalLength); + jamEntry(); + ndbrequire(lockReq->returnCode == AccLockReq::Success); + scan.m_state = ScanOp::Aborting; + commitNodes(signal, frag, true); + return; + } + if (scan.m_state == ScanOp::Locked) { + jam(); + ndbrequire(scan.m_accLockOp != RNIL); + AccLockReq* const lockReq = (AccLockReq*)signal->getDataPtrSend(); + lockReq->returnCode = RNIL; + lockReq->requestInfo = AccLockReq::Unlock; + lockReq->accOpPtr = scan.m_accLockOp; + EXECUTE_DIRECT(DBACC, GSN_ACC_LOCKREQ, signal, AccLockReq::UndoSignalLength); + jamEntry(); + ndbrequire(lockReq->returnCode == AccLockReq::Success); + scan.m_accLockOp = RNIL; + } + scan.m_state = ScanOp::Aborting; + scanClose(signal, scanPtr); + return; + case NextScanReq::ZSCAN_NEXT_ABORT: + jam(); + default: + jam(); + ndbrequire(false); + break; + } + // start looking for next scan result + AccCheckScan* checkReq = (AccCheckScan*)signal->getDataPtrSend(); + checkReq->accPtr = scanPtr.i; + checkReq->checkLcpStop = AccCheckScan::ZNOT_CHECK_LCP_STOP; + EXECUTE_DIRECT(DBTUX, GSN_ACC_CHECK_SCAN, signal, AccCheckScan::SignalLength); + jamEntry(); +} + +void +Dbtux::execACC_CHECK_SCAN(Signal* signal) +{ + jamEntry(); + const AccCheckScan reqCopy = *(const AccCheckScan*)signal->getDataPtr(); + const AccCheckScan* const req = &reqCopy; + ScanOpPtr scanPtr; + scanPtr.i = req->accPtr; + c_scanOpPool.getPtr(scanPtr); + ScanOp& scan = *scanPtr.p; + Frag& frag = *c_fragPool.getPtr(scan.m_fragPtrI); +#ifdef VM_TRACE + if (debugFlags & DebugScan) { + debugOut << "ACC_CHECK_SCAN scan " << scanPtr.i << " " << scan << endl; + } +#endif + if (req->checkLcpStop == AccCheckScan::ZCHECK_LCP_STOP) { + jam(); + signal->theData[0] = scan.m_userPtr; + signal->theData[1] = true; + EXECUTE_DIRECT(DBLQH, GSN_CHECK_LCP_STOP, signal, 2); + jamEntry(); + commitNodes(signal, frag, true); + return; // stop + } + if (scan.m_lockwait) { + jam(); + // LQH asks if we are waiting for lock and we tell it to ask again + const TreeEnt ent = scan.m_scanPos.m_ent; + NextScanConf* const conf = (NextScanConf*)signal->getDataPtrSend(); + conf->scanPtr = scan.m_userPtr; + conf->accOperationPtr = RNIL; // no tuple returned + conf->fragId = frag.m_fragId | (ent.m_fragBit << frag.m_fragOff); + unsigned signalLength = 3; + // if TC has ordered scan close, it will be detected here + sendSignal(scan.m_userRef, GSN_NEXT_SCANCONF, + signal, signalLength, JBB); + commitNodes(signal, frag, true); + return; // stop + } + if (scan.m_state == ScanOp::First) { + jam(); + // search is done only once in single range scan + scanFirst(signal, scanPtr); +#ifdef VM_TRACE + if (debugFlags & DebugScan) { + debugOut << "First scan " << scanPtr.i << " " << scan << endl; + } +#endif + } + if (scan.m_state == ScanOp::Next) { + jam(); + // look for next + scanNext(signal, scanPtr); + } + // for reading tuple key in Current or Locked state + ReadPar keyPar; + keyPar.m_data = 0; // indicates not yet done + if (scan.m_state == ScanOp::Current) { + // found an entry to return + jam(); + ndbrequire(scan.m_accLockOp == RNIL); + if (! scan.m_readCommitted) { + jam(); + const TreeEnt ent = scan.m_scanPos.m_ent; + // read tuple key + keyPar.m_ent = ent; + keyPar.m_data = c_keyBuffer; + tupReadKeys(signal, frag, keyPar); + // get read lock or exclusive lock + AccLockReq* const lockReq = (AccLockReq*)signal->getDataPtrSend(); + lockReq->returnCode = RNIL; + lockReq->requestInfo = + scan.m_lockMode == 0 ? AccLockReq::LockShared : AccLockReq::LockExclusive; + lockReq->accOpPtr = RNIL; + lockReq->userPtr = scanPtr.i; + lockReq->userRef = reference(); + lockReq->tableId = scan.m_tableId; + lockReq->fragId = frag.m_fragId | (ent.m_fragBit << frag.m_fragOff); + // should cache this at fragment create + lockReq->fragPtrI = RNIL; + const Uint32* const buf32 = static_cast(keyPar.m_data); + const Uint64* const buf64 = reinterpret_cast(buf32); + lockReq->hashValue = md5_hash(buf64, keyPar.m_size); + lockReq->tupAddr = ent.m_tupAddr; + lockReq->transId1 = scan.m_transId1; + lockReq->transId2 = scan.m_transId2; + // execute + EXECUTE_DIRECT(DBACC, GSN_ACC_LOCKREQ, signal, AccLockReq::LockSignalLength); + jamEntry(); + switch (lockReq->returnCode) { + case AccLockReq::Success: + jam(); + scan.m_state = ScanOp::Locked; + scan.m_accLockOp = lockReq->accOpPtr; +#ifdef VM_TRACE + if (debugFlags & DebugScan) { + debugOut << "Lock immediate scan " << scanPtr.i << " " << scan << endl; + } +#endif + break; + case AccLockReq::IsBlocked: + jam(); + // normal lock wait + scan.m_state = ScanOp::Blocked; + scan.m_lockwait = true; + scan.m_accLockOp = lockReq->accOpPtr; +#ifdef VM_TRACE + if (debugFlags & DebugScan) { + debugOut << "Lock wait scan " << scanPtr.i << " " << scan << endl; + } +#endif + // LQH will wake us up + signal->theData[0] = scan.m_userPtr; + signal->theData[1] = true; + EXECUTE_DIRECT(DBLQH, GSN_CHECK_LCP_STOP, signal, 2); + jamEntry(); + commitNodes(signal, frag, true); + return; // stop + break; + case AccLockReq::Refused: + jam(); + // we cannot see deleted tuple (assert only) + ndbassert(false); + // skip it + scan.m_state = ScanOp::Next; + signal->theData[0] = scan.m_userPtr; + signal->theData[1] = true; + EXECUTE_DIRECT(DBLQH, GSN_CHECK_LCP_STOP, signal, 2); + jamEntry(); + commitNodes(signal, frag, true); + return; // stop + break; + case AccLockReq::NoFreeOp: + jam(); + // max ops should depend on max scans (assert only) + ndbassert(false); + // stay in Current state + scan.m_state = ScanOp::Current; + signal->theData[0] = scan.m_userPtr; + signal->theData[1] = true; + EXECUTE_DIRECT(DBLQH, GSN_CHECK_LCP_STOP, signal, 2); + jamEntry(); + commitNodes(signal, frag, true); + return; // stop + break; + default: + ndbrequire(false); + break; + } + } else { + scan.m_state = ScanOp::Locked; + } + } + if (scan.m_state == ScanOp::Locked) { + // we have lock or do not need one + jam(); + // read keys if not already done (uses signal) + const TreeEnt ent = scan.m_scanPos.m_ent; + if (scan.m_keyInfo) { + jam(); + if (keyPar.m_data == 0) { + jam(); + keyPar.m_ent = ent; + keyPar.m_data = c_keyBuffer; + tupReadKeys(signal, frag, keyPar); + } + } + // conf signal + NextScanConf* const conf = (NextScanConf*)signal->getDataPtrSend(); + conf->scanPtr = scan.m_userPtr; + // the lock is passed to LQH + Uint32 accLockOp = scan.m_accLockOp; + if (accLockOp != RNIL) { + scan.m_accLockOp = RNIL; + // remember it until LQH unlocks it + addAccLockOp(scan, accLockOp); + } else { + ndbrequire(scan.m_readCommitted); + // operation RNIL in LQH would signal no tuple returned + accLockOp = (Uint32)-1; + } + conf->accOperationPtr = accLockOp; + conf->fragId = frag.m_fragId | (ent.m_fragBit << frag.m_fragOff); + conf->localKey[0] = ent.m_tupAddr; + conf->localKey[1] = 0; + conf->localKeyLength = 1; + unsigned signalLength = 6; + // add key info + if (scan.m_keyInfo) { + jam(); + conf->keyLength = keyPar.m_size; + // piggy-back first 4 words of key data + for (unsigned i = 0; i < 4; i++) { + conf->key[i] = i < keyPar.m_size ? keyPar.m_data[i] : 0; + } + signalLength = 11; + } + if (! scan.m_readCommitted) { + sendSignal(scan.m_userRef, GSN_NEXT_SCANCONF, + signal, signalLength, JBB); + } else { + Uint32 blockNo = refToBlock(scan.m_userRef); + EXECUTE_DIRECT(blockNo, GSN_NEXT_SCANCONF, signal, signalLength); + } + // send rest of key data + if (scan.m_keyInfo && keyPar.m_size > 4) { + unsigned total = 4; + while (total < keyPar.m_size) { + jam(); + unsigned length = keyPar.m_size - total; + if (length > 20) + length = 20; + signal->theData[0] = scan.m_userPtr; + signal->theData[1] = 0; + signal->theData[2] = 0; + signal->theData[3] = length; + memcpy(&signal->theData[4], &keyPar.m_data[total], length << 2); + sendSignal(scan.m_userRef, GSN_ACC_SCAN_INFO24, + signal, 4 + length, JBB); + total += length; + } + } + // remember last entry returned + scan.m_lastEnt = ent; + // next time look for next entry + scan.m_state = ScanOp::Next; + commitNodes(signal, frag, true); + return; + } + // XXX in ACC this is checked before req->checkLcpStop + if (scan.m_state == ScanOp::Last || + scan.m_state == ScanOp::Invalid) { + jam(); + NextScanConf* const conf = (NextScanConf*)signal->getDataPtrSend(); + conf->scanPtr = scan.m_userPtr; + conf->accOperationPtr = RNIL; + conf->fragId = RNIL; + unsigned signalLength = 3; + sendSignal(scanPtr.p->m_userRef, GSN_NEXT_SCANCONF, + signal, signalLength, JBB); + commitNodes(signal, frag, true); + return; + } + ndbrequire(false); +} + +/* + * Lock succeeded (after delay) in ACC. If the lock is for current + * entry, set state to Locked. If the lock is for an entry we were + * moved away from, simply unlock it. Finally, if we are closing the + * scan, do nothing since we have already sent an abort request. + */ +void +Dbtux::execACCKEYCONF(Signal* signal) +{ + jamEntry(); + ScanOpPtr scanPtr; + scanPtr.i = signal->theData[0]; + c_scanOpPool.getPtr(scanPtr); + ScanOp& scan = *scanPtr.p; +#ifdef VM_TRACE + if (debugFlags & DebugScan) { + debugOut << "Lock obtained scan " << scanPtr.i << " " << scan << endl; + } +#endif + ndbrequire(scan.m_lockwait && scan.m_accLockOp != RNIL); + scan.m_lockwait = false; + if (scan.m_state == ScanOp::Blocked) { + // the lock wait was for current entry + jam(); + scan.m_state = ScanOp::Locked; + // LQH has the ball + return; + } + if (scan.m_state != ScanOp::Aborting) { + // we were moved, release lock + jam(); + AccLockReq* const lockReq = (AccLockReq*)signal->getDataPtrSend(); + lockReq->returnCode = RNIL; + lockReq->requestInfo = AccLockReq::Unlock; + lockReq->accOpPtr = scan.m_accLockOp; + EXECUTE_DIRECT(DBACC, GSN_ACC_LOCKREQ, signal, AccLockReq::UndoSignalLength); + jamEntry(); + ndbrequire(lockReq->returnCode == AccLockReq::Success); + scan.m_accLockOp = RNIL; + // LQH has the ball + return; + } + // continue at ACC_ABORTCONF +} + +/* + * Lock failed (after delay) in ACC. Probably means somebody ahead of + * us in lock queue deleted the tuple. + */ +void +Dbtux::execACCKEYREF(Signal* signal) +{ + jamEntry(); + ScanOpPtr scanPtr; + scanPtr.i = signal->theData[0]; + c_scanOpPool.getPtr(scanPtr); + ScanOp& scan = *scanPtr.p; +#ifdef VM_TRACE + if (debugFlags & DebugScan) { + debugOut << "Lock refused scan " << scanPtr.i << " " << scan << endl; + } +#endif + ndbrequire(scan.m_lockwait && scan.m_accLockOp != RNIL); + scan.m_lockwait = false; + if (scan.m_state != ScanOp::Aborting) { + jam(); + // release the operation + AccLockReq* const lockReq = (AccLockReq*)signal->getDataPtrSend(); + lockReq->returnCode = RNIL; + lockReq->requestInfo = AccLockReq::Abort; + lockReq->accOpPtr = scan.m_accLockOp; + EXECUTE_DIRECT(DBACC, GSN_ACC_LOCKREQ, signal, AccLockReq::UndoSignalLength); + jamEntry(); + ndbrequire(lockReq->returnCode == AccLockReq::Success); + scan.m_accLockOp = RNIL; + // scan position should already have been moved (assert only) + if (scan.m_state == ScanOp::Blocked) { + jam(); + ndbassert(false); + scan.m_state = ScanOp::Next; + } + // LQH has the ball + return; + } + // continue at ACC_ABORTCONF +} + +/* + * Received when scan is closing. This signal arrives after any + * ACCKEYCON or ACCKEYREF which may have been in job buffer. + */ +void +Dbtux::execACC_ABORTCONF(Signal* signal) +{ + jamEntry(); + ScanOpPtr scanPtr; + scanPtr.i = signal->theData[0]; + c_scanOpPool.getPtr(scanPtr); + ScanOp& scan = *scanPtr.p; +#ifdef VM_TRACE + if (debugFlags & DebugScan) { + debugOut << "ACC_ABORTCONF scan " << scanPtr.i << " " << scan << endl; + } +#endif + ndbrequire(scan.m_state == ScanOp::Aborting); + // most likely we are still in lock wait + if (scan.m_lockwait) { + jam(); + scan.m_lockwait = false; + scan.m_accLockOp = RNIL; + } + scanClose(signal, scanPtr); +} + +/* + * Find start position for single range scan. If it exists, sets state + * to Next and links the scan to the node. The first entry is returned + * by scanNext. + */ +void +Dbtux::scanFirst(Signal* signal, ScanOpPtr scanPtr) +{ + ScanOp& scan = *scanPtr.p; + Frag& frag = *c_fragPool.getPtr(scan.m_fragPtrI); + TreeHead& tree = frag.m_tree; + if (tree.m_root == NullTupAddr) { + // tree may have become empty + jam(); + scan.m_state = ScanOp::Last; + return; + } + TreePos pos; + pos.m_addr = tree.m_root; + NodeHandlePtr nodePtr; + // unpack lower bound + const ScanBound& bound = *scan.m_bound[0]; + ScanBoundIterator iter; + bound.first(iter); + for (unsigned j = 0; j < bound.getSize(); j++) { + jam(); + c_keyBuffer[j] = *iter.data; + bound.next(iter); + } + // comparison parameters + BoundPar boundPar; + boundPar.m_data1 = c_keyBuffer; + boundPar.m_count1 = scan.m_boundCnt[0]; + boundPar.m_dir = 0; +loop: { + jam(); + selectNode(signal, frag, nodePtr, pos.m_addr, AccPref); + const unsigned occup = nodePtr.p->getOccup(); + ndbrequire(occup != 0); + for (unsigned i = 0; i <= 1; i++) { + jam(); + // compare prefix + boundPar.m_data2 = nodePtr.p->getPref(i); + boundPar.m_len2 = tree.m_prefSize; + int ret = cmpScanBound(frag, boundPar); + if (ret == NdbSqlUtil::CmpUnknown) { + jam(); + // read full value + ReadPar readPar; + readPar.m_ent = nodePtr.p->getMinMax(i); + readPar.m_first = 0; + readPar.m_count = frag.m_numAttrs; + readPar.m_data = 0; // leave in signal data + tupReadAttrs(signal, frag, readPar); + // compare full value + boundPar.m_data2 = readPar.m_data; + boundPar.m_len2 = ZNIL; // big + ret = cmpScanBound(frag, boundPar); + ndbrequire(ret != NdbSqlUtil::CmpUnknown); + } + if (i == 0 && ret < 0) { + jam(); + const TupAddr tupAddr = nodePtr.p->getLink(i); + if (tupAddr != NullTupAddr) { + jam(); + // continue to left subtree + pos.m_addr = tupAddr; + goto loop; + } + // start scanning this node + pos.m_pos = 0; + pos.m_match = false; + pos.m_dir = 3; + scan.m_scanPos = pos; + scan.m_state = ScanOp::Next; + nodePtr.p->linkScan(scanPtr); + return; + } + if (i == 1 && ret > 0) { + jam(); + const TupAddr tupAddr = nodePtr.p->getLink(i); + if (tupAddr != NullTupAddr) { + jam(); + // continue to right subtree + pos.m_addr = tupAddr; + goto loop; + } + // start scanning upwards + pos.m_dir = 1; + scan.m_scanPos = pos; + scan.m_state = ScanOp::Next; + nodePtr.p->linkScan(scanPtr); + return; + } + } + // read rest of current node + accessNode(signal, frag, nodePtr, AccFull); + // look for first entry + ndbrequire(occup >= 2); + for (unsigned j = 1; j < occup; j++) { + jam(); + ReadPar readPar; + readPar.m_ent = nodePtr.p->getEnt(j); + readPar.m_first = 0; + readPar.m_count = frag.m_numAttrs; + readPar.m_data = 0; // leave in signal data + tupReadAttrs(signal, frag, readPar); + // compare + boundPar.m_data2 = readPar.m_data; + boundPar.m_len2 = ZNIL; // big + int ret = cmpScanBound(frag, boundPar); + ndbrequire(ret != NdbSqlUtil::CmpUnknown); + if (ret < 0) { + jam(); + // start scanning this node + pos.m_pos = j; + pos.m_match = false; + pos.m_dir = 3; + scan.m_scanPos = pos; + scan.m_state = ScanOp::Next; + nodePtr.p->linkScan(scanPtr); + return; + } + } + ndbrequire(false); + } +} + +/* + * Move to next entry. The scan is already linked to some node. When + * we leave, if any entry was found, it will be linked to a possibly + * different node. The scan has a direction, one of: + * + * 0 - coming up from left child + * 1 - coming up from right child (proceed to parent immediately) + * 2 - coming up from root (the scan ends) + * 3 - left to right within node + * 4 - coming down from parent to left or right child + */ +void +Dbtux::scanNext(Signal* signal, ScanOpPtr scanPtr) +{ + ScanOp& scan = *scanPtr.p; + Frag& frag = *c_fragPool.getPtr(scan.m_fragPtrI); +#ifdef VM_TRACE + if (debugFlags & DebugScan) { + debugOut << "Next in scan " << scanPtr.i << " " << scan << endl; + } +#endif + if (scan.m_state == ScanOp::Locked) { + jam(); + // version of a tuple locked by us cannot disappear (assert only) + ndbassert(false); + AccLockReq* const lockReq = (AccLockReq*)signal->getDataPtrSend(); + lockReq->returnCode = RNIL; + lockReq->requestInfo = AccLockReq::Unlock; + lockReq->accOpPtr = scan.m_accLockOp; + EXECUTE_DIRECT(DBACC, GSN_ACC_LOCKREQ, signal, AccLockReq::UndoSignalLength); + jamEntry(); + ndbrequire(lockReq->returnCode == AccLockReq::Success); + scan.m_accLockOp = RNIL; + scan.m_state = ScanOp::Current; + } + // unpack upper bound + const ScanBound& bound = *scan.m_bound[1]; + ScanBoundIterator iter; + bound.first(iter); + for (unsigned j = 0; j < bound.getSize(); j++) { + jam(); + c_keyBuffer[j] = *iter.data; + bound.next(iter); + } + // comparison parameters + BoundPar boundPar; + boundPar.m_data1 = c_keyBuffer; + boundPar.m_count1 = scan.m_boundCnt[1]; + boundPar.m_dir = 1; + // use copy of position + TreePos pos = scan.m_scanPos; + // get and remember original node + NodeHandlePtr origNodePtr; + selectNode(signal, frag, origNodePtr, pos.m_addr, AccHead); + ndbrequire(origNodePtr.p->islinkScan(scanPtr)); + // current node in loop + NodeHandlePtr nodePtr = origNodePtr; + while (true) { + jam(); + if (pos.m_dir == 2) { + // coming up from root ends the scan + jam(); + pos.m_addr = NullTupAddr; + scan.m_state = ScanOp::Last; + break; + } + if (nodePtr.p->m_addr != pos.m_addr) { + jam(); + selectNode(signal, frag, nodePtr, pos.m_addr, AccHead); + } + if (pos.m_dir == 4) { + // coming down from parent proceed to left child + jam(); + TupAddr addr = nodePtr.p->getLink(0); + if (addr != NullTupAddr) { + jam(); + pos.m_addr = addr; + pos.m_dir = 4; // unchanged + continue; + } + // pretend we came from left child + pos.m_dir = 0; + } + if (pos.m_dir == 0) { + // coming from left child scan current node + jam(); + pos.m_pos = 0; + pos.m_match = false; + pos.m_dir = 3; + } + if (pos.m_dir == 3) { + // within node + jam(); + unsigned occup = nodePtr.p->getOccup(); + ndbrequire(occup >= 1); + // access full node + accessNode(signal, frag, nodePtr, AccFull); + // advance position + if (! pos.m_match) + pos.m_match = true; + else + pos.m_pos++; + if (pos.m_pos < occup) { + jam(); + pos.m_ent = nodePtr.p->getEnt(pos.m_pos); + pos.m_dir = 3; // unchanged + // XXX implement prefix optimization + ReadPar readPar; + readPar.m_ent = pos.m_ent; + readPar.m_first = 0; + readPar.m_count = frag.m_numAttrs; + readPar.m_data = 0; // leave in signal data + tupReadAttrs(signal, frag, readPar); + // compare + boundPar.m_data2 = readPar.m_data; + boundPar.m_len2 = ZNIL; // big + int ret = cmpScanBound(frag, boundPar); + ndbrequire(ret != NdbSqlUtil::CmpUnknown); + if (ret < 0) { + jam(); + // hit upper bound of single range scan + pos.m_addr = NullTupAddr; + scan.m_state = ScanOp::Last; + break; + } + // can we see it + if (! scanVisible(signal, scanPtr, pos.m_ent)) { + jam(); + continue; + } + // found entry + scan.m_state = ScanOp::Current; + break; + } + // after node proceed to right child + TupAddr addr = nodePtr.p->getLink(1); + if (addr != NullTupAddr) { + jam(); + pos.m_addr = addr; + pos.m_dir = 4; + continue; + } + // pretend we came from right child + pos.m_dir = 1; + } + if (pos.m_dir == 1) { + // coming from right child proceed to parent + jam(); + pos.m_addr = nodePtr.p->getLink(2); + pos.m_dir = nodePtr.p->getSide(); + continue; + } + ndbrequire(false); + } + // copy back position + scan.m_scanPos = pos; + // relink + if (scan.m_state == ScanOp::Current) { + ndbrequire(pos.m_addr == nodePtr.p->m_addr); + if (origNodePtr.i != nodePtr.i) { + jam(); + origNodePtr.p->unlinkScan(scanPtr); + nodePtr.p->linkScan(scanPtr); + } + } else if (scan.m_state == ScanOp::Last) { + jam(); + ndbrequire(pos.m_addr == NullTupAddr); + origNodePtr.p->unlinkScan(scanPtr); + } else { + ndbrequire(false); + } +#ifdef VM_TRACE + if (debugFlags & DebugScan) { + debugOut << "Next out scan " << scanPtr.i << " " << scan << endl; + } +#endif +} + +/* + * Check if an entry is visible to the scan. + * + * There is a special check to never return same tuple twice in a row. + * This is faster than asking TUP. It also fixes some special cases + * which are not analyzed or handled yet. + */ +bool +Dbtux::scanVisible(Signal* signal, ScanOpPtr scanPtr, TreeEnt ent) +{ + TupQueryTh* const req = (TupQueryTh*)signal->getDataPtrSend(); + const ScanOp& scan = *scanPtr.p; + const Frag& frag = *c_fragPool.getPtr(scan.m_fragPtrI); + /* Assign table, fragment, tuple address + version */ + Uint32 tableId = frag.m_tableId; + Uint32 fragBit = ent.m_fragBit; + Uint32 fragId = frag.m_fragId | (fragBit << frag.m_fragOff); + Uint32 tupAddr = ent.m_tupAddr; + Uint32 tupVersion = ent.m_tupVersion; + /* Check for same tuple twice in row */ + if (scan.m_lastEnt.m_tupAddr == tupAddr && + scan.m_lastEnt.m_fragBit == fragBit) { + jam(); + return false; + } + req->tableId = tableId; + req->fragId = fragId; + req->tupAddr = tupAddr; + req->tupVersion = tupVersion; + /* Assign transaction info, trans id + savepoint id */ + Uint32 transId1 = scan.m_transId1; + Uint32 transId2 = scan.m_transId2; + Uint32 savePointId = scan.m_savePointId; + req->transId1 = transId1; + req->transId2 = transId2; + req->savePointId = savePointId; + EXECUTE_DIRECT(DBTUP, GSN_TUP_QUERY_TH, signal, TupQueryTh::SignalLength); + jamEntry(); + return (bool)req->returnCode; +} + +/* + * Finish closing of scan and send conf. Any lock wait has been done + * already. + */ +void +Dbtux::scanClose(Signal* signal, ScanOpPtr scanPtr) +{ + ScanOp& scan = *scanPtr.p; + Frag& frag = *c_fragPool.getPtr(scanPtr.p->m_fragPtrI); + ndbrequire(! scan.m_lockwait && scan.m_accLockOp == RNIL); + // unlock all not unlocked by LQH + for (unsigned i = 0; i < MaxAccLockOps; i++) { + if (scan.m_accLockOps[i] != RNIL) { + jam(); + AccLockReq* const lockReq = (AccLockReq*)signal->getDataPtrSend(); + lockReq->returnCode = RNIL; + lockReq->requestInfo = AccLockReq::Abort; + lockReq->accOpPtr = scan.m_accLockOps[i]; + EXECUTE_DIRECT(DBACC, GSN_ACC_LOCKREQ, signal, AccLockReq::UndoSignalLength); + jamEntry(); + ndbrequire(lockReq->returnCode == AccLockReq::Success); + scan.m_accLockOps[i] = RNIL; + } + } + // send conf + NextScanConf* const conf = (NextScanConf*)signal->getDataPtrSend(); + conf->scanPtr = scanPtr.p->m_userPtr; + conf->accOperationPtr = RNIL; + conf->fragId = RNIL; + unsigned signalLength = 3; + sendSignal(scanPtr.p->m_userRef, GSN_NEXT_SCANCONF, + signal, signalLength, JBB); + releaseScanOp(scanPtr); + commitNodes(signal, frag, true); +} + +void +Dbtux::addAccLockOp(ScanOp& scan, Uint32 accLockOp) +{ + ndbrequire(accLockOp != RNIL); + Uint32* list = scan.m_accLockOps; + bool ok = false; + for (unsigned i = 0; i < MaxAccLockOps; i++) { + ndbrequire(list[i] != accLockOp); + if (! ok && list[i] == RNIL) { + list[i] = accLockOp; + ok = true; + // continue check for duplicates + } + } + ndbrequire(ok); +} + +void +Dbtux::removeAccLockOp(ScanOp& scan, Uint32 accLockOp) +{ + ndbrequire(accLockOp != RNIL); + Uint32* list = scan.m_accLockOps; + bool ok = false; + for (unsigned i = 0; i < MaxAccLockOps; i++) { + if (list[i] == accLockOp) { + list[i] = RNIL; + ok = true; + break; + } + } + ndbrequire(ok); +} + +/* + * Release allocated records. + */ +void +Dbtux::releaseScanOp(ScanOpPtr& scanPtr) +{ +#ifdef VM_TRACE + if (debugFlags & DebugScan) { + debugOut << "Release scan " << scanPtr.i << " " << *scanPtr.p << endl; + } +#endif + Frag& frag = *c_fragPool.getPtr(scanPtr.p->m_fragPtrI); + scanPtr.p->m_boundMin.release(); + scanPtr.p->m_boundMax.release(); + // unlink from per-fragment list and release from pool + frag.m_scanList.release(scanPtr); +} diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxTree.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxTree.cpp new file mode 100644 index 00000000000..860aa65414f --- /dev/null +++ b/ndb/src/kernel/blocks/dbtux/DbtuxTree.cpp @@ -0,0 +1,755 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define DBTUX_TREE_CPP +#include "Dbtux.hpp" + +/* + * Search for entry. + * + * Search key is index attribute data and tree entry value. Start from + * root node and compare the key to min/max of each node. Use linear + * search on the final (bounding) node. Initial attributes which are + * same in min/max need not be checked. + */ +void +Dbtux::treeSearch(Signal* signal, Frag& frag, SearchPar searchPar, TreePos& treePos) +{ + const TreeHead& tree = frag.m_tree; + const unsigned numAttrs = frag.m_numAttrs; + treePos.m_addr = tree.m_root; + NodeHandlePtr nodePtr; + if (treePos.m_addr == NullTupAddr) { + // empty tree + jam(); + treePos.m_pos = 0; + treePos.m_match = false; + return; + } +loop: { + jam(); + selectNode(signal, frag, nodePtr, treePos.m_addr, AccPref); + const unsigned occup = nodePtr.p->getOccup(); + ndbrequire(occup != 0); + // number of equal initial attributes in bounding node + unsigned numEq = ZNIL; + for (unsigned i = 0; i <= 1; i++) { + jam(); + // compare prefix + CmpPar cmpPar; + cmpPar.m_data1 = searchPar.m_data; + cmpPar.m_data2 = nodePtr.p->getPref(i); + cmpPar.m_len2 = tree.m_prefSize; + cmpPar.m_first = 0; + cmpPar.m_numEq = 0; + int ret = cmpTreeAttrs(frag, cmpPar); + if (ret == NdbSqlUtil::CmpUnknown) { + jam(); + // read full value + ReadPar readPar; + readPar.m_ent = nodePtr.p->getMinMax(i); + ndbrequire(cmpPar.m_numEq < numAttrs); + readPar.m_first = cmpPar.m_numEq; + readPar.m_count = numAttrs - cmpPar.m_numEq; + readPar.m_data = 0; // leave in signal data + tupReadAttrs(signal, frag, readPar); + // compare full value + cmpPar.m_data2 = readPar.m_data; + cmpPar.m_len2 = ZNIL; // big + cmpPar.m_first = readPar.m_first; + ret = cmpTreeAttrs(frag, cmpPar); + ndbrequire(ret != NdbSqlUtil::CmpUnknown); + } + if (numEq > cmpPar.m_numEq) + numEq = cmpPar.m_numEq; + if (ret == 0) { + jam(); + // keys are equal, compare entry values + ret = searchPar.m_ent.cmp(nodePtr.p->getMinMax(i)); + } + if (i == 0 ? (ret < 0) : (ret > 0)) { + jam(); + const TupAddr tupAddr = nodePtr.p->getLink(i); + if (tupAddr != NullTupAddr) { + jam(); + // continue to left/right subtree + treePos.m_addr = tupAddr; + goto loop; + } + // position is immediately before/after this node + // XXX disallow second case + treePos.m_pos = (i == 0 ? 0 : occup); + treePos.m_match = false; + return; + } + if (ret == 0) { + jam(); + // position is at first/last entry + treePos.m_pos = (i == 0 ? 0 : occup - 1); + treePos.m_match = true; + return; + } + } + // read rest of the bounding node + accessNode(signal, frag, nodePtr, AccFull); + // position is strictly within the node + ndbrequire(occup >= 2); + const unsigned numWithin = occup - 2; + for (unsigned j = 1; j <= numWithin; j++) { + jam(); + int ret = 0; + // compare remaining attributes + if (numEq < numAttrs) { + jam(); + ReadPar readPar; + readPar.m_ent = nodePtr.p->getEnt(j); + readPar.m_first = numEq; + readPar.m_count = numAttrs - numEq; + readPar.m_data = 0; // leave in signal data + tupReadAttrs(signal, frag, readPar); + // compare + CmpPar cmpPar; + cmpPar.m_data1 = searchPar.m_data; + cmpPar.m_data2 = readPar.m_data; + cmpPar.m_len2 = ZNIL; // big + cmpPar.m_first = readPar.m_first; + ret = cmpTreeAttrs(frag, cmpPar); + ndbrequire(ret != NdbSqlUtil::CmpUnknown); + } + if (ret == 0) { + jam(); + // keys are equal, compare entry values + ret = searchPar.m_ent.cmp(nodePtr.p->getEnt(j)); + } + if (ret <= 0) { + jam(); + // position is before or at this entry + treePos.m_pos = j; + treePos.m_match = (ret == 0); + return; + } + } + // position is before last entry + treePos.m_pos = occup - 1; + treePos.m_match = false; + return; + } +} + +/* + * Add entry. + */ +void +Dbtux::treeAdd(Signal* signal, Frag& frag, TreePos treePos, TreeEnt ent) +{ + TreeHead& tree = frag.m_tree; + unsigned pos = treePos.m_pos; + NodeHandlePtr nodePtr; + // check for empty tree + if (treePos.m_addr == NullTupAddr) { + jam(); + insertNode(signal, frag, nodePtr, AccPref); + nodePtr.p->pushUp(signal, 0, ent); + nodePtr.p->setSide(2); + tree.m_root = nodePtr.p->m_addr; + return; + } + // access full node + selectNode(signal, frag, nodePtr, treePos.m_addr, AccFull); + // check if it is bounding node + if (pos != 0 && pos != nodePtr.p->getOccup()) { + jam(); + // check if room for one more + if (nodePtr.p->getOccup() < tree.m_maxOccup) { + jam(); + nodePtr.p->pushUp(signal, pos, ent); + return; + } + // returns min entry + nodePtr.p->pushDown(signal, pos - 1, ent); + // find position to add the removed min entry + TupAddr childAddr = nodePtr.p->getLink(0); + if (childAddr == NullTupAddr) { + jam(); + // left child will be added + pos = 0; + } else { + jam(); + // find glb node + while (childAddr != NullTupAddr) { + jam(); + selectNode(signal, frag, nodePtr, childAddr, AccHead); + childAddr = nodePtr.p->getLink(1); + } + // access full node again + accessNode(signal, frag, nodePtr, AccFull); + pos = nodePtr.p->getOccup(); + } + // fall thru to next case + } + // adding new min or max + unsigned i = (pos == 0 ? 0 : 1); + ndbrequire(nodePtr.p->getLink(i) == NullTupAddr); + // check if the half-leaf/leaf has room for one more + if (nodePtr.p->getOccup() < tree.m_maxOccup) { + jam(); + nodePtr.p->pushUp(signal, pos, ent); + return; + } + // add a new node + NodeHandlePtr childPtr; + insertNode(signal, frag, childPtr, AccPref); + childPtr.p->pushUp(signal, 0, ent); + // connect parent and child + nodePtr.p->setLink(i, childPtr.p->m_addr); + childPtr.p->setLink(2, nodePtr.p->m_addr); + childPtr.p->setSide(i); + // re-balance tree at each node + while (true) { + // height of subtree i has increased by 1 + int j = (i == 0 ? -1 : +1); + int b = nodePtr.p->getBalance(); + if (b == 0) { + // perfectly balanced + jam(); + nodePtr.p->setBalance(j); + // height change propagates up + } else if (b == -j) { + // height of shorter subtree increased + jam(); + nodePtr.p->setBalance(0); + // height of tree did not change - done + break; + } else if (b == j) { + // height of longer subtree increased + jam(); + NodeHandlePtr childPtr; + selectNode(signal, frag, childPtr, nodePtr.p->getLink(i), AccHead); + int b2 = childPtr.p->getBalance(); + if (b2 == b) { + jam(); + treeRotateSingle(signal, frag, nodePtr, i); + } else if (b2 == -b) { + jam(); + treeRotateDouble(signal, frag, nodePtr, i); + } else { + // height of subtree increased so it cannot be perfectly balanced + ndbrequire(false); + } + // height of tree did not increase - done + break; + } else { + ndbrequire(false); + } + TupAddr parentAddr = nodePtr.p->getLink(2); + if (parentAddr == NullTupAddr) { + jam(); + // root node - done + break; + } + i = nodePtr.p->getSide(); + selectNode(signal, frag, nodePtr, parentAddr, AccHead); + } +} + +/* + * Remove entry. + */ +void +Dbtux::treeRemove(Signal* signal, Frag& frag, TreePos treePos) +{ + TreeHead& tree = frag.m_tree; + unsigned pos = treePos.m_pos; + NodeHandlePtr nodePtr; + // access full node + selectNode(signal, frag, nodePtr, treePos.m_addr, AccFull); + TreeEnt ent; + // check interior node first + if (nodePtr.p->getChilds() == 2) { + jam(); + ndbrequire(nodePtr.p->getOccup() >= tree.m_minOccup); + // check if no underflow + if (nodePtr.p->getOccup() > tree.m_minOccup) { + jam(); + nodePtr.p->popDown(signal, pos, ent); + return; + } + // save current handle + NodeHandlePtr parentPtr = nodePtr; + // find glb node + TupAddr childAddr = nodePtr.p->getLink(0); + while (childAddr != NullTupAddr) { + jam(); + selectNode(signal, frag, nodePtr, childAddr, AccHead); + childAddr = nodePtr.p->getLink(1); + } + // access full node again + accessNode(signal, frag, nodePtr, AccFull); + // use glb max as new parent min + ent = nodePtr.p->getEnt(nodePtr.p->getOccup() - 1); + parentPtr.p->popUp(signal, pos, ent); + // set up to remove glb max + pos = nodePtr.p->getOccup() - 1; + // fall thru to next case + } + // remove the element + nodePtr.p->popDown(signal, pos, ent); + ndbrequire(nodePtr.p->getChilds() <= 1); + // handle half-leaf + for (unsigned i = 0; i <= 1; i++) { + jam(); + TupAddr childAddr = nodePtr.p->getLink(i); + if (childAddr != NullTupAddr) { + // move to child + selectNode(signal, frag, nodePtr, childAddr, AccFull); + // balance of half-leaf parent requires child to be leaf + break; + } + } + ndbrequire(nodePtr.p->getChilds() == 0); + // get parent if any + TupAddr parentAddr = nodePtr.p->getLink(2); + NodeHandlePtr parentPtr; + unsigned i = nodePtr.p->getSide(); + // move all that fits into parent + if (parentAddr != NullTupAddr) { + jam(); + selectNode(signal, frag, parentPtr, nodePtr.p->getLink(2), AccFull); + parentPtr.p->slide(signal, nodePtr, i); + // fall thru to next case + } + // non-empty leaf + if (nodePtr.p->getOccup() >= 1) { + jam(); + return; + } + // remove empty leaf + deleteNode(signal, frag, nodePtr); + if (parentAddr == NullTupAddr) { + jam(); + // tree is now empty + tree.m_root = NullTupAddr; + return; + } + nodePtr = parentPtr; + nodePtr.p->setLink(i, NullTupAddr); +#ifdef dbtux_min_occup_less_max_occup + // check if we created a half-leaf + if (nodePtr.p->getBalance() == 0) { + jam(); + // move entries from the other child + TupAddr childAddr = nodePtr.p->getLink(1 - i); + NodeHandlePtr childPtr; + selectNode(signal, frag, childPtr, childAddr, AccFull); + nodePtr.p->slide(signal, childPtr, 1 - i); + if (childPtr.p->getOccup() == 0) { + jam(); + deleteNode(signal, frag, childPtr); + nodePtr.p->setLink(1 - i, NullTupAddr); + // we are balanced again but our parent balance changes by -1 + parentAddr = nodePtr.p->getLink(2); + if (parentAddr == NullTupAddr) { + jam(); + return; + } + // fix side and become parent + i = nodePtr.p->getSide(); + selectNode(signal, frag, nodePtr, parentAddr, AccHead); + } + } +#endif + // re-balance tree at each node + while (true) { + // height of subtree i has decreased by 1 + int j = (i == 0 ? -1 : +1); + int b = nodePtr.p->getBalance(); + if (b == 0) { + // perfectly balanced + jam(); + nodePtr.p->setBalance(-j); + // height of tree did not change - done + return; + } else if (b == j) { + // height of longer subtree has decreased + jam(); + nodePtr.p->setBalance(0); + // height change propagates up + } else if (b == -j) { + // height of shorter subtree has decreased + jam(); + NodeHandlePtr childPtr; + // child on the other side + selectNode(signal, frag, childPtr, nodePtr.p->getLink(1 - i), AccHead); + int b2 = childPtr.p->getBalance(); + if (b2 == b) { + jam(); + treeRotateSingle(signal, frag, nodePtr, 1 - i); + // height of tree decreased and propagates up + } else if (b2 == -b) { + jam(); + treeRotateDouble(signal, frag, nodePtr, 1 - i); + // height of tree decreased and propagates up + } else { + jam(); + treeRotateSingle(signal, frag, nodePtr, 1 - i); + // height of tree did not change - done + return; + } + } else { + ndbrequire(false); + } + TupAddr parentAddr = nodePtr.p->getLink(2); + if (parentAddr == NullTupAddr) { + jam(); + // root node - done + return; + } + i = nodePtr.p->getSide(); + selectNode(signal, frag, nodePtr, parentAddr, AccHead); + } +} + +/* + * Single rotation about node 5. One of LL (i=0) or RR (i=1). + * + * 0 0 + * | | + * 5 ==> 3 + * / \ / \ + * 3 6 2 5 + * / \ / / \ + * 2 4 1 4 6 + * / + * 1 + * + * In this change 5,3 and 2 must always be there. 0, 1, 2, 4 and 6 are + * all optional. If 4 are there it changes side. +*/ +void +Dbtux::treeRotateSingle(Signal* signal, + Frag& frag, + NodeHandlePtr& nodePtr, + unsigned i) +{ + ndbrequire(i <= 1); + /* + 5 is the old top node that have been unbalanced due to an insert or + delete. The balance is still the old balance before the update. + Verify that n5Bal is 1 if RR rotate and -1 if LL rotate. + */ + NodeHandlePtr n5Ptr = nodePtr; + const TupAddr n5Addr = n5Ptr.p->m_addr; + const int n5Bal = n5Ptr.p->getBalance(); + const int n5side = n5Ptr.p->getSide(); + ndbrequire(n5Bal + (1 - i) == i); + /* + 3 is the new root of this part of the tree which is to swap place with + node 5. For an insert to cause this it must have the same balance as 5. + For deletes it can have the balance 0. + */ + TupAddr n3Addr = n5Ptr.p->getLink(i); + NodeHandlePtr n3Ptr; + selectNode(signal, frag, n3Ptr, n3Addr, AccHead); + const int n3Bal = n3Ptr.p->getBalance(); + /* + 2 must always be there but is not changed. Thus we mereley check that it + exists. + */ + ndbrequire(n3Ptr.p->getLink(i) != NullTupAddr); + /* + 4 is not necessarily there but if it is there it will move from one + side of 3 to the other side of 5. For LL it moves from the right side + to the left side and for RR it moves from the left side to the right + side. This means that it also changes parent from 3 to 5. + */ + TupAddr n4Addr = n3Ptr.p->getLink(1 - i); + NodeHandlePtr n4Ptr; + if (n4Addr != NullTupAddr) { + jam(); + selectNode(signal, frag, n4Ptr, n4Addr, AccHead); + ndbrequire(n4Ptr.p->getSide() == (1 - i) && + n4Ptr.p->getLink(2) == n3Addr); + n4Ptr.p->setSide(i); + n4Ptr.p->setLink(2, n5Addr); + }//if + + /* + Retrieve the address of 5's parent before it is destroyed + */ + TupAddr n0Addr = n5Ptr.p->getLink(2); + + /* + The next step is to perform the rotation. 3 will inherit 5's parent + and side. 5 will become a child of 3 on the right side for LL and on + the left side for RR. + 5 will get 3 as the parent. It will get 4 as a child and it will be + on the right side of 3 for LL and left side of 3 for RR. + The final step of the rotate is to check whether 5 originally had any + parent. If it had not then 3 is the new root node. + We will also verify some preconditions for the change to occur. + 1. 3 must have had 5 as parent before the change. + 2. 3's side is left for LL and right for RR before change. + */ + ndbrequire(n3Ptr.p->getLink(2) == n5Addr); + ndbrequire(n3Ptr.p->getSide() == i); + n3Ptr.p->setLink(1 - i, n5Addr); + n3Ptr.p->setLink(2, n0Addr); + n3Ptr.p->setSide(n5side); + n5Ptr.p->setLink(i, n4Addr); + n5Ptr.p->setLink(2, n3Addr); + n5Ptr.p->setSide(1 - i); + if (n0Addr != NullTupAddr) { + jam(); + NodeHandlePtr n0Ptr; + selectNode(signal, frag, n0Ptr, n0Addr, AccHead); + n0Ptr.p->setLink(n5side, n3Addr); + } else { + jam(); + frag.m_tree.m_root = n3Addr; + }//if + /* The final step of the change is to update the balance of 3 and + 5 that changed places. There are two cases here. The first case is + when 3 unbalanced in the same direction by an insert or a delete. + In this case the changes will make the tree balanced again for both + 3 and 5. + The second case only occurs at deletes. In this case 3 starts out + balanced. In the figure above this could occur if 4 starts out with + a right node and the rotate is triggered by a delete of 6's only child. + In this case 5 will change balance but still be unbalanced and 3 will + be unbalanced in the opposite direction of 5. + */ + if (n3Bal == n5Bal) { + jam(); + n3Ptr.p->setBalance(0); + n5Ptr.p->setBalance(0); + } else if (n3Bal == 0) { + jam(); + n3Ptr.p->setBalance(-n5Bal); + n5Ptr.p->setBalance(n5Bal); + } else { + ndbrequire(false); + }//if + /* + Set nodePtr to 3 as return parameter for enabling caller to continue + traversing the tree. + */ + nodePtr = n3Ptr; +} + +/* + * Double rotation about node 6. One of LR (i=0) or RL (i=1). + * + * 0 0 + * | | + * 6 ==> 4 + * / \ / \ + * 2 7 2 6 + * / \ / \ / \ + * 1 4 1 3 5 7 + * / \ + * 3 5 + * + * In this change 6, 2 and 4 must be there, all others are optional. + * We will start by proving a Lemma. + * Lemma: + * The height of the sub-trees 1 and 7 and the maximum height of the + * threes from 3 and 5 are all the same. + * Proof: + * maxheight(3,5) is defined as the maximum height of 3 and 5. + * If height(7) > maxheight(3,5) then the AVL condition is ok and we + * don't need to perform a rotation. + * If height(7) < maxheight(3,5) then the balance of 6 would be at least + * -3 which cannot happen in an AVL tree even before a rotation. + * Thus we conclude that height(7) == maxheight(3,5) + * + * The next step is to prove that the height of 1 is equal to maxheight(3,5). + * If height(1) - 1 > maxheight(3,5) then we would have + * balance in 6 equal to -3 at least which cannot happen in an AVL-tree. + * If height(1) - 1 = maxheight(3,5) then we should have solved the + * unbalance with a single rotate and not with a double rotate. + * If height(1) + 1 = maxheight(3,5) then we would be doing a rotate + * with node 2 as the root of the rotation. + * If height(1) + k = maxheight(3,5) where k >= 2 then the tree could not have + * been an AVL-tree before the insert or delete. + * Thus we conclude that height(1) = maxheight(3,5) + * + * Thus we conclude that height(1) = maxheight(3,5) = height(7). + * + * Observation: + * The balance of node 4 before the rotation can be any (-1, 0, +1). + * + * The following changes are needed: + * Node 6: + * 1) Changes parent from 0 -> 4 + * 2) 1 - i link stays the same + * 3) i side link is derived from 1 - i side link from 4 + * 4) Side is set to 1 - i + * 5) Balance change: + * If balance(4) == 0 then balance(6) = 0 + * since height(3) = height(5) = maxheight(3,5) = height(7) + * If balance(4) == +1 then balance(6) = 0 + * since height(5) = maxheight(3,5) = height(7) + * If balance(4) == -1 then balance(6) = 1 + * since height(5) + 1 = maxheight(3,5) = height(7) + * + * Node 2: + * 1) Changes parent from 6 -> 4 + * 2) i side link stays the same + * 3) 1 - i side link is derived from i side link of 4 + * 4) Side is set to i (thus not changed) + * 5) Balance change: + * If balance(4) == 0 then balance(2) = 0 + * since height(3) = height(5) = maxheight(3,5) = height(1) + * If balance(4) == -1 then balance(2) = 0 + * since height(3) = maxheight(3,5) = height(1) + * If balance(4) == +1 then balance(6) = 1 + * since height(3) + 1 = maxheight(3,5) = height(1) + * + * Node 4: + * 1) Inherits parent from 6 + * 2) i side link is 2 + * 3) 1 - i side link is 6 + * 4) Side is inherited from 6 + * 5) Balance(4) = 0 independent of previous balance + * Proof: + * If height(1) = 0 then only 2, 4 and 6 are involved and then it is + * trivially true. + * If height(1) >= 1 then we are sure that 1 and 7 exist with the same + * height and that if 3 and 5 exist they are of the same height as 1 and + * 7 and thus we know that 4 is balanced since newheight(2) = newheight(6). + * + * If Node 3 exists: + * 1) Change parent from 4 to 2 + * 2) Change side from i to 1 - i + * + * If Node 5 exists: + * 1) Change parent from 4 to 6 + * 2) Change side from 1 - i to i + * + * If Node 0 exists: + * 1) previous link to 6 is replaced by link to 4 on proper side + * + * Node 1 and 7 needs no changes at all. + * + * Some additional requires are that balance(2) = - balance(6) = -1/+1 since + * otherwise we would do a single rotate. + * + * The balance(6) is -1 if i == 0 and 1 if i == 1 + * + */ +void +Dbtux::treeRotateDouble(Signal* signal, Frag& frag, NodeHandlePtr& nodePtr, unsigned i) +{ + // old top node + NodeHandlePtr n6Ptr = nodePtr; + const TupAddr n6Addr = n6Ptr.p->m_addr; + // the un-updated balance + const int n6Bal = n6Ptr.p->getBalance(); + const unsigned n6Side = n6Ptr.p->getSide(); + + // level 1 + TupAddr n2Addr = n6Ptr.p->getLink(i); + NodeHandlePtr n2Ptr; + selectNode(signal, frag, n2Ptr, n2Addr, AccHead); + const int n2Bal = n2Ptr.p->getBalance(); + + // level 2 + TupAddr n4Addr = n2Ptr.p->getLink(1 - i); + NodeHandlePtr n4Ptr; + selectNode(signal, frag, n4Ptr, n4Addr, AccHead); + const int n4Bal = n4Ptr.p->getBalance(); + + ndbrequire(i <= 1); + ndbrequire(n6Bal + (1 - i) == i); + ndbrequire(n2Bal == -n6Bal); + ndbrequire(n2Ptr.p->getLink(2) == n6Addr); + ndbrequire(n2Ptr.p->getSide() == i); + ndbrequire(n4Ptr.p->getLink(2) == n2Addr); + + // level 3 + TupAddr n3Addr = n4Ptr.p->getLink(i); + TupAddr n5Addr = n4Ptr.p->getLink(1 - i); + + // fill up leaf before it becomes internal + if (n3Addr == NullTupAddr && n5Addr == NullTupAddr) { + jam(); + TreeHead& tree = frag.m_tree; + accessNode(signal, frag, n2Ptr, AccFull); + accessNode(signal, frag, n4Ptr, AccFull); + n4Ptr.p->slide(signal, n2Ptr, i); + // implied by rule of merging half-leaves with leaves + ndbrequire(n4Ptr.p->getOccup() >= tree.m_minOccup); + ndbrequire(n2Ptr.p->getOccup() != 0); + } else { + if (n3Addr != NullTupAddr) { + jam(); + NodeHandlePtr n3Ptr; + selectNode(signal, frag, n3Ptr, n3Addr, AccHead); + n3Ptr.p->setLink(2, n2Addr); + n3Ptr.p->setSide(1 - i); + } + if (n5Addr != NullTupAddr) { + jam(); + NodeHandlePtr n5Ptr; + selectNode(signal, frag, n5Ptr, n5Addr, AccHead); + n5Ptr.p->setLink(2, n6Ptr.p->m_addr); + n5Ptr.p->setSide(i); + } + } + // parent + TupAddr n0Addr = n6Ptr.p->getLink(2); + NodeHandlePtr n0Ptr; + // perform the rotation + n6Ptr.p->setLink(i, n5Addr); + n6Ptr.p->setLink(2, n4Addr); + n6Ptr.p->setSide(1 - i); + + n2Ptr.p->setLink(1 - i, n3Addr); + n2Ptr.p->setLink(2, n4Addr); + + n4Ptr.p->setLink(i, n2Addr); + n4Ptr.p->setLink(1 - i, n6Addr); + n4Ptr.p->setLink(2, n0Addr); + n4Ptr.p->setSide(n6Side); + + if (n0Addr != NullTupAddr) { + jam(); + selectNode(signal, frag, n0Ptr, n0Addr, AccHead); + n0Ptr.p->setLink(n6Side, n4Addr); + } else { + jam(); + frag.m_tree.m_root = n4Addr; + } + // set balance of changed nodes + n4Ptr.p->setBalance(0); + if (n4Bal == 0) { + jam(); + n2Ptr.p->setBalance(0); + n6Ptr.p->setBalance(0); + } else if (n4Bal == -n2Bal) { + jam(); + n2Ptr.p->setBalance(0); + n6Ptr.p->setBalance(n2Bal); + } else if (n4Bal == n2Bal) { + jam(); + n2Ptr.p->setBalance(-n2Bal); + n6Ptr.p->setBalance(0); + } else { + ndbrequire(false); + } + // new top node + nodePtr = n4Ptr; +} diff --git a/ndb/src/kernel/blocks/dbtux/Makefile b/ndb/src/kernel/blocks/dbtux/Makefile new file mode 100644 index 00000000000..30927c31848 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtux/Makefile @@ -0,0 +1,17 @@ +include .defs.mk + +TYPE = kernel + +ARCHIVE_TARGET = dbtux + +SOURCES = \ + DbtuxGen.cpp \ + DbtuxMeta.cpp \ + DbtuxMaint.cpp \ + DbtuxNode.cpp \ + DbtuxTree.cpp \ + DbtuxScan.cpp \ + DbtuxCmp.cpp \ + DbtuxDebug.cpp + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/kernel/blocks/dbtux/tuxstatus.html b/ndb/src/kernel/blocks/dbtux/tuxstatus.html new file mode 100644 index 00000000000..264809cefd3 --- /dev/null +++ b/ndb/src/kernel/blocks/dbtux/tuxstatus.html @@ -0,0 +1,120 @@ + + + +NDB Ordered Index Status + + +

    +

    NDB Ordered Index Status

    +

    +

    Alpha release Jan 30, 2004

    +

    +

      +
    • + Up to 32 index attributes of any type, possibly nullable. +
    • + Index build i.e. table need not be empty. +
    • + Logging NOT done, index rebuilt at system restart. +
    • + Single range scan with lower and upper bounds. +
    • + Scan with locking: read latest, read for update. +
    • + LIMITED number of parallel scans. +
    • + Total result set NOT in index key order. +
    • + NDB ODBC optimizer to use ordered index for equality but NOT for ranges. +
    • + MySQL optimizer to use ordered index for equality and ranges. +
    +

    +As an example, consider following index on integer attributes. +

    +SQL>create index X on T (A, B, C) nologging; +

    +Single range scan means that bounds are set on +an initial sequence of index keys, and all but last is an equality. +
    +For example following scans are supported (the last 2 not via NDB ODBC). +

    +SQL>select * from T where A = 1; +
    +SQL>select * from T where A = 1 and B = 10 and C = 20; +
    +SQL>select * from T where A < 10; +
    +SQL>select * from T where A = 1 and 10 < B and B < 20; +

    +Following scans are NOT supported: +

    +SQL>select * from T where B = 1; +
    +SQL>select * from T where A < 10 and B < 20; +
    +

    Features and dates

    +[ Now = Jan 19 ] +

    +

    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    FeatureNow Jan 30 Mar 01 Never
    Index maintenanceX - - -
    Basic scanX 1) - - -
    Scan bounds on nullable attributes- X - -
    Scan with locking- X - -
    NDB ODBC equality bounds- X - -
    MySQL integration- X - -
    Index build2) X - -
    Unlimited number of scans3) - X -
    Total ordering- - X -
    Multiple range scan- - X -
    NDB ODBC range bounds- - - X
    Logging- - - X
    +

    +1) No locking and bounds must be on non-nullable key attributes. +
    +2) Currently table must be empty when index is created. +
    +3) Currently limited to 11 simultaneous per fragment. + + diff --git a/ndb/src/kernel/blocks/dbutil/DbUtil.cpp b/ndb/src/kernel/blocks/dbutil/DbUtil.cpp new file mode 100644 index 00000000000..3936a211d4b --- /dev/null +++ b/ndb/src/kernel/blocks/dbutil/DbUtil.cpp @@ -0,0 +1,2628 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "DbUtil.hpp" + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: Startup + * ------------------------------------------------------------------------ + * + * Constructors, startup, initializations + **************************************************************************/ + +DbUtil::DbUtil(const Configuration & conf) : + SimulatedBlock(DBUTIL, conf), + c_runningPrepares(c_preparePool), + c_runningPreparedOperations(c_preparedOperationPool), + c_seizingTransactions(c_transactionPool), + c_runningTransactions(c_transactionPool), + c_lockQueues(c_lockQueuePool) +{ + BLOCK_CONSTRUCTOR(DbUtil); + + // Add received signals + addRecSignal(GSN_STTOR, &DbUtil::execSTTOR); + addRecSignal(GSN_NDB_STTOR, &DbUtil::execNDB_STTOR); + addRecSignal(GSN_DUMP_STATE_ORD, &DbUtil::execDUMP_STATE_ORD); + addRecSignal(GSN_CONTINUEB, &DbUtil::execCONTINUEB); + + //addRecSignal(GSN_TCSEIZEREF, &DbUtil::execTCSEIZEREF); + addRecSignal(GSN_TCSEIZECONF, &DbUtil::execTCSEIZECONF); + addRecSignal(GSN_TCKEYCONF, &DbUtil::execTCKEYCONF); + addRecSignal(GSN_TCKEYREF, &DbUtil::execTCKEYREF); + addRecSignal(GSN_TCROLLBACKREP, &DbUtil::execTCROLLBACKREP); + + //addRecSignal(GSN_TCKEY_FAILCONF, &DbUtil::execTCKEY_FAILCONF); + //addRecSignal(GSN_TCKEY_FAILREF, &DbUtil::execTCKEY_FAILREF); + addRecSignal(GSN_TRANSID_AI, &DbUtil::execTRANSID_AI); + + /** + * Sequence Service + */ + addRecSignal(GSN_UTIL_SEQUENCE_REQ, &DbUtil::execUTIL_SEQUENCE_REQ); + // Debug + addRecSignal(GSN_UTIL_SEQUENCE_REF, &DbUtil::execUTIL_SEQUENCE_REF); + addRecSignal(GSN_UTIL_SEQUENCE_CONF, &DbUtil::execUTIL_SEQUENCE_CONF); + + /** + * Locking + */ + addRecSignal(GSN_UTIL_CREATE_LOCK_REQ, &DbUtil::execUTIL_CREATE_LOCK_REQ); + addRecSignal(GSN_UTIL_DESTROY_LOCK_REQ, &DbUtil::execUTIL_DESTORY_LOCK_REQ); + addRecSignal(GSN_UTIL_LOCK_REQ, &DbUtil::execUTIL_LOCK_REQ); + addRecSignal(GSN_UTIL_UNLOCK_REQ, &DbUtil::execUTIL_UNLOCK_REQ); + + /** + * Backend towards Dict + */ + addRecSignal(GSN_GET_TABINFOREF, &DbUtil::execGET_TABINFOREF); + addRecSignal(GSN_GET_TABINFO_CONF, &DbUtil::execGET_TABINFO_CONF); + + /** + * Prepare / Execute / Release Services + */ + addRecSignal(GSN_UTIL_PREPARE_REQ, &DbUtil::execUTIL_PREPARE_REQ); + addRecSignal(GSN_UTIL_PREPARE_CONF, &DbUtil::execUTIL_PREPARE_CONF); + addRecSignal(GSN_UTIL_PREPARE_REF, &DbUtil::execUTIL_PREPARE_REF); + + addRecSignal(GSN_UTIL_EXECUTE_REQ, &DbUtil::execUTIL_EXECUTE_REQ); + addRecSignal(GSN_UTIL_EXECUTE_CONF, &DbUtil::execUTIL_EXECUTE_CONF); + addRecSignal(GSN_UTIL_EXECUTE_REF, &DbUtil::execUTIL_EXECUTE_REF); + + addRecSignal(GSN_UTIL_RELEASE_REQ, &DbUtil::execUTIL_RELEASE_REQ); + addRecSignal(GSN_UTIL_RELEASE_CONF, &DbUtil::execUTIL_RELEASE_CONF); + addRecSignal(GSN_UTIL_RELEASE_REF, &DbUtil::execUTIL_RELEASE_REF); + + c_pagePool.setSize(100); + c_preparePool.setSize(1); // one parallel prepare at a time + c_preparedOperationPool.setSize(5); // three hardcoded, two for test + c_operationPool.setSize(64); // 64 parallel operations + c_transactionPool.setSize(32); // 16 parallel transactions + c_attrMappingPool.setSize(100); + c_dataBufPool.setSize(6000); // 6000*11*4 = 264K > 8k+8k*16 = 256k + { + SLList tmp(c_preparePool); + PreparePtr ptr; + while(tmp.seize(ptr)) + new (ptr.p) Prepare(c_pagePool); + tmp.release(); + } + { + SLList tmp(c_operationPool); + OperationPtr ptr; + while(tmp.seize(ptr)) + new (ptr.p) Operation(c_dataBufPool, c_dataBufPool, c_dataBufPool); + tmp.release(); + } + { + SLList tmp(c_preparedOperationPool); + PreparedOperationPtr ptr; + while(tmp.seize(ptr)) + new (ptr.p) PreparedOperation(c_attrMappingPool, + c_dataBufPool, c_dataBufPool); + tmp.release(); + } + { + SLList tmp(c_transactionPool); + TransactionPtr ptr; + while(tmp.seize(ptr)) + new (ptr.p) Transaction(c_pagePool, c_operationPool); + tmp.release(); + } + + c_lockQueuePool.setSize(5); + c_lockElementPool.setSize(5); + c_lockQueues.setSize(8); +} + +DbUtil::~DbUtil() +{ +} + +BLOCK_FUNCTIONS(DbUtil); + +void +DbUtil::releasePrepare(PreparePtr prepPtr) { + prepPtr.p->preparePages.release(); + c_runningPrepares.release(prepPtr); // Automatic release in pool +} + +void +DbUtil::releasePreparedOperation(PreparedOperationPtr prepOpPtr) { + prepOpPtr.p->attrMapping.release(); + prepOpPtr.p->attrInfo.release(); + prepOpPtr.p->rsInfo.release(); + prepOpPtr.p->pkBitmask.clear(); + c_preparedOperationPool.release(prepOpPtr); // No list holding these structs +} + +void +DbUtil::releaseTransaction(TransactionPtr transPtr){ + transPtr.p->executePages.release(); + OperationPtr opPtr; + for(transPtr.p->operations.first(opPtr); opPtr.i != RNIL; + transPtr.p->operations.next(opPtr)){ + opPtr.p->attrInfo.release(); + opPtr.p->keyInfo.release(); + opPtr.p->rs.release(); + if (opPtr.p->prepOp != 0 && opPtr.p->prepOp_i != RNIL) { + if (opPtr.p->prepOp->releaseFlag) { + PreparedOperationPtr prepOpPtr; + prepOpPtr.i = opPtr.p->prepOp_i; + prepOpPtr.p = opPtr.p->prepOp; + releasePreparedOperation(prepOpPtr); + } + } + } + transPtr.p->operations.release(); + c_runningTransactions.release(transPtr); +} + +void +DbUtil::execSTTOR(Signal* signal) +{ + jamEntry(); + + const Uint32 startphase = signal->theData[1]; + + if(startphase == 1){ + c_transId[0] = (number() << 20) + (getOwnNodeId() << 8); + c_transId[1] = 0; + } + + if(startphase == 6){ + hardcodedPrepare(); + connectTc(signal); + } + + signal->theData[0] = 0; + signal->theData[3] = 1; + signal->theData[4] = 6; + signal->theData[5] = 255; + sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 6, JBB); + + return; +} + +void +DbUtil::execNDB_STTOR(Signal* signal) +{ + (void)signal; // Don't want compiler warning + + jamEntry(); +} + + +/*************************** + * Seize a number of TC records + * to use for Util transactions + */ + +void +DbUtil::connectTc(Signal* signal){ + + TransactionPtr ptr; + while(c_seizingTransactions.seize(ptr)){ + signal->theData[0] = ptr.i << 1; // See TcCommitConf + signal->theData[1] = reference(); + sendSignal(DBTC_REF, GSN_TCSEIZEREQ, signal, 2, JBB); + } +} + +void +DbUtil::execTCSEIZECONF(Signal* signal){ + jamEntry(); + + TransactionPtr ptr; + ptr.i = signal->theData[0] >> 1; + c_seizingTransactions.getPtr(ptr, signal->theData[0] >> 1); + ptr.p->connectPtr = signal->theData[1]; + + c_seizingTransactions.release(ptr); +} + + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: Misc + * ------------------------------------------------------------------------ + * + * ContinueB, Dump + **************************************************************************/ + +void +DbUtil::execCONTINUEB(Signal* signal){ + jamEntry(); + const Uint32 Tdata0 = signal->theData[0]; + + switch(Tdata0){ + default: + ndbrequire(0); + } +} + +void +DbUtil::execDUMP_STATE_ORD(Signal* signal){ + jamEntry(); + + /**************************************************************************** + * SEQUENCE SERVICE + * + * 200 : Simple test of Public Sequence Interface + * ---------------------------------------------- + * - Sends a SEQUENCE_REQ signal to Util (itself) + */ + const Uint32 tCase = signal->theData[0]; + if(tCase == 200){ + jam() + ndbout << "--------------------------------------------------" << endl; + UtilSequenceReq * req = (UtilSequenceReq*)signal->getDataPtrSend(); + Uint32 seqId = 1; + Uint32 reqTy = UtilSequenceReq::CurrVal; + + if(signal->length() > 1) seqId = signal->theData[1]; + if(signal->length() > 2) reqTy = signal->theData[2]; + + req->senderData = 12; + req->sequenceId = seqId; + req->requestType = reqTy; + + sendSignal(DBUTIL_REF, GSN_UTIL_SEQUENCE_REQ, + signal, UtilSequenceReq::SignalLength, JBB); + } + + /****************************************************************************/ + /* // Obsolete tests, should be rewritten for long signals!! + if(tCase == 210){ + jam(); + ndbout << "--------------------------------------------------" << endl; + const Uint32 pageSizeInWords = 128; + Uint32 propPage[pageSizeInWords]; + LinearWriter w(&propPage[0], 128); + w.first(); + w.add(UtilPrepareReq::NoOfOperations, 1); + w.add(UtilPrepareReq::OperationType, UtilPrepareReq::Delete); + w.add(UtilPrepareReq::TableName, "sys/def/SYSTAB_0"); + w.add(UtilPrepareReq::AttributeName, "SYSKEY_0"); // AttrNo = 0 + Uint32 length = w.getWordsUsed(); + ndbassert(length <= pageSizeInWords); + + sendUtilPrepareReqSignals(signal, propPage, length); + } + if(tCase == 211){ + jam(); + ndbout << "--------------------------------------------------" << endl; + const Uint32 pageSizeInWords = 128; + Uint32 propPage[pageSizeInWords]; + LinearWriter w(&propPage[0],128); + w.first(); + w.add(UtilPrepareReq::NoOfOperations, 1); + w.add(UtilPrepareReq::OperationType, UtilPrepareReq::Insert); + w.add(UtilPrepareReq::TableName, "sys/def/SYSTAB_0"); + w.add(UtilPrepareReq::AttributeName, "SYSKEY_0"); // AttrNo = 0 + w.add(UtilPrepareReq::AttributeName, "NEXTID"); // AttrNo = 1 + Uint32 length = w.getWordsUsed(); + ndbassert(length <= pageSizeInWords); + + sendUtilPrepareReqSignals(signal, propPage, length); + } + if(tCase == 212){ + jam(); + ndbout << "--------------------------------------------------" << endl; + const Uint32 pageSizeInWords = 128; + Uint32 propPage[pageSizeInWords]; + LinearWriter w(&propPage[0],128); + w.first(); + w.add(UtilPrepareReq::NoOfOperations, 1); + w.add(UtilPrepareReq::OperationType, UtilPrepareReq::Update); + w.add(UtilPrepareReq::TableName, "sys/def/SYSTAB_0"); + w.add(UtilPrepareReq::AttributeName, "SYSKEY_0"); // AttrNo = 0 + w.add(UtilPrepareReq::AttributeName, "NEXTID"); // AttrNo = 1 + Uint32 length = w.getWordsUsed(); + ndbassert(length <= pageSizeInWords); + + sendUtilPrepareReqSignals(signal, propPage, length); + } + if(tCase == 213){ + jam(); + ndbout << "--------------------------------------------------" << endl; + const Uint32 pageSizeInWords = 128; + Uint32 propPage[pageSizeInWords]; + LinearWriter w(&propPage[0],128); + w.first(); + w.add(UtilPrepareReq::NoOfOperations, 1); + w.add(UtilPrepareReq::OperationType, UtilPrepareReq::Read); + w.add(UtilPrepareReq::TableName, "sys/def/SYSTAB_0"); + w.add(UtilPrepareReq::AttributeName, "SYSKEY_0"); // AttrNo = 0 + Uint32 length = w.getWordsUsed(); + ndbassert(length <= pageSizeInWords); + + sendUtilPrepareReqSignals(signal, propPage, length); + } + if(tCase == 214){ + jam(); + ndbout << "--------------------------------------------------" << endl; + const Uint32 pageSizeInWords = 128; + Uint32 propPage[pageSizeInWords]; + LinearWriter w(&propPage[0], 128); + w.first(); + w.add(UtilPrepareReq::NoOfOperations, 1); + w.add(UtilPrepareReq::OperationType, UtilPrepareReq::Delete); + w.add(UtilPrepareReq::TableId, (unsigned int)0); // SYSTAB_0 + w.add(UtilPrepareReq::AttributeId, (unsigned int)0);// SYSKEY_0 + Uint32 length = w.getWordsUsed(); + ndbassert(length <= pageSizeInWords); + + sendUtilPrepareReqSignals(signal, propPage, length); + } + if(tCase == 215){ + jam(); + ndbout << "--------------------------------------------------" << endl; + const Uint32 pageSizeInWords = 128; + Uint32 propPage[pageSizeInWords]; + LinearWriter w(&propPage[0],128); + w.first(); + w.add(UtilPrepareReq::NoOfOperations, 1); + w.add(UtilPrepareReq::OperationType, UtilPrepareReq::Insert); + w.add(UtilPrepareReq::TableId, (unsigned int)0); // SYSTAB_0 + w.add(UtilPrepareReq::AttributeId, (unsigned int)0); // SYSKEY_0 + w.add(UtilPrepareReq::AttributeId, 1); // NEXTID + Uint32 length = w.getWordsUsed(); + ndbassert(length <= pageSizeInWords); + + sendUtilPrepareReqSignals(signal, propPage, length); + } + if(tCase == 216){ + jam(); + ndbout << "--------------------------------------------------" << endl; + const Uint32 pageSizeInWords = 128; + Uint32 propPage[pageSizeInWords]; + LinearWriter w(&propPage[0],128); + w.first(); + w.add(UtilPrepareReq::NoOfOperations, 1); + w.add(UtilPrepareReq::OperationType, UtilPrepareReq::Update); + w.add(UtilPrepareReq::TableId, (unsigned int)0); // SYSTAB_0 + w.add(UtilPrepareReq::AttributeId, (unsigned int)0);// SYSKEY_0 + w.add(UtilPrepareReq::AttributeId, 1); // NEXTID + Uint32 length = w.getWordsUsed(); + ndbassert(length <= pageSizeInWords); + + sendUtilPrepareReqSignals(signal, propPage, length); + } + if(tCase == 217){ + jam(); + ndbout << "--------------------------------------------------" << endl; + const Uint32 pageSizeInWords = 128; + Uint32 propPage[pageSizeInWords]; + LinearWriter w(&propPage[0],128); + w.first(); + w.add(UtilPrepareReq::NoOfOperations, 1); + w.add(UtilPrepareReq::OperationType, UtilPrepareReq::Read); + w.add(UtilPrepareReq::TableId, (unsigned int)0); // SYSTAB_0 + w.add(UtilPrepareReq::AttributeId, (unsigned int)0);// SYSKEY_0 + Uint32 length = w.getWordsUsed(); + ndbassert(length <= pageSizeInWords); + + sendUtilPrepareReqSignals(signal, propPage, length); + } + */ + /****************************************************************************/ + /* // Obsolete tests, should be rewritten for long signals!! + if(tCase == 220){ + jam(); + ndbout << "--------------------------------------------------" << endl; + Uint32 prepI = signal->theData[1]; + Uint32 length = signal->theData[2]; + Uint32 attributeValue0 = signal->theData[3]; + Uint32 attributeValue1a = signal->theData[4]; + Uint32 attributeValue1b = signal->theData[5]; + ndbrequire(prepI != 0); + + UtilExecuteReq * req = (UtilExecuteReq *)signal->getDataPtrSend(); + + req->senderData = 221; + req->prepareId = prepI; + req->totalDataLen = length; // Including headers + req->offset = 0; + + AttributeHeader::init(&req->attrData[0], 0, 1); // AttrNo 0, DataSize + req->attrData[1] = attributeValue0; // AttrValue + AttributeHeader::init(&req->attrData[2], 1, 2); // AttrNo 1, DataSize + req->attrData[3] = attributeValue1a; // AttrValue + req->attrData[4] = attributeValue1b; // AttrValue + + printUTIL_EXECUTE_REQ(stdout, signal->getDataPtrSend(), 3 + 5,0); + sendSignal(DBUTIL_REF, GSN_UTIL_EXECUTE_REQ, signal, 3 + 5, JBB); + } +*/ + /**************************************************************************** + * 230 : PRINT STATE + */ +#ifdef ARRAY_GUARD + if(tCase == 230){ + jam(); + + ndbout << "--------------------------------------------------" << endl; + if (signal->length() <= 1) { + ndbout << "Usage: DUMP 230 " << endl + << "[1] Print Prepare (running) records" << endl + << "[2] Print PreparedOperation records" << endl + << "[3] Print Transaction records" << endl + << "[4] Print Operation records" << endl + << "Ex. \"dump 230 1 2\" prints Prepare record no 2." << endl + << endl + << "210 : PREPARE_REQ DELETE SYSTAB_0 SYSKEY_0" << endl + << "211 : PREPARE_REQ INSERT SYSTAB_0 SYSKEY_0 NEXTID" << endl + << "212 : PREPARE_REQ UPDATE SYSTAB_0 SYSKEY_0 NEXTID" << endl + << "213 : PREPARE_REQ READ SYSTAB_0 SYSKEY_0" << endl + << "214 : PREPARE_REQ DELETE SYSTAB_0 SYSKEY_0 using id" << endl + << "215 : PREPARE_REQ INSERT SYSTAB_0 SYSKEY_0 NEXTID using id" << endl + << "216 : PREPARE_REQ UPDATE SYSTAB_0 SYSKEY_0 NEXTID using id" << endl + << "217 : PREPARE_REQ READ SYSTAB_0 SYSKEY_0 using id" << endl + << "220 : EXECUTE_REQ " <theData[1]) { + case 1: + // ** Print a specific record ** + if (signal->length() >= 3) { + PreparePtr prepPtr; + if (!c_preparePool.isSeized(signal->theData[2])) { + ndbout << "Prepare Id: " << signal->theData[2] + << " (Not seized!)" << endl; + } else { + c_preparePool.getPtr(prepPtr, signal->theData[2]); + prepPtr.p->print(); + } + return; + } + + // ** Print all records ** + PreparePtr prepPtr; + if (!c_runningPrepares.first(prepPtr)) { + ndbout << "No Prepare records exist" << endl; + return; + } + + while (!prepPtr.isNull()) { + prepPtr.p->print(); + c_runningPrepares.next(prepPtr); + } + return; + + case 2: + // ** Print a specific record ** + if (signal->length() >= 3) { + if (!c_preparedOperationPool.isSeized(signal->theData[2])) { + ndbout << "PreparedOperation Id: " << signal->theData[2] + << " (Not seized!)" << endl; + return; + } + ndbout << "PreparedOperation Id: " << signal->theData[2] << endl; + PreparedOperationPtr prepOpPtr; + c_runningPreparedOperations.getPtr(prepOpPtr, signal->theData[2]); + prepOpPtr.p->print(); + return; + } + + // ** Print all records ** + PreparedOperationPtr prepOpPtr; + if (!c_runningPreparedOperations.first(prepOpPtr)) { + ndbout << "No PreparedOperations exist" << endl; + return; + } + while (!prepOpPtr.isNull()) { + ndbout << "[-PreparedOperation no " << prepOpPtr.i << ":"; + prepOpPtr.p->print(); + ndbout << "]"; + c_runningPreparedOperations.next(prepOpPtr); + } + return; + + case 3: + // ** Print a specific record ** + if (signal->length() >= 3) { + ndbout << "Print specific record not implemented." << endl; + return; + } + + // ** Print all records ** + ndbout << "Print all records not implemented, specify an Id." << endl; + return; + + case 4: + ndbout << "Not implemented" << endl; + return; + + default: + ndbout << "Unknown input (try without any data)" << endl; + return; + } + } +#endif + if(tCase == 240 && signal->getLength() == 2){ + MutexManager::ActiveMutexPtr ptr; + ndbrequire(c_mutexMgr.seize(ptr)); + ptr.p->m_mutexId = signal->theData[1]; + Callback c = { safe_cast(&DbUtil::mutex_created), ptr.i }; + ptr.p->m_callback = c; + c_mutexMgr.create(signal, ptr); + ndbout_c("c_mutexMgr.create ptrI=%d mutexId=%d", ptr.i, ptr.p->m_mutexId); + } + + if(tCase == 241 && signal->getLength() == 2){ + MutexManager::ActiveMutexPtr ptr; + ndbrequire(c_mutexMgr.seize(ptr)); + ptr.p->m_mutexId = signal->theData[1]; + Callback c = { safe_cast(&DbUtil::mutex_locked), ptr.i }; + ptr.p->m_callback = c; + c_mutexMgr.lock(signal, ptr); + ndbout_c("c_mutexMgr.lock ptrI=%d mutexId=%d", ptr.i, ptr.p->m_mutexId); + } + + if(tCase == 242 && signal->getLength() == 2){ + MutexManager::ActiveMutexPtr ptr; + ptr.i = signal->theData[1]; + c_mutexMgr.getPtr(ptr); + Callback c = { safe_cast(&DbUtil::mutex_unlocked), ptr.i }; + ptr.p->m_callback = c; + c_mutexMgr.unlock(signal, ptr); + ndbout_c("c_mutexMgr.unlock ptrI=%d mutexId=%d", ptr.i, ptr.p->m_mutexId); + } + + if(tCase == 243 && signal->getLength() == 3){ + MutexManager::ActiveMutexPtr ptr; + ndbrequire(c_mutexMgr.seize(ptr)); + ptr.p->m_mutexId = signal->theData[1]; + ptr.p->m_mutexKey = signal->theData[2]; + Callback c = { safe_cast(&DbUtil::mutex_destroyed), ptr.i }; + ptr.p->m_callback = c; + c_mutexMgr.destroy(signal, ptr); + ndbout_c("c_mutexMgr.destroy ptrI=%d mutexId=%d key=%d", + ptr.i, ptr.p->m_mutexId, ptr.p->m_mutexKey); + } +} + +void +DbUtil::mutex_created(Signal* signal, Uint32 ptrI, Uint32 retVal){ + MutexManager::ActiveMutexPtr ptr; ptr.i = ptrI; + c_mutexMgr.getPtr(ptr); + ndbout_c("mutex_created - mutexId=%d, retVal=%d", + ptr.p->m_mutexId, retVal); + c_mutexMgr.release(ptrI); +} + +void +DbUtil::mutex_destroyed(Signal* signal, Uint32 ptrI, Uint32 retVal){ + MutexManager::ActiveMutexPtr ptr; ptr.i = ptrI; + c_mutexMgr.getPtr(ptr); + ndbout_c("mutex_destroyed - mutexId=%d, retVal=%d", + ptr.p->m_mutexId, retVal); + c_mutexMgr.release(ptrI); +} + +void +DbUtil::mutex_locked(Signal* signal, Uint32 ptrI, Uint32 retVal){ + MutexManager::ActiveMutexPtr ptr; ptr.i = ptrI; + c_mutexMgr.getPtr(ptr); + ndbout_c("mutex_locked - mutexId=%d, retVal=%d key=%d ptrI=%d", + ptr.p->m_mutexId, retVal, ptr.p->m_mutexKey, ptrI); + if(retVal) + c_mutexMgr.release(ptrI); +} + +void +DbUtil::mutex_unlocked(Signal* signal, Uint32 ptrI, Uint32 retVal){ + MutexManager::ActiveMutexPtr ptr; ptr.i = ptrI; + c_mutexMgr.getPtr(ptr); + ndbout_c("mutex_unlocked - mutexId=%d, retVal=%d", + ptr.p->m_mutexId, retVal); + if(!retVal) + c_mutexMgr.release(ptrI); +} + +void +DbUtil::execUTIL_SEQUENCE_REF(Signal* signal){ + jamEntry(); + ndbout << "UTIL_SEQUENCE_REF" << endl; + printUTIL_SEQUENCE_REF(stdout, signal->getDataPtrSend(), signal->length(), 0); +} + +void +DbUtil::execUTIL_SEQUENCE_CONF(Signal* signal){ + jamEntry(); + ndbout << "UTIL_SEQUENCE_CONF" << endl; + printUTIL_SEQUENCE_CONF(stdout, signal->getDataPtrSend(), signal->length(),0); +} + +void +DbUtil::execUTIL_PREPARE_CONF(Signal* signal){ + jamEntry(); + ndbout << "UTIL_PREPARE_CONF" << endl; + printUTIL_PREPARE_CONF(stdout, signal->getDataPtrSend(), signal->length(), 0); +} + +void +DbUtil::execUTIL_PREPARE_REF(Signal* signal){ + jamEntry(); + ndbout << "UTIL_PREPARE_REF" << endl; + printUTIL_PREPARE_REF(stdout, signal->getDataPtrSend(), signal->length(), 0); +} + +void +DbUtil::execUTIL_EXECUTE_CONF(Signal* signal) { + jamEntry(); + ndbout << "UTIL_EXECUTE_CONF" << endl; + printUTIL_EXECUTE_CONF(stdout, signal->getDataPtrSend(), signal->length(), 0); +} + +void +DbUtil::execUTIL_EXECUTE_REF(Signal* signal) { + jamEntry(); + + ndbout << "UTIL_EXECUTE_REF" << endl; + printUTIL_EXECUTE_REF(stdout, signal->getDataPtrSend(), signal->length(), 0); +} + +void +DbUtil::execUTIL_RELEASE_CONF(Signal* signal) { + jamEntry(); + ndbout << "UTIL_RELEASE_CONF" << endl; +} + +void +DbUtil::execUTIL_RELEASE_REF(Signal* signal) { + jamEntry(); + + ndbout << "UTIL_RELEASE_REF" << endl; +} + +void +DbUtil::sendUtilPrepareRef(Signal* signal, UtilPrepareRef::ErrorCode error, + Uint32 recipient, Uint32 senderData){ + UtilPrepareRef * ref = (UtilPrepareRef *)signal->getDataPtrSend(); + ref->errorCode = error; + ref->senderData = senderData; + + sendSignal(recipient, GSN_UTIL_PREPARE_REF, signal, + UtilPrepareRef::SignalLength, JBB); +} + +void +DbUtil::sendUtilExecuteRef(Signal* signal, UtilExecuteRef::ErrorCode error, + Uint32 TCerror, Uint32 recipient, Uint32 senderData){ + + UtilExecuteRef * ref = (UtilExecuteRef *)signal->getDataPtrSend(); + ref->senderData = senderData; + ref->errorCode = error; + ref->TCErrorCode = TCerror; + + sendSignal(recipient, GSN_UTIL_EXECUTE_REF, signal, + UtilPrepareRef::SignalLength, JBB); +} + + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: Prepare service + * ------------------------------------------------------------------------ + * + * Prepares a transaction by storing info in some structs + **************************************************************************/ + +void +DbUtil::execUTIL_PREPARE_REQ(Signal* signal) +{ + jamEntry(); + + /**************** + * Decode Signal + ****************/ + UtilPrepareReq * req = (UtilPrepareReq *)signal->getDataPtr(); + const Uint32 senderRef = req->senderRef; + const Uint32 senderData = req->senderData; + + if(signal->getNoOfSections() == 0) { + // Missing prepare data + jam(); + releaseSections(signal); + sendUtilPrepareRef(signal, UtilPrepareRef::MISSING_PROPERTIES_SECTION, + senderRef, senderData); + return; + } + + PreparePtr prepPtr; + SegmentedSectionPtr ptr; + + jam(); + if(!c_runningPrepares.seize(prepPtr)) { + jam(); + releaseSections(signal); + sendUtilPrepareRef(signal, UtilPrepareRef::PREPARE_SEIZE_ERROR, + senderRef, senderData); + return; + }; + signal->getSection(ptr, UtilPrepareReq::PROPERTIES_SECTION); + const Uint32 noPages = (ptr.sz + sizeof(Page32)) / sizeof(Page32); + ndbassert(noPages > 0); + if (!prepPtr.p->preparePages.seize(noPages)) { + jam(); + releaseSections(signal); + sendUtilPrepareRef(signal, UtilPrepareRef::PREPARE_PAGES_SEIZE_ERROR, + senderRef, senderData); + c_preparePool.release(prepPtr); + return; + } + // Save SimpleProperties + Uint32* target = &prepPtr.p->preparePages.getPtr(0)->data[0]; + copy(target, ptr); + prepPtr.p->prepDataLen = ptr.sz; + // Release long signal sections + releaseSections(signal); + // Check table properties with DICT + SimplePropertiesSectionReader reader(ptr, getSectionSegmentPool()); + prepPtr.p->clientRef = senderRef; + prepPtr.p->clientData = senderData; + // Release long signal sections + releaseSections(signal); + readPrepareProps(signal, &reader, prepPtr.i); +} + +void DbUtil::readPrepareProps(Signal* signal, + SimpleProperties::Reader* reader, + Uint32 senderData) +{ + jam(); +#if 0 + printf("DbUtil::readPrepareProps: Received SimpleProperties:\n"); + reader->printAll(ndbout); +#endif + ndbrequire(reader->first()); + ndbrequire(reader->getKey() == UtilPrepareReq::NoOfOperations); + ndbrequire(reader->getUint32() == 1); // Only one op/trans implemented + + ndbrequire(reader->next()); + ndbrequire(reader->getKey() == UtilPrepareReq::OperationType); + + ndbrequire(reader->next()); + UtilPrepareReq::KeyValue tableKey = + (UtilPrepareReq::KeyValue) reader->getKey(); + ndbrequire((tableKey == UtilPrepareReq::TableName) || + (tableKey == UtilPrepareReq::TableId)); + + /************************ + * Ask Dict for metadata + ************************/ + { + GetTabInfoReq * req = (GetTabInfoReq *)signal->getDataPtrSend(); + req->senderRef = reference(); + req->senderData = senderData; + if (tableKey == UtilPrepareReq::TableName) { + jam(); + char tableName[MAX_TAB_NAME_SIZE]; + req->requestType = GetTabInfoReq::RequestByName | + GetTabInfoReq::LongSignalConf; + + req->tableNameLen = reader->getValueLen(); // Including trailing \0 + + /******************************************** + * Code signal data and send signals to DICT + ********************************************/ + + ndbrequire(req->tableNameLen < MAX_TAB_NAME_SIZE); + reader->getString((char*)tableName); + LinearSectionPtr ptr[1]; + ptr[0].p = (Uint32*)tableName; + ptr[0].sz = req->tableNameLen; + sendSignal(DBDICT_REF, GSN_GET_TABINFOREQ, signal, + GetTabInfoReq::SignalLength, JBB, ptr,1); + + } + else { // (tableKey == UtilPrepareReq::TableId) + jam(); + req->requestType = GetTabInfoReq::RequestById | + GetTabInfoReq::LongSignalConf; + req->tableId = reader->getUint32(); + sendSignal(DBDICT_REF, GSN_GET_TABINFOREQ, signal, + GetTabInfoReq::SignalLength, JBB); + } + + } +} + +/** + * @note We assume that this signal comes due to a request related + * to a Prepare struct. DictTabInfo:s 'senderData' denotes + * the Prepare struct related to the request. + */ +void +DbUtil::execGET_TABINFO_CONF(Signal* signal){ + jamEntry(); + + if(!assembleFragments(signal)){ + jam(); + return; + } + + /**************** + * Decode signal + ****************/ + GetTabInfoConf * const conf = (GetTabInfoConf*)signal->getDataPtr(); + const Uint32 prepI = conf->senderData; + const Uint32 totalLen = conf->totalLen; + + SegmentedSectionPtr dictTabInfoPtr; + signal->getSection(dictTabInfoPtr, GetTabInfoConf::DICT_TAB_INFO); + ndbrequire(dictTabInfoPtr.sz == totalLen); + + PreparePtr prepPtr; + c_runningPrepares.getPtr(prepPtr, prepI); + prepareOperation(signal, prepPtr); +} + +void +DbUtil::execGET_TABINFOREF(Signal* signal){ + jamEntry(); + + GetTabInfoRef * ref = (GetTabInfoRef *)signal->getDataPtr(); + Uint32 prepI = ref->senderData; +#define EVENT_DEBUG +#if 0 //def EVENT_DEBUG + ndbout << "Signal GET_TABINFOREF received." << endl; + ndbout << "Error Code: " << ref->errorCode << endl; + + switch (ref->errorCode) { + case GetTabInfoRef::InvalidTableId: + ndbout << " Msg: Invalid table id" << endl; + break; + case GetTabInfoRef::TableNotDefined: + ndbout << " Msg: Table not defined" << endl; + break; + case GetTabInfoRef::TableNameToLong: + ndbout << " Msg: Table node too long" << endl; + break; + default: + ndbout << " Msg: Unknown error returned from Dict" << endl; + break; + } +#endif + + PreparePtr prepPtr; + c_runningPrepares.getPtr(prepPtr, prepI); + + sendUtilPrepareRef(signal, UtilPrepareRef::DICT_TAB_INFO_ERROR, + prepPtr.p->clientRef, prepPtr.p->clientData); + + releasePrepare(prepPtr); +} + + +/****************************************************************************** + * Prepare Operation + * + * Using a prepare record, prepare an operation (i.e. create PreparedOperation). + * Info from both Pepare request (PreparePages) and DictTabInfo is used. + * + * Algorithm: + * -# Seize AttrbuteMapping + * - Lookup in preparePages how many attributes should be prepared + * - Seize AttributeMapping + * -# For each attributes in preparePages + * - Lookup id and isPK in dictInfoPages + * - Store "no -> (AttributeId, Position)" in AttributeMapping + * -# For each map in AttributeMapping + * - if (isPK) then assign offset + ******************************************************************************/ +void +DbUtil::prepareOperation(Signal* signal, PreparePtr prepPtr) +{ + jam(); + + /******************************************* + * Seize and store PreparedOperation struct + *******************************************/ + PreparedOperationPtr prepOpPtr; + if(!c_runningPreparedOperations.seize(prepOpPtr)) { + jam(); + releaseSections(signal); + sendUtilPrepareRef(signal, UtilPrepareRef::PREPARED_OPERATION_SEIZE_ERROR, + prepPtr.p->clientRef, prepPtr.p->clientData); + releasePrepare(prepPtr); + return; + } + prepPtr.p->prepOpPtr = prepOpPtr; + + /******************** + * Read request info + ********************/ + SimplePropertiesLinearReader prepPagesReader(&prepPtr.p->preparePages.getPtr(0)->data[0], + prepPtr.p->prepDataLen); + + ndbrequire(prepPagesReader.first()); + ndbrequire(prepPagesReader.getKey() == UtilPrepareReq::NoOfOperations); + const Uint32 noOfOperations = prepPagesReader.getUint32(); + ndbrequire(noOfOperations == 1); + + ndbrequire(prepPagesReader.next()); + ndbrequire(prepPagesReader.getKey() == UtilPrepareReq::OperationType); + const Uint32 operationType = prepPagesReader.getUint32(); + + ndbrequire(prepPagesReader.next()); + + char tableName[MAX_TAB_NAME_SIZE]; + Uint32 tableId; + UtilPrepareReq::KeyValue tableKey = + (UtilPrepareReq::KeyValue) prepPagesReader.getKey(); + if (tableKey == UtilPrepareReq::TableId) { + jam(); + tableId = prepPagesReader.getUint32(); + } + else { + jam(); + ndbrequire(prepPagesReader.getKey() == UtilPrepareReq::TableName); + ndbrequire(prepPagesReader.getValueLen() <= MAX_TAB_NAME_SIZE); + prepPagesReader.getString(tableName); + } + /****************************************************************** + * Seize AttributeMapping (by counting no of attribs in prepPages) + ******************************************************************/ + Uint32 noOfAttributes = 0; // No of attributes in PreparePages (used later) + while(prepPagesReader.next()) { + if (tableKey == UtilPrepareReq::TableName) { + jam(); + ndbrequire(prepPagesReader.getKey() == UtilPrepareReq::AttributeName); + } else { + jam(); + ndbrequire(prepPagesReader.getKey() == UtilPrepareReq::AttributeId); + } + noOfAttributes++; + } + ndbrequire(prepPtr.p->prepOpPtr.p->attrMapping.seize(noOfAttributes)); + if (operationType == UtilPrepareReq::Read) { + ndbrequire(prepPtr.p->prepOpPtr.p->rsInfo.seize(noOfAttributes)); + } + /*************************************** + * For each attribute name, lookup info + ***************************************/ + // Goto start of attribute names + ndbrequire(prepPagesReader.first() && prepPagesReader.next() && + prepPagesReader.next()); + + DictTabInfo::Table tableDesc; tableDesc.init(); + AttrMappingBuffer::DataBufferIterator attrMappingIt; + ndbrequire(prepPtr.p->prepOpPtr.p->attrMapping.first(attrMappingIt)); + + ResultSetBuffer::DataBufferIterator rsInfoIt; + if (operationType == UtilPrepareReq::Read) { + ndbrequire(prepPtr.p->prepOpPtr.p->rsInfo.first(rsInfoIt)); + } + + Uint32 noOfPKAttribsStored = 0; + Uint32 noOfNonPKAttribsStored = 0; + Uint32 attrLength = 0; + Uint32 pkAttrLength = 0; + char attrNameRequested[MAX_ATTR_NAME_SIZE]; + Uint32 attrIdRequested; + + while(prepPagesReader.next()) { + UtilPrepareReq::KeyValue attributeKey = + (UtilPrepareReq::KeyValue) prepPagesReader.getKey(); + + ndbrequire((attributeKey == UtilPrepareReq::AttributeName) || + (attributeKey == UtilPrepareReq::AttributeId)); + if (attributeKey == UtilPrepareReq::AttributeName) { + jam(); + ndbrequire(prepPagesReader.getValueLen() <= MAX_ATTR_NAME_SIZE); + + prepPagesReader.getString(attrNameRequested); + } else { + jam(); + attrIdRequested = prepPagesReader.getUint32(); + } + /***************************************** + * Copy DictTabInfo into tableDesc struct + *****************************************/ + + SegmentedSectionPtr ptr; + signal->getSection(ptr, GetTabInfoConf::DICT_TAB_INFO); + SimplePropertiesSectionReader dictInfoReader(ptr, getSectionSegmentPool()); + + SimpleProperties::UnpackStatus unpackStatus; + unpackStatus = SimpleProperties::unpack(dictInfoReader, &tableDesc, + DictTabInfo::TableMapping, + DictTabInfo::TableMappingSize, + true, true); + ndbrequire(unpackStatus == SimpleProperties::Break); + + /************************ + * Lookup in DictTabInfo + ************************/ + DictTabInfo::Attribute attrDesc; attrDesc.init(); + char attrName[MAX_ATTR_NAME_SIZE]; + Uint32 attrId; + bool attributeFound = false; + Uint32 noOfKeysFound = 0; // # PK attrs found before attr in DICTdata + Uint32 noOfNonKeysFound = 0; // # nonPK attrs found before attr in DICTdata + for (Uint32 i=0; iclientRef, prepPtr.p->clientData); + infoEvent("UTIL: Unknown attribute requested: %s in table: %s", + attrNameRequested, tableName); + releasePreparedOperation(prepOpPtr); + releasePrepare(prepPtr); + return; + } + + /************************************************************** + * Attribute found - store in mapping (AttributeId, Position) + **************************************************************/ + AttributeHeader & attrMap = + AttributeHeader::init(attrMappingIt.data, + attrDesc.AttributeId, // 1. Store AttrId + 0); + + if (attrDesc.AttributeKeyFlag) { + // ** Attribute belongs to PK ** + prepOpPtr.p->pkBitmask.set(attrDesc.AttributeId); + attrMap.setDataSize(noOfKeysFound - 1); // 2. Store Position + noOfPKAttribsStored++; + } else { + attrMap.setDataSize(0x3fff); // 2. Store Position (fake) + noOfNonPKAttribsStored++; + + /*********************************************************** + * Error: Read nonPK Attr before all PK attr have been read + ***********************************************************/ + if (noOfPKAttribsStored != tableDesc.NoOfKeyAttr) { + jam(); + releaseSections(signal); + sendUtilPrepareRef(signal, + UtilPrepareRef::DICT_TAB_INFO_ERROR, + prepPtr.p->clientRef, prepPtr.p->clientData); + infoEvent("UTIL: Non-PK attr not allowed before " + "all PK attrs have been defined, table: %s", + tableName); + releasePreparedOperation(prepOpPtr); + releasePrepare(prepPtr); + return; + } + } +#if 0 + ndbout << "BEFORE: attrLength: " << attrLength << endl; +#endif + { + int len = 0; + switch (attrDesc.AttributeSize) { + case DictTabInfo::an8Bit: + len = (attrDesc.AttributeArraySize + 3)/ 4; + break; + case DictTabInfo::a16Bit: + len = (attrDesc.AttributeArraySize + 1) / 2; + break; + case DictTabInfo::a32Bit: + len = attrDesc.AttributeArraySize; + break; + case DictTabInfo::a64Bit: + len = attrDesc.AttributeArraySize * 2; + break; + case DictTabInfo::a128Bit: + len = attrDesc.AttributeArraySize * 4; + break; + } + attrLength += len; + if (attrDesc.AttributeKeyFlag) + pkAttrLength += len; + + if (operationType == UtilPrepareReq::Read) { + AttributeHeader::init(rsInfoIt.data, + attrDesc.AttributeId, // 1. Store AttrId + len); + prepOpPtr.p->rsInfo.next(rsInfoIt, 1); + } + } +#if 0 + ndbout << ": AttributeSize: " << attrDesc.AttributeSize << endl; + ndbout << ": AttributeArraySize: " << attrDesc.AttributeArraySize << endl; + ndbout << "AFTER: attrLength: " << attrLength << endl; +#endif + //attrMappingIt.print(stdout); + //prepPtr.p->prepOpPtr.p->attrMapping.print(stdout); + prepPtr.p->prepOpPtr.p->attrMapping.next(attrMappingIt, 1); + } + + /*************************** + * Error: Not all PKs found + ***************************/ + if (noOfPKAttribsStored != tableDesc.NoOfKeyAttr) { + jam(); + releaseSections(signal); + sendUtilPrepareRef(signal, + UtilPrepareRef::DICT_TAB_INFO_ERROR, + prepPtr.p->clientRef, prepPtr.p->clientData); + infoEvent("UTIL: Not all primary key attributes requested for table: %s", + tableName); + releasePreparedOperation(prepOpPtr); + releasePrepare(prepPtr); + return; + } + +#if 0 + AttrMappingBuffer::ConstDataBufferIterator tmpIt; + for (prepPtr.p->prepOpPtr.p->attrMapping.first(tmpIt); tmpIt.curr.i != RNIL; + prepPtr.p->prepOpPtr.p->attrMapping.next(tmpIt)) { + AttributeHeader* ah = (AttributeHeader *) tmpIt.data; + ah->print(stdout); + } +#endif + + /********************************************** + * Preparing of PreparedOperation signal train + **********************************************/ + Uint32 static_len = TcKeyReq::StaticLength; + prepOpPtr.p->tckey.tableId = tableDesc.TableId; + prepOpPtr.p->tckey.tableSchemaVersion = tableDesc.TableVersion; + prepOpPtr.p->noOfKeyAttr = tableDesc.NoOfKeyAttr; + prepOpPtr.p->keyLen = tableDesc.KeyLength; // Total no of words in PK + if (prepOpPtr.p->keyLen > TcKeyReq::MaxKeyInfo) { + jam(); + prepOpPtr.p->tckeyLenInBytes = (static_len + TcKeyReq::MaxKeyInfo) * 4; + } else { + jam(); + prepOpPtr.p->tckeyLenInBytes = (static_len + prepOpPtr.p->keyLen) * 4; + } + prepOpPtr.p->keyDataPos = static_len; // Start of keyInfo[] in tckeyreq + + Uint32 requestInfo = 0; + TcKeyReq::setAbortOption(requestInfo, TcKeyReq::AbortOnError); + TcKeyReq::setKeyLength(requestInfo, tableDesc.KeyLength); + switch(operationType) { + case(UtilPrepareReq::Read): + prepOpPtr.p->rsLen = + attrLength + + tableDesc.NoOfKeyAttr + + noOfNonPKAttribsStored; // Read needs a resultset + prepOpPtr.p->noOfAttr = tableDesc.NoOfKeyAttr + noOfNonPKAttribsStored; + prepOpPtr.p->tckey.attrLen = prepOpPtr.p->noOfAttr; + TcKeyReq::setOperationType(requestInfo, ZREAD); + break; + case(UtilPrepareReq::Update): + prepOpPtr.p->rsLen = 0; + prepOpPtr.p->noOfAttr = tableDesc.NoOfKeyAttr + noOfNonPKAttribsStored; + prepOpPtr.p->tckey.attrLen = attrLength + prepOpPtr.p->noOfAttr; + TcKeyReq::setOperationType(requestInfo, ZUPDATE); + break; + case(UtilPrepareReq::Insert): + prepOpPtr.p->rsLen = 0; + prepOpPtr.p->noOfAttr = tableDesc.NoOfKeyAttr + noOfNonPKAttribsStored; + prepOpPtr.p->tckey.attrLen = attrLength + prepOpPtr.p->noOfAttr; + TcKeyReq::setOperationType(requestInfo, ZINSERT); + break; + case(UtilPrepareReq::Delete): + // The number of attributes should equal the size of the primary key + ndbrequire(tableDesc.KeyLength == attrLength); + prepOpPtr.p->rsLen = 0; + prepOpPtr.p->noOfAttr = tableDesc.NoOfKeyAttr; + prepOpPtr.p->tckey.attrLen = 0; + TcKeyReq::setOperationType(requestInfo, ZDELETE); + break; + case(UtilPrepareReq::Write): + prepOpPtr.p->rsLen = 0; + prepOpPtr.p->noOfAttr = tableDesc.NoOfKeyAttr + noOfNonPKAttribsStored; + prepOpPtr.p->tckey.attrLen = attrLength + prepOpPtr.p->noOfAttr; + TcKeyReq::setOperationType(requestInfo, ZWRITE); + break; + } + TcKeyReq::setAIInTcKeyReq(requestInfo, 0); // Attrinfo sent separately + prepOpPtr.p->tckey.requestInfo = requestInfo; + + if (operationType == UtilPrepareReq::Read) { + // ResultSet + AttrMappingBuffer::ConstDataBufferIterator tmpIt; +#if 0 //def EVENT_DEBUG + ResultSetBuffer & rs = prepOpPtr.p->rsInfo; + ResultSetInfoBuffer::DataBufferIterator it; + rs.first(it); + for (prepOpPtr.p->attrMapping.first(tmpIt); + tmpIt.curr.i != RNIL; + prepOpPtr.p->attrMapping.next(tmpIt)) { + AttributeHeader* ah = (AttributeHeader *) tmpIt.data; + ah->print(stdout); + AttributeHeader* rsah = (AttributeHeader *) it.data; + rsah->print(stdout); + rs.next(it,1); + printf("%d\n",it.data); + } +#endif + } + + /**************************** + * Confirm completed prepare + ****************************/ + UtilPrepareConf * conf = (UtilPrepareConf *)signal->getDataPtr(); + conf->senderData = prepPtr.p->clientData; + conf->prepareId = prepPtr.p->prepOpPtr.i; + + releaseSections(signal); + sendSignal(prepPtr.p->clientRef, GSN_UTIL_PREPARE_CONF, signal, + UtilPrepareConf::SignalLength, JBB); + +#if 0 + prepPtr.p->prepOpPtr.p->print(); +#endif + releasePrepare(prepPtr); +} + + +void +DbUtil::execUTIL_RELEASE_REQ(Signal* signal){ + jamEntry(); + + UtilReleaseReq * req = (UtilReleaseReq *)signal->getDataPtr(); + const Uint32 clientRef = signal->senderBlockRef(); + const Uint32 prepareId = req->prepareId; + const Uint32 senderData = req->senderData; + +#if 0 + /** + * This only works in when ARRAY_GUARD is defined (debug-mode) + */ + if (!c_preparedOperationPool.isSeized(prepareId)) { + UtilReleaseRef * ref = (UtilReleaseRef *)signal->getDataPtr(); + ref->prepareId = prepareId; + ref->errorCode = UtilReleaseRef::NO_SUCH_PREPARE_SEIZED; + sendSignal(clientRef, GSN_UTIL_RELEASE_REF, signal, + UtilReleaseRef::SignalLength, JBB); + } +#endif + PreparedOperationPtr prepOpPtr; + c_preparedOperationPool.getPtr(prepOpPtr, prepareId); + + releasePreparedOperation(prepOpPtr); + + UtilReleaseConf * const conf = (UtilReleaseConf*)signal->getDataPtrSend(); + conf->senderData = senderData; + sendSignal(clientRef, GSN_UTIL_RELEASE_CONF, signal, + UtilReleaseConf::SignalLength, JBB); +} + + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: Sequence Service + * ------------------------------------------------------------------------ + * + * A service with a stored incrementable number + **************************************************************************/ + +void +DbUtil::hardcodedPrepare() { + /** + * Prepare SequenceCurrVal (READ) + */ + { + PreparedOperationPtr ptr; + ndbrequire(c_preparedOperationPool.seizeId(ptr, 0)); + ptr.p->keyLen = 1; + ptr.p->tckey.attrLen = 1; + ptr.p->rsLen = 3; + ptr.p->tckeyLenInBytes = (TcKeyReq::StaticLength + + ptr.p->keyLen + ptr.p->tckey.attrLen) * 4; + ptr.p->keyDataPos = TcKeyReq::StaticLength; + ptr.p->tckey.tableId = 0; + Uint32 requestInfo = 0; + TcKeyReq::setAbortOption(requestInfo, TcKeyReq::CommitIfFailFree); + TcKeyReq::setOperationType(requestInfo, ZREAD); + TcKeyReq::setKeyLength(requestInfo, 1); + TcKeyReq::setAIInTcKeyReq(requestInfo, 1); + ptr.p->tckey.requestInfo = requestInfo; + ptr.p->tckey.tableSchemaVersion = 1; + + // This is actually attr data + AttributeHeader::init(&ptr.p->tckey.distrGroupHashValue, 1, 0); + + ndbrequire(ptr.p->rsInfo.seize(1)); + ResultSetInfoBuffer::DataBufferIterator it; + ptr.p->rsInfo.first(it); + AttributeHeader::init(it.data, 1, 2); // Attribute 1 - 2 data words + } + + /** + * Prepare SequenceNextVal (UPDATE) + */ + { + PreparedOperationPtr ptr; + ndbrequire(c_preparedOperationPool.seizeId(ptr, 1)); + ptr.p->keyLen = 1; + ptr.p->rsLen = 3; + ptr.p->tckeyLenInBytes = (TcKeyReq::StaticLength + ptr.p->keyLen + 5) * 4; + ptr.p->keyDataPos = TcKeyReq::StaticLength; + ptr.p->tckey.attrLen = 11; + ptr.p->tckey.tableId = 0; + Uint32 requestInfo = 0; + TcKeyReq::setAbortOption(requestInfo, TcKeyReq::CommitIfFailFree); + TcKeyReq::setOperationType(requestInfo, ZUPDATE); + TcKeyReq::setKeyLength(requestInfo, 1); + TcKeyReq::setAIInTcKeyReq(requestInfo, 5); + TcKeyReq::setInterpretedFlag(requestInfo, 1); + ptr.p->tckey.requestInfo = requestInfo; + ptr.p->tckey.tableSchemaVersion = 1; + + // Signal is packed, which is why attrInfo is at distrGroupHashValue + // position + Uint32 * attrInfo = &ptr.p->tckey.distrGroupHashValue; + attrInfo[0] = 0; // IntialReadSize + attrInfo[1] = 5; // InterpretedSize + attrInfo[2] = 0; // FinalUpdateSize + attrInfo[3] = 1; // FinalReadSize + attrInfo[4] = 0; // SubroutineSize + + { // AttrInfo + ndbrequire(ptr.p->attrInfo.seize(6)); + AttrInfoBuffer::DataBufferIterator it; + ptr.p->attrInfo.first(it); + * it.data = Interpreter::Read(1, 6); + ndbrequire(ptr.p->attrInfo.next(it)); + * it.data = Interpreter::LoadConst16(7, 1); + ndbrequire(ptr.p->attrInfo.next(it)); + * it.data = Interpreter::Add(7, 6, 7); + ndbrequire(ptr.p->attrInfo.next(it)); + * it.data = Interpreter::Write(1, 7); + ndbrequire(ptr.p->attrInfo.next(it)); + * it.data = Interpreter::ExitOK(); + + ndbrequire(ptr.p->attrInfo.next(it)); + AttributeHeader::init(it.data, 1, 0); + } + + { // ResultSet + ndbrequire(ptr.p->rsInfo.seize(1)); + ResultSetInfoBuffer::DataBufferIterator it; + ptr.p->rsInfo.first(it); + AttributeHeader::init(it.data, 1, 2); // Attribute 1 - 2 data words + } + } + + /** + * Prepare CreateSequence (INSERT) + */ + { + PreparedOperationPtr ptr; + ndbrequire(c_preparedOperationPool.seizeId(ptr, 2)); + ptr.p->keyLen = 1; + ptr.p->tckey.attrLen = 5; + ptr.p->rsLen = 0; + ptr.p->tckeyLenInBytes = (TcKeyReq::StaticLength + + ptr.p->keyLen + ptr.p->tckey.attrLen) * 4; + ptr.p->keyDataPos = TcKeyReq::StaticLength; + ptr.p->tckey.tableId = 0; + Uint32 requestInfo = 0; + TcKeyReq::setAbortOption(requestInfo, TcKeyReq::CommitIfFailFree); + TcKeyReq::setOperationType(requestInfo, ZINSERT); + TcKeyReq::setKeyLength(requestInfo, 1); + TcKeyReq::setAIInTcKeyReq(requestInfo, 0); + ptr.p->tckey.requestInfo = requestInfo; + ptr.p->tckey.tableSchemaVersion = 1; + } +} + +void +DbUtil::execUTIL_SEQUENCE_REQ(Signal* signal){ + jamEntry(); + + UtilSequenceReq * req = (UtilSequenceReq*)signal->getDataPtr(); + + PreparedOperation * prepOp; + + switch(req->requestType){ + case UtilSequenceReq::CurrVal: + prepOp = c_preparedOperationPool.getPtr(0); //c_SequenceCurrVal + break; + case UtilSequenceReq::NextVal: + prepOp = c_preparedOperationPool.getPtr(1); //c_SequenceNextVal + break; + case UtilSequenceReq::Create: + prepOp = c_preparedOperationPool.getPtr(2); //c_CreateSequence + break; + default: + ndbrequire(false); + } + + /** + * 1 Transaction with 1 operation + */ + TransactionPtr transPtr; + ndbrequire(c_runningTransactions.seize(transPtr)); + + OperationPtr opPtr; + ndbrequire(transPtr.p->operations.seize(opPtr)); + + ndbrequire(opPtr.p->rs.seize(prepOp->rsLen)); + ndbrequire(opPtr.p->keyInfo.seize(prepOp->keyLen)); + + transPtr.p->gsn = GSN_UTIL_SEQUENCE_REQ; + transPtr.p->clientRef = signal->senderBlockRef(); + transPtr.p->clientData = req->senderData; + transPtr.p->sequence.sequenceId = req->sequenceId; + transPtr.p->sequence.requestType = req->requestType; + + opPtr.p->prepOp = prepOp; + opPtr.p->prepOp_i = RNIL; + + KeyInfoBuffer::DataBufferIterator it; + opPtr.p->keyInfo.first(it); + it.data[0] = transPtr.p->sequence.sequenceId; + + if(req->requestType == UtilSequenceReq::Create){ + ndbrequire(opPtr.p->attrInfo.seize(5)); + AttrInfoBuffer::DataBufferIterator it; + + opPtr.p->attrInfo.first(it); + AttributeHeader::init(it.data, 0, 1); + + ndbrequire(opPtr.p->attrInfo.next(it)); + * it.data = transPtr.p->sequence.sequenceId; + + ndbrequire(opPtr.p->attrInfo.next(it)); + AttributeHeader::init(it.data, 1, 2); + + ndbrequire(opPtr.p->attrInfo.next(it)); + * it.data = 0; + + ndbrequire(opPtr.p->attrInfo.next(it)); + * it.data = 0; + } + + runTransaction(signal, transPtr); +} + +int +DbUtil::getResultSet(Signal* signal, const Transaction * transP, + struct LinearSectionPtr sectionsPtr[]) { + OperationPtr opPtr; + ndbrequire(transP->operations.first(opPtr)); + ndbrequire(transP->operations.hasNext(opPtr) == false); + + int noAttr = 0; + int dataSz = 0; + Uint32* tmpBuf = signal->theData + 25; + const Uint32* headerBuffer = tmpBuf; + + const ResultSetBuffer & rs = opPtr.p->rs; + ResultSetInfoBuffer::ConstDataBufferIterator it; + + // extract headers + for(rs.first(it); it.curr.i != RNIL; ) { + *tmpBuf++ = it.data[0]; + rs.next(it, ((AttributeHeader*)&it.data[0])->getDataSize() + 1); + noAttr++; + } + + if (noAttr == 0) + return 0; + + const Uint32* dataBuffer = tmpBuf; + + // extract data + for(rs.first(it); it.curr.i != RNIL; ) { + int sz = ((AttributeHeader*)&it.data[0])->getDataSize(); + rs.next(it,1); + for (int i = 0; i < sz; i++) { + *tmpBuf++ = *it.data; + rs.next(it,1); + dataSz++; + } + } + + sectionsPtr[UtilExecuteReq::HEADER_SECTION].p = (Uint32 *)headerBuffer; + sectionsPtr[UtilExecuteReq::HEADER_SECTION].sz = noAttr; + sectionsPtr[UtilExecuteReq::DATA_SECTION].p = (Uint32 *)dataBuffer; + sectionsPtr[UtilExecuteReq::DATA_SECTION].sz = dataSz; + + return 1; +} + +void +DbUtil::reportSequence(Signal* signal, const Transaction * transP){ + OperationPtr opPtr; + ndbrequire(transP->operations.first(opPtr)); + ndbrequire(transP->operations.hasNext(opPtr) == false); + + if(transP->errorCode == 0){ + jam(); // OK + + UtilSequenceConf * ret = (UtilSequenceConf *)signal->getDataPtrSend(); + ret->senderData = transP->clientData; + ret->sequenceId = transP->sequence.sequenceId; + ret->requestType = transP->sequence.requestType; + + bool ok = false; + switch(transP->sequence.requestType){ + case UtilSequenceReq::CurrVal: + case UtilSequenceReq::NextVal:{ + ok = true; + ndbrequire(opPtr.p->rsRecv == 3); + + ResultSetBuffer::DataBufferIterator rsit; + ndbrequire(opPtr.p->rs.first(rsit)); + + ret->sequenceValue[0] = rsit.data[1]; + ret->sequenceValue[1] = rsit.data[2]; + break; + } + case UtilSequenceReq::Create: + ok = true; + ret->sequenceValue[0] = 0; + ret->sequenceValue[1] = 0; + break; + } + ndbrequire(ok); + sendSignal(transP->clientRef, GSN_UTIL_SEQUENCE_CONF, signal, + UtilSequenceConf::SignalLength, JBB); + return; + } + + UtilSequenceRef::ErrorCode errCode = UtilSequenceRef::TCError; + + switch(transP->sequence.requestType) + { + case UtilSequenceReq::CurrVal: + case UtilSequenceReq::NextVal:{ + if (transP->errorCode == 626) + errCode = UtilSequenceRef::NoSuchSequence; + break; + } + case UtilSequenceReq::Create: + break; + } + + UtilSequenceRef * ret = (UtilSequenceRef *)signal->getDataPtrSend(); + ret->senderData = transP->clientData; + ret->sequenceId = transP->sequence.sequenceId; + ret->requestType = transP->sequence.requestType; + ret->errorCode = (Uint32)errCode; + sendSignal(transP->clientRef, GSN_UTIL_SEQUENCE_REF, signal, + UtilSequenceRef::SignalLength, JBB); +} +#if 0 + Ndb ndb("ndb","def"); + NdbConnection* tConnection = ndb.startTransaction(); + NdbOperation* tOperation = tConnection->getNdbOperation("SYSTAB_0"); + + //#if 0 && API_CODE + if( tOperation != NULL ) { + tOperation->interpretedUpdateTuple(); + tOperation->equal((U_Int32)0, keyValue ); + tNextId_Result = tOperation->getValue((U_Int32)1); + tOperation->incValue((U_Int32)1, (U_Int32)8192); + + if (tConnection->execute( Commit ) != -1 ) { + U_Int64 tValue = tNextId_Result->u_64_value(); // Read result value + theFirstTransId = tValue; + theLastTransId = tValue + 8191; + closeTransaction(tConnection); + return startTransactionLocal(aPriority, nodeId); + } + } + /** + * IntialReadSize = 0; + * InterpretedSize = incValue(1); + * FinalUpdateSize = 0; + * FinalReadSize = 1; // Read value + * SubroutineSize = 0; + */ +#endif + + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: Transaction execution request + * ------------------------------------------------------------------------ + * + * Handle requests to execute a prepared transaction + **************************************************************************/ + +void +DbUtil::execUTIL_EXECUTE_REQ(Signal* signal) +{ + jamEntry(); + + UtilExecuteReq * req = (UtilExecuteReq *)signal->getDataPtr(); + const Uint32 clientRef = req->senderRef; + const Uint32 clientData = req->senderData; + const Uint32 prepareId = req->getPrepareId(); + const bool releaseFlag = req->getReleaseFlag(); + + if(signal->getNoOfSections() == 0) { + // Missing prepare data + jam(); + releaseSections(signal); + sendUtilExecuteRef(signal, UtilExecuteRef::MissingDataSection, + 0, clientRef, clientData); + return; + } + /******************************* + * Get PreparedOperation struct + *******************************/ + PreparedOperationPtr prepOpPtr; + c_runningPreparedOperations.first(prepOpPtr); + while (!prepOpPtr.isNull() && prepOpPtr.i != prepareId) + c_runningPreparedOperations.next(prepOpPtr); + + if (prepOpPtr.i != prepareId) { + jam(); + releaseSections(signal); + sendUtilExecuteRef(signal, UtilExecuteRef::IllegalPrepareId, + 0, clientRef, clientData); + return; + } + + prepOpPtr.p->releaseFlag = releaseFlag; + + TransactionPtr transPtr; + OperationPtr opPtr; + SegmentedSectionPtr headerPtr, dataPtr; + + signal->getSection(headerPtr, UtilExecuteReq::HEADER_SECTION); + SectionReader headerReader(headerPtr, getSectionSegmentPool()); + signal->getSection(dataPtr, UtilExecuteReq::DATA_SECTION); + SectionReader dataReader(dataPtr, getSectionSegmentPool()); + +#if 0 //def EVENT_DEBUG + // Debugging + printf("DbUtil::execUTIL_EXECUTEL_REQ: Headers (%u): ", headerPtr.sz); + Uint32 word; + while(headerReader.getWord(&word)) + printf("H'%.8x ", word); + printf("\n"); + printf("DbUtil::execUTIL_EXECUTEL_REQ: Data (%u): ", dataPtr.sz); + headerReader.reset(); + while(dataReader.getWord(&word)) + printf("H'%.8x ", word); + printf("\n"); + dataReader.reset(); +#endif + +// Uint32 totalDataLen = headerPtr.sz + dataPtr.sz; + + /************************************************************ + * Seize Transaction record + ************************************************************/ + ndbrequire(c_runningTransactions.seize(transPtr)); + transPtr.p->gsn = GSN_UTIL_EXECUTE_REQ; + transPtr.p->clientRef = clientRef; + transPtr.p->clientData = clientData; + ndbrequire(transPtr.p->operations.seize(opPtr)); + opPtr.p->prepOp = prepOpPtr.p; + opPtr.p->prepOp_i = prepOpPtr.i; + +#if 0 //def EVENT_DEBUG + printf("opPtr.p->rs.seize( %u )\n", prepOpPtr.p->rsLen); +#endif + ndbrequire(opPtr.p->rs.seize(prepOpPtr.p->rsLen)); + + /*********************************************************** + * Store signal data on linear memory in Transaction record + ***********************************************************/ + KeyInfoBuffer* keyInfo = &opPtr.p->keyInfo; + AttrInfoBuffer* attrInfo = &opPtr.p->attrInfo; + AttributeHeader header; + Uint32* tempBuf = signal->theData + 25; + bool dataComplete = true; + + while(headerReader.getWord((Uint32 *)&header)) { + Uint32* bufStart = tempBuf; + header.insertHeader(tempBuf++); + for(unsigned int i = 0; i < header.getDataSize(); i++) { + if (!dataReader.getWord(tempBuf++)) { + dataComplete = false; + break; + } + } + bool res = true; + +#if 0 //def EVENT_DEBUG + if (TcKeyReq::getOperationType(prepOpPtr.p->tckey.requestInfo) == + TcKeyReq::Read) { + if(prepOpPtr.p->pkBitmask.get(header.getAttributeId())) + printf("PrimaryKey\n"); + } + printf("AttrId %u Hdrsz %d Datasz %u \n", + header.getAttributeId(), + header.getHeaderSize(), + header.getDataSize()); +#endif + + if(prepOpPtr.p->pkBitmask.get(header.getAttributeId())) + // A primary key attribute + res = keyInfo->append(bufStart + header.getHeaderSize(), + header.getDataSize()); + + switch (TcKeyReq::getOperationType(prepOpPtr.p->tckey.requestInfo)) { + case ZREAD: + res &= attrInfo->append(bufStart, header.getHeaderSize()); + break; + case ZDELETE: + // no attrinfo for Delete + break; + default: + res &= attrInfo->append(bufStart, + header.getHeaderSize() + header.getDataSize()); + } + + if (!res) { + // Failed to allocate buffer data + jam(); + releaseSections(signal); + sendUtilExecuteRef(signal, UtilExecuteRef::AllocationError, + 0, clientRef, clientData); + releaseTransaction(transPtr); + return; + } + } + if (!dataComplete) { + // Missing data in data section + jam(); + releaseSections(signal); + sendUtilExecuteRef(signal, UtilExecuteRef::MissingData, + 0, clientRef, clientData); + releaseTransaction(transPtr); + return; + } + + const Uint32 l1 = prepOpPtr.p->tckey.attrLen; + const Uint32 l2 = + prepOpPtr.p->attrInfo.getSize() + opPtr.p->attrInfo.getSize(); + + if (TcKeyReq::getOperationType(prepOpPtr.p->tckey.requestInfo) != ZREAD){ + ndbrequire(l1 == l2); + } else { +#if 0 + ndbout_c("TcKeyReq::Read"); +#endif + } + + releaseSections(signal); + runTransaction(signal, transPtr); +} + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: General transaction machinery + * ------------------------------------------------------------------------ + * Executes a prepared transaction + **************************************************************************/ +void +DbUtil::runTransaction(Signal* signal, TransactionPtr transPtr){ + + /* Init transaction */ + transPtr.p->sent = 0; + transPtr.p->recv = 0; + transPtr.p->errorCode = 0; + getTransId(transPtr.p); + + OperationPtr opPtr; + ndbrequire(transPtr.p->operations.first(opPtr)); + + /* First operation */ + Uint32 start = 0; + TcKeyReq::setStartFlag(start, 1); + runOperation(signal, transPtr, opPtr, start); + transPtr.p->sent ++; + + /* Rest of operations */ + start = 0; + while(opPtr.i != RNIL){ + runOperation(signal, transPtr, opPtr, start); + transPtr.p->sent ++; + } + //transPtr.p->print(); +} + +void +DbUtil::runOperation(Signal* signal, TransactionPtr & transPtr, + OperationPtr & opPtr, Uint32 start) { + Uint32 opI = opPtr.i; + Operation * op = opPtr.p; + const PreparedOperation * pop = op->prepOp; + + Uint32 lastFlag = 0; + if(!transPtr.p->operations.next(opPtr)){ + TcKeyReq::setCommitFlag(start, 1); // Last operation + TcKeyReq::setExecuteFlag(start, 1); + } + +#if 0 //def EVENT_DEBUG + if (TcKeyReq::getOperationType(pop->tckey.requestInfo) == + TcKeyReq::Read) { + printf("TcKeyReq::Read runOperation\n"); + } +#endif + + /** + * Init operation w.r.t result set + */ + initResultSet(op->rs, pop->rsInfo); + op->rs.first(op->rsIterator); + op->rsRecv = 0; +#if 0 //def EVENT_DEBUG + printf("pop->rsLen %u\n", pop->rsLen); +#endif + op->rsExpect = 0; + op->transPtrI = transPtr.i; + + TcKeyReq * tcKey = (TcKeyReq*)signal->getDataPtrSend(); + //ndbout << "*** 6 ***"<< endl; pop->print(); + memcpy(tcKey, &pop->tckey, pop->tckeyLenInBytes); + //ndbout << "*** 6b ***"<< endl; + //printTCKEYREQ(stdout, signal->getDataPtrSend(), + // pop->tckeyLenInBytes >> 2, 0); + tcKey->apiConnectPtr = transPtr.p->connectPtr; + tcKey->senderData = opI; + tcKey->transId1 = transPtr.p->transId[0]; + tcKey->transId2 = transPtr.p->transId[1]; + tcKey->requestInfo |= start; + +#if 0 //def EVENT_DEBUG + // Debugging + printf("DbUtil::runOperation: KEYINFO\n"); + op->keyInfo.print(stdout); + printf("DbUtil::runOperation: ATTRINFO\n"); + op->attrInfo.print(stdout); +#endif + + /** + * Key Info + */ + //KeyInfoBuffer::DataBufferIterator kit; + KeyInfoIterator kit; + op->keyInfo.first(kit); + Uint32 *keyDst = ((Uint32*)tcKey) + pop->keyDataPos; + for(Uint32 i = 0; i<8 && kit.curr.i != RNIL; i++, op->keyInfo.next(kit)){ + keyDst[i] = * kit.data; + } + //ndbout << "*** 7 ***" << endl; + //printTCKEYREQ(stdout, signal->getDataPtrSend(), + // pop->tckeyLenInBytes >> 2, 0); + +#if 0 //def EVENT_DEBUG + printf("DbUtil::runOperation: sendSignal(DBTC_REF, GSN_TCKEYREQ, signal, %d , JBB)\n", pop->tckeyLenInBytes >> 2); + printTCKEYREQ(stdout, signal->getDataPtr(), pop->tckeyLenInBytes >> 2,0); +#endif + sendSignal(DBTC_REF, GSN_TCKEYREQ, signal, pop->tckeyLenInBytes >> 2, JBB); + + /** + * More the 8 words of key info not implemented + */ + // ndbrequire(kit.curr.i == RNIL); // Yes it is + + /** + * KeyInfo + */ + KeyInfo* keyInfo = (KeyInfo *)signal->getDataPtrSend(); + keyInfo->connectPtr = transPtr.p->connectPtr; + keyInfo->transId[0] = transPtr.p->transId[0]; + keyInfo->transId[1] = transPtr.p->transId[1]; + sendKeyInfo(signal, keyInfo, op->keyInfo, kit); + + /** + * AttrInfo + */ + AttrInfo* attrInfo = (AttrInfo *)signal->getDataPtrSend(); + attrInfo->connectPtr = transPtr.p->connectPtr; + attrInfo->transId[0] = transPtr.p->transId[0]; + attrInfo->transId[1] = transPtr.p->transId[1]; + + AttrInfoIterator ait; + pop->attrInfo.first(ait); + sendAttrInfo(signal, attrInfo, pop->attrInfo, ait); + + op->attrInfo.first(ait); + sendAttrInfo(signal, attrInfo, op->attrInfo, ait); +} + +void +DbUtil::sendKeyInfo(Signal* signal, + KeyInfo* keyInfo, + const KeyInfoBuffer & keyBuf, + KeyInfoIterator & kit) +{ + while(kit.curr.i != RNIL) { + Uint32 *keyDst = keyInfo->keyData; + Uint32 keyDataLen = 0; + for(Uint32 i = 0; iattrData; + Uint32 i = 0; + for(i = 0; igetDataSize() + 1); +#endif + rs.next(rsit, ((AttributeHeader*)&rsit.data[0])->getDataSize() + 1); + } +} + +void +DbUtil::getTransId(Transaction * transP){ + + Uint32 tmp[2]; + tmp[0] = c_transId[0]; + tmp[1] = c_transId[1]; + + transP->transId[0] = tmp[0]; + transP->transId[1] = tmp[1]; + + c_transId[1] = tmp[1] + 1; +} + + + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: Post Execute + * ------------------------------------------------------------------------ + * + * Handles result from a sent transaction + **************************************************************************/ + +/** + * execTRANSID_AI + * + * Receive result from transaction + * + * NOTE: This codes assumes that + * TransidAI::DataLength = ResultSetBuffer::getSegmentSize() * n + */ +void +DbUtil::execTRANSID_AI(Signal* signal){ + jamEntry(); +#if 0 //def EVENT_DEBUG + ndbout_c("File: %s line: %u",__FILE__,__LINE__); +#endif + + const Uint32 opI = signal->theData[0]; + const Uint32 transId1 = signal->theData[1]; + const Uint32 transId2 = signal->theData[2]; + const Uint32 dataLen = signal->length() - 3; + + Operation * opP = c_operationPool.getPtr(opI); + TransactionPtr transPtr; + c_runningTransactions.getPtr(transPtr, opP->transPtrI); + + ndbrequire(transId1 == transPtr.p->transId[0] && + transId2 == transPtr.p->transId[1]); + opP->rsRecv += dataLen; + + /** + * Save result + */ + Uint32 srcSz = dataLen; + const Uint32 *src = &signal->theData[3]; + const Uint32 segSize = opP->rs.getSegmentSize(); + +#if 0 //def EVENT_DEBUG + printf("rsRecv %u, dataLen %u, rsExpect %u\n", + opP->rsRecv, dataLen, opP->rsExpect); +#endif + + ResultSetBuffer::DataBufferIterator rs = opP->rsIterator; + +#if 0 //def EVENT_DEBUG + for(int i = 0; i < dataLen; i++) + printf("H'%.8x ", src[i]); +#endif + + ndbrequire(opP->rs.import(rs,src,dataLen)); + opP->rs.next(rs, dataLen); + +#if 0 // replaced this section with import() above + while(srcSz > segSize){ + ndbrequire(rs.curr.i != RNIL); + memcpy(rs.data, src, segSize << 2); + opP->rs.next(rs, segSize); + srcSz -= segSize; + // src += segSize * 4; // Bug? + src += segSize; + } + + if(srcSz > 0){ + jam(); + memcpy(rs.data, src, srcSz << 2); + rs.curr.i = RNIL; + rs.data = 0; + } +#endif + + opP->rsIterator = rs; + + if(!opP->complete()){ + jam(); + return; + } + +#if 0 //def EVENT_DEBUG + printf("op complete\n"); +#endif + + transPtr.p->recv++; + if(!transPtr.p->complete()){ + jam(); + return; + } + +#if 0 //def EVENT_DEBUG + printf("trans complete\n"); +#endif + + finishTransaction(signal, transPtr); +} + +void +DbUtil::execTCKEYCONF(Signal* signal){ + jamEntry(); +#if 0 //def EVENT_DEBUG + ndbout_c("File: %s line: %u",__FILE__,__LINE__); +#endif + + TcKeyConf * keyConf = (TcKeyConf*)signal->getDataPtr(); + + //const Uint32 gci = keyConf->gci; + const Uint32 transI = keyConf->apiConnectPtr >> 1; + const Uint32 confInfo = keyConf->confInfo; + const Uint32 transId1 = keyConf->transId1; + const Uint32 transId2 = keyConf->transId2; + + Uint32 recv = 0; + const Uint32 ops = TcKeyConf::getNoOfOperations(confInfo); + for(Uint32 i = 0; ioperations[i].apiOperationPtr); + + ndbrequire(opPtr.p->transPtrI == transI); + opPtr.p->rsExpect += keyConf->operations[i].attrInfoLen; + if(opPtr.p->complete()){ + recv++; + } + } + + /** + * Check commit ack marker flag + */ + if (TcKeyConf::getMarkerFlag(confInfo)){ + signal->theData[0] = transId1; + signal->theData[1] = transId2; + sendSignal(DBTC_REF, GSN_TC_COMMIT_ACK, signal, 2, JBB); + }//if + + TransactionPtr transPtr; + c_runningTransactions.getPtr(transPtr, transI); + ndbrequire(transId1 == transPtr.p->transId[0] && + transId2 == transPtr.p->transId[1]); + + transPtr.p->recv += recv; + if(!transPtr.p->complete()){ + jam(); + return; + } + finishTransaction(signal, transPtr); +} + +void +DbUtil::execTCKEYREF(Signal* signal){ + jamEntry(); +#if 0 //def EVENT_DEBUG + ndbout_c("File: %s line: %u",__FILE__,__LINE__); +#endif + + const Uint32 transI = signal->theData[0] >> 1; + const Uint32 transId1 = signal->theData[1]; + const Uint32 transId2 = signal->theData[2]; + const Uint32 errCode = signal->theData[3]; + + TransactionPtr transPtr; + c_runningTransactions.getPtr(transPtr, transI); + ndbrequire(transId1 == transPtr.p->transId[0] && + transId2 == transPtr.p->transId[1]); + + //if(getClassification(errCode) == PermanentError){ + //} + + //ndbout << "Transaction error (code: " << errCode << ")" << endl; + + transPtr.p->errorCode = errCode; + finishTransaction(signal, transPtr); +} + +void +DbUtil::execTCROLLBACKREP(Signal* signal){ + jamEntry(); +#if 0 //def EVENT_DEBUG + ndbout_c("File: %s line: %u",__FILE__,__LINE__); +#endif + + const Uint32 transI = signal->theData[0] >> 1; + const Uint32 transId1 = signal->theData[1]; + const Uint32 transId2 = signal->theData[2]; + const Uint32 errCode = signal->theData[3]; + + TransactionPtr transPtr; + c_runningTransactions.getPtr(transPtr, transI); + ndbrequire(transId1 == transPtr.p->transId[0] && + transId2 == transPtr.p->transId[1]); + + //if(getClassification(errCode) == PermanentError){ + //} + +#if 0 //def EVENT_DEBUG + ndbout << "Transaction error (code: " << errCode << ")" << endl; +#endif + + transPtr.p->errorCode = errCode; + finishTransaction(signal, transPtr); +} + +void +DbUtil::finishTransaction(Signal* signal, TransactionPtr transPtr){ +#if 0 //def EVENT_DEBUG + ndbout_c("Transaction %x %x completed %s", + transPtr.p->transId[0], + transPtr.p->transId[1], + transPtr.p->errorCode == 0 ? "OK" : "FAILED"); +#endif + + /* + How to find the correct RS? Could we have multi-RS/transaction? + + Operation * opP = c_operationPool.getPtr(opI); + + ResultSetBuffer::DataBufferIterator rsit; + ndbrequire(opP->rs.first(rsit)); + ndbout << "F Result: " << rsit.data << endl; + + while (opP->rs.next(rsit)) { + ndbout << "R Result: " << rsit.data << endl; + } + */ + + switch(transPtr.p->gsn){ + case GSN_UTIL_SEQUENCE_REQ: + jam(); + reportSequence(signal, transPtr.p); + break; + case GSN_UTIL_EXECUTE_REQ: + if (transPtr.p->errorCode) { + UtilExecuteRef * ret = (UtilExecuteRef *)signal->getDataPtrSend(); + ret->senderData = transPtr.p->clientData; + ret->errorCode = UtilExecuteRef::TCError; + ret->TCErrorCode = transPtr.p->errorCode; + sendSignal(transPtr.p->clientRef, GSN_UTIL_EXECUTE_REF, signal, + UtilExecuteRef::SignalLength, JBB); + } else { + struct LinearSectionPtr sectionsPtr[UtilExecuteReq::NoOfSections]; + UtilExecuteConf * ret = (UtilExecuteConf *)signal->getDataPtrSend(); + ret->senderData = transPtr.p->clientData; + if (getResultSet(signal, transPtr.p, sectionsPtr)) { +#if 0 //def EVENT_DEBUG + for (int j = 0; j < 2; j++) { + printf("Result set %u %u\n", j,sectionsPtr[j].sz); + for (int i=0; i < sectionsPtr[j].sz; i++) + printf("H'%.8x ", sectionsPtr[j].p[i]); + printf("\n"); + } +#endif + sendSignal(transPtr.p->clientRef, GSN_UTIL_EXECUTE_CONF, signal, + UtilExecuteConf::SignalLength, JBB, + sectionsPtr, UtilExecuteReq::NoOfSections); + } else + sendSignal(transPtr.p->clientRef, GSN_UTIL_EXECUTE_CONF, signal, + UtilExecuteConf::SignalLength, JBB); + } + break; + default: + ndbrequire(0); + break; + } + releaseTransaction(transPtr); +} + +void +DbUtil::execUTIL_LOCK_REQ(Signal * signal){ + jamEntry(); + UtilLockReq * req = (UtilLockReq*)signal->getDataPtr(); + const Uint32 lockId = req->lockId; + + LockQueuePtr lockQPtr; + if(!c_lockQueues.find(lockQPtr, lockId)){ + jam(); + sendLOCK_REF(signal, req, UtilLockRef::NoSuchLock); + return; + } + +// const Uint32 requestInfo = req->requestInfo; + const Uint32 senderNode = refToNode(req->senderRef); + if(senderNode != getOwnNodeId() && senderNode != 0){ + jam(); + sendLOCK_REF(signal, req, UtilLockRef::DistributedLockNotSupported); + return; + } + + LocalDLFifoList queue(c_lockElementPool, + lockQPtr.p->m_queue); + if(req->requestInfo & UtilLockReq::TryLock && !queue.isEmpty()){ + jam(); + sendLOCK_REF(signal, req, UtilLockRef::LockAlreadyHeld); + return; + } + + LockQueueElementPtr lockEPtr; + if(!c_lockElementPool.seize(lockEPtr)){ + jam(); + sendLOCK_REF(signal, req, UtilLockRef::OutOfLockRecords); + return; + } + + lockEPtr.p->m_senderRef = req->senderRef; + lockEPtr.p->m_senderData = req->senderData; + + if(queue.isEmpty()){ + jam(); + sendLOCK_CONF(signal, lockQPtr.p, lockEPtr.p); + } + + queue.add(lockEPtr); +} + +void +DbUtil::execUTIL_UNLOCK_REQ(Signal* signal){ + jamEntry(); + + UtilUnlockReq * req = (UtilUnlockReq*)signal->getDataPtr(); + const Uint32 lockId = req->lockId; + + LockQueuePtr lockQPtr; + if(!c_lockQueues.find(lockQPtr, lockId)){ + jam(); + sendUNLOCK_REF(signal, req, UtilUnlockRef::NoSuchLock); + return; + } + + LocalDLFifoList queue(c_lockElementPool, + lockQPtr.p->m_queue); + LockQueueElementPtr lockEPtr; + if(!queue.first(lockEPtr)){ + jam(); + sendUNLOCK_REF(signal, req, UtilUnlockRef::NotLockOwner); + return; + } + + if(lockQPtr.p->m_lockKey != req->lockKey){ + jam(); + sendUNLOCK_REF(signal, req, UtilUnlockRef::NotLockOwner); + return; + } + + sendUNLOCK_CONF(signal, lockQPtr.p, lockEPtr.p); + queue.release(lockEPtr); + + if(queue.first(lockEPtr)){ + jam(); + sendLOCK_CONF(signal, lockQPtr.p, lockEPtr.p); + return; + } +} + +void +DbUtil::sendLOCK_REF(Signal* signal, + const UtilLockReq * req, UtilLockRef::ErrorCode err){ + const Uint32 senderData = req->senderData; + const Uint32 senderRef = req->senderRef; + const Uint32 lockId = req->lockId; + + UtilLockRef * ref = (UtilLockRef*)signal->getDataPtrSend(); + ref->senderData = senderData; + ref->senderRef = reference(); + ref->lockId = lockId; + ref->errorCode = err; + sendSignal(senderRef, GSN_UTIL_LOCK_REF, signal, + UtilLockRef::SignalLength, JBB); +} + +void +DbUtil::sendLOCK_CONF(Signal* signal, + LockQueue * lockQP, + LockQueueElement * lockEP){ + const Uint32 senderData = lockEP->m_senderData; + const Uint32 senderRef = lockEP->m_senderRef; + const Uint32 lockId = lockQP->m_lockId; + const Uint32 lockKey = ++lockQP->m_lockKey; + + UtilLockConf * conf = (UtilLockConf*)signal->getDataPtrSend(); + conf->senderData = senderData; + conf->senderRef = reference(); + conf->lockId = lockId; + conf->lockKey = lockKey; + sendSignal(senderRef, GSN_UTIL_LOCK_CONF, signal, + UtilLockConf::SignalLength, JBB); +} + +void +DbUtil::sendUNLOCK_REF(Signal* signal, + const UtilUnlockReq* req, UtilUnlockRef::ErrorCode err){ + + const Uint32 senderData = req->senderData; + const Uint32 senderRef = req->senderRef; + const Uint32 lockId = req->lockId; + + UtilUnlockRef * ref = (UtilUnlockRef*)signal->getDataPtrSend(); + ref->senderData = senderData; + ref->senderRef = reference(); + ref->lockId = lockId; + ref->errorCode = err; + sendSignal(senderRef, GSN_UTIL_UNLOCK_REF, signal, + UtilUnlockRef::SignalLength, JBB); +} + +void +DbUtil::sendUNLOCK_CONF(Signal* signal, + LockQueue * lockQP, + LockQueueElement * lockEP){ + const Uint32 senderData = lockEP->m_senderData; + const Uint32 senderRef = lockEP->m_senderRef; + const Uint32 lockId = lockQP->m_lockId; + ++lockQP->m_lockKey; + + UtilUnlockConf * conf = (UtilUnlockConf*)signal->getDataPtrSend(); + conf->senderData = senderData; + conf->senderRef = reference(); + conf->lockId = lockId; + sendSignal(senderRef, GSN_UTIL_UNLOCK_CONF, signal, + UtilUnlockConf::SignalLength, JBB); +} + +void +DbUtil::execUTIL_CREATE_LOCK_REQ(Signal* signal){ + jamEntry(); + UtilCreateLockReq req = * (UtilCreateLockReq*)signal->getDataPtr(); + + UtilCreateLockRef::ErrorCode err = UtilCreateLockRef::OK; + + do { + LockQueuePtr lockQPtr; + if(c_lockQueues.find(lockQPtr, req.lockId)){ + jam(); + err = UtilCreateLockRef::LockIdAlreadyUsed; + break; + } + + if(req.lockType != UtilCreateLockReq::Mutex){ + jam(); + err = UtilCreateLockRef::UnsupportedLockType; + break; + } + + if(!c_lockQueues.seize(lockQPtr)){ + jam(); + err = UtilCreateLockRef::OutOfLockQueueRecords; + break; + } + + new (lockQPtr.p) LockQueue(req.lockId); + c_lockQueues.add(lockQPtr); + + UtilCreateLockConf * conf = (UtilCreateLockConf*)signal->getDataPtrSend(); + conf->senderData = req.senderData; + conf->senderRef = reference(); + conf->lockId = req.lockId; + + sendSignal(req.senderRef, GSN_UTIL_CREATE_LOCK_CONF, signal, + UtilCreateLockConf::SignalLength, JBB); + return; + } while(false); + + UtilCreateLockRef * ref = (UtilCreateLockRef*)signal->getDataPtrSend(); + ref->senderData = req.senderData; + ref->senderRef = reference(); + ref->lockId = req.lockId; + ref->errorCode = err; + + sendSignal(req.senderRef, GSN_UTIL_CREATE_LOCK_REF, signal, + UtilCreateLockRef::SignalLength, JBB); +} + +void +DbUtil::execUTIL_DESTORY_LOCK_REQ(Signal* signal){ + jamEntry(); + + UtilDestroyLockReq req = * (UtilDestroyLockReq*)signal->getDataPtr(); + UtilDestroyLockRef::ErrorCode err = UtilDestroyLockRef::OK; + do { + LockQueuePtr lockQPtr; + if(!c_lockQueues.find(lockQPtr, req.lockId)){ + jam(); + err = UtilDestroyLockRef::NoSuchLock; + break; + } + + LocalDLFifoList queue(c_lockElementPool, + lockQPtr.p->m_queue); + LockQueueElementPtr lockEPtr; + if(!queue.first(lockEPtr)){ + jam(); + err = UtilDestroyLockRef::NotLockOwner; + break; + } + + if(lockQPtr.p->m_lockKey != req.lockKey){ + jam(); + err = UtilDestroyLockRef::NotLockOwner; + break; + } + + /** + * OK + */ + + // Inform all in lock queue that queue has been destroyed + UtilLockRef * ref = (UtilLockRef*)signal->getDataPtrSend(); + ref->lockId = req.lockId; + ref->errorCode = UtilLockRef::NoSuchLock; + ref->senderRef = reference(); + LockQueueElementPtr loopPtr = lockEPtr; + for(queue.next(loopPtr); !loopPtr.isNull(); queue.next(loopPtr)){ + jam(); + ref->senderData = loopPtr.p->m_senderData; + const Uint32 senderRef = loopPtr.p->m_senderRef; + sendSignal(senderRef, GSN_UTIL_LOCK_REF, signal, + UtilLockRef::SignalLength, JBB); + } + queue.release(); + c_lockQueues.release(lockQPtr); + + // Send Destroy conf + UtilDestroyLockConf* conf=(UtilDestroyLockConf*)signal->getDataPtrSend(); + conf->senderData = req.senderData; + conf->senderRef = reference(); + conf->lockId = req.lockId; + sendSignal(req.senderRef, GSN_UTIL_DESTROY_LOCK_CONF, signal, + UtilDestroyLockConf::SignalLength, JBB); + return; + } while(false); + + UtilDestroyLockRef * ref = (UtilDestroyLockRef*)signal->getDataPtrSend(); + ref->senderData = req.senderData; + ref->senderRef = reference(); + ref->lockId = req.lockId; + ref->errorCode = err; + sendSignal(req.senderRef, GSN_UTIL_DESTROY_LOCK_REF, signal, + UtilDestroyLockRef::SignalLength, JBB); +} diff --git a/ndb/src/kernel/blocks/dbutil/DbUtil.hpp b/ndb/src/kernel/blocks/dbutil/DbUtil.hpp new file mode 100644 index 00000000000..8ab2fe8d8d0 --- /dev/null +++ b/ndb/src/kernel/blocks/dbutil/DbUtil.hpp @@ -0,0 +1,484 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef DBUTIL_H +#define DBUTIL_H + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#define UTIL_WORDS_PER_PAGE 8191 + +/** + * @class DbUtil + * @brief Database utilities + * + * This block implements transactional services which can be used by other + * blocks. + * + * @section secSequence Module: The Sequence Service + * + * A sequence is a varaible stored in the database. Each time it is + * requested with "NextVal" it returns a unique number. If requested + * with "CurrVal" it returns the current number. + * + * - Request: SEQUENCE_REQ + * Requests the 'NextVal' or 'CurrVal' for sequence variable 'sequenceId'. + * + * - Response: SEQUENCE_CONF / REF (if failure) + * Returns value requested. + */ +class DbUtil : public SimulatedBlock +{ +public: + DbUtil(const class Configuration & conf); + virtual ~DbUtil(); + BLOCK_DEFINES(DbUtil); + +protected: + /** + * Startup & Misc + */ + void execSTTOR(Signal* signal); + void execNDB_STTOR(Signal* signal); + void execDUMP_STATE_ORD(Signal* signal); + void execCONTINUEB(Signal* signal); + + /** + * Sequence Service : Public interface + */ + void execUTIL_SEQUENCE_REQ(Signal* signal); + void execUTIL_SEQUENCE_REF(Signal* signal); + void execUTIL_SEQUENCE_CONF(Signal* signal); + + /** + * Prepare Service : Public interface + */ + void execUTIL_PREPARE_REQ(Signal* signal); + void execUTIL_PREPARE_CONF(Signal* signal); + void execUTIL_PREPARE_REF(Signal* signal); + + /** + * Delete Service : Public interface + */ + void execUTIL_DELETE_REQ(Signal* signal); + void execUTIL_DELETE_REF(Signal* signal); + void execUTIL_DELETE_CONF(Signal* signal); + + /** + * Execute Service : Public interface + */ + void execUTIL_EXECUTE_REQ(Signal* signal); + void execUTIL_EXECUTE_REF(Signal* signal); + void execUTIL_EXECUTE_CONF(Signal* signal); + + /** + * Prepare Release Service : Public interface + */ + void execUTIL_RELEASE_REQ(Signal* signal); + void execUTIL_RELEASE_CONF(Signal* signal); + void execUTIL_RELEASE_REF(Signal* signal); + + /** + * Backend interface to a used TC service + */ + void execTCSEIZECONF(Signal* signal); + void execTCKEYCONF(Signal* signal); + void execTCKEYREF(Signal* signal); + void execTCROLLBACKREP(Signal* signal); + void execTCKEY_FAILCONF(Signal* signal); + void execTCKEY_FAILREF(Signal* signal); + void execTRANSID_AI(Signal* signal); + + /** + * Backend interface to a used DICT service + */ + void execGET_TABINFOREF(Signal*); + void execGET_TABINFO_CONF(Signal* signal); + +private: + +public: + struct PreparedOperation; + + typedef DataBuffer<11> KeyInfoBuffer; + typedef KeyInfoBuffer::ConstDataBufferIterator KeyInfoIterator; + typedef DataBuffer<11> AttrInfoBuffer; + typedef AttrInfoBuffer::ConstDataBufferIterator AttrInfoIterator; + typedef DataBuffer<11> ResultSetBuffer; + typedef DataBuffer<11> ResultSetInfoBuffer; + typedef DataBuffer<1> AttrMappingBuffer; + + /** + * @struct Page32 + * @brief For storing SimpleProperties objects and similar temporary data + */ + struct Page32 { + Uint32 data[UTIL_WORDS_PER_PAGE]; + Uint32 nextPool; // Note: This used as data when seized + }; + + /** + * @struct Prepare + * @brief Info regarding prepare request (contains a prepared operation) + * + * The prepare phase interprets the table and attribute names sent + * in the prepare request from the client and asks DICT for meta + * information. + */ + struct Prepare { + Prepare(ArrayPool & ap) : preparePages(ap) {} + + /*** Client info ***/ + Uint32 clientRef; + Uint32 clientData; + + /** + * SimpleProp sent in UTIL_PREPARE_REQ + * + * Example format: + * - UtilPrepareReq::NoOfOperations=1 + * - UtilPrepareReq::OperationType=UtilPrepareReq::Delete + * - UtilPrepareReq::TableName="SYSTAB_0" + * - UtilPrepareReq::AttributeName="SYSKEY_0" + */ + Uint32 prepDataLen; + Array preparePages; + + /*** PreparedOperation constructed in Prepare phase ***/ + Ptr prepOpPtr; + + union { + Uint32 nextPool; + Uint32 nextList; + }; + Uint32 prevList; + + void print() const { + ndbout << "[-Prepare-" << endl + << " clientRef: " << clientRef + << ", clientData: " << clientData + << "]" << endl; + } + }; + + /** + * @struct PreparedOperation + * @brief Contains instantiated TcKeyReq signaldata for operation + * + * The prepare phase is finished by storing the request in a + * PreparedOperation record. + */ + struct PreparedOperation { + PreparedOperation(AttrMappingBuffer::DataBufferPool & am, + AttrInfoBuffer::DataBufferPool & ai, + ResultSetInfoBuffer::DataBufferPool & rs) : + releaseFlag(false), attrMapping(am), attrInfo(ai), rsInfo(rs) + { + pkBitmask.clear(); + } + + /*** Various Operation Info ***/ + Uint32 keyLen; // Length of primary key (fixed size is assumed) + Uint32 rsLen; // Size of result set + Uint32 noOfKeyAttr; // Number of key attributes + Uint32 noOfAttr; // Number of attributes + bool releaseFlag; // flag if operation release after completion + + /** + * Attribute Mapping + * + * This datastructure (buffer of AttributeHeader:s) are used to map + * each execute request to a TCKEYREQ train of signals. + * + * The datastructure contains (AttributeId, Position) pairs, where + * - AttributeId is id used in database, and + * - Position is position of attribute value in TCKEYREQ keyinfo + * part of the train of signals which will be send to TC. + * Position == 0x3fff means it should *not* be sent + * in keyinfo part. + */ + AttrMappingBuffer attrMapping; + + /*** First signal in tckeyreq train ***/ + Uint32 tckeyLenInBytes; // TcKeyReq total signal length (in bytes) + Uint32 keyDataPos; // Where to store keydata[] in tckey signal + // (in #words from base in tckey signal) + TcKeyReq tckey; // Signaldata for first signal in train + + /*** Attrinfo signals sent to TC (part of tckeyreq train) ***/ + AttrInfoBuffer attrInfo; + + /*** Result of executed operation ***/ + ResultSetInfoBuffer rsInfo; + + Bitmask pkBitmask; + + union { + Uint32 nextPool; + Uint32 nextList; + }; + Uint32 prevList; + + void print() const { + ndbout << "[-PreparedOperation-" << endl + << " keyLen: " << keyLen + << ", rsLen: " << rsLen + << ", noOfKeyAttr: " << noOfKeyAttr + << ", noOfAttr: " << noOfAttr + << ", tckeyLenInBytes: " << tckeyLenInBytes + << ", keyDataPos: " << keyDataPos << endl + << "-AttrMapping- (AttrId, KeyPos)-pairs " + << "(Pos=3fff if non-key attr):" << endl; + attrMapping.print(stdout); + ndbout << "[-tckey- "; + printTCKEYREQ(stdout, (Uint32*)&tckey, 8, 0); + ndbout << "[-attrInfo- "; + attrInfo.print(stdout); + ndbout << "[-rsInfo- "; + rsInfo.print(stdout); + ndbout << "]]]]" << endl; + } + }; + + /** + * @struct Operation + * @brief Used in execution (contains resultset and buffers for result) + */ + struct Operation { + Operation(KeyInfoBuffer::DataBufferPool & ki, + AttrInfoBuffer::DataBufferPool & ai, + ResultSetBuffer::DataBufferPool & _rs) : + prepOp_i(RNIL), keyInfo(ki), attrInfo(ai), rs(_rs) {} + + PreparedOperation * prepOp; + Uint32 prepOp_i; + KeyInfoBuffer keyInfo; + AttrInfoBuffer attrInfo; + ResultSetBuffer rs; + ResultSetBuffer::DataBufferIterator rsIterator; + + Uint32 transPtrI; + + Uint32 rsRecv; + Uint32 rsExpect; + inline bool complete() const { return rsRecv == rsExpect; } + + union { + Uint32 nextPool; + Uint32 nextList; + }; + + void print() const { + ndbout << "[-Operation-" << endl + << " transPtrI: " << transPtrI + << ", rsRecv: " << rsRecv; + ndbout << "[-PreparedOperation-" << endl; + prepOp->print(); + ndbout << "[-keyInfo-" << endl; + keyInfo.print(stdout); + ndbout << "[-attrInfo-" << endl; + attrInfo.print(stdout); + ndbout << "]]" << endl; + } + }; + + /** + * @struct Transaction + * @brief Used in execution (contains list of operations) + */ + struct Transaction { + Transaction(ArrayPool & ap, ArrayPool & op) : + executePages(ap), operations(op) {} + + Uint32 clientRef; + Uint32 clientData; + Array executePages; + + Uint32 gsn; // Request type (SEQUENCE, DELETE, etc) + union { + /** + * Sequence transaction + */ + struct { + Uint32 sequenceId; + Uint32 requestType; + } sequence; + }; + + Uint32 connectPtr; + Uint32 transId[2]; + SLList operations; + + Uint32 errorCode; + Uint32 sent; // No of operations sent + Uint32 recv; // No of completed operations received + inline bool complete() const { return sent == recv; }; + + union { + Uint32 nextPool; + Uint32 nextList; + }; + Uint32 prevList; + + void print() const { + ndbout << "[-Transaction-" << endl + << " clientRef: " << clientRef + << ", clientData: " << clientData + << ", gsn: " << gsn + << ", errorCode: " << errorCode + << endl + << " sent: " << sent << " operations" + << ", recv: " << recv << " completed operations"; + OperationPtr opPtr; + this->operations.first(opPtr); + while(opPtr.i != RNIL){ + ndbout << "[-Operation-" << endl; + opPtr.p->print(); + this->operations.next(opPtr); + } + ndbout << "]" << endl; + } + }; + + typedef Ptr Page32Ptr; + typedef Ptr PreparePtr; + typedef Ptr TransactionPtr; + typedef Ptr OperationPtr; + typedef Ptr PreparedOperationPtr; + + Uint32 c_transId[2]; + ArrayPool c_pagePool; + ArrayPool c_preparePool; + ArrayPool c_operationPool; + ArrayPool c_preparedOperationPool; + ArrayPool c_transactionPool; + + DataBuffer<1>::DataBufferPool c_attrMappingPool; + DataBuffer<11>::DataBufferPool c_dataBufPool; + DLList c_runningPrepares; + DLList c_runningPreparedOperations; + DLList c_seizingTransactions; // Being seized at TC + DLList c_runningTransactions; // Seized and now exec. + + void getTransId(Transaction *); + void initResultSet(ResultSetBuffer &, const ResultSetInfoBuffer &); + void runTransaction(Signal* signal, TransactionPtr); + void runOperation(Signal* signal, TransactionPtr &, OperationPtr &, Uint32); + void sendKeyInfo(Signal* signal, + KeyInfo* keyInfo, + const KeyInfoBuffer & keyBuf, + KeyInfoIterator & kit); + void sendAttrInfo(Signal*, + AttrInfo* attrInfo, + const AttrInfoBuffer & attrInfo, + AttrInfoIterator & ait); + int getResultSet(Signal* signal, const Transaction * transP, + struct LinearSectionPtr sectionsPtr[]); + void finishTransaction(Signal*, TransactionPtr); + void releaseTransaction(TransactionPtr transPtr); + void hardcodedPrepare(); + void connectTc(Signal* signal); + void reportSequence(Signal*, const Transaction *); + void readPrepareProps(Signal* signal, + SimpleProperties::Reader* reader, + Uint32 senderData); + void prepareOperation(Signal*, PreparePtr); + void sendUtilPrepareRef(Signal*, UtilPrepareRef::ErrorCode, Uint32, Uint32); + void sendUtilExecuteRef(Signal*, UtilExecuteRef::ErrorCode, + Uint32, Uint32, Uint32); + void releasePrepare(PreparePtr); + void releasePreparedOperation(PreparedOperationPtr); + + /*************************************************************************** + * Lock manager + */ + struct LockQueueElement { + Uint32 m_senderData; + Uint32 m_senderRef; + union { + Uint32 nextPool; + Uint32 nextList; + }; + Uint32 prevList; + }; + typedef Ptr LockQueueElementPtr; + + struct LockQueue { + LockQueue(){} + LockQueue(Uint32 id) : m_queue() { m_lockId = id; m_lockKey = 0;} + union { + Uint32 m_lockId; + Uint32 key; + }; + Uint32 m_lockKey; + DLFifoList::Head m_queue; + union { + Uint32 nextHash; + Uint32 nextPool; + }; + Uint32 prevHash; + + Uint32 hashValue() const { + return m_lockId; + } + bool equal(const LockQueue & rec) const { + return m_lockId == rec.m_lockId; + } + }; + typedef Ptr LockQueuePtr; + + + ArrayPool c_lockQueuePool; + ArrayPool c_lockElementPool; + KeyTable c_lockQueues; + + void execUTIL_CREATE_LOCK_REQ(Signal* signal); + void execUTIL_DESTORY_LOCK_REQ(Signal* signal); + void execUTIL_LOCK_REQ(Signal* signal); + void execUTIL_UNLOCK_REQ(Signal* signal); + + void sendLOCK_REF(Signal*, const UtilLockReq * req, UtilLockRef::ErrorCode); + void sendLOCK_CONF(Signal*, LockQueue *, LockQueueElement *); + + void sendUNLOCK_REF(Signal*, const UtilUnlockReq*, UtilUnlockRef::ErrorCode); + void sendUNLOCK_CONF(Signal*, LockQueue *, LockQueueElement *); + + // For testing of mutex:es + void mutex_created(Signal* signal, Uint32 mutexId, Uint32 retVal); + void mutex_destroyed(Signal* signal, Uint32 mutexId, Uint32 retVal); + void mutex_locked(Signal* signal, Uint32 mutexId, Uint32 retVal); + void mutex_unlocked(Signal* signal, Uint32 mutexId, Uint32 retVal); +}; + +#endif diff --git a/ndb/src/kernel/blocks/dbutil/DbUtil.txt b/ndb/src/kernel/blocks/dbutil/DbUtil.txt new file mode 100644 index 00000000000..cc8c1985009 --- /dev/null +++ b/ndb/src/kernel/blocks/dbutil/DbUtil.txt @@ -0,0 +1,68 @@ +UTIL Protocols +-------------- +Transactions are executed in two phases: +1) PREPARE +2) EXECUTE + + +PREPARE PHASE +------------- +1) ** REQUEST ** + Client (any block) requests prepare service from Util: + + Client --UTIL_PREPARE_REQ--> Util + ... + Client --UTIL_PREPARE_REQ--> Util + +2) ** DICTINFO ** + Util requests Dict for information about table: + + Util --GET_TABINFOREQ--> Dict + + Util <--DICTTABINFO-- Dict + ... + Util <--DICTTABINFO-- Dict + +3) ** PREPARE ** + Operation (= transaction) is prepared (DbUtil::prepareOperation) + + a) AttrMapping is created (a map used to read of the + actual execute request attribute values and put them in KEYINFO) + + b) TC Signal train is prepared + +4) ** CONFIRM ** + Request is confirmed + + Client <--UTIL_PREPARE_CONF-- Util + + +EXECUTE PHASE +------------- +1) Client (any block) requests execute service from Util: + (Execute can be INSERT, DELETE,...) + + Client --UTIL_EXECUTE_REQ--> Util (Multi-signals not yet implemented) + ... + Client --UTIL_EXECUTE_REQ--> Util + +2) Util --TCKEYREQ--> tc + + Util --KEYINFO--> tc (sometimes) (Not yet implemented) + ... + Util --KEYINFO--> tc + + Util --ATTRINFO--> tc (sometimes) + ... + Util --ATTRINFO--> tc + +3) Util <--TCKEYCONF-- tc + + Util --TC_COMMIT_ACK-->tc (sometimes) + + (in parallel with) + + Util <--TRANSID_AI-- tc (sometimes) + ... + Util <--TRANSID_AI-- tc + diff --git a/ndb/src/kernel/blocks/dbutil/Makefile b/ndb/src/kernel/blocks/dbutil/Makefile new file mode 100644 index 00000000000..54b7326e4e5 --- /dev/null +++ b/ndb/src/kernel/blocks/dbutil/Makefile @@ -0,0 +1,8 @@ +include .defs.mk + +TYPE := kernel + +ARCHIVE_TARGET := dbutil +SOURCES = DbUtil.cpp + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/kernel/blocks/grep/Grep.cpp b/ndb/src/kernel/blocks/grep/Grep.cpp new file mode 100644 index 00000000000..093e9a225e6 --- /dev/null +++ b/ndb/src/kernel/blocks/grep/Grep.cpp @@ -0,0 +1,2001 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Grep.hpp" +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define CONTINUEB_DELAY 500 +#define SSREPBLOCKNO 2 +#define PSREPBLOCKNO 2 + +//#define DEBUG_GREP +//#define DEBUG_GREP_SUBSCRIPTION +//#define DEBUG_GREP_TRANSFER +//#define DEBUG_GREP_APPLY +//#define DEBUG_GREP_DELETE + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: STARTUP of GREP Block, etc + * ------------------------------------------------------------------------ + **************************************************************************/ +static Uint32 g_TypeOfStart = NodeState::ST_ILLEGAL_TYPE; +void +Grep::getNodeGroupMembers(Signal* signal) { + jam(); + /** + * Ask DIH for nodeGroupMembers + */ + CheckNodeGroups * sd = (CheckNodeGroups*)signal->getDataPtrSend(); + sd->blockRef = reference(); + sd->requestType = + CheckNodeGroups::Direct | + CheckNodeGroups::GetNodeGroupMembers; + sd->nodeId = getOwnNodeId(); + EXECUTE_DIRECT(DBDIH, GSN_CHECKNODEGROUPSREQ, signal, + CheckNodeGroups::SignalLength); + jamEntry(); + + c_nodeGroup = sd->output; + c_noNodesInGroup = 0; + for (int i = 0; i < MAX_NDB_NODES; i++) { + if (sd->mask.get(i)) { + if (i == getOwnNodeId()) c_idInNodeGroup = c_noNodesInGroup; + c_nodesInGroup[c_noNodesInGroup] = i; + c_noNodesInGroup++; + } + } + ndbrequire(c_noNodesInGroup >= 0); // at least 1 node in the nodegroup + +#ifdef NODEFAIL_DEBUG + for (Uint32 i = 0; i < c_noNodesInGroup; i++) { + ndbout_c ("Grep: NodeGroup %u, me %u, me in group %u, member[%u] %u", + c_nodeGroup, getOwnNodeId(), c_idInNodeGroup, + i, c_nodesInGroup[i]); + } +#endif +} + + +void +Grep::execSTTOR(Signal* signal) +{ + jamEntry(); + const Uint32 startphase = signal->theData[1]; + const Uint32 typeOfStart = signal->theData[7]; + if (startphase == 3) + { + jam(); + signal->theData[0] = reference(); + g_TypeOfStart = typeOfStart; + sendSignal(NDBCNTR_REF, GSN_READ_NODESREQ, signal, 1, JBB); + return; + } + if(startphase == 5) { + jam(); + /** + * we don't want any log/meta records comming to use + * until we are done with the recovery. + */ + if (g_TypeOfStart == NodeState::ST_NODE_RESTART) { + jam(); + pspart.m_recoveryMode = true; + getNodeGroupMembers(signal); + for (Uint32 i = 0; i < c_noNodesInGroup; i++) { + Uint32 ref =numberToRef(GREP, c_nodesInGroup[i]); + if (ref != reference()) + sendSignal(ref, GSN_GREP_START_ME, signal, + 1 /*SumaStartMe::SignalLength*/, JBB); + } + } else pspart.m_recoveryMode = false; + + } + + if(startphase == 7) { + jam(); + if (g_TypeOfStart == NodeState::ST_NODE_RESTART) { + pspart.m_recoveryMode = false; + } + } + + sendSTTORRY(signal); +} + + +void +Grep::PSPart::execSTART_ME(Signal* signal) +{ + jamEntry(); + GrepStartMe * me =(GrepStartMe*)signal->getDataPtr(); + BlockReference ref = me->senderRef; + GrepAddSubReq* const addReq = (GrepAddSubReq *)signal->getDataPtr(); + + + SubscriptionPtr subPtr; + c_subscriptions.first(c_subPtr); + for(; !c_subPtr.isNull(); c_subscriptions.next(c_subPtr)) { + jam(); + subPtr.i = c_subPtr.curr.i; + subPtr.p = c_subscriptions.getPtr(subPtr.i); + addReq->subscriptionId = subPtr.p->m_subscriptionId; + addReq->subscriptionKey = subPtr.p->m_subscriptionKey; + addReq->subscriberData = subPtr.p->m_subscriberData; + addReq->subscriptionType = subPtr.p->m_subscriptionType; + addReq->senderRef = subPtr.p->m_coordinatorRef; + addReq->subscriberRef =subPtr.p->m_subscriberRef; + + sendSignal(ref, + GSN_GREP_ADD_SUB_REQ, + signal, + GrepAddSubReq::SignalLength, + JBB); + } + + addReq->subscriptionId = 0; + addReq->subscriptionKey = 0; + addReq->subscriberData = 0; + addReq->subscriptionType = 0; + addReq->senderRef = 0; + addReq->subscriberRef = 0; + + sendSignal(ref, + GSN_GREP_ADD_SUB_REQ, + signal, + GrepAddSubReq::SignalLength, + JBB); +} + +void +Grep::PSPart::execGREP_ADD_SUB_REQ(Signal* signal) +{ + jamEntry(); + GrepAddSubReq * const grepReq = (GrepAddSubReq *)signal->getDataPtr(); + const Uint32 subId = grepReq->subscriptionId; + const Uint32 subKey = grepReq->subscriptionKey; + const Uint32 subData = grepReq->subscriberData; + const Uint32 subType = grepReq->subscriptionType; + const Uint32 coordinatorRef = grepReq->senderRef; + + /** + * this is ref to the REP node for this subscription. + */ + const Uint32 subRef = grepReq->subscriberRef; + + if(subId!=0 && subKey!=0) { + jam(); + SubscriptionPtr subPtr; + ndbrequire( c_subscriptionPool.seize(subPtr)); + subPtr.p->m_coordinatorRef = coordinatorRef; + subPtr.p->m_subscriptionId = subId; + subPtr.p->m_subscriptionKey = subKey; + subPtr.p->m_subscriberRef = subRef; + subPtr.p->m_subscriberData = subData; + subPtr.p->m_subscriptionType = subType; + + c_subscriptions.add(subPtr); + } + else { + jam(); + GrepAddSubConf * conf = (GrepAddSubConf *)grepReq; + conf->noOfSub = + c_subscriptionPool.getSize()-c_subscriptionPool.getNoOfFree(); + sendSignal(signal->getSendersBlockRef(), + GSN_GREP_ADD_SUB_CONF, + signal, + GrepAddSubConf::SignalLength, + JBB); + } +} + +void +Grep::PSPart::execGREP_ADD_SUB_REF(Signal* signal) +{ + /** + * @todo fix error stuff + */ +} + +void +Grep::PSPart::execGREP_ADD_SUB_CONF(Signal* signal) +{ + jamEntry(); + GrepAddSubConf* const conf = (GrepAddSubConf *)signal->getDataPtr(); + Uint32 noOfSubscriptions = conf->noOfSub; + Uint32 noOfRestoredSubscriptions = + c_subscriptionPool.getSize()-c_subscriptionPool.getNoOfFree(); + if(noOfSubscriptions!=noOfRestoredSubscriptions) { + jam(); + /** + *@todo send ref signal + */ + ndbrequire(false); + } +} + +void +Grep::execREAD_NODESCONF(Signal* signal) +{ + jamEntry(); + ReadNodesConf * conf = (ReadNodesConf *)signal->getDataPtr(); + +#if 0 + ndbout_c("Grep: Recd READ_NODESCONF"); +#endif + + /****************************** + * Check which REP nodes exist + ******************************/ + for (Uint32 i = 1; i < MAX_NODES; i++) + { + jam(); +#if 0 + ndbout_c("Grep: Found node %d of type %d", i, getNodeInfo(i).getType()); +#endif + if (getNodeInfo(i).getType() == NodeInfo::REP) + { + jam(); + /** + * @todo This should work for more than ONE rep node! + */ + pscoord.m_repRef = numberToRef(PSREPBLOCKNO, i); + pspart.m_repRef = numberToRef(PSREPBLOCKNO, i); +#if 0 + ndbout_c("Grep: REP node %d detected", i); +#endif + } + } + + /***************************** + * Check which DB nodes exist + *****************************/ + m_aliveNodes.clear(); + + Uint32 count = 0; + for(Uint32 i = 0; iallNodes, i)) + { + jam(); + count++; + + NodePtr node; + ndbrequire(m_nodes.seize(node)); + + node.p->nodeId = i; + if (NodeBitmask::get(conf->inactiveNodes, i)) + { + node.p->alive = 0; + } + else + { + node.p->alive = 1; + m_aliveNodes.set(i); + } + } + } + m_masterNodeId = conf->masterNodeId; + ndbrequire(count == conf->noOfNodes); + sendSTTORRY(signal); +} + +void +Grep::sendSTTORRY(Signal* signal) +{ + signal->theData[0] = 0; + signal->theData[3] = 1; + signal->theData[4] = 3; + signal->theData[5] = 5; + signal->theData[6] = 7; + signal->theData[7] = 255; // No more start phases from missra + sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 8, JBB); +} + +void +Grep::execNDB_STTOR(Signal* signal) +{ + jamEntry(); +} + +void +Grep::execDUMP_STATE_ORD(Signal* signal) +{ + jamEntry(); + //Uint32 tCase = signal->theData[0]; + +#if 0 + if(sscoord.m_repRef == 0) + { + ndbout << "Grep: Recd DUMP signal but has no connection with REP node" + << endl; + return; + } +#endif + + /* + switch (tCase) + { + case 8100: sscoord.grepReq(signal, GrepReq::START_SUBSCR); break; + case 8102: sscoord.grepReq(signal, GrepReq::START_METALOG); break; + case 8104: sscoord.grepReq(signal, GrepReq::START_METASCAN); break; + case 8106: sscoord.grepReq(signal, GrepReq::START_DATALOG); break; + case 8108: sscoord.grepReq(signal, GrepReq::START_DATASCAN); break; + case 8110: sscoord.grepReq(signal, GrepReq::STOP_SUBSCR); break; + case 8500: sscoord.grepReq(signal, GrepReq::REMOVE_BUFFERS); break; + case 8300: sscoord.grepReq(signal, GrepReq::SLOWSTOP); break; + case 8400: sscoord.grepReq(signal, GrepReq::FASTSTOP); break; + case 8600: sscoord.grepReq(signal, GrepReq::CREATE_SUBSCR); break; + case 8700: sscoord.dropTable(signal,(Uint32)signal->theData[1]);break; + default: break; + } + */ +} + +/** + * Signal received when REP node has failed + */ +void +Grep::execAPI_FAILREQ(Signal* signal) +{ + jamEntry(); + //Uint32 failedApiNode = signal->theData[0]; + //BlockReference retRef = signal->theData[1]; + + /** + * @todo We should probably do something smart if the + * PS REP node fails???? /Lars + */ + +#if 0 + ndbout_c("Grep: API_FAILREQ received for API node %d.", failedApiNode); +#endif + + /** + * @note This signal received is NOT allowed to send any CONF + * signal, since this would screw up TC/DICT to API + * "connections". + */ +} + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: GREP Control + * ------------------------------------------------------------------------ + **************************************************************************/ +void +Grep::execGREP_REQ(Signal* signal) +{ + jamEntry(); + + //GrepReq * req = (GrepReq *)signal->getDataPtr(); + + /** + * @todo Fix so that request is redirected to REP Server + * Obsolete? + * Was: sscoord.grepReq(signal, req->request); + */ + ndbout_c("Warning! REP commands can only be executed at REP SERVER prompt!"); +} + + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: NODE STATE HANDLING + * ------------------------------------------------------------------------ + **************************************************************************/ +void +Grep::execNODE_FAILREP(Signal* signal) +{ + jamEntry(); + NodeFailRep * rep = (NodeFailRep*)signal->getDataPtr(); + bool changed = false; + + NodePtr nodePtr; + for(m_nodes.first(nodePtr); nodePtr.i != RNIL; m_nodes.next(nodePtr)) + { + jam(); + if (NodeBitmask::get(rep->theNodes, nodePtr.p->nodeId)) + { + jam(); + + if (nodePtr.p->alive) + { + jam(); + ndbassert(m_aliveNodes.get(nodePtr.p->nodeId)); + changed = true; + } + else + { + ndbassert(!m_aliveNodes.get(nodePtr.p->nodeId)); + } + + nodePtr.p->alive = 0; + m_aliveNodes.clear(nodePtr.p->nodeId); + } + } + + + /** + * Problem: Fix a node failure running a protocol + * + * 1. Coordinator node of a protocol dies + * - Elect a new coordinator + * - send ref to user + * + * 2. Non-coordinator dies. + * - make coordinator aware of this + * so that coordinator does not wait for + * conf from faulty node + * - node recovery will restore the non-coordinator. + * + */ +} + +void +Grep::execINCL_NODEREQ(Signal* signal) +{ + jamEntry(); + + //const Uint32 senderRef = signal->theData[0]; + const Uint32 inclNode = signal->theData[1]; + + NodePtr node; + for(m_nodes.first(node); node.i != RNIL; m_nodes.next(node)) + { + jam(); + const Uint32 nodeId = node.p->nodeId; + if (inclNode == nodeId) { + jam(); + + ndbrequire(node.p->alive == 0); + ndbassert(!m_aliveNodes.get(nodeId)); + + node.p->alive = 1; + m_aliveNodes.set(nodeId); + + break; + } + } + + /** + * @todo: if we include this DIH's got to be prepared, later if needed... + */ +#if 0 + signal->theData[0] = reference(); + + sendSignal(senderRef, GSN_INCL_NODECONF, signal, 1, JBB); +#endif +} + + +/** + * Helper methods + */ +void +Grep::PSCoord::prepareOperationRec(SubCoordinatorPtr subPtr, + BlockReference subscriber, + Uint32 subId, + Uint32 subKey, + Uint32 request) +{ + subPtr.p->m_coordinatorRef = reference(); + subPtr.p->m_subscriberRef = subscriber; + subPtr.p->m_subscriberData = subPtr.i; + subPtr.p->m_subscriptionId = subId; + subPtr.p->m_subscriptionKey = subKey; + subPtr.p->m_outstandingRequest = request; +} + + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: CREATE SUBSCRIPTION ID + * ------------------------------------------------------------------------ + * + * Requests SUMA to create a unique subscription id + **************************************************************************/ + +void +Grep::PSCoord::execGREP_CREATE_SUBID_REQ(Signal* signal) +{ + jamEntry(); + + CreateSubscriptionIdReq * req = + (CreateSubscriptionIdReq*)signal->getDataPtr(); + BlockReference ref = signal->getSendersBlockRef(); + + SubCoordinatorPtr subPtr; + if( !c_subCoordinatorPool.seize(subPtr)) { + jam(); + SubCoordinator sub; + sub.m_subscriberRef = ref; + sub.m_subscriptionId = 0; + sub.m_subscriptionKey = 0; + sendRefToSS(signal, sub, GrepError::SUBSCRIPTION_ID_NOMEM ); + return; + } + prepareOperationRec(subPtr, + ref, + 0,0, + GSN_CREATE_SUBID_REQ); + + + ndbout_c("SUBID_REQ Ref %d",ref); + req->senderData=subPtr.p->m_subscriberData; + + sendSignal(SUMA_REF, GSN_CREATE_SUBID_REQ, signal, + SubCreateReq::SignalLength, JBB); + +#if 1 //def DEBUG_GREP_SUBSCRIPTION + ndbout_c("Grep::PSCoord: Sent CREATE_SUBID_REQ to SUMA"); +#endif +} + +void +Grep::PSCoord::execCREATE_SUBID_CONF(Signal* signal) +{ + jamEntry(); + CreateSubscriptionIdConf const * conf = + (CreateSubscriptionIdConf *)signal->getDataPtr(); + Uint32 subId = conf->subscriptionId; + Uint32 subKey = conf->subscriptionKey; + Uint32 subData = conf->subscriberData; + +#if 1 //def DEBUG_GREP_SUBSCRIPTION + ndbout_c("Grep::PSCoord: Recd GREP_SUBID_CONF (subId:%d, subKey:%d)", + subId, subKey); +#endif + + SubCoordinatorPtr subPtr; + c_subCoordinatorPool.getPtr(subPtr, subData); + BlockReference repRef = subPtr.p->m_subscriberRef; + + { // Check that id/key is unique + SubCoordinator key; + SubCoordinatorPtr tmp; + key.m_subscriptionId = subId; + key.m_subscriptionKey = subKey; + if(c_runningSubscriptions.find(tmp, key)){ + jam(); + SubCoordinator sub; + sub.m_subscriberRef=repRef; + sub.m_subscriptionId = subId; + sub.m_subscriptionKey = subKey; + sendRefToSS(signal,sub, GrepError::SUBSCRIPTION_ID_NOT_UNIQUE ); + return; + } + } + + sendSignal(subPtr.p->m_subscriberRef, GSN_GREP_CREATE_SUBID_CONF, signal, + CreateSubscriptionIdConf::SignalLength, JBB); + c_subCoordinatorPool.release(subData); + + m_grep->sendEventRep(signal, + EventReport::GrepSubscriptionInfo, + GrepEvent::GrepPS_CreateSubIdConf, + subId, + subKey, + (Uint32)GrepError::NO_ERROR); +} + +void +Grep::PSCoord::execCREATE_SUBID_REF(Signal* signal) { + jamEntry(); + CreateSubscriptionIdRef const * ref = + (CreateSubscriptionIdRef *)signal->getDataPtr(); + Uint32 subData = ref->subscriberData; + GrepError::Code err; + + Uint32 sendersBlockRef = signal->getSendersBlockRef(); + if(sendersBlockRef == SUMA_REF) + { + jam(); + err = GrepError::SUBSCRIPTION_ID_SUMA_FAILED_CREATE; + } + + SubCoordinatorPtr subPtr; + c_runningSubscriptions.getPtr(subPtr, subData); + BlockReference repref = subPtr.p->m_subscriberRef; + + SubCoordinator sub; + sub.m_subscriberRef = repref; + sub.m_subscriptionId = 0; + sub.m_subscriptionKey = 0; + sendRefToSS(signal,sub, err); + +} + + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: CREATE SUBSCRIPTION + * ------------------------------------------------------------------------ + * + * Creates a subscription for every GREP to its local SUMA. + * GREP node that executes createSubscription becomes the GREP Coord. + **************************************************************************/ + +/** + * Request to create a subscription (sent from SS) + */ +void +Grep::PSCoord::execGREP_SUB_CREATE_REQ(Signal* signal) +{ + jamEntry(); + GrepSubCreateReq const * grepReq = (GrepSubCreateReq *)signal->getDataPtr(); + Uint32 subId = grepReq->subscriptionId; + Uint32 subKey = grepReq->subscriptionKey; + Uint32 subType = grepReq->subscriptionType; + BlockReference rep = signal->getSendersBlockRef(); + + GrepCreateReq * req =(GrepCreateReq*)grepReq; + + SubCoordinatorPtr subPtr; + + if( !c_subCoordinatorPool.seize(subPtr)) { + jam(); + SubCoordinator sub; + sub.m_subscriberRef = rep; + sub.m_subscriptionId = 0; + sub.m_subscriptionKey = 0; + sub.m_outstandingRequest = GSN_GREP_CREATE_REQ; + sendRefToSS(signal, sub, GrepError::NOSPACE_IN_POOL); + return; + } + prepareOperationRec(subPtr, + numberToRef(PSREPBLOCKNO, refToNode(rep)), subId, subKey, + GSN_GREP_CREATE_REQ); + + /* Get the payload of the signal. + */ + SegmentedSectionPtr selectedTablesPtr; + if(subType == SubCreateReq::SelectiveTableSnapshot) { + jam(); + ndbrequire(signal->getNoOfSections()==1); + signal->getSection(selectedTablesPtr,0); + signal->header.m_noOfSections = 0; + } + /** + * Prepare the signal to be sent to Grep participatns + */ + subPtr.p->m_subscriptionType = subType; + req->senderRef = reference(); + req->subscriberRef = numberToRef(PSREPBLOCKNO, refToNode(rep)); + req->subscriberData = subPtr.p->m_subscriberData; + req->subscriptionId = subId; + req->subscriptionKey = subKey; + req->subscriptionType = subType; + + /*add payload if it is a selectivetablesnap*/ + if(subType == SubCreateReq::SelectiveTableSnapshot) { + jam(); + signal->setSection(selectedTablesPtr, 0); + } + + /****************************** + * Send to all PS participants + ******************************/ + NodeReceiverGroup rg(GREP, m_grep->m_aliveNodes); + subPtr.p->m_outstandingParticipants = rg; + sendSignal(rg, + GSN_GREP_CREATE_REQ, signal, + GrepCreateReq::SignalLength, JBB); + + +#ifdef DEBUG_GREP_SUBSCRIPTION + ndbout_c("Grep::PSCoord: Sent GREP_CREATE_REQ " + "(subId:%d, subKey:%d, subData:%d, subType:%d) to parts", + subId, subKey, subPtr.p->m_subscriberData, subType); +#endif +} + +void +Grep::PSPart::execGREP_CREATE_REQ(Signal* signal) +{ + jamEntry(); + GrepCreateReq * const grepReq = (GrepCreateReq *)signal->getDataPtr(); + const Uint32 subId = grepReq->subscriptionId; + const Uint32 subKey = grepReq->subscriptionKey; + const Uint32 subData = grepReq->subscriberData; + const Uint32 subType = grepReq->subscriptionType; + const Uint32 coordinatorRef = grepReq->senderRef; + const Uint32 subRef = grepReq->subscriberRef; //this is ref to the + //REP node for this + //subscription. + + SubscriptionPtr subPtr; + ndbrequire( c_subscriptionPool.seize(subPtr)); + subPtr.p->m_coordinatorRef = coordinatorRef; + subPtr.p->m_subscriptionId = subId; + subPtr.p->m_subscriptionKey = subKey; + subPtr.p->m_subscriberRef = subRef; + subPtr.p->m_subscriberData = subPtr.i; + subPtr.p->m_subscriptionType = subType; + subPtr.p->m_outstandingRequest = GSN_GREP_CREATE_REQ; + subPtr.p->m_operationPtrI = subData; + + c_subscriptions.add(subPtr); + + SegmentedSectionPtr selectedTablesPtr; + if(subType == SubCreateReq::SelectiveTableSnapshot) { + jam(); + ndbrequire(signal->getNoOfSections()==1); + signal->getSection(selectedTablesPtr,0);// SubCreateReq::TABLE_LIST); + signal->header.m_noOfSections = 0; + } + + /** + * Prepare signal to be sent to SUMA + */ + SubCreateReq * sumaReq = (SubCreateReq *)grepReq; + sumaReq->subscriberRef = GREP_REF; + sumaReq->subscriberData = subPtr.p->m_subscriberData; + sumaReq->subscriptionId = subPtr.p->m_subscriptionId; + sumaReq->subscriptionKey = subPtr.p->m_subscriptionKey; + sumaReq->subscriptionType = subPtr.p->m_subscriptionType; + /*add payload if it is a selectivetablesnap*/ + if(subType == SubCreateReq::SelectiveTableSnapshot) { + jam(); + signal->setSection(selectedTablesPtr, 0); + } + sendSignal(SUMA_REF, + GSN_SUB_CREATE_REQ, + signal, + SubCreateReq::SignalLength, + JBB); +} + +void +Grep::PSPart::execSUB_CREATE_CONF(Signal* signal) +{ + jamEntry(); + + SubCreateConf * const conf = (SubCreateConf *)signal->getDataPtr(); + Uint32 subData = conf->subscriberData; + + SubscriptionPtr subPtr; + c_subscriptions.getPtr(subPtr, subData); + /** + @todo check why this can fuck up -johan + + ndbrequire(subPtr.p->m_subscriptionId == conf->subscriptionId); + ndbrequire(subPtr.p->m_subscriptionKey == conf->subscriptionKey); + */ +#ifdef DEBUG_GREP_SUBSCRIPTION + ndbout_c("Grep::PSPart: Recd SUB_CREATE_CONF " + "(subId:%d, subKey:%d) from SUMA", + conf->subscriptionId, conf->subscriptionKey); +#endif + + /********************* + * Send conf to coord + *********************/ + GrepCreateConf * grepConf = (GrepCreateConf*)conf; + grepConf->senderNodeId = getOwnNodeId(); + grepConf->senderData = subPtr.p->m_operationPtrI; + sendSignal(subPtr.p->m_coordinatorRef, GSN_GREP_CREATE_CONF, signal, + GrepCreateConf::SignalLength, JBB); + subPtr.p->m_outstandingRequest = 0; +} + +/** + * Handle errors that either occured in: + * 1) PSPart + * or + * 2) propagated from local SUMA + */ +void +Grep::PSPart::execSUB_CREATE_REF(Signal* signal) +{ + jamEntry(); + SubCreateRef * const ref = (SubCreateRef *)signal->getDataPtr(); + Uint32 subData = ref->subscriberData; + GrepError::Code err = (GrepError::Code)ref->err; + SubscriptionPtr subPtr; + c_subscriptions.getPtr(subPtr, subData); + sendRefToPSCoord(signal, *subPtr.p, err /*error*/); + subPtr.p->m_outstandingRequest = 0; +} + +void +Grep::PSCoord::execGREP_CREATE_CONF(Signal* signal) +{ + jamEntry(); + GrepCreateConf const * conf = (GrepCreateConf *)signal->getDataPtr(); + Uint32 subData = conf->senderData; + Uint32 nodeId = conf->senderNodeId; + + SubCoordinatorPtr subPtr; + c_subCoordinatorPool.getPtr(subPtr, subData); + + ndbrequire(subPtr.p->m_outstandingRequest == GSN_GREP_CREATE_REQ); + + subPtr.p->m_outstandingParticipants.clearWaitingFor(nodeId); + + if(!subPtr.p->m_outstandingParticipants.done()) return; + /******************************** + * All participants have CONF:ed + ********************************/ + Uint32 subId = subPtr.p->m_subscriptionId; + Uint32 subKey = subPtr.p->m_subscriptionKey; + + GrepSubCreateConf * grepConf = (GrepSubCreateConf *)signal->getDataPtr(); + grepConf->subscriptionId = subId; + grepConf->subscriptionKey = subKey; + sendSignal(subPtr.p->m_subscriberRef, GSN_GREP_SUB_CREATE_CONF, signal, + GrepSubCreateConf::SignalLength, JBB); + + /** + * Send event report + */ + m_grep->sendEventRep(signal, + EventReport::GrepSubscriptionInfo, + GrepEvent::GrepPS_SubCreateConf, + subId, + subKey, + (Uint32)GrepError::NO_ERROR); + + c_subCoordinatorPool.release(subPtr); + +} + +/** + * Handle errors that either occured in: + * 1) PSCoord + * or + * 2) propagated from PSPart + */ +void +Grep::PSCoord::execGREP_CREATE_REF(Signal* signal) +{ + jamEntry(); + GrepCreateRef * const ref = (GrepCreateRef *)signal->getDataPtr(); + Uint32 subData = ref->senderData; + Uint32 err = ref->err; + SubCoordinatorPtr subPtr; + c_runningSubscriptions.getPtr(subPtr, subData); + + sendRefToSS(signal, *subPtr.p, (GrepError::Code)err /*error*/); +} + + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: START SUBSCRIPTION + * ------------------------------------------------------------------------ + * + * Starts a subscription at SUMA. + * Each participant starts its own subscription. + **************************************************************************/ + +/** + * Request to start subscription (Sent from SS) + */ +void +Grep::PSCoord::execGREP_SUB_START_REQ(Signal* signal) +{ + jamEntry(); + GrepSubStartReq * const subReq = (GrepSubStartReq *)signal->getDataPtr(); + SubscriptionData::Part part = (SubscriptionData::Part) subReq->part; + Uint32 subId = subReq->subscriptionId; + Uint32 subKey = subReq->subscriptionKey; + BlockReference rep = signal->getSendersBlockRef(); + + SubCoordinatorPtr subPtr; + + if(!c_subCoordinatorPool.seize(subPtr)) { + jam(); + SubCoordinator sub; + sub.m_subscriberRef = rep; + sub.m_subscriptionId = 0; + sub.m_subscriptionKey = 0; + sub.m_outstandingRequest = GSN_GREP_START_REQ; + sendRefToSS(signal, sub, GrepError::NOSPACE_IN_POOL); + return; + } + + prepareOperationRec(subPtr, + numberToRef(PSREPBLOCKNO, refToNode(rep)), + subId, subKey, + GSN_GREP_START_REQ); + + GrepStartReq * const req = (GrepStartReq *) subReq; + req->part = (Uint32) part; + req->subscriptionId = subPtr.p->m_subscriptionId; + req->subscriptionKey = subPtr.p->m_subscriptionKey; + req->senderData = subPtr.p->m_subscriberData; + + /*************************** + * Send to all participants + ***************************/ + NodeReceiverGroup rg(GREP, m_grep->m_aliveNodes); + subPtr.p->m_outstandingParticipants = rg; + sendSignal(rg, + GSN_GREP_START_REQ, + signal, + GrepStartReq::SignalLength, JBB); + +#ifdef DEBUG_GREP_SUBSCRIPTION + ndbout_c("Grep::PSCoord: Sent GREP_START_REQ " + "(subId:%d, subKey:%d, senderData:%d, part:%d) to all participants", + req->subscriptionId, req->subscriptionKey, req->senderData, part); +#endif +} + + +void +Grep::PSPart::execGREP_START_REQ(Signal* signal) +{ + jamEntry(); + GrepStartReq * const grepReq = (GrepStartReq *) signal->getDataPtr(); + SubscriptionData::Part part = (SubscriptionData::Part)grepReq->part; + Uint32 subId = grepReq->subscriptionId; + Uint32 subKey = grepReq->subscriptionKey; + Uint32 operationPtrI = grepReq->senderData; + + Subscription key; + key.m_subscriptionId = subId; + key.m_subscriptionKey = subKey; + SubscriptionPtr subPtr; + ndbrequire(c_subscriptions.find(subPtr, key));; + subPtr.p->m_outstandingRequest = GSN_GREP_START_REQ; + subPtr.p->m_operationPtrI = operationPtrI; + /** + * send SUB_START_REQ to local SUMA + */ + SubStartReq * sumaReq = (SubStartReq *) grepReq; + sumaReq->subscriptionId = subId; + sumaReq->subscriptionKey = subKey; + sumaReq->subscriberData = subPtr.i; + sumaReq->part = (Uint32) part; + + sendSignal(SUMA_REF, GSN_SUB_START_REQ, signal, + SubStartReq::SignalLength, JBB); +#ifdef DEBUG_GREP_SUBSCRIPTION + ndbout_c("Grep::PSPart: Sent SUB_START_REQ (subId:%d, subKey:%d, part:%d)", + subId, subKey, (Uint32)part); +#endif +} + + +void +Grep::PSPart::execSUB_START_CONF(Signal* signal) +{ + jamEntry(); + + SubStartConf * const conf = (SubStartConf *) signal->getDataPtr(); + SubscriptionData::Part part = (SubscriptionData::Part)conf->part; + Uint32 subId = conf->subscriptionId; + Uint32 subKey = conf->subscriptionKey; + Uint32 subData = conf->subscriberData; + Uint32 firstGCI = conf->firstGCI; +#ifdef DEBUG_GREP_SUBSCRIPTION + ndbout_c("Grep::PSPart: Recd SUB_START_CONF " + "(subId:%d, subKey:%d, subData:%d)", + subId, subKey, subData); +#endif + + SubscriptionPtr subPtr; + c_subscriptions.getPtr(subPtr, subData); + ndbrequire(subPtr.p->m_subscriptionId == subId); + ndbrequire(subPtr.p->m_subscriptionKey == subKey); + + GrepStartConf * grepConf = (GrepStartConf *)conf; + grepConf->senderData = subPtr.p->m_operationPtrI; + grepConf->part = (Uint32) part; + grepConf->subscriptionKey = subKey; + grepConf->subscriptionId = subId; + grepConf->firstGCI = firstGCI; + grepConf->senderNodeId = getOwnNodeId(); + sendSignal(subPtr.p->m_coordinatorRef, GSN_GREP_START_CONF, signal, + GrepStartConf::SignalLength, JBB); + subPtr.p->m_outstandingRequest = 0; + +#ifdef DEBUG_GREP_SUBSCRIPTION + ndbout_c("Grep::PSPart: Sent GREP_START_CONF " + "(subId:%d, subKey:%d, subData:%d, part:%d)", + subId, subKey, subData, part); +#endif +} + + +/** + * Handle errors that either occured in: + * 1) PSPart + * or + * 2) propagated from local SUMA + * + * Propagates REF signal to PSCoord + */ +void +Grep::PSPart::execSUB_START_REF(Signal* signal) +{ + SubStartRef * const ref = (SubStartRef *)signal->getDataPtr(); + Uint32 subData = ref->subscriberData; + GrepError::Code err = (GrepError::Code)ref->err; + SubscriptionData::Part part = (SubscriptionData::Part)ref->part; + SubscriptionPtr subPtr; + c_subscriptions.getPtr(subPtr, subData); + sendRefToPSCoord(signal, *subPtr.p, err /*error*/, part); + subPtr.p->m_outstandingRequest = 0; +} + + +/** + * Logging has started... (says PS Participant) + */ +void +Grep::PSCoord::execGREP_START_CONF(Signal* signal) +{ + jamEntry(); + + GrepStartConf * const conf = (GrepStartConf *) signal->getDataPtr(); + Uint32 subData = conf->senderData; + SubscriptionData::Part part = (SubscriptionData::Part)conf->part; + Uint32 subId = conf->subscriptionId; + Uint32 subKey = conf->subscriptionKey; + Uint32 firstGCI = conf->firstGCI; + + SubCoordinatorPtr subPtr; + c_subCoordinatorPool.getPtr(subPtr, subData); + ndbrequire(subPtr.p->m_outstandingRequest == GSN_GREP_START_REQ); + + subPtr.p->m_outstandingParticipants.clearWaitingFor(conf->senderNodeId); + + if(!subPtr.p->m_outstandingParticipants.done()) return; + jam(); + + /************************* + * All participants ready + *************************/ + GrepSubStartConf * grepConf = (GrepSubStartConf *) conf; + grepConf->part = part; + grepConf->subscriptionId = subId; + grepConf->subscriptionKey = subKey; + grepConf->firstGCI = firstGCI; + + bool ok = false; + switch(part) { + case SubscriptionData::MetaData: + ok = true; + sendSignal(subPtr.p->m_subscriberRef, GSN_GREP_SUB_START_CONF, signal, + GrepSubStartConf::SignalLength, JBB); + + /** + * Send event report + */ + m_grep->sendEventRep(signal, + EventReport::GrepSubscriptionInfo, + GrepEvent::GrepPS_SubStartMetaConf, + subId, subKey, + (Uint32)GrepError::NO_ERROR); + + c_subCoordinatorPool.release(subPtr); + break; + case SubscriptionData::TableData: + ok = true; + sendSignal(subPtr.p->m_subscriberRef, GSN_GREP_SUB_START_CONF, signal, + GrepSubStartConf::SignalLength, JBB); + + /** + * Send event report + */ + m_grep->sendEventRep(signal, + EventReport::GrepSubscriptionInfo, + GrepEvent::GrepPS_SubStartDataConf, + subId, subKey, + (Uint32)GrepError::NO_ERROR); + + + c_subCoordinatorPool.release(subPtr); + break; + } + ndbrequire(ok); + +#ifdef DEBUG_GREP_SUBSCRIPTION + ndbout_c("Grep::PSCoord: Recd SUB_START_CONF (subId:%d, subKey:%d, part:%d) " + "from all slaves", + subId, subKey, (Uint32)part); +#endif +} + +/** + * Handle errors that either occured in: + * 1) PSCoord + * or + * 2) propagated from PSPart + */ +void +Grep::PSCoord::execGREP_START_REF(Signal* signal) +{ + jamEntry(); + GrepStartRef * const ref = (GrepStartRef *)signal->getDataPtr(); + Uint32 subData = ref->senderData; + GrepError::Code err = (GrepError::Code)ref->err; + SubscriptionData::Part part = (SubscriptionData::Part)ref->part; + + SubCoordinatorPtr subPtr; + c_runningSubscriptions.getPtr(subPtr, subData); + sendRefToSS(signal, *subPtr.p, err /*error*/, part); +} + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: REMOVE SUBSCRIPTION + * ------------------------------------------------------------------------ + * + * Remove a subscription at SUMA. + * Each participant removes its own subscription. + * We start by deleting the subscription inside the requestor + * since, we don't know if nodes (REP nodes or DB nodes) + * have disconnected after we sent out this and + * if we dont delete the sub in the requestor now, + * we won't be able to create a new subscription + **************************************************************************/ + +/** + * Request to abort subscription (Sent from SS) + */ +void +Grep::PSCoord::execGREP_SUB_REMOVE_REQ(Signal* signal) +{ + jamEntry(); + GrepSubRemoveReq * const subReq = (GrepSubRemoveReq *)signal->getDataPtr(); + Uint32 subId = subReq->subscriptionId; + Uint32 subKey = subReq->subscriptionKey; + BlockReference rep = signal->getSendersBlockRef(); + + SubCoordinatorPtr subPtr; + if( !c_subCoordinatorPool.seize(subPtr)) { + jam(); + SubCoordinator sub; + sub.m_subscriberRef = rep; + sub.m_subscriptionId = 0; + sub.m_subscriptionKey = 0; + sub.m_outstandingRequest = GSN_GREP_REMOVE_REQ; + sendRefToSS(signal, sub, GrepError::NOSPACE_IN_POOL); + return; + } + + + prepareOperationRec(subPtr, + numberToRef(PSREPBLOCKNO, refToNode(rep)), + subId, subKey, + GSN_GREP_REMOVE_REQ); + + c_runningSubscriptions.add(subPtr); + + GrepRemoveReq * req = (GrepRemoveReq *) subReq; + req->subscriptionId = subPtr.p->m_subscriptionId; + req->subscriptionKey = subPtr.p->m_subscriptionKey; + req->senderData = subPtr.p->m_subscriberData; + req->senderRef = subPtr.p->m_coordinatorRef; + + /*************************** + * Send to all participants + ***************************/ + NodeReceiverGroup rg(GREP, m_grep->m_aliveNodes); + subPtr.p->m_outstandingParticipants = rg; + sendSignal(rg, + GSN_GREP_REMOVE_REQ, signal, + GrepRemoveReq::SignalLength, JBB); +} + + +void +Grep::PSPart::execGREP_REMOVE_REQ(Signal* signal) +{ + jamEntry(); + GrepRemoveReq * const grepReq = (GrepRemoveReq *) signal->getDataPtr(); + Uint32 subId = grepReq->subscriptionId; + Uint32 subKey = grepReq->subscriptionKey; + Uint32 subData = grepReq->senderData; + Uint32 coordinator = grepReq->senderRef; + + Subscription key; + key.m_subscriptionId = subId; + key.m_subscriptionKey = subKey; + SubscriptionPtr subPtr; + + if(!c_subscriptions.find(subPtr, key)) + { + /** + * The subscription was not found, so it must be deleted. + * Send CONF back, since it does not exist (thus, it is removed) + */ + GrepRemoveConf * grepConf = (GrepRemoveConf *)grepReq; + grepConf->subscriptionKey = subKey; + grepConf->subscriptionId = subId; + grepConf->senderData = subData; + grepConf->senderNodeId = getOwnNodeId(); + sendSignal(coordinator, GSN_GREP_REMOVE_CONF, signal, + GrepRemoveConf::SignalLength, JBB); + return; + } + + subPtr.p->m_operationPtrI = subData; + subPtr.p->m_coordinatorRef = coordinator; + subPtr.p->m_outstandingRequest = GSN_GREP_REMOVE_REQ; + + /** + * send SUB_REMOVE_REQ to local SUMA + */ + SubRemoveReq * sumaReq = (SubRemoveReq *) grepReq; + sumaReq->subscriptionId = subId; + sumaReq->subscriptionKey = subKey; + sumaReq->senderData = subPtr.i; + sendSignal(SUMA_REF, GSN_SUB_REMOVE_REQ, signal, + SubStartReq::SignalLength, JBB); +} + + +/** + * SUB_REMOVE_CONF (from local SUMA) + */ +void +Grep::PSPart::execSUB_REMOVE_CONF(Signal* signal) +{ + jamEntry(); + SubRemoveConf * const conf = (SubRemoveConf *) signal->getDataPtr(); + Uint32 subId = conf->subscriptionId; + Uint32 subKey = conf->subscriptionKey; + Uint32 subData = conf->subscriberData; + + SubscriptionPtr subPtr; + c_subscriptions.getPtr(subPtr, subData); + ndbrequire(subPtr.p->m_subscriptionId == subId); + ndbrequire(subPtr.p->m_subscriptionKey == subKey); + subPtr.p->m_outstandingRequest = 0; + GrepRemoveConf * grepConf = (GrepRemoveConf *)conf; + grepConf->subscriptionKey = subKey; + grepConf->subscriptionId = subId; + grepConf->senderData = subPtr.p->m_operationPtrI; + grepConf->senderNodeId = getOwnNodeId(); + sendSignal(subPtr.p->m_coordinatorRef, GSN_GREP_REMOVE_CONF, signal, + GrepRemoveConf::SignalLength, JBB); + c_subscriptions.release(subPtr); + +} + + +/** + * SUB_REMOVE_CONF (from local SUMA) + */ +void +Grep::PSPart::execSUB_REMOVE_REF(Signal* signal) +{ + jamEntry(); + SubRemoveRef * const ref = (SubRemoveRef *)signal->getDataPtr(); + Uint32 subData = ref->subscriberData; + GrepError::Code err = (GrepError::Code)ref->err; + SubscriptionPtr subPtr; + c_subscriptions.getPtr(subPtr, subData); + + //sendSubRemoveRef_PSCoord(signal, *subPtr.p, err /*error*/); +} + + +/** + * Aborting has been carried out (says Participants) + */ +void +Grep::PSCoord::execGREP_REMOVE_CONF(Signal* signal) +{ + jamEntry(); + GrepRemoveConf * const conf = (GrepRemoveConf *) signal->getDataPtr(); + Uint32 subId = conf->subscriptionId; + Uint32 subKey = conf->subscriptionKey; + Uint32 senderNodeId = conf->senderNodeId; + Uint32 subData = conf->senderData; + SubCoordinatorPtr subPtr; + c_subCoordinatorPool.getPtr(subPtr, subData); + + ndbrequire(subPtr.p->m_outstandingRequest == GSN_GREP_REMOVE_REQ); + + subPtr.p->m_outstandingParticipants.clearWaitingFor(senderNodeId); + + if(!subPtr.p->m_outstandingParticipants.done()) { + jam(); + return; + } + jam(); + + /************************* + * All participants ready + *************************/ + + m_grep->sendEventRep(signal, + EventReport::GrepSubscriptionInfo, + GrepEvent::GrepPS_SubRemoveConf, + subId, subKey, + GrepError::NO_ERROR); + + GrepSubRemoveConf * grepConf = (GrepSubRemoveConf *) conf; + grepConf->subscriptionId = subId; + grepConf->subscriptionKey = subKey; + sendSignal(subPtr.p->m_subscriberRef, GSN_GREP_SUB_REMOVE_CONF, signal, + GrepSubRemoveConf::SignalLength, JBB); + + c_subCoordinatorPool.release(subPtr); +} + + + +void +Grep::PSCoord::execGREP_REMOVE_REF(Signal* signal) +{ + jamEntry(); + GrepRemoveRef * const ref = (GrepRemoveRef *)signal->getDataPtr(); + Uint32 subData = ref->senderData; + Uint32 err = ref->err; + SubCoordinatorPtr subPtr; + + /** + * Get the operationrecord matching subdata and remove it. Subsequent + * execGREP_REMOVE_REF will simply be ignored at this stage. + */ + for( c_runningSubscriptions.first(c_subPtr); + !c_subPtr.isNull(); c_runningSubscriptions.next(c_subPtr)) { + jam(); + subPtr.i = c_subPtr.curr.i; + subPtr.p = c_runningSubscriptions.getPtr(subPtr.i); + if(subData == subPtr.i) + { + sendRefToSS(signal, *subPtr.p, (GrepError::Code)err /*error*/); + c_runningSubscriptions.release(subPtr); + return; + } + } + return; +} + + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: LOG RECORDS (COMING IN FROM LOCAL SUMA) + * ------------------------------------------------------------------------ + * + * After the subscription is started, we get log records from SUMA. + * Both table data and meta data log records are received. + * + * TODO: + * @todo Changes in meta data is currently not + * allowed during global replication + **************************************************************************/ + +void +Grep::PSPart::execSUB_META_DATA(Signal* signal) +{ + jamEntry(); + if(m_recoveryMode) { + jam(); + return; + } + /** + * METASCAN and METALOG + */ + SubMetaData * data = (SubMetaData *) signal->getDataPtrSend(); + SubscriptionPtr subPtr; + c_subscriptions.getPtr(subPtr, data->subscriberData); + + /*************************** + * Forward data to REP node + ***************************/ + sendSignal(subPtr.p->m_subscriberRef, GSN_SUB_META_DATA, signal, + SubMetaData::SignalLength, JBB); +#ifdef DEBUG_GREP_SUBSCRIPTION + ndbout_c("Grep::PSPart: Sent SUB_META_DATA to REP " + "(TableId: %d, SenderData: %d, GCI: %d)", + data->tableId, data->senderData, data->gci); +#endif +} + +/** + * Receive table data from SUMA and dispatches it to REP node. + */ +void +Grep::PSPart::execSUB_TABLE_DATA(Signal* signal) +{ + jamEntry(); + if(m_recoveryMode) { + jam(); + return; + } + ndbrequire(m_repRef!=0); + + if(!assembleFragments(signal)) { jam(); return; } + + /** + * Check if it is SCAN or LOG data that has arrived + */ + if(signal->getNoOfSections() == 2) + { + jam(); + /** + * DATASCAN - Not marked with GCI, so mark with latest seen GCI + */ + if(m_firstScanGCI == 1 && m_lastScanGCI == 0) { + m_firstScanGCI = m_latestSeenGCI; + m_lastScanGCI = m_latestSeenGCI; + } + SubTableData * data = (SubTableData*)signal->getDataPtrSend(); + Uint32 subData = data->senderData; + data->gci = m_latestSeenGCI; + data->logType = SubTableData::SCAN; + + SubscriptionPtr subPtr; + c_subscriptions.getPtr(subPtr, subData); + sendSignal(subPtr.p->m_subscriberRef, GSN_SUB_TABLE_DATA, signal, + SubTableData::SignalLength, JBB); +#ifdef DEBUG_GREP + ndbout_c("Grep::PSPart: Sent SUB_TABLE_DATA (Scan, GCI: %d)", + data->gci); +#endif + } + else + { + jam(); + /** + * DATALOG (TRIGGER) - Already marked with GCI + */ + SubTableData * data = (SubTableData*)signal->getDataPtrSend(); + data->logType = SubTableData::LOG; + Uint32 subData = data->senderData; + if (data->gci > m_latestSeenGCI) m_latestSeenGCI = data->gci; + + // Reformat to sections and send to replication node. + LinearSectionPtr ptr[3]; + ptr[0].p = signal->theData + 25; + ptr[0].sz = data->noOfAttributes; + ptr[1].p = signal->theData + 25 + MAX_ATTRIBUTES_IN_TABLE; + ptr[1].sz = data->dataSize; + + SubscriptionPtr subPtr; + c_subscriptions.getPtr(subPtr, subData); + sendSignal(subPtr.p->m_subscriberRef, GSN_SUB_TABLE_DATA, + signal, SubTableData::SignalLength, JBB, ptr, 2); +#ifdef DEBUG_GREP + ndbout_c("Grep::PSPart: Sent SUB_TABLE_DATA (Log, GCI: %d)", + data->gci); +#endif + } +} + + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: START SYNCHRONIZATION + * ------------------------------------------------------------------------ + * + * + **************************************************************************/ + +/** + * Request to start sync (from Rep SS) + */ +void +Grep::PSCoord::execGREP_SUB_SYNC_REQ(Signal* signal) +{ + jamEntry(); + GrepSubSyncReq * const subReq = (GrepSubSyncReq*)signal->getDataPtr(); + SubscriptionData::Part part = (SubscriptionData::Part) subReq->part; + Uint32 subId = subReq->subscriptionId; + Uint32 subKey = subReq->subscriptionKey; + BlockReference rep = signal->getSendersBlockRef(); + + SubCoordinatorPtr subPtr; + if( !c_subCoordinatorPool.seize(subPtr)) { + jam(); + SubCoordinator sub; + sub.m_subscriberRef = rep; + sub.m_subscriptionId = 0; + sub.m_subscriptionKey = 0; + sub.m_outstandingRequest = GSN_GREP_SYNC_REQ; + sendRefToSS(signal, sub, GrepError::NOSPACE_IN_POOL); + return; + } + + prepareOperationRec(subPtr, + numberToRef(PSREPBLOCKNO, refToNode(rep)), + subId, subKey, + GSN_GREP_SYNC_REQ); + + GrepSyncReq * req = (GrepSyncReq *)subReq; + req->subscriptionId = subPtr.p->m_subscriptionId; + req->subscriptionKey = subPtr.p->m_subscriptionKey; + req->senderData = subPtr.p->m_subscriberData; + req->part = (Uint32)part; + + /*************************** + * Send to all participants + ***************************/ + NodeReceiverGroup rg(GREP, m_grep->m_aliveNodes); + subPtr.p->m_outstandingParticipants = rg; + sendSignal(rg, + GSN_GREP_SYNC_REQ, signal, GrepSyncReq::SignalLength, JBB); +} + + +/** + * Sync req from Grep::PSCoord to PS particpant + */ +void +Grep::PSPart::execGREP_SYNC_REQ(Signal* signal) +{ + jamEntry(); + + GrepSyncReq * const grepReq = (GrepSyncReq *) signal->getDataPtr(); + Uint32 part = grepReq->part; + Uint32 subId = grepReq->subscriptionId; + Uint32 subKey = grepReq->subscriptionKey; + Uint32 subData = grepReq->senderData; + + Subscription key; + key.m_subscriptionId = subId; + key.m_subscriptionKey = subKey; + SubscriptionPtr subPtr; + ndbrequire(c_subscriptions.find(subPtr, key)); + subPtr.p->m_operationPtrI = subData; + subPtr.p->m_outstandingRequest = GSN_GREP_SYNC_REQ; + /********************************** + * Send SUB_SYNC_REQ to local SUMA + **********************************/ + SubSyncReq * sumaReq = (SubSyncReq *)grepReq; + sumaReq->subscriptionId = subId; + sumaReq->subscriptionKey = subKey; + sumaReq->subscriberData = subPtr.i; + sumaReq->part = part; + sendSignal(SUMA_REF, GSN_SUB_SYNC_REQ, signal, + SubSyncReq::SignalLength, JBB); +} + + +/** + * SYNC conf from SUMA + */ +void +Grep::PSPart::execSUB_SYNC_CONF(Signal* signal) +{ + jamEntry(); + + SubSyncConf * const conf = (SubSyncConf *) signal->getDataPtr(); + Uint32 part = conf->part; + Uint32 subId = conf->subscriptionId; + Uint32 subKey = conf->subscriptionKey; + Uint32 subData = conf->subscriberData; + + SubscriptionPtr subPtr; + c_subscriptions.getPtr(subPtr, subData); + + ndbrequire(subPtr.p->m_subscriptionId == subId); + ndbrequire(subPtr.p->m_subscriptionKey == subKey); + + GrepSyncConf * grepConf = (GrepSyncConf *)conf; + grepConf->senderNodeId = getOwnNodeId(); + grepConf->part = part; + grepConf->firstGCI = m_firstScanGCI; + grepConf->lastGCI = m_lastScanGCI; + grepConf->subscriptionId = subId; + grepConf->subscriptionKey = subKey; + grepConf->senderData = subPtr.p->m_operationPtrI; + sendSignal(subPtr.p->m_coordinatorRef, GSN_GREP_SYNC_CONF, signal, + GrepSyncConf::SignalLength, JBB); + + m_firstScanGCI = 1; + m_lastScanGCI = 0; + subPtr.p->m_outstandingRequest = 0; +} + +/** + * Handle errors that either occured in: + * 1) PSPart + * or + * 2) propagated from local SUMA + * + * Propagates REF signal to PSCoord + */ +void +Grep::PSPart::execSUB_SYNC_REF(Signal* signal) { + jamEntry(); + SubSyncRef * const ref = (SubSyncRef *)signal->getDataPtr(); + Uint32 subData = ref->subscriberData; + GrepError::Code err = (GrepError::Code)ref->err; + SubscriptionData::Part part = (SubscriptionData::Part)ref->part; + + SubscriptionPtr subPtr; + c_subscriptions.getPtr(subPtr, subData); + sendRefToPSCoord(signal, *subPtr.p, err /*error*/ ,part); + subPtr.p->m_outstandingRequest = 0; +} + +/** + * Syncing has started... (says PS Participant) + */ +void +Grep::PSCoord::execGREP_SYNC_CONF(Signal* signal) +{ + jamEntry(); + + GrepSyncConf const * conf = (GrepSyncConf *)signal->getDataPtr(); + Uint32 part = conf->part; + Uint32 firstGCI = conf->firstGCI; + Uint32 lastGCI = conf->lastGCI; + Uint32 subId = conf->subscriptionId; + Uint32 subKey = conf->subscriptionKey; + Uint32 subData = conf->senderData; + + SubCoordinatorPtr subPtr; + c_subCoordinatorPool.getPtr(subPtr, subData); + ndbrequire(subPtr.p->m_outstandingRequest == GSN_GREP_SYNC_REQ); + + subPtr.p->m_outstandingParticipants.clearWaitingFor(conf->senderNodeId); + if(!subPtr.p->m_outstandingParticipants.done()) return; + + /** + * Send event + */ + GrepEvent::Subscription event; + if(part == SubscriptionData::MetaData) + event = GrepEvent::GrepPS_SubSyncMetaConf; + else + event = GrepEvent::GrepPS_SubSyncDataConf; + + /* @todo Johan: Add firstGCI here. /Lars */ + m_grep->sendEventRep(signal, EventReport::GrepSubscriptionInfo, + event, subId, subKey, + (Uint32)GrepError::NO_ERROR, + lastGCI); + + /************************* + * All participants ready + *************************/ + GrepSubSyncConf * grepConf = (GrepSubSyncConf *)conf; + grepConf->part = part; + grepConf->firstGCI = firstGCI; + grepConf->lastGCI = lastGCI; + grepConf->subscriptionId = subId; + grepConf->subscriptionKey = subKey; + + sendSignal(subPtr.p->m_subscriberRef, GSN_GREP_SUB_SYNC_CONF, signal, + GrepSubSyncConf::SignalLength, JBB); + c_subCoordinatorPool.release(subPtr); +} + +/** + * Handle errors that either occured in: + * 1) PSCoord + * or + * 2) propagated from PSPart + */ +void +Grep::PSCoord::execGREP_SYNC_REF(Signal* signal) { + jamEntry(); + GrepSyncRef * const ref = (GrepSyncRef *)signal->getDataPtr(); + Uint32 subData = ref->senderData; + SubscriptionData::Part part = (SubscriptionData::Part)ref->part; + GrepError::Code err = (GrepError::Code)ref->err; + SubCoordinatorPtr subPtr; + c_runningSubscriptions.getPtr(subPtr, subData); + sendRefToSS(signal, *subPtr.p, err /*error*/, part); +} + + + +void +Grep::PSCoord::sendRefToSS(Signal * signal, + SubCoordinator sub, + GrepError::Code err, + SubscriptionData::Part part) { + /** + + GrepCreateRef * ref = (GrepCreateRef*)signal->getDataPtrSend(); + ref->senderData = sub.m_subscriberData; + ref->subscriptionId = sub.m_subscriptionId; + ref->subscriptionKey = sub.m_subscriptionKey; + ref->err = err; + sendSignal(sub.m_coordinatorRef, GSN_GREP_CREATE_REF, signal, + GrepCreateRef::SignalLength, JBB); +*/ + + jam(); + GrepEvent::Subscription event; + switch(sub.m_outstandingRequest) { + case GSN_GREP_CREATE_SUBID_REQ: + { + jam(); + CreateSubscriptionIdRef * ref = + (CreateSubscriptionIdRef*)signal->getDataPtrSend(); + ref->err = (Uint32)err; + ref->subscriptionId = sub.m_subscriptionId; + ref->subscriptionKey = sub.m_subscriptionKey; + sendSignal(sub.m_subscriberRef, + GSN_GREP_CREATE_SUBID_REF, + signal, + CreateSubscriptionIdRef::SignalLength, + JBB); + event = GrepEvent::GrepPS_CreateSubIdRef; + } + break; + case GSN_GREP_CREATE_REQ: + { + jam(); + GrepSubCreateRef * ref = (GrepSubCreateRef*)signal->getDataPtrSend(); + ref->err = (Uint32)err; + ref->subscriptionId = sub.m_subscriptionId; + ref->subscriptionKey = sub.m_subscriptionKey; + sendSignal(sub.m_subscriberRef, GSN_GREP_SUB_CREATE_REF, signal, + GrepSubCreateRef::SignalLength, JBB); + event = GrepEvent::GrepPS_SubCreateRef; + } + break; + case GSN_GREP_SYNC_REQ: + { + jam(); + GrepSubSyncRef * ref = (GrepSubSyncRef*)signal->getDataPtrSend(); + ref->err = (Uint32)err; + ref->subscriptionId = sub.m_subscriptionId; + ref->subscriptionKey = sub.m_subscriptionKey; + ref->part = (SubscriptionData::Part) part; + sendSignal(sub.m_subscriberRef, + GSN_GREP_SUB_SYNC_REF, + signal, + GrepSubSyncRef::SignalLength, + JBB); + if(part == SubscriptionData::MetaData) + event = GrepEvent::GrepPS_SubSyncMetaRef; + else + event = GrepEvent::GrepPS_SubSyncDataRef; + } + break; + case GSN_GREP_START_REQ: + { + jam(); + GrepSubStartRef * ref = (GrepSubStartRef*)signal->getDataPtrSend(); + ref->err = (Uint32)err; + ref->subscriptionId = sub.m_subscriptionId; + ref->subscriptionKey = sub.m_subscriptionKey; + + sendSignal(sub.m_subscriberRef, GSN_GREP_SUB_START_REF, + signal, GrepSubStartRef::SignalLength, JBB); + if(part == SubscriptionData::MetaData) + event = GrepEvent::GrepPS_SubStartMetaRef; + else + event = GrepEvent::GrepPS_SubStartDataRef; + /** + * Send event report + */ + m_grep->sendEventRep(signal, + EventReport::GrepSubscriptionAlert, + event, + sub.m_subscriptionId, + sub.m_subscriptionKey, + (Uint32)err); + } + break; + case GSN_GREP_REMOVE_REQ: + { + jam(); + GrepSubRemoveRef * ref = (GrepSubRemoveRef*)signal->getDataPtrSend(); + ref->subscriptionId = sub.m_subscriptionId; + ref->subscriptionKey = sub.m_subscriptionKey; + ref->err = (Uint32)err; + + sendSignal(sub.m_subscriberRef, + GSN_GREP_SUB_REMOVE_REF, + signal, + GrepSubRemoveRef::SignalLength, + JBB); + + event = GrepEvent::GrepPS_SubRemoveRef; + } + break; + default: + ndbrequire(false); + } + /** + * Finally, send an event. + */ + m_grep->sendEventRep(signal, + EventReport::GrepSubscriptionAlert, + event, + sub.m_subscriptionId, + sub.m_subscriptionKey, + err); + +} + + +void +Grep::PSPart::sendRefToPSCoord(Signal * signal, + Subscription sub, + GrepError::Code err, + SubscriptionData::Part part) { + + jam(); + GrepEvent::Subscription event; + switch(sub.m_outstandingRequest) { + + case GSN_GREP_CREATE_REQ: + { + GrepCreateRef * ref = (GrepCreateRef*)signal->getDataPtrSend(); + ref->senderData = sub.m_subscriberData; + ref->subscriptionId = sub.m_subscriptionId; + ref->subscriptionKey = sub.m_subscriptionKey; + ref->err = err; + sendSignal(sub.m_coordinatorRef, GSN_GREP_CREATE_REF, signal, + GrepCreateRef::SignalLength, JBB); + + event = GrepEvent::GrepPS_SubCreateRef; + } + break; + case GSN_GREP_SYNC_REQ: + { + GrepSyncRef * ref = (GrepSyncRef*)signal->getDataPtrSend(); + ref->senderData = sub.m_subscriberData; + ref->subscriptionId = sub.m_subscriptionId; + ref->subscriptionKey = sub.m_subscriptionKey; + ref->part = part; + ref->err = err; + sendSignal(sub.m_coordinatorRef, + GSN_GREP_SYNC_REF, signal, + GrepSyncRef::SignalLength, JBB); + if(part == SubscriptionData::MetaData) + event = GrepEvent::GrepPS_SubSyncMetaRef; + else + event = GrepEvent::GrepPS_SubSyncDataRef; + } + break; + case GSN_GREP_START_REQ: + { + jam(); + GrepStartRef * ref = (GrepStartRef*)signal->getDataPtrSend(); + ref->senderData = sub.m_subscriberData; + ref->subscriptionId = sub.m_subscriptionId; + ref->subscriptionKey = sub.m_subscriptionKey; + ref->part = (Uint32) part; + ref->err = err; + sendSignal(sub.m_coordinatorRef, GSN_GREP_START_REF, signal, + GrepStartRef::SignalLength, JBB); + if(part == SubscriptionData::MetaData) + event = GrepEvent::GrepPS_SubStartMetaRef; + else + event = GrepEvent::GrepPS_SubStartDataRef; + } + break; + + case GSN_GREP_REMOVE_REQ: + { + jamEntry(); + GrepRemoveRef * ref = (GrepRemoveRef*)signal->getDataPtrSend(); + ref->senderData = sub.m_operationPtrI; + ref->subscriptionId = sub.m_subscriptionId; + ref->subscriptionKey = sub.m_subscriptionKey; + ref->err = err; + sendSignal(sub.m_coordinatorRef, GSN_GREP_REMOVE_REF, signal, + GrepCreateRef::SignalLength, JBB); + + } + break; + default: + ndbrequire(false); + } + + /** + * Finally, send an event. + */ + m_grep->sendEventRep(signal, + EventReport::GrepSubscriptionAlert, + event, + sub.m_subscriptionId, + sub.m_subscriptionKey, + err); + +} + +/************************************************************************** + * ------------------------------------------------------------------------ + * MODULE: GREP PS Coordinator GCP + * ------------------------------------------------------------------------ + * + * + **************************************************************************/ + +void +Grep::PSPart::execSUB_GCP_COMPLETE_REP(Signal* signal) +{ + jamEntry(); + if(m_recoveryMode) { + jam(); + return; + } + SubGcpCompleteRep * rep = (SubGcpCompleteRep *)signal->getDataPtrSend(); + rep->senderRef = reference(); + + if (rep->gci > m_latestSeenGCI) m_latestSeenGCI = rep->gci; + SubscriptionPtr subPtr; + c_subscriptions.first(c_subPtr); + for(; !c_subPtr.isNull(); c_subscriptions.next(c_subPtr)) { + + subPtr.i = c_subPtr.curr.i; + subPtr.p = c_subscriptions.getPtr(subPtr.i); + sendSignal(subPtr.p->m_subscriberRef, GSN_SUB_GCP_COMPLETE_REP, signal, + SubGcpCompleteRep::SignalLength, JBB); + } + +#ifdef DEBUG_GREP + ndbout_c("Grep::PSPart: Recd SUB_GCP_COMPLETE_REP " + "(GCI: %d, nodeId: %d) from SUMA", + rep->gci, refToNode(rep->senderRef)); +#endif +} + + +void +Grep::PSPart::execSUB_SYNC_CONTINUE_REQ(Signal* signal) +{ + jamEntry(); + SubSyncContinueReq * const req = (SubSyncContinueReq*)signal->getDataPtr(); + Uint32 subData = req->subscriberData; + + SubscriptionPtr subPtr; + c_subscriptions.getPtr(subPtr,subData); + + /** + * @todo Figure out how to control how much data we can receive? + */ + SubSyncContinueConf * conf = (SubSyncContinueConf*)req; + conf->subscriptionId = subPtr.p->m_subscriptionId; + conf->subscriptionKey = subPtr.p->m_subscriptionKey; + sendSignal(SUMA_REF, GSN_SUB_SYNC_CONTINUE_CONF, signal, + SubSyncContinueConf::SignalLength, JBB); +} + +void +Grep::sendEventRep(Signal * signal, + EventReport::EventType type, + GrepEvent::Subscription event, + Uint32 subId, + Uint32 subKey, + Uint32 err, + Uint32 other) { + jam(); + signal->theData[0] = type; + signal->theData[1] = event; + signal->theData[2] = subId; + signal->theData[3] = subKey; + signal->theData[4] = err; + + if(other==0) + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 5 ,JBB); + else { + signal->theData[5] = other; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 6 ,JBB); + } +} diff --git a/ndb/src/kernel/blocks/grep/Grep.hpp b/ndb/src/kernel/blocks/grep/Grep.hpp new file mode 100644 index 00000000000..ba8f5780522 --- /dev/null +++ b/ndb/src/kernel/blocks/grep/Grep.hpp @@ -0,0 +1,548 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef GREP_HPP +#define GREP_HPP + +#include +#include + +#include +#include +#include + +#include + +#include +#include + +#include +#include + + +/** + * Module in block (Should be placed elsewhere) + */ +class BlockComponent { +public: + BlockComponent(SimulatedBlock *); + BlockReference reference() { return m_sb->reference(); }; + BlockNumber number() { return m_sb->number(); }; + + void sendSignal(NodeReceiverGroup rg, + GlobalSignalNumber gsn, + Signal* signal, + Uint32 length, + JobBufferLevel jbuf ) const { + m_sb->sendSignal(rg, gsn, signal, length, jbuf); + } + + void sendSignal(BlockReference ref, + GlobalSignalNumber gsn, + Signal* signal, + Uint32 length, + JobBufferLevel jbuf ) const { + m_sb->sendSignal(ref, gsn, signal, length, jbuf); + } + + void sendSignal(BlockReference ref, + GlobalSignalNumber gsn, + Signal* signal, + Uint32 length, + JobBufferLevel jbuf, + LinearSectionPtr ptr[3], + Uint32 noOfSections) const { + m_sb->sendSignal(ref, gsn, signal, length, jbuf, ptr, noOfSections); + } + + void sendSignalWithDelay(BlockReference ref, + GlobalSignalNumber gsn, + Signal* signal, + Uint32 delayInMilliSeconds, + Uint32 length) const { + + m_sb->sendSignalWithDelay(ref, gsn, signal, delayInMilliSeconds, length); + } + + NodeId getOwnNodeId() const { + return m_sb->getOwnNodeId(); + } + + bool assembleFragments(Signal * signal) { + return m_sb->assembleFragments(signal); + } + + void progError(int line, int err_code, const char* extra) { + m_sb->progError(line, err_code, extra); + } + +private: + SimulatedBlock * m_sb; +}; + + + +/** + * Participant of GREP Protocols (not necessarily a protocol coordinator) + * + * This object is only used on primary system + */ +#if 0 +class GrepParticipant : public SimulatedBlock +{ +protected: + GrepParticipant(const Configuration & conf); + virtual ~GrepParticipant(); + BLOCK_DEFINES(GrepParticipant); + +protected: + /*************************************************************************** + * SUMA Signal Interface + ***************************************************************************/ + void execSUB_CREATE_CONF(Signal*); + void execSUB_STARTCONF(Signal*); + void execSUB_REMOVE_CONF(Signal*); + + void execSUB_META_DATA(Signal*); + void execSUB_TABLE_DATA(Signal*); + + void execSUB_SYNC_CONF(Signal*); + + void execSUB_GCP_COMPLETE_REP(Signal*); + void execSUB_SYNC_CONTINUE_REQ(Signal*); + + /*************************************************************************** + * GREP Coordinator Signal Interface + ***************************************************************************/ + void execGREP_CREATE_REQ(Signal*); + void execGREP_START_REQ(Signal*); + void execGREP_SYNC_REQ(Signal*); + void execGREP_REMOVE_REQ(Signal*); + + +protected: + BlockReference m_repRef; ///< Replication node (only one rep node per grep) + +private: + BlockReference m_coordinator; + Uint32 m_latestSeenGCI; +}; +#endif + + +/** + * GREP Coordinator + */ +class Grep : public SimulatedBlock //GrepParticipant +{ + //BLOCK_DEFINES(Grep); + +public: + Grep(const Configuration & conf); + virtual ~Grep(); + +private: + /*************************************************************************** + * General Signal Recivers + ***************************************************************************/ + void execSTTOR(Signal*); + void sendSTTORRY(Signal*); + void execNDB_STTOR(Signal*); + void execDUMP_STATE_ORD(Signal*); + void execREAD_NODESCONF(Signal*); + void execNODE_FAILREP(Signal*); + void execINCL_NODEREQ(Signal*); + void execGREP_REQ(Signal*); + void execAPI_FAILREQ(Signal*); + /** + * Forwarded to PSCoord + */ + //CONF + void fwdGREP_CREATE_CONF(Signal* s) { + pscoord.execGREP_CREATE_CONF(s); }; + void fwdGREP_START_CONF(Signal* s) { + pscoord.execGREP_START_CONF(s); }; + void fwdGREP_SYNC_CONF(Signal* s) { + pscoord.execGREP_SYNC_CONF(s); }; + void fwdGREP_REMOVE_CONF(Signal* s) { + pscoord.execGREP_REMOVE_CONF(s); }; + void fwdCREATE_SUBID_CONF(Signal* s) { + pscoord.execCREATE_SUBID_CONF(s); }; + + //REF + + void fwdGREP_CREATE_REF(Signal* s) { + pscoord.execGREP_CREATE_REF(s); }; + void fwdGREP_START_REF(Signal* s) { + pscoord.execGREP_START_REF(s); }; + void fwdGREP_SYNC_REF(Signal* s) { + pscoord.execGREP_SYNC_REF(s); }; + + void fwdGREP_REMOVE_REF(Signal* s) { + pscoord.execGREP_REMOVE_REF(s); }; + + void fwdCREATE_SUBID_REF(Signal* s) { + pscoord.execCREATE_SUBID_REF(s); }; + + //REQ + void fwdGREP_SUB_CREATE_REQ(Signal* s) { + pscoord.execGREP_SUB_CREATE_REQ(s); }; + void fwdGREP_SUB_START_REQ(Signal* s) { + pscoord.execGREP_SUB_START_REQ(s); }; + void fwdGREP_SUB_SYNC_REQ(Signal* s) { + pscoord.execGREP_SUB_SYNC_REQ(s); }; + void fwdGREP_SUB_REMOVE_REQ(Signal* s) { + pscoord.execGREP_SUB_REMOVE_REQ(s); }; + void fwdGREP_CREATE_SUBID_REQ(Signal* s) { + pscoord.execGREP_CREATE_SUBID_REQ(s); }; + + /** + * Forwarded to PSPart + */ + + void fwdSTART_ME(Signal* s){ + pspart.execSTART_ME(s); + }; + void fwdGREP_ADD_SUB_REQ(Signal* s){ + pspart.execGREP_ADD_SUB_REQ(s); + }; + void fwdGREP_ADD_SUB_REF(Signal* s){ + pspart.execGREP_ADD_SUB_REF(s); + }; + void fwdGREP_ADD_SUB_CONF(Signal* s){ + pspart.execGREP_ADD_SUB_CONF(s); + }; + + //CONF + void fwdSUB_CREATE_CONF(Signal* s) { + pspart.execSUB_CREATE_CONF(s); }; + void fwdSUB_START_CONF(Signal* s) { + pspart.execSUB_START_CONF(s); }; + void fwdSUB_REMOVE_CONF(Signal* s) { + pspart.execSUB_REMOVE_CONF(s); }; + void fwdSUB_SYNC_CONF(Signal* s) { + pspart.execSUB_SYNC_CONF(s); }; + + //REF + + void fwdSUB_CREATE_REF(Signal* s) { + pspart.execSUB_CREATE_REF(s); }; + void fwdSUB_START_REF(Signal* s) { + pspart.execSUB_START_REF(s); }; + void fwdSUB_REMOVE_REF(Signal* s) { + pspart.execSUB_REMOVE_REF(s); }; + void fwdSUB_SYNC_REF(Signal* s) { + pspart.execSUB_SYNC_REF(s); }; + + //REQ + void fwdSUB_SYNC_CONTINUE_REQ(Signal* s) { + pspart.execSUB_SYNC_CONTINUE_REQ(s); }; + void fwdGREP_CREATE_REQ(Signal* s) { + pspart.execGREP_CREATE_REQ(s); }; + void fwdGREP_START_REQ(Signal* s) { + pspart.execGREP_START_REQ(s); }; + void fwdGREP_SYNC_REQ(Signal* s) { + pspart.execGREP_SYNC_REQ(s); }; + void fwdGREP_REMOVE_REQ(Signal* s) { + pspart.execGREP_REMOVE_REQ(s); }; + + void fwdSUB_META_DATA(Signal* s) { + pspart.execSUB_META_DATA(s); }; + void fwdSUB_TABLE_DATA(Signal* s) { + pspart.execSUB_TABLE_DATA(s); }; + + void fwdSUB_GCP_COMPLETE_REP(Signal* s) { + pspart.execSUB_GCP_COMPLETE_REP(s); }; + + void sendEventRep(Signal * signal, + EventReport::EventType type, + GrepEvent::Subscription event, + Uint32 subId, + Uint32 subKey, + Uint32 err, + Uint32 gci=0); + + void getNodeGroupMembers(Signal* signal); + + + /*************************************************************************** + * Block Data + ***************************************************************************/ + struct Node { + Uint32 nodeId; + Uint32 alive; + Uint32 nextList; + union { Uint32 prevList; Uint32 nextPool; }; + }; + typedef Ptr NodePtr; + + NodeId m_masterNodeId; + SLList m_nodes; + NdbNodeBitmask m_aliveNodes; + ArrayPool m_nodePool; + + /** + * for all Suma's to keep track of other Suma's in Node group + */ + Uint32 c_nodeGroup; + Uint32 c_noNodesInGroup; + Uint32 c_idInNodeGroup; + NodeId c_nodesInGroup[4]; + + +public: + /*************************************************************************** + * GREP PS Coordinator + ***************************************************************************/ + class PSCoord : public BlockComponent { + + private: + + struct SubCoordinator { + Uint32 m_subscriberRef; + Uint32 m_subscriberData; + Uint32 m_coordinatorRef; + Uint32 m_subscriptionId; + Uint32 m_subscriptionKey; + Uint32 m_subscriptionType; + NdbNodeBitmask m_participants; + Uint32 m_outstandingRequest; + SignalCounter m_outstandingParticipants; + + Uint32 nextHash; + union { Uint32 prevHash; Uint32 nextPool; }; + + Uint32 hashValue() const { + return m_subscriptionId + m_subscriptionKey; + } + + bool equal(const SubCoordinator & s) const { + return + m_subscriptionId == s.m_subscriptionId && + m_subscriptionKey == s.m_subscriptionKey; + } + + }; + + typedef Ptr SubCoordinatorPtr; + ArrayPool c_subCoordinatorPool; + DLHashTable::Iterator c_subPtr; + DLHashTable c_runningSubscriptions; + + void prepareOperationRec(SubCoordinatorPtr ptr, + BlockReference subscriber, + Uint32 subId, + Uint32 subKey, + Uint32 request); + + public: + PSCoord(class Grep *); + + void execGREP_CREATE_CONF(Signal*); + void execGREP_START_CONF(Signal*); + void execGREP_SYNC_CONF(Signal*); + void execGREP_REMOVE_CONF(Signal*); + + void execGREP_CREATE_REF(Signal*); + void execGREP_START_REF(Signal*); + void execGREP_SYNC_REF(Signal*); + void execGREP_REMOVE_REF(Signal*); + + + void execCREATE_SUBID_CONF(Signal*); //comes from SUMA + void execGREP_CREATE_SUBID_REQ(Signal*); + + void execGREP_SUB_CREATE_REQ(Signal*); + void execGREP_SUB_START_REQ(Signal*); + void execGREP_SUB_SYNC_REQ(Signal*); + void execGREP_SUB_REMOVE_REQ(Signal*); + + + + void execCREATE_SUBID_REF(Signal*); + + + + void sendCreateSubIdRef_SS(Signal * signal, + Uint32 subId, + Uint32 subKey, + BlockReference to, + GrepError::Code err); + + + void sendSubRemoveRef_SS(Signal * signal, + SubCoordinator sub, + GrepError::Code err); + + void sendRefToSS(Signal * signal, + SubCoordinator sub, + GrepError::Code err, + SubscriptionData::Part part = (SubscriptionData::Part)0); + + void setRepRef(BlockReference rr) { m_repRef = rr; }; + //void setAliveNodes(NdbNodeBitmask an) { m_aliveNodes = an; }; + + BlockReference m_repRef; ///< Rep node (only one rep node per grep) + // NdbNodeBitmask m_aliveNodes; + + Uint32 m_outstandingRequest; + SignalCounter m_outstandingParticipants; + + Grep * m_grep; + } pscoord; + friend class PSCoord; + + /*************************************************************************** + * GREP PS Participant + *************************************************************************** + * Participant of GREP Protocols (not necessarily a protocol coordinator) + * + * This object is only used on primary system + ***************************************************************************/ + class PSPart: public BlockComponent + { + //protected: + //GrepParticipant(const Configuration & conf); + //virtual ~GrepParticipant(); + //BLOCK_DEFINES(GrepParticipant); + + struct Subscription { + Uint32 m_subscriberRef; + Uint32 m_subscriberData; + Uint32 m_subscriptionId; + Uint32 m_subscriptionKey; + Uint32 m_subscriptionType; + Uint32 m_coordinatorRef; + Uint32 m_outstandingRequest; + Uint32 m_operationPtrI; + Uint32 nextHash; + union { Uint32 prevHash; Uint32 nextPool; }; + + Uint32 hashValue() const { + return m_subscriptionId + m_subscriptionKey; + } + + bool equal(const Subscription & s) const { + return + m_subscriptionId == s.m_subscriptionId && + m_subscriptionKey == s.m_subscriptionKey; + } + + }; + typedef Ptr SubscriptionPtr; + + DLHashTable c_subscriptions; + DLHashTable::Iterator c_subPtr; + ArrayPool c_subscriptionPool; + + public: + PSPart(class Grep *); + + + //protected: + /************************************************************************* + * SUMA Signal Interface + *************************************************************************/ + void execSUB_CREATE_CONF(Signal*); + void execSUB_START_CONF(Signal*); + void execSUB_SYNC_CONF(Signal*); + void execSUB_REMOVE_CONF(Signal*); + + void execSUB_CREATE_REF(Signal*); + void execSUB_START_REF(Signal*); + void execSUB_SYNC_REF(Signal*); + void execSUB_REMOVE_REF(Signal*); + + + void execSUB_META_DATA(Signal*); + void execSUB_TABLE_DATA(Signal*); + + + void execSUB_GCP_COMPLETE_REP(Signal*); + void execSUB_SYNC_CONTINUE_REQ(Signal*); + + /************************************************************************* + * GREP Coordinator Signal Interface + *************************************************************************/ + void execGREP_CREATE_REQ(Signal*); + void execGREP_START_REQ(Signal*); + void execGREP_SYNC_REQ(Signal*); + void execGREP_REMOVE_REQ(Signal*); + + /** + * NR/NF signals + */ + void execSTART_ME(Signal *); + void execGREP_ADD_SUB_REQ(Signal *); + void execGREP_ADD_SUB_REF(Signal *); + void execGREP_ADD_SUB_CONF(Signal *); + + /************************************************************************* + * GREP Coordinator error handling interface + *************************************************************************/ + + void sendRefToPSCoord(Signal * signal, + Subscription sub, + GrepError::Code err, + SubscriptionData::Part part = (SubscriptionData::Part)0); + + //protected: + BlockReference m_repRef; ///< Replication node + ///< (only one rep node per grep) + bool m_recoveryMode; + + private: + BlockReference m_coordinator; + Uint32 m_firstScanGCI; + Uint32 m_lastScanGCI; + Uint32 m_latestSeenGCI; + Grep * m_grep; + } pspart; + friend class PSPart; + + /*************************************************************************** + * AddRecSignal Stuff (should maybe be gerneralized) + ***************************************************************************/ + typedef void (Grep::* ExecSignalLocal1) (Signal* signal); + typedef void (Grep::PSCoord::* ExecSignalLocal2) (Signal* signal); + typedef void (Grep::PSPart::* ExecSignalLocal4) (Signal* signal); + + void + addRecSignal(GlobalSignalNumber gsn, ExecSignalLocal1 f, bool force = false){ + addRecSignalImpl(gsn, (ExecFunction)f, force); + } + void + addRecSignal(GlobalSignalNumber gsn, ExecSignalLocal2 f, bool force = false){ + addRecSignalImpl(gsn, (ExecFunction)f, force); + } + void + addRecSignal(GlobalSignalNumber gsn, ExecSignalLocal4 f, bool force = false){ + addRecSignalImpl(gsn, (ExecFunction)f, force); + } +}; + + +/************************************************************************* + * Requestor + * + * The following methods are callbacks (registered functions) + * for the Requestor. The Requestor calls these when it needs + * something to be done. + *************************************************************************/ +void startSubscription(void * cbObj, Signal*, int type); +void scanSubscription(void * cbObj, Signal*, int type); + +#endif diff --git a/ndb/src/kernel/blocks/grep/GrepInit.cpp b/ndb/src/kernel/blocks/grep/GrepInit.cpp new file mode 100644 index 00000000000..70bf6678754 --- /dev/null +++ b/ndb/src/kernel/blocks/grep/GrepInit.cpp @@ -0,0 +1,165 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Grep.hpp" +#include +#include +#include + +/***************************************************************************** + * Grep Participant + *****************************************************************************/ +#if 0 +GrepParticipant::GrepParticipant(const Configuration & conf) : + SimulatedBlock(GREP, conf) +{ + BLOCK_CONSTRUCTOR(Grep); + //m_repRef = 0; + m_latestSeenGCI = 0; +} + +GrepParticipant::~GrepParticipant() +{ +} + +BLOCK_FUNCTIONS(GrepParticipant); +#endif + +/***************************************************************************** + * Grep Coordinator + *****************************************************************************/ +Grep::Grep(const Configuration & conf) : + // GrepParticipant(conf), + SimulatedBlock(GREP, conf), + m_nodes(m_nodePool), + pscoord(this), + pspart(this) +{ + m_nodePool.setSize(MAX_NDB_NODES); + m_masterNodeId = getOwnNodeId(); + + /*************************************************************************** + * General Signals + ***************************************************************************/ + addRecSignal(GSN_STTOR, &Grep::execSTTOR); + addRecSignal(GSN_NDB_STTOR, &Grep::execNDB_STTOR); + addRecSignal(GSN_DUMP_STATE_ORD, &Grep::execDUMP_STATE_ORD); + addRecSignal(GSN_READ_NODESCONF, &Grep::execREAD_NODESCONF); + addRecSignal(GSN_NODE_FAILREP, &Grep::execNODE_FAILREP); + addRecSignal(GSN_INCL_NODEREQ, &Grep::execINCL_NODEREQ); + + addRecSignal(GSN_GREP_REQ, &Grep::execGREP_REQ); + addRecSignal(GSN_API_FAILREQ, &Grep::execAPI_FAILREQ); + + + /*************************************************************************** + * Grep::PSCoord Signal Interface + ***************************************************************************/ + /** + * From Grep::PSPart + */ + addRecSignal(GSN_GREP_CREATE_CONF, &Grep::fwdGREP_CREATE_CONF); + addRecSignal(GSN_GREP_START_CONF, &Grep::fwdGREP_START_CONF); + addRecSignal(GSN_GREP_SYNC_CONF, &Grep::fwdGREP_SYNC_CONF); + addRecSignal(GSN_GREP_REMOVE_CONF, &Grep::fwdGREP_REMOVE_CONF); + + addRecSignal(GSN_GREP_CREATE_REF, &Grep::fwdGREP_CREATE_REF); + addRecSignal(GSN_GREP_START_REF, &Grep::fwdGREP_START_REF); + addRecSignal(GSN_GREP_REMOVE_REF, &Grep::fwdGREP_REMOVE_REF); + + /** + * From Grep::SSCoord to Grep::PSCoord + */ + addRecSignal(GSN_GREP_SUB_START_REQ, &Grep::fwdGREP_SUB_START_REQ); + addRecSignal(GSN_GREP_SUB_CREATE_REQ, &Grep::fwdGREP_SUB_CREATE_REQ); + addRecSignal(GSN_GREP_SUB_SYNC_REQ, &Grep::fwdGREP_SUB_SYNC_REQ); + addRecSignal(GSN_GREP_SUB_REMOVE_REQ, &Grep::fwdGREP_SUB_REMOVE_REQ); + addRecSignal(GSN_GREP_CREATE_SUBID_REQ, &Grep::fwdGREP_CREATE_SUBID_REQ); + + /**************************************************************************** + * PSPart + ***************************************************************************/ + /** + * From SUMA to GREP PS Participant. If suma is not a coodinator + */ + addRecSignal(GSN_SUB_START_CONF, &Grep::fwdSUB_START_CONF); + addRecSignal(GSN_SUB_CREATE_CONF, &Grep::fwdSUB_CREATE_CONF); + addRecSignal(GSN_SUB_SYNC_CONF, &Grep::fwdSUB_SYNC_CONF); + addRecSignal(GSN_SUB_REMOVE_CONF, &Grep::fwdSUB_REMOVE_CONF); + addRecSignal(GSN_SUB_CREATE_REF, &Grep::fwdSUB_CREATE_REF); + addRecSignal(GSN_SUB_START_REF, &Grep::fwdSUB_START_REF); + addRecSignal(GSN_SUB_SYNC_REF, &Grep::fwdSUB_SYNC_REF); + addRecSignal(GSN_SUB_REMOVE_REF, &Grep::fwdSUB_REMOVE_REF); + + addRecSignal(GSN_SUB_SYNC_CONTINUE_REQ, + &Grep::fwdSUB_SYNC_CONTINUE_REQ); + + /** + * From Suma to Grep::PSPart. Data signals. + */ + addRecSignal(GSN_SUB_META_DATA, &Grep::fwdSUB_META_DATA); + addRecSignal(GSN_SUB_TABLE_DATA, &Grep::fwdSUB_TABLE_DATA); + addRecSignal(GSN_SUB_GCP_COMPLETE_REP, &Grep::fwdSUB_GCP_COMPLETE_REP); + + /** + * From Grep::PSCoord to Grep::PSPart + */ + addRecSignal(GSN_GREP_CREATE_REQ, &Grep::fwdGREP_CREATE_REQ); + addRecSignal(GSN_GREP_START_REQ, &Grep::fwdGREP_START_REQ); + addRecSignal(GSN_GREP_REMOVE_REQ, &Grep::fwdGREP_REMOVE_REQ); + addRecSignal(GSN_GREP_SYNC_REQ, &Grep::fwdGREP_SYNC_REQ); + addRecSignal(GSN_CREATE_SUBID_CONF, &Grep::fwdCREATE_SUBID_CONF); + addRecSignal(GSN_GREP_START_ME, &Grep::fwdSTART_ME); + addRecSignal(GSN_GREP_ADD_SUB_REQ, &Grep::fwdGREP_ADD_SUB_REQ); + addRecSignal(GSN_GREP_ADD_SUB_REF, &Grep::fwdGREP_ADD_SUB_REF); + addRecSignal(GSN_GREP_ADD_SUB_CONF, &Grep::fwdGREP_ADD_SUB_CONF); +} + +Grep::~Grep() +{ +} + +//BLOCK_FUNCTIONS(Grep); + +Grep::PSPart::PSPart(Grep * sb) : + BlockComponent(sb), + c_subscriptions(c_subscriptionPool) +{ + m_grep = sb; + + m_firstScanGCI = 1; // Empty interval = [1,0] + m_lastScanGCI = 0; + + m_latestSeenGCI = 0; + + c_subscriptions.setSize(10); + c_subscriptionPool.setSize(10); +} + +Grep::PSCoord::PSCoord(Grep * sb) : + BlockComponent(sb), + c_runningSubscriptions(c_subCoordinatorPool) +{ + m_grep = sb; + c_runningSubscriptions.setSize(10); + c_subCoordinatorPool.setSize(2); +} + +//BLOCK_FUNCTIONS(Grep::PSCoord); + +BlockComponent::BlockComponent(SimulatedBlock * sb) { + m_sb = sb; +} diff --git a/ndb/src/kernel/blocks/grep/Makefile b/ndb/src/kernel/blocks/grep/Makefile new file mode 100644 index 00000000000..5ad5a0bce3b --- /dev/null +++ b/ndb/src/kernel/blocks/grep/Makefile @@ -0,0 +1,9 @@ +include .defs.mk + +TYPE := kernel + +ARCHIVE_TARGET := grep + +SOURCES = Grep.cpp GrepInit.cpp + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/kernel/blocks/grep/systab_test/Makefile b/ndb/src/kernel/blocks/grep/systab_test/Makefile new file mode 100644 index 00000000000..bd69e0f3799 --- /dev/null +++ b/ndb/src/kernel/blocks/grep/systab_test/Makefile @@ -0,0 +1,12 @@ +include .defs.mk + +TYPE := kernel + +BIN_TARGET := grep_systab_test +BIN_TARGET_ARCHIVES := portlib general + +CCFLAGS_LOC += -I.. + +SOURCES = ../GrepSystemTable.cpp grep_systab_test.cpp + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/kernel/blocks/grep/systab_test/grep_systab_test.cpp b/ndb/src/kernel/blocks/grep/systab_test/grep_systab_test.cpp new file mode 100644 index 00000000000..e3a77af4e4e --- /dev/null +++ b/ndb/src/kernel/blocks/grep/systab_test/grep_systab_test.cpp @@ -0,0 +1,138 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/** + * Unit Test for GrepSystemTable + */ + +#include "../GrepSystemTable.hpp" +#include + +#define EXEC(X) ( ndbout << endl, ndbout_c(#X), X ) + +int +main () { + GrepSystemTable st; + + Uint32 f, l; + + ndbout_c("*************************************"); + ndbout_c("* GrepSystemTable Unit Test Program *"); + ndbout_c("*************************************"); + + ndbout_c("--------------------------------------------------------"); + ndbout_c("Test 1: Clear"); + ndbout_c("--------------------------------------------------------"); + + EXEC(st.set(GrepSystemTable::PS, 22, 26)); + st.print(); + st.require(GrepSystemTable::PS, 22, 26); + + EXEC(st.clear(GrepSystemTable::PS, 20, 24)); + st.print(); + st.require(GrepSystemTable::PS, 25, 26); + + EXEC(st.clear(GrepSystemTable::PS, 0, 100)); + st.print(); + st.require(GrepSystemTable::PS, 1, 0); + + EXEC(st.set(GrepSystemTable::PS, 22, 26)); + st.print(); + st.require(GrepSystemTable::PS, 22, 26); + + EXEC(st.clear(GrepSystemTable::PS, 24, 28)); + st.print(); + st.require(GrepSystemTable::PS, 22, 23); + + EXEC(st.clear(GrepSystemTable::PS, 0, 100)); + st.print(); + st.require(GrepSystemTable::PS, 1, 0); + + EXEC(st.set(GrepSystemTable::PS, 22, 26)); + st.print(); + st.require(GrepSystemTable::PS, 22, 26); + + EXEC(st.clear(GrepSystemTable::PS, 24, 26)); + st.print(); + st.require(GrepSystemTable::PS, 22, 23); + + EXEC(st.clear(GrepSystemTable::PS, 0, 100)); + st.print(); + st.require(GrepSystemTable::PS, 1, 0); + + EXEC(st.set(GrepSystemTable::PS, 22, 26)); + st.print(); + st.require(GrepSystemTable::PS, 22, 26); + + EXEC(st.clear(GrepSystemTable::PS, 22, 24)); + st.print(); + st.require(GrepSystemTable::PS, 25, 26); + + ndbout_c("--------------------------------------------------------"); + ndbout_c("Test 2: PS --> SSreq"); + ndbout_c("--------------------------------------------------------"); + + EXEC(st.set(GrepSystemTable::PS, 22, 26)); + st.print(); + st.require(GrepSystemTable::PS, 22, 26); + st.require(GrepSystemTable::SSReq, 1, 0); + + if (!EXEC(st.copy(GrepSystemTable::PS, GrepSystemTable::SSReq, 3, &f, &l))) + ndbout_c("%s:%d: Illegal copy!", __FILE__, __FILE__); + ndbout_c("f=%d, l=%d", f, l); + st.print(); + st.require(GrepSystemTable::PS, 22, 26); + st.require(GrepSystemTable::SSReq, 22, 24); + + EXEC(st.clear(GrepSystemTable::PS, 22, 22)); + st.print(); + st.require(GrepSystemTable::PS, 23, 26); + st.require(GrepSystemTable::SSReq, 22, 24); + + if (!EXEC(st.copy(GrepSystemTable::PS, GrepSystemTable::SSReq, 2, &f, &l))) + ndbout_c("%s:%d: Illegal copy!", __FILE__, __LINE__); + ndbout_c("f=%d, l=%d", f, l); + st.print(); + st.require(GrepSystemTable::PS, 23, 26); + st.require(GrepSystemTable::SSReq, 22, 26); + + st.set(GrepSystemTable::SS, 7, 9); + st.set(GrepSystemTable::InsReq, 7, 9); + if (EXEC(st.movable(GrepSystemTable::SS, GrepSystemTable::InsReq))) + ndbout_c("%s:%d: Illegal move!", __FILE__, __LINE__); + st.print(); + st.require(GrepSystemTable::SS, 7, 9); + st.require(GrepSystemTable::InsReq, 7, 9); + + EXEC(st.intervalMinus(7, 9, 7, 7, &f, &l)); + ndbout_c("f=%d, l=%d", f, l); + + st.clear(GrepSystemTable::InsReq, 8, 9); + st.require(GrepSystemTable::SS, 7, 9); + st.require(GrepSystemTable::InsReq, 7, 7); + if (EXEC(st.movable(GrepSystemTable::SS, GrepSystemTable::InsReq)) != 2) + ndbout_c("%s:%d: Illegal move!", __FILE__, __LINE__); + st.print(); + + EXEC(st.copy(GrepSystemTable::SS, GrepSystemTable::InsReq, &f)); + st.print(); + st.require(GrepSystemTable::SS, 7, 9); + st.require(GrepSystemTable::InsReq, 7, 8); + + ndbout_c("--------------------------------------------------------"); + ndbout_c("Test completed"); + ndbout_c("--------------------------------------------------------"); +} diff --git a/ndb/src/kernel/blocks/mutexes.hpp b/ndb/src/kernel/blocks/mutexes.hpp new file mode 100644 index 00000000000..5c0276fc4fa --- /dev/null +++ b/ndb/src/kernel/blocks/mutexes.hpp @@ -0,0 +1,39 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef KERNEL_MUTEXES_HPP +#define KERNEL_MUTEXES_HPP + +#include + +/** + * This mutex is used by: + * DIH - before sending START_LCP to all participants + * DICT - before commiting a CREATE TABLE + * BACKUP - before sending DEFINE_BACKUP + */ +#define DIH_START_LCP_MUTEX 0 +#define DICT_COMMIT_TABLE_MUTEX 0 + +/** + * This mutex is used by + * DIH - before switching primary replica + * BACKUP - before sending DEFINE_BACKUP + */ +#define DIH_SWITCH_PRIMARY_MUTEX 1 +#define BACKUP_DEFINE_MUTEX 1 + +#endif diff --git a/ndb/src/kernel/blocks/ndbcntr/Makefile b/ndb/src/kernel/blocks/ndbcntr/Makefile new file mode 100644 index 00000000000..8e9c4f01027 --- /dev/null +++ b/ndb/src/kernel/blocks/ndbcntr/Makefile @@ -0,0 +1,12 @@ +include .defs.mk + +TYPE := kernel + +ARCHIVE_TARGET := ndbcntr + +SOURCES = \ + NdbcntrInit.cpp \ + NdbcntrSysTable.cpp \ + NdbcntrMain.cpp + +include $(NDB_TOP)/Epilogue.mk diff --git a/ndb/src/kernel/blocks/ndbcntr/Ndbcntr.hpp b/ndb/src/kernel/blocks/ndbcntr/Ndbcntr.hpp new file mode 100644 index 00000000000..a481573e370 --- /dev/null +++ b/ndb/src/kernel/blocks/ndbcntr/Ndbcntr.hpp @@ -0,0 +1,513 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef NDBCNTR_H +#define NDBCNTR_H + + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#ifdef NDBCNTR_C +/* +2.1 GLOBAL SYMBOLS +------------------ +*/ +/* +2.2 LOCAL SYMBOLS +----------------- +*/ +#define ZNO_NDB_BLOCKS 6 /* ACC, DICT, DIH, LQH, TC, TUP */ +#define ZDELAY_NODERESTART 5 /* MASTER REFUSED NODERESTART, WAIT SEC */ +#define ZDELAY_START 25 /* WAIT SECONDS FOR OTHER NODES, RESTART*/ +#define ZHB_INTERVAL 10 /* HEART BEAT INTERVAL TIME MS */ +#define ZNO_NDB_NODES 1 +#define ZHB_TYPE 1 + +//------- ERROR CODES ----------------------------------------- +#define ZERROR_ALREADY_EXISTS 901 +#define ZERROR_DOESNT_EXIST 902 +#define ZERROR_VALUE_OUT_OF_RANGE 903 +#define ZERROR_NOT_STARTED 904 +#define ZERROR_NODE_RESTART 905 +#define ZERROR_NO_RESTART_NODES 906 +#define ZERROR_STARTPHASE_VALUE 907 +#define ZERROR_CNTR_MASTERREQ 908 +#define ZERROR_CNTR_MASTERREF 909 +#define ZERROR_CNTR_MASTERCONF 910 +#define ZERROR_NOT_RUNNING 911 +#define ZERROR_CNTR_WAITREP 912 +#define ZNOT_AVAILABLE 913 +#define ZERROR_DISK_FAILURE 914 +#define ZERROR_TOO_MANY_NODES 915 +#define ZERROR_TYPEOFSTART 916 +#define ZERROR_CTYPE_OF_START 917 +#define ZERROR_ZSTART 918 +#define ZERROR_AT_SELECT_START 919 +#define ZERROR_CNTR_CHANGEREP 920 +#define ZERR_DETECT_NODERESTART_1 921 +#define ZERR_DETECT_NODERESTART_2 922 +#define ZERROR_CONTINUEB 923 +#define ZERR_APPL_REGREF 924 +#define ZERR_DICTADDATTRREF 925 +#define ZERR_DICTPREPAREREF 926 +#define ZERR_DICTRELEASEREF 927 +#define ZERR_DICTTABREF 928 +#define ZERR_DICTSEIZEREF 929 +#define ZERR_NDB_STARTREF 930 +#define ZERR_NODE_STATESREF 931 +#define ZERR_READ_NODESREF 932 +#define ZERR_TCKEYREF 933 +#define ZERR_TCRELEASEREF 934 +#define ZERR_TCSEIZEREF 935 +#define ZNOTVALIDSTATE_1 936 +#define ZNOTVALIDSTATE_2 937 +#define ZNODE_FAILURE_DURING_RESTART 938 +#define ZSTART_IN_PROGRESS_ERROR 939 +#define ZCOULD_NOT_OCCUR_ERROR 940 +#define ZTOO_MANY_NODES_ERROR 941 +#define ZNODE_RESTART_ONGOING_ERROR 942 +#define ZWE_ARE_DECLARED_DEAD_ERROR 943 +#define ZTIME_OUT_ERROR 944 +#define ZTYPE_OF_START_ERROR 945 +#define ZMASTER_CONFLICT_ERROR 946 +#define ZNODE_CONFLICT_ERROR 947 + +//------- OTHERS --------------------------------------------- +#define ZCONTINUEB_1 1 +#define ZCONTINUEB_2 2 +#define ZSHUTDOWN 3 + +#define ZAPPL_SUBTYPE 0 +#define ZNAME_OF_APPL "NDB" +#define ZVOTING 2 +#define ZSIZE_CFG_BLOCK_REC 8 +#define ZSIZE_NDB_BLOCKS_REC 16 /* MAX BLOCKS IN NDB */ +#define ZSIZE_SYSTAB 2048 +#define ZSTART_PHASE_1 1 +#define ZSTART_PHASE_2 2 +#define ZSTART_PHASE_3 3 +#define ZSTART_PHASE_4 4 +#define ZSTART_PHASE_5 5 +#define ZSTART_PHASE_6 6 +#define ZSTART_PHASE_7 7 +#define ZSTART_PHASE_8 8 +#define ZSTART_PHASE_9 9 +#define ZSTART_PHASE_END 255 +#define ZWAITPOINT_4_1 1 +#define ZWAITPOINT_4_2 2 +#define ZWAITPOINT_5_1 3 +#define ZWAITPOINT_5_2 4 +#define ZWAITPOINT_6_1 5 +#define ZWAITPOINT_6_2 6 +#define ZWAITPOINT_7_1 7 +#define ZWAITPOINT_7_2 8 +#define ZSYSTAB_VERSION 1 +/* +------- SIGNAL CONSTANTS ----------------------------------- +*/ +#define ZNOT_MASTER 0 +/* REASON OF CNTR_MASTERREF */ +#define ZTOO_FEW_NODES 1 +#define ZNEW_MASTER 0 +#define ZDELETE_NODE 1 +#define ZSYSTAB_EXIST 3 +#define ZVOTE_NEW_NODE 4 +#define ZVARIABLE_NO 1 +#define ZAMOUNT_PAGES 8 +#endif + +class Ndbcntr: public SimulatedBlock { +public: + // State values + enum State { + NOT_ACTIVE = 0, + ACTIVE = 1 + }; + +// Records + +/* FSREADREQ FSWRITEREQ */ +/** + * 2.3 RECORDS AND FILESIZES + * ------------------------------------------------------------ + */ + +/** + * CFG_BLOCK_REC CONTAINS ALL CONFIG DATA SENT IN EACH NDB_STTOR + * SOME OTHER CONFIG DATA IS STORED IN RECORD 0 + * + * WHEN CFG_BLOCK_PTR = ZSTART_PHASE_X ( CINTERNAL_STARTPHASE ) + * WORD 0 DICT_1 + * WORD 1 DICT_2 + * WORD 2 DIH_1 + * WORD 3 DIH_2 + * WORD 4 LQH_1 + * WORD 5 LQH_2 + * WORD 6 TC_1 + * WORD 7 TC_2 + * WORD 8 TUP_1 + * WORD 9 TUP_2 + * WORD 10 ACC_1 + * WORD 11 ACC_2 + * + * CFG_BLOCK_PTR = 0 + * WORD 0 CDELAY_START + * WORD 1 CDELAY_NODERESTART + *------------------------------------------------------------------------*/ + struct CfgBlockRec { + UintR cfgData[CmvmiCfgConf::NO_OF_WORDS]; + }; /* p2c: size = 64 bytes */ + + typedef Ptr CfgBlockRecPtr; + +/*------------------------------------------------------------------------*/ +// CONTAIN INFO ABOUT ALL NODES IN CLUSTER. NODE_PTR ARE USED AS NODE NUMBER. +// IF THE STATE ARE ZDELETE THEN THE NODE DOESN'T EXIST. NODES ARE ALLOWED +// TO REGISTER (ZADD) DURING RESTART. +// WHEN THE SYSTEM IS RUNNING THE MASTER WILL CHECK IF ANY NODE HAS MADE A +// CNTR_MASTERREQ AND TAKE CARE OF THE +// REQUEST. TO CONFIRM THE REQ, THE MASTER DEMANDS THAT ALL RUNNING NODES HAS +// VOTED FOR THE NEW NODE. +// NODE_PTR:MASTER_REQ IS USED DURING RESTART TO LOG POSTPONED +// CNTR_MASTERREQ'S +/*------------------------------------------------------------------------*/ + struct NodeRec { + UintR dynamicId; + BlockReference cntrBlockref; + Uint16 masterReq; + Uint16 state; + Uint16 ndbVersion; + Uint16 subType; + Uint8 votes; + Uint8 voter; + UintR nodeDefined; + }; /* p2c: size = 16 bytes */ + + typedef Ptr NodeRecPtr; + + struct NdbBlocksRec { + BlockReference blockref; + }; /* p2c: size = 2 bytes */ + + typedef Ptr NdbBlocksRecPtr; + + /** + * Ndbcntr creates and initializes system tables on initial system start. + * The tables are defined in static structs in NdbcntrSysTable.cpp. + */ + struct SysColumn { + unsigned pos; + const char* name; + // DictTabInfo + DictTabInfo::ExtType type; + Uint32 length; + bool keyFlag; + bool nullable; + }; + struct SysTable { + const char* name; + unsigned columnCount; + const SysColumn* columnList; + // DictTabInfo + DictTabInfo::TableType tableType; + DictTabInfo::FragmentType fragmentType; + bool tableLoggedFlag; + // saved table id + mutable Uint32 tableId; + }; + struct SysIndex { + const char* name; + const SysTable* primaryTable; + Uint32 columnCount; + Uint32 columnList[4]; + // DictTabInfo + DictTabInfo::TableType indexType; + DictTabInfo::FragmentType fragmentType; + bool indexLoggedFlag; + // saved index table id + mutable Uint32 indexId; + }; + static const SysTable* g_sysTableList[]; + static const unsigned g_sysTableCount; + // the system tables + static const SysTable g_sysTable_SYSTAB_0; + static const SysTable g_sysTable_NDBEVENTS_0; + +public: + Ndbcntr(const class Configuration &); + virtual ~Ndbcntr(); + +private: + BLOCK_DEFINES(Ndbcntr); + + // Transit signals + void execCONTINUEB(Signal* signal); + void execREAD_NODESCONF(Signal* signal); + void execREAD_NODESREF(Signal* signal); + void execCNTR_MASTERREQ(Signal* signal); + void execCNTR_MASTERCONF(Signal* signal); + void execCNTR_MASTERREF(Signal* signal); + void execCNTR_WAITREP(Signal* signal); + void execNODE_STATESREQ(Signal* signal); + void execNODE_STATESCONF(Signal* signal); + void execNODE_STATESREF(Signal* signal); + void execNODE_FAILREP(Signal* signal); + void execSYSTEM_ERROR(Signal* signal); + void execVOTE_MASTERORD(Signal* signal); + + // Received signals + void execDUMP_STATE_ORD(Signal* signal); + void execSTTOR(Signal* signal); + void execTCSEIZECONF(Signal* signal); + void execTCSEIZEREF(Signal* signal); + void execTCRELEASECONF(Signal* signal); + void execTCRELEASEREF(Signal* signal); + void execTCKEYCONF(Signal* signal); + void execTCKEYREF(Signal* signal); + void execTCROLLBACKREP(Signal* signal); + void execGETGCICONF(Signal* signal); + void execDIH_RESTARTCONF(Signal* signal); + void execDIH_RESTARTREF(Signal* signal); + void execCREATE_TABLE_REF(Signal* signal); + void execCREATE_TABLE_CONF(Signal* signal); + void execNDB_STTORRY(Signal* signal); + void execNDB_STARTCONF(Signal* signal); + void execREAD_NODESREQ(Signal* signal); + void execAPPL_REGCONF(Signal* signal); + void execAPPL_REGREF(Signal* signal); + void execAPPL_CHANGEREP(Signal* signal); + void execAPPL_STARTCONF(Signal* signal); + void execNDB_STARTREF(Signal* signal); + void execCMVMI_CFGCONF(Signal* signal); + void execSET_VAR_REQ(Signal* signal); + + void execSTOP_PERM_REF(Signal* signal); + void execSTOP_PERM_CONF(Signal* signal); + + void execSTOP_ME_REF(Signal* signal); + void execSTOP_ME_CONF(Signal* signal); + + void execWAIT_GCP_REF(Signal* signal); + void execWAIT_GCP_CONF(Signal* signal); + + void execSTOP_REQ(Signal* signal); + void execRESUME_REQ(Signal* signal); + + void execCHANGE_NODE_STATE_CONF(Signal* signal); + + void execABORT_ALL_REF(Signal* signal); + void execABORT_ALL_CONF(Signal* signal); + + // Statement blocks + void sendCreateTabReq(Signal* signal, const char* buffer, Uint32 bufLen); + void startInsertTransactions(Signal* signal); + UintR checkNodelist(Signal* signal, Uint16 TnoRestartNodes); + void chooseRestartNodes(Signal* signal); + void copyCfgVariables(Signal* signal); + void deleteNode(Signal* signal); + void detectNoderestart(Signal* signal); + void getStartNodes(Signal* signal); + void initData(Signal* signal); + void replyMasterconfToAll(Signal* signal); + void resetStartVariables(Signal* signal); + void sendCntrMasterreq(Signal* signal); + void sendNdbSttor(Signal* signal); + void sendSttorry(Signal* signal); + + // Generated statement blocks + void systemErrorLab(Signal* signal); + + void createSystableLab(Signal* signal, unsigned index); + void crSystab7Lab(Signal* signal); + void crSystab8Lab(Signal* signal); + void crSystab9Lab(Signal* signal); + + void startPhase1Lab(Signal* signal); + void startPhase2Lab(Signal* signal); + void startPhase3Lab(Signal* signal); + void startPhase4Lab(Signal* signal); + void startPhase5Lab(Signal* signal); + // jump 2 to resync phase counters + void startPhase8Lab(Signal* signal); + void startPhase9Lab(Signal* signal); + void ph2ALab(Signal* signal); + void ph2CLab(Signal* signal); + void ph2ELab(Signal* signal); + void ph2FLab(Signal* signal); + void ph2GLab(Signal* signal); + void ph3ALab(Signal* signal); + void ph4ALab(Signal* signal); + void ph4BLab(Signal* signal); + void ph4CLab(Signal* signal); + void ph5ALab(Signal* signal); + void ph6ALab(Signal* signal); + void ph6BLab(Signal* signal); + void ph7ALab(Signal* signal); + void ph8ALab(Signal* signal); + + void masterreq010Lab(Signal* signal, + Uint16 TnoRestartNodes, + Uint16 TuserNodeId); + void masterreq020Lab(Signal* signal); + void masterreq030Lab(Signal* signal, + Uint16 TnoRestartNodes, + Uint16 TuserNodeId); + + void waitpoint41Lab(Signal* signal); + void waitpoint51Lab(Signal* signal); + void waitpoint52Lab(Signal* signal); + void waitpoint61Lab(Signal* signal); + void waitpoint71Lab(Signal* signal); + + void updateNodeState(Signal* signal, const NodeState & newState) const ; + void getNodeGroup(Signal* signal); + + // Initialisation + void initData(); + void initRecords(); + + // Variables + /**------------------------------------------------------------------------ + * CONTAIN INFO ABOUT ALL NODES IN CLUSTER. NODE_PTR ARE USED AS NODE NUMBER + * IF THE STATE ARE ZDELETE THEN THE NODE DOESN'T EXIST. NODES ARE ALLOWED + * TO REGISTER (ZADD) DURING RESTART. + * + * WHEN THE SYSTEM IS RUNNING THE MASTER WILL CHECK IF ANY NODE HAS MADE + * A CNTR_MASTERREQ AND TAKE CARE OF THE REQUEST. + * TO CONFIRM THE REQ, THE MASTER DEMANDS THAT ALL RUNNING NODES HAS VOTED + * FOR THE NEW NODE. + * NODE_PTR:MASTER_REQ IS USED DURING RESTART TO LOG + * POSTPONED CNTR_MASTERREQ'S + *------------------------------------------------------------------------*/ + CfgBlockRec *cfgBlockRec; + NodeRec *nodeRec; + NdbBlocksRec *ndbBlocksRec; + NodeRecPtr nodePtr; +/* +2.4 COMMON STORED VARIABLES +*/ + Uint16 cstartNodes[MAX_NDB_NODES]; + BlockReference ccmvmiBlockref; + BlockReference cqmgrBlockref; + BlockReference cdictBlockref; + BlockReference cdihBlockref; + BlockReference clqhBlockref; + BlockReference cownBlockref; + BlockReference ctcBlockref; + UintR cnoNdbNodes; + UintR capplStartconfFlag; + UintR cgciSystab; + UintR ckey; + UintR cnoRegNodes; + UintR cnoRunNodes; + UintR cnoNeedNodes; + UintR cnoWaitrep; + UintR cnoWaitrep6; + UintR cnoWaitrep7; + //UintR csystabId; + UintR ctcConnectionP; + UintR ctcReqInfo; + UintR clastGci; + UintR cmasterLastGci; + UintR cmasterCurrentId; + Uint16 cmasterDihId; + Uint16 cresponses; + Uint16 cdelayStart; + + Uint16 cinternalStartphase; + Uint16 cmasterNodeId; + Uint16 cmasterCandidateId; + Uint16 cndbBlocksCount; + Uint16 cnoStartNodes; + Uint16 cnoVoters; + Uint16 cstartProgressFlag; + Uint16 cqmgrConnectionP; + Uint16 csignalKey; + NodeState::StartType ctypeOfStart; + Uint16 cmasterVoters; + Uint16 cdynamicNodeId; + Uint8 cwaitContinuebFlag; + Uint8 cstartPhase; + Uint8 ctransidPhase; + + Uint32 c_fsRemoveCount; + Uint32 c_nodeGroup; + void clearFilesystem(Signal* signal); + void execFSREMOVEREF(Signal* signal); + void execFSREMOVECONF(Signal* signal); + +public: + struct StopRecord { + public: + StopRecord(Ndbcntr & _cntr) : cntr(_cntr) { + stopReq.senderRef = 0; + } + + Ndbcntr & cntr; + StopReq stopReq; // Signal data + NDB_TICKS stopInitiatedTime; // When was the stop initiated + + bool checkNodeFail(Signal* signal); + void checkTimeout(Signal* signal); + void checkApiTimeout(Signal* signal); + void checkTcTimeout(Signal* signal); + void checkLqhTimeout_1(Signal* signal); + void checkLqhTimeout_2(Signal* signal); + + BlockNumber number() const { return cntr.number(); } + void progError(int line, int cause, const char * extra) { + cntr.progError(line, cause, extra); + } + }; +private: + StopRecord c_stopRec; + friend struct StopRecord; + + struct Missra { + Missra(Ndbcntr & ref) : cntr(ref) { } + + Uint32 currentBlockIndex; + Uint32 currentStartPhase; + Uint32 nextStartPhase[NO_OF_BLOCKS]; + + void execSTART_ORD(Signal* signal); + void execSTTORRY(Signal* signal); + void sendNextSTTOR(Signal* signal); + + BlockNumber number() const { return cntr.number(); } + void progError(int line, int cause, const char * extra) { + cntr.progError(line, cause, extra); + } + Ndbcntr & cntr; + }; + + Missra c_missra; + friend struct Missra; + + void execSTTORRY(Signal* signal); + void execSTART_ORD(Signal* signal); +}; + +#endif diff --git a/ndb/src/kernel/blocks/ndbcntr/NdbcntrInit.cpp b/ndb/src/kernel/blocks/ndbcntr/NdbcntrInit.cpp new file mode 100644 index 00000000000..9af6359876b --- /dev/null +++ b/ndb/src/kernel/blocks/ndbcntr/NdbcntrInit.cpp @@ -0,0 +1,126 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + + +#define NDBCNTR_C +#include "Ndbcntr.hpp" +#include + +#define DEBUG(x) { ndbout << "Ndbcntr::" << x << endl; } + + +void Ndbcntr::initData() +{ + + // Records with constant sizes + cfgBlockRec = new CfgBlockRec[ZSIZE_CFG_BLOCK_REC]; + nodeRec = new NodeRec[MAX_NDB_NODES]; + ndbBlocksRec = new NdbBlocksRec[ZSIZE_NDB_BLOCKS_REC]; +}//Ndbcntr::initData() + +void Ndbcntr::initRecords() +{ + // Records with dynamic sizes +}//Ndbcntr::initRecords() + +Ndbcntr::Ndbcntr(const class Configuration & conf): + SimulatedBlock(NDBCNTR, conf), + c_stopRec(* this), + c_missra(* this), + cnoWaitrep6(0), + cnoWaitrep7(0) +{ + + BLOCK_CONSTRUCTOR(Ndbcntr); + + // Transit signals + addRecSignal(GSN_CONTINUEB, &Ndbcntr::execCONTINUEB); + addRecSignal(GSN_READ_NODESCONF, &Ndbcntr::execREAD_NODESCONF); + addRecSignal(GSN_READ_NODESREF, &Ndbcntr::execREAD_NODESREF); + addRecSignal(GSN_CNTR_MASTERREQ, &Ndbcntr::execCNTR_MASTERREQ); + addRecSignal(GSN_CNTR_MASTERCONF, &Ndbcntr::execCNTR_MASTERCONF); + addRecSignal(GSN_CNTR_MASTERREF, &Ndbcntr::execCNTR_MASTERREF); + addRecSignal(GSN_CNTR_WAITREP, &Ndbcntr::execCNTR_WAITREP); + addRecSignal(GSN_NODE_STATESREQ, &Ndbcntr::execNODE_STATESREQ); + addRecSignal(GSN_NODE_STATESCONF, &Ndbcntr::execNODE_STATESCONF); + addRecSignal(GSN_NODE_STATESREF, &Ndbcntr::execNODE_STATESREF); + addRecSignal(GSN_NODE_FAILREP, &Ndbcntr::execNODE_FAILREP); + addRecSignal(GSN_SYSTEM_ERROR , &Ndbcntr::execSYSTEM_ERROR); + addRecSignal(GSN_VOTE_MASTERORD, &Ndbcntr::execVOTE_MASTERORD); + + // Received signals + addRecSignal(GSN_DUMP_STATE_ORD, &Ndbcntr::execDUMP_STATE_ORD); + addRecSignal(GSN_STTOR, &Ndbcntr::execSTTOR); + addRecSignal(GSN_TCSEIZECONF, &Ndbcntr::execTCSEIZECONF); + addRecSignal(GSN_TCSEIZEREF, &Ndbcntr::execTCSEIZEREF); + addRecSignal(GSN_TCRELEASECONF, &Ndbcntr::execTCRELEASECONF); + addRecSignal(GSN_TCRELEASEREF, &Ndbcntr::execTCRELEASEREF); + addRecSignal(GSN_TCKEYCONF, &Ndbcntr::execTCKEYCONF); + addRecSignal(GSN_TCKEYREF, &Ndbcntr::execTCKEYREF); + addRecSignal(GSN_TCROLLBACKREP, &Ndbcntr::execTCROLLBACKREP); + addRecSignal(GSN_GETGCICONF, &Ndbcntr::execGETGCICONF); + addRecSignal(GSN_DIH_RESTARTCONF, &Ndbcntr::execDIH_RESTARTCONF); + addRecSignal(GSN_DIH_RESTARTREF, &Ndbcntr::execDIH_RESTARTREF); + addRecSignal(GSN_CREATE_TABLE_REF, &Ndbcntr::execCREATE_TABLE_REF); + addRecSignal(GSN_CREATE_TABLE_CONF, &Ndbcntr::execCREATE_TABLE_CONF); + addRecSignal(GSN_NDB_STTORRY, &Ndbcntr::execNDB_STTORRY); + addRecSignal(GSN_NDB_STARTCONF, &Ndbcntr::execNDB_STARTCONF); + addRecSignal(GSN_READ_NODESREQ, &Ndbcntr::execREAD_NODESREQ); + addRecSignal(GSN_APPL_REGCONF, &Ndbcntr::execAPPL_REGCONF); + addRecSignal(GSN_APPL_REGREF, &Ndbcntr::execAPPL_REGREF); + addRecSignal(GSN_APPL_CHANGEREP, &Ndbcntr::execAPPL_CHANGEREP); + addRecSignal(GSN_APPL_STARTCONF, &Ndbcntr::execAPPL_STARTCONF); + addRecSignal(GSN_NDB_STARTREF, &Ndbcntr::execNDB_STARTREF); + addRecSignal(GSN_CMVMI_CFGCONF, &Ndbcntr::execCMVMI_CFGCONF); + addRecSignal(GSN_SET_VAR_REQ, &Ndbcntr::execSET_VAR_REQ); + + addRecSignal(GSN_STOP_PERM_REF, &Ndbcntr::execSTOP_PERM_REF); + addRecSignal(GSN_STOP_PERM_CONF, &Ndbcntr::execSTOP_PERM_CONF); + + addRecSignal(GSN_STOP_ME_REF, &Ndbcntr::execSTOP_ME_REF); + addRecSignal(GSN_STOP_ME_CONF, &Ndbcntr::execSTOP_ME_CONF); + + addRecSignal(GSN_STOP_REQ, &Ndbcntr::execSTOP_REQ); + addRecSignal(GSN_RESUME_REQ, &Ndbcntr::execRESUME_REQ); + + addRecSignal(GSN_WAIT_GCP_REF, &Ndbcntr::execWAIT_GCP_REF); + addRecSignal(GSN_WAIT_GCP_CONF, &Ndbcntr::execWAIT_GCP_CONF); + addRecSignal(GSN_CHANGE_NODE_STATE_CONF, + &Ndbcntr::execCHANGE_NODE_STATE_CONF); + + addRecSignal(GSN_ABORT_ALL_REF, &Ndbcntr::execABORT_ALL_REF); + addRecSignal(GSN_ABORT_ALL_CONF, &Ndbcntr::execABORT_ALL_CONF); + + addRecSignal(GSN_START_ORD, &Ndbcntr::execSTART_ORD); + addRecSignal(GSN_STTORRY, &Ndbcntr::execSTTORRY); + + addRecSignal(GSN_FSREMOVEREF, &Ndbcntr::execFSREMOVEREF); + addRecSignal(GSN_FSREMOVECONF, &Ndbcntr::execFSREMOVECONF); + + initData(); + ctypeOfStart = NodeState::ST_ILLEGAL_TYPE; +}//Ndbcntr::Ndbcntr() + +Ndbcntr::~Ndbcntr() +{ + delete []cfgBlockRec; + delete []nodeRec; + delete []ndbBlocksRec; + +}//Ndbcntr::~Ndbcntr() + +BLOCK_FUNCTIONS(Ndbcntr); diff --git a/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp b/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp new file mode 100644 index 00000000000..6f30ff2c511 --- /dev/null +++ b/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp @@ -0,0 +1,3385 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#define NDBCNTR_C +#include "Ndbcntr.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include + +#include +#include + +#define ZSYSTEM_RUN 256 + +/** + * ALL_BLOCKS Used during start phases and while changing node state + * + * NDBFS_REF Has to be before NDBCNTR_REF (due to "ndb -i" stuff) + */ +struct BlockInfo { + BlockReference Ref; // BlockReference + Uint32 NextSP; // Next start phase +}; + +static BlockInfo ALL_BLOCKS[] = { + { DBTC_REF, 1 }, + { DBDIH_REF, 1 }, + { DBLQH_REF, 1 }, + { DBACC_REF, 1 }, + { DBTUP_REF, 1 }, + { DBDICT_REF, 1 }, + { NDBFS_REF, 0 }, + { NDBCNTR_REF, 0 }, + { QMGR_REF, 1 }, + { CMVMI_REF, 1 }, + { TRIX_REF, 1 }, + { BACKUP_REF, 1 }, + { DBUTIL_REF, 1 }, + { SUMA_REF, 1 }, + { GREP_REF, 1 }, + { DBTUX_REF, 1 } +}; + +static const Uint32 ALL_BLOCKS_SZ = sizeof(ALL_BLOCKS)/sizeof(BlockInfo); + +/*******************************/ +/* CONTINUEB */ +/*******************************/ +void Ndbcntr::execCONTINUEB(Signal* signal) +{ + jamEntry(); + UintR Ttemp1 = signal->theData[0]; + switch (Ttemp1) { + case ZCONTINUEB_1: + jam(); + if (cwaitContinuebFlag == ZFALSE) { + jam(); +/*******************************/ +/* SIGNAL NOT WANTED ANYMORE */ +/*******************************/ + return; + } else { + jam(); +/*******************************/ +/* START ALREADY IN PROGRESS */ +/*******************************/ + if (cstartProgressFlag == ZVOTING) { + jam(); + systemErrorLab(signal); + return; + }//if + if (ctypeOfStart == NodeState::ST_NODE_RESTART) { + jam(); + systemErrorLab(signal); + return; + }//if + ph2ELab(signal); + return; + }//if + break; + case ZSHUTDOWN: + jam(); + c_stopRec.checkTimeout(signal); + break; + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch +}//Ndbcntr::execCONTINUEB() + +/*******************************/ +/* SYSTEM_ERROR */ +/*******************************/ +void Ndbcntr::execSYSTEM_ERROR(Signal* signal) +{ + const SystemError * const sysErr = (SystemError *)signal->getDataPtr(); + char buf[100]; + int killingNode = refToNode(sysErr->errorRef); + + jamEntry(); + switch (sysErr->errorCode){ + case SystemError::StartInProgressError: + snprintf(buf, sizeof(buf), + "Node %d killed this node because " + "master start in progress error", + killingNode); + break; + + case SystemError::GCPStopDetected: + snprintf(buf, sizeof(buf), + "Node %d killed this node because " + "GCP stop was detected", + killingNode); + break; + + case SystemError::ScanfragTimeout: + snprintf(buf, sizeof(buf), + "Node %d killed this node because " + "a fragment scan timed out and could not be stopped", + killingNode); + break; + + case SystemError::ScanfragStateError: + snprintf(buf, sizeof(buf), + "Node %d killed this node because " + "the state of a fragment scan was out of sync.", + killingNode); + break; + + case SystemError::CopyFragRefError: + snprintf(buf, sizeof(buf), + "Node %d killed this node because " + "it could not copy a fragment during node restart", + killingNode); + break; + + default: + snprintf(buf, sizeof(buf), "System error %d, " + " this node was killed by node %d", + sysErr->errorCode, killingNode); + break; + } + + progError(__LINE__, + ERR_SYSTEM_ERROR, + buf); + return; +}//Ndbcntr::execSYSTEM_ERROR() + +/*---------------------------------------------------------------------------*/ +/* The STTOR signal is on level C, we use CONTINUEB to get into level B */ +/*---------------------------------------------------------------------------*/ +/**************************** >----------------------------------------------*/ +/* STTOR > SENDER : MISSRA */ +/**************************** >------------------+ RECEIVER : NDBCNTR */ + /* INPUT : CSTART_PHASE */ + /* CSIGNAL_KEY */ + /*---------------------------*/ +/*******************************/ +/* STTOR */ +/*******************************/ +void Ndbcntr::execSTTOR(Signal* signal) +{ + jamEntry(); + cstartPhase = signal->theData[1]; + csignalKey = signal->theData[6]; + + NodeState newState(NodeState::SL_STARTING, cstartPhase, + (NodeState::StartType)ctypeOfStart); + updateNodeState(signal, newState); + + switch (cstartPhase) { + case 0: + if(theConfiguration.getInitialStart()){ + jam(); + c_fsRemoveCount = 0; + clearFilesystem(signal); + return; + } + sendSttorry(signal); + break; + case ZSTART_PHASE_1: + jam(); + startPhase1Lab(signal); + break; + case ZSTART_PHASE_2: + jam(); + startPhase2Lab(signal); + break; + case ZSTART_PHASE_3: + jam(); + startPhase3Lab(signal); + break; + case ZSTART_PHASE_4: + jam(); + startPhase4Lab(signal); + break; + case ZSTART_PHASE_5: + jam(); + startPhase5Lab(signal); + break; + case 6: + jam(); + getNodeGroup(signal); + break; + case ZSTART_PHASE_8: + jam(); + startPhase8Lab(signal); + break; + case ZSTART_PHASE_9: + jam(); + startPhase9Lab(signal); + break; + default: + jam(); + sendSttorry(signal); + break; + }//switch +}//Ndbcntr::execSTTOR() + +void +Ndbcntr::getNodeGroup(Signal* signal){ + jam(); + CheckNodeGroups * sd = (CheckNodeGroups*)signal->getDataPtrSend(); + sd->requestType = CheckNodeGroups::Direct | CheckNodeGroups::GetNodeGroup; + EXECUTE_DIRECT(DBDIH, GSN_CHECKNODEGROUPSREQ, signal, + CheckNodeGroups::SignalLength); + jamEntry(); + c_nodeGroup = sd->output; + sendSttorry(signal); +} + +/*******************************/ +/* NDB_STTORRY */ +/*******************************/ +void Ndbcntr::execNDB_STTORRY(Signal* signal) +{ + jamEntry(); + switch (cstartPhase) { + case ZSTART_PHASE_2: + jam(); + ph2GLab(signal); + return; + break; + case ZSTART_PHASE_3: + jam(); + ph3ALab(signal); + return; + break; + case ZSTART_PHASE_4: + jam(); + ph4BLab(signal); + return; + break; + case ZSTART_PHASE_5: + jam(); + ph5ALab(signal); + return; + break; + case ZSTART_PHASE_6: + jam(); + ph6ALab(signal); + return; + break; + case ZSTART_PHASE_7: + jam(); + ph6BLab(signal); + return; + break; + case ZSTART_PHASE_8: + jam(); + ph7ALab(signal); + return; + break; + case ZSTART_PHASE_9: + jam(); + ph8ALab(signal); + return; + break; + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch +}//Ndbcntr::execNDB_STTORRY() + +/* +4.2 START PHASE 1 */ +/*###########################################################################*/ +/*LOAD OUR BLOCK REFERENCE AND OUR NODE ID. LOAD NODE IDS OF ALL NODES IN */ +/* CLUSTER CALCULATE BLOCK REFERENCES OF ALL BLOCKS IN THIS NODE */ +/*---------------------------------------------------------------------------*/ +/*******************************/ +/* STTOR */ +/*******************************/ +void Ndbcntr::startPhase1Lab(Signal* signal) +{ + jamEntry(); + + initData(signal); + cownBlockref = calcNdbCntrBlockRef(0); + cnoRunNodes = 0; + cnoRegNodes = 0; + + NdbBlocksRecPtr ndbBlocksPtr; + + cdynamicNodeId = 0; + cownBlockref = calcNdbCntrBlockRef(getOwnNodeId()); + cqmgrBlockref = calcQmgrBlockRef(getOwnNodeId()); + cdictBlockref = calcDictBlockRef(getOwnNodeId()); + cdihBlockref = calcDihBlockRef(getOwnNodeId()); + clqhBlockref = calcLqhBlockRef(getOwnNodeId()); + ctcBlockref = calcTcBlockRef(getOwnNodeId()); + ccmvmiBlockref = numberToRef(CMVMI, getOwnNodeId()); + + ndbBlocksPtr.i = 0; + ptrAss(ndbBlocksPtr, ndbBlocksRec); + ndbBlocksPtr.p->blockref = clqhBlockref; + ndbBlocksPtr.i = 1; + ptrAss(ndbBlocksPtr, ndbBlocksRec); + ndbBlocksPtr.p->blockref = cdictBlockref; + ndbBlocksPtr.i = 2; + ptrAss(ndbBlocksPtr, ndbBlocksRec); + ndbBlocksPtr.p->blockref = calcTupBlockRef(getOwnNodeId()); + ndbBlocksPtr.i = 3; + ptrAss(ndbBlocksPtr, ndbBlocksRec); + ndbBlocksPtr.p->blockref = calcAccBlockRef(getOwnNodeId()); + ndbBlocksPtr.i = 4; + ptrAss(ndbBlocksPtr, ndbBlocksRec); + ndbBlocksPtr.p->blockref = ctcBlockref; + ndbBlocksPtr.i = 5; + ptrAss(ndbBlocksPtr, ndbBlocksRec); + ndbBlocksPtr.p->blockref = cdihBlockref; + sendSttorry(signal); + return; +} + +/* +4.3 START PHASE 2 */ +/*###########################################################################*/ +// SEND A REGISTATION REQUEST TO QMGR AND WAIT FOR REPLY APPL_REGCONF OR +// APPL_REGREF COLLECT ALL OTHER NDB NODES +// AND THEIR STATES FIND OUT WHAT KIND OF START THIS NODE ARE GOING TO PERFORM +// IF THIS IS A SYSTEM OR INITIAL +// RESTART THEN FIND OUT WHO IS THE MASTER IF THIS NODE BECOME THE CNTR MASTER +// THEN COLLECT CNTR_MASTERREQ FROM +// ALL OTHER REGISTRATED CNTR THE MASTER WILL SEND BACK A CNTR_MASTERCONF WITH +// FINAL DECISSION ABOUT WHAT TYPE +// OF START AND WHICH NODES ARE APPROVED TO PARTICIPATE IN THE START IF THE +// RECEIVER OF CNTR_MASTERREQ HAVE A +// BETTER CHOICE OF MASTER THEN SEND CNTR_MASTERREF. NEW NODES ARE ALWAYS +// ALLOWED TO REGISTER, EVEN DURING +// RESTART BUT THEY WILL BE IGNORED UNTIL THE START HAVE FINISHED. +// SEND SIGNAL NDBSTTOR TO ALL BLOCKS, ACC, DICT, DIH, LQH, TC AND TUP +// SEND SIGNAL APPL_REGREQ TO QMGR IN THIS NODE AND WAIT FOR REPLY +// APPL_REGCONF OR APPL_REGREF */ +/*--------------------------------------------------------------------------*/ +/*******************************/ +/* READ_NODESREF */ +/*******************************/ +void Ndbcntr::execREAD_NODESREF(Signal* signal) +{ + jamEntry(); + systemErrorLab(signal); + return; +}//Ndbcntr::execREAD_NODESREF() + +/*******************************/ +/* APPL_REGREF */ +/*******************************/ +void Ndbcntr::execAPPL_REGREF(Signal* signal) +{ + jamEntry(); + systemErrorLab(signal); + return; +}//Ndbcntr::execAPPL_REGREF() + +/*******************************/ +/* CNTR_MASTERREF */ +/*******************************/ +void Ndbcntr::execCNTR_MASTERREF(Signal* signal) +{ + jamEntry(); + systemErrorLab(signal); + return; +}//Ndbcntr::execCNTR_MASTERREF() + +/*******************************/ +/* NDB_STARTREF */ +/*******************************/ +void Ndbcntr::execNDB_STARTREF(Signal* signal) +{ + jamEntry(); + systemErrorLab(signal); + return; +}//Ndbcntr::execNDB_STARTREF() + +/*******************************/ +/* STTOR */ +/*******************************/ +void Ndbcntr::startPhase2Lab(Signal* signal) +{ + cinternalStartphase = cstartPhase - 1; +/*--------------------------------------*/ +/* CASE: CSTART_PHASE = ZSTART_PHASE_2 */ +/*--------------------------------------*/ + cndbBlocksCount = 0; + cwaitContinuebFlag = ZFALSE; +/* NOT WAITING FOR SIGNAL CONTINUEB */ + + clastGci = 0; + signal->theData[0] = cownBlockref; + sendSignal(cdihBlockref, GSN_DIH_RESTARTREQ, signal, 1, JBB); + return; +}//Ndbcntr::startPhase2Lab() + +/*******************************/ +/* DIH_RESTARTCONF */ +/*******************************/ +void Ndbcntr::execDIH_RESTARTCONF(Signal* signal) +{ + jamEntry(); + cmasterDihId = signal->theData[0]; + clastGci = signal->theData[1]; + ctypeOfStart = NodeState::ST_SYSTEM_RESTART; + ph2ALab(signal); + return; +}//Ndbcntr::execDIH_RESTARTCONF() + +/*******************************/ +/* DIH_RESTARTREF */ +/*******************************/ +void Ndbcntr::execDIH_RESTARTREF(Signal* signal) +{ + jamEntry(); + ctypeOfStart = NodeState::ST_INITIAL_START; + ph2ALab(signal); + return; +}//Ndbcntr::execDIH_RESTARTREF() + +void Ndbcntr::ph2ALab(Signal* signal) +{ + /******************************/ + /* request configured nodes */ + /* from QMGR */ + /* READ_NODESREQ */ + /******************************/ + signal->theData[0] = cownBlockref; + sendSignal(cqmgrBlockref, GSN_READ_NODESREQ, signal, 1, JBB); + return; +}//Ndbcntr::ph2ALab() + +/*******************************/ +/* READ_NODESCONF */ +/*******************************/ +void Ndbcntr::execREAD_NODESCONF(Signal* signal) +{ + jamEntry(); + ReadNodesConf * const readNodes = (ReadNodesConf *)&signal->theData[0]; + + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRec); + if(NodeBitmask::get(readNodes->allNodes, nodePtr.i)){ + jam(); + nodePtr.p->nodeDefined = ZTRUE; + } else { + jam(); + nodePtr.p->nodeDefined = ZFALSE; + }//if + }//for + + CfgBlockRecPtr cfgBlockPtr; + + cfgBlockPtr.i = 0; + ptrAss(cfgBlockPtr, cfgBlockRec); + signal->theData[0] = cownBlockref; + signal->theData[1] = cfgBlockPtr.i; + sendSignal(ccmvmiBlockref, GSN_CMVMI_CFGREQ, signal, 2, JBB); + return; +} + +/*******************************/ +/* CMVMI_CFGCONF */ +/*******************************/ +void Ndbcntr::execCMVMI_CFGCONF(Signal* signal) +{ + CfgBlockRecPtr cfgBlockPtr; + jamEntry(); + + CmvmiCfgConf * const cfgConf = (CmvmiCfgConf *)&signal->theData[0]; + + cfgBlockPtr.i = cfgConf->startPhase; + ptrCheckGuard(cfgBlockPtr, ZSIZE_CFG_BLOCK_REC, cfgBlockRec); + for(unsigned int i = 0; icfgData[i] = cfgConf->theData[i]; + + if (cfgBlockPtr.i < 4) { + jam(); + cfgBlockPtr.i = cfgBlockPtr.i + 1; + signal->theData[0] = cownBlockref; + signal->theData[1] = cfgBlockPtr.i; + sendSignal(ccmvmiBlockref, GSN_CMVMI_CFGREQ, signal, 2, JBB); + return; + } + + jam(); + + cfgBlockPtr.i = 0; + ptrAss(cfgBlockPtr, cfgBlockRec); + + cdelayStart = cfgBlockPtr.p->cfgData[0]; + + signal->theData[0] = cownBlockref; + signal->theData[1] = strlen(ZNAME_OF_APPL) | (ZNAME_OF_APPL[0] << 8); + signal->theData[2] = ZNAME_OF_APPL[1] | (ZNAME_OF_APPL[2] << 8); + signal->theData[9] = ZAPPL_SUBTYPE; + signal->theData[10] = 0; //NDB_VERSION; + sendSignal(cqmgrBlockref, GSN_APPL_REGREQ, signal, 11, JBB); + return; /* WAIT FOR APPL_REGCONF */ +}//Ndbcntr::execCMVMI_CFGCONF() + +/*******************************/ +/* APPL_REGCONF */ +/*******************************/ +void Ndbcntr::execAPPL_REGCONF(Signal* signal) +{ + jamEntry(); + cqmgrConnectionP = signal->theData[0]; + cnoNdbNodes = signal->theData[1]; + if(ctypeOfStart == NodeState::ST_INITIAL_START){ + cmasterCandidateId = signal->theData[2]; + } else { + cmasterCandidateId = ZNIL; + } + + nodePtr.i = getOwnNodeId(); + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + + /*----------------------------------------------------------------------*/ + /* CALCULATE HOW MANY NODES THAT WE NEED TO PERFORM A START. MAKE A */ + /* DECISION ABOUT WAITING FOR MORE NODES OR TO CONTINUE AT ONCE */ + /*----------------------------------------------------------------------*/ + nodePtr.p->state = ZADD; + nodePtr.p->ndbVersion = 0; //NDB_VERSION; + nodePtr.p->subType = ZAPPL_SUBTYPE; + nodePtr.p->dynamicId = signal->theData[3]; + // Save dynamic nodeid in global variable + cdynamicNodeId = nodePtr.p->dynamicId; + cnoRegNodes = cnoRegNodes + 1; + switch((NodeState::StartType)ctypeOfStart){ + case NodeState::ST_INITIAL_START: + jam(); + cnoNeedNodes = cnoNdbNodes; + break; + case NodeState::ST_SYSTEM_RESTART: + if (cnoNdbNodes == 2) { + jam(); + /*--------------------------------------*/ + /* NEED > 50% OF ALL NODES. */ + /* WE WILL SEND CONTINUEB WHEN THE WE */ + /* RECEIVE THE FIRST APPL_CHANGEREP. */ + /*--------------------------------------*/ + cnoNeedNodes = 1; /* IF ONLY 2 NODES IN CLUSTER, 1 WILL DO*/ + } else { + jam(); + cnoNeedNodes = (cnoNdbNodes >> 1) + 1; + }//if + break; + case NodeState::ST_NODE_RESTART: + case NodeState::ST_INITIAL_NODE_RESTART: + break; + default: + ndbrequire(false); + }//if + + /*--------------------------------------------------------------*/ + /* WE CAN COME HERE ALSO IN A NODE RESTART IF THE */ + /* REGISTRATION OF A RUNNING NODE HAPPENS TO ARRIVE BEFORE*/ + /* THE APPL_REGCONF SIGNAL. */ + /* IN THAT CASE CNO_NEED_NODES = ZNIL IF NOT NODE_STATE */ + /* SIGNAL HAS RETURNED THE PROPER VALUE. IN BOTH CASES WE */ + /* DO NOT NEED TO ASSIGN IT HERE. */ + /*--------------------------------------------------------------*/ + ph2CLab(signal); + return; +}//Ndbcntr::execAPPL_REGCONF() + +/*--------------------------------------------------------------*/ +/* CHECK THAT WE GOT ALL NODES REGISTRATED AS WE NEED FOR THIS */ +/* KIND OF START. WE ALWAYS END UP HERE AFTER HANDLING OF */ +/* APPL_CHANGEREP AND NODE_STATESCONF */ +/*--------------------------------------------------------------*/ +void Ndbcntr::ph2CLab(Signal* signal) +{ + NodeRecPtr ownNodePtr; + ownNodePtr.i = getOwnNodeId(); + ptrCheckGuard(ownNodePtr, MAX_NDB_NODES, nodeRec); + if (ownNodePtr.p->state != ZADD) { + jam(); + return; + }//if + switch (ctypeOfStart) { + case NodeState::ST_INITIAL_START: + jam(); + if (cnoRegNodes == cnoNeedNodes) { + jam(); + ph2ELab(signal); +/*******************************/ +/* ALL NODES ADDED */ +/*******************************/ + return; + }//if + break; + case NodeState::ST_SYSTEM_RESTART: + ndbrequire(cnoRunNodes == 0); + if (cnoRegNodes == cnoNdbNodes) { + jam(); + /*******************************/ + /* ALL NODES ADDED */ + /*******************************/ + ph2ELab(signal); + return; + }//if + if (cwaitContinuebFlag == ZFALSE) { + if (cnoRegNodes == cnoNeedNodes) { + jam(); + /****************************************/ + /* ENOUGH NODES ADDED, WAIT CDELAY_START*/ + /****************************************/ + cwaitContinuebFlag = ZTRUE; + /*******************************/ + /* A DELAY SIGNAL TO MYSELF */ + /*******************************/ + signal->theData[0] = ZCONTINUEB_1; + sendSignalWithDelay(cownBlockref, GSN_CONTINUEB, + signal, cdelayStart * 1000, 1); + return; + }//if + }//if + break; + case NodeState::ST_NODE_RESTART: + case NodeState::ST_INITIAL_NODE_RESTART: + jam(); + if (cnoNeedNodes <= cnoRunNodes) { + /*----------------------------------------------*/ + /* GOT ALL RUNNING NODES */ + /* " =< " :NODES MAY HAVE FINISHED A NODERESTART*/ + /* WHILE WE WERE WAITING FOR NODE_STATESCONF */ + /*----------------------------------------------*/ + if (cnoRegNodes != (cnoRunNodes + 1)) { + jam(); + systemErrorLab(signal); + return; + }//if + getStartNodes(signal); + cwaitContinuebFlag = ZFALSE; + cstartProgressFlag = ZTRUE; + /*--------------------------------------------------------------*/ + /* IF SOMEONE ELSE IS PERFORMING NODERESTART THEN WE GOT A REF */ + /* AND WE HAVE TO MAKE A NEW NODE_STATESREQ */ + /*--------------------------------------------------------------*/ + sendCntrMasterreq(signal); + }//if + break; + default: + jam(); + systemErrorLab(signal); + return; + break; + }//switch + /*--------------------------------------------------------------*/ + /* WAIT FOR THE CONTINUEB SIGNAL */ + /* AND / OR MORE NODES TO REGISTER */ + /*--------------------------------------------------------------*/ + return; +}//Ndbcntr::ph2CLab() + +/*******************************/ +/* CONTINUEB */ +/*******************************/ +/*--------------------------------------------------------------*/ +/* WE COME HERE ONLY IN SYSTEM RESTARTS AND INITIAL START. FOR */ +/* INITIAL START WE HAVE ALREADY CALCULATED THE MASTER. FOR */ +/* SYSTEM RESTART WE NEED TO PERFORM A VOTING SCHEME TO AGREE */ +/* ON A COMMON MASTER. WE GET OUR VOTE FROM DIH AND THE RESTART */ +/* INFORMATION IN DIH. */ +/*--------------------------------------------------------------*/ +void Ndbcntr::ph2ELab(Signal* signal) +{ + cwaitContinuebFlag = ZFALSE; +/*--------------------------------------*/ +/* JMP TO THIS WHEN ENOUGH NO OF */ +/* NODES ADDED */ +/*--------------------------------------*/ +/*--------------------------------------*/ +/* IGNORE CONTINUEB SIGNAL */ +/* CONTINUEB SIGNALS WILL EXIT AT */ +/* SIGNAL RECEPTION */ +/*--------------------------------------*/ + if (cnoRegNodes >= cnoNeedNodes) { + jam(); + getStartNodes(signal); + if (ctypeOfStart == NodeState::ST_INITIAL_START) { + if (cmasterCandidateId != getOwnNodeId()) { + jam(); +/*--------------------------------------*/ +/* THIS NODE IS NOT THE MASTER */ +/* DON'T SEND ANY MORE CNTR_MASTERREQ */ +/* VOTE FOR MASTER */ +/*--------------------------------------*/ + cstartProgressFlag = ZTRUE; + sendCntrMasterreq(signal); + resetStartVariables(signal); + } else { + jam(); + masterreq020Lab(signal); + }//if + } else if (ctypeOfStart == NodeState::ST_SYSTEM_RESTART) { + jam(); +/*--------------------------------------------------------------*/ +/* WE START THE SELECTION OF MASTER PROCESS. IF WE HAVE NOT */ +/* COMPLETED THIS BEFORE THE TIME OUT WE WILL TRY A NEW RESTART.*/ +/*--------------------------------------------------------------*/ + cwaitContinuebFlag = ZTRUE; + cstartProgressFlag = ZVOTING; + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRec); + if (nodePtr.p->state == ZADD) { + jam(); + signal->theData[0] = getOwnNodeId(); + signal->theData[1] = cmasterDihId; + signal->theData[2] = clastGci; + sendSignal(nodePtr.p->cntrBlockref, GSN_VOTE_MASTERORD, + signal, 3, JBB); + }//if + }//for + } else { + jam(); + systemErrorLab(signal); + }//if + } else { + jam(); +/*--------------------------------------------------------------*/ +/* TOO FEW NODES TO START */ +/* WE HAVE WAITED FOR THE GIVEN TIME OUT AND NOT ENOUGH NODES */ +/* HAS REGISTERED. WE WILL CRASH AND RENEW THE ATTEMPT TO START */ +/* THE SYSTEM. */ +/*--------------------------------------------------------------*/ + systemErrorLab(signal); + }//if + return; +}//Ndbcntr::ph2ELab() + +/*******************************/ +/* MASTER NODE CONFIRMS REQ */ +/* CNTR_MASTERCONF */ +/*******************************/ +void Ndbcntr::execCNTR_MASTERCONF(Signal* signal) +{ + jamEntry(); + + CntrMasterConf * const cntrMasterConf = + (CntrMasterConf *)&signal->theData[0]; + + cnoStartNodes = cntrMasterConf->noStartNodes; + int index = 0; + unsigned i; + for (i = 1; i < MAX_NDB_NODES; i++) { + jam(); + if (NodeBitmask::get(cntrMasterConf->theNodes, i)) { + jam(); + cstartNodes[index] = i; + index++; + }//if + }//for + if (cnoStartNodes != index) { + jam(); + systemErrorLab(signal); + }//if + ph2FLab(signal); + return; +}//Ndbcntr::execCNTR_MASTERCONF() + +void Ndbcntr::ph2FLab(Signal* signal) +{ +/*--------------------------------------------------------------*/ +//The nodes have been selected and we now know which nodes are +// included in the system restart. We can reset wait for CONTINUEB +// flag to ensure system is not restarted when CONTINUEB after the +// delay. +/*--------------------------------------------------------------*/ + cmasterNodeId = cmasterCandidateId; + cwaitContinuebFlag = ZFALSE; + ph2GLab(signal); + return; +}//Ndbcntr::ph2FLab() + +/*--------------------------------------*/ +/* RECEIVED CNTR_MASTERCONF */ +/*--------------------------------------*/ +/*******************************/ +/* NDB_STTORRY */ +/*******************************/ +/*---------------------------------------------------------------------------*/ +// NOW WE CAN START NDB START PHASE 1. IN THIS PHASE ALL BLOCKS +// (EXCEPT DIH THAT INITIALISED WHEN +// RECEIVING DIH_RESTARTREQ) WILL INITIALISE THEIR DATA, COMMON VARIABLES, +// LINKED LISTS AND RECORD VARIABLES. +/*---------------------------------------------------------------------------*/ +void Ndbcntr::ph2GLab(Signal* signal) +{ + if (cndbBlocksCount < ZNO_NDB_BLOCKS) { + jam(); + sendNdbSttor(signal); + return; + }//if + sendSttorry(signal); + return; +}//Ndbcntr::ph2GLab() + +/* +4.4 START PHASE 3 */ +/*###########################################################################*/ +// SEND SIGNAL NDBSTTOR TO ALL BLOCKS, ACC, DICT, DIH, LQH, TC AND TUP +// WHEN ALL BLOCKS HAVE RETURNED THEIR NDB_STTORRY ALL BLOCK HAVE FINISHED +// THEIR LOCAL CONNECTIONs SUCESSFULLY +// AND THEN WE CAN SEND APPL_STARTREG TO INFORM QMGR THAT WE ARE READY TO +// SET UP DISTRIBUTED CONNECTIONS. +/*--------------------------------------------------------------*/ +// THIS IS NDB START PHASE 3. +/*--------------------------------------------------------------*/ +/*******************************/ +/* STTOR */ +/*******************************/ +void Ndbcntr::startPhase3Lab(Signal* signal) +{ + cinternalStartphase = cstartPhase - 1; +/*--------------------------------------*/ +/* CASE: CSTART_PHASE = ZSTART_PHASE_3 */ +/*--------------------------------------*/ + cndbBlocksCount = 0; + ph3ALab(signal); + return; +}//Ndbcntr::startPhase3Lab() + +/*******************************/ +/* NDB_STTORRY */ +/*******************************/ +void Ndbcntr::ph3ALab(Signal* signal) +{ + Uint16 tnoStartNodes; + + if (cndbBlocksCount < ZNO_NDB_BLOCKS) { + jam(); + sendNdbSttor(signal); + return; + }//if +/*******************************/ +/*< APPL_STARTREG <*/ +/*******************************/ + if (ctypeOfStart == NodeState::ST_NODE_RESTART) { + jam(); + tnoStartNodes = 1; + } else if (ctypeOfStart == NodeState::ST_INITIAL_NODE_RESTART) { + jam(); + tnoStartNodes = 1; + } else { + jam(); + tnoStartNodes = cnoStartNodes; + }//if + signal->theData[0] = cqmgrConnectionP; + signal->theData[1] = tnoStartNodes; + sendSignal(cqmgrBlockref, GSN_APPL_STARTREG, signal, 2, JBB); + sendSttorry(signal); + return; +}//Ndbcntr::ph3ALab() + +/* +4.5 START PHASE 4 */ +/*###########################################################################*/ +// WAIT FOR ALL NODES IN CLUSTER TO CHANGE STATE INTO ZSTART , +// APPL_CHANGEREP IS ALWAYS SENT WHEN SOMEONE HAVE +// CHANGED THEIR STATE. APPL_STARTCONF INDICATES THAT ALL NODES ARE IN START +// STATE SEND NDB_STARTREQ TO DIH AND THEN WAIT FOR NDB_STARTCONF +/*---------------------------------------------------------------------------*/ +/*******************************/ +/* STTOR */ +/*******************************/ +void Ndbcntr::startPhase4Lab(Signal* signal) +{ + cinternalStartphase = cstartPhase - 1; +/*--------------------------------------*/ +/* CASE: CSTART_PHASE = ZSTART_PHASE_4 */ +/*--------------------------------------*/ + cndbBlocksCount = 0; + cnoWaitrep = 0; + if (capplStartconfFlag != ZTRUE) { + jam(); +/*------------------------------------------------------*/ +/* HAVE WE ALREADY RECEIVED APPL_STARTCONF */ +/*------------------------------------------------------*/ + return; + }//if + ph4ALab(signal); + return; +}//Ndbcntr::startPhase4Lab() + +/*******************************/ +/* APPL_STARTCONF */ +/*******************************/ +void Ndbcntr::execAPPL_STARTCONF(Signal* signal) +{ + jamEntry(); + if (cstartPhase == ZSTART_PHASE_4) { + jam(); + ph4ALab(signal); + return; + } else { + jam(); + capplStartconfFlag = ZTRUE; +//------------------------------------------------ +/* FLAG WILL BE CHECKED WHEN WE RECEIVED STTOR */ +/* SIGNAL MAY BE RECEIVED IN STARTPHASE 3 */ +//------------------------------------------------ + return; + }//if +}//Ndbcntr::execAPPL_STARTCONF() + +void Ndbcntr::ph4ALab(Signal* signal) +{ + nodePtr.i = getOwnNodeId(); + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + nodePtr.p->state = ZSTART; + ph4BLab(signal); + return; +}//Ndbcntr::ph4ALab() + +/*******************************/ +/* NDB_STTORRY */ +/*******************************/ +void Ndbcntr::ph4BLab(Signal* signal) +{ +/*--------------------------------------*/ +/* CASE: CSTART_PHASE = ZSTART_PHASE_4 */ +/*--------------------------------------*/ + if (cndbBlocksCount < ZNO_NDB_BLOCKS) { + jam(); + sendNdbSttor(signal); + return; + }//if + if ((ctypeOfStart == NodeState::ST_NODE_RESTART) || + (ctypeOfStart == NodeState::ST_INITIAL_NODE_RESTART)) { + jam(); + sendSttorry(signal); + return; + }//if + waitpoint41Lab(signal); + return; +}//Ndbcntr::ph4BLab() + +void Ndbcntr::waitpoint41Lab(Signal* signal) +{ + if (getOwnNodeId() == cmasterNodeId) { + jam(); +/*--------------------------------------*/ +/* MASTER WAITS UNTIL ALL SLAVES HAS */ +/* SENT THE REPORTS */ +/*--------------------------------------*/ + cnoWaitrep++; + if (cnoWaitrep == cnoStartNodes) { + jam(); +/*---------------------------------------------------------------------------*/ +// NDB_STARTREQ STARTS UP ALL SET UP OF DISTRIBUTION INFORMATION IN DIH AND +// DICT. AFTER SETTING UP THIS +// DATA IT USES THAT DATA TO SET UP WHICH FRAGMENTS THAT ARE TO START AND +// WHERE THEY ARE TO START. THEN +// IT SETS UP THE FRAGMENTS AND RECOVERS THEM BY: +// 1) READING A LOCAL CHECKPOINT FROM DISK. +// 2) EXECUTING THE UNDO LOG ON INDEX AND DATA. +// 3) EXECUTING THE FRAGMENT REDO LOG FROM ONE OR SEVERAL NODES TO +// RESTORE THE RESTART CONFIGURATION OF DATA IN NDB CLUSTER. +/*---------------------------------------------------------------------------*/ + signal->theData[0] = cownBlockref; + signal->theData[1] = ctypeOfStart; + sendSignal(cdihBlockref, GSN_NDB_STARTREQ, signal, 2, JBB); + }//if + } else { + jam(); +/*--------------------------------------*/ +/* SLAVE NODES WILL PASS HERE ONCE AND */ +/* SEND A WAITPOINT REPORT TO MASTER. */ +/* SLAVES WONT DO ANYTHING UNTIL THEY */ +/* RECEIVE A WAIT REPORT FROM THE MASTER*/ +/*--------------------------------------*/ + nodePtr.i = cmasterNodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + signal->theData[0] = getOwnNodeId(); + signal->theData[1] = ZWAITPOINT_4_1; + sendSignal(nodePtr.p->cntrBlockref, GSN_CNTR_WAITREP, signal, 2, JBB); + }//if + return; +}//Ndbcntr::waitpoint41Lab() + +/*******************************/ +/* NDB_STARTCONF */ +/*******************************/ +void Ndbcntr::execNDB_STARTCONF(Signal* signal) +{ + jamEntry(); + UintR guard0; + UintR Ttemp1; + + guard0 = cnoStartNodes - 1; + arrGuard(guard0, MAX_NDB_NODES); + for (Ttemp1 = 0; Ttemp1 <= guard0; Ttemp1++) { + jam(); + if (cstartNodes[Ttemp1] != getOwnNodeId()) { + jam(); + nodePtr.i = cstartNodes[Ttemp1]; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + signal->theData[0] = getOwnNodeId(); + signal->theData[1] = ZWAITPOINT_4_2; + sendSignal(nodePtr.p->cntrBlockref, GSN_CNTR_WAITREP, signal, 2, JBB); + }//if + }//for + sendSttorry(signal); + return; +}//Ndbcntr::execNDB_STARTCONF() + +/* +4.6 START PHASE 5 */ +/*###########################################################################*/ +// SEND APPL_RUN TO THE QMGR IN THIS BLOCK +// SEND NDB_STTOR ALL BLOCKS ACC, DICT, DIH, LQH, TC AND TUP THEN WAIT FOR +// THEIR NDB_STTORRY +/*---------------------------------------------------------------------------*/ +/*******************************/ +/* STTOR */ +/*******************************/ +void Ndbcntr::startPhase5Lab(Signal* signal) +{ + cinternalStartphase = cstartPhase - 1; + cndbBlocksCount = 0; + cnoWaitrep = 0; + ph5ALab(signal); + return; +}//Ndbcntr::startPhase5Lab() + +/*******************************/ +/* NDB_STTORRY */ +/*******************************/ +/*---------------------------------------------------------------------------*/ +// THIS IS NDB START PHASE 5. +/*---------------------------------------------------------------------------*/ +// IN THIS START PHASE TUP INITIALISES DISK FILES FOR DISK STORAGE IF INITIAL +// START. DIH WILL START UP +// THE GLOBAL CHECKPOINT PROTOCOL AND WILL CONCLUDE ANY UNFINISHED TAKE OVERS +// THAT STARTED BEFORE THE SYSTEM CRASH. +/*---------------------------------------------------------------------------*/ +void Ndbcntr::ph5ALab(Signal* signal) +{ + if (cndbBlocksCount < ZNO_NDB_BLOCKS) { + jam(); + sendNdbSttor(signal); + return; + }//if + + cstartPhase = cstartPhase + 1; + cinternalStartphase = cstartPhase - 1; + if (getOwnNodeId() == cmasterNodeId) { + switch(ctypeOfStart){ + case NodeState::ST_INITIAL_START: + jam(); + /*--------------------------------------*/ + /* MASTER CNTR IS RESPONSIBLE FOR */ + /* CREATING SYSTEM TABLES */ + /*--------------------------------------*/ + createSystableLab(signal, 0); + return; + case NodeState::ST_SYSTEM_RESTART: + jam(); + waitpoint52Lab(signal); + return; + case NodeState::ST_NODE_RESTART: + case NodeState::ST_INITIAL_NODE_RESTART: + break; + case NodeState::ST_ILLEGAL_TYPE: + break; + } + ndbrequire(false); + } + + /** + * Not master + */ + NdbSttor * const req = (NdbSttor*)signal->getDataPtrSend(); + switch(ctypeOfStart){ + case NodeState::ST_NODE_RESTART: + case NodeState::ST_INITIAL_NODE_RESTART: + jam(); + /*----------------------------------------------------------------------*/ + // SEND NDB START PHASE 5 IN NODE RESTARTS TO COPY DATA TO THE NEWLY + // STARTED NODE. + /*----------------------------------------------------------------------*/ + req->senderRef = cownBlockref; + req->nodeId = getOwnNodeId(); + req->internalStartPhase = cinternalStartphase; + req->typeOfStart = ctypeOfStart; + req->masterNodeId = cmasterNodeId; + +#ifdef TRACE_STTOR + ndbout_c("sending NDB_STTOR(%d) to DIH", cinternalStartphase); +#endif + sendSignal(cdihBlockref, GSN_NDB_STTOR, signal, + NdbSttor::SignalLength, JBB); + return; + case NodeState::ST_INITIAL_START: + case NodeState::ST_SYSTEM_RESTART: + jam(); + /*--------------------------------------*/ + /* DURING SYSTEMRESTART AND INITALSTART:*/ + /* SLAVE NODES WILL PASS HERE ONCE AND */ + /* SEND A WAITPOINT REPORT TO MASTER. */ + /* SLAVES WONT DO ANYTHING UNTIL THEY */ + /* RECEIVE A WAIT REPORT FROM THE MASTER*/ + /* WHEN THE MASTER HAS FINISHED HIS WORK*/ + /*--------------------------------------*/ + nodePtr.i = cmasterNodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + signal->theData[0] = getOwnNodeId(); + signal->theData[1] = ZWAITPOINT_5_2; + sendSignal(nodePtr.p->cntrBlockref, GSN_CNTR_WAITREP, signal, 2, JBB); + return; + default: + ndbrequire(false); + } +}//Ndbcntr::ph5ALab() + +void Ndbcntr::waitpoint52Lab(Signal* signal) +{ + cnoWaitrep = cnoWaitrep + 1; +/*---------------------------------------------------------------------------*/ +// THIS WAITING POINT IS ONLY USED BY A MASTER NODE. WE WILL EXECUTE NDB START +// PHASE 5 FOR DIH IN THE +// MASTER. THIS WILL START UP LOCAL CHECKPOINTS AND WILL ALSO CONCLUDE ANY +// UNFINISHED LOCAL CHECKPOINTS +// BEFORE THE SYSTEM CRASH. THIS WILL ENSURE THAT WE ALWAYS RESTART FROM A +// WELL KNOWN STATE. +/*---------------------------------------------------------------------------*/ +/*--------------------------------------*/ +/* MASTER WAITS UNTIL HE RECEIVED WAIT */ +/* REPORTS FROM ALL SLAVE CNTR */ +/*--------------------------------------*/ + if (cnoWaitrep == cnoStartNodes) { + jam(); + NdbSttor * const req = (NdbSttor*)signal->getDataPtrSend(); + req->senderRef = cownBlockref; + req->nodeId = getOwnNodeId(); + req->internalStartPhase = cinternalStartphase; + req->typeOfStart = ctypeOfStart; + req->masterNodeId = cmasterNodeId; +#ifdef TRACE_STTOR + ndbout_c("sending NDB_STTOR(%d) to DIH", cinternalStartphase); +#endif + sendSignal(cdihBlockref, GSN_NDB_STTOR, signal, + NdbSttor::SignalLength, JBB); + }//if + return; +}//Ndbcntr::waitpoint52Lab() + +/*******************************/ +/* NDB_STTORRY */ +/*******************************/ +void Ndbcntr::ph6ALab(Signal* signal) +{ + UintR guard0; + UintR Ttemp1; + + if ((ctypeOfStart == NodeState::ST_NODE_RESTART) || + (ctypeOfStart == NodeState::ST_INITIAL_NODE_RESTART)) { + jam(); + waitpoint51Lab(signal); + return; + }//if + guard0 = cnoStartNodes - 1; + arrGuard(guard0, MAX_NDB_NODES); + for (Ttemp1 = 0; Ttemp1 <= guard0; Ttemp1++) { + jam(); + if (cstartNodes[Ttemp1] != getOwnNodeId()) { + jam(); + nodePtr.i = cstartNodes[Ttemp1]; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + signal->theData[0] = getOwnNodeId(); + signal->theData[1] = ZWAITPOINT_5_1; + sendSignal(nodePtr.p->cntrBlockref, GSN_CNTR_WAITREP, signal, 2, JBB); + }//if + }//for + waitpoint51Lab(signal); + return; +}//Ndbcntr::ph6ALab() + +void Ndbcntr::waitpoint51Lab(Signal* signal) +{ + cstartPhase = cstartPhase + 1; +/*---------------------------------------------------------------------------*/ +// A FINAL STEP IS NOW TO SEND NDB_STTOR TO TC. THIS MAKES IT POSSIBLE TO +// CONNECT TO TC FOR APPLICATIONS. +// THIS IS NDB START PHASE 6 WHICH IS FOR ALL BLOCKS IN ALL NODES. +/*---------------------------------------------------------------------------*/ + cinternalStartphase = cstartPhase - 1; + cndbBlocksCount = 0; + ph6BLab(signal); + return; +}//Ndbcntr::waitpoint51Lab() + +void Ndbcntr::ph6BLab(Signal* signal) +{ + // c_missra.currentStartPhase - cstartPhase - cinternalStartphase = + // 5 - 7 - 6 + if (cndbBlocksCount < ZNO_NDB_BLOCKS) { + jam(); + sendNdbSttor(signal); + return; + }//if + if ((ctypeOfStart == NodeState::ST_NODE_RESTART) || + (ctypeOfStart == NodeState::ST_INITIAL_NODE_RESTART)) { + jam(); + sendSttorry(signal); + return; + } + waitpoint61Lab(signal); +} + +void Ndbcntr::waitpoint61Lab(Signal* signal) +{ + if (getOwnNodeId() == cmasterNodeId) { + jam(); + cnoWaitrep6++; + if (cnoWaitrep6 == cnoStartNodes) { + jam(); + Uint32 guard0 = cnoStartNodes - 1; + arrGuard(guard0, MAX_NDB_NODES); + for (Uint32 Ttemp1 = 0; Ttemp1 <= guard0; Ttemp1++) { + jam(); + if (cstartNodes[Ttemp1] != getOwnNodeId()) { + jam(); + nodePtr.i = cstartNodes[Ttemp1]; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + signal->theData[0] = getOwnNodeId(); + signal->theData[1] = ZWAITPOINT_6_2; + sendSignal(nodePtr.p->cntrBlockref, GSN_CNTR_WAITREP, signal, 2, JBB); + } + } + sendSttorry(signal); + } + } else { + jam(); + nodePtr.i = cmasterNodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + signal->theData[0] = getOwnNodeId(); + signal->theData[1] = ZWAITPOINT_6_1; + sendSignal(nodePtr.p->cntrBlockref, GSN_CNTR_WAITREP, signal, 2, JBB); + } +} + +// Start phase 8 (internal 7) +void Ndbcntr::startPhase8Lab(Signal* signal) +{ + cinternalStartphase = cstartPhase - 1; + cndbBlocksCount = 0; + ph7ALab(signal); +} + +void Ndbcntr::ph7ALab(Signal* signal) +{ + while (cndbBlocksCount < ZNO_NDB_BLOCKS) { + jam(); + sendNdbSttor(signal); + return; + } + if ((ctypeOfStart == NodeState::ST_NODE_RESTART) || + (ctypeOfStart == NodeState::ST_INITIAL_NODE_RESTART)) { + jam(); + sendSttorry(signal); + return; + } + waitpoint71Lab(signal); +} + +void Ndbcntr::waitpoint71Lab(Signal* signal) +{ + if (getOwnNodeId() == cmasterNodeId) { + jam(); + cnoWaitrep7++; + if (cnoWaitrep7 == cnoStartNodes) { + jam(); + Uint32 guard0 = cnoStartNodes - 1; + arrGuard(guard0, MAX_NDB_NODES); + for (Uint32 Ttemp1 = 0; Ttemp1 <= guard0; Ttemp1++) { + jam(); + if (cstartNodes[Ttemp1] != getOwnNodeId()) { + jam(); + nodePtr.i = cstartNodes[Ttemp1]; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + signal->theData[0] = getOwnNodeId(); + signal->theData[1] = ZWAITPOINT_7_2; + sendSignal(nodePtr.p->cntrBlockref, GSN_CNTR_WAITREP, signal, 2, JBB); + } + } + sendSttorry(signal); + } + } else { + jam(); + nodePtr.i = cmasterNodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + signal->theData[0] = getOwnNodeId(); + signal->theData[1] = ZWAITPOINT_7_1; + sendSignal(nodePtr.p->cntrBlockref, GSN_CNTR_WAITREP, signal, 2, JBB); + } +} + +// Start phase 9 (internal 8) +void Ndbcntr::startPhase9Lab(Signal* signal) +{ + cinternalStartphase = cstartPhase - 1; + cndbBlocksCount = 0; + ph8ALab(signal); +} + +void Ndbcntr::ph8ALab(Signal* signal) +{ +/*---------------------------------------------------------------------------*/ +// NODES WHICH PERFORM A NODE RESTART NEEDS TO GET THE DYNAMIC ID'S +// OF THE OTHER NODES HERE. +/*---------------------------------------------------------------------------*/ + signal->theData[0] = cqmgrConnectionP; + sendSignal(cqmgrBlockref, GSN_APPL_RUN, signal, 1, JBB); + nodePtr.i = getOwnNodeId(); + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + nodePtr.p->state = ZRUN; + cnoRunNodes = cnoRunNodes + 1; + sendSttorry(signal); + cstartProgressFlag = ZFALSE; + ctypeOfStart = (NodeState::StartType)ZSYSTEM_RUN; + resetStartVariables(signal); + return; +}//Ndbcntr::ph8BLab() + +/* +4.7 HANDLE GLOBAL EVENTS, NOT BOUNDED TO INITIALSTART OR SYSTEM RESTART */ +/*#######################################################################*/ +/*******************************/ +/* APPL_CHANGEREP */ +/*******************************/ +void Ndbcntr::execAPPL_CHANGEREP(Signal* signal) +{ + jamEntry(); + Uint16 TapplEvent = signal->theData[0]; + Uint16 TapplVersion = signal->theData[1]; + Uint16 TapplNodeId = signal->theData[2]; + Uint16 TapplSubType = signal->theData[3]; + + nodePtr.i = TapplNodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + nodePtr.p->subType = TapplSubType; + nodePtr.p->ndbVersion = TapplVersion; + nodePtr.p->dynamicId = signal->theData[4]; + + switch (TapplEvent) { + case ZADD: +/*----------------------------*/ +/* ADD A NEW NDB NODE TO FILE */ +/*----------------------------*/ + if (nodePtr.p->state == ZREMOVE) { + jam(); + if (cnoRegNodes == cnoNdbNodes) { + jam(); +/*----------------------------------------------*/ +/* DON'T ACCEPT MORE NODES THAN SYSFILE.CFG SPEC*/ +/*----------------------------------------------*/ + systemErrorLab(signal); + return; + }//if + nodePtr.p->state = ZADD; + cnoRegNodes = cnoRegNodes + 1; + } else { + jam(); + systemErrorLab(signal); + return; + }//if + if (cstartProgressFlag == ZFALSE) { +/*----------------------------------------------*/ +/* FLAG = TRUE WHEN CNTR_MASTERREQ IS SENT */ +/*----------------------------------------------*/ + switch (ctypeOfStart) { + case NodeState::ST_INITIAL_START: + case NodeState::ST_SYSTEM_RESTART: + jam(); + ph2CLab(signal); +/*----------------------------------------------*/ +/* CHECK IF READY TO MAKE A CNTR_MASTERREQ */ +/*----------------------------------------------*/ + break; + case NodeState::ST_NODE_RESTART: + case NodeState::ST_INITIAL_NODE_RESTART: + jam(); +/*------------------------------------------------------------------------*/ +/* THIS SHOULD NEVER OCCUR SINCE WE HAVE ALREADY BEEN ALLOWED TO */ +/* START OUR NODE. THE NEXT NODE CANNOT START UNTIL WE ARE FINISHED */ +/*------------------------------------------------------------------------*/ + systemErrorLab(signal); + break; + case ZSYSTEM_RUN: + jam(); + /*empty*/; + break; + default: + jam(); +/*------------------------------------------------------------------------*/ +/* NO PARTICULAR ACTION IS NEEDED. THE NODE WILL PERFORM A NODE */ +/* RESTART BUT NO ACTION IS NEEDED AT THIS STAGE IN THE RESTART. */ +/*------------------------------------------------------------------------*/ + systemErrorLab(signal); + break; + }//switch + } else { + jam(); +/*--------------------------------------------------------------------------*/ +// WHEN A RESTART IS IN PROGRESS THERE IS A POSSIBILITY THAT A NODE +// REGISTER AND +// THINKS THAT HE WOULD BE THE MASTER (LOWER NODE ID) BUT THE OTHER NODE IS +// ALREADY RUNNING THE RESTART. THIS WILL BE DETECTED WHEN HE ATTEMPTS A +// CNTR_MASTERREQ AND RECEIVES A REFUSE SIGNAL IN RETURN. THIS WILL CAUSE HIM +// TO CRASH. IF HE ATTEMPTS TO JOIN AS A NON-MASTER HE WILL WAIT FOR THE MASTER. +// IN THIS CASE IT IS BETTER TO SHOT HIM DOWN. FOR SAFETY REASONS WE WILL ALWAYS +// SHOT HIM DOWN. +/*--------------------------------------------------------------------------*/ + const BlockReference tblockref = calcNdbCntrBlockRef(nodePtr.i); + + SystemError * const sysErr = (SystemError*)&signal->theData[0]; + sysErr->errorCode = SystemError::StartInProgressError; + sysErr->errorRef = reference(); + sendSignal(tblockref, GSN_SYSTEM_ERROR, signal, SystemError::SignalLength, JBA); + }//if + break; + case ZSTART: + jam(); + if (nodePtr.p->state != ZADD) { + jam(); + systemErrorLab(signal); + return; + }//if + nodePtr.p->state = ZSTART; + break; + case ZRUN: + if (nodePtr.p->state == ZREMOVE) { + jam(); + cnoRegNodes = cnoRegNodes + 1; + } else { + jam(); + if (nodePtr.p->state != ZSTART) { + jam(); +/*----------------------------------------------*/ +/* STATE ZADD OR ZRUN -> ZRUN NOT ALLOWED */ +/*----------------------------------------------*/ + systemErrorLab(signal); + return; + }//if + }//if + cnoRunNodes = cnoRunNodes + 1; + nodePtr.p->state = ZRUN; + switch (ctypeOfStart) { + case NodeState::ST_INITIAL_START: + jam(); + detectNoderestart(signal); + if (ctypeOfStart == NodeState::ST_NODE_RESTART) { + jam(); +/*--------------------------------------------------------------------------*/ +/* WE DISCOVERED THAT WE ARE TRYING TO PERFORM A INITIAL START WHEN THERE */ +/* ARE ALREADY RUNNING NODES. THIS MEANS THAT THE NODE HAS CLEANED THE */ +/* FILE SYSTEM AND CONTAINS NO DATA. THIS IS AN INITIAL NODE RESTART WHICH */ +/* IS NECESSARY TO START A NODE THAT HAS BEEN TAKEN OVER. */ +/*--------------------------------------------------------------------------*/ + ctypeOfStart = NodeState::ST_INITIAL_NODE_RESTART; + }//if + break; + case NodeState::ST_SYSTEM_RESTART: + jam(); + detectNoderestart(signal); +/*----------------------------------------------*/ +/* SHOULD THIS NODE PERFORM A NODE RESTART? */ +/* THEN CHANGE CTYPE_OF_START TO NodeState::ST_NODE_RESTART */ +/* AND SEND NODE_STATESREQ. */ +/* WAIT FOR NODE_STATESCONF. */ +/*----------------------------------------------*/ + break; + case NodeState::ST_NODE_RESTART: + case NodeState::ST_INITIAL_NODE_RESTART: + jam(); +/*----------------------------------------------*/ +/* IF WE ARE WAITING FOR NODE_STATESCONF, THIS */ +/* JUMP WILL EXIT BECAUSE CNO_NEED_NODES = ZNIL */ +/* UNTIL WE RECEIVE NODE_STATESCONF */ +/*----------------------------------------------*/ + ph2CLab(signal); + break; + case ZSYSTEM_RUN: + jam(); + break; + default: + jam(); + systemErrorLab(signal); + break; + }//switch + break; + default: + jam(); + systemErrorLab(signal); + break; + }//switch + return; +}//Ndbcntr::execAPPL_CHANGEREP() + +/*--------------------------------------------------------------------------*/ +// A NODE HAS ADDED HAS VOTE ON WHICH MASTER IS TO BE CHOOSEN IN A SYSTEM +// RESTART. WHEN ALL VOTES HAVE +// BEEN ADDED THEN WE ARE PREPARED TO CHOOSE MASTER AND CONTINUE WITH THE +// RESTART PROCESSING. +/*--------------------------------------------------------------------------*/ + +/*******************************/ +/* VOT_MASTERORD */ +/*******************************/ +void Ndbcntr::execVOTE_MASTERORD(Signal* signal) +{ + jamEntry(); + nodePtr.i = signal->theData[0]; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + UintR TmasterCandidateId = signal->theData[1]; + UintR TlastGci = signal->theData[2]; + if (ctypeOfStart != NodeState::ST_SYSTEM_RESTART) { + jam(); + progError(__LINE__, + ERR_SR_RESTARTCONFLICT, + "One ore more nodes probably requested an initial SR"); + return; + }//if + cmasterVoters = cmasterVoters + 1; + if (cmasterVoters == 1) { + jam(); + cmasterCurrentId = TmasterCandidateId; + cmasterLastGci = TlastGci; + } else { + if (cmasterLastGci < TlastGci) { + jam(); + cmasterCurrentId = TmasterCandidateId; + cmasterLastGci = TlastGci; + } else if (cmasterLastGci == TlastGci) { + jam(); + if (cmasterCurrentId != TmasterCandidateId) { + jam(); + systemErrorLab(signal); + return; + }//if + }//if + }//if + if (cstartProgressFlag == ZVOTING) { +/*--------------------------------------------------------------------------*/ +// UNLESS START PROGRESS FLAG IS SET TO VOTING WE HAVE NOT YET REACHED A +// STATE WHERE WE ARE READY TO +// PROCEED WITH THE SYSTEM RESTART. OUR OWN NOTE HAVE AT LEAST NOT BEEN +// CAST INTO THE BALLOT YET. +/*--------------------------------------------------------------------------*/ + if (cmasterVoters == cnoRegNodes) { + cmasterCandidateId = cmasterCurrentId; + if (cmasterCandidateId == getOwnNodeId()) { + jam(); + masterreq020Lab(signal); + return; + } else { + jam(); + cstartProgressFlag = ZTRUE; + sendCntrMasterreq(signal); + resetStartVariables(signal); + }//if + }//if + }//if + return; +}//Ndbcntr::execVOTE_MASTERORD() + +/*******************************/ +/* CNTR_MASTERREQ */ +/*******************************/ +void Ndbcntr::execCNTR_MASTERREQ(Signal* signal) +{ + Uint16 ttypeOfStart; + + jamEntry(); + + CntrMasterReq * const cntrMasterReq = + (CntrMasterReq *)&signal->theData[0]; + +//----------------------------------------------- +// cntrMasterReq->userBlockRef NOT USED +//----------------------------------------------- + Uint16 TuserNodeId = cntrMasterReq->userNodeId; + ttypeOfStart = cntrMasterReq->typeOfStart; + Uint16 TnoRestartNodes = cntrMasterReq->noRestartNodes; + int index = 0; + unsigned i; + for (i = 1; i < MAX_NDB_NODES; i++) { + jam(); + if (NodeBitmask::get(cntrMasterReq->theNodes, i)) { + jam(); + cstartNodes[index] = i; + index++; + }//if + }//for + if (TnoRestartNodes != index) { + jam(); + systemErrorLab(signal); + }//if + switch (ttypeOfStart) { + case NodeState::ST_INITIAL_START: + case NodeState::ST_SYSTEM_RESTART: + jam(); +//-------------------------------- +/* ELECTION OF MASTER AT */ +/* INITIAL OR SYSTEM RESTART */ +//-------------------------------- + masterreq010Lab(signal, TnoRestartNodes, TuserNodeId); + break; + case NodeState::ST_NODE_RESTART: + case NodeState::ST_INITIAL_NODE_RESTART: + jam(); + masterreq030Lab(signal, TnoRestartNodes, TuserNodeId); + break; + default: + jam(); + systemErrorLab(signal); + break; + }//switch +}//Ndbcntr::execCNTR_MASTERREQ() + +/*******************************/ +/* CNTR_WAITREP */ +/*******************************/ +void Ndbcntr::execCNTR_WAITREP(Signal* signal) +{ + Uint16 twaitPoint; + + jamEntry(); + twaitPoint = signal->theData[1]; + switch (twaitPoint) { + case ZWAITPOINT_4_1: + jam(); + waitpoint41Lab(signal); + break; + case ZWAITPOINT_4_2: + jam(); + sendSttorry(signal); + break; + case ZWAITPOINT_5_1: + jam(); + waitpoint51Lab(signal); + break; + case ZWAITPOINT_5_2: + jam(); + waitpoint52Lab(signal); + break; + case ZWAITPOINT_6_1: + jam(); + waitpoint61Lab(signal); + break; + case ZWAITPOINT_6_2: + jam(); + sendSttorry(signal); + break; + case ZWAITPOINT_7_1: + jam(); + waitpoint71Lab(signal); + break; + case ZWAITPOINT_7_2: + jam(); + sendSttorry(signal); + break; + default: + jam(); + systemErrorLab(signal); + break; + }//switch +}//Ndbcntr::execCNTR_WAITREP() + +/* +4.7.4 MASTERREQ_010 ( CASE: INITIALSTART OR SYSTEMRESTART ) */ +/*--------------------------------------------------------------------------*/ +// ELECTION OF MASTER AND ELECTION OF PARTICIPANTS IN START. SENDER OF +// CNTR_MASTERREQ THINKS THAT THIS NODE +// SHOULD BE THE MASTER. WE CAN'T MAKE A DECISION ABOUT WHO THE MASTER +// SHOULD BE UNTIL TIMELIMIT HAS EXPIRED AND +// THAT AT LEAST CNO_NEED_NODES ARE ZADD IN NODE_PTR_REC. IF THIS NODE IS +// MASTER THEN MAKE SURE THAT ALL NODES IN +// THE CLUSTER COMES TO AN AGREEMENT ABOUT A SUBSET OF NODES THAT SATISFIES +// THE NUMBER CNO_NEED_NODES. THERE IS +// A POSSIBILITY THAT THE RECEIVER OF CNTR_MASTERREQ DOESN'T HAS CHOOSEN +// A MASTER, THEN THE RECEIVER CAN'T +// EITHER CONFIRM OR REFUSE JUST STORE THE VOTES OF THE CLUSTERMEMBERS. +// IF THIS NODE BECOME AWARE OF THAT ANOTHER NODE IS MASTER THEN CHECK IF +// ANYONE HAS VOTED (SENT CNTR_MASTERREQ) */ +// AND THEN SEND THEM CNTR_MASTERREF BACK. +/*--------------------------------------------------------------------------*/ +void Ndbcntr::masterreq010Lab(Signal* signal, + Uint16 TnoRestartNodes, + Uint16 TuserNodeId) +{ + UintR guard0; + UintR Ttemp1; + + nodePtr.i = TuserNodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + if (cstartProgressFlag == ZTRUE) { + jam(); +/*--------------------------------------*/ +/* RESTART ALREADY IN PROGRESS */ +/*--------------------------------------*/ + if (ctypeOfStart == NodeState::ST_INITIAL_START) { + jam(); + systemErrorLab(signal); + return; + }//if + signal->theData[0] = cownBlockref; + signal->theData[1] = getOwnNodeId(); + signal->theData[2] = ZSTART_IN_PROGRESS_ERROR; + sendSignal(nodePtr.p->cntrBlockref, GSN_CNTR_MASTERREF, signal, 3, JBB); + return; + }//if + cnoVoters = cnoVoters + 1; + nodePtr.p->voter = ZTRUE; + guard0 = TnoRestartNodes - 1; + arrGuard(guard0, MAX_NDB_NODES); + for (Ttemp1 = 0; Ttemp1 <= guard0; Ttemp1++) { + jam(); + nodePtr.i = cstartNodes[Ttemp1]; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + nodePtr.p->votes = nodePtr.p->votes + 1; + }//for + masterreq020Lab(signal); + return; +}//Ndbcntr::masterreq010Lab() + +/*----------------------------------------------------------------------*/ +/* WHEN WE JUST WANT TO CHECK OUR VOTES IT IS POSSIBLE TO JUMP TO THIS */ +/* LABEL. IF WE HAVEN'T RECEIVED ANY VOTES SINCE OUR LASTCHECK WE WILL */ +/* JUST PERFORM AN EXIT */ +/*----------------------------------------------------------------------*/ +void Ndbcntr::masterreq020Lab(Signal* signal) +{ + if (cmasterCandidateId == ZNIL) { + jam(); +/*--------------------------------------*/ +/* MASTER UNKNOWN */ +/*--------------------------------------*/ + return; + } else if (cmasterCandidateId == getOwnNodeId()) { + jam(); +/*--------------------------------------*/ +/* SATISFIED WHEN WE HAVE AS MANY VOTERS*/ +/* AS RESTARTNODES - 1, DIFFERENT NODES?*/ +/* <- CNO_START_NODES, ALL NODES AGREED */ +/* ON THESE CNO_START_NODES */ +/*--------------------------------------*/ + if ((cnoStartNodes - 1) == cnoVoters) { + chooseRestartNodes(signal); + if (cnoStartNodes >= cnoNeedNodes) { + jam(); + cstartProgressFlag = ZTRUE; +/*--------------------------------------*/ +/* DON'T SEND ANY MORE CNTR_MASTERREQ */ +/*--------------------------------------*/ + replyMasterconfToAll(signal); +/*--------------------------------------*/ +/* SEND CONF TO ALL PASSED REQ */ +/* DON'T SEND ANYTHING TO REJECTED NODES*/ +/* BLOCK THEM UNTIL SYSTEM IS RUNNING */ +/* CONTINUE RESTART */ +/*--------------------------------------*/ + ph2FLab(signal); + } else { + jam(); + systemErrorLab(signal); + }//if + }//if + } else { + jam(); +/*----------------------------------------------------------------------*/ +/* WE RECEIVED A REQUEST TO A MASTER WHILE NOT BEING MASTER. THIS */ +/* MUST BE AN ERROR INDICATION. WE CRASH. */ +/*----------------------------------------------------------------------*/ + systemErrorLab(signal); + }//if + return; /* WAIT FOR MORE CNTR_MASTERREQ */ +}//Ndbcntr::masterreq020Lab() + +void Ndbcntr::masterreq030Lab(Signal* signal, + Uint16 TnoRestartNodes, + Uint16 TuserNodeId) +{ + UintR TretCode; + if (cmasterNodeId == getOwnNodeId()) { + jam(); + TretCode = checkNodelist(signal, TnoRestartNodes); + nodePtr.i = TuserNodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + if (TretCode == 1) { + jam(); +/*******************************************************<*/ +/* CSTART_NODES IS OVERWRITTEN IN RECEIVING BLOCK, */ +/* SO WE MUST SEND CNTR_MASTERCONF TO THE SAME */ +/* CSTART_NODES AS WE RECEIVED IN CNTR_MASTERREQ */ +/*******************************************************<*/ + + CntrMasterConf * const cntrMasterConf = + (CntrMasterConf *)&signal->theData[0]; + NodeBitmask::clear(cntrMasterConf->theNodes); + for (int i = 0; i < TnoRestartNodes; i++){ + jam(); + UintR Tnode = cstartNodes[i]; + arrGuard(Tnode, MAX_NDB_NODES); + NodeBitmask::set(cntrMasterConf->theNodes, Tnode); + }//for + cntrMasterConf->noStartNodes = TnoRestartNodes; + sendSignal(nodePtr.p->cntrBlockref, GSN_CNTR_MASTERCONF, + signal, CntrMasterConf::SignalLength, JBB); + } else { + jam(); + signal->theData[0] = cownBlockref; + signal->theData[1] = getOwnNodeId(); + signal->theData[2] = ZTOO_FEW_NODES; + sendSignal(nodePtr.p->cntrBlockref, GSN_CNTR_MASTERREF, signal, 3, JBB); + }//if + } else { + jam(); + nodePtr.i = TuserNodeId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + signal->theData[0] = cownBlockref; + signal->theData[1] = getOwnNodeId(); + signal->theData[2] = ZNOT_MASTER; + sendSignal(nodePtr.p->cntrBlockref, GSN_CNTR_MASTERREF, signal, 3, JBB); + }//if + return; +}//Ndbcntr::masterreq030Lab() + +/*******************************/ +/* NODE_FAILREP */ +/*******************************/ +void Ndbcntr::execNODE_FAILREP(Signal* signal) +{ + UintR TfailureNr; + UintR TnoOfNodes; + UintR TreadNodes[MAX_NDB_NODES]; + + jamEntry(); + + const NodeState & st = getNodeState(); + if(st.startLevel == st.SL_STARTING){ + if(!st.getNodeRestartInProgress()){ + progError(__LINE__, + ERR_SR_OTHERNODEFAILED, + "Unhandled node failure during system restart"); + } + } + + { + NodeFailRep * const nodeFail = (NodeFailRep *)&signal->theData[0]; + + TfailureNr = nodeFail->failNo; + TnoOfNodes = nodeFail->noOfNodes; + unsigned index = 0; + unsigned i; + for (i = 0; i < MAX_NDB_NODES; i++) { + jam(); + if (NodeBitmask::get(nodeFail->theNodes, i)) { + jam(); + TreadNodes[index] = i; + index++; + ndbrequire(getOwnNodeId() != i); + }//if + }//for + ndbrequire(TnoOfNodes == index); + } + + for (Uint32 i = 0; i < TnoOfNodes; i++) { + jam(); + nodePtr.i = TreadNodes[i]; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + signal->theData[0] = EventReport::NODE_FAILREP; + signal->theData[1] = nodePtr.i; + signal->theData[2] = nodePtr.p->state; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB); + if (nodePtr.p->state != ZREMOVE) { + jam(); + deleteNode(signal); + }//if + }//for + +/*******************************/ +/*< NODE_FAILREP <*/ +/*******************************/ + NodeFailRep * const nodeFail = (NodeFailRep *)&signal->theData[0]; + + nodeFail->failNo = TfailureNr; + nodeFail->masterNodeId = cmasterNodeId; + + nodeFail->noOfNodes = TnoOfNodes; + NodeBitmask::clear(nodeFail->theNodes); + for (unsigned i = 0; i < TnoOfNodes; i++) { + jam(); + NodeBitmask::set(nodeFail->theNodes, TreadNodes[i]); + }//for + + sendSignal(ctcBlockref, GSN_NODE_FAILREP, signal, + NodeFailRep::SignalLength, JBB); + + sendSignal(clqhBlockref, GSN_NODE_FAILREP, signal, + NodeFailRep::SignalLength, JBB); + + sendSignal(cdihBlockref, GSN_NODE_FAILREP, signal, + NodeFailRep::SignalLength, JBB); + + sendSignal(cdictBlockref, GSN_NODE_FAILREP, signal, + NodeFailRep::SignalLength, JBB); + + sendSignal(BACKUP_REF, GSN_NODE_FAILREP, signal, + NodeFailRep::SignalLength, JBB); + + sendSignal(SUMA_REF, GSN_NODE_FAILREP, signal, + NodeFailRep::SignalLength, JBB); + + sendSignal(GREP_REF, GSN_NODE_FAILREP, signal, + NodeFailRep::SignalLength, JBB); + return; +}//Ndbcntr::execNODE_FAILREP() + +/*******************************/ +/* NODE_STATESCONF */ +/*******************************/ +void Ndbcntr::execNODE_STATESCONF(Signal* signal) +{ + jamEntry(); + cmasterCandidateId = signal->theData[0]; + cnoNeedNodes = signal->theData[1]; +/*----------------------------------------------------------------------*/ +// Now that we have knowledge of how many nodes are needed we will call +// ph2CLab to ensure that node restart continues if we already received +// all APPL_CHANGEREP signals. +/*----------------------------------------------------------------------*/ + ph2CLab(signal); + return; +}//Ndbcntr::execNODE_STATESCONF() + +/*******************************/ +/* NODE_STATESREF */ +/*******************************/ +void Ndbcntr::execNODE_STATESREF(Signal* signal) +{ + jamEntry(); + systemErrorLab(signal); + return; +}//Ndbcntr::execNODE_STATESREF() + +/*******************************/ +/* NODE_STATESREQ */ +/*******************************/ +void Ndbcntr::execNODE_STATESREQ(Signal* signal) +{ + UintR TnoNeedNodes = 0; + NodeRecPtr TNodePtr; + jamEntry(); + BlockReference TuserBlockref = signal->theData[0]; +/*----------------------------------------------------------------------*/ +// IF WE ARE RUNNING, WE WILL ANSWER THIS SIGNAL WITH THE AMOUNT OF NODES +// THAT ARE IN THE RUN STATE OR START STATE. +/*----------------------------------------------------------------------*/ + TNodePtr.i = getOwnNodeId(); + ptrCheckGuard(TNodePtr, MAX_NDB_NODES, nodeRec); + if (TNodePtr.p->state == ZRUN) { + jam(); + for (TNodePtr.i = 1; TNodePtr.i < MAX_NDB_NODES; TNodePtr.i++) { + jam(); + ptrAss(TNodePtr, nodeRec); + if ((TNodePtr.p->state == ZRUN) || + (TNodePtr.p->state == ZSTART)) { + jam(); + TnoNeedNodes++; + }//if + }//for + signal->theData[0] = cmasterNodeId; + signal->theData[1] = TnoNeedNodes; + sendSignal(TuserBlockref, GSN_NODE_STATESCONF, signal, 2, JBB); + } else { + jam(); + signal->theData[0] = ZERROR_NOT_RUNNING; + sendSignal(TuserBlockref, GSN_NODE_STATESREF, signal, 1, JBB); + }//if + return; +}//Ndbcntr::execNODE_STATESREQ() + +/*******************************/ +/* READ_NODESREQ */ +/*******************************/ +void Ndbcntr::execREAD_NODESREQ(Signal* signal) +{ + UintR TnoNodes = 0; + NodeRecPtr TNodePtr; + jamEntry(); + + /*----------------------------------------------------------------------*/ + // ANY BLOCK MAY SEND A REQUEST ABOUT NDB NODES AND VERSIONS IN THE + // SYSTEM. THIS REQUEST CAN ONLY BE HANDLED IN + // ABSOLUTE STARTPHASE 3 OR LATER + /*----------------------------------------------------------------------*/ + BlockReference TuserBlockref = signal->theData[0]; + ReadNodesConf * const readNodes = (ReadNodesConf *)&signal->theData[0]; + + if (cstartPhase > ZSTART_PHASE_2) { + ndbrequire(cstartProgressFlag == ZTRUE); + + NodeBitmask::clear(readNodes->allNodes); + NodeBitmask::clear(readNodes->inactiveNodes); + + /** + * Add started nodes + */ + for (int i = 0; i < cnoStartNodes; i++){ + jam(); + TNodePtr.i = cstartNodes[i]; + ptrCheckGuard(TNodePtr, MAX_NDB_NODES, nodeRec); + + NodeBitmask::set(readNodes->allNodes, TNodePtr.i); + readNodes->setVersionId(TNodePtr.i, TNodePtr.p->ndbVersion, + readNodes->theVersionIds); + TnoNodes++; + }//for + + /** + * Sometimes add myself + */ + if ((ctypeOfStart == NodeState::ST_NODE_RESTART) || + (ctypeOfStart == NodeState::ST_INITIAL_NODE_RESTART)) { + jam(); + + NodeBitmask::set(readNodes->allNodes, getOwnNodeId()); + readNodes->setVersionId(getOwnNodeId(), NDB_VERSION, + readNodes->theVersionIds); + TnoNodes++; + }//if + /** + * Check all nodes which are defined but not already added + */ + for (TNodePtr.i = 1; TNodePtr.i < MAX_NDB_NODES; TNodePtr.i++) { + jam(); + ptrAss(TNodePtr, nodeRec); + if ((TNodePtr.p->nodeDefined == ZTRUE) && + (NodeBitmask::get(readNodes->allNodes, TNodePtr.i) == false)){ + jam(); + + NodeBitmask::set(readNodes->allNodes, TNodePtr.i); + NodeBitmask::set(readNodes->inactiveNodes, TNodePtr.i); + readNodes->setVersionId(TNodePtr.i, NDB_VERSION, + readNodes->theVersionIds); + + TnoNodes++; + }//if + }//for + + readNodes->noOfNodes = TnoNodes; + readNodes->masterNodeId = cmasterNodeId; + sendSignal(TuserBlockref, GSN_READ_NODESCONF, signal, + ReadNodesConf::SignalLength, JBB); + + } else { + jam(); + signal->theData[0] = ZNOT_AVAILABLE; + sendSignal(TuserBlockref, GSN_READ_NODESREF, signal, 1, JBB); + }//if +}//Ndbcntr::execREAD_NODESREQ() + +/*----------------------------------------------------------------------*/ +// SENDS APPL_ERROR TO QMGR AND THEN SET A POINTER OUT OF BOUNDS +/*----------------------------------------------------------------------*/ +void Ndbcntr::systemErrorLab(Signal* signal) +{ + progError(0, 0); /* BUG INSERTION */ + return; +}//Ndbcntr::systemErrorLab() + +/*###########################################################################*/ +/* CNTR MASTER CREATES AND INITIALIZES A SYSTEMTABLE AT INITIALSTART */ +/* |-2048| # 1 00000001 | */ +/* | : | : | */ +/* | -1 | # 1 00000001 | */ +/* | 0 | 0 | */ +/* | 1 | 0 | */ +/* | : | : | */ +/* | 2047| 0 | */ +/*---------------------------------------------------------------------------*/ +void Ndbcntr::createSystableLab(Signal* signal, unsigned index) +{ + if (index >= g_sysTableCount) { + ndbassert(index == g_sysTableCount); + startInsertTransactions(signal); + return; + } + const SysTable& table = *g_sysTableList[index]; + Uint32 propPage[256]; + LinearWriter w(propPage, 256); + + // XXX remove commented-out lines later + + w.first(); + w.add(DictTabInfo::TableName, table.name); + w.add(DictTabInfo::TableLoggedFlag, table.tableLoggedFlag); + //w.add(DictTabInfo::TableKValue, 6); + //w.add(DictTabInfo::MinLoadFactor, 70); + //w.add(DictTabInfo::MaxLoadFactor, 80); + w.add(DictTabInfo::FragmentTypeVal, (Uint32)table.fragmentType); + //w.add(DictTabInfo::TableStorageVal, (Uint32)DictTabInfo::MainMemory); + //w.add(DictTabInfo::NoOfKeyAttr, 1); + w.add(DictTabInfo::NoOfAttributes, (Uint32)table.columnCount); + //w.add(DictTabInfo::NoOfNullable, (Uint32)0); + //w.add(DictTabInfo::NoOfVariable, (Uint32)0); + //w.add(DictTabInfo::KeyLength, 1); + w.add(DictTabInfo::TableTypeVal, (Uint32)table.tableType); + + for (unsigned i = 0; i < table.columnCount; i++) { + const SysColumn& column = table.columnList[i]; + ndbassert(column.pos == i); + w.add(DictTabInfo::AttributeName, column.name); + w.add(DictTabInfo::AttributeId, (Uint32)column.pos); + //w.add(DictTabInfo::AttributeType, DictTabInfo::UnSignedType); + //w.add(DictTabInfo::AttributeSize, DictTabInfo::a32Bit); + //w.add(DictTabInfo::AttributeArraySize, 1); + w.add(DictTabInfo::AttributeKeyFlag, (Uint32)column.keyFlag); + //w.add(DictTabInfo::AttributeStorage, (Uint32)DictTabInfo::MainMemory); + w.add(DictTabInfo::AttributeNullableFlag, (Uint32)column.nullable); + // ext type overrides + w.add(DictTabInfo::AttributeExtType, (Uint32)column.type); + w.add(DictTabInfo::AttributeExtLength, (Uint32)column.length); + w.add(DictTabInfo::AttributeEnd, (Uint32)true); + } + w.add(DictTabInfo::TableEnd, (Uint32)true); + + Uint32 length = w.getWordsUsed(); + LinearSectionPtr ptr[3]; + ptr[0].p = &propPage[0]; + ptr[0].sz = length; + + CreateTableReq* const req = (CreateTableReq*)signal->getDataPtrSend(); + req->senderData = index; + req->senderRef = reference(); + sendSignal(DBDICT_REF, GSN_CREATE_TABLE_REQ, signal, + CreateTableReq::SignalLength, JBB, ptr, 1); + return; +}//Ndbcntr::createSystableLab() + +void Ndbcntr::execCREATE_TABLE_REF(Signal* signal) +{ + jamEntry(); + progError(0,0); + return; +}//Ndbcntr::execDICTTABREF() + +void Ndbcntr::execCREATE_TABLE_CONF(Signal* signal) +{ + jamEntry(); + CreateTableConf * const conf = (CreateTableConf*)signal->getDataPtrSend(); + //csystabId = conf->tableId; + ndbrequire(conf->senderData < g_sysTableCount); + const SysTable& table = *g_sysTableList[conf->senderData]; + table.tableId = conf->tableId; + createSystableLab(signal, conf->senderData + 1); + //startInsertTransactions(signal); + return; +}//Ndbcntr::execDICTTABCONF() + +/*******************************/ +/* DICTRELEASECONF */ +/*******************************/ +void Ndbcntr::startInsertTransactions(Signal* signal) +{ + jamEntry(); + + ckey = 1; + ctransidPhase = ZTRUE; + signal->theData[1] = cownBlockref; + sendSignal(ctcBlockref, GSN_TCSEIZEREQ, signal, 2, JBB); + return; +}//Ndbcntr::startInsertTransactions() + +/*******************************/ +/* TCSEIZECONF */ +/*******************************/ +void Ndbcntr::execTCSEIZECONF(Signal* signal) +{ + jamEntry(); + ctcConnectionP = signal->theData[1]; + crSystab7Lab(signal); + return; +}//Ndbcntr::execTCSEIZECONF() + +const unsigned int RowsPerCommit = 16; +void Ndbcntr::crSystab7Lab(Signal* signal) +{ + UintR tkey; + UintR Tmp; + + TcKeyReq * const tcKeyReq = (TcKeyReq *)&signal->theData[0]; + + UintR reqInfo_Start = 0; + tcKeyReq->setOperationType(reqInfo_Start, ZINSERT); // Insert + tcKeyReq->setKeyLength (reqInfo_Start, 1); + tcKeyReq->setAIInTcKeyReq (reqInfo_Start, 5); + tcKeyReq->setAbortOption (reqInfo_Start, TcKeyReq::AbortOnError); + +/* KEY LENGTH = 1, ATTRINFO LENGTH IN TCKEYREQ = 5 */ + cresponses = 0; + const UintR guard0 = ckey + (RowsPerCommit - 1); + for (Tmp = ckey; Tmp <= guard0; Tmp++) { + UintR reqInfo = reqInfo_Start; + if (Tmp == ckey) { // First iteration, Set start flag + jam(); + tcKeyReq->setStartFlag(reqInfo, 1); + } //if + if (Tmp == guard0) { // Last iteration, Set commit flag + jam(); + tcKeyReq->setCommitFlag(reqInfo, 1); + tcKeyReq->setExecuteFlag(reqInfo, 1); + } //if + if (ctransidPhase == ZTRUE) { + jam(); + tkey = 0; + tkey = tkey - Tmp; + } else { + jam(); + tkey = Tmp; + }//if + + tcKeyReq->apiConnectPtr = ctcConnectionP; + tcKeyReq->attrLen = 5; + tcKeyReq->tableId = g_sysTable_SYSTAB_0.tableId; + tcKeyReq->requestInfo = reqInfo; + tcKeyReq->tableSchemaVersion = ZSYSTAB_VERSION; + tcKeyReq->transId1 = 0; + tcKeyReq->transId2 = 0; + +//------------------------------------------------------------- +// There is no optional part in this TCKEYREQ. There is one +// key word and five ATTRINFO words. +//------------------------------------------------------------- + Uint32* tKeyDataPtr = &tcKeyReq->scanInfo; + Uint32* tAIDataPtr = &tKeyDataPtr[1]; + + tKeyDataPtr[0] = tkey; + + AttributeHeader::init(&tAIDataPtr[0], 0, 1); + tAIDataPtr[1] = tkey; + AttributeHeader::init(&tAIDataPtr[2], 1, 2); + tAIDataPtr[3] = (tkey << 16); + tAIDataPtr[4] = 1; + sendSignal(ctcBlockref, GSN_TCKEYREQ, signal, + TcKeyReq::StaticLength + 6, JBB); + }//for + ckey = ckey + RowsPerCommit; + return; +}//Ndbcntr::crSystab7Lab() + +/*******************************/ +/* TCKEYCONF09 */ +/*******************************/ +void Ndbcntr::execTCKEYCONF(Signal* signal) +{ + const TcKeyConf * const keyConf = (TcKeyConf *)&signal->theData[0]; + + jamEntry(); + cgciSystab = keyConf->gci; + UintR confInfo = keyConf->confInfo; + + if (TcKeyConf::getMarkerFlag(confInfo)){ + Uint32 transId1 = keyConf->transId1; + Uint32 transId2 = keyConf->transId2; + signal->theData[0] = transId1; + signal->theData[1] = transId2; + sendSignal(ctcBlockref, GSN_TC_COMMIT_ACK, signal, 2, JBB); + }//if + + cresponses = cresponses + TcKeyConf::getNoOfOperations(confInfo); + if (TcKeyConf::getCommitFlag(confInfo)){ + jam(); + ndbrequire(cresponses == RowsPerCommit); + + crSystab8Lab(signal); + return; + } + return; +}//Ndbcntr::tckeyConfLab() + +void Ndbcntr::crSystab8Lab(Signal* signal) +{ + if (ckey < ZSIZE_SYSTAB) { + jam(); + crSystab7Lab(signal); + return; + } else if (ctransidPhase == ZTRUE) { + jam(); + ckey = 1; + ctransidPhase = ZFALSE; + crSystab7Lab(signal); + return; + }//if + signal->theData[0] = ctcConnectionP; + signal->theData[1] = cownBlockref; + sendSignal(ctcBlockref, GSN_TCRELEASEREQ, signal, 2, JBB); + return; +}//Ndbcntr::crSystab8Lab() + +/*******************************/ +/* TCRELEASECONF */ +/*******************************/ +void Ndbcntr::execTCRELEASECONF(Signal* signal) +{ + jamEntry(); + waitpoint52Lab(signal); + return; +}//Ndbcntr::execTCRELEASECONF() + +void Ndbcntr::crSystab9Lab(Signal* signal) +{ + signal->theData[1] = cownBlockref; + sendSignalWithDelay(cdihBlockref, GSN_GETGCIREQ, signal, 100, 2); + return; +}//Ndbcntr::crSystab9Lab() + +/*******************************/ +/* GETGCICONF */ +/*******************************/ +void Ndbcntr::execGETGCICONF(Signal* signal) +{ + jamEntry(); + +#ifndef NO_GCP + if (signal->theData[1] < cgciSystab) { + jam(); +/*--------------------------------------*/ +/* MAKE SURE THAT THE SYSTABLE IS */ +/* NOW SAFE ON DISK */ +/*--------------------------------------*/ + crSystab9Lab(signal); + return; + }//if +#endif + waitpoint52Lab(signal); + return; +}//Ndbcntr::execGETGCICONF() + +void Ndbcntr::execTCKEYREF(Signal* signal) +{ + jamEntry(); + systemErrorLab(signal); + return; +}//Ndbcntr::execTCKEYREF() + +void Ndbcntr::execTCROLLBACKREP(Signal* signal) +{ + jamEntry(); + systemErrorLab(signal); + return; +}//Ndbcntr::execTCROLLBACKREP() + +void Ndbcntr::execTCRELEASEREF(Signal* signal) +{ + jamEntry(); + systemErrorLab(signal); + return; +}//Ndbcntr::execTCRELEASEREF() + +void Ndbcntr::execTCSEIZEREF(Signal* signal) +{ + jamEntry(); + systemErrorLab(signal); + return; +}//Ndbcntr::execTCSEIZEREF() + +/* +4.10 SUBROUTINES */ +/*##########################################################################*/ +/* +4.10.1 CHECK_NODELIST */ +/*---------------------------------------------------------------------------*/ +/*CHECK THAT ALL THE NEW NODE HAS DETECTED ALL RUNNING NODES */ +/*INPUT: CSTART_NODES */ +/* TNO_RESTART_NODES */ +/* TUSER_NODE_ID */ +/*RET: CNODE_RESTART */ +/*---------------------------------------------------------------------------*/ +UintR Ndbcntr::checkNodelist(Signal* signal, Uint16 TnoRestartNodes) +{ + UintR guard1; + UintR Ttemp1; + + if (cnoRunNodes == TnoRestartNodes) { + jam(); + guard1 = TnoRestartNodes - 1; + arrGuard(guard1, MAX_NDB_NODES); + for (Ttemp1 = 0; Ttemp1 <= guard1; Ttemp1++) { + jam(); + nodePtr.i = cstartNodes[Ttemp1]; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); + if (nodePtr.p->state != ZRUN) { + jam(); + return 0; + }//if + }//for + return 1; + }//if + return 0; +}//Ndbcntr::checkNodelist() + +/*---------------------------------------------------------------------------*/ +// SELECT NODES THAT ARE IN THE STATE TO PERFORM A INITIALSTART OR +// SYSTEMRESTART. +// THIS SUBROUTINE CAN ONLY BE INVOKED BY THE MASTER NODE. +// TO BE CHOOSEN A NODE NEED AS MANY VOTES AS THERE ARE VOTERS, AND OF +// COURSE THE NODE HAS TO BE KNOWN BY THE +// MASTER +// INPUT: NODE_REC +// CNO_NEED_NODES +// RETURN:CNO_START_NODES +// CSTART_NODES +/*---------------------------------------------------------------------------*/ +void Ndbcntr::chooseRestartNodes(Signal* signal) +{ + cnoStartNodes = 0; + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + ptrAss(nodePtr, nodeRec); + if (nodePtr.p->votes == cnoVoters) { + jam(); + if (nodePtr.p->state == ZADD) { + jam(); + arrGuard(cnoStartNodes, MAX_NDB_NODES); + cstartNodes[cnoStartNodes] = nodePtr.i; + cnoStartNodes++; + }//if + } else { + jam(); + if (nodePtr.p->votes > 0) { + jam(); + systemErrorLab(signal); + return; + }//if + }//if + }//for +}//Ndbcntr::chooseRestartNodes() + +/* +4.10.6 DELETE_NODE */ +/*---------------------------------------------------------------------------*/ +// INPUT: NODE_PTR +/*---------------------------------------------------------------------------*/ +void Ndbcntr::deleteNode(Signal* signal) +{ + UintR tminDynamicId; + + if (nodePtr.p->state == ZRUN) { + jam(); + cnoRunNodes = cnoRunNodes - 1; + }//if + nodePtr.p->state = ZREMOVE; + nodePtr.p->votes = 0; + nodePtr.p->voter = ZFALSE; + cnoRegNodes--; + if (nodePtr.i == cmasterNodeId) { + jam(); + cmasterNodeId = ZNIL; +/*---------------------------------------------------------------------------*/ +// IF MASTER HAVE CRASHED WE NEED TO SELECT A NEW MASTER. +/*---------------------------------------------------------------------------*/ + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRec); + if (nodePtr.p->state == ZRUN) { + if (cmasterNodeId == ZNIL) { + jam(); + cmasterNodeId = nodePtr.i; + tminDynamicId = nodePtr.p->dynamicId; + } else { + jam(); + if (nodePtr.p->dynamicId < tminDynamicId) { + jam(); + cmasterNodeId = nodePtr.i; + tminDynamicId = nodePtr.p->dynamicId; + }//if + }//if + }//if + }//for + }//if +}//Ndbcntr::deleteNode() + +/*---------------------------------------------------------------------------*/ +// A NEW NODE TRIES TO DETECT A NODE RESTART. NodeState::ST_NODE_RESTART IS A POSSIBLE +// STATE ONLY WHEN THE SYSTEM IS RUNNING. +// IF THE SYSTEM IS RUNNING THEN +// CTYPE_OF_START = NodeState::ST_SYSTEM_RESTART UNTIL THE FIRST NODE HAS REGISTERED. +// IF SYSTEM IS */ +// RUNNING THE FIRST NODE TO REGISTER WILL BE ZRUN AND CTYPE_OF_START +// WILL BE CHANGED */ +// TO NodeState::ST_NODE_RESTART AT PH_2C. WHEN A NodeState::ST_NODE_RESTART IS DETECTED THE NEW NODE +// HAS TO SEND */ +// A CNTR_MASTERREQ TO THE MASTER +/*---------------------------------------------------------------------------*/ +void Ndbcntr::detectNoderestart(Signal* signal) +{ + NodeRecPtr ownNodePtr; + ownNodePtr.i = getOwnNodeId(); + ptrCheckGuard(ownNodePtr, MAX_NDB_NODES, nodeRec); + if (ownNodePtr.p->state != ZADD) { + if (ownNodePtr.p->state != ZREMOVE) { + jam(); + return; + }//if + }//if + ctypeOfStart = NodeState::ST_NODE_RESTART; +/*----------------------------------------------*/ +/* THIS NODE WILL PERFORM A NODE RESTART */ +/* REQUEST OF ALL NODES STATES IN SYSTEM */ +// The purpose of this signal is to ensure that +// the starting node knows when it has received +// all APPL_CHANGEREP signals and thus can continue +// to the next step of the node restart. Thus we +// need to know the amount of nodes that are in the +// RUN state and in the START state (more than one +// node can be copying data simultaneously in the +// cluster. +/*----------------------------------------------*/ + signal->theData[0] = cownBlockref; + sendSignal(nodePtr.p->cntrBlockref, GSN_NODE_STATESREQ, signal, 1, JBB); + cnoNeedNodes = ZNIL; +/*---------------------------------*/ +/* PREVENT TO SEND NODE_STATESREQ */ +/*---------------------------------------------------------------------------*/ +/* WE NEED TO WATCH THE NODE RESTART WITH A TIME OUT TO NOT WAIT FOR EVER. */ +/*---------------------------------------------------------------------------*/ + cwaitContinuebFlag = ZTRUE; + signal->theData[0] = ZCONTINUEB_1; + sendSignalWithDelay(cownBlockref, GSN_CONTINUEB, signal, 3 * 1000, 1); +}//Ndbcntr::detectNoderestart() + +/*---------------------------------------------------------------------------*/ +// SCAN NODE_REC FOR APPROPRIATE NODES FOR A START. +// SYSTEMRESTART AND INITALSTART DEMANDS NODES OF STATE ZADD. +// NODERESTART DEMANDS NODE OF THE STATE ZRUN. +// INPUT: CTYPE_OF_START, NODE_REC +// RETURN: CSTART_NODES(), CNO_START_NODES, CMASTER_CANDIDATE_ID +// (SYSTEMRESTART AND INITALSTART) +/*---------------------------------------------------------------------------*/ +void Ndbcntr::getStartNodes(Signal* signal) +{ + UintR Ttemp1; + if ((ctypeOfStart == NodeState::ST_NODE_RESTART) || + (ctypeOfStart == NodeState::ST_INITIAL_NODE_RESTART)) { + jam(); + Ttemp1 = ZRUN; + } else { + jam(); +/*---------------------------------*/ +/* SYSTEM RESTART AND INITIAL START*/ +/*---------------------------------*/ + Ttemp1 = ZADD; + }//if + cnoStartNodes = 0; + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + jam(); + ptrAss(nodePtr, nodeRec); + if (nodePtr.p->state == Ttemp1) { + jam(); + cstartNodes[cnoStartNodes] = nodePtr.i;/*OVERWRITTEN AT CNTR_MASTERCONF*/ + cnoStartNodes++; + }//if + }//for +}//Ndbcntr::getStartNodes() + +/*---------------------------------------------------------------------------*/ +/*INITIALIZE VARIABLES AND RECORDS */ +/*---------------------------------------------------------------------------*/ +void Ndbcntr::initData(Signal* signal) +{ + cmasterNodeId = ZNIL; + cmasterCandidateId = ZNIL; + cmasterVoters = 0; + cstartProgressFlag = ZFALSE; + capplStartconfFlag = ZFALSE; + cnoVoters = 0; + cnoStartNodes = 0; + for (nodePtr.i = 0; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { + ptrAss(nodePtr, nodeRec); + nodePtr.p->cntrBlockref = calcNdbCntrBlockRef(nodePtr.i); + nodePtr.p->state = ZREMOVE; + nodePtr.p->dynamicId = 0; + nodePtr.p->votes = 0; /* USED BY MASTER */ + nodePtr.p->voter = ZFALSE; /* USED BY MASTER */ + nodePtr.p->masterReq = ZFALSE; /* USED BY MASTER */ + }//for +}//Ndbcntr::initData() + +/*---------------------------------------------------------------------------*/ +// THE MASTER NODE HAS CHOOSEN THE NODES WHO WERE QUALIFIED TO +// PARTICIPATE IN A INITIALSTART OR SYSTEMRESTART. +// THIS SUBROTINE SENDS A CNTR_MASTERCONF TO THESE NODES +/*---------------------------------------------------------------------------*/ +void Ndbcntr::replyMasterconfToAll(Signal* signal) +{ + if (cnoStartNodes > 1) { + /** + * Construct a MasterConf signal + */ + + CntrMasterConf * const cntrMasterConf = + (CntrMasterConf *)&signal->theData[0]; + NodeBitmask::clear(cntrMasterConf->theNodes); + + cntrMasterConf->noStartNodes = cnoStartNodes; + + for(int i = 0; itheNodes, cstartNodes[i]); + + /** + * Then distribute it to everyone but myself + */ + for(int i = 0; ivotes = 0; + nodePtr.p->voter = ZFALSE; + nodePtr.p->masterReq = ZFALSE; + }//for + cnoVoters = 0; + cnoStartNodes = 0; + cnoWaitrep6 = cnoWaitrep7 = 0; +}//Ndbcntr::resetStartVariables() + +/*---------------------------------------------------------------------------*/ +// SENDER OF THIS SIGNAL HAS CHOOSEN A MASTER NODE AND SENDS A REQUEST +// TO THE MASTER_CANDIDATE AS AN VOTE FOR +// THE MASTER. THE SIGNAL ALSO INCLUDES VOTES FOR NODES WHICH SENDER +// THINKS SHOULD PARTICIPATE IN THE START. +// INPUT: CNO_START_NODES +// CSTART_NODES +/*---------------------------------------------------------------------------*/ +void Ndbcntr::sendCntrMasterreq(Signal* signal) +{ + nodePtr.i = cmasterCandidateId; + ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec); +/*--------------------------------------------------------------*/ +/* O:INITIALSTART, 1:SYSTEMRESTART (ELECTION OF MASTER) */ +/* 2:NODE RESTART (SENDER NODE NOT INCLUDED IN CSTART_NODES) */ +/*--------------------------------------------------------------*/ + CntrMasterReq * const cntrMasterReq = (CntrMasterReq*)&signal->theData[0]; + NodeBitmask::clear(cntrMasterReq->theNodes); + for (int i = 0; i < cnoStartNodes; i++){ + jam(); + UintR Tnode = cstartNodes[i]; + arrGuard(Tnode, MAX_NDB_NODES); + NodeBitmask::set(cntrMasterReq->theNodes, Tnode); + }//for + cntrMasterReq->userBlockRef = cownBlockref; + cntrMasterReq->userNodeId = getOwnNodeId(); + cntrMasterReq->typeOfStart = ctypeOfStart; + cntrMasterReq->noRestartNodes = cnoStartNodes; + sendSignal(nodePtr.p->cntrBlockref, GSN_CNTR_MASTERREQ, + signal, CntrMasterReq::SignalLength, JBB); +}//Ndbcntr::sendCntrMasterreq() + +/*---------------------------------------------------------------------------*/ +// SEND THE SIGNAL +// INPUT CNDB_BLOCKS_COUNT +/*---------------------------------------------------------------------------*/ +void Ndbcntr::sendNdbSttor(Signal* signal) +{ + CfgBlockRecPtr cfgBlockPtr; + NdbBlocksRecPtr ndbBlocksPtr; + + ndbBlocksPtr.i = cndbBlocksCount; + ptrCheckGuard(ndbBlocksPtr, ZSIZE_NDB_BLOCKS_REC, ndbBlocksRec); + cfgBlockPtr.i = cinternalStartphase; + ptrCheckGuard(cfgBlockPtr, ZSIZE_CFG_BLOCK_REC, cfgBlockRec); + NdbSttor * const req = (NdbSttor*)signal->getDataPtrSend(); + req->senderRef = cownBlockref; + req->nodeId = getOwnNodeId(); + req->internalStartPhase = cinternalStartphase; + req->typeOfStart = ctypeOfStart; + req->masterNodeId = cmasterNodeId; + + for (int i = 0; i < 16; i++) { + req->config[i] = cfgBlockPtr.p->cfgData[i]; + } + + //#define TRACE_STTOR + //#define MAX_STARTPHASE 2 +#ifdef TRACE_STTOR + ndbout_c("sending NDB_STTOR(%d) to %s", + cinternalStartphase, + getBlockName( refToBlock(ndbBlocksPtr.p->blockref))); +#endif + sendSignal(ndbBlocksPtr.p->blockref, GSN_NDB_STTOR, signal, 22, JBB); + cndbBlocksCount++; +}//Ndbcntr::sendNdbSttor() + +/*---------------------------------------------------------------------------*/ +// JUST SEND THE SIGNAL +/*---------------------------------------------------------------------------*/ +void Ndbcntr::sendSttorry(Signal* signal) +{ + signal->theData[0] = csignalKey; + signal->theData[1] = 3; + signal->theData[2] = 2; + signal->theData[3] = ZSTART_PHASE_1; + signal->theData[4] = ZSTART_PHASE_2; + signal->theData[5] = ZSTART_PHASE_3; + signal->theData[6] = ZSTART_PHASE_4; + signal->theData[7] = ZSTART_PHASE_5; + signal->theData[8] = ZSTART_PHASE_6; + // skip simulated phase 7 + signal->theData[9] = ZSTART_PHASE_8; + signal->theData[10] = ZSTART_PHASE_9; + signal->theData[11] = ZSTART_PHASE_END; + sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 12, JBB); +}//Ndbcntr::sendSttorry() + +void +Ndbcntr::execDUMP_STATE_ORD(Signal* signal) +{ + DumpStateOrd * const & dumpState = (DumpStateOrd *)&signal->theData[0]; + if(signal->theData[0] == 13){ + infoEvent("Cntr: cstartPhase = %d, cinternalStartphase = %d, block = %d", + cstartPhase, cinternalStartphase, cndbBlocksCount); + infoEvent("Cntr: cmasterNodeId = %d, cmasterCandidateId = %d", + cmasterNodeId, cmasterCandidateId); + } + + if (dumpState->args[0] == DumpStateOrd::NdbcntrTestStopOnError){ + if (theConfiguration.stopOnError() == true) + ((Configuration&)theConfiguration).stopOnError(false); + + const BlockReference tblockref = calcNdbCntrBlockRef(getOwnNodeId()); + + SystemError * const sysErr = (SystemError*)&signal->theData[0]; + sysErr->errorCode = SystemError::TestStopOnError; + sysErr->errorRef = reference(); + sendSignal(tblockref, GSN_SYSTEM_ERROR, signal, + SystemError::SignalLength, JBA); + } + + +}//Ndbcntr::execDUMP_STATE_ORD() + +void Ndbcntr::execSET_VAR_REQ(Signal* signal) { + SetVarReq* const setVarReq = (SetVarReq*)&signal->theData[0]; + ConfigParamId var = setVarReq->variable(); + + switch (var) { + case TimeToWaitAlive: + // Valid only during start so value not set. + sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB); + break; + + default: + sendSignal(CMVMI_REF, GSN_SET_VAR_REF, signal, 1, JBB); + }// switch +}//Ndbcntr::execSET_VAR_REQ() + +void Ndbcntr::updateNodeState(Signal* signal, const NodeState& newState) const{ + NodeStateRep * const stateRep = (NodeStateRep *)&signal->theData[0]; + + stateRep->nodeState = newState; + stateRep->nodeState.masterNodeId = cmasterNodeId; + stateRep->nodeState.setNodeGroup(c_nodeGroup); + + for(Uint32 i = 0; itheData[0]; + //ResumeRef * const ref = (ResumeRef *)&signal->theData[0]; + + jamEntry(); + //Uint32 senderData = req->senderData; + //BlockReference senderRef = req->senderRef; + NodeState newState(NodeState::SL_STARTED); + updateNodeState(signal, newState); + c_stopRec.stopReq.senderRef=0; +} + +void +Ndbcntr::execSTOP_REQ(Signal* signal){ + StopReq * const req = (StopReq *)&signal->theData[0]; + StopRef * const ref = (StopRef *)&signal->theData[0]; + Uint32 singleuser = req->singleuser; + jamEntry(); + Uint32 senderData = req->senderData; + BlockReference senderRef = req->senderRef; + bool abort = StopReq::getStopAbort(req->requestInfo); + + if(getNodeState().startLevel < NodeState::SL_STARTED || + abort && !singleuser){ + /** + * Node is not started yet + * + * So stop it quickly + */ + jam(); + const Uint32 reqInfo = req->requestInfo; + if(StopReq::getPerformRestart(reqInfo)){ + jam(); + StartOrd * startOrd = (StartOrd *)&signal->theData[0]; + startOrd->restartInfo = reqInfo; + sendSignal(CMVMI_REF, GSN_START_ORD, signal, 1, JBA); + } else { + jam(); + sendSignal(CMVMI_REF, GSN_STOP_ORD, signal, 1, JBA); + } + return; + } + + if(c_stopRec.stopReq.senderRef != 0 && !singleuser){ + jam(); + /** + * Requested a system shutdown + */ + if(StopReq::getSystemStop(req->requestInfo)){ + jam(); + sendSignalWithDelay(reference(), GSN_STOP_REQ, signal, 100, + StopReq::SignalLength); + return; + } + + /** + * Requested a node shutdown + */ + if(StopReq::getSystemStop(c_stopRec.stopReq.requestInfo)) + ref->errorCode = StopRef::SystemShutdownInProgress; + else + ref->errorCode = StopRef::NodeShutdownInProgress; + ref->senderData = senderData; + sendSignal(senderRef, GSN_STOP_REF, signal, StopRef::SignalLength, JBB); + return; + } + + c_stopRec.stopReq = * req; + c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond(); + + if(StopReq::getSystemStop(c_stopRec.stopReq.requestInfo) && !singleuser) { + jam(); + if(StopReq::getPerformRestart(c_stopRec.stopReq.requestInfo)){ + ((Configuration&)theConfiguration).stopOnError(false); + } + } + if(!singleuser) { + if(!c_stopRec.checkNodeFail(signal)){ + jam(); + return; + } + } + NodeState newState(NodeState::SL_STOPPING_1, + StopReq::getSystemStop(c_stopRec.stopReq.requestInfo)); + + if(singleuser) { + newState.setSingleUser(true); + newState.setSingleUserApi(c_stopRec.stopReq.singleUserApi); + } + updateNodeState(signal, newState); + signal->theData[0] = ZSHUTDOWN; + sendSignalWithDelay(cownBlockref, GSN_CONTINUEB, signal, 100, 1); +} + +void +Ndbcntr::StopRecord::checkTimeout(Signal* signal){ + jamEntry(); + + if(!cntr.getNodeState().getSingleUserMode()) + if(!checkNodeFail(signal)){ + jam(); + return; + } + + switch(cntr.getNodeState().startLevel){ + case NodeState::SL_STOPPING_1: + checkApiTimeout(signal); + break; + case NodeState::SL_STOPPING_2: + checkTcTimeout(signal); + break; + case NodeState::SL_STOPPING_3: + checkLqhTimeout_1(signal); + break; + case NodeState::SL_STOPPING_4: + checkLqhTimeout_2(signal); + break; + case NodeState::SL_SINGLEUSER: + break; + default: + ndbrequire(false); + } +} + +bool +Ndbcntr::StopRecord::checkNodeFail(Signal* signal){ + jam(); + if(StopReq::getSystemStop(stopReq.requestInfo)){ + jam(); + return true; + } + + /** + * Check if I can survive me stopping + */ + NodeBitmask ndbMask; ndbMask.clear(); + NodeRecPtr aPtr; + for(aPtr.i = 1; aPtr.i < MAX_NDB_NODES; aPtr.i++){ + ptrAss(aPtr, cntr.nodeRec); + if(aPtr.i != cntr.getOwnNodeId() && aPtr.p->state == ZRUN){ + ndbMask.set(aPtr.i); + } + } + + CheckNodeGroups* sd = (CheckNodeGroups*)&signal->theData[0]; + sd->blockRef = cntr.reference(); + sd->requestType = CheckNodeGroups::Direct | CheckNodeGroups::ArbitCheck; + sd->mask = ndbMask; + cntr.EXECUTE_DIRECT(DBDIH, GSN_CHECKNODEGROUPSREQ, signal, + CheckNodeGroups::SignalLength); + jamEntry(); + switch (sd->output) { + case CheckNodeGroups::Win: + case CheckNodeGroups::Partitioning: + return true; + break; + } + + StopRef * const ref = (StopRef *)&signal->theData[0]; + + ref->senderData = stopReq.senderData; + ref->errorCode = StopRef::NodeShutdownWouldCauseSystemCrash; + + const BlockReference bref = stopReq.senderRef; + cntr.sendSignal(bref, GSN_STOP_REF, signal, StopRef::SignalLength, JBB); + + stopReq.senderRef = 0; + + NodeState newState(NodeState::SL_STARTED); + + cntr.updateNodeState(signal, newState); + return false; +} + +void +Ndbcntr::StopRecord::checkApiTimeout(Signal* signal){ + const Int32 timeout = stopReq.apiTimeout; + const NDB_TICKS alarm = stopInitiatedTime + (NDB_TICKS)timeout; + const NDB_TICKS now = NdbTick_CurrentMillisecond(); + if((timeout >= 0 && now >= alarm)){ + // || checkWithApiInSomeMagicWay) + jam(); + NodeState newState(NodeState::SL_STOPPING_2, + StopReq::getSystemStop(stopReq.requestInfo)); + if(stopReq.singleuser) { + newState.setSingleUser(true); + newState.setSingleUserApi(stopReq.singleUserApi); + } + cntr.updateNodeState(signal, newState); + + stopInitiatedTime = now; + } + + signal->theData[0] = ZSHUTDOWN; + cntr.sendSignalWithDelay(cntr.reference(), GSN_CONTINUEB, signal, 100, 1); +} + +void +Ndbcntr::StopRecord::checkTcTimeout(Signal* signal){ + const Int32 timeout = stopReq.transactionTimeout; + const NDB_TICKS alarm = stopInitiatedTime + (NDB_TICKS)timeout; + const NDB_TICKS now = NdbTick_CurrentMillisecond(); + if((timeout >= 0 && now >= alarm)){ + // || checkWithTcInSomeMagicWay) + jam(); + if(stopReq.getSystemStop(stopReq.requestInfo) || stopReq.singleuser){ + jam(); + if(stopReq.singleuser) + { + jam(); + AbortAllReq * req = (AbortAllReq*)&signal->theData[0]; + req->senderRef = cntr.reference(); + req->senderData = 12; + cntr.sendSignal(DBTC_REF, GSN_ABORT_ALL_REQ, signal, + AbortAllReq::SignalLength, JBB); + } + else + { + WaitGCPReq * req = (WaitGCPReq*)&signal->theData[0]; + req->senderRef = cntr.reference(); + req->senderData = 12; + req->requestType = WaitGCPReq::CompleteForceStart; + cntr.sendSignal(DBDIH_REF, GSN_WAIT_GCP_REQ, signal, + WaitGCPReq::SignalLength, JBB); + } + } else { + jam(); + StopPermReq * req = (StopPermReq*)&signal->theData[0]; + req->senderRef = cntr.reference(); + req->senderData = 12; + cntr.sendSignal(DBDIH_REF, GSN_STOP_PERM_REQ, signal, + StopPermReq::SignalLength, JBB); + } + return; + } + signal->theData[0] = ZSHUTDOWN; + cntr.sendSignalWithDelay(cntr.reference(), GSN_CONTINUEB, signal, 100, 1); +} + +void Ndbcntr::execSTOP_PERM_REF(Signal* signal){ + //StopPermRef* const ref = (StopPermRef*)&signal->theData[0]; + + jamEntry(); + + signal->theData[0] = ZSHUTDOWN; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 1); +} + +void Ndbcntr::execSTOP_PERM_CONF(Signal* signal){ + jamEntry(); + + AbortAllReq * req = (AbortAllReq*)&signal->theData[0]; + req->senderRef = reference(); + req->senderData = 12; + sendSignal(DBTC_REF, GSN_ABORT_ALL_REQ, signal, + AbortAllReq::SignalLength, JBB); +} + +void Ndbcntr::execABORT_ALL_CONF(Signal* signal){ + jamEntry(); + if(c_stopRec.stopReq.singleuser) { + jam(); + NodeState newState(NodeState::SL_SINGLEUSER); + newState.setSingleUser(true); + newState.setSingleUserApi(c_stopRec.stopReq.singleUserApi); + updateNodeState(signal, newState); + c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond(); + + } + else + { + jam(); + NodeState newState(NodeState::SL_STOPPING_3, + StopReq::getSystemStop(c_stopRec.stopReq.requestInfo)); + updateNodeState(signal, newState); + + c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond(); + + signal->theData[0] = ZSHUTDOWN; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 1); + } +} + +void Ndbcntr::execABORT_ALL_REF(Signal* signal){ + jamEntry(); + ndbrequire(false); +} + +void +Ndbcntr::StopRecord::checkLqhTimeout_1(Signal* signal){ + const Int32 timeout = stopReq.readOperationTimeout; + const NDB_TICKS alarm = stopInitiatedTime + (NDB_TICKS)timeout; + const NDB_TICKS now = NdbTick_CurrentMillisecond(); + + if((timeout >= 0 && now >= alarm)){ + // || checkWithLqhInSomeMagicWay) + jam(); + + ChangeNodeStateReq * req = (ChangeNodeStateReq*)&signal->theData[0]; + + NodeState newState(NodeState::SL_STOPPING_4, + StopReq::getSystemStop(stopReq.requestInfo)); + req->nodeState = newState; + req->senderRef = cntr.reference(); + req->senderData = 12; + cntr.sendSignal(DBLQH_REF, GSN_CHANGE_NODE_STATE_REQ, signal, 2, JBB); + return; + } + signal->theData[0] = ZSHUTDOWN; + cntr.sendSignalWithDelay(cntr.reference(), GSN_CONTINUEB, signal, 100, 1); +} + +void Ndbcntr::execCHANGE_NODE_STATE_CONF(Signal* signal){ + jamEntry(); + signal->theData[0] = reference(); + signal->theData[1] = 12; + sendSignal(DBDIH_REF, GSN_STOP_ME_REQ, signal, 2, JBB); +} + +void Ndbcntr::execSTOP_ME_REF(Signal* signal){ + jamEntry(); + ndbrequire(false); +} + + +void Ndbcntr::execSTOP_ME_CONF(Signal* signal){ + jamEntry(); + + NodeState newState(NodeState::SL_STOPPING_4, + StopReq::getSystemStop(c_stopRec.stopReq.requestInfo)); + updateNodeState(signal, newState); + + c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond(); + signal->theData[0] = ZSHUTDOWN; + sendSignalWithDelay(cownBlockref, GSN_CONTINUEB, signal, 100, 1); +} + +void +Ndbcntr::StopRecord::checkLqhTimeout_2(Signal* signal){ + const Int32 timeout = stopReq.operationTimeout; + const NDB_TICKS alarm = stopInitiatedTime + (NDB_TICKS)timeout; + const NDB_TICKS now = NdbTick_CurrentMillisecond(); + + if((timeout >= 0 && now >= alarm)){ + // || checkWithLqhInSomeMagicWay) + jam(); + if(StopReq::getPerformRestart(stopReq.requestInfo)){ + jam(); + StartOrd * startOrd = (StartOrd *)&signal->theData[0]; + startOrd->restartInfo = stopReq.requestInfo; + cntr.sendSignal(CMVMI_REF, GSN_START_ORD, signal, 2, JBA); + } else { + jam(); + cntr.sendSignal(CMVMI_REF, GSN_STOP_ORD, signal, 1, JBA); + } + return; + } + signal->theData[0] = ZSHUTDOWN; + cntr.sendSignalWithDelay(cntr.reference(), GSN_CONTINUEB, signal, 100, 1); +} + +void Ndbcntr::execWAIT_GCP_REF(Signal* signal){ + jamEntry(); + + //WaitGCPRef* const ref = (WaitGCPRef*)&signal->theData[0]; + + WaitGCPReq * req = (WaitGCPReq*)&signal->theData[0]; + req->senderRef = reference(); + req->senderData = 12; + req->requestType = WaitGCPReq::CompleteForceStart; + sendSignal(DBDIH_REF, GSN_WAIT_GCP_REQ, signal, + WaitGCPReq::SignalLength, JBB); +} + +void Ndbcntr::execWAIT_GCP_CONF(Signal* signal){ + jamEntry(); + + if(StopReq::getPerformRestart(c_stopRec.stopReq.requestInfo)){ + jam(); + StartOrd * startOrd = (StartOrd *)&signal->theData[0]; + startOrd->restartInfo = c_stopRec.stopReq.requestInfo; + sendSignalWithDelay(CMVMI_REF, GSN_START_ORD, signal, 500, + StartOrd::SignalLength); + } else { + jam(); + sendSignalWithDelay(CMVMI_REF, GSN_STOP_ORD, signal, 500, 1); + } + return; +} + +void Ndbcntr::execSTTORRY(Signal* signal){ + jamEntry(); + c_missra.execSTTORRY(signal); +} + +void Ndbcntr::execSTART_ORD(Signal* signal){ + jamEntry(); + ndbrequire(NO_OF_BLOCKS == ALL_BLOCKS_SZ); + c_missra.execSTART_ORD(signal); +} + +void +Ndbcntr::clearFilesystem(Signal* signal){ + FsRemoveReq * req = (FsRemoveReq *)signal->getDataPtrSend(); + req->userReference = reference(); + req->userPointer = 0; + req->directory = 1; + req->ownDirectory = 1; + FsOpenReq::setVersion(req->fileNumber, 3); + FsOpenReq::setSuffix(req->fileNumber, FsOpenReq::S_CTL); // Can by any... + FsOpenReq::v1_setDisk(req->fileNumber, c_fsRemoveCount); + sendSignal(NDBFS_REF, GSN_FSREMOVEREQ, signal, + FsRemoveReq::SignalLength, JBA); + c_fsRemoveCount++; +} + +void +Ndbcntr::execFSREMOVEREF(Signal* signal){ + jamEntry(); + ndbrequire(0); +} + +void +Ndbcntr::execFSREMOVECONF(Signal* signal){ + jamEntry(); + if(c_fsRemoveCount == 13){ + jam(); + sendSttorry(signal); + } else { + jam(); + ndbrequire(c_fsRemoveCount < 13); + clearFilesystem(signal); + }//if +} + +void Ndbcntr::Missra::execSTART_ORD(Signal* signal){ + signal->theData[0] = EventReport::NDBStartStarted; + signal->theData[1] = NDB_VERSION; + cntr.sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); + + currentStartPhase = 0; + for(Uint32 i = 0; isenderBlockRef(); + ndbrequire(refToBlock(ref) == refToBlock(ALL_BLOCKS[currentBlockIndex].Ref)); + + /** + * Update next start phase + */ + for (Uint32 i = 3; i < 25; i++){ + jam(); + if (signal->theData[i] > currentStartPhase){ + jam(); + ALL_BLOCKS[currentBlockIndex].NextSP = signal->theData[i]; + break; + } + } + + currentBlockIndex++; + sendNextSTTOR(signal); +} + +void Ndbcntr::Missra::sendNextSTTOR(Signal* signal){ + + for(; currentStartPhase < 255 ; currentStartPhase++){ + jam(); + + const Uint32 start = currentBlockIndex; + + for(; currentBlockIndex < ALL_BLOCKS_SZ; currentBlockIndex++){ + jam(); + if(ALL_BLOCKS[currentBlockIndex].NextSP == currentStartPhase){ + jam(); + signal->theData[0] = 0; + signal->theData[1] = currentStartPhase; + signal->theData[2] = 0; + signal->theData[3] = 0; + signal->theData[4] = 0; + signal->theData[5] = 0; + signal->theData[6] = 0; + signal->theData[7] = cntr.ctypeOfStart; + + const BlockReference ref = ALL_BLOCKS[currentBlockIndex].Ref; + +#ifdef MAX_STARTPHASE + ndbrequire(currentStartPhase <= MAX_STARTPHASE); +#endif + +#ifdef TRACE_STTOR + ndbout_c("sending STTOR(%d) to %s(ref=%x index=%d)", + currentStartPhase, + getBlockName( refToBlock(ref)), + ref, + currentBlockIndex); +#endif + + cntr.sendSignal(ref, GSN_STTOR, + signal, 8, JBB); + return; + } + } + + currentBlockIndex = 0; + + if(start != 0){ + /** + * At least one wanted this start phase, report it + */ + jam(); + signal->theData[0] = EventReport::StartPhaseCompleted; + signal->theData[1] = currentStartPhase; + signal->theData[2] = cntr.ctypeOfStart; + cntr.sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB); + } + } + + signal->theData[0] = EventReport::NDBStartCompleted; + signal->theData[1] = NDB_VERSION; + cntr.sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); + + NodeState newState(NodeState::SL_STARTED); + cntr.updateNodeState(signal, newState); +} diff --git a/ndb/src/kernel/blocks/ndbcntr/NdbcntrSysTable.cpp b/ndb/src/kernel/blocks/ndbcntr/NdbcntrSysTable.cpp new file mode 100644 index 00000000000..40e6aa2dcd7 --- /dev/null +++ b/ndb/src/kernel/blocks/ndbcntr/NdbcntrSysTable.cpp @@ -0,0 +1,94 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "Ndbcntr.hpp" + +#define arrayLength(x) sizeof(x)/sizeof(x[0]) + +// SYSTAB_0 + +static const Ndbcntr::SysColumn +column_SYSTAB_0[] = { + { 0, "SYSKEY_0", + DictTabInfo::ExtUnsigned, 1, + true, false + }, + { 1, "NEXTID", + DictTabInfo::ExtBigunsigned, 1, + false, false + } +}; + +const Ndbcntr::SysTable +Ndbcntr::g_sysTable_SYSTAB_0 = { + "sys/def/SYSTAB_0", + arrayLength(column_SYSTAB_0), column_SYSTAB_0, + DictTabInfo::SystemTable, + DictTabInfo::AllNodesSmallTable, + true, ~0 +}; + +// NDB$EVENTS_0 + +static const Ndbcntr::SysColumn +column_NDBEVENTS_0[] = { + { 0, "NAME", + DictTabInfo::ExtChar, MAX_TAB_NAME_SIZE, + true, false + }, + { 1, "EVENT_TYPE", + DictTabInfo::ExtUnsigned, 1, + false, false + }, + { 2, "TABLE_NAME", + DictTabInfo::ExtChar, MAX_TAB_NAME_SIZE, + false, false + }, + { 3, "ATTRIBUTE_MASK", + DictTabInfo::ExtUnsigned, MAXNROFATTRIBUTESINWORDS, + false, false + }, + { 4, "SUBID", + DictTabInfo::ExtUnsigned, 1, + false, false + }, + { 5, "SUBKEY", + DictTabInfo::ExtUnsigned, 1, + false, false + } +}; + +const Ndbcntr::SysTable +Ndbcntr::g_sysTable_NDBEVENTS_0 = { + "sys/def/NDB$EVENTS_0", + arrayLength(column_NDBEVENTS_0), column_NDBEVENTS_0, + DictTabInfo::SystemTable, + DictTabInfo::AllNodesSmallTable, + true, ~0 +}; + +// all + +const Ndbcntr::SysTable* +Ndbcntr::g_sysTableList[] = { + &g_sysTable_SYSTAB_0, + &g_sysTable_NDBEVENTS_0 +}; + +//TODO Backup needs this info to allocate appropriate number of records +//BackupInit.cpp +const unsigned +Ndbcntr::g_sysTableCount = arrayLength(Ndbcntr::g_sysTableList); diff --git a/ndb/src/kernel/blocks/ndbfs/AsyncFile.cpp b/ndb/src/kernel/blocks/ndbfs/AsyncFile.cpp new file mode 100644 index 00000000000..0e2aa4c6903 --- /dev/null +++ b/ndb/src/kernel/blocks/ndbfs/AsyncFile.cpp @@ -0,0 +1,1050 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/** + * O_DIRECT + */ +#ifdef NDB_LINUX +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif +#endif + +#include "Error.hpp" +#include "AsyncFile.hpp" + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef NDB_LINUX +// This is for pread and pwrite +#ifndef __USE_UNIX98 +#define __USE_UNIX98 +#endif +#endif + +#include +#if defined NDB_WIN32 || defined NDB_OSE || defined NDB_SOFTOSE +#include +#else +// For readv and writev +#include +#endif + +#ifndef NDB_WIN32 +#include +#endif + +// Use this define if you want printouts from AsyncFile class +//#define DEBUG_ASYNCFILE + +#ifdef DEBUG_ASYNCFILE +#include +#define DEBUG(x) x +#define PRINT_ERRORANDFLAGS(f) printErrorAndFlags(f) +void printErrorAndFlags(Uint32 used_flags); +#else +#define DEBUG(x) +#define PRINT_ERRORANDFLAGS(f) +#endif + +// Define the size of the write buffer (for each thread) +#if defined NDB_SOFTOSE || defined NDB_OSE +#define WRITEBUFFERSIZE 65536 +#else +#define WRITEBUFFERSIZE 262144 +#endif + +const char *actionName[] = { + "open", + "close", + "closeRemove", + "read", + "readv", + "write", + "writev", + "writeSync", + "writevSync", + "sync", + "end" }; + +static int numAsyncFiles = 0; + +extern "C" void * runAsyncFile(void* arg) +{ + ((AsyncFile*)arg)->run(); + return (NULL); +} + +AsyncFile::AsyncFile() : + theFileName(), +#ifdef NDB_WIN32 + hFile(INVALID_HANDLE_VALUE), +#else + theFd(-1), +#endif + theReportTo(0), + theMemoryChannelPtr(NULL) +{ +} + +void +AsyncFile::doStart(const char * filesystemPath) { + theFileName.init(filesystemPath); + + // Stacksize for filesystem threads + // An 8k stack should be enough + const NDB_THREAD_STACKSIZE stackSize = 8192; + + char buf[16]; + numAsyncFiles++; + snprintf(buf, sizeof(buf), "AsyncFile%d", numAsyncFiles); + + theStartMutexPtr = NdbMutex_Create(); + theStartConditionPtr = NdbCondition_Create(); + NdbMutex_Lock(theStartMutexPtr); + theStartFlag = false; + theThreadPtr = NdbThread_Create(runAsyncFile, + (void**)this, + stackSize, + (char*)&buf, + NDB_THREAD_PRIO_MEAN); + + NdbCondition_Wait(theStartConditionPtr, + theStartMutexPtr); + NdbMutex_Unlock(theStartMutexPtr); + NdbMutex_Destroy(theStartMutexPtr); + NdbCondition_Destroy(theStartConditionPtr); +} + +AsyncFile::~AsyncFile() +{ + void *status; + Request request; + request.action = Request::end; + theMemoryChannelPtr->writeChannel( &request ); + NdbThread_WaitFor(theThreadPtr, &status); + NdbThread_Destroy(&theThreadPtr); + delete theMemoryChannelPtr; +} + +void +AsyncFile::reportTo( MemoryChannel *reportTo ) +{ + theReportTo = reportTo; +} + +void AsyncFile::execute(Request* request) +{ + theMemoryChannelPtr->writeChannel( request ); +} + +void +AsyncFile::run() +{ + Request *request; + // Create theMemoryChannel in the thread that will wait for it + NdbMutex_Lock(theStartMutexPtr); + theMemoryChannelPtr = new MemoryChannel(); + theStartFlag = true; + // Create write buffer for bigger writes + theWriteBufferSize = WRITEBUFFERSIZE; + theWriteBuffer = (char *) NdbMem_Allocate(theWriteBufferSize); + NdbMutex_Unlock(theStartMutexPtr); + NdbCondition_Signal(theStartConditionPtr); + + if (!theWriteBuffer) { + DEBUG(ndbout_c("AsyncFile::writeReq, Failed allocating write buffer")); + return; + }//if + + while (1) { + request = theMemoryChannelPtr->readChannel(); + if (!request) { + DEBUG(ndbout_c("Nothing read from Memory Channel in AsyncFile")); + endReq(); + return; + }//if + switch (request->action) { + case Request:: open: + openReq(request); + break; + case Request:: close: + closeReq(request); + break; + case Request:: closeRemove: + closeReq(request); + removeReq(request); + break; + case Request:: read: + readReq(request); + break; + case Request:: readv: + readvReq(request); + break; + case Request:: write: + writeReq(request); + break; + case Request:: writev: + writevReq(request); + break; + case Request:: writeSync: + writeReq(request); + syncReq(request); + break; + case Request:: writevSync: + writevReq(request); + syncReq(request); + break; + case Request:: sync: + syncReq(request); + break; + case Request:: append: + appendReq(request); + break; + case Request::rmrf: + rmrfReq(request, (char*)theFileName.c_str(), request->par.rmrf.own_directory); + break; + case Request:: end: + closeReq(request); + endReq(); + return; + default: + THREAD_REQUIRE(false, "Using default switch in AsyncFile::run"); + break; + }//switch + theReportTo->writeChannel(request); + }//while +}//AsyncFile::run() + +extern bool Global_useO_SYNC; +extern bool Global_useO_DIRECT; +extern bool Global_unlinkO_CREAT; +extern Uint32 Global_syncFreq; + +void AsyncFile::openReq(Request* request) +{ + m_openedWithSync = false; + m_syncFrequency = 0; + + // for open.flags, see signal FSOPENREQ +#ifdef NDB_WIN32 + DWORD dwCreationDisposition; + DWORD dwDesiredAccess = 0; + DWORD dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE; + DWORD dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS | FILE_FLAG_NO_BUFFERING; + const Uint32 flags = request->par.open.flags; + + // Convert file open flags from Solaris to Windows + if ((flags & FsOpenReq::OM_CREATE) && (flags & FsOpenReq::OM_TRUNCATE)){ + dwCreationDisposition = CREATE_ALWAYS; + } else if (flags & FsOpenReq::OM_TRUNCATE){ + dwCreationDisposition = TRUNCATE_EXISTING; + } else if (flags & FsOpenReq::OM_CREATE){ + dwCreationDisposition = CREATE_NEW; + } else { + dwCreationDisposition = OPEN_EXISTING; + } + + switch(flags & 3){ + case FsOpenReq::OM_READONLY: + dwDesiredAccess = GENERIC_READ; + break; + case FsOpenReq::OM_WRITEONLY: + dwDesiredAccess = GENERIC_WRITE; + break; + case FsOpenReq::OM_READWRITE: + dwDesiredAccess = GENERIC_READ | GENERIC_WRITE; + break; + default: + request->error = 1000; + break; + return; + } + + hFile = CreateFile(theFileName.c_str(), dwDesiredAccess, dwShareMode, + 0, dwCreationDisposition, dwFlagsAndAttributes, 0); + + if(INVALID_HANDLE_VALUE == hFile) { + request->error = GetLastError(); + if(((ERROR_PATH_NOT_FOUND == request->error) || (ERROR_INVALID_NAME == request->error)) + && (flags & FsOpenReq::OM_CREATE)) { + createDirectories(); + hFile = CreateFile(theFileName.c_str(), dwDesiredAccess, dwShareMode, + 0, dwCreationDisposition, dwFlagsAndAttributes, 0); + + if(INVALID_HANDLE_VALUE == hFile) + request->error = GetLastError(); + else + request->error = 0; + + return; + } + } + else { + request->error = 0; + return; + } +#else + const Uint32 flags = request->par.open.flags; + Uint32 new_flags = 0; + + // Convert file open flags from Solaris to Liux + if(flags & FsOpenReq::OM_CREATE){ + new_flags |= O_CREAT; + } + + if(flags & FsOpenReq::OM_TRUNCATE){ +#if 0 + if(Global_unlinkO_CREAT){ + unlink(theFileName.c_str()); + } else +#endif + new_flags |= O_TRUNC; + } + + if(flags & FsOpenReq::OM_APPEND){ + new_flags |= O_APPEND; + } + + if(flags & FsOpenReq::OM_SYNC){ +#if 0 + if(Global_useO_SYNC){ + new_flags |= O_SYNC; + m_openedWithSync = true; + m_syncFrequency = 0; + } else { +#endif + m_openedWithSync = false; + m_syncCount = 0; + m_syncFrequency = Global_syncFreq; +#if 0 + } +#endif + } else { + m_openedWithSync = false; + m_syncFrequency = 0; + } + +#if 0 +#if NDB_LINUX + if(Global_useO_DIRECT){ + new_flags |= O_DIRECT; + } +#endif +#endif + + switch(flags & 0x3){ + case FsOpenReq::OM_READONLY: + new_flags |= O_RDONLY; + break; + case FsOpenReq::OM_WRITEONLY: + new_flags |= O_WRONLY; + break; + case FsOpenReq::OM_READWRITE: + new_flags |= O_RDWR; + break; + default: + request->error = 1000; + break; + return; + } + const int mode = S_IRUSR | S_IWUSR | S_IRGRP; + + if (-1 == (theFd = ::open(theFileName.c_str(), new_flags, mode))) { + PRINT_ERRORANDFLAGS(new_flags); + if( (errno == ENOENT ) && (new_flags & O_CREAT ) ) { + createDirectories(); + if (-1 == (theFd = ::open(theFileName.c_str(), new_flags, mode))) { + PRINT_ERRORANDFLAGS(new_flags); + request->error = errno; + } + } else { + request->error = errno; + } + } +#endif +} + +int +AsyncFile::readBuffer(char * buf, size_t size, off_t offset){ + int return_value; + +#ifdef NDB_WIN32 + DWORD dwSFP = SetFilePointer(hFile, offset, 0, FILE_BEGIN); + if(dwSFP != offset) { + return GetLastError(); + } +#elif defined NDB_OSE || defined NDB_SOFTOSE + return_value = lseek(theFd, offset, SEEK_SET); + if (return_value != offset) { + return errno; + } +#endif + + while (size > 0) { + size_t bytes_read = 0; + +#ifdef NDB_WIN32 + DWORD dwBytesRead; + BOOL bRead = ReadFile(hFile, + buf, + size, + &dwBytesRead, + 0); + if(!bRead){ + return GetLastError(); + } + bytes_read = dwBytesRead; +#elif defined NDB_OSE || defined NDB_SOFTOSE + return_value = ::read(theFd, buf, size); +#else // UNIX + return_value = ::pread(theFd, buf, size, offset); +#endif +#ifndef NDB_WIN32 + if (return_value == -1 && errno == EINTR) { + DEBUG(ndbout_c("EINTR in read")); + continue; + } else if (return_value == -1){ + return errno; + } else { + bytes_read = return_value; + } +#endif + + if(bytes_read == 0){ + DEBUG(ndbout_c("Read underflow %d %d\n %x\n%d %d", + size, offset, buf, bytes_read, return_value)); + return ERR_ReadUnderflow; + } + + if(bytes_read != size){ + DEBUG(ndbout_c("Warning partial read %d != %d", + bytes_read, size)); + } + + buf += bytes_read; + size -= bytes_read; + offset += bytes_read; + } + return 0; +} + +void +AsyncFile::readReq( Request * request) +{ + for(int i = 0; i < request->par.readWrite.numberOfPages ; i++) { + off_t offset = request->par.readWrite.pages[i].offset; + size_t size = request->par.readWrite.pages[i].size; + char * buf = request->par.readWrite.pages[i].buf; + + int err = readBuffer(buf, size, offset); + if(err != 0){ + request->error = err; + return; + } + } +} + +void +AsyncFile::readvReq( Request * request) +{ +#if defined NDB_OSE || defined NDB_SOFTOSE + readReq(request); + return; +#elif defined NDB_WIN32 + // ReadFileScatter? + readReq(request); + return; +#else + int return_value; + int length = 0; + struct iovec iov[20]; // the parameter in the signal restricts this to 20 deep + for(int i=0; i < request->par.readWrite.numberOfPages ; i++) { + iov[i].iov_base= request->par.readWrite.pages[i].buf; + iov[i].iov_len= request->par.readWrite.pages[i].size; + length = length + iov[i].iov_len; + } + lseek( theFd, request->par.readWrite.pages[0].offset, SEEK_SET ); + return_value = ::readv(theFd, iov, request->par.readWrite.numberOfPages); + if (return_value == -1) { + request->error = errno; + return; + } else if (return_value != length) { + request->error = 1011; + return; + } +#endif +} + +int +AsyncFile::extendfile(Request* request) { +#if defined NDB_OSE || defined NDB_SOFTOSE + // Find max size of this file in this request + int maxOffset = 0; + int maxSize = 0; + for(int i=0; i < request->par.readWrite.numberOfPages ; i++) { + if (request->par.readWrite.pages[i].offset > maxOffset) { + maxOffset = request->par.readWrite.pages[i].offset; + maxSize = request->par.readWrite.pages[i].size; + } + } + DEBUG(ndbout_c("extendfile: maxOffset=%d, size=%d", maxOffset, maxSize)); + + // Allocate a buffer and fill it with zeros + void* pbuf = malloc(maxSize); + memset(pbuf, 0, maxSize); + for (int p = 0; p <= maxOffset; p = p + maxSize) { + int return_value; + return_value = lseek(theFd, + p, + SEEK_SET); + if((return_value == -1 ) || (return_value != p)) { + return -1; + } + return_value = ::write(theFd, + pbuf, + maxSize); + if ((return_value == -1) || (return_value != maxSize)) { + return -1; + } + } + free(pbuf); + + DEBUG(ndbout_c("extendfile: \"%s\" OK!", theFileName.c_str())); + return 0; +#else + request = request; + abort(); + return -1; +#endif +} + +void +AsyncFile::writeReq( Request * request) +{ + int page_num = 0; + bool write_not_complete = true; + + while(write_not_complete) { + int totsize = 0; + off_t offset = request->par.readWrite.pages[page_num].offset; + char* bufptr = theWriteBuffer; + + write_not_complete = false; + if (request->par.readWrite.numberOfPages > 1) { + off_t page_offset = offset; + + // Multiple page write, copy to buffer for one write + for(int i=page_num; i < request->par.readWrite.numberOfPages; i++) { + memcpy(bufptr, + request->par.readWrite.pages[i].buf, + request->par.readWrite.pages[i].size); + bufptr += request->par.readWrite.pages[i].size; + totsize += request->par.readWrite.pages[i].size; + if (((i + 1) < request->par.readWrite.numberOfPages)) { + // There are more pages to write + // Check that offsets are consequtive + if ((page_offset + request->par.readWrite.pages[i].size) + != + request->par.readWrite.pages[i+1].offset) { + // Next page is not aligned with previous, not allowed + DEBUG(ndbout_c("Page offsets are not aligned")); + request->error = EINVAL; + return; + } + if ((unsigned)(totsize + request->par.readWrite.pages[i+1].size) > (unsigned)theWriteBufferSize) { + // We are not finished and the buffer is full + write_not_complete = true; + // Start again with next page + page_num = i + 1; + break; + } + } + page_offset += request->par.readWrite.pages[i].size; + } + bufptr = theWriteBuffer; + } else { + // One page write, write page directly + bufptr = request->par.readWrite.pages[0].buf; + totsize = request->par.readWrite.pages[0].size; + } + int err = writeBuffer(bufptr, totsize, offset); + if(err != 0){ + request->error = err; + return; + } + } // while(write_not_complete) +} + +int +AsyncFile::writeBuffer(const char * buf, size_t size, off_t offset, + size_t chunk_size) +{ + size_t bytes_to_write = chunk_size; + int return_value; + +#ifdef NDB_WIN32 + DWORD dwSFP = SetFilePointer(hFile, offset, 0, FILE_BEGIN); + if(dwSFP != offset) { + return GetLastError(); + } +#elif defined NDB_OSE || defined NDB_SOFTOSE + return_value = lseek(theFd, offset, SEEK_SET); + if (return_value != offset) { + DEBUG(ndbout_c("AsyncFile::writeReq, err1: return_value=%d, offset=%d\n", + return_value, chunk_offset)); + PRINT_ERRORANDFLAGS(0); + if (errno == 78) { + // Could not write beyond end of file, try to extend file + DEBUG(ndbout_c("AsyncFile::writeReq, Extend. file! filename=\"%s\" \n", + theFileName.c_str())); + return_value = extendfile(request); + if (return_value == -1) { + return errno; + } + return_value = lseek(theFd, offset, SEEK_SET); + if (return_value != offset) { + return errno; + } + } else { + return errno; + } + } +#endif + + while (size > 0) { + if (size < bytes_to_write){ + // We are at the last chunk + bytes_to_write = size; + } + size_t bytes_written = 0; + +#ifdef NDB_WIN32 + DWORD dwWritten; + BOOL bWrite = WriteFile(hFile, buf, bytes_to_write, &dwWritten, 0); + if(!bWrite) { + return GetLastError(); + } + bytes_written = dwWritten; + if (bytes_written != bytes_to_write) { + DEBUG(ndbout_c("Warning partial write %d != %d", bytes_written, bytes_to_write)); + } + +#elif defined NDB_OSE || defined NDB_SOFTOSE + return_value = ::write(theFd, buf, bytes_to_write); +#else // UNIX + return_value = ::pwrite(theFd, buf, bytes_to_write, offset); +#endif +#ifndef NDB_WIN32 + if (return_value == -1 && errno == EINTR) { + bytes_written = 0; + DEBUG(ndbout_c("EINTR in write")); + } else if (return_value == -1){ + return errno; + } else { + bytes_written = return_value; + + if(bytes_written == 0){ + abort(); + } + + if(bytes_written != bytes_to_write){ + DEBUG(ndbout_c("Warning partial write %d != %d", + bytes_written, bytes_to_write)); + } + } +#endif + + buf += bytes_written; + size -= bytes_written; + offset += bytes_written; + } + return 0; +} + +void +AsyncFile::writevReq( Request * request) +{ + // WriteFileGather on WIN32? + writeReq(request); +} + + +void +AsyncFile::closeReq(Request * request) +{ + syncReq(request); +#ifdef NDB_WIN32 + if(!CloseHandle(hFile)) { + request->error = GetLastError(); + } + hFile = INVALID_HANDLE_VALUE; +#else + if (-1 == ::close(theFd)) { + request->error = errno; + } + theFd = -1; +#endif +} + +bool AsyncFile::isOpen(){ +#ifdef NDB_WIN32 + return (hFile != INVALID_HANDLE_VALUE); +#else + return (theFd != -1); +#endif +} + + +void +AsyncFile::syncReq(Request * request) +{ + if(m_openedWithSync){ + return; + } +#ifdef NDB_WIN32 + if(!FlushFileBuffers(hFile)) { + request->error = GetLastError(); + return; + } +#else + if (-1 == ::fsync(theFd)){ + request->error = errno; + return; + } +#endif + m_syncCount = 0; +} + +void +AsyncFile::appendReq(Request * request){ + + const char * buf = request->par.append.buf; + Uint32 size = request->par.append.size; + + m_syncCount += size; + +#ifdef NDB_WIN32 + DWORD dwWritten = 0; + while(size > 0){ + if(!WriteFile(hFile, buf, size, &dwWritten, 0)){ + request->error = GetLastError(); + return ; + } + + buf += dwWritten; + size -= dwWritten; + } +#else + while(size > 0){ + const int n = write(theFd, buf, size); + if(n == -1 && errno == EINTR){ + continue; + } + if(n == -1){ + request->error = errno; + return; + } + if(n == 0){ + abort(); + } + size -= n; + buf += n; + } +#endif + + if(m_syncFrequency != 0 && m_syncCount > m_syncFrequency){ + syncReq(request); + request->error = 0; + } +} + +void +AsyncFile::removeReq(Request * request) +{ +#ifdef NDB_WIN32 + if(!DeleteFile(theFileName.c_str())) { + request->error = GetLastError(); + } +#else + if (-1 == ::remove(theFileName.c_str())) { + request->error = errno; + + } +#endif +} + +void +AsyncFile::rmrfReq(Request * request, char * path, bool removePath){ + Uint32 path_len = strlen(path); + Uint32 path_max_copy = PATH_MAX - path_len; + char* path_add = &path[path_len]; +#ifndef NDB_WIN32 + if(!request->par.rmrf.directory){ + // Remove file + if(unlink((const char *)path) != 0 && errno != ENOENT) + request->error = errno; + return; + } + // Remove directory + DIR* dirp = opendir((const char *)path); + if(dirp == 0){ + if(errno != ENOENT) + request->error = errno; + return; + } + struct dirent * dp; + while ((dp = readdir(dirp)) != NULL){ + if ((strcmp(".", dp->d_name) != 0) && (strcmp("..", dp->d_name) != 0)) { + snprintf(path_add, (size_t)path_max_copy, "%s%s", + DIR_SEPARATOR, dp->d_name); + if(remove((const char*)path) == 0){ + path[path_len] = 0; + continue; + } + + rmrfReq(request, path, true); + path[path_len] = 0; + if(request->error != 0){ + closedir(dirp); + return; + } + } + } + closedir(dirp); + if(removePath && rmdir((const char *)path) != 0){ + request->error = errno; + } + return; +#else + + if(!request->par.rmrf.directory){ + // Remove file + if(!DeleteFile(path)){ + DWORD dwError = GetLastError(); + if(dwError!=ERROR_FILE_NOT_FOUND) + request->error = dwError; + } + return; + } + + strcat(path, "\\*"); + WIN32_FIND_DATA ffd; + HANDLE hFindFile = FindFirstFile(path, &ffd); + path[path_len] = 0; + if(INVALID_HANDLE_VALUE==hFindFile){ + DWORD dwError = GetLastError(); + if(dwError!=ERROR_PATH_NOT_FOUND) + request->error = dwError; + return; + } + + do { + if(0!=strcmp(".", ffd.cFileName) && 0!=strcmp("..", ffd.cFileName)){ + strcat(path, "\\"); + strcat(path, ffd.cFileName); + if(DeleteFile(path)) { + path[path_len] = 0; + continue; + }//if + + rmrfReq(request, path, true); + path[path_len] = 0; + if(request->error != 0){ + FindClose(hFindFile); + return; + } + } + } while(FindNextFile(hFindFile, &ffd)); + + FindClose(hFindFile); + + if(removePath && !RemoveDirectory(path)) + request->error = GetLastError(); + +#endif +} + +void AsyncFile::endReq() +{ + // Thread is ended with return + if (theWriteBuffer) NdbMem_Free(theWriteBuffer); + NdbThread_Exit(0); +} + + +void AsyncFile::createDirectories() +{ + for (int i = 0; i < theFileName.levels(); i++) { +#ifdef NDB_WIN32 + CreateDirectory(theFileName.directory(i), 0); +#else + //printf("AsyncFile::createDirectories : \"%s\"\n", theFileName.directory(i)); + mkdir(theFileName.directory(i), S_IRUSR | S_IWUSR | S_IXUSR | S_IXGRP | S_IRGRP); +#endif + } +} + +#ifdef DEBUG_ASYNCFILE +void printErrorAndFlags(Uint32 used_flags) { + char buf[255]; + sprintf(buf, "PEAF: errno=%d \"", errno); + + switch(errno) { + case EACCES: + strcat(buf, "EACCES"); + break; + case EDQUOT: + strcat(buf, "EDQUOT"); + break; + case EEXIST : + strcat(buf, "EEXIST"); + break; + case EINTR : + strcat(buf, "EINTR"); + break; + case EFAULT : + strcat(buf, "EFAULT"); + break; + case EIO : + strcat(buf, "EIO"); + break; + case EISDIR : + strcat(buf, "EISDIR"); + break; + case ELOOP : + strcat(buf, "ELOOP"); + break; + case EMFILE : + strcat(buf, "EMFILE"); + break; + case ENFILE : + strcat(buf, "ENFILE"); + break; + case ENOENT : + strcat(buf, "ENOENT "); + break; + case ENOSPC : + strcat(buf, "ENOSPC"); + break; + case ENOTDIR : + strcat(buf, "ENOTDIR"); + break; + case ENXIO : + strcat(buf, "ENXIO"); + break; + case EOPNOTSUPP: + strcat(buf, "EOPNOTSUPP"); + break; +#if !defined NDB_OSE && !defined NDB_SOFTOSE + case EMULTIHOP : + strcat(buf, "EMULTIHOP"); + break; + case ENOLINK : + strcat(buf, "ENOLINK"); + break; + case ENOSR : + strcat(buf, "ENOSR"); + break; + case EOVERFLOW : + strcat(buf, "EOVERFLOW"); + break; +#endif + case EROFS : + strcat(buf, "EROFS"); + break; + case EAGAIN : + strcat(buf, "EAGAIN"); + break; + case EINVAL : + strcat(buf, "EINVAL"); + break; + case ENOMEM : + strcat(buf, "ENOMEM"); + break; + case ETXTBSY : + strcat(buf, "ETXTBSY"); + break; + case ENAMETOOLONG: + strcat(buf, "ENAMETOOLONG"); + break; + case EBADF: + strcat(buf, "EBADF"); + break; + case ESPIPE: + strcat(buf, "ESPIPE"); + break; + case ESTALE: + strcat(buf, "ESTALE"); + break; + default: + strcat(buf, "EOTHER"); + break; + } + strcat(buf, "\" "); +#if defined NDB_OSE + strcat(buf, strerror(errno) << " "); +#endif + strcat(buf, " flags: "); + switch(used_flags & 3){ + case O_RDONLY: + strcat(buf, "O_RDONLY, "); + break; + case O_WRONLY: + strcat(buf, "O_WRONLY, "); + break; + case O_RDWR: + strcat(buf, "O_RDWR, "); + break; + default: + strcat(buf, "Unknown!!, "); + } + + if((used_flags & O_APPEND)==O_APPEND) + strcat(buf, "O_APPEND, "); + if((used_flags & O_CREAT)==O_CREAT) + strcat(buf, "O_CREAT, "); + if((used_flags & O_EXCL)==O_EXCL) + strcat(buf, "O_EXCL, "); + if((used_flags & O_NOCTTY) == O_NOCTTY) + strcat(buf, "O_NOCTTY, "); + if((used_flags & O_NONBLOCK)==O_NONBLOCK) + strcat(buf, "O_NONBLOCK, "); + if((used_flags & O_TRUNC)==O_TRUNC) + strcat(buf, "O_TRUNC, "); +#if !defined NDB_OSE && !defined NDB_SOFTOSE + if((used_flags & O_DSYNC)==O_DSYNC) + strcat(buf, "O_DSYNC, "); + if((used_flags & O_NDELAY)==O_NDELAY) + strcat(buf, "O_NDELAY, "); + if((used_flags & O_RSYNC)==O_RSYNC) + strcat(buf, "O_RSYNC, "); + if((used_flags & O_SYNC)==O_SYNC) + strcat(buf, "O_SYNC, "); + DEBUG(ndbout_c(buf)); +#endif + +} +#endif diff --git a/ndb/src/kernel/blocks/ndbfs/AsyncFile.hpp b/ndb/src/kernel/blocks/ndbfs/AsyncFile.hpp new file mode 100644 index 00000000000..caa03e52d0c --- /dev/null +++ b/ndb/src/kernel/blocks/ndbfs/AsyncFile.hpp @@ -0,0 +1,234 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef AsyncFile_H +#define AsyncFile_H + +//=========================================================================== +// +// .DESCRIPTION +// Asynchronous file, All actions are executed concurrently with other +// activity of the process. +// Because all action are performed in a seperated thread the result of +// of a action is send back tru a memory channel. +// For the asyncronise notivication of a finished request all the calls +// have a request as paramater, the user can use the userData pointer +// to add information it needs when the request is send back. +// +// +// .TYPICAL USE: +// Writing or reading data to/from disk concurrently to other activities. +// +//=========================================================================== +//============================================================================= +// +// .PUBLIC +// +//============================================================================= +/////////////////////////////////////////////////////////////////////////////// +// +// AsyncFile( ); +// Description: +// Initialisation of the class. +// Parameters: +// - +/////////////////////////////////////////////////////////////////////////////// +// +// ~AsyncFile( ); +// Description: +// Tell the thread to stop and wait for it to return +// Parameters: +// - +/////////////////////////////////////////////////////////////////////////////// +// +// doStart( ); +// Description: +// Spawns the new thread. +// Parameters: +// Base path of filesystem +// +/////////////////////////////////////////////////////////////////////////////// +// +// void execute(Request *request); +// Description: +// performens the requered action. +// Parameters: +// request: request to be called when open is finished. +// action= open|close|read|write|sync +// if action is open then: +// par.open.flags= UNIX open flags, see man open +// par.open.name= name of the file to open +// if action is read or write then: +// par.readWrite.buf= user provided buffer to read/write +// the data from/to +// par.readWrite.size= how many bytes must be read/written +// par.readWrite.offset= absolute offset in file in bytes +// return: +// return values are stored in the request error field: +// error= return state of the action, UNIX error see man open/errno +// userData= is untouched can be used be user. +// +/////////////////////////////////////////////////////////////////////////////// +// +// void reportTo( MemoryChannel *reportTo ); +// Description: +// set the channel where the file must report the result of the +// actions back to. +// Parameters: +// reportTo: the memory channel to use use MemoryChannelMultipleWriter +// if more +// than one file uses this channel to report back. +// +/////////////////////////////////////////////////////////////////////////////// + +#include +#include "MemoryChannel.hpp" +#include "Filename.hpp" + +const int ERR_ReadUnderflow = 1000; + +const int WRITECHUNK = 262144; + +class AsyncFile; + +class Request +{ +public: + enum Action { + open, + close, + closeRemove, + read, // Allways leave readv directly after + // read because SimblockAsyncFileSystem depends on it + readv, + write,// Allways leave writev directly after + // write because SimblockAsyncFileSystem depends on it + writev, + writeSync,// Allways leave writevSync directly after + // writeSync because SimblockAsyncFileSystem depends on it + writevSync, + sync, + end, + append, + rmrf + }; + Action action; + union { + struct { + Uint32 flags; + } open; + struct { + int numberOfPages; + struct{ + char *buf; + size_t size; + off_t offset; + } pages[16]; + } readWrite; + struct { + const char * buf; + size_t size; + } append; + struct { + bool directory; + bool own_directory; + } rmrf; + } par; + int error; + + void set(BlockReference userReference, + Uint32 userPointer, + Uint16 filePointer); + BlockReference theUserReference; + Uint32 theUserPointer; + Uint16 theFilePointer; + // Information for open, needed if the first open action fails. + AsyncFile* file; + Uint32 theTrace; +}; + + +inline +void +Request::set(BlockReference userReference, + Uint32 userPointer, Uint16 filePointer) +{ + theUserReference= userReference; + theUserPointer= userPointer; + theFilePointer= filePointer; +} + +class AsyncFile +{ +public: + AsyncFile(); + ~AsyncFile(); + + void reportTo( MemoryChannel *reportTo ); + + void execute( Request* request ); + + void doStart(const char * fspath); + // its a thread so its always running + void run(); + + bool isOpen(); + + Filename theFileName; +private: + + void openReq(Request *request); + void readReq(Request *request); + void readvReq(Request *request); + void writeReq(Request *request); + void writevReq(Request *request); + + void closeReq(Request *request); + void syncReq(Request *request); + void removeReq(Request *request); + void appendReq(Request *request); + void rmrfReq(Request *request, char * path, bool removePath); + void endReq(); + + int readBuffer(char * buf, size_t size, off_t offset); + int writeBuffer(const char * buf, size_t size, off_t offset, + size_t chunk_size = WRITECHUNK); + + int extendfile(Request* request); + void createDirectories(); + +#ifdef NDB_WIN32 + HANDLE hFile; +#else + int theFd; +#endif + + MemoryChannel *theReportTo; + MemoryChannel* theMemoryChannelPtr; + + struct NdbThread* theThreadPtr; + NdbMutex* theStartMutexPtr; + NdbCondition* theStartConditionPtr; + bool theStartFlag; + int theWriteBufferSize; + char* theWriteBuffer; + + bool m_openedWithSync; + Uint32 m_syncCount; + Uint32 m_syncFrequency; +}; + +#endif diff --git a/ndb/src/kernel/blocks/ndbfs/AsyncFileTest/AsyncFileTest.cpp b/ndb/src/kernel/blocks/ndbfs/AsyncFileTest/AsyncFileTest.cpp new file mode 100644 index 00000000000..b9954ba130f --- /dev/null +++ b/ndb/src/kernel/blocks/ndbfs/AsyncFileTest/AsyncFileTest.cpp @@ -0,0 +1,697 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +//#define TESTDEBUG 1 + +#include +#include + +#include +#include +#include +#include "AsyncFile.hpp" +#include "NdbOut.hpp" +#include "NdbTick.h" +#include "NdbThread.h" +#include "NdbMain.h" + +// Test and benchmark functionality of AsyncFile +// -n Number of files +// -r Number of simultaneous requests +// -s Filesize, number of pages +// -l Number of iterations +// -remove, remove files after close +// -reverse, write files in reverse order, start with the last page + +#define MAXFILES 255 +#define DEFAULT_NUM_FILES 1 +#define MAXREQUESTS 256 +#define DEFAULT_NUM_REQUESTS 1 +#define MAXFILESIZE 4096 +#define DEFAULT_FILESIZE 2048 +#define FVERSION 0x01000000 +#define PAGESIZE 8192 + +#define TIMER_START { Uint64 starttick = NdbTick_CurrentMillisecond() +#define TIMER_PRINT(str, ops) Uint64 stoptick = NdbTick_CurrentMillisecond();\ + Uint64 totaltime = (stoptick-starttick); \ + ndbout << ops << " " << str << \ + " total time " << (int)totaltime << "ms" << endl;\ + char buf[255];\ + sprintf(buf, "%d %s/sec\n",(int)((ops*1000)/totaltime), str);\ + ndbout <* files; +AsyncFile* openFiles[MAXFILES]; +Pool* theRequestPool; +MemoryChannelMultipleWriter* theReportChannel; + +char WritePages[MAXFILES][PAGESIZE]; +char ReadPages[MAXFILES][PAGESIZE]; + +int readArguments(int argc, const char** argv); +int openFile(int fileNum); +int openFileWait(); +int closeFile(int fileNum); +int closeFileWait(); +int writeFile( int fileNum, int pagenum); +int writeFileWait(); +int writeSyncFile( int fileNum, int pagenum); +int writeSyncFileWait(); +int readFile( int fileNum, int pagenum); +int readFileWait(); + + +NDB_COMMAND(aftest, "aftest", "aftest [-n ] [-r ] [-s ] [-l ] [-remove, remove files after close] [-reverse, write files in reverse order, start with the last page]", "Test the AsyncFile class of Ndb", 8192) +{ + int s, numReq, numOps; + + readArguments(argc, argv); + + files = new Pool(numberOfFiles, 2); + theRequestPool = new Pool; + theReportChannel = new MemoryChannelMultipleWriter; + + ndbout << "AsyncFileTest starting" << endl; + ndbout << " " << numberOfFiles << " files" << endl; + ndbout << " " << numberOfRequests << " requests" << endl; + ndbout << " " << fileSize << " * 8k files" << endl << endl; + ndbout << " " << numberOfIterations << " iterations" << endl << endl; + + NdbThread_SetConcurrencyLevel(numberOfFiles+2); + + // initialize data to write to files + for (int i = 0; i < MAXFILES; i++) { + for (int j = 0; j < PAGESIZE; j++){ + WritePages[i][j] = (64+i+j)%256; + } + // memset(&WritePages[i][0], i+64, PAGESIZE); + } + + // Set file directory and name + // /T27/F27/NDBFS/S27Pnn.data + FileNameArray[0] = 27; // T27 + FileNameArray[1] = 27; // F27 + FileNameArray[2] = 27; // S27 + FileNameArray[3] = FVERSION; // Version + + for (int l = 0; l < numberOfIterations; l++) + { + + ndbout << "Opening files" << endl; + // Open files + for (int f = 0; f < numberOfFiles; f++) + { + openFile(f); + + } + + // Wait for answer + openFileWait(); + + ndbout << "Files opened!" << endl<< endl; + + // Write to files + ndbout << "Started writing" << endl; + TIMER_START; + s = 0; + numReq = 0; + numOps = 0; + while ( s < fileSize) + { + for (int r = 0; r < numberOfRequests; r++) + { + for (int f = 0; f < numberOfFiles; f++) + { + writeFile(f, s); + numReq++; + numOps++; + } + + s++; + } + + while (numReq > 0) + { + writeFileWait(); + numReq--; + } + + } + + TIMER_PRINT("writes", numOps); + + + ndbout << "Started reading" << endl; + TIMER_START; + + // Read from files + s = 0; + numReq = 0; + numOps = 0; + while ( s < fileSize) + { + for (int r = 0; r < numberOfRequests; r++) + { + for (int f = 0; f < numberOfFiles; f++) + { + readFile(f, s); + numReq++; + numOps++; + } + + s++; + + } + + while (numReq > 0) + { + readFileWait(); + numReq--; + } + + } + TIMER_PRINT("reads", numOps); + + ndbout << "Started writing with sync" << endl; + TIMER_START; + + // Write to files + s = 0; + numReq = 0; + numOps = 0; + while ( s < fileSize) + { + for (int r = 0; r < numberOfRequests; r++) + { + for (int f = 0; f < numberOfFiles; f++) + { + writeSyncFile(f, s); + numReq++; + numOps++; + } + + s++; + } + + while (numReq > 0) + { + writeSyncFileWait(); + numReq--; + } + + } + + TIMER_PRINT("writeSync", numOps); + + // Close files + ndbout << "Closing files" << endl; + for (int f = 0; f < numberOfFiles; f++) + { + closeFile(f); + + } + + // Wait for answer + closeFileWait(); + + ndbout << "Files closed!" << endl<< endl; + } + + // Deallocate memory + delete files; + delete theReportChannel; + delete theRequestPool; + + return 0; + +} + + + +int forward( AsyncFile * file, Request* request ) +{ + file->execute(request); + ERROR_CHECK 0; + return 1; +} + +int openFile( int fileNum) +{ + AsyncFile* file = (AsyncFile *)files->get(); + + FileNameArray[3] = fileNum | FVERSION; + file->fileName().set( NDBFS_REF, &FileNameArray[0] ); + ndbout << "openFile: " << file->fileName().c_str() << endl; + + if( ERROR_STATE ) { + ERROR_RESET; + files->put( file ); + ndbout << "Failed to set filename" << endl; + return 1; + } + file->reportTo(theReportChannel); + + Request* request = theRequestPool->get(); + request->action= Request::open; + request->error= 0; + request->par.open.flags = 0x302; //O_RDWR | O_CREAT | O_TRUNC ; // 770 + request->set(NDBFS_REF, 0x23456789, fileNum ); + request->file = file; + + if (!forward(file,request)) { + // Something went wrong + ndbout << "Could not forward open request" << endl; + theRequestPool->put(request); + return 1; + } + return 0; +} + +int closeFile( int fileNum) +{ + + AsyncFile* file = openFiles[fileNum]; + + Request* request = theRequestPool->get(); + if (removeFiles == 1) + request->action = Request::closeRemove; + else + request->action= Request::close; + + request->error= 0; + request->set(NDBFS_REF, 0x23456789, fileNum ); + request->file = file; + + if (!forward(file,request)) { + // Something went wrong + ndbout << "Could not forward close request" << endl; + theRequestPool->put(request); + return 1; + } + return 0; +} + +int writeFile( int fileNum, int pagenum) +{ + AsyncFile* file = openFiles[fileNum]; +#ifdef TESTDEBUG + ndbout << "writeFile" << fileNum <<": "<fileName().c_str()<< endl; +#endif + Request *request = theRequestPool->get(); + request->action = Request::write; + request->error = 0; + request->set(NDBFS_REF, pagenum, fileNum); + request->file = openFiles[fileNum]; + + // Write only one page, choose the correct page for each file using fileNum + request->par.readWrite.pages[0].buf = &WritePages[fileNum][0]; + request->par.readWrite.pages[0].size = PAGESIZE; + if (writeFilesReverse == 1) + { + // write the last page in the files first + // This is a normal way for the Blocks in Ndb to write to a file + request->par.readWrite.pages[0].offset = (fileSize - pagenum - 1) * PAGESIZE; + } + else + { + request->par.readWrite.pages[0].offset = pagenum * PAGESIZE; + } + request->par.readWrite.numberOfPages = 1; + + if (!forward(file,request)) { + // Something went wrong + ndbout << "Could not forward write request" << endl; + theRequestPool->put(request); + return 1; + } + return 0; + +} + +int writeSyncFile( int fileNum, int pagenum) +{ + AsyncFile* file = openFiles[fileNum]; +#ifdef TESTDEBUG + ndbout << "writeFile" << fileNum <<": "<fileName().c_str() << endl; +#endif + Request *request = theRequestPool->get(); + request->action = Request::writeSync; + request->error = 0; + request->set(NDBFS_REF, pagenum, fileNum); + request->file = openFiles[fileNum]; + + // Write only one page, choose the correct page for each file using fileNum + request->par.readWrite.pages[0].buf = &WritePages[fileNum][0]; + request->par.readWrite.pages[0].size = PAGESIZE; + request->par.readWrite.pages[0].offset = pagenum * PAGESIZE; + request->par.readWrite.numberOfPages = 1; + + if (!forward(file,request)) { + // Something went wrong + ndbout << "Could not forward write request" << endl; + theRequestPool->put(request); + return 1; + } + return 0; + +} + +int readFile( int fileNum, int pagenum) +{ + AsyncFile* file = openFiles[fileNum]; +#ifdef TESTDEBUG + ndbout << "readFile" << fileNum <<": "<fileName().c_str() << endl; +#endif + Request *request = theRequestPool->get(); + request->action = Request::read; + request->error = 0; + request->set(NDBFS_REF, pagenum, fileNum); + request->file = openFiles[fileNum]; + + // Read only one page, choose the correct page for each file using fileNum + request->par.readWrite.pages[0].buf = &ReadPages[fileNum][0]; + request->par.readWrite.pages[0].size = PAGESIZE; + request->par.readWrite.pages[0].offset = pagenum * PAGESIZE; + request->par.readWrite.numberOfPages = 1; + + if (!forward(file,request)) { + // Something went wrong + ndbout << "Could not forward read request" << endl; + theRequestPool->put(request); + return 1; + } + return 0; + +} + +int openFileWait() +{ + int openedFiles = 0; + while (openedFiles < numberOfFiles) + { + Request* request = theReportChannel->readChannel(); + if (request) + { + if (request->action == Request::open) + { + if (request->error ==0) + { +#ifdef TESTDEBUG + ndbout << "Opened file " << request->file->fileName().c_str() << endl; +#endif + openFiles[request->theFilePointer] = request->file; + } + else + { + ndbout << "error while opening file" << endl; + exit(1); + } + theRequestPool->put(request); + openedFiles++; + } + else + { + ndbout << "Unexpected request received" << endl; + } + } + else + { + ndbout << "Nothing read from theReportChannel" << endl; + } + } + return 0; +} + +int closeFileWait() +{ + int closedFiles = 0; + while (closedFiles < numberOfFiles) + { + Request* request = theReportChannel->readChannel(); + if (request) + { + if (request->action == Request::close || request->action == Request::closeRemove) + { + if (request->error ==0) + { +#ifdef TESTDEBUG + ndbout << "Closed file " << request->file->fileName().c_str() << endl; +#endif + openFiles[request->theFilePointer] = NULL; + files->put(request->file); + } + else + { + ndbout << "error while closing file" << endl; + exit(1); + } + theRequestPool->put(request); + closedFiles++; + } + else + { + ndbout << "Unexpected request received" << endl; + } + } + else + { + ndbout << "Nothing read from theReportChannel" << endl; + } + } + return 0; +} + +int writeFileWait() +{ + Request* request = theReportChannel->readChannel(); + if (request) + { + if (request->action == Request::write) + { + if (request->error == 0) + { +#ifdef TESTDEBUG + ndbout << "writeFileWait"<theFilePointer<<", " << request->theUserPointer<<" "<< request->file->fileName().c_str() << endl; +#endif + + } + else + { + ndbout << "error while writing file, error=" << request->error << endl; + exit(1); + } + theRequestPool->put(request); + } + else + { + ndbout << "Unexpected request received" << endl; + } + } + else + { + ndbout << "Nothing read from theReportChannel" << endl; + } + return 0; +} + +int writeSyncFileWait() +{ + Request* request = theReportChannel->readChannel(); + if (request) + { + if (request->action == Request::writeSync) + { + if (request->error == 0) + { +#ifdef TESTDEBUG + ndbout << "writeFileWait"<theFilePointer<<", " << request->theUserPointer<<" "<< request->file->fileName().c_str() << endl; +#endif + + } + else + { + ndbout << "error while writing file" << endl; + exit(1); + } + theRequestPool->put(request); + } + else + { + ndbout << "Unexpected request received" << endl; + } + } + else + { + ndbout << "Nothing read from theReportChannel" << endl; + } + return 0; +} + +int readFileWait() +{ + Request* request = theReportChannel->readChannel(); + if (request) + { + if (request->action == Request::read) + { + if (request->error == 0) + { +#ifdef TESTDEBUG + ndbout << "readFileWait"<theFilePointer<<", " << request->theUserPointer<<" "<< request->file->fileName().c_str() << endl; +#endif + if (memcmp(&(ReadPages[request->theFilePointer][0]), &(WritePages[request->theFilePointer][0]), PAGESIZE)!=0) + { + ndbout <<"Verification error!" << endl; + for (int i = 0; i < PAGESIZE; i++ ){ + ndbout <<" Compare Page " << i << " : " << ReadPages[request->theFilePointer][i] <<", " <theFilePointer][i] << endl;; + if( ReadPages[request->theFilePointer][i] !=WritePages[request->theFilePointer][i]) + + exit(1); + } + } + + } + else + { + ndbout << "error while reading file" << endl; + exit(1); + } + theRequestPool->put(request); + } + else + { + ndbout << "Unexpected request received" << endl; + } + } + else + { + ndbout << "Nothing read from theReportChannel" << endl; + } + return 0; +} + +int readArguments(int argc, const char** argv) +{ + + int i = 1; + while (argc > 1) + { + if (strcmp(argv[i], "-n") == 0) + { + numberOfFiles = atoi(argv[i+1]); + if ((numberOfFiles < 1) || (numberOfFiles > MAXFILES)) + { + ndbout << "Wrong number of files, default = "< MAXREQUESTS)) + { + ndbout << "Wrong number of requests, default = "< MAXFILESIZE)) + { + ndbout << "Wrong number of 8k pages, default = "<= theSize ){ + theIndex= 0; + } + return *this; +} + + +inline int full( const CircularIndex& write, const CircularIndex& read ) +{ + int readTmp= read.theIndex; + + if( read.theIndex < write.theIndex ) + readTmp += read.theSize; + + return ( readTmp - write.theIndex) == 1; +} + +inline int empty( const CircularIndex& write, const CircularIndex& read ) +{ + return read.theIndex == write.theIndex; +} + + +inline CircularIndex::CircularIndex( int start,int size ): + theSize(size), + theIndex(start) +{ +} +#endif diff --git a/ndb/src/kernel/blocks/ndbfs/Filename.cpp b/ndb/src/kernel/blocks/ndbfs/Filename.cpp new file mode 100644 index 00000000000..98ff7c7e4e4 --- /dev/null +++ b/ndb/src/kernel/blocks/ndbfs/Filename.cpp @@ -0,0 +1,220 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include +#include +#include +#include + +#include "Filename.hpp" +#include "ErrorHandlingMacros.hpp" +#include "Error.hpp" +#include "RefConvert.hpp" +#include "DebuggerNames.hpp" + +#include + +static const char* fileExtension[] = { + ".Data", + ".FragLog", + ".LocLog", + ".FragList", + ".TableList", + ".SchemaLog", + ".sysfile", + ".log", + ".ctl" +}; + +static const Uint32 noOfExtensions = sizeof(fileExtension)/sizeof(char*); + +Filename::Filename() : + theLevelDepth(0) +{ +} + +void +Filename::init(const char * pFileSystemPath){ + if (pFileSystemPath == NULL) { + ERROR_SET(fatal, AFS_ERROR_NOPATH, ""," Filename::init()"); + return; + } + + strncpy(theBaseDirectory, pFileSystemPath, PATH_MAX); + + // the environment variable is set, + // check that it is pointing on a valid directory + // + char buf2[PATH_MAX]; memset(buf2, 0,sizeof(buf2)); +#ifdef NDB_WIN32 + char* szFilePart; + if(!GetFullPathName(theBaseDirectory, sizeof(buf2), buf2, &szFilePart) + || (::GetFileAttributes(theBaseDirectory)&FILE_ATTRIBUTE_READONLY)) +#else + if((::realpath(theBaseDirectory, buf2) == NULL)|| + (::access(theBaseDirectory, W_OK) != 0)) +#endif + { + ERROR_SET(fatal, AFS_ERROR_INVALIDPATH, pFileSystemPath, " Filename::init()"); + } + strncpy(theBaseDirectory, buf2, sizeof(theBaseDirectory)); + // path seems ok, add delimiter if missing + if (strcmp(&theBaseDirectory[strlen(theBaseDirectory) - 1], + DIR_SEPARATOR) != 0) + strcat(theBaseDirectory, DIR_SEPARATOR); + +} + + +Filename::~Filename(){ +} + +void +Filename::set(BlockReference blockReference, + const Uint32 filenumber[4], bool dir) +{ + char buf[PATH_MAX]; + theLevelDepth = 0; + strncpy(theName, theBaseDirectory, PATH_MAX); + + const Uint32 type = FsOpenReq::getSuffix(filenumber); + const Uint32 version = FsOpenReq::getVersion(filenumber); + switch(version){ + case 1 :{ + const Uint32 diskNo = FsOpenReq::v1_getDisk(filenumber); + const Uint32 table = FsOpenReq::v1_getTable(filenumber); + const Uint32 frag = FsOpenReq::v1_getFragment(filenumber); + const Uint32 S_val = FsOpenReq::v1_getS(filenumber); + const Uint32 P_val = FsOpenReq::v1_getP(filenumber); + + if (diskNo < 0xff){ + snprintf(buf, sizeof(buf), "D%d%s", diskNo, DIR_SEPARATOR); + strcat(theName, buf); + theLevelDepth++; + } + + { + const char* blockName = getBlockName( refToBlock(blockReference) ); + if (blockName == NULL){ + ERROR_SET(ecError, AFS_ERROR_PARAMETER,"","No Block Name"); + return; + } + snprintf(buf, sizeof(buf), "%s%s", blockName, DIR_SEPARATOR); + strcat(theName, buf); + theLevelDepth++; + } + + if (table < 0xffffffff){ + snprintf(buf, sizeof(buf), "T%d%s", table, DIR_SEPARATOR); + strcat(theName, buf); + theLevelDepth++; + } + + if (frag < 0xffffffff){ + snprintf(buf, sizeof(buf), "F%d%s", frag, DIR_SEPARATOR); + strcat(theName, buf); + theLevelDepth++; + } + + + if (S_val < 0xffffffff){ + snprintf(buf, sizeof(buf), "S%d", S_val); + strcat(theName, buf); + } + + if (P_val < 0xff){ + snprintf(buf, sizeof(buf), "P%d", P_val); + strcat(theName, buf); + } + + } + break; + case 2:{ + const Uint32 seq = FsOpenReq::v2_getSequence(filenumber); + const Uint32 nodeId = FsOpenReq::v2_getNodeId(filenumber); + const Uint32 count = FsOpenReq::v2_getCount(filenumber); + + snprintf(buf, sizeof(buf), "BACKUP%sBACKUP-%d%s", + DIR_SEPARATOR, seq, DIR_SEPARATOR); + strcat(theName, buf); + if(count == 0xffffffff) { + snprintf(buf, sizeof(buf), "BACKUP-%d.%d", + seq, nodeId); strcat(theName, buf); + } else { + snprintf(buf, sizeof(buf), "BACKUP-%d-%d.%d", + seq, count, nodeId); strcat(theName, buf); + } + theLevelDepth = 2; + break; + } + break; + case 3:{ + const Uint32 diskNo = FsOpenReq::v1_getDisk(filenumber); + + if(diskNo == 0xFF){ + ERROR_SET(ecError, AFS_ERROR_PARAMETER,"","Invalid disk specification"); + } + + snprintf(buf, sizeof(buf), "D%d%s", diskNo, DIR_SEPARATOR); + strcat(theName, buf); + theLevelDepth++; + } + break; + default: + ERROR_SET(ecError, AFS_ERROR_PARAMETER,"","Wrong version"); + } + if (type >= noOfExtensions){ + ERROR_SET(ecError, AFS_ERROR_PARAMETER,"","File Type doesn't exist"); + return; + } + strcat(theName, fileExtension[type]); + + if(dir == true){ + for(Uint32 l = strlen(theName) - 1; l >= 0; l--){ + if(theName[l] == DIR_SEPARATOR[0]){ + theName[l] = 0; + break; + } + } + } +} + +/** + * Find out directory name on level + * Ex: + * theName = "/tmp/fs/T0/NDBFS/D0/P0/S27.data" + * level = 1 + * would return "/tmp/fs/T0/NDBFS/ + */ +const char* Filename::directory(int level) +{ + const char* p; + + p = theName; + p += strlen(theBaseDirectory); + + for (int i = 0; i <= level; i++){ + p = strstr(p, DIR_SEPARATOR); + p++; + } + + strncpy(theDirectory, theName, p - theName - 1); + theDirectory[p-theName-1] = 0; + return theDirectory; +} + + diff --git a/ndb/src/kernel/blocks/ndbfs/Filename.hpp b/ndb/src/kernel/blocks/ndbfs/Filename.hpp new file mode 100644 index 00000000000..4c3569b5485 --- /dev/null +++ b/ndb/src/kernel/blocks/ndbfs/Filename.hpp @@ -0,0 +1,97 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef Filename_H +#define Filename_H + +//=========================================================================== +// +// .DESCRIPTION +// Takes a 128 bits value (done as a array of four longs) and +// makes a filename out of it acording the following schema +// Bits 0-31 T +// Bits 32-63 F +// Bits 64-95 S +// Bits 96-103 P +// Bits 104-111 D +// Bits 112-119 File Type +// Bits 120-127 Version number of Filename +// +// T, is used to find/create a directory. If T = 0xFFFF then the +// file is on top level. In that case the F is of no relevance. +// F, same as T. +// S, is used to find/create a filename. If S= 0xFFFF then it is ignored. +// P, same as S +// D, is used to find/create the root directory, this is the +// directory before the blockname. If D= 0xFF then it is ignored. +// File Type +// 0 => .Data +// 1 => .FragLog +// 2 => .LocLog +// 3 => .FragList +// 4 => .TableList +// 5 => .SchemaLog +// 6 => .sysfile +// 15=> ignored +// Version number of Filename, current version is 0x1, must be +// used for the this style of options. +// +// +//=========================================================================== + +#include +#include + +class Filename +{ +public: + // filenumber is 64 bits but is split in to 4 32bits words + Filename(); + ~Filename(); + void set(BlockReference blockReference, + const Uint32 filenumber[4], bool dir = false); + const char* baseDirectory() const; + const char* directory(int level); + int levels() const; + const char* c_str() const; + + void init(const char * fileSystemPath); + +private: + int theLevelDepth; + char theName[PATH_MAX]; + char theBaseDirectory[PATH_MAX]; + char theDirectory[PATH_MAX]; +}; + +// inline methods +inline const char* Filename::c_str() const{ + return theName; +} + +inline const char* Filename::baseDirectory() const{ + return theBaseDirectory; +} + +inline int Filename::levels() const{ + return theLevelDepth; +} + +#endif + + + + diff --git a/ndb/src/kernel/blocks/ndbfs/Makefile b/ndb/src/kernel/blocks/ndbfs/Makefile new file mode 100644 index 00000000000..58e1458bf16 --- /dev/null +++ b/ndb/src/kernel/blocks/ndbfs/Makefile @@ -0,0 +1,14 @@ +include .defs.mk + +TYPE := kernel + +ARCHIVE_TARGET := ndbfs + +SOURCES = \ + AsyncFile.cpp \ + Ndbfs.cpp VoidFs.cpp \ + Filename.cpp \ + CircularIndex.cpp + +include $(NDB_TOP)/Epilogue.mk + diff --git a/ndb/src/kernel/blocks/ndbfs/MemoryChannel.cpp b/ndb/src/kernel/blocks/ndbfs/MemoryChannel.cpp new file mode 100644 index 00000000000..a1aebdef7a1 --- /dev/null +++ b/ndb/src/kernel/blocks/ndbfs/MemoryChannel.cpp @@ -0,0 +1,18 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +//#include "MemoryChannel.hpp" + diff --git a/ndb/src/kernel/blocks/ndbfs/MemoryChannel.hpp b/ndb/src/kernel/blocks/ndbfs/MemoryChannel.hpp new file mode 100644 index 00000000000..6e0c2721ca0 --- /dev/null +++ b/ndb/src/kernel/blocks/ndbfs/MemoryChannel.hpp @@ -0,0 +1,168 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef MemoryChannel_H +#define MemoryChannel_H + +//=========================================================================== +// +// .DESCRIPTION +// Pointer based communication channel for communication between two +// thread. It does not copy any data in or out the channel so the +// item that is put in can not be used untill the other thread has +// given it back. There is no support for detecting the return of a +// item. The channel is half-duplex. +// For comminication between 1 writer and 1 reader use the MemoryChannel +// class, for comminication between multiple writer and 1 reader use the +// MemoryChannelMultipleWriter. There is no support for multiple readers. +// +// .TYPICAL USE: +// to communicate between threads. +// +// .EXAMPLE: +// See AsyncFile.C +//=========================================================================== +// +// +// MemoryChannel( int size= 256); +// Constuctor +// Parameters: +// size : amount of pointer it can hold +// +// void operator ++ (); +// increments the index with one, if size is reached it is set to zero +// +// virtual void write( T *t); +// Puts the item in the channel if the channel is full an error is reported. +// Parameters: +// t: pointer to item to put in the channel, after this the item +// is shared with the other thread. +// errors +// AFS_ERROR_CHANNALFULL, channel is full +// +// T* read(); +// Reads a itemn from the channel, if channel is empty it blocks untill +// an item can be read. +// return +// T : item from the channel +// +// T* tryRead(); +// Reads a item from the channel, if channel is empty it returns zero. +// return +// T : item from the channel or zero if channel is empty. +// + +#if defined NDB_OSE || defined NDB_SOFTOSE +#include "MemoryChannelOSE.hpp" +#else + +#include "ErrorHandlingMacros.hpp" +#include "Error.hpp" +#include "CircularIndex.hpp" +#include "NdbMutex.h" +#include "NdbCondition.h" +#include + +#include + +template +class MemoryChannel +{ +public: + MemoryChannel( int size= 256); + virtual ~MemoryChannel( ); + + virtual void writeChannel( T *t); + T* readChannel(); + T* tryReadChannel(); + +private: + int theSize; + T **theChannel; + CircularIndex theWriteIndex; + CircularIndex theReadIndex; + NdbMutex* theMutexPtr; + NdbCondition* theConditionPtr; + +}; + + +template MemoryChannel::MemoryChannel( int size): + theSize(size), + theChannel(new T*[size] ), + theWriteIndex(0, size), + theReadIndex(0, size) +{ + theMutexPtr = NdbMutex_Create(); + theConditionPtr = NdbCondition_Create(); +} + +template MemoryChannel::~MemoryChannel( ) +{ + NdbMutex_Destroy(theMutexPtr); + NdbCondition_Destroy(theConditionPtr); + delete [] theChannel; +} + +template void MemoryChannel::writeChannel( T *t) +{ + + NdbMutex_Lock(theMutexPtr); + REQUIRE(!full(theWriteIndex, theReadIndex), "Memory Channel Full"); + REQUIRE(theChannel != NULL, "Memory Channel Full"); + theChannel[theWriteIndex]= t; + ++theWriteIndex; + NdbMutex_Unlock(theMutexPtr); + NdbCondition_Signal(theConditionPtr); +} + + +template T* MemoryChannel::readChannel() +{ + T* tmp; + + NdbMutex_Lock(theMutexPtr); + while ( empty(theWriteIndex, theReadIndex) ) + { + NdbCondition_Wait(theConditionPtr, + theMutexPtr); + } + + tmp= theChannel[theReadIndex]; + ++theReadIndex; + NdbMutex_Unlock(theMutexPtr); + return tmp; +} + +template T* MemoryChannel::tryReadChannel() +{ + T* tmp= 0; + NdbMutex_Lock(theMutexPtr); + NdbCondition_WaitTimeout(theConditionPtr, + theMutexPtr, 0); + if ( !empty(theWriteIndex, theReadIndex) ) + { + tmp= theChannel[theReadIndex]; + ++theReadIndex; + } + NdbMutex_Unlock(theMutexPtr); + return tmp; +} + +#endif + +#endif // MemoryChannel_H + diff --git a/ndb/src/kernel/blocks/ndbfs/MemoryChannelOSE.hpp b/ndb/src/kernel/blocks/ndbfs/MemoryChannelOSE.hpp new file mode 100644 index 00000000000..9f70efcadf7 --- /dev/null +++ b/ndb/src/kernel/blocks/ndbfs/MemoryChannelOSE.hpp @@ -0,0 +1,205 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef MemoryChannelOSE_H +#define MemoryChannelOSE_H + +//=========================================================================== +// +// .DESCRIPTION +// Pointer based communication channel for communication between two +// thread. It sends the pointer to the other signal via an OSE signal +// +// .TYPICAL USE: +// to communicate between threads. +// +// .EXAMPLE: +// See AsyncFile.C +//=========================================================================== +// +// +// MemoryChannel( int size= 256); +// Constuctor +// Parameters: +// size : is ignored in OSE version +// +// void operator ++ (); +// increments the index with one, if size is reached it is set to zero +// +// virtual void write( T *t); +// Puts the item in the channel if the channel is full an error is reported. +// Parameters: +// t: pointer to item to put in the channel, after this the item +// is shared with the other thread. +// errors +// AFS_ERROR_CHANNALFULL, channel is full +// +// T* read(); +// Reads a itemn from the channel, if channel is empty it blocks untill +// an item can be read. +// return +// T : item from the channel +// +// T* tryRead(); +// Reads a item from the channel, if channel is empty it returns zero. +// return +// T : item from the channel or zero if channel is empty. +// + +#include +#include "ErrorHandlingMacros.hpp" +#include "Error.hpp" +#include "NdbMutex.h" +#include "NdbCondition.h" + +#include + + + + +template +class MemoryChannel +{ +public: + MemoryChannel( int size= 256); + virtual ~MemoryChannel( ); + + virtual void writeChannel( T *t); + T* readChannel(); + T* tryReadChannel(); + +private: + PROCESS theReceiverPid; +}; + +template class MemoryChannelMultipleWriter:public MemoryChannel +{ +public: + MemoryChannelMultipleWriter( int size= 256); + ~MemoryChannelMultipleWriter( ); + void writeChannel( T *t); + +private: +}; + + +#define MEMCHANNEL_SIGBASE 5643 + +#define MEMCHANNEL_SIGNAL (MEMCHANNEL_SIGBASE + 1) /* !-SIGNO(struct MemChannelSignal)-! */ + + +struct MemChannelSignal +{ + SIGSELECT sigNo; + void* ptr; +}; + +union SIGNAL +{ + SIGSELECT sigNo; + struct MemChannelSignal memChanSig; +}; + +template MemoryChannel::MemoryChannel( int size ) +{ + // Default receiver for this channel is the creating process + theReceiverPid = current_process(); +} + +template MemoryChannel::~MemoryChannel( ) +{ +} + +template void MemoryChannel::writeChannel( T *t) +{ + union SIGNAL* sig; + + sig = alloc(sizeof(struct MemChannelSignal), MEMCHANNEL_SIGNAL); + ((struct MemChannelSignal*)sig)->ptr = t; + send(&sig, theReceiverPid); +} + + +template T* MemoryChannel::readChannel() +{ + T* tmp; + + static const SIGSELECT sel_mem[] = {1, MEMCHANNEL_SIGNAL}; + union SIGNAL* sig; + + tmp = NULL; /* Default value */ + + sig = receive((SIGSELECT*)sel_mem); + if (sig != NIL){ + if (sig->sigNo == MEMCHANNEL_SIGNAL){ + tmp = (T*)(((struct MemChannelSignal*)sig)->ptr); + }else{ + assert(1==0); + } + free_buf(&sig); + } + + return tmp; +} + +template T* MemoryChannel::tryReadChannel() +{ + T* tmp; + + static const SIGSELECT sel_mem[] = {1, MEMCHANNEL_SIGNAL}; + union SIGNAL* sig; + + tmp = NULL; /* Default value */ + + sig = receive_w_tmo(0, (SIGSELECT*)sel_mem); + if (sig != NIL){ + if (sig->sigNo == MEMCHANNEL_SIGNAL){ + tmp = (T*)(((struct MemChannelSignal*)sig)->ptr); + }else{ + assert(1==0); + } + free_buf(&sig); + } + + return tmp; +} + + +#endif // MemoryChannel_H + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/ndb/src/kernel/blocks/ndbfs/MemoryChannelTest/Makefile b/ndb/src/kernel/blocks/ndbfs/MemoryChannelTest/Makefile new file mode 100644 index 00000000000..68f71bfc4cd --- /dev/null +++ b/ndb/src/kernel/blocks/ndbfs/MemoryChannelTest/Makefile @@ -0,0 +1,13 @@ +include .defs.mk + +TYPE := kernel + +BIN_TARGET := mctest +BIN_TARGET_ARCHIVES := portlib + +SOURCES = MemoryChannelTest.cpp + +CFLAGS_MemoryChannelTest.cpp = -I../ + +include $(NDB_TOP)/Epilogue.mk + diff --git a/ndb/src/kernel/blocks/ndbfs/MemoryChannelTest/MemoryChannelTest.cpp b/ndb/src/kernel/blocks/ndbfs/MemoryChannelTest/MemoryChannelTest.cpp new file mode 100644 index 00000000000..aeab9f7828d --- /dev/null +++ b/ndb/src/kernel/blocks/ndbfs/MemoryChannelTest/MemoryChannelTest.cpp @@ -0,0 +1,197 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "MemoryChannel.hpp" +#include "NdbThread.h" +#include "NdbSleep.h" +#include "NdbOut.hpp" +#include "NdbMain.h" + + + +MemoryChannel* theMemoryChannel; + + +extern "C" void* runProducer(void*arg) +{ + // The producer will items into the MemoryChannel + int count = *(int*)arg; + int* p; + int i = 0; + while (i <= count) + { + p = new int(i); + ndbout << "P: " << *p << endl; + theMemoryChannel->writeChannel(p); + if (i%5==0) + NdbSleep_MilliSleep(i); + i++; + } + NdbThread_Exit(0); + return NULL; +} + +extern "C" void* runConsumer(void* arg) +{ + // The producer will read items from MemoryChannel and print on screen + int count = *(int*)arg; + int* p; + int i = 0; + while (i < count) + { + p = theMemoryChannel->readChannel(); + ndbout << "C: " << *p << endl; + i = *p; + delete p; + + } + NdbThread_Exit(0); + return NULL; +} + + + +class ArgStruct +{ +public: + ArgStruct(int _items, int _no){ + items=_items; + no=_no; + }; + int items; + int no; +}; + +MemoryChannelMultipleWriter* theMemoryChannel2; + +extern "C" void* runProducer2(void*arg) +{ + // The producer will items into the MemoryChannel + ArgStruct* pArg = (ArgStruct*)arg; + int count = pArg->items; + ArgStruct* p; + int i = 0; + while (i < count) + { + p = new ArgStruct(i, pArg->no); + ndbout << "P"<no<<": " << i << endl; + theMemoryChannel2->writeChannel(p); + NdbSleep_MilliSleep(i); + i++; + } + NdbThread_Exit(0); + return NULL; +} + +extern "C" void* runConsumer2(void* arg) +{ + // The producer will read items from MemoryChannel and print on screen + ArgStruct* pArg = (ArgStruct*)arg; + int count = pArg->items * pArg->no; + ArgStruct* p; + int i = 0; + while (i < count) + { + p = theMemoryChannel2->readChannel(); + ndbout << "C: "<< p->no << ", " << p->items << endl; + i++; + delete p; + } + ndbout << "Consumer2: " << count << " received" << endl; + NdbThread_Exit(0); + return NULL; +} + + + + +//#if defined MEMORYCHANNELTEST + +//int main(int argc, char **argv) +NDB_COMMAND(mctest, "mctest", "mctest", "Test the memory channel used in Ndb", 32768) +{ + + ndbout << "==== testing MemoryChannel ====" << endl; + + theMemoryChannel = new MemoryChannel; + theMemoryChannel2 = new MemoryChannelMultipleWriter; + + NdbThread* consumerThread; + NdbThread* producerThread; + + NdbThread_SetConcurrencyLevel(2); + + int numItems = 100; + producerThread = NdbThread_Create(runProducer, + (void**)&numItems, + 4096, + (char*)"producer"); + + consumerThread = NdbThread_Create(runConsumer, + (void**)&numItems, + 4096, + (char*)"consumer"); + + + void *status; + NdbThread_WaitFor(consumerThread, &status); + NdbThread_WaitFor(producerThread, &status); + + ndbout << "==== testing MemoryChannelMultipleWriter ====" << endl; +#define NUM_THREADS2 5 + NdbThread_SetConcurrencyLevel(NUM_THREADS2+2); + NdbThread* producerThreads[NUM_THREADS2]; + + ArgStruct *pArg; + for (int j = 0; j < NUM_THREADS2; j++) + { + char buf[25]; + sprintf((char*)&buf, "producer%d", j); + pArg = new ArgStruct(numItems, j); + producerThreads[j] = NdbThread_Create(runProducer2, + (void**)pArg, + 4096, + (char*)&buf); + } + + pArg = new ArgStruct(numItems, NUM_THREADS2); + consumerThread = NdbThread_Create(runConsumer2, + (void**)pArg, + 4096, + (char*)"consumer"); + + + NdbThread_WaitFor(consumerThread, &status); + for (int j = 0; j < NUM_THREADS2; j++) + { + NdbThread_WaitFor(producerThreads[j], &status); + } + + + return 0; + +} + +void ErrorReporter::handleError(ErrorCategory type, int messageID, + const char* problemData, const char* objRef, + NdbShutdownType nst) +{ + + ndbout << "ErrorReporter::handleError activated" << endl; + exit(1); +} + +//#endif diff --git a/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp b/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp new file mode 100644 index 00000000000..8992a2104e9 --- /dev/null +++ b/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp @@ -0,0 +1,1008 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include + +#include "Ndbfs.hpp" +#include "AsyncFile.hpp" +#include "Filename.hpp" +#include "Error.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#define DEBUG(x) { ndbout << "FS::" << x << endl; } + +inline +int pageSize( const NewVARIABLE* baseAddrRef ) +{ + int log_psize; + int log_qsize = baseAddrRef->bits.q; + int log_vsize = baseAddrRef->bits.v; + if (log_vsize < 3) + log_vsize = 3; + log_psize = log_qsize + log_vsize - 3; + return (1 << log_psize); +} + + +Ndbfs::Ndbfs(const Configuration & conf) : + SimulatedBlock(NDBFS, conf), + scanningInProgress(false), + theLastId(0), + m_maxOpenedFiles(0) +{ + theFileSystemPath = conf.fileSystemPath(); + theRequestPool = new Pool; + + const Properties * p = conf.getOwnProperties(); + ndbrequire(p != 0); + + ndbrequire(p->get("MaxNoOfOpenFiles", &m_maxFiles)); + + // Create idle AsyncFiles + Uint32 noIdleFiles = 16; + for (Uint32 i = 0; i < noIdleFiles; i++){ + theIdleFiles.push_back(createAsyncFile()); + } + + BLOCK_CONSTRUCTOR(Ndbfs); + + // Set received signals + addRecSignal(GSN_DUMP_STATE_ORD, &Ndbfs::execDUMP_STATE_ORD); + addRecSignal(GSN_STTOR, &Ndbfs::execSTTOR); + addRecSignal(GSN_FSOPENREQ, &Ndbfs::execFSOPENREQ); + addRecSignal(GSN_FSCLOSEREQ, &Ndbfs::execFSCLOSEREQ); + addRecSignal(GSN_FSWRITEREQ, &Ndbfs::execFSWRITEREQ); + addRecSignal(GSN_FSREADREQ, &Ndbfs::execFSREADREQ); + addRecSignal(GSN_FSSYNCREQ, &Ndbfs::execFSSYNCREQ); + addRecSignal(GSN_CONTINUEB, &Ndbfs::execCONTINUEB); + addRecSignal(GSN_FSAPPENDREQ, &Ndbfs::execFSAPPENDREQ); + addRecSignal(GSN_FSREMOVEREQ, &Ndbfs::execFSREMOVEREQ); + // Set send signals +} + +Ndbfs::~Ndbfs() +{ + // Delete all files + // AsyncFile destuctor will take care of deleting + // the thread it has created + for (unsigned i = 0; i < theFiles.size(); i++){ + AsyncFile* file = theFiles[i]; + delete file; + theFiles[i] = NULL; + }//for + theFiles.clear(); + + delete theRequestPool; +} + +/* Received a restart signal. + * Answer it like any other block + * PR0 : StartCase + * DR0 : StartPhase + * DR1 : ? + * DR2 : ? + * DR3 : ? + * DR4 : ? + * DR5 : SignalKey + */ +void +Ndbfs::execSTTOR(Signal* signal) +{ + jamEntry(); + + if(signal->theData[1] == 0){ // StartPhase 0 + jam(); + cownref = NDBFS_REF; + // close all open files + ndbrequire(theOpenFiles.size() == 0); + + scanningInProgress = false; + + signal->theData[0] = NdbfsContinueB::ZSCAN_MEMORYCHANNEL_10MS_DELAY; + sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 10, 1); + + signal->theData[3] = 255; + sendSignal(NDBCNTR_REF, GSN_STTORRY, signal,4, JBB); + return; + } + ndbrequire(0); +} + +int +Ndbfs::forward( AsyncFile * file, Request* request) +{ + jam(); + file->execute(request); + return 1; +} + +void +Ndbfs::execFSOPENREQ(Signal* signal) +{ + jamEntry(); + const FsOpenReq * const fsOpenReq = (FsOpenReq *)&signal->theData[0]; + const BlockReference userRef = fsOpenReq->userReference; + AsyncFile* file = getIdleFile(); + ndbrequire(file != NULL); + ndbrequire(signal->getLength() == FsOpenReq::SignalLength) + file->theFileName.set( userRef, fsOpenReq->fileNumber); + file->reportTo(&theFromThreads); + + Request* request = theRequestPool->get(); + request->action = Request::open; + request->error = 0; + request->par.open.flags = fsOpenReq->fileFlags; + request->set(userRef, fsOpenReq->userPointer, newId() ); + request->file = file; + request->theTrace = signal->getTrace(); + + ndbrequire(forward(file, request)); +} + +void +Ndbfs::execFSREMOVEREQ(Signal* signal) +{ + jamEntry(); + const FsRemoveReq * const req = (FsRemoveReq *)signal->getDataPtr(); + const BlockReference userRef = req->userReference; + AsyncFile* file = getIdleFile(); + ndbrequire(file != NULL); + + file->theFileName.set( userRef, req->fileNumber, req->directory); + file->reportTo(&theFromThreads); + + Request* request = theRequestPool->get(); + request->action = Request::rmrf; + request->par.rmrf.directory = req->directory; + request->par.rmrf.own_directory = req->ownDirectory; + request->error = 0; + request->set(userRef, req->userPointer, newId() ); + request->file = file; + request->theTrace = signal->getTrace(); + + ndbrequire(forward(file, request)); +} + +/* + * PR0: File Pointer DR0: User reference DR1: User Pointer DR2: Flag bit 0= 1 + * remove file + */ +void +Ndbfs::execFSCLOSEREQ(Signal * signal) +{ + jamEntry(); + const FsCloseReq * const fsCloseReq = (FsCloseReq *)&signal->theData[0]; + const BlockReference userRef = fsCloseReq->userReference; + const Uint16 filePointer = (Uint16)fsCloseReq->filePointer; + const UintR userPointer = fsCloseReq->userPointer; + + AsyncFile* openFile = theOpenFiles.find(filePointer); + if (openFile == NULL) { + // The file was not open, send error back to sender + jam(); + // Initialise FsRef signal + FsRef * const fsRef = (FsRef *)&signal->theData[0]; + fsRef->userPointer = userPointer; + fsRef->setErrorCode(fsRef->errorCode, FsRef::fsErrFileDoesNotExist); + fsRef->osErrorCode = ~0; // Indicate local error + sendSignal(userRef, GSN_FSCLOSEREF, signal, 3, JBB); + return; + } + + Request *request = theRequestPool->get(); + if( fsCloseReq->getRemoveFileFlag(fsCloseReq->fileFlag) == true ) { + jam(); + request->action = Request::closeRemove; + } else { + jam(); + request->action = Request::close; + } + request->set(userRef, fsCloseReq->userPointer, filePointer); + request->file = openFile; + request->error = 0; + request->theTrace = signal->getTrace(); + + ndbrequire(forward(openFile, request)); +} + +void +Ndbfs::readWriteRequest(int action, Signal * signal) +{ + const FsReadWriteReq * const fsRWReq = (FsReadWriteReq *)&signal->theData[0]; + Uint16 filePointer = (Uint16)fsRWReq->filePointer; + const UintR userPointer = fsRWReq->userPointer; + const BlockReference userRef = fsRWReq->userReference; + const BlockNumber blockNumber = refToBlock(userRef); + + AsyncFile* openFile = theOpenFiles.find(filePointer); + + const NewVARIABLE *myBaseAddrRef = &getBat(blockNumber)[fsRWReq->varIndex]; + unsigned int tPageSize; + unsigned int tClusterSize; + unsigned int tNRR; + unsigned int tPageOffset; + char* tWA; + FsRef::NdbfsErrorCodeType errorCode; + + Request *request = theRequestPool->get(); + request->error = 0; + request->set(userRef, userPointer, filePointer); + request->file = openFile; + request->action = (Request::Action) action; + request->theTrace = signal->getTrace(); + + if (fsRWReq->numberOfPages == 0) { //Zero pages not allowed + jam(); + errorCode = FsRef::fsErrInvalidParameters; + goto error; + } + + if (fsRWReq->varIndex >= getBatSize(blockNumber)) { + jam();// Ensure that a valid variable is used + errorCode = FsRef::fsErrInvalidParameters; + goto error; + } + if (myBaseAddrRef == NULL) { + jam(); // Ensure that a valid variable is used + errorCode = FsRef::fsErrInvalidParameters; + goto error; + } + if (openFile == NULL) { + jam(); //file not open + errorCode = FsRef::fsErrFileDoesNotExist; + goto error; + } + tPageSize = pageSize(myBaseAddrRef); + tClusterSize = myBaseAddrRef->ClusterSize; + tNRR = myBaseAddrRef->nrr; + tWA = (char*)myBaseAddrRef->WA; + + switch (fsRWReq->getFormatFlag(fsRWReq->operationFlag)) { + + // List of memory and file pages pairs + case FsReadWriteReq::fsFormatListOfPairs: { + jam(); + for (unsigned int i = 0; i < fsRWReq->numberOfPages; i++) { + jam(); + const Uint32 varIndex = fsRWReq->data.listOfPair[i].varIndex; + const Uint32 fileOffset = fsRWReq->data.listOfPair[i].fileOffset; + if (varIndex >= tNRR) { + jam(); + errorCode = FsRef::fsErrInvalidParameters; + goto error; + }//if + request->par.readWrite.pages[i].buf = &tWA[varIndex * tClusterSize]; + request->par.readWrite.pages[i].size = tPageSize; + request->par.readWrite.pages[i].offset = fileOffset * tPageSize; + }//for + request->par.readWrite.numberOfPages = fsRWReq->numberOfPages; + break; + }//case + + // Range of memory page with one file page + case FsReadWriteReq::fsFormatArrayOfPages: { + if ((fsRWReq->numberOfPages + fsRWReq->data.arrayOfPages.varIndex) > tNRR) { + jam(); + errorCode = FsRef::fsErrInvalidParameters; + goto error; + }//if + const Uint32 varIndex = fsRWReq->data.arrayOfPages.varIndex; + const Uint32 fileOffset = fsRWReq->data.arrayOfPages.fileOffset; + + request->par.readWrite.pages[0].offset = fileOffset * tPageSize; + request->par.readWrite.pages[0].size = tPageSize * fsRWReq->numberOfPages; + request->par.readWrite.numberOfPages = 1; + request->par.readWrite.pages[0].buf = &tWA[varIndex * tPageSize]; + break; + }//case + + // List of memory pages followed by one file page + case FsReadWriteReq::fsFormatListOfMemPages: { + + tPageOffset = fsRWReq->data.listOfMemPages.varIndex[fsRWReq->numberOfPages]; + tPageOffset *= tPageSize; + + for (unsigned int i = 0; i < fsRWReq->numberOfPages; i++) { + jam(); + Uint32 varIndex = fsRWReq->data.listOfMemPages.varIndex[i]; + + if (varIndex >= tNRR) { + jam(); + errorCode = FsRef::fsErrInvalidParameters; + goto error; + }//if + request->par.readWrite.pages[i].buf = &tWA[varIndex * tClusterSize]; + request->par.readWrite.pages[i].size = tPageSize; + request->par.readWrite.pages[i].offset = tPageOffset + (i*tPageSize); + }//for + request->par.readWrite.numberOfPages = fsRWReq->numberOfPages; + break; + // make it a writev or readv + }//case + + default: { + jam(); + errorCode = FsRef::fsErrInvalidParameters; + goto error; + }//default + + }//switch + + ndbrequire(forward(openFile, request)); + return; + +error: + theRequestPool->put(request); + FsRef * const fsRef = (FsRef *)&signal->theData[0]; + fsRef->userPointer = userPointer; + fsRef->setErrorCode(fsRef->errorCode, errorCode); + fsRef->osErrorCode = ~0; // Indicate local error + switch (action) { + case Request:: write: + case Request:: writeSync: { + jam(); + sendSignal(userRef, GSN_FSWRITEREF, signal, 3, JBB); + break; + }//case + case Request:: read: { + jam(); + sendSignal(userRef, GSN_FSREADREF, signal, 3, JBB); + }//case + }//switch + return; +} + +/* + PR0: File Pointer , theData[0] + DR0: User reference, theData[1] + DR1: User Pointer, etc. + DR2: Flag + DR3: Var number + DR4: amount of pages + DR5->: Memory Page id and File page id according to Flag +*/ +void +Ndbfs::execFSWRITEREQ(Signal* signal) +{ + jamEntry(); + const FsReadWriteReq * const fsWriteReq = (FsReadWriteReq *)&signal->theData[0]; + + if (fsWriteReq->getSyncFlag(fsWriteReq->operationFlag) == true){ + jam(); + readWriteRequest( Request::writeSync, signal ); + } else { + jam(); + readWriteRequest( Request::write, signal ); + } +} + +/* + PR0: File Pointer + DR0: User reference + DR1: User Pointer + DR2: Flag + DR3: Var number + DR4: amount of pages + DR5->: Memory Page id and File page id according to Flag +*/ +void +Ndbfs::execFSREADREQ(Signal* signal) +{ + jamEntry(); + readWriteRequest( Request::read, signal ); +} + +/* + * PR0: File Pointer DR0: User reference DR1: User Pointer + */ +void +Ndbfs::execFSSYNCREQ(Signal * signal) +{ + jamEntry(); + Uint16 filePointer = (Uint16)signal->theData[0]; + BlockReference userRef = signal->theData[1]; + const UintR userPointer = signal->theData[2]; + AsyncFile* openFile = theOpenFiles.find(filePointer); + + if (openFile == NULL) { + jam(); //file not open + FsRef * const fsRef = (FsRef *)&signal->theData[0]; + fsRef->userPointer = userPointer; + fsRef->setErrorCode(fsRef->errorCode, FsRef::fsErrFileDoesNotExist); + fsRef->osErrorCode = ~0; // Indicate local error + sendSignal(userRef, GSN_FSSYNCREF, signal, 3, JBB); + return; + } + + Request *request = theRequestPool->get(); + request->error = 0; + request->action = Request::sync; + request->set(userRef, userPointer, filePointer); + request->file = openFile; + request->theTrace = signal->getTrace(); + + ndbrequire(forward(openFile,request)); +} + +void +Ndbfs::execFSAPPENDREQ(Signal * signal) +{ + const FsAppendReq * const fsReq = (FsAppendReq *)&signal->theData[0]; + const Uint16 filePointer = (Uint16)fsReq->filePointer; + const UintR userPointer = fsReq->userPointer; + const BlockReference userRef = fsReq->userReference; + const BlockNumber blockNumber = refToBlock(userRef); + + FsRef::NdbfsErrorCodeType errorCode; + + AsyncFile* openFile = theOpenFiles.find(filePointer); + const NewVARIABLE *myBaseAddrRef = &getBat(blockNumber)[fsReq->varIndex]; + + const Uint32* tWA = (const Uint32*)myBaseAddrRef->WA; + const Uint32 tSz = myBaseAddrRef->nrr; + const Uint32 offset = fsReq->offset; + const Uint32 size = fsReq->size; + Request *request = theRequestPool->get(); + + if (openFile == NULL) { + jam(); + errorCode = FsRef::fsErrFileDoesNotExist; + goto error; + } + + if (myBaseAddrRef == NULL) { + jam(); // Ensure that a valid variable is used + errorCode = FsRef::fsErrInvalidParameters; + goto error; + } + + if (fsReq->varIndex >= getBatSize(blockNumber)) { + jam();// Ensure that a valid variable is used + errorCode = FsRef::fsErrInvalidParameters; + goto error; + } + + if(offset + size > tSz){ + jam(); // Ensure that a valid variable is used + errorCode = FsRef::fsErrInvalidParameters; + goto error; + } + + request->error = 0; + request->set(userRef, userPointer, filePointer); + request->file = openFile; + request->action = Request::append; + request->theTrace = signal->getTrace(); + + request->par.append.buf = (const char *)(tWA + offset); + request->par.append.size = size << 2; + + ndbrequire(forward(openFile, request)); + return; + +error: + jam(); + theRequestPool->put(request); + FsRef * const fsRef = (FsRef *)&signal->theData[0]; + fsRef->userPointer = userPointer; + fsRef->setErrorCode(fsRef->errorCode, errorCode); + fsRef->osErrorCode = ~0; // Indicate local error + + jam(); + sendSignal(userRef, GSN_FSAPPENDREF, signal, 3, JBB); + return; +} + +Uint16 +Ndbfs::newId() +{ + // finds a new key, eg a new filepointer + for (int i = 1; i < SHRT_MAX; i++) + { + if (theLastId == SHRT_MAX) { + jam(); + theLastId = 1; + } else { + jam(); + theLastId++; + } + + if(theOpenFiles.find(theLastId) == NULL) { + jam(); + return theLastId; + } + } + ndbrequire(1 == 0); + // The program will not reach this point + return 0; +} + +AsyncFile* +Ndbfs::createAsyncFile(){ + + // Check limit of open files + if (theFiles.size()+1 == m_maxFiles) { + // Print info about all open files + for (unsigned i = 0; i < theFiles.size(); i++){ + AsyncFile* file = theFiles[i]; + ndbout_c("%2d (0x%x): %s", i, file, file->isOpen()?"OPEN":"CLOSED"); + } + ERROR_SET(fatal, AFS_ERROR_MAXOPEN,""," Ndbfs::createAsyncFile"); + } + + AsyncFile* file = new AsyncFile; + file->doStart(theFileSystemPath); + + // Put the file in list of all files + theFiles.push_back(file); + +#ifdef VM_TRACE + infoEvent("NDBFS: Created new file thread %d", theFiles.size()); +#endif + + return file; +} + +AsyncFile* +Ndbfs::getIdleFile(){ + AsyncFile* file; + if (theIdleFiles.size() > 0){ + file = theIdleFiles[0]; + theIdleFiles.erase(0); + } else { + file = createAsyncFile(); + } + return file; +} + + + +void +Ndbfs::report(Request * request, Signal* signal) +{ + const Uint32 orgTrace = signal->getTrace(); + signal->setTrace(request->theTrace); + const BlockReference ref = request->theUserReference; + if (request->error) { + jam(); + // Initialise FsRef signal + FsRef * const fsRef = (FsRef *)&signal->theData[0]; + fsRef->userPointer = request->theUserPointer; + fsRef->setErrorCode(fsRef->errorCode, translateErrno(request->error)); + fsRef->osErrorCode = request->error; + + switch (request->action) { + case Request:: open: { + jam(); + // Put the file back in idle files list + theIdleFiles.push_back(request->file); + sendSignal(ref, GSN_FSOPENREF, signal, FsRef::SignalLength, JBB); + break; + } + case Request:: closeRemove: + case Request:: close: { + jam(); + sendSignal(ref, GSN_FSCLOSEREF, signal, FsRef::SignalLength, JBB); + break; + } + case Request:: writeSync: + case Request:: writevSync: + case Request:: write: + case Request:: writev: { + jam(); + sendSignal(ref, GSN_FSWRITEREF, signal, FsRef::SignalLength, JBB); + break; + } + case Request:: read: + case Request:: readv: { + jam(); + sendSignal(ref, GSN_FSREADREF, signal, FsRef::SignalLength, JBB); + break; + } + case Request:: sync: { + jam(); + sendSignal(ref, GSN_FSSYNCREF, signal, FsRef::SignalLength, JBB); + break; + } + case Request::append: { + jam(); + sendSignal(ref, GSN_FSAPPENDREF, signal, FsRef::SignalLength, JBB); + break; + } + case Request::rmrf: { + jam(); + // Put the file back in idle files list + theIdleFiles.push_back(request->file); + sendSignal(ref, GSN_FSREMOVEREF, signal, FsRef::SignalLength, JBB); + break; + } + + case Request:: end: { + // Report nothing + break; + } + }//switch + } else { + jam(); + FsConf * const fsConf = (FsConf *)&signal->theData[0]; + fsConf->userPointer = request->theUserPointer; + switch (request->action) { + case Request:: open: { + jam(); + theOpenFiles.insert(request->file, request->theFilePointer); + + // Keep track on max number of opened files + if (theOpenFiles.size() > m_maxOpenedFiles) + m_maxOpenedFiles = theOpenFiles.size(); + + fsConf->filePointer = request->theFilePointer; + sendSignal(ref, GSN_FSOPENCONF, signal, 3, JBB); + break; + } + case Request:: closeRemove: + case Request:: close: { + jam(); + // removes the file from OpenFiles list + theOpenFiles.erase(request->theFilePointer); + // Put the file in idle files list + theIdleFiles.push_back(request->file); + sendSignal(ref, GSN_FSCLOSECONF, signal, 1, JBB); + break; + } + case Request:: writeSync: + case Request:: writevSync: + case Request:: write: + case Request:: writev: { + jam(); + sendSignal(ref, GSN_FSWRITECONF, signal, 1, JBB); + break; + } + case Request:: read: + case Request:: readv: { + jam(); + sendSignal(ref, GSN_FSREADCONF, signal, 1, JBB); + break; + } + case Request:: sync: { + jam(); + sendSignal(ref, GSN_FSSYNCCONF, signal, 1, JBB); + break; + }//case + case Request::append: { + jam(); + signal->theData[1] = request->par.append.size; + sendSignal(ref, GSN_FSAPPENDCONF, signal, 2, JBB); + break; + } + case Request::rmrf: { + jam(); + // Put the file in idle files list + theIdleFiles.push_back(request->file); + sendSignal(ref, GSN_FSREMOVECONF, signal, 1, JBB); + break; + } + case Request:: end: { + // Report nothing + break; + } + } + }//if + signal->setTrace(orgTrace); +} + + +bool +Ndbfs::scanIPC(Signal* signal) +{ + Request* request = theFromThreads.tryReadChannel(); + jam(); + if (request) { + jam(); + report(request, signal); + theRequestPool->put(request); + return &request; + } + return false; +} + +#if defined NDB_WIN32 +int Ndbfs::translateErrno(int aErrno) +{ + switch (aErrno) + { + //permission denied + case ERROR_ACCESS_DENIED: + + return FsRef::fsErrPermissionDenied; + //temporary not accessible + case ERROR_PATH_BUSY: + case ERROR_NO_MORE_SEARCH_HANDLES: + + return FsRef::fsErrTemporaryNotAccessible; + //no space left on device + case ERROR_HANDLE_DISK_FULL: + case ERROR_DISK_FULL: + + return FsRef::fsErrNoSpaceLeftOnDevice; + //none valid parameters + case ERROR_INVALID_HANDLE: + case ERROR_INVALID_DRIVE: + case ERROR_INVALID_ACCESS: + case ERROR_HANDLE_EOF: + case ERROR_BUFFER_OVERFLOW: + + return FsRef::fsErrInvalidParameters; + //environment error + case ERROR_CRC: + case ERROR_ARENA_TRASHED: + case ERROR_BAD_ENVIRONMENT: + case ERROR_INVALID_BLOCK: + case ERROR_WRITE_FAULT: + case ERROR_READ_FAULT: + case ERROR_OPEN_FAILED: + + return FsRef::fsErrEnvironmentError; + + //no more process resources + case ERROR_TOO_MANY_OPEN_FILES: + case ERROR_NOT_ENOUGH_MEMORY: + case ERROR_OUTOFMEMORY: + return FsRef::fsErrNoMoreResources; + //no file + case ERROR_FILE_NOT_FOUND: + return FsRef::fsErrFileDoesNotExist; + + case ERR_ReadUnderflow: + return FsRef::fsErrReadUnderflow; + + default: + return FsRef::fsErrUnknown; + } +} +#elif defined NDB_OSE || defined NDB_SOFTOSE +int Ndbfs::translateErrno(int aErrno) +{ + switch (aErrno) + { + //permission denied + case EACCES: + case EROFS: + case ENXIO: + return FsRef::fsErrPermissionDenied; + //temporary not accessible + case EAGAIN: + case ETIMEDOUT: + case ENOLCK: + return FsRef::fsErrTemporaryNotAccessible; + //no space left on device + case ENFILE: + case EDQUOT: + case ENOSPC: + return FsRef::fsErrNoSpaceLeftOnDevice; + //none valid parameters + case EINVAL: + case EFBIG: + case EBADF: + case ENAMETOOLONG: + case EFAULT: + case EISDIR: + return FsRef::fsErrInvalidParameters; + //environment error + case EMLINK: + case ELOOP: + return FsRef::fsErrEnvironmentError; + + //no more process resources + case EMFILE: + case ENOMEM: + return FsRef::fsErrNoMoreResources; + //no file + case ENOENT: + return FsRef::fsErrFileDoesNotExist; + + case ERR_ReadUnderflow: + return FsRef::fsErrReadUnderflow; + + default: + return FsRef::fsErrUnknown; + } +} +#else +int Ndbfs::translateErrno(int aErrno) +{ + switch (aErrno) + { + //permission denied + case EACCES: + case EROFS: + case ENXIO: + return FsRef::fsErrPermissionDenied; + //temporary not accessible + case EAGAIN: + case ETIMEDOUT: + case ENOLCK: + case EINTR: + case EIO: + return FsRef::fsErrTemporaryNotAccessible; + //no space left on device + case ENFILE: + case EDQUOT: +#ifndef NDB_MACOSX + case ENOSR: +#endif + case ENOSPC: + case EFBIG: + return FsRef::fsErrNoSpaceLeftOnDevice; + //none valid parameters + case EINVAL: + case EBADF: + case ENAMETOOLONG: + case EFAULT: + case EISDIR: + case ENOTDIR: + case EEXIST: + case ETXTBSY: + return FsRef::fsErrInvalidParameters; + //environment error + case ELOOP: +#ifndef NDB_MACOSX + case ENOLINK: + case EMULTIHOP: +#endif +#ifndef NDB_LINUX + case EOPNOTSUPP: + case ESPIPE: +#endif + case EPIPE: + return FsRef::fsErrEnvironmentError; + + //no more process resources + case EMFILE: + case ENOMEM: + return FsRef::fsErrNoMoreResources; + //no file + case ENOENT: + return FsRef::fsErrFileDoesNotExist; + + case ERR_ReadUnderflow: + return FsRef::fsErrReadUnderflow; + + default: + return FsRef::fsErrUnknown; + } +} +#endif + + + +void +Ndbfs::execCONTINUEB(Signal* signal) +{ + jamEntry(); + if (signal->theData[0] == NdbfsContinueB::ZSCAN_MEMORYCHANNEL_10MS_DELAY) { + jam(); + + // Also send CONTINUEB to ourself in order to scan for + // incoming answers from AsyncFile on MemoryChannel theFromThreads + signal->theData[0] = NdbfsContinueB::ZSCAN_MEMORYCHANNEL_10MS_DELAY; + sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 10, 1); + if (scanningInProgress == true) { + jam(); + return; + } + } + if (scanIPC(signal)) { + jam(); + scanningInProgress = true; + signal->theData[0] = NdbfsContinueB::ZSCAN_MEMORYCHANNEL_NO_DELAY; + sendSignal(reference(), GSN_CONTINUEB, signal, 1, JBB); + } else { + jam(); + scanningInProgress = false; + } + return; +} + +bool Global_useO_SYNC = false; +bool Global_useO_DIRECT = false; +bool Global_unlinkO_CREAT = false; +Uint32 Global_syncFreq = 1024 * 1024; + +void +Ndbfs::execDUMP_STATE_ORD(Signal* signal) +{ + if(signal->theData[0] == 19){ + if(signal->length() > 1){ + Global_useO_SYNC = signal->theData[1]; + } + if(signal->length() > 2){ + Global_syncFreq = signal->theData[2] * 1024 * 1024; + } + if(signal->length() > 3){ + Global_unlinkO_CREAT = signal->theData[3]; + } + if(signal->length() > 4){ + Global_useO_DIRECT = signal->theData[4]; + } + ndbout_c("useO_SYNC = %d syncFreq = %d unlinkO_CREATE = %d O_DIRECT = %d", + Global_useO_SYNC, + Global_syncFreq, + Global_unlinkO_CREAT, + Global_useO_DIRECT); + return; + } + if(signal->theData[0] == DumpStateOrd::NdbfsDumpFileStat){ + infoEvent("NDBFS: Files: %d Open files: %d", + theFiles.size(), + theOpenFiles.size()); + infoEvent(" Idle files: %d Max opened files: %d", + theIdleFiles.size(), + m_maxOpenedFiles); + infoEvent(" Max files: %d", + m_maxFiles); + infoEvent(" Requests: %d", + theRequestPool->size()); + + return; + } + if(signal->theData[0] == DumpStateOrd::NdbfsDumpOpenFiles){ + infoEvent("NDBFS: Dump open files: %d", theOpenFiles.size()); + + for (unsigned i = 0; i < theOpenFiles.size(); i++){ + AsyncFile* file = theOpenFiles.getFile(i); + infoEvent("%2d (0x%x): %s", i,file, file->theFileName.c_str()); + } + return; + } + if(signal->theData[0] == DumpStateOrd::NdbfsDumpAllFiles){ + infoEvent("NDBFS: Dump all files: %d", theFiles.size()); + + for (unsigned i = 0; i < theFiles.size(); i++){ + AsyncFile* file = theFiles[i]; + infoEvent("%2d (0x%x): %s", i,file, file->isOpen()?"OPEN":"CLOSED"); + } + return; + } + if(signal->theData[0] == DumpStateOrd::NdbfsDumpIdleFiles){ + infoEvent("NDBFS: Dump idle files: %d", theIdleFiles.size()); + + for (unsigned i = 0; i < theIdleFiles.size(); i++){ + AsyncFile* file = theIdleFiles[i]; + infoEvent("%2d (0x%x): %s", i,file, file->isOpen()?"OPEN":"CLOSED"); + } + return; + } +}//Ndbfs::execDUMP_STATE_ORD() + + + +BLOCK_FUNCTIONS(Ndbfs); + diff --git a/ndb/src/kernel/blocks/ndbfs/Ndbfs.hpp b/ndb/src/kernel/blocks/ndbfs/Ndbfs.hpp new file mode 100644 index 00000000000..080196a9ea5 --- /dev/null +++ b/ndb/src/kernel/blocks/ndbfs/Ndbfs.hpp @@ -0,0 +1,126 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SIMBLOCKASYNCFILESYSTEM_H +#define SIMBLOCKASYNCFILESYSTEM_H + +#include +#include +#include "Pool.hpp" +#include "AsyncFile.hpp" +#include "OpenFiles.hpp" + + + +// Because one NDB Signal request can result in multiple requests to +// AsyncFile one class must be made responsible to keep track +// of all out standing request and when all are finished the result +// must be reported to the sending block. + + +class Ndbfs : public SimulatedBlock +{ +public: + Ndbfs(const class Configuration & conf); + virtual ~Ndbfs(); + +protected: + BLOCK_DEFINES(Ndbfs); + + // The signal processing functions + void execDUMP_STATE_ORD(Signal* signal); + void execFSOPENREQ(Signal* signal); + void execFSCLOSEREQ(Signal* signal); + void execFSWRITEREQ(Signal* signal); + void execFSREADREQ(Signal* signal); + void execFSSYNCREQ(Signal* signal); + void execFSAPPENDREQ(Signal* signal); + void execFSREMOVEREQ(Signal* signal); + void execSTTOR(Signal* signal); + void execCONTINUEB(Signal* signal); + + bool scanningInProgress; + Uint16 newId(); + +private: + int forward(AsyncFile *file, Request* Request); + void report(Request* request, Signal* signal); + bool scanIPC(Signal* signal); + + // Declared but not defined + Ndbfs(Ndbfs & ); + void operator = (Ndbfs &); + + // Used for uniqe number generation + Uint16 theLastId; + BlockReference cownref; + + // Communication from files + MemoryChannel theFromThreads; + + Pool* theRequestPool; + + AsyncFile* createAsyncFile(); + AsyncFile* getIdleFile(); + + Vector theFiles; // List all created AsyncFiles + Vector theIdleFiles; // List of idle AsyncFiles + OpenFiles theOpenFiles; // List of open AsyncFiles + const char * theFileSystemPath; + + // Statistics variables + Uint32 m_maxOpenedFiles; + + // Limit for max number of AsyncFiles created + Uint32 m_maxFiles; + + void readWriteRequest( int action, Signal * signal ); + + static int translateErrno(int aErrno); +}; + +class VoidFs : public SimulatedBlock +{ +public: + VoidFs(const class Configuration & conf); + virtual ~VoidFs(); + +protected: + BLOCK_DEFINES(VoidFs); + + // The signal processing functions + void execDUMP_STATE_ORD(Signal* signal); + void execFSOPENREQ(Signal* signal); + void execFSCLOSEREQ(Signal* signal); + void execFSWRITEREQ(Signal* signal); + void execFSREADREQ(Signal* signal); + void execFSSYNCREQ(Signal* signal); + void execFSAPPENDREQ(Signal* signal); + void execFSREMOVEREQ(Signal* signal); + void execSTTOR(Signal* signal); + +private: + // Declared but not defined + VoidFs(VoidFs & ); + void operator = (VoidFs &); + + // Used for uniqe number generation + Uint32 c_maxFileNo; +}; + +#endif + + diff --git a/ndb/src/kernel/blocks/ndbfs/OpenFiles.hpp b/ndb/src/kernel/blocks/ndbfs/OpenFiles.hpp new file mode 100644 index 00000000000..b944bb5485b --- /dev/null +++ b/ndb/src/kernel/blocks/ndbfs/OpenFiles.hpp @@ -0,0 +1,114 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef OPENFILES_H +#define OPENFILES_H + +#include + +class OpenFiles +{ +public: + OpenFiles(){ } + + /* Get a pointer to the file with id */ + AsyncFile* find(Uint16 id); + /* Insert file with id */ + bool insert(AsyncFile* file, Uint16 id); + /* Erase file with id */ + bool erase(Uint16 id); + /* Get number of open files */ + unsigned size(); + + Uint16 getId(unsigned i); + AsyncFile* getFile(unsigned i); + + +private: + + class OpenFileItem { + public: + OpenFileItem(): m_file(NULL), m_id(0){}; + + AsyncFile* m_file; + Uint16 m_id; + }; + + Vector m_files; +}; + + +//***************************************************************************** +inline AsyncFile* OpenFiles::find(Uint16 id){ + for (unsigned i = 0; i < m_files.size(); i++){ + if (m_files[i].m_id == id){ + return m_files[i].m_file; + } + } + return NULL; +} + +//***************************************************************************** +inline bool OpenFiles::erase(Uint16 id){ + for (unsigned i = 0; i < m_files.size(); i++){ + if (m_files[i].m_id == id){ + m_files.erase(i); + return true; + } + } + // Item was not found in list + return false; +} + + +//***************************************************************************** +inline bool OpenFiles::insert(AsyncFile* file, Uint16 id){ + // Check if file has already been opened + for (unsigned i = 0; i < m_files.size(); i++){ + if(m_files[i].m_file == NULL) + continue; + + if(strcmp(m_files[i].m_file->theFileName.c_str(), + file->theFileName.c_str()) == 0){ + ERROR_SET(fatal, AFS_ERROR_ALLREADY_OPEN,"","OpenFiles::insert()"); + } + } + + // Insert the file into vector + OpenFileItem openFile; + openFile.m_id = id; + openFile.m_file = file; + m_files.push_back(openFile); + + return true; +} + +//***************************************************************************** +inline Uint16 OpenFiles::getId(unsigned i){ + return m_files[i].m_id; +} + +//***************************************************************************** +inline AsyncFile* OpenFiles::getFile(unsigned i){ + return m_files[i].m_file; +} + +//***************************************************************************** +inline unsigned OpenFiles::size(){ + return m_files.size(); +} + +#endif diff --git a/ndb/src/kernel/blocks/ndbfs/Pool.hpp b/ndb/src/kernel/blocks/ndbfs/Pool.hpp new file mode 100644 index 00000000000..a26fa730727 --- /dev/null +++ b/ndb/src/kernel/blocks/ndbfs/Pool.hpp @@ -0,0 +1,262 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef FOR_LIB_POOL_H +#define FOR_LIB_POOL_H + + +//=========================================================================== +// +// .PUBLIC +// +//=========================================================================== + +//////////////////////////////////////////////////////////////// +// +// enum { defInitSize = 256, defIncSize = 64 }; +// Description: type to store initial and incremental size in. +// +//////////////////////////////////////////////////////////////// +// +// Pool(int anInitSize = defInitSize, int anIncSize = defIncSize); +// Description: +// Constructor. Allocates anInitSize of objects